#include "src/api.h"

#include <string.h> // For memcpy, strlen.

#ifdef V8_USE_ADDRESS_SANITIZER

#include <sanitizer/asan_interface.h>

#endif // V8_USE_ADDRESS_SANITIZER

#include <cmath> // For isnan.

#include "include/v8-debug.h"

#include "include/v8-profiler.h"

#include "include/v8-testing.h"

#include "src/api-natives.h"

#include "src/assert-scope.h"

#include "src/background-parsing-task.h"

#include "src/base/functional.h"

#include "src/base/platform/platform.h"

#include "src/base/platform/time.h"

#include "src/base/utils/random-number-generator.h"

#include "src/bootstrapper.h"

#include "src/char-predicates-inl.h"

#include "src/code-stubs.h"

#include "src/compiler.h"

#include "src/context-measure.h"

#include "src/contexts.h"

#include "src/conversions-inl.h"

#include "src/counters.h"

#include "src/cpu-profiler.h"

#include "src/debug/debug.h"

#include "src/deoptimizer.h"

#include "src/execution.h"

#include "src/global-handles.h"

#include "src/heap-profiler.h"

#include "src/heap-snapshot-generator-inl.h"

#include "src/icu_util.h"

#include "src/isolate-inl.h"

#include "src/json-parser.h"

#include "src/messages.h"

#include "src/parser.h"

#include "src/pending-compilation-error-handler.h"

#include "src/profile-generator-inl.h"

#include "src/property.h"

#include "src/property-details.h"

#include "src/prototype.h"

#include "src/runtime/runtime.h"

#include "src/runtime-profiler.h"

#include "src/sampler.h"

#include "src/scanner-character-streams.h"

#include "src/simulator.h"

#include "src/snapshot/natives.h"

#include "src/snapshot/snapshot.h"

#include "src/startup-data-util.h"

#include "src/unicode-inl.h"

#include "src/v8.h"

#include "src/v8threads.h"

#include "src/version.h"

#include "src/vm-state-inl.h"

namespace v8 {

#define LOG_API(isolate, expr) LOG(isolate, ApiEntryCall(expr))

#define ENTER_V8(isolate) i::VMState<v8::OTHER> __state__((isolate))

#define PREPARE_FOR_EXECUTION_GENERIC(isolate, context, function_name, \

bailout_value, HandleScopeClass, \

do_callback) \

if (IsExecutionTerminatingCheck(isolate)) { \

return bailout_value; \

} \

HandleScopeClass handle_scope(isolate); \

CallDepthScope call_depth_scope(isolate, context, do_callback); \

LOG_API(isolate, function_name); \

ENTER_V8(isolate); \

bool has_pending_exception = false

#define PREPARE_FOR_EXECUTION_WITH_CONTEXT( \

context, function_name, bailout_value, HandleScopeClass, do_callback) \

auto isolate = context.IsEmpty() \

? i::Isolate::Current() \

: reinterpret_cast<i::Isolate*>(context->GetIsolate()); \

PREPARE_FOR_EXECUTION_GENERIC(isolate, context, function_name, \

bailout_value, HandleScopeClass, do_callback);

#define PREPARE_FOR_EXECUTION_WITH_ISOLATE(isolate, function_name, T) \

PREPARE_FOR_EXECUTION_GENERIC(isolate, Local<Context>(), function_name, \

MaybeLocal<T>(), InternalEscapableScope, \

false);

#define PREPARE_FOR_EXECUTION(context, function_name, T) \

PREPARE_FOR_EXECUTION_WITH_CONTEXT(context, function_name, MaybeLocal<T>(), \

InternalEscapableScope, false)

#define PREPARE_FOR_EXECUTION_WITH_CALLBACK(context, function_name, T) \

PREPARE_FOR_EXECUTION_WITH_CONTEXT(context, function_name, MaybeLocal<T>(), \

InternalEscapableScope, true)

#define PREPARE_FOR_EXECUTION_PRIMITIVE(context, function_name, T) \

PREPARE_FOR_EXECUTION_WITH_CONTEXT(context, function_name, Nothing<T>(), \

i::HandleScope, false)

#define EXCEPTION_BAILOUT_CHECK_SCOPED(isolate, value) \

do { \

if (has_pending_exception) { \

call_depth_scope.Escape(); \

return value; \

} \

} while (false)

#define RETURN_ON_FAILED_EXECUTION(T) \

EXCEPTION_BAILOUT_CHECK_SCOPED(isolate, MaybeLocal<T>())

#define RETURN_ON_FAILED_EXECUTION_PRIMITIVE(T) \

EXCEPTION_BAILOUT_CHECK_SCOPED(isolate, Nothing<T>())

#define RETURN_TO_LOCAL_UNCHECKED(maybe_local, T) \

return maybe_local.FromMaybe(Local<T>());

#define RETURN_ESCAPED(value) return handle_scope.Escape(value);

namespace {

Local<Context> ContextFromHeapObject(i::Handle<i::Object> obj) {

return reinterpret_cast<v8::Isolate*>(i::HeapObject::cast(*obj)->GetIsolate())

->GetCurrentContext();

}

class InternalEscapableScope : public v8::EscapableHandleScope {

};

class CallDepthScope {

};

} // namespace

static ScriptOrigin GetScriptOriginForScript(i::Isolate* isolate,

}

void i::FatalProcessOutOfMemory(const char* location) {

i::V8::FatalProcessOutOfMemory(location, false);

}

void i::V8::FatalProcessOutOfMemory(const char* location, bool take_snapshot) {

i::Isolate* isolate = i::Isolate::Current();

char last_few_messages[Heap::kTraceRingBufferSize + 1];

char js_stacktrace[Heap::kStacktraceBufferSize + 1];

memset(last_few_messages, 0, Heap::kTraceRingBufferSize + 1);

memset(js_stacktrace, 0, Heap::kStacktraceBufferSize + 1);

i::HeapStats heap_stats;

int start_marker;

heap_stats.start_marker = &start_marker;

int new_space_size;

heap_stats.new_space_size = &new_space_size;

int new_space_capacity;

heap_stats.new_space_capacity = &new_space_capacity;

intptr_t old_space_size;

heap_stats.old_space_size = &old_space_size;

intptr_t old_space_capacity;

heap_stats.old_space_capacity = &old_space_capacity;

intptr_t code_space_size;

heap_stats.code_space_size = &code_space_size;

intptr_t code_space_capacity;

heap_stats.code_space_capacity = &code_space_capacity;

intptr_t map_space_size;

heap_stats.map_space_size = &map_space_size;

intptr_t map_space_capacity;

heap_stats.map_space_capacity = &map_space_capacity;

intptr_t lo_space_size;

heap_stats.lo_space_size = &lo_space_size;

int global_handle_count;

heap_stats.global_handle_count = &global_handle_count;

int weak_global_handle_count;

heap_stats.weak_global_handle_count = &weak_global_handle_count;

int pending_global_handle_count;

heap_stats.pending_global_handle_count = &pending_global_handle_count;

int near_death_global_handle_count;

heap_stats.near_death_global_handle_count = &near_death_global_handle_count;

int free_global_handle_count;

heap_stats.free_global_handle_count = &free_global_handle_count;

intptr_t memory_allocator_size;

heap_stats.memory_allocator_size = &memory_allocator_size;

intptr_t memory_allocator_capacity;

heap_stats.memory_allocator_capacity = &memory_allocator_capacity;

int objects_per_type[LAST_TYPE + 1] = {0};

heap_stats.objects_per_type = objects_per_type;

int size_per_type[LAST_TYPE + 1] = {0};

heap_stats.size_per_type = size_per_type;

int os_error;

heap_stats.os_error = &os_error;

heap_stats.last_few_messages = last_few_messages;

heap_stats.js_stacktrace = js_stacktrace;

int end_marker;

heap_stats.end_marker = &end_marker;

if (isolate->heap()->HasBeenSetUp()) {

// BUG(1718): Don't use the take_snapshot since we don't support

// HeapIterator here without doing a special GC.

isolate->heap()->RecordStats(&heap_stats, false);

char* first_newline = strchr(last_few_messages, '\n');

if (first_newline == NULL || first_newline[1] == '\0')

first_newline = last_few_messages;

PrintF("\n<--- Last few GCs --->\n%s\n", first_newline);

PrintF("\n<--- JS stacktrace --->\n%s\n", js_stacktrace);

}

Utils::ApiCheck(false, location, "Allocation failed - process out of memory");

// If the fatal error handler returns, we stop execution.

FATAL("API fatal error handler returned after process out of memory");

}

void Utils::ReportApiFailure(const char* location, const char* message) {

}

static inline bool IsExecutionTerminatingCheck(i::Isolate* isolate) {

}

void V8::SetNativesDataBlob(StartupData* natives_blob) {

i::V8::SetNativesBlob(natives_blob);

}

void V8::SetSnapshotDataBlob(StartupData* snapshot_blob) {

i::V8::SetSnapshotBlob(snapshot_blob);

}

bool RunExtraCode(Isolate* isolate, Local<Context> context,

}

namespace {

class ArrayBufferAllocator : public v8::ArrayBuffer::Allocator {

};

} // namespace

StartupData V8::CreateSnapshotDataBlob(const char* custom_source) {

}

void V8::SetFlagsFromString(const char* str, int length) {

i::FlagList::SetFlagsFromString(str, length);

}

void V8::SetFlagsFromCommandLine(int* argc, char** argv, bool remove_flags) {

i::FlagList::SetFlagsFromCommandLine(argc, argv, remove_flags);

}

RegisteredExtension* RegisteredExtension::first_extension_ = NULL;

RegisteredExtension::RegisteredExtension(Extension* extension)

: extension_(extension) { }

void RegisteredExtension::Register(RegisteredExtension* that) {

that->next_ = first_extension_;

first_extension_ = that;

}

void RegisteredExtension::UnregisterAll() {

}

void RegisterExtension(Extension* that) {

RegisteredExtension* extension = new RegisteredExtension(that);

RegisteredExtension::Register(extension);

}

Extension::Extension(const char* name,

}

ResourceConstraints::ResourceConstraints()

code_range_size_(0) { }

void ResourceConstraints::ConfigureDefaults(uint64_t physical_memory,

}

void SetResourceConstraints(i::Isolate* isolate,

}

i::Object** V8::GlobalizeReference(i::Isolate* isolate, i::Object** obj) {

LOG_API(isolate, "Persistent::New");

i::Handle<i::Object> result = isolate->global_handles()->Create(*obj);

#ifdef VERIFY_HEAP

if (i::FLAG_verify_heap) {

(*obj)->ObjectVerify();

}

#endif // VERIFY_HEAP

return result.location();

}

i::Object** V8::CopyPersistent(i::Object** obj) {

i::Handle<i::Object> result = i::GlobalHandles::CopyGlobal(obj);

#ifdef VERIFY_HEAP

if (i::FLAG_verify_heap) {

(*obj)->ObjectVerify();

}

#endif // VERIFY_HEAP

return result.location();

}

void V8::MakeWeak(i::Object** object, void* parameter,

WeakCallback weak_callback) {

i::GlobalHandles::MakeWeak(object, parameter, weak_callback);

}

void V8::MakeWeak(i::Object** object, void* parameter,

}

void V8::MakeWeak(i::Object** object, void* parameter,

}

void* V8::ClearWeak(i::Object** obj) {

return i::GlobalHandles::ClearWeakness(obj);

}

void V8::DisposeGlobal(i::Object** obj) {

i::GlobalHandles::Destroy(obj);

}

void V8::Eternalize(Isolate* v8_isolate, Value* value, int* index) {

}

Local<Value> V8::GetEternal(Isolate* v8_isolate, int index) {

i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);

return Utils::ToLocal(isolate->eternal_handles()->Get(index));

}

void V8::FromJustIsNothing() {

Utils::ApiCheck(false, "v8::FromJust", "Maybe value is Nothing.");

}

void V8::ToLocalEmpty() {

Utils::ApiCheck(false, "v8::ToLocalChecked", "Empty MaybeLocal.");

}

void V8::InternalFieldOutOfBounds(int index) {

}

HandleScope::HandleScope(Isolate* isolate) {

Initialize(isolate);

}

void HandleScope::Initialize(Isolate* isolate) {

}

HandleScope::~HandleScope() {

i::HandleScope::CloseScope(isolate_, prev_next_, prev_limit_);

}

int HandleScope::NumberOfHandles(Isolate* isolate) {

return i::HandleScope::NumberOfHandles(

reinterpret_cast<i::Isolate*>(isolate));

}

i::Object** HandleScope::CreateHandle(i::Isolate* isolate, i::Object* value) {

return i::HandleScope::CreateHandle(isolate, value);

}

i::Object** HandleScope::CreateHandle(i::HeapObject* heap_object,

i::Object* value) {

DCHECK(heap_object->IsHeapObject());

return i::HandleScope::CreateHandle(heap_object->GetIsolate(), value);

}

EscapableHandleScope::EscapableHandleScope(Isolate* v8_isolate) {

}

i::Object** EscapableHandleScope::Escape(i::Object** escape_value) {

i::Heap* heap = reinterpret_cast<i::Isolate*>(GetIsolate())->heap();

Utils::ApiCheck(*escape_slot_ == heap->the_hole_value(),

"EscapeableHandleScope::Escape",

"Escape value set twice");

if (escape_value == NULL) {

*escape_slot_ = heap->undefined_value();

return NULL;

}

*escape_slot_ = *escape_value;

return escape_slot_;

}

SealHandleScope::SealHandleScope(Isolate* isolate) {

}

SealHandleScope::~SealHandleScope() {

i::HandleScopeData* current = isolate_->handle_scope_data();

DCHECK_EQ(0, current->level);

current->level = prev_level_;

DCHECK_EQ(current->next, current->limit);

current->limit = prev_limit_;

}

void Context::Enter() {

}

void Context::Exit() {

}

static void* DecodeSmiToAligned(i::Object* value, const char* location) {

Utils::ApiCheck(value->IsSmi(), location, "Not a Smi");

return reinterpret_cast<void*>(value);

}

static i::Smi* EncodeAlignedAsSmi(void* value, const char* location) {

i::Smi* smi = reinterpret_cast<i::Smi*>(value);

Utils::ApiCheck(smi->IsSmi(), location, "Pointer is not aligned");

return smi;

}

static i::Handle<i::FixedArray> EmbedderDataFor(Context* context,

}

v8::Local<v8::Value> Context::SlowGetEmbedderData(int index) {

}

void Context::SetEmbedderData(int index, v8::Local<Value> value) {

}

void* Context::SlowGetAlignedPointerFromEmbedderData(int index) {

const char* location = "v8::Context::GetAlignedPointerFromEmbedderData()";

i::Handle<i::FixedArray> data = EmbedderDataFor(this, index, false, location);

if (data.is_null()) return NULL;

return DecodeSmiToAligned(data->get(index), location);

}

void Context::SetAlignedPointerInEmbedderData(int index, void* value) {

}

NeanderObject::NeanderObject(v8::internal::Isolate* isolate, int size) {

}

int NeanderObject::size() {

return i::FixedArray::cast(value_->elements())->length();

}

NeanderArray::NeanderArray(v8::internal::Isolate* isolate) : obj_(isolate, 2) {

obj_.set(0, i::Smi::FromInt(0));

}

int NeanderArray::length() {

return i::Smi::cast(obj_.get(0))->value();

}

i::Object* NeanderArray::get(int offset) {

DCHECK(0 <= offset);

DCHECK(offset < length());

return obj_.get(offset + 1);

}

void NeanderArray::add(i::Isolate* isolate, i::Handle<i::Object> value) {

}

void NeanderArray::set(int index, i::Object* value) {

if (index < 0 || index >= this->length()) return;

obj_.set(index + 1, value);

}

static void InitializeTemplate(i::Handle<i::TemplateInfo> that, int type) {

that->set_number_of_properties(0);

that->set_tag(i::Smi::FromInt(type));

}

void Template::Set(v8::Local<Name> name, v8::Local<Data> value,

}

void Template::SetAccessorProperty(

}

static void InitializeFunctionTemplate(

}

Local<ObjectTemplate> FunctionTemplate::PrototypeTemplate() {

}

static void EnsureNotInstantiated(i::Handle<i::FunctionTemplateInfo> info,

}

void FunctionTemplate::Inherit(v8::Local<FunctionTemplate> value) {

}

static Local<FunctionTemplate> FunctionTemplateNew(