/*!
Returns true if this QScriptString is equal to \a other;
otherwise returns false.
*/
bool QScriptString::operator==(const QScriptString &other) const
{
Q_D(const QScriptString);
if (!d || !other.d_func())
return d == other.d_func();
return d->identifier == other.d_func()->identifier;
}
QScriptValue::PropertyFlags TestClassPropertyIterator::flags() const
{
QScriptString key = m_props.keys().value(m_last);
if (!key.isValid())
return 0;
TestClass::CustomProperty *prop = m_props.value(key);
return prop->pflags;
}
uint TestClassPropertyIterator::id() const
{
QScriptString key = m_props.keys().value(m_last);
if (!key.isValid())
return 0;
TestClass::CustomProperty *prop = m_props.value(key);
return prop->id;
}
QScriptValue::PropertyFlags DefaultScriptClass::propertyFlags(const QScriptValue& object, const QScriptString& name, uint id)
{
QScriptValue::PropertyFlags result;
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 0;
}
if (name == s_valid || name == s_validationError)
{
if (mode != ScriptHandlerInfo::Validating)
result |= QScriptValue::ReadOnly;
}
else if (mode != ScriptHandlerInfo::Updating)
{
result |= QScriptValue::ReadOnly;
}
for (int i = 0, size = mIterableProperties.size(); i < size; ++i) {
if (mIterableProperties.at(i).first == name)
return result | mIterableProperties.at(i).second;
}
if (additionalPropertyFlags(data, name, id, &result))
return result; //is a child element
else
{
data->logError() << "could not find flags for property with name" << name.toString();
return 0;
}
}
void ScriptDataItem::setProperty(QScriptValue &object, const QScriptString &name,
uint id, const QScriptValue &value)
{
Q_UNUSED(id);
DataItem *item = get_data_item(object);
item->setProperty(name.toString().toUtf8(), value.toVariant());
}
QScriptClass::QueryFlags ScShiftPropertyContainer::queryProperty(const QScriptValue &object, const QScriptString &name, QueryFlags flags, uint *id)
{
ScProfileFunction
SPropertyContainer *prop = (*unpackValue(object))->uncheckedCastTo<SPropertyContainer>();
if (!prop)
{
xAssertFail();
return 0;
}
*id = (uint)-1;
bool isArrayIndex = false;
qint32 pos = name.toArrayIndex(&isArrayIndex);
if(isArrayIndex)
{
*id = pos;
return flags;
}
else
{
SProperty *child = prop->findChild(name);
if(child)
{
return flags;
}
}
return 0;
}
QScriptValue ScriptMessage::property(const QScriptValue &object, const QScriptString &name, uint id)
{
Q_UNUSED(id);
Message *msg = message_get_value(object);
if (name == m_incoming)
return msg->isIncoming();
return engine()->toScriptValue(msg->property(name.toString().toUtf8()));
}
/*!
Returns the flags of the property with the given \a name, using the
given \a mode to resolve the property.
\sa property()
*/
QScriptValue::PropertyFlags QScriptValue::propertyFlags(const QScriptString &name,
const ResolveFlags &mode) const
{
if (!name.isValid())
return 0;
QScriptStringPrivate *s = QScriptStringPrivate::get(name);
return QScriptValuePrivate::valueOf(*this).propertyFlags(s->nameId, mode);
}
QScriptClass::QueryFlags DefaultScriptClass::queryProperty(const QScriptValue& object,
const QScriptString& name, QScriptClass::QueryFlags flags, uint* id)
{
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 0;
}
if (name == s_valid || name == s_validationError)
{
return mode == ScriptHandlerInfo::Validating ? flags : flags & ~HandlesWriteAccess;
}
if (mode != ScriptHandlerInfo::Updating)
{
//the only properties that are possibly writable when not updating are valid and validationError
//but we checked them before so we remove handlesWriteAccess from the flags
flags &= ~HandlesWriteAccess;
}
if (name == s_byteOrder || name == s_name || name == s_updateFunc || name == s_validationFunc
|| name == s_datatype || name == s_customTypeName || name == s_asStringFunc)
{
return flags;
}
else if (name == s_wasAbleToRead || name == s_parent)
{
return flags & ~HandlesWriteAccess;
}
else if (queryAdditionalProperty(data, name, &flags, id))
{
return flags;
}
else
{
data->logError() << "could not find property with name" << name.toString();
engine()->currentContext()->throwError(QScriptContext::ReferenceError,
QStringLiteral("Could not find property with name ") + name.toString());
return 0;
}
}
QScriptValue ScriptDataItem::property(const QScriptValue &object, const QScriptString &name, uint id)
{
Q_UNUSED(id);
if (name == m_subitem)
return m_subitemFunc;
if (name == m_subitems)
return m_subitemsFunc;
DataItem *item = get_data_item(object);
debug() << Q_FUNC_INFO << item << (object.objectId() == m_prototype.objectId());
Q_ASSERT(item);
QVariant data = item->property(name.toString().toUtf8());
if (data.isNull()) {
DataItem subitem = item->subitem(name.toString());
if (!subitem.isNull())
return engine()->toScriptValue(subitem);
return engine()->undefinedValue();
}
return engine()->newVariant(data);
}
/*
var conference = qutim.protocol("jabber").account("*****@*****.**").unit("*****@*****.**", false);
var msg = new Message;
msg.text = "Hi!";
conference.sendMessage(msg);
*/
void ScriptMessage::setProperty(QScriptValue &object, const QScriptString &name,
uint id, const QScriptValue &value)
{
Q_UNUSED(id);
Message *msg = message_get_value(object);
if (name == m_incoming)
msg->setIncoming(value.toBool());
else
msg->setProperty(name.toString().toUtf8(), value.toVariant());
}
void QDeclarativeGlobalScriptClass::setProperty(QScriptValue &object,
const QScriptString &name,
uint id, const QScriptValue &value)
{
Q_UNUSED(object);
Q_UNUSED(id);
Q_UNUSED(value);
QString error = QLatin1String("Invalid write to global property \"") +
name.toString() + QLatin1Char('\"');
engine()->currentContext()->throwError(error);
}
/*!
\since 4.4
Returns the flags of the property with the given \a name, using the
given \a mode to resolve the property.
\sa property()
*/
QScriptValue::PropertyFlags QScriptValue::propertyFlags(const QScriptString &name,
const ResolveFlags &mode) const
{
Q_D(const QScriptValue);
if (!d)
return 0;
if (!name.isValid())
return 0;
QScriptStringPrivate *s = QScriptStringPrivate::get(name);
return d->value.propertyFlags(s->nameId, mode);
}
/*!
\since 4.4
Returns the value of this QScriptValue's property with the given \a name,
using the given \a mode to resolve the property.
This overload of property() is useful when you need to look up the
same property repeatedly, since the lookup can be performed faster
when the name is represented as an interned string.
\sa QScriptEngine::toStringHandle(), setProperty()
*/
QScriptValue QScriptValue::property(const QScriptString &name,
const ResolveFlags &mode) const
{
Q_D(const QScriptValue);
if (!d || !d->value.isObject())
return QScriptValue();
if (!name.isValid())
return QScriptValue();
QScriptStringPrivate *s = QScriptStringPrivate::get(name);
QScriptEnginePrivate *eng = QScriptEnginePrivate::get(engine());
return eng->toPublic(d->value.property(s->nameId, mode));
}
QScriptValue propertyHelper(const QByteArray* arrayBuffer, const QScriptString& name, uint id) {
bool ok = false;
name.toArrayIndex(&ok);
if (ok && arrayBuffer) {
QDataStream stream(*arrayBuffer);
stream.skipRawData(id);
T result;
stream >> result;
return result;
}
/*!
\since 4.4
Sets the value of this QScriptValue's property with the given \a
name to the given \a value. The given \a flags specify how this
property may be accessed by script code.
This overload of setProperty() is useful when you need to set the
same property repeatedly, since the operation can be performed
faster when the name is represented as an interned string.
\sa QScriptEngine::toStringHandle()
*/
void QScriptValue::setProperty(const QScriptString &name,
const QScriptValue &value,
const PropertyFlags &flags)
{
Q_D(QScriptValue);
if (!d || !d->value.isObject() || !name.isValid())
return;
if (value.engine() && (value.engine() != engine())) {
qWarning("QScriptValue::setProperty() failed: "
"cannot set value created in a different engine");
return;
}
QScriptStringPrivate *s = QScriptStringPrivate::get(name);
d->value.setProperty(s->nameId, d->value.engine()->toImpl(value), flags);
}
/*!
Sets the value of this QScriptValue's property with the given \a
name to the given \a value. The given \a flags specify how this
property may be accessed by script code.
This overload of setProperty() is useful when you need to set the
same property repeatedly, since the operation can be performed
faster when the name is represented as an interned string.
\sa QScriptEngine::toStringHandle()
*/
void QScriptValue::setProperty(const QScriptString &name,
const QScriptValue &value,
const PropertyFlags &flags)
{
if (!name.isValid())
return;
if (isValid() && value.isValid() && (value.engine() != engine())) {
qWarning("QScriptValue::setProperty() failed: "
"cannot set value created in a different engine");
return;
}
QScriptStringPrivate *s = QScriptStringPrivate::get(name);
QScriptValuePrivate::valueOf(*this).setProperty(
s->nameId, QScriptValuePrivate::valueOf(value), flags);
}
QScriptClass::QueryFlags ByteArrayClass::queryProperty(const QScriptValue &object,
const QScriptString &name,
QueryFlags flags, uint *id) {
QByteArray *ba = qscriptvalue_cast<QByteArray*>(object.data());
if (!ba)
return 0;
if (name == length) {
return flags;
} else {
bool isArrayIndex;
qint32 pos = name.toArrayIndex(&isArrayIndex);
if (!isArrayIndex)
return 0;
*id = pos;
if ((flags & HandlesReadAccess) && (pos >= ba->size()))
flags &= ~HandlesReadAccess;
return flags;
}
}
QScriptClass::QueryFlags TypedArray::queryProperty(const QScriptValue& object,
const QScriptString& name,
QueryFlags flags, uint* id) {
if (name == _bytesPerElementName || name == _lengthName) {
return flags &= HandlesReadAccess; // Only keep read access flags
}
quint32 byteOffset = object.data().property(_byteOffsetName).toInt32();
quint32 length = object.data().property(_lengthName).toInt32();
bool ok = false;
quint32 pos = name.toArrayIndex(&ok);
// Check that name is a valid index and arrayBuffer exists
if (ok && pos < length) {
*id = byteOffset + pos * _bytesPerElement; // save pos to avoid recomputation
return HandlesReadAccess | HandlesWriteAccess; // Read/Write access
}
return ArrayBufferViewClass::queryProperty(object, name, flags, id);
}
PropertyStackManager(const Item *itemOfProperty, const QScriptString &name, const Value *value,
std::stack<QualifiedId> &requestedProperties,
PropertyDependencies &propertyDependencies)
: m_requestedProperties(requestedProperties)
{
if (value->type() == Value::JSSourceValueType
&& (itemOfProperty->type() == ItemType::ModuleInstance
|| itemOfProperty->type() == ItemType::Module
|| itemOfProperty->type() == ItemType::Export)) {
const VariantValueConstPtr varValue
= itemOfProperty->variantProperty(StringConstants::nameProperty());
QBS_ASSERT(varValue, return);
m_stackUpdate = true;
const QualifiedId fullPropName
= QualifiedId::fromString(varValue->value().toString()) << name.toString();
if (!requestedProperties.empty())
propertyDependencies[fullPropName].insert(requestedProperties.top());
m_requestedProperties.push(fullPropName);
}
}
QScriptClass::QueryFlags AudioOutputCollection::queryProperty(
const QScriptValue &object, const QScriptString &name, QueryFlags flags, uint *id)
{
ActiveAudioTracks* tracks = this->_editor->getPoolOfActiveAudioTrack();
bool isArrayIndex;
quint32 pos = name.toArrayIndex(&isArrayIndex);
if (!isArrayIndex)
{
return 0;
}
*id = pos;
if (pos >= tracks->size())
{
return 0;
}
return flags;
}
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;
}
QScriptValue DefaultScriptClass::property(const QScriptValue& object, const QScriptString& name, uint id)
{
Q_ASSERT(mHandlerInfo->mode() != ScriptHandlerInfo::None);
DataInformation* data = toDataInformation(object);
if (!data)
{
mHandlerInfo->logger()->error() << "could not cast data from" << object.data().toString();
return engine()->currentContext()->throwError(QScriptContext::ReferenceError,
QStringLiteral("Attempting to access an invalid object"));
}
if (name == s_valid)
{
return data->validationSuccessful();
}
else if (name == s_wasAbleToRead)
{
return data->wasAbleToRead();
}
else if (name == s_parent)
{
Q_CHECK_PTR(data->parent());
//parent() cannot be null
if (data->parent()->isTopLevel())
return engine()->nullValue();
return data->parent()->asDataInformation()->toScriptValue(engine(), mHandlerInfo);
}
else if (name == s_datatype)
{
return data->typeName();
}
else if (name == s_updateFunc)
{
return data->updateFunc();
}
else if (name == s_validationFunc)
{
return data->validationFunc();
}
else if (name == s_validationError)
{
return data->validationError();
}
else if (name == s_byteOrder)
{
return ParserUtils::byteOrderToString(data->byteOrder());
}
else if (name == s_name)
{
return data->name();
}
else if (name == s_customTypeName)
{
return data->typeName();
}
else if (name == s_asStringFunc)
{
return data->toStringFunction();
}
QScriptValue other = additionalProperty(data, name, id);
if (other.isValid())
return other;
else
{
data->logError() << "could not find property with name" << name.toString();
return engine()->currentContext()->throwError(QScriptContext::ReferenceError,
QStringLiteral("Cannot read property ") + name.toString());
}
}
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());
}
}
}
void tst_QScriptString::test()
{
QScriptEngine eng;
{
QScriptString str;
QVERIFY(!str.isValid());
QVERIFY(str == str);
QVERIFY(!(str != str));
QVERIFY(str.toString().isNull());
QScriptString str1(str);
QVERIFY(!str1.isValid());
QScriptString str2 = str;
QVERIFY(!str2.isValid());
QCOMPARE(str.toArrayIndex(), quint32(0xffffffff));
}
for (int x = 0; x < 2; ++x) {
QString ciao = QString::fromLatin1("ciao");
QScriptString str = eng.toStringHandle(ciao);
QVERIFY(str.isValid());
QVERIFY(str == str);
QVERIFY(!(str != str));
QCOMPARE(str.toString(), ciao);
QScriptString str1(str);
QCOMPARE(str, str1);
QScriptString str2 = str;
QCOMPARE(str, str2);
QScriptString str3 = eng.toStringHandle(ciao);
QVERIFY(str3.isValid());
QCOMPARE(str, str3);
eng.collectGarbage();
QVERIFY(str.isValid());
QCOMPARE(str.toString(), ciao);
QVERIFY(str1.isValid());
QCOMPARE(str1.toString(), ciao);
QVERIFY(str2.isValid());
QCOMPARE(str2.toString(), ciao);
QVERIFY(str3.isValid());
QCOMPARE(str3.toString(), ciao);
}
{
QScriptEngine* eng2 = new QScriptEngine;
QString one = QString::fromLatin1("one");
QString two = QString::fromLatin1("two");
QScriptString oneInterned = eng2->toStringHandle(one);
QCOMPARE(oneInterned.toString(), one);
QScriptString twoInterned = eng2->toStringHandle(two);
QCOMPARE(twoInterned.toString(), two);
QVERIFY(oneInterned != twoInterned);
QVERIFY(!(oneInterned == twoInterned));
delete eng2;
}
}
