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

// Licensed under the MIT license.

#include "ClearScriptV8Native.h"

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

// FromMaybeScope

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

class FromMaybeScope final

{

};

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

// FromMaybeFailure

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

class FromMaybeFailure final

{

};

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

// local helper functions

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

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

}

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

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

{

return (!hValue.IsEmpty() && hValue->IsString()) ? hValue.As<v8::String>() : 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::BigInt> ValueAsBigInt(const v8::Local<v8::Value>& hValue)

{

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

}

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

template <typename TInfo>

static V8ContextImpl* GetContextImplFromHolder(const TInfo& info)

{

auto hHolder = info.Holder();

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

{

auto hField = hHolder->GetInternalField(0);

if (!hField.IsEmpty() && !hField->IsUndefined())

{

return static_cast<V8ContextImpl*>(hHolder->GetAlignedPointerFromInternalField(0));

}

}

return nullptr;

}

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

template <typename TInfo>

static V8ContextImpl* GetContextImplFromData(const TInfo& info)

{

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

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

}

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

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

#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 \

info.GetReturnValue().Set(RESULT); \

return; \

END_COMPOUND_MACRO

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

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

m_Name(name),

m_spIsolateImpl(std::move(spIsolateImpl)),

m_DateTimeConversionEnabled(options.EnableDateTimeConversion),

m_pvV8ObjectCache(nullptr),

m_AllowHostObjectConstructorCall(false)

{

VerifyNotOutOfMemory();

BEGIN_ISOLATE_SCOPE

FROM_MAYBE_TRY

if (options.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));

auto hGlobal = ::ValueAsObject(m_hContext->Global()->GetPrototype());

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

{

hGlobal->SetAlignedPointerInInternalField(0, this);

}

}

auto hContextImpl = CreateExternal(this);

v8::Local<v8::FunctionTemplate> hGetIteratorFunction;

v8::Local<v8::FunctionTemplate> hGetAsyncIteratorFunction;

v8::Local<v8::FunctionTemplate> hToFunctionFunction;

BEGIN_CONTEXT_SCOPE

m_hIsHostObjectKey = CreatePersistent(CreateSymbol());

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

m_hHostExceptionKey = CreatePersistent(FROM_MAYBE(CreateString(StdString(SL("hostException")))));

m_hCacheKey = CreatePersistent(CreatePrivate());

m_hAccessTokenKey = CreatePersistent(CreatePrivate());

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

m_hStackKey = CreatePersistent(FROM_MAYBE(CreateString(StdString(SL("stack")))));

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

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

m_hPropertyValueNotInvocable = CreatePersistent(FROM_MAYBE(CreateString(StdString(SL("Property value does not support invocation")))));

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

hGetIteratorFunction = CreateFunctionTemplate(GetHostObjectIterator, hContextImpl);

hGetAsyncIteratorFunction = CreateFunctionTemplate(GetHostObjectAsyncIterator, hContextImpl);

hToFunctionFunction = CreateFunctionTemplate(CreateFunctionForHostDelegate, hContextImpl);

m_hAccessToken = CreatePersistent(CreateObject());

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

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

END_CONTEXT_SCOPE

m_hHostObjectTemplate = CreatePersistent(CreateFunctionTemplate());

m_hHostObjectTemplate->SetClassName(FROM_MAYBE(CreateString(StdString(SL("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(), hGetIteratorFunction);

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

m_hHostInvocableTemplate = CreatePersistent(CreateFunctionTemplate());

m_hHostInvocableTemplate->SetClassName(FROM_MAYBE(CreateString(StdString(SL("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(), hGetIteratorFunction);

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

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

m_hHostDelegateTemplate = CreatePersistent(CreateFunctionTemplate());

m_hHostDelegateTemplate->SetClassName(FROM_MAYBE(CreateString(StdString(SL("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(), hGetIteratorFunction);

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

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

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

m_hHostDelegateTemplate->PrototypeTemplate()->Set(FROM_MAYBE(CreateString(StdString(SL("toFunction")))), hToFunctionFunction);

m_pvV8ObjectCache = HostObjectUtil::GetInstance().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 /*executionStarted*/);

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* pvArg)

{

VerifyNotOutOfMemory();

BEGIN_ISOLATE_SCOPE

(*pCallback)(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 /*executionStarted*/);

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 /*executionStarted*/);

}

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

}

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 /*executionStarted*/);

}

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 /*executionStarted*/);

}

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 /*executionStarted*/);

}

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, V8CacheType cacheType, std::vector<uint8_t>& cacheBytes)

{

if (cacheType == V8CacheType::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;

std::unique_ptr<v8::ScriptCompiler::CachedData> upCachedData;

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 /*executionStarted*/);

}

CacheModule(documentInfo, codeDigest, hModule);

}

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

upCachedData.reset(v8::ScriptCompiler::CreateCodeCache(hModule->GetUnboundModuleScript()));

}

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 /*executionStarted*/);

}

CacheScript(documentInfo, codeDigest, hScript);

}

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

upCachedData.reset(v8::ScriptCompiler::CreateCodeCache(hScript));

}

cacheBytes.clear();

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

{

cacheBytes.resize(upCachedData->length);

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

if (documentInfo.IsModule())

{

upScriptHolder->SetCacheBytes(cacheBytes);

}

}

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, V8CacheType cacheType, const std::vector<uint8_t>& cacheBytes, bool& cacheAccepted)

{

if ((cacheType == V8CacheType::None) || (cacheBytes.size() < 1))

{

cacheAccepted = false;

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

}

BEGIN_CONTEXT_SCOPE

BEGIN_DOCUMENT_SCOPE(documentInfo)

BEGIN_EXECUTION_SCOPE

FROM_MAYBE_TRY

auto codeDigest = code.GetDigest();

auto pCachedData = new v8::ScriptCompiler::CachedData(cacheBytes.data(), static_cast<int>(cacheBytes.size()), v8::ScriptCompiler::CachedData::BufferNotOwned);

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

std::unique_ptr<V8ScriptHolder> upScriptHolder;

if (documentInfo.IsModule())

{

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

if (hModule.IsEmpty())

{

hModule = VERIFY_MAYBE(CompileModule(&source, v8::ScriptCompiler::kConsumeCodeCache));

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 /*executionStarted*/);

}

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, v8::ScriptCompiler::kConsumeCodeCache));

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 /*executionStarted*/);

}

CacheScript(documentInfo, codeDigest, hScript);

}

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

}

cacheAccepted = !pCachedData->rejected;

if (cacheAccepted && documentInfo.IsModule())

{

upScriptHolder->SetCacheBytes(cacheBytes);

}

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

}

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

bool V8ContextImpl::CanExecute(const SharedPtr<V8ScriptHolder>& spHolder)

{

return spHolder->IsSameIsolate(m_spIsolateImpl);

}

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

V8Value V8ContextImpl::Execute(const SharedPtr<V8ScriptHolder>& spHolder, bool evaluate)

{

BEGIN_CONTEXT_SCOPE

BEGIN_DOCUMENT_SCOPE(spHolder->GetDocumentInfo())

BEGIN_EXECUTION_SCOPE

FROM_MAYBE_TRY

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

if (spHolder->GetDocumentInfo().IsModule())

{

auto codeDigest = spHolder->GetCode().GetDigest();

auto hModule = GetCachedModule(spHolder->GetDocumentInfo().GetUniqueId(), codeDigest);

if (hModule.IsEmpty())

{

if (spHolder->GetCacheBytes().size() > 0)

{

auto pCachedData = new v8::ScriptCompiler::CachedData(spHolder->GetCacheBytes().data(), static_cast<int>(spHolder->GetCacheBytes().size()), v8::ScriptCompiler::CachedData::BufferNotOwned);

v8::ScriptCompiler::Source source(FROM_MAYBE(CreateString(spHolder->GetCode())), CreateScriptOrigin(spHolder->GetDocumentInfo()), pCachedData);

hModule = VERIFY_MAYBE(CompileModule(&source));

_ASSERTE(!pCachedData->rejected);

}

else

{

v8::ScriptCompiler::Source source(FROM_MAYBE(CreateString(spHolder->GetCode())), CreateScriptOrigin(spHolder->GetDocumentInfo()));

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 /*executionStarted*/);

}

CacheModule(spHolder->GetDocumentInfo(), 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));

}

else

{

evaluate = false;

}

}

else

{

auto hScript = ::HandleFromPtr<v8::UnboundScript>(spHolder->GetScript());

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

}

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

void V8ContextImpl::Interrupt()

{

TerminateExecution();

}

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

void V8ContextImpl::GetIsolateHeapStatistics(v8::HeapStatistics& heapStatistics)

{

m_spIsolateImpl->GetHeapStatistics(heapStatistics);

}

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

V8Isolate::Statistics V8ContextImpl::GetIsolateStatistics()

{

return m_spIsolateImpl->GetStatistics();

}

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

V8ContextImpl::Statistics V8ContextImpl::GetStatistics()

{

_ASSERTE(m_spIsolateImpl->IsCurrent() && m_spIsolateImpl->IsLocked());

return m_Statistics;

}

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

void V8ContextImpl::CollectGarbage(bool exhaustive)

{

m_spIsolateImpl->CollectGarbage(exhaustive);

}

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

void V8ContextImpl::OnAccessSettingsChanged()

{

BEGIN_CONTEXT_SCOPE

BEGIN_EXECUTION_SCOPE

Dispose(m_hAccessToken);

m_hAccessToken = CreatePersistent(CreateObject());

END_EXECUTION_SCOPE

END_CONTEXT_SCOPE

}

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

bool V8ContextImpl::BeginCpuProfile(const StdString& name, v8::CpuProfilingMode mode, bool recordSamples)

{

return m_spIsolateImpl->BeginCpuProfile(name, mode, recordSamples);

}

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

bool V8ContextImpl::EndCpuProfile(const StdString& name, V8Isolate::CpuProfileCallback* pCallback, void* pvArg)

{

return m_spIsolateImpl->EndCpuProfile(name, pCallback, pvArg);

}

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

void V8ContextImpl::CollectCpuProfileSample()

{

return m_spIsolateImpl->CollectCpuProfileSample();

}

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

uint32_t V8ContextImpl::GetCpuProfileSampleInterval()

{

return m_spIsolateImpl->GetCpuProfileSampleInterval();

}

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

void V8ContextImpl::SetCpuProfileSampleInterval(uint32_t value)

{

m_spIsolateImpl->SetCpuProfileSampleInterval(value);

}

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

void V8ContextImpl::WriteIsolateHeapSnapshot(void* pvStream)

{

m_spIsolateImpl->WriteHeapSnapshot(pvStream);

}

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

void V8ContextImpl::Flush()

{

BEGIN_CONTEXT_SCOPE

BEGIN_EXECUTION_SCOPE

(void)m_hFlushFunction->Call(m_hContext, GetUndefined(), 0, nullptr);

END_EXECUTION_SCOPE

END_CONTEXT_SCOPE

}

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

void V8ContextImpl::Destroy()

{

m_spIsolateImpl->CallWithLockNoWait(true /*allowNesting*/, [this] (V8IsolateImpl* /*pIsolateImpl*/)

{

delete this;

});

}

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

V8Value V8ContextImpl::GetV8ObjectProperty(void* pvObject, const StdString& name)

{

BEGIN_CONTEXT_SCOPE

BEGIN_EXECUTION_SCOPE

FROM_MAYBE_TRY

return ExportValue(FROM_MAYBE(::HandleFromPtr<v8::Object>(pvObject)->Get(m_hContext, FROM_MAYBE(CreateString(name)))));

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_CONTEXT_SCOPE

}

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

void V8ContextImpl::SetV8ObjectProperty(void* pvObject, const StdString& name, const V8Value& value)

{

BEGIN_CONTEXT_SCOPE

BEGIN_EXECUTION_SCOPE

FROM_MAYBE_TRY

ASSERT_EVAL(FROM_MAYBE(::HandleFromPtr<v8::Object>(pvObject)->Set(m_hContext, FROM_MAYBE(CreateString(name)), ImportValue(value))));

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_CONTEXT_SCOPE

}

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

bool V8ContextImpl::DeleteV8ObjectProperty(void* pvObject, const StdString& name)

{

BEGIN_CONTEXT_SCOPE

FROM_MAYBE_TRY

return FROM_MAYBE(::HandleFromPtr<v8::Object>(pvObject)->Delete(m_hContext, FROM_MAYBE(CreateString(name))));

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 /*executionStarted*/);

FROM_MAYBE_END

END_CONTEXT_SCOPE

}

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