Method ExecuteScript

src/v8runtime/V8Runtime.cpp:207–257

}

jsi::Value V8Runtime::ExecuteScript(
    v8::Isolate *isolate,
    const v8::Local<v8::String> &script,
    const std::string &sourceURL) {
  v8::HandleScope scopedHandle(isolate);
  v8::TryCatch tryCatch(isolate);

  v8::MaybeLocal<v8::String> sourceURLValue = v8::String::NewFromUtf8(
      isolate,
      sourceURL.c_str(),
      v8::NewStringType::kNormal,
      static_cast<int>(sourceURL.length()));
  v8::ScriptOrigin origin(isolate, sourceURLValue.ToLocalChecked());

  v8::Local<v8::Context> context(isolate->GetCurrentContext());

  auto codecache = LoadCodeCacheIfNeeded(sourceURL);
  v8::ScriptCompiler::CachedData *cachedData = codecache.release();

  std::unique_ptr<v8::ScriptCompiler::Source> source =
      UseFakeSourceIfNeeded(origin, cachedData);
  if (!source) {
    source = std::make_unique<v8::ScriptCompiler::Source>(
        script, origin, cachedData);
  }

  v8::Local<v8::Script> compiledScript;
  if (!v8::ScriptCompiler::Compile(
           context,
           source.release(),
           cachedData ? v8::ScriptCompiler::kConsumeCodeCache
                      : v8::ScriptCompiler::kNoCompileOptions)
           .ToLocal(&compiledScript)) {
    ReportException(isolate, &tryCatch);
    return {};
  }

  if (cachedData && cachedData->rejected) {
    LOG(INFO) << "[rnv8] cache miss: " << sourceURL;
  }
  SaveCodeCacheIfNeeded(compiledScript, sourceURL, cachedData);

  v8::Local<v8::Value> result;
  if (!compiledScript->Run(context).ToLocal(&result)) {
    assert(tryCatch.HasCaught());
    ReportException(isolate, &tryCatch);
    return {};
  }

  return JSIV8ValueConverter::ToJSIValue(isolate, result);
}

void V8Runtime::ReportException(v8::Isolate *isolate, v8::TryCatch *tryCatch)
    const {