assert(watcher == &gc_timer);

assert(revents == EV_TIMER);

if (ev_pending_count(EV_DEFAULT_UC) == 0) V8::IdleNotification();

assert(watcher == &eio_poller);

assert(revents == EV_IDLE);

//printf("eio_poller\n");

if (eio_poll() != -1) {

//printf("eio_poller stop\n");

ev_idle_stop(EV_DEFAULT_UC_ watcher);

}

assert(watcher == &eio_want_poll_notifier);

assert(revents == EV_ASYNC);

//printf("want poll notifier\n");

if (eio_poll() == -1) {

//printf("eio_poller start\n");

ev_idle_start(EV_DEFAULT_UC_ &eio_poller);

}

assert(watcher == &eio_done_poll_notifier);

assert(revents == EV_ASYNC);

//printf("done poll notifier\n");

if (eio_poll() != -1) {

//printf("eio_poller stop\n");

ev_idle_stop(EV_DEFAULT_UC_ &eio_poller);

}

// Signal the main thread that we should stop calling eio_poll().

// from the idle watcher.

ev_async_send(EV_DEFAULT_UC_ &eio_done_poll_notifier);

HandleScope scope;

if (!encoding_v->IsString()) return _default;

String::Utf8Value encoding(encoding_v->ToString());

if (strcasecmp(*encoding, "utf8") == 0) {

return UTF8;

} else if (strcasecmp(*encoding, "utf-8") == 0) {

return UTF8;

} else if (strcasecmp(*encoding, "ascii") == 0) {

return ASCII;

} else if (strcasecmp(*encoding, "binary") == 0) {

return BINARY;

} else if (strcasecmp(*encoding, "raw") == 0) {

fprintf(stderr, "'raw' (array of integers) has been removed. "

"Use 'binary'.\n");

return BINARY;

} else if (strcasecmp(*encoding, "raws") == 0) {

fprintf(stderr, "'raws' encoding has been renamed to 'binary'. "

"Please update your code.\n");

return BINARY;

} else {

return _default;

}

HandleScope scope;

if (!len) return scope.Close(String::Empty());

if (encoding == BINARY) {

const unsigned char *cbuf = static_cast<const unsigned char*>(buf);

uint16_t * twobytebuf = new uint16_t[len];

for (size_t i = 0; i < len; i++) {

// XXX is the following line platform independent?

twobytebuf[i] = cbuf[i];

}

Local<String> chunk = String::New(twobytebuf, len);

delete [] twobytebuf; // TODO use ExternalTwoByteString?

return scope.Close(chunk);

}

// utf8 or ascii encoding

Local<String> chunk = String::New((const char*)buf, len);

return scope.Close(chunk);

HandleScope scope;

if (val->IsArray()) {

fprintf(stderr, "'raw' encoding (array of integers) has been removed. "

"Use 'binary'.\n");

assert(0);

return -1;

}

Local<String> str = val->ToString();

if (encoding == UTF8) return str->Utf8Length();

return str->Length();

v8::Handle<v8::Value> val,

enum encoding encoding) {

HandleScope scope;

// XXX

// A lot of improvement can be made here. See:

// http://code.google.com/p/v8/issues/detail?id=270

// http://groups.google.com/group/v8-dev/browse_thread/thread/dba28a81d9215291/ece2b50a3b4022c

// http://groups.google.com/group/v8-users/browse_thread/thread/1f83b0ba1f0a611

if (val->IsArray()) {

fprintf(stderr, "'raw' encoding (array of integers) has been removed. "

"Use 'binary'.\n");

assert(0);

return -1;

}

Local<String> str = val->ToString();

if (encoding == UTF8) {

str->WriteUtf8(buf, buflen);

return buflen;

}

if (encoding == ASCII) {

str->WriteAscii(buf, 0, buflen);

return buflen;

}

// THIS IS AWFUL!!! FIXME

assert(encoding == BINARY);

uint16_t * twobytebuf = new uint16_t[buflen];

str->Write(twobytebuf, 0, buflen);

for (size_t i = 0; i < buflen; i++) {

unsigned char *b = reinterpret_cast<unsigned char*>(&twobytebuf[i]);

assert(b[1] == 0);

buf[i] = b[0];

}

delete [] twobytebuf;

return buflen;

HandleScope scope;

if (dev_symbol.IsEmpty()) {

dev_symbol = NODE_PSYMBOL("dev");

ino_symbol = NODE_PSYMBOL("ino");

mode_symbol = NODE_PSYMBOL("mode");

nlink_symbol = NODE_PSYMBOL("nlink");

uid_symbol = NODE_PSYMBOL("uid");

gid_symbol = NODE_PSYMBOL("gid");

rdev_symbol = NODE_PSYMBOL("rdev");

size_symbol = NODE_PSYMBOL("size");

blksize_symbol = NODE_PSYMBOL("blksize");

blocks_symbol = NODE_PSYMBOL("blocks");

atime_symbol = NODE_PSYMBOL("atime");

mtime_symbol = NODE_PSYMBOL("mtime");

ctime_symbol = NODE_PSYMBOL("ctime");

}

Local<Object> stats =

stats_constructor_template->GetFunction()->NewInstance();

/* ID of device containing file */

stats->Set(dev_symbol, Integer::New(s->st_dev));

/* inode number */

stats->Set(ino_symbol, Integer::New(s->st_ino));

/* protection */

stats->Set(mode_symbol, Integer::New(s->st_mode));

/* number of hard links */

stats->Set(nlink_symbol, Integer::New(s->st_nlink));

/* user ID of owner */

stats->Set(uid_symbol, Integer::New(s->st_uid));

/* group ID of owner */

stats->Set(gid_symbol, Integer::New(s->st_gid));

/* device ID (if special file) */

stats->Set(rdev_symbol, Integer::New(s->st_rdev));

/* total size, in bytes */

stats->Set(size_symbol, Integer::New(s->st_size));

/* blocksize for filesystem I/O */

stats->Set(blksize_symbol, Integer::New(s->st_blksize));

/* number of blocks allocated */

stats->Set(blocks_symbol, Integer::New(s->st_blocks));

/* time of last access */

stats->Set(atime_symbol, NODE_UNIXTIME_V8(s->st_atime));

/* time of last modification */

stats->Set(mtime_symbol, NODE_UNIXTIME_V8(s->st_mtime));

/* time of last status change */

stats->Set(ctime_symbol, NODE_UNIXTIME_V8(s->st_ctime));

return scope.Close(stats);

Handle<Message> message = try_catch.Message();

if (message.IsEmpty()) {

fprintf(stderr, "Error: (no message)\n");

fflush(stderr);

return;

}

Handle<Value> error = try_catch.Exception();

Handle<String> stack;

if (error->IsObject()) {

Handle<Object> obj = Handle<Object>::Cast(error);

Handle<Value> raw_stack = obj->Get(String::New("stack"));

if (raw_stack->IsString()) stack = Handle<String>::Cast(raw_stack);

}

if (show_line) {

// Print (filename):(line number): (message).

String::Utf8Value filename(message->GetScriptResourceName());

const char* filename_string = ToCString(filename);

int linenum = message->GetLineNumber();

fprintf(stderr, "%s:%i\n", filename_string, linenum);

// Print line of source code.

String::Utf8Value sourceline(message->GetSourceLine());

const char* sourceline_string = ToCString(sourceline);

fprintf(stderr, "%s\n", sourceline_string);

// Print wavy underline (GetUnderline is deprecated).

int start = message->GetStartColumn();

for (int i = 0; i < start; i++) {

fprintf(stderr, " ");

}

int end = message->GetEndColumn();

for (int i = start; i < end; i++) {

fprintf(stderr, "^");

}

fprintf(stderr, "\n");

}

if (stack.IsEmpty()) {

message->PrintCurrentStackTrace(stderr);

} else {

String::Utf8Value trace(stack);

fprintf(stderr, "%s\n", *trace);

}

fflush(stderr);

HandleScope scope;

TryCatch try_catch;

Local<Script> script = Script::Compile(source, filename);

if (script.IsEmpty()) {

ReportException(try_catch);

exit(1);

}

Local<Value> result = script->Run();

if (result.IsEmpty()) {

ReportException(try_catch);

exit(1);

}

return scope.Close(result);

HandleScope scope;

if (args.Length() < 1 || !args[0]->IsString()) {

return ThrowException(Exception::Error(String::New("Bad argument.")));

}

Local<Integer> length = Integer::New(DecodeBytes(args[0], ParseEncoding(args[1], UTF8)));

return scope.Close(length);

HandleScope scope;

// TODO Probably don't need to start this each time.

// Avoids failing on test/mjsunit/test-eio-race3.js though

ev_idle_start(EV_DEFAULT_UC_ &eio_poller);

ev_loop(EV_DEFAULT_UC_ 0);

return Undefined();

HandleScope scope;

int how = EVUNLOOP_ONE;

if (args[0]->IsString()) {

String::Utf8Value how_s(args[0]->ToString());

if (0 == strcmp(*how_s, "all")) {

how = EVUNLOOP_ALL;

}

}

ev_unloop(EV_DEFAULT_ how);

return Undefined();

HandleScope scope;

if (args.Length() != 1 || !args[0]->IsString()) {

return ThrowException(Exception::Error(String::New("Bad argument.")));

}

String::Utf8Value path(args[0]->ToString());

int r = chdir(*path);

if (r != 0) {

return ThrowException(Exception::Error(String::New(strerror(errno))));

}

return Undefined();

HandleScope scope;

char output[PATH_MAX];

char *r = getcwd(output, PATH_MAX);

if (r == NULL) {

return ThrowException(Exception::Error(String::New(strerror(errno))));

}

Local<String> cwd = String::New(output);

return scope.Close(cwd);

HandleScope scope;

if(args.Length() < 1 || !args[0]->IsInt32()) {

return ThrowException(Exception::TypeError(

String::New("argument must be an integer.")));

}

unsigned int mask = args[0]->Uint32Value();

unsigned int old = umask((mode_t)mask);

return scope.Close(Uint32::New(old));

HandleScope scope;

int uid = getuid();

return scope.Close(Integer::New(uid));

HandleScope scope;

int gid = getgid();

return scope.Close(Integer::New(gid));

HandleScope scope;

if (args.Length() < 1) {

return ThrowException(Exception::Error(

String::New("setgid requires 1 argument")));

}

Local<Integer> given_gid = args[0]->ToInteger();

int gid = given_gid->Int32Value();

int result;

if ((result == setgid(gid)) != 0) {

return ThrowException(Exception::Error(String::New(strerror(errno))));

}

return Undefined();

HandleScope scope;

if (args.Length() < 1) {

return ThrowException(Exception::Error(

String::New("setuid requires 1 argument")));

}

Local<Integer> given_uid = args[0]->ToInteger();

int uid = given_uid->Int32Value();

int result;

if ((result = setuid(uid)) != 0) {

return ThrowException(Exception::Error(String::New(strerror(errno))));

}

return Undefined();

HandleScope scope;

fflush(stderr);

Stdio::Flush();

exit(args[0]->IntegerValue());

return Undefined();

pid_t pid = getpid();

size_t page_size = getpagesize();

char pidpath[1024];

sprintf(pidpath, "/proc/%d/psinfo", pid);

psinfo_t psinfo;

FILE *f = fopen(pidpath, "r");

if (!f) return -1;

if (fread(&psinfo, sizeof(psinfo_t), 1, f) != 1) {

fclose (f);

return -1;

}

/* XXX correct? */

*vsize = (size_t) psinfo.pr_size * page_size;

*rss = (size_t) psinfo.pr_rssize * 1024;

fclose (f);

return 0;

kvm_t *kd = NULL;

struct kinfo_proc *kinfo = NULL;

pid_t pid;

int nprocs;

pid = getpid();

kd = kvm_open(NULL, NULL, NULL, O_RDONLY, "kvm_open");

if (kd == NULL) goto error;

kinfo = kvm_getprocs(kd, KERN_PROC_PID, pid, &nprocs);

if (kinfo == NULL) goto error;

*rss = kinfo->ki_rssize * PAGE_SIZE;

*vsize = kinfo->ki_size;

kvm_close(kd);

return 0;

error:

if (kd) kvm_close(kd);

return -1;

struct task_basic_info t_info;

mach_msg_type_number_t t_info_count = TASK_BASIC_INFO_COUNT;

int r = task_info(mach_task_self(),

TASK_BASIC_INFO,

(task_info_t)&t_info,

&t_info_count);

if (r != KERN_SUCCESS) return -1;

*rss = t_info.resident_size;

*vsize = t_info.virtual_size;

return 0;

FILE *f = fopen("/proc/self/stat", "r");

if (!f) return -1;

int itmp;

char ctmp;

char buffer[MAXPATHLEN];

size_t page_size = getpagesize();

/* PID */

if (fscanf(f, "%d ", &itmp) == 0) goto error;

/* Exec file */

if (fscanf (f, "%s ", &buffer[0]) == 0) goto error;

/* State */

if (fscanf (f, "%c ", &ctmp) == 0) goto error;

/* Parent process */

if (fscanf (f, "%d ", &itmp) == 0) goto error;

/* Process group */

if (fscanf (f, "%d ", &itmp) == 0) goto error;

/* Session id */

if (fscanf (f, "%d ", &itmp) == 0) goto error;

/* TTY */

if (fscanf (f, "%d ", &itmp) == 0) goto error;

/* TTY owner process group */

if (fscanf (f, "%d ", &itmp) == 0) goto error;

/* Flags */

if (fscanf (f, "%u ", &itmp) == 0) goto error;

/* Minor faults (no memory page) */

if (fscanf (f, "%u ", &itmp) == 0) goto error;

/* Minor faults, children */

if (fscanf (f, "%u ", &itmp) == 0) goto error;

/* Major faults (memory page faults) */

if (fscanf (f, "%u ", &itmp) == 0) goto error;

/* Major faults, children */

if (fscanf (f, "%u ", &itmp) == 0) goto error;

/* utime */

if (fscanf (f, "%d ", &itmp) == 0) goto error;

/* stime */

if (fscanf (f, "%d ", &itmp) == 0) goto error;

/* utime, children */

if (fscanf (f, "%d ", &itmp) == 0) goto error;

/* stime, children */

if (fscanf (f, "%d ", &itmp) == 0) goto error;

/* jiffies remaining in current time slice */

if (fscanf (f, "%d ", &itmp) == 0) goto error;

/* 'nice' value */

if (fscanf (f, "%d ", &itmp) == 0) goto error;

/* jiffies until next timeout */

if (fscanf (f, "%u ", &itmp) == 0) goto error;

/* jiffies until next SIGALRM */

if (fscanf (f, "%u ", &itmp) == 0) goto error;

/* start time (jiffies since system boot) */

if (fscanf (f, "%d ", &itmp) == 0) goto error;

/* Virtual memory size */

if (fscanf (f, "%u ", &itmp) == 0) goto error;

*vsize = (size_t) itmp;

/* Resident set size */

if (fscanf (f, "%u ", &itmp) == 0) goto error;

*rss = (size_t) itmp * page_size;

/* rlim */

if (fscanf (f, "%u ", &itmp) == 0) goto error;

/* Start of text */

if (fscanf (f, "%u ", &itmp) == 0) goto error;

/* End of text */

if (fscanf (f, "%u ", &itmp) == 0) goto error;

/* Start of stack */

if (fscanf (f, "%u ", &itmp) == 0) goto error;

fclose (f);

return 0;

error:

fclose (f);

return -1;

HandleScope scope;

#ifndef HAVE_GETMEM

return ThrowException(Exception::Error(String::New("Not support on your platform. (Talk to Ryan.)")));

#else

size_t rss, vsize;

int r = getmem(&rss, &vsize);

if (r != 0) {

return ThrowException(Exception::Error(String::New(strerror(errno))));

}

Local<Object> info = Object::New();

if (rss_symbol.IsEmpty()) {

rss_symbol = NODE_PSYMBOL("rss");

vsize_symbol = NODE_PSYMBOL("vsize");

heap_total_symbol = NODE_PSYMBOL("heapTotal");

heap_used_symbol = NODE_PSYMBOL("heapUsed");

}

info->Set(rss_symbol, Integer::NewFromUnsigned(rss));

info->Set(vsize_symbol, Integer::NewFromUnsigned(vsize));

// V8 memory usage

HeapStatistics v8_heap_stats;

V8::GetHeapStatistics(&v8_heap_stats);

info->Set(heap_total_symbol,

Integer::NewFromUnsigned(v8_heap_stats.total_heap_size()));

info->Set(heap_used_symbol,

Integer::NewFromUnsigned(v8_heap_stats.used_heap_size()));

return scope.Close(info);

#endif

HandleScope scope;

if (args.Length() < 1 || !args[0]->IsNumber()) {

return ThrowException(Exception::Error(String::New("Bad argument.")));

}

pid_t pid = args[0]->IntegerValue();

int sig = SIGTERM;

if (args.Length() >= 2) {

if (args[1]->IsNumber()) {

sig = args[1]->Int32Value();

} else if (args[1]->IsString()) {

Local<String> signame = args[1]->ToString();

Local<Value> sig_v = process->Get(signame);

if (!sig_v->IsNumber()) {

return ThrowException(Exception::Error(String::New("Unknown signal")));

}

sig = sig_v->Int32Value();

}

}

int r = kill(pid, sig);

if (r != 0) {

return ThrowException(Exception::Error(String::New(strerror(errno))));

}

return Undefined();

HandleScope scope;

if (args.Length() < 2) return Undefined();

String::Utf8Value filename(args[0]->ToString()); // Cast

Local<Object> target = args[1]->ToObject(); // Cast

// Actually call dlopen().

// FIXME: This is a blocking function and should be called asynchronously!

// This function should be moved to file.cc and use libeio to make this

// system call.

void *handle = dlopen(*filename, RTLD_LAZY);

// Handle errors.

if (handle == NULL) {

Local<Value> exception = Exception::Error(String::New(dlerror()));

return ThrowException(exception);

}

// Get the init() function from the dynamically shared object.

void *init_handle = dlsym(handle, "init");

// Error out if not found.

if (init_handle == NULL) {

Local<Value> exception =

Exception::Error(String::New("No 'init' symbol found in module."));

return ThrowException(exception);

}

extInit init = (extInit)(init_handle); // Cast

// Execute the C++ module

init(target);

return Undefined();

HandleScope scope;

if (args.Length() < 2) {

return ThrowException(Exception::TypeError(

String::New("needs two arguments.")));

}

Local<String> source = args[0]->ToString();

Local<String> filename = args[1]->ToString();

TryCatch try_catch;

Local<Script> script = Script::Compile(source, filename);

if (try_catch.HasCaught()) {

// Hack because I can't get a proper stacktrace on SyntaxError

ReportException(try_catch, true);

exit(1);

}

Local<Value> result = script->Run();

if (try_catch.HasCaught()) return try_catch.ReThrow();

return scope.Close(result);

if (location) {

fprintf(stderr, "FATAL ERROR: %s %s\n", location, message);

} else {

fprintf(stderr, "FATAL ERROR: %s\n", message);

}

exit(1);

HandleScope scope;

// Check if uncaught_exception_counter indicates a recursion

if (uncaught_exception_counter > 0) {

ReportException(try_catch);

exit(1);

}

if (listeners_symbol.IsEmpty()) {

listeners_symbol = NODE_PSYMBOL("listeners");

uncaught_exception_symbol = NODE_PSYMBOL("uncaughtException");

emit_symbol = NODE_PSYMBOL("emit");

}

Local<Value> listeners_v = process->Get(listeners_symbol);

assert(listeners_v->IsFunction());

Local<Function> listeners = Local<Function>::Cast(listeners_v);

Local<String> uncaught_exception_symbol_l = Local<String>::New(uncaught_exception_symbol);

Local<Value> argv[1] = { uncaught_exception_symbol_l };

Local<Value> ret = listeners->Call(process, 1, argv);

assert(ret->IsArray());

Local<Array> listener_array = Local<Array>::Cast(ret);

uint32_t length = listener_array->Length();

// Report and exit if process has no "uncaughtException" listener

if (length == 0) {

ReportException(try_catch);

exit(1);

}

// Otherwise fire the process "uncaughtException" event

Local<Value> emit_v = process->Get(emit_symbol);

assert(emit_v->IsFunction());

Local<Function> emit = Local<Function>::Cast(emit_v);

Local<Value> error = try_catch.Exception();

Local<Value> event_argv[2] = { uncaught_exception_symbol_l, error };

uncaught_exception_counter++;

emit->Call(process, 2, event_argv);

// Decrement so we know if the next exception is a recursion or not

uncaught_exception_counter--;

HandleScope scope;

assert(watcher == &debug_watcher);

assert(revents == EV_ASYNC);

Debug::ProcessDebugMessages();

// This function is called from V8's debug thread when a debug TCP client

// has sent a message.

// Send a signal to our main thread saying that it should enter V8 to

// handle the message.

debugger_msg_pending = true;

ev_async_send(EV_DEFAULT_UC_ &debug_watcher);

HandleScope scope;

// TODO FIXME This function is a hack to wait until V8 is ready to accept

// commands. There seems to be a bug in EnableAgent( _ , _ , true) which

// makes it unusable here. Ideally we'd be able to bind EnableAgent and

// get it to halt until Eclipse connects.

if (!debug_wait_connect)

return Undefined();

printf("Waiting for remote debugger connection...\n");

const int halfSecond = 50;

const int tenMs=10000;

debugger_msg_pending = false;

for (;;) {

if (debugger_msg_pending) {

Debug::DebugBreak();

Debug::ProcessDebugMessages();

debugger_msg_pending = false;

// wait for 500 msec of silence from remote debugger

int cnt = halfSecond;

while (cnt --) {

debugger_msg_pending = false;

usleep(tenMs);

if (debugger_msg_pending) {

debugger_msg_pending = false;

cnt = halfSecond;

}

}

break;

}

usleep(tenMs);

}

return Undefined();

HandleScope scope;

Local<FunctionTemplate> process_template = FunctionTemplate::New();

node::EventEmitter::Initialize(process_template);