Utilities/cmlibuv/src/win/tty.c

   1 /* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
   2  *
   3  * Permission is hereby granted, free of charge, to any person obtaining a copy
   4  * of this software and associated documentation files (the "Software"), to
   5  * deal in the Software without restriction, including without limitation the
   6  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
   7  * sell copies of the Software, and to permit persons to whom the Software is
   8  * furnished to do so, subject to the following conditions:
   9  *
  10  * The above copyright notice and this permission notice shall be included in
  11  * all copies or substantial portions of the Software.
  12  *
  13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  14  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  15  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  16  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  17  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  18  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  19  * IN THE SOFTWARE.
  20  */
  21
  22 #include <assert.h>
  23 #include <io.h>
  24 #include <string.h>
  25 #include <stdlib.h>
  26
  27 #if defined(_MSC_VER) && _MSC_VER < 1600
  28 # include "uv/stdint-msvc2008.h"
  29 #else
  30 # include <stdint.h>
  31 #endif
  32
  33 #ifndef COMMON_LVB_REVERSE_VIDEO
  34 # define COMMON_LVB_REVERSE_VIDEO 0x4000
  35 #endif
  36
  37 #include "uv.h"
  38 #include "internal.h"
  39 #include "handle-inl.h"
  40 #include "stream-inl.h"
  41 #include "req-inl.h"
  42
  43 #ifndef InterlockedOr
  44 # define InterlockedOr _InterlockedOr
  45 #endif
  46
  47 #define UNICODE_REPLACEMENT_CHARACTER (0xfffd)
  48
  49 #define ANSI_NORMAL           0x0000
  50 #define ANSI_ESCAPE_SEEN      0x0002
  51 #define ANSI_CSI              0x0004
  52 #define ANSI_ST_CONTROL       0x0008
  53 #define ANSI_IGNORE           0x0010
  54 #define ANSI_IN_ARG           0x0020
  55 #define ANSI_IN_STRING        0x0040
  56 #define ANSI_BACKSLASH_SEEN   0x0080
  57 #define ANSI_EXTENSION        0x0100
  58 #define ANSI_DECSCUSR         0x0200
  59
  60 #define MAX_INPUT_BUFFER_LENGTH 8192
  61 #define MAX_CONSOLE_CHAR 8192
  62
  63 #ifndef ENABLE_VIRTUAL_TERMINAL_PROCESSING
  64 #define ENABLE_VIRTUAL_TERMINAL_PROCESSING 0x0004
  65 #endif
  66
  67 #define CURSOR_SIZE_SMALL     25
  68 #define CURSOR_SIZE_LARGE     100
  69
  70 static void uv__tty_capture_initial_style(
  71     CONSOLE_SCREEN_BUFFER_INFO* screen_buffer_info,
  72     CONSOLE_CURSOR_INFO* cursor_info);
  73 static void uv__tty_update_virtual_window(CONSOLE_SCREEN_BUFFER_INFO* info);
  74 static int uv__cancel_read_console(uv_tty_t* handle);
  75
  76
  77 /* Null uv_buf_t */
  78 static const uv_buf_t uv_null_buf_ = { 0, NULL };
  79
  80 enum uv__read_console_status_e {
  81   NOT_STARTED,
  82   IN_PROGRESS,
  83   TRAP_REQUESTED,
  84   COMPLETED
  85 };
  86
  87 static volatile LONG uv__read_console_status = NOT_STARTED;
  88 static volatile LONG uv__restore_screen_state;
  89 static CONSOLE_SCREEN_BUFFER_INFO uv__saved_screen_state;
  90
  91
  92 /*
  93  * The console virtual window.
  94  *
  95  * Normally cursor movement in windows is relative to the console screen buffer,
  96  * e.g. the application is allowed to overwrite the 'history'. This is very
  97  * inconvenient, it makes absolute cursor movement pretty useless. There is
  98  * also the concept of 'client rect' which is defined by the actual size of
  99  * the console window and the scroll position of the screen buffer, but it's
 100  * very volatile because it changes when the user scrolls.
 101  *
 102  * To make cursor movement behave sensibly we define a virtual window to which
 103  * cursor movement is confined. The virtual window is always as wide as the
 104  * console screen buffer, but it's height is defined by the size of the
 105  * console window. The top of the virtual window aligns with the position
 106  * of the caret when the first stdout/err handle is created, unless that would
 107  * mean that it would extend beyond the bottom of the screen buffer -  in that
 108  * that case it's located as far down as possible.
 109  *
 110  * When the user writes a long text or many newlines, such that the output
 111  * reaches beyond the bottom of the virtual window, the virtual window is
 112  * shifted downwards, but not resized.
 113  *
 114  * Since all tty i/o happens on the same console, this window is shared
 115  * between all stdout/stderr handles.
 116  */
 117
 118 static int uv_tty_virtual_offset = -1;
 119 static int uv_tty_virtual_height = -1;
 120 static int uv_tty_virtual_width = -1;
 121
 122 /* The console window size
 123  * We keep this separate from uv_tty_virtual_*. We use those values to only
 124  * handle signalling SIGWINCH
 125  */
 126
 127 static HANDLE uv__tty_console_handle = INVALID_HANDLE_VALUE;
 128 static int uv__tty_console_height = -1;
 129 static int uv__tty_console_width = -1;
 130 static HANDLE uv__tty_console_resized = INVALID_HANDLE_VALUE;
 131 static uv_mutex_t uv__tty_console_resize_mutex;
 132
 133 static DWORD WINAPI uv__tty_console_resize_message_loop_thread(void* param);
 134 static void CALLBACK uv__tty_console_resize_event(HWINEVENTHOOK hWinEventHook,
 135                                                   DWORD event,
 136                                                   HWND hwnd,
 137                                                   LONG idObject,
 138                                                   LONG idChild,
 139                                                   DWORD dwEventThread,
 140                                                   DWORD dwmsEventTime);
 141 static DWORD WINAPI uv__tty_console_resize_watcher_thread(void* param);
 142 static void uv__tty_console_signal_resize(void);
 143
 144 /* We use a semaphore rather than a mutex or critical section because in some
 145    cases (uv__cancel_read_console) we need take the lock in the main thread and
 146    release it in another thread. Using a semaphore ensures that in such
 147    scenario the main thread will still block when trying to acquire the lock. */
 148 static uv_sem_t uv_tty_output_lock;
 149
 150 static WORD uv_tty_default_text_attributes =
 151     FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
 152
 153 static char uv_tty_default_fg_color = 7;
 154 static char uv_tty_default_bg_color = 0;
 155 static char uv_tty_default_fg_bright = 0;
 156 static char uv_tty_default_bg_bright = 0;
 157 static char uv_tty_default_inverse = 0;
 158
 159 static CONSOLE_CURSOR_INFO uv_tty_default_cursor_info;
 160
 161 /* Determine whether or not ANSI support is enabled. */
 162 static BOOL uv__need_check_vterm_state = TRUE;
 163 static uv_tty_vtermstate_t uv__vterm_state = UV_TTY_UNSUPPORTED;
 164 static void uv__determine_vterm_state(HANDLE handle);
 165
 166 void uv__console_init(void) {
 167   if (uv_sem_init(&uv_tty_output_lock, 1))
 168     abort();
 169   uv__tty_console_handle = CreateFileW(L"CONOUT$",
 170                                        GENERIC_READ | GENERIC_WRITE,
 171                                        FILE_SHARE_WRITE,
 172                                        0,
 173                                        OPEN_EXISTING,
 174                                        0,
 175                                        0);
 176   if (uv__tty_console_handle != INVALID_HANDLE_VALUE) {
 177     CONSOLE_SCREEN_BUFFER_INFO sb_info;
 178     QueueUserWorkItem(uv__tty_console_resize_message_loop_thread,
 179                       NULL,
 180                       WT_EXECUTELONGFUNCTION);
 181     uv_mutex_init(&uv__tty_console_resize_mutex);
 182     if (GetConsoleScreenBufferInfo(uv__tty_console_handle, &sb_info)) {
 183       uv__tty_console_width = sb_info.dwSize.X;
 184       uv__tty_console_height = sb_info.srWindow.Bottom - sb_info.srWindow.Top + 1;
 185     }
 186   }
 187 }
 188
 189
 190 int uv_tty_init(uv_loop_t* loop, uv_tty_t* tty, uv_file fd, int unused) {
 191   BOOL readable;
 192   DWORD NumberOfEvents;
 193   HANDLE handle;
 194   CONSOLE_SCREEN_BUFFER_INFO screen_buffer_info;
 195   CONSOLE_CURSOR_INFO cursor_info;
 196   (void)unused;
 197
 198   uv__once_init();
 199   handle = (HANDLE) uv__get_osfhandle(fd);
 200   if (handle == INVALID_HANDLE_VALUE)
 201     return UV_EBADF;
 202
 203   if (fd <= 2) {
 204     /* In order to avoid closing a stdio file descriptor 0-2, duplicate the
 205      * underlying OS handle and forget about the original fd.
 206      * We could also opt to use the original OS handle and just never close it,
 207      * but then there would be no reliable way to cancel pending read operations
 208      * upon close.
 209      */
 210     if (!DuplicateHandle(INVALID_HANDLE_VALUE,
 211                          handle,
 212                          INVALID_HANDLE_VALUE,
 213                          &handle,
 214                          0,
 215                          FALSE,
 216                          DUPLICATE_SAME_ACCESS))
 217       return uv_translate_sys_error(GetLastError());
 218     fd = -1;
 219   }
 220
 221   readable = GetNumberOfConsoleInputEvents(handle, &NumberOfEvents);
 222   if (!readable) {
 223     /* Obtain the screen buffer info with the output handle. */
 224     if (!GetConsoleScreenBufferInfo(handle, &screen_buffer_info)) {
 225       return uv_translate_sys_error(GetLastError());
 226     }
 227
 228     /* Obtain the cursor info with the output handle. */
 229     if (!GetConsoleCursorInfo(handle, &cursor_info)) {
 230       return uv_translate_sys_error(GetLastError());
 231     }
 232
 233     /* Obtain the tty_output_lock because the virtual window state is shared
 234      * between all uv_tty_t handles. */
 235     uv_sem_wait(&uv_tty_output_lock);
 236
 237     if (uv__need_check_vterm_state)
 238       uv__determine_vterm_state(handle);
 239
 240     /* Remember the original console text attributes and cursor info. */
 241     uv__tty_capture_initial_style(&screen_buffer_info, &cursor_info);
 242
 243     uv__tty_update_virtual_window(&screen_buffer_info);
 244
 245     uv_sem_post(&uv_tty_output_lock);
 246   }
 247
 248
 249   uv__stream_init(loop, (uv_stream_t*) tty, UV_TTY);
 250   uv__connection_init((uv_stream_t*) tty);
 251
 252   tty->handle = handle;
 253   tty->u.fd = fd;
 254   tty->reqs_pending = 0;
 255   tty->flags |= UV_HANDLE_BOUND;
 256
 257   if (readable) {
 258     /* Initialize TTY input specific fields. */
 259     tty->flags |= UV_HANDLE_TTY_READABLE | UV_HANDLE_READABLE;
 260     /* TODO: remove me in v2.x. */
 261     tty->tty.rd.unused_ = NULL;
 262     tty->tty.rd.read_line_buffer = uv_null_buf_;
 263     tty->tty.rd.read_raw_wait = NULL;
 264
 265     /* Init keycode-to-vt100 mapper state. */
 266     tty->tty.rd.last_key_len = 0;
 267     tty->tty.rd.last_key_offset = 0;
 268     tty->tty.rd.last_utf16_high_surrogate = 0;
 269     memset(&tty->tty.rd.last_input_record, 0, sizeof tty->tty.rd.last_input_record);
 270   } else {
 271     /* TTY output specific fields. */
 272     tty->flags |= UV_HANDLE_WRITABLE;
 273
 274     /* Init utf8-to-utf16 conversion state. */
 275     tty->tty.wr.utf8_bytes_left = 0;
 276     tty->tty.wr.utf8_codepoint = 0;
 277
 278     /* Initialize eol conversion state */
 279     tty->tty.wr.previous_eol = 0;
 280
 281     /* Init ANSI parser state. */
 282     tty->tty.wr.ansi_parser_state = ANSI_NORMAL;
 283   }
 284
 285   return 0;
 286 }
 287
 288
 289 /* Set the default console text attributes based on how the console was
 290  * configured when libuv started.
 291  */
 292 static void uv__tty_capture_initial_style(
 293     CONSOLE_SCREEN_BUFFER_INFO* screen_buffer_info,
 294     CONSOLE_CURSOR_INFO* cursor_info) {
 295   static int style_captured = 0;
 296
 297   /* Only do this once.
 298      Assumption: Caller has acquired uv_tty_output_lock. */
 299   if (style_captured)
 300     return;
 301
 302   /* Save raw win32 attributes. */
 303   uv_tty_default_text_attributes = screen_buffer_info->wAttributes;
 304
 305   /* Convert black text on black background to use white text. */
 306   if (uv_tty_default_text_attributes == 0)
 307     uv_tty_default_text_attributes = 7;
 308
 309   /* Convert Win32 attributes to ANSI colors. */
 310   uv_tty_default_fg_color = 0;
 311   uv_tty_default_bg_color = 0;
 312   uv_tty_default_fg_bright = 0;
 313   uv_tty_default_bg_bright = 0;
 314   uv_tty_default_inverse = 0;
 315
 316   if (uv_tty_default_text_attributes & FOREGROUND_RED)
 317     uv_tty_default_fg_color |= 1;
 318
 319   if (uv_tty_default_text_attributes & FOREGROUND_GREEN)
 320     uv_tty_default_fg_color |= 2;
 321
 322   if (uv_tty_default_text_attributes & FOREGROUND_BLUE)
 323     uv_tty_default_fg_color |= 4;
 324
 325   if (uv_tty_default_text_attributes & BACKGROUND_RED)
 326     uv_tty_default_bg_color |= 1;
 327
 328   if (uv_tty_default_text_attributes & BACKGROUND_GREEN)
 329     uv_tty_default_bg_color |= 2;
 330
 331   if (uv_tty_default_text_attributes & BACKGROUND_BLUE)
 332     uv_tty_default_bg_color |= 4;
 333
 334   if (uv_tty_default_text_attributes & FOREGROUND_INTENSITY)
 335     uv_tty_default_fg_bright = 1;
 336
 337   if (uv_tty_default_text_attributes & BACKGROUND_INTENSITY)
 338     uv_tty_default_bg_bright = 1;
 339
 340   if (uv_tty_default_text_attributes & COMMON_LVB_REVERSE_VIDEO)
 341     uv_tty_default_inverse = 1;
 342
 343   /* Save the cursor size and the cursor state. */
 344   uv_tty_default_cursor_info = *cursor_info;
 345
 346   style_captured = 1;
 347 }
 348
 349
 350 int uv_tty_set_mode(uv_tty_t* tty, uv_tty_mode_t mode) {
 351   DWORD flags;
 352   unsigned char was_reading;
 353   uv_alloc_cb alloc_cb;
 354   uv_read_cb read_cb;
 355   int err;
 356
 357   if (!(tty->flags & UV_HANDLE_TTY_READABLE)) {
 358     return UV_EINVAL;
 359   }
 360
 361   if (!!mode == !!(tty->flags & UV_HANDLE_TTY_RAW)) {
 362     return 0;
 363   }
 364
 365   switch (mode) {
 366     case UV_TTY_MODE_NORMAL:
 367       flags = ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT;
 368       break;
 369     case UV_TTY_MODE_RAW:
 370       flags = ENABLE_WINDOW_INPUT;
 371       break;
 372     case UV_TTY_MODE_IO:
 373       return UV_ENOTSUP;
 374     default:
 375       return UV_EINVAL;
 376   }
 377
 378   /* If currently reading, stop, and restart reading. */
 379   if (tty->flags & UV_HANDLE_READING) {
 380     was_reading = 1;
 381     alloc_cb = tty->alloc_cb;
 382     read_cb = tty->read_cb;
 383     err = uv__tty_read_stop(tty);
 384     if (err) {
 385       return uv_translate_sys_error(err);
 386     }
 387   } else {
 388     was_reading = 0;
 389     alloc_cb = NULL;
 390     read_cb = NULL;
 391   }
 392
 393   uv_sem_wait(&uv_tty_output_lock);
 394   if (!SetConsoleMode(tty->handle, flags)) {
 395     err = uv_translate_sys_error(GetLastError());
 396     uv_sem_post(&uv_tty_output_lock);
 397     return err;
 398   }
 399   uv_sem_post(&uv_tty_output_lock);
 400
 401   /* Update flag. */
 402   tty->flags &= ~UV_HANDLE_TTY_RAW;
 403   tty->flags |= mode ? UV_HANDLE_TTY_RAW : 0;
 404
 405   /* If we just stopped reading, restart. */
 406   if (was_reading) {
 407     err = uv__tty_read_start(tty, alloc_cb, read_cb);
 408     if (err) {
 409       return uv_translate_sys_error(err);
 410     }
 411   }
 412
 413   return 0;
 414 }
 415
 416
 417 int uv_tty_get_winsize(uv_tty_t* tty, int* width, int* height) {
 418   CONSOLE_SCREEN_BUFFER_INFO info;
 419
 420   if (!GetConsoleScreenBufferInfo(tty->handle, &info)) {
 421     return uv_translate_sys_error(GetLastError());
 422   }
 423
 424   uv_sem_wait(&uv_tty_output_lock);
 425   uv__tty_update_virtual_window(&info);
 426   uv_sem_post(&uv_tty_output_lock);
 427
 428   *width = uv_tty_virtual_width;
 429   *height = uv_tty_virtual_height;
 430
 431   return 0;
 432 }
 433
 434
 435 static void CALLBACK uv_tty_post_raw_read(void* data, BOOLEAN didTimeout) {
 436   uv_loop_t* loop;
 437   uv_tty_t* handle;
 438   uv_req_t* req;
 439
 440   assert(data);
 441   assert(!didTimeout);
 442
 443   req = (uv_req_t*) data;
 444   handle = (uv_tty_t*) req->data;
 445   loop = handle->loop;
 446
 447   UnregisterWait(handle->tty.rd.read_raw_wait);
 448   handle->tty.rd.read_raw_wait = NULL;
 449
 450   SET_REQ_SUCCESS(req);
 451   POST_COMPLETION_FOR_REQ(loop, req);
 452 }
 453
 454
 455 static void uv__tty_queue_read_raw(uv_loop_t* loop, uv_tty_t* handle) {
 456   uv_read_t* req;
 457   BOOL r;
 458
 459   assert(handle->flags & UV_HANDLE_READING);
 460   assert(!(handle->flags & UV_HANDLE_READ_PENDING));
 461
 462   assert(handle->handle && handle->handle != INVALID_HANDLE_VALUE);
 463
 464   handle->tty.rd.read_line_buffer = uv_null_buf_;
 465
 466   req = &handle->read_req;
 467   memset(&req->u.io.overlapped, 0, sizeof(req->u.io.overlapped));
 468
 469   r = RegisterWaitForSingleObject(&handle->tty.rd.read_raw_wait,
 470                                   handle->handle,
 471                                   uv_tty_post_raw_read,
 472                                   (void*) req,
 473                                   INFINITE,
 474                                   WT_EXECUTEINWAITTHREAD | WT_EXECUTEONLYONCE);
 475   if (!r) {
 476     handle->tty.rd.read_raw_wait = NULL;
 477     SET_REQ_ERROR(req, GetLastError());
 478     uv__insert_pending_req(loop, (uv_req_t*)req);
 479   }
 480
 481   handle->flags |= UV_HANDLE_READ_PENDING;
 482   handle->reqs_pending++;
 483 }
 484
 485
 486 static DWORD CALLBACK uv_tty_line_read_thread(void* data) {
 487   uv_loop_t* loop;
 488   uv_tty_t* handle;
 489   uv_req_t* req;
 490   DWORD bytes, read_bytes;
 491   WCHAR utf16[MAX_INPUT_BUFFER_LENGTH / 3];
 492   DWORD chars, read_chars;
 493   LONG status;
 494   COORD pos;
 495   BOOL read_console_success;
 496
 497   assert(data);
 498
 499   req = (uv_req_t*) data;
 500   handle = (uv_tty_t*) req->data;
 501   loop = handle->loop;
 502
 503   assert(handle->tty.rd.read_line_buffer.base != NULL);
 504   assert(handle->tty.rd.read_line_buffer.len > 0);
 505
 506   /* ReadConsole can't handle big buffers. */
 507   if (handle->tty.rd.read_line_buffer.len < MAX_INPUT_BUFFER_LENGTH) {
 508     bytes = handle->tty.rd.read_line_buffer.len;
 509   } else {
 510     bytes = MAX_INPUT_BUFFER_LENGTH;
 511   }
 512
 513   /* At last, unicode! One utf-16 codeunit never takes more than 3 utf-8
 514    * codeunits to encode. */
 515   chars = bytes / 3;
 516
 517   status = InterlockedExchange(&uv__read_console_status, IN_PROGRESS);
 518   if (status == TRAP_REQUESTED) {
 519     SET_REQ_SUCCESS(req);
 520     InterlockedExchange(&uv__read_console_status, COMPLETED);
 521     req->u.io.overlapped.InternalHigh = 0;
 522     POST_COMPLETION_FOR_REQ(loop, req);
 523     return 0;
 524   }
 525
 526   read_console_success = ReadConsoleW(handle->handle,
 527                                       (void*) utf16,
 528                                       chars,
 529                                       &read_chars,
 530                                       NULL);
 531
 532   if (read_console_success) {
 533     read_bytes = WideCharToMultiByte(CP_UTF8,
 534                                      0,
 535                                      utf16,
 536                                      read_chars,
 537                                      handle->tty.rd.read_line_buffer.base,
 538                                      bytes,
 539                                      NULL,
 540                                      NULL);
 541     SET_REQ_SUCCESS(req);
 542     req->u.io.overlapped.InternalHigh = read_bytes;
 543   } else {
 544     SET_REQ_ERROR(req, GetLastError());
 545   }
 546
 547   status = InterlockedExchange(&uv__read_console_status, COMPLETED);
 548
 549   if (status ==  TRAP_REQUESTED) {
 550     /* If we canceled the read by sending a VK_RETURN event, restore the
 551        screen state to undo the visual effect of the VK_RETURN */
 552     if (read_console_success && InterlockedOr(&uv__restore_screen_state, 0)) {
 553       HANDLE active_screen_buffer;
 554       active_screen_buffer = CreateFileA("conout$",
 555                                          GENERIC_READ | GENERIC_WRITE,
 556                                          FILE_SHARE_READ | FILE_SHARE_WRITE,
 557                                          NULL,
 558                                          OPEN_EXISTING,
 559                                          FILE_ATTRIBUTE_NORMAL,
 560                                          NULL);
 561       if (active_screen_buffer != INVALID_HANDLE_VALUE) {
 562         pos = uv__saved_screen_state.dwCursorPosition;
 563
 564         /* If the cursor was at the bottom line of the screen buffer, the
 565            VK_RETURN would have caused the buffer contents to scroll up by one
 566            line. The right position to reset the cursor to is therefore one line
 567            higher */
 568         if (pos.Y == uv__saved_screen_state.dwSize.Y - 1)
 569           pos.Y--;
 570
 571         SetConsoleCursorPosition(active_screen_buffer, pos);
 572         CloseHandle(active_screen_buffer);
 573       }
 574     }
 575     uv_sem_post(&uv_tty_output_lock);
 576   }
 577   POST_COMPLETION_FOR_REQ(loop, req);
 578   return 0;
 579 }
 580
 581
 582 static void uv__tty_queue_read_line(uv_loop_t* loop, uv_tty_t* handle) {
 583   uv_read_t* req;
 584   BOOL r;
 585
 586   assert(handle->flags & UV_HANDLE_READING);
 587   assert(!(handle->flags & UV_HANDLE_READ_PENDING));
 588   assert(handle->handle && handle->handle != INVALID_HANDLE_VALUE);
 589
 590   req = &handle->read_req;
 591   memset(&req->u.io.overlapped, 0, sizeof(req->u.io.overlapped));
 592
 593   handle->tty.rd.read_line_buffer = uv_buf_init(NULL, 0);
 594   handle->alloc_cb((uv_handle_t*) handle, 8192, &handle->tty.rd.read_line_buffer);
 595   if (handle->tty.rd.read_line_buffer.base == NULL ||
 596       handle->tty.rd.read_line_buffer.len == 0) {
 597     handle->read_cb((uv_stream_t*) handle,
 598                     UV_ENOBUFS,
 599                     &handle->tty.rd.read_line_buffer);
 600     return;
 601   }
 602   assert(handle->tty.rd.read_line_buffer.base != NULL);
 603
 604   /* Reset flags  No locking is required since there cannot be a line read
 605      in progress. We are also relying on the memory barrier provided by
 606      QueueUserWorkItem*/
 607   uv__restore_screen_state = FALSE;
 608   uv__read_console_status = NOT_STARTED;
 609   r = QueueUserWorkItem(uv_tty_line_read_thread,
 610                         (void*) req,
 611                         WT_EXECUTELONGFUNCTION);
 612   if (!r) {
 613     SET_REQ_ERROR(req, GetLastError());
 614     uv__insert_pending_req(loop, (uv_req_t*)req);
 615   }
 616
 617   handle->flags |= UV_HANDLE_READ_PENDING;
 618   handle->reqs_pending++;
 619 }
 620
 621
 622 static void uv__tty_queue_read(uv_loop_t* loop, uv_tty_t* handle) {
 623   if (handle->flags & UV_HANDLE_TTY_RAW) {
 624     uv__tty_queue_read_raw(loop, handle);
 625   } else {
 626     uv__tty_queue_read_line(loop, handle);
 627   }
 628 }
 629
 630
 631 static const char* get_vt100_fn_key(DWORD code, char shift, char ctrl,
 632     size_t* len) {
 633 #define VK_CASE(vk, normal_str, shift_str, ctrl_str, shift_ctrl_str)          \
 634     case (vk):                                                                \
 635       if (shift && ctrl) {                                                    \
 636         *len = sizeof shift_ctrl_str;                                         \
 637         return "\033" shift_ctrl_str;                                         \
 638       } else if (shift) {                                                     \
 639         *len = sizeof shift_str ;                                             \
 640         return "\033" shift_str;                                              \
 641       } else if (ctrl) {                                                      \
 642         *len = sizeof ctrl_str;                                               \
 643         return "\033" ctrl_str;                                               \
 644       } else {                                                                \
 645         *len = sizeof normal_str;                                             \
 646         return "\033" normal_str;                                             \
 647       }
 648
 649   switch (code) {
 650     /* These mappings are the same as Cygwin's. Unmodified and alt-modified
 651      * keypad keys comply with linux console, modifiers comply with xterm
 652      * modifier usage. F1. f12 and shift-f1. f10 comply with linux console, f6.
 653      * f12 with and without modifiers comply with rxvt. */
 654     VK_CASE(VK_INSERT,  "[2~",  "[2;2~", "[2;5~", "[2;6~")
 655     VK_CASE(VK_END,     "[4~",  "[4;2~", "[4;5~", "[4;6~")
 656     VK_CASE(VK_DOWN,    "[B",   "[1;2B", "[1;5B", "[1;6B")
 657     VK_CASE(VK_NEXT,    "[6~",  "[6;2~", "[6;5~", "[6;6~")
 658     VK_CASE(VK_LEFT,    "[D",   "[1;2D", "[1;5D", "[1;6D")
 659     VK_CASE(VK_CLEAR,   "[G",   "[1;2G", "[1;5G", "[1;6G")
 660     VK_CASE(VK_RIGHT,   "[C",   "[1;2C", "[1;5C", "[1;6C")
 661     VK_CASE(VK_UP,      "[A",   "[1;2A", "[1;5A", "[1;6A")
 662     VK_CASE(VK_HOME,    "[1~",  "[1;2~", "[1;5~", "[1;6~")
 663     VK_CASE(VK_PRIOR,   "[5~",  "[5;2~", "[5;5~", "[5;6~")
 664     VK_CASE(VK_DELETE,  "[3~",  "[3;2~", "[3;5~", "[3;6~")
 665     VK_CASE(VK_NUMPAD0, "[2~",  "[2;2~", "[2;5~", "[2;6~")
 666     VK_CASE(VK_NUMPAD1, "[4~",  "[4;2~", "[4;5~", "[4;6~")
 667     VK_CASE(VK_NUMPAD2, "[B",   "[1;2B", "[1;5B", "[1;6B")
 668     VK_CASE(VK_NUMPAD3, "[6~",  "[6;2~", "[6;5~", "[6;6~")
 669     VK_CASE(VK_NUMPAD4, "[D",   "[1;2D", "[1;5D", "[1;6D")
 670     VK_CASE(VK_NUMPAD5, "[G",   "[1;2G", "[1;5G", "[1;6G")
 671     VK_CASE(VK_NUMPAD6, "[C",   "[1;2C", "[1;5C", "[1;6C")
 672     VK_CASE(VK_NUMPAD7, "[A",   "[1;2A", "[1;5A", "[1;6A")
 673     VK_CASE(VK_NUMPAD8, "[1~",  "[1;2~", "[1;5~", "[1;6~")
 674     VK_CASE(VK_NUMPAD9, "[5~",  "[5;2~", "[5;5~", "[5;6~")
 675     VK_CASE(VK_DECIMAL, "[3~",  "[3;2~", "[3;5~", "[3;6~")
 676     VK_CASE(VK_F1,      "[[A",  "[23~",  "[11^",  "[23^" )
 677     VK_CASE(VK_F2,      "[[B",  "[24~",  "[12^",  "[24^" )
 678     VK_CASE(VK_F3,      "[[C",  "[25~",  "[13^",  "[25^" )
 679     VK_CASE(VK_F4,      "[[D",  "[26~",  "[14^",  "[26^" )
 680     VK_CASE(VK_F5,      "[[E",  "[28~",  "[15^",  "[28^" )
 681     VK_CASE(VK_F6,      "[17~", "[29~",  "[17^",  "[29^" )
 682     VK_CASE(VK_F7,      "[18~", "[31~",  "[18^",  "[31^" )
 683     VK_CASE(VK_F8,      "[19~", "[32~",  "[19^",  "[32^" )
 684     VK_CASE(VK_F9,      "[20~", "[33~",  "[20^",  "[33^" )
 685     VK_CASE(VK_F10,     "[21~", "[34~",  "[21^",  "[34^" )
 686     VK_CASE(VK_F11,     "[23~", "[23$",  "[23^",  "[23@" )
 687     VK_CASE(VK_F12,     "[24~", "[24$",  "[24^",  "[24@" )
 688
 689     default:
 690       *len = 0;
 691       return NULL;
 692   }
 693 #undef VK_CASE
 694 }
 695
 696
 697 void uv_process_tty_read_raw_req(uv_loop_t* loop, uv_tty_t* handle,
 698     uv_req_t* req) {
 699   /* Shortcut for handle->tty.rd.last_input_record.Event.KeyEvent. */
 700 #define KEV handle->tty.rd.last_input_record.Event.KeyEvent
 701
 702   DWORD records_left, records_read;
 703   uv_buf_t buf;
 704   off_t buf_used;
 705
 706   assert(handle->type == UV_TTY);
 707   assert(handle->flags & UV_HANDLE_TTY_READABLE);
 708   handle->flags &= ~UV_HANDLE_READ_PENDING;
 709
 710   if (!(handle->flags & UV_HANDLE_READING) ||
 711       !(handle->flags & UV_HANDLE_TTY_RAW)) {
 712     goto out;
 713   }
 714
 715   if (!REQ_SUCCESS(req)) {
 716     /* An error occurred while waiting for the event. */
 717     if ((handle->flags & UV_HANDLE_READING)) {
 718       handle->flags &= ~UV_HANDLE_READING;
 719       handle->read_cb((uv_stream_t*)handle,
 720                       uv_translate_sys_error(GET_REQ_ERROR(req)),
 721                       &uv_null_buf_);
 722     }
 723     goto out;
 724   }
 725
 726   /* Fetch the number of events  */
 727   if (!GetNumberOfConsoleInputEvents(handle->handle, &records_left)) {
 728     handle->flags &= ~UV_HANDLE_READING;
 729     DECREASE_ACTIVE_COUNT(loop, handle);
 730     handle->read_cb((uv_stream_t*)handle,
 731                     uv_translate_sys_error(GetLastError()),
 732                     &uv_null_buf_);
 733     goto out;
 734   }
 735
 736   /* Windows sends a lot of events that we're not interested in, so buf will be
 737    * allocated on demand, when there's actually something to emit. */
 738   buf = uv_null_buf_;
 739   buf_used = 0;
 740
 741   while ((records_left > 0 || handle->tty.rd.last_key_len > 0) &&
 742          (handle->flags & UV_HANDLE_READING)) {
 743     if (handle->tty.rd.last_key_len == 0) {
 744       /* Read the next input record */
 745       if (!ReadConsoleInputW(handle->handle,
 746                              &handle->tty.rd.last_input_record,
 747                              1,
 748                              &records_read)) {
 749         handle->flags &= ~UV_HANDLE_READING;
 750         DECREASE_ACTIVE_COUNT(loop, handle);
 751         handle->read_cb((uv_stream_t*) handle,
 752                         uv_translate_sys_error(GetLastError()),
 753                         &buf);
 754         goto out;
 755       }
 756       records_left--;
 757
 758       /* We might be not subscribed to EVENT_CONSOLE_LAYOUT or we might be
 759        * running under some TTY emulator that does not send those events. */
 760       if (handle->tty.rd.last_input_record.EventType == WINDOW_BUFFER_SIZE_EVENT) {
 761         uv__tty_console_signal_resize();
 762       }
 763
 764       /* Ignore other events that are not key events. */
 765       if (handle->tty.rd.last_input_record.EventType != KEY_EVENT) {
 766         continue;
 767       }
 768
 769       /* Ignore keyup events, unless the left alt key was held and a valid
 770        * unicode character was emitted. */
 771       if (!KEV.bKeyDown &&
 772           (KEV.wVirtualKeyCode != VK_MENU ||
 773            KEV.uChar.UnicodeChar == 0)) {
 774         continue;
 775       }
 776
 777       /* Ignore keypresses to numpad number keys if the left alt is held
 778        * because the user is composing a character, or windows simulating this.
 779        */
 780       if ((KEV.dwControlKeyState & LEFT_ALT_PRESSED) &&
 781           !(KEV.dwControlKeyState & ENHANCED_KEY) &&
 782           (KEV.wVirtualKeyCode == VK_INSERT ||
 783           KEV.wVirtualKeyCode == VK_END ||
 784           KEV.wVirtualKeyCode == VK_DOWN ||
 785           KEV.wVirtualKeyCode == VK_NEXT ||
 786           KEV.wVirtualKeyCode == VK_LEFT ||
 787           KEV.wVirtualKeyCode == VK_CLEAR ||
 788           KEV.wVirtualKeyCode == VK_RIGHT ||
 789           KEV.wVirtualKeyCode == VK_HOME ||
 790           KEV.wVirtualKeyCode == VK_UP ||
 791           KEV.wVirtualKeyCode == VK_PRIOR ||
 792           KEV.wVirtualKeyCode == VK_NUMPAD0 ||
 793           KEV.wVirtualKeyCode == VK_NUMPAD1 ||
 794           KEV.wVirtualKeyCode == VK_NUMPAD2 ||
 795           KEV.wVirtualKeyCode == VK_NUMPAD3 ||
 796           KEV.wVirtualKeyCode == VK_NUMPAD4 ||
 797           KEV.wVirtualKeyCode == VK_NUMPAD5 ||
 798           KEV.wVirtualKeyCode == VK_NUMPAD6 ||
 799           KEV.wVirtualKeyCode == VK_NUMPAD7 ||
 800           KEV.wVirtualKeyCode == VK_NUMPAD8 ||
 801           KEV.wVirtualKeyCode == VK_NUMPAD9)) {
 802         continue;
 803       }
 804
 805       if (KEV.uChar.UnicodeChar != 0) {
 806         int prefix_len, char_len;
 807
 808         /* Character key pressed */
 809         if (KEV.uChar.UnicodeChar >= 0xD800 &&
 810             KEV.uChar.UnicodeChar < 0xDC00) {
 811           /* UTF-16 high surrogate */
 812           handle->tty.rd.last_utf16_high_surrogate = KEV.uChar.UnicodeChar;
 813           continue;
 814         }
 815
 816         /* Prefix with \u033 if alt was held, but alt was not used as part a
 817          * compose sequence. */
 818         if ((KEV.dwControlKeyState & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED))
 819             && !(KEV.dwControlKeyState & (LEFT_CTRL_PRESSED |
 820             RIGHT_CTRL_PRESSED)) && KEV.bKeyDown) {
 821           handle->tty.rd.last_key[0] = '\033';
 822           prefix_len = 1;
 823         } else {
 824           prefix_len = 0;
 825         }
 826
 827         if (KEV.uChar.UnicodeChar >= 0xDC00 &&
 828             KEV.uChar.UnicodeChar < 0xE000) {
 829           /* UTF-16 surrogate pair */
 830           WCHAR utf16_buffer[2];
 831           utf16_buffer[0] = handle->tty.rd.last_utf16_high_surrogate;
 832           utf16_buffer[1] = KEV.uChar.UnicodeChar;
 833           char_len = WideCharToMultiByte(CP_UTF8,
 834                                          0,
 835                                          utf16_buffer,
 836                                          2,
 837                                          &handle->tty.rd.last_key[prefix_len],
 838                                          sizeof handle->tty.rd.last_key,
 839                                          NULL,
 840                                          NULL);
 841         } else {
 842           /* Single UTF-16 character */
 843           char_len = WideCharToMultiByte(CP_UTF8,
 844                                          0,
 845                                          &KEV.uChar.UnicodeChar,
 846                                          1,
 847                                          &handle->tty.rd.last_key[prefix_len],
 848                                          sizeof handle->tty.rd.last_key,
 849                                          NULL,
 850                                          NULL);
 851         }
 852
 853         /* Whatever happened, the last character wasn't a high surrogate. */
 854         handle->tty.rd.last_utf16_high_surrogate = 0;
 855
 856         /* If the utf16 character(s) couldn't be converted something must be
 857          * wrong. */
 858         if (!char_len) {
 859           handle->flags &= ~UV_HANDLE_READING;
 860           DECREASE_ACTIVE_COUNT(loop, handle);
 861           handle->read_cb((uv_stream_t*) handle,
 862                           uv_translate_sys_error(GetLastError()),
 863                           &buf);
 864           goto out;
 865         }
 866
 867         handle->tty.rd.last_key_len = (unsigned char) (prefix_len + char_len);
 868         handle->tty.rd.last_key_offset = 0;
 869         continue;
 870
 871       } else {
 872         /* Function key pressed */
 873         const char* vt100;
 874         size_t prefix_len, vt100_len;
 875
 876         vt100 = get_vt100_fn_key(KEV.wVirtualKeyCode,
 877                                   !!(KEV.dwControlKeyState & SHIFT_PRESSED),
 878                                   !!(KEV.dwControlKeyState & (
 879                                     LEFT_CTRL_PRESSED |
 880                                     RIGHT_CTRL_PRESSED)),
 881                                   &vt100_len);
 882
 883         /* If we were unable to map to a vt100 sequence, just ignore. */
 884         if (!vt100) {
 885           continue;
 886         }
 887
 888         /* Prefix with \x033 when the alt key was held. */
 889         if (KEV.dwControlKeyState & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED)) {
 890           handle->tty.rd.last_key[0] = '\033';
 891           prefix_len = 1;
 892         } else {
 893           prefix_len = 0;
 894         }
 895
 896         /* Copy the vt100 sequence to the handle buffer. */
 897         assert(prefix_len + vt100_len < sizeof handle->tty.rd.last_key);
 898         memcpy(&handle->tty.rd.last_key[prefix_len], vt100, vt100_len);
 899
 900         handle->tty.rd.last_key_len = (unsigned char) (prefix_len + vt100_len);
 901         handle->tty.rd.last_key_offset = 0;
 902         continue;
 903       }
 904     } else {
 905       /* Copy any bytes left from the last keypress to the user buffer. */
 906       if (handle->tty.rd.last_key_offset < handle->tty.rd.last_key_len) {
 907         /* Allocate a buffer if needed */
 908         if (buf_used == 0) {
 909           buf = uv_buf_init(NULL, 0);
 910           handle->alloc_cb((uv_handle_t*) handle, 1024, &buf);
 911           if (buf.base == NULL || buf.len == 0) {
 912             handle->read_cb((uv_stream_t*) handle, UV_ENOBUFS, &buf);
 913             goto out;
 914           }
 915           assert(buf.base != NULL);
 916         }
 917
 918         buf.base[buf_used++] = handle->tty.rd.last_key[handle->tty.rd.last_key_offset++];
 919
 920         /* If the buffer is full, emit it */
 921         if ((size_t) buf_used == buf.len) {
 922           handle->read_cb((uv_stream_t*) handle, buf_used, &buf);
 923           buf = uv_null_buf_;
 924           buf_used = 0;
 925         }
 926
 927         continue;
 928       }
 929
 930       /* Apply dwRepeat from the last input record. */
 931       if (--KEV.wRepeatCount > 0) {
 932         handle->tty.rd.last_key_offset = 0;
 933         continue;
 934       }
 935
 936       handle->tty.rd.last_key_len = 0;
 937       continue;
 938     }
 939   }
 940
 941   /* Send the buffer back to the user */
 942   if (buf_used > 0) {
 943     handle->read_cb((uv_stream_t*) handle, buf_used, &buf);
 944   }
 945
 946  out:
 947   /* Wait for more input events. */
 948   if ((handle->flags & UV_HANDLE_READING) &&
 949       !(handle->flags & UV_HANDLE_READ_PENDING)) {
 950     uv__tty_queue_read(loop, handle);
 951   }
 952
 953   DECREASE_PENDING_REQ_COUNT(handle);
 954
 955 #undef KEV
 956 }
 957
 958
 959
 960 void uv_process_tty_read_line_req(uv_loop_t* loop, uv_tty_t* handle,
 961     uv_req_t* req) {
 962   uv_buf_t buf;
 963
 964   assert(handle->type == UV_TTY);
 965   assert(handle->flags & UV_HANDLE_TTY_READABLE);
 966
 967   buf = handle->tty.rd.read_line_buffer;
 968
 969   handle->flags &= ~UV_HANDLE_READ_PENDING;
 970   handle->tty.rd.read_line_buffer = uv_null_buf_;
 971
 972   if (!REQ_SUCCESS(req)) {
 973     /* Read was not successful */
 974     if (handle->flags & UV_HANDLE_READING) {
 975       /* Real error */
 976       handle->flags &= ~UV_HANDLE_READING;
 977       DECREASE_ACTIVE_COUNT(loop, handle);
 978       handle->read_cb((uv_stream_t*) handle,
 979                       uv_translate_sys_error(GET_REQ_ERROR(req)),
 980                       &buf);
 981     }
 982   } else {
 983     if (!(handle->flags & UV_HANDLE_CANCELLATION_PENDING) &&
 984         req->u.io.overlapped.InternalHigh != 0) {
 985       /* Read successful. TODO: read unicode, convert to utf-8 */
 986       DWORD bytes = req->u.io.overlapped.InternalHigh;
 987       handle->read_cb((uv_stream_t*) handle, bytes, &buf);
 988     }
 989     handle->flags &= ~UV_HANDLE_CANCELLATION_PENDING;
 990   }
 991
 992   /* Wait for more input events. */
 993   if ((handle->flags & UV_HANDLE_READING) &&
 994       !(handle->flags & UV_HANDLE_READ_PENDING)) {
 995     uv__tty_queue_read(loop, handle);
 996   }
 997
 998   DECREASE_PENDING_REQ_COUNT(handle);
 999 }
1000
1001
1002 void uv__process_tty_read_req(uv_loop_t* loop, uv_tty_t* handle,
1003     uv_req_t* req) {
1004   assert(handle->type == UV_TTY);
1005   assert(handle->flags & UV_HANDLE_TTY_READABLE);
1006
1007   /* If the read_line_buffer member is zero, it must have been an raw read.
1008    * Otherwise it was a line-buffered read. FIXME: This is quite obscure. Use a
1009    * flag or something. */
1010   if (handle->tty.rd.read_line_buffer.len == 0) {
1011     uv_process_tty_read_raw_req(loop, handle, req);
1012   } else {
1013     uv_process_tty_read_line_req(loop, handle, req);
1014   }
1015 }
1016
1017
1018 int uv__tty_read_start(uv_tty_t* handle, uv_alloc_cb alloc_cb,
1019     uv_read_cb read_cb) {
1020   uv_loop_t* loop = handle->loop;
1021
1022   if (!(handle->flags & UV_HANDLE_TTY_READABLE)) {
1023     return ERROR_INVALID_PARAMETER;
1024   }
1025
1026   handle->flags |= UV_HANDLE_READING;
1027   INCREASE_ACTIVE_COUNT(loop, handle);
1028   handle->read_cb = read_cb;
1029   handle->alloc_cb = alloc_cb;
1030
1031   /* If reading was stopped and then started again, there could still be a read
1032    * request pending. */
1033   if (handle->flags & UV_HANDLE_READ_PENDING) {
1034     return 0;
1035   }
1036
1037   /* Maybe the user stopped reading half-way while processing key events.
1038    * Short-circuit if this could be the case. */
1039   if (handle->tty.rd.last_key_len > 0) {
1040     SET_REQ_SUCCESS(&handle->read_req);
1041     uv__insert_pending_req(handle->loop, (uv_req_t*) &handle->read_req);
1042     /* Make sure no attempt is made to insert it again until it's handled. */
1043     handle->flags |= UV_HANDLE_READ_PENDING;
1044     handle->reqs_pending++;
1045     return 0;
1046   }
1047
1048   uv__tty_queue_read(loop, handle);
1049
1050   return 0;
1051 }
1052
1053
1054 int uv__tty_read_stop(uv_tty_t* handle) {
1055   INPUT_RECORD record;
1056   DWORD written, err;
1057
1058   handle->flags &= ~UV_HANDLE_READING;
1059   DECREASE_ACTIVE_COUNT(handle->loop, handle);
1060
1061   if (!(handle->flags & UV_HANDLE_READ_PENDING))
1062     return 0;
1063
1064   if (handle->flags & UV_HANDLE_TTY_RAW) {
1065     /* Cancel raw read. Write some bullshit event to force the console wait to
1066      * return. */
1067     memset(&record, 0, sizeof record);
1068     record.EventType = FOCUS_EVENT;
1069     if (!WriteConsoleInputW(handle->handle, &record, 1, &written)) {
1070       return GetLastError();
1071     }
1072   } else if (!(handle->flags & UV_HANDLE_CANCELLATION_PENDING)) {
1073     /* Cancel line-buffered read if not already pending */
1074     err = uv__cancel_read_console(handle);
1075     if (err)
1076       return err;
1077
1078     handle->flags |= UV_HANDLE_CANCELLATION_PENDING;
1079   }
1080
1081   return 0;
1082 }
1083
1084 static int uv__cancel_read_console(uv_tty_t* handle) {
1085   HANDLE active_screen_buffer = INVALID_HANDLE_VALUE;
1086   INPUT_RECORD record;
1087   DWORD written;
1088   DWORD err = 0;
1089   LONG status;
1090
1091   assert(!(handle->flags & UV_HANDLE_CANCELLATION_PENDING));
1092
1093   /* Hold the output lock during the cancellation, to ensure that further
1094      writes don't interfere with the screen state. It will be the ReadConsole
1095      thread's responsibility to release the lock. */
1096   uv_sem_wait(&uv_tty_output_lock);
1097   status = InterlockedExchange(&uv__read_console_status, TRAP_REQUESTED);
1098   if (status != IN_PROGRESS) {
1099     /* Either we have managed to set a trap for the other thread before
1100        ReadConsole is called, or ReadConsole has returned because the user
1101        has pressed ENTER. In either case, there is nothing else to do. */
1102     uv_sem_post(&uv_tty_output_lock);
1103     return 0;
1104   }
1105
1106   /* Save screen state before sending the VK_RETURN event */
1107   active_screen_buffer = CreateFileA("conout$",
1108                                      GENERIC_READ | GENERIC_WRITE,
1109                                      FILE_SHARE_READ | FILE_SHARE_WRITE,
1110                                      NULL,
1111                                      OPEN_EXISTING,
1112                                      FILE_ATTRIBUTE_NORMAL,
1113                                      NULL);
1114
1115   if (active_screen_buffer != INVALID_HANDLE_VALUE &&
1116       GetConsoleScreenBufferInfo(active_screen_buffer,
1117                                  &uv__saved_screen_state)) {
1118     InterlockedOr(&uv__restore_screen_state, 1);
1119   }
1120
1121   /* Write enter key event to force the console wait to return. */
1122   record.EventType = KEY_EVENT;
1123   record.Event.KeyEvent.bKeyDown = TRUE;
1124   record.Event.KeyEvent.wRepeatCount = 1;
1125   record.Event.KeyEvent.wVirtualKeyCode = VK_RETURN;
1126   record.Event.KeyEvent.wVirtualScanCode =
1127     MapVirtualKeyW(VK_RETURN, MAPVK_VK_TO_VSC);
1128   record.Event.KeyEvent.uChar.UnicodeChar = L'\r';
1129   record.Event.KeyEvent.dwControlKeyState = 0;
1130   if (!WriteConsoleInputW(handle->handle, &record, 1, &written))
1131     err = GetLastError();
1132
1133   if (active_screen_buffer != INVALID_HANDLE_VALUE)
1134     CloseHandle(active_screen_buffer);
1135
1136   return err;
1137 }
1138
1139
1140 static void uv__tty_update_virtual_window(CONSOLE_SCREEN_BUFFER_INFO* info) {
1141   uv_tty_virtual_width = info->dwSize.X;
1142   uv_tty_virtual_height = info->srWindow.Bottom - info->srWindow.Top + 1;
1143
1144   /* Recompute virtual window offset row. */
1145   if (uv_tty_virtual_offset == -1) {
1146     uv_tty_virtual_offset = info->dwCursorPosition.Y;
1147   } else if (uv_tty_virtual_offset < info->dwCursorPosition.Y -
1148              uv_tty_virtual_height + 1) {
1149     /* If suddenly find the cursor outside of the virtual window, it must have
1150      * somehow scrolled. Update the virtual window offset. */
1151     uv_tty_virtual_offset = info->dwCursorPosition.Y -
1152                             uv_tty_virtual_height + 1;
1153   }
1154   if (uv_tty_virtual_offset + uv_tty_virtual_height > info->dwSize.Y) {
1155     uv_tty_virtual_offset = info->dwSize.Y - uv_tty_virtual_height;
1156   }
1157   if (uv_tty_virtual_offset < 0) {
1158     uv_tty_virtual_offset = 0;
1159   }
1160 }
1161
1162
1163 static COORD uv__tty_make_real_coord(uv_tty_t* handle,
1164     CONSOLE_SCREEN_BUFFER_INFO* info, int x, unsigned char x_relative, int y,
1165     unsigned char y_relative) {
1166   COORD result;
1167
1168   uv__tty_update_virtual_window(info);
1169
1170   /* Adjust y position */
1171   if (y_relative) {
1172     y = info->dwCursorPosition.Y + y;
1173   } else {
1174     y = uv_tty_virtual_offset + y;
1175   }
1176   /* Clip y to virtual client rectangle */
1177   if (y < uv_tty_virtual_offset) {
1178     y = uv_tty_virtual_offset;
1179   } else if (y >= uv_tty_virtual_offset + uv_tty_virtual_height) {
1180     y = uv_tty_virtual_offset + uv_tty_virtual_height - 1;
1181   }
1182
1183   /* Adjust x */
1184   if (x_relative) {
1185     x = info->dwCursorPosition.X + x;
1186   }
1187   /* Clip x */
1188   if (x < 0) {
1189     x = 0;
1190   } else if (x >= uv_tty_virtual_width) {
1191     x = uv_tty_virtual_width - 1;
1192   }
1193
1194   result.X = (unsigned short) x;
1195   result.Y = (unsigned short) y;
1196   return result;
1197 }
1198
1199
1200 static int uv__tty_emit_text(uv_tty_t* handle, WCHAR buffer[], DWORD length,
1201     DWORD* error) {
1202   DWORD written;
1203
1204   if (*error != ERROR_SUCCESS) {
1205     return -1;
1206   }
1207
1208   if (!WriteConsoleW(handle->handle,
1209                      (void*) buffer,
1210                      length,
1211                      &written,
1212                      NULL)) {
1213     *error = GetLastError();
1214     return -1;
1215   }
1216
1217   return 0;
1218 }
1219
1220
1221 static int uv__tty_move_caret(uv_tty_t* handle, int x, unsigned char x_relative,
1222     int y, unsigned char y_relative, DWORD* error) {
1223   CONSOLE_SCREEN_BUFFER_INFO info;
1224   COORD pos;
1225
1226   if (*error != ERROR_SUCCESS) {
1227     return -1;
1228   }
1229
1230  retry:
1231   if (!GetConsoleScreenBufferInfo(handle->handle, &info)) {
1232     *error = GetLastError();
1233   }
1234
1235   pos = uv__tty_make_real_coord(handle, &info, x, x_relative, y, y_relative);
1236
1237   if (!SetConsoleCursorPosition(handle->handle, pos)) {
1238     if (GetLastError() == ERROR_INVALID_PARAMETER) {
1239       /* The console may be resized - retry */
1240       goto retry;
1241     } else {
1242       *error = GetLastError();
1243       return -1;
1244     }
1245   }
1246
1247   return 0;
1248 }
1249
1250
1251 static int uv__tty_reset(uv_tty_t* handle, DWORD* error) {
1252   const COORD origin = {0, 0};
1253   const WORD char_attrs = uv_tty_default_text_attributes;
1254   CONSOLE_SCREEN_BUFFER_INFO screen_buffer_info;
1255   DWORD count, written;
1256
1257   if (*error != ERROR_SUCCESS) {
1258     return -1;
1259   }
1260
1261   /* Reset original text attributes. */
1262   if (!SetConsoleTextAttribute(handle->handle, char_attrs)) {
1263     *error = GetLastError();
1264     return -1;
1265   }
1266
1267   /* Move the cursor position to (0, 0). */
1268   if (!SetConsoleCursorPosition(handle->handle, origin)) {
1269     *error = GetLastError();
1270     return -1;
1271   }
1272
1273   /* Clear the screen buffer. */
1274  retry:
1275    if (!GetConsoleScreenBufferInfo(handle->handle, &screen_buffer_info)) {
1276      *error = GetLastError();
1277      return -1;
1278   }
1279
1280   count = screen_buffer_info.dwSize.X * screen_buffer_info.dwSize.Y;
1281
1282   if (!(FillConsoleOutputCharacterW(handle->handle,
1283                                     L'\x20',
1284                                     count,
1285                                     origin,
1286                                     &written) &&
1287         FillConsoleOutputAttribute(handle->handle,
1288                                    char_attrs,
1289                                    written,
1290                                    origin,
1291                                    &written))) {
1292     if (GetLastError() == ERROR_INVALID_PARAMETER) {
1293       /* The console may be resized - retry */
1294       goto retry;
1295     } else {
1296       *error = GetLastError();
1297       return -1;
1298     }
1299   }
1300
1301   /* Move the virtual window up to the top. */
1302   uv_tty_virtual_offset = 0;
1303   uv__tty_update_virtual_window(&screen_buffer_info);
1304
1305   /* Reset the cursor size and the cursor state. */
1306   if (!SetConsoleCursorInfo(handle->handle, &uv_tty_default_cursor_info)) {
1307     *error = GetLastError();
1308     return -1;
1309   }
1310
1311   return 0;
1312 }
1313
1314
1315 static int uv__tty_clear(uv_tty_t* handle, int dir, char entire_screen,
1316     DWORD* error) {
1317   CONSOLE_SCREEN_BUFFER_INFO info;
1318   COORD start, end;
1319   DWORD count, written;
1320
1321   int x1, x2, y1, y2;
1322   int x1r, x2r, y1r, y2r;
1323
1324   if (*error != ERROR_SUCCESS) {
1325     return -1;
1326   }
1327
1328   if (dir == 0) {
1329     /* Clear from current position */
1330     x1 = 0;
1331     x1r = 1;
1332   } else {
1333     /* Clear from column 0 */
1334     x1 = 0;
1335     x1r = 0;
1336   }
1337
1338   if (dir == 1) {
1339     /* Clear to current position */
1340     x2 = 0;
1341     x2r = 1;
1342   } else {
1343     /* Clear to end of row. We pretend the console is 65536 characters wide,
1344      * uv__tty_make_real_coord will clip it to the actual console width. */
1345     x2 = 0xffff;
1346     x2r = 0;
1347   }
1348
1349   if (!entire_screen) {
1350     /* Stay on our own row */
1351     y1 = y2 = 0;
1352     y1r = y2r = 1;
1353   } else {
1354     /* Apply columns direction to row */
1355     y1 = x1;
1356     y1r = x1r;
1357     y2 = x2;
1358     y2r = x2r;
1359   }
1360
1361  retry:
1362   if (!GetConsoleScreenBufferInfo(handle->handle, &info)) {
1363     *error = GetLastError();
1364     return -1;
1365   }
1366
1367   start = uv__tty_make_real_coord(handle, &info, x1, x1r, y1, y1r);
1368   end = uv__tty_make_real_coord(handle, &info, x2, x2r, y2, y2r);
1369   count = (end.Y * info.dwSize.X + end.X) -
1370           (start.Y * info.dwSize.X + start.X) + 1;
1371
1372   if (!(FillConsoleOutputCharacterW(handle->handle,
1373                               L'\x20',
1374                               count,
1375                               start,
1376                               &written) &&
1377         FillConsoleOutputAttribute(handle->handle,
1378                                    info.wAttributes,
1379                                    written,
1380                                    start,
1381                                    &written))) {
1382     if (GetLastError() == ERROR_INVALID_PARAMETER) {
1383       /* The console may be resized - retry */
1384       goto retry;
1385     } else {
1386       *error = GetLastError();
1387       return -1;
1388     }
1389   }
1390
1391   return 0;
1392 }
1393
1394 #define FLIP_FGBG                                                             \
1395     do {                                                                      \
1396       WORD fg = info.wAttributes & 0xF;                                       \
1397       WORD bg = info.wAttributes & 0xF0;                                      \
1398       info.wAttributes &= 0xFF00;                                             \
1399       info.wAttributes |= fg << 4;                                            \
1400       info.wAttributes |= bg >> 4;                                            \
1401     } while (0)
1402
1403 static int uv__tty_set_style(uv_tty_t* handle, DWORD* error) {
1404   unsigned short argc = handle->tty.wr.ansi_csi_argc;
1405   unsigned short* argv = handle->tty.wr.ansi_csi_argv;
1406   int i;
1407   CONSOLE_SCREEN_BUFFER_INFO info;
1408
1409   char fg_color = -1, bg_color = -1;
1410   char fg_bright = -1, bg_bright = -1;
1411   char inverse = -1;
1412
1413   if (argc == 0) {
1414     /* Reset mode */
1415     fg_color = uv_tty_default_fg_color;
1416     bg_color = uv_tty_default_bg_color;
1417     fg_bright = uv_tty_default_fg_bright;
1418     bg_bright = uv_tty_default_bg_bright;
1419     inverse = uv_tty_default_inverse;
1420   }
1421
1422   for (i = 0; i < argc; i++) {
1423     short arg = argv[i];
1424
1425     if (arg == 0) {
1426       /* Reset mode */
1427       fg_color = uv_tty_default_fg_color;
1428       bg_color = uv_tty_default_bg_color;
1429       fg_bright = uv_tty_default_fg_bright;
1430       bg_bright = uv_tty_default_bg_bright;
1431       inverse = uv_tty_default_inverse;
1432
1433     } else if (arg == 1) {
1434       /* Foreground bright on */
1435       fg_bright = 1;
1436
1437     } else if (arg == 2) {
1438       /* Both bright off */
1439       fg_bright = 0;
1440       bg_bright = 0;
1441
1442     } else if (arg == 5) {
1443       /* Background bright on */
1444       bg_bright = 1;
1445
1446     } else if (arg == 7) {
1447       /* Inverse: on */
1448       inverse = 1;
1449
1450     } else if (arg == 21 || arg == 22) {
1451       /* Foreground bright off */
1452       fg_bright = 0;
1453
1454     } else if (arg == 25) {
1455       /* Background bright off */
1456       bg_bright = 0;
1457
1458     } else if (arg == 27) {
1459       /* Inverse: off */
1460       inverse = 0;
1461
1462     } else if (arg >= 30 && arg <= 37) {
1463       /* Set foreground color */
1464       fg_color = arg - 30;
1465
1466     } else if (arg == 39) {
1467       /* Default text color */
1468       fg_color = uv_tty_default_fg_color;
1469       fg_bright = uv_tty_default_fg_bright;
1470
1471     } else if (arg >= 40 && arg <= 47) {
1472       /* Set background color */
1473       bg_color = arg - 40;
1474
1475     } else if (arg ==  49) {
1476       /* Default background color */
1477       bg_color = uv_tty_default_bg_color;
1478       bg_bright = uv_tty_default_bg_bright;
1479
1480     } else if (arg >= 90 && arg <= 97) {
1481       /* Set bold foreground color */
1482       fg_bright = 1;
1483       fg_color = arg - 90;
1484
1485     } else if (arg >= 100 && arg <= 107) {
1486       /* Set bold background color */
1487       bg_bright = 1;
1488       bg_color = arg - 100;
1489
1490     }
1491   }
1492
1493   if (fg_color == -1 && bg_color == -1 && fg_bright == -1 &&
1494       bg_bright == -1 && inverse == -1) {
1495     /* Nothing changed */
1496     return 0;
1497   }
1498
1499   if (!GetConsoleScreenBufferInfo(handle->handle, &info)) {
1500     *error = GetLastError();
1501     return -1;
1502   }
1503
1504   if ((info.wAttributes & COMMON_LVB_REVERSE_VIDEO) > 0) {
1505     FLIP_FGBG;
1506   }
1507
1508   if (fg_color != -1) {
1509     info.wAttributes &= ~(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
1510     if (fg_color & 1) info.wAttributes |= FOREGROUND_RED;
1511     if (fg_color & 2) info.wAttributes |= FOREGROUND_GREEN;
1512     if (fg_color & 4) info.wAttributes |= FOREGROUND_BLUE;
1513   }
1514
1515   if (fg_bright != -1) {
1516     if (fg_bright) {
1517       info.wAttributes |= FOREGROUND_INTENSITY;
1518     } else {
1519       info.wAttributes &= ~FOREGROUND_INTENSITY;
1520     }
1521   }
1522
1523   if (bg_color != -1) {
1524     info.wAttributes &= ~(BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE);
1525     if (bg_color & 1) info.wAttributes |= BACKGROUND_RED;
1526     if (bg_color & 2) info.wAttributes |= BACKGROUND_GREEN;
1527     if (bg_color & 4) info.wAttributes |= BACKGROUND_BLUE;
1528   }
1529
1530   if (bg_bright != -1) {
1531     if (bg_bright) {
1532       info.wAttributes |= BACKGROUND_INTENSITY;
1533     } else {
1534       info.wAttributes &= ~BACKGROUND_INTENSITY;
1535     }
1536   }
1537
1538   if (inverse != -1) {
1539     if (inverse) {
1540       info.wAttributes |= COMMON_LVB_REVERSE_VIDEO;
1541     } else {
1542       info.wAttributes &= ~COMMON_LVB_REVERSE_VIDEO;
1543     }
1544   }
1545
1546   if ((info.wAttributes & COMMON_LVB_REVERSE_VIDEO) > 0) {
1547     FLIP_FGBG;
1548   }
1549
1550   if (!SetConsoleTextAttribute(handle->handle, info.wAttributes)) {
1551     *error = GetLastError();
1552     return -1;
1553   }
1554
1555   return 0;
1556 }
1557
1558
1559 static int uv__tty_save_state(uv_tty_t* handle, unsigned char save_attributes,
1560     DWORD* error) {
1561   CONSOLE_SCREEN_BUFFER_INFO info;
1562
1563   if (*error != ERROR_SUCCESS) {
1564     return -1;
1565   }
1566
1567   if (!GetConsoleScreenBufferInfo(handle->handle, &info)) {
1568     *error = GetLastError();
1569     return -1;
1570   }
1571
1572   uv__tty_update_virtual_window(&info);
1573
1574   handle->tty.wr.saved_position.X = info.dwCursorPosition.X;
1575   handle->tty.wr.saved_position.Y = info.dwCursorPosition.Y -
1576         uv_tty_virtual_offset;
1577   handle->flags |= UV_HANDLE_TTY_SAVED_POSITION;
1578
1579   if (save_attributes) {
1580     handle->tty.wr.saved_attributes = info.wAttributes &
1581         (FOREGROUND_INTENSITY | BACKGROUND_INTENSITY);
1582     handle->flags |= UV_HANDLE_TTY_SAVED_ATTRIBUTES;
1583   }
1584
1585   return 0;
1586 }
1587
1588
1589 static int uv__tty_restore_state(uv_tty_t* handle,
1590     unsigned char restore_attributes, DWORD* error) {
1591   CONSOLE_SCREEN_BUFFER_INFO info;
1592   WORD new_attributes;
1593
1594   if (*error != ERROR_SUCCESS) {
1595     return -1;
1596   }
1597
1598   if (handle->flags & UV_HANDLE_TTY_SAVED_POSITION) {
1599     if (uv__tty_move_caret(handle,
1600                           handle->tty.wr.saved_position.X,
1601                           0,
1602                           handle->tty.wr.saved_position.Y,
1603                           0,
1604                           error) != 0) {
1605       return -1;
1606     }
1607   }
1608
1609   if (restore_attributes &&
1610       (handle->flags & UV_HANDLE_TTY_SAVED_ATTRIBUTES)) {
1611     if (!GetConsoleScreenBufferInfo(handle->handle, &info)) {
1612       *error = GetLastError();
1613       return -1;
1614     }
1615
1616     new_attributes = info.wAttributes;
1617     new_attributes &= ~(FOREGROUND_INTENSITY | BACKGROUND_INTENSITY);
1618     new_attributes |= handle->tty.wr.saved_attributes;
1619
1620     if (!SetConsoleTextAttribute(handle->handle, new_attributes)) {
1621       *error = GetLastError();
1622       return -1;
1623     }
1624   }
1625
1626   return 0;
1627 }
1628
1629 static int uv__tty_set_cursor_visibility(uv_tty_t* handle,
1630                                         BOOL visible,
1631                                         DWORD* error) {
1632   CONSOLE_CURSOR_INFO cursor_info;
1633
1634   if (!GetConsoleCursorInfo(handle->handle, &cursor_info)) {
1635     *error = GetLastError();
1636     return -1;
1637   }
1638
1639   cursor_info.bVisible = visible;
1640
1641   if (!SetConsoleCursorInfo(handle->handle, &cursor_info)) {
1642     *error = GetLastError();
1643     return -1;
1644   }
1645
1646   return 0;
1647 }
1648
1649 static int uv__tty_set_cursor_shape(uv_tty_t* handle, int style, DWORD* error) {
1650   CONSOLE_CURSOR_INFO cursor_info;
1651
1652   if (!GetConsoleCursorInfo(handle->handle, &cursor_info)) {
1653     *error = GetLastError();
1654     return -1;
1655   }
1656
1657   if (style == 0) {
1658     cursor_info.dwSize = uv_tty_default_cursor_info.dwSize;
1659   } else if (style <= 2) {
1660     cursor_info.dwSize = CURSOR_SIZE_LARGE;
1661   } else {
1662     cursor_info.dwSize = CURSOR_SIZE_SMALL;
1663   }
1664
1665   if (!SetConsoleCursorInfo(handle->handle, &cursor_info)) {
1666     *error = GetLastError();
1667     return -1;
1668   }
1669
1670   return 0;
1671 }
1672
1673
1674 static int uv__tty_write_bufs(uv_tty_t* handle,
1675                              const uv_buf_t bufs[],
1676                              unsigned int nbufs,
1677                              DWORD* error) {
1678   /* We can only write 8k characters at a time. Windows can't handle much more
1679    * characters in a single console write anyway. */
1680   WCHAR utf16_buf[MAX_CONSOLE_CHAR];
1681   DWORD utf16_buf_used = 0;
1682   unsigned int i;
1683
1684 #define FLUSH_TEXT()                                                \
1685   do {                                                              \
1686     if (utf16_buf_used > 0) {                                       \
1687       uv__tty_emit_text(handle, utf16_buf, utf16_buf_used, error);  \
1688       utf16_buf_used = 0;                                           \
1689     }                                                               \
1690   } while (0)
1691
1692 #define ENSURE_BUFFER_SPACE(wchars_needed)                          \
1693   if (wchars_needed > ARRAY_SIZE(utf16_buf) - utf16_buf_used) {     \
1694     FLUSH_TEXT();                                                   \
1695   }
1696
1697   /* Cache for fast access */
1698   unsigned char utf8_bytes_left = handle->tty.wr.utf8_bytes_left;
1699   unsigned int utf8_codepoint = handle->tty.wr.utf8_codepoint;
1700   unsigned char previous_eol = handle->tty.wr.previous_eol;
1701   unsigned short ansi_parser_state = handle->tty.wr.ansi_parser_state;
1702
1703   /* Store the error here. If we encounter an error, stop trying to do i/o but
1704    * keep parsing the buffer so we leave the parser in a consistent state. */
1705   *error = ERROR_SUCCESS;
1706
1707   uv_sem_wait(&uv_tty_output_lock);
1708
1709   for (i = 0; i < nbufs; i++) {
1710     uv_buf_t buf = bufs[i];
1711     unsigned int j;
1712
1713     for (j = 0; j < buf.len; j++) {
1714       unsigned char c = buf.base[j];
1715
1716       /* Run the character through the utf8 decoder We happily accept non
1717        * shortest form encodings and invalid code points - there's no real harm
1718        * that can be done. */
1719       if (utf8_bytes_left == 0) {
1720         /* Read utf-8 start byte */
1721         DWORD first_zero_bit;
1722         unsigned char not_c = ~c;
1723 #ifdef _MSC_VER /* msvc */
1724         if (_BitScanReverse(&first_zero_bit, not_c)) {
1725 #else /* assume gcc */
1726         if (c != 0) {
1727           first_zero_bit = (sizeof(int) * 8) - 1 - __builtin_clz(not_c);
1728 #endif
1729           if (first_zero_bit == 7) {
1730             /* Ascii - pass right through */
1731             utf8_codepoint = (unsigned int) c;
1732
1733           } else if (first_zero_bit <= 5) {
1734             /* Multibyte sequence */
1735             utf8_codepoint = (0xff >> (8 - first_zero_bit)) & c;
1736             utf8_bytes_left = (char) (6 - first_zero_bit);
1737
1738           } else {
1739             /* Invalid continuation */
1740             utf8_codepoint = UNICODE_REPLACEMENT_CHARACTER;
1741           }
1742
1743         } else {
1744           /* 0xff -- invalid */
1745           utf8_codepoint = UNICODE_REPLACEMENT_CHARACTER;
1746         }
1747
1748       } else if ((c & 0xc0) == 0x80) {
1749         /* Valid continuation of utf-8 multibyte sequence */
1750         utf8_bytes_left--;
1751         utf8_codepoint <<= 6;
1752         utf8_codepoint |= ((unsigned int) c & 0x3f);
1753
1754       } else {
1755         /* Start byte where continuation was expected. */
1756         utf8_bytes_left = 0;
1757         utf8_codepoint = UNICODE_REPLACEMENT_CHARACTER;
1758         /* Patch buf offset so this character will be parsed again as a start
1759          * byte. */
1760         j--;
1761       }
1762
1763       /* Maybe we need to parse more bytes to find a character. */
1764       if (utf8_bytes_left != 0) {
1765         continue;
1766       }
1767
1768       /* Parse vt100/ansi escape codes */
1769       if (uv__vterm_state == UV_TTY_SUPPORTED) {
1770         /* Pass through escape codes if conhost supports them. */
1771       } else if (ansi_parser_state == ANSI_NORMAL) {
1772         switch (utf8_codepoint) {
1773           case '\033':
1774             ansi_parser_state = ANSI_ESCAPE_SEEN;
1775             continue;
1776
1777           case 0233:
1778             ansi_parser_state = ANSI_CSI;
1779             handle->tty.wr.ansi_csi_argc = 0;
1780             continue;
1781         }
1782
1783       } else if (ansi_parser_state == ANSI_ESCAPE_SEEN) {
1784         switch (utf8_codepoint) {
1785           case '[':
1786             ansi_parser_state = ANSI_CSI;
1787             handle->tty.wr.ansi_csi_argc = 0;
1788             continue;
1789
1790           case '^':
1791           case '_':
1792           case 'P':
1793           case ']':
1794             /* Not supported, but we'll have to parse until we see a stop code,
1795              * e. g. ESC \ or BEL. */
1796             ansi_parser_state = ANSI_ST_CONTROL;
1797             continue;
1798
1799           case '\033':
1800             /* Ignore double escape. */
1801             continue;
1802
1803           case 'c':
1804             /* Full console reset. */
1805             FLUSH_TEXT();
1806             uv__tty_reset(handle, error);
1807             ansi_parser_state = ANSI_NORMAL;
1808             continue;
1809
1810           case '7':
1811             /* Save the cursor position and text attributes. */
1812             FLUSH_TEXT();
1813             uv__tty_save_state(handle, 1, error);
1814             ansi_parser_state = ANSI_NORMAL;
1815             continue;
1816
1817           case '8':
1818             /* Restore the cursor position and text attributes */
1819             FLUSH_TEXT();
1820             uv__tty_restore_state(handle, 1, error);
1821             ansi_parser_state = ANSI_NORMAL;
1822             continue;
1823
1824           default:
1825             if (utf8_codepoint >= '@' && utf8_codepoint <= '_') {
1826               /* Single-char control. */
1827               ansi_parser_state = ANSI_NORMAL;
1828               continue;
1829             } else {
1830               /* Invalid - proceed as normal, */
1831               ansi_parser_state = ANSI_NORMAL;
1832             }
1833         }
1834
1835       } else if (ansi_parser_state == ANSI_IGNORE) {
1836         /* We're ignoring this command. Stop only on command character. */
1837         if (utf8_codepoint >= '@' && utf8_codepoint <= '~') {
1838           ansi_parser_state = ANSI_NORMAL;
1839         }
1840         continue;
1841
1842       } else if (ansi_parser_state == ANSI_DECSCUSR) {
1843         /* So far we've the sequence `ESC [ arg space`, and we're waiting for
1844          * the final command byte. */
1845         if (utf8_codepoint >= '@' && utf8_codepoint <= '~') {
1846           /* Command byte */
1847           if (utf8_codepoint == 'q') {
1848             /* Change the cursor shape */
1849             int style = handle->tty.wr.ansi_csi_argc
1850               ? handle->tty.wr.ansi_csi_argv[0] : 1;
1851             if (style >= 0 && style <= 6) {
1852               FLUSH_TEXT();
1853               uv__tty_set_cursor_shape(handle, style, error);
1854             }
1855           }
1856
1857           /* Sequence ended - go back to normal state. */
1858           ansi_parser_state = ANSI_NORMAL;
1859           continue;
1860         }
1861         /* Unexpected character, but sequence hasn't ended yet. Ignore the rest
1862          * of the sequence. */
1863         ansi_parser_state = ANSI_IGNORE;
1864
1865       } else if (ansi_parser_state & ANSI_CSI) {
1866         /* So far we've seen `ESC [`, and we may or may not have already parsed
1867          * some of the arguments that follow. */
1868
1869         if (utf8_codepoint >= '0' && utf8_codepoint <= '9') {
1870           /* Parse a numerical argument. */
1871           if (!(ansi_parser_state & ANSI_IN_ARG)) {
1872             /* We were not currently parsing a number, add a new one. */
1873             /* Check for that there are too many arguments. */
1874             if (handle->tty.wr.ansi_csi_argc >=
1875                 ARRAY_SIZE(handle->tty.wr.ansi_csi_argv)) {
1876               ansi_parser_state = ANSI_IGNORE;
1877               continue;
1878             }
1879             ansi_parser_state |= ANSI_IN_ARG;
1880             handle->tty.wr.ansi_csi_argc++;
1881             handle->tty.wr.ansi_csi_argv[handle->tty.wr.ansi_csi_argc - 1] =
1882                 (unsigned short) utf8_codepoint - '0';
1883             continue;
1884
1885           } else {
1886             /* We were already parsing a number. Parse next digit. */
1887             uint32_t value = 10 *
1888                 handle->tty.wr.ansi_csi_argv[handle->tty.wr.ansi_csi_argc - 1];
1889
1890             /* Check for overflow. */
1891             if (value > UINT16_MAX) {
1892               ansi_parser_state = ANSI_IGNORE;
1893               continue;
1894             }
1895
1896             handle->tty.wr.ansi_csi_argv[handle->tty.wr.ansi_csi_argc - 1] =
1897                 (unsigned short) value + (utf8_codepoint - '0');
1898             continue;
1899           }
1900
1901         } else if (utf8_codepoint == ';') {
1902           /* Denotes the end of an argument. */
1903           if (ansi_parser_state & ANSI_IN_ARG) {
1904             ansi_parser_state &= ~ANSI_IN_ARG;
1905             continue;
1906
1907           } else {
1908             /* If ANSI_IN_ARG is not set, add another argument and default
1909              * it to 0. */
1910
1911             /* Check for too many arguments */
1912             if (handle->tty.wr.ansi_csi_argc >=
1913
1914                 ARRAY_SIZE(handle->tty.wr.ansi_csi_argv)) {
1915               ansi_parser_state = ANSI_IGNORE;
1916               continue;
1917             }
1918
1919             handle->tty.wr.ansi_csi_argc++;
1920             handle->tty.wr.ansi_csi_argv[handle->tty.wr.ansi_csi_argc - 1] = 0;
1921             continue;
1922           }
1923
1924         } else if (utf8_codepoint == '?' &&
1925                    !(ansi_parser_state & ANSI_IN_ARG) &&
1926                    !(ansi_parser_state & ANSI_EXTENSION) &&
1927                    handle->tty.wr.ansi_csi_argc == 0) {
1928           /* Pass through '?' if it is the first character after CSI */
1929           /* This is an extension character from the VT100 codeset */
1930           /* that is supported and used by most ANSI terminals today. */
1931           ansi_parser_state |= ANSI_EXTENSION;
1932           continue;
1933
1934         } else if (utf8_codepoint == ' ' &&
1935                    !(ansi_parser_state & ANSI_EXTENSION)) {
1936           /* We expect a command byte to follow after this space. The only
1937            * command that we current support is 'set cursor style'. */
1938           ansi_parser_state = ANSI_DECSCUSR;
1939           continue;
1940
1941         } else if (utf8_codepoint >= '@' && utf8_codepoint <= '~') {
1942           /* Command byte */
1943           if (ansi_parser_state & ANSI_EXTENSION) {
1944             /* Sequence is `ESC [ ? args command`. */
1945             switch (utf8_codepoint) {
1946               case 'l':
1947                 /* Hide the cursor */
1948                 if (handle->tty.wr.ansi_csi_argc == 1 &&
1949                     handle->tty.wr.ansi_csi_argv[0] == 25) {
1950                   FLUSH_TEXT();
1951                   uv__tty_set_cursor_visibility(handle, 0, error);
1952                 }
1953                 break;
1954
1955               case 'h':
1956                 /* Show the cursor */
1957                 if (handle->tty.wr.ansi_csi_argc == 1 &&
1958                     handle->tty.wr.ansi_csi_argv[0] == 25) {
1959                   FLUSH_TEXT();
1960                   uv__tty_set_cursor_visibility(handle, 1, error);
1961                 }
1962                 break;
1963             }
1964
1965           } else {
1966             /* Sequence is `ESC [ args command`. */
1967             int x, y, d;
1968             switch (utf8_codepoint) {
1969               case 'A':
1970                 /* cursor up */
1971                 FLUSH_TEXT();
1972                 y = -(handle->tty.wr.ansi_csi_argc
1973                   ? handle->tty.wr.ansi_csi_argv[0] : 1);
1974                 uv__tty_move_caret(handle, 0, 1, y, 1, error);
1975                 break;
1976
1977               case 'B':
1978                 /* cursor down */
1979                 FLUSH_TEXT();
1980                 y = handle->tty.wr.ansi_csi_argc
1981                   ? handle->tty.wr.ansi_csi_argv[0] : 1;
1982                 uv__tty_move_caret(handle, 0, 1, y, 1, error);
1983                 break;
1984
1985               case 'C':
1986                 /* cursor forward */
1987                 FLUSH_TEXT();
1988                 x = handle->tty.wr.ansi_csi_argc
1989                   ? handle->tty.wr.ansi_csi_argv[0] : 1;
1990                 uv__tty_move_caret(handle, x, 1, 0, 1, error);
1991                 break;
1992
1993               case 'D':
1994                 /* cursor back */
1995                 FLUSH_TEXT();
1996                 x = -(handle->tty.wr.ansi_csi_argc
1997                   ? handle->tty.wr.ansi_csi_argv[0] : 1);
1998                 uv__tty_move_caret(handle, x, 1, 0, 1, error);
1999                 break;
2000
2001               case 'E':
2002                 /* cursor next line */
2003                 FLUSH_TEXT();
2004                 y = handle->tty.wr.ansi_csi_argc
2005                   ? handle->tty.wr.ansi_csi_argv[0] : 1;
2006                 uv__tty_move_caret(handle, 0, 0, y, 1, error);
2007                 break;
2008
2009               case 'F':
2010                 /* cursor previous line */
2011                 FLUSH_TEXT();
2012                 y = -(handle->tty.wr.ansi_csi_argc
2013                   ? handle->tty.wr.ansi_csi_argv[0] : 1);
2014                 uv__tty_move_caret(handle, 0, 0, y, 1, error);
2015                 break;
2016
2017               case 'G':
2018                 /* cursor horizontal move absolute */
2019                 FLUSH_TEXT();
2020                 x = (handle->tty.wr.ansi_csi_argc >= 1 &&
2021                      handle->tty.wr.ansi_csi_argv[0])
2022                   ? handle->tty.wr.ansi_csi_argv[0] - 1 : 0;
2023                 uv__tty_move_caret(handle, x, 0, 0, 1, error);
2024                 break;
2025
2026               case 'H':
2027               case 'f':
2028                 /* cursor move absolute */
2029                 FLUSH_TEXT();
2030                 y = (handle->tty.wr.ansi_csi_argc >= 1 &&
2031                      handle->tty.wr.ansi_csi_argv[0])
2032                   ? handle->tty.wr.ansi_csi_argv[0] - 1 : 0;
2033                 x = (handle->tty.wr.ansi_csi_argc >= 2 &&
2034                      handle->tty.wr.ansi_csi_argv[1])
2035                   ? handle->tty.wr.ansi_csi_argv[1] - 1 : 0;
2036                 uv__tty_move_caret(handle, x, 0, y, 0, error);
2037                 break;
2038
2039               case 'J':
2040                 /* Erase screen */
2041                 FLUSH_TEXT();
2042                 d = handle->tty.wr.ansi_csi_argc
2043                   ? handle->tty.wr.ansi_csi_argv[0] : 0;
2044                 if (d >= 0 && d <= 2) {
2045                   uv__tty_clear(handle, d, 1, error);
2046                 }
2047                 break;
2048
2049               case 'K':
2050                 /* Erase line */
2051                 FLUSH_TEXT();
2052                 d = handle->tty.wr.ansi_csi_argc
2053                   ? handle->tty.wr.ansi_csi_argv[0] : 0;
2054                 if (d >= 0 && d <= 2) {
2055                   uv__tty_clear(handle, d, 0, error);
2056                 }
2057                 break;
2058
2059               case 'm':
2060                 /* Set style */
2061                 FLUSH_TEXT();
2062                 uv__tty_set_style(handle, error);
2063                 break;
2064
2065               case 's':
2066                 /* Save the cursor position. */
2067                 FLUSH_TEXT();
2068                 uv__tty_save_state(handle, 0, error);
2069                 break;
2070
2071               case 'u':
2072                 /* Restore the cursor position */
2073                 FLUSH_TEXT();
2074                 uv__tty_restore_state(handle, 0, error);
2075                 break;
2076             }
2077           }
2078
2079           /* Sequence ended - go back to normal state. */
2080           ansi_parser_state = ANSI_NORMAL;
2081           continue;
2082
2083         } else {
2084           /* We don't support commands that use private mode characters or
2085            * intermediaries. Ignore the rest of the sequence. */
2086           ansi_parser_state = ANSI_IGNORE;
2087           continue;
2088         }
2089
2090       } else if (ansi_parser_state & ANSI_ST_CONTROL) {
2091         /* Unsupported control code.
2092          * Ignore everything until we see `BEL` or `ESC \`. */
2093         if (ansi_parser_state & ANSI_IN_STRING) {
2094           if (!(ansi_parser_state & ANSI_BACKSLASH_SEEN)) {
2095             if (utf8_codepoint == '"') {
2096               ansi_parser_state &= ~ANSI_IN_STRING;
2097             } else if (utf8_codepoint == '\\') {
2098               ansi_parser_state |= ANSI_BACKSLASH_SEEN;
2099             }
2100           } else {
2101             ansi_parser_state &= ~ANSI_BACKSLASH_SEEN;
2102           }
2103         } else {
2104           if (utf8_codepoint == '\007' || (utf8_codepoint == '\\' &&
2105               (ansi_parser_state & ANSI_ESCAPE_SEEN))) {
2106             /* End of sequence */
2107             ansi_parser_state = ANSI_NORMAL;
2108           } else if (utf8_codepoint == '\033') {
2109             /* Escape character */
2110             ansi_parser_state |= ANSI_ESCAPE_SEEN;
2111           } else if (utf8_codepoint == '"') {
2112              /* String starting */
2113             ansi_parser_state |= ANSI_IN_STRING;
2114             ansi_parser_state &= ~ANSI_ESCAPE_SEEN;
2115             ansi_parser_state &= ~ANSI_BACKSLASH_SEEN;
2116           } else {
2117             ansi_parser_state &= ~ANSI_ESCAPE_SEEN;
2118           }
2119         }
2120         continue;
2121       } else {
2122         /* Inconsistent state */
2123         abort();
2124       }
2125
2126       if (utf8_codepoint == 0x0a || utf8_codepoint == 0x0d) {
2127         /* EOL conversion - emit \r\n when we see \n. */
2128
2129         if (utf8_codepoint == 0x0a && previous_eol != 0x0d) {
2130           /* \n was not preceded by \r; print \r\n. */
2131           ENSURE_BUFFER_SPACE(2);
2132           utf16_buf[utf16_buf_used++] = L'\r';
2133           utf16_buf[utf16_buf_used++] = L'\n';
2134         } else if (utf8_codepoint == 0x0d && previous_eol == 0x0a) {
2135           /* \n was followed by \r; do not print the \r, since the source was
2136            * either \r\n\r (so the second \r is redundant) or was \n\r (so the
2137            * \n was processed by the last case and an \r automatically
2138            * inserted). */
2139         } else {
2140           /* \r without \n; print \r as-is. */
2141           ENSURE_BUFFER_SPACE(1);
2142           utf16_buf[utf16_buf_used++] = (WCHAR) utf8_codepoint;
2143         }
2144
2145         previous_eol = (char) utf8_codepoint;
2146
2147       } else if (utf8_codepoint <= 0xffff) {
2148         /* Encode character into utf-16 buffer. */
2149         ENSURE_BUFFER_SPACE(1);
2150         utf16_buf[utf16_buf_used++] = (WCHAR) utf8_codepoint;
2151         previous_eol = 0;
2152       } else {
2153         ENSURE_BUFFER_SPACE(2);
2154         utf8_codepoint -= 0x10000;
2155         utf16_buf[utf16_buf_used++] = (WCHAR) (utf8_codepoint / 0x400 + 0xD800);
2156         utf16_buf[utf16_buf_used++] = (WCHAR) (utf8_codepoint % 0x400 + 0xDC00);
2157         previous_eol = 0;
2158       }
2159     }
2160   }
2161
2162   /* Flush remaining characters */
2163   FLUSH_TEXT();
2164
2165   /* Copy cached values back to struct. */
2166   handle->tty.wr.utf8_bytes_left = utf8_bytes_left;
2167   handle->tty.wr.utf8_codepoint = utf8_codepoint;
2168   handle->tty.wr.previous_eol = previous_eol;
2169   handle->tty.wr.ansi_parser_state = ansi_parser_state;
2170
2171   uv_sem_post(&uv_tty_output_lock);
2172
2173   if (*error == STATUS_SUCCESS) {
2174     return 0;
2175   } else {
2176     return -1;
2177   }
2178
2179 #undef FLUSH_TEXT
2180 }
2181
2182
2183 int uv__tty_write(uv_loop_t* loop,
2184                  uv_write_t* req,
2185                  uv_tty_t* handle,
2186                  const uv_buf_t bufs[],
2187                  unsigned int nbufs,
2188                  uv_write_cb cb) {
2189   DWORD error;
2190
2191   UV_REQ_INIT(req, UV_WRITE);
2192   req->handle = (uv_stream_t*) handle;
2193   req->cb = cb;
2194
2195   handle->reqs_pending++;
2196   handle->stream.conn.write_reqs_pending++;
2197   REGISTER_HANDLE_REQ(loop, handle, req);
2198
2199   req->u.io.queued_bytes = 0;
2200
2201   if (!uv__tty_write_bufs(handle, bufs, nbufs, &error)) {
2202     SET_REQ_SUCCESS(req);
2203   } else {
2204     SET_REQ_ERROR(req, error);
2205   }
2206
2207   uv__insert_pending_req(loop, (uv_req_t*) req);
2208
2209   return 0;
2210 }
2211
2212
2213 int uv__tty_try_write(uv_tty_t* handle,
2214                       const uv_buf_t bufs[],
2215                       unsigned int nbufs) {
2216   DWORD error;
2217
2218   if (handle->stream.conn.write_reqs_pending > 0)
2219     return UV_EAGAIN;
2220
2221   if (uv__tty_write_bufs(handle, bufs, nbufs, &error))
2222     return uv_translate_sys_error(error);
2223
2224   return uv__count_bufs(bufs, nbufs);
2225 }
2226
2227
2228 void uv__process_tty_write_req(uv_loop_t* loop, uv_tty_t* handle,
2229   uv_write_t* req) {
2230   int err;
2231
2232   handle->write_queue_size -= req->u.io.queued_bytes;
2233   UNREGISTER_HANDLE_REQ(loop, handle, req);
2234
2235   if (req->cb) {
2236     err = GET_REQ_ERROR(req);
2237     req->cb(req, uv_translate_sys_error(err));
2238   }
2239
2240
2241   handle->stream.conn.write_reqs_pending--;
2242   if (handle->stream.conn.write_reqs_pending == 0)
2243     if (handle->flags & UV_HANDLE_SHUTTING)
2244       uv__process_tty_shutdown_req(loop,
2245                                    handle,
2246                                    handle->stream.conn.shutdown_req);
2247
2248   DECREASE_PENDING_REQ_COUNT(handle);
2249 }
2250
2251
2252 void uv__tty_close(uv_tty_t* handle) {
2253   assert(handle->u.fd == -1 || handle->u.fd > 2);
2254   if (handle->flags & UV_HANDLE_READING)
2255     uv__tty_read_stop(handle);
2256
2257   if (handle->u.fd == -1)
2258     CloseHandle(handle->handle);
2259   else
2260     close(handle->u.fd);
2261
2262   handle->u.fd = -1;
2263   handle->handle = INVALID_HANDLE_VALUE;
2264   handle->flags &= ~(UV_HANDLE_READABLE | UV_HANDLE_WRITABLE);
2265   uv__handle_closing(handle);
2266
2267   if (handle->reqs_pending == 0)
2268     uv__want_endgame(handle->loop, (uv_handle_t*) handle);
2269 }
2270
2271
2272 void uv__process_tty_shutdown_req(uv_loop_t* loop, uv_tty_t* stream, uv_shutdown_t* req) {
2273   assert(stream->stream.conn.write_reqs_pending == 0);
2274   assert(req);
2275
2276   stream->stream.conn.shutdown_req = NULL;
2277   stream->flags &= ~UV_HANDLE_SHUTTING;
2278   UNREGISTER_HANDLE_REQ(loop, stream, req);
2279
2280   /* TTY shutdown is really just a no-op */
2281   if (req->cb) {
2282     if (stream->flags & UV_HANDLE_CLOSING) {
2283       req->cb(req, UV_ECANCELED);
2284     } else {
2285       req->cb(req, 0);
2286     }
2287   }
2288
2289   DECREASE_PENDING_REQ_COUNT(stream);
2290 }
2291
2292
2293 void uv__tty_endgame(uv_loop_t* loop, uv_tty_t* handle) {
2294   assert(handle->flags & UV_HANDLE_CLOSING);
2295   assert(handle->reqs_pending == 0);
2296
2297   /* The wait handle used for raw reading should be unregistered when the
2298    * wait callback runs. */
2299   assert(!(handle->flags & UV_HANDLE_TTY_READABLE) ||
2300          handle->tty.rd.read_raw_wait == NULL);
2301
2302   assert(!(handle->flags & UV_HANDLE_CLOSED));
2303   uv__handle_close(handle);
2304 }
2305
2306
2307 /*
2308  * uv__process_tty_accept_req() is a stub to keep DELEGATE_STREAM_REQ working
2309  * TODO: find a way to remove it
2310  */
2311 void uv__process_tty_accept_req(uv_loop_t* loop, uv_tty_t* handle,
2312     uv_req_t* raw_req) {
2313   abort();
2314 }
2315
2316
2317 /*
2318  * uv__process_tty_connect_req() is a stub to keep DELEGATE_STREAM_REQ working
2319  * TODO: find a way to remove it
2320  */
2321 void uv__process_tty_connect_req(uv_loop_t* loop, uv_tty_t* handle,
2322     uv_connect_t* req) {
2323   abort();
2324 }
2325
2326
2327 int uv_tty_reset_mode(void) {
2328   /* Not necessary to do anything. */
2329   return 0;
2330 }
2331
2332 /* Determine whether or not this version of windows supports
2333  * proper ANSI color codes. Should be supported as of windows
2334  * 10 version 1511, build number 10.0.10586.
2335  */
2336 static void uv__determine_vterm_state(HANDLE handle) {
2337   DWORD dwMode = 0;
2338
2339   uv__need_check_vterm_state = FALSE;
2340   if (!GetConsoleMode(handle, &dwMode)) {
2341     return;
2342   }
2343
2344   dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
2345   if (!SetConsoleMode(handle, dwMode)) {
2346     return;
2347   }
2348
2349   uv__vterm_state = UV_TTY_SUPPORTED;
2350 }
2351
2352 static DWORD WINAPI uv__tty_console_resize_message_loop_thread(void* param) {
2353   NTSTATUS status;
2354   ULONG_PTR conhost_pid;
2355   MSG msg;
2356
2357   if (pSetWinEventHook == NULL || pNtQueryInformationProcess == NULL)
2358     return 0;
2359
2360   status = pNtQueryInformationProcess(GetCurrentProcess(),
2361                                       ProcessConsoleHostProcess,
2362                                       &conhost_pid,
2363                                       sizeof(conhost_pid),
2364                                       NULL);
2365
2366   if (!NT_SUCCESS(status)) {
2367     /* We couldn't retrieve our console host process, probably because this
2368      * is a 32-bit process running on 64-bit Windows. Fall back to receiving
2369      * console events from the input stream only. */
2370     return 0;
2371   }
2372
2373   /* Ensure the PID is a multiple of 4, which is required by SetWinEventHook */
2374   conhost_pid &= ~(ULONG_PTR)0x3;
2375
2376   uv__tty_console_resized = CreateEvent(NULL, TRUE, FALSE, NULL);
2377   if (uv__tty_console_resized == NULL)
2378     return 0;
2379   if (QueueUserWorkItem(uv__tty_console_resize_watcher_thread,
2380                         NULL,
2381                         WT_EXECUTELONGFUNCTION) == 0)
2382     return 0;
2383
2384   if (!pSetWinEventHook(EVENT_CONSOLE_LAYOUT,
2385                         EVENT_CONSOLE_LAYOUT,
2386                         NULL,
2387                         uv__tty_console_resize_event,
2388                         (DWORD)conhost_pid,
2389                         0,
2390                         WINEVENT_OUTOFCONTEXT))
2391     return 0;
2392
2393   while (GetMessage(&msg, NULL, 0, 0)) {
2394     TranslateMessage(&msg);
2395     DispatchMessage(&msg);
2396   }
2397   return 0;
2398 }
2399
2400 static void CALLBACK uv__tty_console_resize_event(HWINEVENTHOOK hWinEventHook,
2401                                                   DWORD event,
2402                                                   HWND hwnd,
2403                                                   LONG idObject,
2404                                                   LONG idChild,
2405                                                   DWORD dwEventThread,
2406                                                   DWORD dwmsEventTime) {
2407   SetEvent(uv__tty_console_resized);
2408 }
2409
2410 static DWORD WINAPI uv__tty_console_resize_watcher_thread(void* param) {
2411   for (;;) {
2412     /* Make sure to not overwhelm the system with resize events */
2413     Sleep(33);
2414     WaitForSingleObject(uv__tty_console_resized, INFINITE);
2415     uv__tty_console_signal_resize();
2416     ResetEvent(uv__tty_console_resized);
2417   }
2418   return 0;
2419 }
2420
2421 static void uv__tty_console_signal_resize(void) {
2422   CONSOLE_SCREEN_BUFFER_INFO sb_info;
2423   int width, height;
2424
2425   if (!GetConsoleScreenBufferInfo(uv__tty_console_handle, &sb_info))
2426     return;
2427
2428   width = sb_info.dwSize.X;
2429   height = sb_info.srWindow.Bottom - sb_info.srWindow.Top + 1;
2430
2431   uv_mutex_lock(&uv__tty_console_resize_mutex);
2432   assert(uv__tty_console_width != -1 && uv__tty_console_height != -1);
2433   if (width != uv__tty_console_width || height != uv__tty_console_height) {
2434     uv__tty_console_width = width;
2435     uv__tty_console_height = height;
2436     uv_mutex_unlock(&uv__tty_console_resize_mutex);
2437     uv__signal_dispatch(SIGWINCH);
2438   } else {
2439     uv_mutex_unlock(&uv__tty_console_resize_mutex);
2440   }
2441 }
2442
2443 void uv_tty_set_vterm_state(uv_tty_vtermstate_t state) {
2444   uv_sem_wait(&uv_tty_output_lock);
2445   uv__need_check_vterm_state = FALSE;
2446   uv__vterm_state = state;
2447   uv_sem_post(&uv_tty_output_lock);
2448 }
2449
2450 int uv_tty_get_vterm_state(uv_tty_vtermstate_t* state) {
2451   uv_sem_wait(&uv_tty_output_lock);
2452   *state = uv__vterm_state;
2453   uv_sem_post(&uv_tty_output_lock);
2454   return 0;
2455 }