#include "ClearScriptV8Native.h"

class V8Platform final: public v8::Platform

};

V8Platform& V8Platform::GetInstance()

{

return ms_Instance;

}

V8GlobalFlags V8Platform::GetGlobalFlags() const

{

return m_GlobalFlags;

}

void V8Platform::EnsureInitialized()

}

v8::PageAllocator* V8Platform::GetPageAllocator()

{

return m_upPageAllocator.get();

}

int V8Platform::NumberOfWorkerThreads()

{

return static_cast<int>(HighResolutionClock::GetHardwareConcurrency());

}

std::shared_ptr<v8::TaskRunner> V8Platform::GetForegroundTaskRunner(v8::Isolate* pIsolate, v8::TaskPriority /*priority*/)

{

return V8IsolateImpl::GetInstanceFromIsolate(pIsolate)->GetForegroundTaskRunner();

}

std::unique_ptr<v8::JobHandle> V8Platform::CreateJobImpl(v8::TaskPriority priority, std::unique_ptr<v8::JobTask> upJobTask, const v8::SourceLocation& /*location*/)

{

return v8::platform::NewDefaultJobHandle(this, priority, std::move(upJobTask), NumberOfWorkerThreads());

}

void V8Platform::PostTaskOnWorkerThreadImpl(v8::TaskPriority /*priority*/, std::unique_ptr<v8::Task> upTask, const v8::SourceLocation& /*location*/)

}

void V8Platform::PostDelayedTaskOnWorkerThreadImpl(v8::TaskPriority /*priority*/, std::unique_ptr<v8::Task> upTask, double delayInSeconds, const v8::SourceLocation& /*location*/)

}

double V8Platform::MonotonicallyIncreasingTime()

{

return HighResolutionClock::GetRelativeSeconds();

}

double V8Platform::CurrentClockTimeMillis()

{

return std::chrono::duration_cast<std::chrono::duration<double, std::milli>>(std::chrono::system_clock::now().time_since_epoch()).count();

}

v8::TracingController* V8Platform::GetTracingController()

{

return &m_TracingController;

}

V8Platform::V8Platform():

}

V8Platform V8Platform::ms_Instance;

class V8ForegroundTaskRunner final: public v8::TaskRunner

};

V8ForegroundTaskRunner::V8ForegroundTaskRunner(V8IsolateImpl& isolateImpl):

}

bool V8ForegroundTaskRunner::IdleTasksEnabled()

{

return false;

}

bool V8ForegroundTaskRunner::NonNestableTasksEnabled() const

{

return true;

}

bool V8ForegroundTaskRunner::NonNestableDelayedTasksEnabled() const

{

return true;

}

void V8ForegroundTaskRunner::PostTaskImpl(std::unique_ptr<v8::Task> upTask, const v8::SourceLocation& /*location*/)

}

void V8ForegroundTaskRunner::PostNonNestableTaskImpl(std::unique_ptr<v8::Task> upTask, const v8::SourceLocation& /*location*/)

}

void V8ForegroundTaskRunner::PostDelayedTaskImpl(std::unique_ptr<v8::Task> upTask, double delayInSeconds, const v8::SourceLocation& /*location*/)

}

void V8ForegroundTaskRunner::PostNonNestableDelayedTaskImpl(std::unique_ptr<v8::Task> upTask, double delayInSeconds, const v8::SourceLocation& /*location*/)

}

void V8ForegroundTaskRunner::PostIdleTaskImpl(std::unique_ptr<v8::IdleTask> /*upTask*/, const v8::SourceLocation& /*location*/)

}

class V8ArrayBufferAllocator final: public v8::ArrayBuffer::Allocator

};

V8ArrayBufferAllocator::V8ArrayBufferAllocator(V8IsolateImpl& isolateImpl):

}

void* V8ArrayBufferAllocator::Allocate(size_t size)

{

auto spIsolate = m_wrIsolate.GetTarget();

if (!spIsolate.IsEmpty())

{

return m_IsolateImpl.AllocateArrayBuffer(size);

}

return nullptr;

}

void* V8ArrayBufferAllocator::AllocateUninitialized(size_t size)

{

auto spIsolate = m_wrIsolate.GetTarget();

if (!spIsolate.IsEmpty())

{

return m_IsolateImpl.AllocateUninitializedArrayBuffer(size);

}

return nullptr;

}

void V8ArrayBufferAllocator::Free(void* pvData, size_t size)

}

class V8OutputStream final: public v8::OutputStream

};

int V8OutputStream::GetChunkSize()

{

return 64 * 1024;

}

V8OutputStream::WriteResult V8OutputStream::WriteAsciiChunk(char* pData, int size)

}

void V8OutputStream::EndOfStream()

{

}

#define BEGIN_ISOLATE_NATIVE_SCOPE \

{ \

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

NativeScope t_IsolateNativeScope(*this); \

DEFAULT_WARNING(4456)

#define END_ISOLATE_NATIVE_SCOPE \

IGNORE_UNUSED(t_IsolateNativeScope); \

}

#define BEGIN_ISOLATE_SCOPE \

{ \

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

Scope t_IsolateScope(*this); \

DEFAULT_WARNING(4456)

#define END_ISOLATE_SCOPE \

IGNORE_UNUSED(t_IsolateScope); \

}

#define BEGIN_PROMISE_HOOK_SCOPE \

{ \

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

PromiseHookScope t_PromiseHookScope(*this); \

DEFAULT_WARNING(4456)

#define END_PROMISE_HOOK_SCOPE \

IGNORE_UNUSED(t_PromiseHookScope); \

}

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

static const int s_ContextGroupId = 1;

static const size_t s_StackBreathingRoom = static_cast<size_t>(16 * 1024);

static size_t* const s_pMinStackLimit = reinterpret_cast<size_t*>(sizeof(size_t));

V8IsolateImpl::V8IsolateImpl(const StdString& name, const v8::ResourceConstraints* pConstraints, const Options& options):

}

V8GlobalFlags V8IsolateImpl::GetGlobalFlags()

{

return V8Platform::GetInstance().GetGlobalFlags();

}

V8IsolateImpl* V8IsolateImpl::GetInstanceFromIsolate(v8::Isolate* pIsolate)

{

_ASSERTE(pIsolate);

return static_cast<V8IsolateImpl*>(pIsolate->GetData(0));

}

size_t V8IsolateImpl::GetInstanceCount()

{

return s_InstanceCount;

}

void V8IsolateImpl::AddContext(V8ContextImpl* pContextImpl, const V8Context::Options& options)

}

void V8IsolateImpl::RemoveContext(V8ContextImpl* pContextImpl)

}

V8ContextImpl* V8IsolateImpl::FindContext(v8::Local<v8::Context> hContext)

{

_ASSERTE(IsCurrent() && IsLocked());

for (const auto& entry : m_ContextEntries)

{

if (entry.pContextImpl->GetContext() == hContext)

{

return entry.pContextImpl;

}

}

return nullptr;

}

void V8IsolateImpl::EnableDebugging(int port, bool remote)

}

void V8IsolateImpl::DisableDebugging()

}

size_t V8IsolateImpl::GetMaxHeapSize()

{

return m_MaxHeapSize;

}

void V8IsolateImpl::SetMaxHeapSize(size_t value)

}

double V8IsolateImpl::GetHeapSizeSampleInterval()

{

return m_HeapSizeSampleInterval;

}

void V8IsolateImpl::SetHeapSizeSampleInterval(double value)

{

m_HeapSizeSampleInterval = value;

}

size_t V8IsolateImpl::GetMaxStackUsage()

{

return m_MaxStackUsage;

}

void V8IsolateImpl::SetMaxStackUsage(size_t value)

{

m_MaxStackUsage = value;

}

void V8IsolateImpl::AwaitDebuggerAndPause()

}

void V8IsolateImpl::CancelAwaitDebugger()

}

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

{

BEGIN_ISOLATE_SCOPE

SharedPtr<V8ContextImpl> spContextImpl(!m_ContextEntries.empty() ? m_ContextEntries.front().pContextImpl : new V8ContextImpl(this, m_Name));

return spContextImpl->Compile(documentInfo, std::move(code));

END_ISOLATE_SCOPE

}

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

{

BEGIN_ISOLATE_SCOPE

SharedPtr<V8ContextImpl> spContextImpl(!m_ContextEntries.empty() ? m_ContextEntries.front().pContextImpl : new V8ContextImpl(this, m_Name));

return spContextImpl->Compile(documentInfo, std::move(code), cacheKind, cacheBytes);

END_ISOLATE_SCOPE

}

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

{

BEGIN_ISOLATE_SCOPE

SharedPtr<V8ContextImpl> spContextImpl(!m_ContextEntries.empty() ? m_ContextEntries.front().pContextImpl : new V8ContextImpl(this, m_Name));

return spContextImpl->Compile(documentInfo, std::move(code), cacheKind, cacheBytes, cacheAccepted);

END_ISOLATE_SCOPE

}

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

{

BEGIN_ISOLATE_SCOPE

SharedPtr<V8ContextImpl> spContextImpl(!m_ContextEntries.empty() ? m_ContextEntries.front().pContextImpl : new V8ContextImpl(this, m_Name));

return spContextImpl->Compile(documentInfo, std::move(code), cacheKind, cacheBytes, cacheResult);

END_ISOLATE_SCOPE

}

bool V8IsolateImpl::GetEnableInterruptPropagation()

{

return m_EnableInterruptPropagation;

}

void V8IsolateImpl::SetEnableInterruptPropagation(bool value)

{

m_EnableInterruptPropagation = value;

}

bool V8IsolateImpl::GetDisableHeapSizeViolationInterrupt()

{

return m_DisableHeapSizeViolationInterrupt;

}

void V8IsolateImpl::SetDisableHeapSizeViolationInterrupt(bool value)

{

m_DisableHeapSizeViolationInterrupt = value;

}

void V8IsolateImpl::GetHeapStatistics(v8::HeapStatistics& heapStatistics)

}

V8Isolate::Statistics V8IsolateImpl::GetStatistics()

}

void V8IsolateImpl::CollectGarbage(bool exhaustive)

}

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

}

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

}

void V8IsolateImpl::CollectCpuProfileSample()

}

uint32_t V8IsolateImpl::GetCpuProfileSampleInterval()

{

return m_CpuProfileSampleInterval;

}

void V8IsolateImpl::SetCpuProfileSampleInterval(uint32_t value)

}

void V8IsolateImpl::WriteHeapSnapshot(void* pvStream)