* rework _requireResolve error throws (to avoid using lambda w/default args -- which vc++ didn't care for) * add ExceptionEmitters to require/resolve so errors get logged even if invoked indpendently from a script

humbletim committed 9 years ago

Commit 32e450e1 parent efc61c21 file · +24 −24Browse files

Showing the changes to libraries/script-engine/src/ScriptEngine.cpp (1 of 1 file). Show all

Unified · Split

libraries/script-engine/src/ScriptEngine.cpp+24−24

 QString ScriptEngine::_requireResolve(const QString& moduleId, const QString& relativeTo) {
     QUrl defaultScriptsLoc = defaultScriptsLocation();
     QUrl url(moduleId);
+    ExceptionEmitter tryCatcher(this, __FUNCTION__);
-    // helper to generate an exception and return a null string
+    auto displayId = moduleId;
-    auto resolverException = [=](const QString& detail, const QString& type = "Error") -> QString {
+    if (displayId.length() > MAX_DEBUG_VALUE_LENGTH) {
-        auto displayId = moduleId;
+        displayId = displayId.mid(0, MAX_DEBUG_VALUE_LENGTH) + "...";
-        if (displayId.length() > MAX_DEBUG_VALUE_LENGTH) {
+    }
-            displayId = displayId.mid(0, MAX_DEBUG_VALUE_LENGTH) + "...";
+    auto message = QString("Cannot find module '%1' (%2)").arg(displayId);
-        }
+    auto ctx = currentContext();
-        currentContext()->throwValue(makeError(
-            QString("Cannot find module '%1' (%2)")
-                .arg(displayId)
-                .arg(detail), type));
-        return QString();
-    };
     // de-fuzz the input a little by restricting to rational sizes
     auto idLength = url.toString().length();
     if (idLength < 1 || idLength > MAX_MODULE_ID_LENTGH) {
-        return resolverException(
+        auto details = QString("rejecting invalid module id size (%1 chars [1,%2])")
-            QString("rejecting invalid module id size (%1 chars [1,%2])")
+            .arg(idLength).arg(MAX_MODULE_ID_LENTGH);
-               .arg(idLength).arg(MAX_MODULE_ID_LENTGH),
+        ctx->throwValue(makeError(message.arg(details), "RangeError"));
-            "RangeError"
+        return nullptr;
-        );
     }
     // this regex matches: absolute, dotted or path-like URLs
         url = defaultScriptsLoc;
         url.setPath(systemModulePath);
         if (!QFileInfo(url.toLocalFile()).isFile()) {
-            return resolverException("system module not found");
+            ctx->throwValue(makeError(message.arg("system module not found")));
+            return nullptr;
         }
     }
     if (url.isRelative()) {
-        return resolverException("could not resolve module id");
+        ctx->throwValue(makeError(message.arg("could not resolve module id")));
+        return nullptr;
     }
     // if it looks like a local file, verify that it's an allowed path and really a file
         bool disallowOutsideFiles = !defaultScriptsLocation().isParentOf(canonical) && !currentSandboxURL.isLocalFile();
         if (disallowOutsideFiles && !PathUtils::isDescendantOf(canonical, currentSandboxURL)) {
-            return resolverException(
+            ctx->throwValue(makeError(message.arg(
                 QString("path '%1' outside of origin script '%2' '%3'")
                     .arg(PathUtils::stripFilename(url))
                     .arg(PathUtils::stripFilename(currentSandboxURL))
                     .arg(canonical.toString())
-            );
+            )));
+            return nullptr;
         }
         if (!file.exists()) {
-            return resolverException("path does not exist: " + url.toLocalFile());
+            ctx->throwValue(makeError(message.arg("path does not exist: " + url.toLocalFile())));
+            return nullptr;
         }
         if (!file.isFile()) {
-            return resolverException("path is not a file: " + url.toLocalFile());
+            ctx->throwValue(makeError(message.arg("path is not a file: " + url.toLocalFile())));
+            return nullptr;
         }
     }
     // serialize require calls so the ordering/caching works correctly across multiple Entities
     // note: this is a Recursive mutex so nested require's should not affected
     QMutexLocker locker(&_requireLock);
+    ExceptionEmitter tryCatcher(this, __FUNCTION__);
     // _requireDepth++;
     // QObject autoDecrement;connect(&autoDecrement, &QObject::destroyed, this, [this](){ _requireDepth--; });
     // start by resolving the moduleId into a fully-qualified path/URL
     QString modulePath = _requireResolve(moduleId);
-    if (hasUncaughtException()) {
+    if (modulePath.isNull() || tryCatcher.hasPending()) {
         // the resolver already threw an exception -- bail early
         return nullValue();
     }