Long live Qt 4.5!

1 files changed, 2111 insertions, 0 deletions

diff --git a/src/script/qscriptcompiler.cpp b/src/script/qscriptcompiler.cpp
new file mode 100644
index 0000000..157e466
--- /dev/null
+++ b/src/script/qscriptcompiler.cpp
@@ -0,0 +1,2111 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtScript 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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qscriptcompiler_p.h"
+
+#ifndef QT_NO_SCRIPT
+
+#include "qscriptast_p.h"
+#include "qscriptengine_p.h"
+#include "qscriptvalueimpl_p.h"
+#include "qscriptcontext_p.h"
+#include "qscriptmember_p.h"
+#include "qscriptobject_p.h"
+
+#include <QtCore/QtDebug>
+
+QT_BEGIN_NAMESPACE
+
+namespace QScript {
+
+class Compare : protected AST::Visitor
+{
+public:
+    bool operator()(AST::ExpressionNode *e1, AST::ExpressionNode *e2)
+    {
+        if (!e1 || !e2)
+            return (e1 == e2);
+
+        if (e1->kind != e2->kind)
+            return false;
+
+        m_e2 = e2;
+        m_equal = false;
+        e1->accept(this);
+        return m_equal;
+    }
+
+protected:
+    virtual bool visit(AST::ThisExpression *)
+    {
+        m_equal = true;
+        return false;
+    }
+    virtual bool visit(AST::NullExpression *)
+    {
+        m_equal = true;
+        return false;
+    }
+    virtual bool visit(AST::VoidExpression *)
+    {
+        m_equal = true;
+        return false;
+    }
+    virtual bool visit(AST::FalseLiteral *)
+    {
+        m_equal = true;
+        return false;
+    }
+    virtual bool visit(AST::TrueLiteral *)
+    {
+        m_equal = true;
+        return false;
+    }
+    virtual bool visit(AST::NumericLiteral *e1)
+    {
+        AST::NumericLiteral *e2 = static_cast<AST::NumericLiteral*>(m_e2);
+        m_equal = (e1->value == e2->value);
+        return false;
+    }
+    virtual bool visit(AST::RegExpLiteral *e1)
+    {
+        AST::RegExpLiteral *e2 = static_cast<AST::RegExpLiteral*>(m_e2);
+        m_equal = (e1->pattern == e2->pattern)
+                  && (e1->flags == e2->flags);
+        return false;
+    }
+    virtual bool visit(AST::StringLiteral *e1)
+    {
+        AST::StringLiteral *e2 = static_cast<AST::StringLiteral*>(m_e2);
+        m_equal = (e1->value == e2->value);
+        return false;
+    }
+    virtual bool visit(AST::IdentifierExpression *e1)
+    {
+        AST::IdentifierExpression *e2 = static_cast<AST::IdentifierExpression*>(m_e2);
+        m_equal = (e1->name == e2->name);
+        return false;
+    }
+    virtual bool visit(AST::ArrayMemberExpression *e1)
+    {
+        AST::ArrayMemberExpression *e2 = static_cast<AST::ArrayMemberExpression*>(m_e2);
+        m_equal = operator()(e1->base, e2->base)
+                  && operator()(e1->expression, e2->expression);
+        return false;
+    }
+    virtual bool visit(AST::FieldMemberExpression *e1)
+    {
+        AST::FieldMemberExpression *e2 = static_cast<AST::FieldMemberExpression*>(m_e2);
+        m_equal = (e1->name == e2->name) && operator()(e1->base, e2->base);
+        return false;
+    }
+    virtual bool visit(AST::BinaryExpression *e1)
+    {
+        AST::BinaryExpression *e2 = static_cast<AST::BinaryExpression*>(m_e2);
+        m_equal = (e1->op == e2->op) && operator()(e1->left, e2->left)
+                  && operator()(e1->right, e2->right);
+        return false;
+    }
+    virtual bool visit(AST::ConditionalExpression *e1)
+    {
+        AST::ConditionalExpression *e2 = static_cast<AST::ConditionalExpression*>(m_e2);
+        m_equal = operator()(e1->expression, e2->expression)
+                  && operator()(e1->ok, e2->ok)
+                  && operator()(e1->ko, e2->ko);
+        return false;
+    }
+    virtual bool visit(AST::TypeOfExpression *e1)
+    {
+        AST::TypeOfExpression *e2 = static_cast<AST::TypeOfExpression*>(m_e2);
+        m_equal = operator()(e1->expression, e2->expression);
+        return false;
+    }
+    virtual bool visit(AST::UnaryPlusExpression *e1)
+    {
+        AST::UnaryPlusExpression *e2 = static_cast<AST::UnaryPlusExpression*>(m_e2);
+        m_equal = operator()(e1->expression, e2->expression);
+        return false;
+    }
+    virtual bool visit(AST::UnaryMinusExpression *e1)
+    {
+        AST::UnaryMinusExpression *e2 = static_cast<AST::UnaryMinusExpression*>(m_e2);
+        m_equal = operator()(e1->expression, e2->expression);
+        return false;
+    }
+    virtual bool visit(AST::TildeExpression *e1)
+    {
+        AST::TildeExpression *e2 = static_cast<AST::TildeExpression*>(m_e2);
+        m_equal = operator()(e1->expression, e2->expression);
+        return false;
+    }
+    virtual bool visit(AST::NotExpression *e1)
+    {
+        AST::NotExpression *e2 = static_cast<AST::NotExpression*>(m_e2);
+        m_equal = operator()(e1->expression, e2->expression);
+        return false;
+    }
+    virtual bool visit(AST::Expression *)
+    { return false; }
+    virtual bool visit(AST::ArrayLiteral *)
+    { return false; }
+    virtual bool visit(AST::ObjectLiteral *)
+    { return false; }
+    virtual bool visit(AST::CallExpression *)
+    { return false; }
+    virtual bool visit(AST::DeleteExpression *)
+    { return false; }
+    virtual bool visit(AST::FunctionExpression *)
+    { return false; }
+    virtual bool visit(AST::NewExpression *)
+    { return false; }
+    virtual bool visit(AST::NewMemberExpression *)
+    { return false; }
+    virtual bool visit(AST::PostDecrementExpression *)
+    { return false; }
+    virtual bool visit(AST::PostIncrementExpression *)
+    { return false; }
+    virtual bool visit(AST::PreDecrementExpression *)
+    { return false; }
+    virtual bool visit(AST::PreIncrementExpression *)
+    { return false; }
+
+private:
+    AST::ExpressionNode *m_e2;
+    bool m_equal;
+};
+
+class FetchName: protected AST::Visitor
+{
+public:
+    inline FetchName(QScriptEnginePrivate *e):
+        eng(e), name(0) {}
+
+    QScriptNameIdImpl *operator() (AST::PropertyName *node)
+    {
+        name = 0;
+        node->accept(this);
+        return name;
+    }
+
+protected:
+    virtual bool visit(AST::IdentifierPropertyName *node)
+    {
+        name = node->id;
+        return false;
+    }
+
+    virtual bool visit(AST::StringLiteralPropertyName *node)
+    {
+        name = node->id;
+        return false;
+    }
+
+    virtual bool visit(AST::NumericLiteralPropertyName *node)
+    {
+        name = eng->nameId(QString::number(node->id), /*persistent=*/false); // ### don't use QString::number
+        name->persistent = true; // ### remove
+        return false;
+    }
+
+private:
+    QScriptEnginePrivate *eng;
+    QScriptNameIdImpl *name;
+};
+
+class EmptySourceElements: protected AST::Visitor
+{
+public:
+    EmptySourceElements(QScriptEngine *d):
+        driver(d), empty(false) {}
+
+    inline bool operator () (AST::Node *)
+    {
+        empty = false;
+        return empty;
+    }
+
+private:
+    QScriptEngine *driver;
+    bool empty;
+};
+
+class DeclareLocals: protected AST::Visitor
+{
+public:
+    DeclareLocals(Compiler *c):
+        compiler(c),
+        eng(c->engine())
+    {
+    }
+
+    void operator () (AST::Node *node)
+    {
+        if (node)
+            node->accept(this);
+    }
+
+protected:
+    virtual bool visit(AST::FunctionDeclaration *node)
+    {
+        compiler->iDeclareLocal(node->name, /*readOnly=*/false);
+        return false;
+    }
+
+    virtual bool visit(AST::FunctionExpression *)
+    { return false; }
+
+    virtual bool visit(AST::VariableDeclaration *node)
+    {
+        compiler->iDeclareLocal(node->name, node->readOnly);
+        return false;
+    }
+
+private:
+    Compiler *compiler;
+    QScriptEnginePrivate *eng;
+};
+
+Compiler::Compiler(QScriptEnginePrivate *eng):
+    m_eng(eng),
+    m_generateReferences(0), m_iterationStatement(0),
+    m_switchStatement(0), m_withStatement(0),
+    m_generateLeaveWithOnBreak(0), m_generateFastArgumentLookup(0),
+    m_parseStatements(0), m_pad(0),
+    m_topLevelCompiler(false),
+    m_activeLoop(0)
+{
+}
+
+Compiler::~Compiler()
+{
+}
+
+bool Compiler::topLevelCompiler() const
+{
+    return m_topLevelCompiler;
+}
+
+void Compiler::setTopLevelCompiler(bool b)
+{
+    m_topLevelCompiler = b;
+}
+
+ CompilationUnit Compiler::compile(AST::Node *node, const QList<QScriptNameIdImpl *> &formals)
+{
+    m_formals = formals;
+    m_generateReferences = 0;
+    m_iterationStatement = 0;
+    m_switchStatement = 0;
+    m_withStatement = 0;
+    m_generateLeaveWithOnBreak = 0;
+    m_generateFastArgumentLookup = 0;
+    m_parseStatements = 0;
+    m_pad = 0;
+    m_instructions.clear();
+    m_exceptionHandlers.clear();
+    m_generateFastArgumentLookup = false; // ### !formals.isEmpty();  // ### disabled for now.. it's buggy :(
+
+    m_compilationUnit = CompilationUnit();
+
+    if (node)
+        node->accept(this);
+
+    // add a terminator
+    if (topLevelCompiler()) {
+        iHalt();
+    } else if (m_instructions.isEmpty() || m_instructions.last().op != QScriptInstruction::OP_Ret) {
+        iLoadUndefined();
+        iRet();
+    }
+
+    m_compilationUnit.setInstructions(m_instructions);
+    m_compilationUnit.setExceptionHandlers(m_exceptionHandlers);
+    return m_compilationUnit;
+}
+
+bool Compiler::preVisit(AST::Node *)
+{
+    return m_compilationUnit.isValid();
+}
+
+bool Compiler::visit(AST::SourceElements *node)
+{
+    DeclareLocals declareLocals(this);
+    declareLocals(node);
+
+    bool was = changeParseStatements(false);
+
+    for (AST::SourceElements *it = node; it != 0; it = it->next)
+        it->element->accept(this);
+
+    changeParseStatements(true);
+
+    for (AST::SourceElements *it = node; it != 0; it = it->next)
+        it->element->accept(this);
+
+    changeParseStatements(was);
+
+    return false;
+}
+
+bool Compiler::visit(AST::StatementList *)
+{
+    return true;
+}
+
+bool Compiler::visit(AST::FunctionSourceElement *)
+{
+    return m_parseStatements == 0;
+}
+
+bool Compiler::visit(AST::StatementSourceElement *)
+{
+    return m_parseStatements;
+}
+
+bool Compiler::visit(AST::ThisExpression *)
+{
+    iLoadThis();
+    return false;
+}
+
+bool Compiler::visit(AST::NullExpression *)
+{
+    iLoadNull();
+    return false;
+}
+
+bool Compiler::visit(AST::RegExpLiteral *node)
+{
+    Q_ASSERT(node->pattern != 0);
+
+    if (node->flags)
+        iNewRegExp(node->pattern, node->flags);
+    else
+        iNewRegExp(node->pattern);
+
+    return false;
+}
+
+bool Compiler::visit(AST::NumericLiteral *node)
+{
+    iLoadNumber(node->value);
+    return false;
+}
+
+bool Compiler::visit(AST::StringLiteral *node)
+{
+    iNewString(node->value);
+
+    return false;
+}
+
+bool Compiler::visit(AST::ObjectLiteral *node)
+{
+    iNewObject();
+
+    FetchName fetchName(m_eng);
+    bool was = generateReferences(false);
+    for (AST::PropertyNameAndValueList *it = node->properties; it != 0; it = it->next) {
+        iLine(it->value);
+        iDuplicate();
+
+        QScriptNameIdImpl *name = fetchName(it->name);
+        Q_ASSERT(name != 0);
+        iLoadString(name);
+        iMakeReference();
+
+        it->value->accept(this);
+        iPutField();
+    }
+    generateReferences(was);
+
+    return false;
+}
+
+bool Compiler::visit(AST::IdentifierExpression *node)
+{
+    Q_ASSERT(node->name != 0);
+
+    if (node->name == m_eng->idTable()->id_arguments)
+        iLazyArguments();
+    if (m_generateReferences)
+        iResolve(node->name);
+    else
+        iFetch(node->name);
+
+    return false;
+}
+
+bool Compiler::visit(AST::FunctionDeclaration *node)
+{
+    iLoadActivation();
+    iLoadString(node->name);
+    iMakeReference();
+    iNewClosure(node);
+    iPutField();
+    return false;
+}
+
+bool Compiler::visit(AST::FunctionExpression *node)
+{
+    iNewClosure(node);
+    if (node->name) {
+        iDuplicate();
+        iLoadActivation();
+        iSwap();
+        iLoadString(node->name);
+        iSwap();
+        iMakeReference();
+        iSwap();
+        iPutField();
+    }
+    return false;
+}
+
+bool Compiler::visit(AST::CallExpression *node)
+{
+    bool was = generateReferences(true);
+    node->base->accept(this);
+    generateReferences(false);
+
+    int argc = 0;
+    for (AST::ArgumentList *it = node->arguments; it != 0; it = it->next) {
+        it->expression->accept(this);
+        ++argc;
+    }
+
+    generateReferences(was);
+
+    iCall(argc);
+    return false;
+}
+
+bool Compiler::visit(AST::NewExpression *node)
+{
+    bool was = generateReferences(true);
+    node->expression->accept(this);
+    generateReferences(was);
+    iNew(0);
+    return false;
+}
+
+bool Compiler::visit(AST::NewMemberExpression *node)
+{
+    bool was = generateReferences(true);
+    node->base->accept(this);
+    generateReferences(false);
+
+    int argc = 0;
+    for (AST::ArgumentList *it = node->arguments; it != 0; it = it->next) {
+        it->expression->accept(this);
+        ++argc;
+    }
+
+    generateReferences(was);
+
+    iNew(argc);
+    return false;
+}
+
+bool Compiler::visit(AST::FieldMemberExpression *node)
+{
+    bool was = generateReferences(false);
+    node->base->accept(this);
+    generateReferences(was);
+
+    iLoadString(node->name);
+
+    if (! was)
+        iFetchField();
+    else
+        iMakeReference();
+
+    return false;
+}
+
+bool Compiler::visit(AST::ArrayMemberExpression *node)
+{
+    bool was = generateReferences(false);
+    node->base->accept(this);
+    node->expression->accept(this);
+    generateReferences(was);
+
+    if (! was)
+        iFetchField();
+    else
+        iMakeReference();
+
+    return false;
+}
+
+bool Compiler::visit(AST::PostIncrementExpression *node)
+{
+    bool was = generateReferences(true);
+    node->base->accept(this);
+    generateReferences(was);
+    iPostIncr();
+
+    return false;
+}
+
+bool Compiler::visit(AST::PostDecrementExpression *node)
+{
+    bool was = generateReferences(true);
+    node->base->accept(this);
+    generateReferences(was);
+    iPostDecr();
+
+    return false;
+}
+
+bool Compiler::visit(AST::PreIncrementExpression *node)
+{
+    bool was = generateReferences(true);
+    node->expression->accept(this);
+    generateReferences(was);
+    iIncr();
+    return false;
+}
+
+bool Compiler::visit(AST::PreDecrementExpression *node)
+{
+    bool was = generateReferences(true);
+    node->expression->accept(this);
+    generateReferences(was);
+    iDecr();
+    return false;
+}
+
+void Compiler::endVisit(AST::NotExpression *)
+{
+    iNot();
+}
+
+void Compiler::endVisit(AST::TildeExpression *)
+{
+    iBitNot();
+}
+
+bool Compiler::visit(AST::ThrowStatement *node)
+{
+    iLine(node);
+    return true;
+}
+
+bool Compiler::visit(AST::TryStatement *node)
+{
+    int start = nextInstructionOffset();
+    if (node->statement)
+        node->statement->accept(this);
+    int end = nextInstructionOffset();
+    if (node->catchExpression) {
+        iBranch(0); // skip the catch if no exception
+        ExceptionHandlerDescriptor ehd(start, end, nextInstructionOffset());
+        m_exceptionHandlers.append(ehd);
+        iBeginCatch(node->catchExpression->name);
+        node->catchExpression->statement->accept(this);
+        iEndCatch();
+        patchInstruction(end, nextInstructionOffset() - end);
+    }
+    if (node->finallyExpression) {
+        if (!node->catchExpression) {
+            ExceptionHandlerDescriptor ehd(start, end, nextInstructionOffset());
+            m_exceptionHandlers.prepend(ehd);
+        }
+        node->finallyExpression->statement->accept(this);
+    }
+    return false;
+}
+
+void Compiler::endVisit(AST::ThrowStatement *node)
+{
+    if (! node->expression)
+        iLoadUndefined();
+
+    iThrow();
+}
+
+void Compiler::endVisit(AST::VoidExpression *)
+{
+    iPop();
+    iLoadUndefined();
+}
+
+bool Compiler::visit(AST::TypeOfExpression *node)
+{
+    bool was = generateReferences(true);
+    node->expression->accept(this);
+    generateReferences(was);
+    iTypeOf();
+    return false;
+}
+
+bool Compiler::visit(AST::DeleteExpression *node)
+{
+    bool was = generateReferences(true);
+    node->expression->accept(this);
+    generateReferences(was);
+    iDelete();
+    return false;
+}
+
+bool Compiler::visit(AST::ReturnStatement *node)
+{
+    if (topLevelCompiler()) {
+        m_compilationUnit.setError(QString::fromUtf8("return outside function body"),
+                                   node->startLine);
+        return false;
+    }
+    iLine(node);
+    return true;
+}
+
+void Compiler::endVisit(AST::ReturnStatement *node)
+{
+    if (! node->expression)
+        iLoadUndefined();
+
+    iRet();
+}
+
+bool Compiler::visit(AST::VariableStatement *node)
+{
+    AST::VariableDeclarationList *lst = node->declarations;
+    while (lst) {
+        if (lst->declaration->expression) {
+            iLine(node);
+            break;
+        }
+        lst = lst->next;
+    }
+    return true;
+}
+
+bool Compiler::visit(AST::VariableDeclaration *node)
+{
+    if (node->expression != 0) {
+        iResolve(node->name);
+        node->expression->accept(this);
+        iAssign();
+        iPop();
+    }
+
+    return false;
+}
+
+bool Compiler::visit(AST::ConditionalExpression *node)
+{
+    node->expression->accept(this);
+
+    int cond = nextInstructionOffset();
+    iBranchFalse(0);
+
+    node->ok->accept(this);
+
+    if (! node->ko) {
+        patchInstruction(cond, nextInstructionOffset() - cond);
+    } else {
+        int terminator = nextInstructionOffset();
+        iBranch(0);
+        node->ko->accept(this);
+
+        patchInstruction(cond, terminator + 1 - cond);
+        patchInstruction(terminator, nextInstructionOffset() - terminator);
+    }
+
+    return false;
+}
+
+bool Compiler::visit(AST::IfStatement *node)
+{
+    iLine(node);
+    node->expression->accept(this);
+
+    int cond = nextInstructionOffset();
+    iBranchFalse(0);
+
+    node->ok->accept(this);
+
+    if (! node->ko) {
+        patchInstruction(cond, nextInstructionOffset() - cond);
+    } else {
+        int terminator = nextInstructionOffset();
+        iBranch(0);
+        node->ko->accept(this);
+
+        patchInstruction(cond, terminator + 1 - cond);
+        patchInstruction(terminator, nextInstructionOffset() - terminator);
+    }
+    if (!m_instructions.isEmpty() && m_instructions.last().op == QScriptInstruction::OP_Ret)
+        iNop();
+
+    return false;
+}
+
+bool Compiler::visit(AST::Block *node)
+{
+    if (node->statements && m_loops.contains(node)) {
+        Loop &loop = m_loops[node];
+
+        node->statements->accept(this);
+
+        loop.breakLabel.offset = nextInstructionOffset();
+
+        foreach (int index, loop.breakLabel.uses) {
+            patchInstruction(index, loop.breakLabel.offset - index);
+        }
+
+        return false;
+    }
+
+    return true;
+}
+
+bool Compiler::visit(AST::WhileStatement *node)
+{
+    Loop *previousLoop = changeActiveLoop(&m_loops[node]);
+    m_activeLoop->continueLabel.offset = nextInstructionOffset();
+
+    iLine(node);
+    int again = nextInstructionOffset();
+    node->expression->accept(this);
+
+    int cond = nextInstructionOffset();
+    iBranchFalse(0);
+
+    bool was = iterationStatement(true);
+    bool was2 = generateLeaveOnBreak(false);
+    node->statement->accept(this);
+    generateLeaveOnBreak(was2);
+    iterationStatement(was);
+
+    iBranch(again - nextInstructionOffset());
+    patchInstruction(cond, nextInstructionOffset() - cond);
+
+    m_activeLoop->breakLabel.offset = nextInstructionOffset();
+
+    foreach (int index, m_activeLoop->breakLabel.uses) {
+        patchInstruction(index, m_activeLoop->breakLabel.offset - index);
+    }
+
+    foreach (int index, m_activeLoop->continueLabel.uses) {
+        patchInstruction(index, m_activeLoop->continueLabel.offset - index);
+    }
+
+    changeActiveLoop(previousLoop);
+    m_loops.remove(node);
+
+    return false;
+}
+
+bool Compiler::visit(AST::DoWhileStatement *node)
+{
+    Loop *previousLoop = changeActiveLoop(&m_loops[node]);
+    int again = nextInstructionOffset();
+    iLine(node);
+    bool was = iterationStatement(true);
+    node->statement->accept(this);
+    iterationStatement(was);
+
+    m_activeLoop->continueLabel.offset = nextInstructionOffset();
+
+    node->expression->accept(this);
+
+    iBranchTrue(again - nextInstructionOffset());
+    m_activeLoop->breakLabel.offset = nextInstructionOffset();
+
+    foreach (int index, m_activeLoop->breakLabel.uses) {
+        patchInstruction(index, m_activeLoop->breakLabel.offset - index);
+    }
+
+    foreach (int index, m_activeLoop->continueLabel.uses) {
+        patchInstruction(index, m_activeLoop->continueLabel.offset - index);
+    }
+
+    changeActiveLoop(previousLoop);
+    m_loops.remove(node);
+
+    return false;
+}
+
+bool Compiler::visit(AST::ForEachStatement *node)
+{
+    Loop *previousLoop = changeActiveLoop(&m_loops[node]);
+
+    iLine(node);
+    node->expression->accept(this);
+    iNewEnumeration();
+    iDuplicate();
+    iToFirstElement();
+
+    int again = nextInstructionOffset();
+    m_activeLoop->continueLabel.offset = again;
+    iDuplicate();
+    iHasNextElement();
+    int cond = nextInstructionOffset();
+    iBranchFalse(0);
+    bool was = generateReferences(true);
+    node->initialiser->accept(this);
+    generateReferences(was);
+    iNextElement();
+    iAssign();
+    iPop();
+    was = iterationStatement(true);
+    node->statement->accept(this);
+    iterationStatement(was);
+    iBranch(again - nextInstructionOffset());
+    patchInstruction(cond, nextInstructionOffset() - cond);
+
+    m_activeLoop->breakLabel.offset = nextInstructionOffset();
+    iPop(); // pop the Enumeration
+
+    foreach (int index, m_activeLoop->breakLabel.uses) {
+        patchInstruction(index, m_activeLoop->breakLabel.offset - index);
+    }
+
+    foreach (int index, m_activeLoop->continueLabel.uses) {
+        patchInstruction(index, m_activeLoop->continueLabel.offset - index);
+    }
+
+    changeActiveLoop(previousLoop);
+    m_loops.remove(node);
+
+    return false;
+}
+
+bool Compiler::visit(AST::LocalForEachStatement *node)
+{
+    Loop *previousLoop = changeActiveLoop(&m_loops[node]);
+
+    iLine(node);
+    node->declaration->accept(this);
+    node->expression->accept(this);
+    iNewEnumeration();
+    iDuplicate();
+    iToFirstElement();
+
+    int again = nextInstructionOffset();
+    m_activeLoop->continueLabel.offset = again;
+    iDuplicate();
+    iHasNextElement();
+    int cond = nextInstructionOffset();
+    iBranchFalse(0);
+    iResolve(node->declaration->name);
+    iNextElement();
+    iAssign();
+    iPop();
+    bool was = iterationStatement(true);
+    node->statement->accept(this);
+    iterationStatement(was);
+    iBranch(again - nextInstructionOffset());
+    patchInstruction(cond, nextInstructionOffset() - cond);
+
+    m_activeLoop->breakLabel.offset = nextInstructionOffset();
+    iPop(); // pop the Enumeration
+
+    foreach (int index, m_activeLoop->breakLabel.uses) {
+        patchInstruction(index, m_activeLoop->breakLabel.offset - index);
+    }
+
+    foreach (int index, m_activeLoop->continueLabel.uses) {
+        patchInstruction(index, m_activeLoop->continueLabel.offset - index);
+    }
+
+    changeActiveLoop(previousLoop);
+    m_loops.remove(node);
+
+    return false;
+}
+
+void Compiler::visitForInternal(AST::Statement *node, AST::ExpressionNode *condition, AST::Statement *statement, AST::ExpressionNode *expression)
+{
+    Q_ASSERT(statement != 0);
+
+    int again = nextInstructionOffset();
+    if (condition != 0) {
+//        iLine(condition);
+        condition->accept(this);
+    } else {
+//        iLine(node);
+        iLoadNumber(1);
+    }
+
+    int cond = nextInstructionOffset();
+    iBranchFalse(0);
+
+    Loop *previousLoop = changeActiveLoop(&m_loops[node]);
+
+    bool was = iterationStatement(true);
+    statement->accept(this);
+    iterationStatement(was);
+
+    m_activeLoop->continueLabel.offset = nextInstructionOffset();
+
+    if (expression != 0) {
+        expression->accept(this);
+        iPop();
+    }
+
+    iBranch(again - nextInstructionOffset());
+    patchInstruction(cond, nextInstructionOffset() - cond);
+
+    m_activeLoop->breakLabel.offset = nextInstructionOffset();
+
+    foreach (int index, m_activeLoop->breakLabel.uses) {
+        patchInstruction(index, m_activeLoop->breakLabel.offset - index);
+    }
+
+    foreach (int index, m_activeLoop->continueLabel.uses) {
+        patchInstruction(index, m_activeLoop->continueLabel.offset - index);
+    }
+
+    changeActiveLoop(previousLoop);
+    m_loops.remove(node);
+}
+
+bool Compiler::visit(AST::ForStatement *node)
+{
+    iLine(node);
+
+    if (node->initialiser != 0) {
+        node->initialiser->accept(this);
+        iPop();
+    }
+
+    visitForInternal(node, node->condition, node->statement, node->expression);
+    return false;
+}
+
+bool Compiler::visit(AST::LocalForStatement *node)
+{
+    iLine(node);
+
+    if (node->declarations)
+        node->declarations->accept(this);
+
+    visitForInternal(node, node->condition, node->statement, node->expression);
+    return false;
+}
+
+bool Compiler::isAssignmentOperator(int op) const
+{
+    switch (op) {
+
+    case QSOperator::Assign:
+    case QSOperator::InplaceAnd:
+    case QSOperator::InplaceSub:
+    case QSOperator::InplaceDiv:
+    case QSOperator::InplaceAdd:
+    case QSOperator::InplaceLeftShift:
+    case QSOperator::InplaceMod:
+    case QSOperator::InplaceMul:
+    case QSOperator::InplaceOr:
+    case QSOperator::InplaceRightShift:
+    case QSOperator::InplaceURightShift:
+    case QSOperator::InplaceXor:
+        return true;
+
+    default:
+        break;
+
+    }
+
+    return false;
+}
+
+int Compiler::inplaceAssignmentOperator(int op) const
+{
+    switch (op) {
+    case QSOperator::BitAnd:
+        return QSOperator::InplaceAnd;
+    case QSOperator::Sub:
+        return QSOperator::InplaceSub;
+    case QSOperator::Div:
+        return QSOperator::InplaceDiv;
+    case QSOperator::Add:
+        return QSOperator::InplaceAdd;
+    case QSOperator::LShift:
+        return QSOperator::InplaceLeftShift;
+    case QSOperator::Mod:
+        return QSOperator::InplaceMod;
+    case QSOperator::Mul:
+        return QSOperator::InplaceMul;
+    case QSOperator::BitOr:
+        return QSOperator::InplaceOr;
+    case QSOperator::RShift:
+        return QSOperator::InplaceRightShift;
+    case QSOperator::URShift:
+        return QSOperator::InplaceURightShift;
+    case QSOperator::BitXor:
+        return QSOperator::InplaceXor;
+
+    default:
+        break;
+
+    }
+
+    return(-1);
+}
+
+bool Compiler::visit(AST::Expression *node)
+{
+    node->left->accept(this);
+    iPop(); // ### or iSync?
+    node->right->accept(this);
+    return false;
+}
+
+bool Compiler::visit(AST::BinaryExpression *node)
+{
+    if (isAssignmentOperator(node->op)) {
+        bool was = generateReferences(true);
+        node->left->accept(this);
+        generateReferences(was);
+    } else {
+        node->left->accept(this);
+    }
+
+    int address = 0;
+    if (node->op == QSOperator::Or || node->op == QSOperator::And) {
+        iDuplicate();
+        address = nextInstructionOffset();
+        if (node->op == QSOperator::Or)
+            iBranchTrue(0);
+        else
+            iBranchFalse(0);
+        iPop();
+    }
+
+    int op = node->op;
+    Compare compare;
+    if ((op == QSOperator::Assign) && node->right->binaryExpressionCast()
+        && (inplaceAssignmentOperator(node->right->binaryExpressionCast()->op) != -1)
+        && compare(node->left, node->right->binaryExpressionCast()->left)) {
+        // node->left is equivalent to node->right->left, so we generate
+        // x op= y rather than x = x op y
+        op = inplaceAssignmentOperator(node->right->binaryExpressionCast()->op);
+        node->right->binaryExpressionCast()->right->accept(this);
+    } else {
+        node->right->accept(this);
+    }
+
+    switch (op) {
+
+    case QSOperator::Assign:
+        iAssign();
+        break;
+
+    case QSOperator::InplaceAnd:
+        iInplaceAnd();
+        break;
+
+    case QSOperator::InplaceSub:
+        iInplaceSub();
+        break;
+
+    case QSOperator::InplaceDiv:
+        iInplaceDiv();
+        break;
+
+    case QSOperator::InplaceAdd:
+        iInplaceAdd();
+        break;
+
+    case QSOperator::InplaceLeftShift:
+        iInplaceLeftShift();
+        break;
+
+    case QSOperator::InplaceMod:
+        iInplaceMod();
+        break;
+
+    case QSOperator::InplaceMul:
+        iInplaceMul();
+        break;
+
+    case QSOperator::InplaceOr:
+        iInplaceOr();
+        break;
+
+    case QSOperator::InplaceRightShift:
+        iInplaceRightShift();
+        break;
+
+    case QSOperator::InplaceURightShift:
+        iInplaceURightShift();
+        break;
+
+    case QSOperator::InplaceXor:
+        iInplaceXor();
+        break;
+
+    case QSOperator::BitAnd:
+        iBitAnd();
+        break;
+
+    case QSOperator::BitOr:
+        iBitOr();
+        break;
+
+    case QSOperator::BitXor:
+        iBitXor();
+        break;
+
+    case QSOperator::LShift:
+        iLeftShift();
+        break;
+
+    case QSOperator::Mod:
+        iMod();
+        break;
+
+    case QSOperator::RShift:
+        iRightShift();
+        break;
+
+    case QSOperator::URShift:
+        iURightShift();
+        break;
+
+    case QSOperator::InstanceOf:
+        iInstanceOf();
+        break;
+
+    case QSOperator::Add:
+        iAdd();
+        break;
+
+    case QSOperator::And:
+        patchInstruction(address, nextInstructionOffset() - address);
+        break;
+
+    case QSOperator::Div:
+        iDiv();
+        break;
+
+    case QSOperator::Equal:
+        iEqual();
+        break;
+
+    case QSOperator::Ge:
+        iGreatOrEqual();
+        break;
+
+    case QSOperator::Gt:
+        iGreatThan();
+        break;
+
+    case QSOperator::Le:
+        iLessOrEqual();
+        break;
+
+    case QSOperator::Lt:
+        iLessThan();
+        break;
+
+    case QSOperator::Mul:
+        iMul();
+        break;
+
+    case QSOperator::NotEqual:
+        iNotEqual();
+        break;
+
+    case QSOperator::Or:
+        patchInstruction(address, nextInstructionOffset() - address);
+        break;
+
+    case QSOperator::Sub:
+        iSub();
+        break;
+
+    case QSOperator::StrictEqual:
+        iStrictEqual();
+        break;
+
+    case QSOperator::StrictNotEqual:
+        iStrictNotEqual();
+        break;
+
+    case QSOperator::In:
+        iIn();
+        break;
+    }
+
+    return false;
+}
+
+bool Compiler::visit(AST::TrueLiteral *)
+{
+    iLoadTrue();
+    return false;
+}
+
+bool Compiler::visit(AST::FalseLiteral *)
+{
+    iLoadFalse();
+    return false;
+}
+
+bool Compiler::visit(AST::SwitchStatement *node)
+{
+    iLine(node);
+    Loop *previousLoop = changeActiveLoop(&m_loops[node]);
+
+    node->expression->accept(this);
+
+    bool was = switchStatement(true);
+
+    AST::CaseClauses *clauses;
+    int skipIndex = -1;
+    int fallthroughIndex = -1;
+    // ### make a function for this
+    for (clauses = node->block->clauses; clauses != 0; clauses = clauses->next) {
+        AST::CaseClause *clause = clauses->clause;
+        if (skipIndex != -1)
+            patchInstruction(skipIndex, nextInstructionOffset() - skipIndex);
+
+        iDuplicate(); // expression
+        clause->expression->accept(this);
+        iStrictEqual();
+        skipIndex = nextInstructionOffset();
+        iBranchFalse(0); // next case
+
+        if (fallthroughIndex != -1) // previous case falls through to here
+            patchInstruction(fallthroughIndex, nextInstructionOffset() - fallthroughIndex);
+
+        int breaksBefore = m_activeLoop->breakLabel.uses.count();
+        if (clause->statements)
+            clause->statements->accept(this);
+        int breaksAfter = m_activeLoop->breakLabel.uses.count();
+        if (breaksAfter == breaksBefore) { // fallthrough
+            fallthroughIndex = nextInstructionOffset();
+            iBranch(0);
+        } else { // no fallthrough (break)
+            fallthroughIndex = -1;
+        }
+    }
+
+    if (fallthroughIndex != -1) {
+        patchInstruction(fallthroughIndex, nextInstructionOffset() - fallthroughIndex);
+        fallthroughIndex = -1;
+    }
+
+    int defaultIndex = -1;
+    if (node->block->defaultClause) {
+        int skipDefaultIndex = -1;
+        if (!node->block->clauses && node->block->moreClauses) {
+            skipDefaultIndex = nextInstructionOffset();
+            iBranch(0);
+        }
+        defaultIndex = nextInstructionOffset();
+        int breaksBefore = m_activeLoop->breakLabel.uses.count();
+        if (node->block->defaultClause->statements)
+            node->block->defaultClause->statements->accept(this);
+        int breaksAfter = m_activeLoop->breakLabel.uses.count();
+        if (breaksAfter == breaksBefore) { // fallthrough
+            fallthroughIndex = nextInstructionOffset();
+            iBranch(0);
+        } else { // no fallthrough (break)
+            fallthroughIndex = -1;
+        }
+        if (skipDefaultIndex != -1)
+            patchInstruction(skipDefaultIndex, nextInstructionOffset() - skipDefaultIndex);
+    }
+
+    for (clauses = node->block->moreClauses; clauses != 0; clauses = clauses->next) {
+        AST::CaseClause *clause = clauses->clause;
+        if (skipIndex != -1)
+            patchInstruction(skipIndex, nextInstructionOffset() - skipIndex);
+
+        iDuplicate(); // expression
+        clause->expression->accept(this);
+        iStrictEqual();
+        skipIndex = nextInstructionOffset();
+        iBranchFalse(0); // next case
+
+        if (fallthroughIndex != -1) // previous case falls through to here
+            patchInstruction(fallthroughIndex, nextInstructionOffset() - fallthroughIndex);
+
+        int breaksBefore = m_activeLoop->breakLabel.uses.count();
+        if (clause->statements)
+            clause->statements->accept(this);
+        int breaksAfter = m_activeLoop->breakLabel.uses.count();
+        if (breaksAfter == breaksBefore) { // fallthrough
+            fallthroughIndex = nextInstructionOffset();
+            iBranch(0);
+        } else { // no fallthrough (break)
+            fallthroughIndex = -1;
+        }
+    }
+
+    if (skipIndex != -1) {
+        patchInstruction(skipIndex, nextInstructionOffset() - skipIndex);
+        if (defaultIndex != -1)
+            iBranch(defaultIndex - nextInstructionOffset()); // goto default
+    }
+
+    if (fallthroughIndex != -1)
+        patchInstruction(fallthroughIndex, nextInstructionOffset() - fallthroughIndex);
+
+    // backpatch the breaks
+    int term = nextInstructionOffset();
+    foreach (int index, m_activeLoop->breakLabel.uses) {
+        patchInstruction(index, term - index);
+    }
+
+    iPop(); // expression
+
+    if (previousLoop && !m_activeLoop->continueLabel.uses.isEmpty()) {
+        // join the continues and add to outer loop
+        iBranch(3);
+        foreach (int index, m_activeLoop->continueLabel.uses) {
+            patchInstruction(index, nextInstructionOffset() - index);
+        }
+        iPop();
+        iBranch(0);
+        previousLoop->continueLabel.uses.append(nextInstructionOffset() - 1);
+    }
+
+    switchStatement(was);
+    changeActiveLoop(previousLoop);
+    m_loops.remove(node);
+    return false;
+}
+
+bool Compiler::visit(AST::LabelledStatement *node)
+{
+    Loop *loop = findLoop(node->label);
+    if (loop != 0) {
+        QString str = m_eng->toString(node->label);
+        m_compilationUnit.setError(QString::fromUtf8("duplicate label `%1'").arg(str),
+                                   node->startLine);
+        return false;
+    }
+
+    loop = &m_loops[node->statement];
+    loop->name = node->label;
+    node->statement->accept(this);
+    if (m_loops.contains(node->statement)) {
+        loop->breakLabel.offset = nextInstructionOffset();
+        foreach (int index, loop->breakLabel.uses) {
+            patchInstruction(index, loop->breakLabel.offset - index);
+        }
+        m_loops.remove(node->statement);
+    }
+    return false;
+}
+
+bool Compiler::visit(AST::ExpressionStatement *node)
+{
+    if (node->expression)
+        iLine(node->expression);
+    return true;
+}
+
+void Compiler::endVisit(AST::ExpressionStatement *)
+{
+    if (topLevelCompiler())
+        iSync();
+    else
+        iPop();
+}
+
+void Compiler::endVisit(AST::UnaryPlusExpression *)
+{
+    iUnaryPlus();
+}
+
+void Compiler::endVisit(AST::UnaryMinusExpression *)
+{
+    iUnaryMinus();
+}
+
+bool Compiler::visit(AST::ContinueStatement *node)
+{
+    iLine(node);
+    return true;
+}
+
+void Compiler::endVisit(AST::ContinueStatement *node)
+{
+    int offset = nextInstructionOffset();
+    iBranch(0);
+
+    Loop *loop = findLoop(node->label);
+    if (!loop || !m_iterationStatement) {
+        m_compilationUnit.setError(QString::fromUtf8("label not found"),
+                                   node->startLine);
+        return;
+    }
+
+    loop->continueLabel.uses.append(offset);
+}
+
+bool Compiler::visit(AST::BreakStatement *node)
+{
+    iLine(node);
+    return true;
+}
+
+void Compiler::endVisit(AST::BreakStatement *node)
+{
+    Loop *loop = findLoop(node->label);
+    if (! loop) {
+        m_compilationUnit.setError(QString::fromUtf8("label not found"),
+                                   node->startLine);
+        return;
+    }
+
+    if (m_generateLeaveWithOnBreak)
+        iLeaveWith();
+    int offset = nextInstructionOffset();
+    iBranch(0);
+    loop->breakLabel.uses.append(offset);
+}
+
+void Compiler::endVisit(AST::EmptyStatement *node)
+{
+    iLine(node);
+}
+
+bool Compiler::visit(AST::DebuggerStatement *node)
+{
+    iLine(node);
+    iDebugger();
+    return false;
+}
+
+void Compiler::patchInstruction(int index, int offset)
+{
+    QScriptInstruction &i = m_instructions[index];
+
+    switch (i.op) {
+        case QScriptInstruction::OP_Branch:
+        case QScriptInstruction::OP_BranchFalse:
+        case QScriptInstruction::OP_BranchTrue:
+            m_eng->newInteger(&i.operand[0], offset);
+            break;
+
+        default:
+            Q_ASSERT_X(0, "Compiler::patchInstruction()", "expected a branch instruction");
+            break;
+    }
+}
+
+bool Compiler::visit(AST::WithStatement *node)
+{
+    iLine(node);
+    node->expression->accept(this);
+    iEnterWith();
+    bool was = withStatement(true);
+    bool was2 = generateLeaveOnBreak(true);
+    node->statement->accept(this);
+    generateLeaveOnBreak(was2);
+    withStatement(was);
+    iLeaveWith();
+    return false;
+}
+
+bool Compiler::visit(AST::ArrayLiteral *node)
+{
+    iNewArray();
+
+    int length = 0;
+
+    for (AST::ElementList *it = node->elements; it != 0; it = it->next) {
+        for (AST::Elision *eit = it->elision; eit != 0; eit = eit->next) {
+            iDuplicate();
+            iLoadNumber(length);
+            iMakeReference();
+            iLoadUndefined();
+            iAssign();
+            iPop();
+            ++length;
+        }
+
+        if (it->expression) {
+            iDuplicate();
+            iLoadNumber(length);
+            iMakeReference();
+            it->expression->accept(this);
+            iAssign();
+            iPop();
+            ++length;
+        }
+    }
+
+    for (AST::Elision *eit = node->elision; eit != 0; eit = eit->next) {
+        iDuplicate();
+        iLoadNumber(length);
+        iMakeReference();
+        iLoadUndefined();
+        iAssign();
+        iPop();
+        ++length;
+    }
+
+    return false;
+}
+
+void Compiler::iLoadUndefined()
+{
+    pushInstruction(QScriptInstruction::OP_LoadUndefined);
+}
+
+void Compiler::iLoadThis()
+{
+    pushInstruction(QScriptInstruction::OP_LoadThis);
+}
+
+void Compiler::iLoadActivation()
+{
+    pushInstruction(QScriptInstruction::OP_LoadActivation);
+}
+
+void Compiler::iLoadNull()
+{
+    pushInstruction(QScriptInstruction::OP_LoadNull);
+}
+
+void Compiler::iLoadNumber(double number)
+{
+    QScriptValueImpl arg0(number);
+    pushInstruction(QScriptInstruction::OP_LoadNumber, arg0);
+}
+
+void Compiler::iLoadString(QScriptNameIdImpl *id)
+{
+    QScriptValueImpl arg0;
+    id->persistent = true;
+    m_eng->newNameId(&arg0, id);
+    pushInstruction(QScriptInstruction::OP_LoadString, arg0);
+}
+
+void Compiler::iDuplicate()
+{
+    pushInstruction(QScriptInstruction::OP_Duplicate);
+}
+
+void Compiler::iSwap()
+{
+    pushInstruction(QScriptInstruction::OP_Swap);
+}
+
+void Compiler::iResolve(QScriptNameIdImpl *id)
+{
+    QScriptValueImpl arg0;
+    id->persistent = true;
+    m_eng->newNameId(&arg0, id);
+    pushInstruction(QScriptInstruction::OP_Resolve, arg0);
+}
+
+void Compiler::iPutField()
+{
+    pushInstruction(QScriptInstruction::OP_PutField);
+}
+
+void Compiler::iCall(int argc)
+{
+    QScriptValueImpl arg0;
+    m_eng->newInteger(&arg0, argc);
+    pushInstruction(QScriptInstruction::OP_Call, arg0);
+}
+
+void Compiler::iNew(int argc)
+{
+    QScriptValueImpl arg0;
+    m_eng->newInteger(&arg0, argc);
+    pushInstruction(QScriptInstruction::OP_New, arg0);
+}
+
+void Compiler::iFetchField()
+{
+    pushInstruction(QScriptInstruction::OP_FetchField);
+}
+
+void Compiler::iLazyArguments()
+{
+    pushInstruction(QScriptInstruction::OP_LazyArguments);
+}
+
+void Compiler::iRet()
+{
+    pushInstruction(QScriptInstruction::OP_Ret);
+}
+
+void Compiler::iDeclareLocal(QScriptNameIdImpl *id, bool readOnly)
+{
+    QScriptValueImpl arg0;
+    id->persistent = true;
+    m_eng->newNameId(&arg0, id);
+    QScriptValueImpl arg1;
+    m_eng->newInteger(&arg1, readOnly);
+    pushInstruction(QScriptInstruction::OP_DeclareLocal, arg0, arg1);
+}
+
+void Compiler::iAssign()
+{
+    pushInstruction(QScriptInstruction::OP_Assign);
+}
+
+void Compiler::iBitAnd()
+{
+    pushInstruction(QScriptInstruction::OP_BitAnd);
+}
+
+void Compiler::iBitOr()
+{
+    pushInstruction(QScriptInstruction::OP_BitOr);
+}
+
+void Compiler::iBitXor()
+{
+    pushInstruction(QScriptInstruction::OP_BitXor);
+}
+
+void Compiler::iLeftShift()
+{
+    pushInstruction(QScriptInstruction::OP_LeftShift);
+}
+
+void Compiler::iMod()
+{
+    pushInstruction(QScriptInstruction::OP_Mod);
+}
+
+void Compiler::iRightShift()
+{
+    pushInstruction(QScriptInstruction::OP_RightShift);
+}
+
+void Compiler::iURightShift()
+{
+    pushInstruction(QScriptInstruction::OP_URightShift);
+}
+
+void Compiler::iAdd()
+{
+    pushInstruction(QScriptInstruction::OP_Add);
+}
+
+void Compiler::iDiv()
+{
+    pushInstruction(QScriptInstruction::OP_Div);
+}
+
+void Compiler::iEqual()
+{
+    pushInstruction(QScriptInstruction::OP_Equal);
+}
+
+void Compiler::iGreatOrEqual()
+{
+    pushInstruction(QScriptInstruction::OP_GreatOrEqual);
+}
+
+void Compiler::iGreatThan()
+{
+    pushInstruction(QScriptInstruction::OP_GreatThan);
+}
+
+void Compiler::iLessOrEqual()
+{
+    pushInstruction(QScriptInstruction::OP_LessOrEqual);
+}
+
+void Compiler::iLessThan()
+{
+    pushInstruction(QScriptInstruction::OP_LessThan);
+}
+
+void Compiler::iMul()
+{
+    pushInstruction(QScriptInstruction::OP_Mul);
+}
+
+void Compiler::iNotEqual()
+{
+    pushInstruction(QScriptInstruction::OP_NotEqual);
+}
+
+void Compiler::iSub()
+{
+    pushInstruction(QScriptInstruction::OP_Sub);
+}
+
+void Compiler::iStrictEqual()
+{
+    pushInstruction(QScriptInstruction::OP_StrictEqual);
+}
+
+void Compiler::iStrictNotEqual()
+{
+    pushInstruction(QScriptInstruction::OP_StrictNotEqual);
+}
+
+void Compiler::iBranch(int index)
+{
+    QScriptValueImpl arg0;
+    m_eng->newInteger(&arg0, index);
+    pushInstruction(QScriptInstruction::OP_Branch, arg0);
+}
+
+void Compiler::iBranchFalse(int index)
+{
+    QScriptValueImpl arg0;
+    m_eng->newInteger(&arg0, index);
+    pushInstruction(QScriptInstruction::OP_BranchFalse, arg0);
+}
+
+void Compiler::iBranchTrue(int index)
+{
+    QScriptValueImpl arg0;
+    m_eng->newInteger(&arg0, index);
+    pushInstruction(QScriptInstruction::OP_BranchTrue, arg0);
+}
+
+void Compiler::iNewClosure(AST::FunctionExpression *expr)
+{
+    QScriptValueImpl arg0;
+    m_eng->newPointer(&arg0, expr);
+
+    pushInstruction(QScriptInstruction::OP_NewClosure, arg0);
+}
+
+void Compiler::iIncr()
+{
+    pushInstruction(QScriptInstruction::OP_Incr);
+}
+
+void Compiler::iDecr()
+{
+    pushInstruction(QScriptInstruction::OP_Decr);
+}
+
+void Compiler::iPop()
+{
+    pushInstruction(QScriptInstruction::OP_Pop);
+}
+
+void Compiler::iFetch(QScriptNameIdImpl *id)
+{
+    if (m_generateFastArgumentLookup) {
+        int index = m_formals.indexOf(id);
+
+        if (index != -1) {
+            QScriptValueImpl arg0;
+            m_eng->newInteger(&arg0, index);
+            pushInstruction(QScriptInstruction::OP_Receive, arg0);
+            return;
+        }
+    }
+
+    QScriptValueImpl arg0;
+    id->persistent = true;
+    m_eng->newNameId(&arg0, id);
+    pushInstruction(QScriptInstruction::OP_Fetch, arg0);
+}
+
+void Compiler::iLoadTrue()
+{
+    pushInstruction(QScriptInstruction::OP_LoadTrue);
+}
+
+void Compiler::iLoadFalse()
+{
+    pushInstruction(QScriptInstruction::OP_LoadFalse);
+}
+
+void Compiler::iUnaryMinus()
+{
+    pushInstruction(QScriptInstruction::OP_UnaryMinus);
+}
+
+void Compiler::iUnaryPlus()
+{
+    pushInstruction(QScriptInstruction::OP_UnaryPlus);
+}
+
+void Compiler::iPostIncr()
+{
+    pushInstruction(QScriptInstruction::OP_PostIncr);
+}
+
+void Compiler::iPostDecr()
+{
+    pushInstruction(QScriptInstruction::OP_PostDecr);
+}
+
+void Compiler::iNewArray()
+{
+    pushInstruction(QScriptInstruction::OP_NewArray);
+}
+
+void Compiler::iNewObject()
+{
+    pushInstruction(QScriptInstruction::OP_NewObject);
+}
+
+void Compiler::iTypeOf()
+{
+    pushInstruction(QScriptInstruction::OP_TypeOf);
+}
+
+void Compiler::iDelete()
+{
+    pushInstruction(QScriptInstruction::OP_Delete);
+}
+
+void Compiler::iInstanceOf()
+{
+    pushInstruction(QScriptInstruction::OP_InstanceOf);
+}
+
+void Compiler::iInplaceAnd()
+{
+    pushInstruction(QScriptInstruction::OP_InplaceAnd);
+}
+
+void Compiler::iInplaceSub()
+{
+    pushInstruction(QScriptInstruction::OP_InplaceSub);
+}
+
+void Compiler::iInplaceDiv()
+{
+    pushInstruction(QScriptInstruction::OP_InplaceDiv);
+}
+
+void Compiler::iInplaceAdd()
+{
+    pushInstruction(QScriptInstruction::OP_InplaceAdd);
+}
+
+void Compiler::iInplaceLeftShift()
+{
+    pushInstruction(QScriptInstruction::OP_InplaceLeftShift);
+}
+
+void Compiler::iInplaceMod()
+{
+    pushInstruction(QScriptInstruction::OP_InplaceMod);
+}
+
+void Compiler::iInplaceMul()
+{
+    pushInstruction(QScriptInstruction::OP_InplaceMul);
+}
+
+void Compiler::iInplaceOr()
+{
+    pushInstruction(QScriptInstruction::OP_InplaceOr);
+}
+
+void Compiler::iInplaceRightShift()
+{
+    pushInstruction(QScriptInstruction::OP_InplaceRightShift);
+}
+
+void Compiler::iInplaceURightShift()
+{
+    pushInstruction(QScriptInstruction::OP_InplaceURightShift);
+}
+
+void Compiler::iInplaceXor()
+{
+    pushInstruction(QScriptInstruction::OP_InplaceXor);
+}
+
+void Compiler::iThrow()
+{
+    pushInstruction(QScriptInstruction::OP_Throw);
+}
+
+void Compiler::iLine(AST::Node *node)
+{
+    if (! node)
+        return;
+
+    QScriptValueImpl arg0;
+    m_eng->newInteger(&arg0, node->startLine);
+
+    QScriptValueImpl arg1;
+    m_eng->newInteger(&arg1, node->startColumn);
+
+    pushInstruction(QScriptInstruction::OP_Line, arg0, arg1);
+}
+
+void Compiler::iBitNot()
+{
+    pushInstruction(QScriptInstruction::OP_BitNot);
+}
+
+void Compiler::iNot()
+{
+    pushInstruction(QScriptInstruction::OP_Not);
+}
+
+void Compiler::iNewRegExp(QScriptNameIdImpl *pattern)
+{
+    QScriptValueImpl arg0;
+    pattern->persistent = true;
+    m_eng->newNameId(&arg0, pattern);
+    pushInstruction(QScriptInstruction::OP_NewRegExp, arg0);
+}
+
+void Compiler::iNewRegExp(QScriptNameIdImpl *pattern, int flags)
+{
+    QScriptValueImpl arg0;
+    pattern->persistent = true;
+    m_eng->newNameId(&arg0, pattern);
+
+    QScriptValueImpl arg1;
+    m_eng->newInteger(&arg1, flags);
+
+    pushInstruction(QScriptInstruction::OP_NewRegExp, arg0, arg1);
+}
+
+void Compiler::iNewEnumeration()
+{
+    pushInstruction(QScriptInstruction::OP_NewEnumeration);
+}
+
+void Compiler::iToFirstElement()
+{
+    pushInstruction(QScriptInstruction::OP_ToFirstElement);
+}
+
+void Compiler::iHasNextElement()
+{
+    pushInstruction(QScriptInstruction::OP_HasNextElement);
+}
+
+void Compiler::iNextElement()
+{
+    pushInstruction(QScriptInstruction::OP_NextElement);
+}
+
+void Compiler::iEnterWith()
+{
+    pushInstruction(QScriptInstruction::OP_EnterWith);
+}
+
+void Compiler::iLeaveWith()
+{
+    pushInstruction(QScriptInstruction::OP_LeaveWith);
+}
+
+void Compiler::iBeginCatch(QScriptNameIdImpl *id)
+{
+    QScriptValueImpl arg0;
+    id->persistent = true;
+    m_eng->newNameId(&arg0, id);
+    pushInstruction(QScriptInstruction::OP_BeginCatch, arg0);
+}
+
+void Compiler::iEndCatch()
+{
+    pushInstruction(QScriptInstruction::OP_EndCatch);
+}
+
+void Compiler::iSync()
+{
+    pushInstruction(QScriptInstruction::OP_Sync);
+}
+
+void Compiler::iHalt()
+{
+    pushInstruction(QScriptInstruction::OP_Halt);
+}
+
+void Compiler::iMakeReference()
+{
+    pushInstruction(QScriptInstruction::OP_MakeReference);
+}
+
+void Compiler::iIn()
+{
+    pushInstruction(QScriptInstruction::OP_In);
+}
+
+void Compiler::iNop()
+{
+    pushInstruction(QScriptInstruction::OP_Nop);
+}
+
+void Compiler::iNewString(QScriptNameIdImpl *id)
+{
+    QScriptValueImpl arg0;
+    id->persistent = true;
+    m_eng->newNameId(&arg0, id);
+    pushInstruction(QScriptInstruction::OP_NewString, arg0);
+}
+
+void Compiler::iDebugger()
+{
+    pushInstruction(QScriptInstruction::OP_Debugger);
+}
+
+Compiler::Loop *Compiler::findLoop(QScriptNameIdImpl *name)
+{
+    if (! name)
+        return m_activeLoop;
+
+    QMap<AST::Statement*, Loop>::iterator it = m_loops.begin();
+
+    for (; it != m_loops.end(); ++it) {
+        Loop &loop = *it;
+
+        if (loop.name == name)
+            return &loop;
+    }
+
+    return 0;
+}
+
+
+} // namespace QScript
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_SCRIPT