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

virtual void* Allocate(size_t length) override;

virtual void* AllocateUninitialized(size_t length) override;

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

private:

ArrayBufferAllocator() = default;

DISALLOW_COPY_AND_ASSIGN(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,

const char* dest) {

Environment::GetCurrent(isolate)

->ThrowUVException(errorno, syscall, message, path, dest);

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 == nullptr || msg[0] == '\0') {

msg = strerror(errorno);

}

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

Local<String> cons =

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

cons = String::Concat(cons, message);

Local<String> path_string;

if (path != nullptr) {

// FIXME(bnoordhuis) It's questionable to interpret the file path as UTF-8.

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

}

if (path_string.IsEmpty() == false) {

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

cons = String::Concat(cons, path_string);

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

}

e = Exception::Error(cons);

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

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

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

if (path_string.IsEmpty() == false) {

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

}

if (syscall != nullptr) {

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

}

return e;

#ifdef _WIN32

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

return String::Concat(FIXED_ONE_BYTE_STRING(isolate, "\\\\"),

String::NewFromUtf8(isolate, path + 8));

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

return String::NewFromUtf8(isolate, path + 4);

}

#endif

return String::NewFromUtf8(isolate, path);

int errorno,

const char* syscall,

const char* msg,

const char* path) {

return UVException(isolate, errorno, syscall, msg, path, nullptr);

int errorno,

const char* syscall,

const char* msg,

const char* path,

const char* dest) {

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

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

msg = uv_strerror(errorno);

Local<String> js_code = OneByteString(isolate, uv_err_name(errorno));

Local<String> js_syscall = OneByteString(isolate, syscall);

Local<String> js_path;

Local<String> js_dest;

Local<String> js_msg = js_code;

js_msg = String::Concat(js_msg, FIXED_ONE_BYTE_STRING(isolate, ": "));

js_msg = String::Concat(js_msg, OneByteString(isolate, msg));

js_msg = String::Concat(js_msg, FIXED_ONE_BYTE_STRING(isolate, ", "));

js_msg = String::Concat(js_msg, js_syscall);

if (path != nullptr) {

js_path = StringFromPath(isolate, path);

js_msg = String::Concat(js_msg, FIXED_ONE_BYTE_STRING(isolate, " '"));

js_msg = String::Concat(js_msg, js_path);

js_msg = String::Concat(js_msg, FIXED_ONE_BYTE_STRING(isolate, "'"));

}

if (dest != nullptr) {

js_dest = StringFromPath(isolate, dest);

js_msg = String::Concat(js_msg, FIXED_ONE_BYTE_STRING(isolate, " -> '"));

js_msg = String::Concat(js_msg, js_dest);

js_msg = String::Concat(js_msg, FIXED_ONE_BYTE_STRING(isolate, "'"));

}

Local<Object> e = Exception::Error(js_msg)->ToObject(isolate);

// TODO(piscisaureus) errno should probably go; the user has no way of

// knowing which uv errno value maps to which error.

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

e->Set(env->code_string(), js_code);

e->Set(env->syscall_string(), js_syscall);

if (!js_path.IsEmpty())

e->Set(env->path_string(), js_path);

if (!js_dest.IsEmpty())

e->Set(env->dest_string(), js_dest);

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

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

if (path != nullptr) {

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

}

if (syscall != nullptr) {

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

}

if (must_free)

LocalFree((HLOCAL)msg);

return e;

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

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

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

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

// Do a little housekeeping.

env->process_object()->Delete(

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

uint32_t* const fields = env->domain_flag()->fields();

uint32_t const fields_count = env->domain_flag()->fields_count();

Local<ArrayBuffer> array_buffer =

ArrayBuffer::New(env->isolate(), fields, sizeof(*fields) * fields_count);

args.GetReturnValue().Set(Uint32Array::New(array_buffer, 0, fields_count));

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

CHECK(args[0]->IsFunction());

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

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

env->SetMethod(args[1].As<Object>(), "runMicrotasks", RunMicrotasks);

// Do a little housekeeping.

env->process_object()->Delete(

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

// Values use to cross communicate with processNextTick.

uint32_t* const fields = env->tick_info()->fields();

uint32_t const fields_count = env->tick_info()->fields_count();

Local<ArrayBuffer> array_buffer =

ArrayBuffer::New(env->isolate(), fields, sizeof(*fields) * fields_count);

args.GetReturnValue().Set(Uint32Array::New(array_buffer, 0, fields_count));

Local<Promise> promise = message.GetPromise();

Isolate* isolate = promise->GetIsolate();

Local<Value> value = message.GetValue();

Local<Integer> event = Integer::New(isolate, message.GetEvent());

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

Local<Function> callback = env->promise_reject_function();

if (value.IsEmpty())

value = Undefined(isolate);