void ScriptToolbox::listProperties(const QScriptValue &obj) const
{
qWarning("Properties of %s:", qPrintable(obj.toString()));
QScriptValue tmp = obj;
while (tmp.isObject())
{
QScriptValueIterator prop(tmp);
while (prop.hasNext())
{
prop.next();
qWarning(" %s\t= %s",
qPrintable(prop.name()), qPrintable(prop.value().toString()));
}
tmp = tmp.prototype();
if (! (tmp.isNull() || tmp.isUndefined()))
qWarning(" Prototype %s of %s:",
qPrintable(tmp.toString()), qPrintable(obj.toString()));
}
qWarning("End of %s", qPrintable(obj.toString()));
}
JsonData JsonHandler::property(const QString &data, const QString &prop)
{
QScriptValue sc;
QScriptEngine engine;
JsonData errorData;
JsonData propData;;
sc = engine.evaluate("(" + QString(data) + ")");
if (sc.property("error").isObject()) {
JsonData result;
result.setType(JsonData::Error);
QScriptValue errorObj = sc.property("error").toObject();
qDebug() << Q_FUNC_INFO <<
"Error in Result" <<
errorObj.property("type").toString() <<
errorObj.property("message").toString();
errorData = result;
}
QScriptValue propValue = sc.property(prop);
if (!propValue.isValid() || propValue.isUndefined()) {
return errorData;
}else {
qDebug() << Q_FUNC_INFO << "Start parsing property :" << propValue.isObject();
if (propValue.isObject()) {
QVariantMap list = qscriptvalue_cast<QVariantMap>(propValue);
propData.setType(JsonData::Object);
propData.addData(prop, QVariant(list));
return propData;
} else if (propValue.isString()) {
propData.setType(JsonData::String);
propData.addData(prop, QVariant(propValue.toString()));
return propData;
} else if (propValue.isArray()) {
propData.setType(JsonData::Array);
propData.addData(prop, QVariant(arrayToMap(propValue)));
return propData;
}
}
}
QList< QAction * > KWin::AbstractScript::actionsForUserActionMenu(KWin::AbstractClient *c, QMenu *parent)
{
QList<QAction*> returnActions;
for (QList<QScriptValue>::const_iterator it = m_userActionsMenuCallbacks.constBegin(); it != m_userActionsMenuCallbacks.constEnd(); ++it) {
QScriptValue callback(*it);
QScriptValueList arguments;
arguments << callback.engine()->newQObject(c);
QScriptValue actions = callback.call(QScriptValue(), arguments);
if (!actions.isValid() || actions.isUndefined() || actions.isNull()) {
// script does not want to handle this Client
continue;
}
if (actions.isObject()) {
QAction *a = scriptValueToAction(actions, parent);
if (a) {
returnActions << a;
}
}
}
return returnActions;
}
QScriptValue MessageBox::setIconPixmap(const QScriptValue &image)
{
if(image.isUndefined() || image.isNull())
{
mMessageBox->setIconPixmap(QPixmap());
return thisObject();
}
QObject *object = image.toQObject();
if(Image *otherImage = qobject_cast<Image*>(object))
{
mMessageBox->setIconPixmap(QPixmap::fromImage(otherImage->image()));
}
else
{
throwError("SetIconPixmapError", tr("Invalid image"));
return thisObject();
}
return thisObject();
}
QScriptValue QtScriptObject::validateNumber(const QString& parameterName, QScriptValue value, double minValue, double maxValue)
{
QScriptValue result = this->validateNumber(parameterName, value);
if (result.isUndefined())
{
qsreal number = value.toNumber();
if (number < minValue)
{
result = this->throwError(QString(QT_TR_NOOP("Parameter %1 must be greater than %2")).arg(parameterName).arg(minValue));
}
else if (number > maxValue)
{
result = this->throwError(QString(QT_TR_NOOP("Parameter %1 must be less than %2")).arg(parameterName).arg(maxValue));
}
else
{
result = QScriptValue(QScriptValue::UndefinedValue);
}
}
return result;
}
void MetaCallArgument::fromScriptValue(int callType, QDeclarativeEngine *engine, const QScriptValue &value)
{
if (type != 0) { cleanup(); type = 0; }
if (callType == qMetaTypeId<QScriptValue>()) {
new (&data) QScriptValue(value);
type = qMetaTypeId<QScriptValue>();
} else if (callType == QMetaType::Int) {
*((int *)&data) = int(value.toInt32());
type = callType;
} else if (callType == QMetaType::UInt) {
*((uint *)&data) = uint(value.toUInt32());
type = callType;
} else if (callType == QMetaType::Bool) {
*((bool *)&data) = value.toBool();
type = callType;
} else if (callType == QMetaType::Double) {
*((double *)&data) = double(value.toNumber());
type = callType;
} else if (callType == QMetaType::Float) {
*((float *)&data) = float(value.toNumber());
type = callType;
} else if (callType == QMetaType::QString) {
if (value.isNull() || value.isUndefined())
new (&data) QString();
else
new (&data) QString(value.toString());
type = callType;
} else if (callType == QMetaType::QObjectStar) {
*((QObject **)&data) = value.toQObject();
type = callType;
} else if (callType == qMetaTypeId<QVariant>()) {
new (&data) QVariant(QDeclarativeEnginePrivate::get(engine)->scriptValueToVariant(value));
type = callType;
} else if (callType == qMetaTypeId<QList<QObject*> >()) {
QList<QObject *> *list = new (&data) QList<QObject *>();
if (value.isArray()) {
int length = value.property(QLatin1String("length")).toInt32();
for (int ii = 0; ii < length; ++ii) {
QScriptValue arrayItem = value.property(ii);
QObject *d = arrayItem.toQObject();
list->append(d);
}
} else if (QObject *d = value.toQObject()) {
list->append(d);
}
type = callType;
} else {
new (&data) QVariant();
type = -1;
QVariant v = QDeclarativeEnginePrivate::get(engine)->scriptValueToVariant(value);
if (v.userType() == callType) {
*((QVariant *)&data) = v;
} else if (v.canConvert((QVariant::Type)callType)) {
*((QVariant *)&data) = v;
((QVariant *)&data)->convert((QVariant::Type)callType);
} else {
*((QVariant *)&data) = QVariant(callType, (void *)0);
}
}
}
void QDeclarativeObjectScriptClass::setProperty(QObject *obj,
const Identifier &name,
const QScriptValue &value,
QScriptContext *context,
QDeclarativeContextData *evalContext)
{
Q_UNUSED(name);
Q_ASSERT(obj);
Q_ASSERT(lastData);
Q_ASSERT(context);
if (!lastData->isValid()) {
QString error = QLatin1String("Cannot assign to non-existent property \"") +
toString(name) + QLatin1Char('\"');
context->throwError(error);
return;
}
if (!(lastData->flags & QDeclarativePropertyCache::Data::IsWritable) &&
!(lastData->flags & QDeclarativePropertyCache::Data::IsQList)) {
QString error = QLatin1String("Cannot assign to read-only property \"") +
toString(name) + QLatin1Char('\"');
context->throwError(error);
return;
}
QDeclarativeEnginePrivate *enginePriv = QDeclarativeEnginePrivate::get(engine);
if (!evalContext) {
// Global object, QScriptContext activation object, QDeclarativeContext object
QScriptValue scopeNode = scopeChainValue(context, -3);
if (scopeNode.isValid()) {
Q_ASSERT(scriptClass(scopeNode) == enginePriv->contextClass);
evalContext = enginePriv->contextClass->contextFromValue(scopeNode);
}
}
QDeclarativeAbstractBinding *delBinding =
QDeclarativePropertyPrivate::setBinding(obj, lastData->coreIndex, -1, 0);
if (delBinding)
delBinding->destroy();
if (value.isNull() && lastData->flags & QDeclarativePropertyCache::Data::IsQObjectDerived) {
QObject *o = 0;
int status = -1;
int flags = 0;
void *argv[] = { &o, 0, &status, &flags };
QMetaObject::metacall(obj, QMetaObject::WriteProperty, lastData->coreIndex, argv);
} else if (value.isUndefined() && lastData->flags & QDeclarativePropertyCache::Data::IsResettable) {
void *a[] = { 0 };
QMetaObject::metacall(obj, QMetaObject::ResetProperty, lastData->coreIndex, a);
} else if (value.isUndefined() && lastData->propType == qMetaTypeId<QVariant>()) {
QDeclarativePropertyPrivate::write(obj, *lastData, QVariant(), evalContext);
} else if (value.isUndefined()) {
QString error = QLatin1String("Cannot assign [undefined] to ") +
QLatin1String(QMetaType::typeName(lastData->propType));
context->throwError(error);
} else {
QVariant v;
if (lastData->flags & QDeclarativePropertyCache::Data::IsQList)
v = enginePriv->scriptValueToVariant(value, qMetaTypeId<QList<QObject *> >());
else
v = enginePriv->scriptValueToVariant(value, lastData->propType);
if (!QDeclarativePropertyPrivate::write(obj, *lastData, v, evalContext)) {
const char *valueType = 0;
if (v.userType() == QVariant::Invalid) valueType = "null";
else valueType = QMetaType::typeName(v.userType());
QString error = QLatin1String("Cannot assign ") +
QLatin1String(valueType) +
QLatin1String(" to ") +
QLatin1String(QMetaType::typeName(lastData->propType));
context->throwError(error);
}
}
}
bool operator==(const QScriptValue& first, const QScriptValue& second) {
if (first.isUndefined()) {
return second.isUndefined();
} else if (first.isNull()) {
return second.isNull();
} else if (first.isBool()) {
return second.isBool() && first.toBool() == second.toBool();
} else if (first.isNumber()) {
return second.isNumber() && first.toNumber() == second.toNumber();
} else if (first.isString()) {
return second.isString() && first.toString() == second.toString();
} else if (first.isVariant()) {
return second.isVariant() && first.toVariant() == second.toVariant();
} else if (first.isQObject()) {
return second.isQObject() && first.toQObject() == second.toQObject();
} else if (first.isQMetaObject()) {
return second.isQMetaObject() && first.toQMetaObject() == second.toQMetaObject();
} else if (first.isDate()) {
return second.isDate() && first.toDateTime() == second.toDateTime();
} else if (first.isRegExp()) {
return second.isRegExp() && first.toRegExp() == second.toRegExp();
} else if (first.isArray()) {
if (!second.isArray()) {
return false;
}
int length = first.property(ScriptCache::getInstance()->getLengthString()).toInt32();
if (second.property(ScriptCache::getInstance()->getLengthString()).toInt32() != length) {
return false;
}
for (int i = 0; i < length; i++) {
if (first.property(i) != second.property(i)) {
return false;
}
}
return true;
} else if (first.isObject()) {
if (!second.isObject()) {
return false;
}
int propertyCount = 0;
for (QScriptValueIterator it(first); it.hasNext(); ) {
it.next();
if (second.property(it.scriptName()) != it.value()) {
return false;
}
propertyCount++;
}
// make sure the second has exactly as many properties as the first
for (QScriptValueIterator it(second); it.hasNext(); ) {
it.next();
if (--propertyCount < 0) {
return false;
}
}
return true;
} else {
// if none of the above tests apply, first must be invalid
return !second.isValid();
}
}
void MetaCallArgument::fromScriptValue(int callType, QDeclarativeEngine *engine, const QScriptValue &value)
{
if (type != 0) { cleanup(); type = 0; }
if (callType == qMetaTypeId<QScriptValue>()) {
qscriptValuePtr = new (&allocData) QScriptValue(value);
type = qMetaTypeId<QScriptValue>();
} else if (callType == QMetaType::Int) {
intValue = quint32(value.toInt32());
type = callType;
} else if (callType == QMetaType::UInt) {
intValue = quint32(value.toUInt32());
type = callType;
} else if (callType == QMetaType::Bool) {
boolValue = value.toBool();
type = callType;
} else if (callType == QMetaType::Double) {
doubleValue = double(value.toNumber());
type = callType;
} else if (callType == QMetaType::Float) {
floatValue = float(value.toNumber());
type = callType;
} else if (callType == QMetaType::QString) {
if (value.isNull() || value.isUndefined())
qstringPtr = new (&allocData) QString();
else
qstringPtr = new (&allocData) QString(value.toString());
type = callType;
} else if (callType == QMetaType::QObjectStar) {
qobjectPtr = value.toQObject();
type = callType;
} else if (callType == qMetaTypeId<QVariant>()) {
QVariant other = QDeclarativeEnginePrivate::get(engine)->scriptValueToVariant(value);
qvariantPtr = new (&allocData) QVariant(other);
type = callType;
} else if (callType == qMetaTypeId<QList<QObject*> >()) {
qlistPtr = new (&allocData) QList<QObject *>();
if (value.isArray()) {
int length = value.property(QLatin1String("length")).toInt32();
for (int ii = 0; ii < length; ++ii) {
QScriptValue arrayItem = value.property(ii);
QObject *d = arrayItem.toQObject();
qlistPtr->append(d);
}
} else if (QObject *d = value.toQObject()) {
qlistPtr->append(d);
}
type = callType;
} else {
qvariantPtr = new (&allocData) QVariant();
type = -1;
QDeclarativeEnginePrivate *priv = QDeclarativeEnginePrivate::get(engine);
QVariant v = priv->scriptValueToVariant(value);
if (v.userType() == callType) {
*qvariantPtr = v;
} else if (v.canConvert((QVariant::Type)callType)) {
*qvariantPtr = v;
qvariantPtr->convert((QVariant::Type)callType);
} else if (const QMetaObject *mo = priv->rawMetaObjectForType(callType)) {
QObject *obj = priv->toQObject(v);
if (obj) {
const QMetaObject *objMo = obj->metaObject();
while (objMo && objMo != mo) objMo = objMo->superClass();
if (!objMo) obj = 0;
}
*qvariantPtr = QVariant(callType, &obj);
} else {
*qvariantPtr = QVariant(callType, (void *)0);
}
}
}
void QDeclarativeObjectScriptClass::setProperty(QObject *obj,
const Identifier &name,
const QScriptValue &value,
QScriptContext *context,
QDeclarativeContextData *evalContext)
{
Q_UNUSED(name);
Q_ASSERT(obj);
Q_ASSERT(lastData);
Q_ASSERT(context);
if (!lastData->isValid()) {
QString error = QLatin1String("Cannot assign to non-existent property \"") +
toString(name) + QLatin1Char('\"');
context->throwError(error);
return;
}
if (!(lastData->flags & QDeclarativePropertyCache::Data::IsWritable) &&
!(lastData->flags & QDeclarativePropertyCache::Data::IsQList)) {
QString error = QLatin1String("Cannot assign to read-only property \"") +
toString(name) + QLatin1Char('\"');
context->throwError(error);
return;
}
QDeclarativeEnginePrivate *enginePriv = QDeclarativeEnginePrivate::get(engine);
if (!evalContext) {
// Global object, QScriptContext activation object, QDeclarativeContext object
QScriptValue scopeNode = scopeChainValue(context, -3);
if (scopeNode.isValid()) {
Q_ASSERT(scriptClass(scopeNode) == enginePriv->contextClass);
evalContext = enginePriv->contextClass->contextFromValue(scopeNode);
}
}
QDeclarativeBinding *newBinding = 0;
if (value.isFunction() && !value.isRegExp()) {
QScriptContextInfo ctxtInfo(context);
QDeclarativePropertyCache::ValueTypeData valueTypeData;
newBinding = new QDeclarativeBinding(value, obj, evalContext);
newBinding->setSourceLocation(ctxtInfo.fileName(), ctxtInfo.functionStartLineNumber());
newBinding->setTarget(QDeclarativePropertyPrivate::restore(*lastData, valueTypeData, obj, evalContext));
if (newBinding->expression().contains(QLatin1String("this")))
newBinding->setEvaluateFlags(newBinding->evaluateFlags() | QDeclarativeBinding::RequiresThisObject);
}
QDeclarativeAbstractBinding *delBinding =
QDeclarativePropertyPrivate::setBinding(obj, lastData->coreIndex, -1, newBinding);
if (delBinding)
delBinding->destroy();
if (value.isNull() && lastData->flags & QDeclarativePropertyCache::Data::IsQObjectDerived) {
QObject *o = 0;
int status = -1;
int flags = 0;
void *argv[] = { &o, 0, &status, &flags };
QMetaObject::metacall(obj, QMetaObject::WriteProperty, lastData->coreIndex, argv);
} else if (value.isUndefined() && lastData->flags & QDeclarativePropertyCache::Data::IsResettable) {
void *a[] = { 0 };
QMetaObject::metacall(obj, QMetaObject::ResetProperty, lastData->coreIndex, a);
} else if (value.isUndefined() && lastData->propType == qMetaTypeId<QVariant>()) {
QDeclarativePropertyPrivate::write(obj, *lastData, QVariant(), evalContext);
} else if (value.isUndefined()) {
QString error = QLatin1String("Cannot assign [undefined] to ") +
QLatin1String(QMetaType::typeName(lastData->propType));
context->throwError(error);
} else if (value.isFunction() && !value.isRegExp()) {
// this is handled by the binding creation above
} else {
//### expand optimization for other known types
if (lastData->propType == QMetaType::Int && value.isNumber()) {
int rawValue = qRoundDouble(value.toNumber());
int status = -1;
int flags = 0;
void *a[] = { (void *)&rawValue, 0, &status, &flags };
QMetaObject::metacall(obj, QMetaObject::WriteProperty,
lastData->coreIndex, a);
return;
} else if (lastData->propType == QMetaType::QReal && value.isNumber()) {
qreal rawValue = qreal(value.toNumber());
int status = -1;
int flags = 0;
void *a[] = { (void *)&rawValue, 0, &status, &flags };
QMetaObject::metacall(obj, QMetaObject::WriteProperty,
lastData->coreIndex, a);
return;
} else if (lastData->propType == QMetaType::QString && value.isString()) {
const QString &rawValue = value.toString();
int status = -1;
int flags = 0;
void *a[] = { (void *)&rawValue, 0, &status, &flags };
QMetaObject::metacall(obj, QMetaObject::WriteProperty,
lastData->coreIndex, a);
return;
}
QVariant v;
if (lastData->flags & QDeclarativePropertyCache::Data::IsQList)
v = enginePriv->scriptValueToVariant(value, qMetaTypeId<QList<QObject *> >());
else
v = enginePriv->scriptValueToVariant(value, lastData->propType);
if (!QDeclarativePropertyPrivate::write(obj, *lastData, v, evalContext)) {
const char *valueType = 0;
if (v.userType() == QVariant::Invalid) valueType = "null";
else valueType = QMetaType::typeName(v.userType());
QString error = QLatin1String("Cannot assign ") +
QLatin1String(valueType) +
QLatin1String(" to ") +
QLatin1String(QMetaType::typeName(lastData->propType));
context->throwError(error);
}
}
}
bool JavascriptInstance::ImportExtension(const QString &scriptExtensionName)
{
// Currently QtScriptGenerator extensions are not supported on Android. Attempting to import is a fatal error for the script engine,
// so bypass for now
#ifdef ANDROID
LogWarning("JavascriptInstance::ImportExtension(" + scriptExtensionName + ") failed, script extensions not yet supported on Android");
return false;
#endif
assert(engine_);
if (!engine_)
{
LogWarning("JavascriptInstance::ImportExtension(" + scriptExtensionName + ") failed, QScriptEngine == null!");
return false;
}
QStringList qt_extension_whitelist;
QStringList qt_class_blacklist;
/// Allowed extension imports
qt_extension_whitelist << "qt.core" << "qt.gui" << "qt.xml" << "qt.xmlpatterns" << "qt.opengl" << "qt.webkit";
/// qt.core and qt.gui: Classes that may be harmful to your system from untrusted scripts
qt_class_blacklist << "QLibrary" << "QPluginLoader" << "QProcess" // process and library access
<< "QFile" << "QDir" << "QFileSystemModel" << "QDirModel" // file system access
<< "QFileDialog" << "QFileSystemWatcher" << "QFileInfo"
<< "QFileOpenEvent" << "QFileSystemModel"
<< "QClipboard" << "QDesktopServices"; // "system" access
/// qt.webkit: Initial blacklist, enabling some of these can be discussed.
/// Availble classes: QWebView, QGraphicsWebView, QWebPage, QWebFrame
qt_class_blacklist << "QWebDatabase" << "QWebElement" << "QWebElementCollection" << "QWebHistory" << "QWebHistoryInterface" << "QWebHistoryItem"
<< "QWebHitTestResult" << "QWebInspector" << "QWebPluginFactory" << "QWebSecurityOrigin" << "QWebSettings";
if (!trusted_ && !qt_extension_whitelist.contains(scriptExtensionName, Qt::CaseInsensitive))
{
LogWarning("JavascriptInstance::ImportExtension: refusing to load a QtScript plugin for an untrusted instance: " + scriptExtensionName);
return false;
}
bool ret = true;
QScriptValue success = engine_->importExtension(scriptExtensionName);
if (!success.isUndefined()) // Yes, importExtension returns undefinedValue if the import succeeds. http://doc.qt.nokia.com/4.7/qscriptengine.html#importExtension
{
LogWarning("JavascriptInstance::ImportExtension: Failed to load " + scriptExtensionName + " plugin for QtScript!");
ret = false;
}
if (!trusted_)
{
QScriptValue exposed;
foreach (const QString &blacktype, qt_class_blacklist)
{
exposed = engine_->globalObject().property(blacktype);
if (exposed.isValid())
{
engine_->globalObject().setProperty(blacktype, QScriptValue()); //passing an invalid val removes the property, http://doc.qt.nokia.com/4.6/qscriptvalue.html#setProperty
//LogInfo("JavascriptInstance::ImportExtension: removed a type from the untrusted context: " + blacktype);
}
}
void DefaultScriptClass::setProperty(QScriptValue& object, const QScriptString& name, uint id, const QScriptValue& value)
{
const ScriptHandlerInfo::Mode mode = mHandlerInfo->mode();
Q_ASSERT(mode != ScriptHandlerInfo::None);
DataInformation* data = toDataInformation(object);
if (!data)
{
mHandlerInfo->logger()->error() << "could not cast data from" << object.data().toString();
engine()->currentContext()->throwError(QScriptContext::ReferenceError,
QStringLiteral("Attempting to access an invalid object"));
return;
}
if (mode == ScriptHandlerInfo::Validating)
{
//only way write access is allowed is when validating: valid and validationError
if (data->hasBeenValidated())
data->logError() << "Cannot modify this object, it has already been validated!";
else if (name == s_valid)
data->mValidationSuccessful = value.toBool();
else if (name == s_validationError)
data->setValidationError(value.toString());
else
data->logError() << "Cannot write to property" << name.toString() << "while validating!";
return;
}
if (mode != ScriptHandlerInfo::Updating)
{
data->logError() << "Writing to property" << name.toString() << "is only allowed when updating.";
return;
}
Q_ASSERT(mode == ScriptHandlerInfo::Updating);
if (name == s_byteOrder)
{
data->setByteOrder(ParserUtils::byteOrderFromString(value.toString(),
LoggerWithContext(data->logger(), data->fullObjectPath())));
}
else if (name == s_datatype)
{
//change the type of the underlying object
setDataType(value, data);
}
else if (name == s_updateFunc)
{
data->setUpdateFunc(value);
}
else if (name == s_validationFunc)
{
data->setValidationFunc(value);
}
else if (name == s_name)
{
data->setName(value.toString());
}
else if (name == s_customTypeName)
{
if (!value.isValid() || value.isNull() || value.isUndefined())
data->setCustomTypeName(QString()); //unset
else
data->setCustomTypeName(value.toString());
}
else if (name == s_asStringFunc)
{
data->setToStringFunction(value);
}
else
{
bool setAdditional = setAdditionalProperty(data, name, id, value);
if (setAdditional)
return;
else
{
data->logError() << "could not set property with name" << name.toString();
engine()->currentContext()->throwError(QScriptContext::ReferenceError,
QStringLiteral("Cannot write property ") + name.toString());
}
}
}
QVariant QDeclarativeExpressionPrivate::evalQtScript(QObject *secondaryScope, bool *isUndefined)
{
QDeclarativeExpressionData *data = this->data;
QDeclarativeEngine *engine = data->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 QVariant();
}
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) {
oldSharedContext = ep->sharedContext;
oldSharedScope = ep->sharedScope;
ep->sharedContext = data->context();
ep->sharedScope = data->me;
} else {
oldOverride = ep->contextClass->setOverrideObject(data->expressionContext, secondaryScope);
}
QScriptValue svalue = data->expressionFunction.call();
if (data->isShared) {
ep->sharedContext = oldSharedContext;
ep->sharedScope = oldSharedScope;
} else {
ep->contextClass->setOverrideObject(data->expressionContext, oldOverride);
}
if (isUndefined)
*isUndefined = svalue.isUndefined() || scriptEngine->hasUncaughtException();
// Handle exception
if (scriptEngine->hasUncaughtException()) {
exceptionToError(scriptEngine, data->error);
scriptEngine->clearExceptions();
return QVariant();
} else {
data->error = QDeclarativeError();
}
QVariant rv;
if (svalue.isArray()) {
int length = svalue.property(QLatin1String("length")).toInt32();
if (length && svalue.property(0).isObject()) {
QList<QObject *> list;
for (int ii = 0; ii < length; ++ii) {
QScriptValue arrayItem = svalue.property(ii);
QObject *d = arrayItem.toQObject();
list << d;
}
rv = QVariant::fromValue(list);
}
} else if (svalue.isObject() &&
ep->objectClass->scriptClass(svalue) == ep->objectClass) {
QObject *o = svalue.toQObject();
int type = QMetaType::QObjectStar;
// If the object is null, we extract the predicted type. While this isn't
// 100% reliable, in many cases it gives us better error messages if we
// assign this null-object to an incompatible property
if (!o) type = ep->objectClass->objectType(svalue);
return QVariant(type, &o);
}
if (rv.isNull())
rv = svalue.toVariant();
return rv;
}
void tst_QScriptClass::extension()
{
QScriptEngine eng;
{
TestClass cls(&eng);
cls.setCallableMode(TestClass::NotCallable);
QVERIFY(!cls.supportsExtension(QScriptClass::Callable));
QVERIFY(!cls.supportsExtension(QScriptClass::HasInstance));
QScriptValue obj = eng.newObject(&cls);
QVERIFY(!obj.call().isValid());
QCOMPARE((int)cls.lastExtensionType(), -1);
QVERIFY(!obj.instanceOf(obj));
QCOMPARE((int)cls.lastExtensionType(), -1);
}
// Callable
{
TestClass cls(&eng);
cls.setCallableMode(TestClass::CallableReturnsSum);
QVERIFY(cls.supportsExtension(QScriptClass::Callable));
QScriptValue obj = eng.newObject(&cls);
eng.globalObject().setProperty("obj", obj);
obj.setProperty("one", QScriptValue(&eng, 1));
obj.setProperty("two", QScriptValue(&eng, 2));
obj.setProperty("three", QScriptValue(&eng, 3));
// From C++
cls.clearReceivedArgs();
{
QScriptValueList args;
args << QScriptValue(&eng, 4) << QScriptValue(&eng, 5);
QScriptValue ret = obj.call(obj, args);
QCOMPARE(cls.lastExtensionType(), QScriptClass::Callable);
QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptContext*>());
QVERIFY(ret.isNumber());
QCOMPARE(ret.toNumber(), qsreal(15));
}
// From JS
cls.clearReceivedArgs();
{
QScriptValue ret = eng.evaluate("obj(4, 5)");
QCOMPARE(cls.lastExtensionType(), QScriptClass::Callable);
QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptContext*>());
QVERIFY(ret.isNumber());
QCOMPARE(ret.toNumber(), qsreal(15));
}
cls.setCallableMode(TestClass::CallableReturnsArgument);
// From C++
cls.clearReceivedArgs();
{
QScriptValue ret = obj.call(obj, QScriptValueList() << 123);
QCOMPARE(cls.lastExtensionType(), QScriptClass::Callable);
QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptContext*>());
QVERIFY(ret.isNumber());
QCOMPARE(ret.toInt32(), 123);
}
cls.clearReceivedArgs();
{
QScriptValue ret = obj.call(obj, QScriptValueList() << true);
QCOMPARE(cls.lastExtensionType(), QScriptClass::Callable);
QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptContext*>());
QVERIFY(ret.isBoolean());
QCOMPARE(ret.toBoolean(), true);
}
{
QScriptValue ret = obj.call(obj, QScriptValueList() << QString::fromLatin1("ciao"));
QVERIFY(ret.isString());
QCOMPARE(ret.toString(), QString::fromLatin1("ciao"));
}
{
QScriptValue objobj = eng.newObject();
QScriptValue ret = obj.call(obj, QScriptValueList() << objobj);
QVERIFY(ret.isObject());
QVERIFY(ret.strictlyEquals(objobj));
}
{
QScriptValue ret = obj.call(obj, QScriptValueList() << QScriptValue());
QVERIFY(ret.isUndefined());
}
// From JS
cls.clearReceivedArgs();
{
QScriptValue ret = eng.evaluate("obj(123)");
QVERIFY(ret.isNumber());
QCOMPARE(ret.toInt32(), 123);
}
cls.setCallableMode(TestClass::CallableReturnsInvalidVariant);
{
QScriptValue ret = obj.call(obj);
QVERIFY(ret.isUndefined());
}
cls.setCallableMode(TestClass::CallableReturnsThisObject);
// From C++
{
QScriptValue ret = obj.call(obj);
QVERIFY(ret.isObject());
QVERIFY(ret.strictlyEquals(obj));
}
// From JS
{
QScriptValue ret = eng.evaluate("obj()");
QVERIFY(ret.isObject());
QVERIFY(ret.strictlyEquals(eng.globalObject()));
}
cls.setCallableMode(TestClass::CallableReturnsCallee);
// From C++
{
QScriptValue ret = obj.call();
QVERIFY(ret.isObject());
QVERIFY(ret.strictlyEquals(obj));
}
// From JS
{
QScriptValue ret = eng.evaluate("obj()");
QVERIFY(ret.isObject());
QVERIFY(ret.strictlyEquals(obj));
}
cls.setCallableMode(TestClass::CallableReturnsArgumentsObject);
// From C++
{
QScriptValue ret = obj.call(obj, QScriptValueList() << 123);
QVERIFY(ret.isObject());
QVERIFY(ret.property("length").isNumber());
QCOMPARE(ret.property("length").toInt32(), 1);
QVERIFY(ret.property(0).isNumber());
QCOMPARE(ret.property(0).toInt32(), 123);
}
// From JS
{
QScriptValue ret = eng.evaluate("obj(123)");
QVERIFY(ret.isObject());
QVERIFY(ret.property("length").isNumber());
QCOMPARE(ret.property("length").toInt32(), 1);
QVERIFY(ret.property(0).isNumber());
QCOMPARE(ret.property(0).toInt32(), 123);
}
// construct()
// From C++
cls.clearReceivedArgs();
cls.setCallableMode(TestClass::CallableReturnsGlobalObject);
{
QScriptValue ret = obj.construct();
QCOMPARE(cls.lastExtensionType(), QScriptClass::Callable);
QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptContext*>());
QVERIFY(ret.isObject());
QVERIFY(ret.strictlyEquals(eng.globalObject()));
}
// From JS
cls.clearReceivedArgs();
{
QScriptValue ret = eng.evaluate("new obj()");
QCOMPARE(cls.lastExtensionType(), QScriptClass::Callable);
QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptContext*>());
QVERIFY(ret.isObject());
QVERIFY(ret.strictlyEquals(eng.globalObject()));
}
// From C++
cls.clearReceivedArgs();
cls.setCallableMode(TestClass::CallableInitializesThisObject);
{
QScriptValue ret = obj.construct();
QCOMPARE(cls.lastExtensionType(), QScriptClass::Callable);
QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptContext*>());
QVERIFY(ret.isQObject());
QCOMPARE(ret.toQObject(), (QObject*)&eng);
}
// From JS
cls.clearReceivedArgs();
{
QScriptValue ret = eng.evaluate("new obj()");
QCOMPARE(cls.lastExtensionType(), QScriptClass::Callable);
QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptContext*>());
QVERIFY(ret.isQObject());
QCOMPARE(ret.toQObject(), (QObject*)&eng);
}
}
// HasInstance
{
TestClass cls(&eng);
cls.setHasInstance(true);
QVERIFY(cls.supportsExtension(QScriptClass::HasInstance));
QScriptValue obj = eng.newObject(&cls);
obj.setProperty("foo", QScriptValue(&eng, 123));
QScriptValue plain = eng.newObject();
QVERIFY(!plain.instanceOf(obj));
eng.globalObject().setProperty("HasInstanceTester", obj);
eng.globalObject().setProperty("hasInstanceValue", plain);
cls.clearReceivedArgs();
{
QScriptValue ret = eng.evaluate("hasInstanceValue instanceof HasInstanceTester");
QCOMPARE(cls.lastExtensionType(), QScriptClass::HasInstance);
QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptValueList>());
QScriptValueList lst = qvariant_cast<QScriptValueList>(cls.lastExtensionArgument());
QCOMPARE(lst.size(), 2);
QVERIFY(lst.at(0).strictlyEquals(obj));
QVERIFY(lst.at(1).strictlyEquals(plain));
QVERIFY(ret.isBoolean());
QVERIFY(!ret.toBoolean());
}
plain.setProperty("foo", QScriptValue(&eng, 456));
QVERIFY(!plain.instanceOf(obj));
{
QScriptValue ret = eng.evaluate("hasInstanceValue instanceof HasInstanceTester");
QVERIFY(ret.isBoolean());
QVERIFY(!ret.toBoolean());
}
plain.setProperty("foo", obj.property("foo"));
QVERIFY(plain.instanceOf(obj));
{
QScriptValue ret = eng.evaluate("hasInstanceValue instanceof HasInstanceTester");
QVERIFY(ret.isBoolean());
QVERIFY(ret.toBoolean());
}
}
}
QString ActionInstance::evaluateTextString(bool &ok, const QString &toEvaluate, int &position)
{
ok = true;
int startIndex = position;
QString result;
while(position < toEvaluate.length())
{
if(toEvaluate[position] == QLatin1Char('$'))
{
//find a variable name
if(VariableRegExp.indexIn(toEvaluate, position) != -1)
{
QString foundVariableName = VariableRegExp.cap(1);
QScriptValue foundVariable = d->scriptEngine->globalObject().property(foundVariableName);
position += foundVariableName.length();
if(!foundVariable.isValid())
{
ok = false;
emit executionException(ActionException::InvalidParameterException, tr("Undefined variable \"%1\"").arg(foundVariableName));
return QString();
}
QString stringEvaluationResult;
if(foundVariable.isNull())
stringEvaluationResult = QStringLiteral("[Null]");
else if(foundVariable.isUndefined())
stringEvaluationResult = QStringLiteral("[Undefined]");
else if(foundVariable.isArray())
{
while((position + 1 < toEvaluate.length()) && toEvaluate[position + 1] == QLatin1Char('['))
{
position += 2;
QString indexArray = evaluateTextString(ok, toEvaluate, position);
if((position < toEvaluate.length()) && toEvaluate[position] == QLatin1Char(']'))
{
QScriptString internalIndexArray = d->scriptEngine->toStringHandle(indexArray);
bool flag = true;
int numIndex = internalIndexArray.toArrayIndex(&flag);
if(flag) //numIndex is valid
foundVariable = foundVariable.property(numIndex);
else //use internalIndexArray
foundVariable = foundVariable.property(internalIndexArray);
}
else
{
//syntax error
ok = false;
emit executionException(ActionException::InvalidParameterException, tr("Invalid parameter. Unable to evaluate string"));
return QString();
}
//COMPATIBILITY: we break the while loop if foundVariable is no more of Array type
if(!foundVariable.isArray())
break;
}
//end of while, no more '['
if(foundVariable.isArray())
stringEvaluationResult = evaluateVariableArray(ok, foundVariable);
else
stringEvaluationResult = foundVariable.toString();
}
else if(foundVariable.isVariant())
{
QVariant variantEvaluationResult = foundVariable.toVariant();
switch(variantEvaluationResult.type())
{
case QVariant::StringList:
stringEvaluationResult = variantEvaluationResult.toStringList().join(QStringLiteral("\n"));
break;
case QVariant::ByteArray:
stringEvaluationResult = QStringLiteral("[Raw data]");
break;
default:
stringEvaluationResult = foundVariable.toString();
break;
}
}
else
stringEvaluationResult = foundVariable.toString();
result.append(stringEvaluationResult);
}
}
else if (toEvaluate[position] == QLatin1Char(']'))
{
if(startIndex == 0)
//in top level evaluation isolated character ']' is accepted (for compatibility reason), now prefer "\]"
//i.e without matching '['
result.append(toEvaluate[position]);
else
//on other levels, the parsing is stopped at this point
return result;
}
else if(toEvaluate[position] == QLatin1Char('\\'))
{
if(startIndex == 0)
{
//for ascendant compatibility reason
//in top level evaluation '\' is not only an escape character,
//but can also be a standard character in some cases
if((position + 1) < toEvaluate.length())
{
position++;
if(toEvaluate[position] == QLatin1Char('$') || toEvaluate[position] == QLatin1Char('[') || toEvaluate[position] == QLatin1Char(']') || toEvaluate[position] == QLatin1Char('\\'))
result.append(toEvaluate[position]);
else
{
position--;
result.append(toEvaluate[position]);
}
}
else
result.append(toEvaluate[position]);
}
else
{
position++;
if( position < toEvaluate.length() )
result.append(toEvaluate[position]);
}
}
else
result.append(toEvaluate[position]);
position++;
}
return result;
}
static void convertToPropertyType_impl(const QString &pathPropertiesBaseDir, const Item *item,
const PropertyDeclaration& decl,
const CodeLocation &location, QScriptValue &v)
{
if (v.isUndefined() || v.isError())
return;
QString srcDir;
QString actualBaseDir;
if (item && !pathPropertiesBaseDir.isEmpty()) {
const VariantValueConstPtr itemSourceDir
= item->variantProperty(QLatin1String("sourceDirectory"));
actualBaseDir = itemSourceDir ? itemSourceDir->value().toString() : pathPropertiesBaseDir;
}
switch (decl.type()) {
case PropertyDeclaration::UnknownType:
case PropertyDeclaration::Variant:
break;
case PropertyDeclaration::Boolean:
if (!v.isBool())
v = v.toBool();
break;
case PropertyDeclaration::Integer:
if (!v.isNumber())
makeTypeError(decl, location, v);
break;
case PropertyDeclaration::Path:
{
if (!v.isString()) {
makeTypeError(decl, location, v);
break;
}
const QString srcDir = item ? overriddenSourceDirectory(item, actualBaseDir)
: pathPropertiesBaseDir;
if (!srcDir.isEmpty())
v = v.engine()->toScriptValue(QDir::cleanPath(
FileInfo::resolvePath(srcDir, v.toString())));
break;
}
case PropertyDeclaration::String:
if (!v.isString())
makeTypeError(decl, location, v);
break;
case PropertyDeclaration::PathList:
srcDir = item ? overriddenSourceDirectory(item, actualBaseDir)
: pathPropertiesBaseDir;
// Fall-through.
case PropertyDeclaration::StringList:
{
if (!v.isArray()) {
QScriptValue x = v.engine()->newArray(1);
x.setProperty(0, v);
v = x;
}
const quint32 c = v.property(StringConstants::lengthProperty()).toUInt32();
for (quint32 i = 0; i < c; ++i) {
QScriptValue elem = v.property(i);
if (elem.isUndefined()) {
ErrorInfo error(Tr::tr("Element at index %1 of list property '%2' is undefined. "
"String expected.").arg(i).arg(decl.name()), location);
makeTypeError(error, v);
break;
}
if (elem.isNull()) {
ErrorInfo error(Tr::tr("Element at index %1 of list property '%2' is null. "
"String expected.").arg(i).arg(decl.name()), location);
makeTypeError(error, v);
break;
}
if (!elem.isString()) {
ErrorInfo error(Tr::tr("Element at index %1 of list property '%2' does not have "
"string type.").arg(i).arg(decl.name()), location);
makeTypeError(error, v);
break;
}
if (srcDir.isEmpty())
continue;
elem = v.engine()->toScriptValue(
QDir::cleanPath(FileInfo::resolvePath(srcDir, elem.toString())));
v.setProperty(i, elem);
}
break;
}
case PropertyDeclaration::VariantList:
if (!v.isArray()) {
QScriptValue x = v.engine()->newArray(1);
x.setProperty(0, v);
v = x;
}
break;
}
}
//! [67]
QScriptValue sort(QScriptContext *ctx, QScriptEngine *eng)
{
QScriptValue comparefn = ctx->argument(0);
if (comparefn.isUndefined())
comparefn = /* the built-in comparison function */;
else if (!comparefn.isFunction())
void tst_QScriptValueGenerated::isUndefined_test(const char*, const QScriptValue& value)
{
QFETCH(bool, expected);
QCOMPARE(value.isUndefined(), expected);
QCOMPARE(value.isUndefined(), expected);
}
void tst_QScriptClass::extension()
{
QScriptEngine eng;
{
TestClass cls(&eng);
cls.setCallableMode(TestClass::NotCallable);
QVERIFY(!cls.supportsExtension(QScriptClass::Callable));
QVERIFY(!cls.supportsExtension(QScriptClass::HasInstance));
}
// Callable
{
TestClass cls(&eng);
cls.setCallableMode(TestClass::CallableReturnsSum);
QVERIFY(cls.supportsExtension(QScriptClass::Callable));
QScriptValue obj = eng.newObject(&cls);
obj.setProperty("one", QScriptValue(&eng, 1));
obj.setProperty("two", QScriptValue(&eng, 2));
obj.setProperty("three", QScriptValue(&eng, 3));
{
QScriptValueList args;
args << QScriptValue(&eng, 4) << QScriptValue(&eng, 5);
QScriptValue ret = obj.call(obj, args);
QCOMPARE(ret.toNumber(), qsreal(15));
}
cls.setCallableMode(TestClass::CallableReturnsArgument);
{
QScriptValue ret = obj.call(obj, QScriptValueList() << 123);
QVERIFY(ret.isNumber());
QCOMPARE(ret.toInt32(), 123);
}
{
QScriptValue ret = obj.call(obj, QScriptValueList() << true);
QVERIFY(ret.isBoolean());
QCOMPARE(ret.toBoolean(), true);
}
{
QScriptValue ret = obj.call(obj, QScriptValueList() << QString::fromLatin1("ciao"));
QVERIFY(ret.isString());
QCOMPARE(ret.toString(), QString::fromLatin1("ciao"));
}
{
QScriptValue objobj = eng.newObject();
QScriptValue ret = obj.call(obj, QScriptValueList() << objobj);
QVERIFY(ret.isObject());
QVERIFY(ret.strictlyEquals(objobj));
}
{
QScriptValue ret = obj.call(obj, QScriptValueList() << QScriptValue());
QVERIFY(ret.isUndefined());
}
cls.setCallableMode(TestClass::CallableReturnsInvalidVariant);
{
QScriptValue ret = obj.call(obj);
QVERIFY(ret.isUndefined());
}
}
// HasInstance
{
TestClass cls(&eng);
cls.setHasInstance(true);
QVERIFY(cls.supportsExtension(QScriptClass::HasInstance));
QScriptValue obj = eng.newObject(&cls);
obj.setProperty("foo", QScriptValue(&eng, 123));
QScriptValue plain = eng.newObject();
QVERIFY(!plain.instanceOf(obj));
eng.globalObject().setProperty("HasInstanceTester", obj);
eng.globalObject().setProperty("hasInstanceValue", plain);
{
QScriptValue ret = eng.evaluate("hasInstanceValue instanceof HasInstanceTester");
QVERIFY(ret.isBoolean());
QVERIFY(!ret.toBoolean());
}
plain.setProperty("foo", QScriptValue(&eng, 456));
QVERIFY(!plain.instanceOf(obj));
{
QScriptValue ret = eng.evaluate("hasInstanceValue instanceof HasInstanceTester");
QVERIFY(ret.isBoolean());
QVERIFY(!ret.toBoolean());
}
plain.setProperty("foo", obj.property("foo"));
QVERIFY(plain.instanceOf(obj));
{
QScriptValue ret = eng.evaluate("hasInstanceValue instanceof HasInstanceTester");
QVERIFY(ret.isBoolean());
QVERIFY(ret.toBoolean());
}
}
}
void Color::fromScriptValue(const QScriptValue &object)
{
// red component
QScriptValue value = object.property("r");
if ((!value.isValid()) || (value.isUndefined()))
{
// property is not valid or Undefined. set to 0, not the default NaN
m_r = 0;
}
else
{
// convert to unsigned integer
quint32 r = value.toUInt32();
if (r > MAX_COLOR_VALUE)
{
// clip value
m_r = MAX_COLOR_VALUE;
}
else
{
m_r = r;
}
}
// green component
value = object.property("g");
if ((!value.isValid()) || (value.isUndefined()))
{
// property is not valid or Undefined. set to 0, not the default NaN
m_g = 0;
}
else
{
// convert to unsigned integer
quint32 g = value.toUInt32();
if (g > MAX_COLOR_VALUE)
{
// clip value
m_g = MAX_COLOR_VALUE;
}
else
{
m_g = g;
}
}
// blue component
value = object.property("b");
if ((!value.isValid()) || (value.isUndefined()))
{
// property is Undefined. set to 0, not the default NaN
m_b = 0;
}
else
{
// convert to unsigned integer
quint32 b = value.toUInt32();
if (b > MAX_COLOR_VALUE)
{
// clip value
m_b = MAX_COLOR_VALUE;
}
else
{
m_b = b;
}
}
}
