Say hello to QScriptProgram :-)

QScriptProgram encapsulates a Qt Script program (AKA a script).
It retains the compiled representation of the script, so that
repeated evaluation of the same script becomes faster.

An overload of QScriptEngine::evaluate() that takes a QScriptProgram
has been added.

Reviewed-by: Olivier Goffart

2 files changed, 235 insertions, 0 deletions

diff --git a/tests/auto/qscriptengine/tst_qscriptengine.cpp b/tests/auto/qscriptengine/tst_qscriptengine.cpp
index 25ee00f..804534f 100644
--- a/tests/auto/qscriptengine/tst_qscriptengine.cpp
+++ b/tests/auto/qscriptengine/tst_qscriptengine.cpp
@@ -44,6 +44,7 @@
 
 #include <qscriptengine.h>
 #include <qscriptengineagent.h>
+#include <qscriptprogram.h>
 #include <qscriptvalueiterator.h>
 #include <qgraphicsitem.h>
 #include <qstandarditemmodel.h>
@@ -52,6 +53,7 @@
 
 Q_DECLARE_METATYPE(QList<int>)
 Q_DECLARE_METATYPE(QObjectList)
+Q_DECLARE_METATYPE(QScriptProgram)
 
 //TESTED_CLASS=
 //TESTED_FILES=
@@ -151,6 +153,7 @@ private slots:
     void installTranslatorFunctions();
     void functionScopes();
     void nativeFunctionScopes();
+    void evaluateProgram();
 
     void qRegExpInport_data();
     void qRegExpInport();
@@ -4289,6 +4292,152 @@ void tst_QScriptEngine::nativeFunctionScopes()
     }
 }
 
+static QScriptValue createProgram(QScriptContext *ctx, QScriptEngine *eng)
+{
+    QString code = ctx->argument(0).toString();
+    QScriptProgram result(code);
+    return qScriptValueFromValue(eng, result);
+}
+
+void tst_QScriptEngine::evaluateProgram()
+{
+    QScriptEngine eng;
+
+    {
+        QString code("1 + 2");
+        QString fileName("hello.js");
+        int lineNumber(123);
+        QScriptProgram program(code, fileName, lineNumber);
+        QVERIFY(!program.isNull());
+        QCOMPARE(program.sourceCode(), code);
+        QCOMPARE(program.fileName(), fileName);
+        QCOMPARE(program.firstLineNumber(), lineNumber);
+
+        QScriptValue expected = eng.evaluate(code);
+        for (int x = 0; x < 10; ++x) {
+            QScriptValue ret = eng.evaluate(program);
+            QVERIFY(ret.equals(expected));
+        }
+
+        // operator=
+        QScriptProgram sameProgram = program;
+        QVERIFY(sameProgram == program);
+        QVERIFY(eng.evaluate(sameProgram).equals(expected));
+
+        // copy constructor
+        QScriptProgram sameProgram2(program);
+        QVERIFY(sameProgram2 == program);
+        QVERIFY(eng.evaluate(sameProgram2).equals(expected));
+
+        QScriptProgram differentProgram("2 + 3");
+        QVERIFY(differentProgram != program);
+        QVERIFY(!eng.evaluate(differentProgram).equals(expected));
+    }
+
+    // Program that accesses variable in the scope
+    {
+        QScriptProgram program("a");
+        QVERIFY(!program.isNull());
+        {
+            QScriptValue ret = eng.evaluate(program);
+            QVERIFY(ret.isError());
+            QCOMPARE(ret.toString(), QString::fromLatin1("ReferenceError: Can't find variable: a"));
+        }
+
+        QScriptValue obj = eng.newObject();
+        obj.setProperty("a", 123);
+        QScriptContext *ctx = eng.currentContext();
+        ctx->pushScope(obj);
+        {
+            QScriptValue ret = eng.evaluate(program);
+            QVERIFY(!ret.isError());
+            QVERIFY(ret.equals(obj.property("a")));
+        }
+
+        obj.setProperty("a", QScriptValue());
+        {
+            QScriptValue ret = eng.evaluate(program);
+            QVERIFY(ret.isError());
+        }
+
+        QScriptValue obj2 = eng.newObject();
+        obj2.setProperty("a", 456);
+        ctx->pushScope(obj2);
+        {
+            QScriptValue ret = eng.evaluate(program);
+            QVERIFY(!ret.isError());
+            QVERIFY(ret.equals(obj2.property("a")));
+        }
+
+        ctx->popScope();
+    }
+
+    // Program that creates closure
+    {
+        QScriptProgram program("(function() { var count = 0; return function() { return count++; }; })");
+        QVERIFY(!program.isNull());
+        QScriptValue createCounter = eng.evaluate(program);
+        QVERIFY(createCounter.isFunction());
+        QScriptValue counter = createCounter.call();
+        QVERIFY(counter.isFunction());
+        {
+            QScriptValue ret = counter.call();
+            QVERIFY(ret.isNumber());
+        }
+        QScriptValue counter2 = createCounter.call();
+        QVERIFY(counter2.isFunction());
+        QVERIFY(!counter2.equals(counter));
+        {
+            QScriptValue ret = counter2.call();
+            QVERIFY(ret.isNumber());
+        }
+    }
+
+    // Program created in a function call, then executed later
+    {
+        QScriptValue fun = eng.newFunction(createProgram);
+        QScriptProgram program = qscriptvalue_cast<QScriptProgram>(
+            fun.call(QScriptValue(), QScriptValueList() << "a + 1"));
+        QVERIFY(!program.isNull());
+        eng.globalObject().setProperty("a", QScriptValue());
+        {
+            QScriptValue ret = eng.evaluate(program);
+            QVERIFY(ret.isError());
+            QCOMPARE(ret.toString(), QString::fromLatin1("ReferenceError: Can't find variable: a"));
+        }
+        eng.globalObject().setProperty("a", 122);
+        {
+            QScriptValue ret = eng.evaluate(program);
+            QVERIFY(!ret.isError());
+            QVERIFY(ret.isNumber());
+            QCOMPARE(ret.toInt32(), 123);
+        }
+    }
+
+    // Same program run in different engines
+    {
+        QString code("1 + 2");
+        QScriptProgram program(code);
+        QVERIFY(!program.isNull());
+        double expected = eng.evaluate(program).toNumber();
+        for (int x = 0; x < 2; ++x) {
+            QScriptEngine eng2;
+            for (int y = 0; y < 2; ++y) {
+                double ret = eng2.evaluate(program).toNumber();
+                QCOMPARE(ret, expected);
+            }
+        }
+    }
+
+    // No program
+    {
+        QScriptProgram program;
+        QVERIFY(program.isNull());
+        QScriptValue ret = eng.evaluate(program);
+        QVERIFY(!ret.isValid());
+    }
+}
+
 static QRegExp minimal(QRegExp r) { r.setMinimal(true); return r; }
 
 void tst_QScriptEngine::qRegExpInport_data()
diff --git a/tests/auto/qscriptengineagent/tst_qscriptengineagent.cpp b/tests/auto/qscriptengineagent/tst_qscriptengineagent.cpp
index 82c8ccd..032c34b 100644
--- a/tests/auto/qscriptengineagent/tst_qscriptengineagent.cpp
+++ b/tests/auto/qscriptengineagent/tst_qscriptengineagent.cpp
@@ -44,6 +44,7 @@
 
 #include <QtScript/qscriptengineagent.h>
 #include <QtScript/qscriptengine.h>
+#include <QtScript/qscriptprogram.h>
 #include <qscriptvalueiterator.h>
 
 //TESTED_CLASS=
@@ -110,6 +111,9 @@ private slots:
     void extension();
     void isEvaluatingInExtension();
     void hasUncaughtException();
+    void evaluateProgram();
+    void evaluateProgram_SyntaxError();
+    void evaluateNullProgram();
 
 private:
     double m_testProperty;
@@ -2219,6 +2223,88 @@ void tst_QScriptEngineAgent::hasUncaughtException()
   QVERIFY2(spy->isPass(), "At least one of a functionExit event should set hasUncaughtException flag.");
 }
 
+void tst_QScriptEngineAgent::evaluateProgram()
+{
+    QScriptEngine eng;
+    QScriptProgram program("1 + 2", "foo.js", 123);
+    ScriptEngineSpy *spy = new ScriptEngineSpy(&eng);
+    qint64 scriptId = -1;
+    for (int x = 0; x < 10; ++x) {
+        spy->clear();
+        (void)eng.evaluate(program);
+        QCOMPARE(spy->count(), (x == 0) ? 4 : 3);
+
+        if (x == 0) {
+            // script is only loaded on first execution
+            QCOMPARE(spy->at(0).type, ScriptEngineEvent::ScriptLoad);
+            scriptId = spy->at(0).scriptId;
+            QVERIFY(scriptId != -1);
+            QCOMPARE(spy->at(0).script, program.sourceCode());
+            QCOMPARE(spy->at(0).fileName, program.fileName());
+            QCOMPARE(spy->at(0).lineNumber, program.firstLineNumber());
+            spy->removeFirst();
+        }
+
+        QCOMPARE(spy->at(0).type, ScriptEngineEvent::FunctionEntry); // evaluate()
+        QCOMPARE(spy->at(0).scriptId, scriptId);
+
+        QCOMPARE(spy->at(1).type, ScriptEngineEvent::PositionChange);
+        QCOMPARE(spy->at(1).scriptId, scriptId);
+        QCOMPARE(spy->at(1).lineNumber, program.firstLineNumber());
+
+        QCOMPARE(spy->at(2).type, ScriptEngineEvent::FunctionExit); // evaluate()
+        QCOMPARE(spy->at(2).scriptId, scriptId);
+        QVERIFY(spy->at(2).value.isNumber());
+        QCOMPARE(spy->at(2).value.toNumber(), qsreal(3));
+    }
+}
+
+void tst_QScriptEngineAgent::evaluateProgram_SyntaxError()
+{
+    QScriptEngine eng;
+    QScriptProgram program("this is not valid syntax", "foo.js", 123);
+    ScriptEngineSpy *spy = new ScriptEngineSpy(&eng);
+    qint64 scriptId = -1;
+    for (int x = 0; x < 10; ++x) {
+        spy->clear();
+        (void)eng.evaluate(program);
+        QCOMPARE(spy->count(), (x == 0) ? 8 : 7);
+
+        if (x == 0) {
+            // script is only loaded on first execution
+            QCOMPARE(spy->at(0).type, ScriptEngineEvent::ScriptLoad);
+            scriptId = spy->at(0).scriptId;
+            QVERIFY(scriptId != -1);
+            QCOMPARE(spy->at(0).script, program.sourceCode());
+            QCOMPARE(spy->at(0).fileName, program.fileName());
+            QCOMPARE(spy->at(0).lineNumber, program.firstLineNumber());
+            spy->removeFirst();
+        }
+
+        QCOMPARE(spy->at(0).type, ScriptEngineEvent::FunctionEntry); // evaluate()
+        QCOMPARE(spy->at(0).scriptId, scriptId);
+
+        QCOMPARE(spy->at(1).type, ScriptEngineEvent::ContextPush); // SyntaxError constructor
+        QCOMPARE(spy->at(2).type, ScriptEngineEvent::FunctionEntry); // SyntaxError constructor
+        QCOMPARE(spy->at(3).type, ScriptEngineEvent::FunctionExit); // SyntaxError constructor
+        QCOMPARE(spy->at(4).type, ScriptEngineEvent::ContextPop); // SyntaxError constructor
+
+        QCOMPARE(spy->at(5).type, ScriptEngineEvent::ExceptionThrow);
+        QVERIFY(spy->at(5).value.isError());
+        QCOMPARE(spy->at(5).value.toString(), QString::fromLatin1("SyntaxError: Parse error"));
+
+        QCOMPARE(spy->at(6).type, ScriptEngineEvent::FunctionExit); // evaluate()
+        QCOMPARE(spy->at(6).scriptId, scriptId);
+    }
+}
+
+void tst_QScriptEngineAgent::evaluateNullProgram()
+{
+    QScriptEngine eng;
+    ScriptEngineSpy *spy = new ScriptEngineSpy(&eng);
+    (void)eng.evaluate(QScriptProgram());
+    QCOMPARE(spy->count(), 0);
+}
 
 QTEST_MAIN(tst_QScriptEngineAgent)
 #include "tst_qscriptengineagent.moc"