/****************************************************************************

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (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 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 "config.h"

#include "qscriptengine.h"

#include "qscriptsyntaxchecker_p.h"

#include "qnumeric.h"

#include "qscriptengine_p.h"

#include "qscriptengineagent_p.h"

#include "qscriptcontext_p.h"

#include "qscriptstring_p.h"

#include "qscriptvalue_p.h"

#include "qscriptvalueiterator.h"

#include "qscriptclass.h"

#include "qdebug.h"

#include <QtCore/qstringlist.h>

#include <QtCore/qmetaobject.h>

#include "Error.h"

#include "JSArray.h"

#include "JSLock.h"

#include "Interpreter.h"

#include "DateConstructor.h"

#include "RegExpConstructor.h"

#include "PrototypeFunction.h"

#include "InitializeThreading.h"

#include "ObjectPrototype.h"

#include "SourceCode.h"

#include "FunctionPrototype.h"

#include "TimeoutChecker.h"

#include "JSFunction.h"

#include "Parser.h"

#include "Operations.h"

#include "utils/qscriptdate_p.h"

#include "bridge/qscriptfunction_p.h"

#include "bridge/qscriptobject_p.h"

#include "bridge/qscriptclassobject_p.h"

#include "bridge/qscriptvariant_p.h"

#include "bridge/qscriptqobject_p.h"

#include "bridge/qscriptglobalobject_p.h"

#include "bridge/qscriptactivationobject_p.h"

#ifndef QT_NO_QOBJECT

#include <QtCore/qcoreapplication.h>

#include <QtCore/qdir.h>

#include <QtCore/qfile.h>

#include <QtCore/qfileinfo.h>

#include <QtCore/qpluginloader.h>

#include <QtCore/qset.h>

#include <QtCore/qtextstream.h>

#include "qscriptextensioninterface.h"

#endif

Q_DECLARE_METATYPE(QScriptValue)

#ifndef QT_NO_QOBJECT

Q_DECLARE_METATYPE(QObjectList)

#endif

Q_DECLARE_METATYPE(QList<int>)

QT_BEGIN_NAMESPACE

/*!

  \since 4.3

  \class QScriptEngine

  \reentrant

  \brief The QScriptEngine class provides an environment for evaluating Qt Script code.

  \ingroup script

  \mainclass

  See the \l{QtScript} documentation for information about the Qt Script language,

  and how to get started with scripting your C++ application.

  \section1 Evaluating Scripts

  Use evaluate() to evaluate script code; this is the C++ equivalent

  of the built-in script function \c{eval()}.

  \snippet doc/src/snippets/code/src_script_qscriptengine.cpp 0

  evaluate() returns a QScriptValue that holds the result of the

  evaluation. The QScriptValue class provides functions for converting

  the result to various C++ types (e.g. QScriptValue::toString()

  and QScriptValue::toNumber()).

  The following code snippet shows how a script function can be

  defined and then invoked from C++ using QScriptValue::call():

  \snippet doc/src/snippets/code/src_script_qscriptengine.cpp 1

  As can be seen from the above snippets, a script is provided to the

  engine in the form of a string. One common way of loading scripts is

  by reading the contents of a file and passing it to evaluate():

  \snippet doc/src/snippets/code/src_script_qscriptengine.cpp 2

  Here we pass the name of the file as the second argument to

  evaluate().  This does not affect evaluation in any way; the second

  argument is a general-purpose string that is used to identify the

  script for debugging purposes (for example, our filename will now

  show up in any uncaughtExceptionBacktrace() involving the script).

  \section1 Engine Configuration

  The globalObject() function returns the \bold {Global Object}

  associated with the script engine. Properties of the Global Object

  are accessible from any script code (i.e. they are global

  variables). Typically, before evaluating "user" scripts, you will

  want to configure a script engine by adding one or more properties

  to the Global Object:

  \snippet doc/src/snippets/code/src_script_qscriptengine.cpp 3

  Adding custom properties to the scripting environment is one of the

  standard means of providing a scripting API that is specific to your

  application. Usually these custom properties are objects created by

  the newQObject() or newObject() functions, or constructor functions

  created by newFunction().

  \section1 Script Exceptions

  evaluate() can throw a script exception (e.g. due to a syntax

  error); in that case, the return value is the value that was thrown

  (typically an \c{Error} object). You can check whether the

  evaluation caused an exception by calling hasUncaughtException(). In

  that case, you can call toString() on the error object to obtain an

  error message. The current uncaught exception is also available

  through uncaughtException(). You can obtain a human-readable

  backtrace of the exception with uncaughtExceptionBacktrace().

  Calling clearExceptions() will cause any uncaught exceptions to be

  cleared.

  \snippet doc/src/snippets/code/src_script_qscriptengine.cpp 4

  The checkSyntax() function can be used to determine whether code can be

  usefully passed to evaluate().

  \section1 Script Object Creation

  Use newObject() to create a standard Qt Script object; this is the

  C++ equivalent of the script statement \c{new Object()}. You can use

  the object-specific functionality in QScriptValue to manipulate the

  script object (e.g. QScriptValue::setProperty()). Similarly, use

  newArray() to create a Qt Script array object. Use newDate() to

  create a \c{Date} object, and newRegExp() to create a \c{RegExp}

  object.

  \section1 QObject Integration

  Use newQObject() to wrap a QObject (or subclass)

  pointer. newQObject() returns a proxy script object; properties,

  children, and signals and slots of the QObject are available as

  properties of the proxy object. No binding code is needed because it

  is done dynamically using the Qt meta object system.

  \snippet doc/src/snippets/code/src_script_qscriptengine.cpp 5

  Use qScriptConnect() to connect a C++ signal to a script function;

  this is the Qt Script equivalent of QObject::connect().  When a

  script function is invoked in response to a C++ signal, it can cause

  a script exception; you can connect to the signalHandlerException()

  signal to catch such an exception.

  Use newQMetaObject() to wrap a QMetaObject; this gives you a "script

  representation" of a QObject-based class. newQMetaObject() returns a

  proxy script object; enum values of the class are available as

  properties of the proxy object. You can also specify a function that

  will be used to construct objects of the class (e.g.  when the

  constructor is invoked from a script). For classes that have a

  "standard" Qt constructor, Qt Script can provide a default script

  constructor for you; see scriptValueFromQMetaObject().

  See the \l{QtScript} documentation for more information on

  the QObject integration.

  \section1 Support for Custom C++ Types

  Use newVariant() to wrap a QVariant. This can be used to store

  values of custom (non-QObject) C++ types that have been registered

  with the Qt meta-type system. To make such types scriptable, you

  typically associate a prototype (delegate) object with the C++ type

  by calling setDefaultPrototype(); the prototype object defines the

  scripting API for the C++ type. Unlike the QObject integration,

  there is no automatic binding possible here; i.e. you have to create

  the scripting API yourself, for example by using the QScriptable

  class.

  Use fromScriptValue() to cast from a QScriptValue to another type,

  and toScriptValue() to create a QScriptValue from another value.

  You can specify how the conversion of C++ types is to be performed

  with qScriptRegisterMetaType() and qScriptRegisterSequenceMetaType().

  By default, Qt Script will use QVariant to store values of custom

  types.

  \section1 Importing Extensions

  Use importExtension() to import plugin-based extensions into the

  engine. Call availableExtensions() to obtain a list naming all the

  available extensions, and importedExtensions() to obtain a list

  naming only those extensions that have been imported.

  Call pushContext() to open up a new variable scope, and popContext()

  to close the current scope. This is useful if you are implementing

  an extension that evaluates script code containing temporary

  variable definitions (e.g. \c{var foo = 123;}) that are safe to

  discard when evaluation has completed.

  \section1 Native Functions

  Use newFunction() to wrap native (C++) functions, including

  constructors for your own custom types, so that these can be invoked

  from script code. Such functions must have the signature

  QScriptEngine::FunctionSignature. You may then pass the function as

  argument to newFunction(). Here is an example of a function that

  returns the sum of its first two arguments:

  \snippet doc/src/snippets/code/src_script_qscriptengine.cpp 6

  To expose this function to script code, you can set it as a property

  of the Global Object:

  \snippet doc/src/snippets/code/src_script_qscriptengine.cpp 7

  Once this is done, script code can call your function in the exact

  same manner as a "normal" script function:

  \snippet doc/src/snippets/code/src_script_qscriptengine.cpp 8

  \section1 Long-running Scripts

  If you need to evaluate possibly long-running scripts from the main

  (GUI) thread, you should first call setProcessEventsInterval() to

  make sure that the GUI stays responsive. You can abort a currently

  running script by calling abortEvaluation(). You can determine

  whether an engine is currently running a script by calling

  isEvaluating().

  \section1 Core Debugging/Tracing Facilities

  Since Qt 4.4, you can be notified of events pertaining to script

  execution (e.g. script function calls and statement execution)

  through the QScriptEngineAgent interface; see the setAgent()

  function. This can be used to implement debugging and profiling of a

  QScriptEngine.

  \sa QScriptValue, QScriptContext, QScriptEngineAgent

*/

/*!

    \enum QScriptEngine::ValueOwnership

    This enum specifies the ownership when wrapping a C++ value, e.g. by using newQObject().

    \value QtOwnership The standard Qt ownership rules apply, i.e. the associated object will never be explicitly deleted by the script engine. This is the default. (QObject ownership is explained in \l{Object Trees and Object Ownership}.)

    \value ScriptOwnership The value is owned by the script environment. The associated data will be deleted when appropriate (i.e. after the garbage collector has discovered that there are no more live references to the value).

    \value AutoOwnership If the associated object has a parent, the Qt ownership rules apply (QtOwnership); otherwise, the object is owned by the script environment (ScriptOwnership).

*/

/*!

    \enum  QScriptEngine::QObjectWrapOption

    These flags specify options when wrapping a QObject pointer with newQObject().

    \value ExcludeChildObjects The script object will not expose child objects as properties.

    \value ExcludeSuperClassMethods The script object will not expose signals and slots inherited from the superclass.

    \value ExcludeSuperClassProperties The script object will not expose properties inherited from the superclass.

    \value ExcludeSuperClassContents Shorthand form for ExcludeSuperClassMethods | ExcludeSuperClassProperties

    \value ExcludeDeleteLater The script object will not expose the QObject::deleteLater() slot.

    \value AutoCreateDynamicProperties Properties that don't already exist in the QObject will be created as dynamic properties of that object, rather than as properties of the script object.

    \value PreferExistingWrapperObject If a wrapper object with the requested configuration already exists, return that object.

    \value SkipMethodsInEnumeration Don't include methods (signals and slots) when enumerating the object's properties.

*/

class QScriptSyntaxCheckResultPrivate

{

public:

    QScriptSyntaxCheckResultPrivate() { ref = 0; }

    ~QScriptSyntaxCheckResultPrivate() {}

    QScriptSyntaxCheckResult::State state;

    int errorColumnNumber;

    int errorLineNumber;

    QString errorMessage;

    QBasicAtomicInt ref;

};

class QScriptTypeInfo

{

public:

    QScriptTypeInfo() : signature(0, '\0'), marshal(0), demarshal(0)

    { }

    QByteArray signature;

    QScriptEngine::MarshalFunction marshal;

    QScriptEngine::DemarshalFunction demarshal;

    JSC::JSValue prototype;

};

namespace QScript

{

void GlobalClientData::mark(JSC::MarkStack& markStack)

{

    engine->mark(markStack);

}

class TimeoutCheckerProxy : public JSC::TimeoutChecker

{

public:

    TimeoutCheckerProxy(const JSC::TimeoutChecker& originalChecker)

        : JSC::TimeoutChecker(originalChecker)

        , m_shouldProcessEvents(false)

        , m_shouldAbortEvaluation(false)

    {}

    void setShouldProcessEvents(bool shouldProcess) { m_shouldProcessEvents = shouldProcess; }

    void setShouldAbort(bool shouldAbort) { m_shouldAbortEvaluation = shouldAbort; }

    bool shouldAbort() { return m_shouldAbortEvaluation; }

    virtual bool didTimeOut(JSC::ExecState* exec)

    {

        if (JSC::TimeoutChecker::didTimeOut(exec))

            return true;

        if (m_shouldProcessEvents)

            QCoreApplication::processEvents();

        return m_shouldAbortEvaluation;

    }

private:

    bool m_shouldProcessEvents;

    bool m_shouldAbortEvaluation;

};

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;

}

qsreal integerFromString(const char *buf, int size, int radix)

{

    if (size == 0)

        return qSNaN();

    qsreal 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;

    }

    qsreal result;

    if (j == i) {

        if (!qstrcmp(buf, "Infinity"))

            result = qInf();

        else

            result = qSNaN();

    } else {

        result = 0;

        qsreal multiplier = 1;

        for (--i ; i >= j; --i, multiplier *= radix)

            result += toDigit(buf[i]) * multiplier;

    }

    result *= sign;

    return result;

}

qsreal integerFromString(const QString &str, int radix)

{

    QByteArray ba = str.trimmed().toUtf8();

    return integerFromString(ba.constData(), ba.size(), radix);

}

bool isFunction(JSC::JSValue value)

{

    if (!value || !value.isObject())

        return false;

    JSC::CallData callData;

    return (JSC::asObject(value)->getCallData(callData) != JSC::CallTypeNone);

}

static JSC::JSValue JSC_HOST_CALL functionConnect(JSC::ExecState*, JSC::JSObject*, JSC::JSValue, const JSC::ArgList&);

static JSC::JSValue JSC_HOST_CALL functionDisconnect(JSC::ExecState*, JSC::JSObject*, JSC::JSValue, const JSC::ArgList&);

JSC::JSValue JSC_HOST_CALL functionDisconnect(JSC::ExecState *exec, JSC::JSObject * /*callee*/, JSC::JSValue thisObject, const JSC::ArgList &args)

{

#ifndef QT_NO_QOBJECT

    if (args.size() == 0) {

        return JSC::throwError(exec, JSC::GeneralError, "Function.prototype.disconnect: no arguments given");

    }

    if (!JSC::asObject(thisObject)->inherits(&QScript::QtFunction::info)) {

        return JSC::throwError(exec, JSC::TypeError, "Function.prototype.disconnect: this object is not a signal");

    }

    QScript::QtFunction *qtSignal = static_cast<QScript::QtFunction*>(JSC::asObject(thisObject));

    const QMetaObject *meta = qtSignal->metaObject();

    if (!meta) {

        return JSC::throwError(exec, JSC::TypeError, "Function.prototype.discconnect: cannot disconnect from deleted QObject");

    }

    QMetaMethod sig = meta->method(qtSignal->initialIndex());

    if (sig.methodType() != QMetaMethod::Signal) {

        QString message = QString::fromLatin1("Function.prototype.disconnect: %0::%1 is not a signal")

                          .arg(QLatin1String(qtSignal->metaObject()->className()))

                          .arg(QLatin1String(sig.signature()));

        return JSC::throwError(exec, JSC::TypeError, message);

    }

    QScriptEnginePrivate *engine = scriptEngineFromExec(exec);

    JSC::JSValue receiver;

    JSC::JSValue slot;

    JSC::JSValue arg0 = args.at(0);

    if (args.size() < 2) {

        slot = arg0;

    } else {

        receiver = arg0;

        JSC::JSValue arg1 = args.at(1);

        if (isFunction(arg1))

            slot = arg1;

        else {

            // ### don't go via QScriptValue

            QScript::SaveFrameHelper saveFrame(engine, exec);

            QScriptValue tmp = engine->scriptValueFromJSCValue(arg0);

            QString propertyName(arg1.toString(exec));

            slot = engine->scriptValueToJSCValue(tmp.property(propertyName, QScriptValue::ResolvePrototype));

        }

    }

    if (!isFunction(slot)) {

        return JSC::throwError(exec, JSC::TypeError, "Function.prototype.disconnect: target is not a function");

    }

    bool ok = engine->scriptDisconnect(thisObject, receiver, slot);

    if (!ok) {

        QString message = QString::fromLatin1("Function.prototype.disconnect: failed to disconnect from %0::%1")

                          .arg(QLatin1String(qtSignal->metaObject()->className()))

                          .arg(QLatin1String(sig.signature()));

        return JSC::throwError(exec, JSC::GeneralError, message);

    }

    return JSC::jsUndefined();

#else

    Q_UNUSED(eng);

    return context->throwError(QScriptContext::TypeError,

                               QLatin1String("Function.prototype.disconnect"));

#endif // QT_NO_QOBJECT

}

JSC::JSValue JSC_HOST_CALL functionConnect(JSC::ExecState *exec, JSC::JSObject * /*callee*/, JSC::JSValue thisObject, const JSC::ArgList &args)

{