void quatFromScriptValue(const QScriptValue &object, glm::quat& quat) {
quat.x = object.property("x").toVariant().toFloat();
quat.y = object.property("y").toVariant().toFloat();
quat.z = object.property("z").toVariant().toFloat();
quat.w = object.property("w").toVariant().toFloat();
}
void ScriptEngine::run() {
if (!_isInitialized) {
init();
}
_isRunning = true;
_isFinished = false;
emit runningStateChanged();
QScriptValue result = evaluate(_scriptContents);
if (hasUncaughtException()) {
int line = uncaughtExceptionLineNumber();
qDebug() << "Uncaught exception at (" << _fileNameString << ") line" << line << ":" << result.toString();
emit errorMessage("Uncaught exception at (" + _fileNameString + ") line" + QString::number(line) + ":" + result.toString());
clearExceptions();
}
QElapsedTimer startTime;
startTime.start();
int thisFrame = 0;
NodeList* nodeList = NodeList::getInstance();
qint64 lastUpdate = usecTimestampNow();
while (!_isFinished) {
int usecToSleep = (thisFrame++ * SCRIPT_DATA_CALLBACK_USECS) - startTime.nsecsElapsed() / 1000; // nsec to usec
if (usecToSleep > 0) {
usleep(usecToSleep);
}
if (_isFinished) {
break;
}
QCoreApplication::processEvents();
if (_isFinished) {
break;
}
if (_voxelsScriptingInterface.getVoxelPacketSender()->serversExist()) {
// release the queue of edit voxel messages.
_voxelsScriptingInterface.getVoxelPacketSender()->releaseQueuedMessages();
// since we're in non-threaded mode, call process so that the packets are sent
if (!_voxelsScriptingInterface.getVoxelPacketSender()->isThreaded()) {
_voxelsScriptingInterface.getVoxelPacketSender()->process();
}
}
if (_particlesScriptingInterface.getParticlePacketSender()->serversExist()) {
// release the queue of edit voxel messages.
_particlesScriptingInterface.getParticlePacketSender()->releaseQueuedMessages();
// since we're in non-threaded mode, call process so that the packets are sent
if (!_particlesScriptingInterface.getParticlePacketSender()->isThreaded()) {
_particlesScriptingInterface.getParticlePacketSender()->process();
}
}
if (_entityScriptingInterface.getEntityPacketSender()->serversExist()) {
// release the queue of edit voxel messages.
_entityScriptingInterface.getEntityPacketSender()->releaseQueuedMessages();
// since we're in non-threaded mode, call process so that the packets are sent
if (!_entityScriptingInterface.getEntityPacketSender()->isThreaded()) {
_entityScriptingInterface.getEntityPacketSender()->process();
}
}
if (_isAvatar && _avatarData) {
const int SCRIPT_AUDIO_BUFFER_SAMPLES = floor(((SCRIPT_DATA_CALLBACK_USECS * SAMPLE_RATE) / (1000 * 1000)) + 0.5);
const int SCRIPT_AUDIO_BUFFER_BYTES = SCRIPT_AUDIO_BUFFER_SAMPLES * sizeof(int16_t);
QByteArray avatarPacket = byteArrayWithPopulatedHeader(PacketTypeAvatarData);
avatarPacket.append(_avatarData->toByteArray());
nodeList->broadcastToNodes(avatarPacket, NodeSet() << NodeType::AvatarMixer);
if (_isListeningToAudioStream || _avatarSound) {
// if we have an avatar audio stream then send it out to our audio-mixer
bool silentFrame = true;
int16_t numAvailableSamples = SCRIPT_AUDIO_BUFFER_SAMPLES;
const int16_t* nextSoundOutput = NULL;
if (_avatarSound) {
const QByteArray& soundByteArray = _avatarSound->getByteArray();
nextSoundOutput = reinterpret_cast<const int16_t*>(soundByteArray.data()
+ _numAvatarSoundSentBytes);
int numAvailableBytes = (soundByteArray.size() - _numAvatarSoundSentBytes) > SCRIPT_AUDIO_BUFFER_BYTES
? SCRIPT_AUDIO_BUFFER_BYTES
: soundByteArray.size() - _numAvatarSoundSentBytes;
numAvailableSamples = numAvailableBytes / sizeof(int16_t);
// check if the all of the _numAvatarAudioBufferSamples to be sent are silence
for (int i = 0; i < numAvailableSamples; ++i) {
if (nextSoundOutput[i] != 0) {
silentFrame = false;
break;
}
}
_numAvatarSoundSentBytes += numAvailableBytes;
if (_numAvatarSoundSentBytes == soundByteArray.size()) {
// we're done with this sound object - so set our pointer back to NULL
// and our sent bytes back to zero
_avatarSound = NULL;
_numAvatarSoundSentBytes = 0;
}
}
QByteArray audioPacket = byteArrayWithPopulatedHeader(silentFrame
? PacketTypeSilentAudioFrame
: PacketTypeMicrophoneAudioNoEcho);
QDataStream packetStream(&audioPacket, QIODevice::Append);
// pack a placeholder value for sequence number for now, will be packed when destination node is known
int numPreSequenceNumberBytes = audioPacket.size();
packetStream << (quint16) 0;
if (silentFrame) {
if (!_isListeningToAudioStream) {
// if we have a silent frame and we're not listening then just send nothing and break out of here
break;
}
// write the number of silent samples so the audio-mixer can uphold timing
packetStream.writeRawData(reinterpret_cast<const char*>(&SCRIPT_AUDIO_BUFFER_SAMPLES), sizeof(int16_t));
// use the orientation and position of this avatar for the source of this audio
packetStream.writeRawData(reinterpret_cast<const char*>(&_avatarData->getPosition()), sizeof(glm::vec3));
glm::quat headOrientation = _avatarData->getHeadOrientation();
packetStream.writeRawData(reinterpret_cast<const char*>(&headOrientation), sizeof(glm::quat));
} else if (nextSoundOutput) {
// assume scripted avatar audio is mono and set channel flag to zero
packetStream << (quint8)0;
// use the orientation and position of this avatar for the source of this audio
packetStream.writeRawData(reinterpret_cast<const char*>(&_avatarData->getPosition()), sizeof(glm::vec3));
glm::quat headOrientation = _avatarData->getHeadOrientation();
packetStream.writeRawData(reinterpret_cast<const char*>(&headOrientation), sizeof(glm::quat));
// write the raw audio data
packetStream.writeRawData(reinterpret_cast<const char*>(nextSoundOutput), numAvailableSamples * sizeof(int16_t));
}
// write audio packet to AudioMixer nodes
NodeList* nodeList = NodeList::getInstance();
foreach(const SharedNodePointer& node, nodeList->getNodeHash()) {
// only send to nodes of type AudioMixer
if (node->getType() == NodeType::AudioMixer) {
// pack sequence number
quint16 sequence = _outgoingScriptAudioSequenceNumbers[node->getUUID()]++;
memcpy(audioPacket.data() + numPreSequenceNumberBytes, &sequence, sizeof(quint16));
// send audio packet
nodeList->writeDatagram(audioPacket, node);
}
}
}
}
qint64 now = usecTimestampNow();
float deltaTime = (float) (now - lastUpdate) / (float) USECS_PER_SECOND;
if (hasUncaughtException()) {
int line = uncaughtExceptionLineNumber();
qDebug() << "Uncaught exception at (" << _fileNameString << ") line" << line << ":" << uncaughtException().toString();
emit errorMessage("Uncaught exception at (" + _fileNameString + ") line" + QString::number(line) + ":" + uncaughtException().toString());
clearExceptions();
}
emit update(deltaTime);
lastUpdate = now;
}
void inputControllerFromScriptValue(const QScriptValue &object, AbstractInputController* &out) {
out = qobject_cast<AbstractInputController*>(object.toQObject());
}
static QScriptValue qtscript_QProcess_ExitStatus_toScriptValue(QScriptEngine *engine, const QProcess::ExitStatus &value)
{
QScriptValue clazz = engine->globalObject().property(QString::fromLatin1("QProcess"));
return clazz.property(qtscript_QProcess_ExitStatus_toStringHelper(value));
}
static void qtscript_QProcess_fromScriptValue(const QScriptValue &value, QProcess* &out)
{
out = qobject_cast<QProcess*>(value.toQObject());
}
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 tst_QScriptJSTestSuite::runTestFunction(int testIndex)
{
if (!(testIndex & 1)) {
// data
QTest::addColumn<TestRecord>("record");
bool hasData = false;
QString testsShellPath = testsDir.absoluteFilePath("shell.js");
QString testsShellContents = readFile(testsShellPath);
QDir subSuiteDir(subSuitePaths.at(testIndex / 2));
QString subSuiteShellPath = subSuiteDir.absoluteFilePath("shell.js");
QString subSuiteShellContents = readFile(subSuiteShellPath);
QDir testSuiteDir(subSuiteDir);
testSuiteDir.cdUp();
QString suiteJsrefPath = testSuiteDir.absoluteFilePath("jsref.js");
QString suiteJsrefContents = readFile(suiteJsrefPath);
QString suiteShellPath = testSuiteDir.absoluteFilePath("shell.js");
QString suiteShellContents = readFile(suiteShellPath);
QFileInfoList testFileInfos = subSuiteDir.entryInfoList(QStringList() << "*.js", QDir::Files);
foreach (QFileInfo tfi, testFileInfos) {
if ((tfi.fileName() == "shell.js") || (tfi.fileName() == "browser.js"))
continue;
QString abspath = tfi.absoluteFilePath();
QString relpath = testsDir.relativeFilePath(abspath);
QString excludeMessage;
if (isExcludedFile(relpath, &excludeMessage)) {
QTest::newRow(relpath.toLatin1()) << TestRecord(excludeMessage, relpath);
continue;
}
QScriptEngine eng;
QScriptValue global = eng.globalObject();
global.setProperty("print", eng.newFunction(qscript_void));
global.setProperty("quit", eng.newFunction(qscript_quit));
global.setProperty("options", eng.newFunction(qscript_options));
eng.evaluate(testsShellContents, testsShellPath);
if (eng.hasUncaughtException()) {
QStringList bt = eng.uncaughtExceptionBacktrace();
QString err = eng.uncaughtException().toString();
qWarning("%s\n%s", qPrintable(err), qPrintable(bt.join("\n")));
break;
}
eng.evaluate(suiteJsrefContents, suiteJsrefPath);
if (eng.hasUncaughtException()) {
QStringList bt = eng.uncaughtExceptionBacktrace();
QString err = eng.uncaughtException().toString();
qWarning("%s\n%s", qPrintable(err), qPrintable(bt.join("\n")));
break;
}
eng.evaluate(suiteShellContents, suiteShellPath);
if (eng.hasUncaughtException()) {
QStringList bt = eng.uncaughtExceptionBacktrace();
QString err = eng.uncaughtException().toString();
qWarning("%s\n%s", qPrintable(err), qPrintable(bt.join("\n")));
break;
}
eng.evaluate(subSuiteShellContents, subSuiteShellPath);
if (eng.hasUncaughtException()) {
QStringList bt = eng.uncaughtExceptionBacktrace();
QString err = eng.uncaughtException().toString();
qWarning("%s\n%s", qPrintable(err), qPrintable(bt.join("\n")));
break;
}
QScriptValue origTestCaseCtor = global.property("TestCase");
QScriptValue myTestCaseCtor = eng.newFunction(qscript_TestCase);
myTestCaseCtor.setData(origTestCaseCtor);
global.setProperty("TestCase", myTestCaseCtor);
global.setProperty("gTestfile", tfi.fileName());
global.setProperty("gTestsuite", testSuiteDir.dirName());
global.setProperty("gTestsubsuite", subSuiteDir.dirName());
QString testFileContents = readFile(abspath);
// qDebug() << relpath;
eng.evaluate(testFileContents, abspath);
if (eng.hasUncaughtException() && !relpath.endsWith("-n.js")) {
QStringList bt = eng.uncaughtExceptionBacktrace();
QString err = eng.uncaughtException().toString();
qWarning("%s\n%s\n", qPrintable(err), qPrintable(bt.join("\n")));
continue;
}
QScriptValue testcases = global.property("testcases");
if (!testcases.isArray())
testcases = global.property("gTestcases");
int count = testcases.property("length").toInt32();
if (count == 0)
continue;
hasData = true;
QString title = global.property("TITLE").toString();
for (int i = 0; i < count; ++i) {
QScriptValue kase = testcases.property(i);
QString description = kase.property("description").toString();
QScriptValue expect = kase.property("expect");
QScriptValue actual = kase.property("actual");
bool passed = kase.property("passed").toBoolean();
int lineNumber = kase.property("__lineNumber__").toInt32();
TestRecord rec(description, passed,
actual.toString(), expect.toString(),
relpath, lineNumber);
QTest::newRow(description.toLatin1()) << rec;
}
}
if (!hasData)
QTest::newRow("") << TestRecord(); // dummy
} else {
void vec4FromScriptValue(const QScriptValue& object, glm::vec4& vec4) {
vec4.x = object.property("x").toVariant().toFloat();
vec4.y = object.property("y").toVariant().toFloat();
vec4.z = object.property("z").toVariant().toFloat();
vec4.w = object.property("w").toVariant().toFloat();
}
void vec3FromScriptValue(const QScriptValue &object, glm::vec3 &vec3) {
vec3.x = object.property("x").toVariant().toFloat();
vec3.y = object.property("y").toVariant().toFloat();
vec3.z = object.property("z").toVariant().toFloat();
}
QScriptValue qSizeFToScriptValue(QScriptEngine* engine, const QSizeF& qSizeF) {
QScriptValue obj = engine->newObject();
obj.setProperty("width", qSizeF.width());
obj.setProperty("height", qSizeF.height());
return obj;
}
void qSizeFFromScriptValue(const QScriptValue& object, QSizeF& qSizeF) {
qSizeF.setWidth(object.property("width").toVariant().toFloat());
qSizeF.setHeight(object.property("height").toVariant().toFloat());
}
void qURLFromScriptValue(const QScriptValue& object, QUrl& url) {
url = object.toString();
}
void xColorFromScriptValue(const QScriptValue &object, xColor& color) {
color.red = object.property("red").toVariant().toInt();
color.green = object.property("green").toVariant().toInt();
color.blue = object.property("blue").toVariant().toInt();
}
void qRectFromScriptValue(const QScriptValue &object, QRect& rect) {
rect.setX(object.property("x").toVariant().toInt());
rect.setY(object.property("y").toVariant().toInt());
rect.setWidth(object.property("width").toVariant().toInt());
rect.setHeight(object.property("height").toVariant().toInt());
}
static void qtscript_QPropertyAnimation_fromScriptValue(const QScriptValue &value, QPropertyAnimation* &out)
{
out = qobject_cast<QPropertyAnimation*>(value.toQObject());
}
void PainterPathClass::fromScriptValue(const QScriptValue& obj, QPainterPath& pp)
{
pp = qvariant_cast<QPainterPath>(obj.data().toVariant());
}
void REcmaAddObjectOperation::initEcma(QScriptEngine& engine, QScriptValue* proto
)
{
bool protoCreated = false;
if(proto == NULL){
proto = new QScriptValue(engine.newVariant(qVariantFromValue(
(RAddObjectOperation*) 0)));
protoCreated = true;
}
// primary base class RAddObjectsOperation:
QScriptValue dpt = engine.defaultPrototype(
qMetaTypeId<RAddObjectsOperation*>());
if (dpt.isValid()) {
proto->setPrototype(dpt);
}
/*
*/
QScriptValue fun;
// toString:
REcmaHelper::registerFunction(&engine, proto, toString, "toString");
// destroy:
REcmaHelper::registerFunction(&engine, proto, destroy, "destroy");
// conversion for base class RAddObjectsOperation
REcmaHelper::registerFunction(&engine, proto, getRAddObjectsOperation, "getRAddObjectsOperation");
// conversion for base class ROperation
REcmaHelper::registerFunction(&engine, proto, getROperation, "getROperation");
// conversion for base class RRequireHeap
REcmaHelper::registerFunction(&engine, proto, getRRequireHeap, "getRRequireHeap");
// get class name
REcmaHelper::registerFunction(&engine, proto, getClassName, "getClassName");
// conversion to all base classes (multiple inheritance):
REcmaHelper::registerFunction(&engine, proto, getBaseClasses, "getBaseClasses");
// properties:
// methods:
engine.setDefaultPrototype(
qMetaTypeId<RAddObjectOperation*>(), *proto);
QScriptValue ctor = engine.newFunction(createEcma, *proto, 2);
// static methods:
// static properties:
// enum values:
// enum conversions:
// init class:
engine.globalObject().setProperty("RAddObjectOperation",
ctor, QScriptValue::SkipInEnumeration);
if( protoCreated ){
delete proto;
}
}
QScriptValue ScShiftDatabase::addType(QScriptContext *ctx, QScriptEngine *engine)
{
ScProfileFunction
SProperty **propPtr = getThis(ctx);
SDatabase *db = 0;
if(propPtr)
{
db = (*propPtr)->uncheckedCastTo<SDatabase>();
}
if(!db)
{
ctx->throwError(QScriptContext::SyntaxError, "Incorrect this argument to SPropertyContainer.size(...);");
}
if(ctx->argumentCount() != 1)
{
ctx->throwError(QScriptContext::SyntaxError, "Incorrect number of arguments to SDatabase.addType(...);");
return QScriptValue();
}
QScriptValue typeObject = ctx->argument(0);
if(!typeObject.isObject())
{
ctx->throwError(QScriptContext::SyntaxError, "Incorrect argument type to SDatabase.addType(...); expected object");
return QScriptValue();
}
QScriptValue tempObject;
tempObject = typeObject.property("name");
QString name = tempObject.toString();
if(name == "" || STypeRegistry::findType(name) != 0)
{
ctx->throwError(QScriptContext::SyntaxError, "Unique, non zero-lengthed string expected as 'name' property");
return QScriptValue();
}
tempObject = typeObject.property("parent");
const SPropertyInformation *parent = 0;
if(tempObject.isString())
{
parent = STypeRegistry::findType(tempObject.toString());
}
if(parent == 0)
{
ctx->throwError(QScriptContext::SyntaxError, "Defined property type expected as 'parent' property");
return QScriptValue();
}
tempObject = typeObject.property("version");
xuint32 version = tempObject.toUInt32();
xsize endOfUsedMemory = parent->dynamicSize();
QList<SPropertyInstanceInformation*> properties;
tempObject = typeObject.property("properties");
if(tempObject.isArray())
{
xuint32 i = 0;
QScriptValue val = tempObject.property(i);
QScriptValue tempArrayObject;
while(val.isObject())
{
tempArrayObject = val.property("name");
if(!tempArrayObject.isString())
{
ctx->throwError(QScriptContext::SyntaxError, "String expected as 'properties' array 'name' entry");
break;
}
QString propName = tempArrayObject.toString();
tempArrayObject = val.property("type");
const SPropertyInformation *propType = 0;
if(tempArrayObject.isString())
{
propType = STypeRegistry::findType(tempArrayObject.toString());
}
if(!propType)
{
ctx->throwError(QScriptContext::SyntaxError, "String expected as 'properties' array 'type' entry");
break;
}
SPropertyInstanceInformation::ComputeFunction computeFn = 0;
tempArrayObject = val.property("compute");
if(tempArrayObject.isFunction())
{
computeFn = computeNode;
}
SPropertyInstanceInformation *info = propType->createInstanceInformation()(propType, propName, i, *reinterpret_cast<SProperty SPropertyContainer::**>(&endOfUsedMemory));
info->setCompute(computeFn);
info->setExtra(true);
endOfUsedMemory += propType->size();
properties << info;
if(computeFn)
{
info->setData(g_computeKey, qVariantFromValue(tempArrayObject));
}
val = tempObject.property(++i);
}
i = 0;
val = tempObject.property(i);
while(val.isObject())
{
SProperty SPropertyContainer::* *affects = 0;
tempArrayObject = val.property("affects");
bool affectsIsValid = false;
if(tempArrayObject.isArray())
{
affectsIsValid = true;
xuint32 length = tempArrayObject.property("length").toUInt32();
affects = new SProperty SPropertyContainer::* [length+1];
affects[length] = 0;
for(xuint32 i=0; i<length; ++i)
{
affects[i] = 0;
QString name = tempArrayObject.property(i).toString();
for(int propIdx=0, s=properties.size(); propIdx<s; ++propIdx)
{
if(name == properties[propIdx]->name())
{
affects[i] = properties[propIdx]->location();
break;
}
}
if(!affects[i])
{
affectsIsValid = false;
ctx->throwError(QScriptContext::SyntaxError, "Defined sibling property name expected for affectedBy members.");
break;
}
}
}
if(!affectsIsValid)
{
delete [] affects;
affects = 0;
}
SPropertyInstanceInformation *info = properties[i];
info->setAffects(affects);
val = tempObject.property(++i);
}
}
#warning check what happens if you embed a script type in a script type... etc, i think it will crash and burn?
SPropertyInformation *newType = new SPropertyInformation(*parent);
newType->setVersion(version);
newType->typeName() = name;
newType->setParentTypeInformation(parent);
newType->setSize(endOfUsedMemory);
newType->children() << parent->children() << properties;
STypeRegistry::addType(newType);
return QScriptValue();
}
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 REcmaSharedPointerDimRadialEntity::initEcma(QScriptEngine& engine, QScriptValue* proto
)
{
bool protoCreated = false;
if(proto == NULL){
proto = new QScriptValue(engine.newVariant(qVariantFromValue(
(RDimRadialEntityPointer*) 0)));
protoCreated = true;
}
// primary base class RDimensionEntity:
proto->setPrototype(engine.defaultPrototype(
qMetaTypeId<RDimensionEntityPointer>()));
/*
*/
QScriptValue fun;
// toString:
REcmaHelper::registerFunction(&engine, proto, toString, "toString");
// shared pointer support:
REcmaHelper::registerFunction(&engine, proto, data, "data");
REcmaHelper::registerFunction(&engine, proto, isNull, "isNull");
// destroy:
REcmaHelper::registerFunction(&engine, proto, destroy, "destroy");
// conversion for base class RDimensionEntity
REcmaHelper::registerFunction(&engine, proto, getRDimensionEntity, "getRDimensionEntity");
// conversion for base class REntity
REcmaHelper::registerFunction(&engine, proto, getREntity, "getREntity");
// conversion for base class RObject
REcmaHelper::registerFunction(&engine, proto, getRObject, "getRObject");
// get class name
REcmaHelper::registerFunction(&engine, proto, getClassName, "getClassName");
// conversion to all base classes (multiple inheritance):
REcmaHelper::registerFunction(&engine, proto, getBaseClasses, "getBaseClasses");
// properties:
// methods:
REcmaHelper::registerFunction(&engine, proto, clone, "clone");
REcmaHelper::registerFunction(&engine, proto, getType, "getType");
REcmaHelper::registerFunction(&engine, proto, setProperty, "setProperty");
REcmaHelper::registerFunction(&engine, proto, getProperty, "getProperty");
REcmaHelper::registerFunction(&engine, proto, getData, "getData");
REcmaHelper::registerFunction(&engine, proto, setData, "setData");
REcmaHelper::registerFunction(&engine, proto, setChordPoint, "setChordPoint");
REcmaHelper::registerFunction(&engine, proto, getChordPoint, "getChordPoint");
engine.setDefaultPrototype(
qMetaTypeId<RDimRadialEntityPointer>(), *proto);
QScriptValue ctor = engine.newFunction(createEcma, *proto, 2);
// static methods:
REcmaHelper::registerFunction(&engine, &ctor, init, "init");
REcmaHelper::registerFunction(&engine, &ctor, getStaticPropertyTypeIds, "getStaticPropertyTypeIds");
// static properties:
ctor.setProperty("PropertyCustom",
qScriptValueFromValue(&engine, RDimRadialEntity::PropertyCustom),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyHandle",
qScriptValueFromValue(&engine, RDimRadialEntity::PropertyHandle),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyProtected",
qScriptValueFromValue(&engine, RDimRadialEntity::PropertyProtected),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyType",
qScriptValueFromValue(&engine, RDimRadialEntity::PropertyType),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyBlock",
qScriptValueFromValue(&engine, RDimRadialEntity::PropertyBlock),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyLayer",
qScriptValueFromValue(&engine, RDimRadialEntity::PropertyLayer),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyLinetype",
qScriptValueFromValue(&engine, RDimRadialEntity::PropertyLinetype),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyLinetypeScale",
qScriptValueFromValue(&engine, RDimRadialEntity::PropertyLinetypeScale),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyLineweight",
qScriptValueFromValue(&engine, RDimRadialEntity::PropertyLineweight),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyColor",
qScriptValueFromValue(&engine, RDimRadialEntity::PropertyColor),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyDisplayedColor",
qScriptValueFromValue(&engine, RDimRadialEntity::PropertyDisplayedColor),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyDrawOrder",
qScriptValueFromValue(&engine, RDimRadialEntity::PropertyDrawOrder),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyMiddleOfTextX",
qScriptValueFromValue(&engine, RDimRadialEntity::PropertyMiddleOfTextX),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyMiddleOfTextY",
qScriptValueFromValue(&engine, RDimRadialEntity::PropertyMiddleOfTextY),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyMiddleOfTextZ",
qScriptValueFromValue(&engine, RDimRadialEntity::PropertyMiddleOfTextZ),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyText",
qScriptValueFromValue(&engine, RDimRadialEntity::PropertyText),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyUpperTolerance",
qScriptValueFromValue(&engine, RDimRadialEntity::PropertyUpperTolerance),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyLowerTolerance",
qScriptValueFromValue(&engine, RDimRadialEntity::PropertyLowerTolerance),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyMeasuredValue",
qScriptValueFromValue(&engine, RDimRadialEntity::PropertyMeasuredValue),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyLinearFactor",
qScriptValueFromValue(&engine, RDimRadialEntity::PropertyLinearFactor),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyDimScale",
qScriptValueFromValue(&engine, RDimRadialEntity::PropertyDimScale),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyDimBlockName",
qScriptValueFromValue(&engine, RDimRadialEntity::PropertyDimBlockName),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyAutoTextPos",
qScriptValueFromValue(&engine, RDimRadialEntity::PropertyAutoTextPos),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyFontName",
qScriptValueFromValue(&engine, RDimRadialEntity::PropertyFontName),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyCenterPointX",
qScriptValueFromValue(&engine, RDimRadialEntity::PropertyCenterPointX),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyCenterPointY",
qScriptValueFromValue(&engine, RDimRadialEntity::PropertyCenterPointY),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyCenterPointZ",
qScriptValueFromValue(&engine, RDimRadialEntity::PropertyCenterPointZ),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyChordPointX",
qScriptValueFromValue(&engine, RDimRadialEntity::PropertyChordPointX),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyChordPointY",
qScriptValueFromValue(&engine, RDimRadialEntity::PropertyChordPointY),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
ctor.setProperty("PropertyChordPointZ",
qScriptValueFromValue(&engine, RDimRadialEntity::PropertyChordPointZ),
QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly);
// enum values:
// enum conversions:
// init class:
engine.globalObject().setProperty("RDimRadialEntityPointer",
ctor, QScriptValue::SkipInEnumeration);
if( protoCreated ){
delete proto;
}
}
static void qtscript_QProcess_ProcessState_fromScriptValue(const QScriptValue &value, QProcess::ProcessState &out)
{
out = qvariant_cast<QProcess::ProcessState>(value.toVariant());
}
//! [35]
QScriptValue Person_prototype_toString(QScriptContext *context, QScriptEngine *engine)
{
QString name = context->thisObject().property("name").toString();
QString result = QString::fromLatin1("Person(name: %0)").arg(name);
return result;
}
//! [35]
//! [36]
QScriptEngine engine;
QScriptValue ctor = engine.newFunction(Person_ctor);
ctor.property("prototype").setProperty("toString", engine.newFunction(Person_prototype_toString));
QScriptValue global = engine.globalObject();
global.setProperty("Person", ctor);
//! [36]
//! [37]
QScriptValue Employee_ctor(QScriptContext *context, QScriptEngine *engine)
{
QScriptValue super = context->callee().property("prototype").property("constructor");
super.call(context->thisObject(), QScriptValueList() << context->argument(0));
context->thisObject().setProperty("salary", context->argument(1));
return engine->undefinedValue();
}
//! [37]
static void qtscript_QProcess_ExitStatus_fromScriptValue(const QScriptValue &value, QProcess::ExitStatus &out)
{
out = qvariant_cast<QProcess::ExitStatus>(value.toVariant());
}
//! [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())
QScriptValue qtscript_create_QProcess_class(QScriptEngine *engine)
{
static const int function_lengths[] = {
1
// static
, 2
, 4
, 0
// prototype
, 1
, 0
, 0
, 0
, 0
, 0
, 0
, 0
, 0
, 0
, 1
, 1
, 1
, 2
, 1
, 2
, 1
, 1
, 3
, 0
, 1
, 1
, 0
, 0
};
engine->setDefaultPrototype(qMetaTypeId<QProcess*>(), QScriptValue());
QScriptValue proto = engine->newVariant(qVariantFromValue((QProcess*)0));
proto.setPrototype(engine->defaultPrototype(qMetaTypeId<QIODevice*>()));
for (int i = 0; i < 24; ++i) {
QScriptValue fun = engine->newFunction(qtscript_QProcess_prototype_call, function_lengths[i+4]);
fun.setData(QScriptValue(engine, uint(0xBABE0000 + i)));
proto.setProperty(QString::fromLatin1(qtscript_QProcess_function_names[i+4]),
fun, QScriptValue::SkipInEnumeration);
}
qScriptRegisterMetaType<QProcess*>(engine, qtscript_QProcess_toScriptValue,
qtscript_QProcess_fromScriptValue, proto);
QScriptValue ctor = engine->newFunction(qtscript_QProcess_static_call, proto, function_lengths[0]);
ctor.setData(QScriptValue(engine, uint(0xBABE0000 + 0)));
for (int i = 0; i < 3; ++i) {
QScriptValue fun = engine->newFunction(qtscript_QProcess_static_call,
function_lengths[i+1]);
fun.setData(QScriptValue(engine, uint(0xBABE0000 + i+1)));
ctor.setProperty(QString::fromLatin1(qtscript_QProcess_function_names[i+1]),
fun, QScriptValue::SkipInEnumeration);
}
ctor.setProperty(QString::fromLatin1("ProcessError"),
qtscript_create_QProcess_ProcessError_class(engine, ctor));
ctor.setProperty(QString::fromLatin1("ProcessChannelMode"),
qtscript_create_QProcess_ProcessChannelMode_class(engine, ctor));
ctor.setProperty(QString::fromLatin1("ProcessChannel"),
qtscript_create_QProcess_ProcessChannel_class(engine, ctor));
ctor.setProperty(QString::fromLatin1("ProcessState"),
qtscript_create_QProcess_ProcessState_class(engine, ctor));
ctor.setProperty(QString::fromLatin1("ExitStatus"),
qtscript_create_QProcess_ExitStatus_class(engine, ctor));
return ctor;
}
//! [74]
QScriptValue counter_hybrid(QScriptContext *ctx, QScriptEngine *eng)
{
QScriptValue act = ctx->activationObject();
act.setProperty("count", 0);
return eng->evaluate("(function() { return count++; })");
}
void injectorFromScriptValue(const QScriptValue &object, AudioInjector* &out) {
out = qobject_cast<AudioInjector*>(object.toQObject());
}
QScriptObjectSnapshot::Delta QScriptObjectSnapshot::capture(const QScriptValue &object)
{
Delta result;
QMap<QString, QScriptValueProperty> currProps;
QHash<QString, int> propertyNameToIndex;
{
int i = 0;
QScriptValueIterator it(object);
while (it.hasNext()) {
it.next();
QScriptValueProperty prop(it.name(), it.value(), it.flags());
currProps.insert(it.name(), prop);
propertyNameToIndex.insert(it.name(), i);
++i;
}
if (object.prototype().isValid()) {
QString __proto__ = QString::fromLatin1("__proto__");
QScriptValueProperty protoProp(
__proto__, object.prototype(),
QScriptValue::Undeletable | QScriptValue::ReadOnly);
currProps.insert(__proto__, protoProp);
propertyNameToIndex.insert(__proto__, i);
++i;
}
}
QSet<QString> prevSet;
for (int i = 0; i < m_properties.size(); ++i)
prevSet.insert(m_properties.at(i).name());
QSet<QString> currSet = currProps.keys().toSet();
QSet<QString> removedProperties = prevSet - currSet;
QSet<QString> addedProperties = currSet - prevSet;
QSet<QString> maybeChangedProperties = currSet & prevSet;
{
QMap<int, QScriptValueProperty> am;
QSet<QString>::const_iterator it;
for (it = addedProperties.constBegin(); it != addedProperties.constEnd(); ++it) {
int idx = propertyNameToIndex[*it];
am[idx] = currProps[*it];
}
result.addedProperties = am.values();
}
{
QSet<QString>::const_iterator it;
for (it = maybeChangedProperties.constBegin(); it != maybeChangedProperties.constEnd(); ++it) {
const QScriptValueProperty &p1 = currProps[*it];
const QScriptValueProperty &p2 = findProperty(*it);
if (!_q_equal(p1.value(), p2.value())
|| (p1.flags() != p2.flags())) {
result.changedProperties.append(p1);
}
}
}
result.removedProperties = removedProperties.toList();
m_properties = currProps.values();
return result;
}
int tst_Suite::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
QString name = testNames.at(_id);
QString path = testsDir.absoluteFilePath(name + ".js");
QString excludeMessage;
if (isExcludedTest(name, &excludeMessage)) {
QTest::qSkip(excludeMessage.toLatin1(), QTest::SkipAll, path.toLatin1(), -1);
} else {
QScriptEngine engine;
engine.evaluate(mjsunitContents).toString();
if (engine.hasUncaughtException()) {
QStringList bt = engine.uncaughtExceptionBacktrace();
QString err = engine.uncaughtException().toString();
qWarning("%s\n%s", qPrintable(err), qPrintable(bt.join("\n")));
} else {
QScriptValue fakeFail = engine.newFunction(qscript_fail);
fakeFail.setData(engine.globalObject().property("fail"));
engine.globalObject().setProperty("fail", fakeFail);
QString contents = readFile(path);
QScriptValue ret = engine.evaluate(contents);
if (engine.hasUncaughtException()) {
if (!ret.isError()) {
Q_ASSERT(ret.instanceOf(engine.globalObject().property("MjsUnitAssertionError")));
QString actual = ret.property("actual").toString();
QString expected = ret.property("expected").toString();
int lineNumber = ret.property("lineNumber").toInt32();
QString failMessage;
if (isExpectedFailure(name, actual, expected, &failMessage)) {
QTest::qExpectFail("", failMessage.toLatin1(),
QTest::Continue, path.toLatin1(),
lineNumber);
}
#ifdef GENERATE_ADDEXPECTEDFAILURE_CODE
else {
generatedAddExpectedFailureCode.append(
" addExpectedFailure(\"" + name
+ "\", \"" + actual + "\", \"" + expected
+ "\", willFixInNextReleaseMessage);\n");
}
#endif
QTest::qCompare(actual, expected, "actual", "expect",
path.toLatin1(), lineNumber);
} else {
int lineNumber = ret.property("lineNumber").toInt32();
QTest::qExpectFail("", ret.toString().toLatin1(),
QTest::Continue, path.toLatin1(), lineNumber);
QTest::qVerify(false, ret.toString().toLatin1(), "", path.toLatin1(), lineNumber);
}
}
}
}
_id -= testNames.size();
}
return _id;
}
void vec2FromScriptValue(const QScriptValue &object, glm::vec2 &vec2) {
vec2.x = object.property("x").toVariant().toFloat();
vec2.y = object.property("y").toVariant().toFloat();
}