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

}

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

}

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;

}

#define BEGIN_ISOLATE_SCOPE \

{ \

__pragma(warning(disable:4456)) /* declaration hides previous local declaration */ \

V8IsolateImpl::Scope t_IsolateScope(m_spIsolateImpl); \

__pragma(warning(default:4456))

#define END_ISOLATE_SCOPE \

IGNORE_UNUSED(t_IsolateScope); \

}

#define FROM_MAYBE_TRY \

{ \

__pragma(warning(disable:4456)) /* declaration hides previous local declaration */ \

FromMaybeScope t_FromMaybeScope; \

__pragma(warning(default: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 \

{ \

__pragma(warning(disable:4456)) /* declaration hides previous local declaration */ \

Scope t_ContextScope(this); \

__pragma(warning(default:4456))

#define END_CONTEXT_SCOPE \

IGNORE_UNUSED(t_ContextScope); \

}

#define BEGIN_EXECUTION_SCOPE \

{ \

__pragma(warning(disable:4456)) /* declaration hides previous local declaration */ \

V8IsolateImpl::ExecutionScope t_ExecutionScope(m_spIsolateImpl); \

V8IsolateImpl::TryCatch t_TryCatch(m_spIsolateImpl); \

__pragma(warning(default:4456))

#define END_EXECUTION_SCOPE \

IGNORE_UNUSED(t_TryCatch); \

IGNORE_UNUSED(t_ExecutionScope); \

}

#define EXECUTION_STARTED \

(t_ExecutionScope.ExecutionStarted())

#define VERIFY(RESULT) \

(Verify(t_ExecutionScope, t_TryCatch, RESULT))

#define VERIFY_MAYBE(RESULT) \

(Verify(t_ExecutionScope, t_TryCatch, 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):

V8ContextImpl(pIsolateImpl, StdString(), Options())

{

}

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

}

auto hContextImpl = CreateExternal(this);

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

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

v8::Local<v8::FunctionTemplate> hNextFunction;

BEGIN_CONTEXT_SCOPE

m_hIsHostObjectKey = CreatePersistent(CreateSymbol());

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

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

m_hEnumeratorKey = CreatePersistent(CreatePrivate());

m_hDoneKey = CreatePersistent(FROM_MAYBE(CreateString(StdString(L"done"))));

m_hValueKey = CreatePersistent(FROM_MAYBE(CreateString(StdString(L"value"))));

m_hCacheKey = CreatePersistent(CreatePrivate());

m_hAccessTokenKey = CreatePersistent(CreatePrivate());

m_hInternalUseOnly = CreatePersistent(FROM_MAYBE(CreateString(StdString(L"This function is for ClearScript internal use only"))));

hGetIteratorFunction = CreateFunctionTemplate(GetIteratorForHostObject, hContextImpl);

hToFunctionFunction = CreateFunctionTemplate(CreateFunctionForHostDelegate, hContextImpl);

hNextFunction = CreateFunctionTemplate(AdvanceHostObjectIterator, 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(L"Script execution was interrupted")))));

END_CONTEXT_SCOPE

m_hHostObjectTemplate = CreatePersistent(CreateFunctionTemplate());

m_hHostObjectTemplate->SetClassName(FROM_MAYBE(CreateString(StdString(L"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_hHostInvocableTemplate = CreatePersistent(CreateFunctionTemplate());

m_hHostInvocableTemplate->SetClassName(FROM_MAYBE(CreateString(StdString(L"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->InstanceTemplate()->SetCallAsFunctionHandler(InvokeHostObject, hContextImpl);

m_hHostDelegateTemplate = CreatePersistent(CreateFunctionTemplate());

m_hHostDelegateTemplate->SetClassName(FROM_MAYBE(CreateString(StdString(L"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->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(L"toFunction"))), hToFunctionFunction);

m_hHostIteratorTemplate = CreatePersistent(CreateFunctionTemplate());

m_hHostIteratorTemplate->SetClassName(FROM_MAYBE(CreateString(StdString(L"HostIterator"))));

m_hHostIteratorTemplate->SetCallHandler(HostObjectConstructorCallHandler, hContextImpl);

m_hHostIteratorTemplate->PrototypeTemplate()->Set(FROM_MAYBE(CreateString(StdString(L"next"))), hNextFunction);

m_spIsolateImpl->AddContext(this, options);

m_pvV8ObjectCache = HostObjectHelpers::CreateV8ObjectCache();

FROM_MAYBE_CATCH

Teardown();

throw V8Exception(V8Exception::Type::General, m_Name, StdString(L"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(LockCallbackT* pCallback, void* pvArg)

}

V8Value V8ContextImpl::GetRootObject()

}

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

}

void V8ContextImpl::AwaitDebuggerAndPause()

{

m_spIsolateImpl->AwaitDebuggerAndPause();

}

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

}

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

{

BEGIN_CONTEXT_SCOPE

BEGIN_EXECUTION_SCOPE

FROM_MAYBE_TRY

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

auto hScript = VERIFY_MAYBE(CreateUnboundScript(&source));

if (hScript.IsEmpty())

{

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

}

return new V8ScriptHolderImpl(GetWeakBinding(), ::PtrFromHandle(CreatePersistent(hScript)));

FROM_MAYBE_CATCH

throw V8Exception(V8Exception::Type::General, m_Name, StdString(L"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

}

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

{

if (cacheType == V8CacheType::None)

{

cacheBytes.clear();

return Compile(documentInfo, code);

}

BEGIN_CONTEXT_SCOPE

BEGIN_EXECUTION_SCOPE

FROM_MAYBE_TRY

auto hCode = FROM_MAYBE(CreateString(code));

v8::ScriptCompiler::Source source(hCode, CreateScriptOrigin(documentInfo));

auto hScript = VERIFY_MAYBE(CreateUnboundScript(&source));

if (hScript.IsEmpty())

{

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

}

cacheBytes.clear();

if (cacheType != V8CacheType::None)

{

auto pCachedData = v8::ScriptCompiler::CreateCodeCache(hScript);

if (pCachedData != nullptr)

{

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

{

cacheBytes.resize(pCachedData->length);

memcpy_s(&cacheBytes[0], cacheBytes.size(), pCachedData->data, pCachedData->length);

}

// Delete cached data explicitly via a custom exported method. Doing so avoids Debug-

// Release heap mismatches.

pCachedData->Delete();

}

}

return new V8ScriptHolderImpl(GetWeakBinding(), ::PtrFromHandle(CreatePersistent(hScript)));

FROM_MAYBE_CATCH

throw V8Exception(V8Exception::Type::General, m_Name, StdString(L"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

}

V8ScriptHolder* V8ContextImpl::Compile(const V8DocumentInfo& documentInfo, const StdString& code, V8CacheType cacheType, const std::vector<std::uint8_t>& cacheBytes, bool& cacheAccepted)

{

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

{

cacheAccepted = false;

return Compile(documentInfo, code);

}

BEGIN_CONTEXT_SCOPE

BEGIN_EXECUTION_SCOPE

FROM_MAYBE_TRY

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

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

auto hScript = VERIFY_MAYBE(CreateUnboundScript(&source, v8::ScriptCompiler::kConsumeCodeCache));

if (hScript.IsEmpty())

{

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

}

cacheAccepted = !m_spIsolateImpl->IsDebuggingEnabled() && !pCachedData->rejected;

return new V8ScriptHolderImpl(GetWeakBinding(), ::PtrFromHandle(CreatePersistent(hScript)));

FROM_MAYBE_CATCH

throw V8Exception(V8Exception::Type::General, m_Name, StdString(L"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::CanExecute(V8ScriptHolder* pHolder)

{

return pHolder->IsSameIsolate(m_spIsolateImpl.GetRawPtr());

}

V8Value V8ContextImpl::Execute(V8ScriptHolder* pHolder, bool evaluate)

}

void V8ContextImpl::Interrupt()

{

TerminateExecution();

}

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

{

m_spIsolateImpl->GetHeapStatistics(heapStatistics);

}

void V8ContextImpl::CollectGarbage(bool exhaustive)

{

m_spIsolateImpl->CollectGarbage(exhaustive);

}

void V8ContextImpl::OnAccessSettingsChanged()

}

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::CpuProfileCallbackT* 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::Flush()

}

void V8ContextImpl::Destroy()

}

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

}

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

}

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

}

void V8ContextImpl::GetV8ObjectPropertyNames(void* pvObject, std::vector<StdString>& names)

}

V8Value V8ContextImpl::GetV8ObjectProperty(void* pvObject, int index)

}

void V8ContextImpl::SetV8ObjectProperty(void* pvObject, int index, const V8Value& value)

}

bool V8ContextImpl::DeleteV8ObjectProperty(void* pvObject, int index)

}

void V8ContextImpl::GetV8ObjectPropertyIndices(void* pvObject, std::vector<int>& indices)

}

V8Value V8ContextImpl::InvokeV8Object(void* pvObject, bool asConstructor, const std::vector<V8Value>& args)

}

V8Value V8ContextImpl::InvokeV8ObjectMethod(void* pvObject, const StdString& name, const std::vector<V8Value>& args)

}

void V8ContextImpl::GetV8ObjectArrayBufferOrViewInfo(void* pvObject, V8Value& arrayBuffer, size_t& offset, size_t& size, size_t& length)

}

void V8ContextImpl::InvokeWithV8ObjectArrayBufferOrViewData(void* pvObject, V8ObjectHelpers::ArrayBufferOrViewDataCallbackT* pCallback, void* pvArg)