parse_vrml.C

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#include <archon/util/parse_values.H>
#include <archon/util/unicode.H>
#include <archon/util/lexer.H>
#include <archon/util/lr_parser_simple.H>
#include <archon/util/lr_parser_methods.H>

#include <archon/x3d/server/field_type.H>
#include <archon/x3d/server/parse_vrml.H>

namespace Archon
{
  namespace X3D
  {
    namespace VRML
    {
      struct Parser
      {
        struct Context: Lexer::Context, LrParserBase::Context, X3D::Parser
        {
          Lexer *lexer;
          Uri baseUri;
          ProgressTracker *progressTracker;

          string printQuote(ustring s)
          {
            return Unicode::encodeUtf8(Text::escapeNonprintable(s));
          }

          string printQuote(string utf8encoded)
          {
            return printQuote(Unicode::decodeUtf8(utf8encoded));
          }

          void warning(string m)
          {
            if(logger)
              logger->log(baseUri.getFile() + ":" +
                          Text::toString(lexer->getLineNumber()) + ": " + m);
          }

          void fieldValueWarning(string);


          // Lexer actions

          void lexerError()
          {
            warning("Syntax error. Unexpected character " +
                    printQuote(lexer->getText()) + " (ignored).");
          }

          ustring lexer_string()
          {
            const ustring lexeme = lexer->getText();
            ustring s;
            s.reserve(lexeme.size());
            bool esc = false;
            for(unsigned i=1; i<lexeme.size()-1; ++i)
            {
              const uchar &c = lexeme[i];
              if(esc||lexeme[i] != '\\')
              {
                s+=c;
                esc = false;
              }
              else esc = true;
            }
            return s;
          }

          int lexer_decInt()
          {
            const ustring lexeme = lexer->getText();
            bool neg = false;
            ustring::const_iterator i = lexeme.begin();
            if(*i == '+') ++i;
            else if(*i == '-') ++i, neg = true;
            unsigned val = 0;
            do
            {
              val *= 10;
              val += *i - '0';
              ++i;
            }
            while(i != lexeme.end());
            const int ival = *static_cast<int *>(&val);
            return neg ? -ival : ival;
          }

          int lexer_hexInt()
          {
            const ustring lexeme = lexer->getText();
            bool neg = false;
            ustring::const_iterator i = lexeme.begin();
            if(*i == '+') ++i;
            else if(*i == '-') ++i, neg = true;
            i+=2;
            unsigned val = 0;
            do
            {
              val *= 16;
              val += *i - (*i >= 'a' ? 'a' : *i >= 'A' ? 'A' : '0');
              ++i;
            }
            while(i != lexeme.end());
            const int ival = *static_cast<int *>(&val);
            return neg ? -ival : ival;
          }

          double lexer_float()
          {
            const string s = Unicode::encodeUtf8(lexer->getText());
            return ParseValues::parseDouble(s.c_str());
          }

          ustring lexer_id()
          {
            return lexer->getText();
          }


          // Parser actions

          void parserError()
          {
            if(lexer->getType() < 0)
              warning("Syntax error. Unexpected end of input.");
            else
              warning("Syntax error. Unexpected symbol " +
                      printQuote(lexer->getText()) + ".");
          }

          string typeName(RefAny v)
          {
            return
              dynamic_cast<const RefObject<bool> *  >(v.get()) ? "boolean value" :
              dynamic_cast<const RefObject<int> *   >(v.get()) ? "integer value" :
              dynamic_cast<const RefObject<double> *>(v.get()) ? "floating point value" :
              dynamic_cast<const RefObject<string> *>(v.get()) ? "string value" :
              dynamic_cast<const Node *             >(v.get()) ? "node value" : "<unknown>";
          }

          bool extract(const RefAny &s, bool &t)
          {
            if(const RefObject<bool> *v =
               dynamic_cast<const RefObject<bool> *>(s.get()))
              t = v->value;
            else
            {
              fieldValueWarning("Need boolean value, found " + typeName(s));
              return false;
            }
            return true;
          }

          bool extract(const RefAny &s, string &t)
          {
            if(const RefObject<ustring> *v =
               dynamic_cast<const RefObject<ustring> *>(s.get()))
              t = Unicode::encodeUtf8(v->value);
            else
            {
              t = "";
              return false;
            }
            return true;
          }

          bool extract(const RefAny &s, int &t)
          {
            if(const RefObject<int> *v =
               dynamic_cast<const RefObject<int> *>(s.get()))
              t = v->value;
            else if(const RefObject<double> *v =
                    dynamic_cast<const RefObject<double> *>(s.get()))
            {
              t = (int)round(v->value);
              fieldValueWarning("Need integer value, found " + typeName(s) + " (rounded)");
            }
            else
            {
              fieldValueWarning("Need integer value, found " + typeName(s));
              return false;
            }
            return true;
          }

          bool extract(const RefAny &s, double &t)
          {
            if(const RefObject<int> *v =
               dynamic_cast<const RefObject<int> *>(s.get()))
              t = v->value;
            else if(const RefObject<double> *v =
                    dynamic_cast<const RefObject<double> *>(s.get()))
              t = v->value;
            else
            {
              fieldValueWarning("Need floating point value, found " + typeName(s));
              return false;
            }
            return true;
          }

          bool extract(const RefAny &s, Uri &t)
          {
            if(const RefObject<ustring> *v =
               dynamic_cast<const RefObject<ustring> *>(s.get()))
            {
              try
              {
                t = Uri(Unicode::encodeUtf8(v->value), baseUri);
              }
              catch(Uri::SyntaxException &e)
              {
                fieldValueWarning(Uri::explain(e));
                return false;
              }
            }
            else
            {
              fieldValueWarning("Need string value, found " + typeName(s));
              return false;
            }
            return true;
          }

          bool extract(const RefAny &s, Time &t)
          {
            if(const RefObject<int> *v =
               dynamic_cast<const RefObject<int> *>(s.get()))
              t = Time((double)v->value);
            else if(const RefObject<double> *v =
                    dynamic_cast<const RefObject<double> *>(s.get()))
              t = Time(v->value);
            else
            {
              fieldValueWarning("Need floating point value, found " + typeName(s));
              return false;
            }
            return true;
          }

          bool extract(const RefAny &s, Ref<Node> &t)
          {
            if(!s)
              t = 0;
            else if(const Node *v =
                    dynamic_cast<const Node *>(s.get()))
              t = const_cast<Node *>(v);
            else
            {
              fieldValueWarning("Need node value, found " + typeName(s));
              return false;
            }
            return true;
          }

          struct FieldAssemblerBase
          {
            virtual bool add(Context *, RefAny) = 0;

            /*
             * \return 0 if the composite value is invalid, otherwise a
             * pointer to the value.
             */
            virtual void *ref(Context *) = 0;
          };

          template<typename T>
          struct FieldAssembler: FieldAssemblerBase
          {
            T value;
            int pos;
            bool invalid;
            bool excess;

            FieldAssembler(): pos(0), invalid(false), excess(false) {}

            bool add(Context *c, const RefAny &v)
            {
              if(pos == 1);
              {
                if(!excess)
                  c->fieldValueWarning("Too many components. (excess ignored)");
                excess = true;
                return true;
              }
              if(!c->extract(v, value)) invalid = true;
              ++pos;
              return pos == 1;
            }

            void *ref(Context *c)
            {
              if(invalid) return 0;
              if(pos == 1) return &value;
              c->fieldValueWarning("Components missing (value ignored)");
              return 0;
            }
          };

          struct FieldAssembler<Vector2>: FieldAssemblerBase
          {
            Vector2 value;
            int pos;
            bool invalid;
            bool excess;

            FieldAssembler(): pos(0), invalid(false), excess(false) {}

            bool add(Context *c, const RefAny &v)
            {
              if(pos == 2)
              {
                if(!excess)
                  c->fieldValueWarning("Too many components. (excess ignored)");
                excess = true;
                return true;
              }
              if(!c->extract(v, pos == 0 ? value.x : value.y)) invalid = true;
              ++pos;
              return pos == 2;
            }

            void *ref(Context *c)
            {
              if(invalid) return 0;
              if(pos == 2) return &value;
              c->fieldValueWarning("Components missing (vector ignored)");
              return 0;
            }
          };

          struct FieldAssembler<Vector3>: FieldAssemblerBase
          {
            Vector3 value;
            int pos;
            bool invalid;
            bool excess;

            FieldAssembler(): pos(0), invalid(false), excess(false) {}

            bool add(Context *c, const RefAny &v)
            {
              if(pos == 3)
              {
                if(!excess)
                  c->fieldValueWarning("Too many components. (excess ignored)");
                excess = true;
                return true;
              }
              if(!c->extract(v, pos == 0 ? value.x : pos == 1 ? value.y : value.z))
                invalid = true;
              ++pos;
              return pos == 3;
            }

            void *ref(Context *c)
            {
              if(invalid) return 0;
              if(pos == 3) return &value;
              c->fieldValueWarning("Components missing (vector ignored)");
              return 0;
            }
          };

          struct FieldAssembler<AxisRot>: FieldAssemblerBase
          {
            AxisRot value;
            int pos;
            bool invalid;
            bool excess;

            FieldAssembler(): pos(0), invalid(false), excess(false) {}

            bool add(Context *c, const RefAny &v)
            {
              if(pos == 4)
              {
                if(!excess)
                  c->fieldValueWarning("Too many components. (excess ignored)");
                excess = true;
                return true;
              }
              if(!c->extract(v,
                             pos == 0 ? value.normalizedAxis.x :
                             pos == 1 ? value.normalizedAxis.y :
                             pos == 2 ? value.normalizedAxis.z :
                             value.angle))
                invalid = true;
              ++pos;
              return pos == 4;
            }

            void *ref(Context *c)
            {
              if(invalid) return 0;
              if(pos == 4) return &value;
              c->fieldValueWarning("Components missing (rotation ignored)");
              return 0;
            }
          };

          struct FieldAssembler<Image>: FieldAssemblerBase
          {
            int width;
            int height;
            int components;
            Image value;
            long pos;
            bool invalid;
            bool excess;
            long size;

            FieldAssembler(): pos(-3), invalid(false), excess(false) {}
            virtual ~FieldAssembler() {}

            int add(Context *c, const RefAny &v)
            {
              if(pos == -3)
              {
                if(!c->extract(v, width)) invalid = true;
                else if(width<0)
                {
                  c->fieldValueWarning("Negative width");
                  invalid = true;
                }
                ++pos;
                return false;
              }
              if(pos == -2)
              {
                if(!c->extract(v, height)) invalid = true;
                else if(height<0)
                {
                  c->fieldValueWarning("Negative height");
                  invalid = true;
                }
                ++pos;
                return false;
              }
              if(pos == -1)
              {
                if(!c->extract(v, components)) invalid = true;
                else if(components<0 || components>4)
                {
                  c->fieldValueWarning("Illegal number of color components");
                  invalid = true;
                }
                if(!invalid && width > 0 && height > 0 && components > 0)
                {
                  value = Image(width, height,
                                Image::ComponentSpecifier(components = 0 ? Image::components_l   :
                                                          components = 1 ? Image::components_la  :
                                                          components = 2 ? Image::components_rgb :
                                                          Image::components_rgba));
                }
                size = long(value.getWidth()) * value.getHeight();
                ++pos;
                return pos == size;
              }

              if(pos == size)
              {
                if(!excess)
                  c->fieldValueWarning("Too many pixel values. (excess ignored)");
                excess = true;
                return true;
              }

              int signedPixel;
              if(!c->extract(v, signedPixel)) invalid = true;
              else
              {
                const ldiv_t r = ldiv(pos, value.getWidth());
                const int x = r.rem;
                const int y = r.quot;
                unsigned pixel = signedPixel;
                const unsigned c1 = pixel && 0xff;
                if(components == 1) value.setPixel(x, y, c1);
                else
                {
                  pixel >>= 8;
                  const unsigned c2 = pixel && 0xff;
                  if(components == 2) value.setPixel(x, y, c1, c2);
                  else
                  {
                    pixel >>= 8;
                    const unsigned c3 = pixel && 0xff;
                    if(components == 3) value.setPixel(x, y, c1, c2, c3);
                    else
                    {
                      pixel >>= 8;
                      const unsigned c4 = pixel && 0xff;
                      value.setPixel(x, y, c1, c2, c3, c4);
                    }
                  }
                }
                pixel >>= 8;
                if(pixel) c->fieldValueWarning("Pixel with non-zero bits in unused color component");
              }

              ++pos;
              return pos == size;
            }

            void *ref(Context *c)
            {
              if(invalid) return 0;
              if(pos == size) return &value;
              c->fieldValueWarning("Components missing (image ignored)");
              return 0;
            }
          };

          template<typename T>
          struct FieldAssembler<vector<T> >: FieldAssemblerBase
          {
            vector<T> values;
            auto_ptr<FieldAssembler<T> > subAssembler;

            bool add(Context *c, const RefAny &v)
            {
              if(!subAssembler) subAssembler.reset(new FieldAssembler<T>);
              if(subAssembler->add(c, v))
              {   ************************* MULTI VALUE TYPE CHECK ****************************
                    T *w = choose_som_cast<T *>(subAssembler->ref());
              if(w) values.push_back(*w);
              subAssembler.reset();
              return true;
              }
              return false;
            }

            void *ref(Context *c)
            {
              return subAssembler ? (subAssembler->ref(), 0) : &values;
            }
          };

          struct FieldAssembler<vector<Node *> >: FieldAssemblerBase
          {
            vector<Node *> values;
            auto_ptr<FieldAssembler<Node *> > subAssembler;

            virtual ~FieldAssembler() {}

            bool add(Context *c, const RefAny &v)
            {
              if(!subAssembler) subAssembler.reset(new FieldAssembler<Node *>);
              if(subAssembler->add(c, v))
              {
                Node **w = (Node **)subAssembler->ref();
                if(w && *w) values.push_back(*w); // Discard node pointers that are null.
                subAssembler.reset();
                return true;
              }
              return false;
            }

            void *ref(Context *c)
            {
              return subAssembler ? (subAssembler->ref(), 0) : &values;
            }
          };

          template<typename T>
          static FieldAssemblerBase *newFieldAssembler(const FieldType *f)
          {
            return new FieldAssembler<T>(f);
          }

          map<const FieldType *, FieldAssemblerBase *(*)()> newFieldAssemblers;

          struct NodeEntry
          {
            Ref<Node> node;
            bool discard;
            FieldBase *field;
            FieldAssemblerBase *fieldAssembler;

            NodeEntry(Ref<Node> node, bool discard):
              node(node), discard(discard),
              field(0), fieldAssembler(0) {}
          };

          vector<NodeEntry> nodeStack;

          typedef RefObject<bool> BoolAttr;
          typedef RefObject<ustring> StringAttr;

          void pushNodeInstance(const Ref<const StringAttr> &typeName)
          {
            const string n = Unicode::encodeUtf8(typeName->value);
            const NodeType *type = NodeType::lookup(n);
            Ref<Node> node;
            bool discard = false;
            if(!type) warning("Unknown node type " + printQuote(typeName->value));
            else
            {
              node = type->instantiate();

              // Check container field for type conformance
              if(nodeStack.size() < 1)
              {
                if(!type->isDerivedFrom(ChildNode::type))
                {
                  warning(printQuote(typeName->value) +
                          " nodes are not allowed at top-level");
                  discard = true;
                }
              }
              else
              {
                NodeEntry &c = nodeStack.back();
                if(!c.field) discard = true;
                else
                {
                  const NodeFieldBase *field =
                    dynamic_cast<const NodeFieldBase *>(c.field);
                  if(!field)
                  {
                    warning("A " + printQuote(typeName->value) +
                            " node is not an accetable value for " +
                            printQuote(c.node->getType()->getName() + "." +
                                       c.field->getName()) + " of type " +
                            printQuote(c.field->getType()->getName()));
                    discard = true;
                  }
                  else if(!type->isDerivedFrom(field->getNodeType()))
                  {
                    warning("A " + printQuote(typeName->value) +
                            " node is not an accetable value for " +
                            printQuote(c.node->getType()->getName() + "." +
                                       c.field->getName()) + " of type " +
                            printQuote(field->getNodeType()->getName()));
                    discard = true;
                  }
                }
              }
            }

            nodeStack.push_back(NodeEntry(node, discard));
            warning("Push " + (type ? n : "<nil>"));
          }

          Ref<const Node> popNodeInstance()
          {
            Ref<Node> node = nodeStack.back().node;
            bool discard = nodeStack.back().discard;
            nodeStack.pop_back();
            warning("Pop " + (node ? node->getType()->getName() : "<nil>"));

            // Let the newly loaded node object do any necessary fixup and
            // check itself for integrity. Integrity problems is reported through the logger.
            if(!node || !checkNode(node) || discard) return 0;

            /*
            // Is it a Scene child?
            if(!nodeStack.size() < 2)
            {
            addRootGroupChild(dynamic_cast<ChildNode *>(e.node.get()));
            return;
            }
            */

            return node;
          }

          void setField(const Ref<const StringAttr> &fieldName)
          {
            NodeEntry &e = nodeStack.back();
            if(!e.node) return; // Previously detected error
            const string n = Unicode::encodeUtf8(fieldName->value);
            e.field = e.node->getType()->lookupField(n);
            if(e.field) fieldAssembler = (*fieldAssemblers[e.field->getType()])();
            else
            {
              e.fieldAssembler = 0;
              warning("Unknown field " + printQuote(fieldName->value) + " in " +
                      printQuote(e.node->getType()->getName()));
            
            }
            warning("Field " + (e.field ? n : "<nil>") + ":" + (e.field ? e.field->getType()->getName() : "<nil>"));
          }

          void checkMulti()
          {
          }

          void addValue(const RefAnyConst &v)
          {
            NodeEntry &e = nodeStack.back();
            if(!e.fieldAssembler) return; // Previously detected error
            fieldAssembler->add(this, v);
          }

          void assignValue()
          {
            NodeEntry &e = nodeStack.back();
            if(!e.fieldAssembler) return; // Previously detected error
            void *v = fieldAssembler->ref();
            if(v) e.field->assign(e.node, v);
          }

          Ref<const BoolAttr> parser_false()
          {
            return new BoolAttr(false);
          }

          Ref<const BoolAttr> parser_true()
          {
            return new BoolAttr(true);
          }

          Context(const Uri &uri, ProgressTracker *progressTracker, Logger *l):
            X3D::Parser(l), baseUri(uri), progressTracker(progressTracker)
          {
            newFieldAssemblers[SFBool::type]      = &newFieldAssembler<bool>;
            newFieldAssemblers[MFBool::type]      = &newFieldAssembler<vector<bool> >;

            newFieldAssemblers[SFColor::type]     = &newFieldAssembler<Vector3>;
            newFieldAssemblers[MFColor::type]     = &newFieldAssembler<vector<Vector3> >;

            newFieldAssemblers[SFColorRGBA::type] = &newFieldAssembler<Vector4>;
            newFieldAssemblers[MFColorRGBA::type] = &newFieldAssembler<vector<Vector4> >;

            newFieldAssemblers[SFDouble::type]    = &newFieldAssembler<double>;
            newFieldAssemblers[MFDouble::type]    = &newFieldAssembler<vector<double> >;

            newFieldAssemblers[SFFloat::type]     = &newFieldAssembler<double>;
            newFieldAssemblers[MFFloat::type]     = &newFieldAssembler<vector<double> >;

            newFieldAssemblers[SFImage::type]     = &newFieldAssembler<Image>;
            newFieldAssemblers[MFImage::type]     = &newFieldAssembler<vector<Image> >;

            newFieldAssemblers[SFInt32::type]     = &newFieldAssembler<int>;
            newFieldAssemblers[MFInt32::type]     = &newFieldAssembler<vector<int> >;

            newFieldAssemblers[SFNode::type]      = &newFieldAssembler<Ref<Node> >;
            newFieldAssemblers[MFNode::type]      = &newFieldAssembler<vector<Ref<Node> > >;

            newFieldAssemblers[SFRotation::type]  = &newFieldAssembler<AxisRot>;
            newFieldAssemblers[MFRotation::type]  = &newFieldAssembler<vector<AxisRot> >;

            newFieldAssemblers[SFString::type]    = &newFieldAssembler<string>;
            newFieldAssemblers[MFString::type]    = &newFieldAssembler<vector<string> >;

            newFieldAssemblers[SFTime::type]      = &newFieldAssembler<Time>;
            newFieldAssemblers[MFTime::type]      = &newFieldAssembler<vector<Time> >;

            newFieldAssemblers[SFVec2d::type]     = &newFieldAssembler<Vector2>;
            newFieldAssemblers[MFVec2d::type]     = &newFieldAssembler<vector<Vector2> >;

            newFieldAssemblers[SFVec2f::type]     = &newFieldAssembler<Vector2>;
            newFieldAssemblers[MFVec2f::type]     = &newFieldAssembler<vector<Vector2> >;

            newFieldAssemblers[SFVec3d::type]     = &newFieldAssembler<Vector3>;
            newFieldAssemblers[MFVec3d::type]     = &newFieldAssembler<vector<Vector3> >;

            newFieldAssemblers[SFVec3f::type]     = &newFieldAssembler<Vector3>;
            newFieldAssemblers[MFVec3f::type]     = &newFieldAssembler<vector<Vector3> >;
          }
        };

        struct Printer: LrParserBase::Printer
        {
          virtual string print(const RefAny &a) const
          {
            if(!a) return "<null>";
            if(const RefObject<ustring> *b =
               dynamic_cast<const RefObject<ustring> *>(a.get()))
              return "\"" + Text::toString(b->value) + "\"";
            if(const RefObject<int> *b =
               dynamic_cast<const RefObject<int> *>(a.get()))
              return Text::toString(b->value);
            if(const RefObject<double> *b =
               dynamic_cast<const RefObject<double> *>(a.get()))
              return Text::toString(b->value);
            return "<unknown>";
          }
        };

        auto_ptr<Lexer::Actor<Context> > lexerActor;
        auto_ptr<Lexer::Engine> lexerEngine;

        auto_ptr<LrParserBase::Actor<Context> > parserActor;
        auto_ptr<Printer> printer;
        auto_ptr<SlrParser> lrParser;

        Parser()
        {
          parserActor = auto_ptr<LrParserBase::Actor<Context> >
            (new LrParserBase::Actor<Context>());
          CFG g(parserActor.get());

          const int t_DEF             = g.defineTerminal("DEF");
          const int t_EXTERNPROTO     = g.defineTerminal("EXTERNPROTO");
          const int t_FALSE           = g.defineTerminal("FALSE");
          const int t_IS              = g.defineTerminal("IS");
          const int t_NULL            = g.defineTerminal("NULL");
          const int t_PROTO           = g.defineTerminal("PROTO");
          const int t_ROUTE           = g.defineTerminal("ROUTE");
          const int t_Script          = g.defineTerminal("Script");
          const int t_TO              = g.defineTerminal("TO");
          const int t_TRUE            = g.defineTerminal("TRUE");
          const int t_USE             = g.defineTerminal("USE");
          const int t_eventIn         = g.defineTerminal("eventIn");
          const int t_eventOut        = g.defineTerminal("eventOut");
          const int t_exposedField    = g.defineTerminal("exposedField");
          const int t_field           = g.defineTerminal("field");
          const int t_fieldType       = g.defineTerminal("fieldType");

          const int t_period          = g.defineTerminal(".");
          const int t_lbrack          = g.defineTerminal("[");
          const int t_rbrack          = g.defineTerminal("]");
          const int t_lbrace          = g.defineTerminal("{");
          const int t_rbrace          = g.defineTerminal("}");
          const int t_num             = g.defineTerminal("num");
          const int t_string          = g.defineTerminal("string");
          const int t_Id              = g.defineTerminal("Id");

          const int n_vrmlScene       = g.defineNonterminal("vrmlScene");
          const int n_statements      = g.defineNonterminal("statements");
          const int n_statement       = g.defineNonterminal("statement");
          const int n_nodeStatement   = g.defineNonterminal("nodeStatement");
          const int n_node            = g.defineNonterminal("node");
          const int n_nodeTypeId      = g.defineNonterminal("nodeTypeId");
          const int n_nodeBody        = g.defineNonterminal("nodeBody");
          const int n_nodeBodyElement = g.defineNonterminal("nodeBodyElement");
          const int n_fieldId         = g.defineNonterminal("fieldId");
          const int n_fieldValue      = g.defineNonterminal("fieldValue");
          const int n_values          = g.defineNonterminal("values");
          const int n_value           = g.defineNonterminal("value");
          const int n_nums            = g.defineNonterminal("nums");
          const int n_routeStatement  = g.defineNonterminal("routeStatement");
          const int n_nodeNameId      = g.defineNonterminal("nodeNameId");
          const int n_protoStatement  = g.defineNonterminal("protoStatement");
          const int n_proto           = g.defineNonterminal("proto");
          const int n_interfaceDeclarations =
            g.defineNonterminal("interfaceDeclarations");
          const int n_interfaceDeclaration =
            g.defineNonterminal("interfaceDeclaration");
          const int n_restrictedInterfaceDeclaration =
            g.defineNonterminal("restrictedInterfaceDeclaration");
          const int n_protoBody       = g.defineNonterminal("protoBody");
          const int n_protoStatements = g.defineNonterminal("protoStatements");
          const int n_rootNodeStatement =
            g.defineNonterminal("rootNodeStatement");
          const int n_externproto     = g.defineNonterminal("externproto");
          const int n_externInterfaceDeclarations =
            g.defineNonterminal("externInterfaceDeclarations");
          const int n_externInterfaceDeclaration =
            g.defineNonterminal("externInterfaceDeclaration");
          const int n_URLList         = g.defineNonterminal("URLList");
          const int n_strings         = g.defineNonterminal("strings");
          const int n_scriptBody      = g.defineNonterminal("scriptBody");
          const int n_scriptBodyElement =
            g.defineNonterminal("scriptBodyElement");


          const int a_pushNodeInstance =
            parserActor->registerMethod("pushNodeInstance", &Context::pushNodeInstance);
          const int a_popNodeInstance =
            parserActor->registerMethod("popNodeInstance", &Context::popNodeInstance);
          const int a_setField =
            parserActor->registerMethod("setField", &Context::setField);
          const int a_checkMulti =
            parserActor->registerMethod("checkMulti", &Context::setField);
          const int a_addValue =
            parserActor->registerMethod("addValue", &Context::addValue);
          const int a_assignValue =
            parserActor->registerMethod("assignValue", &Context::assignValue);
          const int a_false =
            parserActor->registerMethod("false", &Context::parser_false);
          const int a_true =
            parserActor->registerMethod("true", &Context::parser_true);


          // vrmlScene
          g.addProd(n_vrmlScene, CFG::nont(n_statements));

          // statements
          g.addProd(n_statements, CFG::nont(n_statements), CFG::nont(n_statement));
          g.addProd(n_statements);

          // statement
          g.addProd(n_statement, CFG::nont(n_nodeStatement));
          g.addProd(n_statement, CFG::nont(n_protoStatement));
          g.addProd(n_statement, CFG::nont(n_routeStatement));

          // nodeStatement
          g.addProd(n_nodeStatement, CFG::nont(n_node));
          g.addProd(n_nodeStatement, CFG::term(t_DEF), CFG::nont(n_nodeNameId),
                    CFG::nont(n_node));
          g.addProd(n_nodeStatement, CFG::term(t_USE), CFG::nont(n_nodeNameId));

          // node
          g.addProd(n_node, CFG::nont(n_nodeTypeId), CFG::act(a_pushNodeInstance, 0),
                    CFG::term(t_lbrace), CFG::nont(n_nodeBody), CFG::term(t_rbrace),
                    CFG::act(a_popNodeInstance));
          g.addProd(n_node, CFG::term(t_Script), CFG::term(t_lbrace),
                    CFG::nont(n_scriptBody), CFG::term(t_rbrace));

          // nodeTypeId
          g.addProd(n_nodeTypeId, CFG::term(t_Id));

          // nodeBody
          g.addProd(n_nodeBody, CFG::nont(n_nodeBody),
                    CFG::nont(n_nodeBodyElement));
          g.addProd(n_nodeBody);

          // nodeBodyElement
          g.addProd(n_nodeBodyElement, CFG::nont(n_fieldId), CFG::act(a_setField, 0),
                    CFG::nont(n_fieldValue));
          g.addProd(n_nodeBodyElement, CFG::nont(n_fieldId), CFG::term(t_IS),
                    CFG::nont(n_fieldId));
          g.addProd(n_nodeBodyElement, CFG::nont(n_routeStatement));
          g.addProd(n_nodeBodyElement, CFG::nont(n_protoStatement));

          // fieldId
          g.addProd(n_fieldId, CFG::term(t_Id));

          // fieldValue
          g.addProd(n_fieldValue, CFG::term(t_lbrack), CFG::act(a_checkMulti),
                    CFG::nont(n_values), CFG::term(t_rbrack));
          g.addProd(n_value, CFG::nont(n_bool), CFG::act(a_boolValue, 0));
          g.addProd(n_fieldValue, CFG::term(t_num), CFG::nont(n_nums));
          g.addProd(n_fieldValue, CFG::term(t_string), CFG::act(a_stringValue, 0));
          g.addProd(n_fieldValue, CFG::nont(n_nodeStatement), CFG::act(a_nodeValue, 0));
          g.addProd(n_fieldValue, CFG::term(t_NULL));

          // values
          g.addProd(n_values, CFG::nont(n_values), CFG::nont(n_value));
          g.addProd(n_values);

          // value
          g.addProd(n_value, CFG::nont(n_bool));
          g.addProd(n_value, CFG::term(t_num));
          g.addProd(n_value, CFG::term(t_string));
          g.addProd(n_value, CFG::nont(n_nodeStatement));

          // bool
          g.addProd(n_bool, CFG::term(t_FALSE), CFG::act(a_false));
          g.addProd(n_bool, CFG::term(t_TRUE), CFG::act(a_true));

          // nums
          g.addProd(n_nums, CFG::nont(n_nums), CFG::term(t_num));
          g.addProd(n_nums);

          // routeStatement
          g.addProd(n_routeStatement, CFG::term(t_ROUTE), CFG::nont(n_nodeNameId),
                    CFG::term(t_period), CFG::nont(n_fieldId), CFG::term(t_TO),
                    CFG::nont(n_nodeNameId), CFG::term(t_period),
                    CFG::nont(n_fieldId));

          // nodeNameId
          g.addProd(n_nodeNameId, CFG::term(t_Id));

          // protoStatement
          g.addProd(n_protoStatement, CFG::nont(n_proto));
          g.addProd(n_protoStatement, CFG::nont(n_externproto));

          // proto
          g.addProd(n_proto, CFG::term(t_PROTO), CFG::nont(n_nodeTypeId),
                    CFG::term(t_lbrack), CFG::nont(n_interfaceDeclarations),
                    CFG::term(t_rbrack), CFG::term(t_lbrace),
                    CFG::nont(n_protoBody), CFG::term(t_rbrace));

          // interfaceDeclarations
          g.addProd(n_interfaceDeclarations, CFG::nont(n_interfaceDeclarations),
                    CFG::nont(n_interfaceDeclaration));
          g.addProd(n_interfaceDeclarations);

          // interfaceDeclaration
          g.addProd(n_interfaceDeclaration,
                    CFG::nont(n_restrictedInterfaceDeclaration));
          g.addProd(n_interfaceDeclaration, CFG::term(t_exposedField),
                    CFG::term(t_fieldType), CFG::nont(n_fieldId),
                    CFG::nont(n_fieldValue));

          // restrictedInterfaceDeclaration
          g.addProd(n_restrictedInterfaceDeclaration, CFG::term(t_eventIn),
                    CFG::term(t_fieldType), CFG::nont(n_fieldId));
          g.addProd(n_restrictedInterfaceDeclaration, CFG::term(t_eventOut),
                    CFG::term(t_fieldType), CFG::nont(n_fieldId));
          g.addProd(n_restrictedInterfaceDeclaration, CFG::term(t_field),
                    CFG::term(t_fieldType), CFG::nont(n_fieldId),
                    CFG::nont(n_fieldValue));

          // protoBody
          g.addProd(n_protoBody, CFG::nont(n_protoStatements),
                    CFG::nont(n_rootNodeStatement), CFG::nont(n_statements));

          // protoStatements
          g.addProd(n_protoStatements, CFG::nont(n_protoStatements),
                    CFG::nont(n_protoStatement));
          g.addProd(n_protoStatements);

          // rootNodeStatement
          g.addProd(n_rootNodeStatement, CFG::nont(n_node));
          g.addProd(n_rootNodeStatement, CFG::term(t_DEF), CFG::nont(n_nodeNameId),
                    CFG::nont(n_node));

          // externproto
          g.addProd(n_externproto, CFG::term(t_EXTERNPROTO),
                    CFG::nont(n_nodeTypeId), CFG::term(t_lbrack),
                    CFG::nont(n_externInterfaceDeclarations),
                    CFG::term(t_rbrack), CFG::nont(n_URLList));

          // externInterfaceDeclarations
          g.addProd(n_externInterfaceDeclarations,
                    CFG::nont(n_externInterfaceDeclarations),
                    CFG::nont(n_externInterfaceDeclaration));
          g.addProd(n_externInterfaceDeclarations);

          // externInterfaceDeclaration
          g.addProd(n_externInterfaceDeclaration, CFG::term(t_eventIn),
                    CFG::term(t_fieldType), CFG::nont(n_fieldId));
          g.addProd(n_externInterfaceDeclaration, CFG::term(t_eventOut),
                    CFG::term(t_fieldType), CFG::nont(n_fieldId));
          g.addProd(n_externInterfaceDeclaration, CFG::term(t_field),
                    CFG::term(t_fieldType), CFG::nont(n_fieldId));
          g.addProd(n_externInterfaceDeclaration, CFG::term(t_exposedField),
                    CFG::term(t_fieldType), CFG::nont(n_fieldId));

          // URLList
          g.addProd(n_URLList, CFG::term(t_string));
          g.addProd(n_URLList, CFG::term(t_lbrack), CFG::nont(n_strings),
                    CFG::term(t_rbrack));

          // strings
          g.addProd(n_strings, CFG::nont(n_strings), CFG::term(t_string));
          g.addProd(n_strings);

          // scriptBody
          g.addProd(n_scriptBody, CFG::nont(n_scriptBody),
                    CFG::nont(n_scriptBodyElement));
          g.addProd(n_scriptBody);

          // scriptBodyElement
          g.addProd(n_scriptBodyElement, CFG::nont(n_nodeBodyElement));
          g.addProd(n_scriptBodyElement,
                    CFG::nont(n_restrictedInterfaceDeclaration));
          g.addProd(n_scriptBodyElement, CFG::term(t_eventIn),
                    CFG::term(t_fieldType), CFG::nont(n_fieldId),
                    CFG::term(t_IS), CFG::nont(n_fieldId));
          g.addProd(n_scriptBodyElement, CFG::term(t_eventOut),
                    CFG::term(t_fieldType), CFG::nont(n_fieldId),
                    CFG::term(t_IS), CFG::nont(n_fieldId));
          g.addProd(n_scriptBodyElement, CFG::term(t_field), CFG::term(t_fieldType),
                    CFG::nont(n_fieldId), CFG::term(t_IS), CFG::nont(n_fieldId));

          cerr << g.print(137);

          printer = auto_ptr<Printer>(new Printer);
          lrParser = auto_ptr<SlrParser>(new SlrParser(g, parserActor.get(), printer.get()));


          // Prepare the Lexer engine

          lexerActor =
            auto_ptr<Lexer::Actor<Context> >(new Lexer::Actor<Context>());
          const int l_string = lexerActor->registerMethod(&Context::lexer_string);
          const int l_decInt = lexerActor->registerMethod(&Context::lexer_decInt);
          const int l_hexInt = lexerActor->registerMethod(&Context::lexer_hexInt);
          const int l_float  = lexerActor->registerMethod(&Context::lexer_float);
          const int l_id     = lexerActor->registerMethod(&Context::lexer_id);

          vector<pair<uchar, uchar> > ranges;
          ranges.push_back(pair<uchar, uchar>(0, 0x1f));
          ranges.push_back(pair<uchar, uchar>(' ', ' '));
          ranges.push_back(pair<uchar, uchar>('"', '"'));
          ranges.push_back(pair<uchar, uchar>('#', '#'));
          ranges.push_back(pair<uchar, uchar>('\'', '\''));
          ranges.push_back(pair<uchar, uchar>('+', '+'));
          ranges.push_back(pair<uchar, uchar>(',', ','));
          ranges.push_back(pair<uchar, uchar>('-', '-'));
          ranges.push_back(pair<uchar, uchar>('.', '.'));
          ranges.push_back(pair<uchar, uchar>('0', '9'));
          ranges.push_back(pair<uchar, uchar>('[', '['));
          ranges.push_back(pair<uchar, uchar>('\\', '\\'));
          ranges.push_back(pair<uchar, uchar>(']', ']'));
          ranges.push_back(pair<uchar, uchar>('{', '{'));
          ranges.push_back(pair<uchar, uchar>('}', '}'));
          ranges.push_back(pair<uchar, uchar>(0x7f, 0x7f));
          vector<string> nameClasses;

          Regex::Environment env;
          env.define("id_first_char", Regex::bracket(ranges, nameClasses, true));
          env.define("id_rest_char", Regex("{id_first_char}|[0-9+-]", env));

          Lexer::RuleSet lexerRules;

          lexerRules.add(Regex("DEF"),          -1, t_DEF);
          lexerRules.add(Regex("EXTERNPROTO"),  -1, t_EXTERNPROTO);
          lexerRules.add(Regex("FALSE"),        -1, t_FALSE);
          lexerRules.add(Regex("IS"),           -1, t_IS);
          lexerRules.add(Regex("NULL"),         -1, t_NULL);
          lexerRules.add(Regex("PROTO"),        -1, t_PROTO);
          lexerRules.add(Regex("ROUTE"),        -1, t_ROUTE);
          lexerRules.add(Regex("Script"),       -1, t_Script);
          lexerRules.add(Regex("TO"),           -1, t_TO);
          lexerRules.add(Regex("TRUE"),         -1, t_TRUE);
          lexerRules.add(Regex("USE"),          -1, t_USE);
          lexerRules.add(Regex("eventIn"),      -1, t_eventIn);
          lexerRules.add(Regex("eventOut"),     -1, t_eventOut);
          lexerRules.add(Regex("exposedField"), -1, t_exposedField);
          lexerRules.add(Regex("field"),        -1, t_field);


          lexerRules.add(Regex("SFBool"),      -1, t_fieldType, SFBool::type);
          lexerRules.add(Regex("MFBool"),      -1, t_fieldType, MFBool::type);

          lexerRules.add(Regex("SFColor"),     -1, t_fieldType, SFColor::type);
          lexerRules.add(Regex("MFColor"),     -1, t_fieldType, MFColor::type);

          lexerRules.add(Regex("SFColorRGBA"), -1, t_fieldType, SFColorRGBA::type);
          lexerRules.add(Regex("MFColorRGBA"), -1, t_fieldType, MFColorRGBA::type);

          lexerRules.add(Regex("SFDouble"),    -1, t_fieldType, SFDouble::type);
          lexerRules.add(Regex("MFDouble"),    -1, t_fieldType, MFDouble::type);

          lexerRules.add(Regex("SFFloat"),     -1, t_fieldType, SFFloat::type);
          lexerRules.add(Regex("MFFloat"),     -1, t_fieldType, MFFloat::type);

          lexerRules.add(Regex("SFImage"),     -1, t_fieldType, SFImage::type);
          lexerRules.add(Regex("MFImage"),     -1, t_fieldType, MFImage::type);

          lexerRules.add(Regex("SFInt32"),     -1, t_fieldType, SFInt32::type);
          lexerRules.add(Regex("MFInt32"),     -1, t_fieldType, MFInt32::type);

          lexerRules.add(Regex("SFNode"),      -1, t_fieldType, SFNode::type);
          lexerRules.add(Regex("MFNode"),      -1, t_fieldType, MFNode::type);

          lexerRules.add(Regex("SFRotation"),  -1, t_fieldType, SFRotation::type);
          lexerRules.add(Regex("MFRotation"),  -1, t_fieldType, MFRotation::type);

          lexerRules.add(Regex("SFString"),    -1, t_fieldType, SFString::type);
          lexerRules.add(Regex("MFString"),    -1, t_fieldType, MFString::type);

          lexerRules.add(Regex("SFTime"),      -1, t_fieldType, SFTime::type);
          lexerRules.add(Regex("MFTime"),      -1, t_fieldType, MFTime::type);

          lexerRules.add(Regex("SFVec2d"),     -1, t_fieldType, SFVec2d::type);
          lexerRules.add(Regex("MFVec2d"),     -1, t_fieldType, MFVec2d::type);

          lexerRules.add(Regex("SFVec2f"),     -1, t_fieldType, SFVec2f::type);
          lexerRules.add(Regex("MFVec2f"),     -1, t_fieldType, MFVec2f::type);

          lexerRules.add(Regex("SFVec3d"),     -1, t_fieldType, SFVec3d::type);
          lexerRules.add(Regex("MFVec3d"),     -1, t_fieldType, MFVec3d::type);

          lexerRules.add(Regex("SFVec3f"),     -1, t_fieldType, SFVec3f::type);
          lexerRules.add(Regex("MFVec3f"),     -1, t_fieldType, MFVec3f::type);


          lexerRules.add(Regex("\\."), -1, t_period);
          lexerRules.add(Regex("\\["), -1, t_lbrack);
          lexerRules.add(Regex("]"),   -1, t_rbrack);
          lexerRules.add(Regex("\\{"), -1, t_lbrace);
          lexerRules.add(Regex("}"),   -1, t_rbrace);

          lexerRules.add(Regex("[\r\n \t,]+")); // Whitespace
          lexerRules.add(Regex("#[^\r\n]*$"));  // Comments

          // Double quoted strings
          lexerRules.add(Regex("\"([^\"\\]|\\\\.)*\""), l_string, t_string);

          // Signed decimal integers
          lexerRules.add(Regex("[+-]?[0-9]+"), l_decInt, t_num);

          // Signed hexadecimal integers
          lexerRules.add(Regex("[+-]?0[xX][0-9a-fA-F]+"), l_hexInt, t_num);

          // Signed floating point numbers
          lexerRules.add(Regex("[+-]?([0-9]+\\.|[0-9]*\\.[0-9]+)"
                               "([eE][+-]?[0-9]+)?"), l_float, t_num);

          // Identifiers
          lexerRules.add(Regex("{id_first_char}{id_rest_char}*", env), l_id, t_Id);

          lexerEngine =
            auto_ptr<Lexer::Engine>(new Lexer::Engine(lexerRules,
                                                      lexerActor.get()));
        }
      };

      void Parser::Context::fieldValueWarning(string m)
      {
        NodeEntry &e = nodeStack.back();
        warning("In field " + printQuote(e.node->getType()->getName()) +
                "." + printQuote(e.field->getName()) + " of type " +
                e.field->getType()->getName() + ": " + m);
      }

      /*
        class Parser
        {
        Tokenizer tokenizer;

        Ref<Value> parseSingeFieldValue()
        {
        switch(valueTypeId)
        {
        case type_bool:
        {
        Ref<Token> t = tokenizer.get();
        if(t->type == token_TRUE) return Bool(true);
        else if(t->type == token_FALSE) return Bool(false);
        else
        {
        warning("Invalid boolean value");
        return false;
        }
        return Ref<Value>(new SFBool())
        }
        }
        }

        void parseFieldValue()
        {
        Ref<Token> t = tokenizer.get();

        if(if(dynamic_cast<MultipleFieldType>(fieldType)) && t->type == token_leftBracket)
        {
        for(;;)
        {
        tokenizer.next();
        Ref<Token> t = tokenizer.get();
        if(t->type == token_rightBracket) break;
        parseSingeFieldValue();
        }

        return;
        }

        parseSingeFieldValue();
        }

        void parseNodeBodyElement(Ref<Node> n)
        {
        Ref<Token> t = tokenizer.get();

        if(t->type == token_PROTO || t->type == token_EXTERNPROTO)
        {
        parseProtoStatement();
        return;
        }

        if(t->type == token_ROUTE)
        {
        parseRouteStatement();
        return;
        }

        if(t->type != token_id) error("Field name expected");
        const Field *field = n->getField(t.value);
        if(!field) warning((string)"Invalid field name '" + t.value + "'");
        tokenizer.next();
        t = tokenizer.getToken();
        if(t->type == token_IS) error("Prototypes are not yet supported");
        field->assignValue(parseFieldValue(field->getType()));
        
        }

        void parseNodeBody(Ref<Node> n)
        {
        for(;;)
        {
        Ref<Token> t = tokenizer.get();
        if(t->type == token_leftBrace) break;
        parseNodeBodyElement(n);
        }
        }
      
        void parseScriptBodyElement(Ref<Script> s)
        {
        error("Scripts are not yet supported");
        }

        void parseScriptBody(Ref<Script> s)
        {
        for(;;)
        {
        Ref<Token> t = tokenizer.get();
        if(t->type == token_leftBrace) break;
        parseScriptBodyElement(s);
        }
        }

        Ref<Node> parseNode()
        {
        Ref<Token> t = tokenizer.get();

        if(t->type == token_Script)
        {
        tokenizer.next();
        t = tokenizer.getToken();
        if(t->type != token_leftBrace) error("'{' expected");
        parseScriptBody(instantiateScript());
        t = tokenizer.getToken();
        if(t->type != token_rightBrace) error("'}' expected");
        tokenizer.next();
        return n;
        }

        if(t->type != token_id) error("Node type name expected");
        Ref<Node> n = instantiateNode(t.value);
        tokenizer.next();
        t = tokenizer.getToken();
        if(t->type != token_leftBrace) error("'}' expected");
        parseNodeBody(n);
        t = tokenizer.getToken();
        if(t->type != token_rightBrace) error("'}' expected");
        tokenizer.next();
        return n;
        }

        void parseNodeStatement()
        {
        Ref<Token> t = tokenizer.get();

        if(t->type == token_DEF)
        {
        tokenizer.next();
        t = tokenizer.getToken();
        if(t->type != token_id) error("Node instance name expected");
        if(Ref<Node> n = parseNode())
        {
        registerNamedNode(n, t->value);
        addNodeToGroup(n);
        }
        return;
        }

        if(t->type == token_USE)
        {
        tokenizer.next();
        t = tokenizer.getToken();
        if(t->type != token_id) error("Node instance name expected");
        if(Ref<Node> n = lookupNamedNode(t->value)) addNodeToGroup(n);
        return;
        }

        if(Ref<Node> n = parseNode()) addNodeToGroup(n);
        }

        void parseProtoStatement()
        {
        error("Prototypes are not yet supported");
        }

        void parseRouteStatement()
        {
        Ref<Token> t = tokenizer.get();
        if(t->type != token_ROUTE) error("ROUTE keyword expected");
        tokenizer.next();
        t = tokenizer.getToken();
        if(t->type != token_id) error("Node instance name expected");
        const Ref<Node> fromNode = lookupNamedNode(t->value);
        if(!fromNode)
        {
        warning((string)"Undefined node instance name '" + t->value + "'");
        return;
        }
        tokenizer.next();
        t = tokenizer.getToken();
        if(t->type != token_dot) error("'.' expected");
        tokenizer.next();
        t = tokenizer.getToken();
        if(t->type != token_id) error("Field name expected");
        const Ref<FieldType> fromField = fromNode->getField(t->value);
        if(!fromField)
        {
        warning((string)"There is no field named '" + t->value + "' in a '" +
        fromNode->getName() + "'");
        return;
        }
        tokenizer.next();
        t = tokenizer.getToken();
        if(t->type != token_TO) error("TO keyword expected");
        tokenizer.next();
        t = tokenizer.getToken();
        if(t->type != token_id) error("Node instance name expected");
        const Ref<Node> toNode = lookupNamedNode(t->value);
        if(!toNode)
        {
        warning((string)"Undefined node instance name '" + t->value + "'");
        return;
        }
        tokenizer.next();
        t = tokenizer.getToken();
        if(t->type != token_dot) error("'.' expected");
        tokenizer.next();
        t = tokenizer.getToken();
        if(t->type != token_id) error("Field name expected");
        const Ref<Field> toField = toNode->getField(t->value);
        if(!fromField)
        {
        warning((string)"There is no field named '" + t->value + "' in a '" +
        toNode->getTypeName() + "'");
        return;
        }
        tokenizer.next();
        addRoute(fromField, toField);
        }

        void parseStatement()
        {
        Ref<Token> t = tokenizer.get();

        if(t->type == token_PROTO || t->type == token_EXTERNPROTO)
        {
        parseProtoStatement();
        return;
        }

        if(t->type == token_ROUTE)
        {
        parseRouteStatement();
        return;
        }

        parseNodeStatement();
        }

        void parseStatements()
        {
        for(;;)
        {
        Ref<Token> t = tokenizer.get();
        if(t == token_eof || t->type == token_leftBrace) break;
        parseStatement();
        }
        }

        Parser(const Reader &r): lexer(r)
        {
        Regex<wchar_t>::Environment e;
        e.define("[^\\zero-\x20\x30-\x39\x22\x23\x27\x2b\x2c\x2d\x2e\x5b\x5c\x5d\x7b\x7d\x7f]");
        }

        void parse()
        {
        parseStatements(); // Jump into the parser
        }
        };
      */

      Ref<Scene> parse(Stream::BasicReader<uchar> &r, const Uri &uri,
                       ProgressTracker *progressTracker,
                       Logger *logger)
      {
        static Parser parser;
        Parser::Context context(uri, progressTracker, logger);
        Lexer lexer(*(parser.lexerEngine.get()), r, &context);
        context.lexer = &lexer;
        Ref<const Scene> scene;
        parser.lrParser->parse(lexer, context, scene/*, logger*/); // Comment in the logger for debugging
        Ref<Scene> scene2(const_cast<Scene *>(scene.get()));
        if(progressTracker) progressTracker->set(scene2);
        return scene2;
      }
    }
  }
}

---