assert((uv_idle_t*) handle == &tick_spinner);

assert(status == 0);

// Avoid entering a V8 scope.

if (!need_tick_cb) return;

need_tick_cb = false;

uv_idle_stop(&tick_spinner);

HandleScope scope(node_isolate);

if (process_tickFromSpinner.IsEmpty()) {

Local<Value> cb_v = process->Get(String::New("_tickFromSpinner"));

if (!cb_v->IsFunction()) {

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

abort();

}

Local<Function> cb = cb_v.As<Function>();

process_tickFromSpinner = Persistent<Function>::New(node_isolate, cb);

}

TryCatch try_catch;

process_tickFromSpinner->Call(process, 0, NULL);

if (try_catch.HasCaught()) {

FatalException(try_catch);

}

need_tick_cb = true;

uv_idle_start(&tick_spinner, Spin);

return Undefined(node_isolate);

assert(handle == &check_immediate_watcher);

assert(status == 0);

HandleScope scope(node_isolate);

if (immediate_callback_sym.IsEmpty()) {

immediate_callback_sym = NODE_PSYMBOL("_immediateCallback");

}

MakeCallback(process, immediate_callback_sym, 0, NULL);

// Do nothing. Only for maintaining event loop

assert(handle == &idle_immediate_dummy);

assert(status == 0);

const char *syscall,

const char *msg,

const char *path) {

Local<Value> e;

Local<String> estring = String::NewSymbol(errno_string(errorno));

if (!msg[0]) {

msg = strerror(errorno);

}

Local<String> message = String::NewSymbol(msg);

Local<String> cons1 = String::Concat(estring, String::NewSymbol(", "));

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

if (syscall_symbol.IsEmpty()) {

syscall_symbol = NODE_PSYMBOL("syscall");

errno_symbol = NODE_PSYMBOL("errno");

errpath_symbol = NODE_PSYMBOL("path");

code_symbol = NODE_PSYMBOL("code");

}

if (path) {

Local<String> cons3 = String::Concat(cons2, String::NewSymbol(" '"));

Local<String> cons4 = String::Concat(cons3, String::New(path));

Local<String> cons5 = String::Concat(cons4, String::NewSymbol("'"));

e = Exception::Error(cons5);

} else {

e = Exception::Error(cons2);

}

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

obj->Set(errno_symbol, Integer::New(errorno, node_isolate));

obj->Set(code_symbol, estring);

if (path) obj->Set(errpath_symbol, String::New(path));

if (syscall) obj->Set(syscall_symbol, String::NewSymbol(syscall));

return e;

const char *syscall,

const char *msg,

const char *path) {

if (syscall_symbol.IsEmpty()) {

syscall_symbol = NODE_PSYMBOL("syscall");

errno_symbol = NODE_PSYMBOL("errno");

errpath_symbol = NODE_PSYMBOL("path");

code_symbol = NODE_PSYMBOL("code");

}

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

msg = get_uv_errno_message(errorno);

Local<String> estring = String::NewSymbol(get_uv_errno_string(errorno));

Local<String> message = String::NewSymbol(msg);

Local<String> cons1 = String::Concat(estring, String::NewSymbol(", "));

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(String::New("\\\\"), String::New(path + 8));

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

path_str = String::New(path + 4);

} else {

path_str = String::New(path);

}

#else

path_str = String::New(path);

#endif

Local<String> cons3 = String::Concat(cons2, String::NewSymbol(" '"));

Local<String> cons4 = String::Concat(cons3, path_str);

Local<String> cons5 = String::Concat(cons4, String::NewSymbol("'"));

e = Exception::Error(cons5);

} else {

e = Exception::Error(cons2);

}

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

// TODO errno should probably go

obj->Set(errno_symbol, Integer::New(errorno, node_isolate));

obj->Set(code_symbol, estring);

if (path) obj->Set(errpath_symbol, path_str);

if (syscall) obj->Set(syscall_symbol, String::NewSymbol(syscall));

return e;

const char* syscall,

const char* msg,

const char* path) {

Local<Value> e;

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

msg = winapi_strerror(errorno);

}

Local<String> message = String::NewSymbol(msg);

if (syscall_symbol.IsEmpty()) {

syscall_symbol = NODE_PSYMBOL("syscall");

errno_symbol = NODE_PSYMBOL("errno");

errpath_symbol = NODE_PSYMBOL("path");

code_symbol = NODE_PSYMBOL("code");

}

if (path) {

Local<String> cons1 = String::Concat(message, String::NewSymbol(" '"));

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

Local<String> cons3 = String::Concat(cons2, String::NewSymbol("'"));

e = Exception::Error(cons3);

} else {

e = Exception::Error(message);

}

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

obj->Set(errno_symbol, Integer::New(errorno, node_isolate));

if (path) obj->Set(errpath_symbol, String::New(path));

if (syscall) obj->Set(syscall_symbol, String::NewSymbol(syscall));

return e;

const Arguments& args) {

HandleScope scope(node_isolate);

Local<Value> argv[32];

unsigned argc = args.Length();

if (argc > ARRAY_SIZE(argv)) argc = ARRAY_SIZE(argv);

for (unsigned i = 0; i < argc; ++i) argv[i] = args[i];

return scope.Close(t->GetFunction()->NewInstance(argc, argv));

HandleScope scope(node_isolate);

if (using_domains)

return Undefined();

using_domains = true;

Local<Value> tdc_v = process->Get(String::New("_tickDomainCallback"));

Local<Value> ndt_v = process->Get(String::New("_nextDomainTick"));

if (!tdc_v->IsFunction()) {

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

abort();

}

if (!ndt_v->IsFunction()) {

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

abort();

}

Local<Function> tdc = tdc_v.As<Function>();

Local<Function> ndt = ndt_v.As<Function>();

process->Set(String::New("_tickCallback"), tdc);

process->Set(String::New("nextTick"), ndt);

process_tickCallback = Persistent<Function>::New(node_isolate, tdc);

return Undefined();

const Handle<Function> callback,

int argc,

Handle<Value> argv[]) {

// TODO Hook for long stack traces to be made here.

// lazy load domain specific symbols

if (enter_symbol.IsEmpty()) {

enter_symbol = NODE_PSYMBOL("enter");

exit_symbol = NODE_PSYMBOL("exit");

disposed_symbol = NODE_PSYMBOL("_disposed");

}

Local<Value> domain_v = object->Get(domain_symbol);

Local<Object> domain;

Local<Function> enter;

Local<Function> exit;

TryCatch try_catch;

bool has_domain = domain_v->IsObject();

if (has_domain) {

domain = domain_v->ToObject();

assert(!domain.IsEmpty());

if (domain->Get(disposed_symbol)->IsTrue()) {

// domain has been disposed of.

return Undefined(node_isolate);

}

enter = Local<Function>::Cast(domain->Get(enter_symbol));

assert(!enter.IsEmpty());

enter->Call(domain, 0, NULL);

if (try_catch.HasCaught()) {

FatalException(try_catch);

return Undefined(node_isolate);

}

}

Local<Value> ret = callback->Call(object, argc, argv);

if (try_catch.HasCaught()) {

FatalException(try_catch);

return Undefined(node_isolate);

}

if (has_domain) {

exit = Local<Function>::Cast(domain->Get(exit_symbol));

assert(!exit.IsEmpty());

exit->Call(domain, 0, NULL);

if (try_catch.HasCaught()) {

FatalException(try_catch);

return Undefined(node_isolate);

}

}

if (tick_infobox.length == 0) {

tick_infobox.index = 0;

tick_infobox.depth = 0;

return ret;

}

// process nextTicks after call

process_tickCallback->Call(process, 0, NULL);

if (try_catch.HasCaught()) {

FatalException(try_catch);

return Undefined(node_isolate);

}

return ret;