This source file includes following definitions.
- uv_console_init
- uv_tty_init
- uv_tty_set_mode
- uv_is_tty
- uv_tty_get_winsize
- uv_tty_post_raw_read
- uv_tty_queue_read_raw
- uv_tty_line_read_thread
- uv_tty_queue_read_line
- uv_tty_queue_read
- get_vt100_fn_key
- uv_process_tty_read_raw_req
- uv_process_tty_read_line_req
- uv_process_tty_read_req
- uv_tty_read_start
- uv_tty_read_stop
- uv_tty_update_virtual_window
- uv_tty_make_real_coord
- uv_tty_emit_text
- uv_tty_move_caret
- uv_tty_reset
- uv_tty_clear
- uv_tty_set_style
- uv_tty_save_state
- uv_tty_restore_state
- uv_tty_write_bufs
- uv_tty_write
- uv_process_tty_write_req
- uv_tty_close
- uv_tty_endgame
- uv_process_tty_accept_req
- uv_process_tty_connect_req
- uv_tty_reset_mode
#include <assert.h>
#include <io.h>
#include <string.h>
#if defined(_MSC_VER) && _MSC_VER < 1600
# include "stdint-msvc2008.h"
#else
# include <stdint.h>
#endif
#include "uv.h"
#include "internal.h"
#include "handle-inl.h"
#include "stream-inl.h"
#include "req-inl.h"
#define UNICODE_REPLACEMENT_CHARACTER (0xfffd)
#define ANSI_NORMAL 0x00
#define ANSI_ESCAPE_SEEN 0x02
#define ANSI_CSI 0x04
#define ANSI_ST_CONTROL 0x08
#define ANSI_IGNORE 0x10
#define ANSI_IN_ARG 0x20
#define ANSI_IN_STRING 0x40
#define ANSI_BACKSLASH_SEEN 0x80
static void uv_tty_update_virtual_window(CONSOLE_SCREEN_BUFFER_INFO* info);
static const uv_buf_t uv_null_buf_ = { 0, NULL };
static int uv_tty_virtual_offset = -1;
static int uv_tty_virtual_height = -1;
static int uv_tty_virtual_width = -1;
static CRITICAL_SECTION uv_tty_output_lock;
static HANDLE uv_tty_output_handle = INVALID_HANDLE_VALUE;
void uv_console_init() {
InitializeCriticalSection(&uv_tty_output_lock);
}
int uv_tty_init(uv_loop_t* loop, uv_tty_t* tty, uv_file fd, int readable) {
HANDLE handle;
CONSOLE_SCREEN_BUFFER_INFO screen_buffer_info;
handle = (HANDLE) _get_osfhandle(fd);
if (handle == INVALID_HANDLE_VALUE) {
return UV_EBADF;
}
if (!readable) {
if (!GetConsoleScreenBufferInfo(handle, &screen_buffer_info)) {
return uv_translate_sys_error(GetLastError());
}
EnterCriticalSection(&uv_tty_output_lock);
uv_tty_output_handle = handle;
uv_tty_update_virtual_window(&screen_buffer_info);
LeaveCriticalSection(&uv_tty_output_lock);
}
uv_stream_init(loop, (uv_stream_t*) tty, UV_TTY);
uv_connection_init((uv_stream_t*) tty);
tty->handle = handle;
tty->reqs_pending = 0;
tty->flags |= UV_HANDLE_BOUND;
if (readable) {
tty->flags |= UV_HANDLE_TTY_READABLE | UV_HANDLE_READABLE;
tty->read_line_handle = NULL;
tty->read_line_buffer = uv_null_buf_;
tty->read_raw_wait = NULL;
tty->last_key_len = 0;
tty->last_key_offset = 0;
tty->last_utf16_high_surrogate = 0;
memset(&tty->last_input_record, 0, sizeof tty->last_input_record);
} else {
tty->flags |= UV_HANDLE_WRITABLE;
tty->utf8_bytes_left = 0;
tty->utf8_codepoint = 0;
tty->previous_eol = 0;
tty->ansi_parser_state = ANSI_NORMAL;
}
return 0;
}
int uv_tty_set_mode(uv_tty_t* tty, int mode) {
DWORD flags;
unsigned char was_reading;
uv_alloc_cb alloc_cb;
uv_read_cb read_cb;
int err;
if (!(tty->flags & UV_HANDLE_TTY_READABLE)) {
return UV_EINVAL;
}
if (!!mode == !!(tty->flags & UV_HANDLE_TTY_RAW)) {
return 0;
}
if (mode) {
flags = ENABLE_WINDOW_INPUT;
} else {
flags = ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT;
}
if (!SetConsoleMode(tty->handle, flags)) {
return uv_translate_sys_error(GetLastError());
}
if (tty->flags & UV_HANDLE_READING) {
was_reading = 1;
alloc_cb = tty->alloc_cb;
read_cb = tty->read_cb;
if (was_reading) {
err = uv_tty_read_stop(tty);
if (err) {
return uv_translate_sys_error(err);
}
}
} else {
was_reading = 0;
}
tty->flags &= ~UV_HANDLE_TTY_RAW;
tty->flags |= mode ? UV_HANDLE_TTY_RAW : 0;
if (was_reading) {
err = uv_tty_read_start(tty, alloc_cb, read_cb);
if (err) {
return uv_translate_sys_error(err);
}
}
return 0;
}
int uv_is_tty(uv_file file) {
DWORD result;
return GetConsoleMode((HANDLE) _get_osfhandle(file), &result) != 0;
}
int uv_tty_get_winsize(uv_tty_t* tty, int* width, int* height) {
CONSOLE_SCREEN_BUFFER_INFO info;
if (!GetConsoleScreenBufferInfo(tty->handle, &info)) {
return uv_translate_sys_error(GetLastError());
}
EnterCriticalSection(&uv_tty_output_lock);
uv_tty_update_virtual_window(&info);
LeaveCriticalSection(&uv_tty_output_lock);
*width = uv_tty_virtual_width;
*height = uv_tty_virtual_height;
return 0;
}
static void CALLBACK uv_tty_post_raw_read(void* data, BOOLEAN didTimeout) {
uv_loop_t* loop;
uv_tty_t* handle;
uv_req_t* req;
assert(data);
assert(!didTimeout);
req = (uv_req_t*) data;
handle = (uv_tty_t*) req->data;
loop = handle->loop;
UnregisterWait(handle->read_raw_wait);
handle->read_raw_wait = NULL;
SET_REQ_SUCCESS(req);
POST_COMPLETION_FOR_REQ(loop, req);
}
static void uv_tty_queue_read_raw(uv_loop_t* loop, uv_tty_t* handle) {
uv_read_t* req;
BOOL r;
assert(handle->flags & UV_HANDLE_READING);
assert(!(handle->flags & UV_HANDLE_READ_PENDING));
assert(handle->handle && handle->handle != INVALID_HANDLE_VALUE);
handle->read_line_buffer = uv_null_buf_;
req = &handle->read_req;
memset(&req->overlapped, 0, sizeof(req->overlapped));
r = RegisterWaitForSingleObject(&handle->read_raw_wait,
handle->handle,
uv_tty_post_raw_read,
(void*) req,
INFINITE,
WT_EXECUTEINWAITTHREAD | WT_EXECUTEONLYONCE);
if (!r) {
handle->read_raw_wait = NULL;
SET_REQ_ERROR(req, GetLastError());
uv_insert_pending_req(loop, (uv_req_t*)req);
}
handle->flags |= UV_HANDLE_READ_PENDING;
handle->reqs_pending++;
}
static DWORD CALLBACK uv_tty_line_read_thread(void* data) {
uv_loop_t* loop;
uv_tty_t* handle;
uv_req_t* req;
DWORD bytes, read_bytes;
assert(data);
req = (uv_req_t*) data;
handle = (uv_tty_t*) req->data;
loop = handle->loop;
assert(handle->read_line_buffer.base != NULL);
assert(handle->read_line_buffer.len > 0);
if (handle->read_line_buffer.len < 8192) {
bytes = handle->read_line_buffer.len;
} else {
bytes = 8192;
}
if (ReadConsoleA(handle->read_line_handle,
(void*) handle->read_line_buffer.base,
bytes,
&read_bytes,
NULL)) {
SET_REQ_SUCCESS(req);
req->overlapped.InternalHigh = read_bytes;
} else {
SET_REQ_ERROR(req, GetLastError());
}
POST_COMPLETION_FOR_REQ(loop, req);
return 0;
}
static void uv_tty_queue_read_line(uv_loop_t* loop, uv_tty_t* handle) {
uv_read_t* req;
BOOL r;
assert(handle->flags & UV_HANDLE_READING);
assert(!(handle->flags & UV_HANDLE_READ_PENDING));
assert(handle->handle && handle->handle != INVALID_HANDLE_VALUE);
req = &handle->read_req;
memset(&req->overlapped, 0, sizeof(req->overlapped));
handle->read_line_buffer = handle->alloc_cb((uv_handle_t*) handle, 8192);
if (handle->read_line_buffer.len == 0) {
handle->read_cb(handle, UV_ENOBUFS, handle->read_line_buffer);
return;
}
assert(handle->read_line_buffer.base != NULL);
if (handle->read_line_handle == NULL) {
HANDLE this_process = GetCurrentProcess();
r = DuplicateHandle(this_process,
handle->handle,
this_process,
&handle->read_line_handle,
0,
0,
DUPLICATE_SAME_ACCESS);
if (!r) {
handle->read_line_handle = NULL;
SET_REQ_ERROR(req, GetLastError());
uv_insert_pending_req(loop, (uv_req_t*)req);
goto out;
}
}
r = QueueUserWorkItem(uv_tty_line_read_thread,
(void*) req,
WT_EXECUTELONGFUNCTION);
if (!r) {
SET_REQ_ERROR(req, GetLastError());
uv_insert_pending_req(loop, (uv_req_t*)req);
}
out:
handle->flags |= UV_HANDLE_READ_PENDING;
handle->reqs_pending++;
}
static void uv_tty_queue_read(uv_loop_t* loop, uv_tty_t* handle) {
if (handle->flags & UV_HANDLE_TTY_RAW) {
uv_tty_queue_read_raw(loop, handle);
} else {
uv_tty_queue_read_line(loop, handle);
}
}
static const char* get_vt100_fn_key(DWORD code, char shift, char ctrl,
size_t* len) {
#define VK_CASE(vk, normal_str, shift_str, ctrl_str, shift_ctrl_str) \
case (vk): \
if (shift && ctrl) { \
*len = sizeof shift_ctrl_str; \
return "\033" shift_ctrl_str; \
} else if (shift) { \
*len = sizeof shift_str ; \
return "\033" shift_str; \
} else if (ctrl) { \
*len = sizeof ctrl_str; \
return "\033" ctrl_str; \
} else { \
*len = sizeof normal_str; \
return "\033" normal_str; \
}
switch (code) {
VK_CASE(VK_INSERT, "[2~", "[2;2~", "[2;5~", "[2;6~")
VK_CASE(VK_END, "[4~", "[4;2~", "[4;5~", "[4;6~")
VK_CASE(VK_DOWN, "[B", "[1;2B", "[1;5B", "[1;6B")
VK_CASE(VK_NEXT, "[6~", "[6;2~", "[6;5~", "[6;6~")
VK_CASE(VK_LEFT, "[D", "[1;2D", "[1;5D", "[1;6D")
VK_CASE(VK_CLEAR, "[G", "[1;2G", "[1;5G", "[1;6G")
VK_CASE(VK_RIGHT, "[C", "[1;2C", "[1;5C", "[1;6C")
VK_CASE(VK_UP, "[A", "[1;2A", "[1;5A", "[1;6A")
VK_CASE(VK_HOME, "[1~", "[1;2~", "[1;5~", "[1;6~")
VK_CASE(VK_PRIOR, "[5~", "[5;2~", "[5;5~", "[5;6~")
VK_CASE(VK_DELETE, "[3~", "[3;2~", "[3;5~", "[3;6~")
VK_CASE(VK_NUMPAD0, "[2~", "[2;2~", "[2;5~", "[2;6~")
VK_CASE(VK_NUMPAD1, "[4~", "[4;2~", "[4;5~", "[4;6~")
VK_CASE(VK_NUMPAD2, "[B", "[1;2B", "[1;5B", "[1;6B")
VK_CASE(VK_NUMPAD3, "[6~", "[6;2~", "[6;5~", "[6;6~")
VK_CASE(VK_NUMPAD4, "[D", "[1;2D", "[1;5D", "[1;6D")
VK_CASE(VK_NUMPAD5, "[G", "[1;2G", "[1;5G", "[1;6G")
VK_CASE(VK_NUMPAD6, "[C", "[1;2C", "[1;5C", "[1;6C")
VK_CASE(VK_NUMPAD7, "[A", "[1;2A", "[1;5A", "[1;6A")
VK_CASE(VK_NUMPAD8, "[1~", "[1;2~", "[1;5~", "[1;6~")
VK_CASE(VK_NUMPAD9, "[5~", "[5;2~", "[5;5~", "[5;6~")
VK_CASE(VK_DECIMAL, "[3~", "[3;2~", "[3;5~", "[3;6~")
VK_CASE(VK_F1, "[[A", "[23~", "[11^", "[23^" )
VK_CASE(VK_F2, "[[B", "[24~", "[12^", "[24^" )
VK_CASE(VK_F3, "[[C", "[25~", "[13^", "[25^" )
VK_CASE(VK_F4, "[[D", "[26~", "[14^", "[26^" )
VK_CASE(VK_F5, "[[E", "[28~", "[15^", "[28^" )
VK_CASE(VK_F6, "[17~", "[29~", "[17^", "[29^" )
VK_CASE(VK_F7, "[18~", "[31~", "[18^", "[31^" )
VK_CASE(VK_F8, "[19~", "[32~", "[19^", "[32^" )
VK_CASE(VK_F9, "[20~", "[33~", "[20^", "[33^" )
VK_CASE(VK_F10, "[21~", "[34~", "[21^", "[34^" )
VK_CASE(VK_F11, "[23~", "[23$", "[23^", "[23@" )
VK_CASE(VK_F12, "[24~", "[24$", "[24^", "[24@" )
default:
*len = 0;
return NULL;
}
#undef VK_CASE
}
void uv_process_tty_read_raw_req(uv_loop_t* loop, uv_tty_t* handle,
uv_req_t* req) {
#define KEV handle->last_input_record.Event.KeyEvent
DWORD records_left, records_read;
uv_buf_t buf;
off_t buf_used;
assert(handle->type == UV_TTY);
assert(handle->flags & UV_HANDLE_TTY_READABLE);
handle->flags &= ~UV_HANDLE_READ_PENDING;
if (!(handle->flags & UV_HANDLE_READING) ||
!(handle->flags & UV_HANDLE_TTY_RAW)) {
goto out;
}
if (!REQ_SUCCESS(req)) {
if ((handle->flags & UV_HANDLE_READING)) {
handle->flags &= ~UV_HANDLE_READING;
handle->read_cb((uv_stream_t*)handle,
uv_translate_sys_error(GET_REQ_ERROR(req)),
uv_null_buf_);
}
goto out;
}
if (!GetNumberOfConsoleInputEvents(handle->handle, &records_left)) {
handle->flags &= ~UV_HANDLE_READING;
DECREASE_ACTIVE_COUNT(loop, handle);
handle->read_cb((uv_stream_t*)handle,
uv_translate_sys_error(GetLastError()),
uv_null_buf_);
goto out;
}
buf = uv_null_buf_;
buf_used = 0;
while ((records_left > 0 || handle->last_key_len > 0) &&
(handle->flags & UV_HANDLE_READING)) {
if (handle->last_key_len == 0) {
if (!ReadConsoleInputW(handle->handle,
&handle->last_input_record,
1,
&records_read)) {
handle->flags &= ~UV_HANDLE_READING;
DECREASE_ACTIVE_COUNT(loop, handle);
handle->read_cb((uv_stream_t*) handle,
uv_translate_sys_error(GetLastError()),
buf);
goto out;
}
records_left--;
if (handle->last_input_record.EventType == WINDOW_BUFFER_SIZE_EVENT) {
CONSOLE_SCREEN_BUFFER_INFO info;
EnterCriticalSection(&uv_tty_output_lock);
if (uv_tty_output_handle != INVALID_HANDLE_VALUE &&
GetConsoleScreenBufferInfo(uv_tty_output_handle, &info)) {
uv_tty_update_virtual_window(&info);
}
LeaveCriticalSection(&uv_tty_output_lock);
continue;
}
if (handle->last_input_record.EventType != KEY_EVENT) {
continue;
}
if (!KEV.bKeyDown && !(((KEV.dwControlKeyState & LEFT_ALT_PRESSED) ||
KEV.wVirtualKeyCode==VK_MENU) && KEV.uChar.UnicodeChar != 0)) {
continue;
}
if ((KEV.dwControlKeyState & LEFT_ALT_PRESSED) &&
!(KEV.dwControlKeyState & ENHANCED_KEY) &&
(KEV.wVirtualKeyCode == VK_INSERT ||
KEV.wVirtualKeyCode == VK_END ||
KEV.wVirtualKeyCode == VK_DOWN ||
KEV.wVirtualKeyCode == VK_NEXT ||
KEV.wVirtualKeyCode == VK_LEFT ||
KEV.wVirtualKeyCode == VK_CLEAR ||
KEV.wVirtualKeyCode == VK_RIGHT ||
KEV.wVirtualKeyCode == VK_HOME ||
KEV.wVirtualKeyCode == VK_UP ||
KEV.wVirtualKeyCode == VK_PRIOR ||
KEV.wVirtualKeyCode == VK_NUMPAD0 ||
KEV.wVirtualKeyCode == VK_NUMPAD1 ||
KEV.wVirtualKeyCode == VK_NUMPAD2 ||
KEV.wVirtualKeyCode == VK_NUMPAD3 ||
KEV.wVirtualKeyCode == VK_NUMPAD4 ||
KEV.wVirtualKeyCode == VK_NUMPAD5 ||
KEV.wVirtualKeyCode == VK_NUMPAD6 ||
KEV.wVirtualKeyCode == VK_NUMPAD7 ||
KEV.wVirtualKeyCode == VK_NUMPAD8 ||
KEV.wVirtualKeyCode == VK_NUMPAD9)) {
continue;
}
if (KEV.uChar.UnicodeChar != 0) {
int prefix_len, char_len;
if (KEV.uChar.UnicodeChar >= 0xD800 &&
KEV.uChar.UnicodeChar < 0xDC00) {
handle->last_utf16_high_surrogate = KEV.uChar.UnicodeChar;
continue;
}
if ((KEV.dwControlKeyState & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED))
&& !(KEV.dwControlKeyState & (LEFT_CTRL_PRESSED |
RIGHT_CTRL_PRESSED)) && KEV.bKeyDown) {
handle->last_key[0] = '\033';
prefix_len = 1;
} else {
prefix_len = 0;
}
if (KEV.uChar.UnicodeChar >= 0xDC00 &&
KEV.uChar.UnicodeChar < 0xE000) {
WCHAR utf16_buffer[2] = { handle->last_utf16_high_surrogate,
KEV.uChar.UnicodeChar};
char_len = WideCharToMultiByte(CP_UTF8,
0,
utf16_buffer,
2,
&handle->last_key[prefix_len],
sizeof handle->last_key,
NULL,
NULL);
} else {
char_len = WideCharToMultiByte(CP_UTF8,
0,
&KEV.uChar.UnicodeChar,
1,
&handle->last_key[prefix_len],
sizeof handle->last_key,
NULL,
NULL);
}
handle->last_utf16_high_surrogate = 0;
if (!char_len) {
handle->flags &= ~UV_HANDLE_READING;
DECREASE_ACTIVE_COUNT(loop, handle);
handle->read_cb((uv_stream_t*) handle,
uv_translate_sys_error(GetLastError()),
buf);
goto out;
}
handle->last_key_len = (unsigned char) (prefix_len + char_len);
handle->last_key_offset = 0;
continue;
} else {
const char* vt100;
size_t prefix_len, vt100_len;
vt100 = get_vt100_fn_key(KEV.wVirtualKeyCode,
!!(KEV.dwControlKeyState & SHIFT_PRESSED),
!!(KEV.dwControlKeyState & (
LEFT_CTRL_PRESSED |
RIGHT_CTRL_PRESSED)),
&vt100_len);
if (!vt100) {
continue;
}
if (KEV.dwControlKeyState & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED)) {
handle->last_key[0] = '\033';
prefix_len = 1;
} else {
prefix_len = 0;
}
assert(prefix_len + vt100_len < sizeof handle->last_key);
memcpy(&handle->last_key[prefix_len], vt100, vt100_len);
handle->last_key_len = (unsigned char) (prefix_len + vt100_len);
handle->last_key_offset = 0;
continue;
}
} else {
if (handle->last_key_offset < handle->last_key_len) {
if (buf_used == 0) {
buf = handle->alloc_cb((uv_handle_t*) handle, 1024);
if (buf.len == 0) {
handle->read_cb((uv_stream_t*) handle, UV_ENOBUFS, buf);
goto out;
}
assert(buf.base != NULL);
}
buf.base[buf_used++] = handle->last_key[handle->last_key_offset++];
if (buf_used == buf.len) {
handle->read_cb((uv_stream_t*) handle, buf_used, buf);
buf = uv_null_buf_;
buf_used = 0;
}
continue;
}
if (--KEV.wRepeatCount > 0) {
handle->last_key_offset = 0;
continue;
}
handle->last_key_len = 0;
continue;
}
}
if (buf_used > 0) {
handle->read_cb((uv_stream_t*) handle, buf_used, buf);
}
out:
if ((handle->flags & UV_HANDLE_READING) &&
!(handle->flags & UV_HANDLE_READ_PENDING)) {
uv_tty_queue_read(loop, handle);
}
DECREASE_PENDING_REQ_COUNT(handle);
#undef KEV
}
void uv_process_tty_read_line_req(uv_loop_t* loop, uv_tty_t* handle,
uv_req_t* req) {
uv_buf_t buf;
assert(handle->type == UV_TTY);
assert(handle->flags & UV_HANDLE_TTY_READABLE);
buf = handle->read_line_buffer;
handle->flags &= ~UV_HANDLE_READ_PENDING;
handle->read_line_buffer = uv_null_buf_;
if (!REQ_SUCCESS(req)) {
if ((handle->flags & UV_HANDLE_READING) &&
handle->read_line_handle != NULL) {
handle->flags &= ~UV_HANDLE_READING;
DECREASE_ACTIVE_COUNT(loop, handle);
handle->read_cb((uv_stream_t*) handle,
uv_translate_sys_error(GET_REQ_ERROR(req)),
buf);
} else {
handle->read_cb((uv_stream_t*) handle, 0, buf);
}
} else {
DWORD bytes = req->overlapped.InternalHigh;
handle->read_cb((uv_stream_t*) handle, bytes, buf);
}
if ((handle->flags & UV_HANDLE_READING) &&
!(handle->flags & UV_HANDLE_READ_PENDING)) {
uv_tty_queue_read(loop, handle);
}
DECREASE_PENDING_REQ_COUNT(handle);
}
void uv_process_tty_read_req(uv_loop_t* loop, uv_tty_t* handle,
uv_req_t* req) {
assert(handle->type == UV_TTY);
assert(handle->flags & UV_HANDLE_TTY_READABLE);
if (handle->read_line_buffer.len == 0) {
uv_process_tty_read_raw_req(loop, handle, req);
} else {
uv_process_tty_read_line_req(loop, handle, req);
}
}
int uv_tty_read_start(uv_tty_t* handle, uv_alloc_cb alloc_cb,
uv_read_cb read_cb) {
uv_loop_t* loop = handle->loop;
if (!(handle->flags & UV_HANDLE_TTY_READABLE)) {
return ERROR_INVALID_PARAMETER;
}
handle->flags |= UV_HANDLE_READING;
INCREASE_ACTIVE_COUNT(loop, handle);
handle->read_cb = read_cb;
handle->alloc_cb = alloc_cb;
if (handle->flags & UV_HANDLE_READ_PENDING) {
return 0;
}
if (handle->last_key_len > 0) {
SET_REQ_SUCCESS(&handle->read_req);
uv_insert_pending_req(handle->loop, (uv_req_t*) &handle->read_req);
return 0;
}
uv_tty_queue_read(loop, handle);
return 0;
}
int uv_tty_read_stop(uv_tty_t* handle) {
uv_loop_t* loop = handle->loop;
handle->flags &= ~UV_HANDLE_READING;
DECREASE_ACTIVE_COUNT(loop, handle);
if ((handle->flags & UV_HANDLE_READ_PENDING) &&
(handle->flags & UV_HANDLE_TTY_RAW)) {
INPUT_RECORD record;
DWORD written;
memset(&record, 0, sizeof record);
if (!WriteConsoleInputW(handle->handle, &record, 1, &written)) {
return GetLastError();
}
}
if (handle->read_line_handle != NULL) {
CloseHandle(handle->read_line_handle);
handle->read_line_handle = NULL;
}
return 0;
}
static void uv_tty_update_virtual_window(CONSOLE_SCREEN_BUFFER_INFO* info) {
int old_virtual_width = uv_tty_virtual_width;
int old_virtual_height = uv_tty_virtual_height;
uv_tty_virtual_width = info->dwSize.X;
uv_tty_virtual_height = info->srWindow.Bottom - info->srWindow.Top + 1;
if (uv_tty_virtual_offset == -1) {
uv_tty_virtual_offset = info->dwCursorPosition.Y;
} else if (uv_tty_virtual_offset < info->dwCursorPosition.Y -
uv_tty_virtual_height + 1) {
uv_tty_virtual_offset = info->dwCursorPosition.Y -
uv_tty_virtual_height + 1;
}
if (uv_tty_virtual_offset + uv_tty_virtual_height > info->dwSize.Y) {
uv_tty_virtual_offset = info->dwSize.Y - uv_tty_virtual_height;
}
if (uv_tty_virtual_offset < 0) {
uv_tty_virtual_offset = 0;
}
if (old_virtual_width != -1 && old_virtual_height != -1 &&
(uv_tty_virtual_width != old_virtual_width ||
uv_tty_virtual_height != old_virtual_height)) {
uv__signal_dispatch(SIGWINCH);
}
}
static COORD uv_tty_make_real_coord(uv_tty_t* handle,
CONSOLE_SCREEN_BUFFER_INFO* info, int x, unsigned char x_relative, int y,
unsigned char y_relative) {
COORD result;
uv_tty_update_virtual_window(info);
if (y_relative) {
y = info->dwCursorPosition.Y + y;
} else {
y = uv_tty_virtual_offset + y;
}
if (y < uv_tty_virtual_offset) {
y = uv_tty_virtual_offset;
} else if (y >= uv_tty_virtual_offset + uv_tty_virtual_height) {
y = uv_tty_virtual_offset + uv_tty_virtual_height - 1;
}
if (x_relative) {
x = info->dwCursorPosition.X + x;
}
if (x < 0) {
x = 0;
} else if (x >= uv_tty_virtual_width) {
x = uv_tty_virtual_width - 1;
}
result.X = (unsigned short) x;
result.Y = (unsigned short) y;
return result;
}
static int uv_tty_emit_text(uv_tty_t* handle, WCHAR buffer[], DWORD length,
DWORD* error) {
DWORD written;
if (*error != ERROR_SUCCESS) {
return -1;
}
if (!WriteConsoleW(handle->handle,
(void*) buffer,
length,
&written,
NULL)) {
*error = GetLastError();
return -1;
}
return 0;
}
static int uv_tty_move_caret(uv_tty_t* handle, int x, unsigned char x_relative,
int y, unsigned char y_relative, DWORD* error) {
CONSOLE_SCREEN_BUFFER_INFO info;
COORD pos;
if (*error != ERROR_SUCCESS) {
return -1;
}
retry:
if (!GetConsoleScreenBufferInfo(handle->handle, &info)) {
*error = GetLastError();
}
pos = uv_tty_make_real_coord(handle, &info, x, x_relative, y, y_relative);
if (!SetConsoleCursorPosition(handle->handle, pos)) {
if (GetLastError() == ERROR_INVALID_PARAMETER) {
goto retry;
} else {
*error = GetLastError();
return -1;
}
}
return 0;
}
static int uv_tty_reset(uv_tty_t* handle, DWORD* error) {
const COORD origin = {0, 0};
const WORD char_attrs = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
CONSOLE_SCREEN_BUFFER_INFO info;
DWORD count, written;
if (*error != ERROR_SUCCESS) {
return -1;
}
if (!SetConsoleTextAttribute(handle->handle, char_attrs)) {
*error = GetLastError();
return -1;
}
if (!SetConsoleCursorPosition(handle->handle, origin)) {
*error = GetLastError();
return -1;
}
retry:
if (!GetConsoleScreenBufferInfo(handle->handle, &info)) {
*error = GetLastError();
return -1;
}
count = info.dwSize.X * info.dwSize.Y;
if (!(FillConsoleOutputCharacterW(handle->handle,
L'\x20',
count,
origin,
&written) &&
FillConsoleOutputAttribute(handle->handle,
char_attrs,
written,
origin,
&written))) {
if (GetLastError() == ERROR_INVALID_PARAMETER) {
goto retry;
} else {
*error = GetLastError();
return -1;
}
}
uv_tty_virtual_offset = 0;
uv_tty_update_virtual_window(&info);
return 0;
}
static int uv_tty_clear(uv_tty_t* handle, int dir, char entire_screen,
DWORD* error) {
CONSOLE_SCREEN_BUFFER_INFO info;
COORD start, end;
DWORD count, written;
int x1, x2, y1, y2;
int x1r, x2r, y1r, y2r;
if (*error != ERROR_SUCCESS) {
return -1;
}
if (dir == 0) {
x1 = 0;
x1r = 1;
} else {
x1 = 0;
x1r = 0;
}
if (dir == 1) {
x2 = 0;
x2r = 1;
} else {
x2 = 0xffff;
x2r = 0;
}
if (!entire_screen) {
y1 = y2 = 0;
y1r = y2r = 1;
} else {
y1 = x1;
y1r = x1r;
y2 = x2;
y2r = x2r;
}
retry:
if (!GetConsoleScreenBufferInfo(handle->handle, &info)) {
*error = GetLastError();
return -1;
}
start = uv_tty_make_real_coord(handle, &info, x1, x1r, y1, y1r);
end = uv_tty_make_real_coord(handle, &info, x2, x2r, y2, y2r);
count = (end.Y * info.dwSize.X + end.X) -
(start.Y * info.dwSize.X + start.X) + 1;
if (!(FillConsoleOutputCharacterW(handle->handle,
L'\x20',
count,
start,
&written) &&
FillConsoleOutputAttribute(handle->handle,
info.wAttributes,
written,
start,
&written))) {
if (GetLastError() == ERROR_INVALID_PARAMETER) {
goto retry;
} else {
*error = GetLastError();
return -1;
}
}
return 0;
}
static int uv_tty_set_style(uv_tty_t* handle, DWORD* error) {
unsigned short argc = handle->ansi_csi_argc;
unsigned short* argv = handle->ansi_csi_argv;
int i;
CONSOLE_SCREEN_BUFFER_INFO info;
char fg_color = -1, bg_color = -1;
char fg_bright = -1, bg_bright = -1;
if (argc == 0) {
fg_color = 7;
bg_color = 0;
fg_bright = 0;
bg_bright = 0;
}
for (i = 0; i < argc; i++) {
short arg = argv[i];
if (arg == 0) {
fg_color = 7;
bg_color = 0;
fg_bright = 0;
bg_bright = 0;
} else if (arg == 1) {
fg_bright = 1;
} else if (arg == 2) {
fg_bright = 0;
bg_bright = 0;
} else if (arg == 5) {
bg_bright = 1;
} else if (arg == 21 || arg == 22) {
fg_bright = 0;
} else if (arg == 25) {
bg_bright = 0;
} else if (arg >= 30 && arg <= 37) {
fg_color = arg - 30;
} else if (arg == 39) {
fg_color = 7;
fg_bright = 0;
} else if (arg >= 40 && arg <= 47) {
bg_color = arg - 40;
} else if (arg == 49) {
bg_color = 0;
bg_bright = 0;
} else if (arg >= 90 && arg <= 97) {
fg_bright = 1;
fg_color = arg - 90;
} else if (arg >= 100 && arg <= 107) {
bg_bright = 1;
bg_color = arg - 100;
}
}
if (fg_color == -1 && bg_color == -1 && fg_bright == -1 &&
bg_bright == -1) {
return 0;
}
if (!GetConsoleScreenBufferInfo(handle->handle, &info)) {
*error = GetLastError();
return -1;
}
if (fg_color != -1) {
info.wAttributes &= ~(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
if (fg_color & 1) info.wAttributes |= FOREGROUND_RED;
if (fg_color & 2) info.wAttributes |= FOREGROUND_GREEN;
if (fg_color & 4) info.wAttributes |= FOREGROUND_BLUE;
}
if (fg_bright != -1) {
if (fg_bright) {
info.wAttributes |= FOREGROUND_INTENSITY;
} else {
info.wAttributes &= ~FOREGROUND_INTENSITY;
}
}
if (bg_color != -1) {
info.wAttributes &= ~(BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE);
if (bg_color & 1) info.wAttributes |= BACKGROUND_RED;
if (bg_color & 2) info.wAttributes |= BACKGROUND_GREEN;
if (bg_color & 4) info.wAttributes |= BACKGROUND_BLUE;
}
if (bg_bright != -1) {
if (bg_bright) {
info.wAttributes |= BACKGROUND_INTENSITY;
} else {
info.wAttributes &= ~BACKGROUND_INTENSITY;
}
}
if (!SetConsoleTextAttribute(handle->handle, info.wAttributes)) {
*error = GetLastError();
return -1;
}
return 0;
}
static int uv_tty_save_state(uv_tty_t* handle, unsigned char save_attributes,
DWORD* error) {
CONSOLE_SCREEN_BUFFER_INFO info;
if (*error != ERROR_SUCCESS) {
return -1;
}
if (!GetConsoleScreenBufferInfo(handle->handle, &info)) {
*error = GetLastError();
return -1;
}
uv_tty_update_virtual_window(&info);
handle->saved_position.X = info.dwCursorPosition.X;
handle->saved_position.Y = info.dwCursorPosition.Y - uv_tty_virtual_offset;
handle->flags |= UV_HANDLE_TTY_SAVED_POSITION;
if (save_attributes) {
handle->saved_attributes = info.wAttributes &
(FOREGROUND_INTENSITY | BACKGROUND_INTENSITY);
handle->flags |= UV_HANDLE_TTY_SAVED_ATTRIBUTES;
}
return 0;
}
static int uv_tty_restore_state(uv_tty_t* handle,
unsigned char restore_attributes, DWORD* error) {
CONSOLE_SCREEN_BUFFER_INFO info;
WORD new_attributes;
if (*error != ERROR_SUCCESS) {
return -1;
}
if (handle->flags & UV_HANDLE_TTY_SAVED_POSITION) {
if (uv_tty_move_caret(handle,
handle->saved_position.X,
0,
handle->saved_position.Y,
0,
error) != 0) {
return -1;
}
}
if (restore_attributes &&
(handle->flags & UV_HANDLE_TTY_SAVED_ATTRIBUTES)) {
if (!GetConsoleScreenBufferInfo(handle->handle, &info)) {
*error = GetLastError();
return -1;
}
new_attributes = info.wAttributes;
new_attributes &= ~(FOREGROUND_INTENSITY | BACKGROUND_INTENSITY);
new_attributes |= handle->saved_attributes;
if (!SetConsoleTextAttribute(handle->handle, new_attributes)) {
*error = GetLastError();
return -1;
}
}
return 0;
}
static int uv_tty_write_bufs(uv_tty_t* handle, uv_buf_t bufs[], int bufcnt,
DWORD* error) {
WCHAR utf16_buf[8192];
DWORD utf16_buf_used = 0;
int i;
#define FLUSH_TEXT() \
do { \
if (utf16_buf_used > 0) { \
uv_tty_emit_text(handle, utf16_buf, utf16_buf_used, error); \
utf16_buf_used = 0; \
} \
} while (0)
unsigned char utf8_bytes_left = handle->utf8_bytes_left;
unsigned int utf8_codepoint = handle->utf8_codepoint;
unsigned char previous_eol = handle->previous_eol;
unsigned char ansi_parser_state = handle->ansi_parser_state;
*error = ERROR_SUCCESS;
EnterCriticalSection(&uv_tty_output_lock);
for (i = 0; i < bufcnt; i++) {
uv_buf_t buf = bufs[i];
unsigned int j;
for (j = 0; j < buf.len; j++) {
unsigned char c = buf.base[j];
if (utf8_bytes_left == 0) {
DWORD first_zero_bit;
unsigned char not_c = ~c;
#ifdef _MSC_VER
if (_BitScanReverse(&first_zero_bit, not_c)) {
#else
if (c != 0) {
first_zero_bit = (sizeof(int) * 8) - 1 - __builtin_clz(not_c);
#endif
if (first_zero_bit == 7) {
utf8_codepoint = (unsigned int) c;
} else if (first_zero_bit <= 5) {
utf8_codepoint = (0xff >> (8 - first_zero_bit)) & c;
utf8_bytes_left = (char) (6 - first_zero_bit);
} else {
utf8_codepoint = UNICODE_REPLACEMENT_CHARACTER;
}
} else {
utf8_codepoint = UNICODE_REPLACEMENT_CHARACTER;
}
} else if ((c & 0xc0) == 0x80) {
utf8_bytes_left--;
utf8_codepoint <<= 6;
utf8_codepoint |= ((unsigned int) c & 0x3f);
} else {
utf8_bytes_left = 0;
utf8_codepoint = UNICODE_REPLACEMENT_CHARACTER;
j--;
}
if (utf8_bytes_left != 0) {
continue;
}
if (ansi_parser_state == ANSI_NORMAL) {
switch (utf8_codepoint) {
case '\033':
ansi_parser_state = ANSI_ESCAPE_SEEN;
continue;
case 0233:
ansi_parser_state = ANSI_CSI;
handle->ansi_csi_argc = 0;
continue;
}
} else if (ansi_parser_state == ANSI_ESCAPE_SEEN) {
switch (utf8_codepoint) {
case '[':
ansi_parser_state = ANSI_CSI;
handle->ansi_csi_argc = 0;
continue;
case '^':
case '_':
case 'P':
case ']':
ansi_parser_state = ANSI_ST_CONTROL;
continue;
case '\033':
continue;
case 'c':
FLUSH_TEXT();
uv_tty_reset(handle, error);
ansi_parser_state = ANSI_NORMAL;
continue;
case '7':
FLUSH_TEXT();
uv_tty_save_state(handle, 1, error);
ansi_parser_state = ANSI_NORMAL;
continue;
case '8':
FLUSH_TEXT();
uv_tty_restore_state(handle, 1, error);
ansi_parser_state = ANSI_NORMAL;
continue;
default:
if (utf8_codepoint >= '@' && utf8_codepoint <= '_') {
ansi_parser_state = ANSI_NORMAL;
continue;
} else {
ansi_parser_state = ANSI_NORMAL;
}
}
} else if (ansi_parser_state & ANSI_CSI) {
if (!(ansi_parser_state & ANSI_IGNORE)) {
if (utf8_codepoint >= '0' && utf8_codepoint <= '9') {
if (!(ansi_parser_state & ANSI_IN_ARG)) {
if (handle->ansi_csi_argc >= ARRAY_SIZE(handle->ansi_csi_argv)) {
ansi_parser_state |= ANSI_IGNORE;
continue;
}
ansi_parser_state |= ANSI_IN_ARG;
handle->ansi_csi_argc++;
handle->ansi_csi_argv[handle->ansi_csi_argc - 1] =
(unsigned short) utf8_codepoint - '0';
continue;
} else {
uint32_t value = 10 *
handle->ansi_csi_argv[handle->ansi_csi_argc - 1];
if (value > UINT16_MAX) {
ansi_parser_state |= ANSI_IGNORE;
continue;
}
handle->ansi_csi_argv[handle->ansi_csi_argc - 1] =
(unsigned short) value + (utf8_codepoint - '0');
continue;
}
} else if (utf8_codepoint == ';') {
if (ansi_parser_state & ANSI_IN_ARG) {
ansi_parser_state &= ~ANSI_IN_ARG;
continue;
} else {
if (handle->ansi_csi_argc >= ARRAY_SIZE(handle->ansi_csi_argv)) {
ansi_parser_state |= ANSI_IGNORE;
continue;
}
handle->ansi_csi_argc++;
handle->ansi_csi_argv[handle->ansi_csi_argc - 1] = 0;
continue;
}
} else if (utf8_codepoint >= '@' && utf8_codepoint <= '~' &&
(handle->ansi_csi_argc > 0 || utf8_codepoint != '[')) {
int x, y, d;
switch (utf8_codepoint) {
case 'A':
FLUSH_TEXT();
y = -(handle->ansi_csi_argc ? handle->ansi_csi_argv[0] : 1);
uv_tty_move_caret(handle, 0, 1, y, 1, error);
break;
case 'B':
FLUSH_TEXT();
y = handle->ansi_csi_argc ? handle->ansi_csi_argv[0] : 1;
uv_tty_move_caret(handle, 0, 1, y, 1, error);
break;
case 'C':
FLUSH_TEXT();
x = handle->ansi_csi_argc ? handle->ansi_csi_argv[0] : 1;
uv_tty_move_caret(handle, x, 1, 0, 1, error);
break;
case 'D':
FLUSH_TEXT();
x = -(handle->ansi_csi_argc ? handle->ansi_csi_argv[0] : 1);
uv_tty_move_caret(handle, x, 1, 0, 1, error);
break;
case 'E':
FLUSH_TEXT();
y = handle->ansi_csi_argc ? handle->ansi_csi_argv[0] : 1;
uv_tty_move_caret(handle, 0, 0, y, 1, error);
break;
case 'F':
FLUSH_TEXT();
y = -(handle->ansi_csi_argc ? handle->ansi_csi_argv[0] : 1);
uv_tty_move_caret(handle, 0, 0, y, 1, error);
break;
case 'G':
FLUSH_TEXT();
x = (handle->ansi_csi_argc >= 1 && handle->ansi_csi_argv[0])
? handle->ansi_csi_argv[0] - 1 : 0;
uv_tty_move_caret(handle, x, 0, 0, 1, error);
break;
case 'H':
case 'f':
FLUSH_TEXT();
y = (handle->ansi_csi_argc >= 1 && handle->ansi_csi_argv[0])
? handle->ansi_csi_argv[0] - 1 : 0;
x = (handle->ansi_csi_argc >= 2 && handle->ansi_csi_argv[1])
? handle->ansi_csi_argv[1] - 1 : 0;
uv_tty_move_caret(handle, x, 0, y, 0, error);
break;
case 'J':
FLUSH_TEXT();
d = handle->ansi_csi_argc ? handle->ansi_csi_argv[0] : 0;
if (d >= 0 && d <= 2) {
uv_tty_clear(handle, d, 1, error);
}
break;
case 'K':
FLUSH_TEXT();
d = handle->ansi_csi_argc ? handle->ansi_csi_argv[0] : 0;
if (d >= 0 && d <= 2) {
uv_tty_clear(handle, d, 0, error);
}
break;
case 'm':
FLUSH_TEXT();
uv_tty_set_style(handle, error);
break;
case 's':
FLUSH_TEXT();
uv_tty_save_state(handle, 0, error);
break;
case 'u':
FLUSH_TEXT();
uv_tty_restore_state(handle, 0, error);
break;
}
ansi_parser_state = ANSI_NORMAL;
continue;
} else {
ansi_parser_state |= ANSI_IGNORE;
continue;
}
} else {
if (utf8_codepoint >= '@' && utf8_codepoint <= '~') {
ansi_parser_state = ANSI_NORMAL;
}
continue;
}
} else if (ansi_parser_state & ANSI_ST_CONTROL) {
if (ansi_parser_state & ANSI_IN_STRING) {
if (!(ansi_parser_state & ANSI_BACKSLASH_SEEN)) {
if (utf8_codepoint == '"') {
ansi_parser_state &= ~ANSI_IN_STRING;
} else if (utf8_codepoint == '\\') {
ansi_parser_state |= ANSI_BACKSLASH_SEEN;
}
} else {
ansi_parser_state &= ~ANSI_BACKSLASH_SEEN;
}
} else {
if (utf8_codepoint == '\007' || (utf8_codepoint == '\\' &&
(ansi_parser_state & ANSI_ESCAPE_SEEN))) {
ansi_parser_state = ANSI_NORMAL;
} else if (utf8_codepoint == '\033') {
ansi_parser_state |= ANSI_ESCAPE_SEEN;
} else if (utf8_codepoint == '"') {
ansi_parser_state |= ANSI_IN_STRING;
ansi_parser_state &= ~ANSI_ESCAPE_SEEN;
ansi_parser_state &= ~ANSI_BACKSLASH_SEEN;
} else {
ansi_parser_state &= ~ANSI_ESCAPE_SEEN;
}
}
continue;
} else {
abort();
}
if (utf8_codepoint > 0xffff) {
utf8_codepoint = UNICODE_REPLACEMENT_CHARACTER;
}
if (utf8_codepoint == 0x0a || utf8_codepoint == 0x0d) {
if (previous_eol == 0 || utf8_codepoint == previous_eol) {
if (2 > ARRAY_SIZE(utf16_buf) - utf16_buf_used) {
uv_tty_emit_text(handle, utf16_buf, utf16_buf_used, error);
utf16_buf_used = 0;
}
utf16_buf[utf16_buf_used++] = L'\r';
utf16_buf[utf16_buf_used++] = L'\n';
previous_eol = (char) utf8_codepoint;
} else {
previous_eol = 0;
}
} else if (utf8_codepoint <= 0xffff) {
if (1 > ARRAY_SIZE(utf16_buf) - utf16_buf_used) {
uv_tty_emit_text(handle, utf16_buf, utf16_buf_used, error);
utf16_buf_used = 0;
}
utf16_buf[utf16_buf_used++] = (WCHAR) utf8_codepoint;
previous_eol = 0;
}
}
}
FLUSH_TEXT();
handle->utf8_bytes_left = utf8_bytes_left;
handle->utf8_codepoint = utf8_codepoint;
handle->previous_eol = previous_eol;
handle->ansi_parser_state = ansi_parser_state;
LeaveCriticalSection(&uv_tty_output_lock);
if (*error == STATUS_SUCCESS) {
return 0;
} else {
return -1;
}
#undef FLUSH_TEXT
}
int uv_tty_write(uv_loop_t* loop, uv_write_t* req, uv_tty_t* handle,
uv_buf_t bufs[], int bufcnt, uv_write_cb cb) {
DWORD error;
uv_req_init(loop, (uv_req_t*) req);
req->type = UV_WRITE;
req->handle = (uv_stream_t*) handle;
req->cb = cb;
handle->reqs_pending++;
handle->write_reqs_pending++;
REGISTER_HANDLE_REQ(loop, handle, req);
req->queued_bytes = 0;
if (!uv_tty_write_bufs(handle, bufs, bufcnt, &error)) {
SET_REQ_SUCCESS(req);
} else {
SET_REQ_ERROR(req, error);
}
uv_insert_pending_req(loop, (uv_req_t*) req);
return 0;
}
void uv_process_tty_write_req(uv_loop_t* loop, uv_tty_t* handle,
uv_write_t* req) {
int err;
handle->write_queue_size -= req->queued_bytes;
UNREGISTER_HANDLE_REQ(loop, handle, req);
if (req->cb) {
err = GET_REQ_ERROR(req);
req->cb(req, uv_translate_sys_error(err));
}
handle->write_reqs_pending--;
if (handle->shutdown_req != NULL &&
handle->write_reqs_pending == 0) {
uv_want_endgame(loop, (uv_handle_t*)handle);
}
DECREASE_PENDING_REQ_COUNT(handle);
}
void uv_tty_close(uv_tty_t* handle) {
CloseHandle(handle->handle);
if (handle->flags & UV_HANDLE_READING)
uv_tty_read_stop(handle);
handle->flags &= ~(UV_HANDLE_READABLE | UV_HANDLE_WRITABLE);
uv__handle_closing(handle);
if (handle->reqs_pending == 0) {
uv_want_endgame(handle->loop, (uv_handle_t*) handle);
}
}
void uv_tty_endgame(uv_loop_t* loop, uv_tty_t* handle) {
if (!(handle->flags && UV_HANDLE_TTY_READABLE) &&
handle->shutdown_req != NULL &&
handle->write_reqs_pending == 0) {
UNREGISTER_HANDLE_REQ(loop, handle, handle->shutdown_req);
if (handle->shutdown_req->cb) {
if (handle->flags & UV__HANDLE_CLOSING) {
handle->shutdown_req->cb(handle->shutdown_req, UV_ECANCELED);
} else {
handle->shutdown_req->cb(handle->shutdown_req, 0);
}
}
handle->shutdown_req = NULL;
DECREASE_PENDING_REQ_COUNT(handle);
return;
}
if (handle->flags & UV__HANDLE_CLOSING &&
handle->reqs_pending == 0) {
assert(!(handle->flags & UV_HANDLE_TTY_READABLE) ||
handle->read_line_handle == NULL);
assert(!(handle->flags & UV_HANDLE_TTY_READABLE) ||
handle->read_raw_wait == NULL);
assert(!(handle->flags & UV_HANDLE_CLOSED));
uv__handle_close(handle);
}
}
void uv_process_tty_accept_req(uv_loop_t* loop, uv_tty_t* handle,
uv_req_t* raw_req) {
abort();
}
void uv_process_tty_connect_req(uv_loop_t* loop, uv_tty_t* handle,
uv_connect_t* req) {
abort();
}
void uv_tty_reset_mode(void) {
;
}