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

**

** Copyright (C) 2010 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-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$

**

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

#ifndef QSCRIPTENGINE_P_H

#define QSCRIPTENGINE_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/qobject_p.h"

#include <QtCore/qdatetime.h>

#include <QtCore/qhash.h>

#include <QtCore/qnumeric.h>

#include <QtCore/qregexp.h>

#include <QtCore/qset.h>

#include "qscriptvalue_p.h"

#include "qscriptstring_p.h"

#include "bridge/qscriptclassobject_p.h"

#include "bridge/qscriptdeclarativeclass_p.h"

#include "bridge/qscriptdeclarativeobject_p.h"

#include "bridge/qscriptobject_p.h"

#include "bridge/qscriptqobject_p.h"

#include "bridge/qscriptvariant_p.h"

#include "DateConstructor.h"

#include "DateInstance.h"

#include "Debugger.h"

#include "ErrorInstance.h"

#include "JSArray.h"

#include "Lexer.h"

#include "RefPtr.h"

#include "RegExpConstructor.h"

#include "RegExpObject.h"

#include "SourceProvider.h"

#include "Structure.h"

#include "UString.h"

#include "JSGlobalObject.h"

#include "JSValue.h"

namespace JSC

{

    class EvalExecutable;

    class ExecState;

    typedef ExecState CallFrame;

    class JSCell;

    class JSGlobalObject;

}

QT_BEGIN_NAMESPACE

class QString;

class QStringList;

class QScriptContext;

class QScriptValue;

class QScriptTypeInfo;

class QScriptEngineAgent;

class QScriptEnginePrivate;

class QScriptSyntaxCheckResult;

class QScriptEngine;

namespace QScript

{

    class QObjectPrototype;

    class QMetaObjectPrototype;

    class QVariantPrototype;

#ifndef QT_NO_QOBJECT

    class QObjectData;

#endif

    class TimeoutCheckerProxy;

    qint32 ToInt32(qsreal);

    quint32 ToUInt32(qsreal);

    quint16 ToUInt16(qsreal);

    qsreal ToInteger(qsreal);

    inline bool ToBool(qsreal);

    inline bool ToBool(const QString &);

    inline qint32 ToInt32(const QString &);

    inline quint32 ToUInt32(const QString &);

    inline quint16 ToUInt16(const QString &);

    inline qsreal ToInteger(const QString &);

#ifdef Q_CC_MSVC

    // MSVC2008 crashes if these are inlined.

    qsreal ToNumber(const QString &);

    QString ToString(qsreal);

#else

    inline qsreal ToNumber(const QString &);

    inline QString ToString(qsreal);

#endif

    QDateTime MsToDateTime(JSC::ExecState *, qsreal);

    qsreal DateTimeToMs(JSC::ExecState *, const QDateTime &);

    //some conversion helper functions

    inline QScriptEnginePrivate *scriptEngineFromExec(const JSC::ExecState *exec);

    bool isFunction(JSC::JSValue value);

    inline void convertToLatin1_helper(const UChar *i, int length, char *s);

    inline QByteArray convertToLatin1(const JSC::UString &str);

    class UStringSourceProviderWithFeedback;

struct GlobalClientData : public JSC::JSGlobalData::ClientData

{

    GlobalClientData(QScriptEnginePrivate *e)

        : engine(e) {}

    virtual ~GlobalClientData() {}

    virtual void mark(JSC::MarkStack& markStack);

    QScriptEnginePrivate *engine;

};

} // namespace QScript

class QScriptEnginePrivate

#ifndef QT_NO_QOBJECT

    : public QObjectPrivate

#endif

{

    Q_DECLARE_PUBLIC(QScriptEngine)

public:

    QScriptEnginePrivate();

    virtual ~QScriptEnginePrivate();

    static QScriptEnginePrivate *get(QScriptEngine *q) { return q ? q->d_func() : 0; }

    static QScriptEngine *get(QScriptEnginePrivate *d) { return d ? d->q_func() : 0; }

    static inline bool isArray(JSC::JSValue);

    static inline bool isDate(JSC::JSValue);

    static inline bool isError(JSC::JSValue);

    static inline bool isObject(JSC::JSValue);

    static inline bool isRegExp(JSC::JSValue);

    static inline bool isVariant(JSC::JSValue);

    static inline bool isQObject(JSC::JSValue);

    static inline bool isQMetaObject(JSC::JSValue);

    static inline bool toBool(JSC::ExecState *, JSC::JSValue);

    static inline qsreal toInteger(JSC::ExecState *, JSC::JSValue);

    static inline qsreal toNumber(JSC::ExecState *, JSC::JSValue);

    static inline qint32 toInt32(JSC::ExecState *, JSC::JSValue);

    static inline quint32 toUInt32(JSC::ExecState *, JSC::JSValue);

    static inline quint16 toUInt16(JSC::ExecState *, JSC::JSValue);

    static inline JSC::UString toString(JSC::ExecState *, JSC::JSValue);

    static inline QDateTime toDateTime(JSC::ExecState *, JSC::JSValue);

#ifndef QT_NO_REGEXP

    static QRegExp toRegExp(JSC::ExecState*, JSC::JSValue);

#endif

    static QVariant toVariant(JSC::ExecState *, JSC::JSValue);

    static inline QObject *toQObject(JSC::ExecState *, JSC::JSValue);

    static inline const QMetaObject *toQMetaObject(JSC::ExecState *, JSC::JSValue);

    static inline JSC::JSValue property(JSC::ExecState*, JSC::JSValue, const JSC::Identifier &id,

                                 int resolveMode = QScriptValue::ResolvePrototype);

    static JSC::JSValue propertyHelper(JSC::ExecState*, JSC::JSValue, const JSC::Identifier &id, int resolveMode);

    static inline JSC::JSValue property(JSC::ExecState*, JSC::JSValue, quint32 index,

                                 int resolveMode = QScriptValue::ResolvePrototype);

    static JSC::JSValue propertyHelper(JSC::ExecState*, JSC::JSValue, quint32, int resolveMode);

    static inline JSC::JSValue property(JSC::ExecState*, JSC::JSValue, const JSC::UString &, int resolveMode);

    static inline void setProperty(JSC::ExecState*, JSC::JSValue object, const JSC::UString &name, JSC::JSValue,

                     const QScriptValue::PropertyFlags &flags = QScriptValue::KeepExistingFlags);

    static void setProperty(JSC::ExecState*, JSC::JSValue object, const JSC::Identifier &id, JSC::JSValue,

                     const QScriptValue::PropertyFlags &flags = QScriptValue::KeepExistingFlags);

    static void setProperty(JSC::ExecState*, JSC::JSValue object, quint32 index, JSC::JSValue,

                     const QScriptValue::PropertyFlags &flags = QScriptValue::KeepExistingFlags);

    static QScriptValue::PropertyFlags propertyFlags(JSC::ExecState*, JSC::JSValue value,

                                              const JSC::Identifier &id, const QScriptValue::ResolveFlags &mode);

    static inline QScriptValue::PropertyFlags propertyFlags(JSC::ExecState*, JSC::JSValue value,

                                              const JSC::UString &name, const QScriptValue::ResolveFlags &mode);

    static bool convertValue(JSC::ExecState*, JSC::JSValue value,

                             int type, void *ptr);

    static bool convertNumber(qsreal, int type, void *ptr);

    static bool convertString(const QString &, int type, void *ptr);

    static JSC::JSValue create(JSC::ExecState*, int type, const void *ptr);

    bool hasDemarshalFunction(int type) const;

    inline QScriptValue scriptValueFromJSCValue(JSC::JSValue value);

    inline JSC::JSValue scriptValueToJSCValue(const QScriptValue &value);

    static inline unsigned propertyFlagsToJSCAttributes(const QScriptValue::PropertyFlags &flags);

    static inline JSC::JSValue jscValueFromVariant(JSC::ExecState*, const QVariant &value);

    static QVariant jscValueToVariant(JSC::ExecState*, JSC::JSValue value, int targetType);

    static inline QVariant &variantValue(JSC::JSValue value);

    static inline void setVariantValue(JSC::JSValue objectValue, const QVariant &value);

    static JSC::JSValue arrayFromStringList(JSC::ExecState*, const QStringList &lst);

    static QStringList stringListFromArray(JSC::ExecState*, JSC::JSValue arr);

    static JSC::JSValue arrayFromVariantList(JSC::ExecState*, const QVariantList &lst);

    static QVariantList variantListFromArray(JSC::ExecState*, JSC::JSArray *arr);

    static JSC::JSValue objectFromVariantMap(JSC::ExecState*, const QVariantMap &vmap);

    static QVariantMap variantMapFromObject(JSC::ExecState*, JSC::JSObject *obj);

    JSC::JSValue defaultPrototype(int metaTypeId) const;

    void setDefaultPrototype(int metaTypeId, JSC::JSValue prototype);

    static inline QScriptContext *contextForFrame(JSC::ExecState *frame);

    static inline JSC::ExecState *frameForContext(QScriptContext *context);

    static inline const JSC::ExecState *frameForContext(const QScriptContext *context);

    JSC::JSGlobalObject *originalGlobalObject() const;

    JSC::JSObject *getOriginalGlobalObjectProxy();

    JSC::JSObject *customGlobalObject() const;

    JSC::JSObject *globalObject() const;

    void setGlobalObject(JSC::JSObject *object);

    inline JSC::ExecState *globalExec() const;

    JSC::JSValue toUsableValue(JSC::JSValue value);

    static JSC::JSValue thisForContext(JSC::ExecState *frame);

    static JSC::Register *thisRegisterForFrame(JSC::ExecState *frame);

    JSC::CallFrame *pushContext(JSC::CallFrame *exec, JSC::JSValue thisObject, const JSC::ArgList& args,

                                JSC::JSObject *callee, bool calledAsConstructor = false, bool clearScopeChain = false);

    void popContext();

    void mark(JSC::MarkStack& markStack);

    bool isCollecting() const;

    void collectGarbage();

    void reportAdditionalMemoryCost(int size);

    //flags that we set on the return value register for native function. (ie when codeBlock is 0)

    enum ContextFlags {

        NativeContext = 1,

        CalledAsConstructorContext = 2,

        HasScopeContext = 4, // Specifies that the is a QScriptActivationObject

        ShouldRestoreCallFrame = 8

    };

    static uint contextFlags(JSC::ExecState *);

    static void setContextFlags(JSC::ExecState *, uint);

    QScript::TimeoutCheckerProxy *timeoutChecker() const;

    void agentDeleted(QScriptEngineAgent *agent);

    static inline void saveException(JSC::ExecState *, JSC::JSValue *);

    static inline void restoreException(JSC::ExecState *, JSC::JSValue);

    void setCurrentException(QScriptValue exception) { m_currentException = exception; }

    QScriptValue currentException() const { return m_currentException; }

    void clearCurrentException() { m_currentException.d_ptr.reset(); }

    static QScriptSyntaxCheckResult checkSyntax(const QString &program);

    static bool canEvaluate(const QString &program);

    inline QScriptValuePrivate *allocateScriptValuePrivate(size_t);

    inline void freeScriptValuePrivate(QScriptValuePrivate *p);

    inline void registerScriptValue(QScriptValuePrivate *value);

    inline void unregisterScriptValue(QScriptValuePrivate *value);

    void detachAllRegisteredScriptValues();

    inline void registerScriptString(QScriptStringPrivate *value);

    inline void unregisterScriptString(QScriptStringPrivate *value);

    void detachAllRegisteredScriptStrings();

    QScriptString toStringHandle(const JSC::Identifier &name);

    static inline JSC::JSValue newArray(JSC::ExecState *, uint length);

    static inline JSC::JSValue newDate(JSC::ExecState *, qsreal value);

    static inline JSC::JSValue newDate(JSC::ExecState *, const QDateTime &);

    inline JSC::JSValue newObject();

#ifndef QT_NO_REGEXP

    static JSC::JSValue newRegExp(JSC::ExecState *, const QRegExp &);

#endif

    static JSC::JSValue newRegExp(JSC::ExecState *, const QString &pattern, const QString &flags);

    JSC::JSValue newVariant(const QVariant &);

    JSC::JSValue newVariant(JSC::JSValue objectValue, const QVariant &);

    static inline QScriptDeclarativeClass *declarativeClass(JSC::JSValue);

    static inline QScriptDeclarativeClass::Object *declarativeObject(JSC::JSValue);

    JSC::UString translationContextFromUrl(const JSC::UString &);

#ifndef QT_NO_QOBJECT

    JSC::JSValue newQObject(QObject *object,

        QScriptEngine::ValueOwnership ownership = QScriptEngine::QtOwnership,

        const QScriptEngine:: QObjectWrapOptions &options = 0);

    JSC::JSValue newQMetaObject(const QMetaObject *metaObject,

                                JSC::JSValue ctor);

    static bool convertToNativeQObject(JSC::ExecState*, JSC::JSValue,

                                       const QByteArray &targetType,

                                       void **result);

    JSC::JSValue evaluateHelper(JSC::ExecState *exec, intptr_t sourceId,

                                JSC::EvalExecutable *executable,

                                bool &compile);

    QScript::QObjectData *qobjectData(QObject *object);

    void disposeQObject(QObject *object);

    void emitSignalHandlerException();

    bool scriptConnect(QObject *sender, const char *signal,

                       JSC::JSValue receiver, JSC::JSValue function,

                       Qt::ConnectionType type);

    bool scriptDisconnect(QObject *sender, const char *signal,

                          JSC::JSValue receiver, JSC::JSValue function);

    bool scriptConnect(QObject *sender, int index,

                       JSC::JSValue receiver, JSC::JSValue function,

                       JSC::JSValue senderWrapper,

                       Qt::ConnectionType type);

    bool scriptDisconnect(QObject *sender, int index,

                          JSC::JSValue receiver, JSC::JSValue function);

    bool scriptConnect(JSC::JSValue signal, JSC::JSValue receiver,

                       JSC::JSValue function, Qt::ConnectionType type);

    bool scriptDisconnect(JSC::JSValue signal, JSC::JSValue receiver,

                          JSC::JSValue function);

    // private slots

    void _q_objectDestroyed(QObject *);

#endif

    JSC::JSGlobalData *globalData;

    JSC::JSObject *originalGlobalObjectProxy;

    JSC::ExecState *currentFrame;

    WTF::RefPtr<JSC::Structure> scriptObjectStructure;

    WTF::RefPtr<JSC::Structure> staticScopeObjectStructure;

    QScript::QObjectPrototype *qobjectPrototype;

    WTF::RefPtr<JSC::Structure> qobjectWrapperObjectStructure;

    QScript::QMetaObjectPrototype *qmetaobjectPrototype;

    WTF::RefPtr<JSC::Structure> qmetaobjectWrapperObjectStructure;

    QScript::QVariantPrototype *variantPrototype;

    WTF::RefPtr<JSC::Structure> variantWrapperObjectStructure;

    QList<QScriptEngineAgent*> ownedAgents;

    QScriptEngineAgent *activeAgent;

    int agentLineNumber;

    QScriptValuePrivate *registeredScriptValues;

    QScriptValuePrivate *freeScriptValues;

    static const int maxFreeScriptValues = 256;

    int freeScriptValuesCount;

    QScriptStringPrivate *registeredScriptStrings;

    QHash<int, QScriptTypeInfo*> m_typeInfos;

    int processEventsInterval;

    QScriptValue abortResult;

    bool inEval;

    JSC::UString cachedTranslationUrl;

    JSC::UString cachedTranslationContext;

    QSet<QString> importedExtensions;

    QSet<QString> extensionsBeingImported;

    QHash<intptr_t, QScript::UStringSourceProviderWithFeedback*> loadedScripts;

    QScriptValue m_currentException;

    QSet<JSC::JSObject*> visitedConversionObjects;

#ifndef QT_NO_QOBJECT

    QHash<QObject*, QScript::QObjectData*> m_qobjectData;

#endif

#ifdef QT_NO_QOBJECT

    QScriptEngine *q_ptr;

#endif

};

namespace QScript

{

class APIShim

{

public:

    APIShim(QScriptEnginePrivate *engine)

        : m_engine(engine), m_oldTable(JSC::setCurrentIdentifierTable(engine->globalData->identifierTable))

    {

    }

    ~APIShim()

    {

        JSC::setCurrentIdentifierTable(m_oldTable);

    }

private:

    QScriptEnginePrivate *m_engine;

    JSC::IdentifierTable *m_oldTable;

};

/*Helper class. Main purpose is to give debugger feedback about unloading and loading scripts.

  It keeps pointer to JSGlobalObject assuming that it is always the same - there is no way to update

  this data. Class is internal and used as an implementation detail in and only in QScriptEngine::evaluate.*/

class UStringSourceProviderWithFeedback: public JSC::UStringSourceProvider

{

public:

    static PassRefPtr<UStringSourceProviderWithFeedback> create(

        const JSC::UString& source, const JSC::UString& url,

        int lineNumber, QScriptEnginePrivate* engine)

    {

        return adoptRef(new UStringSourceProviderWithFeedback(source, url, lineNumber, engine));

    }

    /* Destruction means that there is no more copies of script so create scriptUnload event

       and unregister script in QScriptEnginePrivate::loadedScripts */

    virtual ~UStringSourceProviderWithFeedback()

    {

        if (m_ptr) {

            if (JSC::Debugger* debugger = this->debugger())

                debugger->scriptUnload(asID());

            m_ptr->loadedScripts.remove(asID());

        }

    }

    /* set internal QScriptEnginePrivate pointer to null and create unloadScript event, should be called

       only if QScriptEnginePrivate is about to be  destroyed.*/

    void disconnectFromEngine()

    {

        if (JSC::Debugger* debugger = this->debugger())

            debugger->scriptUnload(asID());

        m_ptr = 0;

    }

    int columnNumberFromOffset(int offset) const

    {

        for (const UChar *c = m_source.data() + offset; c >= m_source.data(); --c) {

            if (JSC::Lexer::isLineTerminator(*c))

                return offset - static_cast<int>(c - data());

        }

        return offset + 1;

    }

protected:

    UStringSourceProviderWithFeedback(const JSC::UString& source, const JSC::UString& url,

                                      int lineNumber, QScriptEnginePrivate* engine)

        : UStringSourceProvider(source, url),

          m_ptr(engine)

    {

        if (JSC::Debugger* debugger = this->debugger())

            debugger->scriptLoad(asID(), source, url, lineNumber);

        if (m_ptr)

            m_ptr->loadedScripts.insert(asID(), this);

    }

    JSC::Debugger* debugger()

    {

        //if m_ptr is null it mean that QScriptEnginePrivate was destroyed and scriptUnload was called

        //else m_ptr is stable and we can use it as normal pointer without hesitation

        if(!m_ptr)

            return 0; //we are in ~QScriptEnginePrivate

        else

            return m_ptr->originalGlobalObject()->debugger(); //QScriptEnginePrivate is still alive

    }

    //trace global object and debugger instance

    QScriptEnginePrivate* m_ptr;

};

class SaveFrameHelper

{

public:

    SaveFrameHelper(QScriptEnginePrivate *eng,

                    JSC::ExecState *newFrame)

        : engine(eng), oldFrame(eng->currentFrame)

    {

        eng->currentFrame = newFrame;

    }

    ~SaveFrameHelper()

    {

        engine->currentFrame = oldFrame;

    }

private:

    QScriptEnginePrivate *engine;

    JSC::ExecState *oldFrame;

};

inline QScriptEnginePrivate *scriptEngineFromExec(const JSC::ExecState *exec)

{

    return static_cast<GlobalClientData*>(exec->globalData().clientData)->engine;

}

#ifndef Q_CC_MSVC

// MSVC2008 crashes if these are inlined.

inline QString ToString(qsreal value)

{

    return JSC::UString::from(value);