Merge branch '4.7' of scm.dev.nokia.troll.no:qt/qt-doc-staging into 4.7-integration

* '4.7' of scm.dev.nokia.troll.no:qt/qt-doc-staging: (45 commits)
  Removed mobile demos from the Symbian build in demos.pro
  Fixed demo subdirs for mobile examples.
  qdoc: Updates to the qdoc manual.
  Moved a couple of links into one list.
  Doc: Work on GettingStartedQt tutorial
  Added a link to the Debugging Techniques article.
  qdoc: Updates to the qdoc manual.
  qdoc: Added a way to exclude directories from receiving default metadata
  Edited the Tutorials and Examples pages. Renamed links in index.qdoc.
  Doc: Update to QStyledItemDelegate::displayText()
  qdoc: Added default values to config file for DITA
  Doc: Work on QAudioInput::start() functions.
  Avoided the use of hard-coded file names.
  Copied the declarative parser into qdoc3 to avoid dependency issues.
  qdoc: Don't wrap <image> in <fig> if in an <xref>
  Doc: Work on a11y docs
  qdoc: Added <copyright>, <copyryear>, and <copyrholder>.
  qdoc: Completed metadata handling.
  Doc: Small update to QImageReader/Writer::supportedImageFomrmats()
  Edited QtWebKit Guide qdoc and added external links.
  ...

37 files changed, 13504 insertions, 243 deletions

diff --git a/tools/qdoc3/codemarker.cpp b/tools/qdoc3/codemarker.cpp
index 58642ef..84a09ce 100644
--- a/tools/qdoc3/codemarker.cpp
+++ b/tools/qdoc3/codemarker.cpp
@@ -491,7 +491,7 @@ static QString encode(const QString &string)
 #endif
 }
 
-QStringList CodeMarker::macRefsForNode(const Node *node)
+QStringList CodeMarker::macRefsForNode(Node *node)
 {
     QString result = QLatin1String("cpp/");
     switch (node->type()) {
@@ -583,7 +583,7 @@ QStringList CodeMarker::macRefsForNode(const Node *node)
          {
              NodeList list = static_cast<const PropertyNode*>(node)->functions();
              QStringList stringList;
-             foreach (const Node *node, list) {
+             foreach (Node* node, list) {
                 stringList += macRefsForNode(node);
              }
              return stringList;
diff --git a/tools/qdoc3/codemarker.h b/tools/qdoc3/codemarker.h
index 65fcdd4..21bc31f 100644
--- a/tools/qdoc3/codemarker.h
+++ b/tools/qdoc3/codemarker.h
@@ -155,7 +155,7 @@ class CodeMarker
                                       const Tree* tree,
 		                      const Node* relative,
                                       const Node* self = 0);
-    virtual QStringList macRefsForNode(const Node* node);
+    virtual QStringList macRefsForNode(Node* node);
 
     static void initialize(const Config& config);
     static void terminate();
diff --git a/tools/qdoc3/config.cpp b/tools/qdoc3/config.cpp
index 08a8187..267a09c 100644
--- a/tools/qdoc3/config.cpp
+++ b/tools/qdoc3/config.cpp
@@ -329,7 +329,10 @@ QList<QRegExp> Config::getRegExpList(const QString& var) const
 }
 
 /*!
-  This function is slower than it could be.
+  This function is slower than it could be. What it does is
+  find all the keys that begin with \a var + dot and return
+  the matching keys in a set, stripped of the matching prefix
+  and dot.
  */
 QSet<QString> Config::subVars(const QString& var) const
 {
@@ -350,6 +353,27 @@ QSet<QString> Config::subVars(const QString& var) const
 }
 
 /*!
+  Same as subVars(), but in this case we return a string map
+  with the matching keys (stripped of the prefix \a var and
+  mapped to their values. The pairs are inserted into \a t
+ */
+void Config::subVarsAndValues(const QString& var, QStringMap& t) const
+{
+    QString varDot = var + QLatin1Char('.');
+    QMap<QString, QString>::ConstIterator v = stringValueMap.begin();
+    while (v != stringValueMap.end()) {
+        if (v.key().startsWith(varDot)) {
+            QString subVar = v.key().mid(varDot.length());
+            int dot = subVar.indexOf(QLatin1Char('.'));
+            if (dot != -1)
+                subVar.truncate(dot);
+            t.insert(subVar,v.value());
+        }
+        ++v;
+    }
+}
+
+/*!
   Builds and returns a list of file pathnames for the file
   type specified by \a filesVar (e.g. "headers" or "sources").
   The files are found in the directories specified by
diff --git a/tools/qdoc3/config.h b/tools/qdoc3/config.h
index 9ebc0f8..767acb1 100644
--- a/tools/qdoc3/config.h
+++ b/tools/qdoc3/config.h
@@ -54,6 +54,8 @@
 
 QT_BEGIN_NAMESPACE
 
+typedef QMap<QString,QString> QStringMap;
+
 class Config
 {
  public:
@@ -74,6 +76,7 @@ class Config
     QRegExp getRegExp(const QString& var) const;
     QList<QRegExp> getRegExpList(const QString& var) const;
     QSet<QString> subVars(const QString& var) const;
+    void subVarsAndValues(const QString& var, QStringMap& t) const;
     QStringList getAllFiles(const QString& filesVar, 
                             const QString& dirsVar,
                             const QSet<QString> &excludedDirs = QSet<QString>());
diff --git a/tools/qdoc3/cppcodeparser.cpp b/tools/qdoc3/cppcodeparser.cpp
index 595756a..4d04085 100644
--- a/tools/qdoc3/cppcodeparser.cpp
+++ b/tools/qdoc3/cppcodeparser.cpp
@@ -97,6 +97,22 @@ QT_BEGIN_NAMESPACE
 #define COMMAND_QMLBASICTYPE            Doc::alias("qmlbasictype")
 #endif
 
+#define COMMAND_AUDIENCE                Doc::alias("audience")
+#define COMMAND_CATEGORY                Doc::alias("category")
+#define COMMAND_PRODNAME                Doc::alias("prodname")
+#define COMMAND_COMPONENT               Doc::alias("component")
+#define COMMAND_AUTHOR                  Doc::alias("author")
+#define COMMAND_PUBLISHER               Doc::alias("publisher")
+#define COMMAND_COPYRYEAR               Doc::alias("copyryear")
+#define COMMAND_COPYRHOLDER             Doc::alias("copyrholder")
+#define COMMAND_PERMISSIONS             Doc::alias("permissions")
+#define COMMAND_LIFECYCLEVERSION        Doc::alias("lifecycleversion")
+#define COMMAND_LIFECYCLEWSTATUS        Doc::alias("lifecyclestatus")
+#define COMMAND_LICENSEYEAR             Doc::alias("licenseyear")
+#define COMMAND_LICENSENAME             Doc::alias("licensename")
+#define COMMAND_LICENSEDESCRIPTION      Doc::alias("licensedescription")
+#define COMMAND_RELEASEDATE             Doc::alias("releasedate")
+
 QStringList CppCodeParser::exampleFiles;
 QStringList CppCodeParser::exampleDirs;
 
@@ -1811,7 +1827,7 @@ bool CppCodeParser::matchProperty(InnerNode *parent)
              !match(Tok_QDOC_PROPERTY)) {
         return false;
     }
-    
+
     if (!match(expected_tok))
         return false;
 
@@ -1893,9 +1909,9 @@ bool CppCodeParser::matchProperty(InnerNode *parent)
                 property->setRuntimeScrFunc(value);
             }
         }
-        else if (key == "CONSTANT") 
+        else if (key == "CONSTANT")
             property->setConstant();
-        else if (key == "FINAL") 
+        else if (key == "FINAL")
             property->setFinal();
     }
     match(Tok_RightParen);
diff --git a/tools/qdoc3/declarativeparser/parser.pri b/tools/qdoc3/declarativeparser/parser.pri
new file mode 100644
index 0000000..fd4361c
--- /dev/null
+++ b/tools/qdoc3/declarativeparser/parser.pri
@@ -0,0 +1,21 @@
+INCLUDEPATH += $$PWD
+
+HEADERS += \
+    $$PWD/qdeclarativejsast_p.h \
+    $$PWD/qdeclarativejsastfwd_p.h \
+    $$PWD/qdeclarativejsastvisitor_p.h \
+    $$PWD/qdeclarativejsengine_p.h \
+    $$PWD/qdeclarativejsgrammar_p.h \
+    $$PWD/qdeclarativejslexer_p.h \
+    $$PWD/qdeclarativejsmemorypool_p.h \
+    $$PWD/qdeclarativejsnodepool_p.h \
+    $$PWD/qdeclarativejsparser_p.h \
+    $$PWD/qdeclarativejsglobal_p.h
+
+SOURCES += \
+    $$PWD/qdeclarativejsast.cpp \
+    $$PWD/qdeclarativejsastvisitor.cpp \
+    $$PWD/qdeclarativejsengine_p.cpp \
+    $$PWD/qdeclarativejsgrammar.cpp \
+    $$PWD/qdeclarativejslexer.cpp \
+    $$PWD/qdeclarativejsparser.cpp
diff --git a/tools/qdoc3/declarativeparser/qdeclarativejs.g b/tools/qdoc3/declarativeparser/qdeclarativejs.g
new file mode 100644
index 0000000..0e7454e
--- /dev/null
+++ b/tools/qdoc3/declarativeparser/qdeclarativejs.g
@@ -0,0 +1,3149 @@
+----------------------------------------------------------------------------
+--
+-- Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+-- All rights reserved.
+-- Contact: Nokia Corporation (qt-info@nokia.com)
+--
+-- This file is part of the QtDeclarative module of the Qt Toolkit.
+--
+-- $QT_BEGIN_LICENSE:LGPL-ONLY$
+-- GNU Lesser General Public License Usage
+-- This file may be used under the terms of the GNU Lesser
+-- General Public License version 2.1 as published by the Free Software
+-- Foundation and appearing in the file LICENSE.LGPL included in the
+-- packaging of this file.  Please review the following information to
+-- ensure the GNU Lesser General Public License version 2.1 requirements
+-- will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+--
+-- If you have questions regarding the use of this file, please contact
+-- Nokia at qt-info@nokia.com.
+-- $QT_END_LICENSE$
+--
+----------------------------------------------------------------------------
+
+%parser         QDeclarativeJSGrammar
+%decl           qdeclarativejsparser_p.h
+%impl           qdeclarativejsparser.cpp
+%expect         2
+%expect-rr      2
+
+%token T_AND "&"                T_AND_AND "&&"              T_AND_EQ "&="
+%token T_BREAK "break"          T_CASE "case"               T_CATCH "catch"
+%token T_COLON ":"              T_COMMA ";"                 T_CONTINUE "continue"
+%token T_DEFAULT "default"      T_DELETE "delete"           T_DIVIDE_ "/"
+%token T_DIVIDE_EQ "/="         T_DO "do"                   T_DOT "."
+%token T_ELSE "else"            T_EQ "="                    T_EQ_EQ "=="
+%token T_EQ_EQ_EQ "==="         T_FINALLY "finally"         T_FOR "for"
+%token T_FUNCTION "function"    T_GE ">="                   T_GT ">"
+%token T_GT_GT ">>"             T_GT_GT_EQ ">>="            T_GT_GT_GT ">>>"
+%token T_GT_GT_GT_EQ ">>>="     T_IDENTIFIER "identifier"   T_IF "if"
+%token T_IN "in"                T_INSTANCEOF "instanceof"   T_LBRACE "{"
+%token T_LBRACKET "["           T_LE "<="                   T_LPAREN "("
+%token T_LT "<"                 T_LT_LT "<<"                T_LT_LT_EQ "<<="
+%token T_MINUS "-"              T_MINUS_EQ "-="             T_MINUS_MINUS "--"
+%token T_NEW "new"              T_NOT "!"                   T_NOT_EQ "!="
+%token T_NOT_EQ_EQ "!=="        T_NUMERIC_LITERAL "numeric literal"     T_OR "|"
+%token T_OR_EQ "|="             T_OR_OR "||"                T_PLUS "+"
+%token T_PLUS_EQ "+="           T_PLUS_PLUS "++"            T_QUESTION "?"
+%token T_RBRACE "}"             T_RBRACKET "]"              T_REMAINDER "%"
+%token T_REMAINDER_EQ "%="      T_RETURN "return"           T_RPAREN ")"
+%token T_SEMICOLON ";"          T_AUTOMATIC_SEMICOLON       T_STAR "*"
+%token T_STAR_EQ "*="           T_STRING_LITERAL "string literal"
+%token T_PROPERTY "property"    T_SIGNAL "signal"           T_READONLY "readonly"
+%token T_SWITCH "switch"        T_THIS "this"               T_THROW "throw"
+%token T_TILDE "~"              T_TRY "try"                 T_TYPEOF "typeof"
+%token T_VAR "var"              T_VOID "void"               T_WHILE "while"
+%token T_WITH "with"            T_XOR "^"                   T_XOR_EQ "^="
+%token T_NULL "null"            T_TRUE "true"               T_FALSE "false"
+%token T_CONST "const"
+%token T_DEBUGGER "debugger"
+%token T_RESERVED_WORD "reserved word"
+%token T_MULTILINE_STRING_LITERAL "multiline string literal"
+%token T_COMMENT "comment"
+
+--- context keywords.
+%token T_PUBLIC "public"
+%token T_IMPORT "import"
+%token T_AS "as"
+%token T_ON "on"
+
+--- feed tokens
+%token T_FEED_UI_PROGRAM
+%token T_FEED_UI_OBJECT_MEMBER
+%token T_FEED_JS_STATEMENT
+%token T_FEED_JS_EXPRESSION
+%token T_FEED_JS_SOURCE_ELEMENT
+%token T_FEED_JS_PROGRAM
+
+%nonassoc SHIFT_THERE
+%nonassoc T_IDENTIFIER T_COLON T_SIGNAL T_PROPERTY T_READONLY
+%nonassoc REDUCE_HERE
+
+%start TopLevel
+
+/./****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtCore/QtDebug>
+#include <QtGui/QApplication>
+
+#include <string.h>
+
+#include "private/qdeclarativejsengine_p.h"
+#include "private/qdeclarativejslexer_p.h"
+#include "private/qdeclarativejsast_p.h"
+#include "private/qdeclarativejsnodepool_p.h"
+
+./
+
+/:/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+//
+// This file is automatically generated from qmljs.g.
+// Changes will be lost.
+//
+
+#ifndef QDECLARATIVEJSPARSER_P_H
+#define QDECLARATIVEJSPARSER_P_H
+
+#include "private/qdeclarativejsglobal_p.h"
+#include "private/qdeclarativejsgrammar_p.h"
+#include "private/qdeclarativejsast_p.h"
+#include "private/qdeclarativejsengine_p.h"
+
+#include <QtCore/QList>
+#include <QtCore/QString>
+
+QT_QML_BEGIN_NAMESPACE
+
+namespace QDeclarativeJS {
+
+class Engine;
+class NameId;
+
+class QML_PARSER_EXPORT Parser: protected $table
+{
+public:
+    union Value {
+      int ival;
+      double dval;
+      NameId *sval;
+      AST::ArgumentList *ArgumentList;
+      AST::CaseBlock *CaseBlock;
+      AST::CaseClause *CaseClause;
+      AST::CaseClauses *CaseClauses;
+      AST::Catch *Catch;
+      AST::DefaultClause *DefaultClause;
+      AST::ElementList *ElementList;
+      AST::Elision *Elision;
+      AST::ExpressionNode *Expression;
+      AST::Finally *Finally;
+      AST::FormalParameterList *FormalParameterList;
+      AST::FunctionBody *FunctionBody;
+      AST::FunctionDeclaration *FunctionDeclaration;
+      AST::Node *Node;
+      AST::PropertyName *PropertyName;
+      AST::PropertyNameAndValueList *PropertyNameAndValueList;
+      AST::SourceElement *SourceElement;
+      AST::SourceElements *SourceElements;
+      AST::Statement *Statement;
+      AST::StatementList *StatementList;
+      AST::Block *Block;
+      AST::VariableDeclaration *VariableDeclaration;
+      AST::VariableDeclarationList *VariableDeclarationList;
+
+      AST::UiProgram *UiProgram;
+      AST::UiImportList *UiImportList;
+      AST::UiImport *UiImport;
+      AST::UiParameterList *UiParameterList;
+      AST::UiPublicMember *UiPublicMember;
+      AST::UiObjectDefinition *UiObjectDefinition;
+      AST::UiObjectInitializer *UiObjectInitializer;
+      AST::UiObjectBinding *UiObjectBinding;
+      AST::UiScriptBinding *UiScriptBinding;
+      AST::UiArrayBinding *UiArrayBinding;
+      AST::UiObjectMember *UiObjectMember;
+      AST::UiObjectMemberList *UiObjectMemberList;
+      AST::UiArrayMemberList *UiArrayMemberList;
+      AST::UiQualifiedId *UiQualifiedId;
+      AST::UiSignature *UiSignature;
+      AST::UiFormalList *UiFormalList;
+      AST::UiFormal *UiFormal;
+    };
+
+public:
+    Parser(Engine *engine);
+    ~Parser();
+
+    // parse a UI program
+    bool parse() { return parse(T_FEED_UI_PROGRAM); }
+    bool parseStatement() { return parse(T_FEED_JS_STATEMENT); }
+    bool parseExpression() { return parse(T_FEED_JS_EXPRESSION); }
+    bool parseSourceElement() { return parse(T_FEED_JS_SOURCE_ELEMENT); }
+    bool parseUiObjectMember() { return parse(T_FEED_UI_OBJECT_MEMBER); }
+    bool parseProgram() { return parse(T_FEED_JS_PROGRAM); }
+
+    AST::UiProgram *ast() const
+    { return AST::cast<AST::UiProgram *>(program); }
+
+    AST::Statement *statement() const
+    {
+        if (! program)
+            return 0;
+
+        return program->statementCast();
+    }
+
+    AST::ExpressionNode *expression() const
+    {
+        if (! program)
+            return 0;
+
+        return program->expressionCast();
+    }
+
+    AST::UiObjectMember *uiObjectMember() const
+    {
+        if (! program)
+            return 0;
+
+        return program->uiObjectMemberCast();
+    }
+
+    AST::Node *rootNode() const
+    { return program; }
+
+    QList<DiagnosticMessage> diagnosticMessages() const
+    { return diagnostic_messages; }
+
+    inline DiagnosticMessage diagnosticMessage() const
+    {
+        foreach (const DiagnosticMessage &d, diagnostic_messages) {
+            if (! d.kind == DiagnosticMessage::Warning)
+                return d;
+        }
+
+        return DiagnosticMessage();
+    }
+
+    inline QString errorMessage() const
+    { return diagnosticMessage().message; }
+
+    inline int errorLineNumber() const
+    { return diagnosticMessage().loc.startLine; }
+
+    inline int errorColumnNumber() const
+    { return diagnosticMessage().loc.startColumn; }
+
+protected:
+    bool parse(int startToken);
+
+    void reallocateStack();
+
+    inline Value &sym(int index)
+    { return sym_stack [tos + index - 1]; }
+
+    inline AST::SourceLocation &loc(int index)
+    { return location_stack [tos + index - 1]; }
+
+    AST::UiQualifiedId *reparseAsQualifiedId(AST::ExpressionNode *expr);
+
+protected:
+    Engine *driver;
+    int tos;
+    int stack_size;
+    Value *sym_stack;
+    int *state_stack;
+    AST::SourceLocation *location_stack;
+
+    AST::Node *program;
+
+    // error recovery
+    enum { TOKEN_BUFFER_SIZE = 3 };
+
+    struct SavedToken {
+       int token;
+       double dval;
+       AST::SourceLocation loc;
+    };
+
+    double yylval;
+    AST::SourceLocation yylloc;
+    AST::SourceLocation yyprevlloc;
+
+    SavedToken token_buffer[TOKEN_BUFFER_SIZE];
+    SavedToken *first_token;
+    SavedToken *last_token;
+
+    QList<DiagnosticMessage> diagnostic_messages;
+};
+
+} // end of namespace QDeclarativeJS
+
+
+:/
+
+
+/.
+
+#include "private/qdeclarativejsparser_p.h"
+#include <QVarLengthArray>
+
+//
+// This file is automatically generated from qmljs.g.
+// Changes will be lost.
+//
+
+using namespace QDeclarativeJS;
+
+QT_QML_BEGIN_NAMESPACE
+
+void Parser::reallocateStack()
+{
+    if (! stack_size)
+        stack_size = 128;
+    else
+        stack_size <<= 1;
+
+    sym_stack = reinterpret_cast<Value*> (qRealloc(sym_stack, stack_size * sizeof(Value)));
+    state_stack = reinterpret_cast<int*> (qRealloc(state_stack, stack_size * sizeof(int)));
+    location_stack = reinterpret_cast<AST::SourceLocation*> (qRealloc(location_stack, stack_size * sizeof(AST::SourceLocation)));
+}
+
+inline static bool automatic(Engine *driver, int token)
+{
+    return token == $table::T_RBRACE
+        || token == 0
+        || driver->lexer()->prevTerminator();
+}
+
+
+Parser::Parser(Engine *engine):
+    driver(engine),
+    tos(0),
+    stack_size(0),
+    sym_stack(0),
+    state_stack(0),
+    location_stack(0),
+    first_token(0),
+    last_token(0)
+{
+}
+
+Parser::~Parser()
+{
+    if (stack_size) {
+        qFree(sym_stack);
+        qFree(state_stack);
+        qFree(location_stack);
+    }
+}
+
+static inline AST::SourceLocation location(Lexer *lexer)
+{
+    AST::SourceLocation loc;
+    loc.offset = lexer->tokenOffset();
+    loc.length = lexer->tokenLength();
+    loc.startLine = lexer->startLineNo();
+    loc.startColumn = lexer->startColumnNo();
+    return loc;
+}
+
+AST::UiQualifiedId *Parser::reparseAsQualifiedId(AST::ExpressionNode *expr)
+{
+    QVarLengthArray<NameId *, 4> nameIds;
+    QVarLengthArray<AST::SourceLocation, 4> locations;
+
+    AST::ExpressionNode *it = expr;
+    while (AST::FieldMemberExpression *m = AST::cast<AST::FieldMemberExpression *>(it)) {
+        nameIds.append(m->name);
+        locations.append(m->identifierToken);
+        it = m->base;
+    }
+
+    if (AST::IdentifierExpression *idExpr = AST::cast<AST::IdentifierExpression *>(it)) {
+        AST::UiQualifiedId *q = makeAstNode<AST::UiQualifiedId>(driver->nodePool(), idExpr->name);
+        q->identifierToken = idExpr->identifierToken;
+
+        AST::UiQualifiedId *currentId = q;
+        for (int i = nameIds.size() - 1; i != -1; --i) {
+            currentId = makeAstNode<AST::UiQualifiedId>(driver->nodePool(), currentId, nameIds[i]);
+            currentId->identifierToken = locations[i];
+        }
+
+        return currentId->finish();
+    }
+
+    return 0;
+}
+
+bool Parser::parse(int startToken)
+{
+    Lexer *lexer = driver->lexer();
+    bool hadErrors = false;
+    int yytoken = -1;
+    int action = 0;
+
+    token_buffer[0].token = startToken;
+    first_token = &token_buffer[0];
+    last_token = &token_buffer[1];
+
+    tos = -1;
+    program = 0;
+
+    do {
+        if (++tos == stack_size)
+            reallocateStack();
+
+        state_stack[tos] = action;
+
+    _Lcheck_token:
+        if (yytoken == -1 && -TERMINAL_COUNT != action_index[action]) {
+            yyprevlloc = yylloc;
+
+            if (first_token == last_token) {
+                yytoken = lexer->lex();
+                yylval = lexer->dval();
+                yylloc = location(lexer);
+            } else {
+                yytoken = first_token->token;
+                yylval = first_token->dval;
+                yylloc = first_token->loc;
+                ++first_token;
+            }
+        }
+
+        action = t_action(action, yytoken);
+        if (action > 0) {
+            if (action != ACCEPT_STATE) {
+                yytoken = -1;
+                sym(1).dval = yylval;
+                loc(1) = yylloc;
+            } else {
+              --tos;
+              return ! hadErrors;
+            }
+        } else if (action < 0) {
+          const int r = -action - 1;
+          tos -= rhs[r];
+
+          switch (r) {
+./
+
+--------------------------------------------------------------------------------------------------------
+-- Declarative UI
+--------------------------------------------------------------------------------------------------------
+
+TopLevel: T_FEED_UI_PROGRAM UiProgram ;
+/.
+case $rule_number: {
+  sym(1).Node = sym(2).Node;
+  program = sym(1).Node;
+} break;
+./
+
+TopLevel: T_FEED_JS_STATEMENT Statement ;
+/.
+case $rule_number: {
+  sym(1).Node = sym(2).Node;
+  program = sym(1).Node;
+} break;
+./
+
+TopLevel: T_FEED_JS_EXPRESSION Expression ;
+/.
+case $rule_number: {
+  sym(1).Node = sym(2).Node;
+  program = sym(1).Node;
+} break;
+./
+
+TopLevel: T_FEED_JS_SOURCE_ELEMENT SourceElement ;
+/.
+case $rule_number: {
+  sym(1).Node = sym(2).Node;
+  program = sym(1).Node;
+} break;
+./
+
+TopLevel: T_FEED_UI_OBJECT_MEMBER UiObjectMember ;
+/.
+case $rule_number: {
+  sym(1).Node = sym(2).Node;
+  program = sym(1).Node;
+} break;
+./
+
+TopLevel: T_FEED_JS_PROGRAM Program ;
+/.
+case $rule_number: {
+  sym(1).Node = sym(2).Node;
+  program = sym(1).Node;
+} break;
+./
+
+UiProgram: UiImportListOpt UiRootMember ;
+/.
+case $rule_number: {
+  sym(1).UiProgram = makeAstNode<AST::UiProgram> (driver->nodePool(), sym(1).UiImportList,
+        sym(2).UiObjectMemberList->finish());
+} break;
+./
+
+UiImportListOpt: Empty ;
+UiImportListOpt: UiImportList ;
+/.
+case $rule_number: {
+    sym(1).Node = sym(1).UiImportList->finish();
+} break;
+./
+
+UiImportList: UiImport ;
+/.
+case $rule_number: {
+    sym(1).Node = makeAstNode<AST::UiImportList> (driver->nodePool(), sym(1).UiImport);
+} break;
+./
+
+UiImportList: UiImportList UiImport ;
+/.
+case $rule_number: {
+    sym(1).Node = makeAstNode<AST::UiImportList> (driver->nodePool(),
+        sym(1).UiImportList, sym(2).UiImport);
+} break;
+./
+
+ImportId: MemberExpression ;
+
+UiImport: UiImportHead T_AUTOMATIC_SEMICOLON ;
+UiImport: UiImportHead T_SEMICOLON ;
+/.
+case $rule_number: {
+    sym(1).UiImport->semicolonToken = loc(2);
+} break;
+./
+
+UiImport: UiImportHead T_NUMERIC_LITERAL T_AUTOMATIC_SEMICOLON ;
+UiImport: UiImportHead T_NUMERIC_LITERAL T_SEMICOLON ;
+/.
+case $rule_number: {
+    sym(1).UiImport->versionToken = loc(2);
+    sym(1).UiImport->semicolonToken = loc(3);
+} break;
+./
+
+UiImport: UiImportHead T_NUMERIC_LITERAL T_AS JsIdentifier T_AUTOMATIC_SEMICOLON ;
+UiImport: UiImportHead T_NUMERIC_LITERAL T_AS JsIdentifier T_SEMICOLON ;
+/.
+case $rule_number: {
+    sym(1).UiImport->versionToken = loc(2);
+    sym(1).UiImport->asToken = loc(3);
+    sym(1).UiImport->importIdToken = loc(4);
+    sym(1).UiImport->importId = sym(4).sval;
+    sym(1).UiImport->semicolonToken = loc(5);
+} break;
+./
+
+UiImport: UiImportHead T_AS JsIdentifier T_AUTOMATIC_SEMICOLON ;
+UiImport: UiImportHead T_AS JsIdentifier T_SEMICOLON ;
+/.
+case $rule_number: {
+    sym(1).UiImport->asToken = loc(2);
+    sym(1).UiImport->importIdToken = loc(3);
+    sym(1).UiImport->importId = sym(3).sval;
+    sym(1).UiImport->semicolonToken = loc(4);
+} break;
+./
+
+
+UiImportHead: T_IMPORT ImportId ;
+/.
+case $rule_number: {
+    AST::UiImport *node = 0;
+
+    if (AST::StringLiteral *importIdLiteral = AST::cast<AST::StringLiteral *>(sym(2).Expression)) {
+        node = makeAstNode<AST::UiImport>(driver->nodePool(), importIdLiteral->value);
+        node->fileNameToken = loc(2);
+    } else if (AST::UiQualifiedId *qualifiedId = reparseAsQualifiedId(sym(2).Expression)) {
+        node = makeAstNode<AST::UiImport>(driver->nodePool(), qualifiedId);
+        node->fileNameToken = loc(2);
+    }
+
+    sym(1).Node = node;
+
+    if (node) {
+        node->importToken = loc(1);
+    } else {
+       diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, loc(1),
+         QLatin1String("Expected a qualified name id or a string literal")));
+
+        return false; // ### remove me
+    }
+} break;
+./
+
+Empty: ;
+/.
+case $rule_number: {
+    sym(1).Node = 0;
+} break;
+./
+
+UiRootMember: UiObjectDefinition ;
+/.
+case $rule_number: {
+    sym(1).Node = makeAstNode<AST::UiObjectMemberList> (driver->nodePool(), sym(1).UiObjectMember);
+} break;
+./
+
+UiObjectMemberList: UiObjectMember ;
+/.
+case $rule_number: {
+    sym(1).Node = makeAstNode<AST::UiObjectMemberList> (driver->nodePool(), sym(1).UiObjectMember);
+} break;
+./
+
+UiObjectMemberList: UiObjectMemberList UiObjectMember ;
+/.
+case $rule_number: {
+    AST::UiObjectMemberList *node = makeAstNode<AST:: UiObjectMemberList> (driver->nodePool(),
+        sym(1).UiObjectMemberList, sym(2).UiObjectMember);
+    sym(1).Node = node;
+} break;
+./
+
+UiArrayMemberList: UiObjectDefinition ;
+/.
+case $rule_number: {
+    sym(1).Node = makeAstNode<AST::UiArrayMemberList> (driver->nodePool(), sym(1).UiObjectMember);
+} break;
+./
+
+UiArrayMemberList: UiArrayMemberList T_COMMA UiObjectDefinition ;
+/.
+case $rule_number: {
+    AST::UiArrayMemberList *node = makeAstNode<AST::UiArrayMemberList> (driver->nodePool(),
+        sym(1).UiArrayMemberList, sym(3).UiObjectMember);
+    node->commaToken = loc(2);
+    sym(1).Node = node;
+} break;
+./
+
+UiObjectInitializer: T_LBRACE T_RBRACE ;
+/.
+case $rule_number: {
+    AST::UiObjectInitializer *node = makeAstNode<AST::UiObjectInitializer> (driver->nodePool(), (AST::UiObjectMemberList*)0);
+    node->lbraceToken = loc(1);
+    node->rbraceToken = loc(2);
+    sym(1).Node = node;
+}   break;
+./
+
+UiObjectInitializer: T_LBRACE UiObjectMemberList T_RBRACE ;
+/.
+case $rule_number: {
+    AST::UiObjectInitializer *node = makeAstNode<AST::UiObjectInitializer> (driver->nodePool(), sym(2).UiObjectMemberList->finish());
+    node->lbraceToken = loc(1);
+    node->rbraceToken = loc(3);
+    sym(1).Node = node;
+}   break;
+./
+
+UiObjectDefinition: UiQualifiedId UiObjectInitializer ;
+/.
+case $rule_number: {
+    AST::UiObjectDefinition *node = makeAstNode<AST::UiObjectDefinition> (driver->nodePool(), sym(1).UiQualifiedId,
+        sym(2).UiObjectInitializer);
+    sym(1).Node = node;
+}   break;
+./
+
+UiObjectMember: UiObjectDefinition ;
+
+UiObjectMember: UiQualifiedId T_COLON T_LBRACKET UiArrayMemberList T_RBRACKET ;
+/.
+case $rule_number: {
+    AST::UiArrayBinding *node = makeAstNode<AST::UiArrayBinding> (driver->nodePool(),
+        sym(1).UiQualifiedId, sym(4).UiArrayMemberList->finish());
+    node->colonToken = loc(2);
+    node->lbracketToken = loc(3);
+    node->rbracketToken = loc(5);
+    sym(1).Node = node;
+}   break;
+./
+
+UiObjectMember: UiQualifiedId             T_COLON UiQualifiedId  UiObjectInitializer ;
+/.
+case $rule_number: {
+    AST::UiObjectBinding *node = makeAstNode<AST::UiObjectBinding> (driver->nodePool(),
+      sym(1).UiQualifiedId, sym(3).UiQualifiedId, sym(4).UiObjectInitializer);
+    node->colonToken = loc(2);
+    sym(1).Node = node;
+} break;
+./
+
+UiObjectMember: UiQualifiedId             T_ON UiQualifiedId  UiObjectInitializer ;
+/.
+case $rule_number: {
+    AST::UiObjectBinding *node = makeAstNode<AST::UiObjectBinding> (driver->nodePool(),
+      sym(3).UiQualifiedId, sym(1).UiQualifiedId, sym(4).UiObjectInitializer);
+    node->colonToken = loc(2);
+    node->hasOnToken = true;
+    sym(1).Node = node;
+} break;
+./
+
+UiObjectMember: UiQualifiedId T_COLON Block ;
+/.case $rule_number:./
+
+UiObjectMember: UiQualifiedId T_COLON EmptyStatement ;
+/.case $rule_number:./
+
+UiObjectMember: UiQualifiedId T_COLON ExpressionStatement ;
+/.case $rule_number:./
+
+UiObjectMember: UiQualifiedId T_COLON IfStatement ; --- ### do we really want if statement in a binding?
+/.case $rule_number:./
+
+/.
+{
+    AST::UiScriptBinding *node = makeAstNode<AST::UiScriptBinding> (driver->nodePool(),
+        sym(1).UiQualifiedId, sym(3).Statement);
+    node->colonToken = loc(2);
+    sym(1).Node = node;
+}   break;
+./
+
+UiPropertyType: T_VAR ;
+/.
+case $rule_number:
+./
+UiPropertyType: T_RESERVED_WORD ;
+/.
+case $rule_number: {
+    sym(1).sval = driver->intern(lexer->characterBuffer(), lexer->characterCount());
+    break;
+}
+./
+
+UiPropertyType: T_IDENTIFIER ;
+
+UiParameterListOpt: ;
+/.
+case $rule_number: {
+  sym(1).Node = 0;
+} break;
+./
+
+UiParameterListOpt: UiParameterList ;
+/.
+case $rule_number: {
+  sym(1).Node = sym(1).UiParameterList->finish ();
+} break;
+./
+
+UiParameterList: UiPropertyType JsIdentifier ;
+/.
+case $rule_number: {
+  AST::UiParameterList *node = makeAstNode<AST::UiParameterList> (driver->nodePool(), sym(1).sval, sym(2).sval);
+  node->identifierToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+UiParameterList: UiParameterList T_COMMA UiPropertyType JsIdentifier ;
+/.
+case $rule_number: {
+  AST::UiParameterList *node = makeAstNode<AST::UiParameterList> (driver->nodePool(), sym(1).UiParameterList, sym(3).sval, sym(4).sval);
+  node->commaToken = loc(2);
+  node->identifierToken = loc(4);
+  sym(1).Node = node;
+} break;
+./
+
+UiObjectMember: T_SIGNAL T_IDENTIFIER T_LPAREN UiParameterListOpt T_RPAREN T_AUTOMATIC_SEMICOLON ;
+UiObjectMember: T_SIGNAL T_IDENTIFIER T_LPAREN UiParameterListOpt T_RPAREN T_SEMICOLON ;
+/.
+case $rule_number: {
+    AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), (NameId *)0, sym(2).sval);
+    node->type = AST::UiPublicMember::Signal;
+    node->propertyToken = loc(1);
+    node->typeToken = loc(2);
+    node->identifierToken = loc(2);
+    node->parameters = sym(4).UiParameterList;
+    node->semicolonToken = loc(6);
+    sym(1).Node = node;
+}   break;
+./
+
+UiObjectMember: T_SIGNAL T_IDENTIFIER T_AUTOMATIC_SEMICOLON ;
+UiObjectMember: T_SIGNAL T_IDENTIFIER T_SEMICOLON ;
+/.
+case $rule_number: {
+    AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), (NameId *)0, sym(2).sval);
+    node->type = AST::UiPublicMember::Signal;
+    node->propertyToken = loc(1);
+    node->typeToken = loc(2);
+    node->identifierToken = loc(2);
+    node->semicolonToken = loc(3);
+    sym(1).Node = node;
+}   break;
+./
+
+UiObjectMember: T_PROPERTY T_IDENTIFIER T_LT UiPropertyType T_GT JsIdentifier T_AUTOMATIC_SEMICOLON ;
+UiObjectMember: T_PROPERTY T_IDENTIFIER T_LT UiPropertyType T_GT JsIdentifier T_SEMICOLON ;
+/.
+case $rule_number: {
+    AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(4).sval, sym(6).sval);
+    node->typeModifier = sym(2).sval;
+    node->propertyToken = loc(1);
+    node->typeModifierToken = loc(2);
+    node->typeToken = loc(4);
+    node->identifierToken = loc(6);
+    node->semicolonToken = loc(7);
+    sym(1).Node = node;
+}   break;
+./
+
+UiObjectMember: T_PROPERTY UiPropertyType JsIdentifier T_AUTOMATIC_SEMICOLON ;
+UiObjectMember: T_PROPERTY UiPropertyType JsIdentifier T_SEMICOLON ;
+/.
+case $rule_number: {
+    AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(2).sval, sym(3).sval);
+    node->propertyToken = loc(1);
+    node->typeToken = loc(2);
+    node->identifierToken = loc(3);
+    node->semicolonToken = loc(4);
+    sym(1).Node = node;
+}   break;
+./
+
+UiObjectMember: T_DEFAULT T_PROPERTY UiPropertyType JsIdentifier T_AUTOMATIC_SEMICOLON ;
+UiObjectMember: T_DEFAULT T_PROPERTY UiPropertyType JsIdentifier T_SEMICOLON ;
+/.
+case $rule_number: {
+    AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(3).sval, sym(4).sval);
+    node->isDefaultMember = true;
+    node->defaultToken = loc(1);
+    node->propertyToken = loc(2);
+    node->typeToken = loc(3);
+    node->identifierToken = loc(4);
+    node->semicolonToken = loc(5);
+    sym(1).Node = node;
+}   break;
+./
+
+UiObjectMember: T_PROPERTY UiPropertyType JsIdentifier T_COLON Expression T_AUTOMATIC_SEMICOLON ;
+UiObjectMember: T_PROPERTY UiPropertyType JsIdentifier T_COLON Expression T_SEMICOLON ;
+/.
+case $rule_number: {
+    AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(2).sval, sym(3).sval,
+        sym(5).Expression);
+    node->propertyToken = loc(1);
+    node->typeToken = loc(2);
+    node->identifierToken = loc(3);
+    node->colonToken = loc(4);
+    node->semicolonToken = loc(6);
+    sym(1).Node = node;
+}   break;
+./
+
+UiObjectMember: T_READONLY T_PROPERTY UiPropertyType JsIdentifier T_COLON Expression T_AUTOMATIC_SEMICOLON ;
+UiObjectMember: T_READONLY T_PROPERTY UiPropertyType JsIdentifier T_COLON Expression T_SEMICOLON ;
+/.
+case $rule_number: {
+    AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(3).sval, sym(4).sval,
+        sym(6).Expression);
+    node->isReadonlyMember = true;
+    node->readonlyToken = loc(1);
+    node->propertyToken = loc(2);
+    node->typeToken = loc(3);
+    node->identifierToken = loc(4);
+    node->colonToken = loc(5);
+    node->semicolonToken = loc(7);
+    sym(1).Node = node;
+}   break;
+./
+
+UiObjectMember: T_DEFAULT T_PROPERTY UiPropertyType JsIdentifier T_COLON Expression T_AUTOMATIC_SEMICOLON ;
+UiObjectMember: T_DEFAULT T_PROPERTY UiPropertyType JsIdentifier T_COLON Expression T_SEMICOLON ;
+/.
+case $rule_number: {
+    AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(3).sval, sym(4).sval,
+        sym(6).Expression);
+    node->isDefaultMember = true;
+    node->defaultToken = loc(1);
+    node->propertyToken = loc(2);
+    node->typeToken = loc(3);
+    node->identifierToken = loc(4);
+    node->colonToken = loc(5);
+    node->semicolonToken = loc(7);
+    sym(1).Node = node;
+}   break;
+./
+
+UiObjectMember: T_PROPERTY T_IDENTIFIER T_LT UiPropertyType T_GT JsIdentifier T_COLON T_LBRACKET UiArrayMemberList T_RBRACKET ;
+/.
+case $rule_number: {
+    AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(4).sval, sym(6).sval);
+    node->typeModifier = sym(2).sval;
+    node->propertyToken = loc(1);
+    node->typeModifierToken = loc(2);
+    node->typeToken = loc(4);
+    node->identifierToken = loc(6);
+    node->semicolonToken = loc(7); // insert a fake ';' before ':'
+
+    AST::UiQualifiedId *propertyName = makeAstNode<AST::UiQualifiedId>(driver->nodePool(), sym(6).sval);
+    propertyName->identifierToken = loc(6);
+    propertyName->next = 0;
+
+    AST::UiArrayBinding *binding = makeAstNode<AST::UiArrayBinding> (driver->nodePool(),
+        propertyName, sym(9).UiArrayMemberList->finish());
+    binding->colonToken = loc(7);
+    binding->lbracketToken = loc(8);
+    binding->rbracketToken = loc(10);
+
+    node->binding = binding;
+
+    sym(1).Node = node;
+}   break;
+./
+
+UiObjectMember: T_PROPERTY UiPropertyType JsIdentifier T_COLON UiQualifiedId UiObjectInitializer ;
+/.
+case $rule_number: {
+    AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(2).sval, sym(3).sval);
+    node->propertyToken = loc(1);
+    node->typeToken = loc(2);
+    node->identifierToken = loc(3);
+    node->semicolonToken = loc(4); // insert a fake ';' before ':'
+
+    AST::UiQualifiedId *propertyName = makeAstNode<AST::UiQualifiedId>(driver->nodePool(), sym(3).sval);
+    propertyName->identifierToken = loc(3);
+    propertyName->next = 0;
+
+    AST::UiObjectBinding *binding = makeAstNode<AST::UiObjectBinding> (driver->nodePool(),
+      propertyName, sym(5).UiQualifiedId, sym(6).UiObjectInitializer);
+    binding->colonToken = loc(4);
+
+    node->binding = binding;
+
+    sym(1).Node = node;
+}   break;
+./
+
+UiObjectMember: FunctionDeclaration ;
+/.
+case $rule_number: {
+    sym(1).Node = makeAstNode<AST::UiSourceElement>(driver->nodePool(), sym(1).Node);
+}   break;
+./
+
+UiObjectMember: VariableStatement ;
+/.
+case $rule_number: {
+    sym(1).Node = makeAstNode<AST::UiSourceElement>(driver->nodePool(), sym(1).Node);
+}   break;
+./
+
+JsIdentifier: T_IDENTIFIER;
+
+JsIdentifier: T_PROPERTY ;
+/.
+case $rule_number: {
+    QString s = QLatin1String(QDeclarativeJSGrammar::spell[T_PROPERTY]);
+    sym(1).sval = driver->intern(s.constData(), s.length());
+    break;
+}
+./
+
+JsIdentifier: T_SIGNAL ;
+/.
+case $rule_number: {
+    QString s = QLatin1String(QDeclarativeJSGrammar::spell[T_SIGNAL]);
+    sym(1).sval = driver->intern(s.constData(), s.length());
+    break;
+}
+./
+
+JsIdentifier: T_READONLY ;
+/.
+case $rule_number: {
+    QString s = QLatin1String(QDeclarativeJSGrammar::spell[T_READONLY]);
+    sym(1).sval = driver->intern(s.constData(), s.length());
+    break;
+}
+./
+
+JsIdentifier: T_ON ;
+/.
+case $rule_number: {
+    QString s = QLatin1String(QDeclarativeJSGrammar::spell[T_ON]);
+    sym(1).sval = driver->intern(s.constData(), s.length());
+    break;
+}
+./
+
+--------------------------------------------------------------------------------------------------------
+-- Expressions
+--------------------------------------------------------------------------------------------------------
+
+PrimaryExpression: T_THIS ;
+/.
+case $rule_number: {
+  AST::ThisExpression *node = makeAstNode<AST::ThisExpression> (driver->nodePool());
+  node->thisToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+PrimaryExpression: JsIdentifier ;
+/.
+case $rule_number: {
+  AST::IdentifierExpression *node = makeAstNode<AST::IdentifierExpression> (driver->nodePool(), sym(1).sval);
+  node->identifierToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+PrimaryExpression: T_NULL ;
+/.
+case $rule_number: {
+  AST::NullExpression *node = makeAstNode<AST::NullExpression> (driver->nodePool());
+  node->nullToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+PrimaryExpression: T_TRUE ;
+/.
+case $rule_number: {
+  AST::TrueLiteral *node = makeAstNode<AST::TrueLiteral> (driver->nodePool());
+  node->trueToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+PrimaryExpression: T_FALSE ;
+/.
+case $rule_number: {
+  AST::FalseLiteral *node = makeAstNode<AST::FalseLiteral> (driver->nodePool());
+  node->falseToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+PrimaryExpression: T_NUMERIC_LITERAL ;
+/.
+case $rule_number: {
+  AST::NumericLiteral *node = makeAstNode<AST::NumericLiteral> (driver->nodePool(), sym(1).dval);
+  node->literalToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+PrimaryExpression: T_MULTILINE_STRING_LITERAL ;
+/.case $rule_number:./
+
+PrimaryExpression: T_STRING_LITERAL ;
+/.
+case $rule_number: {
+  AST::StringLiteral *node = makeAstNode<AST::StringLiteral> (driver->nodePool(), sym(1).sval);
+  node->literalToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+PrimaryExpression: T_DIVIDE_ ;
+/:
+#define J_SCRIPT_REGEXPLITERAL_RULE1 $rule_number
+:/
+/.
+case $rule_number: {
+  bool rx = lexer->scanRegExp(Lexer::NoPrefix);
+  if (!rx) {
+    diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, location(lexer), lexer->errorMessage()));
+    return false; // ### remove me
+  }
+
+  loc(1).length = lexer->tokenLength();
+
+  AST::RegExpLiteral *node = makeAstNode<AST::RegExpLiteral> (driver->nodePool(), lexer->pattern, lexer->flags);
+  node->literalToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+PrimaryExpression: T_DIVIDE_EQ ;
+/:
+#define J_SCRIPT_REGEXPLITERAL_RULE2 $rule_number
+:/
+/.
+case $rule_number: {
+  bool rx = lexer->scanRegExp(Lexer::EqualPrefix);
+  if (!rx) {
+    diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, location(lexer), lexer->errorMessage()));
+    return false;
+  }
+
+  loc(1).length = lexer->tokenLength();
+
+  AST::RegExpLiteral *node = makeAstNode<AST::RegExpLiteral> (driver->nodePool(), lexer->pattern, lexer->flags);
+  node->literalToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+PrimaryExpression: T_LBRACKET T_RBRACKET ;
+/.
+case $rule_number: {
+  AST::ArrayLiteral *node = makeAstNode<AST::ArrayLiteral> (driver->nodePool(), (AST::Elision *) 0);
+  node->lbracketToken = loc(1);
+  node->rbracketToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+PrimaryExpression: T_LBRACKET Elision T_RBRACKET ;
+/.
+case $rule_number: {
+  AST::ArrayLiteral *node = makeAstNode<AST::ArrayLiteral> (driver->nodePool(), sym(2).Elision->finish());
+  node->lbracketToken = loc(1);
+  node->rbracketToken = loc(3);
+  sym(1).Node = node;
+} break;
+./
+
+PrimaryExpression: T_LBRACKET ElementList T_RBRACKET ;
+/.
+case $rule_number: {
+  AST::ArrayLiteral *node = makeAstNode<AST::ArrayLiteral> (driver->nodePool(), sym(2).ElementList->finish ());
+  node->lbracketToken = loc(1);
+  node->rbracketToken = loc(3);
+  sym(1).Node = node;
+} break;
+./
+
+PrimaryExpression: T_LBRACKET ElementList T_COMMA T_RBRACKET ;
+/.
+case $rule_number: {
+  AST::ArrayLiteral *node = makeAstNode<AST::ArrayLiteral> (driver->nodePool(), sym(2).ElementList->finish (),
+    (AST::Elision *) 0);
+  node->lbracketToken = loc(1);
+  node->commaToken = loc(3);
+  node->rbracketToken = loc(4);
+  sym(1).Node = node;
+} break;
+./
+
+PrimaryExpression: T_LBRACKET ElementList T_COMMA Elision T_RBRACKET ;
+/.
+case $rule_number: {
+  AST::ArrayLiteral *node = makeAstNode<AST::ArrayLiteral> (driver->nodePool(), sym(2).ElementList->finish (),
+    sym(4).Elision->finish());
+  node->lbracketToken = loc(1);
+  node->commaToken = loc(3);
+  node->rbracketToken = loc(5);
+  sym(1).Node = node;
+} break;
+./
+
+-- PrimaryExpression: T_LBRACE T_RBRACE ;
+-- /.
+-- case $rule_number: {
+--   sym(1).Node = makeAstNode<AST::ObjectLiteral> (driver->nodePool());
+-- } break;
+-- ./
+
+PrimaryExpression: T_LBRACE PropertyNameAndValueListOpt T_RBRACE ;
+/.
+case $rule_number: {
+  AST::ObjectLiteral *node = 0;
+  if (sym(2).Node)
+    node = makeAstNode<AST::ObjectLiteral> (driver->nodePool(),
+        sym(2).PropertyNameAndValueList->finish ());
+  else
+    node = makeAstNode<AST::ObjectLiteral> (driver->nodePool());
+  node->lbraceToken = loc(1);
+  node->rbraceToken = loc(3);
+  sym(1).Node = node;
+} break;
+./
+
+PrimaryExpression: T_LBRACE PropertyNameAndValueList T_COMMA T_RBRACE ;
+/.
+case $rule_number: {
+  AST::ObjectLiteral *node = makeAstNode<AST::ObjectLiteral> (driver->nodePool(),
+    sym(2).PropertyNameAndValueList->finish ());
+  node->lbraceToken = loc(1);
+  node->rbraceToken = loc(4);
+  sym(1).Node = node;
+} break;
+./
+
+PrimaryExpression: T_LPAREN Expression T_RPAREN ;
+/.
+case $rule_number: {
+  AST::NestedExpression *node = makeAstNode<AST::NestedExpression>(driver->nodePool(), sym(2).Expression);
+  node->lparenToken = loc(1);
+  node->rparenToken = loc(3);
+  sym(1).Node = node;
+} break;
+./
+
+UiQualifiedId: MemberExpression ;
+/.
+case $rule_number: {
+  if (AST::ArrayMemberExpression *mem = AST::cast<AST::ArrayMemberExpression *>(sym(1).Expression)) {
+    diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Warning, mem->lbracketToken,
+      QLatin1String("Ignored annotation")));
+
+    sym(1).Expression = mem->base;
+  }
+
+  if (AST::UiQualifiedId *qualifiedId = reparseAsQualifiedId(sym(1).Expression)) {
+    sym(1).UiQualifiedId = qualifiedId;
+  } else {
+    sym(1).UiQualifiedId = 0;
+
+    diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, loc(1),
+      QLatin1String("Expected a qualified name id")));
+
+    return false; // ### recover
+  }
+} break;
+./
+
+ElementList: AssignmentExpression ;
+/.
+case $rule_number: {
+  sym(1).Node = makeAstNode<AST::ElementList> (driver->nodePool(), (AST::Elision *) 0, sym(1).Expression);
+} break;
+./
+
+ElementList: Elision AssignmentExpression ;
+/.
+case $rule_number: {
+  sym(1).Node = makeAstNode<AST::ElementList> (driver->nodePool(), sym(1).Elision->finish(), sym(2).Expression);
+} break;
+./
+
+ElementList: ElementList T_COMMA AssignmentExpression ;
+/.
+case $rule_number: {
+  AST::ElementList *node = makeAstNode<AST::ElementList> (driver->nodePool(), sym(1).ElementList,
+    (AST::Elision *) 0, sym(3).Expression);
+  node->commaToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+ElementList: ElementList T_COMMA Elision AssignmentExpression ;
+/.
+case $rule_number: {
+  AST::ElementList *node = makeAstNode<AST::ElementList> (driver->nodePool(), sym(1).ElementList, sym(3).Elision->finish(),
+    sym(4).Expression);
+  node->commaToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+Elision: T_COMMA ;
+/.
+case $rule_number: {
+  AST::Elision *node = makeAstNode<AST::Elision> (driver->nodePool());
+  node->commaToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+Elision: Elision T_COMMA ;
+/.
+case $rule_number: {
+  AST::Elision *node = makeAstNode<AST::Elision> (driver->nodePool(), sym(1).Elision);
+  node->commaToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+PropertyNameAndValueList: PropertyName T_COLON AssignmentExpression ;
+/.
+case $rule_number: {
+  AST::PropertyNameAndValueList *node = makeAstNode<AST::PropertyNameAndValueList> (driver->nodePool(),
+      sym(1).PropertyName, sym(3).Expression);
+  node->colonToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+PropertyNameAndValueList: PropertyNameAndValueList T_COMMA PropertyName T_COLON AssignmentExpression ;
+/.
+case $rule_number: {
+  AST::PropertyNameAndValueList *node = makeAstNode<AST::PropertyNameAndValueList> (driver->nodePool(),
+      sym(1).PropertyNameAndValueList, sym(3).PropertyName, sym(5).Expression);
+  node->commaToken = loc(2);
+  node->colonToken = loc(4);
+  sym(1).Node = node;
+} break;
+./
+
+PropertyName: T_IDENTIFIER %prec SHIFT_THERE ;
+/.
+case $rule_number: {
+  AST::IdentifierPropertyName *node = makeAstNode<AST::IdentifierPropertyName> (driver->nodePool(), sym(1).sval);
+  node->propertyNameToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+PropertyName: T_SIGNAL ;
+/.case $rule_number:./
+
+PropertyName: T_PROPERTY ;
+/.
+case $rule_number: {
+  AST::IdentifierPropertyName *node = makeAstNode<AST::IdentifierPropertyName> (driver->nodePool(), driver->intern(lexer->characterBuffer(), lexer->characterCount()));
+  node->propertyNameToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+PropertyName: T_STRING_LITERAL ;
+/.
+case $rule_number: {
+  AST::StringLiteralPropertyName *node = makeAstNode<AST::StringLiteralPropertyName> (driver->nodePool(), sym(1).sval);
+  node->propertyNameToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+PropertyName: T_NUMERIC_LITERAL ;
+/.
+case $rule_number: {
+  AST::NumericLiteralPropertyName *node = makeAstNode<AST::NumericLiteralPropertyName> (driver->nodePool(), sym(1).dval);
+  node->propertyNameToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+PropertyName: ReservedIdentifier ;
+/.
+case $rule_number: {
+  AST::IdentifierPropertyName *node = makeAstNode<AST::IdentifierPropertyName> (driver->nodePool(), sym(1).sval);
+  node->propertyNameToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+ReservedIdentifier: T_BREAK ;
+/.
+case $rule_number:
+./
+ReservedIdentifier: T_CASE ;
+/.
+case $rule_number:
+./
+ReservedIdentifier: T_CATCH ;
+/.
+case $rule_number:
+./
+ReservedIdentifier: T_CONTINUE ;
+/.
+case $rule_number:
+./
+ReservedIdentifier: T_DEFAULT ;
+/.
+case $rule_number:
+./
+ReservedIdentifier: T_DELETE ;
+/.
+case $rule_number:
+./
+ReservedIdentifier: T_DO ;
+/.
+case $rule_number:
+./
+ReservedIdentifier: T_ELSE ;
+/.
+case $rule_number:
+./
+ReservedIdentifier: T_FALSE ;
+/.
+case $rule_number:
+./
+ReservedIdentifier: T_FINALLY ;
+/.
+case $rule_number:
+./
+ReservedIdentifier: T_FOR ;
+/.
+case $rule_number:
+./
+ReservedIdentifier: T_FUNCTION ;
+/.
+case $rule_number:
+./
+ReservedIdentifier: T_IF ;
+/.
+case $rule_number:
+./
+ReservedIdentifier: T_IN ;
+/.
+case $rule_number:
+./
+ReservedIdentifier: T_INSTANCEOF ;
+/.
+case $rule_number:
+./
+ReservedIdentifier: T_NEW ;
+/.
+case $rule_number:
+./
+ReservedIdentifier: T_NULL ;
+/.
+case $rule_number:
+./
+ReservedIdentifier: T_RETURN ;
+/.
+case $rule_number:
+./
+ReservedIdentifier: T_SWITCH ;
+/.
+case $rule_number:
+./
+ReservedIdentifier: T_THIS ;
+/.
+case $rule_number:
+./
+ReservedIdentifier: T_THROW ;
+/.
+case $rule_number:
+./
+ReservedIdentifier: T_TRUE ;
+/.
+case $rule_number:
+./
+ReservedIdentifier: T_TRY ;
+/.
+case $rule_number:
+./
+ReservedIdentifier: T_TYPEOF ;
+/.
+case $rule_number:
+./
+ReservedIdentifier: T_VAR ;
+/.
+case $rule_number:
+./
+ReservedIdentifier: T_VOID ;
+/.
+case $rule_number:
+./
+ReservedIdentifier: T_WHILE ;
+/.
+case $rule_number:
+./
+ReservedIdentifier: T_CONST ;
+/.
+case $rule_number:
+./
+ReservedIdentifier: T_DEBUGGER ;
+/.
+case $rule_number:
+./
+ReservedIdentifier: T_RESERVED_WORD ;
+/.
+case $rule_number:
+./
+ReservedIdentifier: T_WITH ;
+/.
+case $rule_number:
+{
+  sym(1).sval = driver->intern(lexer->characterBuffer(), lexer->characterCount());
+} break;
+./
+
+PropertyIdentifier: JsIdentifier ;
+PropertyIdentifier: ReservedIdentifier ;
+
+MemberExpression: PrimaryExpression ;
+MemberExpression: FunctionExpression ;
+
+MemberExpression: MemberExpression T_LBRACKET Expression T_RBRACKET ;
+/.
+case $rule_number: {
+  AST::ArrayMemberExpression *node = makeAstNode<AST::ArrayMemberExpression> (driver->nodePool(), sym(1).Expression, sym(3).Expression);
+  node->lbracketToken = loc(2);
+  node->rbracketToken = loc(4);
+  sym(1).Node = node;
+} break;
+./
+
+MemberExpression: MemberExpression T_DOT PropertyIdentifier ;
+/.
+case $rule_number: {
+  AST::FieldMemberExpression *node = makeAstNode<AST::FieldMemberExpression> (driver->nodePool(), sym(1).Expression, sym(3).sval);
+  node->dotToken = loc(2);
+  node->identifierToken = loc(3);
+  sym(1).Node = node;
+} break;
+./
+
+MemberExpression: T_NEW MemberExpression T_LPAREN ArgumentListOpt T_RPAREN ;
+/.
+case $rule_number: {
+  AST::NewMemberExpression *node = makeAstNode<AST::NewMemberExpression> (driver->nodePool(), sym(2).Expression, sym(4).ArgumentList);
+  node->newToken = loc(1);
+  node->lparenToken = loc(3);
+  node->rparenToken = loc(5);
+  sym(1).Node = node;
+} break;
+./
+
+NewExpression: MemberExpression ;
+
+NewExpression: T_NEW NewExpression ;
+/.
+case $rule_number: {
+  AST::NewExpression *node = makeAstNode<AST::NewExpression> (driver->nodePool(), sym(2).Expression);
+  node->newToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+CallExpression: MemberExpression T_LPAREN ArgumentListOpt T_RPAREN ;
+/.
+case $rule_number: {
+  AST::CallExpression *node = makeAstNode<AST::CallExpression> (driver->nodePool(), sym(1).Expression, sym(3).ArgumentList);
+  node->lparenToken = loc(2);
+  node->rparenToken = loc(4);
+  sym(1).Node = node;
+} break;
+./
+
+CallExpression: CallExpression T_LPAREN ArgumentListOpt T_RPAREN ;
+/.
+case $rule_number: {
+  AST::CallExpression *node = makeAstNode<AST::CallExpression> (driver->nodePool(), sym(1).Expression, sym(3).ArgumentList);
+  node->lparenToken = loc(2);
+  node->rparenToken = loc(4);
+  sym(1).Node = node;
+} break;
+./
+
+CallExpression: CallExpression T_LBRACKET Expression T_RBRACKET ;
+/.
+case $rule_number: {
+  AST::ArrayMemberExpression *node = makeAstNode<AST::ArrayMemberExpression> (driver->nodePool(), sym(1).Expression, sym(3).Expression);
+  node->lbracketToken = loc(2);
+  node->rbracketToken = loc(4);
+  sym(1).Node = node;
+} break;
+./
+
+CallExpression: CallExpression T_DOT PropertyIdentifier ;
+/.
+case $rule_number: {
+  AST::FieldMemberExpression *node = makeAstNode<AST::FieldMemberExpression> (driver->nodePool(), sym(1).Expression, sym(3).sval);
+  node->dotToken = loc(2);
+  node->identifierToken = loc(3);
+  sym(1).Node = node;
+} break;
+./
+
+ArgumentListOpt: ;
+/.
+case $rule_number: {
+  sym(1).Node = 0;
+} break;
+./
+
+ArgumentListOpt: ArgumentList ;
+/.
+case $rule_number: {
+  sym(1).Node = sym(1).ArgumentList->finish();
+} break;
+./
+
+ArgumentList: AssignmentExpression ;
+/.
+case $rule_number: {
+  sym(1).Node = makeAstNode<AST::ArgumentList> (driver->nodePool(), sym(1).Expression);
+} break;
+./
+
+ArgumentList: ArgumentList T_COMMA AssignmentExpression ;
+/.
+case $rule_number: {
+  AST::ArgumentList *node = makeAstNode<AST::ArgumentList> (driver->nodePool(), sym(1).ArgumentList, sym(3).Expression);
+  node->commaToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+LeftHandSideExpression: NewExpression ;
+LeftHandSideExpression: CallExpression ;
+PostfixExpression: LeftHandSideExpression ;
+
+PostfixExpression: LeftHandSideExpression T_PLUS_PLUS ;
+/.
+case $rule_number: {
+  AST::PostIncrementExpression *node = makeAstNode<AST::PostIncrementExpression> (driver->nodePool(), sym(1).Expression);
+  node->incrementToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+PostfixExpression: LeftHandSideExpression T_MINUS_MINUS ;
+/.
+case $rule_number: {
+  AST::PostDecrementExpression *node = makeAstNode<AST::PostDecrementExpression> (driver->nodePool(), sym(1).Expression);
+  node->decrementToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+UnaryExpression: PostfixExpression ;
+
+UnaryExpression: T_DELETE UnaryExpression ;
+/.
+case $rule_number: {
+  AST::DeleteExpression *node = makeAstNode<AST::DeleteExpression> (driver->nodePool(), sym(2).Expression);
+  node->deleteToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+UnaryExpression: T_VOID UnaryExpression ;
+/.
+case $rule_number: {
+  AST::VoidExpression *node = makeAstNode<AST::VoidExpression> (driver->nodePool(), sym(2).Expression);
+  node->voidToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+UnaryExpression: T_TYPEOF UnaryExpression ;
+/.
+case $rule_number: {
+  AST::TypeOfExpression *node = makeAstNode<AST::TypeOfExpression> (driver->nodePool(), sym(2).Expression);
+  node->typeofToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+UnaryExpression: T_PLUS_PLUS UnaryExpression ;
+/.
+case $rule_number: {
+  AST::PreIncrementExpression *node = makeAstNode<AST::PreIncrementExpression> (driver->nodePool(), sym(2).Expression);
+  node->incrementToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+UnaryExpression: T_MINUS_MINUS UnaryExpression ;
+/.
+case $rule_number: {
+  AST::PreDecrementExpression *node = makeAstNode<AST::PreDecrementExpression> (driver->nodePool(), sym(2).Expression);
+  node->decrementToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+UnaryExpression: T_PLUS UnaryExpression ;
+/.
+case $rule_number: {
+  AST::UnaryPlusExpression *node = makeAstNode<AST::UnaryPlusExpression> (driver->nodePool(), sym(2).Expression);
+  node->plusToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+UnaryExpression: T_MINUS UnaryExpression ;
+/.
+case $rule_number: {
+  AST::UnaryMinusExpression *node = makeAstNode<AST::UnaryMinusExpression> (driver->nodePool(), sym(2).Expression);
+  node->minusToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+UnaryExpression: T_TILDE UnaryExpression ;
+/.
+case $rule_number: {
+  AST::TildeExpression *node = makeAstNode<AST::TildeExpression> (driver->nodePool(), sym(2).Expression);
+  node->tildeToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+UnaryExpression: T_NOT UnaryExpression ;
+/.
+case $rule_number: {
+  AST::NotExpression *node = makeAstNode<AST::NotExpression> (driver->nodePool(), sym(2).Expression);
+  node->notToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+MultiplicativeExpression: UnaryExpression ;
+
+MultiplicativeExpression: MultiplicativeExpression T_STAR UnaryExpression ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Mul, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+MultiplicativeExpression: MultiplicativeExpression T_DIVIDE_ UnaryExpression ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Div, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+MultiplicativeExpression: MultiplicativeExpression T_REMAINDER UnaryExpression ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Mod, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+AdditiveExpression: MultiplicativeExpression ;
+
+AdditiveExpression: AdditiveExpression T_PLUS MultiplicativeExpression ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Add, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+AdditiveExpression: AdditiveExpression T_MINUS MultiplicativeExpression ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Sub, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+ShiftExpression: AdditiveExpression ;
+
+ShiftExpression: ShiftExpression T_LT_LT AdditiveExpression ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::LShift, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+ShiftExpression: ShiftExpression T_GT_GT AdditiveExpression ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::RShift, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+ShiftExpression: ShiftExpression T_GT_GT_GT AdditiveExpression ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::URShift, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+RelationalExpression: ShiftExpression ;
+
+RelationalExpression: RelationalExpression T_LT ShiftExpression ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Lt, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+RelationalExpression: RelationalExpression T_GT ShiftExpression ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Gt, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+RelationalExpression: RelationalExpression T_LE ShiftExpression ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Le, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+RelationalExpression: RelationalExpression T_GE ShiftExpression ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Ge, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+RelationalExpression: RelationalExpression T_INSTANCEOF ShiftExpression ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::InstanceOf, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+RelationalExpression: RelationalExpression T_IN ShiftExpression ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::In, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+RelationalExpressionNotIn: ShiftExpression ;
+
+RelationalExpressionNotIn: RelationalExpressionNotIn T_LT ShiftExpression ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Lt, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+RelationalExpressionNotIn: RelationalExpressionNotIn T_GT ShiftExpression ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Gt, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+RelationalExpressionNotIn: RelationalExpressionNotIn T_LE ShiftExpression ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Le, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+RelationalExpressionNotIn: RelationalExpressionNotIn T_GE ShiftExpression ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+   QSOperator::Ge, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+RelationalExpressionNotIn: RelationalExpressionNotIn T_INSTANCEOF ShiftExpression ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::InstanceOf, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+EqualityExpression: RelationalExpression ;
+
+EqualityExpression: EqualityExpression T_EQ_EQ RelationalExpression ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Equal, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+EqualityExpression: EqualityExpression T_NOT_EQ RelationalExpression ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::NotEqual, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+EqualityExpression: EqualityExpression T_EQ_EQ_EQ RelationalExpression ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::StrictEqual, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+EqualityExpression: EqualityExpression T_NOT_EQ_EQ RelationalExpression ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::StrictNotEqual, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+EqualityExpressionNotIn: RelationalExpressionNotIn ;
+
+EqualityExpressionNotIn: EqualityExpressionNotIn T_EQ_EQ RelationalExpressionNotIn ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Equal, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+EqualityExpressionNotIn: EqualityExpressionNotIn T_NOT_EQ RelationalExpressionNotIn;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::NotEqual, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+EqualityExpressionNotIn: EqualityExpressionNotIn T_EQ_EQ_EQ RelationalExpressionNotIn ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::StrictEqual, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+EqualityExpressionNotIn: EqualityExpressionNotIn T_NOT_EQ_EQ RelationalExpressionNotIn ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::StrictNotEqual, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+BitwiseANDExpression: EqualityExpression ;
+
+BitwiseANDExpression: BitwiseANDExpression T_AND EqualityExpression ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::BitAnd, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+BitwiseANDExpressionNotIn: EqualityExpressionNotIn ;
+
+BitwiseANDExpressionNotIn: BitwiseANDExpressionNotIn T_AND EqualityExpressionNotIn ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::BitAnd, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+BitwiseXORExpression: BitwiseANDExpression ;
+
+BitwiseXORExpression: BitwiseXORExpression T_XOR BitwiseANDExpression ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::BitXor, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+BitwiseXORExpressionNotIn: BitwiseANDExpressionNotIn ;
+
+BitwiseXORExpressionNotIn: BitwiseXORExpressionNotIn T_XOR BitwiseANDExpressionNotIn ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::BitXor, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+BitwiseORExpression: BitwiseXORExpression ;
+
+BitwiseORExpression: BitwiseORExpression T_OR BitwiseXORExpression ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::BitOr, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+BitwiseORExpressionNotIn: BitwiseXORExpressionNotIn ;
+
+BitwiseORExpressionNotIn: BitwiseORExpressionNotIn T_OR BitwiseXORExpressionNotIn ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::BitOr, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+LogicalANDExpression: BitwiseORExpression ;
+
+LogicalANDExpression: LogicalANDExpression T_AND_AND BitwiseORExpression ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::And, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+LogicalANDExpressionNotIn: BitwiseORExpressionNotIn ;
+
+LogicalANDExpressionNotIn: LogicalANDExpressionNotIn T_AND_AND BitwiseORExpressionNotIn ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::And, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+LogicalORExpression: LogicalANDExpression ;
+
+LogicalORExpression: LogicalORExpression T_OR_OR LogicalANDExpression ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Or, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+LogicalORExpressionNotIn: LogicalANDExpressionNotIn ;
+
+LogicalORExpressionNotIn: LogicalORExpressionNotIn T_OR_OR LogicalANDExpressionNotIn ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Or, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+ConditionalExpression: LogicalORExpression ;
+
+ConditionalExpression: LogicalORExpression T_QUESTION AssignmentExpression T_COLON AssignmentExpression ;
+/.
+case $rule_number: {
+  AST::ConditionalExpression *node = makeAstNode<AST::ConditionalExpression> (driver->nodePool(), sym(1).Expression,
+    sym(3).Expression, sym(5).Expression);
+  node->questionToken = loc(2);
+  node->colonToken = loc(4);
+  sym(1).Node = node;
+} break;
+./
+
+ConditionalExpressionNotIn: LogicalORExpressionNotIn ;
+
+ConditionalExpressionNotIn: LogicalORExpressionNotIn T_QUESTION AssignmentExpressionNotIn T_COLON AssignmentExpressionNotIn ;
+/.
+case $rule_number: {
+  AST::ConditionalExpression *node = makeAstNode<AST::ConditionalExpression> (driver->nodePool(), sym(1).Expression,
+    sym(3).Expression, sym(5).Expression);
+  node->questionToken = loc(2);
+  node->colonToken = loc(4);
+  sym(1).Node = node;
+} break;
+./
+
+AssignmentExpression: ConditionalExpression ;
+
+AssignmentExpression: LeftHandSideExpression AssignmentOperator AssignmentExpression ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    sym(2).ival, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+AssignmentExpressionNotIn: ConditionalExpressionNotIn ;
+
+AssignmentExpressionNotIn: LeftHandSideExpression AssignmentOperator AssignmentExpressionNotIn ;
+/.
+case $rule_number: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    sym(2).ival, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+AssignmentOperator: T_EQ ;
+/.
+case $rule_number: {
+  sym(1).ival = QSOperator::Assign;
+} break;
+./
+
+AssignmentOperator: T_STAR_EQ ;
+/.
+case $rule_number: {
+  sym(1).ival = QSOperator::InplaceMul;
+} break;
+./
+
+AssignmentOperator: T_DIVIDE_EQ ;
+/.
+case $rule_number: {
+  sym(1).ival = QSOperator::InplaceDiv;
+} break;
+./
+
+AssignmentOperator: T_REMAINDER_EQ ;
+/.
+case $rule_number: {
+  sym(1).ival = QSOperator::InplaceMod;
+} break;
+./
+
+AssignmentOperator: T_PLUS_EQ ;
+/.
+case $rule_number: {
+  sym(1).ival = QSOperator::InplaceAdd;
+} break;
+./
+
+AssignmentOperator: T_MINUS_EQ ;
+/.
+case $rule_number: {
+  sym(1).ival = QSOperator::InplaceSub;
+} break;
+./
+
+AssignmentOperator: T_LT_LT_EQ ;
+/.
+case $rule_number: {
+  sym(1).ival = QSOperator::InplaceLeftShift;
+} break;
+./
+
+AssignmentOperator: T_GT_GT_EQ ;
+/.
+case $rule_number: {
+  sym(1).ival = QSOperator::InplaceRightShift;
+} break;
+./
+
+AssignmentOperator: T_GT_GT_GT_EQ ;
+/.
+case $rule_number: {
+  sym(1).ival = QSOperator::InplaceURightShift;
+} break;
+./
+
+AssignmentOperator: T_AND_EQ ;
+/.
+case $rule_number: {
+  sym(1).ival = QSOperator::InplaceAnd;
+} break;
+./
+
+AssignmentOperator: T_XOR_EQ ;
+/.
+case $rule_number: {
+  sym(1).ival = QSOperator::InplaceXor;
+} break;
+./
+
+AssignmentOperator: T_OR_EQ ;
+/.
+case $rule_number: {
+  sym(1).ival = QSOperator::InplaceOr;
+} break;
+./
+
+Expression: AssignmentExpression ;
+
+Expression: Expression T_COMMA AssignmentExpression ;
+/.
+case $rule_number: {
+  AST::Expression *node = makeAstNode<AST::Expression> (driver->nodePool(), sym(1).Expression, sym(3).Expression);
+  node->commaToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+ExpressionOpt: ;
+/.
+case $rule_number: {
+  sym(1).Node = 0;
+} break;
+./
+
+ExpressionOpt: Expression ;
+
+ExpressionNotIn: AssignmentExpressionNotIn ;
+
+ExpressionNotIn: ExpressionNotIn T_COMMA AssignmentExpressionNotIn ;
+/.
+case $rule_number: {
+  AST::Expression *node = makeAstNode<AST::Expression> (driver->nodePool(), sym(1).Expression, sym(3).Expression);
+  node->commaToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+ExpressionNotInOpt: ;
+/.
+case $rule_number: {
+  sym(1).Node = 0;
+} break;
+./
+
+ExpressionNotInOpt: ExpressionNotIn ;
+
+Statement: Block ;
+Statement: VariableStatement ;
+Statement: EmptyStatement ;
+Statement: ExpressionStatement ;
+Statement: IfStatement ;
+Statement: IterationStatement ;
+Statement: ContinueStatement ;
+Statement: BreakStatement ;
+Statement: ReturnStatement ;
+Statement: WithStatement ;
+Statement: LabelledStatement ;
+Statement: SwitchStatement ;
+Statement: ThrowStatement ;
+Statement: TryStatement ;
+Statement: DebuggerStatement ;
+
+
+Block: T_LBRACE StatementListOpt T_RBRACE ;
+/.
+case $rule_number: {
+  AST::Block *node = makeAstNode<AST::Block> (driver->nodePool(), sym(2).StatementList);
+  node->lbraceToken = loc(1);
+  node->rbraceToken = loc(3);
+  sym(1).Node = node;
+} break;
+./
+
+StatementList: Statement ;
+/.
+case $rule_number: {
+  sym(1).Node = makeAstNode<AST::StatementList> (driver->nodePool(), sym(1).Statement);
+} break;
+./
+
+StatementList: StatementList Statement ;
+/.
+case $rule_number: {
+  sym(1).Node = makeAstNode<AST::StatementList> (driver->nodePool(), sym(1).StatementList, sym(2).Statement);
+} break;
+./
+
+StatementListOpt: ;
+/.
+case $rule_number: {
+  sym(1).Node = 0;
+} break;
+./
+
+StatementListOpt: StatementList ;
+/.
+case $rule_number: {
+  sym(1).Node = sym(1).StatementList->finish ();
+} break;
+./
+
+VariableStatement: VariableDeclarationKind VariableDeclarationList T_AUTOMATIC_SEMICOLON ;  -- automatic semicolon
+VariableStatement: VariableDeclarationKind VariableDeclarationList T_SEMICOLON ;
+/.
+case $rule_number: {
+  AST::VariableStatement *node = makeAstNode<AST::VariableStatement> (driver->nodePool(),
+     sym(2).VariableDeclarationList->finish (/*readOnly=*/sym(1).ival == T_CONST));
+  node->declarationKindToken = loc(1);
+  node->semicolonToken = loc(3);
+  sym(1).Node = node;
+} break;
+./
+
+VariableDeclarationKind: T_CONST ;
+/.
+case $rule_number: {
+  sym(1).ival = T_CONST;
+} break;
+./
+
+VariableDeclarationKind: T_VAR ;
+/.
+case $rule_number: {
+  sym(1).ival = T_VAR;
+} break;
+./
+
+VariableDeclarationList: VariableDeclaration ;
+/.
+case $rule_number: {
+  sym(1).Node = makeAstNode<AST::VariableDeclarationList> (driver->nodePool(), sym(1).VariableDeclaration);
+} break;
+./
+
+VariableDeclarationList: VariableDeclarationList T_COMMA VariableDeclaration ;
+/.
+case $rule_number: {
+  AST::VariableDeclarationList *node = makeAstNode<AST::VariableDeclarationList> (driver->nodePool(),
+    sym(1).VariableDeclarationList, sym(3).VariableDeclaration);
+  node->commaToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+VariableDeclarationListNotIn: VariableDeclarationNotIn ;
+/.
+case $rule_number: {
+  sym(1).Node = makeAstNode<AST::VariableDeclarationList> (driver->nodePool(), sym(1).VariableDeclaration);
+} break;
+./
+
+VariableDeclarationListNotIn: VariableDeclarationListNotIn T_COMMA VariableDeclarationNotIn ;
+/.
+case $rule_number: {
+  sym(1).Node = makeAstNode<AST::VariableDeclarationList> (driver->nodePool(), sym(1).VariableDeclarationList, sym(3).VariableDeclaration);
+} break;
+./
+
+VariableDeclaration: JsIdentifier InitialiserOpt ;
+/.
+case $rule_number: {
+  AST::VariableDeclaration *node = makeAstNode<AST::VariableDeclaration> (driver->nodePool(), sym(1).sval, sym(2).Expression);
+  node->identifierToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+VariableDeclarationNotIn: JsIdentifier InitialiserNotInOpt ;
+/.
+case $rule_number: {
+  AST::VariableDeclaration *node = makeAstNode<AST::VariableDeclaration> (driver->nodePool(), sym(1).sval, sym(2).Expression);
+  node->identifierToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+Initialiser: T_EQ AssignmentExpression ;
+/.
+case $rule_number: {
+  // ### TODO: AST for initializer
+  sym(1) = sym(2);
+} break;
+./
+
+InitialiserOpt: ;
+/.
+case $rule_number: {
+  sym(1).Node = 0;
+} break;
+./
+
+InitialiserOpt: Initialiser ;
+
+InitialiserNotIn: T_EQ AssignmentExpressionNotIn ;
+/.
+case $rule_number: {
+  // ### TODO: AST for initializer
+  sym(1) = sym(2);
+} break;
+./
+
+InitialiserNotInOpt: ;
+/.
+case $rule_number: {
+  sym(1).Node = 0;
+} break;
+./
+
+InitialiserNotInOpt: InitialiserNotIn ;
+
+EmptyStatement: T_SEMICOLON ;
+/.
+case $rule_number: {
+  AST::EmptyStatement *node = makeAstNode<AST::EmptyStatement> (driver->nodePool());
+  node->semicolonToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+ExpressionStatement: Expression T_AUTOMATIC_SEMICOLON ;  -- automatic semicolon
+ExpressionStatement: Expression T_SEMICOLON ;
+/.
+case $rule_number: {
+  AST::ExpressionStatement *node = makeAstNode<AST::ExpressionStatement> (driver->nodePool(), sym(1).Expression);
+  node->semicolonToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+IfStatement: T_IF T_LPAREN Expression T_RPAREN Statement T_ELSE Statement ;
+/.
+case $rule_number: {
+  AST::IfStatement *node = makeAstNode<AST::IfStatement> (driver->nodePool(), sym(3).Expression, sym(5).Statement, sym(7).Statement);
+  node->ifToken = loc(1);
+  node->lparenToken = loc(2);
+  node->rparenToken = loc(4);
+  node->elseToken = loc(5);
+  sym(1).Node = node;
+} break;
+./
+
+IfStatement: T_IF T_LPAREN Expression T_RPAREN Statement ;
+/.
+case $rule_number: {
+  AST::IfStatement *node = makeAstNode<AST::IfStatement> (driver->nodePool(), sym(3).Expression, sym(5).Statement);
+  node->ifToken = loc(1);
+  node->lparenToken = loc(2);
+  node->rparenToken = loc(4);
+  sym(1).Node = node;
+} break;
+./
+
+
+IterationStatement: T_DO Statement T_WHILE T_LPAREN Expression T_RPAREN T_AUTOMATIC_SEMICOLON ;  -- automatic semicolon
+IterationStatement: T_DO Statement T_WHILE T_LPAREN Expression T_RPAREN T_SEMICOLON ;
+/.
+case $rule_number: {
+  AST::DoWhileStatement *node = makeAstNode<AST::DoWhileStatement> (driver->nodePool(), sym(2).Statement, sym(5).Expression);
+  node->doToken = loc(1);
+  node->whileToken = loc(3);
+  node->lparenToken = loc(4);
+  node->rparenToken = loc(6);
+  node->semicolonToken = loc(7);
+  sym(1).Node = node;
+} break;
+./
+
+IterationStatement: T_WHILE T_LPAREN Expression T_RPAREN Statement ;
+/.
+case $rule_number: {
+  AST::WhileStatement *node = makeAstNode<AST::WhileStatement> (driver->nodePool(), sym(3).Expression, sym(5).Statement);
+  node->whileToken = loc(1);
+  node->lparenToken = loc(2);
+  node->rparenToken = loc(4);
+  sym(1).Node = node;
+} break;
+./
+
+IterationStatement: T_FOR T_LPAREN ExpressionNotInOpt T_SEMICOLON ExpressionOpt T_SEMICOLON ExpressionOpt T_RPAREN Statement ;
+/.
+case $rule_number: {
+  AST::ForStatement *node = makeAstNode<AST::ForStatement> (driver->nodePool(), sym(3).Expression,
+    sym(5).Expression, sym(7).Expression, sym(9).Statement);
+  node->forToken = loc(1);
+  node->lparenToken = loc(2);
+  node->firstSemicolonToken = loc(4);
+  node->secondSemicolonToken = loc(6);
+  node->rparenToken = loc(8);
+  sym(1).Node = node;
+} break;
+./
+
+IterationStatement: T_FOR T_LPAREN T_VAR VariableDeclarationListNotIn T_SEMICOLON ExpressionOpt T_SEMICOLON ExpressionOpt T_RPAREN Statement ;
+/.
+case $rule_number: {
+  AST::LocalForStatement *node = makeAstNode<AST::LocalForStatement> (driver->nodePool(),
+     sym(4).VariableDeclarationList->finish (/*readOnly=*/false), sym(6).Expression,
+     sym(8).Expression, sym(10).Statement);
+  node->forToken = loc(1);
+  node->lparenToken = loc(2);
+  node->varToken = loc(3);
+  node->firstSemicolonToken = loc(5);
+  node->secondSemicolonToken = loc(7);
+  node->rparenToken = loc(9);
+  sym(1).Node = node;
+} break;
+./
+
+IterationStatement: T_FOR T_LPAREN LeftHandSideExpression T_IN Expression T_RPAREN Statement ;
+/.
+case $rule_number: {
+  AST:: ForEachStatement *node = makeAstNode<AST::ForEachStatement> (driver->nodePool(), sym(3).Expression,
+    sym(5).Expression, sym(7).Statement);
+  node->forToken = loc(1);
+  node->lparenToken = loc(2);
+  node->inToken = loc(4);
+  node->rparenToken = loc(6);
+  sym(1).Node = node;
+} break;
+./
+
+IterationStatement: T_FOR T_LPAREN T_VAR VariableDeclarationNotIn T_IN Expression T_RPAREN Statement ;
+/.
+case $rule_number: {
+  AST::LocalForEachStatement *node = makeAstNode<AST::LocalForEachStatement> (driver->nodePool(),
+    sym(4).VariableDeclaration, sym(6).Expression, sym(8).Statement);
+  node->forToken = loc(1);
+  node->lparenToken = loc(2);
+  node->varToken = loc(3);
+  node->inToken = loc(5);
+  node->rparenToken = loc(7);
+  sym(1).Node = node;
+} break;
+./
+
+ContinueStatement: T_CONTINUE T_AUTOMATIC_SEMICOLON ;  -- automatic semicolon
+ContinueStatement: T_CONTINUE T_SEMICOLON ;
+/.
+case $rule_number: {
+  AST::ContinueStatement *node = makeAstNode<AST::ContinueStatement> (driver->nodePool());
+  node->continueToken = loc(1);
+  node->semicolonToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+ContinueStatement: T_CONTINUE JsIdentifier T_AUTOMATIC_SEMICOLON ;  -- automatic semicolon
+ContinueStatement: T_CONTINUE JsIdentifier T_SEMICOLON ;
+/.
+case $rule_number: {
+  AST::ContinueStatement *node = makeAstNode<AST::ContinueStatement> (driver->nodePool(), sym(2).sval);
+  node->continueToken = loc(1);
+  node->identifierToken = loc(2);
+  node->semicolonToken = loc(3);
+  sym(1).Node = node;
+} break;
+./
+
+BreakStatement: T_BREAK T_AUTOMATIC_SEMICOLON ;  -- automatic semicolon
+BreakStatement: T_BREAK T_SEMICOLON ;
+/.
+case $rule_number: {
+  AST::BreakStatement *node = makeAstNode<AST::BreakStatement> (driver->nodePool());
+  node->breakToken = loc(1);
+  node->semicolonToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+BreakStatement: T_BREAK JsIdentifier T_AUTOMATIC_SEMICOLON ;  -- automatic semicolon
+BreakStatement: T_BREAK JsIdentifier T_SEMICOLON ;
+/.
+case $rule_number: {
+  AST::BreakStatement *node = makeAstNode<AST::BreakStatement> (driver->nodePool(), sym(2).sval);
+  node->breakToken = loc(1);
+  node->identifierToken = loc(2);
+  node->semicolonToken = loc(3);
+  sym(1).Node = node;
+} break;
+./
+
+ReturnStatement: T_RETURN ExpressionOpt T_AUTOMATIC_SEMICOLON ;  -- automatic semicolon
+ReturnStatement: T_RETURN ExpressionOpt T_SEMICOLON ;
+/.
+case $rule_number: {
+  AST::ReturnStatement *node = makeAstNode<AST::ReturnStatement> (driver->nodePool(), sym(2).Expression);
+  node->returnToken = loc(1);
+  node->semicolonToken = loc(3);
+  sym(1).Node = node;
+} break;
+./
+
+WithStatement: T_WITH T_LPAREN Expression T_RPAREN Statement ;
+/.
+case $rule_number: {
+  AST::WithStatement *node = makeAstNode<AST::WithStatement> (driver->nodePool(), sym(3).Expression, sym(5).Statement);
+  node->withToken = loc(1);
+  node->lparenToken = loc(2);
+  node->rparenToken = loc(4);
+  sym(1).Node = node;
+} break;
+./
+
+SwitchStatement: T_SWITCH T_LPAREN Expression T_RPAREN CaseBlock ;
+/.
+case $rule_number: {
+  AST::SwitchStatement *node = makeAstNode<AST::SwitchStatement> (driver->nodePool(), sym(3).Expression, sym(5).CaseBlock);
+  node->switchToken = loc(1);
+  node->lparenToken = loc(2);
+  node->rparenToken = loc(4);
+  sym(1).Node = node;
+} break;
+./
+
+CaseBlock: T_LBRACE CaseClausesOpt T_RBRACE ;
+/.
+case $rule_number: {
+  AST::CaseBlock *node = makeAstNode<AST::CaseBlock> (driver->nodePool(), sym(2).CaseClauses);
+  node->lbraceToken = loc(1);
+  node->rbraceToken = loc(3);
+  sym(1).Node = node;
+} break;
+./
+
+CaseBlock: T_LBRACE CaseClausesOpt DefaultClause CaseClausesOpt T_RBRACE ;
+/.
+case $rule_number: {
+  AST::CaseBlock *node = makeAstNode<AST::CaseBlock> (driver->nodePool(), sym(2).CaseClauses, sym(3).DefaultClause, sym(4).CaseClauses);
+  node->lbraceToken = loc(1);
+  node->rbraceToken = loc(5);
+  sym(1).Node = node;
+} break;
+./
+
+CaseClauses: CaseClause ;
+/.
+case $rule_number: {
+  sym(1).Node = makeAstNode<AST::CaseClauses> (driver->nodePool(), sym(1).CaseClause);
+} break;
+./
+
+CaseClauses: CaseClauses CaseClause ;
+/.
+case $rule_number: {
+  sym(1).Node = makeAstNode<AST::CaseClauses> (driver->nodePool(), sym(1).CaseClauses, sym(2).CaseClause);
+} break;
+./
+
+CaseClausesOpt: ;
+/.
+case $rule_number: {
+  sym(1).Node = 0;
+} break;
+./
+
+CaseClausesOpt: CaseClauses ;
+/.
+case $rule_number: {
+  sym(1).Node = sym(1).CaseClauses->finish ();
+} break;
+./
+
+CaseClause: T_CASE Expression T_COLON StatementListOpt ;
+/.
+case $rule_number: {
+  AST::CaseClause *node = makeAstNode<AST::CaseClause> (driver->nodePool(), sym(2).Expression, sym(4).StatementList);
+  node->caseToken = loc(1);
+  node->colonToken = loc(3);
+  sym(1).Node = node;
+} break;
+./
+
+DefaultClause: T_DEFAULT T_COLON StatementListOpt ;
+/.
+case $rule_number: {
+  AST::DefaultClause *node = makeAstNode<AST::DefaultClause> (driver->nodePool(), sym(3).StatementList);
+  node->defaultToken = loc(1);
+  node->colonToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+LabelledStatement: T_SIGNAL T_COLON Statement ;
+/.case $rule_number:./
+
+LabelledStatement: T_PROPERTY T_COLON Statement ;
+/.
+case $rule_number: {
+  AST::LabelledStatement *node = makeAstNode<AST::LabelledStatement> (driver->nodePool(), driver->intern(lexer->characterBuffer(), lexer->characterCount()), sym(3).Statement);
+  node->identifierToken = loc(1);
+  node->colonToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+LabelledStatement: T_IDENTIFIER T_COLON Statement ;
+/.
+case $rule_number: {
+  AST::LabelledStatement *node = makeAstNode<AST::LabelledStatement> (driver->nodePool(), sym(1).sval, sym(3).Statement);
+  node->identifierToken = loc(1);
+  node->colonToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+ThrowStatement: T_THROW Expression T_AUTOMATIC_SEMICOLON ;  -- automatic semicolon
+ThrowStatement: T_THROW Expression T_SEMICOLON ;
+/.
+case $rule_number: {
+  AST::ThrowStatement *node = makeAstNode<AST::ThrowStatement> (driver->nodePool(), sym(2).Expression);
+  node->throwToken = loc(1);
+  node->semicolonToken = loc(3);
+  sym(1).Node = node;
+} break;
+./
+
+TryStatement: T_TRY Block Catch ;
+/.
+case $rule_number: {
+  AST::TryStatement *node = makeAstNode<AST::TryStatement> (driver->nodePool(), sym(2).Statement, sym(3).Catch);
+  node->tryToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+TryStatement: T_TRY Block Finally ;
+/.
+case $rule_number: {
+  AST::TryStatement *node = makeAstNode<AST::TryStatement> (driver->nodePool(), sym(2).Statement, sym(3).Finally);
+  node->tryToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+TryStatement: T_TRY Block Catch Finally ;
+/.
+case $rule_number: {
+  AST::TryStatement *node = makeAstNode<AST::TryStatement> (driver->nodePool(), sym(2).Statement, sym(3).Catch, sym(4).Finally);
+  node->tryToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+Catch: T_CATCH T_LPAREN JsIdentifier T_RPAREN Block ;
+/.
+case $rule_number: {
+  AST::Catch *node = makeAstNode<AST::Catch> (driver->nodePool(), sym(3).sval, sym(5).Block);
+  node->catchToken = loc(1);
+  node->lparenToken = loc(2);
+  node->identifierToken = loc(3);
+  node->rparenToken = loc(4);
+  sym(1).Node = node;
+} break;
+./
+
+Finally: T_FINALLY Block ;
+/.
+case $rule_number: {
+  AST::Finally *node = makeAstNode<AST::Finally> (driver->nodePool(), sym(2).Block);
+  node->finallyToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+DebuggerStatement: T_DEBUGGER T_AUTOMATIC_SEMICOLON ; -- automatic semicolon
+DebuggerStatement: T_DEBUGGER T_SEMICOLON ;
+/.
+case $rule_number: {
+  AST::DebuggerStatement *node = makeAstNode<AST::DebuggerStatement> (driver->nodePool());
+  node->debuggerToken = loc(1);
+  node->semicolonToken = loc(2);
+  sym(1).Node = node;
+} break;
+./
+
+FunctionDeclaration: T_FUNCTION JsIdentifier T_LPAREN FormalParameterListOpt T_RPAREN T_LBRACE FunctionBodyOpt T_RBRACE ;
+/.
+case $rule_number: {
+  AST::FunctionDeclaration *node = makeAstNode<AST::FunctionDeclaration> (driver->nodePool(), sym(2).sval, sym(4).FormalParameterList, sym(7).FunctionBody);
+  node->functionToken = loc(1);
+  node->identifierToken = loc(2);
+  node->lparenToken = loc(3);
+  node->rparenToken = loc(5);
+  node->lbraceToken = loc(6);
+  node->rbraceToken = loc(8);
+  sym(1).Node = node;
+} break;
+./
+
+FunctionExpression: T_FUNCTION IdentifierOpt T_LPAREN FormalParameterListOpt T_RPAREN T_LBRACE FunctionBodyOpt T_RBRACE ;
+/.
+case $rule_number: {
+  AST::FunctionExpression *node = makeAstNode<AST::FunctionExpression> (driver->nodePool(), sym(2).sval, sym(4).FormalParameterList, sym(7).FunctionBody);
+  node->functionToken = loc(1);
+  if (sym(2).sval)
+      node->identifierToken = loc(2);
+  node->lparenToken = loc(3);
+  node->rparenToken = loc(5);
+  node->lbraceToken = loc(6);
+  node->rbraceToken = loc(8);
+  sym(1).Node = node;
+} break;
+./
+
+FormalParameterList: JsIdentifier ;
+/.
+case $rule_number: {
+  AST::FormalParameterList *node = makeAstNode<AST::FormalParameterList> (driver->nodePool(), sym(1).sval);
+  node->identifierToken = loc(1);
+  sym(1).Node = node;
+} break;
+./
+
+FormalParameterList: FormalParameterList T_COMMA JsIdentifier ;
+/.
+case $rule_number: {
+  AST::FormalParameterList *node = makeAstNode<AST::FormalParameterList> (driver->nodePool(), sym(1).FormalParameterList, sym(3).sval);
+  node->commaToken = loc(2);
+  node->identifierToken = loc(3);
+  sym(1).Node = node;
+} break;
+./
+
+FormalParameterListOpt: ;
+/.
+case $rule_number: {
+  sym(1).Node = 0;
+} break;
+./
+
+FormalParameterListOpt: FormalParameterList ;
+/.
+case $rule_number: {
+  sym(1).Node = sym(1).FormalParameterList->finish ();
+} break;
+./
+
+FunctionBodyOpt: ;
+/.
+case $rule_number: {
+  sym(1).Node = 0;
+} break;
+./
+
+FunctionBodyOpt: FunctionBody ;
+
+FunctionBody: SourceElements ;
+/.
+case $rule_number: {
+  sym(1).Node = makeAstNode<AST::FunctionBody> (driver->nodePool(), sym(1).SourceElements->finish ());
+} break;
+./
+
+Program: SourceElements ;
+/.
+case $rule_number: {
+  sym(1).Node = makeAstNode<AST::Program> (driver->nodePool(), sym(1).SourceElements->finish ());
+} break;
+./
+
+SourceElements: SourceElement ;
+/.
+case $rule_number: {
+  sym(1).Node = makeAstNode<AST::SourceElements> (driver->nodePool(), sym(1).SourceElement);
+} break;
+./
+
+SourceElements: SourceElements SourceElement ;
+/.
+case $rule_number: {
+  sym(1).Node = makeAstNode<AST::SourceElements> (driver->nodePool(), sym(1).SourceElements, sym(2).SourceElement);
+} break;
+./
+
+SourceElement: Statement ;
+/.
+case $rule_number: {
+  sym(1).Node = makeAstNode<AST::StatementSourceElement> (driver->nodePool(), sym(1).Statement);
+} break;
+./
+
+SourceElement: FunctionDeclaration ;
+/.
+case $rule_number: {
+  sym(1).Node = makeAstNode<AST::FunctionSourceElement> (driver->nodePool(), sym(1).FunctionDeclaration);
+} break;
+./
+
+IdentifierOpt: ;
+/.
+case $rule_number: {
+  sym(1).sval = 0;
+} break;
+./
+
+IdentifierOpt: JsIdentifier ;
+
+PropertyNameAndValueListOpt: ;
+/.
+case $rule_number: {
+  sym(1).Node = 0;
+} break;
+./
+
+PropertyNameAndValueListOpt: PropertyNameAndValueList ;
+
+/.
+            } // switch
+            action = nt_action(state_stack[tos], lhs[r] - TERMINAL_COUNT);
+        } // if
+    } while (action != 0);
+
+    if (first_token == last_token) {
+        const int errorState = state_stack[tos];
+
+        // automatic insertion of `;'
+        if (yytoken != -1 && t_action(errorState, T_AUTOMATIC_SEMICOLON) && automatic(driver, yytoken)) {
+            SavedToken &tk = token_buffer[0];
+            tk.token = yytoken;
+            tk.dval = yylval;
+            tk.loc = yylloc;
+
+            yylloc = yyprevlloc;
+            yylloc.offset += yylloc.length;
+            yylloc.startColumn += yylloc.length;
+            yylloc.length = 0;
+
+            //const QString msg = qApp->translate("QDeclarativeParser", "Missing `;'");
+            //diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Warning, yylloc, msg));
+
+            first_token = &token_buffer[0];
+            last_token = &token_buffer[1];
+
+            yytoken = T_SEMICOLON;
+            yylval = 0;
+
+            action = errorState;
+
+            goto _Lcheck_token;
+        }
+
+        hadErrors = true;
+
+        token_buffer[0].token = yytoken;
+        token_buffer[0].dval = yylval;
+        token_buffer[0].loc = yylloc;
+
+        token_buffer[1].token = yytoken = lexer->lex();
+        token_buffer[1].dval  = yylval  = lexer->dval();
+        token_buffer[1].loc   = yylloc  = location(lexer);
+
+        if (t_action(errorState, yytoken)) {
+            QString msg;
+            int token = token_buffer[0].token;
+            if (token < 0 || token >= TERMINAL_COUNT)
+                msg = qApp->translate("QDeclarativeParser", "Syntax error");
+            else
+                msg = qApp->translate("QDeclarativeParser", "Unexpected token `%1'").arg(QLatin1String(spell[token]));
+            diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));
+
+            action = errorState;
+            goto _Lcheck_token;
+        }
+
+        static int tokens[] = {
+            T_PLUS,
+            T_EQ,
+
+            T_COMMA,
+            T_COLON,
+            T_SEMICOLON,
+
+            T_RPAREN, T_RBRACKET, T_RBRACE,
+
+            T_NUMERIC_LITERAL,
+            T_IDENTIFIER,
+
+            T_LPAREN, T_LBRACKET, T_LBRACE,
+
+            EOF_SYMBOL
+        };
+
+        for (int *tk = tokens; *tk != EOF_SYMBOL; ++tk) {
+            int a = t_action(errorState, *tk);
+            if (a > 0 && t_action(a, yytoken)) {
+                const QString msg = qApp->translate("QDeclarativeParser", "Expected token `%1'").arg(QLatin1String(spell[*tk]));
+                diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));
+
+                yytoken = *tk;
+                yylval = 0;
+                yylloc = token_buffer[0].loc;
+                yylloc.length = 0;
+
+                first_token = &token_buffer[0];
+                last_token = &token_buffer[2];
+
+                action = errorState;
+                goto _Lcheck_token;
+            }
+        }
+
+        for (int tk = 1; tk < TERMINAL_COUNT; ++tk) {
+            if (tk == T_AUTOMATIC_SEMICOLON || tk == T_FEED_UI_PROGRAM    ||
+                tk == T_FEED_JS_STATEMENT   || tk == T_FEED_JS_EXPRESSION ||
+                tk == T_FEED_JS_SOURCE_ELEMENT)
+               continue;
+
+            int a = t_action(errorState, tk);
+            if (a > 0 && t_action(a, yytoken)) {
+                const QString msg = qApp->translate("QDeclarativeParser", "Expected token `%1'").arg(QLatin1String(spell[tk]));
+                diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));
+
+                yytoken = tk;
+                yylval = 0;
+                yylloc = token_buffer[0].loc;
+                yylloc.length = 0;
+
+                action = errorState;
+                goto _Lcheck_token;
+            }
+        }
+
+        const QString msg = qApp->translate("QDeclarativeParser", "Syntax error");
+        diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));
+    }
+
+    return false;
+}
+
+QT_QML_END_NAMESPACE
+
+
+./
+/:
+QT_QML_END_NAMESPACE
+
+
+
+#endif // QDECLARATIVEJSPARSER_P_H
+:/
diff --git a/tools/qdoc3/declarativeparser/qdeclarativejsast.cpp b/tools/qdoc3/declarativeparser/qdeclarativejsast.cpp
new file mode 100644
index 0000000..afb399a
--- /dev/null
+++ b/tools/qdoc3/declarativeparser/qdeclarativejsast.cpp
@@ -0,0 +1,956 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "private/qdeclarativejsast_p.h"
+
+#include "private/qdeclarativejsastvisitor_p.h"
+
+QT_QML_BEGIN_NAMESPACE
+
+namespace QDeclarativeJS { namespace AST {
+
+void Node::accept(Visitor *visitor)
+{
+    if (visitor->preVisit(this)) {
+        accept0(visitor);
+    }
+    visitor->postVisit(this);
+}
+
+void Node::accept(Node *node, Visitor *visitor)
+{
+    if (node)
+        node->accept(visitor);
+}
+
+ExpressionNode *Node::expressionCast()
+{
+    return 0;
+}
+
+BinaryExpression *Node::binaryExpressionCast()
+{
+    return 0;
+}
+
+Statement *Node::statementCast()
+{
+    return 0;
+}
+
+UiObjectMember *Node::uiObjectMemberCast()
+{
+    return 0;
+}
+
+ExpressionNode *ExpressionNode::expressionCast()
+{
+    return this;
+}
+
+BinaryExpression *BinaryExpression::binaryExpressionCast()
+{
+    return this;
+}
+
+Statement *Statement::statementCast()
+{
+    return this;
+}
+
+UiObjectMember *UiObjectMember::uiObjectMemberCast()
+{
+    return this;
+}
+
+void NestedExpression::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(expression, visitor);
+    }
+    visitor->endVisit(this);
+}
+
+void ThisExpression::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+    }
+
+    visitor->endVisit(this);
+}
+
+void IdentifierExpression::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+    }
+
+    visitor->endVisit(this);
+}
+
+void NullExpression::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+    }
+
+    visitor->endVisit(this);
+}
+
+void TrueLiteral::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+    }
+
+    visitor->endVisit(this);
+}
+
+void FalseLiteral::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+    }
+
+    visitor->endVisit(this);
+}
+
+void StringLiteral::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+    }
+
+    visitor->endVisit(this);
+}
+
+void NumericLiteral::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+    }
+
+    visitor->endVisit(this);
+}
+
+void RegExpLiteral::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+    }
+
+    visitor->endVisit(this);
+}
+
+void ArrayLiteral::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(elements, visitor);
+        accept(elision, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void ObjectLiteral::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(properties, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void ElementList::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        for (ElementList *it = this; it; it = it->next) {
+            accept(it->elision, visitor);
+            accept(it->expression, visitor);
+        }
+    }
+
+    visitor->endVisit(this);
+}
+
+void Elision::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        // ###
+    }
+
+    visitor->endVisit(this);
+}
+
+void PropertyNameAndValueList::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        for (PropertyNameAndValueList *it = this; it; it = it->next) {
+            accept(it->name, visitor);
+            accept(it->value, visitor);
+        }
+    }
+
+    visitor->endVisit(this);
+}
+
+void IdentifierPropertyName::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+    }
+
+    visitor->endVisit(this);
+}
+
+void StringLiteralPropertyName::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+    }
+
+    visitor->endVisit(this);
+}
+
+void NumericLiteralPropertyName::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+    }
+
+    visitor->endVisit(this);
+}
+
+void ArrayMemberExpression::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(base, visitor);
+        accept(expression, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void FieldMemberExpression::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(base, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void NewMemberExpression::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(base, visitor);
+        accept(arguments, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void NewExpression::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(expression, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void CallExpression::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(base, visitor);
+        accept(arguments, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void ArgumentList::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        for (ArgumentList *it = this; it; it = it->next) {
+            accept(it->expression, visitor);
+        }
+    }
+
+    visitor->endVisit(this);
+}
+
+void PostIncrementExpression::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(base, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void PostDecrementExpression::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(base, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void DeleteExpression::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(expression, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void VoidExpression::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(expression, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void TypeOfExpression::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(expression, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void PreIncrementExpression::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(expression, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void PreDecrementExpression::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(expression, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void UnaryPlusExpression::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(expression, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void UnaryMinusExpression::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(expression, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void TildeExpression::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(expression, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void NotExpression::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(expression, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void BinaryExpression::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(left, visitor);
+        accept(right, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void ConditionalExpression::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(expression, visitor);
+        accept(ok, visitor);
+        accept(ko, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void Expression::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(left, visitor);
+        accept(right, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void Block::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(statements, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void StatementList::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        for (StatementList *it = this; it; it = it->next) {
+            accept(it->statement, visitor);
+        }
+    }
+
+    visitor->endVisit(this);
+}
+
+void VariableStatement::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(declarations, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void VariableDeclarationList::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        for (VariableDeclarationList *it = this; it; it = it->next) {
+            accept(it->declaration, visitor);
+        }
+    }
+
+    visitor->endVisit(this);
+}
+
+void VariableDeclaration::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(expression, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void EmptyStatement::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+    }
+
+    visitor->endVisit(this);
+}
+
+void ExpressionStatement::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(expression, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void IfStatement::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(expression, visitor);
+        accept(ok, visitor);
+        accept(ko, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void DoWhileStatement::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(statement, visitor);
+        accept(expression, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void WhileStatement::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(expression, visitor);
+        accept(statement, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void ForStatement::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(initialiser, visitor);
+        accept(condition, visitor);
+        accept(expression, visitor);
+        accept(statement, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void LocalForStatement::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(declarations, visitor);
+        accept(condition, visitor);
+        accept(expression, visitor);
+        accept(statement, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void ForEachStatement::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(initialiser, visitor);
+        accept(expression, visitor);
+        accept(statement, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void LocalForEachStatement::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(declaration, visitor);
+        accept(expression, visitor);
+        accept(statement, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void ContinueStatement::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+    }
+
+    visitor->endVisit(this);
+}
+
+void BreakStatement::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+    }
+
+    visitor->endVisit(this);
+}
+
+void ReturnStatement::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(expression, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void WithStatement::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(expression, visitor);
+        accept(statement, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void SwitchStatement::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(expression, visitor);
+        accept(block, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void CaseBlock::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(clauses, visitor);
+        accept(defaultClause, visitor);
+        accept(moreClauses, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void CaseClauses::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        for (CaseClauses *it = this; it; it = it->next) {
+            accept(it->clause, visitor);
+        }
+    }
+
+    visitor->endVisit(this);
+}
+
+void CaseClause::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(expression, visitor);
+        accept(statements, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void DefaultClause::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(statements, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void LabelledStatement::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(statement, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void ThrowStatement::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(expression, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void TryStatement::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(statement, visitor);
+        accept(catchExpression, visitor);
+        accept(finallyExpression, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void Catch::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(statement, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void Finally::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(statement, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void FunctionDeclaration::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(formals, visitor);
+        accept(body, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void FunctionExpression::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(formals, visitor);
+        accept(body, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void FormalParameterList::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        // ###
+    }
+
+    visitor->endVisit(this);
+}
+
+void FunctionBody::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(elements, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void Program::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(elements, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void SourceElements::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        for (SourceElements *it = this; it; it = it->next) {
+            accept(it->element, visitor);
+        }
+    }
+
+    visitor->endVisit(this);
+}
+
+void FunctionSourceElement::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(declaration, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void StatementSourceElement::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(statement, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void DebuggerStatement::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+    }
+
+    visitor->endVisit(this);
+}
+
+void UiProgram::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(imports, visitor);
+        accept(members, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void UiSignature::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(formals, visitor);
+    }
+    visitor->endVisit(this);
+}
+
+void UiFormalList::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        for (UiFormalList *it = this; it; it = it->next) {
+            accept(it->formal, visitor);
+        }
+    }
+    visitor->endVisit(this);
+}
+
+void UiFormal::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+    }
+    visitor->endVisit(this);
+}
+
+void UiPublicMember::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(expression, visitor);
+        accept(binding, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void UiObjectDefinition::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(qualifiedTypeNameId, visitor);
+        accept(initializer, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void UiObjectInitializer::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(members, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void UiObjectBinding::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(qualifiedId, visitor);
+        accept(qualifiedTypeNameId, visitor);
+        accept(initializer, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void UiScriptBinding::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(qualifiedId, visitor);
+        accept(statement, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void UiArrayBinding::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(qualifiedId, visitor);
+        accept(members, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void UiObjectMemberList::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        for (UiObjectMemberList *it = this; it; it = it->next)
+            accept(it->member, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void UiArrayMemberList::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        for (UiArrayMemberList *it = this; it; it = it->next)
+            accept(it->member, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void UiQualifiedId::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+    }
+
+    visitor->endVisit(this);
+}
+
+void UiImport::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(importUri, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void UiImportList::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(import, visitor);
+        accept(next, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+void UiSourceElement::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(sourceElement, visitor);
+    }
+
+    visitor->endVisit(this);
+}
+
+} } // namespace QDeclarativeJS::AST
+
+QT_QML_END_NAMESPACE
+
+
diff --git a/tools/qdoc3/declarativeparser/qdeclarativejsast_p.h b/tools/qdoc3/declarativeparser/qdeclarativejsast_p.h
new file mode 100644
index 0000000..956d6e7
--- /dev/null
+++ b/tools/qdoc3/declarativeparser/qdeclarativejsast_p.h
@@ -0,0 +1,2546 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDECLARATIVEJSAST_P_H
+#define QDECLARATIVEJSAST_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "private/qdeclarativejsastvisitor_p.h"
+#include "private/qdeclarativejsglobal_p.h"
+
+#include <QtCore/QString>
+
+QT_QML_BEGIN_NAMESPACE
+
+#define QDECLARATIVEJS_DECLARE_AST_NODE(name) \
+  enum { K = Kind_##name };
+
+namespace QSOperator // ### rename
+{
+
+enum Op {
+    Add,
+    And,
+    InplaceAnd,
+    Assign,
+    BitAnd,
+    BitOr,
+    BitXor,
+    InplaceSub,
+    Div,
+    InplaceDiv,
+    Equal,
+    Ge,
+    Gt,
+    In,
+    InplaceAdd,
+    InstanceOf,
+    Le,
+    LShift,
+    InplaceLeftShift,
+    Lt,
+    Mod,
+    InplaceMod,
+    Mul,
+    InplaceMul,
+    NotEqual,
+    Or,
+    InplaceOr,
+    RShift,
+    InplaceRightShift,
+    StrictEqual,
+    StrictNotEqual,
+    Sub,
+    URShift,
+    InplaceURightShift,
+    InplaceXor
+};
+
+} // namespace QSOperator
+
+namespace QDeclarativeJS {
+class NameId;
+namespace AST {
+
+template <typename _T1, typename _T2>
+_T1 cast(_T2 *ast)
+{
+    if (ast && ast->kind == static_cast<_T1>(0)->K)
+        return static_cast<_T1>(ast);
+
+    return 0;
+}
+
+class QML_PARSER_EXPORT Node
+{
+public:
+    enum Kind {
+        Kind_Undefined,
+
+        Kind_ArgumentList,
+        Kind_ArrayLiteral,
+        Kind_ArrayMemberExpression,
+        Kind_BinaryExpression,
+        Kind_Block,
+        Kind_BreakStatement,
+        Kind_CallExpression,
+        Kind_CaseBlock,
+        Kind_CaseClause,
+        Kind_CaseClauses,
+        Kind_Catch,
+        Kind_ConditionalExpression,
+        Kind_ContinueStatement,
+        Kind_DebuggerStatement,
+        Kind_DefaultClause,
+        Kind_DeleteExpression,
+        Kind_DoWhileStatement,
+        Kind_ElementList,
+        Kind_Elision,
+        Kind_EmptyStatement,
+        Kind_Expression,
+        Kind_ExpressionStatement,
+        Kind_FalseLiteral,
+        Kind_FieldMemberExpression,
+        Kind_Finally,
+        Kind_ForEachStatement,
+        Kind_ForStatement,
+        Kind_FormalParameterList,
+        Kind_FunctionBody,
+        Kind_FunctionDeclaration,
+        Kind_FunctionExpression,
+        Kind_FunctionSourceElement,
+        Kind_IdentifierExpression,
+        Kind_IdentifierPropertyName,
+        Kind_IfStatement,
+        Kind_LabelledStatement,
+        Kind_LocalForEachStatement,
+        Kind_LocalForStatement,
+        Kind_NewExpression,
+        Kind_NewMemberExpression,
+        Kind_NotExpression,
+        Kind_NullExpression,
+        Kind_NumericLiteral,
+        Kind_NumericLiteralPropertyName,
+        Kind_ObjectLiteral,
+        Kind_PostDecrementExpression,
+        Kind_PostIncrementExpression,
+        Kind_PreDecrementExpression,
+        Kind_PreIncrementExpression,
+        Kind_Program,
+        Kind_PropertyName,
+        Kind_PropertyNameAndValueList,
+        Kind_RegExpLiteral,
+        Kind_ReturnStatement,
+        Kind_SourceElement,
+        Kind_SourceElements,
+        Kind_StatementList,
+        Kind_StatementSourceElement,
+        Kind_StringLiteral,
+        Kind_StringLiteralPropertyName,
+        Kind_SwitchStatement,
+        Kind_ThisExpression,
+        Kind_ThrowStatement,
+        Kind_TildeExpression,
+        Kind_TrueLiteral,
+        Kind_TryStatement,
+        Kind_TypeOfExpression,
+        Kind_UnaryMinusExpression,
+        Kind_UnaryPlusExpression,
+        Kind_VariableDeclaration,
+        Kind_VariableDeclarationList,
+        Kind_VariableStatement,
+        Kind_VoidExpression,
+        Kind_WhileStatement,
+        Kind_WithStatement,
+        Kind_NestedExpression,
+
+        Kind_UiArrayBinding,
+        Kind_UiImport,
+        Kind_UiImportList,
+        Kind_UiObjectBinding,
+        Kind_UiObjectDefinition,
+        Kind_UiObjectInitializer,
+        Kind_UiObjectMemberList,
+        Kind_UiArrayMemberList,
+        Kind_UiProgram,
+        Kind_UiParameterList,
+        Kind_UiPublicMember,
+        Kind_UiQualifiedId,
+        Kind_UiScriptBinding,
+        Kind_UiSourceElement,
+        Kind_UiFormal,
+        Kind_UiFormalList,
+        Kind_UiSignature
+    };
+
+    inline Node()
+        : kind(Kind_Undefined) {}
+
+    // NOTE: node destructors are never called,
+    //       instead we block free the memory
+    //       (see the NodePool class)
+    virtual ~Node() {}
+
+    virtual ExpressionNode *expressionCast();
+    virtual BinaryExpression *binaryExpressionCast();
+    virtual Statement *statementCast();
+    virtual UiObjectMember *uiObjectMemberCast();
+
+    void accept(Visitor *visitor);
+    static void accept(Node *node, Visitor *visitor);
+
+    inline static void acceptChild(Node *node, Visitor *visitor)
+    { return accept(node, visitor); } // ### remove
+
+    virtual void accept0(Visitor *visitor) = 0;
+
+// attributes
+    int kind;
+};
+
+class QML_PARSER_EXPORT ExpressionNode: public Node
+{
+public:
+    ExpressionNode() {}
+
+    virtual ExpressionNode *expressionCast();
+
+    virtual SourceLocation firstSourceLocation() const = 0;
+    virtual SourceLocation lastSourceLocation() const = 0;
+};
+
+class QML_PARSER_EXPORT Statement: public Node
+{
+public:
+    Statement() {}
+
+    virtual Statement *statementCast();
+
+    virtual SourceLocation firstSourceLocation() const = 0;
+    virtual SourceLocation lastSourceLocation() const = 0;
+};
+
+class QML_PARSER_EXPORT UiFormal: public Node
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(UiFormal)
+
+    UiFormal(NameId *name, NameId *alias = 0)
+      : name(name), alias(alias)
+    { }
+
+    virtual SourceLocation firstSourceLocation() const
+    { return SourceLocation(); }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return SourceLocation(); }
+
+    virtual void accept0(Visitor *visitor);
+
+// attributes
+    NameId *name;
+    NameId *alias;
+    SourceLocation identifierToken;
+    SourceLocation asToken;
+    SourceLocation aliasToken;
+};
+
+class QML_PARSER_EXPORT UiFormalList: public Node
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(UiFormalList)
+
+    UiFormalList(UiFormal *formal)
+            : formal(formal), next(this) {}
+
+    UiFormalList(UiFormalList *previous, UiFormal *formal)
+            : formal(formal)
+    {
+        next = previous->next;
+        previous->next = this;
+    }
+
+    UiFormalList *finish()
+    {
+        UiFormalList *head = next;
+        next = 0;
+        return head;
+    }
+
+    virtual SourceLocation firstSourceLocation() const
+    { return SourceLocation(); }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return SourceLocation(); }
+
+    virtual void accept0(Visitor *visitor);
+
+// attributes
+    UiFormal *formal;
+    UiFormalList *next;
+};
+
+class QML_PARSER_EXPORT UiSignature: public Node
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(UiSignature)
+
+    UiSignature(UiFormalList *formals = 0)
+        : formals(formals)
+    { }
+
+    virtual SourceLocation firstSourceLocation() const
+    { return SourceLocation(); }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return SourceLocation(); }
+
+    virtual void accept0(Visitor *visitor);
+
+// attributes
+    SourceLocation lparenToken;
+    UiFormalList *formals;
+    SourceLocation rparenToken;
+};
+
+class QML_PARSER_EXPORT NestedExpression: public ExpressionNode
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(NestedExpression)
+
+    NestedExpression(ExpressionNode *expression)
+        : expression(expression)
+    { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return lparenToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return rparenToken; }
+
+// attributes
+    ExpressionNode *expression;
+    SourceLocation lparenToken;
+    SourceLocation rparenToken;
+};
+
+class QML_PARSER_EXPORT ThisExpression: public ExpressionNode
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(ThisExpression)
+
+    ThisExpression() { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return thisToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return thisToken; }
+
+// attributes
+    SourceLocation thisToken;
+};
+
+class QML_PARSER_EXPORT IdentifierExpression: public ExpressionNode
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(IdentifierExpression)
+
+    IdentifierExpression(NameId *n):
+        name (n) { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return identifierToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return identifierToken; }
+
+// attributes
+    NameId *name;
+    SourceLocation identifierToken;
+};
+
+class QML_PARSER_EXPORT NullExpression: public ExpressionNode
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(NullExpression)
+
+    NullExpression() { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return nullToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return nullToken; }
+
+// attributes
+    SourceLocation nullToken;
+};
+
+class QML_PARSER_EXPORT TrueLiteral: public ExpressionNode
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(TrueLiteral)
+
+    TrueLiteral() { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return trueToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return trueToken; }
+
+// attributes
+    SourceLocation trueToken;
+};
+
+class QML_PARSER_EXPORT FalseLiteral: public ExpressionNode
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(FalseLiteral)
+
+    FalseLiteral() { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return falseToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return falseToken; }
+
+// attributes
+    SourceLocation falseToken;
+};
+
+class QML_PARSER_EXPORT NumericLiteral: public ExpressionNode
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(NumericLiteral)
+
+    NumericLiteral(double v):
+        value(v) { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return literalToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return literalToken; }
+
+// attributes:
+    double value;
+    SourceLocation literalToken;
+};
+
+class QML_PARSER_EXPORT StringLiteral: public ExpressionNode
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(StringLiteral)
+
+    StringLiteral(NameId *v):
+        value (v) { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return literalToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return literalToken; }
+
+// attributes:
+    NameId *value;
+    SourceLocation literalToken;
+};
+
+class QML_PARSER_EXPORT RegExpLiteral: public ExpressionNode
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(RegExpLiteral)
+
+    RegExpLiteral(NameId *p, int f):
+        pattern (p), flags (f) { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return literalToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return literalToken; }
+
+// attributes:
+    NameId *pattern;
+    int flags;
+    SourceLocation literalToken;
+};
+
+class QML_PARSER_EXPORT ArrayLiteral: public ExpressionNode
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(ArrayLiteral)
+
+    ArrayLiteral(Elision *e):
+        elements (0), elision (e)
+        { kind = K; }
+
+    ArrayLiteral(ElementList *elts):
+        elements (elts), elision (0)
+        { kind = K; }
+
+    ArrayLiteral(ElementList *elts, Elision *e):
+        elements (elts), elision (e)
+        { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return lbracketToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return rbracketToken; }
+
+// attributes
+    ElementList *elements;
+    Elision *elision;
+    SourceLocation lbracketToken;
+    SourceLocation commaToken;
+    SourceLocation rbracketToken;
+};
+
+class QML_PARSER_EXPORT ObjectLiteral: public ExpressionNode
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(ObjectLiteral)
+
+    ObjectLiteral():
+        properties (0) { kind = K; }
+
+    ObjectLiteral(PropertyNameAndValueList *plist):
+        properties (plist) { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return lbraceToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return rbraceToken; }
+
+// attributes
+    PropertyNameAndValueList *properties;
+    SourceLocation lbraceToken;
+    SourceLocation rbraceToken;
+};
+
+class QML_PARSER_EXPORT ElementList: public Node
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(ElementList)
+
+    ElementList(Elision *e, ExpressionNode *expr):
+        elision (e), expression (expr), next (this)
+    { kind = K; }
+
+    ElementList(ElementList *previous, Elision *e, ExpressionNode *expr):
+        elision (e), expression (expr)
+    {
+        kind = K;
+        next = previous->next;
+        previous->next = this;
+    }
+
+    inline ElementList *finish ()
+    {
+        ElementList *front = next;
+        next = 0;
+        return front;
+    }
+
+    virtual void accept0(Visitor *visitor);
+
+// attributes
+    Elision *elision;
+    ExpressionNode *expression;
+    ElementList *next;
+    SourceLocation commaToken;
+};
+
+class QML_PARSER_EXPORT Elision: public Node
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(Elision)
+
+    Elision():
+        next (this) { kind = K; }
+
+    Elision(Elision *previous)
+    {
+        kind = K;
+        next = previous->next;
+        previous->next = this;
+    }
+
+    virtual void accept0(Visitor *visitor);
+
+    inline Elision *finish ()
+    {
+        Elision *front = next;
+        next = 0;
+        return front;
+    }
+
+// attributes
+    Elision *next;
+    SourceLocation commaToken;
+};
+
+class QML_PARSER_EXPORT PropertyNameAndValueList: public Node
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(PropertyNameAndValueList)
+
+    PropertyNameAndValueList(PropertyName *n, ExpressionNode *v):
+        name (n), value (v), next (this)
+        { kind = K; }
+
+    PropertyNameAndValueList(PropertyNameAndValueList *previous, PropertyName *n, ExpressionNode *v):
+        name (n), value (v)
+    {
+        kind = K;
+        next = previous->next;
+        previous->next = this;
+    }
+
+    virtual void accept0(Visitor *visitor);
+
+    inline PropertyNameAndValueList *finish ()
+    {
+        PropertyNameAndValueList *front = next;
+        next = 0;
+        return front;
+    }
+
+// attributes
+    PropertyName *name;
+    ExpressionNode *value;
+    PropertyNameAndValueList *next;
+    SourceLocation colonToken;
+    SourceLocation commaToken;
+};
+
+class QML_PARSER_EXPORT PropertyName: public Node
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(PropertyName)
+
+    PropertyName() { kind = K; }
+
+// attributes
+    SourceLocation propertyNameToken;
+};
+
+class QML_PARSER_EXPORT IdentifierPropertyName: public PropertyName
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(IdentifierPropertyName)
+
+    IdentifierPropertyName(NameId *n):
+        id (n) { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+// attributes
+    NameId *id;
+};
+
+class QML_PARSER_EXPORT StringLiteralPropertyName: public PropertyName
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(StringLiteralPropertyName)
+
+    StringLiteralPropertyName(NameId *n):
+        id (n) { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+// attributes
+    NameId *id;
+};
+
+class QML_PARSER_EXPORT NumericLiteralPropertyName: public PropertyName
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(NumericLiteralPropertyName)
+
+    NumericLiteralPropertyName(double n):
+        id (n) { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+// attributes
+    double id;
+};
+
+class QML_PARSER_EXPORT ArrayMemberExpression: public ExpressionNode
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(ArrayMemberExpression)
+
+    ArrayMemberExpression(ExpressionNode *b, ExpressionNode *e):
+        base (b), expression (e)
+        { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return base->firstSourceLocation(); }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return rbracketToken; }
+
+// attributes
+    ExpressionNode *base;
+    ExpressionNode *expression;
+    SourceLocation lbracketToken;
+    SourceLocation rbracketToken;
+};
+
+class QML_PARSER_EXPORT FieldMemberExpression: public ExpressionNode
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(FieldMemberExpression)
+
+    FieldMemberExpression(ExpressionNode *b, NameId *n):
+        base (b), name (n)
+        { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return base->firstSourceLocation(); }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return identifierToken; }
+
+    // attributes
+    ExpressionNode *base;
+    NameId *name;
+    SourceLocation dotToken;
+    SourceLocation identifierToken;
+};
+
+class QML_PARSER_EXPORT NewMemberExpression: public ExpressionNode
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(NewMemberExpression)
+
+    NewMemberExpression(ExpressionNode *b, ArgumentList *a):
+        base (b), arguments (a)
+        { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return newToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return rparenToken; }
+
+    // attributes
+    ExpressionNode *base;
+    ArgumentList *arguments;
+    SourceLocation newToken;
+    SourceLocation lparenToken;
+    SourceLocation rparenToken;
+};
+
+class QML_PARSER_EXPORT NewExpression: public ExpressionNode
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(NewExpression)
+
+    NewExpression(ExpressionNode *e):
+        expression (e) { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return newToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return expression->lastSourceLocation(); }
+
+// attributes
+    ExpressionNode *expression;
+    SourceLocation newToken;
+};
+
+class QML_PARSER_EXPORT CallExpression: public ExpressionNode
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(CallExpression)
+
+    CallExpression(ExpressionNode *b, ArgumentList *a):
+        base (b), arguments (a)
+        { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return base->firstSourceLocation(); }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return rparenToken; }
+
+// attributes
+    ExpressionNode *base;
+    ArgumentList *arguments;
+    SourceLocation lparenToken;
+    SourceLocation rparenToken;
+};
+
+class QML_PARSER_EXPORT ArgumentList: public Node
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(ArgumentList)
+
+    ArgumentList(ExpressionNode *e):
+        expression (e), next (this)
+        { kind = K; }
+
+    ArgumentList(ArgumentList *previous, ExpressionNode *e):
+        expression (e)
+    {
+        kind = K;
+        next = previous->next;
+        previous->next = this;
+    }
+
+    virtual void accept0(Visitor *visitor);
+
+    inline ArgumentList *finish ()
+    {
+        ArgumentList *front = next;
+        next = 0;
+        return front;
+    }
+
+// attributes
+    ExpressionNode *expression;
+    ArgumentList *next;
+    SourceLocation commaToken;
+};
+
+class QML_PARSER_EXPORT PostIncrementExpression: public ExpressionNode
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(PostIncrementExpression)
+
+    PostIncrementExpression(ExpressionNode *b):
+        base (b) { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return base->firstSourceLocation(); }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return incrementToken; }
+
+// attributes
+    ExpressionNode *base;
+    SourceLocation incrementToken;
+};
+
+class QML_PARSER_EXPORT PostDecrementExpression: public ExpressionNode
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(PostDecrementExpression)
+
+    PostDecrementExpression(ExpressionNode *b):
+        base (b) { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return base->firstSourceLocation(); }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return decrementToken; }
+
+// attributes
+    ExpressionNode *base;
+    SourceLocation decrementToken;
+};
+
+class QML_PARSER_EXPORT DeleteExpression: public ExpressionNode
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(DeleteExpression)
+
+    DeleteExpression(ExpressionNode *e):
+        expression (e) { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return deleteToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return expression->lastSourceLocation(); }
+
+// attributes
+    ExpressionNode *expression;
+    SourceLocation deleteToken;
+};
+
+class QML_PARSER_EXPORT VoidExpression: public ExpressionNode
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(VoidExpression)
+
+    VoidExpression(ExpressionNode *e):
+        expression (e) { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return voidToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return expression->lastSourceLocation(); }
+
+// attributes
+    ExpressionNode *expression;
+    SourceLocation voidToken;
+};
+
+class QML_PARSER_EXPORT TypeOfExpression: public ExpressionNode
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(TypeOfExpression)
+
+    TypeOfExpression(ExpressionNode *e):
+        expression (e) { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return typeofToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return expression->lastSourceLocation(); }
+
+// attributes
+    ExpressionNode *expression;
+    SourceLocation typeofToken;
+};
+
+class QML_PARSER_EXPORT PreIncrementExpression: public ExpressionNode
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(PreIncrementExpression)
+
+    PreIncrementExpression(ExpressionNode *e):
+        expression (e) { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return incrementToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return expression->lastSourceLocation(); }
+
+// attributes
+    ExpressionNode *expression;
+    SourceLocation incrementToken;
+};
+
+class QML_PARSER_EXPORT PreDecrementExpression: public ExpressionNode
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(PreDecrementExpression)
+
+    PreDecrementExpression(ExpressionNode *e):
+        expression (e) { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return decrementToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return expression->lastSourceLocation(); }
+
+// attributes
+    ExpressionNode *expression;
+    SourceLocation decrementToken;
+};
+
+class QML_PARSER_EXPORT UnaryPlusExpression: public ExpressionNode
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(UnaryPlusExpression)
+
+    UnaryPlusExpression(ExpressionNode *e):
+        expression (e) { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return plusToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return expression->lastSourceLocation(); }
+
+// attributes
+    ExpressionNode *expression;
+    SourceLocation plusToken;
+};
+
+class QML_PARSER_EXPORT UnaryMinusExpression: public ExpressionNode
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(UnaryMinusExpression)
+
+    UnaryMinusExpression(ExpressionNode *e):
+        expression (e) { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return minusToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return expression->lastSourceLocation(); }
+
+// attributes
+    ExpressionNode *expression;
+    SourceLocation minusToken;
+};
+
+class QML_PARSER_EXPORT TildeExpression: public ExpressionNode
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(TildeExpression)
+
+    TildeExpression(ExpressionNode *e):
+        expression (e) { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return tildeToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return expression->lastSourceLocation(); }
+
+// attributes
+    ExpressionNode *expression;
+    SourceLocation tildeToken;
+};
+
+class QML_PARSER_EXPORT NotExpression: public ExpressionNode
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(NotExpression)
+
+    NotExpression(ExpressionNode *e):
+        expression (e) { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return notToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return expression->lastSourceLocation(); }
+
+// attributes
+    ExpressionNode *expression;
+    SourceLocation notToken;
+};
+
+class QML_PARSER_EXPORT BinaryExpression: public ExpressionNode
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(BinaryExpression)
+
+    BinaryExpression(ExpressionNode *l, int o, ExpressionNode *r):
+        left (l), op (o), right (r)
+        { kind = K; }
+
+    virtual BinaryExpression *binaryExpressionCast();
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return left->firstSourceLocation(); }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return right->lastSourceLocation(); }
+
+// attributes
+    ExpressionNode *left;
+    int op;
+    ExpressionNode *right;
+    SourceLocation operatorToken;
+};
+
+class QML_PARSER_EXPORT ConditionalExpression: public ExpressionNode
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(ConditionalExpression)
+
+    ConditionalExpression(ExpressionNode *e, ExpressionNode *t, ExpressionNode *f):
+        expression (e), ok (t), ko (f)
+        { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return expression->firstSourceLocation(); }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return ko->lastSourceLocation(); }
+
+// attributes
+    ExpressionNode *expression;
+    ExpressionNode *ok;
+    ExpressionNode *ko;
+    SourceLocation questionToken;
+    SourceLocation colonToken;
+};
+
+class QML_PARSER_EXPORT Expression: public ExpressionNode // ### rename
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(Expression)
+
+    Expression(ExpressionNode *l, ExpressionNode *r):
+        left (l), right (r) { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return left->firstSourceLocation(); }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return right->lastSourceLocation(); }
+
+// attributes
+    ExpressionNode *left;
+    ExpressionNode *right;
+    SourceLocation commaToken;
+};
+
+class QML_PARSER_EXPORT Block: public Statement
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(Block)
+
+    Block(StatementList *slist):
+        statements (slist) { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return lbraceToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return rbraceToken; }
+
+    // attributes
+    StatementList *statements;
+    SourceLocation lbraceToken;
+    SourceLocation rbraceToken;
+};
+
+class QML_PARSER_EXPORT StatementList: public Node
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(StatementList)
+
+    StatementList(Statement *stmt):
+        statement (stmt), next (this)
+        { kind = K; }
+
+    StatementList(StatementList *previous, Statement *stmt):
+        statement (stmt)
+    {
+        kind = K;
+        next = previous->next;
+        previous->next = this;
+    }
+
+    virtual void accept0(Visitor *visitor);
+
+    inline StatementList *finish ()
+    {
+        StatementList *front = next;
+        next = 0;
+        return front;
+    }
+
+// attributes
+    Statement *statement;
+    StatementList *next;
+};
+
+class QML_PARSER_EXPORT VariableStatement: public Statement
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(VariableStatement)
+
+    VariableStatement(VariableDeclarationList *vlist):
+        declarations (vlist)
+        { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return declarationKindToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return semicolonToken; }
+
+// attributes
+    VariableDeclarationList *declarations;
+    SourceLocation declarationKindToken;
+    SourceLocation semicolonToken;
+};
+
+class QML_PARSER_EXPORT VariableDeclaration: public Node
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(VariableDeclaration)
+
+    VariableDeclaration(NameId *n, ExpressionNode *e):
+        name (n), expression (e), readOnly(false)
+        { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+// attributes
+    NameId *name;
+    ExpressionNode *expression;
+    bool readOnly;
+    SourceLocation identifierToken;
+};
+
+class QML_PARSER_EXPORT VariableDeclarationList: public Node
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(VariableDeclarationList)
+
+    VariableDeclarationList(VariableDeclaration *decl):
+        declaration (decl), next (this)
+        { kind = K; }
+
+    VariableDeclarationList(VariableDeclarationList *previous, VariableDeclaration *decl):
+        declaration (decl)
+    {
+        kind = K;
+        next = previous->next;
+        previous->next = this;
+    }
+
+    virtual void accept0(Visitor *visitor);
+
+    inline VariableDeclarationList *finish (bool readOnly)
+    {
+        VariableDeclarationList *front = next;
+        next = 0;
+        if (readOnly) {
+            VariableDeclarationList *vdl;
+            for (vdl = front; vdl != 0; vdl = vdl->next)
+                vdl->declaration->readOnly = true;
+        }
+        return front;
+    }
+
+// attributes
+    VariableDeclaration *declaration;
+    VariableDeclarationList *next;
+    SourceLocation commaToken;
+};
+
+class QML_PARSER_EXPORT EmptyStatement: public Statement
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(EmptyStatement)
+
+    EmptyStatement() { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return semicolonToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return semicolonToken; }
+
+// attributes
+    SourceLocation semicolonToken;
+};
+
+class QML_PARSER_EXPORT ExpressionStatement: public Statement
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(ExpressionStatement)
+
+    ExpressionStatement(ExpressionNode *e):
+        expression (e) { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return expression->firstSourceLocation(); }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return semicolonToken; }
+
+// attributes
+    ExpressionNode *expression;
+    SourceLocation semicolonToken;
+};
+
+class QML_PARSER_EXPORT IfStatement: public Statement
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(IfStatement)
+
+    IfStatement(ExpressionNode *e, Statement *t, Statement *f = 0):
+        expression (e), ok (t), ko (f)
+        { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return ifToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    {
+        if (ko)
+            return ko->lastSourceLocation();
+
+        return ok->lastSourceLocation();
+    }
+
+// attributes
+    ExpressionNode *expression;
+    Statement *ok;
+    Statement *ko;
+    SourceLocation ifToken;
+    SourceLocation lparenToken;
+    SourceLocation rparenToken;
+    SourceLocation elseToken;
+};
+
+class QML_PARSER_EXPORT DoWhileStatement: public Statement
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(DoWhileStatement)
+
+    DoWhileStatement(Statement *stmt, ExpressionNode *e):
+        statement (stmt), expression (e)
+        { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return doToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return semicolonToken; }
+
+// attributes
+    Statement *statement;
+    ExpressionNode *expression;
+    SourceLocation doToken;
+    SourceLocation whileToken;
+    SourceLocation lparenToken;
+    SourceLocation rparenToken;
+    SourceLocation semicolonToken;
+};
+
+class QML_PARSER_EXPORT WhileStatement: public Statement
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(WhileStatement)
+
+    WhileStatement(ExpressionNode *e, Statement *stmt):
+        expression (e), statement (stmt)
+        { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return whileToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return statement->lastSourceLocation(); }
+
+// attributes
+    ExpressionNode *expression;
+    Statement *statement;
+    SourceLocation whileToken;
+    SourceLocation lparenToken;
+    SourceLocation rparenToken;
+};
+
+class QML_PARSER_EXPORT ForStatement: public Statement
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(ForStatement)
+
+    ForStatement(ExpressionNode *i, ExpressionNode *c, ExpressionNode *e, Statement *stmt):
+        initialiser (i), condition (c), expression (e), statement (stmt)
+        { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return forToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return statement->lastSourceLocation(); }
+
+// attributes
+    ExpressionNode *initialiser;
+    ExpressionNode *condition;
+    ExpressionNode *expression;
+    Statement *statement;
+    SourceLocation forToken;
+    SourceLocation lparenToken;
+    SourceLocation firstSemicolonToken;
+    SourceLocation secondSemicolonToken;
+    SourceLocation rparenToken;
+};
+
+class QML_PARSER_EXPORT LocalForStatement: public Statement
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(LocalForStatement)
+
+    LocalForStatement(VariableDeclarationList *vlist, ExpressionNode *c, ExpressionNode *e, Statement *stmt):
+        declarations (vlist), condition (c), expression (e), statement (stmt)
+        { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return forToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return statement->lastSourceLocation(); }
+
+// attributes
+    VariableDeclarationList *declarations;
+    ExpressionNode *condition;
+    ExpressionNode *expression;
+    Statement *statement;
+    SourceLocation forToken;
+    SourceLocation lparenToken;
+    SourceLocation varToken;
+    SourceLocation firstSemicolonToken;
+    SourceLocation secondSemicolonToken;
+    SourceLocation rparenToken;
+};
+
+class QML_PARSER_EXPORT ForEachStatement: public Statement
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(ForEachStatement)
+
+    ForEachStatement(ExpressionNode *i, ExpressionNode *e, Statement *stmt):
+        initialiser (i), expression (e), statement (stmt)
+        { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return forToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return statement->lastSourceLocation(); }
+
+// attributes
+    ExpressionNode *initialiser;
+    ExpressionNode *expression;
+    Statement *statement;
+    SourceLocation forToken;
+    SourceLocation lparenToken;
+    SourceLocation inToken;
+    SourceLocation rparenToken;
+};
+
+class QML_PARSER_EXPORT LocalForEachStatement: public Statement
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(LocalForEachStatement)
+
+    LocalForEachStatement(VariableDeclaration *v, ExpressionNode *e, Statement *stmt):
+        declaration (v), expression (e), statement (stmt)
+        { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return forToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return statement->lastSourceLocation(); }
+
+// attributes
+    VariableDeclaration *declaration;
+    ExpressionNode *expression;
+    Statement *statement;
+    SourceLocation forToken;
+    SourceLocation lparenToken;
+    SourceLocation varToken;
+    SourceLocation inToken;
+    SourceLocation rparenToken;
+};
+
+class QML_PARSER_EXPORT ContinueStatement: public Statement
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(ContinueStatement)
+
+    ContinueStatement(NameId *l = 0):
+        label (l) { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return continueToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return semicolonToken; }
+
+// attributes
+    NameId *label;
+    SourceLocation continueToken;
+    SourceLocation identifierToken;
+    SourceLocation semicolonToken;
+};
+
+class QML_PARSER_EXPORT BreakStatement: public Statement
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(BreakStatement)
+
+    BreakStatement(NameId *l = 0):
+        label (l) { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return breakToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return semicolonToken; }
+
+    // attributes
+    NameId *label;
+    SourceLocation breakToken;
+    SourceLocation identifierToken;
+    SourceLocation semicolonToken;
+};
+
+class QML_PARSER_EXPORT ReturnStatement: public Statement
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(ReturnStatement)
+
+    ReturnStatement(ExpressionNode *e):
+        expression (e) { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return returnToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return semicolonToken; }
+
+// attributes
+    ExpressionNode *expression;
+    SourceLocation returnToken;
+    SourceLocation semicolonToken;
+};
+
+class QML_PARSER_EXPORT WithStatement: public Statement
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(WithStatement)
+
+    WithStatement(ExpressionNode *e, Statement *stmt):
+        expression (e), statement (stmt)
+        { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return withToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return statement->lastSourceLocation(); }
+
+// attributes
+    ExpressionNode *expression;
+    Statement *statement;
+    SourceLocation withToken;
+    SourceLocation lparenToken;
+    SourceLocation rparenToken;
+};
+
+class QML_PARSER_EXPORT CaseBlock: public Node
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(CaseBlock)
+
+    CaseBlock(CaseClauses *c, DefaultClause *d = 0, CaseClauses *r = 0):
+        clauses (c), defaultClause (d), moreClauses (r)
+        { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+// attributes
+    CaseClauses *clauses;
+    DefaultClause *defaultClause;
+    CaseClauses *moreClauses;
+    SourceLocation lbraceToken;
+    SourceLocation rbraceToken;
+};
+
+class QML_PARSER_EXPORT SwitchStatement: public Statement
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(SwitchStatement)
+
+    SwitchStatement(ExpressionNode *e, CaseBlock *b):
+        expression (e), block (b)
+        { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return switchToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return block->rbraceToken; }
+
+// attributes
+    ExpressionNode *expression;
+    CaseBlock *block;
+    SourceLocation switchToken;
+    SourceLocation lparenToken;
+    SourceLocation rparenToken;
+};
+
+class QML_PARSER_EXPORT CaseClauses: public Node
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(CaseClauses)
+
+    CaseClauses(CaseClause *c):
+        clause (c), next (this)
+        { kind = K; }
+
+    CaseClauses(CaseClauses *previous, CaseClause *c):
+        clause (c)
+    {
+        kind = K;
+        next = previous->next;
+        previous->next = this;
+    }
+
+    virtual void accept0(Visitor *visitor);
+
+    inline CaseClauses *finish ()
+    {
+        CaseClauses *front = next;
+        next = 0;
+        return front;
+    }
+
+//attributes
+    CaseClause *clause;
+    CaseClauses *next;
+};
+
+class QML_PARSER_EXPORT CaseClause: public Node
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(CaseClause)
+
+    CaseClause(ExpressionNode *e, StatementList *slist):
+        expression (e), statements (slist)
+        { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+// attributes
+    ExpressionNode *expression;
+    StatementList *statements;
+    SourceLocation caseToken;
+    SourceLocation colonToken;
+};
+
+class QML_PARSER_EXPORT DefaultClause: public Node
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(DefaultClause)
+
+    DefaultClause(StatementList *slist):
+        statements (slist)
+        { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+// attributes
+    StatementList *statements;
+    SourceLocation defaultToken;
+    SourceLocation colonToken;
+};
+
+class QML_PARSER_EXPORT LabelledStatement: public Statement
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(LabelledStatement)
+
+    LabelledStatement(NameId *l, Statement *stmt):
+        label (l), statement (stmt)
+        { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return identifierToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return statement->lastSourceLocation(); }
+
+// attributes
+    NameId *label;
+    Statement *statement;
+    SourceLocation identifierToken;
+    SourceLocation colonToken;
+};
+
+class QML_PARSER_EXPORT ThrowStatement: public Statement
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(ThrowStatement)
+
+    ThrowStatement(ExpressionNode *e):
+        expression (e) { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return throwToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return semicolonToken; }
+
+    // attributes
+    ExpressionNode *expression;
+    SourceLocation throwToken;
+    SourceLocation semicolonToken;
+};
+
+class QML_PARSER_EXPORT Catch: public Node
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(Catch)
+
+    Catch(NameId *n, Block *stmt):
+        name (n), statement (stmt)
+        { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+// attributes
+    NameId *name;
+    Block *statement;
+    SourceLocation catchToken;
+    SourceLocation lparenToken;
+    SourceLocation identifierToken;
+    SourceLocation rparenToken;
+};
+
+class QML_PARSER_EXPORT Finally: public Node
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(Finally)
+
+    Finally(Block *stmt):
+        statement (stmt)
+        { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+// attributes
+    Block *statement;
+    SourceLocation finallyToken;
+};
+
+class QML_PARSER_EXPORT TryStatement: public Statement
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(TryStatement)
+
+    TryStatement(Statement *stmt, Catch *c, Finally *f):
+        statement (stmt), catchExpression (c), finallyExpression (f)
+        { kind = K; }
+
+    TryStatement(Statement *stmt, Finally *f):
+        statement (stmt), catchExpression (0), finallyExpression (f)
+        { kind = K; }
+
+    TryStatement(Statement *stmt, Catch *c):
+        statement (stmt), catchExpression (c), finallyExpression (0)
+        { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return tryToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    {
+        if (finallyExpression)
+            return finallyExpression->statement->rbraceToken;
+        else if (catchExpression)
+            return catchExpression->statement->rbraceToken;
+
+        return statement->lastSourceLocation();
+    }
+
+// attributes
+    Statement *statement;
+    Catch *catchExpression;
+    Finally *finallyExpression;
+    SourceLocation tryToken;
+};
+
+class QML_PARSER_EXPORT FunctionExpression: public ExpressionNode
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(FunctionExpression)
+
+    FunctionExpression(NameId *n, FormalParameterList *f, FunctionBody *b):
+        name (n), formals (f), body (b)
+        { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return functionToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return rbraceToken; }
+
+// attributes
+    NameId *name;
+    FormalParameterList *formals;
+    FunctionBody *body;
+    SourceLocation functionToken;
+    SourceLocation identifierToken;
+    SourceLocation lparenToken;
+    SourceLocation rparenToken;
+    SourceLocation lbraceToken;
+    SourceLocation rbraceToken;
+};
+
+class QML_PARSER_EXPORT FunctionDeclaration: public FunctionExpression
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(FunctionDeclaration)
+
+    FunctionDeclaration(NameId *n, FormalParameterList *f, FunctionBody *b):
+        FunctionExpression(n, f, b)
+        { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+};
+
+class QML_PARSER_EXPORT FormalParameterList: public Node
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(FormalParameterList)
+
+    FormalParameterList(NameId *n):
+        name (n), next (this)
+        { kind = K; }
+
+    FormalParameterList(FormalParameterList *previous, NameId *n):
+        name (n)
+    {
+        kind = K;
+        next = previous->next;
+        previous->next = this;
+    }
+
+    virtual void accept0(Visitor *visitor);
+
+    inline FormalParameterList *finish ()
+    {
+        FormalParameterList *front = next;
+        next = 0;
+        return front;
+    }
+
+// attributes
+    NameId *name;
+    FormalParameterList *next;
+    SourceLocation commaToken;
+    SourceLocation identifierToken;
+};
+
+class QML_PARSER_EXPORT FunctionBody: public Node
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(FunctionBody)
+
+    FunctionBody(SourceElements *elts):
+        elements (elts)
+        { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+// attributes
+    SourceElements *elements;
+};
+
+class QML_PARSER_EXPORT Program: public Node
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(Program)
+
+    Program(SourceElements *elts):
+        elements (elts)
+        { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+// attributes
+    SourceElements *elements;
+};
+
+class QML_PARSER_EXPORT SourceElements: public Node
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(SourceElements)
+
+    SourceElements(SourceElement *elt):
+        element (elt), next (this)
+        { kind = K; }
+
+    SourceElements(SourceElements *previous, SourceElement *elt):
+        element (elt)
+    {
+        kind = K;
+        next = previous->next;
+        previous->next = this;
+    }
+
+    virtual void accept0(Visitor *visitor);
+
+    inline SourceElements *finish ()
+    {
+        SourceElements *front = next;
+        next = 0;
+        return front;
+    }
+
+// attributes
+    SourceElement *element;
+    SourceElements *next;
+};
+
+class QML_PARSER_EXPORT SourceElement: public Node
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(SourceElement)
+
+    inline SourceElement()
+        { kind = K; }
+};
+
+class QML_PARSER_EXPORT FunctionSourceElement: public SourceElement
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(FunctionSourceElement)
+
+    FunctionSourceElement(FunctionDeclaration *f):
+        declaration (f)
+        { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+// attributes
+    FunctionDeclaration *declaration;
+};
+
+class QML_PARSER_EXPORT StatementSourceElement: public SourceElement
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(StatementSourceElement)
+
+    StatementSourceElement(Statement *stmt):
+        statement (stmt)
+        { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+// attributes
+    Statement *statement;
+};
+
+class QML_PARSER_EXPORT DebuggerStatement: public Statement
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(DebuggerStatement)
+
+    DebuggerStatement()
+        { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual SourceLocation firstSourceLocation() const
+    { return debuggerToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return semicolonToken; }
+
+// attributes
+    SourceLocation debuggerToken;
+    SourceLocation semicolonToken;
+};
+
+class QML_PARSER_EXPORT UiProgram: public Node
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(UiProgram)
+
+    UiProgram(UiImportList *imports, UiObjectMemberList *members)
+        : imports(imports), members(members)
+    { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+// attributes
+    UiImportList *imports;
+    UiObjectMemberList *members;
+};
+
+class QML_PARSER_EXPORT UiQualifiedId: public Node
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(UiQualifiedId)
+
+    UiQualifiedId(NameId *name)
+        : next(this), name(name)
+    { kind = K; }
+
+    UiQualifiedId(UiQualifiedId *previous, NameId *name)
+        : name(name)
+    {
+        kind = K;
+        next = previous->next;
+        previous->next = this;
+    }
+
+    UiQualifiedId *finish()
+    {
+        UiQualifiedId *head = next;
+        next = 0;
+        return head;
+    }
+
+    virtual void accept0(Visitor *visitor);
+
+// attributes
+    UiQualifiedId *next;
+    NameId *name;
+    SourceLocation identifierToken;
+};
+
+class QML_PARSER_EXPORT UiImport: public Node
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(UiImport)
+
+    UiImport(NameId *fileName)
+        : fileName(fileName), importUri(0), importId(0)
+    { kind = K; }
+
+    UiImport(UiQualifiedId *uri)
+        : fileName(0), importUri(uri), importId(0)
+    { kind = K; }
+
+    virtual SourceLocation firstSourceLocation() const
+    { return importToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return semicolonToken; }
+
+    virtual void accept0(Visitor *visitor);
+
+// attributes
+    NameId *fileName;
+    UiQualifiedId *importUri;
+    NameId *importId;
+    SourceLocation importToken;
+    SourceLocation fileNameToken;
+    SourceLocation versionToken;
+    SourceLocation asToken;
+    SourceLocation importIdToken;
+    SourceLocation semicolonToken;
+};
+
+class QML_PARSER_EXPORT UiImportList: public Node
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(UiImportList)
+
+    UiImportList(UiImport *import)
+        : import(import),
+          next(this)
+    { kind = K; }
+
+    UiImportList(UiImportList *previous, UiImport *import)
+        : import(import)
+    {
+        kind = K;
+        next = previous->next;
+        previous->next = this;
+    }
+
+    virtual SourceLocation firstSourceLocation() const
+    {
+        if (import) return import->firstSourceLocation();
+        else return SourceLocation();
+    }
+
+    virtual SourceLocation lastSourceLocation() const
+    {
+        for (const UiImportList *it = this; it; it = it->next)
+            if (!it->next && it->import)
+                return it->import->lastSourceLocation();
+
+        return SourceLocation();
+    }
+
+    UiImportList *finish()
+    {
+        UiImportList *head = next;
+        next = 0;
+        return head;
+    }
+
+    virtual void accept0(Visitor *visitor);
+
+// attributes
+    UiImport *import;
+    UiImportList *next;
+};
+
+class QML_PARSER_EXPORT UiObjectMember: public Node
+{
+public:
+    virtual SourceLocation firstSourceLocation() const = 0;
+    virtual SourceLocation lastSourceLocation() const = 0;
+
+    virtual UiObjectMember *uiObjectMemberCast();
+};
+
+class QML_PARSER_EXPORT UiObjectMemberList: public Node
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(UiObjectMemberList)
+
+    UiObjectMemberList(UiObjectMember *member)
+        : next(this), member(member)
+    { kind = K; }
+
+    UiObjectMemberList(UiObjectMemberList *previous, UiObjectMember *member)
+        : member(member)
+    {
+        kind = K;
+        next = previous->next;
+        previous->next = this;
+    }
+
+    virtual void accept0(Visitor *visitor);
+
+    UiObjectMemberList *finish()
+    {
+        UiObjectMemberList *head = next;
+        next = 0;
+        return head;
+    }
+
+// attributes
+    UiObjectMemberList *next;
+    UiObjectMember *member;
+};
+
+class QML_PARSER_EXPORT UiArrayMemberList: public Node
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(UiArrayMemberList)
+
+    UiArrayMemberList(UiObjectMember *member)
+        : next(this), member(member)
+    { kind = K; }
+
+    UiArrayMemberList(UiArrayMemberList *previous, UiObjectMember *member)
+        : member(member)
+    {
+        kind = K;
+        next = previous->next;
+        previous->next = this;
+    }
+
+    virtual void accept0(Visitor *visitor);
+
+    UiArrayMemberList *finish()
+    {
+        UiArrayMemberList *head = next;
+        next = 0;
+        return head;
+    }
+
+// attributes
+    UiArrayMemberList *next;
+    UiObjectMember *member;
+    SourceLocation commaToken;
+};
+
+class QML_PARSER_EXPORT UiObjectInitializer: public Node
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(UiObjectInitializer)
+
+    UiObjectInitializer(UiObjectMemberList *members)
+        : members(members)
+    { kind = K; }
+
+    virtual void accept0(Visitor *visitor);
+
+// attributes
+    SourceLocation lbraceToken;
+    UiObjectMemberList *members;
+    SourceLocation rbraceToken;
+};
+
+class QML_PARSER_EXPORT UiParameterList: public Node
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(UiParameterList)
+
+    UiParameterList(NameId *t, NameId *n):
+        type (t), name (n), next (this)
+        { kind = K; }
+
+    UiParameterList(UiParameterList *previous, NameId *t, NameId *n):
+        type (t), name (n)
+    {
+        kind = K;
+        next = previous->next;
+        previous->next = this;
+    }
+
+    virtual void accept0(Visitor *) {}
+
+    inline UiParameterList *finish ()
+    {
+        UiParameterList *front = next;
+        next = 0;
+        return front;
+    }
+
+// attributes
+    NameId *type;
+    NameId *name;
+    UiParameterList *next;
+    SourceLocation commaToken;
+    SourceLocation identifierToken;
+};
+
+class QML_PARSER_EXPORT UiPublicMember: public UiObjectMember
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(UiPublicMember)
+
+    UiPublicMember(NameId *memberType,
+                   NameId *name)
+        : type(Property), typeModifier(0), memberType(memberType), name(name), expression(0), binding(0), isDefaultMember(false), isReadonlyMember(false), parameters(0)
+    { kind = K; }
+
+    UiPublicMember(NameId *memberType,
+                   NameId *name,
+                   ExpressionNode *expression)
+        : type(Property), typeModifier(0), memberType(memberType), name(name), expression(expression), binding(0), isDefaultMember(false), isReadonlyMember(false), parameters(0)
+    { kind = K; }
+
+    virtual SourceLocation firstSourceLocation() const
+    {
+      if (defaultToken.isValid())
+        return defaultToken;
+      else if (readonlyToken.isValid())
+          return readonlyToken;
+
+      return propertyToken;
+    }
+
+    virtual SourceLocation lastSourceLocation() const
+    {
+      if (binding)
+          return binding->lastSourceLocation();
+
+      return semicolonToken;
+    }
+
+    virtual void accept0(Visitor *visitor);
+
+// attributes
+    enum { Signal, Property } type;
+    NameId *typeModifier;
+    NameId *memberType;
+    NameId *name;
+    ExpressionNode *expression; // initialized with a JS expression
+    UiObjectMember *binding; // initialized with a QML object or array.
+    bool isDefaultMember;
+    bool isReadonlyMember;
+    UiParameterList *parameters;
+    SourceLocation defaultToken;
+    SourceLocation readonlyToken;
+    SourceLocation propertyToken;
+    SourceLocation typeModifierToken;
+    SourceLocation typeToken;
+    SourceLocation identifierToken;
+    SourceLocation colonToken;
+    SourceLocation semicolonToken;
+};
+
+class QML_PARSER_EXPORT UiObjectDefinition: public UiObjectMember
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(UiObjectDefinition)
+
+    UiObjectDefinition(UiQualifiedId *qualifiedTypeNameId,
+                       UiObjectInitializer *initializer)
+        : qualifiedTypeNameId(qualifiedTypeNameId), initializer(initializer)
+    { kind = K; }
+
+    virtual SourceLocation firstSourceLocation() const
+    { return qualifiedTypeNameId->identifierToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return initializer->rbraceToken; }
+
+    virtual void accept0(Visitor *visitor);
+
+// attributes
+    UiQualifiedId *qualifiedTypeNameId;
+    UiObjectInitializer *initializer;
+};
+
+class QML_PARSER_EXPORT UiSourceElement: public UiObjectMember
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(UiSourceElement)
+
+    UiSourceElement(Node *sourceElement)
+        : sourceElement(sourceElement)
+    { kind = K; }
+
+    virtual SourceLocation firstSourceLocation() const
+    {
+      if (FunctionDeclaration *funDecl = cast<FunctionDeclaration *>(sourceElement))
+        return funDecl->firstSourceLocation();
+      else if (VariableStatement *varStmt = cast<VariableStatement *>(sourceElement))
+        return varStmt->firstSourceLocation();
+
+      return SourceLocation();
+    }
+
+    virtual SourceLocation lastSourceLocation() const
+    {
+      if (FunctionDeclaration *funDecl = cast<FunctionDeclaration *>(sourceElement))
+        return funDecl->lastSourceLocation();
+      else if (VariableStatement *varStmt = cast<VariableStatement *>(sourceElement))
+        return varStmt->lastSourceLocation();
+
+      return SourceLocation();
+    }
+
+
+    virtual void accept0(Visitor *visitor);
+
+// attributes
+    Node *sourceElement;
+};
+
+class QML_PARSER_EXPORT UiObjectBinding: public UiObjectMember
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(UiObjectBinding)
+
+    UiObjectBinding(UiQualifiedId *qualifiedId,
+                    UiQualifiedId *qualifiedTypeNameId,
+                    UiObjectInitializer *initializer)
+        : qualifiedId(qualifiedId),
+          qualifiedTypeNameId(qualifiedTypeNameId),
+          initializer(initializer),
+          hasOnToken(false)
+    { kind = K; }
+
+    virtual SourceLocation firstSourceLocation() const
+    {
+        if (hasOnToken && qualifiedTypeNameId)
+            return qualifiedTypeNameId->identifierToken;
+
+        return qualifiedId->identifierToken;
+    }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return initializer->rbraceToken; }
+
+    virtual void accept0(Visitor *visitor);
+
+// attributes
+    UiQualifiedId *qualifiedId;
+    UiQualifiedId *qualifiedTypeNameId;
+    UiObjectInitializer *initializer;
+    SourceLocation colonToken;
+    bool hasOnToken;
+};
+
+class QML_PARSER_EXPORT UiScriptBinding: public UiObjectMember
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(UiScriptBinding)
+
+    UiScriptBinding(UiQualifiedId *qualifiedId,
+                    Statement *statement)
+        : qualifiedId(qualifiedId),
+          statement(statement)
+    { kind = K; }
+
+    virtual SourceLocation firstSourceLocation() const
+    { return qualifiedId->identifierToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return statement->lastSourceLocation(); }
+
+    virtual void accept0(Visitor *visitor);
+
+// attributes
+    UiQualifiedId *qualifiedId;
+    Statement *statement;
+    SourceLocation colonToken;
+};
+
+class QML_PARSER_EXPORT UiArrayBinding: public UiObjectMember
+{
+public:
+    QDECLARATIVEJS_DECLARE_AST_NODE(UiArrayBinding)
+
+    UiArrayBinding(UiQualifiedId *qualifiedId,
+                   UiArrayMemberList *members)
+        : qualifiedId(qualifiedId),
+          members(members)
+    { kind = K; }
+
+    virtual SourceLocation firstSourceLocation() const
+    { return qualifiedId->identifierToken; }
+
+    virtual SourceLocation lastSourceLocation() const
+    { return rbracketToken; }
+
+    virtual void accept0(Visitor *visitor);
+
+// attributes
+    UiQualifiedId *qualifiedId;
+    UiArrayMemberList *members;
+    SourceLocation colonToken;
+    SourceLocation lbracketToken;
+    SourceLocation rbracketToken;
+};
+
+} } // namespace AST
+
+
+
+QT_QML_END_NAMESPACE
+
+#endif
diff --git a/tools/qdoc3/declarativeparser/qdeclarativejsastfwd_p.h b/tools/qdoc3/declarativeparser/qdeclarativejsastfwd_p.h
new file mode 100644
index 0000000..8a20ab2
--- /dev/null
+++ b/tools/qdoc3/declarativeparser/qdeclarativejsastfwd_p.h
@@ -0,0 +1,189 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDECLARATIVEJSAST_FWD_P_H
+#define QDECLARATIVEJSAST_FWD_P_H
+
+#include "private/qdeclarativejsglobal_p.h"
+
+#include <QtCore/qglobal.h>
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+QT_QML_BEGIN_NAMESPACE
+
+namespace QDeclarativeJS { namespace AST {
+
+class SourceLocation
+{
+public:
+    SourceLocation(quint32 offset = 0, quint32 length = 0, quint32 line = 0, quint32 column = 0)
+        : offset(offset), length(length),
+          startLine(line), startColumn(column)
+    { }
+
+    bool isValid() const { return length != 0; }
+
+    quint32 begin() const { return offset; }
+    quint32 end() const { return offset + length; }
+
+// attributes
+    // ### encode
+    quint32 offset;
+    quint32 length;
+    quint32 startLine;
+    quint32 startColumn;
+};
+
+class Visitor;
+class Node;
+class ExpressionNode;
+class Statement;
+class ThisExpression;
+class IdentifierExpression;
+class NullExpression;
+class TrueLiteral;
+class FalseLiteral;
+class NumericLiteral;
+class StringLiteral;
+class RegExpLiteral;
+class ArrayLiteral;
+class ObjectLiteral;
+class ElementList;
+class Elision;
+class PropertyNameAndValueList;
+class PropertyName;
+class IdentifierPropertyName;
+class StringLiteralPropertyName;
+class NumericLiteralPropertyName;
+class ArrayMemberExpression;
+class FieldMemberExpression;
+class NewMemberExpression;
+class NewExpression;
+class CallExpression;
+class ArgumentList;
+class PostIncrementExpression;
+class PostDecrementExpression;
+class DeleteExpression;
+class VoidExpression;
+class TypeOfExpression;
+class PreIncrementExpression;
+class PreDecrementExpression;
+class UnaryPlusExpression;
+class UnaryMinusExpression;
+class TildeExpression;
+class NotExpression;
+class BinaryExpression;
+class ConditionalExpression;
+class Expression; // ### rename
+class Block;
+class StatementList;
+class VariableStatement;
+class VariableDeclarationList;
+class VariableDeclaration;
+class EmptyStatement;
+class ExpressionStatement;
+class IfStatement;
+class DoWhileStatement;
+class WhileStatement;
+class ForStatement;
+class LocalForStatement;
+class ForEachStatement;
+class LocalForEachStatement;
+class ContinueStatement;
+class BreakStatement;
+class ReturnStatement;
+class WithStatement;
+class SwitchStatement;
+class CaseBlock;
+class CaseClauses;
+class CaseClause;
+class DefaultClause;
+class LabelledStatement;
+class ThrowStatement;
+class TryStatement;
+class Catch;
+class Finally;
+class FunctionDeclaration;
+class FunctionExpression;
+class FormalParameterList;
+class FunctionBody;
+class Program;
+class SourceElements;
+class SourceElement;
+class FunctionSourceElement;
+class StatementSourceElement;
+class DebuggerStatement;
+class NestedExpression;
+
+// ui elements
+class UiProgram;
+class UiImportList;
+class UiImport;
+class UiPublicMember;
+class UiObjectDefinition;
+class UiObjectInitializer;
+class UiObjectBinding;
+class UiScriptBinding;
+class UiSourceElement;
+class UiArrayBinding;
+class UiObjectMember;
+class UiObjectMemberList;
+class UiArrayMemberList;
+class UiQualifiedId;
+class UiFormalList;
+class UiFormal;
+class UiSignature;
+
+} } // namespace AST
+
+QT_QML_END_NAMESPACE
+
+#endif
diff --git a/tools/qdoc3/declarativeparser/qdeclarativejsastvisitor.cpp b/tools/qdoc3/declarativeparser/qdeclarativejsastvisitor.cpp
new file mode 100644
index 0000000..8df755a
--- /dev/null
+++ b/tools/qdoc3/declarativeparser/qdeclarativejsastvisitor.cpp
@@ -0,0 +1,58 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "private/qdeclarativejsastvisitor_p.h"
+
+QT_QML_BEGIN_NAMESPACE
+
+namespace QDeclarativeJS { namespace AST {
+
+Visitor::Visitor()
+{
+}
+
+Visitor::~Visitor()
+{
+}
+
+} } // namespace QDeclarativeJS::AST
+
+QT_QML_END_NAMESPACE
diff --git a/tools/qdoc3/declarativeparser/qdeclarativejsastvisitor_p.h b/tools/qdoc3/declarativeparser/qdeclarativejsastvisitor_p.h
new file mode 100644
index 0000000..519b8c8
--- /dev/null
+++ b/tools/qdoc3/declarativeparser/qdeclarativejsastvisitor_p.h
@@ -0,0 +1,335 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDECLARATIVEJSASTVISITOR_P_H
+#define QDECLARATIVEJSASTVISITOR_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "private/qdeclarativejsastfwd_p.h"
+#include "private/qdeclarativejsglobal_p.h"
+
+QT_QML_BEGIN_NAMESPACE
+
+namespace QDeclarativeJS { namespace AST {
+
+class QML_PARSER_EXPORT Visitor
+{
+public:
+    Visitor();
+    virtual ~Visitor();
+
+    virtual bool preVisit(Node *) { return true; }
+    virtual void postVisit(Node *) {}
+
+    // Ui
+    virtual bool visit(UiProgram *) { return true; }
+    virtual bool visit(UiImportList *) { return true; }
+    virtual bool visit(UiImport *) { return true; }
+    virtual bool visit(UiPublicMember *) { return true; }
+    virtual bool visit(UiSourceElement *) { return true; }
+    virtual bool visit(UiObjectDefinition *) { return true; }
+    virtual bool visit(UiObjectInitializer *) { return true; }
+    virtual bool visit(UiObjectBinding *) { return true; }
+    virtual bool visit(UiScriptBinding *) { return true; }
+    virtual bool visit(UiArrayBinding *) { return true; }
+    virtual bool visit(UiObjectMemberList *) { return true; }
+    virtual bool visit(UiArrayMemberList *) { return true; }
+    virtual bool visit(UiQualifiedId *) { return true; }
+    virtual bool visit(UiSignature *) { return true; }
+    virtual bool visit(UiFormalList *) { return true; }
+    virtual bool visit(UiFormal *) { return true; }
+
+    virtual void endVisit(UiProgram *) {}
+    virtual void endVisit(UiImportList *) {}
+    virtual void endVisit(UiImport *) {}
+    virtual void endVisit(UiPublicMember *) {}
+    virtual void endVisit(UiSourceElement *) {}
+    virtual void endVisit(UiObjectDefinition *) {}
+    virtual void endVisit(UiObjectInitializer *) {}
+    virtual void endVisit(UiObjectBinding *) {}
+    virtual void endVisit(UiScriptBinding *) {}
+    virtual void endVisit(UiArrayBinding *) {}
+    virtual void endVisit(UiObjectMemberList *) {}
+    virtual void endVisit(UiArrayMemberList *) {}
+    virtual void endVisit(UiQualifiedId *) {}
+    virtual void endVisit(UiSignature *) {}
+    virtual void endVisit(UiFormalList *) {}
+    virtual void endVisit(UiFormal *) {}
+
+    // QDeclarativeJS
+    virtual bool visit(ThisExpression *) { return true; }
+    virtual void endVisit(ThisExpression *) {}
+
+    virtual bool visit(IdentifierExpression *) { return true; }
+    virtual void endVisit(IdentifierExpression *) {}
+
+    virtual bool visit(NullExpression *) { return true; }
+    virtual void endVisit(NullExpression *) {}
+
+    virtual bool visit(TrueLiteral *) { return true; }
+    virtual void endVisit(TrueLiteral *) {}
+
+    virtual bool visit(FalseLiteral *) { return true; }
+    virtual void endVisit(FalseLiteral *) {}
+
+    virtual bool visit(StringLiteral *) { return true; }
+    virtual void endVisit(StringLiteral *) {}
+
+    virtual bool visit(NumericLiteral *) { return true; }
+    virtual void endVisit(NumericLiteral *) {}
+
+    virtual bool visit(RegExpLiteral *) { return true; }
+    virtual void endVisit(RegExpLiteral *) {}
+
+    virtual bool visit(ArrayLiteral *) { return true; }
+    virtual void endVisit(ArrayLiteral *) {}
+
+    virtual bool visit(ObjectLiteral *) { return true; }
+    virtual void endVisit(ObjectLiteral *) {}
+
+    virtual bool visit(ElementList *) { return true; }
+    virtual void endVisit(ElementList *) {}
+
+    virtual bool visit(Elision *) { return true; }
+    virtual void endVisit(Elision *) {}
+
+    virtual bool visit(PropertyNameAndValueList *) { return true; }
+    virtual void endVisit(PropertyNameAndValueList *) {}
+
+    virtual bool visit(NestedExpression *) { return true; }
+    virtual void endVisit(NestedExpression *) {}
+
+    virtual bool visit(IdentifierPropertyName *) { return true; }
+    virtual void endVisit(IdentifierPropertyName *) {}
+
+    virtual bool visit(StringLiteralPropertyName *) { return true; }
+    virtual void endVisit(StringLiteralPropertyName *) {}
+
+    virtual bool visit(NumericLiteralPropertyName *) { return true; }
+    virtual void endVisit(NumericLiteralPropertyName *) {}
+
+    virtual bool visit(ArrayMemberExpression *) { return true; }
+    virtual void endVisit(ArrayMemberExpression *) {}
+
+    virtual bool visit(FieldMemberExpression *) { return true; }
+    virtual void endVisit(FieldMemberExpression *) {}
+
+    virtual bool visit(NewMemberExpression *) { return true; }
+    virtual void endVisit(NewMemberExpression *) {}
+
+    virtual bool visit(NewExpression *) { return true; }
+    virtual void endVisit(NewExpression *) {}
+
+    virtual bool visit(CallExpression *) { return true; }
+    virtual void endVisit(CallExpression *) {}
+
+    virtual bool visit(ArgumentList *) { return true; }
+    virtual void endVisit(ArgumentList *) {}
+
+    virtual bool visit(PostIncrementExpression *) { return true; }
+    virtual void endVisit(PostIncrementExpression *) {}
+
+    virtual bool visit(PostDecrementExpression *) { return true; }
+    virtual void endVisit(PostDecrementExpression *) {}
+
+    virtual bool visit(DeleteExpression *) { return true; }
+    virtual void endVisit(DeleteExpression *) {}
+
+    virtual bool visit(VoidExpression *) { return true; }
+    virtual void endVisit(VoidExpression *) {}
+
+    virtual bool visit(TypeOfExpression *) { return true; }
+    virtual void endVisit(TypeOfExpression *) {}
+
+    virtual bool visit(PreIncrementExpression *) { return true; }
+    virtual void endVisit(PreIncrementExpression *) {}
+
+    virtual bool visit(PreDecrementExpression *) { return true; }
+    virtual void endVisit(PreDecrementExpression *) {}
+
+    virtual bool visit(UnaryPlusExpression *) { return true; }
+    virtual void endVisit(UnaryPlusExpression *) {}
+
+    virtual bool visit(UnaryMinusExpression *) { return true; }
+    virtual void endVisit(UnaryMinusExpression *) {}
+
+    virtual bool visit(TildeExpression *) { return true; }
+    virtual void endVisit(TildeExpression *) {}
+
+    virtual bool visit(NotExpression *) { return true; }
+    virtual void endVisit(NotExpression *) {}
+
+    virtual bool visit(BinaryExpression *) { return true; }
+    virtual void endVisit(BinaryExpression *) {}
+
+    virtual bool visit(ConditionalExpression *) { return true; }
+    virtual void endVisit(ConditionalExpression *) {}
+
+    virtual bool visit(Expression *) { return true; }
+    virtual void endVisit(Expression *) {}
+
+    virtual bool visit(Block *) { return true; }
+    virtual void endVisit(Block *) {}
+
+    virtual bool visit(StatementList *) { return true; }
+    virtual void endVisit(StatementList *) {}
+
+    virtual bool visit(VariableStatement *) { return true; }
+    virtual void endVisit(VariableStatement *) {}
+
+    virtual bool visit(VariableDeclarationList *) { return true; }
+    virtual void endVisit(VariableDeclarationList *) {}
+
+    virtual bool visit(VariableDeclaration *) { return true; }
+    virtual void endVisit(VariableDeclaration *) {}
+
+    virtual bool visit(EmptyStatement *) { return true; }
+    virtual void endVisit(EmptyStatement *) {}
+
+    virtual bool visit(ExpressionStatement *) { return true; }
+    virtual void endVisit(ExpressionStatement *) {}
+
+    virtual bool visit(IfStatement *) { return true; }
+    virtual void endVisit(IfStatement *) {}
+
+    virtual bool visit(DoWhileStatement *) { return true; }
+    virtual void endVisit(DoWhileStatement *) {}
+
+    virtual bool visit(WhileStatement *) { return true; }
+    virtual void endVisit(WhileStatement *) {}
+
+    virtual bool visit(ForStatement *) { return true; }
+    virtual void endVisit(ForStatement *) {}
+
+    virtual bool visit(LocalForStatement *) { return true; }
+    virtual void endVisit(LocalForStatement *) {}
+
+    virtual bool visit(ForEachStatement *) { return true; }
+    virtual void endVisit(ForEachStatement *) {}
+
+    virtual bool visit(LocalForEachStatement *) { return true; }
+    virtual void endVisit(LocalForEachStatement *) {}
+
+    virtual bool visit(ContinueStatement *) { return true; }
+    virtual void endVisit(ContinueStatement *) {}
+
+    virtual bool visit(BreakStatement *) { return true; }
+    virtual void endVisit(BreakStatement *) {}
+
+    virtual bool visit(ReturnStatement *) { return true; }
+    virtual void endVisit(ReturnStatement *) {}
+
+    virtual bool visit(WithStatement *) { return true; }
+    virtual void endVisit(WithStatement *) {}
+
+    virtual bool visit(SwitchStatement *) { return true; }
+    virtual void endVisit(SwitchStatement *) {}
+
+    virtual bool visit(CaseBlock *) { return true; }
+    virtual void endVisit(CaseBlock *) {}
+
+    virtual bool visit(CaseClauses *) { return true; }
+    virtual void endVisit(CaseClauses *) {}
+
+    virtual bool visit(CaseClause *) { return true; }
+    virtual void endVisit(CaseClause *) {}
+
+    virtual bool visit(DefaultClause *) { return true; }
+    virtual void endVisit(DefaultClause *) {}
+
+    virtual bool visit(LabelledStatement *) { return true; }
+    virtual void endVisit(LabelledStatement *) {}
+
+    virtual bool visit(ThrowStatement *) { return true; }
+    virtual void endVisit(ThrowStatement *) {}
+
+    virtual bool visit(TryStatement *) { return true; }
+    virtual void endVisit(TryStatement *) {}
+
+    virtual bool visit(Catch *) { return true; }
+    virtual void endVisit(Catch *) {}
+
+    virtual bool visit(Finally *) { return true; }
+    virtual void endVisit(Finally *) {}
+
+    virtual bool visit(FunctionDeclaration *) { return true; }
+    virtual void endVisit(FunctionDeclaration *) {}
+
+    virtual bool visit(FunctionExpression *) { return true; }
+    virtual void endVisit(FunctionExpression *) {}
+
+    virtual bool visit(FormalParameterList *) { return true; }
+    virtual void endVisit(FormalParameterList *) {}
+
+    virtual bool visit(FunctionBody *) { return true; }
+    virtual void endVisit(FunctionBody *) {}
+
+    virtual bool visit(Program *) { return true; }
+    virtual void endVisit(Program *) {}
+
+    virtual bool visit(SourceElements *) { return true; }
+    virtual void endVisit(SourceElements *) {}
+
+    virtual bool visit(FunctionSourceElement *) { return true; }
+    virtual void endVisit(FunctionSourceElement *) {}
+
+    virtual bool visit(StatementSourceElement *) { return true; }
+    virtual void endVisit(StatementSourceElement *) {}
+
+    virtual bool visit(DebuggerStatement *) { return true; }
+    virtual void endVisit(DebuggerStatement *) {}
+};
+
+} } // namespace AST
+
+QT_QML_END_NAMESPACE
+
+#endif // QDECLARATIVEJSASTVISITOR_P_H
diff --git a/tools/qdoc3/declarativeparser/qdeclarativejsengine_p.cpp b/tools/qdoc3/declarativeparser/qdeclarativejsengine_p.cpp
new file mode 100644
index 0000000..ec9271a
--- /dev/null
+++ b/tools/qdoc3/declarativeparser/qdeclarativejsengine_p.cpp
@@ -0,0 +1,212 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "private/qdeclarativejsengine_p.h"
+
+#include "private/qdeclarativejsglobal_p.h"
+#include "private/qdeclarativejsnodepool_p.h"
+
+#include <qnumeric.h>
+#include <QHash>
+
+QT_QML_BEGIN_NAMESPACE
+
+namespace QDeclarativeJS {
+
+uint qHash(const QDeclarativeJS::NameId &id)
+{ return qHash(id.asString()); }
+
+QString numberToString(double value)
+{ return QString::number(value); }
+
+int Ecma::RegExp::flagFromChar(const QChar &ch)
+{
+    static QHash<QChar, int> flagsHash;
+    if (flagsHash.isEmpty()) {
+        flagsHash[QLatin1Char('g')] = Global;
+        flagsHash[QLatin1Char('i')] = IgnoreCase;
+        flagsHash[QLatin1Char('m')] = Multiline;
+    }
+    QHash<QChar, int>::const_iterator it;
+    it = flagsHash.constFind(ch);
+    if (it == flagsHash.constEnd())
+        return 0;
+    return it.value();
+}
+
+QString Ecma::RegExp::flagsToString(int flags)
+{
+    QString result;
+    if (flags & Global)
+        result += QLatin1Char('g');
+    if (flags & IgnoreCase)
+        result += QLatin1Char('i');
+    if (flags & Multiline)
+        result += QLatin1Char('m');
+    return result;
+}
+
+NodePool::NodePool(const QString &fileName, Engine *engine)
+    : m_fileName(fileName), m_engine(engine)
+{
+    m_engine->setNodePool(this);
+}
+
+NodePool::~NodePool()
+{
+}
+
+Code *NodePool::createCompiledCode(AST::Node *, CompilationUnit &)
+{
+    Q_ASSERT(0);
+    return 0;
+}
+
+static int toDigit(char c)
+{
+    if ((c >= '0') && (c <= '9'))
+        return c - '0';
+    else if ((c >= 'a') && (c <= 'z'))
+        return 10 + c - 'a';
+    else if ((c >= 'A') && (c <= 'Z'))
+        return 10 + c - 'A';
+    return -1;
+}
+
+double integerFromString(const char *buf, int size, int radix)
+{
+    if (size == 0)
+        return qSNaN();
+
+    double sign = 1.0;
+    int i = 0;
+    if (buf[0] == '+') {
+        ++i;
+    } else if (buf[0] == '-') {
+        sign = -1.0;
+        ++i;
+    }
+
+    if (((size-i) >= 2) && (buf[i] == '0')) {
+        if (((buf[i+1] == 'x') || (buf[i+1] == 'X'))
+            && (radix < 34)) {
+            if ((radix != 0) && (radix != 16))
+                return 0;
+            radix = 16;
+            i += 2;
+        } else {
+            if (radix == 0) {
+                radix = 8;
+                ++i;
+            }
+        }
+    } else if (radix == 0) {
+        radix = 10;
+    }
+
+    int j = i;
+    for ( ; i < size; ++i) {
+        int d = toDigit(buf[i]);
+        if ((d == -1) || (d >= radix))
+            break;
+    }
+    double result;
+    if (j == i) {
+        if (!qstrcmp(buf, "Infinity"))
+            result = qInf();
+        else
+            result = qSNaN();
+    } else {
+        result = 0;
+        double multiplier = 1;
+        for (--i ; i >= j; --i, multiplier *= radix)
+            result += toDigit(buf[i]) * multiplier;
+    }
+    result *= sign;
+    return result;
+}
+
+double integerFromString(const QString &str, int radix)
+{
+    QByteArray ba = str.trimmed().toLatin1();
+    return integerFromString(ba.constData(), ba.size(), radix);
+}
+
+
+Engine::Engine()
+    : _lexer(0), _nodePool(0)
+{ }
+
+Engine::~Engine()
+{ }
+
+QSet<NameId> Engine::literals() const
+{ return _literals; }
+
+void Engine::addComment(int pos, int len, int line, int col)
+{ if (len > 0) _comments.append(QDeclarativeJS::AST::SourceLocation(pos, len, line, col)); }
+
+QList<QDeclarativeJS::AST::SourceLocation> Engine::comments() const
+{ return _comments; }
+
+NameId *Engine::intern(const QChar *u, int s)
+{ return const_cast<NameId *>(&*_literals.insert(NameId(u, s))); }
+
+QString Engine::toString(NameId *id)
+{ return id->asString(); }
+
+Lexer *Engine::lexer() const
+{ return _lexer; }
+
+void Engine::setLexer(Lexer *lexer)
+{ _lexer = lexer; }
+
+NodePool *Engine::nodePool() const
+{ return _nodePool; }
+
+void Engine::setNodePool(NodePool *nodePool)
+{ _nodePool = nodePool; }
+
+
+
+} // end of namespace QDeclarativeJS
+
+QT_QML_END_NAMESPACE
diff --git a/tools/qdoc3/declarativeparser/qdeclarativejsengine_p.h b/tools/qdoc3/declarativeparser/qdeclarativejsengine_p.h
new file mode 100644
index 0000000..6c18b50
--- /dev/null
+++ b/tools/qdoc3/declarativeparser/qdeclarativejsengine_p.h
@@ -0,0 +1,173 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDECLARATIVEJSENGINE_P_H
+#define QDECLARATIVEJSENGINE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "private/qdeclarativejsglobal_p.h"
+#include "private/qdeclarativejsastfwd_p.h"
+
+#include <QString>
+#include <QSet>
+
+QT_QML_BEGIN_NAMESPACE
+
+namespace QDeclarativeJS {
+class QML_PARSER_EXPORT NameId
+{
+    QString _text;
+
+public:
+    NameId(const QChar *u, int s)
+        : _text(u, s)
+    { }
+
+    const QString asString() const
+    { return _text; }
+
+    bool operator == (const NameId &other) const
+    { return _text == other._text; }
+
+    bool operator != (const NameId &other) const
+    { return _text != other._text; }
+
+    bool operator < (const NameId &other) const
+    { return _text < other._text; }
+};
+
+uint qHash(const QDeclarativeJS::NameId &id);
+
+} // end of namespace QDeclarativeJS
+
+#if defined(Q_CC_MSVC) && _MSC_VER <= 1300
+//this ensures that code outside QDeclarativeJS can use the hash function
+//it also a workaround for some compilers
+inline uint qHash(const QDeclarativeJS::NameId &nameId) { return QDeclarativeJS::qHash(nameId); }
+#endif
+
+namespace QDeclarativeJS {
+
+class Lexer;
+class NodePool;
+
+namespace Ecma {
+
+class QML_PARSER_EXPORT RegExp
+{
+public:
+    enum RegExpFlag {
+        Global     = 0x01,
+        IgnoreCase = 0x02,
+        Multiline  = 0x04
+    };
+
+public:
+    static int flagFromChar(const QChar &);
+    static QString flagsToString(int flags);
+};
+
+} // end of namespace Ecma
+
+class QML_PARSER_EXPORT DiagnosticMessage
+{
+public:
+    enum Kind { Warning, Error };
+
+    DiagnosticMessage()
+        : kind(Error) {}
+
+    DiagnosticMessage(Kind kind, const AST::SourceLocation &loc, const QString &message)
+        : kind(kind), loc(loc), message(message) {}
+
+    bool isWarning() const
+    { return kind == Warning; }
+
+    bool isError() const
+    { return kind == Error; }
+
+    Kind kind;
+    AST::SourceLocation loc;
+    QString message;
+};
+
+class QML_PARSER_EXPORT Engine
+{
+    Lexer *_lexer;
+    NodePool *_nodePool;
+    QSet<NameId> _literals;
+    QList<QDeclarativeJS::AST::SourceLocation> _comments;
+
+public:
+    Engine();
+    ~Engine();
+
+    QSet<NameId> literals() const;
+
+    void addComment(int pos, int len, int line, int col);
+    QList<QDeclarativeJS::AST::SourceLocation> comments() const;
+
+    NameId *intern(const QChar *u, int s);
+
+    static QString toString(NameId *id);
+
+    Lexer *lexer() const;
+    void setLexer(Lexer *lexer);
+
+    NodePool *nodePool() const;
+    void setNodePool(NodePool *nodePool);
+};
+
+} // end of namespace QDeclarativeJS
+
+QT_QML_END_NAMESPACE
+
+#endif // QDECLARATIVEJSENGINE_P_H
diff --git a/tools/qdoc3/declarativeparser/qdeclarativejsglobal_p.h b/tools/qdoc3/declarativeparser/qdeclarativejsglobal_p.h
new file mode 100644
index 0000000..776937c
--- /dev/null
+++ b/tools/qdoc3/declarativeparser/qdeclarativejsglobal_p.h
@@ -0,0 +1,64 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#ifndef QDECLARATIVEJSGLOBAL_P_H
+#define QDECLARATIVEJSGLOBAL_P_H
+
+#include <QtCore/qglobal.h>
+
+#ifdef QT_CREATOR
+#  define QT_QML_BEGIN_NAMESPACE
+#  define QT_QML_END_NAMESPACE
+
+#  ifdef QDECLARATIVEJS_BUILD_DIR
+#    define QML_PARSER_EXPORT Q_DECL_EXPORT
+#  elif QML_BUILD_STATIC_LIB
+#    define QML_PARSER_EXPORT
+#  else
+#    define QML_PARSER_EXPORT Q_DECL_IMPORT
+#  endif // QDECLARATIVEJS_BUILD_DIR
+
+#else // !QT_CREATOR
+#  define QT_QML_BEGIN_NAMESPACE QT_BEGIN_NAMESPACE
+#  define QT_QML_END_NAMESPACE QT_END_NAMESPACE
+#  define QML_PARSER_EXPORT
+#endif // QT_CREATOR
+
+#endif // QDECLARATIVEJSGLOBAL_P_H
diff --git a/tools/qdoc3/declarativeparser/qdeclarativejsgrammar.cpp b/tools/qdoc3/declarativeparser/qdeclarativejsgrammar.cpp
new file mode 100644
index 0000000..ea19e1c
--- /dev/null
+++ b/tools/qdoc3/declarativeparser/qdeclarativejsgrammar.cpp
@@ -0,0 +1,989 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+// This file was generated by qlalr - DO NOT EDIT!
+#include "qdeclarativejsgrammar_p.h"
+
+QT_BEGIN_NAMESPACE
+
+const char *const QDeclarativeJSGrammar::spell [] = {
+  "end of file", "&", "&&", "&=", "break", "case", "catch", ":", ";", "continue", 
+  "default", "delete", "/", "/=", "do", ".", "else", "=", "==", "===", 
+  "finally", "for", "function", ">=", ">", ">>", ">>=", ">>>", ">>>=", "identifier", 
+  "if", "in", "instanceof", "{", "[", "<=", "(", "<", "<<", "<<=", 
+  "-", "-=", "--", "new", "!", "!=", "!==", "numeric literal", "|", "|=", 
+  "||", "+", "+=", "++", "?", "}", "]", "%", "%=", "return", 
+  ")", ";", 0, "*", "*=", "string literal", "property", "signal", "readonly", "switch", 
+  "this", "throw", "~", "try", "typeof", "var", "void", "while", "with", "^", 
+  "^=", "null", "true", "false", "const", "debugger", "reserved word", "multiline string literal", "comment", "public", 
+  "import", "as", "on", 0, 0, 0, 0, 0, 0, 0, 
+  0};
+
+const short QDeclarativeJSGrammar::lhs [] = {
+  101, 101, 101, 101, 101, 101, 102, 108, 108, 111, 
+  111, 113, 112, 112, 112, 112, 112, 112, 112, 112, 
+  115, 110, 109, 118, 118, 119, 119, 120, 120, 117, 
+  106, 106, 106, 106, 106, 106, 106, 106, 126, 126, 
+  126, 127, 127, 128, 128, 106, 106, 106, 106, 106, 
+  106, 106, 106, 106, 106, 106, 106, 106, 106, 106, 
+  106, 106, 106, 106, 106, 116, 116, 116, 116, 116, 
+  131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 
+  131, 131, 131, 131, 131, 131, 131, 131, 121, 133, 
+  133, 133, 133, 132, 132, 135, 135, 137, 137, 137, 
+  137, 137, 137, 138, 138, 138, 138, 138, 138, 138, 
+  138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 
+  138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 
+  138, 138, 138, 138, 139, 139, 114, 114, 114, 114, 
+  114, 142, 142, 143, 143, 143, 143, 141, 141, 144, 
+  144, 145, 145, 146, 146, 146, 147, 147, 147, 147, 
+  147, 147, 147, 147, 147, 147, 148, 148, 148, 148, 
+  149, 149, 149, 150, 150, 150, 150, 151, 151, 151, 
+  151, 151, 151, 151, 152, 152, 152, 152, 152, 152, 
+  153, 153, 153, 153, 153, 154, 154, 154, 154, 154, 
+  155, 155, 156, 156, 157, 157, 158, 158, 159, 159, 
+  160, 160, 161, 161, 162, 162, 163, 163, 164, 164, 
+  165, 165, 166, 166, 136, 136, 167, 167, 168, 168, 
+  168, 168, 168, 168, 168, 168, 168, 168, 168, 168, 
+  104, 104, 169, 169, 170, 170, 171, 171, 103, 103, 
+  103, 103, 103, 103, 103, 103, 103, 103, 103, 103, 
+  103, 103, 103, 122, 183, 183, 182, 182, 130, 130, 
+  184, 184, 185, 185, 187, 187, 186, 188, 191, 189, 
+  189, 192, 190, 190, 123, 124, 124, 125, 125, 172, 
+  172, 172, 172, 172, 172, 172, 173, 173, 173, 173, 
+  174, 174, 174, 174, 175, 175, 176, 178, 193, 193, 
+  196, 196, 194, 194, 197, 195, 177, 177, 177, 179, 
+  179, 180, 180, 180, 198, 199, 181, 181, 129, 140, 
+  203, 203, 200, 200, 201, 201, 204, 107, 205, 205, 
+  105, 105, 202, 202, 134, 134, 206};
+
+const short QDeclarativeJSGrammar::rhs [] = {
+  2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 
+  2, 1, 2, 2, 3, 3, 5, 5, 4, 4, 
+  2, 0, 1, 1, 2, 1, 3, 2, 3, 2, 
+  1, 5, 4, 4, 3, 3, 3, 3, 1, 1, 
+  1, 0, 1, 2, 4, 6, 6, 3, 3, 7, 
+  7, 4, 4, 5, 5, 6, 6, 7, 7, 7, 
+  7, 10, 6, 1, 1, 1, 1, 1, 1, 1, 
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
+  2, 3, 3, 4, 5, 3, 4, 3, 1, 1, 
+  2, 3, 4, 1, 2, 3, 5, 1, 1, 1, 
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
+  1, 1, 1, 1, 1, 1, 1, 1, 4, 3, 
+  5, 1, 2, 4, 4, 4, 3, 0, 1, 1, 
+  3, 1, 1, 1, 2, 2, 1, 2, 2, 2, 
+  2, 2, 2, 2, 2, 2, 1, 3, 3, 3, 
+  1, 3, 3, 1, 3, 3, 3, 1, 3, 3, 
+  3, 3, 3, 3, 1, 3, 3, 3, 3, 3, 
+  1, 3, 3, 3, 3, 1, 3, 3, 3, 3, 
+  1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 
+  1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 
+  1, 5, 1, 5, 1, 3, 1, 3, 1, 1, 
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
+  1, 3, 0, 1, 1, 3, 0, 1, 1, 1, 
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
+  1, 1, 1, 3, 1, 2, 0, 1, 3, 3, 
+  1, 1, 1, 3, 1, 3, 2, 2, 2, 0, 
+  1, 2, 0, 1, 1, 2, 2, 7, 5, 7, 
+  7, 5, 9, 10, 7, 8, 2, 2, 3, 3, 
+  2, 2, 3, 3, 3, 3, 5, 5, 3, 5, 
+  1, 2, 0, 1, 4, 3, 3, 3, 3, 3, 
+  3, 3, 3, 4, 5, 2, 2, 2, 8, 8, 
+  1, 3, 0, 1, 0, 1, 1, 1, 1, 2, 
+  1, 1, 0, 1, 0, 1, 2};
+
+const short QDeclarativeJSGrammar::action_default [] = {
+  0, 0, 0, 0, 0, 0, 22, 0, 174, 241, 
+  205, 213, 209, 153, 225, 201, 3, 138, 72, 154, 
+  217, 221, 142, 171, 152, 157, 137, 191, 178, 0, 
+  79, 80, 75, 343, 66, 345, 0, 0, 0, 0, 
+  77, 0, 0, 73, 76, 70, 0, 0, 67, 69, 
+  68, 78, 71, 0, 74, 0, 0, 167, 0, 0, 
+  154, 173, 156, 155, 0, 0, 0, 169, 170, 168, 
+  172, 0, 202, 0, 0, 0, 0, 192, 0, 0, 
+  0, 0, 0, 0, 182, 0, 0, 0, 176, 177, 
+  175, 180, 184, 183, 181, 179, 194, 193, 195, 0, 
+  210, 0, 206, 0, 0, 148, 135, 147, 136, 104, 
+  105, 106, 131, 107, 132, 108, 109, 110, 111, 112, 
+  113, 114, 115, 116, 117, 118, 119, 120, 133, 121, 
+  122, 123, 124, 125, 126, 127, 128, 129, 130, 134, 
+  0, 0, 146, 242, 149, 0, 150, 0, 151, 145, 
+  0, 238, 231, 229, 236, 237, 235, 234, 240, 233, 
+  232, 230, 239, 226, 0, 214, 0, 0, 218, 0, 
+  0, 222, 0, 0, 148, 140, 0, 139, 0, 144, 
+  158, 0, 344, 333, 334, 0, 331, 0, 332, 0, 
+  335, 249, 256, 255, 263, 251, 0, 252, 336, 0, 
+  342, 253, 254, 259, 257, 339, 337, 341, 260, 0, 
+  271, 0, 0, 0, 0, 343, 66, 0, 345, 67, 
+  243, 285, 68, 0, 0, 0, 272, 0, 0, 261, 
+  262, 0, 250, 258, 286, 287, 330, 340, 0, 301, 
+  302, 303, 304, 0, 297, 298, 299, 300, 327, 328, 
+  0, 0, 0, 0, 0, 290, 291, 247, 245, 207, 
+  215, 211, 227, 203, 248, 0, 154, 219, 223, 196, 
+  185, 0, 0, 204, 0, 0, 0, 0, 197, 0, 
+  0, 0, 0, 0, 189, 187, 190, 188, 186, 199, 
+  198, 200, 0, 212, 0, 208, 0, 246, 154, 0, 
+  228, 243, 244, 0, 243, 0, 0, 293, 0, 0, 
+  0, 295, 0, 216, 0, 0, 220, 0, 0, 224, 
+  283, 0, 275, 284, 278, 0, 282, 0, 243, 276, 
+  0, 243, 0, 0, 294, 0, 0, 0, 296, 344, 
+  333, 0, 0, 335, 0, 329, 0, 319, 0, 0, 
+  0, 289, 0, 288, 0, 346, 0, 103, 265, 268, 
+  0, 104, 271, 107, 132, 109, 110, 75, 114, 115, 
+  66, 116, 119, 73, 76, 67, 243, 68, 78, 122, 
+  71, 124, 74, 126, 127, 272, 129, 130, 134, 0, 
+  96, 0, 0, 98, 102, 100, 87, 99, 101, 0, 
+  97, 86, 266, 264, 142, 143, 148, 0, 141, 0, 
+  318, 0, 305, 306, 0, 317, 0, 0, 0, 308, 
+  313, 311, 314, 0, 0, 312, 313, 0, 309, 0, 
+  310, 267, 316, 0, 267, 315, 0, 320, 321, 0, 
+  267, 322, 323, 0, 0, 324, 0, 0, 0, 325, 
+  326, 160, 159, 0, 0, 0, 292, 0, 0, 0, 
+  307, 280, 273, 0, 281, 277, 0, 279, 269, 0, 
+  270, 274, 90, 0, 0, 94, 81, 0, 83, 92, 
+  0, 84, 93, 95, 85, 91, 82, 0, 88, 164, 
+  162, 166, 163, 161, 165, 6, 338, 4, 2, 64, 
+  89, 0, 0, 67, 69, 68, 31, 5, 0, 65, 
+  0, 41, 40, 39, 0, 0, 54, 0, 55, 0, 
+  60, 61, 0, 41, 0, 0, 0, 0, 0, 50, 
+  0, 51, 0, 0, 26, 0, 0, 62, 27, 0, 
+  30, 28, 24, 0, 29, 25, 0, 52, 0, 53, 
+  0, 142, 0, 56, 57, 63, 0, 0, 0, 0, 
+  0, 58, 59, 0, 48, 42, 49, 43, 0, 0, 
+  0, 0, 45, 0, 46, 47, 44, 0, 0, 35, 
+  36, 37, 38, 142, 267, 0, 0, 104, 271, 107, 
+  132, 109, 110, 75, 114, 115, 66, 116, 119, 73, 
+  76, 67, 243, 68, 78, 122, 71, 124, 74, 126, 
+  127, 272, 129, 130, 134, 0, 32, 33, 0, 34, 
+  8, 0, 10, 0, 9, 0, 1, 21, 12, 0, 
+  13, 0, 14, 0, 19, 20, 0, 15, 16, 0, 
+  17, 18, 11, 23, 7, 347};
+
+const short QDeclarativeJSGrammar::goto_default [] = {
+  7, 626, 207, 196, 205, 507, 495, 625, 644, 620, 
+  624, 622, 627, 22, 623, 18, 506, 543, 533, 540, 
+  535, 191, 195, 197, 201, 524, 568, 567, 200, 232, 
+  26, 474, 473, 356, 355, 9, 354, 357, 107, 17, 
+  145, 24, 13, 144, 19, 25, 57, 23, 8, 28, 
+  27, 269, 15, 263, 10, 259, 12, 261, 11, 260, 
+  20, 267, 21, 268, 14, 262, 258, 299, 411, 264, 
+  265, 202, 193, 192, 204, 233, 203, 208, 229, 230, 
+  194, 360, 359, 231, 463, 462, 321, 322, 465, 324, 
+  464, 323, 419, 423, 426, 422, 421, 441, 442, 185, 
+  199, 181, 184, 198, 206, 0};
+
+const short QDeclarativeJSGrammar::action_index [] = {
+  421, 1288, 2322, 2322, 2419, 1016, -52, 37, 140, -101, 
+  35, -13, -40, 190, -101, 272, 34, -101, -101, 658, 
+  42, 103, 194, 201, -101, -101, -101, 439, 256, 1288, 
+  -101, -101, -101, 282, -101, 2128, 1751, 1288, 1288, 1288, 
+  -101, 917, 1288, -101, -101, -101, 1288, 1288, -101, -101, 
+  -101, -101, -101, 1288, -101, 1288, 1288, -101, 1288, 1288, 
+  109, 245, -101, -101, 1288, 1288, 1288, -101, -101, -101, 
+  185, 1288, 295, 1288, 1288, 1288, 1288, 461, 1288, 1288, 
+  1288, 1288, 1288, 1288, 256, 1288, 1288, 1288, 155, 119, 
+  114, 176, 256, 332, 202, 332, 560, 560, 471, 1288, 
+  -23, 1288, 53, 2031, 1288, 1288, -101, -101, -101, -101, 
+  -101, -101, -101, -101, -101, -101, -101, -101, -101, -101, 
+  -101, -101, -101, -101, -101, -101, -101, -101, -101, -101, 
+  -101, -101, -101, -101, -101, -101, -101, -101, -101, -101, 
+  100, 1288, -101, -101, 70, 59, -101, 1288, -101, -101, 
+  1288, -101, -101, -101, -101, -101, -101, -101, -101, -101, 
+  -101, -101, -101, -101, 1288, 41, 1288, 1288, 98, 91, 
+  1288, -101, 2031, 1288, 1288, -101, 121, -101, 73, -101, 
+  -101, 39, -101, 385, 180, 78, -101, 391, -101, 64, 
+  2322, -101, -101, -101, -101, -101, 208, -101, -101, 82, 
+  -101, -101, -101, -101, -101, -101, 2322, -101, -101, 538, 
+  -101, 495, 128, 2419, 54, 358, 62, 44, 2613, 67, 
+  1288, -101, 76, 63, 1288, 58, -101, 60, 46, -101, 
+  -101, 309, -101, -101, -101, -101, -101, -101, 86, -101, 
+  -101, -101, -101, 107, -101, -101, -101, -101, -101, -101, 
+  28, 52, 1288, 101, 102, -101, -101, 1472, -101, 83, 
+  75, 79, -101, 287, 84, 80, 585, 69, 89, 321, 
+  177, 482, 1288, 297, 1288, 1288, 1288, 1288, 331, 1288, 
+  1288, 1288, 1288, 1288, 332, 222, 332, 332, 332, 410, 
+  410, 410, 1288, 57, 1288, 72, 1288, -101, 658, 1288, 
+  -101, 1288, 71, 45, 1288, 61, 2419, -101, 1288, 132, 
+  2419, -101, 1288, 47, 1288, 1288, 66, 65, 1288, -101, 
+  68, 112, 81, -101, -101, 1288, -101, 369, 1288, -101, 
+  85, 1288, 74, 2419, -101, 1288, 122, 2419, -101, 77, 
+  294, 16, -29, 2322, -53, -101, 2419, -101, 1288, 127, 
+  2419, -15, 2419, -101, 10, 11, -34, -101, -101, 2419, 
+  -48, 504, 4, 476, 113, 1288, 2419, 2, -28, 420, 
+  6, -21, 719, 7, 87, -101, 1382, -101, -4, -16, 
+  5, 1288, 3, -27, 1288, 9, 1288, -18, -31, 1288, 
+  -101, 2225, -7, -101, -101, -101, -101, -101, -101, 1288, 
+  -101, -101, -101, -101, 246, -101, 1288, -38, -101, 2419, 
+  -101, 88, -101, -101, 2419, -101, 1288, 106, 26, -101, 
+  55, -101, 50, 105, 1288, -101, 48, 38, -101, -8, 
+  -101, 2419, -101, 94, 2419, -101, 238, -101, -101, 104, 
+  2419, 31, -101, 21, 19, -101, 305, 1, 30, -101, 
+  -101, -101, -101, 1288, 136, 2419, -101, 1288, 134, 2419, 
+  -101, 49, -101, 173, -101, -101, 1288, -101, -101, 363, 
+  -101, -101, -101, 137, 1565, -101, -101, 1658, -101, -101, 
+  1844, -101, -101, -101, -101, -101, -101, 95, -101, -101, 
+  -101, -101, -101, -101, -101, -101, 2322, -101, -101, -101, 
+  92, 15, 925, 169, 27, -6, -101, -101, 212, -101, 
+  191, -101, -101, -101, 323, 211, -101, 1288, -101, 214, 
+  -101, -101, 216, 40, 317, 210, 43, 259, 236, -101, 
+  36, -101, 747, 96, -101, 29, 747, -101, -101, 1198, 
+  -101, -101, -101, 1107, -101, -101, 231, -101, 1288, -101, 
+  217, 286, 32, -101, -101, -101, 188, 340, 51, 1288, 
+  175, -101, -101, 171, -101, 179, -101, 56, -11, 351, 
+  181, 336, -101, 110, -101, -101, -101, 1934, 647, -101, 
+  -101, -101, -101, 253, 2516, 1751, -5, 460, 22, 468, 
+  138, 1288, 2419, 24, -2, 412, 23, -3, 836, 20, 
+  87, -101, 1382, -101, 17, -10, 18, 1288, 25, 8, 
+  1288, 33, 1288, 12, 14, 120, -101, -101, 13, -101, 
+  -101, 747, -101, 248, -47, 828, -101, -101, 152, 482, 
+  -101, 150, -101, 123, -101, -101, 398, -101, -101, 117, 
+  -101, -101, -101, -101, -101, -101, 
+
+  -106, 6, -92, 10, 5, 278, -106, -106, -106, -106, 
+  -106, -106, -106, -106, -106, -106, -106, -106, -106, -42, 
+  -106, -106, -106, -106, -106, -106, -106, -106, -106, 109, 
+  -106, -106, -106, -10, -106, -106, -35, 24, 73, 90, 
+  -106, 219, 181, -106, -106, -106, 171, 120, -106, -106, 
+  -106, -106, -106, 174, -106, 170, 167, -106, 175, 163, 
+  -106, -106, -106, -106, 184, 177, 180, -106, -106, -106, 
+  -106, 125, -106, 132, 134, 162, 130, -106, 121, 124, 
+  123, 141, 142, 152, -106, 154, 161, 160, -106, -106, 
+  -106, -106, -106, -106, -106, -106, -106, -106, -106, 139, 
+  -106, 143, -106, 156, 91, 55, -106, -106, -106, -106, 
+  -106, -106, -106, -106, -106, -106, -106, -106, -106, -106, 
+  -106, -106, -106, -106, -106, -106, -106, -106, -106, -106, 
+  -106, -106, -106, -106, -106, -106, -106, -106, -106, -106, 
+  -106, 32, -106, -106, -106, -106, -106, 33, -106, -106, 
+  26, -106, -106, -106, -106, -106, -106, -106, -106, -106, 
+  -106, -106, -106, -106, 96, -106, 119, 52, -106, -106, 
+  66, -106, 220, 69, 71, -106, -106, -106, -106, -106, 
+  -106, -106, -106, 25, -106, -106, -106, 64, -106, -106, 
+  -106, -106, -106, -106, -106, -106, -106, -106, -106, -106, 
+  -106, -106, -106, -106, -106, -106, 70, -106, -106, 61, 
+  -106, 41, -106, 39, -106, 37, -106, -106, 42, -106, 
+  79, -106, -106, -106, 81, 72, -106, -106, -106, -106, 
+  -106, -5, -106, -106, -106, -106, -106, -106, -106, -106, 
+  -106, -106, -106, -106, -106, -106, -106, -106, -106, -106, 
+  -106, -106, 21, -106, -106, -106, -106, 112, -106, -106, 
+  -106, -106, -106, -106, -106, -106, -106, -106, -106, -106, 
+  -106, 17, 237, -106, 192, 236, 224, 225, -106, 97, 
+  98, 101, 99, 113, -106, -106, -106, -106, -106, -106, 
+  -106, -106, 204, -106, 223, -106, 235, -106, -106, 239, 
+  -106, 197, -106, -106, 228, -106, 27, -106, 13, -106, 
+  2, -106, 233, -106, 190, 198, -106, -106, 196, -106, 
+  -106, -106, -106, -106, -106, 200, -106, 107, 135, -106, 
+  -106, 186, -106, 84, -106, 80, -106, 76, -106, -106, 
+  89, -106, -106, -49, -106, -106, 47, -106, 40, -106, 
+  44, -106, 68, -106, -106, -106, -106, -106, -106, 53, 
+  -106, 35, -106, 49, -106, 87, 63, -106, -106, 30, 
+  -106, -106, 103, -106, -106, -106, 51, -106, -106, -106, 
+  -106, 86, -106, 67, 114, -106, 74, -106, -106, 65, 
+  -106, 56, -106, -106, -106, -106, -106, -106, -106, 62, 
+  -106, -106, -106, -106, -106, -106, 95, -106, -106, 78, 
+  -106, -106, -106, -106, 75, -106, 88, -106, -106, -106, 
+  -106, -106, -54, -106, 45, -106, -40, -106, -106, -106, 
+  -106, 94, -106, -106, 100, -106, -106, -106, -106, -106, 
+  150, -41, -106, -106, 54, -106, 43, -106, 48, -106, 
+  -106, -106, -106, 59, -106, 57, -106, 60, -106, 58, 
+  -106, -106, -106, -106, -106, -106, 38, -106, -106, 144, 
+  -106, -106, -106, -106, 31, -106, -106, 202, -106, -106, 
+  50, -106, -106, -106, -106, -106, -106, -106, -106, -106, 
+  -106, -106, -106, -106, -106, -106, 77, -106, -106, -106, 
+  -106, -106, 82, -106, -106, -106, -106, -106, -106, -106, 
+  -17, -106, -106, -106, -4, -106, -106, 12, -106, -106, 
+  -106, -106, -106, -106, -14, 46, -106, -13, -106, -106, 
+  -106, -106, 108, -106, -106, -106, 243, -106, -106, 295, 
+  -106, -106, -106, 290, -106, -106, -106, -106, 346, -106, 
+  -106, -106, 16, -106, -106, -106, 22, 23, -106, 34, 
+  -106, -106, -106, -106, -106, 11, -106, -106, -106, 7, 
+  1, 8, -106, -106, -106, -106, -106, 307, 179, -106, 
+  -106, -106, -106, -106, 18, 281, 9, 15, -106, 4, 
+  -106, 83, 29, -106, -106, -2, -106, -106, 85, -106, 
+  -106, -106, 3, -106, -106, -106, -106, 14, -106, 0, 
+  105, -106, 93, -106, -106, -106, -106, -106, -1, -106, 
+  -106, 20, -106, -106, 28, 92, -106, -106, -106, 19, 
+  -106, -106, -106, -106, -106, -106, -12, -106, -106, -106, 
+  -106, -106, -106, -106, -106, -106};
+
+const short QDeclarativeJSGrammar::action_info [] = {
+  399, 352, 345, -101, 343, 457, 440, 403, 257, -112, 
+  -125, -131, -123, 346, -120, 348, -128, 389, 453, 391, 
+  416, 401, 408, 563, -101, -123, 416, -120, 539, -131, 
+  346, -112, -125, 348, 257, 99, 71, 645, 621, 101, 
+  -128, 440, 141, 621, 164, 431, 539, 430, 453, 573, 
+  457, 444, 440, 424, 71, 424, 101, 446, 559, 420, 
+  424, 448, 539, 440, 570, 539, 466, 527, 312, 346, 
+  532, 312, 318, 272, 409, 183, 342, 525, 147, 141, 
+  348, 510, 457, 414, 272, 325, 0, 0, 252, 99, 
+  257, 440, 296, 556, -102, 292, 453, 190, 170, 416, 
+  164, 434, 141, 141, 536, 251, 304, 172, 141, 141, 
+  443, 0, 335, 340, 141, 427, 0, 0, 0, 149, 
+  327, 306, 0, 292, 444, 0, 173, 0, 536, 141, 
+  141, 0, 0, 179, 333, 141, 294, 236, 189, 314, 
+  141, 301, 141, 315, 141, 477, 331, 242, 241, 413, 
+  412, 62, 537, 166, 58, 488, 142, 167, 294, 58, 
+  428, 254, 63, 256, 255, 59, 418, 172, 247, 246, 
+  59, 575, 574, 328, 249, 248, 616, 177, 641, 640, 
+  58, 469, 337, 141, 635, 634, 173, 350, 187, 249, 
+  248, 59, 310, 478, 459, 58, 455, 64, 523, 249, 
+  248, 85, 85, 86, 86, 103, 59, 565, 511, 172, 
+  511, 638, 637, 64, 87, 87, 141, 511, 517, 577, 
+  511, 0, 141, 0, 104, 141, 105, 85, 173, 86, 
+  174, 172, 566, 564, 470, 468, 562, 561, 548, 511, 
+  87, 636, 65, 530, 513, 539, 141, 85, 66, 86, 
+  173, 0, 406, 0, 513, 512, 513, 64, 65, 0, 
+  87, 172, 0, 513, 66, 512, 513, 512, 172, 235, 
+  234, 0, 518, 516, 512, 521, 520, 512, 554, 553, 
+  173, 85, 406, 86, 0, 513, -89, 173, 34, 174, 
+  73, 74, 549, 547, 87, 631, 512, 531, 529, 438, 
+  437, 172, 65, 0, 578, 274, 275, 0, 66, 632, 
+  630, 34, 0, 73, 74, 274, 275, 75, 76, -89, 
+  173, 0, 174, 34, 0, 48, 50, 49, 0, 0, 
+  0, 0, 276, 277, 34, 0, 0, 0, 34, 629, 
+  75, 76, 276, 277, 279, 280, 34, 0, 48, 50, 
+  49, 45, 34, 281, 279, 280, 282, 85, 283, 86, 
+  48, 50, 49, 281, 0, 34, 282, 0, 283, 34, 
+  87, 48, 50, 49, 45, 48, 50, 49, 0, 0, 
+  34, 0, 0, 48, 50, 49, 45, 34, 0, 48, 
+  50, 49, 34, 0, 0, 0, 0, 45, 34, 0, 
+  0, 45, 48, 50, 49, 0, 48, 50, 49, 45, 
+  0, 0, 0, 0, 34, 45, 0, 48, 50, 49, 
+  34, 0, 0, 0, 48, 50, 49, 34, 45, 48, 
+  50, 49, 45, 279, 280, 48, 50, 49, 0, 0, 
+  0, 34, 281, 45, 0, 282, 0, 283, -343, 34, 
+  45, 48, 50, 49, 0, 45, -343, 48, 50, 49, 
+  0, 45, 78, 79, 48, 50, 49, 0, 0, 0, 
+  80, 81, 0, 0, 82, 0, 83, 45, 48, 50, 
+  49, 0, 0, 45, 78, 79, 48, 50, 49, 34, 
+  45, 0, 80, 81, 78, 79, 82, 34, 83, 0, 
+  0, 0, 80, 81, 45, 34, 82, 0, 83, 0, 
+  0, 34, 45, 0, 6, 5, 4, 1, 3, 2, 
+  0, 240, 239, 0, 34, 0, 48, 50, 49, 245, 
+  244, 0, 0, 34, 48, 50, 49, 245, 244, 0, 
+  0, 0, 48, 50, 49, 0, 0, 0, 48, 50, 
+  49, 0, 45, 0, 0, 0, 245, 244, 0, 0, 
+  45, 48, 50, 49, 0, 240, 239, 34, 45, 0, 
+  48, 50, 49, 0, 45, 0, 0, 0, 0, 0, 
+  0, 0, 0, 78, 79, 0, 0, 45, 151, 0, 
+  0, 80, 81, 0, 0, 82, 45, 83, 152, 240, 
+  239, 0, 153, 0, 48, 50, 49, 0, 0, 0, 
+  0, 154, 0, 155, 0, 0, 308, 0, 0, 0, 
+  0, 0, 0, 0, 156, 0, 157, 62, 0, 0, 
+  45, 0, 0, 0, 158, 0, 0, 159, 63, 0, 
+  0, 0, 0, 160, 0, 0, 0, 0, 0, 161, 
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 30, 
+  31, 151, 0, 0, 0, 162, 0, 0, 0, 33, 
+  0, 152, 0, 0, 0, 153, 34, 0, 0, 0, 
+  35, 36, 0, 37, 154, 0, 155, 0, 0, 0, 
+  502, 0, 0, 0, 44, 0, 0, 156, 0, 157, 
+  62, 0, 0, 0, 0, 0, 0, 158, 0, 0, 
+  159, 63, 51, 48, 50, 49, 160, 52, 0, 0, 
+  0, 0, 161, 0, 0, 0, 0, 0, 43, 54, 
+  32, 30, 31, 0, 40, 0, 0, 0, 162, 45, 
+  0, 33, 0, 0, 0, 0, 0, 0, 34, 0, 
+  0, 0, 35, 36, 0, 37, 0, 0, 0, 30, 
+  31, 0, 41, 0, 0, 0, 44, 0, 0, 33, 
+  0, 0, 0, 0, 0, 0, 34, 0, 0, 0, 
+  35, 36, 0, 37, 51, 48, 50, 49, 0, 52, 
+  502, 0, 0, 0, 44, 0, 0, 0, 0, 0, 
+  43, 54, 32, 0, 0, 0, 40, 0, 0, 0, 
+  0, 45, 51, 48, 50, 49, 0, 52, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0, 43, 54, 
+  32, 0, 0, 0, 40, 0, 0, 0, 0, 45, 
+  30, 31, 0, 0, 0, 0, 0, 0, 30, 31, 
+  33, 0, 0, 0, 0, 0, 0, 34, 33, 0, 
+  0, 35, 36, 0, 37, 34, 0, 0, 0, 35, 
+  36, 502, 37, 0, 0, 44, 0, 0, 0, 41, 
+  0, 0, 0, 44, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 51, 48, 50, 49, 0, 52, 0, 
+  0, 51, 48, 50, 49, 0, 52, 0, 0, 43, 
+  54, 32, 0, 0, 0, 40, 0, 43, 54, 32, 
+  45, 0, 0, 40, 0, 0, 0, 0, 45, 30, 
+  31, 0, 0, 0, 0, 0, 0, 30, 31, 33, 
+  0, 0, 0, 0, 0, 0, 34, 33, 0, 0, 
+  35, 36, 0, 37, 34, 0, 0, 0, 35, 36, 
+  41, 37, 0, 0, 44, 0, 0, 0, 502, 0, 
+  0, 0, 44, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 51, 48, 50, 49, 0, 52, 0, 0, 
+  51, 48, 50, 49, 0, 52, 0, 0, 43, 54, 
+  32, 0, 0, 0, 40, 0, 43, 54, 32, 45, 
+  0, 0, 40, 0, 0, 0, 0, 45, 0, 0, 
+  0, 0, 0, 0, 0, 0, 501, 0, 30, 31, 
+  0, 0, 0, 0, 0, 0, 0, 0, 215, 0, 
+  0, 0, 0, 0, 0, 34, 0, 0, 0, 35, 
+  36, 0, 37, 0, 0, 0, 0, 0, 0, 502, 
+  0, 0, 0, 44, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 51, 503, 505, 504, 0, 52, 0, 0, 0, 
+  0, 226, 0, 0, 0, 0, 0, 43, 54, 32, 
+  210, 0, 0, 40, 0, 0, 0, 0, 45, 0, 
+  0, 0, 0, 0, 0, 0, 0, 501, 0, 30, 
+  31, 0, 0, 0, 0, 0, 0, 0, 0, 215, 
+  0, 0, 0, 0, 0, 0, 34, 0, 0, 0, 
+  35, 36, 0, 37, 0, 0, 0, 0, 0, 0, 
+  502, 0, 0, 0, 44, 0, 0, 0, 0, 0, 
+  0, 0, 544, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 51, 503, 505, 504, 0, 52, 0, 0, 
+  0, 0, 226, 0, 0, 0, 0, 0, 43, 54, 
+  32, 210, 0, 0, 40, 0, 0, 0, 0, 45, 
+  0, 0, 0, 0, 0, 0, 0, 0, 501, 0, 
+  30, 31, 0, 0, 0, 0, 0, 0, 0, 0, 
+  215, 0, 0, 0, 0, 0, 0, 34, 0, 0, 
+  0, 35, 36, 0, 37, 0, 0, 0, 0, 0, 
+  0, 502, 0, 0, 0, 44, 0, 0, 0, 0, 
+  0, 0, 0, 541, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 51, 503, 505, 504, 0, 52, 0, 
+  0, 0, 0, 226, 0, 0, 0, 0, 0, 43, 
+  54, 32, 210, 0, 0, 40, 0, 0, 0, 0, 
+  45, 0, 0, 0, 0, 0, 0, 0, 0, 29, 
+  30, 31, 0, 0, 0, 0, 0, 0, 0, 0, 
+  33, 0, 0, 0, 0, 0, 0, 34, 0, 0, 
+  0, 35, 36, 0, 37, 0, 0, 0, 38, 0, 
+  39, 41, 42, 0, 0, 44, 0, 0, 0, 46, 
+  0, 47, 0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 51, 48, 50, 49, 0, 52, 0, 
+  53, 0, 55, 0, 56, 0, 0, 0, 0, 43, 
+  54, 32, 0, 0, 0, 40, 0, 0, 0, 0, 
+  45, 0, 0, 0, 0, 0, 0, 0, 0, -121, 
+  0, 0, 0, 29, 30, 31, 0, 0, 0, 0, 
+  0, 0, 0, 0, 33, 0, 0, 0, 0, 0, 
+  0, 34, 0, 0, 0, 35, 36, 0, 37, 0, 
+  0, 0, 38, 0, 39, 41, 42, 0, 0, 44, 
+  0, 0, 0, 46, 0, 47, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 51, 48, 50, 
+  49, 0, 52, 0, 53, 0, 55, 0, 56, 0, 
+  0, 0, 0, 43, 54, 32, 0, 0, 0, 40, 
+  0, 0, 0, 0, 45, 0, 0, 0, 0, 0, 
+  0, 0, 0, 29, 30, 31, 0, 0, 0, 0, 
+  0, 0, 0, 0, 33, 0, 0, 0, 0, 0, 
+  0, 34, 0, 0, 0, 35, 36, 0, 37, 0, 
+  0, 0, 38, 0, 39, 41, 42, 0, 0, 44, 
+  0, 0, 0, 46, 0, 47, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 51, 48, 50, 
+  49, 0, 52, 0, 53, 0, 55, 271, 56, 0, 
+  0, 0, 0, 43, 54, 32, 0, 0, 0, 40, 
+  0, 0, 0, 0, 45, 0, 0, 0, 0, 0, 
+  0, 0, 0, 483, 0, 0, 29, 30, 31, 0, 
+  0, 0, 0, 0, 0, 0, 0, 33, 0, 0, 
+  0, 0, 0, 0, 34, 0, 0, 0, 35, 36, 
+  0, 37, 0, 0, 0, 38, 0, 39, 41, 42, 
+  0, 0, 44, 0, 0, 0, 46, 0, 47, 0, 
+  0, 486, 0, 0, 0, 0, 0, 0, 0, 0, 
+  51, 48, 50, 49, 0, 52, 0, 53, 0, 55, 
+  0, 56, 0, 0, 0, 0, 43, 54, 32, 0, 
+  0, 0, 40, 0, 0, 0, 0, 45, 0, 0, 
+  0, 0, 0, 0, 0, 0, 475, 0, 0, 29, 
+  30, 31, 0, 0, 0, 0, 0, 0, 0, 0, 
+  33, 0, 0, 0, 0, 0, 0, 34, 0, 0, 
+  0, 35, 36, 0, 37, 0, 0, 0, 38, 0, 
+  39, 41, 42, 0, 0, 44, 0, 0, 0, 46, 
+  0, 47, 0, 0, 481, 0, 0, 0, 0, 0, 
+  0, 0, 0, 51, 48, 50, 49, 0, 52, 0, 
+  53, 0, 55, 0, 56, 0, 0, 0, 0, 43, 
+  54, 32, 0, 0, 0, 40, 0, 0, 0, 0, 
+  45, 0, 0, 0, 0, 0, 0, 0, 0, 475, 
+  0, 0, 29, 30, 31, 0, 0, 0, 0, 0, 
+  0, 0, 0, 33, 0, 0, 0, 0, 0, 0, 
+  34, 0, 0, 0, 35, 36, 0, 37, 0, 0, 
+  0, 38, 0, 39, 41, 42, 0, 0, 44, 0, 
+  0, 0, 46, 0, 47, 0, 0, 476, 0, 0, 
+  0, 0, 0, 0, 0, 0, 51, 48, 50, 49, 
+  0, 52, 0, 53, 0, 55, 0, 56, 0, 0, 
+  0, 0, 43, 54, 32, 0, 0, 0, 40, 0, 
+  0, 0, 0, 45, 0, 0, 0, 0, 0, 0, 
+  0, 0, 483, 0, 0, 29, 30, 31, 0, 0, 
+  0, 0, 0, 0, 0, 0, 33, 0, 0, 0, 
+  0, 0, 0, 34, 0, 0, 0, 35, 36, 0, 
+  37, 0, 0, 0, 38, 0, 39, 41, 42, 0, 
+  0, 44, 0, 0, 0, 46, 0, 47, 0, 0, 
+  484, 0, 0, 0, 0, 0, 0, 0, 0, 51, 
+  48, 50, 49, 0, 52, 0, 53, 0, 55, 0, 
+  56, 0, 0, 0, 0, 43, 54, 32, 0, 0, 
+  0, 40, 0, 0, 0, 0, 45, 0, 0, 0, 
+  0, 0, 0, 0, 0, 29, 30, 31, 0, 0, 
+  0, 0, 0, 0, 0, 0, 33, 0, 0, 0, 
+  0, 0, 0, 34, 217, 0, 0, 584, 585, 0, 
+  37, 0, 0, 0, 38, 0, 39, 41, 42, 0, 
+  0, 44, 0, 0, 0, 46, 0, 47, 0, 0, 
+  0, 0, 0, 0, 0, 221, 0, 0, 0, 51, 
+  48, 50, 49, 0, 52, 0, 53, 0, 55, 0, 
+  56, 0, 0, 0, 0, 43, 54, 32, 0, 0, 
+  0, 40, 0, 0, 0, 0, 45, 0, 0, 0, 
+  0, 0, 0, 0, 0, 109, 110, 111, 0, 0, 
+  113, 115, 116, 0, 0, 117, 0, 118, 0, 0, 
+  0, 120, 121, 122, 0, 0, 0, 0, 0, 0, 
+  34, 123, 124, 125, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 126, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+  129, 0, 0, 0, 0, 0, 0, 48, 50, 49, 
+  130, 131, 132, 0, 134, 135, 136, 137, 138, 139, 
+  0, 0, 127, 133, 119, 112, 114, 128, 0, 0, 
+  0, 0, 0, 45, 0, 0, 0, 0, 0, 0, 
+  0, 0, 109, 110, 111, 0, 0, 113, 115, 116, 
+  0, 0, 117, 0, 118, 0, 0, 0, 120, 121, 
+  122, 0, 0, 0, 0, 0, 0, 393, 123, 124, 
+  125, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 126, 0, 0, 0, 394, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 129, 0, 0, 
+  0, 0, 0, 398, 395, 397, 0, 130, 131, 132, 
+  0, 134, 135, 136, 137, 138, 139, 0, 0, 127, 
+  133, 119, 112, 114, 128, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 109, 
+  110, 111, 0, 0, 113, 115, 116, 0, 0, 117, 
+  0, 118, 0, 0, 0, 120, 121, 122, 0, 0, 
+  0, 0, 0, 0, 393, 123, 124, 125, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0, 126, 0, 
+  0, 0, 394, 0, 0, 0, 0, 0, 0, 0, 
+  396, 0, 0, 0, 129, 0, 0, 0, 0, 0, 
+  398, 395, 397, 0, 130, 131, 132, 0, 134, 135, 
+  136, 137, 138, 139, 0, 0, 127, 133, 119, 112, 
+  114, 128, 0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 209, 0, 0, 0, 
+  0, 211, 0, 29, 30, 31, 213, 0, 0, 0, 
+  0, 0, 0, 214, 215, 0, 0, 0, 0, 0, 
+  0, 216, 217, 0, 0, 218, 36, 0, 37, 0, 
+  0, 0, 38, 0, 39, 41, 42, 0, 0, 44, 
+  0, 0, 0, 46, 0, 47, 0, 0, 0, 0, 
+  0, 220, 0, 221, 0, 0, 0, 51, 219, 222, 
+  49, 223, 52, 224, 53, 225, 55, 226, 56, 227, 
+  228, 0, 0, 43, 54, 32, 210, 212, 0, 40, 
+  0, 0, 0, 0, 45, 0, 0, 0, 0, 0, 
+  0, 0, 0, 209, 0, 0, 0, 0, 211, 0, 
+  29, 30, 31, 213, 0, 0, 0, 0, 0, 0, 
+  214, 33, 0, 0, 0, 0, 0, 0, 216, 217, 
+  0, 0, 218, 36, 0, 37, 0, 0, 0, 38, 
+  0, 39, 41, 42, 0, 0, 44, 0, 0, 0, 
+  46, 0, 47, 0, 0, 0, 0, 0, 220, 0, 
+  221, 0, 0, 0, 51, 219, 222, 49, 223, 52, 
+  224, 53, 225, 55, 226, 56, 227, 228, 0, 0, 
+  43, 54, 32, 210, 212, 0, 40, 0, 0, 0, 
+  0, 45, 0, 0, 0, 0, 0, 0, 0, 0, 
+  587, 110, 111, 0, 0, 589, 115, 591, 30, 31, 
+  592, 0, 118, 0, 0, 0, 120, 594, 595, 0, 
+  0, 0, 0, 0, 0, 596, 597, 124, 125, 218, 
+  36, 0, 37, 0, 0, 0, 38, 0, 39, 598, 
+  42, 0, 0, 600, 0, 0, 0, 46, 0, 47, 
+  0, 0, 0, 0, 0, 602, 0, 221, 0, 0, 
+  0, 604, 601, 603, 49, 605, 606, 607, 53, 609, 
+  610, 611, 612, 613, 614, 0, 0, 599, 608, 593, 
+  588, 590, 128, 40, 0, 0, 0, 0, 45, 0, 
+  0, 0, 0, 0, 0, 0, 0, 361, 110, 111, 
+  0, 0, 363, 115, 365, 30, 31, 366, 0, 118, 
+  0, 0, 0, 120, 368, 369, 0, 0, 0, 0, 
+  0, 0, 370, 371, 124, 125, 218, 36, 0, 37, 
+  0, 0, 0, 38, 0, 39, 372, 42, 0, 0, 
+  374, 0, 0, 0, 46, 0, 47, 0, -267, 0, 
+  0, 0, 376, 0, 221, 0, 0, 0, 378, 375, 
+  377, 49, 379, 380, 381, 53, 383, 384, 385, 386, 
+  387, 388, 0, 0, 373, 382, 367, 362, 364, 128, 
+  40, 0, 0, 0, 0, 45, 0, 0, 0, 0, 
+  0, 0, 0, 0, 
+
+  472, 546, 528, 639, 311, 182, 302, 498, 514, 16, 
+  461, 515, 496, 182, 497, 519, 309, 436, 619, 243, 
+  358, 439, 576, 572, 253, 150, 571, 487, 617, 307, 
+  238, 250, 320, 628, 633, 555, 569, 560, 558, 642, 
+  186, 250, 425, 349, 358, 182, 351, 557, 433, 347, 
+  238, 344, 339, 429, 302, 402, 243, 445, 447, 456, 
+  460, 163, 454, 458, 243, 250, 485, 143, 148, 449, 
+  353, 526, 176, 467, 237, 450, 238, 415, 338, 188, 
+  410, 237, 302, 336, 436, 482, 334, 169, 439, 436, 
+  146, 417, 392, 439, 140, 522, 358, 400, 404, 0, 
+  390, 171, 358, 0, 186, 500, 146, 0, 643, 0, 
+  0, 178, 0, 0, 0, 0, 404, 60, 60, 489, 
+  452, 500, 320, 0, 534, 0, 405, 60, 0, 180, 
+  146, 60, 0, 180, 60, 407, 490, 60, 302, 452, 
+  60, 60, 60, 60, 405, 60, 284, 285, 287, 60, 
+  286, 451, 358, 60, 165, 180, 266, 60, 60, 461, 
+  451, 270, 288, 60, 60, 60, 493, 60, 60, 60, 
+  84, 106, 92, 91, 60, 432, 60, 72, 60, 168, 
+  98, 435, 77, 60, 96, 60, 60, 60, 341, 302, 
+  93, 94, 500, 108, 329, 100, 60, 102, 60, 618, 
+  302, 95, 88, 330, 60, 60, 60, 60, 90, 89, 
+  70, 60, 97, 452, 60, 60, 451, 492, 60, 60, 
+  494, 60, 61, 68, 60, 60, 69, 491, 60, 471, 
+  67, 302, 404, 480, 60, 106, 60, 479, 0, 270, 
+  298, 270, 298, 278, 298, 270, 0, 270, 60, 270, 
+  0, 316, 0, 270, 332, 0, 500, 108, 175, 538, 
+  405, 293, 319, 0, 317, 303, 326, 60, 60, 60, 
+  0, 0, 270, 270, 270, 290, 291, 60, 295, 298, 
+  60, 60, 270, 298, 270, 270, 270, 289, 270, 0, 
+  273, 500, 313, 0, 551, 545, 305, 534, 508, 615, 
+  542, 297, 0, 500, 0, 300, 499, 509, 500, 0, 
+  508, 0, 0, 0, 0, 508, 472, 0, 499, 509, 
+  583, 0, 0, 499, 509, 0, 0, 586, 579, 580, 
+  581, 582, 0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 550, 
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 551, 
+  0, 0, 0, 0, 0, 0, 552, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0};
+
+const short QDeclarativeJSGrammar::action_check [] = {
+  7, 16, 55, 7, 33, 36, 33, 55, 36, 7, 
+  7, 7, 7, 7, 7, 36, 7, 7, 36, 8, 
+  36, 55, 60, 29, 7, 7, 36, 7, 33, 7, 
+  7, 7, 7, 36, 36, 48, 1, 0, 90, 79, 
+  7, 33, 8, 90, 2, 7, 33, 55, 36, 60, 
+  36, 20, 33, 5, 1, 5, 79, 36, 7, 33, 
+  5, 60, 33, 33, 8, 33, 17, 24, 2, 7, 
+  34, 2, 7, 1, 7, 36, 60, 37, 8, 8, 
+  36, 66, 36, 7, 1, 17, -1, -1, 36, 48, 
+  36, 33, 8, 66, 7, 48, 36, 33, 7, 36, 
+  2, 7, 8, 8, 8, 77, 61, 15, 8, 8, 
+  6, -1, 31, 36, 8, 10, -1, -1, -1, 60, 
+  8, 60, -1, 48, 20, -1, 34, -1, 8, 8, 
+  8, -1, -1, 60, 60, 8, 79, 55, 60, 50, 
+  8, 61, 8, 54, 8, 8, 61, 61, 62, 61, 
+  62, 42, 56, 50, 40, 60, 56, 54, 79, 40, 
+  55, 60, 53, 61, 62, 51, 60, 15, 61, 62, 
+  51, 61, 62, 61, 61, 62, 56, 56, 61, 62, 
+  40, 8, 60, 8, 61, 62, 34, 60, 8, 61, 
+  62, 51, 60, 56, 60, 40, 60, 12, 29, 61, 
+  62, 25, 25, 27, 27, 15, 51, 36, 29, 15, 
+  29, 61, 62, 12, 38, 38, 8, 29, 7, 7, 
+  29, -1, 8, -1, 34, 8, 36, 25, 34, 27, 
+  36, 15, 61, 62, 61, 62, 61, 62, 7, 29, 
+  38, 91, 57, 7, 75, 33, 8, 25, 63, 27, 
+  34, -1, 36, -1, 75, 86, 75, 12, 57, -1, 
+  38, 15, -1, 75, 63, 86, 75, 86, 15, 61, 
+  62, -1, 61, 62, 86, 61, 62, 86, 61, 62, 
+  34, 25, 36, 27, -1, 75, 33, 34, 29, 36, 
+  18, 19, 61, 62, 38, 47, 86, 61, 62, 61, 
+  62, 15, 57, -1, 92, 18, 19, -1, 63, 61, 
+  62, 29, -1, 18, 19, 18, 19, 45, 46, 33, 
+  34, -1, 36, 29, -1, 66, 67, 68, -1, -1, 
+  -1, -1, 45, 46, 29, -1, -1, -1, 29, 91, 
+  45, 46, 45, 46, 23, 24, 29, -1, 66, 67, 
+  68, 92, 29, 32, 23, 24, 35, 25, 37, 27, 
+  66, 67, 68, 32, -1, 29, 35, -1, 37, 29, 
+  38, 66, 67, 68, 92, 66, 67, 68, -1, -1, 
+  29, -1, -1, 66, 67, 68, 92, 29, -1, 66, 
+  67, 68, 29, -1, -1, -1, -1, 92, 29, -1, 
+  -1, 92, 66, 67, 68, -1, 66, 67, 68, 92, 
+  -1, -1, -1, -1, 29, 92, -1, 66, 67, 68, 
+  29, -1, -1, -1, 66, 67, 68, 29, 92, 66, 
+  67, 68, 92, 23, 24, 66, 67, 68, -1, -1, 
+  -1, 29, 32, 92, -1, 35, -1, 37, 36, 29, 
+  92, 66, 67, 68, -1, 92, 36, 66, 67, 68, 
+  -1, 92, 23, 24, 66, 67, 68, -1, -1, -1, 
+  31, 32, -1, -1, 35, -1, 37, 92, 66, 67, 
+  68, -1, -1, 92, 23, 24, 66, 67, 68, 29, 
+  92, -1, 31, 32, 23, 24, 35, 29, 37, -1, 
+  -1, -1, 31, 32, 92, 29, 35, -1, 37, -1, 
+  -1, 29, 92, -1, 93, 94, 95, 96, 97, 98, 
+  -1, 61, 62, -1, 29, -1, 66, 67, 68, 61, 
+  62, -1, -1, 29, 66, 67, 68, 61, 62, -1, 
+  -1, -1, 66, 67, 68, -1, -1, -1, 66, 67, 
+  68, -1, 92, -1, -1, -1, 61, 62, -1, -1, 
+  92, 66, 67, 68, -1, 61, 62, 29, 92, -1, 
+  66, 67, 68, -1, 92, -1, -1, -1, -1, -1, 
+  -1, -1, -1, 23, 24, -1, -1, 92, 3, -1, 
+  -1, 31, 32, -1, -1, 35, 92, 37, 13, 61, 
+  62, -1, 17, -1, 66, 67, 68, -1, -1, -1, 
+  -1, 26, -1, 28, -1, -1, 31, -1, -1, -1, 
+  -1, -1, -1, -1, 39, -1, 41, 42, -1, -1, 
+  92, -1, -1, -1, 49, -1, -1, 52, 53, -1, 
+  -1, -1, -1, 58, -1, -1, -1, -1, -1, 64, 
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, 12, 
+  13, 3, -1, -1, -1, 80, -1, -1, -1, 22, 
+  -1, 13, -1, -1, -1, 17, 29, -1, -1, -1, 
+  33, 34, -1, 36, 26, -1, 28, -1, -1, -1, 
+  43, -1, -1, -1, 47, -1, -1, 39, -1, 41, 
+  42, -1, -1, -1, -1, -1, -1, 49, -1, -1, 
+  52, 53, 65, 66, 67, 68, 58, 70, -1, -1, 
+  -1, -1, 64, -1, -1, -1, -1, -1, 81, 82, 
+  83, 12, 13, -1, 87, -1, -1, -1, 80, 92, 
+  -1, 22, -1, -1, -1, -1, -1, -1, 29, -1, 
+  -1, -1, 33, 34, -1, 36, -1, -1, -1, 12, 
+  13, -1, 43, -1, -1, -1, 47, -1, -1, 22, 
+  -1, -1, -1, -1, -1, -1, 29, -1, -1, -1, 
+  33, 34, -1, 36, 65, 66, 67, 68, -1, 70, 
+  43, -1, -1, -1, 47, -1, -1, -1, -1, -1, 
+  81, 82, 83, -1, -1, -1, 87, -1, -1, -1, 
+  -1, 92, 65, 66, 67, 68, -1, 70, -1, -1, 
+  -1, -1, -1, -1, -1, -1, -1, -1, 81, 82, 
+  83, -1, -1, -1, 87, -1, -1, -1, -1, 92, 
+  12, 13, -1, -1, -1, -1, -1, -1, 12, 13, 
+  22, -1, -1, -1, -1, -1, -1, 29, 22, -1, 
+  -1, 33, 34, -1, 36, 29, -1, -1, -1, 33, 
+  34, 43, 36, -1, -1, 47, -1, -1, -1, 43, 
+  -1, -1, -1, 47, -1, -1, -1, -1, -1, -1, 
+  -1, -1, -1, 65, 66, 67, 68, -1, 70, -1, 
+  -1, 65, 66, 67, 68, -1, 70, -1, -1, 81, 
+  82, 83, -1, -1, -1, 87, -1, 81, 82, 83, 
+  92, -1, -1, 87, -1, -1, -1, -1, 92, 12, 
+  13, -1, -1, -1, -1, -1, -1, 12, 13, 22, 
+  -1, -1, -1, -1, -1, -1, 29, 22, -1, -1, 
+  33, 34, -1, 36, 29, -1, -1, -1, 33, 34, 
+  43, 36, -1, -1, 47, -1, -1, -1, 43, -1, 
+  -1, -1, 47, -1, -1, -1, -1, -1, -1, -1, 
+  -1, -1, 65, 66, 67, 68, -1, 70, -1, -1, 
+  65, 66, 67, 68, -1, 70, -1, -1, 81, 82, 
+  83, -1, -1, -1, 87, -1, 81, 82, 83, 92, 
+  -1, -1, 87, -1, -1, -1, -1, 92, -1, -1, 
+  -1, -1, -1, -1, -1, -1, 10, -1, 12, 13, 
+  -1, -1, -1, -1, -1, -1, -1, -1, 22, -1, 
+  -1, -1, -1, -1, -1, 29, -1, -1, -1, 33, 
+  34, -1, 36, -1, -1, -1, -1, -1, -1, 43, 
+  -1, -1, -1, 47, -1, -1, -1, -1, -1, -1, 
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+  -1, 65, 66, 67, 68, -1, 70, -1, -1, -1, 
+  -1, 75, -1, -1, -1, -1, -1, 81, 82, 83, 
+  84, -1, -1, 87, -1, -1, -1, -1, 92, -1, 
+  -1, -1, -1, -1, -1, -1, -1, 10, -1, 12, 
+  13, -1, -1, -1, -1, -1, -1, -1, -1, 22, 
+  -1, -1, -1, -1, -1, -1, 29, -1, -1, -1, 
+  33, 34, -1, 36, -1, -1, -1, -1, -1, -1, 
+  43, -1, -1, -1, 47, -1, -1, -1, -1, -1, 
+  -1, -1, 55, -1, -1, -1, -1, -1, -1, -1, 
+  -1, -1, 65, 66, 67, 68, -1, 70, -1, -1, 
+  -1, -1, 75, -1, -1, -1, -1, -1, 81, 82, 
+  83, 84, -1, -1, 87, -1, -1, -1, -1, 92, 
+  -1, -1, -1, -1, -1, -1, -1, -1, 10, -1, 
+  12, 13, -1, -1, -1, -1, -1, -1, -1, -1, 
+  22, -1, -1, -1, -1, -1, -1, 29, -1, -1, 
+  -1, 33, 34, -1, 36, -1, -1, -1, -1, -1, 
+  -1, 43, -1, -1, -1, 47, -1, -1, -1, -1, 
+  -1, -1, -1, 55, -1, -1, -1, -1, -1, -1, 
+  -1, -1, -1, 65, 66, 67, 68, -1, 70, -1, 
+  -1, -1, -1, 75, -1, -1, -1, -1, -1, 81, 
+  82, 83, 84, -1, -1, 87, -1, -1, -1, -1, 
+  92, -1, -1, -1, -1, -1, -1, -1, -1, 11, 
+  12, 13, -1, -1, -1, -1, -1, -1, -1, -1, 
+  22, -1, -1, -1, -1, -1, -1, 29, -1, -1, 
+  -1, 33, 34, -1, 36, -1, -1, -1, 40, -1, 
+  42, 43, 44, -1, -1, 47, -1, -1, -1, 51, 
+  -1, 53, -1, -1, -1, -1, -1, -1, -1, -1, 
+  -1, -1, -1, 65, 66, 67, 68, -1, 70, -1, 
+  72, -1, 74, -1, 76, -1, -1, -1, -1, 81, 
+  82, 83, -1, -1, -1, 87, -1, -1, -1, -1, 
+  92, -1, -1, -1, -1, -1, -1, -1, -1, 7, 
+  -1, -1, -1, 11, 12, 13, -1, -1, -1, -1, 
+  -1, -1, -1, -1, 22, -1, -1, -1, -1, -1, 
+  -1, 29, -1, -1, -1, 33, 34, -1, 36, -1, 
+  -1, -1, 40, -1, 42, 43, 44, -1, -1, 47, 
+  -1, -1, -1, 51, -1, 53, -1, -1, -1, -1, 
+  -1, -1, -1, -1, -1, -1, -1, 65, 66, 67, 
+  68, -1, 70, -1, 72, -1, 74, -1, 76, -1, 
+  -1, -1, -1, 81, 82, 83, -1, -1, -1, 87, 
+  -1, -1, -1, -1, 92, -1, -1, -1, -1, -1, 
+  -1, -1, -1, 11, 12, 13, -1, -1, -1, -1, 
+  -1, -1, -1, -1, 22, -1, -1, -1, -1, -1, 
+  -1, 29, -1, -1, -1, 33, 34, -1, 36, -1, 
+  -1, -1, 40, -1, 42, 43, 44, -1, -1, 47, 
+  -1, -1, -1, 51, -1, 53, -1, -1, -1, -1, 
+  -1, -1, -1, -1, -1, -1, -1, 65, 66, 67, 
+  68, -1, 70, -1, 72, -1, 74, 75, 76, -1, 
+  -1, -1, -1, 81, 82, 83, -1, -1, -1, 87, 
+  -1, -1, -1, -1, 92, -1, -1, -1, -1, -1, 
+  -1, -1, -1, 8, -1, -1, 11, 12, 13, -1, 
+  -1, -1, -1, -1, -1, -1, -1, 22, -1, -1, 
+  -1, -1, -1, -1, 29, -1, -1, -1, 33, 34, 
+  -1, 36, -1, -1, -1, 40, -1, 42, 43, 44, 
+  -1, -1, 47, -1, -1, -1, 51, -1, 53, -1, 
+  -1, 56, -1, -1, -1, -1, -1, -1, -1, -1, 
+  65, 66, 67, 68, -1, 70, -1, 72, -1, 74, 
+  -1, 76, -1, -1, -1, -1, 81, 82, 83, -1, 
+  -1, -1, 87, -1, -1, -1, -1, 92, -1, -1, 
+  -1, -1, -1, -1, -1, -1, 8, -1, -1, 11, 
+  12, 13, -1, -1, -1, -1, -1, -1, -1, -1, 
+  22, -1, -1, -1, -1, -1, -1, 29, -1, -1, 
+  -1, 33, 34, -1, 36, -1, -1, -1, 40, -1, 
+  42, 43, 44, -1, -1, 47, -1, -1, -1, 51, 
+  -1, 53, -1, -1, 56, -1, -1, -1, -1, -1, 
+  -1, -1, -1, 65, 66, 67, 68, -1, 70, -1, 
+  72, -1, 74, -1, 76, -1, -1, -1, -1, 81, 
+  82, 83, -1, -1, -1, 87, -1, -1, -1, -1, 
+  92, -1, -1, -1, -1, -1, -1, -1, -1, 8, 
+  -1, -1, 11, 12, 13, -1, -1, -1, -1, -1, 
+  -1, -1, -1, 22, -1, -1, -1, -1, -1, -1, 
+  29, -1, -1, -1, 33, 34, -1, 36, -1, -1, 
+  -1, 40, -1, 42, 43, 44, -1, -1, 47, -1, 
+  -1, -1, 51, -1, 53, -1, -1, 56, -1, -1, 
+  -1, -1, -1, -1, -1, -1, 65, 66, 67, 68, 
+  -1, 70, -1, 72, -1, 74, -1, 76, -1, -1, 
+  -1, -1, 81, 82, 83, -1, -1, -1, 87, -1, 
+  -1, -1, -1, 92, -1, -1, -1, -1, -1, -1, 
+  -1, -1, 8, -1, -1, 11, 12, 13, -1, -1, 
+  -1, -1, -1, -1, -1, -1, 22, -1, -1, -1, 
+  -1, -1, -1, 29, -1, -1, -1, 33, 34, -1, 
+  36, -1, -1, -1, 40, -1, 42, 43, 44, -1, 
+  -1, 47, -1, -1, -1, 51, -1, 53, -1, -1, 
+  56, -1, -1, -1, -1, -1, -1, -1, -1, 65, 
+  66, 67, 68, -1, 70, -1, 72, -1, 74, -1, 
+  76, -1, -1, -1, -1, 81, 82, 83, -1, -1, 
+  -1, 87, -1, -1, -1, -1, 92, -1, -1, -1, 
+  -1, -1, -1, -1, -1, 11, 12, 13, -1, -1, 
+  -1, -1, -1, -1, -1, -1, 22, -1, -1, -1, 
+  -1, -1, -1, 29, 30, -1, -1, 33, 34, -1, 
+  36, -1, -1, -1, 40, -1, 42, 43, 44, -1, 
+  -1, 47, -1, -1, -1, 51, -1, 53, -1, -1, 
+  -1, -1, -1, -1, -1, 61, -1, -1, -1, 65, 
+  66, 67, 68, -1, 70, -1, 72, -1, 74, -1, 
+  76, -1, -1, -1, -1, 81, 82, 83, -1, -1, 
+  -1, 87, -1, -1, -1, -1, 92, -1, -1, -1, 
+  -1, -1, -1, -1, -1, 4, 5, 6, -1, -1, 
+  9, 10, 11, -1, -1, 14, -1, 16, -1, -1, 
+  -1, 20, 21, 22, -1, -1, -1, -1, -1, -1, 
+  29, 30, 31, 32, -1, -1, -1, -1, -1, -1, 
+  -1, -1, -1, -1, 43, -1, -1, -1, -1, -1, 
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+  59, -1, -1, -1, -1, -1, -1, 66, 67, 68, 
+  69, 70, 71, -1, 73, 74, 75, 76, 77, 78, 
+  -1, -1, 81, 82, 83, 84, 85, 86, -1, -1, 
+  -1, -1, -1, 92, -1, -1, -1, -1, -1, -1, 
+  -1, -1, 4, 5, 6, -1, -1, 9, 10, 11, 
+  -1, -1, 14, -1, 16, -1, -1, -1, 20, 21, 
+  22, -1, -1, -1, -1, -1, -1, 29, 30, 31, 
+  32, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+  -1, 43, -1, -1, -1, 47, -1, -1, -1, -1, 
+  -1, -1, -1, -1, -1, -1, -1, 59, -1, -1, 
+  -1, -1, -1, 65, 66, 67, -1, 69, 70, 71, 
+  -1, 73, 74, 75, 76, 77, 78, -1, -1, 81, 
+  82, 83, 84, 85, 86, -1, -1, -1, -1, -1, 
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, 4, 
+  5, 6, -1, -1, 9, 10, 11, -1, -1, 14, 
+  -1, 16, -1, -1, -1, 20, 21, 22, -1, -1, 
+  -1, -1, -1, -1, 29, 30, 31, 32, -1, -1, 
+  -1, -1, -1, -1, -1, -1, -1, -1, 43, -1, 
+  -1, -1, 47, -1, -1, -1, -1, -1, -1, -1, 
+  55, -1, -1, -1, 59, -1, -1, -1, -1, -1, 
+  65, 66, 67, -1, 69, 70, 71, -1, 73, 74, 
+  75, 76, 77, 78, -1, -1, 81, 82, 83, 84, 
+  85, 86, -1, -1, -1, -1, -1, -1, -1, -1, 
+  -1, -1, -1, -1, -1, -1, 4, -1, -1, -1, 
+  -1, 9, -1, 11, 12, 13, 14, -1, -1, -1, 
+  -1, -1, -1, 21, 22, -1, -1, -1, -1, -1, 
+  -1, 29, 30, -1, -1, 33, 34, -1, 36, -1, 
+  -1, -1, 40, -1, 42, 43, 44, -1, -1, 47, 
+  -1, -1, -1, 51, -1, 53, -1, -1, -1, -1, 
+  -1, 59, -1, 61, -1, -1, -1, 65, 66, 67, 
+  68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 
+  78, -1, -1, 81, 82, 83, 84, 85, -1, 87, 
+  -1, -1, -1, -1, 92, -1, -1, -1, -1, -1, 
+  -1, -1, -1, 4, -1, -1, -1, -1, 9, -1, 
+  11, 12, 13, 14, -1, -1, -1, -1, -1, -1, 
+  21, 22, -1, -1, -1, -1, -1, -1, 29, 30, 
+  -1, -1, 33, 34, -1, 36, -1, -1, -1, 40, 
+  -1, 42, 43, 44, -1, -1, 47, -1, -1, -1, 
+  51, -1, 53, -1, -1, -1, -1, -1, 59, -1, 
+  61, -1, -1, -1, 65, 66, 67, 68, 69, 70, 
+  71, 72, 73, 74, 75, 76, 77, 78, -1, -1, 
+  81, 82, 83, 84, 85, -1, 87, -1, -1, -1, 
+  -1, 92, -1, -1, -1, -1, -1, -1, -1, -1, 
+  4, 5, 6, -1, -1, 9, 10, 11, 12, 13, 
+  14, -1, 16, -1, -1, -1, 20, 21, 22, -1, 
+  -1, -1, -1, -1, -1, 29, 30, 31, 32, 33, 
+  34, -1, 36, -1, -1, -1, 40, -1, 42, 43, 
+  44, -1, -1, 47, -1, -1, -1, 51, -1, 53, 
+  -1, -1, -1, -1, -1, 59, -1, 61, -1, -1, 
+  -1, 65, 66, 67, 68, 69, 70, 71, 72, 73, 
+  74, 75, 76, 77, 78, -1, -1, 81, 82, 83, 
+  84, 85, 86, 87, -1, -1, -1, -1, 92, -1, 
+  -1, -1, -1, -1, -1, -1, -1, 4, 5, 6, 
+  -1, -1, 9, 10, 11, 12, 13, 14, -1, 16, 
+  -1, -1, -1, 20, 21, 22, -1, -1, -1, -1, 
+  -1, -1, 29, 30, 31, 32, 33, 34, -1, 36, 
+  -1, -1, -1, 40, -1, 42, 43, 44, -1, -1, 
+  47, -1, -1, -1, 51, -1, 53, -1, 55, -1, 
+  -1, -1, 59, -1, 61, -1, -1, -1, 65, 66, 
+  67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 
+  77, 78, -1, -1, 81, 82, 83, 84, 85, 86, 
+  87, -1, -1, -1, -1, 92, -1, -1, -1, -1, 
+  -1, -1, -1, -1, 
+
+  35, 15, 15, 15, 2, 15, 3, 2, 25, 3, 
+  15, 15, 104, 15, 4, 3, 3, 3, 19, 15, 
+  2, 21, 15, 15, 3, 67, 25, 3, 19, 2, 
+  15, 2, 15, 13, 15, 19, 25, 3, 15, 11, 
+  15, 2, 96, 3, 2, 15, 2, 25, 3, 2, 
+  15, 100, 15, 93, 3, 2, 15, 98, 15, 2, 
+  2, 35, 3, 3, 15, 2, 35, 35, 35, 21, 
+  2, 25, 3, 35, 4, 21, 15, 2, 2, 15, 
+  2, 4, 3, 3, 3, 35, 2, 35, 21, 3, 
+  35, 3, 36, 21, 3, 13, 2, 35, 13, -1, 
+  35, 35, 2, -1, 15, 13, 35, -1, 16, -1, 
+  -1, 40, -1, -1, -1, -1, 13, 44, 44, 46, 
+  46, 13, 15, -1, 16, -1, 41, 44, -1, 46, 
+  35, 44, -1, 46, 44, 40, 46, 44, 3, 46, 
+  44, 44, 44, 44, 41, 44, 49, 49, 49, 44, 
+  49, 46, 2, 44, 58, 46, 44, 44, 44, 15, 
+  46, 49, 49, 44, 44, 44, 46, 44, 44, 44, 
+  49, 15, 49, 49, 44, 81, 44, 52, 44, 60, 
+  50, 81, 50, 44, 50, 44, 44, 44, 99, 3, 
+  49, 49, 13, 37, 87, 56, 44, 54, 44, 20, 
+  3, 49, 48, 68, 44, 44, 44, 44, 48, 48, 
+  47, 44, 50, 46, 44, 44, 46, 46, 44, 44, 
+  46, 44, 47, 46, 44, 44, 46, 46, 44, 85, 
+  46, 3, 13, 31, 44, 15, 44, 35, -1, 49, 
+  44, 49, 44, 51, 44, 49, -1, 49, 44, 49, 
+  -1, 61, -1, 49, 68, -1, 13, 37, 38, 16, 
+  41, 57, 66, -1, 66, 68, 66, 44, 44, 44, 
+  -1, -1, 49, 49, 49, 51, 51, 44, 55, 44, 
+  44, 44, 49, 44, 49, 49, 49, 51, 49, -1, 
+  53, 13, 59, -1, 13, 5, 68, 16, 20, 18, 
+  5, 66, -1, 13, -1, 66, 28, 29, 13, -1, 
+  20, -1, -1, -1, -1, 20, 35, -1, 28, 29, 
+  13, -1, -1, 28, 29, -1, -1, 20, 21, 22, 
+  23, 24, -1, -1, -1, -1, -1, -1, -1, -1, 
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, 3, 
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, 13, 
+  -1, -1, -1, -1, -1, -1, 20, -1, -1, -1, 
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 
+  -1, -1};
+
+QT_END_NAMESPACE
diff --git a/tools/qdoc3/declarativeparser/qdeclarativejsgrammar_p.h b/tools/qdoc3/declarativeparser/qdeclarativejsgrammar_p.h
new file mode 100644
index 0000000..ed3ca19
--- /dev/null
+++ b/tools/qdoc3/declarativeparser/qdeclarativejsgrammar_p.h
@@ -0,0 +1,210 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+// This file was generated by qlalr - DO NOT EDIT!
+#ifndef QDECLARATIVEJSGRAMMAR_P_H
+#define QDECLARATIVEJSGRAMMAR_P_H
+
+#include <QtCore/qglobal.h>
+
+QT_BEGIN_NAMESPACE
+
+class QDeclarativeJSGrammar
+{
+public:
+  enum VariousConstants {
+    EOF_SYMBOL = 0,
+    REDUCE_HERE = 100,
+    SHIFT_THERE = 99,
+    T_AND = 1,
+    T_AND_AND = 2,
+    T_AND_EQ = 3,
+    T_AS = 91,
+    T_AUTOMATIC_SEMICOLON = 62,
+    T_BREAK = 4,
+    T_CASE = 5,
+    T_CATCH = 6,
+    T_COLON = 7,
+    T_COMMA = 8,
+    T_COMMENT = 88,
+    T_CONST = 84,
+    T_CONTINUE = 9,
+    T_DEBUGGER = 85,
+    T_DEFAULT = 10,
+    T_DELETE = 11,
+    T_DIVIDE_ = 12,
+    T_DIVIDE_EQ = 13,
+    T_DO = 14,
+    T_DOT = 15,
+    T_ELSE = 16,
+    T_EQ = 17,
+    T_EQ_EQ = 18,
+    T_EQ_EQ_EQ = 19,
+    T_FALSE = 83,
+    T_FEED_JS_EXPRESSION = 96,
+    T_FEED_JS_PROGRAM = 98,
+    T_FEED_JS_SOURCE_ELEMENT = 97,
+    T_FEED_JS_STATEMENT = 95,
+    T_FEED_UI_OBJECT_MEMBER = 94,
+    T_FEED_UI_PROGRAM = 93,
+    T_FINALLY = 20,
+    T_FOR = 21,
+    T_FUNCTION = 22,
+    T_GE = 23,
+    T_GT = 24,
+    T_GT_GT = 25,
+    T_GT_GT_EQ = 26,
+    T_GT_GT_GT = 27,
+    T_GT_GT_GT_EQ = 28,
+    T_IDENTIFIER = 29,
+    T_IF = 30,
+    T_IMPORT = 90,
+    T_IN = 31,
+    T_INSTANCEOF = 32,
+    T_LBRACE = 33,
+    T_LBRACKET = 34,
+    T_LE = 35,
+    T_LPAREN = 36,
+    T_LT = 37,
+    T_LT_LT = 38,
+    T_LT_LT_EQ = 39,
+    T_MINUS = 40,
+    T_MINUS_EQ = 41,
+    T_MINUS_MINUS = 42,
+    T_MULTILINE_STRING_LITERAL = 87,
+    T_NEW = 43,
+    T_NOT = 44,
+    T_NOT_EQ = 45,
+    T_NOT_EQ_EQ = 46,
+    T_NULL = 81,
+    T_NUMERIC_LITERAL = 47,
+    T_ON = 92,
+    T_OR = 48,
+    T_OR_EQ = 49,
+    T_OR_OR = 50,
+    T_PLUS = 51,
+    T_PLUS_EQ = 52,
+    T_PLUS_PLUS = 53,
+    T_PROPERTY = 66,
+    T_PUBLIC = 89,
+    T_QUESTION = 54,
+    T_RBRACE = 55,
+    T_RBRACKET = 56,
+    T_READONLY = 68,
+    T_REMAINDER = 57,
+    T_REMAINDER_EQ = 58,
+    T_RESERVED_WORD = 86,
+    T_RETURN = 59,
+    T_RPAREN = 60,
+    T_SEMICOLON = 61,
+    T_SIGNAL = 67,
+    T_STAR = 63,
+    T_STAR_EQ = 64,
+    T_STRING_LITERAL = 65,
+    T_SWITCH = 69,
+    T_THIS = 70,
+    T_THROW = 71,
+    T_TILDE = 72,
+    T_TRUE = 82,
+    T_TRY = 73,
+    T_TYPEOF = 74,
+    T_VAR = 75,
+    T_VOID = 76,
+    T_WHILE = 77,
+    T_WITH = 78,
+    T_XOR = 79,
+    T_XOR_EQ = 80,
+
+    ACCEPT_STATE = 645,
+    RULE_COUNT = 347,
+    STATE_COUNT = 646,
+    TERMINAL_COUNT = 101,
+    NON_TERMINAL_COUNT = 106,
+
+    GOTO_INDEX_OFFSET = 646,
+    GOTO_INFO_OFFSET = 2714,
+    GOTO_CHECK_OFFSET = 2714
+  };
+
+  static const char  *const    spell [];
+  static const short             lhs [];
+  static const short             rhs [];
+  static const short    goto_default [];
+  static const short  action_default [];
+  static const short    action_index [];
+  static const short     action_info [];
+  static const short    action_check [];
+
+  static inline int nt_action (int state, int nt)
+  {
+    const int yyn = action_index [GOTO_INDEX_OFFSET + state] + nt;
+    if (yyn < 0 || action_check [GOTO_CHECK_OFFSET + yyn] != nt)
+      return goto_default [nt];
+
+    return action_info [GOTO_INFO_OFFSET + yyn];
+  }
+
+  static inline int t_action (int state, int token)
+  {
+    const int yyn = action_index [state] + token;
+
+    if (yyn < 0 || action_check [yyn] != token)
+      return - action_default [state];
+
+    return action_info [yyn];
+  }
+};
+
+
+QT_END_NAMESPACE
+#endif // QDECLARATIVEJSGRAMMAR_P_H
+
diff --git a/tools/qdoc3/declarativeparser/qdeclarativejslexer.cpp b/tools/qdoc3/declarativeparser/qdeclarativejslexer.cpp
new file mode 100644
index 0000000..4dfef45
--- /dev/null
+++ b/tools/qdoc3/declarativeparser/qdeclarativejslexer.cpp
@@ -0,0 +1,1258 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "private/qdeclarativejslexer_p.h"
+
+#include "private/qdeclarativejsglobal_p.h"
+#include "private/qdeclarativejsengine_p.h"
+#include "private/qdeclarativejsgrammar_p.h"
+
+#include <QtCore/qcoreapplication.h>
+
+#include <ctype.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+QT_BEGIN_NAMESPACE
+Q_CORE_EXPORT double qstrtod(const char *s00, char const **se, bool *ok);
+QT_END_NAMESPACE
+
+QT_QML_BEGIN_NAMESPACE
+
+#define shiftWindowsLineBreak() \
+    do { \
+        if (((current == '\r') && (next1 == '\n')) \
+            || ((current == '\n') && (next1 == '\r'))) { \
+            shift(1); \
+        } \
+    } \
+    while (0)
+
+namespace QDeclarativeJS {
+extern double integerFromString(const char *buf, int size, int radix);
+}
+
+using namespace QDeclarativeJS;
+
+Lexer::Lexer(Engine *eng, bool tokenizeComments)
+    : driver(eng),
+      yylineno(0),
+      done(false),
+      size8(128), size16(128),
+      pos8(0), pos16(0),
+      terminator(false),
+      restrKeyword(false),
+      delimited(false),
+      stackToken(-1),
+      state(Start),
+      pos(0),
+      code(0), length(0),
+      yycolumn(0),
+      startpos(0),
+      startlineno(0), startcolumn(0),
+      bol(true),
+      current(0), next1(0), next2(0), next3(0),
+      err(NoError),
+      wantRx(false),
+      check_reserved(true),
+      parenthesesState(IgnoreParentheses),
+      parenthesesCount(0),
+      prohibitAutomaticSemicolon(false),
+      tokenizeComments(tokenizeComments)
+{
+    if (driver) driver->setLexer(this);
+    // allocate space for read buffers
+    buffer8 = new char[size8];
+    buffer16 = new QChar[size16];
+    pattern = 0;
+    flags = 0;
+
+}
+
+Lexer::~Lexer()
+{
+    delete [] buffer8;
+    delete [] buffer16;
+}
+
+void Lexer::setCode(const QString &c, int lineno)
+{
+    errmsg.clear();
+    yylineno = lineno;
+    yycolumn = 1;
+    restrKeyword = false;
+    delimited = false;
+    stackToken = -1;
+    pos = 0;
+    code = c.unicode();
+    length = c.length();
+    bol = true;
+
+    // read first characters
+    current = (length > 0) ? code[0].unicode() : 0;
+    next1 = (length > 1) ? code[1].unicode() : 0;
+    next2 = (length > 2) ? code[2].unicode() : 0;
+    next3 = (length > 3) ? code[3].unicode() : 0;
+}
+
+void Lexer::shift(uint p)
+{
+    while (p--) {
+        ++pos;
+        ++yycolumn;
+        current = next1;
+        next1 = next2;
+        next2 = next3;
+        next3 = (pos + 3 < length) ? code[pos+3].unicode() : 0;
+    }
+}
+
+void Lexer::setDone(State s)
+{
+    state = s;
+    done = true;
+}
+
+int Lexer::findReservedWord(const QChar *c, int size) const
+{
+    switch (size) {
+    case 2: {
+        if (c[0] == QLatin1Char('d') && c[1] == QLatin1Char('o'))
+            return QDeclarativeJSGrammar::T_DO;
+        else if (c[0] == QLatin1Char('i') && c[1] == QLatin1Char('f'))
+            return QDeclarativeJSGrammar::T_IF;
+        else if (c[0] == QLatin1Char('i') && c[1] == QLatin1Char('n'))
+            return QDeclarativeJSGrammar::T_IN;
+        else if (c[0] == QLatin1Char('a') && c[1] == QLatin1Char('s'))
+            return QDeclarativeJSGrammar::T_AS;
+        else if (c[0] == QLatin1Char('o') && c[1] == QLatin1Char('n'))
+            return QDeclarativeJSGrammar::T_ON;
+    }   break;
+
+    case 3: {
+        if (c[0] == QLatin1Char('f') && c[1] == QLatin1Char('o') && c[2] == QLatin1Char('r'))
+            return QDeclarativeJSGrammar::T_FOR;
+        else if (c[0] == QLatin1Char('n') && c[1] == QLatin1Char('e') && c[2] == QLatin1Char('w'))
+            return QDeclarativeJSGrammar::T_NEW;
+        else if (c[0] == QLatin1Char('t') && c[1] == QLatin1Char('r') && c[2] == QLatin1Char('y'))
+            return QDeclarativeJSGrammar::T_TRY;
+        else if (c[0] == QLatin1Char('v') && c[1] == QLatin1Char('a') && c[2] == QLatin1Char('r'))
+            return QDeclarativeJSGrammar::T_VAR;
+        else if (check_reserved) {
+            if (c[0] == QLatin1Char('i') && c[1] == QLatin1Char('n') && c[2] == QLatin1Char('t'))
+                return QDeclarativeJSGrammar::T_RESERVED_WORD;
+        }
+    }   break;
+
+    case 4: {
+        if (c[0] == QLatin1Char('c') && c[1] == QLatin1Char('a')
+                && c[2] == QLatin1Char('s') && c[3] == QLatin1Char('e'))
+            return QDeclarativeJSGrammar::T_CASE;
+        else if (c[0] == QLatin1Char('e') && c[1] == QLatin1Char('l')
+                && c[2] == QLatin1Char('s') && c[3] == QLatin1Char('e'))
+            return QDeclarativeJSGrammar::T_ELSE;
+        else if (c[0] == QLatin1Char('t') && c[1] == QLatin1Char('h')
+                && c[2] == QLatin1Char('i') && c[3] == QLatin1Char('s'))
+            return QDeclarativeJSGrammar::T_THIS;
+        else if (c[0] == QLatin1Char('v') && c[1] == QLatin1Char('o')
+                && c[2] == QLatin1Char('i') && c[3] == QLatin1Char('d'))
+            return QDeclarativeJSGrammar::T_VOID;
+        else if (c[0] == QLatin1Char('w') && c[1] == QLatin1Char('i')
+                && c[2] == QLatin1Char('t') && c[3] == QLatin1Char('h'))
+            return QDeclarativeJSGrammar::T_WITH;
+        else if (c[0] == QLatin1Char('t') && c[1] == QLatin1Char('r')
+                && c[2] == QLatin1Char('u') && c[3] == QLatin1Char('e'))
+            return QDeclarativeJSGrammar::T_TRUE;
+        else if (c[0] == QLatin1Char('n') && c[1] == QLatin1Char('u')
+                && c[2] == QLatin1Char('l') && c[3] == QLatin1Char('l'))
+            return QDeclarativeJSGrammar::T_NULL;
+        else if (check_reserved) {
+            if (c[0] == QLatin1Char('e') && c[1] == QLatin1Char('n')
+                    && c[2] == QLatin1Char('u') && c[3] == QLatin1Char('m'))
+                return QDeclarativeJSGrammar::T_RESERVED_WORD;
+            else if (c[0] == QLatin1Char('b') && c[1] == QLatin1Char('y')
+                    && c[2] == QLatin1Char('t') && c[3] == QLatin1Char('e'))
+                return QDeclarativeJSGrammar::T_RESERVED_WORD;
+            else if (c[0] == QLatin1Char('l') && c[1] == QLatin1Char('o')
+                    && c[2] == QLatin1Char('n') && c[3] == QLatin1Char('g'))
+                return QDeclarativeJSGrammar::T_RESERVED_WORD;
+            else if (c[0] == QLatin1Char('c') && c[1] == QLatin1Char('h')
+                    && c[2] == QLatin1Char('a') && c[3] == QLatin1Char('r'))
+                return QDeclarativeJSGrammar::T_RESERVED_WORD;
+            else if (c[0] == QLatin1Char('g') && c[1] == QLatin1Char('o')
+                    && c[2] == QLatin1Char('t') && c[3] == QLatin1Char('o'))
+                return QDeclarativeJSGrammar::T_RESERVED_WORD;
+        }
+    }   break;
+
+    case 5: {
+        if (c[0] == QLatin1Char('b') && c[1] == QLatin1Char('r')
+                && c[2] == QLatin1Char('e') && c[3] == QLatin1Char('a')
+                && c[4] == QLatin1Char('k'))
+            return QDeclarativeJSGrammar::T_BREAK;
+        else if (c[0] == QLatin1Char('c') && c[1] == QLatin1Char('a')
+                && c[2] == QLatin1Char('t') && c[3] == QLatin1Char('c')
+                && c[4] == QLatin1Char('h'))
+            return QDeclarativeJSGrammar::T_CATCH;
+        else if (c[0] == QLatin1Char('t') && c[1] == QLatin1Char('h')
+                && c[2] == QLatin1Char('r') && c[3] == QLatin1Char('o')
+                && c[4] == QLatin1Char('w'))
+            return QDeclarativeJSGrammar::T_THROW;
+        else if (c[0] == QLatin1Char('w') && c[1] == QLatin1Char('h')
+                && c[2] == QLatin1Char('i') && c[3] == QLatin1Char('l')
+                && c[4] == QLatin1Char('e'))
+            return QDeclarativeJSGrammar::T_WHILE;
+        else if (c[0] == QLatin1Char('c') && c[1] == QLatin1Char('o')
+                && c[2] == QLatin1Char('n') && c[3] == QLatin1Char('s')
+                && c[4] == QLatin1Char('t'))
+            return QDeclarativeJSGrammar::T_CONST;
+        else if (c[0] == QLatin1Char('f') && c[1] == QLatin1Char('a')
+                && c[2] == QLatin1Char('l') && c[3] == QLatin1Char('s')
+                && c[4] == QLatin1Char('e'))
+            return QDeclarativeJSGrammar::T_FALSE;
+        else if (check_reserved) {
+            if (c[0] == QLatin1Char('s') && c[1] == QLatin1Char('h')
+                    && c[2] == QLatin1Char('o') && c[3] == QLatin1Char('r')
+                    && c[4] == QLatin1Char('t'))
+                return QDeclarativeJSGrammar::T_RESERVED_WORD;
+            else if (c[0] == QLatin1Char('s') && c[1] == QLatin1Char('u')
+                    && c[2] == QLatin1Char('p') && c[3] == QLatin1Char('e')
+                    && c[4] == QLatin1Char('r'))
+                return QDeclarativeJSGrammar::T_RESERVED_WORD;
+            else if (c[0] == QLatin1Char('f') && c[1] == QLatin1Char('i')
+                    && c[2] == QLatin1Char('n') && c[3] == QLatin1Char('a')
+                    && c[4] == QLatin1Char('l'))
+                return QDeclarativeJSGrammar::T_RESERVED_WORD;
+            else if (c[0] == QLatin1Char('c') && c[1] == QLatin1Char('l')
+                    && c[2] == QLatin1Char('a') && c[3] == QLatin1Char('s')
+                    && c[4] == QLatin1Char('s'))
+                return QDeclarativeJSGrammar::T_RESERVED_WORD;
+            else if (c[0] == QLatin1Char('f') && c[1] == QLatin1Char('l')
+                    && c[2] == QLatin1Char('o') && c[3] == QLatin1Char('a')
+                    && c[4] == QLatin1Char('t'))
+                return QDeclarativeJSGrammar::T_RESERVED_WORD;
+        }
+    }   break;
+
+    case 6: {
+        if (c[0] == QLatin1Char('d') && c[1] == QLatin1Char('e')
+                && c[2] == QLatin1Char('l') && c[3] == QLatin1Char('e')
+                && c[4] == QLatin1Char('t') && c[5] == QLatin1Char('e'))
+            return QDeclarativeJSGrammar::T_DELETE;
+        else if (c[0] == QLatin1Char('r') && c[1] == QLatin1Char('e')
+                && c[2] == QLatin1Char('t') && c[3] == QLatin1Char('u')
+                && c[4] == QLatin1Char('r') && c[5] == QLatin1Char('n'))
+            return QDeclarativeJSGrammar::T_RETURN;
+        else if (c[0] == QLatin1Char('s') && c[1] == QLatin1Char('w')
+                && c[2] == QLatin1Char('i') && c[3] == QLatin1Char('t')
+                && c[4] == QLatin1Char('c') && c[5] == QLatin1Char('h'))
+            return QDeclarativeJSGrammar::T_SWITCH;
+        else if (c[0] == QLatin1Char('t') && c[1] == QLatin1Char('y')
+                && c[2] == QLatin1Char('p') && c[3] == QLatin1Char('e')
+                && c[4] == QLatin1Char('o') && c[5] == QLatin1Char('f'))
+            return QDeclarativeJSGrammar::T_TYPEOF;
+        else if (c[0] == QLatin1Char('i') && c[1] == QLatin1Char('m')
+            && c[2] == QLatin1Char('p') && c[3] == QLatin1Char('o')
+            && c[4] == QLatin1Char('r') && c[5] == QLatin1Char('t'))
+            return QDeclarativeJSGrammar::T_IMPORT;
+        else if (c[0] == QLatin1Char('s') && c[1] == QLatin1Char('i')
+            && c[2] == QLatin1Char('g') && c[3] == QLatin1Char('n')
+            && c[4] == QLatin1Char('a') && c[5] == QLatin1Char('l'))
+            return QDeclarativeJSGrammar::T_SIGNAL;
+        else if (check_reserved) {
+            if (c[0] == QLatin1Char('e') && c[1] == QLatin1Char('x')
+                    && c[2] == QLatin1Char('p') && c[3] == QLatin1Char('o')
+                    && c[4] == QLatin1Char('r') && c[5] == QLatin1Char('t'))
+                return QDeclarativeJSGrammar::T_RESERVED_WORD;
+            else if (c[0] == QLatin1Char('s') && c[1] == QLatin1Char('t')
+                    && c[2] == QLatin1Char('a') && c[3] == QLatin1Char('t')
+                    && c[4] == QLatin1Char('i') && c[5] == QLatin1Char('c'))
+                return QDeclarativeJSGrammar::T_RESERVED_WORD;
+            else if (c[0] == QLatin1Char('d') && c[1] == QLatin1Char('o')
+                    && c[2] == QLatin1Char('u') && c[3] == QLatin1Char('b')
+                    && c[4] == QLatin1Char('l') && c[5] == QLatin1Char('e'))
+                return QDeclarativeJSGrammar::T_RESERVED_WORD;
+            else if (c[0] == QLatin1Char('i') && c[1] == QLatin1Char('m')
+                    && c[2] == QLatin1Char('p') && c[3] == QLatin1Char('o')
+                    && c[4] == QLatin1Char('r') && c[5] == QLatin1Char('t'))
+                return QDeclarativeJSGrammar::T_RESERVED_WORD;
+            else if (c[0] == QLatin1Char('p') && c[1] == QLatin1Char('u')
+                    && c[2] == QLatin1Char('b') && c[3] == QLatin1Char('l')
+                    && c[4] == QLatin1Char('i') && c[5] == QLatin1Char('c'))
+                return QDeclarativeJSGrammar::T_PUBLIC;
+            else if (c[0] == QLatin1Char('n') && c[1] == QLatin1Char('a')
+                    && c[2] == QLatin1Char('t') && c[3] == QLatin1Char('i')
+                    && c[4] == QLatin1Char('v') && c[5] == QLatin1Char('e'))
+                return QDeclarativeJSGrammar::T_RESERVED_WORD;
+            else if (c[0] == QLatin1Char('t') && c[1] == QLatin1Char('h')
+                    && c[2] == QLatin1Char('r') && c[3] == QLatin1Char('o')
+                    && c[4] == QLatin1Char('w') && c[5] == QLatin1Char('s'))
+                return QDeclarativeJSGrammar::T_RESERVED_WORD;
+        }
+    }   break;
+
+    case 7: {
+        if (c[0] == QLatin1Char('d') && c[1] == QLatin1Char('e')
+                && c[2] == QLatin1Char('f') && c[3] == QLatin1Char('a')
+                && c[4] == QLatin1Char('u') && c[5] == QLatin1Char('l')
+                && c[6] == QLatin1Char('t'))
+            return QDeclarativeJSGrammar::T_DEFAULT;
+        else if (c[0] == QLatin1Char('f') && c[1] == QLatin1Char('i')
+                && c[2] == QLatin1Char('n') && c[3] == QLatin1Char('a')
+                && c[4] == QLatin1Char('l') && c[5] == QLatin1Char('l')
+                && c[6] == QLatin1Char('y'))
+            return QDeclarativeJSGrammar::T_FINALLY;
+        else if (check_reserved) {
+            if (c[0] == QLatin1Char('b') && c[1] == QLatin1Char('o')
+                    && c[2] == QLatin1Char('o') && c[3] == QLatin1Char('l')
+                    && c[4] == QLatin1Char('e') && c[5] == QLatin1Char('a')
+                    && c[6] == QLatin1Char('n'))
+                return QDeclarativeJSGrammar::T_RESERVED_WORD;
+            else if (c[0] == QLatin1Char('e') && c[1] == QLatin1Char('x')
+                    && c[2] == QLatin1Char('t') && c[3] == QLatin1Char('e')
+                    && c[4] == QLatin1Char('n') && c[5] == QLatin1Char('d')
+                    && c[6] == QLatin1Char('s'))
+                return QDeclarativeJSGrammar::T_RESERVED_WORD;
+            else if (c[0] == QLatin1Char('p') && c[1] == QLatin1Char('a')
+                    && c[2] == QLatin1Char('c') && c[3] == QLatin1Char('k')
+                    && c[4] == QLatin1Char('a') && c[5] == QLatin1Char('g')
+                    && c[6] == QLatin1Char('e'))
+                return QDeclarativeJSGrammar::T_RESERVED_WORD;
+            else if (c[0] == QLatin1Char('p') && c[1] == QLatin1Char('r')
+                    && c[2] == QLatin1Char('i') && c[3] == QLatin1Char('v')
+                    && c[4] == QLatin1Char('a') && c[5] == QLatin1Char('t')
+                    && c[6] == QLatin1Char('e'))
+                return QDeclarativeJSGrammar::T_RESERVED_WORD;
+        }
+    }   break;
+
+    case 8: {
+        if (c[0] == QLatin1Char('c') && c[1] == QLatin1Char('o')
+                && c[2] == QLatin1Char('n') && c[3] == QLatin1Char('t')
+                && c[4] == QLatin1Char('i') && c[5] == QLatin1Char('n')
+                && c[6] == QLatin1Char('u') && c[7] == QLatin1Char('e'))
+            return QDeclarativeJSGrammar::T_CONTINUE;
+        else if (c[0] == QLatin1Char('f') && c[1] == QLatin1Char('u')
+                && c[2] == QLatin1Char('n') && c[3] == QLatin1Char('c')
+                && c[4] == QLatin1Char('t') && c[5] == QLatin1Char('i')
+                && c[6] == QLatin1Char('o') && c[7] == QLatin1Char('n'))
+            return QDeclarativeJSGrammar::T_FUNCTION;
+        else if (c[0] == QLatin1Char('d') && c[1] == QLatin1Char('e')
+                && c[2] == QLatin1Char('b') && c[3] == QLatin1Char('u')
+                && c[4] == QLatin1Char('g') && c[5] == QLatin1Char('g')
+                && c[6] == QLatin1Char('e') && c[7] == QLatin1Char('r'))
+            return QDeclarativeJSGrammar::T_DEBUGGER;
+        else if (c[0] == QLatin1Char('p') && c[1] == QLatin1Char('r')
+                && c[2] == QLatin1Char('o') && c[3] == QLatin1Char('p')
+                && c[4] == QLatin1Char('e') && c[5] == QLatin1Char('r')
+                && c[6] == QLatin1Char('t') && c[7] == QLatin1Char('y'))
+            return QDeclarativeJSGrammar::T_PROPERTY;
+        else if (c[0] == QLatin1Char('r') && c[1] == QLatin1Char('e')
+                && c[2] == QLatin1Char('a') && c[3] == QLatin1Char('d')
+                && c[4] == QLatin1Char('o') && c[5] == QLatin1Char('n')
+                && c[6] == QLatin1Char('l') && c[7] == QLatin1Char('y'))
+            return QDeclarativeJSGrammar::T_READONLY;
+        else if (check_reserved) {
+            if (c[0] == QLatin1Char('a') && c[1] == QLatin1Char('b')
+                    && c[2] == QLatin1Char('s') && c[3] == QLatin1Char('t')
+                    && c[4] == QLatin1Char('r') && c[5] == QLatin1Char('a')
+                    && c[6] == QLatin1Char('c') && c[7] == QLatin1Char('t'))
+                return QDeclarativeJSGrammar::T_RESERVED_WORD;
+            else if (c[0] == QLatin1Char('v') && c[1] == QLatin1Char('o')
+                    && c[2] == QLatin1Char('l') && c[3] == QLatin1Char('a')
+                    && c[4] == QLatin1Char('t') && c[5] == QLatin1Char('i')
+                    && c[6] == QLatin1Char('l') && c[7] == QLatin1Char('e'))
+                return QDeclarativeJSGrammar::T_RESERVED_WORD;
+        }
+    }   break;
+
+    case 9: {
+        if (check_reserved) {
+            if (c[0] == QLatin1Char('i') && c[1] == QLatin1Char('n')
+                    && c[2] == QLatin1Char('t') && c[3] == QLatin1Char('e')
+                    && c[4] == QLatin1Char('r') && c[5] == QLatin1Char('f')
+                    && c[6] == QLatin1Char('a') && c[7] == QLatin1Char('c')
+                    && c[8] == QLatin1Char('e'))
+                return QDeclarativeJSGrammar::T_RESERVED_WORD;
+            else if (c[0] == QLatin1Char('t') && c[1] == QLatin1Char('r')
+                    && c[2] == QLatin1Char('a') && c[3] == QLatin1Char('n')
+                    && c[4] == QLatin1Char('s') && c[5] == QLatin1Char('i')
+                    && c[6] == QLatin1Char('e') && c[7] == QLatin1Char('n')
+                    && c[8] == QLatin1Char('t'))
+                return QDeclarativeJSGrammar::T_RESERVED_WORD;
+            else if (c[0] == QLatin1Char('p') && c[1] == QLatin1Char('r')
+                    && c[2] == QLatin1Char('o') && c[3] == QLatin1Char('t')
+                    && c[4] == QLatin1Char('e') && c[5] == QLatin1Char('c')
+                    && c[6] == QLatin1Char('t') && c[7] == QLatin1Char('e')
+                    && c[8] == QLatin1Char('d'))
+                return QDeclarativeJSGrammar::T_RESERVED_WORD;
+        }
+    }   break;
+
+    case 10: {
+        if (c[0] == QLatin1Char('i') && c[1] == QLatin1Char('n')
+                && c[2] == QLatin1Char('s') && c[3] == QLatin1Char('t')
+                && c[4] == QLatin1Char('a') && c[5] == QLatin1Char('n')
+                && c[6] == QLatin1Char('c') && c[7] == QLatin1Char('e')
+                && c[8] == QLatin1Char('o') && c[9] == QLatin1Char('f'))
+            return QDeclarativeJSGrammar::T_INSTANCEOF;
+        else if (check_reserved) {
+            if (c[0] == QLatin1Char('i') && c[1] == QLatin1Char('m')
+                    && c[2] == QLatin1Char('p') && c[3] == QLatin1Char('l')
+                    && c[4] == QLatin1Char('e') && c[5] == QLatin1Char('m')
+                    && c[6] == QLatin1Char('e') && c[7] == QLatin1Char('n')
+                    && c[8] == QLatin1Char('t') && c[9] == QLatin1Char('s'))
+                return QDeclarativeJSGrammar::T_RESERVED_WORD;
+        }
+    }   break;
+
+    case 12: {
+        if (check_reserved) {
+            if (c[0] == QLatin1Char('s') && c[1] == QLatin1Char('y')
+                    && c[2] == QLatin1Char('n') && c[3] == QLatin1Char('c')
+                    && c[4] == QLatin1Char('h') && c[5] == QLatin1Char('r')
+                    && c[6] == QLatin1Char('o') && c[7] == QLatin1Char('n')
+                    && c[8] == QLatin1Char('i') && c[9] == QLatin1Char('z')
+                    && c[10] == QLatin1Char('e') && c[11] == QLatin1Char('d'))
+                return QDeclarativeJSGrammar::T_RESERVED_WORD;
+        }
+    }   break;
+
+    } // switch
+
+    return -1;
+}
+
+int Lexer::lex()
+{
+    int token = 0;
+    state = Start;
+    ushort stringType = 0; // either single or double quotes
+    bool multiLineString = false;
+    pos8 = pos16 = 0;
+    done = false;
+    terminator = false;
+
+    // did we push a token on the stack previously ?
+    // (after an automatic semicolon insertion)
+    if (stackToken >= 0) {
+        setDone(Other);
+        token = stackToken;
+        stackToken = -1;
+    }
+
+    bool identifierWithEscapedUnicode = false;
+
+    while (!done) {
+        switch (state) {
+        case Start:
+            if (isWhiteSpace()) {
+                // do nothing
+            } else if (current == '/' && next1 == '/') {
+                recordStartPos();
+                shift(1);
+                state = InSingleLineComment;
+            } else if (current == '/' && next1 == '*') {
+                recordStartPos();
+                shift(1);
+                state = InMultiLineComment;
+            } else if (current == 0) {
+                syncProhibitAutomaticSemicolon();
+                if (!terminator && !delimited && !prohibitAutomaticSemicolon) {
+                    // automatic semicolon insertion if program incomplete
+                    token = QDeclarativeJSGrammar::T_SEMICOLON;
+                    stackToken = 0;
+                    setDone(Other);
+                } else {
+                    setDone(Eof);
+                }
+            } else if (isLineTerminator()) {
+                if (restrKeyword) {
+                    // automatic semicolon insertion
+                    recordStartPos();
+                    token = QDeclarativeJSGrammar::T_SEMICOLON;
+                    setDone(Other);
+                } else {
+                    shiftWindowsLineBreak();
+                    yylineno++;
+                    yycolumn = 0;
+                    bol = true;
+                    terminator = true;
+                    syncProhibitAutomaticSemicolon();
+                }
+            } else if (current == '"' || current == '\'') {
+                recordStartPos();
+                state = InString;
+                multiLineString = false;
+                stringType = current;
+            } else if (current == '\\' && next1 == 'u') {
+                identifierWithEscapedUnicode = true;
+                recordStartPos();
+
+                shift(2); // skip the unicode escape prefix `\u'
+
+                if (isHexDigit(current) && isHexDigit(next1) &&
+                     isHexDigit(next2) && isHexDigit(next3)) {
+                    record16(convertUnicode(current, next1, next2, next3));
+                    shift(3);
+                    state = InIdentifier;
+                } else {
+                    setDone(Bad);
+                    err = IllegalUnicodeEscapeSequence;
+                    errmsg = QCoreApplication::translate("QDeclarativeParser", "Illegal unicode escape sequence");
+                    break;
+                }
+
+            } else if (isIdentLetter(current)) {
+                identifierWithEscapedUnicode = false;
+                recordStartPos();
+                record16(current);
+                state = InIdentifier;
+            } else if (current == '0') {
+                recordStartPos();
+                record8(current);
+                state = InNum0;
+            } else if (isDecimalDigit(current)) {
+                recordStartPos();
+                record8(current);
+                state = InNum;
+            } else if (current == '.' && isDecimalDigit(next1)) {
+                recordStartPos();
+                record8(current);
+                state = InDecimal;
+            } else {
+                recordStartPos();
+                token = matchPunctuator(current, next1, next2, next3);
+                if (token != -1) {
+                    if (terminator && !delimited && !prohibitAutomaticSemicolon
+                        && (token == QDeclarativeJSGrammar::T_PLUS_PLUS
+                            || token == QDeclarativeJSGrammar::T_MINUS_MINUS)) {
+                        // automatic semicolon insertion
+                        stackToken = token;
+                        token = QDeclarativeJSGrammar::T_SEMICOLON;
+                    }
+                    setDone(Other);
+                }
+                else {
+                    setDone(Bad);
+                    err = IllegalCharacter;
+                    errmsg = QCoreApplication::translate("QDeclarativeParser", "Illegal character");
+                }
+            }
+            break;
+        case InString:
+            if (current == stringType) {
+                shift(1);
+                setDone(String);
+            } else if (isLineTerminator()) {
+                multiLineString = true;
+                record16(current);
+            } else if (current == 0 || isLineTerminator()) {
+                setDone(Bad);
+                err = UnclosedStringLiteral;
+                errmsg = QCoreApplication::translate("QDeclarativeParser", "Unclosed string at end of line");
+            } else if (current == '\\') {
+                state = InEscapeSequence;
+            } else {
+                record16(current);
+            }
+            break;
+            // Escape Sequences inside of strings
+        case InEscapeSequence:
+            if (isOctalDigit(current)) {
+                if (current >= '0' && current <= '3' &&
+                     isOctalDigit(next1) && isOctalDigit(next2)) {
+                    record16(convertOctal(current, next1, next2));
+                    shift(2);
+                    state = InString;
+                } else if (isOctalDigit(current) &&
+                            isOctalDigit(next1)) {
+                    record16(convertOctal('0', current, next1));
+                    shift(1);
+                    state = InString;
+                } else if (isOctalDigit(current)) {
+                    record16(convertOctal('0', '0', current));
+                    state = InString;
+                } else {
+                    setDone(Bad);
+                    err = IllegalEscapeSequence;
+                    errmsg = QCoreApplication::translate("QDeclarativeParser", "Illegal escape sequence");
+                }
+            } else if (current == 'x')
+                state = InHexEscape;
+            else if (current == 'u')
+                state = InUnicodeEscape;
+            else {
+                if (isLineTerminator()) {
+                    shiftWindowsLineBreak();
+                    yylineno++;
+                    yycolumn = 0;
+                    bol = true;
+                } else {
+                    record16(singleEscape(current));
+                }
+                state = InString;
+            }
+            break;
+        case InHexEscape:
+            if (isHexDigit(current) && isHexDigit(next1)) {
+                state = InString;
+                record16(QLatin1Char(convertHex(current, next1)));
+                shift(1);
+            } else if (current == stringType) {
+                record16(QLatin1Char('x'));
+                shift(1);
+                setDone(String);
+            } else {
+                record16(QLatin1Char('x'));
+                record16(current);
+                state = InString;
+            }
+            break;
+        case InUnicodeEscape:
+            if (isHexDigit(current) && isHexDigit(next1) &&
+                 isHexDigit(next2) && isHexDigit(next3)) {
+                record16(convertUnicode(current, next1, next2, next3));
+                shift(3);
+                state = InString;
+            } else if (current == stringType) {
+                record16(QLatin1Char('u'));
+                shift(1);
+                setDone(String);
+            } else {
+                setDone(Bad);
+                err = IllegalUnicodeEscapeSequence;
+                errmsg = QCoreApplication::translate("QDeclarativeParser", "Illegal unicode escape sequence");
+            }
+            break;
+        case InSingleLineComment:
+            if (isLineTerminator()) {
+                shiftWindowsLineBreak();
+                yylineno++;
+                yycolumn = 0;
+                terminator = true;
+                bol = true;
+                if (restrKeyword) {
+                    token = QDeclarativeJSGrammar::T_SEMICOLON;
+                    setDone(Other);
+                } else
+                    state = Start;
+                if (driver) driver->addComment(startpos+2, tokenLength()-2, startlineno, startcolumn+2);
+            } else if (current == 0) {
+                if (driver) driver->addComment(startpos+2, tokenLength()-2, startlineno, startcolumn+2);
+                setDone(Eof);
+            }
+
+            break;
+        case InMultiLineComment:
+            if (current == 0) {
+                setDone(Bad);
+                err = UnclosedComment;
+                errmsg = QCoreApplication::translate("QDeclarativeParser", "Unclosed comment at end of file");
+                if (driver) driver->addComment(startpos+2, tokenLength()-2, startlineno, startcolumn+2);
+            } else if (isLineTerminator()) {
+                shiftWindowsLineBreak();
+                yylineno++;
+            } else if (current == '*' && next1 == '/') {
+                state = Start;
+                shift(1);
+                if (driver) driver->addComment(startpos+2, tokenLength()-3, startlineno, startcolumn+2);
+            }
+
+            break;
+        case InIdentifier:
+            if (isIdentLetter(current) || isDecimalDigit(current)) {
+                record16(current);
+                break;
+            } else if (current == '\\' && next1 == 'u') {
+                identifierWithEscapedUnicode = true;
+                shift(2); // skip the unicode escape prefix `\u'
+
+                if (isHexDigit(current) && isHexDigit(next1) &&
+                     isHexDigit(next2) && isHexDigit(next3)) {
+                    record16(convertUnicode(current, next1, next2, next3));
+                    shift(3);
+                    break;
+                } else {
+                    setDone(Bad);
+                    err = IllegalUnicodeEscapeSequence;
+                    errmsg = QCoreApplication::translate("QDeclarativeParser", "Illegal unicode escape sequence");
+                    break;
+                }
+            }
+            setDone(Identifier);
+            break;
+        case InNum0:
+            if (current == 'x' || current == 'X') {
+                record8(current);
+                state = InHex;
+            } else if (current == '.') {
+                record8(current);
+                state = InDecimal;
+            } else if (current == 'e' || current == 'E') {
+                record8(current);
+                state = InExponentIndicator;
+            } else if (isOctalDigit(current)) {
+                record8(current);
+                state = InOctal;
+            } else if (isDecimalDigit(current)) {
+                record8(current);
+                state = InDecimal;
+            } else {
+                setDone(Number);
+            }
+            break;
+        case InHex:
+            if (isHexDigit(current))
+                record8(current);
+            else
+                setDone(Hex);
+            break;
+        case InOctal:
+            if (isOctalDigit(current)) {
+                record8(current);
+            } else if (isDecimalDigit(current)) {
+                record8(current);
+                state = InDecimal;
+            } else {
+                setDone(Octal);
+            }
+            break;
+        case InNum:
+            if (isDecimalDigit(current)) {
+                record8(current);
+            } else if (current == '.') {
+                record8(current);
+                state = InDecimal;
+            } else if (current == 'e' || current == 'E') {
+                record8(current);
+                state = InExponentIndicator;
+            } else {
+                setDone(Number);
+            }
+            break;
+        case InDecimal:
+            if (isDecimalDigit(current)) {
+                record8(current);
+            } else if (current == 'e' || current == 'E') {
+                record8(current);
+                state = InExponentIndicator;
+            } else {
+                setDone(Number);
+            }
+            break;
+        case InExponentIndicator:
+            if (current == '+' || current == '-') {
+                record8(current);
+            } else if (isDecimalDigit(current)) {
+                record8(current);
+                state = InExponent;
+            } else {
+                setDone(Bad);
+                err = IllegalExponentIndicator;
+                errmsg = QCoreApplication::translate("QDeclarativeParser", "Illegal syntax for exponential number");
+            }
+            break;
+        case InExponent:
+            if (isDecimalDigit(current)) {
+                record8(current);
+            } else {
+                setDone(Number);
+            }
+            break;
+        default:
+            Q_ASSERT_X(0, "Lexer::lex", "Unhandled state in switch statement");
+        }
+
+        // move on to the next character
+        if (!done)
+            shift(1);
+        if (state != Start && state != InSingleLineComment)
+            bol = false;
+    }
+
+    // no identifiers allowed directly after numeric literal, e.g. "3in" is bad
+    if ((state == Number || state == Octal || state == Hex)
+         && isIdentLetter(current)) {
+        state = Bad;
+        err = IllegalIdentifier;
+        errmsg = QCoreApplication::translate("QDeclarativeParser", "Identifier cannot start with numeric literal");
+    }
+
+    // terminate string
+    buffer8[pos8] = '\0';
+
+    double dval = 0;
+    if (state == Number) {
+        dval = qstrtod(buffer8, 0, 0);
+    } else if (state == Hex) { // scan hex numbers
+        dval = integerFromString(buffer8, pos8, 16);
+        state = Number;
+    } else if (state == Octal) {   // scan octal number
+        dval = integerFromString(buffer8, pos8, 8);
+        state = Number;
+    }
+
+    restrKeyword = false;
+    delimited = false;
+
+    switch (parenthesesState) {
+    case IgnoreParentheses:
+        break;
+    case CountParentheses:
+        if (token == QDeclarativeJSGrammar::T_RPAREN) {
+            --parenthesesCount;
+            if (parenthesesCount == 0)
+                parenthesesState = BalancedParentheses;
+        } else if (token == QDeclarativeJSGrammar::T_LPAREN) {
+            ++parenthesesCount;
+        }
+        break;
+    case BalancedParentheses:
+        parenthesesState = IgnoreParentheses;
+        break;
+    }
+
+    switch (state) {
+    case Eof:
+        return 0;
+    case Other:
+        if (token == QDeclarativeJSGrammar::T_RBRACE || token == QDeclarativeJSGrammar::T_SEMICOLON)
+            delimited = true;
+        return token;
+    case Identifier:
+        token = -1;
+        if (! identifierWithEscapedUnicode)
+            token = findReservedWord(buffer16, pos16);
+
+        if (token < 0) {
+            /* TODO: close leak on parse error. same holds true for String */
+            if (driver)
+                qsyylval.ustr = driver->intern(buffer16, pos16);
+            else
+                qsyylval.ustr = 0;
+            return QDeclarativeJSGrammar::T_IDENTIFIER;
+        }
+        if (token == QDeclarativeJSGrammar::T_CONTINUE || token == QDeclarativeJSGrammar::T_BREAK
+            || token == QDeclarativeJSGrammar::T_RETURN || token == QDeclarativeJSGrammar::T_THROW) {
+            restrKeyword = true;
+        } else if (token == QDeclarativeJSGrammar::T_IF || token == QDeclarativeJSGrammar::T_FOR
+                   || token == QDeclarativeJSGrammar::T_WHILE || token == QDeclarativeJSGrammar::T_WITH) {
+            parenthesesState = CountParentheses;
+            parenthesesCount = 0;
+        } else if (token == QDeclarativeJSGrammar::T_DO) {
+            parenthesesState = BalancedParentheses;
+        }
+        return token;
+    case String:
+        if (driver)
+            qsyylval.ustr = driver->intern(buffer16, pos16);
+        else
+            qsyylval.ustr = 0;
+        return multiLineString?QDeclarativeJSGrammar::T_MULTILINE_STRING_LITERAL:QDeclarativeJSGrammar::T_STRING_LITERAL;
+    case Number:
+        qsyylval.dval = dval;
+        return QDeclarativeJSGrammar::T_NUMERIC_LITERAL;
+    case Bad:
+        return -1;
+    default:
+        Q_ASSERT(!"unhandled numeration value in switch");
+        return -1;
+    }
+}
+
+bool Lexer::isWhiteSpace() const
+{
+    return (current == ' ' || current == '\t' ||
+             current == 0x0b || current == 0x0c);
+}
+
+bool Lexer::isLineTerminator() const
+{
+    return (current == '\n' || current == '\r');
+}
+
+bool Lexer::isIdentLetter(ushort c)
+{
+    // ASCII-biased, since all reserved words are ASCII, aand hence the
+    // bulk of content to be parsed.
+    if ((c >= 'a' && c <= 'z')
+            || (c >= 'A' && c <= 'Z')
+            || c == '$'
+            || c == '_')
+        return true;
+    if (c < 128)
+        return false;
+    return QChar(c).isLetterOrNumber();
+}
+
+bool Lexer::isDecimalDigit(ushort c)
+{
+    return (c >= '0' && c <= '9');
+}
+
+bool Lexer::isHexDigit(ushort c) const
+{
+    return ((c >= '0' && c <= '9')
+            || (c >= 'a' && c <= 'f')
+            || (c >= 'A' && c <= 'F'));
+}
+
+bool Lexer::isOctalDigit(ushort c) const
+{
+    return (c >= '0' && c <= '7');
+}
+
+int Lexer::matchPunctuator(ushort c1, ushort c2,
+                            ushort c3, ushort c4)
+{
+    if (c1 == '>' && c2 == '>' && c3 == '>' && c4 == '=') {
+        shift(4);
+        return QDeclarativeJSGrammar::T_GT_GT_GT_EQ;
+    } else if (c1 == '=' && c2 == '=' && c3 == '=') {
+        shift(3);
+        return QDeclarativeJSGrammar::T_EQ_EQ_EQ;
+    } else if (c1 == '!' && c2 == '=' && c3 == '=') {
+        shift(3);
+        return QDeclarativeJSGrammar::T_NOT_EQ_EQ;
+    } else if (c1 == '>' && c2 == '>' && c3 == '>') {
+        shift(3);
+        return QDeclarativeJSGrammar::T_GT_GT_GT;
+    } else if (c1 == '<' && c2 == '<' && c3 == '=') {
+        shift(3);
+        return QDeclarativeJSGrammar::T_LT_LT_EQ;
+    } else if (c1 == '>' && c2 == '>' && c3 == '=') {
+        shift(3);
+        return QDeclarativeJSGrammar::T_GT_GT_EQ;
+    } else if (c1 == '<' && c2 == '=') {
+        shift(2);
+        return QDeclarativeJSGrammar::T_LE;
+    } else if (c1 == '>' && c2 == '=') {
+        shift(2);
+        return QDeclarativeJSGrammar::T_GE;
+    } else if (c1 == '!' && c2 == '=') {
+        shift(2);
+        return QDeclarativeJSGrammar::T_NOT_EQ;
+    } else if (c1 == '+' && c2 == '+') {
+        shift(2);
+        return QDeclarativeJSGrammar::T_PLUS_PLUS;
+    } else if (c1 == '-' && c2 == '-') {
+        shift(2);
+        return QDeclarativeJSGrammar::T_MINUS_MINUS;
+    } else if (c1 == '=' && c2 == '=') {
+        shift(2);
+        return QDeclarativeJSGrammar::T_EQ_EQ;
+    } else if (c1 == '+' && c2 == '=') {
+        shift(2);
+        return QDeclarativeJSGrammar::T_PLUS_EQ;
+    } else if (c1 == '-' && c2 == '=') {
+        shift(2);
+        return QDeclarativeJSGrammar::T_MINUS_EQ;
+    } else if (c1 == '*' && c2 == '=') {
+        shift(2);
+        return QDeclarativeJSGrammar::T_STAR_EQ;
+    } else if (c1 == '/' && c2 == '=') {
+        shift(2);
+        return QDeclarativeJSGrammar::T_DIVIDE_EQ;
+    } else if (c1 == '&' && c2 == '=') {
+        shift(2);
+        return QDeclarativeJSGrammar::T_AND_EQ;
+    } else if (c1 == '^' && c2 == '=') {
+        shift(2);
+        return QDeclarativeJSGrammar::T_XOR_EQ;
+    } else if (c1 == '%' && c2 == '=') {
+        shift(2);
+        return QDeclarativeJSGrammar::T_REMAINDER_EQ;
+    } else if (c1 == '|' && c2 == '=') {
+        shift(2);
+        return QDeclarativeJSGrammar::T_OR_EQ;
+    } else if (c1 == '<' && c2 == '<') {
+        shift(2);
+        return QDeclarativeJSGrammar::T_LT_LT;
+    } else if (c1 == '>' && c2 == '>') {
+        shift(2);
+        return QDeclarativeJSGrammar::T_GT_GT;
+    } else if (c1 == '&' && c2 == '&') {
+        shift(2);
+        return QDeclarativeJSGrammar::T_AND_AND;
+    } else if (c1 == '|' && c2 == '|') {
+        shift(2);
+        return QDeclarativeJSGrammar::T_OR_OR;
+    }
+
+    switch(c1) {
+        case '=': shift(1); return QDeclarativeJSGrammar::T_EQ;
+        case '>': shift(1); return QDeclarativeJSGrammar::T_GT;
+        case '<': shift(1); return QDeclarativeJSGrammar::T_LT;
+        case ',': shift(1); return QDeclarativeJSGrammar::T_COMMA;
+        case '!': shift(1); return QDeclarativeJSGrammar::T_NOT;
+        case '~': shift(1); return QDeclarativeJSGrammar::T_TILDE;
+        case '?': shift(1); return QDeclarativeJSGrammar::T_QUESTION;
+        case ':': shift(1); return QDeclarativeJSGrammar::T_COLON;
+        case '.': shift(1); return QDeclarativeJSGrammar::T_DOT;
+        case '+': shift(1); return QDeclarativeJSGrammar::T_PLUS;
+        case '-': shift(1); return QDeclarativeJSGrammar::T_MINUS;
+        case '*': shift(1); return QDeclarativeJSGrammar::T_STAR;
+        case '/': shift(1); return QDeclarativeJSGrammar::T_DIVIDE_;
+        case '&': shift(1); return QDeclarativeJSGrammar::T_AND;
+        case '|': shift(1); return QDeclarativeJSGrammar::T_OR;
+        case '^': shift(1); return QDeclarativeJSGrammar::T_XOR;
+        case '%': shift(1); return QDeclarativeJSGrammar::T_REMAINDER;
+        case '(': shift(1); return QDeclarativeJSGrammar::T_LPAREN;
+        case ')': shift(1); return QDeclarativeJSGrammar::T_RPAREN;
+        case '{': shift(1); return QDeclarativeJSGrammar::T_LBRACE;
+        case '}': shift(1); return QDeclarativeJSGrammar::T_RBRACE;
+        case '[': shift(1); return QDeclarativeJSGrammar::T_LBRACKET;
+        case ']': shift(1); return QDeclarativeJSGrammar::T_RBRACKET;
+        case ';': shift(1); return QDeclarativeJSGrammar::T_SEMICOLON;
+
+        default: return -1;
+    }
+}
+
+ushort Lexer::singleEscape(ushort c) const
+{
+    switch(c) {
+    case 'b':
+        return 0x08;
+    case 't':
+        return 0x09;
+    case 'n':
+        return 0x0A;
+    case 'v':
+        return 0x0B;
+    case 'f':
+        return 0x0C;
+    case 'r':
+        return 0x0D;
+    case '"':
+        return 0x22;
+    case '\'':
+        return 0x27;
+    case '\\':
+        return 0x5C;
+    default:
+        return c;
+    }
+}
+
+ushort Lexer::convertOctal(ushort c1, ushort c2,
+                            ushort c3) const
+{
+    return ((c1 - '0') * 64 + (c2 - '0') * 8 + c3 - '0');
+}
+
+unsigned char Lexer::convertHex(ushort c)
+{
+    if (c >= '0' && c <= '9')
+        return (c - '0');
+    else if (c >= 'a' && c <= 'f')
+        return (c - 'a' + 10);
+    else
+        return (c - 'A' + 10);
+}
+
+unsigned char Lexer::convertHex(ushort c1, ushort c2)
+{
+    return ((convertHex(c1) << 4) + convertHex(c2));
+}
+
+QChar Lexer::convertUnicode(ushort c1, ushort c2,
+                             ushort c3, ushort c4)
+{
+    return QChar((convertHex(c3) << 4) + convertHex(c4),
+                  (convertHex(c1) << 4) + convertHex(c2));
+}
+
+void Lexer::record8(ushort c)
+{
+    Q_ASSERT(c <= 0xff);
+
+    // enlarge buffer if full
+    if (pos8 >= size8 - 1) {
+        char *tmp = new char[2 * size8];
+        memcpy(tmp, buffer8, size8 * sizeof(char));
+        delete [] buffer8;
+        buffer8 = tmp;
+        size8 *= 2;
+    }
+
+    buffer8[pos8++] = (char) c;
+}
+
+void Lexer::record16(QChar c)
+{
+    // enlarge buffer if full
+    if (pos16 >= size16 - 1) {
+        QChar *tmp = new QChar[2 * size16];
+        memcpy(tmp, buffer16, size16 * sizeof(QChar));
+        delete [] buffer16;
+        buffer16 = tmp;
+        size16 *= 2;
+    }
+
+    buffer16[pos16++] = c;
+}
+
+void Lexer::recordStartPos()
+{
+    startpos = pos;
+    startlineno = yylineno;
+    startcolumn = yycolumn;
+}
+
+bool Lexer::scanRegExp(RegExpBodyPrefix prefix)
+{
+    pos16 = 0;
+    pattern = 0;
+
+    if (prefix == EqualPrefix)
+        record16(QLatin1Char('='));
+
+    while (true) {
+        switch (current) {
+
+        case 0: // eof
+        case '\n': case '\r': // line terminator
+            errmsg = QCoreApplication::translate("QDeclarativeParser", "Unterminated regular expression literal");
+            return false;
+
+        case '/':
+            shift(1);
+
+            if (driver) // create the pattern
+                pattern = driver->intern(buffer16, pos16);
+
+            // scan the flags
+            pos16 = 0;
+            flags = 0;
+            while (isIdentLetter(current)) {
+                int flag = Ecma::RegExp::flagFromChar(current);
+                if (flag == 0) {
+                    errmsg = QCoreApplication::translate("QDeclarativeParser", "Invalid regular expression flag '%0'")
+                             .arg(QChar(current));
+                    return false;
+                }
+                flags |= flag;
+                record16(current);
+                shift(1);
+            }
+            return true;
+
+        case '\\':
+            // regular expression backslash sequence
+            record16(current);
+            shift(1);
+
+            if (! current || isLineTerminator()) {
+                errmsg = QCoreApplication::translate("QDeclarativeParser", "Unterminated regular expression backslash sequence");
+                return false;
+            }
+
+            record16(current);
+            shift(1);
+            break;
+
+        case '[':
+            // regular expression class
+            record16(current);
+            shift(1);
+
+            while (current && ! isLineTerminator()) {
+                if (current == ']')
+                    break;
+                else if (current == '\\') {
+                    // regular expression backslash sequence
+                    record16(current);
+                    shift(1);
+
+                    if (! current || isLineTerminator()) {
+                        errmsg = QCoreApplication::translate("QDeclarativeParser", "Unterminated regular expression backslash sequence");
+                        return false;
+                    }
+
+                    record16(current);
+                    shift(1);
+                } else {
+                    record16(current);
+                    shift(1);
+                }
+            }
+
+            if (current != ']') {
+                errmsg = QCoreApplication::translate("QDeclarativeParser", "Unterminated regular expression class");
+                return false;
+            }
+
+            record16(current);
+            shift(1); // skip ]
+            break;
+
+        default:
+            record16(current);
+            shift(1);
+        } // switch
+    } // while
+
+    return false;
+}
+
+void Lexer::syncProhibitAutomaticSemicolon()
+{
+    if (parenthesesState == BalancedParentheses) {
+        // we have seen something like "if (foo)", which means we should
+        // never insert an automatic semicolon at this point, since it would
+        // then be expanded into an empty statement (ECMA-262 7.9.1)
+        prohibitAutomaticSemicolon = true;
+        parenthesesState = IgnoreParentheses;
+    } else {
+        prohibitAutomaticSemicolon = false;
+    }
+}
+
+QT_QML_END_NAMESPACE
+
+
diff --git a/tools/qdoc3/declarativeparser/qdeclarativejslexer_p.h b/tools/qdoc3/declarativeparser/qdeclarativejslexer_p.h
new file mode 100644
index 0000000..e41337d
--- /dev/null
+++ b/tools/qdoc3/declarativeparser/qdeclarativejslexer_p.h
@@ -0,0 +1,249 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDECLARATIVEJSLEXER_P_H
+#define QDECLARATIVEJSLEXER_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "private/qdeclarativejsglobal_p.h"
+
+#include <QtCore/QString>
+
+QT_QML_BEGIN_NAMESPACE
+
+namespace QDeclarativeJS {
+
+class Engine;
+class NameId;
+
+class QML_PARSER_EXPORT Lexer
+{
+public:
+    Lexer(Engine *eng, bool tokenizeComments = false);
+    ~Lexer();
+
+    void setCode(const QString &c, int lineno);
+    int lex();
+
+    int currentLineNo() const { return yylineno; }
+    int currentColumnNo() const { return yycolumn; }
+
+    int tokenOffset() const { return startpos; }
+    int tokenLength() const { return pos - startpos; }
+
+    int startLineNo() const { return startlineno; }
+    int startColumnNo() const { return startcolumn; }
+
+    int endLineNo() const { return currentLineNo(); }
+    int endColumnNo() const
+    { int col = currentColumnNo(); return (col > 0) ? col - 1 : col; }
+
+    bool prevTerminator() const { return terminator; }
+
+    enum State { Start,
+                 Identifier,
+                 InIdentifier,
+                 InSingleLineComment,
+                 InMultiLineComment,
+                 InNum,
+                 InNum0,
+                 InHex,
+                 InOctal,
+                 InDecimal,
+                 InExponentIndicator,
+                 InExponent,
+                 Hex,
+                 Octal,
+                 Number,
+                 String,
+                 Eof,
+                 InString,
+                 InEscapeSequence,
+                 InHexEscape,
+                 InUnicodeEscape,
+                 Other,
+                 Bad };
+
+    enum Error {
+        NoError,
+        IllegalCharacter,
+        UnclosedStringLiteral,
+        IllegalEscapeSequence,
+        IllegalUnicodeEscapeSequence,
+        UnclosedComment,
+        IllegalExponentIndicator,
+        IllegalIdentifier
+    };
+
+    enum ParenthesesState {
+        IgnoreParentheses,
+        CountParentheses,
+        BalancedParentheses
+    };
+
+    enum RegExpBodyPrefix {
+        NoPrefix,
+        EqualPrefix
+    };
+
+    bool scanRegExp(RegExpBodyPrefix prefix = NoPrefix);
+
+    NameId *pattern;
+    int flags;
+
+    State lexerState() const
+        { return state; }
+
+    QString errorMessage() const
+        { return errmsg; }
+    void setErrorMessage(const QString &err)
+        { errmsg = err; }
+    void setErrorMessage(const char *err)
+        { setErrorMessage(QString::fromLatin1(err)); }
+
+    Error error() const
+        { return err; }
+    void clearError()
+        { err = NoError; }
+
+private:
+    Engine *driver;
+    int yylineno;
+    bool done;
+    char *buffer8;
+    QChar *buffer16;
+    uint size8, size16;
+    uint pos8, pos16;
+    bool terminator;
+    bool restrKeyword;
+    // encountered delimiter like "'" and "}" on last run
+    bool delimited;
+    int stackToken;
+
+    State state;
+    void setDone(State s);
+    uint pos;
+    void shift(uint p);
+    int lookupKeyword(const char *);
+
+    bool isWhiteSpace() const;
+    bool isLineTerminator() const;
+    bool isHexDigit(ushort c) const;
+    bool isOctalDigit(ushort c) const;
+
+    int matchPunctuator(ushort c1, ushort c2,
+                         ushort c3, ushort c4);
+    ushort singleEscape(ushort c) const;
+    ushort convertOctal(ushort c1, ushort c2,
+                         ushort c3) const;
+public:
+    static unsigned char convertHex(ushort c1);
+    static unsigned char convertHex(ushort c1, ushort c2);
+    static QChar convertUnicode(ushort c1, ushort c2,
+                                 ushort c3, ushort c4);
+    static bool isIdentLetter(ushort c);
+    static bool isDecimalDigit(ushort c);
+
+    inline int ival() const { return qsyylval.ival; }
+    inline double dval() const { return qsyylval.dval; }
+    inline NameId *ustr() const { return qsyylval.ustr; }
+
+    const QChar *characterBuffer() const { return buffer16; }
+    int characterCount() const { return pos16; }
+
+private:
+    void record8(ushort c);
+    void record16(QChar c);
+    void recordStartPos();
+
+    int findReservedWord(const QChar *buffer, int size) const;
+
+    void syncProhibitAutomaticSemicolon();
+
+    const QChar *code;
+    uint length;
+    int yycolumn;
+    int startpos;
+    int startlineno;
+    int startcolumn;
+    int bol;     // begin of line
+
+    union {
+        int ival;
+        double dval;
+        NameId *ustr;
+    } qsyylval;
+
+    // current and following unicode characters
+    ushort current, next1, next2, next3;
+
+    struct keyword {
+        const char *name;
+        int token;
+    };
+
+    QString errmsg;
+    Error err;
+
+    bool wantRx;
+    bool check_reserved;
+
+    ParenthesesState parenthesesState;
+    int parenthesesCount;
+    bool prohibitAutomaticSemicolon;
+    bool tokenizeComments;
+};
+
+} // namespace QDeclarativeJS
+
+QT_QML_END_NAMESPACE
+
+#endif
diff --git a/tools/qdoc3/declarativeparser/qdeclarativejsmemorypool_p.h b/tools/qdoc3/declarativeparser/qdeclarativejsmemorypool_p.h
new file mode 100644
index 0000000..7eea975
--- /dev/null
+++ b/tools/qdoc3/declarativeparser/qdeclarativejsmemorypool_p.h
@@ -0,0 +1,133 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDECLARATIVEJSMEMORYPOOL_P_H
+#define QDECLARATIVEJSMEMORYPOOL_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "private/qdeclarativejsglobal_p.h"
+
+#include <QtCore/qglobal.h>
+#include <QtCore/qshareddata.h>
+
+#include <string.h>
+
+QT_QML_BEGIN_NAMESPACE
+
+namespace QDeclarativeJS {
+
+class QML_PARSER_EXPORT MemoryPool : public QSharedData
+{
+public:
+    enum { maxBlockCount = -1 };
+    enum { defaultBlockSize = 1 << 12 };
+
+    MemoryPool() {
+        m_blockIndex = maxBlockCount;
+        m_currentIndex = 0;
+        m_storage = 0;
+        m_currentBlock = 0;
+        m_currentBlockSize = 0;
+    }
+
+    virtual ~MemoryPool() {
+        for (int index = 0; index < m_blockIndex + 1; ++index)
+            qFree(m_storage[index]);
+
+        qFree(m_storage);
+    }
+
+    char *allocate(int bytes) {
+        bytes += (8 - bytes) & 7; // ensure multiple of 8 bytes (maintain alignment)
+        if (m_currentBlock == 0 || m_currentBlockSize < m_currentIndex + bytes) {
+            ++m_blockIndex;
+            m_currentBlockSize = defaultBlockSize << m_blockIndex;
+
+            m_storage = reinterpret_cast<char**>(qRealloc(m_storage, sizeof(char*) * (1 + m_blockIndex)));
+            m_currentBlock = m_storage[m_blockIndex] = reinterpret_cast<char*>(qMalloc(m_currentBlockSize));
+            ::memset(m_currentBlock, 0, m_currentBlockSize);
+
+            m_currentIndex = (8 - quintptr(m_currentBlock)) & 7; // ensure first chunk is 64-bit aligned
+            Q_ASSERT(m_currentIndex + bytes <= m_currentBlockSize);
+        }
+
+        char *p = reinterpret_cast<char *>
+            (m_currentBlock + m_currentIndex);
+
+        m_currentIndex += bytes;
+
+        return p;
+    }
+
+    int bytesAllocated() const {
+        int bytes = 0;
+        for (int index = 0; index < m_blockIndex; ++index)
+            bytes += (defaultBlockSize << index);
+        bytes += m_currentIndex;
+        return bytes;
+    }
+
+private:
+    int m_blockIndex;
+    int m_currentIndex;
+    char *m_currentBlock;
+    int m_currentBlockSize;
+    char **m_storage;
+
+private:
+    Q_DISABLE_COPY(MemoryPool)
+};
+
+} // namespace QDeclarativeJS
+
+QT_QML_END_NAMESPACE
+
+#endif
diff --git a/tools/qdoc3/declarativeparser/qdeclarativejsnodepool_p.h b/tools/qdoc3/declarativeparser/qdeclarativejsnodepool_p.h
new file mode 100644
index 0000000..fde4897
--- /dev/null
+++ b/tools/qdoc3/declarativeparser/qdeclarativejsnodepool_p.h
@@ -0,0 +1,139 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDECLARATIVEJSNODEPOOL_P_H
+#define QDECLARATIVEJSNODEPOOL_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "private/qdeclarativejsglobal_p.h"
+#include "private/qdeclarativejsmemorypool_p.h"
+
+#include <QtCore/QHash>
+#include <QtCore/QString>
+
+QT_QML_BEGIN_NAMESPACE
+
+namespace QDeclarativeJS {
+
+namespace AST {
+class Node;
+} // namespace AST
+
+class Code;
+class CompilationUnit;
+class Engine;
+
+template <typename NodeType>
+inline NodeType *makeAstNode(MemoryPool *storage)
+{
+    NodeType *node = new (storage->allocate(sizeof(NodeType))) NodeType();
+    return node;
+}
+
+template <typename NodeType, typename Arg1>
+inline NodeType *makeAstNode(MemoryPool *storage, Arg1 arg1)
+{
+    NodeType *node = new (storage->allocate(sizeof(NodeType))) NodeType(arg1);
+    return node;
+}
+
+template <typename NodeType, typename Arg1, typename Arg2>
+inline NodeType *makeAstNode(MemoryPool *storage, Arg1 arg1, Arg2 arg2)
+{
+    NodeType *node = new (storage->allocate(sizeof(NodeType))) NodeType(arg1, arg2);
+    return node;
+}
+
+template <typename NodeType, typename Arg1, typename Arg2, typename Arg3>
+inline NodeType *makeAstNode(MemoryPool *storage, Arg1 arg1, Arg2 arg2, Arg3 arg3)
+{
+    NodeType *node = new (storage->allocate(sizeof(NodeType))) NodeType(arg1, arg2, arg3);
+    return node;
+}
+
+template <typename NodeType, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
+inline NodeType *makeAstNode(MemoryPool *storage, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4)
+{
+    NodeType *node = new (storage->allocate(sizeof(NodeType))) NodeType(arg1, arg2, arg3, arg4);
+    return node;
+}
+
+class QML_PARSER_EXPORT NodePool : public MemoryPool
+{
+public:
+    NodePool(const QString &fileName, Engine *engine);
+    virtual ~NodePool();
+
+    Code *createCompiledCode(AST::Node *node, CompilationUnit &compilation);
+
+    inline QString fileName() const { return m_fileName; }
+    inline Engine *engine() const { return m_engine; }
+#ifndef J_SCRIPT_NO_EVENT_NOTIFY
+    inline qint64 id() const { return m_id; }
+#endif
+
+private:
+    QHash<AST::Node*, Code*> m_codeCache;
+    QString m_fileName;
+    Engine *m_engine;
+#ifndef J_SCRIPT_NO_EVENT_NOTIFY
+    qint64 m_id;
+#endif
+
+private:
+    Q_DISABLE_COPY(NodePool)
+};
+
+} // namespace QDeclarativeJS
+
+QT_QML_END_NAMESPACE
+
+#endif
diff --git a/tools/qdoc3/declarativeparser/qdeclarativejsparser.cpp b/tools/qdoc3/declarativeparser/qdeclarativejsparser.cpp
new file mode 100644
index 0000000..9a93fa1
--- /dev/null
+++ b/tools/qdoc3/declarativeparser/qdeclarativejsparser.cpp
@@ -0,0 +1,1904 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtCore/QtDebug>
+#include <QtGui/QApplication>
+
+#include <string.h>
+
+#include "private/qdeclarativejsengine_p.h"
+#include "private/qdeclarativejslexer_p.h"
+#include "private/qdeclarativejsast_p.h"
+#include "private/qdeclarativejsnodepool_p.h"
+
+
+
+#include "private/qdeclarativejsparser_p.h"
+#include <QVarLengthArray>
+
+//
+// This file is automatically generated from qmljs.g.
+// Changes will be lost.
+//
+
+using namespace QDeclarativeJS;
+
+QT_QML_BEGIN_NAMESPACE
+
+void Parser::reallocateStack()
+{
+    if (! stack_size)
+        stack_size = 128;
+    else
+        stack_size <<= 1;
+
+    sym_stack = reinterpret_cast<Value*> (qRealloc(sym_stack, stack_size * sizeof(Value)));
+    state_stack = reinterpret_cast<int*> (qRealloc(state_stack, stack_size * sizeof(int)));
+    location_stack = reinterpret_cast<AST::SourceLocation*> (qRealloc(location_stack, stack_size * sizeof(AST::SourceLocation)));
+}
+
+inline static bool automatic(Engine *driver, int token)
+{
+    return token == QDeclarativeJSGrammar::T_RBRACE
+        || token == 0
+        || driver->lexer()->prevTerminator();
+}
+
+
+Parser::Parser(Engine *engine):
+    driver(engine),
+    tos(0),
+    stack_size(0),
+    sym_stack(0),
+    state_stack(0),
+    location_stack(0),
+    first_token(0),
+    last_token(0)
+{
+}
+
+Parser::~Parser()
+{
+    if (stack_size) {
+        qFree(sym_stack);
+        qFree(state_stack);
+        qFree(location_stack);
+    }
+}
+
+static inline AST::SourceLocation location(Lexer *lexer)
+{
+    AST::SourceLocation loc;
+    loc.offset = lexer->tokenOffset();
+    loc.length = lexer->tokenLength();
+    loc.startLine = lexer->startLineNo();
+    loc.startColumn = lexer->startColumnNo();
+    return loc;
+}
+
+AST::UiQualifiedId *Parser::reparseAsQualifiedId(AST::ExpressionNode *expr)
+{
+    QVarLengthArray<NameId *, 4> nameIds;
+    QVarLengthArray<AST::SourceLocation, 4> locations;
+
+    AST::ExpressionNode *it = expr;
+    while (AST::FieldMemberExpression *m = AST::cast<AST::FieldMemberExpression *>(it)) {
+        nameIds.append(m->name);
+        locations.append(m->identifierToken);
+        it = m->base;
+    }
+
+    if (AST::IdentifierExpression *idExpr = AST::cast<AST::IdentifierExpression *>(it)) {
+        AST::UiQualifiedId *q = makeAstNode<AST::UiQualifiedId>(driver->nodePool(), idExpr->name);
+        q->identifierToken = idExpr->identifierToken;
+
+        AST::UiQualifiedId *currentId = q;
+        for (int i = nameIds.size() - 1; i != -1; --i) {
+            currentId = makeAstNode<AST::UiQualifiedId>(driver->nodePool(), currentId, nameIds[i]);
+            currentId->identifierToken = locations[i];
+        }
+
+        return currentId->finish();
+    }
+
+    return 0;
+}
+
+bool Parser::parse(int startToken)
+{
+    Lexer *lexer = driver->lexer();
+    bool hadErrors = false;
+    int yytoken = -1;
+    int action = 0;
+
+    token_buffer[0].token = startToken;
+    first_token = &token_buffer[0];
+    last_token = &token_buffer[1];
+
+    tos = -1;
+    program = 0;
+
+    do {
+        if (++tos == stack_size)
+            reallocateStack();
+
+        state_stack[tos] = action;
+
+    _Lcheck_token:
+        if (yytoken == -1 && -TERMINAL_COUNT != action_index[action]) {
+            yyprevlloc = yylloc;
+
+            if (first_token == last_token) {
+                yytoken = lexer->lex();
+                yylval = lexer->dval();
+                yylloc = location(lexer);
+            } else {
+                yytoken = first_token->token;
+                yylval = first_token->dval;
+                yylloc = first_token->loc;
+                ++first_token;
+            }
+        }
+
+        action = t_action(action, yytoken);
+        if (action > 0) {
+            if (action != ACCEPT_STATE) {
+                yytoken = -1;
+                sym(1).dval = yylval;
+                loc(1) = yylloc;
+            } else {
+              --tos;
+              return ! hadErrors;
+            }
+        } else if (action < 0) {
+          const int r = -action - 1;
+          tos -= rhs[r];
+
+          switch (r) {
+
+case 0: {
+  sym(1).Node = sym(2).Node;
+  program = sym(1).Node;
+} break;
+
+case 1: {
+  sym(1).Node = sym(2).Node;
+  program = sym(1).Node;
+} break;
+
+case 2: {
+  sym(1).Node = sym(2).Node;
+  program = sym(1).Node;
+} break;
+
+case 3: {
+  sym(1).Node = sym(2).Node;
+  program = sym(1).Node;
+} break;
+
+case 4: {
+  sym(1).Node = sym(2).Node;
+  program = sym(1).Node;
+} break;
+
+case 5: {
+  sym(1).Node = sym(2).Node;
+  program = sym(1).Node;
+} break;
+
+case 6: {
+  sym(1).UiProgram = makeAstNode<AST::UiProgram> (driver->nodePool(), sym(1).UiImportList,
+        sym(2).UiObjectMemberList->finish());
+} break;
+
+case 8: {
+    sym(1).Node = sym(1).UiImportList->finish();
+} break;
+
+case 9: {
+    sym(1).Node = makeAstNode<AST::UiImportList> (driver->nodePool(), sym(1).UiImport);
+} break;
+
+case 10: {
+    sym(1).Node = makeAstNode<AST::UiImportList> (driver->nodePool(),
+        sym(1).UiImportList, sym(2).UiImport);
+} break;
+
+case 13: {
+    sym(1).UiImport->semicolonToken = loc(2);
+} break;
+
+case 15: {
+    sym(1).UiImport->versionToken = loc(2);
+    sym(1).UiImport->semicolonToken = loc(3);
+} break;
+
+case 17: {
+    sym(1).UiImport->versionToken = loc(2);
+    sym(1).UiImport->asToken = loc(3);
+    sym(1).UiImport->importIdToken = loc(4);
+    sym(1).UiImport->importId = sym(4).sval;
+    sym(1).UiImport->semicolonToken = loc(5);
+} break;
+
+case 19: {
+    sym(1).UiImport->asToken = loc(2);
+    sym(1).UiImport->importIdToken = loc(3);
+    sym(1).UiImport->importId = sym(3).sval;
+    sym(1).UiImport->semicolonToken = loc(4);
+} break;
+
+case 20: {
+    AST::UiImport *node = 0;
+
+    if (AST::StringLiteral *importIdLiteral = AST::cast<AST::StringLiteral *>(sym(2).Expression)) {
+        node = makeAstNode<AST::UiImport>(driver->nodePool(), importIdLiteral->value);
+        node->fileNameToken = loc(2);
+    } else if (AST::UiQualifiedId *qualifiedId = reparseAsQualifiedId(sym(2).Expression)) {
+        node = makeAstNode<AST::UiImport>(driver->nodePool(), qualifiedId);
+        node->fileNameToken = loc(2);
+    }
+
+    sym(1).Node = node;
+
+    if (node) {
+        node->importToken = loc(1);
+    } else {
+       diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, loc(1),
+         QLatin1String("Expected a qualified name id or a string literal")));
+
+        return false; // ### remove me
+    }
+} break;
+
+case 21: {
+    sym(1).Node = 0;
+} break;
+
+case 22: {
+    sym(1).Node = makeAstNode<AST::UiObjectMemberList> (driver->nodePool(), sym(1).UiObjectMember);
+} break;
+
+case 23: {
+    sym(1).Node = makeAstNode<AST::UiObjectMemberList> (driver->nodePool(), sym(1).UiObjectMember);
+} break;
+
+case 24: {
+    AST::UiObjectMemberList *node = makeAstNode<AST:: UiObjectMemberList> (driver->nodePool(),
+        sym(1).UiObjectMemberList, sym(2).UiObjectMember);
+    sym(1).Node = node;
+} break;
+
+case 25: {
+    sym(1).Node = makeAstNode<AST::UiArrayMemberList> (driver->nodePool(), sym(1).UiObjectMember);
+} break;
+
+case 26: {
+    AST::UiArrayMemberList *node = makeAstNode<AST::UiArrayMemberList> (driver->nodePool(),
+        sym(1).UiArrayMemberList, sym(3).UiObjectMember);
+    node->commaToken = loc(2);
+    sym(1).Node = node;
+} break;
+
+case 27: {
+    AST::UiObjectInitializer *node = makeAstNode<AST::UiObjectInitializer> (driver->nodePool(), (AST::UiObjectMemberList*)0);
+    node->lbraceToken = loc(1);
+    node->rbraceToken = loc(2);
+    sym(1).Node = node;
+}   break;
+
+case 28: {
+    AST::UiObjectInitializer *node = makeAstNode<AST::UiObjectInitializer> (driver->nodePool(), sym(2).UiObjectMemberList->finish());
+    node->lbraceToken = loc(1);
+    node->rbraceToken = loc(3);
+    sym(1).Node = node;
+}   break;
+
+case 29: {
+    AST::UiObjectDefinition *node = makeAstNode<AST::UiObjectDefinition> (driver->nodePool(), sym(1).UiQualifiedId,
+        sym(2).UiObjectInitializer);
+    sym(1).Node = node;
+}   break;
+
+case 31: {
+    AST::UiArrayBinding *node = makeAstNode<AST::UiArrayBinding> (driver->nodePool(),
+        sym(1).UiQualifiedId, sym(4).UiArrayMemberList->finish());
+    node->colonToken = loc(2);
+    node->lbracketToken = loc(3);
+    node->rbracketToken = loc(5);
+    sym(1).Node = node;
+}   break;
+
+case 32: {
+    AST::UiObjectBinding *node = makeAstNode<AST::UiObjectBinding> (driver->nodePool(),
+      sym(1).UiQualifiedId, sym(3).UiQualifiedId, sym(4).UiObjectInitializer);
+    node->colonToken = loc(2);
+    sym(1).Node = node;
+} break;
+
+case 33: {
+    AST::UiObjectBinding *node = makeAstNode<AST::UiObjectBinding> (driver->nodePool(),
+      sym(3).UiQualifiedId, sym(1).UiQualifiedId, sym(4).UiObjectInitializer);
+    node->colonToken = loc(2);
+    node->hasOnToken = true;
+    sym(1).Node = node;
+} break;
+case 34:case 35:case 36:case 37:
+{
+    AST::UiScriptBinding *node = makeAstNode<AST::UiScriptBinding> (driver->nodePool(),
+        sym(1).UiQualifiedId, sym(3).Statement);
+    node->colonToken = loc(2);
+    sym(1).Node = node;
+}   break;
+
+case 38:
+
+case 39: {
+    sym(1).sval = driver->intern(lexer->characterBuffer(), lexer->characterCount());
+    break;
+}
+
+case 41: {
+  sym(1).Node = 0;
+} break;
+
+case 42: {
+  sym(1).Node = sym(1).UiParameterList->finish ();
+} break;
+
+case 43: {
+  AST::UiParameterList *node = makeAstNode<AST::UiParameterList> (driver->nodePool(), sym(1).sval, sym(2).sval);
+  node->identifierToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 44: {
+  AST::UiParameterList *node = makeAstNode<AST::UiParameterList> (driver->nodePool(), sym(1).UiParameterList, sym(3).sval, sym(4).sval);
+  node->commaToken = loc(2);
+  node->identifierToken = loc(4);
+  sym(1).Node = node;
+} break;
+
+case 46: {
+    AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), (NameId *)0, sym(2).sval);
+    node->type = AST::UiPublicMember::Signal;
+    node->propertyToken = loc(1);
+    node->typeToken = loc(2);
+    node->identifierToken = loc(2);
+    node->parameters = sym(4).UiParameterList;
+    node->semicolonToken = loc(6);
+    sym(1).Node = node;
+}   break;
+
+case 48: {
+    AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), (NameId *)0, sym(2).sval);
+    node->type = AST::UiPublicMember::Signal;
+    node->propertyToken = loc(1);
+    node->typeToken = loc(2);
+    node->identifierToken = loc(2);
+    node->semicolonToken = loc(3);
+    sym(1).Node = node;
+}   break;
+
+case 50: {
+    AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(4).sval, sym(6).sval);
+    node->typeModifier = sym(2).sval;
+    node->propertyToken = loc(1);
+    node->typeModifierToken = loc(2);
+    node->typeToken = loc(4);
+    node->identifierToken = loc(6);
+    node->semicolonToken = loc(7);
+    sym(1).Node = node;
+}   break;
+
+case 52: {
+    AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(2).sval, sym(3).sval);
+    node->propertyToken = loc(1);
+    node->typeToken = loc(2);
+    node->identifierToken = loc(3);
+    node->semicolonToken = loc(4);
+    sym(1).Node = node;
+}   break;
+
+case 54: {
+    AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(3).sval, sym(4).sval);
+    node->isDefaultMember = true;
+    node->defaultToken = loc(1);
+    node->propertyToken = loc(2);
+    node->typeToken = loc(3);
+    node->identifierToken = loc(4);
+    node->semicolonToken = loc(5);
+    sym(1).Node = node;
+}   break;
+
+case 56: {
+    AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(2).sval, sym(3).sval,
+        sym(5).Expression);
+    node->propertyToken = loc(1);
+    node->typeToken = loc(2);
+    node->identifierToken = loc(3);
+    node->colonToken = loc(4);
+    node->semicolonToken = loc(6);
+    sym(1).Node = node;
+}   break;
+
+case 58: {
+    AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(3).sval, sym(4).sval,
+        sym(6).Expression);
+    node->isReadonlyMember = true;
+    node->readonlyToken = loc(1);
+    node->propertyToken = loc(2);
+    node->typeToken = loc(3);
+    node->identifierToken = loc(4);
+    node->colonToken = loc(5);
+    node->semicolonToken = loc(7);
+    sym(1).Node = node;
+}   break;
+
+case 60: {
+    AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(3).sval, sym(4).sval,
+        sym(6).Expression);
+    node->isDefaultMember = true;
+    node->defaultToken = loc(1);
+    node->propertyToken = loc(2);
+    node->typeToken = loc(3);
+    node->identifierToken = loc(4);
+    node->colonToken = loc(5);
+    node->semicolonToken = loc(7);
+    sym(1).Node = node;
+}   break;
+
+case 61: {
+    AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(4).sval, sym(6).sval);
+    node->typeModifier = sym(2).sval;
+    node->propertyToken = loc(1);
+    node->typeModifierToken = loc(2);
+    node->typeToken = loc(4);
+    node->identifierToken = loc(6);
+    node->semicolonToken = loc(7); // insert a fake ';' before ':'
+
+    AST::UiQualifiedId *propertyName = makeAstNode<AST::UiQualifiedId>(driver->nodePool(), sym(6).sval);
+    propertyName->identifierToken = loc(6);
+    propertyName->next = 0;
+
+    AST::UiArrayBinding *binding = makeAstNode<AST::UiArrayBinding> (driver->nodePool(),
+        propertyName, sym(9).UiArrayMemberList->finish());
+    binding->colonToken = loc(7);
+    binding->lbracketToken = loc(8);
+    binding->rbracketToken = loc(10);
+
+    node->binding = binding;
+
+    sym(1).Node = node;
+}   break;
+
+case 62: {
+    AST::UiPublicMember *node = makeAstNode<AST::UiPublicMember> (driver->nodePool(), sym(2).sval, sym(3).sval);
+    node->propertyToken = loc(1);
+    node->typeToken = loc(2);
+    node->identifierToken = loc(3);
+    node->semicolonToken = loc(4); // insert a fake ';' before ':'
+
+    AST::UiQualifiedId *propertyName = makeAstNode<AST::UiQualifiedId>(driver->nodePool(), sym(3).sval);
+    propertyName->identifierToken = loc(3);
+    propertyName->next = 0;
+
+    AST::UiObjectBinding *binding = makeAstNode<AST::UiObjectBinding> (driver->nodePool(),
+      propertyName, sym(5).UiQualifiedId, sym(6).UiObjectInitializer);
+    binding->colonToken = loc(4);
+
+    node->binding = binding;
+
+    sym(1).Node = node;
+}   break;
+
+case 63: {
+    sym(1).Node = makeAstNode<AST::UiSourceElement>(driver->nodePool(), sym(1).Node);
+}   break;
+
+case 64: {
+    sym(1).Node = makeAstNode<AST::UiSourceElement>(driver->nodePool(), sym(1).Node);
+}   break;
+
+case 66: {
+    QString s = QLatin1String(QDeclarativeJSGrammar::spell[T_PROPERTY]);
+    sym(1).sval = driver->intern(s.constData(), s.length());
+    break;
+}
+
+case 67: {
+    QString s = QLatin1String(QDeclarativeJSGrammar::spell[T_SIGNAL]);
+    sym(1).sval = driver->intern(s.constData(), s.length());
+    break;
+}
+
+case 68: {
+    QString s = QLatin1String(QDeclarativeJSGrammar::spell[T_READONLY]);
+    sym(1).sval = driver->intern(s.constData(), s.length());
+    break;
+}
+
+case 69: {
+    QString s = QLatin1String(QDeclarativeJSGrammar::spell[T_ON]);
+    sym(1).sval = driver->intern(s.constData(), s.length());
+    break;
+}
+
+case 70: {
+  AST::ThisExpression *node = makeAstNode<AST::ThisExpression> (driver->nodePool());
+  node->thisToken = loc(1);
+  sym(1).Node = node;
+} break;
+
+case 71: {
+  AST::IdentifierExpression *node = makeAstNode<AST::IdentifierExpression> (driver->nodePool(), sym(1).sval);
+  node->identifierToken = loc(1);
+  sym(1).Node = node;
+} break;
+
+case 72: {
+  AST::NullExpression *node = makeAstNode<AST::NullExpression> (driver->nodePool());
+  node->nullToken = loc(1);
+  sym(1).Node = node;
+} break;
+
+case 73: {
+  AST::TrueLiteral *node = makeAstNode<AST::TrueLiteral> (driver->nodePool());
+  node->trueToken = loc(1);
+  sym(1).Node = node;
+} break;
+
+case 74: {
+  AST::FalseLiteral *node = makeAstNode<AST::FalseLiteral> (driver->nodePool());
+  node->falseToken = loc(1);
+  sym(1).Node = node;
+} break;
+
+case 75: {
+  AST::NumericLiteral *node = makeAstNode<AST::NumericLiteral> (driver->nodePool(), sym(1).dval);
+  node->literalToken = loc(1);
+  sym(1).Node = node;
+} break;
+case 76:
+case 77: {
+  AST::StringLiteral *node = makeAstNode<AST::StringLiteral> (driver->nodePool(), sym(1).sval);
+  node->literalToken = loc(1);
+  sym(1).Node = node;
+} break;
+
+case 78: {
+  bool rx = lexer->scanRegExp(Lexer::NoPrefix);
+  if (!rx) {
+    diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, location(lexer), lexer->errorMessage()));
+    return false; // ### remove me
+  }
+
+  loc(1).length = lexer->tokenLength();
+
+  AST::RegExpLiteral *node = makeAstNode<AST::RegExpLiteral> (driver->nodePool(), lexer->pattern, lexer->flags);
+  node->literalToken = loc(1);
+  sym(1).Node = node;
+} break;
+
+case 79: {
+  bool rx = lexer->scanRegExp(Lexer::EqualPrefix);
+  if (!rx) {
+    diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, location(lexer), lexer->errorMessage()));
+    return false;
+  }
+
+  loc(1).length = lexer->tokenLength();
+
+  AST::RegExpLiteral *node = makeAstNode<AST::RegExpLiteral> (driver->nodePool(), lexer->pattern, lexer->flags);
+  node->literalToken = loc(1);
+  sym(1).Node = node;
+} break;
+
+case 80: {
+  AST::ArrayLiteral *node = makeAstNode<AST::ArrayLiteral> (driver->nodePool(), (AST::Elision *) 0);
+  node->lbracketToken = loc(1);
+  node->rbracketToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 81: {
+  AST::ArrayLiteral *node = makeAstNode<AST::ArrayLiteral> (driver->nodePool(), sym(2).Elision->finish());
+  node->lbracketToken = loc(1);
+  node->rbracketToken = loc(3);
+  sym(1).Node = node;
+} break;
+
+case 82: {
+  AST::ArrayLiteral *node = makeAstNode<AST::ArrayLiteral> (driver->nodePool(), sym(2).ElementList->finish ());
+  node->lbracketToken = loc(1);
+  node->rbracketToken = loc(3);
+  sym(1).Node = node;
+} break;
+
+case 83: {
+  AST::ArrayLiteral *node = makeAstNode<AST::ArrayLiteral> (driver->nodePool(), sym(2).ElementList->finish (),
+    (AST::Elision *) 0);
+  node->lbracketToken = loc(1);
+  node->commaToken = loc(3);
+  node->rbracketToken = loc(4);
+  sym(1).Node = node;
+} break;
+
+case 84: {
+  AST::ArrayLiteral *node = makeAstNode<AST::ArrayLiteral> (driver->nodePool(), sym(2).ElementList->finish (),
+    sym(4).Elision->finish());
+  node->lbracketToken = loc(1);
+  node->commaToken = loc(3);
+  node->rbracketToken = loc(5);
+  sym(1).Node = node;
+} break;
+
+case 85: {
+  AST::ObjectLiteral *node = 0;
+  if (sym(2).Node)
+    node = makeAstNode<AST::ObjectLiteral> (driver->nodePool(),
+        sym(2).PropertyNameAndValueList->finish ());
+  else
+    node = makeAstNode<AST::ObjectLiteral> (driver->nodePool());
+  node->lbraceToken = loc(1);
+  node->rbraceToken = loc(3);
+  sym(1).Node = node;
+} break;
+
+case 86: {
+  AST::ObjectLiteral *node = makeAstNode<AST::ObjectLiteral> (driver->nodePool(),
+    sym(2).PropertyNameAndValueList->finish ());
+  node->lbraceToken = loc(1);
+  node->rbraceToken = loc(4);
+  sym(1).Node = node;
+} break;
+
+case 87: {
+  AST::NestedExpression *node = makeAstNode<AST::NestedExpression>(driver->nodePool(), sym(2).Expression);
+  node->lparenToken = loc(1);
+  node->rparenToken = loc(3);
+  sym(1).Node = node;
+} break;
+
+case 88: {
+  if (AST::ArrayMemberExpression *mem = AST::cast<AST::ArrayMemberExpression *>(sym(1).Expression)) {
+    diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Warning, mem->lbracketToken,
+      QLatin1String("Ignored annotation")));
+
+    sym(1).Expression = mem->base;
+  }
+
+  if (AST::UiQualifiedId *qualifiedId = reparseAsQualifiedId(sym(1).Expression)) {
+    sym(1).UiQualifiedId = qualifiedId;
+  } else {
+    sym(1).UiQualifiedId = 0;
+
+    diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, loc(1),
+      QLatin1String("Expected a qualified name id")));
+
+    return false; // ### recover
+  }
+} break;
+
+case 89: {
+  sym(1).Node = makeAstNode<AST::ElementList> (driver->nodePool(), (AST::Elision *) 0, sym(1).Expression);
+} break;
+
+case 90: {
+  sym(1).Node = makeAstNode<AST::ElementList> (driver->nodePool(), sym(1).Elision->finish(), sym(2).Expression);
+} break;
+
+case 91: {
+  AST::ElementList *node = makeAstNode<AST::ElementList> (driver->nodePool(), sym(1).ElementList,
+    (AST::Elision *) 0, sym(3).Expression);
+  node->commaToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 92: {
+  AST::ElementList *node = makeAstNode<AST::ElementList> (driver->nodePool(), sym(1).ElementList, sym(3).Elision->finish(),
+    sym(4).Expression);
+  node->commaToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 93: {
+  AST::Elision *node = makeAstNode<AST::Elision> (driver->nodePool());
+  node->commaToken = loc(1);
+  sym(1).Node = node;
+} break;
+
+case 94: {
+  AST::Elision *node = makeAstNode<AST::Elision> (driver->nodePool(), sym(1).Elision);
+  node->commaToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 95: {
+  AST::PropertyNameAndValueList *node = makeAstNode<AST::PropertyNameAndValueList> (driver->nodePool(),
+      sym(1).PropertyName, sym(3).Expression);
+  node->colonToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 96: {
+  AST::PropertyNameAndValueList *node = makeAstNode<AST::PropertyNameAndValueList> (driver->nodePool(),
+      sym(1).PropertyNameAndValueList, sym(3).PropertyName, sym(5).Expression);
+  node->commaToken = loc(2);
+  node->colonToken = loc(4);
+  sym(1).Node = node;
+} break;
+
+case 97: {
+  AST::IdentifierPropertyName *node = makeAstNode<AST::IdentifierPropertyName> (driver->nodePool(), sym(1).sval);
+  node->propertyNameToken = loc(1);
+  sym(1).Node = node;
+} break;
+case 98:
+case 99: {
+  AST::IdentifierPropertyName *node = makeAstNode<AST::IdentifierPropertyName> (driver->nodePool(), driver->intern(lexer->characterBuffer(), lexer->characterCount()));
+  node->propertyNameToken = loc(1);
+  sym(1).Node = node;
+} break;
+
+case 100: {
+  AST::StringLiteralPropertyName *node = makeAstNode<AST::StringLiteralPropertyName> (driver->nodePool(), sym(1).sval);
+  node->propertyNameToken = loc(1);
+  sym(1).Node = node;
+} break;
+
+case 101: {
+  AST::NumericLiteralPropertyName *node = makeAstNode<AST::NumericLiteralPropertyName> (driver->nodePool(), sym(1).dval);
+  node->propertyNameToken = loc(1);
+  sym(1).Node = node;
+} break;
+
+case 102: {
+  AST::IdentifierPropertyName *node = makeAstNode<AST::IdentifierPropertyName> (driver->nodePool(), sym(1).sval);
+  node->propertyNameToken = loc(1);
+  sym(1).Node = node;
+} break;
+
+case 103:
+
+case 104:
+
+case 105:
+
+case 106:
+
+case 107:
+
+case 108:
+
+case 109:
+
+case 110:
+
+case 111:
+
+case 112:
+
+case 113:
+
+case 114:
+
+case 115:
+
+case 116:
+
+case 117:
+
+case 118:
+
+case 119:
+
+case 120:
+
+case 121:
+
+case 122:
+
+case 123:
+
+case 124:
+
+case 125:
+
+case 126:
+
+case 127:
+
+case 128:
+
+case 129:
+
+case 130:
+
+case 131:
+
+case 132:
+
+case 133:
+{
+  sym(1).sval = driver->intern(lexer->characterBuffer(), lexer->characterCount());
+} break;
+
+case 138: {
+  AST::ArrayMemberExpression *node = makeAstNode<AST::ArrayMemberExpression> (driver->nodePool(), sym(1).Expression, sym(3).Expression);
+  node->lbracketToken = loc(2);
+  node->rbracketToken = loc(4);
+  sym(1).Node = node;
+} break;
+
+case 139: {
+  AST::FieldMemberExpression *node = makeAstNode<AST::FieldMemberExpression> (driver->nodePool(), sym(1).Expression, sym(3).sval);
+  node->dotToken = loc(2);
+  node->identifierToken = loc(3);
+  sym(1).Node = node;
+} break;
+
+case 140: {
+  AST::NewMemberExpression *node = makeAstNode<AST::NewMemberExpression> (driver->nodePool(), sym(2).Expression, sym(4).ArgumentList);
+  node->newToken = loc(1);
+  node->lparenToken = loc(3);
+  node->rparenToken = loc(5);
+  sym(1).Node = node;
+} break;
+
+case 142: {
+  AST::NewExpression *node = makeAstNode<AST::NewExpression> (driver->nodePool(), sym(2).Expression);
+  node->newToken = loc(1);
+  sym(1).Node = node;
+} break;
+
+case 143: {
+  AST::CallExpression *node = makeAstNode<AST::CallExpression> (driver->nodePool(), sym(1).Expression, sym(3).ArgumentList);
+  node->lparenToken = loc(2);
+  node->rparenToken = loc(4);
+  sym(1).Node = node;
+} break;
+
+case 144: {
+  AST::CallExpression *node = makeAstNode<AST::CallExpression> (driver->nodePool(), sym(1).Expression, sym(3).ArgumentList);
+  node->lparenToken = loc(2);
+  node->rparenToken = loc(4);
+  sym(1).Node = node;
+} break;
+
+case 145: {
+  AST::ArrayMemberExpression *node = makeAstNode<AST::ArrayMemberExpression> (driver->nodePool(), sym(1).Expression, sym(3).Expression);
+  node->lbracketToken = loc(2);
+  node->rbracketToken = loc(4);
+  sym(1).Node = node;
+} break;
+
+case 146: {
+  AST::FieldMemberExpression *node = makeAstNode<AST::FieldMemberExpression> (driver->nodePool(), sym(1).Expression, sym(3).sval);
+  node->dotToken = loc(2);
+  node->identifierToken = loc(3);
+  sym(1).Node = node;
+} break;
+
+case 147: {
+  sym(1).Node = 0;
+} break;
+
+case 148: {
+  sym(1).Node = sym(1).ArgumentList->finish();
+} break;
+
+case 149: {
+  sym(1).Node = makeAstNode<AST::ArgumentList> (driver->nodePool(), sym(1).Expression);
+} break;
+
+case 150: {
+  AST::ArgumentList *node = makeAstNode<AST::ArgumentList> (driver->nodePool(), sym(1).ArgumentList, sym(3).Expression);
+  node->commaToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 154: {
+  AST::PostIncrementExpression *node = makeAstNode<AST::PostIncrementExpression> (driver->nodePool(), sym(1).Expression);
+  node->incrementToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 155: {
+  AST::PostDecrementExpression *node = makeAstNode<AST::PostDecrementExpression> (driver->nodePool(), sym(1).Expression);
+  node->decrementToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 157: {
+  AST::DeleteExpression *node = makeAstNode<AST::DeleteExpression> (driver->nodePool(), sym(2).Expression);
+  node->deleteToken = loc(1);
+  sym(1).Node = node;
+} break;
+
+case 158: {
+  AST::VoidExpression *node = makeAstNode<AST::VoidExpression> (driver->nodePool(), sym(2).Expression);
+  node->voidToken = loc(1);
+  sym(1).Node = node;
+} break;
+
+case 159: {
+  AST::TypeOfExpression *node = makeAstNode<AST::TypeOfExpression> (driver->nodePool(), sym(2).Expression);
+  node->typeofToken = loc(1);
+  sym(1).Node = node;
+} break;
+
+case 160: {
+  AST::PreIncrementExpression *node = makeAstNode<AST::PreIncrementExpression> (driver->nodePool(), sym(2).Expression);
+  node->incrementToken = loc(1);
+  sym(1).Node = node;
+} break;
+
+case 161: {
+  AST::PreDecrementExpression *node = makeAstNode<AST::PreDecrementExpression> (driver->nodePool(), sym(2).Expression);
+  node->decrementToken = loc(1);
+  sym(1).Node = node;
+} break;
+
+case 162: {
+  AST::UnaryPlusExpression *node = makeAstNode<AST::UnaryPlusExpression> (driver->nodePool(), sym(2).Expression);
+  node->plusToken = loc(1);
+  sym(1).Node = node;
+} break;
+
+case 163: {
+  AST::UnaryMinusExpression *node = makeAstNode<AST::UnaryMinusExpression> (driver->nodePool(), sym(2).Expression);
+  node->minusToken = loc(1);
+  sym(1).Node = node;
+} break;
+
+case 164: {
+  AST::TildeExpression *node = makeAstNode<AST::TildeExpression> (driver->nodePool(), sym(2).Expression);
+  node->tildeToken = loc(1);
+  sym(1).Node = node;
+} break;
+
+case 165: {
+  AST::NotExpression *node = makeAstNode<AST::NotExpression> (driver->nodePool(), sym(2).Expression);
+  node->notToken = loc(1);
+  sym(1).Node = node;
+} break;
+
+case 167: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Mul, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 168: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Div, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 169: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Mod, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 171: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Add, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 172: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Sub, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 174: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::LShift, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 175: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::RShift, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 176: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::URShift, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 178: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Lt, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 179: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Gt, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 180: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Le, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 181: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Ge, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 182: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::InstanceOf, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 183: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::In, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 185: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Lt, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 186: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Gt, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 187: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Le, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 188: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+   QSOperator::Ge, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 189: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::InstanceOf, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 191: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Equal, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 192: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::NotEqual, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 193: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::StrictEqual, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 194: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::StrictNotEqual, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 196: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Equal, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 197: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::NotEqual, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 198: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::StrictEqual, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 199: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::StrictNotEqual, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 201: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::BitAnd, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 203: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::BitAnd, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 205: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::BitXor, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 207: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::BitXor, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 209: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::BitOr, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 211: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::BitOr, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 213: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::And, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 215: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::And, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 217: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Or, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 219: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    QSOperator::Or, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 221: {
+  AST::ConditionalExpression *node = makeAstNode<AST::ConditionalExpression> (driver->nodePool(), sym(1).Expression,
+    sym(3).Expression, sym(5).Expression);
+  node->questionToken = loc(2);
+  node->colonToken = loc(4);
+  sym(1).Node = node;
+} break;
+
+case 223: {
+  AST::ConditionalExpression *node = makeAstNode<AST::ConditionalExpression> (driver->nodePool(), sym(1).Expression,
+    sym(3).Expression, sym(5).Expression);
+  node->questionToken = loc(2);
+  node->colonToken = loc(4);
+  sym(1).Node = node;
+} break;
+
+case 225: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    sym(2).ival, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 227: {
+  AST::BinaryExpression *node = makeAstNode<AST::BinaryExpression> (driver->nodePool(), sym(1).Expression,
+    sym(2).ival, sym(3).Expression);
+  node->operatorToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 228: {
+  sym(1).ival = QSOperator::Assign;
+} break;
+
+case 229: {
+  sym(1).ival = QSOperator::InplaceMul;
+} break;
+
+case 230: {
+  sym(1).ival = QSOperator::InplaceDiv;
+} break;
+
+case 231: {
+  sym(1).ival = QSOperator::InplaceMod;
+} break;
+
+case 232: {
+  sym(1).ival = QSOperator::InplaceAdd;
+} break;
+
+case 233: {
+  sym(1).ival = QSOperator::InplaceSub;
+} break;
+
+case 234: {
+  sym(1).ival = QSOperator::InplaceLeftShift;
+} break;
+
+case 235: {
+  sym(1).ival = QSOperator::InplaceRightShift;
+} break;
+
+case 236: {
+  sym(1).ival = QSOperator::InplaceURightShift;
+} break;
+
+case 237: {
+  sym(1).ival = QSOperator::InplaceAnd;
+} break;
+
+case 238: {
+  sym(1).ival = QSOperator::InplaceXor;
+} break;
+
+case 239: {
+  sym(1).ival = QSOperator::InplaceOr;
+} break;
+
+case 241: {
+  AST::Expression *node = makeAstNode<AST::Expression> (driver->nodePool(), sym(1).Expression, sym(3).Expression);
+  node->commaToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 242: {
+  sym(1).Node = 0;
+} break;
+
+case 245: {
+  AST::Expression *node = makeAstNode<AST::Expression> (driver->nodePool(), sym(1).Expression, sym(3).Expression);
+  node->commaToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 246: {
+  sym(1).Node = 0;
+} break;
+
+case 263: {
+  AST::Block *node = makeAstNode<AST::Block> (driver->nodePool(), sym(2).StatementList);
+  node->lbraceToken = loc(1);
+  node->rbraceToken = loc(3);
+  sym(1).Node = node;
+} break;
+
+case 264: {
+  sym(1).Node = makeAstNode<AST::StatementList> (driver->nodePool(), sym(1).Statement);
+} break;
+
+case 265: {
+  sym(1).Node = makeAstNode<AST::StatementList> (driver->nodePool(), sym(1).StatementList, sym(2).Statement);
+} break;
+
+case 266: {
+  sym(1).Node = 0;
+} break;
+
+case 267: {
+  sym(1).Node = sym(1).StatementList->finish ();
+} break;
+
+case 269: {
+  AST::VariableStatement *node = makeAstNode<AST::VariableStatement> (driver->nodePool(),
+     sym(2).VariableDeclarationList->finish (/*readOnly=*/sym(1).ival == T_CONST));
+  node->declarationKindToken = loc(1);
+  node->semicolonToken = loc(3);
+  sym(1).Node = node;
+} break;
+
+case 270: {
+  sym(1).ival = T_CONST;
+} break;
+
+case 271: {
+  sym(1).ival = T_VAR;
+} break;
+
+case 272: {
+  sym(1).Node = makeAstNode<AST::VariableDeclarationList> (driver->nodePool(), sym(1).VariableDeclaration);
+} break;
+
+case 273: {
+  AST::VariableDeclarationList *node = makeAstNode<AST::VariableDeclarationList> (driver->nodePool(),
+    sym(1).VariableDeclarationList, sym(3).VariableDeclaration);
+  node->commaToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 274: {
+  sym(1).Node = makeAstNode<AST::VariableDeclarationList> (driver->nodePool(), sym(1).VariableDeclaration);
+} break;
+
+case 275: {
+  sym(1).Node = makeAstNode<AST::VariableDeclarationList> (driver->nodePool(), sym(1).VariableDeclarationList, sym(3).VariableDeclaration);
+} break;
+
+case 276: {
+  AST::VariableDeclaration *node = makeAstNode<AST::VariableDeclaration> (driver->nodePool(), sym(1).sval, sym(2).Expression);
+  node->identifierToken = loc(1);
+  sym(1).Node = node;
+} break;
+
+case 277: {
+  AST::VariableDeclaration *node = makeAstNode<AST::VariableDeclaration> (driver->nodePool(), sym(1).sval, sym(2).Expression);
+  node->identifierToken = loc(1);
+  sym(1).Node = node;
+} break;
+
+case 278: {
+  // ### TODO: AST for initializer
+  sym(1) = sym(2);
+} break;
+
+case 279: {
+  sym(1).Node = 0;
+} break;
+
+case 281: {
+  // ### TODO: AST for initializer
+  sym(1) = sym(2);
+} break;
+
+case 282: {
+  sym(1).Node = 0;
+} break;
+
+case 284: {
+  AST::EmptyStatement *node = makeAstNode<AST::EmptyStatement> (driver->nodePool());
+  node->semicolonToken = loc(1);
+  sym(1).Node = node;
+} break;
+
+case 286: {
+  AST::ExpressionStatement *node = makeAstNode<AST::ExpressionStatement> (driver->nodePool(), sym(1).Expression);
+  node->semicolonToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 287: {
+  AST::IfStatement *node = makeAstNode<AST::IfStatement> (driver->nodePool(), sym(3).Expression, sym(5).Statement, sym(7).Statement);
+  node->ifToken = loc(1);
+  node->lparenToken = loc(2);
+  node->rparenToken = loc(4);
+  node->elseToken = loc(5);
+  sym(1).Node = node;
+} break;
+
+case 288: {
+  AST::IfStatement *node = makeAstNode<AST::IfStatement> (driver->nodePool(), sym(3).Expression, sym(5).Statement);
+  node->ifToken = loc(1);
+  node->lparenToken = loc(2);
+  node->rparenToken = loc(4);
+  sym(1).Node = node;
+} break;
+
+case 290: {
+  AST::DoWhileStatement *node = makeAstNode<AST::DoWhileStatement> (driver->nodePool(), sym(2).Statement, sym(5).Expression);
+  node->doToken = loc(1);
+  node->whileToken = loc(3);
+  node->lparenToken = loc(4);
+  node->rparenToken = loc(6);
+  node->semicolonToken = loc(7);
+  sym(1).Node = node;
+} break;
+
+case 291: {
+  AST::WhileStatement *node = makeAstNode<AST::WhileStatement> (driver->nodePool(), sym(3).Expression, sym(5).Statement);
+  node->whileToken = loc(1);
+  node->lparenToken = loc(2);
+  node->rparenToken = loc(4);
+  sym(1).Node = node;
+} break;
+
+case 292: {
+  AST::ForStatement *node = makeAstNode<AST::ForStatement> (driver->nodePool(), sym(3).Expression,
+    sym(5).Expression, sym(7).Expression, sym(9).Statement);
+  node->forToken = loc(1);
+  node->lparenToken = loc(2);
+  node->firstSemicolonToken = loc(4);
+  node->secondSemicolonToken = loc(6);
+  node->rparenToken = loc(8);
+  sym(1).Node = node;
+} break;
+
+case 293: {
+  AST::LocalForStatement *node = makeAstNode<AST::LocalForStatement> (driver->nodePool(),
+     sym(4).VariableDeclarationList->finish (/*readOnly=*/false), sym(6).Expression,
+     sym(8).Expression, sym(10).Statement);
+  node->forToken = loc(1);
+  node->lparenToken = loc(2);
+  node->varToken = loc(3);
+  node->firstSemicolonToken = loc(5);
+  node->secondSemicolonToken = loc(7);
+  node->rparenToken = loc(9);
+  sym(1).Node = node;
+} break;
+
+case 294: {
+  AST:: ForEachStatement *node = makeAstNode<AST::ForEachStatement> (driver->nodePool(), sym(3).Expression,
+    sym(5).Expression, sym(7).Statement);
+  node->forToken = loc(1);
+  node->lparenToken = loc(2);
+  node->inToken = loc(4);
+  node->rparenToken = loc(6);
+  sym(1).Node = node;
+} break;
+
+case 295: {
+  AST::LocalForEachStatement *node = makeAstNode<AST::LocalForEachStatement> (driver->nodePool(),
+    sym(4).VariableDeclaration, sym(6).Expression, sym(8).Statement);
+  node->forToken = loc(1);
+  node->lparenToken = loc(2);
+  node->varToken = loc(3);
+  node->inToken = loc(5);
+  node->rparenToken = loc(7);
+  sym(1).Node = node;
+} break;
+
+case 297: {
+  AST::ContinueStatement *node = makeAstNode<AST::ContinueStatement> (driver->nodePool());
+  node->continueToken = loc(1);
+  node->semicolonToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 299: {
+  AST::ContinueStatement *node = makeAstNode<AST::ContinueStatement> (driver->nodePool(), sym(2).sval);
+  node->continueToken = loc(1);
+  node->identifierToken = loc(2);
+  node->semicolonToken = loc(3);
+  sym(1).Node = node;
+} break;
+
+case 301: {
+  AST::BreakStatement *node = makeAstNode<AST::BreakStatement> (driver->nodePool());
+  node->breakToken = loc(1);
+  node->semicolonToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 303: {
+  AST::BreakStatement *node = makeAstNode<AST::BreakStatement> (driver->nodePool(), sym(2).sval);
+  node->breakToken = loc(1);
+  node->identifierToken = loc(2);
+  node->semicolonToken = loc(3);
+  sym(1).Node = node;
+} break;
+
+case 305: {
+  AST::ReturnStatement *node = makeAstNode<AST::ReturnStatement> (driver->nodePool(), sym(2).Expression);
+  node->returnToken = loc(1);
+  node->semicolonToken = loc(3);
+  sym(1).Node = node;
+} break;
+
+case 306: {
+  AST::WithStatement *node = makeAstNode<AST::WithStatement> (driver->nodePool(), sym(3).Expression, sym(5).Statement);
+  node->withToken = loc(1);
+  node->lparenToken = loc(2);
+  node->rparenToken = loc(4);
+  sym(1).Node = node;
+} break;
+
+case 307: {
+  AST::SwitchStatement *node = makeAstNode<AST::SwitchStatement> (driver->nodePool(), sym(3).Expression, sym(5).CaseBlock);
+  node->switchToken = loc(1);
+  node->lparenToken = loc(2);
+  node->rparenToken = loc(4);
+  sym(1).Node = node;
+} break;
+
+case 308: {
+  AST::CaseBlock *node = makeAstNode<AST::CaseBlock> (driver->nodePool(), sym(2).CaseClauses);
+  node->lbraceToken = loc(1);
+  node->rbraceToken = loc(3);
+  sym(1).Node = node;
+} break;
+
+case 309: {
+  AST::CaseBlock *node = makeAstNode<AST::CaseBlock> (driver->nodePool(), sym(2).CaseClauses, sym(3).DefaultClause, sym(4).CaseClauses);
+  node->lbraceToken = loc(1);
+  node->rbraceToken = loc(5);
+  sym(1).Node = node;
+} break;
+
+case 310: {
+  sym(1).Node = makeAstNode<AST::CaseClauses> (driver->nodePool(), sym(1).CaseClause);
+} break;
+
+case 311: {
+  sym(1).Node = makeAstNode<AST::CaseClauses> (driver->nodePool(), sym(1).CaseClauses, sym(2).CaseClause);
+} break;
+
+case 312: {
+  sym(1).Node = 0;
+} break;
+
+case 313: {
+  sym(1).Node = sym(1).CaseClauses->finish ();
+} break;
+
+case 314: {
+  AST::CaseClause *node = makeAstNode<AST::CaseClause> (driver->nodePool(), sym(2).Expression, sym(4).StatementList);
+  node->caseToken = loc(1);
+  node->colonToken = loc(3);
+  sym(1).Node = node;
+} break;
+
+case 315: {
+  AST::DefaultClause *node = makeAstNode<AST::DefaultClause> (driver->nodePool(), sym(3).StatementList);
+  node->defaultToken = loc(1);
+  node->colonToken = loc(2);
+  sym(1).Node = node;
+} break;
+case 316:
+case 317: {
+  AST::LabelledStatement *node = makeAstNode<AST::LabelledStatement> (driver->nodePool(), driver->intern(lexer->characterBuffer(), lexer->characterCount()), sym(3).Statement);
+  node->identifierToken = loc(1);
+  node->colonToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 318: {
+  AST::LabelledStatement *node = makeAstNode<AST::LabelledStatement> (driver->nodePool(), sym(1).sval, sym(3).Statement);
+  node->identifierToken = loc(1);
+  node->colonToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 320: {
+  AST::ThrowStatement *node = makeAstNode<AST::ThrowStatement> (driver->nodePool(), sym(2).Expression);
+  node->throwToken = loc(1);
+  node->semicolonToken = loc(3);
+  sym(1).Node = node;
+} break;
+
+case 321: {
+  AST::TryStatement *node = makeAstNode<AST::TryStatement> (driver->nodePool(), sym(2).Statement, sym(3).Catch);
+  node->tryToken = loc(1);
+  sym(1).Node = node;
+} break;
+
+case 322: {
+  AST::TryStatement *node = makeAstNode<AST::TryStatement> (driver->nodePool(), sym(2).Statement, sym(3).Finally);
+  node->tryToken = loc(1);
+  sym(1).Node = node;
+} break;
+
+case 323: {
+  AST::TryStatement *node = makeAstNode<AST::TryStatement> (driver->nodePool(), sym(2).Statement, sym(3).Catch, sym(4).Finally);
+  node->tryToken = loc(1);
+  sym(1).Node = node;
+} break;
+
+case 324: {
+  AST::Catch *node = makeAstNode<AST::Catch> (driver->nodePool(), sym(3).sval, sym(5).Block);
+  node->catchToken = loc(1);
+  node->lparenToken = loc(2);
+  node->identifierToken = loc(3);
+  node->rparenToken = loc(4);
+  sym(1).Node = node;
+} break;
+
+case 325: {
+  AST::Finally *node = makeAstNode<AST::Finally> (driver->nodePool(), sym(2).Block);
+  node->finallyToken = loc(1);
+  sym(1).Node = node;
+} break;
+
+case 327: {
+  AST::DebuggerStatement *node = makeAstNode<AST::DebuggerStatement> (driver->nodePool());
+  node->debuggerToken = loc(1);
+  node->semicolonToken = loc(2);
+  sym(1).Node = node;
+} break;
+
+case 328: {
+  AST::FunctionDeclaration *node = makeAstNode<AST::FunctionDeclaration> (driver->nodePool(), sym(2).sval, sym(4).FormalParameterList, sym(7).FunctionBody);
+  node->functionToken = loc(1);
+  node->identifierToken = loc(2);
+  node->lparenToken = loc(3);
+  node->rparenToken = loc(5);
+  node->lbraceToken = loc(6);
+  node->rbraceToken = loc(8);
+  sym(1).Node = node;
+} break;
+
+case 329: {
+  AST::FunctionExpression *node = makeAstNode<AST::FunctionExpression> (driver->nodePool(), sym(2).sval, sym(4).FormalParameterList, sym(7).FunctionBody);
+  node->functionToken = loc(1);
+  if (sym(2).sval)
+      node->identifierToken = loc(2);
+  node->lparenToken = loc(3);
+  node->rparenToken = loc(5);
+  node->lbraceToken = loc(6);
+  node->rbraceToken = loc(8);
+  sym(1).Node = node;
+} break;
+
+case 330: {
+  AST::FormalParameterList *node = makeAstNode<AST::FormalParameterList> (driver->nodePool(), sym(1).sval);
+  node->identifierToken = loc(1);
+  sym(1).Node = node;
+} break;
+
+case 331: {
+  AST::FormalParameterList *node = makeAstNode<AST::FormalParameterList> (driver->nodePool(), sym(1).FormalParameterList, sym(3).sval);
+  node->commaToken = loc(2);
+  node->identifierToken = loc(3);
+  sym(1).Node = node;
+} break;
+
+case 332: {
+  sym(1).Node = 0;
+} break;
+
+case 333: {
+  sym(1).Node = sym(1).FormalParameterList->finish ();
+} break;
+
+case 334: {
+  sym(1).Node = 0;
+} break;
+
+case 336: {
+  sym(1).Node = makeAstNode<AST::FunctionBody> (driver->nodePool(), sym(1).SourceElements->finish ());
+} break;
+
+case 337: {
+  sym(1).Node = makeAstNode<AST::Program> (driver->nodePool(), sym(1).SourceElements->finish ());
+} break;
+
+case 338: {
+  sym(1).Node = makeAstNode<AST::SourceElements> (driver->nodePool(), sym(1).SourceElement);
+} break;
+
+case 339: {
+  sym(1).Node = makeAstNode<AST::SourceElements> (driver->nodePool(), sym(1).SourceElements, sym(2).SourceElement);
+} break;
+
+case 340: {
+  sym(1).Node = makeAstNode<AST::StatementSourceElement> (driver->nodePool(), sym(1).Statement);
+} break;
+
+case 341: {
+  sym(1).Node = makeAstNode<AST::FunctionSourceElement> (driver->nodePool(), sym(1).FunctionDeclaration);
+} break;
+
+case 342: {
+  sym(1).sval = 0;
+} break;
+
+case 344: {
+  sym(1).Node = 0;
+} break;
+
+            } // switch
+            action = nt_action(state_stack[tos], lhs[r] - TERMINAL_COUNT);
+        } // if
+    } while (action != 0);
+
+    if (first_token == last_token) {
+        const int errorState = state_stack[tos];
+
+        // automatic insertion of `;'
+        if (yytoken != -1 && t_action(errorState, T_AUTOMATIC_SEMICOLON) && automatic(driver, yytoken)) {
+            SavedToken &tk = token_buffer[0];
+            tk.token = yytoken;
+            tk.dval = yylval;
+            tk.loc = yylloc;
+
+            yylloc = yyprevlloc;
+            yylloc.offset += yylloc.length;
+            yylloc.startColumn += yylloc.length;
+            yylloc.length = 0;
+
+            //const QString msg = qApp->translate("QDeclarativeParser", "Missing `;'");
+            //diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Warning, yylloc, msg));
+
+            first_token = &token_buffer[0];
+            last_token = &token_buffer[1];
+
+            yytoken = T_SEMICOLON;
+            yylval = 0;
+
+            action = errorState;
+
+            goto _Lcheck_token;
+        }
+
+        hadErrors = true;
+
+        token_buffer[0].token = yytoken;
+        token_buffer[0].dval = yylval;
+        token_buffer[0].loc = yylloc;
+
+        token_buffer[1].token = yytoken = lexer->lex();
+        token_buffer[1].dval  = yylval  = lexer->dval();
+        token_buffer[1].loc   = yylloc  = location(lexer);
+
+        if (t_action(errorState, yytoken)) {
+            QString msg;
+            int token = token_buffer[0].token;
+            if (token < 0 || token >= TERMINAL_COUNT)
+                msg = qApp->translate("QDeclarativeParser", "Syntax error");
+            else
+                msg = qApp->translate("QDeclarativeParser", "Unexpected token `%1'").arg(QLatin1String(spell[token]));
+            diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));
+
+            action = errorState;
+            goto _Lcheck_token;
+        }
+
+        static int tokens[] = {
+            T_PLUS,
+            T_EQ,
+
+            T_COMMA,
+            T_COLON,
+            T_SEMICOLON,
+
+            T_RPAREN, T_RBRACKET, T_RBRACE,
+
+            T_NUMERIC_LITERAL,
+            T_IDENTIFIER,
+
+            T_LPAREN, T_LBRACKET, T_LBRACE,
+
+            EOF_SYMBOL
+        };
+
+        for (int *tk = tokens; *tk != EOF_SYMBOL; ++tk) {
+            int a = t_action(errorState, *tk);
+            if (a > 0 && t_action(a, yytoken)) {
+                const QString msg = qApp->translate("QDeclarativeParser", "Expected token `%1'").arg(QLatin1String(spell[*tk]));
+                diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));
+
+                yytoken = *tk;
+                yylval = 0;
+                yylloc = token_buffer[0].loc;
+                yylloc.length = 0;
+
+                first_token = &token_buffer[0];
+                last_token = &token_buffer[2];
+
+                action = errorState;
+                goto _Lcheck_token;
+            }
+        }
+
+        for (int tk = 1; tk < TERMINAL_COUNT; ++tk) {
+            if (tk == T_AUTOMATIC_SEMICOLON || tk == T_FEED_UI_PROGRAM    ||
+                tk == T_FEED_JS_STATEMENT   || tk == T_FEED_JS_EXPRESSION ||
+                tk == T_FEED_JS_SOURCE_ELEMENT)
+               continue;
+
+            int a = t_action(errorState, tk);
+            if (a > 0 && t_action(a, yytoken)) {
+                const QString msg = qApp->translate("QDeclarativeParser", "Expected token `%1'").arg(QLatin1String(spell[tk]));
+                diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));
+
+                yytoken = tk;
+                yylval = 0;
+                yylloc = token_buffer[0].loc;
+                yylloc.length = 0;
+
+                action = errorState;
+                goto _Lcheck_token;
+            }
+        }
+
+        const QString msg = qApp->translate("QDeclarativeParser", "Syntax error");
+        diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));
+    }
+
+    return false;
+}
+
+QT_QML_END_NAMESPACE
+
+
diff --git a/tools/qdoc3/declarativeparser/qdeclarativejsparser_p.h b/tools/qdoc3/declarativeparser/qdeclarativejsparser_p.h
new file mode 100644
index 0000000..ad46bff
--- /dev/null
+++ b/tools/qdoc3/declarativeparser/qdeclarativejsparser_p.h
@@ -0,0 +1,246 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDeclarative module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+//
+// This file is automatically generated from qmljs.g.
+// Changes will be lost.
+//
+
+#ifndef QDECLARATIVEJSPARSER_P_H
+#define QDECLARATIVEJSPARSER_P_H
+
+#include "private/qdeclarativejsglobal_p.h"
+#include "private/qdeclarativejsgrammar_p.h"
+#include "private/qdeclarativejsast_p.h"
+#include "private/qdeclarativejsengine_p.h"
+
+#include <QtCore/QList>
+#include <QtCore/QString>
+
+QT_QML_BEGIN_NAMESPACE
+
+namespace QDeclarativeJS {
+
+class Engine;
+class NameId;
+
+class QML_PARSER_EXPORT Parser: protected QDeclarativeJSGrammar
+{
+public:
+    union Value {
+      int ival;
+      double dval;
+      NameId *sval;
+      AST::ArgumentList *ArgumentList;
+      AST::CaseBlock *CaseBlock;
+      AST::CaseClause *CaseClause;
+      AST::CaseClauses *CaseClauses;
+      AST::Catch *Catch;
+      AST::DefaultClause *DefaultClause;
+      AST::ElementList *ElementList;
+      AST::Elision *Elision;
+      AST::ExpressionNode *Expression;
+      AST::Finally *Finally;
+      AST::FormalParameterList *FormalParameterList;
+      AST::FunctionBody *FunctionBody;
+      AST::FunctionDeclaration *FunctionDeclaration;
+      AST::Node *Node;
+      AST::PropertyName *PropertyName;
+      AST::PropertyNameAndValueList *PropertyNameAndValueList;
+      AST::SourceElement *SourceElement;
+      AST::SourceElements *SourceElements;
+      AST::Statement *Statement;
+      AST::StatementList *StatementList;
+      AST::Block *Block;
+      AST::VariableDeclaration *VariableDeclaration;
+      AST::VariableDeclarationList *VariableDeclarationList;
+
+      AST::UiProgram *UiProgram;
+      AST::UiImportList *UiImportList;
+      AST::UiImport *UiImport;
+      AST::UiParameterList *UiParameterList;
+      AST::UiPublicMember *UiPublicMember;
+      AST::UiObjectDefinition *UiObjectDefinition;
+      AST::UiObjectInitializer *UiObjectInitializer;
+      AST::UiObjectBinding *UiObjectBinding;
+      AST::UiScriptBinding *UiScriptBinding;
+      AST::UiArrayBinding *UiArrayBinding;
+      AST::UiObjectMember *UiObjectMember;
+      AST::UiObjectMemberList *UiObjectMemberList;
+      AST::UiArrayMemberList *UiArrayMemberList;
+      AST::UiQualifiedId *UiQualifiedId;
+      AST::UiSignature *UiSignature;
+      AST::UiFormalList *UiFormalList;
+      AST::UiFormal *UiFormal;
+    };
+
+public:
+    Parser(Engine *engine);
+    ~Parser();
+
+    // parse a UI program
+    bool parse() { return parse(T_FEED_UI_PROGRAM); }
+    bool parseStatement() { return parse(T_FEED_JS_STATEMENT); }
+    bool parseExpression() { return parse(T_FEED_JS_EXPRESSION); }
+    bool parseSourceElement() { return parse(T_FEED_JS_SOURCE_ELEMENT); }
+    bool parseUiObjectMember() { return parse(T_FEED_UI_OBJECT_MEMBER); }
+    bool parseProgram() { return parse(T_FEED_JS_PROGRAM); }
+
+    AST::UiProgram *ast() const
+    { return AST::cast<AST::UiProgram *>(program); }
+
+    AST::Statement *statement() const
+    {
+        if (! program)
+            return 0;
+
+        return program->statementCast();
+    }
+
+    AST::ExpressionNode *expression() const
+    {
+        if (! program)
+            return 0;
+
+        return program->expressionCast();
+    }
+
+    AST::UiObjectMember *uiObjectMember() const
+    {
+        if (! program)
+            return 0;
+
+        return program->uiObjectMemberCast();
+    }
+
+    AST::Node *rootNode() const
+    { return program; }
+
+    QList<DiagnosticMessage> diagnosticMessages() const
+    { return diagnostic_messages; }
+
+    inline DiagnosticMessage diagnosticMessage() const
+    {
+        foreach (const DiagnosticMessage &d, diagnostic_messages) {
+            if (! d.kind == DiagnosticMessage::Warning)
+                return d;
+        }
+
+        return DiagnosticMessage();
+    }
+
+    inline QString errorMessage() const
+    { return diagnosticMessage().message; }
+
+    inline int errorLineNumber() const
+    { return diagnosticMessage().loc.startLine; }
+
+    inline int errorColumnNumber() const
+    { return diagnosticMessage().loc.startColumn; }
+
+protected:
+    bool parse(int startToken);
+
+    void reallocateStack();
+
+    inline Value &sym(int index)
+    { return sym_stack [tos + index - 1]; }
+
+    inline AST::SourceLocation &loc(int index)
+    { return location_stack [tos + index - 1]; }
+
+    AST::UiQualifiedId *reparseAsQualifiedId(AST::ExpressionNode *expr);
+
+protected:
+    Engine *driver;
+    int tos;
+    int stack_size;
+    Value *sym_stack;
+    int *state_stack;
+    AST::SourceLocation *location_stack;
+
+    AST::Node *program;
+
+    // error recovery
+    enum { TOKEN_BUFFER_SIZE = 3 };
+
+    struct SavedToken {
+       int token;
+       double dval;
+       AST::SourceLocation loc;
+    };
+
+    double yylval;
+    AST::SourceLocation yylloc;
+    AST::SourceLocation yyprevlloc;
+
+    SavedToken token_buffer[TOKEN_BUFFER_SIZE];
+    SavedToken *first_token;
+    SavedToken *last_token;
+
+    QList<DiagnosticMessage> diagnostic_messages;
+};
+
+} // end of namespace QDeclarativeJS
+
+
+
+#define J_SCRIPT_REGEXPLITERAL_RULE1 78
+
+#define J_SCRIPT_REGEXPLITERAL_RULE2 79
+
+QT_QML_END_NAMESPACE
+
+
+
+#endif // QDECLARATIVEJSPARSER_P_H
diff --git a/tools/qdoc3/ditaxmlgenerator.cpp b/tools/qdoc3/ditaxmlgenerator.cpp
index 5d3e34a..4b4f776 100644
--- a/tools/qdoc3/ditaxmlgenerator.cpp
+++ b/tools/qdoc3/ditaxmlgenerator.cpp
@@ -482,6 +482,7 @@ void DitaXmlGenerator::initializeGenerator(const Config &config)
     if (naturalLanguage.isEmpty())
         naturalLanguage = QLatin1String("en");
 
+    config.subVarsAndValues("dita.metadata.default",metadataDefaults);
     QSet<QString> editionNames = config.subVars(CONFIG_EDITION);
     QSet<QString>::ConstIterator edition = editionNames.begin();
     while (edition != editionNames.end()) {
@@ -1193,7 +1194,8 @@ int DitaXmlGenerator::generateAtom(const Atom *atom,
                 fileName = QLatin1String("images/") + protectEnc(atom->string());
             }
 
-            writeStartTag(DT_fig);
+            if (currentTag() != DT_xref)
+                writeStartTag(DT_fig);
             writeStartTag(DT_image);
             xmlWriter().writeAttribute("href",protectEnc(fileName));
             if (atom->type() == Atom::InlineImage)
@@ -1208,7 +1210,8 @@ int DitaXmlGenerator::generateAtom(const Atom *atom,
                 writeEndTag(); // </alt>
             }
             writeEndTag(); // </image>
-            writeEndTag(); // </fig>
+            if (currentTag() != DT_xref)
+                writeEndTag(); // </fig>
         }
         break;
     case Atom::ImageText:
@@ -5551,21 +5554,94 @@ void DitaXmlGenerator::writeDitaMap()
 }
 
 /*!
+  Looks up the tag name for \a t in the map of metadata
+  values for the current topic in \a inner. If a value
+  for the tag is found, the element is written with the
+  found value. Otherwise if \a force is set, an empty
+  element is written using the tag.
+
+  Returns true or false depending on whether it writes
+  an element using the tag \a t.
+
+  \note If \a t is found in the metadata map, it is erased.
+  i.e. Once you call this function for a particular \a t,
+  you consume \a t.
+
+  At the moment, it doesn't chaeck to see if there is a
+  default value for the tag. But it will eventually.
+ */
+bool DitaXmlGenerator::writeMetadataElement(const InnerNode* inner,
+                                            DitaXmlGenerator::DitaTag t,
+                                            bool force)
+{
+    QString s;
+    QStringMap& metaTagMap = const_cast<QStringMap&>(inner->doc().metaTagMap());
+    QStringMap::iterator i = metaTagMap.find(ditaTags[t]);
+    if (i == metaTagMap.end()) {
+        s = metadataDefault(t);
+    }
+    else {
+        s = i.value();
+        metaTagMap.erase(i);
+    }
+    if (s.isEmpty() && !force)
+        return false;
+    writeStartTag(t);
+    if (!s.isEmpty())
+        xmlWriter().writeCharacters(s);
+    writeEndTag();
+    return true;
+}
+
+/*!
+  Looks up the tag name for \a t in the map of metadata
+  values for the current topic in \a inner. If a value
+  for the tag is found, the value is returned.
+
+  \note If \a t is found in the metadata map, it is erased.
+  i.e. Once you call this function for a particular \a t,
+  you consume \a t.
+ */
+QString DitaXmlGenerator::getMetadataElement(const InnerNode* inner, DitaXmlGenerator::DitaTag t)
+{
+    QString s;
+    QStringMap& metaTagMap = const_cast<QStringMap&>(inner->doc().metaTagMap());
+    QStringMap::iterator i = metaTagMap.find(ditaTags[t]);
+    if (i != metaTagMap.end()) {
+        s = i.value();
+        metaTagMap.erase(i);
+    }
+    else {
+        s = metadataDefault(t);
+    }
+    return s;
+}
+
+/*!
+  Returns the value of key \a t or an empty string
+  if \a t is not found in the map.
+ */
+QString DitaXmlGenerator::metadataDefault(DitaTag t) const
+{
+    return metadataDefaults.value(ditaTags[t]);
+}
+
+/*!
   Writes the <prolog> element for the \a inner node
   using the \a marker. The <prolog> element contains
   the <metadata> element, plus some others. This
   function writes one or more of these elements:
 
   \list
-    \o <audience>
+    \o <audience> *
     \o <author> *
     \o <brand>
     \o <category> *
     \o <compomnent> *
-    \o <copyrholder>
-    \o <copyright>
+    \o <copyrholder> *
+    \o <copyright> *
     \o <created>
-    \o <copyryear>
+    \o <copyryear> *
     \o <critdates>
     \o <keyword>
     \o <keywords>
@@ -5595,64 +5671,70 @@ DitaXmlGenerator::writeProlog(const InnerNode* inner, CodeMarker* marker)
     if (!inner)
         return;
     writeStartTag(DT_prolog);
-    
-    QString author = inner->author();
-    writeStartTag(DT_author);
-    if (author.isEmpty())
-        author = "Qt Development Frameworks";
-    xmlWriter().writeCharacters(author);
-    writeEndTag(); // <author>
-
-    QString publisher = inner->publisher();
-    writeStartTag(DT_publisher);
-    if (publisher.isEmpty())
-        publisher = "Nokia";
-    xmlWriter().writeCharacters(publisher);
-    writeEndTag(); // <publisher>
-
-    QString permissions = inner->permissions();
+    writeMetadataElement(inner,DT_author);
+    writeMetadataElement(inner,DT_publisher);
+    QString s = getMetadataElement(inner,DT_copyryear);
+    QString t = getMetadataElement(inner,DT_copyrholder);
+    writeStartTag(DT_copyright);
+    writeStartTag(DT_copyryear);
+    if (!s.isEmpty())
+        xmlWriter().writeAttribute("year",s);
+    writeEndTag(); // </copyryear>
+    writeStartTag(DT_copyrholder);
+    if (!s.isEmpty())
+        xmlWriter().writeCharacters(t);
+    writeEndTag(); // </copyrholder>
+    writeEndTag(); // </copyright>
+    s = getMetadataElement(inner,DT_permissions);
     writeStartTag(DT_permissions);
-    if (permissions.isEmpty())
-        permissions = "all";
-    xmlWriter().writeAttribute("view",permissions);
-    writeEndTag(); // <permissions>
-
+    xmlWriter().writeAttribute("view",s);
+    writeEndTag(); // </permissions>
     writeStartTag(DT_metadata);
-    writeStartTag(DT_category);
-    QString category = "Page";
-    if (inner->type() == Node::Class)
-        category = "C++ Class";
-    else if (inner->type() == Node::Namespace)
-        category = "C++ Namespace";
-    else if (inner->type() == Node::Fake) {
-        if (inner->subType() == Node::QmlBasicType)
-            category = "QML Class";
-        else if (inner->subType() == Node::QmlClass)
-            category = "QML Basic Type";
-        else if (inner->subType() == Node::HeaderFile)
-            category = "Header File";
-        else if (inner->subType() == Node::Module)
-            category = "Module";
-        else if (inner->subType() == Node::File)
-            category = "Example Source File";
-        else if (inner->subType() == Node::Example)
-            category = "Example";
-        else if (inner->subType() == Node::Image)
-            category = "Image";
-        else if (inner->subType() == Node::Group)
-            category = "Group";
-        else if (inner->subType() == Node::Page)
-            category = "Page";
-        else if (inner->subType() == Node::ExternalPage)
-            category = "External Page"; // Is this necessary?
+    s = getMetadataElement(inner,DT_audience);
+    if (!s.isEmpty()) {
+        writeStartTag(DT_audience);
+        xmlWriter().writeAttribute("type",s);
+        writeEndTag(); // </audience>
+    }
+    if (!writeMetadataElement(inner,DT_category,false)) {
+        writeStartTag(DT_category);
+        QString category = "Page";
+        if (inner->type() == Node::Class)
+            category = "Class reference";
+        else if (inner->type() == Node::Namespace)
+            category = "Namespace";
+        else if (inner->type() == Node::Fake) {
+            if (inner->subType() == Node::QmlClass)
+                category = "QML Element Reference";
+            else if (inner->subType() == Node::QmlBasicType)
+                category = "QML Basic Type";
+            else if (inner->subType() == Node::HeaderFile)
+                category = "Header File";
+            else if (inner->subType() == Node::Module)
+                category = "Module";
+            else if (inner->subType() == Node::File)
+                category = "Example Source File";
+            else if (inner->subType() == Node::Example)
+                category = "Example";
+            else if (inner->subType() == Node::Image)
+                category = "Image";
+            else if (inner->subType() == Node::Group)
+                category = "Group";
+            else if (inner->subType() == Node::Page)
+                category = "Page";
+            else if (inner->subType() == Node::ExternalPage)
+                category = "External Page"; // Is this necessary?
+        }
+        xmlWriter().writeCharacters(category);
+        writeEndTag(); // </category>
     }
-    xmlWriter().writeCharacters(category);
-    writeEndTag(); // <category>
     if (vrm.size() > 0) {
         writeStartTag(DT_prodinfo);
-        writeStartTag(DT_prodname);
-        xmlWriter().writeCharacters(projectDescription);
-        writeEndTag(); // <prodname>
+        if (!writeMetadataElement(inner,DT_prodname,false)) {
+            writeStartTag(DT_prodname);
+            xmlWriter().writeCharacters(projectDescription);
+            writeEndTag(); // </prodname>
+        }
         writeStartTag(DT_vrmlist);
         writeStartTag(DT_vrm);
         if (vrm.size() > 0)
@@ -5663,26 +5745,27 @@ DitaXmlGenerator::writeProlog(const InnerNode* inner, CodeMarker* marker)
             xmlWriter().writeAttribute("modification",vrm[2]);
         writeEndTag(); // <vrm>
         writeEndTag(); // <vrmlist>
-        QString component = inner->moduleName();
-        if (!component.isEmpty()) {
-            writeStartTag(DT_component);
-            xmlWriter().writeCharacters(component);
-            writeEndTag(); // <component>
-        }
-        writeEndTag(); // <prodinfo>
-        if (inner->hasOtherMetadata()) {
-            const QMap<QString, QString>& omd = inner->otherMetadata();
-            QMapIterator<QString, QString> i(omd);
-            while (i.hasNext()) {
-                i.next();
-                writeStartTag(DT_othermeta);
-                xmlWriter().writeAttribute("name",i.key());
-                xmlWriter().writeAttribute("content",i.value());
+        if (!writeMetadataElement(inner,DT_component,false)) {
+            QString component = inner->moduleName();
+            if (!component.isEmpty()) {
+                writeStartTag(DT_component);
+                xmlWriter().writeCharacters(component);
+                writeEndTag(); // </component>
             }
         }
+        writeEndTag(); // </prodinfo>
+    }
+    const QStringMap& metaTagMap = inner->doc().metaTagMap(); 
+    QMapIterator<QString, QString> i(metaTagMap);
+    while (i.hasNext()) {
+        i.next();
+        writeStartTag(DT_othermeta);
+        xmlWriter().writeAttribute("name",i.key());
+        xmlWriter().writeAttribute("content",i.value());
+        writeEndTag(); // </othermeta>
     }
-    writeEndTag(); // <metadata>
-    writeEndTag(); // <prolog>
+    writeEndTag(); // </metadata>
+    writeEndTag(); // </prolog>
 }
 
 QT_END_NAMESPACE
diff --git a/tools/qdoc3/ditaxmlgenerator.h b/tools/qdoc3/ditaxmlgenerator.h
index 7793db0..c7400bb 100644
--- a/tools/qdoc3/ditaxmlgenerator.h
+++ b/tools/qdoc3/ditaxmlgenerator.h
@@ -316,6 +316,10 @@ class DitaXmlGenerator : public PageGenerator
     void writeRelatedLinks(const FakeNode* fake, CodeMarker* marker);
     void writeLink(const Node* node, const QString& tex, const QString& role);
     void writeProlog(const InnerNode* inner, CodeMarker* marker);
+    bool writeMetadataElement(const InnerNode* inner, 
+                              DitaXmlGenerator::DitaTag t, 
+                              bool force=true);
+    QString getMetadataElement(const InnerNode* inner, DitaXmlGenerator::DitaTag t);
 
  private:
     enum SubTitleSize { SmallSubTitle, LargeSubTitle };
@@ -443,7 +447,7 @@ class DitaXmlGenerator : public PageGenerator
     int leaveSection();
     bool inSection() const { return (sectionNestingLevel > 0); }
     int currentSectionNestingLevel() const { return sectionNestingLevel; }
-    
+    QString metadataDefault(DitaTag t) const;
 
  private:
     /*
@@ -512,6 +516,7 @@ class DitaXmlGenerator : public PageGenerator
     static QString ditaTags[];
     QStack<QXmlStreamWriter*> xmlWriterStack;
     QStack<DitaTag> tagStack;
+    QStringMap metadataDefaults;
 };
 
 #define DITAXMLGENERATOR_ADDRESS           "address"
diff --git a/tools/qdoc3/doc.cpp b/tools/qdoc3/doc.cpp
index 5f563be..945b765 100644
--- a/tools/qdoc3/doc.cpp
+++ b/tools/qdoc3/doc.cpp
@@ -877,7 +877,7 @@ void DocParser::parse(const QString& source,
                     case CMD_META:
                         priv->constructExtra();
                         p1 = getArgument();
-                        priv->extra->metaMap.insert(p1, getRestOfLine());
+                        priv->extra->metaMap.insert(p1, getArgument());
                         break;
                     case CMD_NEWCODE:
                         location().warning(tr("Unexpected '\\%1'").arg(cmdName(CMD_NEWCODE)));
diff --git a/tools/qdoc3/doc/qdoc-manual.qdoc b/tools/qdoc3/doc/qdoc-manual.qdoc
index 712dcea..49dd819 100644
--- a/tools/qdoc3/doc/qdoc-manual.qdoc
+++ b/tools/qdoc3/doc/qdoc-manual.qdoc
@@ -58,7 +58,7 @@
         \endlist
       \o \l {The QDoc Configuration File}
         \list
-          \o \l {General Configuration Variables}
+          \o \l {Generic Configuration Variables}
           \o \l {Creating Help Project Files}
           \o \l {C++ Specific Configuration Variables}
           \o \l {HTML Specific Configuration Variables}
@@ -79,12 +79,13 @@
 
     \title Introduction to QDoc
 
-    QDoc is a tool used by Qt Developers to generate documentation of
-    software projects by extracting the documentation from the project
-    source files and then formatting it as HTML pages or DITA XML
-    documents, etc. The documentation is embedded in the source files
-    in \e {qdoc comments}. A qdoc comment begins with an exclamation
-    mark \bold{(!)} e.g.:
+    QDoc is a tool used by Qt Developers to generate documentation for
+    software projects. It works by extracting \e {qdoc comments} from
+    project source files and then formatting these comments as HTML
+    pages or DITA XML documents, etc. QDoc finds qdoc comments in \c
+    {.cpp} files and in \c {.qdoc} files. QDoc does not look for qdoc
+    comments in \c {.h} files. A qdoc comment always begins with an
+    exclamation mark \bold{!} e.g.:
 
     \code 
         / *! 
@@ -124,13 +125,14 @@
 	* /
     \endcode
 
-    From this snippet, QDoc generates the now famous HTML page \l
-    {http://doc.trolltech.com/4.7/qobject.html#details} {QObject Class Reference}.
+    From the qdoc comment above, QDoc generates the now famous HTML
+    page \l {http://doc.trolltech.com/4.7/qobject.html#details}
+    {QObject Class Reference}.
     
-    This manual explains how to use the QDoc commands to write useful
-    qdoc comments in your source files. It also explains how to create
-    a \l {The QDoc Configuration File} {QDoc configuration file},
-    which you must pass to QDoc on the command line when you run it.
+    This manual explains how to use the QDoc commands in qdoc comments
+    to embed good documentation in your source files. It also explains
+    how to make a \l {The QDoc Configuration File} {QDoc configuration
+    file}, which you will pass to QDoc on the command line.
 
     \section1 Running QDoc
 
@@ -138,17 +140,64 @@
     from the command line, give it the name of a configuration file:
 
     \quotation
-        \c {/current/dir$ ../../bin/qdoc3 ./config.qdocconf}
+        \c {$ ../../bin/qdoc3 ./config.qdocconf}
     \endquotation
 
-    \c{config.qdocconf} is your \l{The QDoc Configuration File} {QDoc
-    configuration file}. The configuration file is where tell QDoc
-    where to find the source files from which it will extract the QDoc
-    comments it will use to generate the documentation. It is also
-    where you tell QDoc what kind of output to generate (HTML, DITA
-    XML,...), and where to put the generated output. The configuration
+    QDoc recognizes the \c {.qdocconf} suffix as a \l{The QDoc
+    Configuration File} {QDoc configuration file}. The configuration
+    file is where you tell QDoc where to find the project source
+    files, header files, and \c {.qdoc} files. It is also where you
+    tell QDoc what kind of output to generate (HTML, DITA XML,...),
+    and where to put the generated documentation. The configuration
     file also contains other information for QDoc.
 
+    See \l{The QDoc Configuration File} for a instructions on how to
+    build a Qdoc configuration file.
+
+    \section1 How QDoc Works
+
+    QDoc begins by reading the configuarion file you specified on the
+    command line. It stores all the variables from the configuration
+    file for later use. One of the first variables it uses is \c
+    {outputformats}. This variable tells QDoc which output generators
+    it will run. The default value is \e {HTML}, so if you don't set
+    \c {outputformats} in your configuration file, QDoc will generate
+    HTML output. That's usually what you will want anyway, but you can
+    also specify \e {DITAXML} to get DITA XML output instead.
+
+    Next, QDoc uses the values of the \l
+    {22-qdoc-configuration-generalvariables.html#headerdirs-variable}
+    {headerdirs} variable and/or the \l
+    {22-qdoc-configuration-generalvariables.html#headers-variable}
+    {headers} variable to find and parse all the header files for your
+    project. QDoc does \e not scan header files for qdoc comments. It
+    parses the header files to build a master tree of all the items
+    that should be documented (i.e. the items that QDoc should find 
+    qdoc comments for).
+
+    After parsing all the header files and building the master tree of
+    items to be documented, QDoc uses the value of the \l
+    {22-qdoc-configuration-generalvariables.html#sourcedirs-variable}
+    {sourcedirs} variable and/or the value of the \l
+    {22-qdoc-configuration-generalvariables.html#sources-variable}
+    {sources} variable to find and parse all the \c {.cpp} and \c
+    {.qdoc} files for your project. These are the files QDoc scans for
+    \e {qdoc comments}. Remember that a qdoc comment begins with 
+    an exclamation mark, i.e. \bold {/*!} .
+
+    For each qdoc comment it finds, it searches the master tree for
+    the item where the documentation belongs. The it interprets the
+    qdoc commands in the comment and stores the interpreted commands
+    and the comment text in the tree node for the item. 
+
+    Finally, QDoc traverses the master tree. For each node, if the
+    node has stored documentation, QDoc calls the output generator
+    specified by the \c {outputformats} variable to format and write
+    the documentation in the directory specified in the configuration
+    file in the \l
+    {22-qdoc-configuration-generalvariables.html#outputdir-variable}
+    {outputdir} variable.
+
     \section1 Command Types
 
     QDoc interprets three types of commands: 
@@ -6736,63 +6785,45 @@
     \page 21-0-qdoc-configuration.html
     \previouspage Miscellaneous
     \contentspage Table of Contents
-    \nextpage General Configuration Variables
+    \nextpage Generic Configuration Variables
 
     \title The QDoc Configuration File
 
-    Before running QDoc to to extract and format your QDOC comments,
-    you must create a QDoc configuration file to tell QDoc where to find 
-    them.
-
-    \list
-    \o \l {Supporting Derived Projects}
-    \o \l {Compatibility Issues}
-    \endlist
+    Before running QDoc, you must create a QDoc configuration file to
+    tell QDoc where to find the source files that contain the QDoc
+    comments. The pathname to your configuration file is passed to
+    QDoc on the command line:
 
-    When running QDoc to generate the documentation, you must specify
-    a configuration file on the command line:
+    \quotation
+        \c {/current/dir$ ../../bin/qdoc3 ./config.qdocconf}
+    \endquotation
 
     \section1 General Description
 
-    The configuration file is a list of entries of entries of the form
-    \e {"variable = value"}. Using the configuration variables, you
-    can define where QDoc should find the various source files, images
-    and examples, where to put generated documentation etc. The
+    The configuration file is a list of entries of the form \e
+    {"variable = value"}. Using the configuration variables, you can
+    define where QDoc should find the various source files, images and
+    examples, where to put generated documentation etc. The
     configuration file can also contain directives like \c
     include. For an example, see the \l minimum.qdocconf file.
 
-    In addition, you can use some particular configuration variables
-    to make QDoc support derived projects, i.e make the projects, for
-    example Qt Solutions, contain links to the online Qt
-    documentation. These variables are documented in the \l
-    {Supporting Derived projects} section. In this section you can
-    also find out how to use these variables to support your derived
-    projects.
-
-    If some of the variable keys have the same values, they can be set
-    at the same time.
-
-    \code
-    {header, source}dirs = kernel
-    \endcode
-
-    is equivalent to
-
-    \code
-    headerdirs = kernel
-    sourcedirs = kernel
-    \endcode
+    You can also use configuration variables to get QDoc to support
+    \l{Supporting Derived Projects} {derived projects}, i.e QDoc can
+    generate links in your project's documentation to elements in the
+    Qt online documentation. See the \l {Supporting Derived projects}
+    section. 
 
-    A variable's value can be set using either '=' or '+='. The
-    difference is that '=' overrides any previously set value, while
-    '+=' only adds the value to the previously set ones.
+    The value of a configuration variable can be set using either '='
+    or '+='. The difference is that '=' overrides the previous value,
+    while '+=' adds a new value to the current one.
 
-    In general, some of the variables accepts a list of strings as
-    their value, while others only accept a single string. If you
-    provide a variable of the latter type with several strings they
-    will simply be concatenated. The quotes around the value string
-    are optional. But applying them allows you to use special
-    characters like '=' and ' \" ' within the string.
+    Some configuration variables accept a list of strings as their
+    value, e.g. 
+    \l {22-qdoc-configuration-generalvariables.html#sourcedirs-variable}
+    {\c{sourcedirs}}, while others accept only a single string. Double
+    quotes around a value string are optional, but including them allows 
+    you to use special characters like '=' and ' \" ' within the valuem
+    string, e.g.:
 
     \code
     HTML.postheader = "<a href=\"index.html\">Home</a>"
@@ -6848,7 +6879,7 @@
     \section1 Categories
 
     \list
-    \o \l {General Configuration Variables}
+    \o \l {Generic Configuration Variables}
     \o \l {C++ Specific Configuration Variables}
     \o \l {HTML Specific Configuration Variables}
     \endlist
@@ -6889,7 +6920,7 @@
     \contentspage Table of Contents
     \nextpage Creating Help Project Files
 
-    \title General Configuration Variables
+    \title Generic Configuration Variables
 
     With the general QDoc configuration variables, you can define
     where QDoc will find the various source files it needs to generate
@@ -7766,7 +7797,7 @@
 
 /*!
     \page 22-creating-help-project-files.html
-    \previouspage General Configuration Variables
+    \previouspage Generic Configuration Variables
     \contentspage Table of Contents
     \nextpage C++ Specific Configuration Variables
 
diff --git a/tools/qdoc3/htmlgenerator.cpp b/tools/qdoc3/htmlgenerator.cpp
index 2019e85..d1d1561 100644
--- a/tools/qdoc3/htmlgenerator.cpp
+++ b/tools/qdoc3/htmlgenerator.cpp
@@ -1595,75 +1595,111 @@ QString HtmlGenerator::fileExtension(const Node * /* node */) const
 /*!
   Output breadcrumb list in the html file.
  */
-void HtmlGenerator::generateBreadCrumbs(const QString& title,
+void HtmlGenerator::generateBreadCrumbs(const QString &title,
                                         const Node *node,
                                         CodeMarker *marker)
 {
-    Text breadcrumb;
+    Text breadcrumbs;
+
     if (node->type() == Node::Class) {
-        const ClassNode* cn = static_cast<const ClassNode*>(node);
+        const ClassNode *cn = static_cast<const ClassNode *>(node);
         QString name =  node->moduleName();
-        out() << "              <li><a href=\"modules.html\">Modules</a></li>";
-        if (!name.isEmpty()) {
-            out() << "              <li>";
-            breadcrumb << Atom(Atom::AutoLink,name);
-            generateText(breadcrumb, node, marker);
-            out() << "</li>\n";
-        }
+        breadcrumbs << Atom(Atom::ListItemLeft)
+                    << Atom(Atom::AutoLink, QLatin1String("Modules"))
+                    << Atom(Atom::ListItemRight);
+        if (!name.isEmpty())
+            breadcrumbs << Atom(Atom::ListItemLeft)
+                        << Atom(Atom::AutoLink, name)
+                        << Atom(Atom::ListItemRight);
         if (!cn->name().isEmpty())
-            out() << "              <li>" << protectEnc(cn->name()) << "</li>\n";
+            breadcrumbs << Atom(Atom::ListItemLeft)
+                        << Atom(Atom::String, protectEnc(cn->name()))
+                        << Atom(Atom::ListItemRight);
     }
     else if (node->type() == Node::Fake) {
         const FakeNode* fn = static_cast<const FakeNode*>(node);
         if (node->subType() == Node::Module) {
-            out() << "              <li><a href=\"modules.html\">Modules</a></li>";
+            breadcrumbs << Atom(Atom::ListItemLeft)
+                        << Atom(Atom::AutoLink, QLatin1String("Modules"))
+                        << Atom(Atom::ListItemRight);
             QString name =  node->name();
             if (!name.isEmpty())
-                out() << "              <li>" << protectEnc(name) << "</li>\n";
+                breadcrumbs << Atom(Atom::ListItemLeft)
+                            << Atom(Atom::String, protectEnc(name))
+                            << Atom(Atom::ListItemRight);
         }
         else if (node->subType() == Node::Group) {
             if (fn->name() == QString("modules"))
-                out() << "              <li>Modules</li>";
-            else {
-                out() << "              <li>" << protectEnc(title) << "</li>";
-            }
+                breadcrumbs << Atom(Atom::ListItemLeft)
+                            << Atom(Atom::AutoLink, QLatin1String("Modules"))
+                            << Atom(Atom::ListItemRight);
+            else
+                breadcrumbs << Atom(Atom::ListItemLeft)
+                            << Atom(Atom::String, protectEnc(title))
+                            << Atom(Atom::ListItemRight);
         }
         else if (node->subType() == Node::Page) {
             if (fn->name() == QString("qdeclarativeexamples.html")) {
-                out() << "              <li><a href=\"all-examples.html\">Examples</a></li>";
-                out() << "              <li>QML Examples &amp; Demos</li>";
+                breadcrumbs << Atom(Atom::ListItemLeft)
+                            << Atom(Atom::AutoLink, QLatin1String("Examples"))
+                            << Atom(Atom::ListItemRight);
+                breadcrumbs << Atom(Atom::ListItemLeft)
+                            << Atom(Atom::AutoLink, QLatin1String("QML Examples & Demos"))
+                            << Atom(Atom::ListItemRight);
             }
             else if (fn->name().startsWith("examples-")) {
-                out() << "              <li><a href=\"all-examples.html\">Examples</a></li>";
-                out() << "              <li>" << protectEnc(title) << "</li>";
-            }
-            else if (fn->name() == QString("namespaces.html")) {
-                out() << "              <li>Namespaces</li>";
-            }
-            else {
-                out() << "              <li>" << protectEnc(title) << "</li>";
+                breadcrumbs << Atom(Atom::ListItemLeft)
+                            << Atom(Atom::AutoLink, QLatin1String("Examples"))
+                            << Atom(Atom::ListItemRight);
+                breadcrumbs << Atom(Atom::ListItemLeft)
+                            << Atom(Atom::String, protectEnc(title))
+                            << Atom(Atom::ListItemRight);
             }
+            else if (fn->name() == QString("namespaces.html"))
+                breadcrumbs << Atom(Atom::ListItemLeft)
+                            << Atom(Atom::AutoLink, QLatin1String("Namespaces"))
+                            << Atom(Atom::ListItemRight);
+            else
+                breadcrumbs << Atom(Atom::ListItemLeft)
+                            << Atom(Atom::String, protectEnc(title))
+                            << Atom(Atom::ListItemRight);
         }
         else if (node->subType() == Node::QmlClass) {
-            out() << "              <li><a href=\"qdeclarativeelements.html\">QML Elements</a></li>";
-            out() << "              <li>" << protectEnc(title) << "</li>";
+                breadcrumbs << Atom(Atom::ListItemLeft)
+                            << Atom(Atom::AutoLink, QLatin1String("QML Elements"))
+                            << Atom(Atom::ListItemRight);
+                breadcrumbs << Atom(Atom::ListItemLeft)
+                            << Atom(Atom::String, protectEnc(title))
+                            << Atom(Atom::ListItemRight);
         }
         else if (node->subType() == Node::Example) {
-            out() << "              <li><a href=\"all-examples.html\">Examples</a></li>";
+            breadcrumbs << Atom(Atom::ListItemLeft)
+                        << Atom(Atom::AutoLink, QLatin1String("Examples"))
+                        << Atom(Atom::ListItemRight);
             QStringList sl = fn->name().split('/');
             if (sl.contains("declarative"))
-                out() << "              <li><a href=\"qdeclarativeexamples.html\">QML Examples &amp; Demos</a></li>";
+                breadcrumbs << Atom(Atom::ListItemLeft)
+                            << Atom(Atom::AutoLink, QLatin1String("QML Examples & Demos"))
+                            << Atom(Atom::ListItemRight);
             else {
                 QString name = protectEnc("examples-" + sl.at(0) + ".html"); // this generates an empty link
                 QString t = CodeParser::titleFromName(name);
             }
-            out() << "              <li>" << protectEnc(title) << "</li>";
+            breadcrumbs << Atom(Atom::ListItemLeft)
+                        << Atom(Atom::String, protectEnc(title))
+                        << Atom(Atom::ListItemRight);
         }
     }
     else if (node->type() == Node::Namespace) {
-        out() << "              <li><a href=\"namespaces.html\">Namespaces</a></li>";
-        out() << "              <li>" << protectEnc(title) << "</li>";
+        breadcrumbs << Atom(Atom::ListItemLeft)
+                    << Atom(Atom::AutoLink, QLatin1String("Namespaces"))
+                    << Atom(Atom::ListItemRight);
+        breadcrumbs << Atom(Atom::ListItemLeft)
+                    << Atom(Atom::String, protectEnc(title))
+                    << Atom(Atom::ListItemRight);
     }
+
+    generateText(breadcrumbs, node, marker);
 }
 
 void HtmlGenerator::generateHeader(const QString& title,
diff --git a/tools/qdoc3/main.cpp b/tools/qdoc3/main.cpp
index 7eb8067..52715a3 100644
--- a/tools/qdoc3/main.cpp
+++ b/tools/qdoc3/main.cpp
@@ -235,6 +235,26 @@ static void processQdocconfFile(const QString &fileName)
     QStringList indexFiles = config.getStringList(CONFIG_INDEXES);
     tree->readIndexes(indexFiles);
 
+#if 0
+    /*
+      I think we won't beusing this...
+
+      Read the list of DITA excluded directories.
+     */
+    QSet<QString> ditaExcludedDirs;
+    QStringList ditaExcludedDirsList = config.getStringList("dita.metadata.excludedirs");
+    foreach (const QString &t, ditaExcludedDirsList)
+        ditaExcludedDirs.insert(QDir::fromNativeSeparators(t));
+
+    if (!ditaExcludedDirs.isEmpty()) {
+        QSet<QString>::iterator i = ditaExcludedDirs.begin();
+        while (i != ditaExcludedDirs.end()) {
+            qDebug() << "DITA EXCLUDED DIR:" << (*i);
+            ++i;
+        }
+    }
+#endif
+
     /*
       Read the list of excluded directories.
      */
diff --git a/tools/qdoc3/node.cpp b/tools/qdoc3/node.cpp
index 0f85d37..ee050f5 100644
--- a/tools/qdoc3/node.cpp
+++ b/tools/qdoc3/node.cpp
@@ -771,30 +771,6 @@ void InnerNode::removeChild(Node *child)
     }
 }
 
-/*! \fn QString InnerNode::author() const
-  Returns the author.
- */
-
-/*! \fn void InnerNode::setAuthor(const QString& author)
-  Sets the \a author.
- */
-
-/*! \fn QString InnerNode::publisher() const
-  Returns the publisher.
- */
-
-/*! \fn void InnerNode::setPublisher(const QString& publisher)
-  Sets the \a publisher.
- */
-
-/*! \fn QString InnerNode::permissions() const
-  Returns the permissions.
- */
-
-/*! \fn void InnerNode::setPermissions(const QString& permissions)
-  Sets the \a permissions.
- */
-
 /*!
   Find the module (QtCore, QtGui, etc.) to which the class belongs.
   We do this by obtaining the full path to the header file's location
@@ -858,21 +834,6 @@ void InnerNode::removeRelated(Node *pseudoChild)
     related.removeAll(pseudoChild);
 }
 
-/*! \fn bool InnerNode::hasOtherMetadata() const
-  Returns tru if the other metadata map is not empty.
- */
-
-/*!
-  Insert the pair \a name and \a content into the other metadata map.
- */
-void insertOtherMetadata(const QString& name, const QString& content)
-{
-}
-
-/*! \fn const QMap<QString, QString>& InnerNode::otherMetadata() cont
-  Returns the map containing pairs for output as \c {<othermetadata>}.
- */
-
 /*!
   \class LeafNode
  */
diff --git a/tools/qdoc3/node.h b/tools/qdoc3/node.h
index 2de2b5a..d1123dc 100644
--- a/tools/qdoc3/node.h
+++ b/tools/qdoc3/node.h
@@ -262,21 +262,12 @@ class InnerNode : public Node
     NodeList overloads(const QString &funcName) const;
     const QStringList& includes() const { return inc; }
 
-    QString author() const { return author_; }
-    void setAuthor(const QString& author) { author_ = author; }
-    QString publisher() const { return publisher_; }
-    void setPublisher(const QString& publisher) { publisher_ = publisher; }
-    QString permissions() const { return permissions_; }
-    void setPermissions(const QString& permissions) { permissions_ = permissions; }
     QStringList primaryKeys();
     QStringList secondaryKeys();
     const QStringList& pageKeywords() const { return pageKeywds; }
     virtual void addPageKeywords(const QString& t) { pageKeywds << t; }
     virtual bool isAbstract() const { return false; }
     virtual void setAbstract(bool ) { }
-    bool hasOtherMetadata() const { return !otherMetadataMap.isEmpty(); }
-    void insertOtherMetadata(const QString& name, const QString& content);
-    const QMap<QString, QString>& otherMetadata() const { return otherMetadataMap; }
 
  protected:
     InnerNode(Type type, InnerNode* parent, const QString& name);
@@ -289,9 +280,6 @@ class InnerNode : public Node
     void removeChild(Node* child);
     void removeRelated(Node* pseudoChild);
 
-    QString author_;
-    QString publisher_;
-    QString permissions_;
     QStringList pageKeywds;
     QStringList inc;
     NodeList children;
@@ -300,7 +288,6 @@ class InnerNode : public Node
     QMap<QString, Node*> childMap;
     QMap<QString, Node*> primaryFunctionMap;
     QMap<QString, NodeList> secondaryFunctionMap;
-    QMap<QString, QString> otherMetadataMap;
 };
 
 class LeafNode : public Node
diff --git a/tools/qdoc3/qdoc3.pro b/tools/qdoc3/qdoc3.pro
index 5b4131f..2b4c6a0 100644
--- a/tools/qdoc3/qdoc3.pro
+++ b/tools/qdoc3/qdoc3.pro
@@ -88,7 +88,7 @@ SOURCES += atom.cpp \
 
 INCLUDEPATH += $$QT_BUILD_TREE/include/QtDeclarative
 
-include($$QT_SOURCE_TREE/src/declarative/qml/parser/parser.pri)
+include(declarativeparser/parser.pri)
 
 ### Documentation for qdoc3 ###
 
diff --git a/tools/qdoc3/test/macros.qdocconf b/tools/qdoc3/test/macros.qdocconf
index 2262daa..87e442d 100644
--- a/tools/qdoc3/test/macros.qdocconf
+++ b/tools/qdoc3/test/macros.qdocconf
@@ -29,6 +29,7 @@ macro.begincomment      = "\\c{/*}"
 macro.endcomment        = "\\c{*/}"
 macro.uuml.HTML         = "&uuml;"
 macro.mdash.HTML        = "&mdash;"
+macro.pi.HTML         = "&Pi;"
 
 macro.beginfloatleft.HTML   = "<div style=\"float: left; margin-right: 2em\">"
 macro.beginfloatright.HTML  = "<div style=\"float: right; margin-left: 2em\">"
diff --git a/tools/qdoc3/test/qt-build-docs_ja_JP.qdocconf b/tools/qdoc3/test/qt-build-docs_ja_JP.qdocconf
index ef3f78b..a14054c 100644
--- a/tools/qdoc3/test/qt-build-docs_ja_JP.qdocconf
+++ b/tools/qdoc3/test/qt-build-docs_ja_JP.qdocconf
@@ -96,7 +96,7 @@ excludedirs             = $QT_SOURCE_TREE/src/3rdparty/clucene \
                           $QT_SOURCE_TREE/src/3rdparty/phonon/waveout
 
 sources.fileextensions  = "*.cpp *.qdoc *.mm"
-examples.fileextensions = "*.cpp *.h *.js *.xq *.svg *.xml *.ui *.qhp *.qhcp"
+examples.fileextensions = "*.cpp *.h *.js *.xq *.svg *.xml *.ui *.qhp *.qhcp *.css"
 examples.imageextensions = "*.png"
 
 exampledirs             = $QT_SOURCE_TREE/doc/src \
diff --git a/tools/qdoc3/test/qt-build-docs_zh_CN.qdocconf b/tools/qdoc3/test/qt-build-docs_zh_CN.qdocconf
index 3eef92c..d4d43b8 100644
--- a/tools/qdoc3/test/qt-build-docs_zh_CN.qdocconf
+++ b/tools/qdoc3/test/qt-build-docs_zh_CN.qdocconf
@@ -96,7 +96,7 @@ excludedirs             = $QT_SOURCE_TREE/src/3rdparty/clucene \
                           $QT_SOURCE_TREE/src/3rdparty/phonon/waveout
 
 sources.fileextensions  = "*.cpp *.qdoc *.mm"
-examples.fileextensions = "*.cpp *.h *.js *.xq *.svg *.xml *.ui *.qhp *.qhcp"
+examples.fileextensions = "*.cpp *.h *.js *.xq *.svg *.xml *.ui *.qhp *.qhcp *.css"
 examples.imageextensions = "*.png"
 
 exampledirs             = $QT_SOURCE_TREE/doc/src \
diff --git a/tools/qdoc3/test/qt-html-templates.qdocconf b/tools/qdoc3/test/qt-html-templates.qdocconf
index 6f756da..8a70f3b 100644
--- a/tools/qdoc3/test/qt-html-templates.qdocconf
+++ b/tools/qdoc3/test/qt-html-templates.qdocconf
@@ -52,3 +52,259 @@ qhp.Qt.extraFiles = index.html \
                     images/horBar.png \
                     images/sprites-combined.png \
                     style/offline.css
+
+#QtWebKit Guide files
+qhp.Qt.extraFiles += webkit-guide/anim_accord.htm \
+webkit-guide/anim_demo-rotate.htm \
+webkit-guide/anim_demo-scale.htm \
+webkit-guide/anim_demo-skew.htm \
+webkit-guide/anim_gallery.htm \
+webkit-guide/anim_panel.htm \
+webkit-guide/anim_pulse.htm \
+webkit-guide/anim_skew.htm \
+webkit-guide/anim_slide1.htm \
+webkit-guide/anim_slide2.htm \
+webkit-guide/anim_slide3.htm \
+webkit-guide/anim_tabbedSkew.htm \
+webkit-guide/_copyright.txt \
+webkit-guide/css3_backgrounds.htm \
+webkit-guide/css3_border-img.htm \
+webkit-guide/css3_gradientBack.htm \
+webkit-guide/css3_gradientBackStop.htm \
+webkit-guide/css3_gradientButton.htm \
+webkit-guide/css3_grad-radial.htm \
+webkit-guide/css3_mask-grad.htm \
+webkit-guide/css3_mask-img.htm \
+webkit-guide/css3_multicol.htm \
+webkit-guide/css3_reflect.htm \
+webkit-guide/css3_scroll.htm \
+webkit-guide/css3_sel-nth.htm \
+webkit-guide/css3_shadow.htm \
+webkit-guide/css3_text-overflow.htm \
+webkit-guide/css3_text-shadow.htm \
+webkit-guide/css3_text-stroke.htm \
+webkit-guide/form_tapper.htm \
+webkit-guide/form_toggler.htm \
+webkit-guide/_image_assets.htm \
+webkit-guide/_index.html \
+webkit-guide/layout_link-fmt.htm \
+webkit-guide/layout_tbl-keyhole.htm \
+webkit-guide/mob_condjs.htm \
+webkit-guide/mob_layout.htm \
+webkit-guide/mob_mediaquery.htm \
+webkit-guide/storage.htm \
+webkit-guide/css/anim_accord.css \
+webkit-guide/css/anim_demo-rotate.css \
+webkit-guide/css/anim_demo-scale.css \
+webkit-guide/css/anim_demo-skew.css \
+webkit-guide/css/anim_gallery.css \
+webkit-guide/css/anim_panel.css \
+webkit-guide/css/anim_pulse.css \
+webkit-guide/css/anim_skew.css \
+webkit-guide/css/anim_slide.css \
+webkit-guide/css/anim_tabbedSkew.css \
+webkit-guide/css/css3_backgrounds.css \
+webkit-guide/css/css3_border-img.css \
+webkit-guide/css/css3_gradientBack.css \
+webkit-guide/css/css3_gradientBackStop.css \
+webkit-guide/css/css3_gradientButton.css \
+webkit-guide/css/css3_grad-radial.css \
+webkit-guide/css/css3_mask-grad.css \
+webkit-guide/css/css3_mask-img.css \
+webkit-guide/css/css3_multicol.css \
+webkit-guide/css/css3_reflect.css \
+webkit-guide/css/css3_scroll.css \
+webkit-guide/css/css3_sel-nth.css \
+webkit-guide/css/css3_shadowBlur.css \
+webkit-guide/css/css3_shadow.css \
+webkit-guide/css/css3_text-overflow.css \
+webkit-guide/css/css3_text-shadow.css \
+webkit-guide/css/css3_text-stroke.css \
+webkit-guide/css/form_tapper.css \
+webkit-guide/css/form_toggler.css \
+webkit-guide/css/layout_link-fmt.css \
+webkit-guide/css/layout_tbl-keyhole.css \
+webkit-guide/css/mob_condjs.css \
+webkit-guide/css/mobile.css \
+webkit-guide/css/mob_mediaquery.css \
+webkit-guide/css/mq_desktop.css \
+webkit-guide/css/mqlayout_desktop.css \
+webkit-guide/css/mqlayout_mobile.css \
+webkit-guide/css/mqlayout_touch.css \
+webkit-guide/css/mq_mobile.css \
+webkit-guide/css/mq_touch.css \
+webkit-guide/css/storage.css \
+webkit-guide/img/border-frame.png \
+webkit-guide/img/gal0.png \
+webkit-guide/img/gal1.png \
+webkit-guide/img/gal2.png \
+webkit-guide/img/gal3.png \
+webkit-guide/img/gal4.png \
+webkit-guide/img/gal5.png \
+webkit-guide/img/gal6.png \
+webkit-guide/img/gal7.png \
+webkit-guide/img/gal8.png \
+webkit-guide/img/gradient.jpg \
+webkit-guide/img/gray_icon_close.png \
+webkit-guide/img/ic_ag_016.png \
+webkit-guide/img/ic_ag_032.png \
+webkit-guide/img/ic_ag_036.png \
+webkit-guide/img/ic_ag_048.png \
+webkit-guide/img/ic_al_016.png \
+webkit-guide/img/ic_al_032.png \
+webkit-guide/img/ic_al_036.png \
+webkit-guide/img/ic_al_048.png \
+webkit-guide/img/ic_ar_016.png \
+webkit-guide/img/ic_ar_032.png \
+webkit-guide/img/ic_ar_036.png \
+webkit-guide/img/ic_ar_048.png \
+webkit-guide/img/ic_b_016.png \
+webkit-guide/img/ic_b_032.png \
+webkit-guide/img/ic_b_036.png \
+webkit-guide/img/ic_b_048.png \
+webkit-guide/img/ic_be_016.png \
+webkit-guide/img/ic_be_032.png \
+webkit-guide/img/ic_be_036.png \
+webkit-guide/img/ic_be_048.png \
+webkit-guide/img/ic_c_016.png \
+webkit-guide/img/ic_c_032.png \
+webkit-guide/img/ic_c_036.png \
+webkit-guide/img/ic_c_048.png \
+webkit-guide/img/ic_ca_016.png \
+webkit-guide/img/ic_ca_032.png \
+webkit-guide/img/ic_ca_036.png \
+webkit-guide/img/ic_ca_048.png \
+webkit-guide/img/ic_cl_016.png \
+webkit-guide/img/ic_cl_032.png \
+webkit-guide/img/ic_cl_036.png \
+webkit-guide/img/ic_cl_048.png \
+webkit-guide/img/ic_cu_016.png \
+webkit-guide/img/ic_cu_032.png \
+webkit-guide/img/ic_cu_036.png \
+webkit-guide/img/ic_cu_048.png \
+webkit-guide/img/ic_f_016.png \
+webkit-guide/img/ic_f_032.png \
+webkit-guide/img/ic_f_036.png \
+webkit-guide/img/ic_f_048.png \
+webkit-guide/img/ic_fe_016.png \
+webkit-guide/img/ic_fe_032.png \
+webkit-guide/img/ic_fe_036.png \
+webkit-guide/img/ic_fe_048.png \
+webkit-guide/img/ic_h_016.png \
+webkit-guide/img/ic_h_032.png \
+webkit-guide/img/ic_h_036.png \
+webkit-guide/img/ic_h_048.png \
+webkit-guide/img/ic_he_016.png \
+webkit-guide/img/ic_he_032.png \
+webkit-guide/img/ic_he_036.png \
+webkit-guide/img/ic_he_048.png \
+webkit-guide/img/ic_k_016.png \
+webkit-guide/img/ic_k_032.png \
+webkit-guide/img/ic_k_036.png \
+webkit-guide/img/ic_k_048.png \
+webkit-guide/img/ic_li_016.png \
+webkit-guide/img/ic_li_032.png \
+webkit-guide/img/ic_li_036.png \
+webkit-guide/img/ic_li_048.png \
+webkit-guide/img/ic_mg_016.png \
+webkit-guide/img/ic_mg_032.png \
+webkit-guide/img/ic_mg_036.png \
+webkit-guide/img/ic_mg_048.png \
+webkit-guide/img/ic_n_016.png \
+webkit-guide/img/ic_n_032.png \
+webkit-guide/img/ic_n_036.png \
+webkit-guide/img/ic_n_048.png \
+webkit-guide/img/ic_na_016.png \
+webkit-guide/img/ic_na_032.png \
+webkit-guide/img/ic_na_036.png \
+webkit-guide/img/ic_na_048.png \
+webkit-guide/img/ic_ne_016.png \
+webkit-guide/img/ic_ne_032.png \
+webkit-guide/img/ic_ne_036.png \
+webkit-guide/img/ic_ne_048.png \
+webkit-guide/img/ic_ni_016.png \
+webkit-guide/img/ic_ni_032.png \
+webkit-guide/img/ic_ni_036.png \
+webkit-guide/img/ic_ni_048.png \
+webkit-guide/img/ic_o_016.png \
+webkit-guide/img/ic_o_032.png \
+webkit-guide/img/ic_o_036.png \
+webkit-guide/img/ic_o_048.png \
+webkit-guide/img/icon_check.png \
+webkit-guide/img/icon_check_x24green.png \
+webkit-guide/img/icon_dismiss.png \
+webkit-guide/img/icon_dismiss_x22.png \
+webkit-guide/img/icon_drill-down.png \
+webkit-guide/img/icon_drill-down_x32.png \
+webkit-guide/img/icon_drill-up.png \
+webkit-guide/img/icon_drill-up_x32.png \
+webkit-guide/img/icon_expand-nav.png \
+webkit-guide/img/icon_head-collapsed.png \
+webkit-guide/img/icon_head-collapsed_x13.png \
+webkit-guide/img/icon_head-expanded.png \
+webkit-guide/img/icon_head-expanded_x13.png \
+webkit-guide/img/icon_info.png \
+webkit-guide/img/icon_info_x24.png \
+webkit-guide/img/icon_link-doc.png \
+webkit-guide/img/icon_link-email.png \
+webkit-guide/img/icon_link-external.png \
+webkit-guide/img/icon_link-pdf.png \
+webkit-guide/img/icon_link-ppt.png \
+webkit-guide/img/icon_link-rss.png \
+webkit-guide/img/icon_link-sms.png \
+webkit-guide/img/icon_link-tel.png \
+webkit-guide/img/icon_link-xls.png \
+webkit-guide/img/icon_list-all_circ.png \
+webkit-guide/img/icon_list-all.png \
+webkit-guide/img/icon_nav_end.png \
+webkit-guide/img/icon_nav-start.png \
+webkit-guide/img/icon_nav-top.png \
+webkit-guide/img/icon_nav-up.png \
+webkit-guide/img/icon_question.png \
+webkit-guide/img/icon_scroll-left.png \
+webkit-guide/img/icon_scroll-right.png \
+webkit-guide/img/icon_trash.png \
+webkit-guide/img/ic_pt_016.png \
+webkit-guide/img/ic_pt_032.png \
+webkit-guide/img/ic_pt_036.png \
+webkit-guide/img/ic_pt_048.png \
+webkit-guide/img/ic_si_016.png \
+webkit-guide/img/ic_si_032.png \
+webkit-guide/img/ic_si_036.png \
+webkit-guide/img/ic_si_048.png \
+webkit-guide/img/ic_zn_016.png \
+webkit-guide/img/ic_zn_032.png \
+webkit-guide/img/ic_zn_036.png \
+webkit-guide/img/ic_zn_048.png \
+webkit-guide/img/land1.png \
+webkit-guide/img/land2.png \
+webkit-guide/img/land3.png \
+webkit-guide/img/land4.png \
+webkit-guide/img/land5.png \
+webkit-guide/img/land6.png \
+webkit-guide/img/land7.png \
+webkit-guide/img/land8.png \
+webkit-guide/img/mask.png \
+webkit-guide/img/tnail_gal1.png \
+webkit-guide/img/tnail_gal2.png \
+webkit-guide/img/tnail_gal3.png \
+webkit-guide/img/tnail_gal4.png \
+webkit-guide/img/tnail_gal5.png \
+webkit-guide/img/tnail_gal6.png \
+webkit-guide/img/tnail_gal7.png \
+webkit-guide/img/tnail_gal8.png \
+webkit-guide/js/anim_accord.js \
+webkit-guide/js/anim_gallery.js \
+webkit-guide/js/anim_panel.js \
+webkit-guide/js/anim_skew.js \
+webkit-guide/js/css3_backgrounds.js \
+webkit-guide/js/css3_border-img.js \
+webkit-guide/js/css3_grad-radial.js \
+webkit-guide/js/css3_mask-grad.js \
+webkit-guide/js/css3_mask-img.js \
+webkit-guide/js/css3_text-overflow.js \
+webkit-guide/js/form_tapper.js \
+webkit-guide/js/mob_condjs.js \
+webkit-guide/js/mobile.js \
+webkit-guide/js/storage.js \
+
diff --git a/tools/qdoc3/test/qt-project.qdocconf b/tools/qdoc3/test/qt-project.qdocconf
index 3091cf8..9c18608 100644
--- a/tools/qdoc3/test/qt-project.qdocconf
+++ b/tools/qdoc3/test/qt-project.qdocconf
@@ -35,6 +35,13 @@ qhp.Qt.subprojects.examples.title = Tutorials and Examples
 qhp.Qt.subprojects.examples.indexTitle = Qt Examples
 qhp.Qt.subprojects.examples.selectors = fake:example
 
+dita.metadata.default.author      = Qt Development Frameworks
+dita.metadata.default.permissions = all
+dita.metadata.default.publisher   = Nokia
+dita.metadata.default.copyryear = 2011
+dita.metadata.default.copyrholder = Nokia
+dita.metadata.default.audience = programmer
+
 language                = Cpp
 
 headerdirs              = $QT_SOURCE_TREE/src \
@@ -90,7 +97,7 @@ excludedirs             = $QT_SOURCE_TREE/src/3rdparty/clucene \
 sources.fileextensions  = "*.c++ *.cc *.cpp *.cxx *.mm *.qml *.qdoc"
 headers.fileextensions  = "*.ch *.h *.h++ *.hh *.hpp *.hxx"
 
-examples.fileextensions = "*.cpp *.h *.js *.xq *.svg *.xml *.ui *.qhp *.qhcp *.qml"
+examples.fileextensions = "*.cpp *.h *.js *.xq *.svg *.xml *.ui *.qhp *.qhcp *.qml *.css"
 examples.imageextensions = "*.png"
 
 exampledirs             = $QT_SOURCE_TREE/doc/src \