#include "ClearScriptV8Native.h"

class FromMaybeScope final

{

};

class FromMaybeFailure final

{

};

template <typename T>

inline T FromMaybe(FromMaybeScope& /*scope*/, const v8::Maybe<T>& maybe)

}

template <typename T>

inline v8::Local<T> FromMaybe(FromMaybeScope& /*scope*/, const v8::MaybeLocal<T>& maybe)

}

template <typename T>

inline T FromMaybeDefault(const v8::Maybe<T>& maybe, const T& defaultValue = T())

{

return maybe.FromMaybe(defaultValue);

}

template <typename T>

inline v8::Local<T> FromMaybeDefault(const v8::MaybeLocal<T>& maybe, const v8::Local<T>& defaultValue = v8::Local<T>())

{

return maybe.FromMaybe(defaultValue);

}

#define FROM_MAYBE_TRY \

{ \

DISABLE_WARNING(4456) /* declaration hides previous local declaration */ \

FromMaybeScope t_FromMaybeScope; \

DEFAULT_WARNING(4456) \

try \

{

#define FROM_MAYBE_CATCH \

IGNORE_UNUSED(t_FromMaybeScope); \

} \

catch (const FromMaybeFailure&) \

{ \

#define FROM_MAYBE_END \

IGNORE_UNUSED(t_FromMaybeScope); \

} \

}

#define FROM_MAYBE_CATCH_CONSUME \

FROM_MAYBE_CATCH \

FROM_MAYBE_END

#define FROM_MAYBE(...) \

(::FromMaybe(t_FromMaybeScope, __VA_ARGS__))

#define FROM_MAYBE_DEFAULT(...) \

(::FromMaybeDefault(__VA_ARGS__))

inline v8::Local<v8::String> ValueAsString(const v8::Local<v8::Value>& hValue)

}

inline v8::Local<v8::Object> ValueAsObject(const v8::Local<v8::Value>& hValue)

{

return (!hValue.IsEmpty() && hValue->IsObject()) ? hValue.As<v8::Object>() : v8::Local<v8::Object>();

}

inline v8::Local<v8::External> ValueAsExternal(const v8::Local<v8::Value>& hValue)

{

return (!hValue.IsEmpty() && hValue->IsExternal()) ? hValue.As<v8::External>() : v8::Local<v8::External>();

}

inline v8::Local<v8::Function> ValueAsFunction(const v8::Local<v8::Value>& hValue)

{

return (!hValue.IsEmpty() && hValue->IsFunction()) ? hValue.As<v8::Function>() : v8::Local<v8::Function>();

}

inline v8::Local<v8::BigInt> ValueAsBigInt(const v8::Local<v8::Value>& hValue)

}

inline bool TryGetValueAsBoolean(const SharedPtr<V8IsolateImpl>& spIsolateImpl, const v8::Local<v8::Value>& hValue, bool& value)

}

inline bool TryGetValueAsNumber(v8::Local<v8::Context> hContext, const v8::Local<v8::Value>& hValue, double& value)

}

template <typename TInfo>

inline V8ContextImpl* GetContextImplFromHolder(const TInfo& info)

{

auto hHolder = info.Holder();

if (!hHolder.IsEmpty() && hHolder->InternalFieldCount() > 0)

{

auto hField = hHolder->GetInternalField(0);

if (!hField.IsEmpty() && hField->IsValue() && !hField.template As<v8::Value>()->IsUndefined())

{

return static_cast<V8ContextImpl*>(hHolder->GetAlignedPointerFromInternalField(0, v8::kEmbedderDataTypeTagDefault));

}

}

return nullptr;

}

template <typename TInfo>

inline V8ContextImpl* GetContextImplFromData(const TInfo& info)

{

auto hContextImpl = ::ValueAsExternal(info.Data());

return !hContextImpl.IsEmpty() ? static_cast<V8ContextImpl*>(hContextImpl->Value(v8::kExternalPointerTypeTagDefault)) : nullptr;

}

template <typename TVariable, typename TValue>

inline void SetIfSameType(TVariable& /*variable*/, TValue /*value*/)

{

}

template <typename TVariable>

inline void SetIfSameType(TVariable& variable, TVariable value)

{

variable = value;

}

template <typename T>

inline v8::Intercepted GetCallbackStatus(const T& /*value*/)

{

return v8::Intercepted::kYes;

}

template <typename T>

inline v8::Intercepted GetCallbackStatus(const v8::Local<T>& hValue)

{

return hValue.IsEmpty() ? v8::Intercepted::kNo : v8::Intercepted::kYes;

}

template <typename TInfo, typename TResult, typename TStatus>

inline void ProcessCallbackResult(const TResult& result, const TInfo& info, TStatus& status)

}

template <typename TInfo, typename TStatus>

inline void ProcessVoidCallbackResult(const TInfo& info, TStatus& status)

}

#define BEGIN_ISOLATE_SCOPE \

{ \

DISABLE_WARNING(4456) /* declaration hides previous local declaration */ \

V8IsolateImpl::Scope t_IsolateScope(*m_spIsolateImpl); \

DEFAULT_WARNING(4456)

#define END_ISOLATE_SCOPE \

IGNORE_UNUSED(t_IsolateScope); \

}

#define BEGIN_CONTEXT_SCOPE \

{ \

DISABLE_WARNING(4456) /* declaration hides previous local declaration */ \

Scope t_ContextScope(this); \

DEFAULT_WARNING(4456)

#define END_CONTEXT_SCOPE \

IGNORE_UNUSED(t_ContextScope); \

}

#define BEGIN_EXECUTION_SCOPE \

{ \

DISABLE_WARNING(4456) /* declaration hides previous local declaration */ \

V8IsolateImpl::ExecutionScope t_ExecutionScope(*m_spIsolateImpl); \

V8IsolateImpl::TryCatch t_TryCatch(*m_spIsolateImpl); \

DEFAULT_WARNING(4456)

#define END_EXECUTION_SCOPE \

IGNORE_UNUSED(t_TryCatch); \

IGNORE_UNUSED(t_ExecutionScope); \

}

#define EXECUTION_STARTED \

(t_ExecutionScope.ExecutionStarted())

#define BEGIN_DOCUMENT_SCOPE(DOCUMENT_INFO) \

{ \

DISABLE_WARNING(4456) /* declaration hides previous local declaration */ \

V8IsolateImpl::DocumentScope t_DocumentScope(*m_spIsolateImpl, DOCUMENT_INFO); \

DEFAULT_WARNING(4456)

#define END_DOCUMENT_SCOPE \

IGNORE_UNUSED(t_DocumentScope); \

}

#define VERIFY(RESULT) \

(Verify(t_ExecutionScope, t_TryCatch, RESULT))

#define VERIFY_MAYBE(RESULT) \

VERIFY(FROM_MAYBE_DEFAULT(RESULT))

#define VERIFY_CHECKPOINT() \

(Verify(t_ExecutionScope, t_TryCatch))

#define CALLBACK_RETURN(RESULT) \

BEGIN_COMPOUND_MACRO \

::ProcessCallbackResult(RESULT, info, t_CallbackStatus); \

return; \

END_COMPOUND_MACRO

#define CALLBACK_RETURN_VOID() \

BEGIN_COMPOUND_MACRO \

::ProcessVoidCallbackResult(info, t_CallbackStatus); \

return; \

END_COMPOUND_MACRO

#define CALLBACK_ENTER \

auto t_CallbackStatus = v8::Intercepted::kNo; \

([&] () noexcept -> void \

{ \

#define CALLBACK_EXIT \

} \

)(); \

return t_CallbackStatus;

constexpr enum class DummyCallbackStatus {} t_CallbackStatus {};

static std::atomic<size_t> s_InstanceCount(0);

V8ContextImpl::V8ContextImpl(V8IsolateImpl* pIsolateImpl, const StdString& name):

V8ContextImpl(SharedPtr<V8IsolateImpl>(pIsolateImpl), name, Options())

{

}

V8ContextImpl::V8ContextImpl(SharedPtr<V8IsolateImpl>&& spIsolateImpl, const StdString& name, const Options& options):

}

if (m_hContext.IsEmpty())

{

throw FromMaybeFailure();

}

auto hContextImpl = CreateExternal(this);

auto globalFlags = V8IsolateImpl::GetGlobalFlags();

v8::Local<v8::FunctionTemplate> hGetHostObjectIteratorFunction;

v8::Local<v8::FunctionTemplate> hGetHostObjectAsyncIteratorFunction;

v8::Local<v8::FunctionTemplate> hDisposeHostObjectFunction;

v8::Local<v8::FunctionTemplate> hAsyncDisposeHostObjectFunction;

v8::Local<v8::FunctionTemplate> hGetFastHostObjectIteratorFunction;

v8::Local<v8::FunctionTemplate> hGetFastHostObjectAsyncIteratorFunction;

v8::Local<v8::FunctionTemplate> hDisposeFastHostObjectFunction;

v8::Local<v8::FunctionTemplate> hAsyncDisposeFastHostObjectFunction;

v8::Local<v8::FunctionTemplate> hGetHostObjectJsonFunction;

v8::Local<v8::FunctionTemplate> hHostDelegateToFunctionFunction;

BEGIN_CONTEXT_SCOPE

m_hContext->SetAlignedPointerInEmbedderData(1, this, 1);

m_hIsHostObjectKey = CreatePersistent(CreateSymbol());

ASSERT_EVAL(FROM_MAYBE(m_hContext->Global()->Set(m_hContext, CreateString("isHostObjectKey"), m_hIsHostObjectKey)));

m_hModuleResultKey = CreatePersistent(CreateSymbol());

ASSERT_EVAL(FROM_MAYBE(m_hContext->Global()->Set(m_hContext, CreateString("moduleResultKey"), m_hModuleResultKey)));

ASSERT_EVAL(FROM_MAYBE(m_hContext->Global()->Set(m_hContext, CreateString("getPromiseState"), FROM_MAYBE(v8::Function::New(m_hContext, GetPromiseStateCallback, hContextImpl)))));

ASSERT_EVAL(FROM_MAYBE(m_hContext->Global()->Set(m_hContext, CreateString("getPromiseResult"), FROM_MAYBE(v8::Function::New(m_hContext, GetPromiseResultCallback, hContextImpl)))));

m_hMissingPropertyValue = CreatePersistent(CreateSymbol());

m_hHostExceptionKey = CreatePersistent(CreateString("hostException"));

m_hCacheKey = CreatePersistent(CreatePrivate());

m_hAccessTokenKey = CreatePersistent(CreatePrivate());

m_hInternalUseOnly = CreatePersistent(CreateString("The invoked function is for ClearScript internal use only"));

m_hStackKey = CreatePersistent(CreateString("stack"));

m_hObjectNotInvocable = CreatePersistent(CreateString("The object does not support invocation"));

m_hMethodOrPropertyNotFound = CreatePersistent(CreateString("Method or property not found"));

m_hPropertyValueNotInvocable = CreatePersistent(CreateString("The property value does not support invocation"));

m_hInvalidModuleRequest = CreatePersistent(CreateString("Invalid module load request"));

m_hConstructorKey = CreatePersistent(CreateString("constructor"));

m_hSetModuleResultKey = CreatePersistent(CreateString("setResult"));

hGetHostObjectIteratorFunction = CreateFunctionTemplate(GetHostObjectIterator, hContextImpl);

hGetHostObjectAsyncIteratorFunction = CreateFunctionTemplate(GetHostObjectAsyncIterator, hContextImpl);

if (!::HasFlag(globalFlags, V8GlobalFlags::DisableExplicitResourceManagement))

{

hDisposeHostObjectFunction = CreateFunctionTemplate(DisposeHostObject, hContextImpl);

hAsyncDisposeHostObjectFunction = CreateFunctionTemplate(AsyncDisposeHostObject, hContextImpl);

}

hGetFastHostObjectIteratorFunction = CreateFunctionTemplate(GetFastHostObjectIterator, hContextImpl);

hGetFastHostObjectAsyncIteratorFunction = CreateFunctionTemplate(GetFastHostObjectAsyncIterator, hContextImpl);

if (!::HasFlag(globalFlags, V8GlobalFlags::DisableExplicitResourceManagement))

{

hDisposeFastHostObjectFunction = CreateFunctionTemplate(DisposeFastHostObject, hContextImpl);

hAsyncDisposeFastHostObjectFunction = CreateFunctionTemplate(AsyncDisposeFastHostObject, hContextImpl);

}

hGetHostObjectJsonFunction = CreateFunctionTemplate(GetHostObjectJson, hContextImpl);

hHostDelegateToFunctionFunction = CreateFunctionTemplate(CreateFunctionForHostDelegate, hContextImpl);

m_hAccessToken = CreatePersistent(CreateObject());

m_hFlushFunction = CreatePersistent(FROM_MAYBE(v8::Function::New(m_hContext, FlushCallback)));

m_hTerminationException = CreatePersistent(v8::Exception::Error(CreateString("Script execution was interrupted")));

if (::HasFlag(options.Flags, Flags::AddPerformanceObject))

{

auto hPerformance = CreateObject();

ASSERT_EVAL(FROM_MAYBE(hPerformance->DefineOwnProperty(m_hContext, CreateString("timeOrigin"), CreateNumber(timeOrigin), ::CombineFlags(v8::ReadOnly, v8::DontDelete))));

ASSERT_EVAL(FROM_MAYBE(hPerformance->DefineOwnProperty(m_hContext, CreateString("now"), FROM_MAYBE(v8::Function::New(m_hContext, PerformanceNowCallback, hContextImpl)), ::CombineFlags(v8::ReadOnly, v8::DontDelete))));

ASSERT_EVAL(FROM_MAYBE(hPerformance->DefineOwnProperty(m_hContext, CreateString("sleep"), FROM_MAYBE(v8::Function::New(m_hContext, PerformanceSleepCallback, hContextImpl)), ::CombineFlags(v8::ReadOnly, v8::DontDelete))));

ASSERT_EVAL(FROM_MAYBE(m_hContext->Global()->DefineOwnProperty(m_hContext, CreateString("Performance"), hPerformance, v8::DontEnum)));

}

END_CONTEXT_SCOPE

auto hToJSON = CreateString("toJSON");

m_hHostObjectTemplate = CreatePersistent(CreateFunctionTemplate());

m_hHostObjectTemplate->SetClassName(CreateString("HostObject"));

m_hHostObjectTemplate->SetCallHandler(HostObjectConstructorCallHandler, hContextImpl);

m_hHostObjectTemplate->InstanceTemplate()->SetHandler(v8::NamedPropertyHandlerConfiguration(GetHostObjectProperty, SetHostObjectProperty, QueryHostObjectProperty, DeleteHostObjectProperty, GetHostObjectPropertyNames, hContextImpl, v8::PropertyHandlerFlags::kNone));

m_hHostObjectTemplate->InstanceTemplate()->SetHandler(v8::IndexedPropertyHandlerConfiguration(GetHostObjectProperty, SetHostObjectProperty, QueryHostObjectProperty, DeleteHostObjectProperty, GetHostObjectPropertyIndices, hContextImpl));

m_hHostObjectTemplate->PrototypeTemplate()->Set(GetIteratorSymbol(), hGetHostObjectIteratorFunction);

m_hHostObjectTemplate->PrototypeTemplate()->Set(GetAsyncIteratorSymbol(), hGetHostObjectAsyncIteratorFunction);

m_hHostObjectTemplate->PrototypeTemplate()->Set(hToJSON, hGetHostObjectJsonFunction, ::CombineFlags(v8::ReadOnly, v8::DontDelete, v8::DontEnum));

if (!::HasFlag(globalFlags, V8GlobalFlags::DisableExplicitResourceManagement))

{

m_hHostObjectTemplate->PrototypeTemplate()->Set(GetDisposeSymbol(), hDisposeHostObjectFunction);

m_hHostObjectTemplate->PrototypeTemplate()->Set(GetAsyncDisposeSymbol(), hAsyncDisposeHostObjectFunction);

}

m_hHostInvocableTemplate = CreatePersistent(CreateFunctionTemplate());

m_hHostInvocableTemplate->SetClassName(CreateString("HostInvocable"));

m_hHostInvocableTemplate->SetCallHandler(HostObjectConstructorCallHandler, hContextImpl);

m_hHostInvocableTemplate->InstanceTemplate()->SetHandler(v8::NamedPropertyHandlerConfiguration(GetHostObjectProperty, SetHostObjectProperty, QueryHostObjectProperty, DeleteHostObjectProperty, GetHostObjectPropertyNames, hContextImpl, v8::PropertyHandlerFlags::kNone));

m_hHostInvocableTemplate->InstanceTemplate()->SetHandler(v8::IndexedPropertyHandlerConfiguration(GetHostObjectProperty, SetHostObjectProperty, QueryHostObjectProperty, DeleteHostObjectProperty, GetHostObjectPropertyIndices, hContextImpl));

m_hHostInvocableTemplate->PrototypeTemplate()->Set(GetIteratorSymbol(), hGetHostObjectIteratorFunction);

m_hHostInvocableTemplate->PrototypeTemplate()->Set(GetAsyncIteratorSymbol(), hGetHostObjectAsyncIteratorFunction);

m_hHostInvocableTemplate->PrototypeTemplate()->Set(hToJSON, hGetHostObjectJsonFunction, ::CombineFlags(v8::ReadOnly, v8::DontDelete, v8::DontEnum));

m_hHostInvocableTemplate->InstanceTemplate()->SetCallAsFunctionHandler(InvokeHostObject, hContextImpl);

if (!::HasFlag(globalFlags, V8GlobalFlags::DisableExplicitResourceManagement))

{

m_hHostInvocableTemplate->PrototypeTemplate()->Set(GetDisposeSymbol(), hDisposeHostObjectFunction);

m_hHostInvocableTemplate->PrototypeTemplate()->Set(GetAsyncDisposeSymbol(), hAsyncDisposeHostObjectFunction);

}

m_hHostDelegateTemplate = CreatePersistent(CreateFunctionTemplate());

m_hHostDelegateTemplate->SetClassName(CreateString("HostDelegate"));

m_hHostDelegateTemplate->SetCallHandler(HostObjectConstructorCallHandler, hContextImpl);

m_hHostDelegateTemplate->InstanceTemplate()->SetHandler(v8::NamedPropertyHandlerConfiguration(GetHostObjectProperty, SetHostObjectProperty, QueryHostObjectProperty, DeleteHostObjectProperty, GetHostObjectPropertyNames, hContextImpl, v8::PropertyHandlerFlags::kNone));

m_hHostDelegateTemplate->InstanceTemplate()->SetHandler(v8::IndexedPropertyHandlerConfiguration(GetHostObjectProperty, SetHostObjectProperty, QueryHostObjectProperty, DeleteHostObjectProperty, GetHostObjectPropertyIndices, hContextImpl));

m_hHostDelegateTemplate->PrototypeTemplate()->Set(GetIteratorSymbol(), hGetHostObjectIteratorFunction);

m_hHostDelegateTemplate->PrototypeTemplate()->Set(GetAsyncIteratorSymbol(), hGetHostObjectAsyncIteratorFunction);

m_hHostDelegateTemplate->PrototypeTemplate()->Set(hToJSON, hGetHostObjectJsonFunction, ::CombineFlags(v8::ReadOnly, v8::DontDelete, v8::DontEnum));

m_hHostDelegateTemplate->InstanceTemplate()->SetCallAsFunctionHandler(InvokeHostObject, hContextImpl);

m_hHostDelegateTemplate->InstanceTemplate()->SetHostDelegate(); // instructs our patched V8 typeof implementation to return "function"

m_hHostDelegateTemplate->PrototypeTemplate()->Set(CreateString("toFunction"), hHostDelegateToFunctionFunction);

if (!::HasFlag(globalFlags, V8GlobalFlags::DisableExplicitResourceManagement))

{

m_hHostDelegateTemplate->PrototypeTemplate()->Set(GetDisposeSymbol(), hDisposeHostObjectFunction);

m_hHostDelegateTemplate->PrototypeTemplate()->Set(GetAsyncDisposeSymbol(), hAsyncDisposeHostObjectFunction);

}

m_hFastHostObjectTemplate = CreatePersistent(CreateFunctionTemplate());

m_hFastHostObjectTemplate->SetClassName(CreateString("FastHostObject"));

m_hFastHostObjectTemplate->SetCallHandler(HostObjectConstructorCallHandler, hContextImpl);

m_hFastHostObjectTemplate->InstanceTemplate()->SetHandler(v8::NamedPropertyHandlerConfiguration(GetFastHostObjectProperty, SetFastHostObjectProperty, QueryFastHostObjectProperty, DeleteFastHostObjectProperty, GetFastHostObjectPropertyNames, hContextImpl, v8::PropertyHandlerFlags::kNone));

m_hFastHostObjectTemplate->InstanceTemplate()->SetHandler(v8::IndexedPropertyHandlerConfiguration(GetFastHostObjectProperty, SetFastHostObjectProperty, QueryFastHostObjectProperty, DeleteFastHostObjectProperty, GetFastHostObjectPropertyIndices, hContextImpl));

m_hFastHostObjectTemplate->PrototypeTemplate()->Set(GetIteratorSymbol(), hGetFastHostObjectIteratorFunction);

m_hFastHostObjectTemplate->PrototypeTemplate()->Set(GetAsyncIteratorSymbol(), hGetFastHostObjectAsyncIteratorFunction);

if (!::HasFlag(globalFlags, V8GlobalFlags::DisableExplicitResourceManagement))

{

m_hFastHostObjectTemplate->PrototypeTemplate()->Set(GetDisposeSymbol(), hDisposeFastHostObjectFunction);

m_hFastHostObjectTemplate->PrototypeTemplate()->Set(GetAsyncDisposeSymbol(), hAsyncDisposeFastHostObjectFunction);

}

m_hFastHostFunctionTemplate = CreatePersistent(CreateFunctionTemplate());

m_hFastHostFunctionTemplate->SetClassName(CreateString("FastHostFunction"));

m_hFastHostFunctionTemplate->SetCallHandler(HostObjectConstructorCallHandler, hContextImpl);

m_hFastHostFunctionTemplate->InstanceTemplate()->SetHandler(v8::NamedPropertyHandlerConfiguration(GetFastHostObjectProperty, SetFastHostObjectProperty, QueryFastHostObjectProperty, DeleteFastHostObjectProperty, GetFastHostObjectPropertyNames, hContextImpl, v8::PropertyHandlerFlags::kNone));

m_hFastHostFunctionTemplate->InstanceTemplate()->SetHandler(v8::IndexedPropertyHandlerConfiguration(GetFastHostObjectProperty, SetFastHostObjectProperty, QueryFastHostObjectProperty, DeleteFastHostObjectProperty, GetFastHostObjectPropertyIndices, hContextImpl));

m_hFastHostFunctionTemplate->PrototypeTemplate()->Set(GetIteratorSymbol(), hGetFastHostObjectIteratorFunction);

m_hFastHostFunctionTemplate->PrototypeTemplate()->Set(GetAsyncIteratorSymbol(), hGetFastHostObjectAsyncIteratorFunction);

m_hFastHostFunctionTemplate->InstanceTemplate()->SetCallAsFunctionHandler(InvokeFastHostObject, hContextImpl);

m_hFastHostFunctionTemplate->InstanceTemplate()->SetHostDelegate(); // instructs our patched V8 typeof implementation to return "function"

m_hFastHostFunctionTemplate->PrototypeTemplate()->Set(CreateString("toFunction"), hHostDelegateToFunctionFunction);

if (!::HasFlag(globalFlags, V8GlobalFlags::DisableExplicitResourceManagement))

{

m_hFastHostFunctionTemplate->PrototypeTemplate()->Set(GetDisposeSymbol(), hDisposeFastHostObjectFunction);

m_hFastHostFunctionTemplate->PrototypeTemplate()->Set(GetAsyncDisposeSymbol(), hAsyncDisposeFastHostObjectFunction);

}

m_pvV8ObjectCache = HostObjectUtil::CreateV8ObjectCache();

m_spIsolateImpl->AddContext(this, options);

FROM_MAYBE_CATCH

Teardown();

throw V8Exception(V8Exception::Type::General, m_Name, StdString(SL("The V8 runtime cannot initialize the script engine because a script exception is pending")), false);

FROM_MAYBE_END

END_ISOLATE_SCOPE

++s_InstanceCount;

}

size_t V8ContextImpl::GetInstanceCount()

{

return s_InstanceCount;

}

size_t V8ContextImpl::GetMaxIsolateHeapSize()

{

return m_spIsolateImpl->GetMaxHeapSize();

}

void V8ContextImpl::SetMaxIsolateHeapSize(size_t value)

{

m_spIsolateImpl->SetMaxHeapSize(value);

}

double V8ContextImpl::GetIsolateHeapSizeSampleInterval()

{

return m_spIsolateImpl->GetHeapSizeSampleInterval();

}

void V8ContextImpl::SetIsolateHeapSizeSampleInterval(double value)

{

m_spIsolateImpl->SetHeapSizeSampleInterval(value);

}

size_t V8ContextImpl::GetMaxIsolateStackUsage()

{

return m_spIsolateImpl->GetMaxStackUsage();

}

void V8ContextImpl::SetMaxIsolateStackUsage(size_t value)

{

m_spIsolateImpl->SetMaxStackUsage(value);

}

void V8ContextImpl::CallWithLock(CallWithLockCallback* pCallback, void* pvAction)

}

void V8ContextImpl::CallWithLockWithArg(CallWithLockWithArgCallback* pCallback, void* pvAction, void* pvArg)

}

V8Value V8ContextImpl::GetRootObject()

}

void V8ContextImpl::SetGlobalProperty(const StdString& name, const V8Value& value, bool globalMembers)

}

void V8ContextImpl::AwaitDebuggerAndPause()

{

m_spIsolateImpl->AwaitDebuggerAndPause();

}

void V8ContextImpl::CancelAwaitDebugger()

{

m_spIsolateImpl->CancelAwaitDebugger();

}

V8Value V8ContextImpl::Execute(const V8DocumentInfo& documentInfo, const StdString& code, bool evaluate)

}

V8ScriptHolder* V8ContextImpl::Compile(const V8DocumentInfo& documentInfo, StdString&& code)

{

BEGIN_CONTEXT_SCOPE

BEGIN_DOCUMENT_SCOPE(documentInfo)

BEGIN_EXECUTION_SCOPE

FROM_MAYBE_TRY

auto codeDigest = code.GetDigest();

v8::ScriptCompiler::Source source(FROM_MAYBE(CreateString(code)), CreateScriptOrigin(documentInfo));

std::unique_ptr<V8ScriptHolder> upScriptHolder;

if (documentInfo.IsModule())

{

auto hModule = GetCachedModule(documentInfo.GetUniqueId(), codeDigest);

if (hModule.IsEmpty())

{

hModule = VERIFY_MAYBE(CompileModule(&source));

if (hModule.IsEmpty())

{

throw V8Exception(V8Exception::Type::General, m_Name, StdString(SL("Module compilation failed; no additional information was provided by the V8 runtime")), false);

}

CacheModule(documentInfo, codeDigest, hModule);

}

upScriptHolder.reset(new V8ScriptHolderImpl(GetWeakBinding(), ::PtrFromHandle(CreatePersistent(hModule)), documentInfo, codeDigest, std::move(code)));

}

else

{

auto hScript = GetCachedScript(documentInfo.GetUniqueId(), codeDigest);

if (hScript.IsEmpty())

{

hScript = VERIFY_MAYBE(CompileUnboundScript(&source));

if (hScript.IsEmpty())

{

throw V8Exception(V8Exception::Type::General, m_Name, StdString(SL("Script compilation failed; no additional information was provided by the V8 runtime")), false);

}

CacheScript(documentInfo, codeDigest, hScript);

}

upScriptHolder.reset(new V8ScriptHolderImpl(GetWeakBinding(), ::PtrFromHandle(CreatePersistent(hScript)), documentInfo, codeDigest));

}

return upScriptHolder.release();

FROM_MAYBE_CATCH

throw V8Exception(V8Exception::Type::General, m_Name, StdString(SL("The V8 runtime cannot perform the requested operation because a script exception is pending")), EXECUTION_STARTED);

FROM_MAYBE_END

END_EXECUTION_SCOPE

END_DOCUMENT_SCOPE

END_CONTEXT_SCOPE

}

V8ScriptHolder* V8ContextImpl::Compile(const V8DocumentInfo& documentInfo, StdString&& code, V8CacheKind cacheKind, std::vector<uint8_t>& cacheBytes)

{

if (cacheKind == V8CacheKind::None)

{

cacheBytes.clear();

return Compile(documentInfo, std::move(code));

}

BEGIN_CONTEXT_SCOPE

BEGIN_DOCUMENT_SCOPE(documentInfo)

BEGIN_EXECUTION_SCOPE

FROM_MAYBE_TRY

auto codeDigest = code.GetDigest();

v8::ScriptCompiler::Source source(FROM_MAYBE(CreateString(code)), CreateScriptOrigin(documentInfo));

std::unique_ptr<V8ScriptHolder> upScriptHolder;

if (documentInfo.IsModule())

{

auto hModule = GetCachedModule(documentInfo.GetUniqueId(), codeDigest, cacheBytes);

if (hModule.IsEmpty())

{

hModule = VERIFY_MAYBE(CompileModule(&source));

if (hModule.IsEmpty())

{

throw V8Exception(V8Exception::Type::General, m_Name, StdString(SL("Module compilation failed; no additional information was provided by the V8 runtime")), false);

}

std::unique_ptr<v8::ScriptCompiler::CachedData> upCachedData(v8::ScriptCompiler::CreateCodeCache(hModule->GetUnboundModuleScript()));

if (upCachedData && (upCachedData->length > 0) && (upCachedData->data != nullptr))

{

cacheBytes.resize(upCachedData->length);

memcpy(cacheBytes.data(), upCachedData->data, upCachedData->length);

}

CacheModule(documentInfo, codeDigest, hModule, cacheBytes);

}

else if (cacheBytes.empty())

{

std::unique_ptr<v8::ScriptCompiler::CachedData> upCachedData(v8::ScriptCompiler::CreateCodeCache(hModule->GetUnboundModuleScript()));

if (upCachedData && (upCachedData->length > 0) && (upCachedData->data != nullptr))

{

cacheBytes.resize(upCachedData->length);

memcpy(cacheBytes.data(), upCachedData->data, upCachedData->length);

SetCachedModuleCacheBytes(documentInfo.GetUniqueId(), codeDigest, cacheBytes);

}

}

upScriptHolder.reset(new V8ScriptHolderImpl(GetWeakBinding(), ::PtrFromHandle(CreatePersistent(hModule)), documentInfo, codeDigest, std::move(code)));

}

else

{

auto hScript = GetCachedScript(documentInfo.GetUniqueId(), codeDigest, cacheBytes);

if (hScript.IsEmpty())

{

hScript = VERIFY_MAYBE(CompileUnboundScript(&source));

if (hScript.IsEmpty())

{

throw V8Exception(V8Exception::Type::General, m_Name, StdString(SL("Script compilation failed; no additional information was provided by the V8 runtime")), false);

}

std::unique_ptr<v8::ScriptCompiler::CachedData> upCachedData(v8::ScriptCompiler::CreateCodeCache(hScript));

if (upCachedData && (upCachedData->length > 0) && (upCachedData->data != nullptr))

{

cacheBytes.resize(upCachedData->length);

memcpy(cacheBytes.data(), upCachedData->data, upCachedData->length);

}

CacheScript(documentInfo, codeDigest, hScript, cacheBytes);

}

else if (cacheBytes.empty())

{

std::unique_ptr<v8::ScriptCompiler::CachedData> upCachedData(v8::ScriptCompiler::CreateCodeCache(hScript));

if (upCachedData && (upCachedData->length > 0) && (upCachedData->data != nullptr))

{