#include // IWYU pragma: keep #include #include #include #include #include #include #include #ifdef _WIN32 #define WIN32_LEAN_AND_MEAN #include #include #include #define STDIN_FILENO 0 #define STDOUT_FILENO 1 #define STDERR_FILENO 2 #else #include #include #include #include #include #include #include #include #endif #include "ant.h" #include "errors.h" #include "utils.h" #include "internal.h" #include "descriptors.h" #include "runtime.h" #include "silver/engine.h" #include "modules/process.h" #include "modules/symbol.h" #include "modules/buffer.h" #include "modules/napi.h" #ifndef _WIN32 extern char **environ; #else #define environ _environ #endif #define DEFAULT_MAX_LISTENERS 10 #define INITIAL_LISTENER_CAPACITY 4 typedef struct { jsval_t listener; bool once; } ProcessEventListener; typedef struct { char *event_type; ProcessEventListener *listeners; int listener_count; int listener_capacity; int emitting; bool free_deferred; UT_hash_handle hh; } ProcessEventType; static int max_listeners = DEFAULT_MAX_LISTENERS; static ProcessEventType *process_events = NULL; static ProcessEventType *stdin_events = NULL; static ProcessEventType *stdout_events = NULL; static ProcessEventType *stderr_events = NULL; typedef struct { uv_tty_t tty; bool tty_initialized; bool reading; bool keypress_enabled; int escape_state; int escape_len; char escape_buf[16]; } stdin_state_t; static stdin_state_t stdin_state = {0}; static uint64_t process_start_time = 0; #ifndef _WIN32 static struct termios stdin_saved_termios; static bool stdin_raw_mode = false; static uv_signal_t sigwinch_handle; static bool sigwinch_initialized = false; #endif typedef struct { const char *name; int signum; UT_hash_handle hh_name; UT_hash_handle hh_num; } SignalEntry; static SignalEntry *signals_by_name = NULL; static SignalEntry *signals_by_num = NULL; static void init_signal_map(void) { static bool initialized = false; if (initialized) return; static SignalEntry entries[] = { #ifdef SIGHUP { "SIGHUP", SIGHUP, {0}, {0} }, #endif #ifdef SIGINT { "SIGINT", SIGINT, {0}, {0} }, #endif #ifdef SIGQUIT { "SIGQUIT", SIGQUIT, {0}, {0} }, #endif #ifdef SIGILL { "SIGILL", SIGILL, {0}, {0} }, #endif #ifdef SIGTRAP { "SIGTRAP", SIGTRAP, {0}, {0} }, #endif #ifdef SIGABRT { "SIGABRT", SIGABRT, {0}, {0} }, #endif #ifdef SIGBUS { "SIGBUS", SIGBUS, {0}, {0} }, #endif #ifdef SIGFPE { "SIGFPE", SIGFPE, {0}, {0} }, #endif #ifdef SIGUSR1 { "SIGUSR1", SIGUSR1, {0}, {0} }, #endif #ifdef SIGUSR2 { "SIGUSR2", SIGUSR2, {0}, {0} }, #endif #ifdef SIGSEGV { "SIGSEGV", SIGSEGV, {0}, {0} }, #endif #ifdef SIGPIPE { "SIGPIPE", SIGPIPE, {0}, {0} }, #endif #ifdef SIGALRM { "SIGALRM", SIGALRM, {0}, {0} }, #endif #ifdef SIGTERM { "SIGTERM", SIGTERM, {0}, {0} }, #endif #ifdef SIGCHLD { "SIGCHLD", SIGCHLD, {0}, {0} }, #endif #ifdef SIGCONT { "SIGCONT", SIGCONT, {0}, {0} }, #endif #ifdef SIGTSTP { "SIGTSTP", SIGTSTP, {0}, {0} }, #endif #ifdef SIGTTIN { "SIGTTIN", SIGTTIN, {0}, {0} }, #endif #ifdef SIGTTOU { "SIGTTOU", SIGTTOU, {0}, {0} }, #endif #ifdef SIGURG { "SIGURG", SIGURG, {0}, {0} }, #endif #ifdef SIGXCPU { "SIGXCPU", SIGXCPU, {0}, {0} }, #endif #ifdef SIGXFSZ { "SIGXFSZ", SIGXFSZ, {0}, {0} }, #endif #ifdef SIGVTALRM { "SIGVTALRM", SIGVTALRM, {0}, {0} }, #endif #ifdef SIGPROF { "SIGPROF", SIGPROF, {0}, {0} }, #endif #ifdef SIGWINCH { "SIGWINCH", SIGWINCH, {0}, {0} }, #endif #ifdef SIGIO { "SIGIO", SIGIO, {0}, {0} }, #endif #ifdef SIGSYS { "SIGSYS", SIGSYS, {0}, {0} }, #endif }; for (size_t i = 0; i < sizeof(entries) / sizeof(entries[0]); i++) { HASH_ADD_KEYPTR(hh_name, signals_by_name, entries[i].name, strlen(entries[i].name), &entries[i]); HASH_ADD(hh_num, signals_by_num, signum, sizeof(int), &entries[i]); } initialized = true; } static int get_signal_number(const char *name) { init_signal_map(); SignalEntry *entry = NULL; HASH_FIND(hh_name, signals_by_name, name, strlen(name), entry); return entry ? entry->signum : -1; } static const char *get_signal_name(int signum) { init_signal_map(); SignalEntry *entry = NULL; HASH_FIND(hh_num, signals_by_num, &signum, sizeof(int), entry); return entry ? entry->name : NULL; } static ProcessEventType *find_or_create_event(ProcessEventType **table, const char *event_type) { ProcessEventType *evt = NULL; HASH_FIND_STR(*table, event_type, evt); if (evt == NULL) { evt = malloc(sizeof(ProcessEventType)); *evt = (ProcessEventType){ .event_type = strdup(event_type), .emitting = 0, .listener_count = 0, .free_deferred = false, .listener_capacity = INITIAL_LISTENER_CAPACITY, .listeners = malloc(sizeof(ProcessEventListener) * INITIAL_LISTENER_CAPACITY), }; HASH_ADD_KEYPTR(hh, *table, evt->event_type, strlen(evt->event_type), evt); } return evt; } static bool ensure_listener_capacity(ProcessEventType *evt) { if (evt->listener_count >= evt->listener_capacity) { int new_capacity = evt->listener_capacity * 2; ProcessEventListener *new_listeners = realloc(evt->listeners, sizeof(ProcessEventListener) * new_capacity); if (!new_listeners) return false; evt->listeners = new_listeners; evt->listener_capacity = new_capacity; } return true; } static void free_event_type(ProcessEventType **events, ProcessEventType *evt) { if (!evt) return; if (evt->emitting > 0) { evt->free_deferred = true; return; } HASH_DEL(*events, evt); free(evt->listeners); free(evt->event_type); free(evt); } static void check_listener_warning(const char *event) { ProcessEventType *evt = NULL; HASH_FIND_STR(process_events, event, evt); if (evt && evt->listener_count == max_listeners) fprintf(stderr, "Warning: Possible EventEmitter memory leak detected. " "%d '%s' listeners added. Use process.setMaxListeners() to increase limit.\n", evt->listener_count, event ); } void emit_process_event(const char *event_type, jsval_t *args, int nargs) { if (!rt->js) return; ProcessEventType *evt = NULL; HASH_FIND_STR(process_events, event_type, evt); if (evt == NULL || evt->listener_count == 0) return; evt->emitting++; int i = 0; while (i < evt->listener_count) { ProcessEventListener *listener = &evt->listeners[i]; sv_vm_call(rt->js->vm, rt->js, listener->listener, js_mkundef(), args, nargs, NULL, false); if (listener->once) { for (int j = i; j < evt->listener_count - 1; j++) { evt->listeners[j] = evt->listeners[j + 1]; } evt->listener_count--; } else i++; } evt->emitting--; if (evt->listener_count == 0 || evt->free_deferred) { int signum = get_signal_number(event_type); if (signum > 0) signal(signum, SIG_DFL); if (evt->emitting == 0) free_event_type(&process_events, evt); } } static void process_signal_handler(int signum) { const char *name = get_signal_name(signum); if (name) { jsval_t sig_arg = js_mkstr(rt->js, name, strlen(name)); emit_process_event(name, &sig_arg, 1); } } static void emit_stdio_event(ProcessEventType **events, const char *event_type, jsval_t *args, int nargs) { if (!rt->js) return; ProcessEventType *evt = NULL; HASH_FIND_STR(*events, event_type, evt); if (evt == NULL || evt->listener_count == 0) return; evt->emitting++; int i = 0; while (i < evt->listener_count) { ProcessEventListener *listener = &evt->listeners[i]; sv_vm_call(rt->js->vm, rt->js, listener->listener, js_mkundef(), args, nargs, NULL, false); if (listener->once) { for (int j = i; j < evt->listener_count - 1; j++) evt->listeners[j] = evt->listeners[j + 1]; evt->listener_count--; } else i++; } evt->emitting--; if ((evt->listener_count == 0 || evt->free_deferred) && evt->emitting == 0) free_event_type(events, evt); } static const char *stdin_escape_name(const char *seq, int len) { if (len < 2) return NULL; if (seq[0] == '[') { if (seq[1] >= '0' && seq[1] <= '9') { int num = 0; int idx = 1; while (idx < len && seq[idx] >= '0' && seq[idx] <= '9') { num = num * 10 + (seq[idx] - '0'); idx++; } if (idx < len && seq[idx] == '~') { typedef struct { int code; const char *name; } esc_num_map_t; static const esc_num_map_t esc_num_map[] = { { 1, "home" }, { 2, "insert" }, { 3, "delete" }, { 4, "end" }, { 5, "pageup" }, { 6, "pagedown" }, { 7, "home" }, { 8, "end" }, { 15, "f5" }, { 17, "f6" }, { 18, "f7" }, { 19, "f8" }, { 20, "f9" }, { 21, "f10" }, { 23, "f11" }, { 24, "f12" }, }; for (size_t i = 0; i < sizeof(esc_num_map) / sizeof(esc_num_map[0]); i++) { if (esc_num_map[i].code == num) return esc_num_map[i].name; } } return NULL; } typedef struct { char code; bool needs_tilde; const char *name; } esc_map_t; static const esc_map_t esc_map[] = { { 'A', false, "up" }, { 'B', false, "down" }, { 'C', false, "right" }, { 'D', false, "left" }, { 'H', false, "home" }, { 'F', false, "end" }, { 'Z', false, "tab" }, { '2', true, "insert" }, { '3', true, "delete" }, { '5', true, "pageup" }, { '6', true, "pagedown" }, }; for (size_t i = 0; i < sizeof(esc_map) / sizeof(esc_map[0]); i++) { if (seq[1] != esc_map[i].code) continue; if (esc_map[i].needs_tilde) { return (len >= 3 && seq[2] == '~') ? esc_map[i].name : NULL; } return esc_map[i].name; } return NULL; } if (seq[0] == 'O') { switch (seq[1]) { case 'P': return "f1"; case 'Q': return "f2"; case 'R': return "f3"; case 'S': return "f4"; default: return NULL; } } return NULL; } static void emit_keypress_event( ant_t *js, const char *str, size_t str_len, const char *name, bool ctrl, bool meta, bool shift, const char *sequence, size_t sequence_len ) { jsval_t str_val = js_mkstr(js, str ? str : "", str ? str_len : 0); jsval_t key_obj = js_mkobj(js); if (name) { js_set(js, key_obj, "name", js_mkstr(js, name, strlen(name))); } else { js_set(js, key_obj, "name", js_mkundef()); } js_set(js, key_obj, "ctrl", js_bool(ctrl)); js_set(js, key_obj, "meta", js_bool(meta)); js_set(js, key_obj, "shift", js_bool(shift)); if (sequence) { js_set(js, key_obj, "sequence", js_mkstr(js, sequence, sequence_len)); } jsval_t args[2] = { str_val, key_obj }; emit_stdio_event(&stdin_events, "keypress", args, 2); } static void process_keypress_data(ant_t *js, const char *data, size_t len) { for (size_t i = 0; i < len; i++) { unsigned char c = (unsigned char)data[i]; if (stdin_state.escape_state == 1) { stdin_state.escape_buf[stdin_state.escape_len++] = (char)c; if (c == '[' || c == 'O') { stdin_state.escape_state = 2; continue; } emit_keypress_event(js, "\x1b", 1, "escape", false, false, false, "\x1b", 1); stdin_state.escape_state = 0; stdin_state.escape_len = 0; } if (stdin_state.escape_state == 2) { stdin_state.escape_buf[stdin_state.escape_len++] = (char)c; if ((c >= 'A' && c <= 'Z') || c == '~' || stdin_state.escape_len >= 15) { char sequence[18]; size_t seq_len = 0; sequence[seq_len++] = '\x1b'; memcpy(sequence + seq_len, stdin_state.escape_buf, (size_t)stdin_state.escape_len); seq_len += (size_t)stdin_state.escape_len; const char *name = stdin_escape_name(stdin_state.escape_buf, stdin_state.escape_len); if (!name) name = "escape"; emit_keypress_event(js, "", 0, name, false, false, false, sequence, seq_len); stdin_state.escape_state = 0; stdin_state.escape_len = 0; } continue; } if (c == 27) { stdin_state.escape_state = 1; stdin_state.escape_len = 0; continue; } if (c == '\r' || c == '\n') { emit_keypress_event(js, "\r", 1, "return", false, false, false, "\r", 1); continue; } if (c == 127 || c == 8) { emit_keypress_event(js, "", 0, "backspace", false, false, false, NULL, 0); continue; } if (c == '\t') { emit_keypress_event(js, "\t", 1, "tab", false, false, false, "\t", 1); continue; } if (c < 32) { char name_buf[2] = { (char)('a' + c - 1), '\0' }; char seq = (char)c; emit_keypress_event(js, &seq, 1, name_buf, true, false, false, &seq, 1); continue; } char ch = (char)c; char name_buf[2] = { ch, '\0' }; emit_keypress_event(js, &ch, 1, name_buf, false, false, false, &ch, 1); } if (stdin_state.escape_state == 1) { emit_keypress_event(js, "\x1b", 1, "escape", false, false, false, "\x1b", 1); stdin_state.escape_state = 0; stdin_state.escape_len = 0; } } static bool remove_listener_from_events(ProcessEventType **events, const char *event, jsval_t listener) { ProcessEventType *evt = NULL; HASH_FIND_STR(*events, event, evt); if (!evt) return false; for (int i = 0; i < evt->listener_count; i++) { if (evt->listeners[i].listener != listener) continue; memmove( &evt->listeners[i], &evt->listeners[i + 1], (size_t)(evt->listener_count - i - 1) * sizeof(ProcessEventListener) ); if (--evt->listener_count == 0) { free_event_type(events, evt); return true; } return false; } return false; } static bool stdin_is_tty(void) { return uv_guess_handle(STDIN_FILENO) == UV_TTY; } static bool stdout_is_tty(void) { return uv_guess_handle(STDOUT_FILENO) == UV_TTY; } static bool stderr_is_tty(void) { return uv_guess_handle(STDERR_FILENO) == UV_TTY; } static void get_tty_size(int fd, int *rows, int *cols) { int out_rows = 24, out_cols = 80; #ifndef _WIN32 struct winsize ws; if (ioctl(fd, TIOCGWINSZ, &ws) == 0) { if (ws.ws_row > 0) out_rows = ws.ws_row; if (ws.ws_col > 0) out_cols = ws.ws_col; } #else CONSOLE_SCREEN_BUFFER_INFO csbi; if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi)) { int width = csbi.srWindow.Right - csbi.srWindow.Left + 1; int height = csbi.srWindow.Bottom - csbi.srWindow.Top + 1; if (height > 0) out_rows = height; if (width > 0) out_cols = width; } #endif if (rows) *rows = out_rows; if (cols) *cols = out_cols; } #ifndef _WIN32 static bool stdin_set_raw_mode(bool enable) { if (!stdin_is_tty()) return false; if (enable) { if (stdin_raw_mode) return true; if (tcgetattr(STDIN_FILENO, &stdin_saved_termios) == -1) return false; struct termios raw = stdin_saved_termios; raw.c_lflag &= ~(ICANON | ECHO | ISIG); raw.c_cc[VMIN] = 1; raw.c_cc[VTIME] = 0; if (tcsetattr(STDIN_FILENO, TCSANOW, &raw) == -1) return false; stdin_raw_mode = true; return true; } if (!stdin_raw_mode) return true; if (tcsetattr(STDIN_FILENO, TCSANOW, &stdin_saved_termios) == -1) return false; stdin_raw_mode = false; return true; } #else static bool stdin_set_raw_mode(bool enable) { (void)enable; return false; } #endif static void stdin_alloc_buffer(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf) { (void)handle; buf->base = malloc(suggested_size); buf->len = suggested_size; } static void on_stdin_read(uv_stream_t *stream, ssize_t nread, const uv_buf_t *buf) { (void)stream; if (nread > 0 && rt->js) { ArrayBufferData *ab = create_array_buffer_data((size_t)nread); if (ab) memcpy(ab->data, buf->base, (size_t)nread); jsval_t data_val = ab ? create_typed_array(rt->js, TYPED_ARRAY_UINT8, ab, 0, (size_t)nread, "Buffer") : js_mkstr(rt->js, buf->base, (size_t)nread); emit_stdio_event(&stdin_events, "data", &data_val, 1); if (stdin_state.keypress_enabled) process_keypress_data(rt->js, buf->base, (size_t)nread); } if (buf->base) free(buf->base); } static void stdin_start_reading(void) { if (stdin_state.reading) return; if (!stdin_state.tty_initialized) { uv_loop_t *loop = uv_default_loop(); if (uv_tty_init(loop, &stdin_state.tty, STDIN_FILENO, 1) != 0) return; #ifndef _WIN32 uv_tty_set_mode(&stdin_state.tty, stdin_raw_mode ? UV_TTY_MODE_RAW : UV_TTY_MODE_NORMAL); #endif stdin_state.tty.data = NULL; stdin_state.tty_initialized = true; } else { #ifndef _WIN32 uv_tty_set_mode(&stdin_state.tty, stdin_raw_mode ? UV_TTY_MODE_RAW : UV_TTY_MODE_NORMAL); #endif } stdin_state.reading = true; uv_read_start((uv_stream_t *)&stdin_state.tty, stdin_alloc_buffer, on_stdin_read); } static void stdin_stop_reading(void) { if (!stdin_state.reading) return; uv_read_stop((uv_stream_t *)&stdin_state.tty); stdin_state.reading = false; } #ifndef _WIN32 static void on_sigwinch(uv_signal_t *handle, int signum) { (void)handle; (void)signum; if (!rt->js) return; jsval_t process_obj = js_get(rt->js, js_glob(rt->js), "process"); if (!is_special_object(process_obj)) return; jsval_t stdout_obj = js_get(rt->js, process_obj, "stdout"); if (!is_special_object(stdout_obj)) return; int rows = 0, cols = 0; get_tty_size(STDOUT_FILENO, &rows, &cols); js_set(rt->js, stdout_obj, "rows", js_mknum(rows)); js_set(rt->js, stdout_obj, "columns", js_mknum(cols)); emit_stdio_event(&stdout_events, "resize", NULL, 0); } #endif static void start_sigwinch_handler(void) { #ifndef _WIN32 if (sigwinch_initialized) return; uv_loop_t *loop = uv_default_loop(); if (uv_signal_init(loop, &sigwinch_handle) != 0) return; if (uv_signal_start(&sigwinch_handle, on_sigwinch, SIGWINCH) != 0) { uv_close((uv_handle_t *)&sigwinch_handle, NULL); return; } uv_unref((uv_handle_t *)&sigwinch_handle); sigwinch_initialized = true; #endif } static jsval_t js_stdin_set_raw_mode(ant_t *js, jsval_t *args, int nargs) { bool enable = nargs > 0 ? js_truthy(js, args[0]) : true; return js_bool(stdin_set_raw_mode(enable)); } static jsval_t js_stdin_resume(ant_t *js, jsval_t *args, int nargs) { (void)args; (void)nargs; stdin_start_reading(); return js_getthis(js); } static jsval_t js_stdin_pause(ant_t *js, jsval_t *args, int nargs) { (void)args; (void)nargs; stdin_stop_reading(); return js_getthis(js); } static jsval_t js_stdin_on(ant_t *js, jsval_t *args, int nargs) { jsval_t this_obj = js_getthis(js); if (nargs < 2) return this_obj; char *event = js_getstr(js, args[0], NULL); if (!event || vtype(args[1]) != T_FUNC) return this_obj; ProcessEventType *evt = find_or_create_event(&stdin_events, event); if (!ensure_listener_capacity(evt)) return this_obj; evt->listeners[evt->listener_count].listener = args[1]; evt->listeners[evt->listener_count].once = false; evt->listener_count++; if (strcmp(event, "data") == 0) stdin_start_reading(); return this_obj; } static jsval_t js_stdin_remove_all_listeners(ant_t *js, jsval_t *args, int nargs) { jsval_t this_obj = js_getthis(js); if (nargs < 1) { ProcessEventType *evt, *tmp; HASH_ITER(hh, stdin_events, evt, tmp) { free_event_type(&stdin_events, evt); } stdin_stop_reading(); return this_obj; } char *event = js_getstr(js, args[0], NULL); if (!event) return this_obj; ProcessEventType *evt = NULL; HASH_FIND_STR(stdin_events, event, evt); if (evt) free_event_type(&stdin_events, evt); if (strcmp(event, "data") == 0) stdin_stop_reading(); return this_obj; } static jsval_t js_stdin_remove_listener(ant_t *js, jsval_t *args, int nargs) { jsval_t this_obj = js_getthis(js); if (nargs < 2) return this_obj; char *event = js_getstr(js, args[0], NULL); if (!event) return this_obj; bool now_empty = remove_listener_from_events(&stdin_events, event, args[1]); if (now_empty && strcmp(event, "data") == 0) stdin_stop_reading(); return this_obj; } static jsval_t js_stdout_write(ant_t *js, jsval_t *args, int nargs) { if (nargs < 1) return js_false; size_t len = 0; char *data = js_getstr(js, args[0], &len); if (!data) return js_false; fwrite(data, 1, len, stdout); fflush(stdout); return js_true; } static jsval_t js_stdout_on(ant_t *js, jsval_t *args, int nargs) { jsval_t this_obj = js_getthis(js); if (nargs < 2) return this_obj; char *event = js_getstr(js, args[0], NULL); if (!event || vtype(args[1]) != T_FUNC) return this_obj; ProcessEventType *evt = find_or_create_event(&stdout_events, event); if (!ensure_listener_capacity(evt)) return this_obj; evt->listeners[evt->listener_count].listener = args[1]; evt->listeners[evt->listener_count].once = false; evt->listener_count++; if (strcmp(event, "resize") == 0) start_sigwinch_handler(); return this_obj; } static jsval_t js_stdout_once(ant_t *js, jsval_t *args, int nargs) { jsval_t this_obj = js_getthis(js); if (nargs < 2) return this_obj; char *event = js_getstr(js, args[0], NULL); if (!event || vtype(args[1]) != T_FUNC) return this_obj; ProcessEventType *evt = find_or_create_event(&stdout_events, event); if (!ensure_listener_capacity(evt)) return this_obj; evt->listeners[evt->listener_count].listener = args[1]; evt->listeners[evt->listener_count].once = true; evt->listener_count++; if (strcmp(event, "resize") == 0) start_sigwinch_handler(); return this_obj; } static jsval_t js_stdout_remove_all_listeners(ant_t *js, jsval_t *args, int nargs) { jsval_t this_obj = js_getthis(js); if (nargs < 1) { ProcessEventType *evt, *tmp; HASH_ITER(hh, stdout_events, evt, tmp) { free_event_type(&stdout_events, evt); } return this_obj; } char *event = js_getstr(js, args[0], NULL); if (!event) return this_obj; ProcessEventType *evt = NULL; HASH_FIND_STR(stdout_events, event, evt); if (evt) free_event_type(&stdout_events, evt); return this_obj; } static jsval_t js_stdout_remove_listener(ant_t *js, jsval_t *args, int nargs) { jsval_t this_obj = js_getthis(js); if (nargs < 2) return this_obj; char *event = js_getstr(js, args[0], NULL); if (!event) return this_obj; remove_listener_from_events(&stdout_events, event, args[1]); return this_obj; } static jsval_t js_stdout_get_window_size(ant_t *js, jsval_t *args, int nargs) { (void)args; (void)nargs; int rows = 0, cols = 0; get_tty_size(STDOUT_FILENO, &rows, &cols); jsval_t arr = js_mkarr(js); js_arr_push(js, arr, js_mknum(cols)); js_arr_push(js, arr, js_mknum(rows)); return arr; } static jsval_t js_stdout_rows_getter(ant_t *js, jsval_t *args, int nargs) { (void)args; (void)nargs; int rows = 0, cols = 0; get_tty_size(STDOUT_FILENO, &rows, &cols); return js_mknum(rows); } static jsval_t js_stdout_columns_getter(ant_t *js, jsval_t *args, int nargs) { (void)args; (void)nargs; int rows = 0, cols = 0; get_tty_size(STDOUT_FILENO, &rows, &cols); return js_mknum(cols); } static jsval_t js_stderr_write(ant_t *js, jsval_t *args, int nargs) { if (nargs < 1) return js_false; size_t len = 0; char *data = js_getstr(js, args[0], &len); if (!data) return js_false; fwrite(data, 1, len, stderr); fflush(stderr); return js_true; } static jsval_t js_stderr_on(ant_t *js, jsval_t *args, int nargs) { jsval_t this_obj = js_getthis(js); if (nargs < 2) return this_obj; char *event = js_getstr(js, args[0], NULL); if (!event || vtype(args[1]) != T_FUNC) return this_obj; ProcessEventType *evt = find_or_create_event(&stderr_events, event); if (!ensure_listener_capacity(evt)) return this_obj; evt->listeners[evt->listener_count].listener = args[1]; evt->listeners[evt->listener_count].once = false; evt->listener_count++; return this_obj; } static jsval_t js_stderr_once(ant_t *js, jsval_t *args, int nargs) { jsval_t this_obj = js_getthis(js); if (nargs < 2) return this_obj; char *event = js_getstr(js, args[0], NULL); if (!event || vtype(args[1]) != T_FUNC) return this_obj; ProcessEventType *evt = find_or_create_event(&stderr_events, event); if (!ensure_listener_capacity(evt)) return this_obj; evt->listeners[evt->listener_count].listener = args[1]; evt->listeners[evt->listener_count].once = true; evt->listener_count++; return this_obj; } static jsval_t js_stderr_remove_all_listeners(ant_t *js, jsval_t *args, int nargs) { jsval_t this_obj = js_getthis(js); if (nargs < 1) { ProcessEventType *evt, *tmp; HASH_ITER(hh, stderr_events, evt, tmp) { free_event_type(&stderr_events, evt); } return this_obj; } char *event = js_getstr(js, args[0], NULL); if (!event) return this_obj; ProcessEventType *evt = NULL; HASH_FIND_STR(stderr_events, event, evt); if (evt) free_event_type(&stderr_events, evt); return this_obj; } static jsval_t js_stderr_remove_listener(ant_t *js, jsval_t *args, int nargs) { jsval_t this_obj = js_getthis(js); if (nargs < 2) return this_obj; char *event = js_getstr(js, args[0], NULL); if (!event) return this_obj; remove_listener_from_events(&stderr_events, event, args[1]); return this_obj; } static jsval_t process_uptime(ant_t *js, jsval_t *args, int nargs) { (void)args; (void)nargs; uint64_t now = uv_hrtime(); double seconds = (double)(now - process_start_time) / 1e9; return js_mknum(seconds); } static jsval_t process_hrtime(ant_t *js, jsval_t *args, int nargs) { uint64_t now = uv_hrtime(); if (nargs > 0 && vtype(args[0]) == T_ARR) { jsval_t prev_sec = js_get(js, args[0], "0"); jsval_t prev_nsec = js_get(js, args[0], "1"); if (vtype(prev_sec) == T_NUM && vtype(prev_nsec) == T_NUM) { uint64_t prev = (uint64_t)js_getnum(prev_sec) * 1000000000ULL + (uint64_t)js_getnum(prev_nsec); now = now - prev; } } jsval_t arr = js_mkarr(js); uint64_t secs = now / 1000000000ULL; uint64_t nsecs = now % 1000000000ULL; js_arr_push(js, arr, js_mknum((double)secs)); js_arr_push(js, arr, js_mknum((double)nsecs)); return arr; } static jsval_t process_hrtime_bigint(ant_t *js, jsval_t *args, int nargs) { (void)args; (void)nargs; uint64_t now = uv_hrtime(); char buf[32]; snprintf(buf, sizeof(buf), "%llu", (unsigned long long)now); return js_mkbigint(js, buf, strlen(buf), false); } static jsval_t process_memory_usage(ant_t *js, jsval_t *args, int nargs) { (void)args; (void)nargs; jsval_t obj = js_mkobj(js); size_t rss = 0; uv_resident_set_memory(&rss); js_set(js, obj, "rss", js_mknum((double)rss)); #ifdef _WIN32 PROCESS_MEMORY_COUNTERS_EX pmc; if (GetProcessMemoryInfo(GetCurrentProcess(), (PROCESS_MEMORY_COUNTERS*)&pmc, sizeof(pmc))) { js_set(js, obj, "heapTotal", js_mknum((double)pmc.WorkingSetSize)); js_set(js, obj, "heapUsed", js_mknum((double)pmc.PrivateUsage)); } else { js_set(js, obj, "heapTotal", js_mknum(0)); js_set(js, obj, "heapUsed", js_mknum(0)); } #else struct rusage usage; if (getrusage(RUSAGE_SELF, &usage) == 0) { js_set(js, obj, "heapTotal", js_mknum((double)rss)); js_set(js, obj, "heapUsed", js_mknum((double)rss)); } else { js_set(js, obj, "heapTotal", js_mknum(0)); js_set(js, obj, "heapUsed", js_mknum(0)); } #endif js_set(js, obj, "external", js_mknum(0)); js_set(js, obj, "arrayBuffers", js_mknum(0)); return obj; } static jsval_t process_memory_usage_rss(ant_t *js, jsval_t *args, int nargs) { (void)args; (void)nargs; size_t rss = 0; uv_resident_set_memory(&rss); return js_mknum((double)rss); } static jsval_t process_cpu_usage(ant_t *js, jsval_t *args, int nargs) { jsval_t obj = js_mkobj(js); uv_rusage_t rusage; if (uv_getrusage(&rusage) == 0) { int64_t user_usec = rusage.ru_utime.tv_sec * 1000000LL + rusage.ru_utime.tv_usec; int64_t sys_usec = rusage.ru_stime.tv_sec * 1000000LL + rusage.ru_stime.tv_usec; if (nargs > 0 && is_special_object(args[0])) { jsval_t prev_user = js_get(js, args[0], "user"); jsval_t prev_system = js_get(js, args[0], "system"); if (vtype(prev_user) == T_NUM) user_usec -= (int64_t)js_getnum(prev_user); if (vtype(prev_system) == T_NUM) sys_usec -= (int64_t)js_getnum(prev_system); } js_set(js, obj, "user", js_mknum((double)user_usec)); js_set(js, obj, "system", js_mknum((double)sys_usec)); } else { js_set(js, obj, "user", js_mknum(0)); js_set(js, obj, "system", js_mknum(0)); } return obj; } static jsval_t process_kill(ant_t *js, jsval_t *args, int nargs) { if (nargs < 1) return js_mkerr(js, "process.kill requires at least 1 argument"); if (vtype(args[0]) != T_NUM) return js_mkerr(js, "pid must be a number"); int pid = (int)js_getnum(args[0]); int sig = SIGTERM; if (nargs > 1) { if (vtype(args[1]) == T_NUM) { sig = (int)js_getnum(args[1]); } else if (vtype(args[1]) == T_STR) { char *sig_name = js_getstr(js, args[1], NULL); if (sig_name) { int signum = get_signal_number(sig_name); if (signum > 0) sig = signum; else return js_mkerr(js, "Unknown signal"); } } } int result = uv_kill(pid, sig); if (result != 0) return js_mkerr(js, "Failed to send signal"); return js_true; } static jsval_t process_abort(ant_t *js, jsval_t *args, int nargs) { (void)js; (void)args; (void)nargs; abort(); return js_mkundef(); } static jsval_t process_chdir(ant_t *js, jsval_t *args, int nargs) { if (nargs < 1) return js_mkerr(js, "process.chdir requires 1 argument"); char *dir = js_getstr(js, args[0], NULL); if (!dir) return js_mkerr(js, "directory must be a string"); int result = uv_chdir(dir); if (result != 0) return js_mkerr(js, "ENOENT: no such file or directory, chdir"); return js_mkundef(); } static jsval_t process_umask(ant_t *js, jsval_t *args, int nargs) { #ifdef _WIN32 (void)args; (void)nargs; return js_mknum(0); #else if (nargs > 0 && vtype(args[0]) == T_NUM) { int new_mask = (int)js_getnum(args[0]); int old_mask = umask((mode_t)new_mask); return js_mknum(old_mask); } int cur = umask(0); umask((mode_t)cur); return js_mknum(cur); #endif } #ifndef _WIN32 static jsval_t process_getuid(ant_t *js, jsval_t *args, int nargs) { (void)args; (void)nargs; return js_mknum((double)getuid()); } static jsval_t process_geteuid(ant_t *js, jsval_t *args, int nargs) { (void)args; (void)nargs; return js_mknum((double)geteuid()); } static jsval_t process_getgid(ant_t *js, jsval_t *args, int nargs) { (void)args; (void)nargs; return js_mknum((double)getgid()); } static jsval_t process_getegid(ant_t *js, jsval_t *args, int nargs) { (void)args; (void)nargs; return js_mknum((double)getegid()); } static jsval_t process_getgroups(ant_t *js, jsval_t *args, int nargs) { (void)args; (void)nargs; int ngroups = getgroups(0, NULL); if (ngroups < 0) return js_mkarr(js); gid_t *groups = malloc(sizeof(gid_t) * (size_t)ngroups); if (!groups) return js_mkarr(js); ngroups = getgroups(ngroups, groups); jsval_t arr = js_mkarr(js); for (int i = 0; i < ngroups; i++) { js_arr_push(js, arr, js_mknum((double)groups[i])); } free(groups); return arr; } static jsval_t process_setuid(ant_t *js, jsval_t *args, int nargs) { if (nargs < 1) return js_mkerr(js, "process.setuid requires 1 argument"); uid_t uid; if (vtype(args[0]) == T_NUM) { uid = (uid_t)js_getnum(args[0]); } else if (vtype(args[0]) == T_STR) { char *name = js_getstr(js, args[0], NULL); struct passwd *pwd = getpwnam(name); if (!pwd) return js_mkerr(js, "setuid user not found"); uid = pwd->pw_uid; } else { return js_mkerr(js, "uid must be a number or string"); } if (setuid(uid) != 0) return js_mkerr(js, "setuid failed"); return js_mkundef(); } static jsval_t process_setgid(ant_t *js, jsval_t *args, int nargs) { if (nargs < 1) return js_mkerr(js, "process.setgid requires 1 argument"); gid_t gid; if (vtype(args[0]) == T_NUM) { gid = (gid_t)js_getnum(args[0]); } else if (vtype(args[0]) == T_STR) { char *name = js_getstr(js, args[0], NULL); struct group *grp = getgrnam(name); if (!grp) return js_mkerr(js, "setgid group not found"); gid = grp->gr_gid; } else { return js_mkerr(js, "gid must be a number or string"); } if (setgid(gid) != 0) return js_mkerr(js, "setgid failed"); return js_mkundef(); } static jsval_t process_seteuid(ant_t *js, jsval_t *args, int nargs) { if (nargs < 1) return js_mkerr(js, "process.seteuid requires 1 argument"); uid_t uid; if (vtype(args[0]) == T_NUM) { uid = (uid_t)js_getnum(args[0]); } else if (vtype(args[0]) == T_STR) { char *name = js_getstr(js, args[0], NULL); struct passwd *pwd = getpwnam(name); if (!pwd) return js_mkerr(js, "seteuid user not found"); uid = pwd->pw_uid; } else { return js_mkerr(js, "uid must be a number or string"); } if (seteuid(uid) != 0) return js_mkerr(js, "seteuid failed"); return js_mkundef(); } static jsval_t process_setegid(ant_t *js, jsval_t *args, int nargs) { if (nargs < 1) return js_mkerr(js, "process.setegid requires 1 argument"); gid_t gid; if (vtype(args[0]) == T_NUM) { gid = (gid_t)js_getnum(args[0]); } else if (vtype(args[0]) == T_STR) { char *name = js_getstr(js, args[0], NULL); struct group *grp = getgrnam(name); if (!grp) return js_mkerr(js, "setegid group not found"); gid = grp->gr_gid; } else { return js_mkerr(js, "gid must be a number or string"); } if (setegid(gid) != 0) return js_mkerr(js, "setegid failed"); return js_mkundef(); } static jsval_t process_setgroups(ant_t *js, jsval_t *args, int nargs) { if (nargs < 1 || vtype(args[0]) != T_ARR) { return js_mkerr(js, "process.setgroups requires an array"); } jsval_t len_val = js_get(js, args[0], "length"); int len = (int)js_getnum(len_val); gid_t *groups = malloc(sizeof(gid_t) * (size_t)len); if (!groups) return js_mkerr(js, "allocation failed"); for (int i = 0; i < len; i++) { char idx[16]; snprintf(idx, sizeof(idx), "%d", i); jsval_t val = js_get(js, args[0], idx); if (vtype(val) == T_NUM) { groups[i] = (gid_t)js_getnum(val); } else if (vtype(val) == T_STR) { char *name = js_getstr(js, val, NULL); struct group *grp = getgrnam(name); if (!grp) { free(groups); return js_mkerr(js, "group not found"); } groups[i] = grp->gr_gid; } else { free(groups); return js_mkerr(js, "group id must be number or string"); } } if (setgroups(len, groups) != 0) { free(groups); return js_mkerr(js, "setgroups failed"); } free(groups); return js_mkundef(); } static jsval_t process_initgroups(ant_t *js, jsval_t *args, int nargs) { if (nargs < 2) return js_mkerr(js, "process.initgroups requires 2 arguments"); char *user = js_getstr(js, args[0], NULL); if (!user) return js_mkerr(js, "user must be a string"); gid_t gid; if (vtype(args[1]) == T_NUM) { gid = (gid_t)js_getnum(args[1]); } else if (vtype(args[1]) == T_STR) { char *name = js_getstr(js, args[1], NULL); struct group *grp = getgrnam(name); if (!grp) return js_mkerr(js, "group not found"); gid = grp->gr_gid; } else { return js_mkerr(js, "gid must be a number or string"); } if (initgroups(user, gid) != 0) return js_mkerr(js, "initgroups failed"); return js_mkundef(); } #endif static jsval_t env_getter(ant_t *js, jsval_t obj, const char *key, size_t key_len) { CSTR_BUF(buf, 256); char *key_str = CSTR_INIT(buf, key, key_len); if (!key_str) return js_mkundef(); char *value = getenv(key_str); cstr_free(&buf); if (value == NULL) return js_mkundef(); return js_mkstr(js, value, strlen(value)); } static bool env_setter(ant_t *js, jsval_t obj, const char *key, size_t key_len, jsval_t value) { jsval_t str_val = coerce_to_str(js, value); if (is_err(str_val)) return false; setprop_cstr(js, obj, key, key_len, str_val); CSTR_BUF(buf, 256); char *key_str = CSTR_INIT(buf, key, key_len); if (key_str) { size_t val_len; char *val_str = js_getstr(js, str_val, &val_len); if (val_str) setenv(key_str, val_str, 1); cstr_free(&buf); } return true; } static bool env_deleter(ant_t *js, jsval_t obj, const char *key, size_t key_len) { CSTR_BUF(buf, 256); char *key_str = CSTR_INIT(buf, key, key_len); if (key_str) { unsetenv(key_str); cstr_free(&buf); } return true; } static void load_dotenv_file(ant_t *js, jsval_t env_obj) { FILE *fp = fopen(".env", "r"); if (fp == NULL) return; char line[1024]; while (fgets(line, sizeof(line), fp) != NULL) { size_t len = strlen(line); if (len > 0 && line[len - 1] == '\n') { line[len - 1] = '\0'; len--; } if (len > 0 && line[len - 1] == '\r') { line[len - 1] = '\0'; len--; } if (len == 0 || line[0] == '#') continue; char *equals = strchr(line, '='); if (equals == NULL) continue; *equals = '\0'; char *key = line; char *value = equals + 1; while (*key == ' ' || *key == '\t') key++; char *key_end = key + strlen(key) - 1; while (key_end > key && (*key_end == ' ' || *key_end == '\t')) { *key_end = '\0'; key_end--; } while (*value == ' ' || *value == '\t') value++; char *value_end = value + strlen(value) - 1; while (value_end > value && (*value_end == ' ' || *value_end == '\t')) { *value_end = '\0'; value_end--; } if (strlen(value) >= 2 && ((value[0] == '"' && value[strlen(value) - 1] == '"') || (value[0] == '\'' && value[strlen(value) - 1] == '\''))) { value[strlen(value) - 1] = '\0'; value++; } js_set(js, env_obj, key, js_mkstr(js, value, strlen(value))); } fclose(fp); } static jsval_t process_exit(ant_t *js, jsval_t *args, int nargs) { int code = 0; if (nargs > 0 && vtype(args[0]) == T_NUM) { code = (int)js_getnum(args[0]); } exit(code); return js_mkundef(); } typedef struct { char *buf; size_t pos; size_t cap; } env_str_ctx; typedef void (*env_iter_cb)( ant_t *js, const char *key, size_t key_len, const char *value, size_t val_len, void *ctx ); static void env_foreach(ant_t *js, jsval_t env_obj, env_iter_cb cb, void *ctx) { for (char **env = environ; *env != NULL; env++) { char *entry = *env; char *equals = strchr(entry, '='); if (equals == NULL) continue; size_t key_len = (size_t)(equals - entry); char *value = equals + 1; cb(js, entry, key_len, value, strlen(value), ctx); } ant_iter_t iter = js_prop_iter_begin(js, env_obj); const char *key; size_t key_len; jsval_t value; while (js_prop_iter_next(&iter, &key, &key_len, &value)) { if (key_len >= 2 && key[0] == '_' && key[1] == '_') continue; if (vtype(value) != T_STR) continue; CSTR_BUF(buf, 256); char *key_str = CSTR_INIT(buf, key, key_len); if (!key_str) continue; if (getenv(key_str)) { cstr_free(&buf); continue; } cstr_free(&buf); size_t val_len; char *val_str = js_getstr(js, value, &val_len); cb(js, key, key_len, val_str ? val_str : "", val_str ? val_len : 0, ctx); } js_prop_iter_end(&iter); } static void env_to_object_cb(ant_t *js, const char *key, size_t key_len, const char *value, size_t val_len, void *ctx) { jsval_t obj = *(jsval_t *)ctx; CSTR_BUF(buf, 256); char *key_str = CSTR_INIT(buf, key, key_len); if (!key_str) return; js_set(js, obj, key_str, js_mkstr(js, value, val_len)); cstr_free(&buf); } static jsval_t env_to_object(ant_t *js, jsval_t *args, int nargs) { jsval_t obj = js_mkobj(js); env_foreach(js, js->this_val, env_to_object_cb, &obj); return obj; } static void env_tostring_cb(ant_t *js, const char *key, size_t key_len, const char *value, size_t val_len, void *ctx) { env_str_ctx *c = ctx; size_t entry_len = key_len + 1 + val_len; if (c->pos + entry_len + 2 >= c->cap) { size_t new_cap = c->cap * 2 + entry_len; char *new_buf = realloc(c->buf, new_cap); if (!new_buf) return; c->buf = new_buf; c->cap = new_cap; } if (c->pos > 0) c->buf[c->pos++] = '\n'; memcpy(c->buf + c->pos, key, key_len); c->pos += key_len; c->buf[c->pos++] = '='; memcpy(c->buf + c->pos, value, val_len); c->pos += val_len; } static jsval_t env_toString(ant_t *js, jsval_t *args, int nargs) { env_str_ctx ctx = { .buf = malloc(4096), .pos = 0, .cap = 4096 }; if (!ctx.buf) return js_mkstr(js, "", 0); env_foreach(js, js->this_val, env_tostring_cb, &ctx); ctx.buf[ctx.pos] = '\0'; jsval_t ret = js_mkstr(js, ctx.buf, ctx.pos); free(ctx.buf); return ret; } static void env_keys_cb(ant_t *js, const char *key, size_t key_len, const char *value, size_t val_len, void *ctx) { jsval_t arr = *(jsval_t *)ctx; js_arr_push(js, arr, js_mkstr(js, key, key_len)); } static jsval_t env_keys(ant_t *js, jsval_t obj) { jsval_t arr = js_mkarr(js); env_foreach(js, obj, env_keys_cb, &arr); return arr; } static jsval_t process_cwd(ant_t *js, jsval_t *args, int nargs) { char cwd[4096]; if (getcwd(cwd, sizeof(cwd)) != NULL) { return js_mkstr(js, cwd, strlen(cwd)); } return js_mkundef(); } static jsval_t process_on(ant_t *js, jsval_t *args, int nargs) { if (nargs < 2) return js_mkerr(js, "process.on requires 2 arguments"); char *event = js_getstr(js, args[0], NULL); if (!event) return js_mkerr(js, "event must be a string"); if (vtype(args[1]) != T_FUNC) return js_mkerr(js, "listener must be a function"); int signum = get_signal_number(event); if (signum > 0) { signal(signum, process_signal_handler); } ProcessEventType *evt = find_or_create_event(&process_events, event); if (!ensure_listener_capacity(evt)) { return js_mkerr(js, "failed to allocate listener"); } evt->listeners[evt->listener_count].listener = args[1]; evt->listeners[evt->listener_count].once = false; evt->listener_count++; check_listener_warning(event); return js_get(js, js_glob(js), "process"); } static jsval_t process_once(ant_t *js, jsval_t *args, int nargs) { if (nargs < 2) return js_mkerr(js, "process.once requires 2 arguments"); char *event = js_getstr(js, args[0], NULL); if (!event) return js_mkerr(js, "event must be a string"); if (vtype(args[1]) != T_FUNC) return js_mkerr(js, "listener must be a function"); int signum = get_signal_number(event); if (signum > 0) { signal(signum, process_signal_handler); } ProcessEventType *evt = find_or_create_event(&process_events, event); if (!ensure_listener_capacity(evt)) { return js_mkerr(js, "failed to allocate listener"); } evt->listeners[evt->listener_count].listener = args[1]; evt->listeners[evt->listener_count].once = true; evt->listener_count++; check_listener_warning(event); return js_get(js, js_glob(js), "process"); } static jsval_t process_off(ant_t *js, jsval_t *args, int nargs) { jsval_t process_obj = js_get(js, js_glob(js), "process"); if (nargs < 2) return process_obj; char *event = js_getstr(js, args[0], NULL); if (!event) return process_obj; ProcessEventType *evt = NULL; HASH_FIND_STR(process_events, event, evt); if (!evt) return process_obj; for (int i = 0; i < evt->listener_count; i++) { if (evt->listeners[i].listener == args[1]) { for (int j = i; j < evt->listener_count - 1; j++) { evt->listeners[j] = evt->listeners[j + 1]; } evt->listener_count--; break; } } if (evt->listener_count == 0) { int signum = get_signal_number(event); if (signum > 0) signal(signum, SIG_DFL); } return process_obj; } static jsval_t process_remove_all_listeners(ant_t *js, jsval_t *args, int nargs) { jsval_t process_obj = js_get(js, js_glob(js), "process"); if (nargs > 0 && vtype(args[0]) == T_STR) { char *event = js_getstr(js, args[0], NULL); if (event) { ProcessEventType *evt = NULL; HASH_FIND_STR(process_events, event, evt); if (evt) { int signum = get_signal_number(event); if (signum > 0) signal(signum, SIG_DFL); free_event_type(&process_events, evt); } } } else { ProcessEventType *evt, *tmp; HASH_ITER(hh, process_events, evt, tmp) { int signum = get_signal_number(evt->event_type); if (signum > 0) signal(signum, SIG_DFL); free_event_type(&process_events, evt); } } return process_obj; } static jsval_t process_emit(ant_t *js, jsval_t *args, int nargs) { if (nargs < 1) return js_false; char *event = js_getstr(js, args[0], NULL); if (!event) return js_false; emit_process_event(event, nargs > 1 ? &args[1] : NULL, nargs - 1); return js_true; } static jsval_t process_listener_count(ant_t *js, jsval_t *args, int nargs) { if (nargs < 1) return js_mknum(0); char *event = js_getstr(js, args[0], NULL); if (!event) return js_mknum(0); ProcessEventType *evt = NULL; HASH_FIND_STR(process_events, event, evt); return js_mknum(evt ? evt->listener_count : 0); } static jsval_t process_set_max_listeners(ant_t *js, jsval_t *args, int nargs) { if (nargs < 1) return js_mkerr(js, "setMaxListeners requires 1 argument"); if (vtype(args[0]) != T_NUM) return js_mkerr(js, "n must be a number"); int n = (int)js_getnum(args[0]); if (n < 0) return js_mkerr(js, "n must be non-negative"); max_listeners = n; return js_get(js, js_glob(js), "process"); } static jsval_t process_get_max_listeners(ant_t *js, jsval_t *args, int nargs) { return js_mknum(max_listeners); } jsval_t process_library(ant_t *js) { return js_get(js, js_glob(js), "process"); } void init_process_module() { ant_t *js = rt->js; jsval_t global = js_glob(js); process_start_time = uv_hrtime(); jsval_t process_proto = js_mkobj(js); js_set(js, process_proto, "exit", js_mkfun(process_exit)); js_set(js, process_proto, "on", js_mkfun(process_on)); js_set(js, process_proto, "addListener", js_mkfun(process_on)); js_set(js, process_proto, "once", js_mkfun(process_once)); js_set(js, process_proto, "off", js_mkfun(process_off)); js_set(js, process_proto, "removeListener", js_mkfun(process_off)); js_set(js, process_proto, "removeAllListeners", js_mkfun(process_remove_all_listeners)); js_set(js, process_proto, "emit", js_mkfun(process_emit)); js_set(js, process_proto, "listenerCount", js_mkfun(process_listener_count)); js_set(js, process_proto, "setMaxListeners", js_mkfun(process_set_max_listeners)); js_set(js, process_proto, "getMaxListeners", js_mkfun(process_get_max_listeners)); js_set(js, process_proto, "cwd", js_mkfun(process_cwd)); js_set(js, process_proto, "chdir", js_mkfun(process_chdir)); js_set(js, process_proto, "uptime", js_mkfun(process_uptime)); js_set(js, process_proto, "cpuUsage", js_mkfun(process_cpu_usage)); js_set(js, process_proto, "kill", js_mkfun(process_kill)); js_set(js, process_proto, "abort", js_mkfun(process_abort)); js_set(js, process_proto, "umask", js_mkfun(process_umask)); jsval_t mem_usage_fn = js_heavy_mkfun(js, process_memory_usage, js_mkundef()); js_set(js, mem_usage_fn, "rss", js_mkfun(process_memory_usage_rss)); js_set(js, process_proto, "memoryUsage", mem_usage_fn); jsval_t hrtime_fn = js_heavy_mkfun(js, process_hrtime, js_mkundef()); js_set(js, hrtime_fn, "bigint", js_mkfun(process_hrtime_bigint)); js_set(js, process_proto, "hrtime", hrtime_fn); js_set(js, process_proto, "dlopen", js_mkfun(napi_process_dlopen_js)); #ifndef _WIN32 js_set(js, process_proto, "getuid", js_mkfun(process_getuid)); js_set(js, process_proto, "geteuid", js_mkfun(process_geteuid)); js_set(js, process_proto, "getgid", js_mkfun(process_getgid)); js_set(js, process_proto, "getegid", js_mkfun(process_getegid)); js_set(js, process_proto, "getgroups", js_mkfun(process_getgroups)); js_set(js, process_proto, "setuid", js_mkfun(process_setuid)); js_set(js, process_proto, "setgid", js_mkfun(process_setgid)); js_set(js, process_proto, "seteuid", js_mkfun(process_seteuid)); js_set(js, process_proto, "setegid", js_mkfun(process_setegid)); js_set(js, process_proto, "setgroups", js_mkfun(process_setgroups)); js_set(js, process_proto, "initgroups", js_mkfun(process_initgroups)); #endif js_set_sym(js, process_proto, get_toStringTag_sym(), js_mkstr(js, "process", 7)); jsval_t process_obj = js_mkobj(js); jsval_t env_obj = js_mkobj(js); js_set_proto(js, process_obj, process_proto); load_dotenv_file(js, env_obj); js_set_keys(js, env_obj, env_keys); js_set_getter(js, env_obj, env_getter); js_set_setter(js, env_obj, env_setter); js_set_deleter(js, env_obj, env_deleter); js_set(js, env_obj, "toObject", js_mkfun(env_to_object)); js_set(js, env_obj, "toString", js_mkfun(env_toString)); js_set(js, process_obj, "env", env_obj); jsval_t argv_arr = js_mkarr(js); for (int i = 0; i < rt->argc; i++) { js_arr_push(js, argv_arr, js_mkstr(js, rt->argv[i], strlen(rt->argv[i]))); } js_set(js, process_obj, "argv", argv_arr); js_set(js, process_obj, "execArgv", js_mkarr(js)); js_set(js, process_obj, "argv0", rt->argc > 0 ? js_mkstr(js, rt->argv[0], strlen(rt->argv[0])) : js_mkstr(js, "ant", 3)); js_set(js, process_obj, "execPath", rt->argc > 0 ? js_mkstr(js, rt->argv[0], strlen(rt->argv[0])) : js_mkundef()); js_set(js, process_obj, "pid", js_mknum((double)getpid())); js_set(js, process_obj, "ppid", js_mknum((double)getppid())); char version_str[128]; snprintf(version_str, sizeof(version_str), "v%s", ANT_VERSION); js_set(js, process_obj, "version", js_mkstr(js, version_str, strlen(version_str))); jsval_t versions_obj = js_mkobj(js); js_set(js, versions_obj, "ant", js_mkstr(js, ANT_VERSION, strlen(ANT_VERSION))); char uv_ver[32]; snprintf(uv_ver, sizeof(uv_ver), "%d.%d.%d", UV_VERSION_MAJOR, UV_VERSION_MINOR, UV_VERSION_PATCH); js_set(js, versions_obj, "uv", js_mkstr(js, uv_ver, strlen(uv_ver))); js_set(js, process_obj, "versions", versions_obj); jsval_t release_obj = js_mkobj(js); js_set(js, release_obj, "name", js_mkstr(js, "ant", 3)); js_set(js, process_obj, "release", release_obj); // process.platform #if defined(__APPLE__) js_set(js, process_obj, "platform", js_mkstr(js, "darwin", 6)); #elif defined(__linux__) js_set(js, process_obj, "platform", js_mkstr(js, "linux", 5)); #elif defined(_WIN32) || defined(_WIN64) js_set(js, process_obj, "platform", js_mkstr(js, "win32", 5)); #elif defined(__FreeBSD__) js_set(js, process_obj, "platform", js_mkstr(js, "freebsd", 7)); #else js_set(js, process_obj, "platform", js_mkstr(js, "unknown", 7)); #endif // process.arch #if defined(__x86_64__) || defined(_M_X64) js_set(js, process_obj, "arch", js_mkstr(js, "x64", 3)); #elif defined(__i386__) || defined(_M_IX86) js_set(js, process_obj, "arch", js_mkstr(js, "ia32", 4)); #elif defined(__aarch64__) || defined(_M_ARM64) js_set(js, process_obj, "arch", js_mkstr(js, "arm64", 5)); #elif defined(__arm__) || defined(_M_ARM) js_set(js, process_obj, "arch", js_mkstr(js, "arm", 3)); #else js_set(js, process_obj, "arch", js_mkstr(js, "unknown", 7)); #endif jsval_t stdin_proto = js_mkobj(js); js_set(js, stdin_proto, "setRawMode", js_mkfun(js_stdin_set_raw_mode)); js_set(js, stdin_proto, "resume", js_mkfun(js_stdin_resume)); js_set(js, stdin_proto, "pause", js_mkfun(js_stdin_pause)); js_set(js, stdin_proto, "on", js_mkfun(js_stdin_on)); js_set(js, stdin_proto, "removeListener", js_mkfun(js_stdin_remove_listener)); js_set(js, stdin_proto, "off", js_mkfun(js_stdin_remove_listener)); js_set(js, stdin_proto, "removeAllListeners", js_mkfun(js_stdin_remove_all_listeners)); js_set_sym(js, stdin_proto, get_toStringTag_sym(), js_mkstr(js, "ReadStream", 10)); jsval_t stdin_obj = js_mkobj(js); js_set_proto(js, stdin_obj, stdin_proto); js_set(js, stdin_obj, "isTTY", js_bool(stdin_is_tty())); js_set(js, process_obj, "stdin", stdin_obj); jsval_t stdout_proto = js_mkobj(js); js_set(js, stdout_proto, "write", js_mkfun(js_stdout_write)); js_set(js, stdout_proto, "on", js_mkfun(js_stdout_on)); js_set(js, stdout_proto, "once", js_mkfun(js_stdout_once)); js_set(js, stdout_proto, "removeListener", js_mkfun(js_stdout_remove_listener)); js_set(js, stdout_proto, "off", js_mkfun(js_stdout_remove_listener)); js_set(js, stdout_proto, "removeAllListeners", js_mkfun(js_stdout_remove_all_listeners)); js_set(js, stdout_proto, "getWindowSize", js_mkfun(js_stdout_get_window_size)); js_set_sym(js, stdout_proto, get_toStringTag_sym(), js_mkstr(js, "WriteStream", 11)); jsval_t stdout_obj = js_mkobj(js); js_set_proto(js, stdout_obj, stdout_proto); js_set(js, stdout_obj, "isTTY", js_bool(stdout_is_tty())); js_set_getter_desc(js, stdout_obj, "rows", 4, js_mkfun(js_stdout_rows_getter), JS_DESC_E | JS_DESC_C); js_set_getter_desc(js, stdout_obj, "columns", 7, js_mkfun(js_stdout_columns_getter), JS_DESC_E | JS_DESC_C); js_set(js, process_obj, "stdout", stdout_obj); jsval_t stderr_proto = js_mkobj(js); js_set(js, stderr_proto, "write", js_mkfun(js_stderr_write)); js_set(js, stderr_proto, "on", js_mkfun(js_stderr_on)); js_set(js, stderr_proto, "once", js_mkfun(js_stderr_once)); js_set(js, stderr_proto, "removeListener", js_mkfun(js_stderr_remove_listener)); js_set(js, stderr_proto, "off", js_mkfun(js_stderr_remove_listener)); js_set(js, stderr_proto, "removeAllListeners", js_mkfun(js_stderr_remove_all_listeners)); js_set_sym(js, stderr_proto, get_toStringTag_sym(), js_mkstr(js, "WriteStream", 11)); jsval_t stderr_obj = js_mkobj(js); js_set_proto(js, stderr_obj, stderr_proto); js_set(js, stderr_obj, "isTTY", js_bool(stderr_is_tty())); js_set(js, process_obj, "stderr", stderr_obj); js_set(js, global, "process", process_obj); } #define GC_OP_EVENTS(events) do { \ ProcessEventType *evt, *tmp; \ HASH_ITER(hh, events, evt, tmp) { \ for (int i = 0; i < evt->listener_count; i++) \ op_val(ctx, &evt->listeners[i].listener); \ } \ } while(0) void process_gc_update_roots(GC_OP_VAL_ARGS) { GC_OP_EVENTS(process_events); GC_OP_EVENTS(stdin_events); GC_OP_EVENTS(stdout_events); GC_OP_EVENTS(stderr_events); } #undef GC_OP_EVENTS bool has_active_stdin(void) { return stdin_state.reading; } void process_enable_keypress_events(void) { stdin_state.keypress_enabled = true; stdin_state.escape_state = 0; stdin_state.escape_len = 0; }