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

**

** 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 QtDeclarative module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

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

#include "qdeclarativeexpression.h"

#include "private/qdeclarativeexpression_p.h"

#include "private/qdeclarativeengine_p.h"

#include "private/qdeclarativecontext_p.h"

#include "private/qdeclarativerewrite_p.h"

#include "private/qdeclarativecompiler_p.h"

#include "private/qdeclarativeglobalscriptclass_p.h"

#include <QtCore/qdebug.h>

#include <QtScript/qscriptprogram.h>

#include <private/qscriptdeclarativeclass_p.h>

QT_BEGIN_NAMESPACE

bool QDeclarativeDelayedError::addError(QDeclarativeEnginePrivate *e)

{

    if (!e) return false;

    if (e->inProgressCreations == 0) return false; // Not in construction

    if (prevError) return true; // Already in error chain

    prevError = &e->erroredBindings;

    nextError = e->erroredBindings;

    e->erroredBindings = this;

    if (nextError) nextError->prevError = &nextError;

    return true;

}

QDeclarativeQtScriptExpression::QDeclarativeQtScriptExpression()

: dataRef(0), expressionFunctionMode(ExplicitContext), scopeObject(0), trackChange(false), 

  guardList(0), guardListLength(0), guardObject(0), guardObjectNotifyIndex(-1), deleted(0)

{

}

QDeclarativeQtScriptExpression::~QDeclarativeQtScriptExpression()

{

    if (guardList) { delete [] guardList; guardList = 0; }

    if (dataRef) dataRef->release();

    if (deleted) *deleted = true;

}

QDeclarativeExpressionPrivate::QDeclarativeExpressionPrivate()

: expressionFunctionValid(true), line(-1)

{

}

QDeclarativeExpressionPrivate::~QDeclarativeExpressionPrivate()

{

}

void QDeclarativeExpressionPrivate::init(QDeclarativeContextData *ctxt, const QString &expr, 

                                         QObject *me)

{

    expression = expr;

    QDeclarativeAbstractExpression::setContext(ctxt);

    scopeObject = me;

    expressionFunctionValid = false;

}

void QDeclarativeExpressionPrivate::init(QDeclarativeContextData *ctxt, void *expr, 

                                         QDeclarativeRefCount *rc, 

                                         QObject *me, const QString &srcUrl, int lineNumber)

{

    url = srcUrl;

    line = lineNumber;

    if (dataRef) dataRef->release();

    dataRef = rc;

    if (dataRef) dataRef->addref();

    quint32 *exprData = (quint32 *)expr;

    QDeclarativeCompiledData *dd = (QDeclarativeCompiledData *)rc;

    expression = QString::fromRawData((QChar *)(exprData + 2), exprData[1]);

    int progIdx = *(exprData);

    bool isSharedProgram = progIdx & 0x80000000;

    progIdx &= 0x7FFFFFFF;

    QDeclarativeEngine *engine = ctxt->engine;

    QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(engine);

    QScriptEngine *scriptEngine = QDeclarativeEnginePrivate::getScriptEngine(engine);

    if (isSharedProgram) {

        if (!dd->cachedClosures.at(progIdx)) {

            QScriptContext *scriptContext = QScriptDeclarativeClass::pushCleanContext(scriptEngine);

            scriptContext->pushScope(ep->contextClass->newSharedContext());

            scriptContext->pushScope(ep->globalClass->staticGlobalObject());

            dd->cachedClosures[progIdx] = new QScriptValue(scriptEngine->evaluate(expression, url, line));

            scriptEngine->popContext();

        }

        expressionFunction = *dd->cachedClosures.at(progIdx);

        expressionFunctionMode = SharedContext;

        expressionFunctionValid = true;

    } else {

        if (!dd->cachedPrograms.at(progIdx)) {

            dd->cachedPrograms[progIdx] = new QScriptProgram(expression, url, line);

        }

        expressionFunction = evalInObjectScope(ctxt, me, *dd->cachedPrograms.at(progIdx), 

                                                     &expressionContext);

        expressionFunctionMode = ExplicitContext;

        expressionFunctionValid = true;

    }

    QDeclarativeAbstractExpression::setContext(ctxt);

    scopeObject = me;

}

QScriptValue QDeclarativeExpressionPrivate::evalInObjectScope(QDeclarativeContextData *context, QObject *object, 

                                                              const QString &program, const QString &fileName,

                                                              int lineNumber, QScriptValue *contextObject)

{

    QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(context->engine);

    QScriptContext *scriptContext = QScriptDeclarativeClass::pushCleanContext(&ep->scriptEngine);

    if (contextObject) {

        *contextObject = ep->contextClass->newContext(context, object);

        scriptContext->pushScope(*contextObject);

    } else {

        scriptContext->pushScope(ep->contextClass->newContext(context, object));

    }

    scriptContext->pushScope(ep->globalClass->staticGlobalObject());

    QScriptValue rv = ep->scriptEngine.evaluate(program, fileName, lineNumber);

    ep->scriptEngine.popContext();

    return rv;

}

QScriptValue QDeclarativeExpressionPrivate::evalInObjectScope(QDeclarativeContextData *context, QObject *object, 

                                                              const QScriptProgram &program, 

                                                              QScriptValue *contextObject)

{

    QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(context->engine);

    QScriptContext *scriptContext = QScriptDeclarativeClass::pushCleanContext(&ep->scriptEngine);

    if (contextObject) {

        *contextObject = ep->contextClass->newContext(context, object);

        scriptContext->pushScope(*contextObject);

    } else {

        scriptContext->pushScope(ep->contextClass->newContext(context, object));

    }

    scriptContext->pushScope(ep->globalClass->staticGlobalObject());

    QScriptValue rv = ep->scriptEngine.evaluate(program);

    ep->scriptEngine.popContext();

    return rv;

}

/*!

    \class QDeclarativeExpression

    \since 4.7

    \brief The QDeclarativeExpression class evaluates JavaScript in a QML context.

    For example, given a file \c main.qml like this:

    \qml

    import Qt 4.7

    Item {

        width: 200; height: 200

    }

    \endqml

    The following code evaluates a JavaScript expression in the context of the

    above QML:

    \code

    QDeclarativeEngine *engine = new QDeclarativeEngine;

    QDeclarativeComponent component(engine, QUrl::fromLocalFile("main.qml"));

    QObject *myObject = component.create();

    QDeclarativeExpression *expr = new QDeclarativeExpression(engine->rootContext(), myObject, "width * 2");

    int result = expr->evaluate().toInt();  // result = 400

    \endcode

*/

static int QDeclarativeExpression_notifyIdx = -1;

/*!

    Create an invalid QDeclarativeExpression.

    As the expression will not have an associated QDeclarativeContext, this will be a

    null expression object and its value will always be an invalid QVariant.

 */

QDeclarativeExpression::QDeclarativeExpression()

: QObject(*new QDeclarativeExpressionPrivate, 0)

{

    Q_D(QDeclarativeExpression);

    if (QDeclarativeExpression_notifyIdx == -1) 

        QDeclarativeExpression_notifyIdx = QDeclarativeExpression::staticMetaObject.indexOfMethod("_q_notify()");

    d->setNotifyObject(this, QDeclarativeExpression_notifyIdx);

}

/*!  \internal */

QDeclarativeExpression::QDeclarativeExpression(QDeclarativeContextData *ctxt, void *expr,

                                               QDeclarativeRefCount *rc, QObject *me, 

                                               const QString &url, int lineNumber,

                                               QDeclarativeExpressionPrivate &dd)

: QObject(dd, 0)

{

    Q_D(QDeclarativeExpression);

    d->init(ctxt, expr, rc, me, url, lineNumber);

    if (QDeclarativeExpression_notifyIdx == -1) 

        QDeclarativeExpression_notifyIdx = QDeclarativeExpression::staticMetaObject.indexOfMethod("_q_notify()");

    d->setNotifyObject(this, QDeclarativeExpression_notifyIdx);

}

/*!

    Create a QDeclarativeExpression object that is a child of \a parent.

    The \a expression JavaScript will be executed in the \a ctxt QDeclarativeContext.

    If specified, the \a scope object's properties will also be in scope during

    the expression's execution.

*/

QDeclarativeExpression::QDeclarativeExpression(QDeclarativeContext *ctxt,

                                               QObject *scope,

                                               const QString &expression,

                                               QObject *parent)

: QObject(*new QDeclarativeExpressionPrivate, parent)

{

    Q_D(QDeclarativeExpression);

    d->init(QDeclarativeContextData::get(ctxt), expression, scope);

    if (QDeclarativeExpression_notifyIdx == -1) 

        QDeclarativeExpression_notifyIdx = QDeclarativeExpression::staticMetaObject.indexOfMethod("_q_notify()");

    d->setNotifyObject(this, QDeclarativeExpression_notifyIdx);

}

/*! 

    \internal

*/

QDeclarativeExpression::QDeclarativeExpression(QDeclarativeContextData *ctxt, QObject *scope,

                                               const QString &expression)

: QObject(*new QDeclarativeExpressionPrivate, 0)

{

    Q_D(QDeclarativeExpression);

    d->init(ctxt, expression, scope);

    if (QDeclarativeExpression_notifyIdx == -1) 

        QDeclarativeExpression_notifyIdx = QDeclarativeExpression::staticMetaObject.indexOfMethod("_q_notify()");

    d->setNotifyObject(this, QDeclarativeExpression_notifyIdx);

}

/*!  \internal */

QDeclarativeExpression::QDeclarativeExpression(QDeclarativeContextData *ctxt, QObject *scope,

                                               const QString &expression, QDeclarativeExpressionPrivate &dd)

: QObject(dd, 0)

{

    Q_D(QDeclarativeExpression);

    d->init(ctxt, expression, scope);

    if (QDeclarativeExpression_notifyIdx == -1) 

        QDeclarativeExpression_notifyIdx = QDeclarativeExpression::staticMetaObject.indexOfMethod("_q_notify()");

    d->setNotifyObject(this, QDeclarativeExpression_notifyIdx);

}

/*!

    Destroy the QDeclarativeExpression instance.

*/

QDeclarativeExpression::~QDeclarativeExpression()

{

}

/*!

    Returns the QDeclarativeEngine this expression is associated with, or 0 if there

    is no association or the QDeclarativeEngine has been destroyed.

*/

QDeclarativeEngine *QDeclarativeExpression::engine() const

{

    Q_D(const QDeclarativeExpression);

    return d->context()?d->context()->engine:0;

}

/*!

    Returns the QDeclarativeContext this expression is associated with, or 0 if there

    is no association or the QDeclarativeContext has been destroyed.

*/

QDeclarativeContext *QDeclarativeExpression::context() const

{

    Q_D(const QDeclarativeExpression);

    QDeclarativeContextData *data = d->context();

    return data?data->asQDeclarativeContext():0;

}

/*!

    Returns the expression string.

*/

QString QDeclarativeExpression::expression() const

{

    Q_D(const QDeclarativeExpression);

    return d->expression;

}

/*!

    Set the expression to \a expression.

*/

void QDeclarativeExpression::setExpression(const QString &expression)

{

    Q_D(QDeclarativeExpression);

    d->resetNotifyOnChange();

    d->expression = expression;

    d->expressionFunctionValid = false;

    d->expressionFunction = QScriptValue();

}

void QDeclarativeExpressionPrivate::exceptionToError(QScriptEngine *scriptEngine, 

                                            QDeclarativeError &error)

{

    if (scriptEngine->hasUncaughtException() && 

        scriptEngine->uncaughtException().isError()) {

        QString fileName;

        int lineNumber = scriptEngine->uncaughtExceptionLineNumber();

        QScriptValue exception = scriptEngine->uncaughtException();

        QLatin1String fileNameProp("fileName");

        if (!exception.property(fileNameProp).toString().isEmpty()){

            fileName = exception.property(fileNameProp).toString();

        } else {

            fileName = QLatin1String("<Unknown File>");

        }

        error.setUrl(QUrl(fileName));

        error.setLine(lineNumber);

        error.setColumn(-1);

        error.setDescription(exception.toString());

    } else {

        error = QDeclarativeError();

    }

}

bool QDeclarativeQtScriptExpression::notifyOnValueChange() const

{

    return trackChange;

}

void QDeclarativeQtScriptExpression::setNotifyOnValueChange(bool notify)

{

    trackChange = notify;

    if (!notify && guardList) 

        clearGuards();

}

void QDeclarativeQtScriptExpression::resetNotifyOnChange()

{

    clearGuards();

}

void QDeclarativeQtScriptExpression::setNotifyObject(QObject *object, int notifyIndex)

{

    if (guardList) clearGuards();

    if (!object || notifyIndex == -1) {

        guardObject = 0;

        notifyIndex = -1;

    } else {

        guardObject = object;

        guardObjectNotifyIndex = notifyIndex;

    }

}

QScriptValue QDeclarativeQtScriptExpression::scriptValue(QObject *secondaryScope, bool *isUndefined)

{

    Q_ASSERT(context() && context()->engine);

    Q_ASSERT(!trackChange || (guardObject && guardObjectNotifyIndex != -1));

    if (!expressionFunction.isValid()) {

        if (isUndefined) *isUndefined = true;

        return QScriptValue();

    }

    DeleteWatcher watcher(this);

    QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(context()->engine);

    bool lastCaptureProperties = ep->captureProperties;

    QPODVector<QDeclarativeEnginePrivate::CapturedProperty> lastCapturedProperties;

    ep->captureProperties = trackChange;

    ep->capturedProperties.copyAndClear(lastCapturedProperties);

    QScriptValue value = eval(secondaryScope, isUndefined);

    if (!watcher.wasDeleted() && trackChange) {

        if (ep->capturedProperties.count() == 0) {

            if (guardList) clearGuards();

        } else {

            updateGuards(ep->capturedProperties);

        }

    }

    lastCapturedProperties.copyAndClear(ep->capturedProperties);

    ep->captureProperties = lastCaptureProperties;

    return value;

}

QScriptValue QDeclarativeQtScriptExpression::eval(QObject *secondaryScope, bool *isUndefined)

{

    Q_ASSERT(context() && context()->engine);

    DeleteWatcher watcher(this);

    QDeclarativeEngine *engine = context()->engine;

    QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(engine);

    QScriptEngine *scriptEngine = QDeclarativeEnginePrivate::getScriptEngine(engine);

    QDeclarativeContextData *oldSharedContext = 0;

    QObject *oldSharedScope = 0;

    QObject *oldOverride = 0;

    bool isShared = (expressionFunctionMode == SharedContext);

    if (isShared) {

        oldSharedContext = ep->sharedContext;

        oldSharedScope = ep->sharedScope;

        ep->sharedContext = context();

        ep->sharedScope = scopeObject;

    } else {

        oldOverride = ep->contextClass->setOverrideObject(expressionContext, secondaryScope);

    }

    QScriptValue svalue = expressionFunction.call(); // This could cause this to be deleted

    if (isShared) {

        ep->sharedContext = oldSharedContext;

        ep->sharedScope = oldSharedScope;

    } else if (!watcher.wasDeleted()) {

        ep->contextClass->setOverrideObject(expressionContext, oldOverride);

    }

    if (isUndefined)

        *isUndefined = svalue.isUndefined() || scriptEngine->hasUncaughtException();

    // Handle exception

    if (scriptEngine->hasUncaughtException()) {

        if (!watcher.wasDeleted()) 

           QDeclarativeExpressionPrivate::exceptionToError(scriptEngine, error);

       scriptEngine->clearExceptions();

       return QScriptValue();

    } else {

        if (!watcher.wasDeleted())

            error = QDeclarativeError();

        return svalue;

    }

}

void QDeclarativeQtScriptExpression::updateGuards(const QPODVector<QDeclarativeEnginePrivate::CapturedProperty> &properties)

{

    Q_ASSERT(guardObject);

    Q_ASSERT(guardObjectNotifyIndex != -1);