#include // IWYU pragma: keep #include #include #include #include #include #include #include #ifdef _WIN32 #include #define WIN32_LEAN_AND_MEAN #include #define ANT_ISATTY _isatty #define ANT_STDIN_FD 0 #define ANT_STDOUT_FD 1 #define ANT_STDERR_FD 2 #else #include #include #include #include #define ANT_ISATTY isatty #define ANT_STDIN_FD STDIN_FILENO #define ANT_STDOUT_FD STDOUT_FILENO #define ANT_STDERR_FD STDERR_FILENO #endif #include "ant.h" #include "gc/roots.h" #include "descriptors.h" #include "errors.h" #include "internal.h" #include "runtime.h" #include "tty_ctrl.h" #include "silver/engine.h" #include "modules/stream.h" #include "modules/buffer.h" #include "modules/events.h" #include "modules/symbol.h" #include "modules/tty.h" static ant_value_t g_tty_readstream_proto = 0; static ant_value_t g_tty_readstream_ctor = 0; static ant_value_t g_tty_writestream_proto = 0; static ant_value_t g_tty_writestream_ctor = 0; typedef struct tty_read_stream_state { ant_t *js; ant_value_t stream_obj; uv_tty_t tty; int fd; bool initialized; bool reading; bool closing; } tty_read_stream_state_t; static void invoke_callback_if_needed(ant_t *js, ant_value_t cb, ant_value_t arg) { if (!is_callable(cb)) return; ant_value_t cb_args[1] = { arg }; sv_vm_call(js->vm, js, cb, js_mkundef(), cb_args, 1, NULL, false); } static bool parse_fd(ant_value_t value, int *fd_out) { int fd = 0; if (!tty_ctrl_parse_int_value(value, &fd)) return false; if (fd < 0) return false; *fd_out = fd; return true; } static bool is_tty_fd(int fd) { if (fd < 0) return false; return uv_guess_handle(fd) == UV_TTY; } static int stream_fd_from_this(ant_t *js, int fallback_fd) { ant_value_t this_obj = js_getthis(js); if (!is_special_object(this_obj)) return fallback_fd; ant_value_t fd_val = js_get(js, this_obj, "fd"); int fd = 0; if (!parse_fd(fd_val, &fd)) return fallback_fd; return fd; } static tty_read_stream_state_t *tty_read_stream_state_from_obj(ant_value_t stream_obj) { return (tty_read_stream_state_t *)stream_get_attached_state(stream_obj); } static ant_value_t make_stream_error(ant_t *js, const char *op, int fd, int uv_code) { if (uv_code != 0) return js_mkerr_typed( js, JS_ERR_GENERIC, "tty stream %s failed for fd %d: %s", op, fd, uv_strerror(uv_code) ); return js_mkerr_typed(js, JS_ERR_GENERIC, "tty stream %s failed for fd %d", op, fd); } static void tty_read_stream_emit_error(tty_read_stream_state_t *state, const char *op, int uv_code) { ant_value_t err = 0; if (!state || !state->js || !is_object_type(state->stream_obj)) return; err = make_stream_error(state->js, op, state->fd, uv_code); eventemitter_emit_args(state->js, state->stream_obj, "error", &err, 1); } static void tty_read_stream_push_chunk(tty_read_stream_state_t *state, const char *data, size_t len) { ArrayBufferData *ab = NULL; ant_value_t chunk = 0; if (!state || !state->js || !data || len == 0) return; ab = create_array_buffer_data(len); if (ab) memcpy(ab->data, data, len); chunk = ab ? create_typed_array(state->js, TYPED_ARRAY_UINT8, ab, 0, len, "Buffer") : js_mkstr(state->js, data, len); (void)stream_readable_push(state->js, state->stream_obj, chunk, js_mkundef()); } static void tty_read_stream_alloc_buffer(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf) { buf->base = malloc(suggested_size); #ifdef _WIN32 buf->len = (ULONG)suggested_size; #else buf->len = suggested_size; #endif } static void tty_read_stream_stop(tty_read_stream_state_t *state) { if (!state || !state->initialized || !state->reading) return; uv_read_stop((uv_stream_t *)&state->tty); state->reading = false; } static void tty_read_stream_close_cb(uv_handle_t *handle) { tty_read_stream_state_t *state = (tty_read_stream_state_t *)handle->data; free(state); } static void tty_read_stream_finalize(ant_t *js, ant_value_t stream_obj, void *data) { tty_read_stream_state_t *state = (tty_read_stream_state_t *)data; if (!state) return; tty_read_stream_stop(state); if (state->initialized && !state->closing) { state->closing = true; uv_close((uv_handle_t *)&state->tty, tty_read_stream_close_cb); return; } if (!state->initialized) free(state); } static void tty_read_stream_on_read(uv_stream_t *stream, ssize_t nread, const uv_buf_t *buf) { tty_read_stream_state_t *state = (tty_read_stream_state_t *)stream->data; if (!state || !state->js) goto cleanup; if (nread > 0) { tty_read_stream_push_chunk(state, buf->base, (size_t)nread); goto cleanup; } if (nread == UV_EOF) { tty_read_stream_stop(state); (void)stream_readable_push(state->js, state->stream_obj, js_mknull(), js_mkundef()); goto cleanup; } if (nread < 0) { tty_read_stream_stop(state); tty_read_stream_emit_error(state, "read", (int)nread); } cleanup: if (buf->base) free(buf->base); } static ant_value_t tty_readstream__read(ant_t *js, ant_value_t *args, int nargs) { ant_value_t stream_obj = js_getthis(js); tty_read_stream_state_t *state = tty_read_stream_state_from_obj(stream_obj); int rc = 0; if (!state) return js_mkundef(); if (state->closing || js_truthy(js, js_get(js, stream_obj, "destroyed"))) return js_mkundef(); if (!state->initialized) { rc = uv_tty_init(uv_default_loop(), &state->tty, state->fd, 0); if (rc != 0) { tty_read_stream_emit_error(state, "open", rc); return js_mkundef(); } state->tty.data = state; state->initialized = true; } if (state->reading) return js_mkundef(); rc = uv_read_start((uv_stream_t *)&state->tty, tty_read_stream_alloc_buffer, tty_read_stream_on_read); if (rc != 0) { tty_read_stream_emit_error(state, "read", rc); return js_mkundef(); } state->reading = true; return js_mkundef(); } static ant_value_t tty_readstream__destroy(ant_t *js, ant_value_t *args, int nargs) { ant_value_t stream_obj = js_getthis(js); tty_read_stream_state_t *state = tty_read_stream_state_from_obj(stream_obj); ant_value_t cb = nargs > 1 ? args[1] : js_mkundef(); if (!state) { invoke_callback_if_needed(js, cb, js_mknull()); return js_mkundef(); } tty_read_stream_stop(state); stream_clear_attached_state(stream_obj); if (state->initialized && !state->closing) { state->closing = true; uv_close((uv_handle_t *)&state->tty, tty_read_stream_close_cb); } else if (!state->initialized) free(state); invoke_callback_if_needed(js, cb, js_mknull()); return js_mkundef(); } static void get_tty_size(int fd, int *rows, int *cols) { int out_rows = 24; int out_cols = 80; #ifdef _WIN32 HANDLE handle = INVALID_HANDLE_VALUE; if (fd == ANT_STDOUT_FD) { handle = GetStdHandle(STD_OUTPUT_HANDLE); } else if (fd == ANT_STDERR_FD) { handle = GetStdHandle(STD_ERROR_HANDLE); } else { intptr_t os_handle = _get_osfhandle(fd); if (os_handle != -1) handle = (HANDLE)os_handle; } if (handle != INVALID_HANDLE_VALUE) { CONSOLE_SCREEN_BUFFER_INFO csbi; if (GetConsoleScreenBufferInfo(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; } } #else struct winsize ws; if (ioctl(fd, TIOCGWINSZ, &ws) == 0) { if (ws.ws_row > 0) out_rows = (int)ws.ws_row; if (ws.ws_col > 0) out_cols = (int)ws.ws_col; } #endif if (rows) *rows = out_rows; if (cols) *cols = out_cols; } static bool str_case_eq(const char *a, const char *b) { if (!a || !b) return false; while (*a && *b) { int ca = tolower((unsigned char)*a); int cb = tolower((unsigned char)*b); if (ca != cb) return false; a++; b++; } return *a == '\0' && *b == '\0'; } static bool str_case_contains(const char *haystack, const char *needle) { if (!haystack || !needle) return false; size_t needle_len = strlen(needle); if (needle_len == 0) return true; size_t hay_len = strlen(haystack); if (needle_len > hay_len) return false; for (size_t i = 0; i + needle_len <= hay_len; i++) { bool match = true; for (size_t j = 0; j < needle_len; j++) { int ca = tolower((unsigned char)haystack[i + j]); int cb = tolower((unsigned char)needle[j]); if (ca != cb) { match = false; break; } } if (match) return true; } return false; } static bool read_env_object_value( ant_t *js, ant_value_t env_obj, const char *key, char *buf, size_t buf_len ) { if (!is_special_object(env_obj) || !key || !buf || buf_len == 0) return false; ant_value_t value = js_get(js, env_obj, key); if (vtype(value) == T_UNDEF || vtype(value) == T_NULL) return false; ant_value_t str_val = js_tostring_val(js, value); size_t len = 0; char *str = js_getstr(js, str_val, &len); if (!str) return false; if (len >= buf_len) len = buf_len - 1; memcpy(buf, str, len); buf[len] = '\0'; return true; } static const char *get_env_value( ant_t *js, ant_value_t env_obj, const char *key, char *buf, size_t buf_len ) { if (read_env_object_value(js, env_obj, key, buf, buf_len)) return buf; return getenv(key); } static int force_color_depth(const char *force_color) { if (!force_color) return 0; if (*force_color == '\0') return 4; if (strcmp(force_color, "0") == 0) return 1; if (strcmp(force_color, "1") == 0) return 4; if (strcmp(force_color, "2") == 0) return 8; if (strcmp(force_color, "3") == 0) return 24; return 4; } static int detect_color_depth(ant_t *js, int fd, ant_value_t env_obj) { char scratch[128]; const char *force_color = get_env_value(js, env_obj, "FORCE_COLOR", scratch, sizeof(scratch)); int forced = force_color_depth(force_color); if (forced > 0) return forced; const char *no_color = get_env_value(js, env_obj, "NO_COLOR", scratch, sizeof(scratch)); if (no_color && *no_color) return 1; if (!is_tty_fd(fd)) return 1; const char *colorterm = get_env_value(js, env_obj, "COLORTERM", scratch, sizeof(scratch)); if (colorterm) { if (str_case_contains(colorterm, "truecolor") || str_case_contains(colorterm, "24bit")) return 24; } #ifdef _WIN32 return 24; #else const char *term = get_env_value(js, env_obj, "TERM", scratch, sizeof(scratch)); if (!term) return 4; if (str_case_eq(term, "dumb")) return 1; if (str_case_contains(term, "256color")) return 8; if (str_case_contains(term, "color") || str_case_contains(term, "xterm") || str_case_contains(term, "screen") || str_case_contains(term, "ansi") || str_case_contains(term, "linux") || str_case_contains(term, "cygwin") || str_case_contains(term, "vt100") ) return 4; return 4; #endif } static int palette_size_for_depth(int depth) { switch (depth) { case 1: return 2; case 4: return 16; case 8: return 256; case 24: return 16777216; default: return 2; } } static ant_value_t maybe_callback_or_throw( ant_t *js, ant_value_t this_obj, ant_value_t cb, bool ok, const char *op, int fd ) { if (is_callable(cb)) { if (ok) invoke_callback_if_needed(js, cb, js_mknull()); else { ant_value_t err = make_stream_error(js, op, fd, 0); invoke_callback_if_needed(js, cb, err); } return this_obj; } if (!ok) return make_stream_error(js, op, fd, 0); return this_obj; } #ifndef _WIN32 static struct { int fd; bool active; struct termios saved; } raw_state = { .fd = -1, .active = false }; static int tty_tcsetattr_no_sigtou(int fd, int optional_actions, const struct termios *tio) { #ifdef SIGTTOU sigset_t block_set; sigset_t prev_set; if (sigemptyset(&block_set) == 0 && sigaddset(&block_set, SIGTTOU) == 0 && sigprocmask(SIG_BLOCK, &block_set, &prev_set) == 0) { int rc = tcsetattr(fd, optional_actions, tio); int saved_errno = errno; sigprocmask(SIG_SETMASK, &prev_set, NULL); errno = saved_errno; return rc; } #endif return tcsetattr(fd, optional_actions, tio); } #endif bool tty_set_raw_mode(int fd, bool enable) { #ifdef _WIN32 intptr_t os_handle = _get_osfhandle(fd); if (os_handle == -1) return false; HANDLE handle = (HANDLE)os_handle; DWORD mode = 0; if (!GetConsoleMode(handle, &mode)) return false; if (enable) { mode &= ~(ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT); } else { mode |= ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT; } return SetConsoleMode(handle, mode) != 0; #else if (!is_tty_fd(fd)) return false; if (enable) { if (raw_state.active && raw_state.fd == fd) return true; struct termios saved; if (tcgetattr(fd, &saved) == -1) return false; struct termios raw = saved; raw.c_lflag &= ~(ICANON | ECHO | ISIG); raw.c_iflag &= ~(IXON | ICRNL); raw.c_cc[VMIN] = 1; raw.c_cc[VTIME] = 0; #ifdef VDISCARD raw.c_cc[VDISCARD] = _POSIX_VDISABLE; #endif #ifdef VLNEXT raw.c_cc[VLNEXT] = _POSIX_VDISABLE; #endif if (tty_tcsetattr_no_sigtou(fd, TCSANOW, &raw) == -1) return false; raw_state.fd = fd; raw_state.saved = saved; raw_state.active = true; return true; } if (!(raw_state.active && raw_state.fd == fd)) return true; if (tty_tcsetattr_no_sigtou(fd, TCSANOW, &raw_state.saved) == -1) return false; raw_state.fd = -1; raw_state.active = false; return true; #endif } bool tty_is_raw_mode(int fd) { #ifdef _WIN32 return false; #else return raw_state.active && raw_state.fd == fd; #endif } static ant_value_t get_process_stream(ant_t *js, const char *name) { ant_value_t process_obj = js_get(js, js_glob(js), "process"); if (!is_special_object(process_obj)) return js_mkundef(); ant_value_t stream = js_get(js, process_obj, name); if (!is_special_object(stream)) return js_mkundef(); return stream; } static void ensure_stream_common_props(ant_t *js, ant_value_t stream, int fd) { if (!is_special_object(stream)) return; js_set(js, stream, "fd", js_mknum((double)fd)); js_set(js, stream, "isTTY", js_bool(is_tty_fd(fd))); } static ant_value_t tty_isatty(ant_t *js, ant_value_t *args, int nargs) { if (nargs < 1) return js_false; int fd = 0; if (!parse_fd(args[0], &fd)) return js_false; return js_bool(ANT_ISATTY(fd) != 0); } static ant_value_t tty_stream_write(ant_t *js, ant_value_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; ant_value_t cb = js_mkundef(); if (nargs > 1 && is_callable(args[1])) cb = args[1]; int fd = stream_fd_from_this(js, ANT_STDOUT_FD); bool ok = tty_ctrl_write_fd(fd, data, len); if (is_callable(cb)) { if (ok) invoke_callback_if_needed(js, cb, js_mknull()); else invoke_callback_if_needed(js, cb, make_stream_error(js, "write", fd, 0)); } if (!ok) return js_false; return js_true; } static ant_value_t tty_write_stream_rows_getter(ant_t *js, ant_value_t *args, int nargs) { int fd = stream_fd_from_this(js, ANT_STDOUT_FD); if (!is_tty_fd(fd)) return js_mkundef(); int rows = 0; int cols = 0; get_tty_size(fd, &rows, &cols); return js_mknum((double)rows); } static ant_value_t tty_write_stream_columns_getter(ant_t *js, ant_value_t *args, int nargs) { int fd = stream_fd_from_this(js, ANT_STDOUT_FD); if (!is_tty_fd(fd)) return js_mkundef(); int rows = 0; int cols = 0; get_tty_size(fd, &rows, &cols); return js_mknum((double)cols); } static ant_value_t tty_write_stream_get_window_size(ant_t *js, ant_value_t *args, int nargs) { int fd = stream_fd_from_this(js, ANT_STDOUT_FD); int rows = 0; int cols = 0; get_tty_size(fd, &rows, &cols); ant_value_t arr = js_mkarr(js); js_arr_push(js, arr, js_mknum((double)cols)); js_arr_push(js, arr, js_mknum((double)rows)); return arr; } static ant_value_t tty_write_stream_clear_line(ant_t *js, ant_value_t *args, int nargs) { ant_value_t this_obj = js_getthis(js); int dir = 0; if (!tty_ctrl_parse_clear_line_dir(args, nargs, 0, &dir)) { return js_mkerr_typed(js, JS_ERR_TYPE, "clearLine(dir) requires a numeric dir"); } ant_value_t cb = js_mkundef(); if (nargs > 1 && is_callable(args[1])) cb = args[1]; int fd = stream_fd_from_this(js, ANT_STDOUT_FD); size_t seq_len = 0; const char *seq = tty_ctrl_clear_line_seq(dir, &seq_len); bool ok = tty_ctrl_write_fd(fd, seq, seq_len); return maybe_callback_or_throw(js, this_obj, cb, ok, "clearLine", fd); } static ant_value_t tty_write_stream_clear_screen_down(ant_t *js, ant_value_t *args, int nargs) { ant_value_t this_obj = js_getthis(js); ant_value_t cb = js_mkundef(); if (nargs > 0 && is_callable(args[0])) cb = args[0]; int fd = stream_fd_from_this(js, ANT_STDOUT_FD); size_t seq_len = 0; const char *seq = tty_ctrl_clear_screen_down_seq(&seq_len); bool ok = tty_ctrl_write_fd(fd, seq, seq_len); return maybe_callback_or_throw(js, this_obj, cb, ok, "clearScreenDown", fd); } static ant_value_t tty_write_stream_cursor_to(ant_t *js, ant_value_t *args, int nargs) { ant_value_t this_obj = js_getthis(js); int x = 0; if (nargs < 1 || !tty_ctrl_parse_int_value(args[0], &x)) { return js_mkerr_typed(js, JS_ERR_TYPE, "cursorTo(x[, y][, callback]) requires numeric x"); } x = tty_ctrl_normalize_coord(x); bool has_y = false; int y = 0; ant_value_t cb = js_mkundef(); if (nargs > 1) { if (is_callable(args[1])) { cb = args[1]; } else if (vtype(args[1]) == T_UNDEF) { // no-op } else if (tty_ctrl_parse_int_value(args[1], &y)) { has_y = true; y = tty_ctrl_normalize_coord(y); if (nargs > 2 && is_callable(args[2])) cb = args[2]; } else { return js_mkerr_typed(js, JS_ERR_TYPE, "cursorTo y must be a number when provided"); } } char seq[64]; size_t seq_len = 0; if (!tty_ctrl_build_cursor_to(seq, sizeof(seq), x, has_y, y, &seq_len)) { return js_mkerr(js, "Failed to build cursor sequence"); } int fd = stream_fd_from_this(js, ANT_STDOUT_FD); bool ok = tty_ctrl_write_fd(fd, seq, seq_len); return maybe_callback_or_throw(js, this_obj, cb, ok, "cursorTo", fd); } static ant_value_t tty_write_stream_move_cursor(ant_t *js, ant_value_t *args, int nargs) { ant_value_t this_obj = js_getthis(js); if (nargs < 2) { return js_mkerr_typed(js, JS_ERR_TYPE, "moveCursor(dx, dy[, callback]) requires dx and dy"); } int dx = 0; int dy = 0; if (!tty_ctrl_parse_move_cursor_args(args, nargs, 0, 1, &dx, &dy)) { return js_mkerr_typed(js, JS_ERR_TYPE, "moveCursor(dx, dy[, callback]) requires numeric dx and dy"); } ant_value_t cb = js_mkundef(); if (nargs > 2 && is_callable(args[2])) cb = args[2]; int fd = stream_fd_from_this(js, ANT_STDOUT_FD); bool ok = true; if (dx != 0) { char seq_x[32]; size_t len_x = 0; if (!tty_ctrl_build_move_cursor_axis(seq_x, sizeof(seq_x), dx, true, &len_x)) { return js_mkerr(js, "Failed to build moveCursor sequence"); } if (!tty_ctrl_write_fd(fd, seq_x, len_x)) ok = false; } if (ok && dy != 0) { char seq_y[32]; size_t len_y = 0; if (!tty_ctrl_build_move_cursor_axis(seq_y, sizeof(seq_y), dy, false, &len_y)) { return js_mkerr(js, "Failed to build moveCursor sequence"); } if (!tty_ctrl_write_fd(fd, seq_y, len_y)) ok = false; } return maybe_callback_or_throw(js, this_obj, cb, ok, "moveCursor", fd); } static ant_value_t tty_write_stream_get_color_depth(ant_t *js, ant_value_t *args, int nargs) { ant_value_t env_obj = js_mkundef(); if (nargs > 0 && is_special_object(args[0])) env_obj = args[0]; int fd = stream_fd_from_this(js, ANT_STDOUT_FD); int depth = detect_color_depth(js, fd, env_obj); return js_mknum((double)depth); } static ant_value_t tty_write_stream_has_colors(ant_t *js, ant_value_t *args, int nargs) { int count = 16; ant_value_t env_obj = js_mkundef(); if (nargs > 0) { if (vtype(args[0]) == T_NUM) { int parsed_count = 16; if (!tty_ctrl_parse_int_value(args[0], &parsed_count)) { return js_mkerr_typed(js, JS_ERR_TYPE, "hasColors(count[, env]) count must be an integer"); } count = parsed_count; } else if (is_special_object(args[0])) { env_obj = args[0]; } else if (vtype(args[0]) != T_UNDEF) { return js_mkerr_typed(js, JS_ERR_TYPE, "hasColors(count[, env]) invalid first argument"); } } if (nargs > 1 && is_special_object(args[1])) env_obj = args[1]; if (count < 1) count = 1; int fd = stream_fd_from_this(js, ANT_STDOUT_FD); int depth = detect_color_depth(js, fd, env_obj); int max_colors = palette_size_for_depth(depth); return js_bool(max_colors >= count); } static ant_value_t tty_read_stream_set_raw_mode(ant_t *js, ant_value_t *args, int nargs) { ant_value_t this_obj = js_getthis(js); if (!is_special_object(this_obj)) { return js_mkerr_typed(js, JS_ERR_TYPE, "setRawMode() requires a ReadStream receiver"); } bool enable = nargs > 0 ? js_truthy(js, args[0]) : true; int fd = stream_fd_from_this(js, ANT_STDIN_FD); if (!tty_set_raw_mode(fd, enable)) { return js_mkerr_typed(js, JS_ERR_GENERIC, "Failed to set raw mode for fd %d", fd); } js_set(js, this_obj, "isRaw", js_bool(enable)); return this_obj; } static ant_value_t tty_read_stream_constructor(ant_t *js, ant_value_t *args, int nargs) { tty_read_stream_state_t *state = NULL; if (nargs < 1) return js_mkerr_typed(js, JS_ERR_TYPE, "ReadStream(fd) requires a file descriptor"); int fd = 0; if (!parse_fd(args[0], &fd)) { return js_mkerr_typed(js, JS_ERR_TYPE, "ReadStream(fd) requires an integer file descriptor"); } if (!is_tty_fd(fd)) { return js_mkerr_typed(js, JS_ERR_TYPE, "ReadStream fd %d is not a TTY", fd); } if (fd == ANT_STDIN_FD) { ant_value_t stdin_obj = get_process_stream(js, "stdin"); if (is_special_object(stdin_obj)) { ensure_stream_common_props(js, stdin_obj, fd); if (vtype(js_get(js, stdin_obj, "isRaw")) == T_UNDEF) js_set(js, stdin_obj, "isRaw", js_false); return stdin_obj; }} ant_value_t obj = stream_construct_readable(js, g_tty_readstream_proto, js_mkundef()); if (is_err(obj)) return obj; state = calloc(1, sizeof(*state)); if (!state) return js_mkerr(js, "Out of memory"); state->js = js; state->stream_obj = obj; state->fd = fd; ensure_stream_common_props(js, obj, fd); stream_set_attached_state(obj, state, tty_read_stream_finalize); js_set(js, obj, "isRaw", js_false); js_set(js, obj, "_read", js_mkfun(tty_readstream__read)); js_set(js, obj, "_destroy", js_mkfun(tty_readstream__destroy)); return obj; } static ant_value_t tty_write_stream_constructor(ant_t *js, ant_value_t *args, int nargs) { if (nargs < 1) return js_mkerr_typed(js, JS_ERR_TYPE, "WriteStream(fd) requires a file descriptor"); int fd = 0; if (!parse_fd(args[0], &fd)) { return js_mkerr_typed(js, JS_ERR_TYPE, "WriteStream(fd) requires an integer file descriptor"); } if (!is_tty_fd(fd)) { return js_mkerr_typed(js, JS_ERR_TYPE, "WriteStream fd %d is not a TTY", fd); } if (fd == ANT_STDOUT_FD || fd == ANT_STDERR_FD) { ant_value_t stream = get_process_stream(js, fd == ANT_STDOUT_FD ? "stdout" : "stderr"); if (is_special_object(stream)) { ensure_stream_common_props(js, stream, fd); return stream; } } ant_value_t obj = stream_construct_writable(js, g_tty_writestream_proto, js_mkundef()); if (is_err(obj)) return obj; ensure_stream_common_props(js, obj, fd); return obj; } static void setup_readstream_proto(ant_t *js, ant_value_t proto) { if (!is_special_object(proto)) return; js_set(js, proto, "setRawMode", js_mkfun(tty_read_stream_set_raw_mode)); js_set_sym(js, proto, get_toStringTag_sym(), js_mkstr(js, "ReadStream", 10)); } static void setup_writestream_proto(ant_t *js, ant_value_t proto) { if (!is_special_object(proto)) return; js_set(js, proto, "write", js_mkfun(tty_stream_write)); js_set(js, proto, "clearLine", js_mkfun(tty_write_stream_clear_line)); js_set(js, proto, "clearScreenDown", js_mkfun(tty_write_stream_clear_screen_down)); js_set(js, proto, "cursorTo", js_mkfun(tty_write_stream_cursor_to)); js_set(js, proto, "moveCursor", js_mkfun(tty_write_stream_move_cursor)); js_set(js, proto, "getWindowSize", js_mkfun(tty_write_stream_get_window_size)); js_set(js, proto, "getColorDepth", js_mkfun(tty_write_stream_get_color_depth)); js_set(js, proto, "hasColors", js_mkfun(tty_write_stream_has_colors)); js_set_getter_desc(js, proto, "rows", 4, js_mkfun(tty_write_stream_rows_getter), JS_DESC_E | JS_DESC_C); js_set_getter_desc(js, proto, "columns", 7, js_mkfun(tty_write_stream_columns_getter), JS_DESC_E | JS_DESC_C); js_set_sym(js, proto, get_toStringTag_sym(), js_mkstr(js, "WriteStream", 11)); } static void tty_init_stream_constructors(ant_t *js) { if (g_tty_readstream_ctor && g_tty_writestream_ctor) return; stream_init_constructors(js); g_tty_readstream_proto = js_mkobj(js); js_set_proto_init(g_tty_readstream_proto, stream_readable_prototype(js)); setup_readstream_proto(js, g_tty_readstream_proto); g_tty_readstream_ctor = js_make_ctor(js, tty_read_stream_constructor, g_tty_readstream_proto, "ReadStream", 10); js_set_proto_init(g_tty_readstream_ctor, stream_readable_constructor(js)); gc_register_root(&g_tty_readstream_proto); gc_register_root(&g_tty_readstream_ctor); g_tty_writestream_proto = js_mkobj(js); js_set_proto_init(g_tty_writestream_proto, stream_writable_prototype(js)); setup_writestream_proto(js, g_tty_writestream_proto); g_tty_writestream_ctor = js_make_ctor(js, tty_write_stream_constructor, g_tty_writestream_proto, "WriteStream", 11); js_set_proto_init(g_tty_writestream_ctor, stream_writable_constructor(js)); gc_register_root(&g_tty_writestream_proto); gc_register_root(&g_tty_writestream_ctor); } void init_tty_module(void) { ant_t *js = rt->js; if (!js) return; tty_init_stream_constructors(js); ant_value_t process_obj = js_get(js, js_glob(js), "process"); if (!is_special_object(process_obj)) return; ant_value_t stdin_obj = js_get(js, process_obj, "stdin"); if (is_special_object(stdin_obj)) { ensure_stream_common_props(js, stdin_obj, ANT_STDIN_FD); if (vtype(js_get(js, stdin_obj, "isRaw")) == T_UNDEF) js_set(js, stdin_obj, "isRaw", js_false); ant_value_t stdin_proto = js_get_proto(js, stdin_obj); if (is_special_object(stdin_proto)) { js_set_proto_init(stdin_proto, stream_readable_prototype(js)); setup_readstream_proto(js, stdin_proto); } stream_init_readable_object(js, stdin_obj, js_mkundef()); } ant_value_t stdout_obj = js_get(js, process_obj, "stdout"); if (is_special_object(stdout_obj)) { ensure_stream_common_props(js, stdout_obj, ANT_STDOUT_FD); js_set_getter_desc(js, stdout_obj, "rows", 4, js_mkfun(tty_write_stream_rows_getter), JS_DESC_E | JS_DESC_C); js_set_getter_desc(js, stdout_obj, "columns", 7, js_mkfun(tty_write_stream_columns_getter), JS_DESC_E | JS_DESC_C); ant_value_t stdout_proto = js_get_proto(js, stdout_obj); if (is_special_object(stdout_proto)) js_set_proto_init(stdout_proto, stream_duplex_prototype(js)); setup_writestream_proto(js, stdout_proto); stream_init_duplex_object(js, stdout_obj, js_mkundef()); js_set(js, stdout_obj, "readable", js_false); } ant_value_t stderr_obj = js_get(js, process_obj, "stderr"); if (is_special_object(stderr_obj)) { ensure_stream_common_props(js, stderr_obj, ANT_STDERR_FD); js_set_getter_desc(js, stderr_obj, "rows", 4, js_mkfun(tty_write_stream_rows_getter), JS_DESC_E | JS_DESC_C); js_set_getter_desc(js, stderr_obj, "columns", 7, js_mkfun(tty_write_stream_columns_getter), JS_DESC_E | JS_DESC_C); ant_value_t stderr_proto = js_get_proto(js, stderr_obj); if (is_special_object(stderr_proto)) js_set_proto_init(stderr_proto, stream_duplex_prototype(js)); setup_writestream_proto(js, stderr_proto); stream_init_duplex_object(js, stderr_obj, js_mkundef()); js_set(js, stderr_obj, "readable", js_false); } } ant_value_t tty_library(ant_t *js) { ant_value_t lib = js_mkobj(js); tty_init_stream_constructors(js); js_set(js, lib, "isatty", js_mkfun(tty_isatty)); js_set(js, lib, "ReadStream", g_tty_readstream_ctor); js_set(js, lib, "WriteStream", g_tty_writestream_ctor); js_set_sym(js, lib, get_toStringTag_sym(), js_mkstr(js, "tty", 3)); return lib; }