FCL/sf/mw/qt: comparison src/declarative/qml/qdeclarativeexpression.cpp

equal deleted inserted replaced

-:5dc02b23752f
+:3e2da88830cd
 if (nextError) nextError->prevError = &nextError;
 return true;
 }
-QDeclarativeExpressionData::QDeclarativeExpressionData()
+QDeclarativeQtScriptExpression::QDeclarativeQtScriptExpression()
-: q(0), dataRef(0), expressionFunctionValid(false), expressionRewritten(false), me(0),
+: dataRef(0), expressionFunctionMode(ExplicitContext), scopeObject(0), trackChange(false),
-trackChange(false), isShared(false), line(-1), guardList(0), guardListLength(0)
+guardList(0), guardListLength(0), guardObject(0), guardObjectNotifyIndex(-1), deleted(0)
 {
 }
-QDeclarativeExpressionData::~QDeclarativeExpressionData()
+QDeclarativeQtScriptExpression::~QDeclarativeQtScriptExpression()
 {
 if (guardList) { delete [] guardList; guardList = 0; }
 if (dataRef) dataRef->release();
+if (deleted) *deleted = true;
 }
 QDeclarativeExpressionPrivate::QDeclarativeExpressionPrivate()
-: data(new QDeclarativeExpressionData)
+: expressionFunctionValid(true), line(-1)
 {
-data->q = this;
-}
-QDeclarativeExpressionPrivate::QDeclarativeExpressionPrivate(QDeclarativeExpressionData *d)
-: data(d)
-{
-data->q = this;
 }
 QDeclarativeExpressionPrivate::~QDeclarativeExpressionPrivate()
 {
-if (data) {
-delete [] data->guardList;
-data->guardList = 0;
-data->guardListLength = 0;
-data->q = 0;
-data->release();
-data = 0;
-}
 }
 void QDeclarativeExpressionPrivate::init(QDeclarativeContextData *ctxt, const QString &expr,
 QObject *me)
 {
-data->expression = expr;
+expression = expr;
-data->QDeclarativeAbstractExpression::setContext(ctxt);
+QDeclarativeAbstractExpression::setContext(ctxt);
-data->me = me;
+scopeObject = me;
-}
+expressionFunctionValid = false;
+}
-void QDeclarativeExpressionPrivate::init(QDeclarativeContextData *ctxt, void *expr, QDeclarativeRefCount *rc,
-QObject *me, const QString &url, int lineNumber)
+void QDeclarativeExpressionPrivate::init(QDeclarativeContextData *ctxt, void *expr,
-{
+QDeclarativeRefCount *rc,
-data->url = url;
+QObject *me, const QString &srcUrl, int lineNumber)
-data->line = lineNumber;
+{
+url = srcUrl;
-if (data->dataRef) data->dataRef->release();
+line = lineNumber;
-data->dataRef = rc;
-if (data->dataRef) data->dataRef->addref();
+if (dataRef) dataRef->release();
+dataRef = rc;
+if (dataRef) dataRef->addref();
 quint32 *exprData = (quint32 *)expr;
 QDeclarativeCompiledData *dd = (QDeclarativeCompiledData *)rc;
-data->expressionRewritten = true;
+expression = QString::fromRawData((QChar *)(exprData + 2), exprData[1]);
-data->expression = QString::fromRawData((QChar *)(exprData + 2), exprData[1]);
 int progIdx = *(exprData);
-bool isShared = progIdx & 0x80000000;
+bool isSharedProgram = progIdx & 0x80000000;
 progIdx &= 0x7FFFFFFF;
 QDeclarativeEngine *engine = ctxt->engine;
 QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(engine);
 QScriptEngine *scriptEngine = QDeclarativeEnginePrivate::getScriptEngine(engine);
-if (isShared) {
+if (isSharedProgram) {
 if (!dd->cachedClosures.at(progIdx)) {
 QScriptContext *scriptContext = QScriptDeclarativeClass::pushCleanContext(scriptEngine);
 scriptContext->pushScope(ep->contextClass->newSharedContext());
-scriptContext->pushScope(ep->globalClass->globalObject());
+scriptContext->pushScope(ep->globalClass->staticGlobalObject());
-dd->cachedClosures[progIdx] = new QScriptValue(scriptEngine->evaluate(data->expression, data->url, data->line));
+dd->cachedClosures[progIdx] = new QScriptValue(scriptEngine->evaluate(expression, url, line));
 scriptEngine->popContext();
 }
-data->expressionFunction = *dd->cachedClosures.at(progIdx);
+expressionFunction = *dd->cachedClosures.at(progIdx);
-data->isShared = true;
+expressionFunctionMode = SharedContext;
-data->expressionFunctionValid = true;
+expressionFunctionValid = true;
 } else {
 #if !defined(Q_OS_SYMBIAN) //XXX Why doesn't this work?
 if (!dd->cachedPrograms.at(progIdx)) {
-dd->cachedPrograms[progIdx] =
+dd->cachedPrograms[progIdx] = new QScriptProgram(expression, url, line);
-new QScriptProgram(data->expression, data->url, data->line);
 }
-data->expressionFunction = evalInObjectScope(ctxt, me, *dd->cachedPrograms.at(progIdx),
+expressionFunction = evalInObjectScope(ctxt, me, *dd->cachedPrograms.at(progIdx),
-&data->expressionContext);
+&expressionContext);
 #else
-data->expressionFunction = evalInObjectScope(ctxt, me, data->expression,
+expressionFunction = evalInObjectScope(ctxt, me, expression, &expressionContext);
-&data->expressionContext);
 #endif
-data->expressionFunctionValid = true;
+expressionFunctionMode = ExplicitContext;
-}
+expressionFunctionValid = true;
+}
-data->QDeclarativeAbstractExpression::setContext(ctxt);
-data->me = me;
+QDeclarativeAbstractExpression::setContext(ctxt);
+scopeObject = me;
 }
 QScriptValue QDeclarativeExpressionPrivate::evalInObjectScope(QDeclarativeContextData *context, QObject *object,
 const QString &program, const QString &fileName,
 int lineNumber, QScriptValue *contextObject)
 *contextObject = ep->contextClass->newContext(context, object);
 scriptContext->pushScope(*contextObject);
 } else {
 scriptContext->pushScope(ep->contextClass->newContext(context, object));
 }
-scriptContext->pushScope(ep->globalClass->globalObject());
+scriptContext->pushScope(ep->globalClass->staticGlobalObject());
 QScriptValue rv = ep->scriptEngine.evaluate(program, fileName, lineNumber);
 ep->scriptEngine.popContext();
 return rv;
 }
 *contextObject = ep->contextClass->newContext(context, object);
 scriptContext->pushScope(*contextObject);
 } else {
 scriptContext->pushScope(ep->contextClass->newContext(context, object));
 }
-scriptContext->pushScope(ep->globalClass->globalObject());
+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,
 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.
 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
 */
 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.
 */
 is no association or the QDeclarativeEngine has been destroyed.
 */
 QDeclarativeEngine *QDeclarativeExpression::engine() const
 {
 Q_D(const QDeclarativeExpression);
-return d->data->context()?d->data->context()->engine:0;
+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->data->context();
+QDeclarativeContextData *data = d->context();
 return data?data->asQDeclarativeContext():0;
 }
 /*!
 Returns the expression string.
 */
 QString QDeclarativeExpression::expression() const
 {
 Q_D(const QDeclarativeExpression);
-return d->data->expression;
+return d->expression;
 }
 /*!
 Set the expression to \a expression.
 */
 void QDeclarativeExpression::setExpression(const QString &expression)
 {
 Q_D(QDeclarativeExpression);
-d->clearGuards();
+d->resetNotifyOnChange();
+d->expression = expression;
-d->data->expression = expression;
+d->expressionFunctionValid = false;
-d->data->expressionFunctionValid = false;
+d->expressionFunction = QScriptValue();
-d->data->expressionRewritten = false;
-d->data->expressionFunction = QScriptValue();
 }
 void QDeclarativeExpressionPrivate::exceptionToError(QScriptEngine *scriptEngine,
 QDeclarativeError &error)
 {
 } else {
 error = QDeclarativeError();
 }
 }
-QScriptValue QDeclarativeExpressionPrivate::eval(QObject *secondaryScope, bool *isUndefined)
+bool QDeclarativeQtScriptExpression::notifyOnValueChange() const
 {
-QDeclarativeExpressionData *data = this->data;
+return trackChange;
-QDeclarativeEngine *engine = data->context()->engine;
+}
+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);
-if (!data->expressionFunctionValid) {
-QScriptContext *scriptContext = QScriptDeclarativeClass::pushCleanContext(scriptEngine);
-data->expressionContext = ep->contextClass->newContext(data->context(), data->me);
-scriptContext->pushScope(data->expressionContext);
-scriptContext->pushScope(ep->globalClass->globalObject());
-if (data->expressionRewritten) {
-data->expressionFunction = scriptEngine->evaluate(data->expression,
-data->url, data->line);
-} else {
-QDeclarativeRewrite::RewriteBinding rewriteBinding;
-bool ok = true;
-const QString code = rewriteBinding(data->expression, &ok);
-if (!ok) {
-scriptEngine->popContext();
-return QScriptValue();
-}
-data->expressionFunction = scriptEngine->evaluate(code, data->url, data->line);
-}
-scriptEngine->popContext();
-data->expressionFunctionValid = true;
-}
 QDeclarativeContextData *oldSharedContext = 0;
 QObject *oldSharedScope = 0;
 QObject *oldOverride = 0;
-if (data->isShared) {
+bool isShared = (expressionFunctionMode == SharedContext);
+if (isShared) {
 oldSharedContext = ep->sharedContext;
 oldSharedScope = ep->sharedScope;
-ep->sharedContext = data->context();
+ep->sharedContext = context();
-ep->sharedScope = data->me;
+ep->sharedScope = scopeObject;
 } else {
-oldOverride = ep->contextClass->setOverrideObject(data->expressionContext, secondaryScope);
+oldOverride = ep->contextClass->setOverrideObject(expressionContext, secondaryScope);
 }
-QScriptValue svalue = data->expressionFunction.call();
+QScriptValue svalue = expressionFunction.call(); // This could cause this to be deleted
-if (data->isShared) {
+if (isShared) {
 ep->sharedContext = oldSharedContext;
 ep->sharedScope = oldSharedScope;
-} else {
+} else if (!watcher.wasDeleted()) {
-ep->contextClass->setOverrideObject(data->expressionContext, oldOverride);
+ep->contextClass->setOverrideObject(expressionContext, oldOverride);
 }
 if (isUndefined)
 *isUndefined = svalue.isUndefined() || scriptEngine->hasUncaughtException();
 // Handle exception
 if (scriptEngine->hasUncaughtException()) {
-exceptionToError(scriptEngine, data->error);
+if (!watcher.wasDeleted())
+QDeclarativeExpressionPrivate::exceptionToError(scriptEngine, error);
 scriptEngine->clearExceptions();
 return QScriptValue();
 } else {
-data->error = QDeclarativeError();
+if (!watcher.wasDeleted())
+error = QDeclarativeError();
 return svalue;
 }
 }
-QScriptValue QDeclarativeExpressionPrivate::scriptValue(QObject *secondaryScope, bool *isUndefined)
+void QDeclarativeQtScriptExpression::updateGuards(const QPODVector<QDeclarativeEnginePrivate::CapturedProperty> &properties)
 {
-Q_Q(QDeclarativeExpression);
+Q_ASSERT(guardObject);
-Q_ASSERT(q->engine());
+Q_ASSERT(guardObjectNotifyIndex != -1);
-if (data->expression.isEmpty())
+if (properties.count() != guardListLength) {
-return QScriptValue();
+QDeclarativeNotifierEndpoint *newGuardList = new QDeclarativeNotifierEndpoint[properties.count()];
-QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(q->engine());
+for (int ii = 0; ii < qMin(guardListLength, properties.count()); ++ii)
+guardList[ii].copyAndClear(newGuardList[ii]);
-QDeclarativeExpression *lastCurrentExpression = ep->currentExpression;
-bool lastCaptureProperties = ep->captureProperties;
+delete [] guardList;
-QPODVector<QDeclarativeEnginePrivate::CapturedProperty> lastCapturedProperties;
+guardList = newGuardList;
-ep->capturedProperties.copyAndClear(lastCapturedProperties);
+guardListLength = properties.count();
-ep->currentExpression = q;
-ep->captureProperties = data->trackChange;
-// This object might be deleted during the eval
-QDeclarativeExpressionData *localData = data;
-localData->addref();
-QScriptValue value = eval(secondaryScope, isUndefined);
-ep->currentExpression = lastCurrentExpression;
-ep->captureProperties = lastCaptureProperties;
-// Check if we were deleted
-if (localData->q) {
-if ((!data->trackChange || !ep->capturedProperties.count()) && data->guardList) {
-clearGuards();
-} else if(data->trackChange) {
-updateGuards(ep->capturedProperties);
-}
-}
-localData->release();
-lastCapturedProperties.copyAndClear(ep->capturedProperties);
-return value;
-}
-QVariant QDeclarativeExpressionPrivate::value(QObject *secondaryScope, bool *isUndefined)
-{
-Q_Q(QDeclarativeExpression);
-if (!data || !data->context() || !data->context()->isValid()) {
-qWarning("QDeclarativeExpression: Attempted to evaluate an expression in an invalid context");
-return QVariant();
-}
-QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(q->engine());
-return ep->scriptValueToVariant(scriptValue(secondaryScope, isUndefined), qMetaTypeId<QList<QObject*> >());
-}
-/*!
-Evaulates the expression, returning the result of the evaluation,
-or an invalid QVariant if the expression is invalid or has an error.
-\a valueIsUndefined is set to true if the expression resulted in an
-undefined value.
-\sa hasError(), error()
-*/
-QVariant QDeclarativeExpression::evaluate(bool *valueIsUndefined)
-{
-Q_D(QDeclarativeExpression);
-return d->value(0, valueIsUndefined);
-}
-/*!
-Returns true if the valueChanged() signal is emitted when the expression's evaluated
-value changes.
-*/
-bool QDeclarativeExpression::notifyOnValueChanged() const
-{
-Q_D(const QDeclarativeExpression);
-return d->data->trackChange;
-}
-/*!
-Sets whether the valueChanged() signal is emitted when the
-expression's evaluated value changes.
-If \a notifyOnChange is true, the QDeclarativeExpression will
-monitor properties involved in the expression's evaluation, and emit
-QDeclarativeExpression::valueChanged() if they have changed.  This
-allows an application to ensure that any value associated with the
-result of the expression remains up to date.
-If \a notifyOnChange is false (default), the QDeclarativeExpression
-will not montitor properties involved in the expression's
-evaluation, and QDeclarativeExpression::valueChanged() will never be
-emitted.  This is more efficient if an application wants a "one off"
-evaluation of the expression.
-*/
-void QDeclarativeExpression::setNotifyOnValueChanged(bool notifyOnChange)
-{
-Q_D(QDeclarativeExpression);
-d->data->trackChange = notifyOnChange;
-}
-/*!
-Returns the source file URL for this expression.  The source location must
-have been previously set by calling setSourceLocation().
-*/
-QString QDeclarativeExpression::sourceFile() const
-{
-Q_D(const QDeclarativeExpression);
-return d->data->url;
-}
-/*!
-Returns the source file line number for this expression.  The source location
-must have been previously set by calling setSourceLocation().
-*/
-int QDeclarativeExpression::lineNumber() const
-{
-Q_D(const QDeclarativeExpression);
-return d->data->line;
-}
-/*!
-Set the location of this expression to \a line of \a url. This information
-is used by the script engine.
-*/
-void QDeclarativeExpression::setSourceLocation(const QString &url, int line)
-{
-Q_D(QDeclarativeExpression);
-d->data->url = url;
-d->data->line = line;
-}
-/*!
-Returns the expression's scope object, if provided, otherwise 0.
-In addition to data provided by the expression's QDeclarativeContext, the scope
-object's properties are also in scope during the expression's evaluation.
-*/
-QObject *QDeclarativeExpression::scopeObject() const
-{
-Q_D(const QDeclarativeExpression);
-return d->data->me;
-}
-/*!
-Returns true if the last call to evaluate() resulted in an error,
-otherwise false.
-\sa error(), clearError()
-*/
-bool QDeclarativeExpression::hasError() const
-{
-Q_D(const QDeclarativeExpression);
-return d->data->error.isValid();
-}
-/*!
-Clear any expression errors.  Calls to hasError() following this will
-return false.
-\sa hasError(), error()
-*/
-void QDeclarativeExpression::clearError()
-{
-Q_D(QDeclarativeExpression);
-d->data->error = QDeclarativeError();
-}
-/*!
-Return any error from the last call to evaluate().  If there was no error,
-this returns an invalid QDeclarativeError instance.
-\sa hasError(), clearError()
-*/
-QDeclarativeError QDeclarativeExpression::error() const
-{
-Q_D(const QDeclarativeExpression);
-return d->data->error;
-}
-/*! \internal */
-void QDeclarativeExpressionPrivate::_q_notify()
-{
-emitValueChanged();
-}
-void QDeclarativeExpressionPrivate::clearGuards()
-{
-delete [] data->guardList;
-data->guardList = 0;
-data->guardListLength = 0;
-}
-void QDeclarativeExpressionPrivate::updateGuards(const QPODVector<QDeclarativeEnginePrivate::CapturedProperty> &properties)
-{
-Q_Q(QDeclarativeExpression);
-static int notifyIdx = -1;
-if (notifyIdx == -1)
-notifyIdx = QDeclarativeExpression::staticMetaObject.indexOfMethod("_q_notify()");
-if (properties.count() != data->guardListLength) {
-QDeclarativeNotifierEndpoint *newGuardList =
-new QDeclarativeNotifierEndpoint[properties.count()];
-for (int ii = 0; ii < qMin(data->guardListLength, properties.count()); ++ii)
-data->guardList[ii].copyAndClear(newGuardList[ii]);
-delete [] data->guardList;
-data->guardList = newGuardList;
-data->guardListLength = properties.count();
 }
 bool outputWarningHeader = false;
 bool noChanges = true;
 for (int ii = 0; ii < properties.count(); ++ii) {
-QDeclarativeNotifierEndpoint &guard = data->guardList[ii];
+QDeclarativeNotifierEndpoint &guard = guardList[ii];
 const QDeclarativeEnginePrivate::CapturedProperty &property = properties.at(ii);
-guard.target = q;
+guard.target = guardObject;
-guard.targetMethod = notifyIdx;
+guard.targetMethod = guardObjectNotifyIndex;
 if (property.notifier != 0) {
 if (!noChanges && guard.isConnected(property.notifier)) {
 // Nothing to do
 } else {
 noChanges = false;
 bool existing = false;
 for (int jj = 0; !existing && jj < ii; ++jj)
-if (data->guardList[jj].isConnected(property.notifier))
+if (guardList[jj].isConnected(property.notifier))
 existing = true;
 if (existing) {
 // duplicate
 guard.disconnect();
 } else {
 noChanges = false;
 bool existing = false;
 for (int jj = 0; !existing && jj < ii; ++jj)
-if (data->guardList[jj].isConnected(property.object, property.notifyIndex))
+if (guardList[jj].isConnected(property.object, property.notifyIndex))
 existing = true;
 if (existing) {
 // duplicate
 guard.disconnect();
 }
 } else {
 if (!outputWarningHeader) {
 outputWarningHeader = true;
-qWarning() << "QDeclarativeExpression: Expression" << q->expression()
+qWarning() << "QDeclarativeExpression: Expression" << expression
 << "depends on non-NOTIFYable properties:";
 }
 const QMetaObject *metaObj = property.object->metaObject();
 QMetaProperty metaProp = metaObj->property(property.coreIndex);
 qWarning().nospace() << "    " << metaObj->className() << "::" << metaProp.name();
 }
 }
+}
+QScriptValue QDeclarativeExpressionPrivate::scriptValue(QObject *secondaryScope, bool *isUndefined)
+{
+if (!expressionFunctionValid) {
+QDeclarativeEngine *engine = context()->engine;
+QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(engine);
+QScriptEngine *scriptEngine = QDeclarativeEnginePrivate::getScriptEngine(engine);
+QScriptContext *scriptContext = QScriptDeclarativeClass::pushCleanContext(scriptEngine);
+expressionContext = ep->contextClass->newContext(context(), scopeObject);
+scriptContext->pushScope(expressionContext);
+scriptContext->pushScope(ep->globalClass->staticGlobalObject());
+QDeclarativeRewrite::RewriteBinding rewriteBinding;
+bool ok = true;
+const QString code = rewriteBinding(expression, &ok);
+if (ok)
+expressionFunction = scriptEngine->evaluate(code, url, line);
+scriptEngine->popContext();
+expressionFunctionMode = ExplicitContext;
+expressionFunctionValid = true;
+}
+return QDeclarativeQtScriptExpression::scriptValue(secondaryScope, isUndefined);
+}
+QVariant QDeclarativeExpressionPrivate::value(QObject *secondaryScope, bool *isUndefined)
+{
+Q_Q(QDeclarativeExpression);
+if (!context() || !context()->isValid()) {
+qWarning("QDeclarativeExpression: Attempted to evaluate an expression in an invalid context");
+return QVariant();
+}
+QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(q->engine());
+return ep->scriptValueToVariant(scriptValue(secondaryScope, isUndefined), qMetaTypeId<QList<QObject*> >());
+}
+/*!
+Evaulates the expression, returning the result of the evaluation,
+or an invalid QVariant if the expression is invalid or has an error.
+\a valueIsUndefined is set to true if the expression resulted in an
+undefined value.
+\sa hasError(), error()
+*/
+QVariant QDeclarativeExpression::evaluate(bool *valueIsUndefined)
+{
+Q_D(QDeclarativeExpression);
+return d->value(0, valueIsUndefined);
+}
+/*!
+Returns true if the valueChanged() signal is emitted when the expression's evaluated
+value changes.
+*/
+bool QDeclarativeExpression::notifyOnValueChanged() const
+{
+Q_D(const QDeclarativeExpression);
+return d->notifyOnValueChange();
+}
+/*!
+Sets whether the valueChanged() signal is emitted when the
+expression's evaluated value changes.
+If \a notifyOnChange is true, the QDeclarativeExpression will
+monitor properties involved in the expression's evaluation, and emit
+QDeclarativeExpression::valueChanged() if they have changed.  This
+allows an application to ensure that any value associated with the
+result of the expression remains up to date.
+If \a notifyOnChange is false (default), the QDeclarativeExpression
+will not montitor properties involved in the expression's
+evaluation, and QDeclarativeExpression::valueChanged() will never be
+emitted.  This is more efficient if an application wants a "one off"
+evaluation of the expression.
+*/
+void QDeclarativeExpression::setNotifyOnValueChanged(bool notifyOnChange)
+{
+Q_D(QDeclarativeExpression);
+d->setNotifyOnValueChange(notifyOnChange);
+}
+/*!
+Returns the source file URL for this expression.  The source location must
+have been previously set by calling setSourceLocation().
+*/
+QString QDeclarativeExpression::sourceFile() const
+{
+Q_D(const QDeclarativeExpression);
+return d->url;
+}
+/*!
+Returns the source file line number for this expression.  The source location
+must have been previously set by calling setSourceLocation().
+*/
+int QDeclarativeExpression::lineNumber() const
+{
+Q_D(const QDeclarativeExpression);
+return d->line;
+}
+/*!
+Set the location of this expression to \a line of \a url. This information
+is used by the script engine.
+*/
+void QDeclarativeExpression::setSourceLocation(const QString &url, int line)
+{
+Q_D(QDeclarativeExpression);
+d->url = url;
+d->line = line;
+}
+/*!
+Returns the expression's scope object, if provided, otherwise 0.
+In addition to data provided by the expression's QDeclarativeContext, the scope
+object's properties are also in scope during the expression's evaluation.
+*/
+QObject *QDeclarativeExpression::scopeObject() const
+{
+Q_D(const QDeclarativeExpression);
+return d->scopeObject;
+}
+/*!
+Returns true if the last call to evaluate() resulted in an error,
+otherwise false.
+\sa error(), clearError()
+*/
+bool QDeclarativeExpression::hasError() const
+{
+Q_D(const QDeclarativeExpression);
+return d->error.isValid();
+}
+/*!
+Clear any expression errors.  Calls to hasError() following this will
+return false.
+\sa hasError(), error()
+*/
+void QDeclarativeExpression::clearError()
+{
+Q_D(QDeclarativeExpression);
+d->error = QDeclarativeError();
+}
+/*!
+Return any error from the last call to evaluate().  If there was no error,
+this returns an invalid QDeclarativeError instance.
+\sa hasError(), clearError()
+*/
+QDeclarativeError QDeclarativeExpression::error() const
+{
+Q_D(const QDeclarativeExpression);
+return d->error;
+}
+/*! \internal */
+void QDeclarativeExpressionPrivate::_q_notify()
+{
+emitValueChanged();
+}
+void QDeclarativeQtScriptExpression::clearGuards()
+{
+delete [] guardList;
+guardList = 0;
+guardListLength = 0;
 }
 /*!
 \fn void QDeclarativeExpression::valueChanged()

changeset 33	3e2da88830cd
parent 30	5dc02b23752f
child 37	758a864f9613