// Copyright (c) Microsoft Corporation. All rights reserved.

// Licensed under the MIT license.

#include "ClearScriptV8Native.h"

//-----------------------------------------------------------------------------

// support for v8::Maybe and v8::MaybeLocal

//-----------------------------------------------------------------------------

class FromMaybeScope final

{

};

//-----------------------------------------------------------------------------

class FromMaybeFailure final

{

};

//-----------------------------------------------------------------------------

template <typename T>

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

{

T result;

if (maybe.To(&result))

{

return result;

}

throw FromMaybeFailure();

}

//-----------------------------------------------------------------------------

template <typename T>

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

{

v8::Local<T> result;

if (maybe.ToLocal(&result))

{

return result;

}

throw FromMaybeFailure();

}

//-----------------------------------------------------------------------------

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__))

//-----------------------------------------------------------------------------

// local helper functions

//-----------------------------------------------------------------------------

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

{

if (hValue.IsEmpty())

{

return v8::Local<v8::String>();

}

if (hValue->IsString())

{

return hValue.As<v8::String>();

}

if (hValue->IsStringObject())

{

return hValue.As<v8::StringObject>()->ValueOf();

}

return v8::Local<v8::String>();

}

//-----------------------------------------------------------------------------

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)

{

if (hValue.IsEmpty())

{

return v8::Local<v8::BigInt>();

}

if (hValue->IsBigInt())

{

return hValue.As<v8::BigInt>();

}

if (hValue->IsBigIntObject())

{

return hValue.As<v8::BigIntObject>()->ValueOf();

}

return v8::Local<v8::BigInt>();

}

//-----------------------------------------------------------------------------

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

{

if (hValue.IsEmpty())

{

return false;

}

if (hValue->IsBoolean())

{

value = spIsolateImpl->BooleanValue(hValue);

return true;

}

if (hValue->IsBooleanObject())

{

value = hValue.As<v8::BooleanObject>()->ValueOf();

return true;

}

return false;

}

//-----------------------------------------------------------------------------

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

{

if (hValue.IsEmpty())

{

return false;

}

FROM_MAYBE_TRY

if (hValue->IsNumber())

{

value = FROM_MAYBE(hValue->NumberValue(hContext));

return true;

}

if (hValue->IsNumberObject())

{

value = hValue.As<v8::NumberObject>()->ValueOf();

return true;

}

FROM_MAYBE_CATCH_CONSUME

return false;

}

//-----------------------------------------------------------------------------

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)

{

::SetIfSameType(status, ::GetCallbackStatus(result));

info.GetReturnValue().Set(result);

}

//-----------------------------------------------------------------------------

template <typename TInfo, typename TStatus>

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

{

IGNORE_UNUSED(info);

::SetIfSameType(status, v8::Intercepted::kYes);

}

//-----------------------------------------------------------------------------

// V8ContextImpl implementation

//-----------------------------------------------------------------------------

#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), nullptr, name, Options())

{

}

//-----------------------------------------------------------------------------

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

m_Name(name),

m_pvEngine(pvEngine),

m_spIsolateImpl(std::move(spIsolateImpl)),

m_DateTimeConversionEnabled(::HasFlag(options.Flags, Flags::EnableDateTimeConversion)),

m_HideHostExceptions(::HasFlag(options.Flags, Flags::HideHostExceptions)),

m_AllowHostObjectConstructorCall(false),

m_ChangedTimerResolution(false),

m_pvV8ObjectCache(nullptr),

m_PromiseHookEnabled(false),

m_PromiseRejectionCallbackEnabled(false)

{

VerifyNotOutOfMemory();

if (::HasAllFlags(options.Flags, Flags::AddPerformanceObject, Flags::SetTimerResolution))

{

m_ChangedTimerResolution = HighResolutionClock::SetTimerResolution();

}

auto timeOrigin = HighResolutionClock::GetMillisecondsSinceUnixEpoch();

m_RelativeTimeOrigin = HighResolutionClock::GetRelativeMilliseconds();

BEGIN_ISOLATE_SCOPE

FROM_MAYBE_TRY

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

{

m_hContext = CreatePersistent(CreateContext());

}

else

{

auto hGlobalTemplate = CreateObjectTemplate();

hGlobalTemplate->SetInternalFieldCount(1);

hGlobalTemplate->SetHandler(v8::NamedPropertyHandlerConfiguration(GetGlobalProperty, SetGlobalProperty, QueryGlobalProperty, DeleteGlobalProperty, GetGlobalPropertyNames, v8::Local<v8::Value>(), v8::PropertyHandlerFlags::kNonMasking));

hGlobalTemplate->SetHandler(v8::IndexedPropertyHandlerConfiguration(GetGlobalProperty, SetGlobalProperty, QueryGlobalProperty, DeleteGlobalProperty, GetGlobalPropertyIndices));

m_hContext = CreatePersistent(CreateContext(nullptr, hGlobalTemplate));

if (!m_hContext.IsEmpty())

{

auto hGlobal = m_hContext->Global();

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

{

hGlobal->SetAlignedPointerInInternalField(0, this, 0);

}

}

}

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)

{

VerifyNotOutOfMemory();

BEGIN_ISOLATE_SCOPE

(*pCallback)(pvAction);

END_ISOLATE_SCOPE

}

//-----------------------------------------------------------------------------

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

{

VerifyNotOutOfMemory();

BEGIN_ISOLATE_SCOPE

(*pCallback)(pvAction, pvArg);

END_ISOLATE_SCOPE

}

//-----------------------------------------------------------------------------

V8Value V8ContextImpl::GetRootObject()

{

BEGIN_CONTEXT_SCOPE

return ExportValue(m_hContext->Global());

END_CONTEXT_SCOPE

}

//-----------------------------------------------------------------------------

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

{

BEGIN_CONTEXT_SCOPE

FROM_MAYBE_TRY

auto hName = FROM_MAYBE(CreateString(name));

auto hValue = ::ValueAsObject(ImportValue(value));

v8::Local<v8::Object> hOldValue;

if (FROM_MAYBE(m_hContext->Global()->HasOwnProperty(m_hContext, hName)))

{

hOldValue = ::ValueAsObject(FROM_MAYBE(m_hContext->Global()->GetRealNamedProperty(m_hContext, hName)));

}

auto result = FROM_MAYBE(m_hContext->Global()->DefineOwnProperty(m_hContext, hName, hValue, v8::ReadOnly));

if (result && globalMembers && !hValue.IsEmpty())

{

if (!hOldValue.IsEmpty())

{

for (auto it = m_GlobalMembersStack.begin(); it != m_GlobalMembersStack.end(); it++)

{

if (it->first == name)

{

Dispose(it->second);

m_GlobalMembersStack.erase(it);

break;

}

}

}

m_GlobalMembersStack.emplace_back(name, CreatePersistent(hValue));

}

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")), false);

FROM_MAYBE_END

END_CONTEXT_SCOPE

}

//-----------------------------------------------------------------------------

void V8ContextImpl::AwaitDebuggerAndPause()

{

m_spIsolateImpl->AwaitDebuggerAndPause();

}

//-----------------------------------------------------------------------------

void V8ContextImpl::CancelAwaitDebugger()

{

m_spIsolateImpl->CancelAwaitDebugger();

}

//-----------------------------------------------------------------------------

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

{

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));

v8::Local<v8::Value> hResult;

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);

}

if (hModule->GetStatus() == v8::Module::kUninstantiated)

{

ASSERT_EVAL(VERIFY_MAYBE(hModule->InstantiateModule(m_hContext, V8IsolateImpl::ModuleResolveCallback)));

}

if (hModule->GetStatus() == v8::Module::kInstantiated)

{

hResult = VERIFY_MAYBE(hModule->Evaluate(m_hContext));

if (hResult->IsPromise())

{

auto hPromise = hResult.As<v8::Promise>();

if (hModule->IsGraphAsync() || (hPromise->State() == v8::Promise::PromiseState::kPending))

{

v8::Local<v8::Object> hMetaHolder;

if (TryGetCachedModuleMetaHolder(hModule, hMetaHolder))

{

if (m_hGetModuleResultFunction.IsEmpty())

{

m_hGetModuleResultFunction = CreatePersistent(FROM_MAYBE(GetEngineInternal()->Get(m_hContext, CreateString("getModuleResult"))).As<v8::Function>());

}

v8::Local<v8::Value> args[] = { hResult, hMetaHolder };

hResult = FROM_MAYBE(m_hGetModuleResultFunction->Call(m_hContext, GetUndefined(), 2, args));

}

}

else if (hPromise->State() == v8::Promise::PromiseState::kFulfilled)

{

hResult = hPromise->Result();

if (evaluate && (hResult.IsEmpty() || hResult->IsUndefined()))

{

v8::Local<v8::Object> hMetaHolder;

if (TryGetCachedModuleMetaHolder(hModule, hMetaHolder))

{

auto hMeta = ::ValueAsObject(FROM_MAYBE(hMetaHolder->Get(m_hContext, 0)));

if (!hMeta.IsEmpty())

{

hResult = FROM_MAYBE(hMeta->Get(m_hContext, m_hModuleResultKey));

}

}

}

}

else if (hPromise->State() == v8::Promise::PromiseState::kRejected)

{

auto hException = hPromise->Result();

if (hException->IsObject())

{

auto hExceptionObject = hException.As<v8::Object>();

auto hHostException = FROM_MAYBE(hExceptionObject->Get(m_hContext, m_hHostExceptionKey));

throw V8Exception(V8Exception::Type::General, m_Name, CreateStdString(hExceptionObject), CreateStdString(FROM_MAYBE(hExceptionObject->Get(m_hContext, m_hStackKey))), EXECUTION_STARTED, ExportValue(hException), ExportValue(hHostException));

}

throw V8Exception(V8Exception::Type::General, m_Name, CreateStdString(hException), StdString(), EXECUTION_STARTED, ExportValue(hException), V8Value(V8Value::Undefined));

}

}

}

else

{

evaluate = false;

}

}

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);

}

hResult = VERIFY_MAYBE(hScript->BindToCurrentContext()->Run(m_hContext));

}

if (!evaluate)

{

hResult = GetUndefined();

}

return ExportValue(hResult);

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)

{

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())

{