// Copyright 2012 the V8 project authors. All rights reserved.

// Use of this source code is governed by a BSD-style license that can be

// found in the LICENSE file.

#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/code-stubs.h"

#include "src/compiler.h"

#include "src/conversions-inl.h"

#include "src/counters.h"

#include "src/cpu-profiler.h"

#include "src/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/json-parser.h"

#include "src/messages.h"

#include "src/natives.h"

#include "src/parser.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.h"

#include "src/unicode-inl.h"

#include "src/v8threads.h"

#include "src/version.h"

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

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

#define ENTER_V8(isolate) \

i::VMState<v8::OTHER> __state__((isolate))

namespace v8 {

#define ON_BAILOUT(isolate, location, code) \

if (IsExecutionTerminatingCheck(isolate)) { \

code; \

UNREACHABLE(); \

}

#define EXCEPTION_PREAMBLE(isolate) \

(isolate)->handle_scope_implementer()->IncrementCallDepth(); \

DCHECK(!(isolate)->external_caught_exception()); \

bool has_pending_exception = false

#define EXCEPTION_BAILOUT_CHECK_GENERIC(isolate, value, do_callback) \

do { \

i::HandleScopeImplementer* handle_scope_implementer = \

(isolate)->handle_scope_implementer(); \

handle_scope_implementer->DecrementCallDepth(); \

if (has_pending_exception) { \

bool call_depth_is_zero = handle_scope_implementer->CallDepthIsZero(); \

(isolate)->OptionalRescheduleException(call_depth_is_zero); \

do_callback \

return value; \

} \

do_callback \

} while (false)

#define EXCEPTION_BAILOUT_CHECK_DO_CALLBACK(isolate, value) \

EXCEPTION_BAILOUT_CHECK_GENERIC( \

isolate, value, isolate->FireCallCompletedCallback();)

#define EXCEPTION_BAILOUT_CHECK(isolate, value) \

EXCEPTION_BAILOUT_CHECK_GENERIC(isolate, value, ;)

// --- E x c e p t i o n B e h a v i o r ---

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

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

}

// When V8 cannot allocated memory FatalProcessOutOfMemory is called.

// The default fatal error handler is called and execution is stopped.

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

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

heap_stats.old_pointer_space_size = &old_pointer_space_size;

intptr_t old_pointer_space_capacity;

heap_stats.old_pointer_space_capacity = &old_pointer_space_capacity;

intptr_t old_data_space_size;

heap_stats.old_data_space_size = &old_data_space_size;

intptr_t old_data_space_capacity;

heap_stats.old_data_space_capacity = &old_data_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 cell_space_size;

heap_stats.cell_space_size = &cell_space_size;

intptr_t cell_space_capacity;

heap_stats.cell_space_capacity = &cell_space_capacity;

intptr_t property_cell_space_size;

heap_stats.property_cell_space_size = &property_cell_space_size;

intptr_t property_cell_space_capacity;

heap_stats.property_cell_space_capacity = &property_cell_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;

int end_marker;

heap_stats.end_marker = &end_marker;

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

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

}

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

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

FatalErrorCallback callback = isolate->exception_behavior();

if (callback == NULL) {

base::OS::PrintError("\n#\n# Fatal error in %s\n# %s\n#\n\n", location,

message);

base::OS::Abort();

} else {

callback(location, message);

}

isolate->SignalFatalError();

}

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

if (isolate->has_scheduled_exception()) {

return isolate->scheduled_exception() ==

isolate->heap()->termination_exception();

}

return false;

}

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, char* utf8_source) {

// Run custom script if provided.

TryCatch try_catch;

Local<String> source_string = String::NewFromUtf8(isolate, utf8_source);

if (try_catch.HasCaught()) return false;

ScriptOrigin origin(String::NewFromUtf8(isolate, "<embedded script>"));

ScriptCompiler::Source source(source_string, origin);

Local<Script> script = ScriptCompiler::Compile(isolate, &source);

if (try_catch.HasCaught()) return false;

script->Run();

return !try_catch.HasCaught();

}

StartupData V8::CreateSnapshotDataBlob(char* custom_source) {

Isolate::CreateParams params;

params.enable_serializer = true;

Isolate* isolate = v8::Isolate::New(params);

StartupData result = {NULL, 0};

{

Isolate::Scope isolate_scope(isolate);

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

Persistent<Context> context;

i::Snapshot::Metadata metadata;

{

HandleScope handle_scope(isolate);

Handle<Context> new_context = Context::New(isolate);

context.Reset(isolate, new_context);

if (custom_source != NULL) {

metadata.set_embeds_script(true);

Context::Scope context_scope(new_context);

if (!RunExtraCode(isolate, custom_source)) context.Reset();

}

}

if (!context.IsEmpty()) {

// Make sure all builtin scripts are cached.

{

HandleScope scope(isolate);

for (int i = 0; i < i::Natives::GetBuiltinsCount(); i++) {

internal_isolate->bootstrapper()->NativesSourceLookup(i);

}

}

// If we don't do this then we end up with a stray root pointing at the

// context even after we have disposed of the context.

internal_isolate->heap()->CollectAllAvailableGarbage("mksnapshot");

i::Object* raw_context = *v8::Utils::OpenPersistent(context);

context.Reset();

i::SnapshotByteSink snapshot_sink;

i::StartupSerializer ser(internal_isolate, &snapshot_sink);

ser.SerializeStrongReferences();

i::SnapshotByteSink context_sink;

i::PartialSerializer context_ser(internal_isolate, &ser, &context_sink);

context_ser.Serialize(&raw_context);

ser.SerializeWeakReferences();

result = i::Snapshot::CreateSnapshotBlob(ser, context_ser, metadata);

}

}

isolate->Dispose();

return result;

}

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

RegisteredExtension* re = first_extension_;

while (re != NULL) {

RegisteredExtension* next = re->next();

delete re;

re = next;

}

first_extension_ = NULL;

}

void RegisterExtension(Extension* that) {

RegisteredExtension* extension = new RegisteredExtension(that);

RegisteredExtension::Register(extension);

}

Extension::Extension(const char* name,

const char* source,

int dep_count,

const char** deps,

int source_length)

: name_(name),

source_length_(source_length >= 0 ?

source_length :

(source ? static_cast<int>(strlen(source)) : 0)),

source_(source, source_length_),

dep_count_(dep_count),

deps_(deps),

auto_enable_(false) {

CHECK(source != NULL || source_length_ == 0);

}

ResourceConstraints::ResourceConstraints()

: max_semi_space_size_(0),

max_old_space_size_(0),

max_executable_size_(0),

stack_limit_(NULL),

max_available_threads_(0),

code_range_size_(0) { }

void ResourceConstraints::ConfigureDefaults(uint64_t physical_memory,

uint64_t virtual_memory_limit,

uint32_t number_of_processors) {

#if V8_OS_ANDROID

// Android has higher physical memory requirements before raising the maximum

// heap size limits since it has no swap space.

const uint64_t low_limit = 512ul * i::MB;

const uint64_t medium_limit = 1ul * i::GB;

const uint64_t high_limit = 2ul * i::GB;

#else

const uint64_t low_limit = 512ul * i::MB;

const uint64_t medium_limit = 768ul * i::MB;

const uint64_t high_limit = 1ul * i::GB;

#endif

if (physical_memory <= low_limit) {

set_max_semi_space_size(i::Heap::kMaxSemiSpaceSizeLowMemoryDevice);

set_max_old_space_size(i::Heap::kMaxOldSpaceSizeLowMemoryDevice);

set_max_executable_size(i::Heap::kMaxExecutableSizeLowMemoryDevice);

} else if (physical_memory <= medium_limit) {

set_max_semi_space_size(i::Heap::kMaxSemiSpaceSizeMediumMemoryDevice);

set_max_old_space_size(i::Heap::kMaxOldSpaceSizeMediumMemoryDevice);

set_max_executable_size(i::Heap::kMaxExecutableSizeMediumMemoryDevice);

} else if (physical_memory <= high_limit) {

set_max_semi_space_size(i::Heap::kMaxSemiSpaceSizeHighMemoryDevice);

set_max_old_space_size(i::Heap::kMaxOldSpaceSizeHighMemoryDevice);

set_max_executable_size(i::Heap::kMaxExecutableSizeHighMemoryDevice);

} else {

set_max_semi_space_size(i::Heap::kMaxSemiSpaceSizeHugeMemoryDevice);

set_max_old_space_size(i::Heap::kMaxOldSpaceSizeHugeMemoryDevice);

set_max_executable_size(i::Heap::kMaxExecutableSizeHugeMemoryDevice);

}

set_max_available_threads(i::Max(i::Min(number_of_processors, 4u), 1u));

if (virtual_memory_limit > 0 && i::kRequiresCodeRange) {

// Reserve no more than 1/8 of the memory for the code range, but at most

// kMaximalCodeRangeSize.

set_code_range_size(

i::Min(i::kMaximalCodeRangeSize / i::MB,

static_cast<size_t>((virtual_memory_limit >> 3) / i::MB)));

}

}

void SetResourceConstraints(i::Isolate* isolate,

const ResourceConstraints& constraints) {

int semi_space_size = constraints.max_semi_space_size();

int old_space_size = constraints.max_old_space_size();

int max_executable_size = constraints.max_executable_size();

size_t code_range_size = constraints.code_range_size();

if (semi_space_size != 0 || old_space_size != 0 ||

max_executable_size != 0 || code_range_size != 0) {

isolate->heap()->ConfigureHeap(semi_space_size, old_space_size,

max_executable_size, code_range_size);

}

if (constraints.stack_limit() != NULL) {

uintptr_t limit = reinterpret_cast<uintptr_t>(constraints.stack_limit());

isolate->stack_guard()->SetStackLimit(limit);

}

isolate->set_max_available_threads(constraints.max_available_threads());

}

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::MakePhantom(i::Object** object, void* parameter,

int internal_field_index1, int internal_field_index2,

PhantomCallbackData<void>::Callback weak_callback) {

if (internal_field_index1 == 0) {

if (internal_field_index2 == 1) {

i::GlobalHandles::MakePhantom(object, parameter, 2, weak_callback);

} else {

DCHECK_EQ(internal_field_index2, kNoInternalFieldIndex);

i::GlobalHandles::MakePhantom(object, parameter, 1, weak_callback);

}

} else {

DCHECK_EQ(internal_field_index1, kNoInternalFieldIndex);

DCHECK_EQ(internal_field_index2, kNoInternalFieldIndex);

i::GlobalHandles::MakePhantom(object, parameter, 0, weak_callback);

}

}

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

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

i::Object* object = *Utils::OpenHandle(value);

isolate->eternal_handles()->Create(isolate, object, 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));

}

// --- H a n d l e s ---

HandleScope::HandleScope(Isolate* isolate) {

Initialize(isolate);

}

void HandleScope::Initialize(Isolate* isolate) {

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

// We do not want to check the correct usage of the Locker class all over the

// place, so we do it only here: Without a HandleScope, an embedder can do

// almost nothing, so it is enough to check in this central place.

Utils::ApiCheck(!v8::Locker::IsActive() ||

internal_isolate->thread_manager()->IsLockedByCurrentThread(),

"HandleScope::HandleScope",

"Entering the V8 API without proper locking in place");

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

isolate_ = internal_isolate;

prev_next_ = current->next;

prev_limit_ = current->limit;

current->level++;

}

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::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);

escape_slot_ = CreateHandle(isolate, isolate->heap()->the_hole_value());

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

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

isolate_ = internal_isolate;

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

prev_limit_ = current->limit;

current->limit = current->next;

prev_level_ = current->level;

current->level = 0;

}

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

i::Handle<i::Context> env = Utils::OpenHandle(this);

i::Isolate* isolate = env->GetIsolate();

ENTER_V8(isolate);

i::HandleScopeImplementer* impl = isolate->handle_scope_implementer();

impl->EnterContext(env);

impl->SaveContext(isolate->context());

isolate->set_context(*env);

}

void Context::Exit() {

i::Handle<i::Context> env = Utils::OpenHandle(this);

i::Isolate* isolate = env->GetIsolate();

ENTER_V8(isolate);

i::HandleScopeImplementer* impl = isolate->handle_scope_implementer();

if (!Utils::ApiCheck(impl->LastEnteredContextWas(env),

"v8::Context::Exit()",

"Cannot exit non-entered context")) {

return;

}

impl->LeaveContext();

isolate->set_context(impl->RestoreContext());

}

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,

int index,

bool can_grow,

const char* location) {

i::Handle<i::Context> env = Utils::OpenHandle(context);

bool ok =

Utils::ApiCheck(env->IsNativeContext(),

location,

"Not a native context") &&

Utils::ApiCheck(index >= 0, location, "Negative index");

if (!ok) return i::Handle<i::FixedArray>();

i::Handle<i::FixedArray> data(env->embedder_data());

if (index < data->length()) return data;

if (!Utils::ApiCheck(can_grow, location, "Index too large")) {

return i::Handle<i::FixedArray>();

}

int new_size = i::Max(index, data->length() << 1) + 1;

data = i::FixedArray::CopySize(data, new_size);

env->set_embedder_data(*data);

return data;

}

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

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

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

if (data.is_null()) return Local<Value>();

i::Handle<i::Object> result(data->get(index), data->GetIsolate());

return Utils::ToLocal(result);

}

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

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

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

if (data.is_null()) return;

i::Handle<i::Object> val = Utils::OpenHandle(*value);

data->set(index, *val);

DCHECK_EQ(*Utils::OpenHandle(*value),

*Utils::OpenHandle(*GetEmbedderData(index)));

}

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

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

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

data->set(index, EncodeAlignedAsSmi(value, location));

DCHECK_EQ(value, GetAlignedPointerFromEmbedderData(index));

}

// --- N e a n d e r ---

// A constructor cannot easily return an error value, therefore it is necessary

// to check for a dead VM with ON_BAILOUT before constructing any Neander

// objects. To remind you about this there is no HandleScope in the

// NeanderObject constructor. When you add one to the site calling the

// constructor you should check that you ensured the VM was not dead first.

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

ENTER_V8(isolate);

value_ = isolate->factory()->NewNeanderObject();

i::Handle<i::FixedArray> elements = isolate->factory()->NewFixedArray(size);

value_->set_elements(*elements);

}

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

}

// This method cannot easily return an error value, therefore it is necessary

// to check for a dead VM with ON_BAILOUT before calling it. To remind you

// about this there is no HandleScope in this method. When you add one to the

// site calling this method you should check that you ensured the VM was not

// dead first.

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

int length = this->length();

int size = obj_.size();

if (length == size - 1) {

i::Factory* factory = isolate->factory();

i::Handle<i::FixedArray> new_elms = factory->NewFixedArray(2 * size);

for (int i = 0; i < length; i++)

new_elms->set(i + 1, get(i));

obj_.value()->set_elements(*new_elms);

}

obj_.set(length + 1, *value);

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

}

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

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

obj_.set(index + 1, value);

}

// --- T e m p l a t e ---

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

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

}

void Template::Set(v8::Handle<Name> name,

v8::Handle<Data> value,

v8::PropertyAttribute attribute) {

auto templ = Utils::OpenHandle(this);

i::Isolate* isolate = templ->GetIsolate();

ENTER_V8(isolate);

i::HandleScope scope(isolate);

// TODO(dcarney): split api to allow values of v8::Value or v8::TemplateInfo.

i::ApiNatives::AddDataProperty(isolate, templ, Utils::OpenHandle(*name),

Utils::OpenHandle(*value),

static_cast<PropertyAttributes>(attribute));

}

void Template::SetAccessorProperty(

v8::Local<v8::Name> name,

v8::Local<FunctionTemplate> getter,

v8::Local<FunctionTemplate> setter,

v8::PropertyAttribute attribute,

v8::AccessControl access_control) {

// TODO(verwaest): Remove |access_control|.

DCHECK_EQ(v8::DEFAULT, access_control);

auto templ = Utils::OpenHandle(this);

auto isolate = templ->GetIsolate();

ENTER_V8(isolate);

DCHECK(!name.IsEmpty());

DCHECK(!getter.IsEmpty() || !setter.IsEmpty());

i::HandleScope scope(isolate);

i::ApiNatives::AddAccessorProperty(

isolate, templ, Utils::OpenHandle(*name),

Utils::OpenHandle(*getter, true), Utils::OpenHandle(*setter, true),

static_cast<PropertyAttributes>(attribute));

}

// --- F u n c t i o n T e m p l a t e ---

static void InitializeFunctionTemplate(

i::Handle<i::FunctionTemplateInfo> info) {

info->set_tag(i::Smi::FromInt(Consts::FUNCTION_TEMPLATE));

info->set_flag(0);

}

Local<ObjectTemplate> FunctionTemplate::PrototypeTemplate() {

i::Isolate* i_isolate = Utils::OpenHandle(this)->GetIsolate();

ENTER_V8(i_isolate);

i::Handle<i::Object> result(Utils::OpenHandle(this)->prototype_template(),

i_isolate);

if (result->IsUndefined()) {

v8::Isolate* isolate = reinterpret_cast<v8::Isolate*>(i_isolate);

result = Utils::OpenHandle(*ObjectTemplate::New(isolate));

Utils::OpenHandle(this)->set_prototype_template(*result);

}

return ToApiHandle<ObjectTemplate>(result);

}

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

const char* func) {

Utils::ApiCheck(!info->instantiated(), func,

"FunctionTemplate already instantiated");

}

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

auto info = Utils::OpenHandle(this);

EnsureNotInstantiated(info, "v8::FunctionTemplate::Inherit");

i::Isolate* isolate = info->GetIsolate();

ENTER_V8(isolate);

info->set_parent_template(*Utils::OpenHandle(*value));

}

static Local<FunctionTemplate> FunctionTemplateNew(

i::Isolate* isolate,

FunctionCallback callback,

v8::Handle<Value> data,

v8::Handle<Signature> signature,

int length,

bool do_not_cache) {

i::Handle<i::Struct> struct_obj =

isolate->factory()->NewStruct(i::FUNCTION_TEMPLATE_INFO_TYPE);

i::Handle<i::FunctionTemplateInfo> obj =

i::Handle<i::FunctionTemplateInfo>::cast(struct_obj);

InitializeFunctionTemplate(obj);

obj->set_do_not_cache(do_not_cache);

int next_serial_number = 0;

if (!do_not_cache) {

next_serial_number = isolate->next_serial_number() + 1;

isolate->set_next_serial_number(next_serial_number);

}

obj->set_serial_number(i::Smi::FromInt(next_serial_number));

if (callback != 0) {

if (data.IsEmpty()) {

data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));

}

Utils::ToLocal(obj)->SetCallHandler(callback, data);

}

obj->set_length(length);

obj->set_undetectable(false);

obj->set_needs_access_check(false);

if (!signature.IsEmpty())

obj->set_signature(*Utils::OpenHandle(*signature));

return Utils::ToLocal(obj);

}

Local<FunctionTemplate> FunctionTemplate::New(

Isolate* isolate,

FunctionCallback callback,

v8::Handle<Value> data,

v8::Handle<Signature> signature,

int length) {

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

// Changes to the environment cannot be captured in the snapshot. Expect no

// function templates when the isolate is created for serialization.

DCHECK(!i_isolate->serializer_enabled());

LOG_API(i_isolate, "FunctionTemplate::New");

ENTER_V8(i_isolate);

return FunctionTemplateNew(

i_isolate, callback, data, signature, length, false);

}

Local<Signature> Signature::New(Isolate* isolate,

Handle<FunctionTemplate> receiver) {

return Utils::SignatureToLocal(Utils::OpenHandle(*receiver));

}

Local<AccessorSignature> AccessorSignature::New(

Isolate* isolate,

Handle<FunctionTemplate> receiver) {

return Utils::AccessorSignatureToLocal(Utils::OpenHandle(*receiver));

}

Local<TypeSwitch> TypeSwitch::New(Handle<FunctionTemplate> type) {

Handle<FunctionTemplate> types[1] = { type };

return TypeSwitch::New(1, types);

}

Local<TypeSwitch> TypeSwitch::New(int argc, Handle<FunctionTemplate> types[]) {

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

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

ENTER_V8(isolate);

i::Handle<i::FixedArray> vector = isolate->factory()->NewFixedArray(argc);

for (int i = 0; i < argc; i++)

vector->set(i, *Utils::OpenHandle(*types[i]));

i::Handle<i::Struct> struct_obj =

isolate->factory()->NewStruct(i::TYPE_SWITCH_INFO_TYPE);

i::Handle<i::TypeSwitchInfo> obj =

i::Handle<i::TypeSwitchInfo>::cast(struct_obj);

obj->set_types(*vector);

return Utils::ToLocal(obj);

}

int TypeSwitch::match(v8::Handle<Value> value) {

i::Handle<i::TypeSwitchInfo> info = Utils::OpenHandle(this);

LOG_API(info->GetIsolate(), "TypeSwitch::match");

i::Handle<i::Object> obj = Utils::OpenHandle(*value);

i::FixedArray* types = i::FixedArray::cast(info->types());

for (int i = 0; i < types->length(); i++) {

if (i::FunctionTemplateInfo::cast(types->get(i))->IsTemplateFor(*obj))

return i + 1;

}

return 0;

}

#define SET_FIELD_WRAPPED(obj, setter, cdata) do { \

i::Handle<i::Object> foreign = FromCData(obj->GetIsolate(), cdata); \

(obj)->setter(*foreign); \

} while (false)

void FunctionTemplate::SetCallHandler(FunctionCallback callback,

v8::Handle<Value> data) {

auto info = Utils::OpenHandle(this);

EnsureNotInstantiated(info, "v8::FunctionTemplate::SetCallHandler");

i::Isolate* isolate = info->GetIsolate();

ENTER_V8(isolate);

i::HandleScope scope(isolate);

i::Handle<i::Struct> struct_obj =

isolate->factory()->NewStruct(i::CALL_HANDLER_INFO_TYPE);

i::Handle<i::CallHandlerInfo> obj =

i::Handle<i::CallHandlerInfo>::cast(struct_obj);

SET_FIELD_WRAPPED(obj, set_callback, callback);

if (data.IsEmpty()) {

data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));

}

obj->set_data(*Utils::OpenHandle(*data));

info->set_call_code(*obj);

}

static i::Handle<i::AccessorInfo> SetAccessorInfoProperties(

i::Handle<i::AccessorInfo> obj,

v8::Handle<Name> name,

v8::AccessControl settings,

v8::PropertyAttribute attributes,

v8::Handle<AccessorSignature> signature) {

obj->set_name(*Utils::OpenHandle(*name));

if (settings & ALL_CAN_READ) obj->set_all_can_read(true);

if (settings & ALL_CAN_WRITE) obj->set_all_can_write(true);

obj->set_property_attributes(static_cast<PropertyAttributes>(attributes));

if (!signature.IsEmpty()) {

obj->set_expected_receiver_type(*Utils::OpenHandle(*signature));

}

return obj;

}

template<typename Getter, typename Setter>

static i::Handle<i::AccessorInfo> MakeAccessorInfo(

v8::Handle<Name> name,

Getter getter,

Setter setter,

v8::Handle<Value> data,

v8::AccessControl settings,

v8::PropertyAttribute attributes,

v8::Handle<AccessorSignature> signature) {

i::Isolate* isolate = Utils::OpenHandle(*name)->GetIsolate();

i::Handle<i::ExecutableAccessorInfo> obj =

isolate->factory()->NewExecutableAccessorInfo();

SET_FIELD_WRAPPED(obj, set_getter, getter);

SET_FIELD_WRAPPED(obj, set_setter, setter);

if (data.IsEmpty()) {

data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));

}

obj->set_data(*Utils::OpenHandle(*data));

return SetAccessorInfoProperties(obj, name, settings, attributes, signature);

}

Local<ObjectTemplate> FunctionTemplate::InstanceTemplate() {

i::Handle<i::FunctionTemplateInfo> handle = Utils::OpenHandle(this, true);

if (!Utils::ApiCheck(!handle.is_null(),

"v8::FunctionTemplate::InstanceTemplate()",

"Reading from empty handle")) {

return Local<ObjectTemplate>();

}

i::Isolate* isolate = handle->GetIsolate();

ENTER_V8(isolate);

if (handle->instance_template()->IsUndefined()) {

Local<ObjectTemplate> templ =

ObjectTemplate::New(isolate, ToApiHandle<FunctionTemplate>(handle));

handle->set_instance_template(*Utils::OpenHandle(*templ));

}

i::Handle<i::ObjectTemplateInfo> result(

i::ObjectTemplateInfo::cast(handle->instance_template()));

return Utils::ToLocal(result);

}

void FunctionTemplate::SetLength(int length) {

auto info = Utils::OpenHandle(this);

EnsureNotInstantiated(info, "v8::FunctionTemplate::SetLength");

auto isolate = info->GetIsolate();

ENTER_V8(isolate);

info->set_length(length);

}

void FunctionTemplate::SetClassName(Handle<String> name) {