public:

// Impose an upper limit to avoid out of memory errors that bring down

// the process.

static const size_t kMaxLength = 0x3fffffff;

static ArrayBufferAllocator the_singleton;

virtual ~ArrayBufferAllocator() {}

virtual void* Allocate(size_t length);

virtual void* AllocateUninitialized(size_t length);

virtual void Free(void* data, size_t length);

private:

ArrayBufferAllocator() {}

ArrayBufferAllocator(const ArrayBufferAllocator&);

void operator=(const ArrayBufferAllocator&);

Environment* env = Environment::from_immediate_check_handle(handle);

HandleScope scope(env->isolate());

Context::Scope context_scope(env->context());

MakeCallback(env, env->process_object(), env->immediate_callback_string());

int errorno,

const char* syscall,

const char* message,

const char* path) {

Environment::GetCurrent(isolate)->ThrowErrnoException(errorno,

syscall,

message,

path);

int errorno,

const char* syscall,

const char* message,

const char* path) {

Environment::GetCurrent(isolate)->ThrowErrnoException(errorno,

syscall,

message,

path);

int errorno,

const char *syscall,

const char *msg,

const char *path) {

Environment* env = Environment::GetCurrent(isolate);

Local<Value> e;

Local<String> estring = OneByteString(env->isolate(), errno_string(errorno));

if (msg == NULL || msg[0] == '\0') {

msg = strerror(errorno);

}

Local<String> message = OneByteString(env->isolate(), msg);

Local<String> cons1 =

String::Concat(estring, FIXED_ONE_BYTE_STRING(env->isolate(), ", "));

Local<String> cons2 = String::Concat(cons1, message);

if (path) {

Local<String> cons3 =

String::Concat(cons2, FIXED_ONE_BYTE_STRING(env->isolate(), " '"));

Local<String> cons4 =

String::Concat(cons3, String::NewFromUtf8(env->isolate(), path));

Local<String> cons5 =

String::Concat(cons4, FIXED_ONE_BYTE_STRING(env->isolate(), "'"));

e = Exception::Error(cons5);

} else {

e = Exception::Error(cons2);

}

Local<Object> obj = e->ToObject();

obj->Set(env->errno_string(), Integer::New(env->isolate(), errorno));

obj->Set(env->code_string(), estring);

if (path != NULL) {

obj->Set(env->path_string(), String::NewFromUtf8(env->isolate(), path));

}

if (syscall != NULL) {

obj->Set(env->syscall_string(), OneByteString(env->isolate(), syscall));

}

return e;

int errorno,

const char *syscall,

const char *msg,

const char *path) {

Environment* env = Environment::GetCurrent(isolate);

if (!msg || !msg[0])

msg = uv_strerror(errorno);

Local<String> estring = OneByteString(env->isolate(), uv_err_name(errorno));

Local<String> message = OneByteString(env->isolate(), msg);

Local<String> cons1 =

String::Concat(estring, FIXED_ONE_BYTE_STRING(env->isolate(), ", "));

Local<String> cons2 = String::Concat(cons1, message);

Local<Value> e;

Local<String> path_str;

if (path) {

#ifdef _WIN32

if (strncmp(path, "\\\\?\\UNC\\", 8) == 0) {

path_str = String::Concat(FIXED_ONE_BYTE_STRING(env->isolate(), "\\\\"),

String::NewFromUtf8(env->isolate(), path + 8));

} else if (strncmp(path, "\\\\?\\", 4) == 0) {

path_str = String::NewFromUtf8(env->isolate(), path + 4);

} else {

path_str = String::NewFromUtf8(env->isolate(), path);

}

#else

path_str = String::NewFromUtf8(env->isolate(), path);

#endif

Local<String> cons3 =

String::Concat(cons2, FIXED_ONE_BYTE_STRING(env->isolate(), " '"));

Local<String> cons4 =

String::Concat(cons3, path_str);

Local<String> cons5 =

String::Concat(cons4, FIXED_ONE_BYTE_STRING(env->isolate(), "'"));

e = Exception::Error(cons5);

} else {

e = Exception::Error(cons2);

}

Local<Object> obj = e->ToObject();

// TODO(piscisaureus) errno should probably go

obj->Set(env->errno_string(), Integer::New(env->isolate(), errorno));

obj->Set(env->code_string(), estring);

if (path != NULL) {

obj->Set(env->path_string(), path_str);

}

if (syscall != NULL) {

obj->Set(env->syscall_string(), OneByteString(env->isolate(), syscall));

}

return e;

int errorno,

const char* syscall,

const char* msg,

const char* path) {

Environment* env = Environment::GetCurrent(isolate);

Local<Value> e;

bool must_free = false;

if (!msg || !msg[0]) {

msg = winapi_strerror(errorno, &must_free);

}

Local<String> message = OneByteString(env->isolate(), msg);

if (path) {

Local<String> cons1 =

String::Concat(message, FIXED_ONE_BYTE_STRING(isolate, " '"));

Local<String> cons2 =

String::Concat(cons1, String::NewFromUtf8(isolate, path));

Local<String> cons3 =

String::Concat(cons2, FIXED_ONE_BYTE_STRING(isolate, "'"));

e = Exception::Error(cons3);

} else {

e = Exception::Error(message);

}

Local<Object> obj = e->ToObject();

obj->Set(env->errno_string(), Integer::New(isolate, errorno));

if (path != NULL) {

obj->Set(env->path_string(), String::NewFromUtf8(isolate, path));

}

if (syscall != NULL) {

obj->Set(env->syscall_string(), OneByteString(isolate, syscall));

}

if (must_free)

LocalFree((HLOCAL)msg);

return e;

Environment* env = Environment::GetCurrent(args.GetIsolate());

if (env->using_domains())

return;

env->set_using_domains(true);

HandleScope scope(env->isolate());

Local<Object> process_object = env->process_object();

Local<String> tick_callback_function_key = env->tick_domain_cb_string();

Local<Function> tick_callback_function =

process_object->Get(tick_callback_function_key).As<Function>();

if (!tick_callback_function->IsFunction()) {

fprintf(stderr, "process._tickDomainCallback assigned to non-function\n");

abort();

}

process_object->Set(env->tick_callback_string(), tick_callback_function);

env->set_tick_callback_function(tick_callback_function);

assert(args[0]->IsArray());

assert(args[1]->IsObject());

env->set_domain_array(args[0].As<Array>());

Local<Object> domain_flag_obj = args[1].As<Object>();

Environment::DomainFlag* domain_flag = env->domain_flag();

domain_flag_obj->SetIndexedPropertiesToExternalArrayData(

domain_flag->fields(),

kExternalUint32Array,

domain_flag->fields_count());

// Do a little housekeeping.

env->process_object()->Delete(

FIXED_ONE_BYTE_STRING(args.GetIsolate(), "_setupDomainUse"));

HandleScope handle_scope(args.GetIsolate());

Environment* env = Environment::GetCurrent(args.GetIsolate());

assert(args[0]->IsObject());

assert(args[1]->IsFunction());

assert(args[2]->IsObject());

// Values use to cross communicate with processNextTick.

Local<Object> tick_info_obj = args[0].As<Object>();

tick_info_obj->SetIndexedPropertiesToExternalArrayData(

env->tick_info()->fields(),

kExternalUint32Array,

env->tick_info()->fields_count());

env->set_tick_callback_function(args[1].As<Function>());

NODE_SET_METHOD(args[2].As<Object>(), "runMicrotasks", RunMicrotasks);

// Do a little housekeeping.

env->process_object()->Delete(

FIXED_ONE_BYTE_STRING(args.GetIsolate(), "_setupNextTick"));

Handle<Value> recv,

const Handle<Function> callback,

int argc,

Handle<Value> argv[]) {

// If you hit this assertion, you forgot to enter the v8::Context first.

CHECK(env->context() == env->isolate()->GetCurrentContext());

Local<Object> process = env->process_object();

Local<Object> object, domain;

bool has_async_queue = false;

bool has_domain = false;

if (recv->IsObject()) {

object = recv.As<Object>();

Local<Value> async_queue_v = object->Get(env->async_queue_string());

if (async_queue_v->IsObject())

has_async_queue = true;