////  ScriptEngine.cpp//  libraries/script-engine/src////  Created by Brad Hefta-Gaub on 12/14/13.//  Copyright 2013 High Fidelity, Inc.////  Distributed under the Apache License, Version 2.0.//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html// #include <chrono>#include <thread> #include <QtCore/QCoreApplication>#include <QtCore/QEventLoop>#include <QtCore/QFileInfo>#include <QtCore/QTimer>#include <QtCore/QThread>#include <QtCore/QRegularExpression> #include <QtWidgets/QMainWindow>#include <QtWidgets/QApplication> #include <QtNetwork/QNetworkRequest>#include <QtNetwork/QNetworkReply> #include <QtScript/QScriptValue>#include <QtScript/QScriptValueIterator> #include <QtScriptTools/QScriptEngineDebugger> #include <AudioConstants.h>#include <AudioEffectOptions.h>#include <AvatarData.h>#include <EntityScriptingInterface.h>#include <MessagesClient.h>#include <NetworkAccessManager.h>#include <ResourceScriptingInterface.h>#include <NodeList.h>#include <udt/PacketHeaders.h>#include <UUID.h>#include <ui/Menu.h> #include <controllers/ScriptingInterface.h>#include <AnimationObject.h> #include "ArrayBufferViewClass.h"#include "BatchLoader.h"#include "DataViewClass.h"#include "EventTypes.h"#include "MenuItemProperties.h"#include "ScriptAudioInjector.h"#include "ScriptCache.h"#include "ScriptEngineLogging.h"#include "ScriptEngine.h"#include "TypedArrays.h"#include "XMLHttpRequestClass.h"#include "WebSocketClass.h"#include "RecordingScriptingInterface.h"#include "ScriptEngines.h" #include "MIDIEvent.h" std::atomic<bool> ScriptEngine::_stoppingAllScripts { false }; static const QString SCRIPT_EXCEPTION_FORMAT = "[UncaughtException] %1 in %2:%3"; Q_DECLARE_METATYPE(QScriptEngine::FunctionSignature)static int functionSignatureMetaID = qRegisterMetaType<QScriptEngine::FunctionSignature>(); static QScriptValue debugPrint(QScriptContext* context, QScriptEngine* engine){    QString message = "";    for (int i = 0; i < context->argumentCount(); i++) {        if (i > 0) {            message += " ";        }        message += context->argument(i).toString();    }    qCDebug(scriptengine).noquote() << "script:print()<<" << message;  // noquote() so that \n is treated as newline     message = message.replace("\\", "\\\\")                     .replace("\n", "\\n")                     .replace("\r", "\\r")                     .replace("'", "\\'");    engine->evaluate("Script.print('" + message + "')");     return QScriptValue();} QScriptValue avatarDataToScriptValue(QScriptEngine* engine, AvatarData* const &in) {    return engine->newQObject(in);} void avatarDataFromScriptValue(const QScriptValue &object, AvatarData* &out) {    out = qobject_cast<AvatarData*>(object.toQObject());} Q_DECLARE_METATYPE(controller::InputController*)//static int inputControllerPointerId = qRegisterMetaType<controller::InputController*>(); QScriptValue inputControllerToScriptValue(QScriptEngine *engine, controller::InputController* const &in) {    return engine->newQObject(in);} void inputControllerFromScriptValue(const QScriptValue &object, controller::InputController* &out) {    out = qobject_cast<controller::InputController*>(object.toQObject());} static bool hasCorrectSyntax(const QScriptProgram& program) {    const auto syntaxCheck = QScriptEngine::checkSyntax(program.sourceCode());    if (syntaxCheck.state() != QScriptSyntaxCheckResult::Valid) {        const auto error = syntaxCheck.errorMessage();        const auto line = QString::number(syntaxCheck.errorLineNumber());        const auto column = QString::number(syntaxCheck.errorColumnNumber());        const auto message = QString("[SyntaxError] %1 in %2:%3(%4)").arg(error, program.fileName(), line, column);        qCWarning(scriptengine) << qPrintable(message);        return false;    }    return true;} static bool hadUncaughtExceptions(QScriptEngine& engine, const QString& fileName) {    if (engine.hasUncaughtException()) {        const auto backtrace = engine.uncaughtExceptionBacktrace();        const auto exception = engine.uncaughtException().toString();        const auto line = QString::number(engine.uncaughtExceptionLineNumber());        engine.clearExceptions();         auto message = QString(SCRIPT_EXCEPTION_FORMAT).arg(exception, fileName, line);        if (!backtrace.empty()) {            static const auto lineSeparator = "\n    ";            message += QString("\n[Backtrace]%1%2").arg(lineSeparator, backtrace.join(lineSeparator));        }        qCWarning(scriptengine) << qPrintable(message);        return true;    }    return false;} ScriptEngine::ScriptEngine(const QString& scriptContents, const QString& fileNameString) :    _scriptContents(scriptContents),    _timerFunctionMap(),    _fileNameString(fileNameString),    _arrayBufferClass(new ArrayBufferClass(this)){    DependencyManager::get<ScriptEngines>()->addScriptEngine(this);     connect(this, &QScriptEngine::signalHandlerException, this, [this](const QScriptValue& exception) {        hadUncaughtExceptions(*this, _fileNameString);    });        setProcessEventsInterval(MSECS_PER_SECOND);} ScriptEngine::~ScriptEngine() {    qCDebug(scriptengine) << "Script Engine shutting down (destructor) for script:" << getFilename();     auto scriptEngines = DependencyManager::get<ScriptEngines>();    if (scriptEngines) {        scriptEngines->removeScriptEngine(this);    } else {        qCWarning(scriptengine) << "Script destroyed after ScriptEngines!";    }     waitTillDoneRunning();} void ScriptEngine::disconnectNonEssentialSignals() {    disconnect();    QThread* receiver;    // Ensure the thread should be running, and does exist    if (_isRunning && _isThreaded && (receiver = thread())) {        connect(this, &ScriptEngine::doneRunning, receiver, &QThread::quit);    }} void ScriptEngine::runDebuggable() {    static QMenuBar* menuBar { nullptr };    static QMenu* scriptDebugMenu { nullptr };    static size_t scriptMenuCount { 0 };    if (!scriptDebugMenu) {        for (auto window : qApp->topLevelWidgets()) {            auto mainWindow = qobject_cast<QMainWindow*>(window);            if (mainWindow) {                menuBar = mainWindow->menuBar();                break;            }        }        if (menuBar) {            scriptDebugMenu = menuBar->addMenu("Script Debug");        }    }     init();    _isRunning = true;    _debuggable = true;    _debugger = new QScriptEngineDebugger(this);    _debugger->attachTo(this);     QMenu* parentMenu = scriptDebugMenu;    QMenu* scriptMenu { nullptr };    if (parentMenu) {        ++scriptMenuCount;        scriptMenu = parentMenu->addMenu(_fileNameString);        scriptMenu->addMenu(_debugger->createStandardMenu(qApp->activeWindow()));    } else {        qWarning() << "Unable to add script debug menu";    }     QScriptValue result = evaluate(_scriptContents, _fileNameString);     _lastUpdate = usecTimestampNow();    QTimer* timer = new QTimer(this);    connect(this, &ScriptEngine::finished, [this, timer, parentMenu, scriptMenu] {        if (scriptMenu) {            parentMenu->removeAction(scriptMenu->menuAction());            --scriptMenuCount;            if (0 == scriptMenuCount) {                menuBar->removeAction(scriptDebugMenu->menuAction());                scriptDebugMenu = nullptr;            }        }        disconnect(timer);     });     connect(timer, &QTimer::timeout, [this, timer] {        if (_isFinished) {            if (!_isRunning) {                return;            }            stopAllTimers(); // make sure all our timers are stopped if the script is ending             emit scriptEnding();            emit finished(_fileNameString, this);            _isRunning = false;             emit runningStateChanged();            emit doneRunning();             timer->deleteLater();            return;        }         qint64 now = usecTimestampNow();        // we check for 'now' in the past in case people set their clock back        if (_lastUpdate < now) {            float deltaTime = (float)(now - _lastUpdate) / (float)USECS_PER_SECOND;            if (!_isFinished) {                emit update(deltaTime);            }        }        _lastUpdate = now;        // Debug and clear exceptions        hadUncaughtExceptions(*this, _fileNameString);    });     timer->start(10);}  void ScriptEngine::runInThread() {    Q_ASSERT_X(!_isThreaded, "ScriptEngine::runInThread()", "runInThread should not be called more than once");     if (_isThreaded) {        qCWarning(scriptengine) << "ScriptEngine already running in thread: " << getFilename();        return;    }     _isThreaded = true;    QThread* workerThread = new QThread();    QString scriptEngineName = QString("Script Thread:") + getFilename();    workerThread->setObjectName(scriptEngineName);     // NOTE: If you connect any essential signals for proper shutdown or cleanup of    // the script engine, make sure to add code to "reconnect" them to the    // disconnectNonEssentialSignals() method     // when the worker thread is started, call our engine's run..    connect(workerThread, &QThread::started, this, &ScriptEngine::run);     // tell the thread to stop when the script engine is done    connect(this, &ScriptEngine::doneRunning, workerThread, &QThread::quit);     moveToThread(workerThread);     // Starts an event loop, and emits workerThread->started()    workerThread->start();} void ScriptEngine::waitTillDoneRunning() {    // If the script never started running or finished running before we got here, we don't need to wait for it    auto workerThread = thread();    if (_isThreaded && workerThread) {        QString scriptName = getFilename();        auto startedWaiting = usecTimestampNow();         while (workerThread->isRunning()) {            // NOTE: This will be called on the main application thread from stopAllScripts.            //       The application thread will need to continue to process events, because            //       the scripts will likely need to marshall messages across to the main thread, e.g.            //       if they access Settings or Menu in any of their shutdown code. So:            // Process events for the main application thread, allowing invokeMethod calls to pass between threads.            QCoreApplication::processEvents(); // thread-safe :)             // If we've been waiting a second or more, then tell the script engine to stop evaluating            static const auto MAX_SCRIPT_EVALUATION_TIME =  USECS_PER_SECOND;            auto elapsedUsecs = usecTimestampNow() - startedWaiting;            if (elapsedUsecs > MAX_SCRIPT_EVALUATION_TIME) {                qCDebug(scriptengine) <<                    "Script " << scriptName << " has been running too long [" << elapsedUsecs << " usecs] quitting.";                abortEvaluation(); // to allow the thread to quit                workerThread->quit();                break;            }             // Avoid a pure busy wait            QThread::yieldCurrentThread();        }         workerThread->deleteLater();    }} QString ScriptEngine::getFilename() const {    QStringList fileNameParts = _fileNameString.split("/");    QString lastPart;    if (!fileNameParts.isEmpty()) {        lastPart = fileNameParts.last();    }    return lastPart;}  // FIXME - switch this to the new model of ScriptCache callbacksvoid ScriptEngine::loadURL(const QUrl& scriptURL, bool reload) {    if (_isRunning) {        return;    }     QUrl url = expandScriptUrl(scriptURL);    _fileNameString = url.toString();    _isReloading = reload;     bool isPending;    auto scriptCache = DependencyManager::get<ScriptCache>();    scriptCache->getScript(url, this, isPending, reload);} // FIXME - switch this to the new model of ScriptCache callbacksvoid ScriptEngine::scriptContentsAvailable(const QUrl& url, const QString& scriptContents) {    _scriptContents = scriptContents;    static const QString DEBUG_FLAG("#debug");    if (QRegularExpression(DEBUG_FLAG).match(scriptContents).hasMatch()) {        _debuggable = true;    }    emit scriptLoaded(url.toString());} // FIXME - switch this to the new model of ScriptCache callbacksvoid ScriptEngine::errorInLoadingScript(const QUrl& url) {    qCDebug(scriptengine) << "ERROR Loading file:" << url.toString() << "line:" << __LINE__;    emit errorLoadingScript(_fileNameString); // ??} // Even though we never pass AnimVariantMap directly to and from javascript, the queued invokeMethod of// callAnimationStateHandler requires that the type be registered.// These two are meaningful, if we ever do want to use them...static QScriptValue animVarMapToScriptValue(QScriptEngine* engine, const AnimVariantMap& parameters) {    QStringList unused;    return parameters.animVariantMapToScriptValue(engine, unused, false);}static void animVarMapFromScriptValue(const QScriptValue& value, AnimVariantMap& parameters) {    parameters.animVariantMapFromScriptValue(value);}// ... while these two are not. But none of the four are ever used.static QScriptValue resultHandlerToScriptValue(QScriptEngine* engine, const AnimVariantResultHandler& resultHandler) {    qCCritical(scriptengine) << "Attempt to marshall result handler to javascript";    assert(false);    return QScriptValue();}static void resultHandlerFromScriptValue(const QScriptValue& value, AnimVariantResultHandler& resultHandler) {    qCCritical(scriptengine) << "Attempt to marshall result handler from javascript";    assert(false);} // Templated qScriptRegisterMetaType fails to compile with raw pointersusing ScriptableResourceRawPtr = ScriptableResource*; static QScriptValue scriptableResourceToScriptValue(QScriptEngine* engine, const ScriptableResourceRawPtr& resource) {    // The first script to encounter this resource will track its memory.    // In this way, it will be more likely to GC.    // This fails in the case that the resource is used across many scripts, but    // in that case it would be too difficult to tell which one should track the memory, and    // this serves the common case (use in a single script).    auto data = resource->getResource();    if (data && !resource->isInScript()) {        resource->setInScript(true);        QObject::connect(data.data(), SIGNAL(updateSize(qint64)), engine, SLOT(updateMemoryCost(qint64)));    }     auto object = engine->newQObject(        const_cast<ScriptableResourceRawPtr>(resource),        QScriptEngine::ScriptOwnership);    return object;} static void scriptableResourceFromScriptValue(const QScriptValue& value, ScriptableResourceRawPtr& resource) {    resource = static_cast<ScriptableResourceRawPtr>(value.toQObject());} static QScriptValue createScriptableResourcePrototype(QScriptEngine* engine) {    auto prototype = engine->newObject();     // Expose enum State to JS/QML via properties    QObject* state = new QObject(engine);    state->setObjectName("ResourceState");    auto metaEnum = QMetaEnum::fromType<ScriptableResource::State>();    for (int i = 0; i < metaEnum.keyCount(); ++i) {        state->setProperty(metaEnum.key(i), metaEnum.value(i));    }     auto prototypeState = engine->newQObject(state, QScriptEngine::QtOwnership, QScriptEngine::ExcludeSlots | QScriptEngine::ExcludeSuperClassMethods);    prototype.setProperty("State", prototypeState);     return prototype;} void ScriptEngine::init() {    if (_isInitialized) {        return; // only initialize once    }     _isInitialized = true;     auto entityScriptingInterface = DependencyManager::get<EntityScriptingInterface>();    entityScriptingInterface->init();     // register various meta-types    registerMetaTypes(this);    registerMIDIMetaTypes(this);    registerEventTypes(this);    registerMenuItemProperties(this);    registerAnimationTypes(this);    registerAvatarTypes(this);    registerAudioMetaTypes(this);     qScriptRegisterMetaType(this, EntityPropertyFlagsToScriptValue, EntityPropertyFlagsFromScriptValue);    qScriptRegisterMetaType(this, EntityItemPropertiesToScriptValue, EntityItemPropertiesFromScriptValueHonorReadOnly);    qScriptRegisterMetaType(this, EntityItemIDtoScriptValue, EntityItemIDfromScriptValue);    qScriptRegisterMetaType(this, RayToEntityIntersectionResultToScriptValue, RayToEntityIntersectionResultFromScriptValue);    qScriptRegisterSequenceMetaType<QVector<QUuid>>(this);    qScriptRegisterSequenceMetaType<QVector<EntityItemID>>(this);     qScriptRegisterSequenceMetaType<QVector<glm::vec2> >(this);    qScriptRegisterSequenceMetaType<QVector<glm::quat> >(this);    qScriptRegisterSequenceMetaType<QVector<QString> >(this);     QScriptValue xmlHttpRequestConstructorValue = newFunction(XMLHttpRequestClass::constructor);    globalObject().setProperty("XMLHttpRequest", xmlHttpRequestConstructorValue);     QScriptValue webSocketConstructorValue = newFunction(WebSocketClass::constructor);    globalObject().setProperty("WebSocket", webSocketConstructorValue);     QScriptValue printConstructorValue = newFunction(debugPrint);    globalObject().setProperty("print", printConstructorValue);     QScriptValue audioEffectOptionsConstructorValue = newFunction(AudioEffectOptions::constructor);    globalObject().setProperty("AudioEffectOptions", audioEffectOptionsConstructorValue);     qScriptRegisterMetaType(this, injectorToScriptValue, injectorFromScriptValue);    qScriptRegisterMetaType(this, inputControllerToScriptValue, inputControllerFromScriptValue);    qScriptRegisterMetaType(this, avatarDataToScriptValue, avatarDataFromScriptValue);    qScriptRegisterMetaType(this, animationDetailsToScriptValue, animationDetailsFromScriptValue);    qScriptRegisterMetaType(this, webSocketToScriptValue, webSocketFromScriptValue);    qScriptRegisterMetaType(this, qWSCloseCodeToScriptValue, qWSCloseCodeFromScriptValue);    qScriptRegisterMetaType(this, wscReadyStateToScriptValue, wscReadyStateFromScriptValue);     registerGlobalObject("Script", this);    registerGlobalObject("Audio", &AudioScriptingInterface::getInstance());    registerGlobalObject("Entities", entityScriptingInterface.data());    registerGlobalObject("Quat", &_quatLibrary);    registerGlobalObject("Vec3", &_vec3Library);    registerGlobalObject("Mat4", &_mat4Library);    registerGlobalObject("Uuid", &_uuidLibrary);    registerGlobalObject("Messages", DependencyManager::get<MessagesClient>().data());    qScriptRegisterMetaType(this, animVarMapToScriptValue, animVarMapFromScriptValue);    qScriptRegisterMetaType(this, resultHandlerToScriptValue, resultHandlerFromScriptValue);     // Scriptable cache access    auto resourcePrototype = createScriptableResourcePrototype(this);    globalObject().setProperty("Resource", resourcePrototype);    setDefaultPrototype(qMetaTypeId<ScriptableResource*>(), resourcePrototype);    qScriptRegisterMetaType(this, scriptableResourceToScriptValue, scriptableResourceFromScriptValue);     // constants    globalObject().setProperty("TREE_SCALE", newVariant(QVariant(TREE_SCALE)));     auto scriptingInterface = DependencyManager::get<controller::ScriptingInterface>();    registerGlobalObject("Controller", scriptingInterface.data());

Lines 1–500 of 1544. Load more