tty.c File Reference

#include <assert.h>
#include <io.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include "uv.h"
#include "internal.h"
#include "handle-inl.h"
#include "stream-inl.h"
#include "req-inl.h"

Go to the source code of this file.

Macros
#define	COMMON_LVB_REVERSE_VIDEO   0x4000
#define	InterlockedOr   _InterlockedOr
#define	UNICODE_REPLACEMENT_CHARACTER   (0xfffd)
#define	ANSI_NORMAL   0x0000
#define	ANSI_ESCAPE_SEEN   0x0002
#define	ANSI_CSI   0x0004
#define	ANSI_ST_CONTROL   0x0008
#define	ANSI_IGNORE   0x0010
#define	ANSI_IN_ARG   0x0020
#define	ANSI_IN_STRING   0x0040
#define	ANSI_BACKSLASH_SEEN   0x0080
#define	ANSI_EXTENSION   0x0100
#define	ANSI_DECSCUSR   0x0200
#define	MAX_INPUT_BUFFER_LENGTH   8192
#define	MAX_CONSOLE_CHAR   8192
#define	ENABLE_VIRTUAL_TERMINAL_PROCESSING   0x0004
#define	CURSOR_SIZE_SMALL   25
#define	CURSOR_SIZE_LARGE   100
#define	VK_CASE(vk, normal_str, shift_str, ctrl_str, shift_ctrl_str)
#define	KEV   handle->tty.rd.last_input_record.Event.KeyEvent
#define	FLIP_FGBG
#define	FLUSH_TEXT()
#define	ENSURE_BUFFER_SPACE(wchars_needed)

Enumerations
enum	uv__read_console_status_e { NOT_STARTED , IN_PROGRESS , TRAP_REQUESTED , COMPLETED }

Functions
static void	uv_tty_capture_initial_style (CONSOLE_SCREEN_BUFFER_INFO *screen_buffer_info, CONSOLE_CURSOR_INFO *cursor_info)
static void	uv_tty_update_virtual_window (CONSOLE_SCREEN_BUFFER_INFO *info)
static int	uv__cancel_read_console (uv_tty_t *handle)
static DWORD WINAPI	uv__tty_console_resize_message_loop_thread (void *param)
static void CALLBACK	uv__tty_console_resize_event (HWINEVENTHOOK hWinEventHook, DWORD event, HWND hwnd, LONG idObject, LONG idChild, DWORD dwEventThread, DWORD dwmsEventTime)
static DWORD WINAPI	uv__tty_console_resize_watcher_thread (void *param)
static void	uv__tty_console_signal_resize (void)
static void	uv__determine_vterm_state (HANDLE handle)
void	uv_console_init (void)
int	uv_tty_init (uv_loop_t *loop, uv_tty_t *tty, uv_file fd, int unused)
int	uv_tty_set_mode (uv_tty_t *tty, uv_tty_mode_t mode)
int	uv_tty_get_winsize (uv_tty_t *tty, int *width, int *height)
static void CALLBACK	uv_tty_post_raw_read (void *data, BOOLEAN didTimeout)
static void	uv_tty_queue_read_raw (uv_loop_t *loop, uv_tty_t *handle)
static DWORD CALLBACK	uv_tty_line_read_thread (void *data)
static void	uv_tty_queue_read_line (uv_loop_t *loop, uv_tty_t *handle)
static void	uv_tty_queue_read (uv_loop_t *loop, uv_tty_t *handle)
static const char *	get_vt100_fn_key (DWORD code, char shift, char ctrl, size_t *len)
void	uv_process_tty_read_raw_req (uv_loop_t *loop, uv_tty_t *handle, uv_req_t *req)
void	uv_process_tty_read_line_req (uv_loop_t *loop, uv_tty_t *handle, uv_req_t *req)
void	uv_process_tty_read_req (uv_loop_t *loop, uv_tty_t *handle, uv_req_t *req)
int	uv_tty_read_start (uv_tty_t *handle, uv_alloc_cb alloc_cb, uv_read_cb read_cb)
int	uv_tty_read_stop (uv_tty_t *handle)
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)
static int	uv_tty_emit_text (uv_tty_t *handle, WCHAR buffer[], DWORD length, DWORD *error)
static int	uv_tty_move_caret (uv_tty_t *handle, int x, unsigned char x_relative, int y, unsigned char y_relative, DWORD *error)
static int	uv_tty_reset (uv_tty_t *handle, DWORD *error)
static int	uv_tty_clear (uv_tty_t *handle, int dir, char entire_screen, DWORD *error)
static int	uv_tty_set_style (uv_tty_t *handle, DWORD *error)
static int	uv_tty_save_state (uv_tty_t *handle, unsigned char save_attributes, DWORD *error)
static int	uv_tty_restore_state (uv_tty_t *handle, unsigned char restore_attributes, DWORD *error)
static int	uv_tty_set_cursor_visibility (uv_tty_t *handle, BOOL visible, DWORD *error)
static int	uv_tty_set_cursor_shape (uv_tty_t *handle, int style, DWORD *error)
static int	uv_tty_write_bufs (uv_tty_t *handle, const uv_buf_t bufs[], unsigned int nbufs, DWORD *error)
int	uv_tty_write (uv_loop_t *loop, uv_write_t *req, uv_tty_t *handle, const uv_buf_t bufs[], unsigned int nbufs, uv_write_cb cb)
int	uv__tty_try_write (uv_tty_t *handle, const uv_buf_t bufs[], unsigned int nbufs)
void	uv_process_tty_write_req (uv_loop_t *loop, uv_tty_t *handle, uv_write_t *req)
void	uv_tty_close (uv_tty_t *handle)
void	uv_tty_endgame (uv_loop_t *loop, uv_tty_t *handle)
void	uv_process_tty_accept_req (uv_loop_t *loop, uv_tty_t *handle, uv_req_t *raw_req)
void	uv_process_tty_connect_req (uv_loop_t *loop, uv_tty_t *handle, uv_connect_t *req)
int	uv_tty_reset_mode (void)
void	uv_tty_set_vterm_state (uv_tty_vtermstate_t state)
int	uv_tty_get_vterm_state (uv_tty_vtermstate_t *state)

Variables
static const uv_buf_t	uv_null_buf_ = { 0, NULL }
static volatile LONG	uv__read_console_status = NOT_STARTED
static volatile LONG	uv__restore_screen_state
static CONSOLE_SCREEN_BUFFER_INFO	uv__saved_screen_state
static int	uv_tty_virtual_offset = -1
static int	uv_tty_virtual_height = -1
static int	uv_tty_virtual_width = -1
static HANDLE	uv__tty_console_handle = INVALID_HANDLE_VALUE
static int	uv__tty_console_height = -1
static int	uv__tty_console_width = -1
static HANDLE	uv__tty_console_resized = INVALID_HANDLE_VALUE
static uv_mutex_t	uv__tty_console_resize_mutex
static uv_sem_t	uv_tty_output_lock
static WORD	uv_tty_default_text_attributes
static char	uv_tty_default_fg_color = 7
static char	uv_tty_default_bg_color = 0
static char	uv_tty_default_fg_bright = 0
static char	uv_tty_default_bg_bright = 0
static char	uv_tty_default_inverse = 0
static CONSOLE_CURSOR_INFO	uv_tty_default_cursor_info
static BOOL	uv__need_check_vterm_state = TRUE
static uv_tty_vtermstate_t	uv__vterm_state = UV_TTY_UNSUPPORTED

Macro Definition Documentation

ANSI_BACKSLASH_SEEN

#define ANSI_BACKSLASH_SEEN   0x0080

Definition at line 56 of file tty.c.

ANSI_CSI

#define ANSI_CSI   0x0004

Definition at line 51 of file tty.c.

ANSI_DECSCUSR

#define ANSI_DECSCUSR   0x0200

Definition at line 58 of file tty.c.

ANSI_ESCAPE_SEEN

#define ANSI_ESCAPE_SEEN   0x0002

Definition at line 50 of file tty.c.

ANSI_EXTENSION

#define ANSI_EXTENSION   0x0100

Definition at line 57 of file tty.c.

ANSI_IGNORE

#define ANSI_IGNORE   0x0010

Definition at line 53 of file tty.c.

ANSI_IN_ARG

#define ANSI_IN_ARG   0x0020

Definition at line 54 of file tty.c.

ANSI_IN_STRING

#define ANSI_IN_STRING   0x0040

Definition at line 55 of file tty.c.

ANSI_NORMAL

#define ANSI_NORMAL   0x0000

Definition at line 49 of file tty.c.

ANSI_ST_CONTROL

#define ANSI_ST_CONTROL   0x0008

Definition at line 52 of file tty.c.

COMMON_LVB_REVERSE_VIDEO

#define COMMON_LVB_REVERSE_VIDEO   0x4000

Definition at line 34 of file tty.c.

CURSOR_SIZE_LARGE

#define CURSOR_SIZE_LARGE   100

Definition at line 68 of file tty.c.

CURSOR_SIZE_SMALL

#define CURSOR_SIZE_SMALL   25

Definition at line 67 of file tty.c.

ENABLE_VIRTUAL_TERMINAL_PROCESSING

#define ENABLE_VIRTUAL_TERMINAL_PROCESSING   0x0004

Definition at line 64 of file tty.c.

ENSURE_BUFFER_SPACE

#define ENSURE_BUFFER_SPACE

(

wchars_needed

)

Value:

  if (wchars_needed > ARRAY_SIZE(utf16_buf) - utf16_buf_used) {     \
    FLUSH_TEXT();                                                   \
  }

FLIP_FGBG

#define FLIP_FGBG

Value:

    do {                                                                      \
      WORD fg = info.wAttributes & 0xF;                                       \
      WORD bg = info.wAttributes & 0xF0;                                      \
      info.wAttributes &= 0xFF00;                                             \
      info.wAttributes |= fg << 4;                                            \
      info.wAttributes |= bg >> 4;                                            \
    } while (0)

Definition at line 1394 of file tty.c.

FLUSH_TEXT

#define FLUSH_TEXT

(

)

Value:

  do {                                                              \
    if (utf16_buf_used > 0) {                                       \
      uv_tty_emit_text(handle, utf16_buf, utf16_buf_used, error);   \
      utf16_buf_used = 0;                                           \
    }                                                               \
  } while (0)

InterlockedOr

#define InterlockedOr   _InterlockedOr

Definition at line 44 of file tty.c.

KEV

#define KEV   handle->tty.rd.last_input_record.Event.KeyEvent

MAX_CONSOLE_CHAR

#define MAX_CONSOLE_CHAR   8192

Definition at line 61 of file tty.c.

MAX_INPUT_BUFFER_LENGTH

#define MAX_INPUT_BUFFER_LENGTH   8192

Definition at line 60 of file tty.c.

UNICODE_REPLACEMENT_CHARACTER

#define UNICODE_REPLACEMENT_CHARACTER   (0xfffd)

Definition at line 47 of file tty.c.

VK_CASE

#define VK_CASE	(		vk,
			normal_str,
			shift_str,
			ctrl_str,
			shift_ctrl_str
	)

Value:

    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;                                             \
      }

Enumeration Type Documentation

uv__read_console_status_e

enum uv__read_console_status_e

Enumerator
NOT_STARTED
IN_PROGRESS
TRAP_REQUESTED
COMPLETED

Definition at line 80 of file tty.c.

                               {
  NOT_STARTED,
  IN_PROGRESS,
  TRAP_REQUESTED,
  COMPLETED
};

Function Documentation

get_vt100_fn_key()

static const char* get_vt100_fn_key ( DWORD  code, char  shift, char  ctrl, size_t *  len  )

static

Definition at line 631 of file tty.c.

                 {
#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) {
    /* These mappings are the same as Cygwin's. Unmodified and alt-modified
     * keypad keys comply with linux console, modifiers comply with xterm
     * modifier usage. F1. f12 and shift-f1. f10 comply with linux console, f6.
     * f12 with and without modifiers comply with rxvt. */
    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
}

References len, NULL, and VK_CASE.

Referenced by uv_process_tty_read_raw_req().

uv__cancel_read_console()

static int uv__cancel_read_console ( uv_tty_t *  handle )

static

Definition at line 1084 of file tty.c.

                                                     {
  HANDLE active_screen_buffer = INVALID_HANDLE_VALUE;
  INPUT_RECORD record;
  DWORD written;
  DWORD err = 0;
  LONG status;
 
  assert(!(handle->flags & UV_HANDLE_CANCELLATION_PENDING));
 
  /* Hold the output lock during the cancellation, to ensure that further
     writes don't interfere with the screen state. It will be the ReadConsole
     thread's responsibility to release the lock. */
  uv_sem_wait(&uv_tty_output_lock);
  status = InterlockedExchange(&uv__read_console_status, TRAP_REQUESTED);
  if (status != IN_PROGRESS) {
    /* Either we have managed to set a trap for the other thread before
       ReadConsole is called, or ReadConsole has returned because the user
       has pressed ENTER. In either case, there is nothing else to do. */
    uv_sem_post(&uv_tty_output_lock);
    return 0;
  }
 
  /* Save screen state before sending the VK_RETURN event */
  active_screen_buffer = CreateFileA("conout$",
                                     GENERIC_READ | GENERIC_WRITE,
                                     FILE_SHARE_READ | FILE_SHARE_WRITE,
                                     NULL,
                                     OPEN_EXISTING,
                                     FILE_ATTRIBUTE_NORMAL,
                                     NULL);
 
  if (active_screen_buffer != INVALID_HANDLE_VALUE &&
      GetConsoleScreenBufferInfo(active_screen_buffer,
                                 &uv__saved_screen_state)) {
    InterlockedOr(&uv__restore_screen_state, 1);
  }
 
  /* Write enter key event to force the console wait to return. */
  record.EventType = KEY_EVENT;
  record.Event.KeyEvent.bKeyDown = TRUE;
  record.Event.KeyEvent.wRepeatCount = 1;
  record.Event.KeyEvent.wVirtualKeyCode = VK_RETURN;
  record.Event.KeyEvent.wVirtualScanCode =
    MapVirtualKeyW(VK_RETURN, MAPVK_VK_TO_VSC);
  record.Event.KeyEvent.uChar.UnicodeChar = L'\r';
  record.Event.KeyEvent.dwControlKeyState = 0;
  if (!WriteConsoleInputW(handle->handle, &record, 1, &written))
    err = GetLastError();
 
  if (active_screen_buffer != INVALID_HANDLE_VALUE)
    CloseHandle(active_screen_buffer);
 
  return err;
}

References assert(), DWORD, err, handle, HANDLE, IN_PROGRESS, InterlockedExchange, InterlockedOr, INVALID_HANDLE_VALUE, L, LONG, NULL, status, TRAP_REQUESTED, TRUE, uv__read_console_status, uv__restore_screen_state, uv__saved_screen_state, UV_HANDLE_CANCELLATION_PENDING, uv_sem_post(), uv_sem_wait(), and uv_tty_output_lock.

Referenced by uv_tty_read_stop().

uv__determine_vterm_state()

static void uv__determine_vterm_state ( HANDLE  handle )

static

Definition at line 2333 of file tty.c.

                                                     {
  DWORD dwMode = 0;
 
  uv__need_check_vterm_state = FALSE;
  if (!GetConsoleMode(handle, &dwMode)) {
    return;
  }
 
  dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
  if (!SetConsoleMode(handle, dwMode)) {
    return;
  }
 
  uv__vterm_state = UV_TTY_SUPPORTED;
}

References DWORD, ENABLE_VIRTUAL_TERMINAL_PROCESSING, FALSE, handle, uv__need_check_vterm_state, uv__vterm_state, and UV_TTY_SUPPORTED.

Referenced by uv_tty_init().

uv__tty_console_resize_event()

static void CALLBACK uv__tty_console_resize_event ( HWINEVENTHOOK  hWinEventHook, DWORD  event, HWND  hwnd, LONG  idObject, LONG  idChild, DWORD  dwEventThread, DWORD  dwmsEventTime  )

static

Definition at line 2397 of file tty.c.

                                                                       {
  SetEvent(uv__tty_console_resized);
}

References uv__tty_console_resized.

Referenced by uv__tty_console_resize_message_loop_thread().

uv__tty_console_resize_message_loop_thread()

static DWORD WINAPI uv__tty_console_resize_message_loop_thread ( void *  param )

static

Definition at line 2349 of file tty.c.

                                                                            {
  NTSTATUS status;
  ULONG_PTR conhost_pid;
  MSG msg;
 
  if (pSetWinEventHook == NULL || pNtQueryInformationProcess == NULL)
    return 0;
 
  status = pNtQueryInformationProcess(GetCurrentProcess(),
                                      ProcessConsoleHostProcess,
                                      &conhost_pid,
                                      sizeof(conhost_pid),
                                      NULL);
 
  if (!NT_SUCCESS(status)) {
    /* We couldn't retrieve our console host process, probably because this
     * is a 32-bit process running on 64-bit Windows. Fall back to receiving
     * console events from the input stream only. */
    return 0;
  }
 
  /* Ensure the PID is a multiple of 4, which is required by SetWinEventHook */
  conhost_pid &= ~(ULONG_PTR)0x3;
 
  uv__tty_console_resized = CreateEvent(NULL, TRUE, FALSE, NULL);
  if (uv__tty_console_resized == NULL)
    return 0;
  if (QueueUserWorkItem(uv__tty_console_resize_watcher_thread,
                        NULL,
                        WT_EXECUTELONGFUNCTION) == 0)
    return 0;
 
  if (!pSetWinEventHook(EVENT_CONSOLE_LAYOUT,
                        EVENT_CONSOLE_LAYOUT,
                        NULL,
                        uv__tty_console_resize_event,
                        (DWORD)conhost_pid,
                        0,
                        WINEVENT_OUTOFCONTEXT))
    return 0;
 
  while (GetMessage(&msg, NULL, 0, 0)) {
    TranslateMessage(&msg);
    DispatchMessage(&msg);
  }
  return 0;
}

References DWORD, FALSE, msg, MSG, NT_SUCCESS, NULL, pNtQueryInformationProcess, ProcessConsoleHostProcess, pSetWinEventHook, status, TRUE, uv__tty_console_resize_event(), uv__tty_console_resize_watcher_thread(), and uv__tty_console_resized.

Referenced by uv_console_init().

uv__tty_console_resize_watcher_thread()

static DWORD WINAPI uv__tty_console_resize_watcher_thread ( void *  param )

static

Definition at line 2407 of file tty.c.

                                                                       {
  for (;;) {
    /* Make sure to not overwhelm the system with resize events */
    Sleep(33);
    WaitForSingleObject(uv__tty_console_resized, INFINITE);
    uv__tty_console_signal_resize();
    ResetEvent(uv__tty_console_resized);
  }
  return 0;
}

References uv__tty_console_resized, and uv__tty_console_signal_resize().

Referenced by uv__tty_console_resize_message_loop_thread().

uv__tty_console_signal_resize()

static void uv__tty_console_signal_resize ( void  )

static

Definition at line 2418 of file tty.c.

                                                {
  CONSOLE_SCREEN_BUFFER_INFO sb_info;
  int width, height;
 
  if (!GetConsoleScreenBufferInfo(uv__tty_console_handle, &sb_info))
    return;
 
  width = sb_info.dwSize.X;
  height = sb_info.srWindow.Bottom - sb_info.srWindow.Top + 1;
 
  uv_mutex_lock(&uv__tty_console_resize_mutex);
  assert(uv__tty_console_width != -1 && uv__tty_console_height != -1);
  if (width != uv__tty_console_width || height != uv__tty_console_height) {
    uv__tty_console_width = width;
    uv__tty_console_height = height;
    uv_mutex_unlock(&uv__tty_console_resize_mutex);
    uv__signal_dispatch(SIGWINCH);
  } else {
    uv_mutex_unlock(&uv__tty_console_resize_mutex);
  }
}

References assert(), height, SIGWINCH, uv__signal_dispatch(), uv__tty_console_handle, uv__tty_console_height, uv__tty_console_resize_mutex, uv__tty_console_width, uv_mutex_lock(), uv_mutex_unlock(), and width.

Referenced by uv__tty_console_resize_watcher_thread(), and uv_process_tty_read_raw_req().

uv__tty_try_write()

int uv__tty_try_write	(	uv_tty_t *	handle,
		const uv_buf_t	bufs[],
		unsigned int	nbufs
	)

Definition at line 2212 of file tty.c.

                                          {
  DWORD error;
 
  if (handle->stream.conn.write_reqs_pending > 0)
    return UV_EAGAIN;
 
  if (uv_tty_write_bufs(handle, bufs, nbufs, &error))
    return uv_translate_sys_error(error);
 
  return uv__count_bufs(bufs, nbufs);
}

References bufs, DWORD, error(), handle, uv__count_bufs(), uv_translate_sys_error(), and uv_tty_write_bufs().

Referenced by uv_try_write().

uv_console_init()

void uv_console_init

(

void

)

Definition at line 166 of file tty.c.

                           {
  if (uv_sem_init(&uv_tty_output_lock, 1))
    abort();
  uv__tty_console_handle = CreateFileW(L"CONOUT$",
                                       GENERIC_READ | GENERIC_WRITE,
                                       FILE_SHARE_WRITE,
                                       0,
                                       OPEN_EXISTING,
                                       0,
                                       0);
  if (uv__tty_console_handle != INVALID_HANDLE_VALUE) {
    CONSOLE_SCREEN_BUFFER_INFO sb_info;
    QueueUserWorkItem(uv__tty_console_resize_message_loop_thread,
                      NULL,
                      WT_EXECUTELONGFUNCTION);
    uv_mutex_init(&uv__tty_console_resize_mutex);
    if (GetConsoleScreenBufferInfo(uv__tty_console_handle, &sb_info)) {
      uv__tty_console_width = sb_info.dwSize.X;
      uv__tty_console_height = sb_info.srWindow.Bottom - sb_info.srWindow.Top + 1;
    }
  }
}

References INVALID_HANDLE_VALUE, L, NULL, uv__tty_console_handle, uv__tty_console_height, uv__tty_console_resize_message_loop_thread(), uv__tty_console_resize_mutex, uv__tty_console_width, uv_mutex_init(), uv_sem_init(), and uv_tty_output_lock.

Referenced by uv_init().

uv_process_tty_accept_req()

void uv_process_tty_accept_req	(	uv_loop_t *	loop,
		uv_tty_t *	handle,
		uv_req_t *	raw_req
	)

Definition at line 2308 of file tty.c.

                       {
  abort();
}

uv_process_tty_connect_req()

void uv_process_tty_connect_req	(	uv_loop_t *	loop,
		uv_tty_t *	handle,
		uv_connect_t *	req
	)

Definition at line 2318 of file tty.c.

                       {
  abort();
}

uv_process_tty_read_line_req()

void uv_process_tty_read_line_req	(	uv_loop_t *	loop,
		uv_tty_t *	handle,
		uv_req_t *	req
	)

Definition at line 960 of file tty.c.

                   {
  uv_buf_t buf;
 
  assert(handle->type == UV_TTY);
  assert(handle->flags & UV_HANDLE_TTY_READABLE);
 
  buf = handle->tty.rd.read_line_buffer;
 
  handle->flags &= ~UV_HANDLE_READ_PENDING;
  handle->tty.rd.read_line_buffer = uv_null_buf_;
 
  if (!REQ_SUCCESS(req)) {
    /* Read was not successful */
    if (handle->flags & UV_HANDLE_READING) {
      /* Real error */
      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 {
    if (!(handle->flags & UV_HANDLE_CANCELLATION_PENDING) &&
        req->u.io.overlapped.InternalHigh != 0) {
      /* Read successful. TODO: read unicode, convert to utf-8 */
      DWORD bytes = req->u.io.overlapped.InternalHigh;
      handle->read_cb((uv_stream_t*) handle, bytes, &buf);
    }
    handle->flags &= ~UV_HANDLE_CANCELLATION_PENDING;
  }
 
  /* Wait for more input events. */
  if ((handle->flags & UV_HANDLE_READING) &&
      !(handle->flags & UV_HANDLE_READ_PENDING)) {
    uv_tty_queue_read(loop, handle);
  }
 
  DECREASE_PENDING_REQ_COUNT(handle);
}

References assert(), bytes, DECREASE_ACTIVE_COUNT, DECREASE_PENDING_REQ_COUNT, DWORD, GET_REQ_ERROR, handle, loop, req, REQ_SUCCESS, UV_HANDLE_CANCELLATION_PENDING, UV_HANDLE_READ_PENDING, UV_HANDLE_READING, UV_HANDLE_TTY_READABLE, uv_null_buf_, uv_translate_sys_error(), and uv_tty_queue_read().

Referenced by uv_process_tty_read_req().

uv_process_tty_read_raw_req()

void uv_process_tty_read_raw_req	(	uv_loop_t *	loop,
		uv_tty_t *	handle,
		uv_req_t *	req
	)

Definition at line 697 of file tty.c.

                   {
  /* Shortcut for handle->tty.rd.last_input_record.Event.KeyEvent. */
#define KEV handle->tty.rd.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)) {
    /* An error occurred while waiting for the event. */
    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;
  }
 
  /* Fetch the number of events  */
  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;
  }
 
  /* Windows sends a lot of events that we're not interested in, so buf will be
   * allocated on demand, when there's actually something to emit. */
  buf = uv_null_buf_;
  buf_used = 0;
 
  while ((records_left > 0 || handle->tty.rd.last_key_len > 0) &&
         (handle->flags & UV_HANDLE_READING)) {
    if (handle->tty.rd.last_key_len == 0) {
      /* Read the next input record */
      if (!ReadConsoleInputW(handle->handle,
                             &handle->tty.rd.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--;
 
      /* We might be not subscribed to EVENT_CONSOLE_LAYOUT or we might be
       * running under some TTY emulator that does not send those events. */
      if (handle->tty.rd.last_input_record.EventType == WINDOW_BUFFER_SIZE_EVENT) {
        uv__tty_console_signal_resize();
      }
 
      /* Ignore other events that are not key events. */
      if (handle->tty.rd.last_input_record.EventType != KEY_EVENT) {
        continue;
      }
 
      /* Ignore keyup events, unless the left alt key was held and a valid
       * unicode character was emitted. */
      if (!KEV.bKeyDown &&
          (KEV.wVirtualKeyCode != VK_MENU ||
           KEV.uChar.UnicodeChar == 0)) {
        continue;
      }
 
      /* Ignore keypresses to numpad number keys if the left alt is held
       * because the user is composing a character, or windows simulating this.
       */
      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;
 
        /* Character key pressed */
        if (KEV.uChar.UnicodeChar >= 0xD800 &&
            KEV.uChar.UnicodeChar < 0xDC00) {
          /* UTF-16 high surrogate */
          handle->tty.rd.last_utf16_high_surrogate = KEV.uChar.UnicodeChar;
          continue;
        }
 
        /* Prefix with \u033 if alt was held, but alt was not used as part a
         * compose sequence. */
        if ((KEV.dwControlKeyState & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED))
            && !(KEV.dwControlKeyState & (LEFT_CTRL_PRESSED |
            RIGHT_CTRL_PRESSED)) && KEV.bKeyDown) {
          handle->tty.rd.last_key[0] = '\033';
          prefix_len = 1;
        } else {
          prefix_len = 0;
        }
 
        if (KEV.uChar.UnicodeChar >= 0xDC00 &&
            KEV.uChar.UnicodeChar < 0xE000) {
          /* UTF-16 surrogate pair */
          WCHAR utf16_buffer[2];
          utf16_buffer[0] = handle->tty.rd.last_utf16_high_surrogate;
          utf16_buffer[1] = KEV.uChar.UnicodeChar;
          char_len = WideCharToMultiByte(CP_UTF8,
                                         0,
                                         utf16_buffer,
                                         2,
                                         &handle->tty.rd.last_key[prefix_len],
                                         sizeof handle->tty.rd.last_key,
                                         NULL,
                                         NULL);
        } else {
          /* Single UTF-16 character */
          char_len = WideCharToMultiByte(CP_UTF8,
                                         0,
                                         &KEV.uChar.UnicodeChar,
                                         1,
                                         &handle->tty.rd.last_key[prefix_len],
                                         sizeof handle->tty.rd.last_key,
                                         NULL,
                                         NULL);
        }
 
        /* Whatever happened, the last character wasn't a high surrogate. */
        handle->tty.rd.last_utf16_high_surrogate = 0;
 
        /* If the utf16 character(s) couldn't be converted something must be
         * wrong. */
        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->tty.rd.last_key_len = (unsigned char) (prefix_len + char_len);
        handle->tty.rd.last_key_offset = 0;
        continue;
 
      } else {
        /* Function key pressed */
        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 we were unable to map to a vt100 sequence, just ignore. */
        if (!vt100) {
          continue;
        }
 
        /* Prefix with \x033 when the alt key was held. */
        if (KEV.dwControlKeyState & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED)) {
          handle->tty.rd.last_key[0] = '\033';
          prefix_len = 1;
        } else {
          prefix_len = 0;
        }
 
        /* Copy the vt100 sequence to the handle buffer. */
        assert(prefix_len + vt100_len < sizeof handle->tty.rd.last_key);
        memcpy(&handle->tty.rd.last_key[prefix_len], vt100, vt100_len);
 
        handle->tty.rd.last_key_len = (unsigned char) (prefix_len + vt100_len);
        handle->tty.rd.last_key_offset = 0;
        continue;
      }
    } else {
      /* Copy any bytes left from the last keypress to the user buffer. */
      if (handle->tty.rd.last_key_offset < handle->tty.rd.last_key_len) {
        /* Allocate a buffer if needed */
        if (buf_used == 0) {
          buf = uv_buf_init(NULL, 0);
          handle->alloc_cb((uv_handle_t*) handle, 1024, &buf);
          if (buf.base == NULL || buf.len == 0) {
            handle->read_cb((uv_stream_t*) handle, UV_ENOBUFS, &buf);
            goto out;
          }
          assert(buf.base != NULL);
        }
 
        buf.base[buf_used++] = handle->tty.rd.last_key[handle->tty.rd.last_key_offset++];
 
        /* If the buffer is full, emit it */
        if ((size_t) buf_used == buf.len) {
          handle->read_cb((uv_stream_t*) handle, buf_used, &buf);
          buf = uv_null_buf_;
          buf_used = 0;
        }
 
        continue;
      }
 
      /* Apply dwRepeat from the last input record. */
      if (--KEV.wRepeatCount > 0) {
        handle->tty.rd.last_key_offset = 0;
        continue;
      }
 
      handle->tty.rd.last_key_len = 0;
      continue;
    }
  }
 
  /* Send the buffer back to the user */
  if (buf_used > 0) {
    handle->read_cb((uv_stream_t*) handle, buf_used, &buf);
  }
 
 out:
  /* Wait for more input events. */
  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
}

References assert(), DECREASE_ACTIVE_COUNT, DECREASE_PENDING_REQ_COUNT, DWORD, GET_REQ_ERROR, get_vt100_fn_key(), handle, KEV, loop, memcpy(), NULL, out, req, REQ_SUCCESS, tty, uv__tty_console_signal_resize(), uv_buf_init(), UV_HANDLE_READ_PENDING, UV_HANDLE_READING, UV_HANDLE_TTY_RAW, UV_HANDLE_TTY_READABLE, uv_null_buf_, uv_translate_sys_error(), and uv_tty_queue_read().

Referenced by uv_process_tty_read_req().

uv_process_tty_read_req()

void uv_process_tty_read_req	(	uv_loop_t *	loop,
		uv_tty_t *	handle,
		uv_req_t *	req
	)

Definition at line 1002 of file tty.c.

                   {
  assert(handle->type == UV_TTY);
  assert(handle->flags & UV_HANDLE_TTY_READABLE);
 
  /* If the read_line_buffer member is zero, it must have been an raw read.
   * Otherwise it was a line-buffered read. FIXME: This is quite obscure. Use a
   * flag or something. */
  if (handle->tty.rd.read_line_buffer.len == 0) {
    uv_process_tty_read_raw_req(loop, handle, req);
  } else {
    uv_process_tty_read_line_req(loop, handle, req);
  }
}

References assert(), handle, loop, req, UV_HANDLE_TTY_READABLE, uv_process_tty_read_line_req(), and uv_process_tty_read_raw_req().

uv_process_tty_write_req()

void uv_process_tty_write_req	(	uv_loop_t *	loop,
		uv_tty_t *	handle,
		uv_write_t *	req
	)

Definition at line 2227 of file tty.c.

                   {
  int err;
 
  handle->write_queue_size -= req->u.io.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->stream.conn.write_reqs_pending--;
  if (handle->stream.conn.shutdown_req != NULL &&
      handle->stream.conn.write_reqs_pending == 0) {
    uv_want_endgame(loop, (uv_handle_t*)handle);
  }
 
  DECREASE_PENDING_REQ_COUNT(handle);
}

References DECREASE_PENDING_REQ_COUNT, err, GET_REQ_ERROR, handle, loop, NULL, req, UNREGISTER_HANDLE_REQ, uv_translate_sys_error(), and uv_want_endgame().

uv_tty_capture_initial_style()

static void uv_tty_capture_initial_style ( CONSOLE_SCREEN_BUFFER_INFO *  screen_buffer_info, CONSOLE_CURSOR_INFO *  cursor_info  )

static

Definition at line 292 of file tty.c.

                                      {
  static int style_captured = 0;
 
  /* Only do this once.
     Assumption: Caller has acquired uv_tty_output_lock. */
  if (style_captured)
    return;
 
  /* Save raw win32 attributes. */
  uv_tty_default_text_attributes = screen_buffer_info->wAttributes;
 
  /* Convert black text on black background to use white text. */
  if (uv_tty_default_text_attributes == 0)
    uv_tty_default_text_attributes = 7;
 
  /* Convert Win32 attributes to ANSI colors. */
  uv_tty_default_fg_color = 0;
  uv_tty_default_bg_color = 0;
  uv_tty_default_fg_bright = 0;
  uv_tty_default_bg_bright = 0;
  uv_tty_default_inverse = 0;
 
  if (uv_tty_default_text_attributes & FOREGROUND_RED)
    uv_tty_default_fg_color |= 1;
 
  if (uv_tty_default_text_attributes & FOREGROUND_GREEN)
    uv_tty_default_fg_color |= 2;
 
  if (uv_tty_default_text_attributes & FOREGROUND_BLUE)
    uv_tty_default_fg_color |= 4;
 
  if (uv_tty_default_text_attributes & BACKGROUND_RED)
    uv_tty_default_bg_color |= 1;
 
  if (uv_tty_default_text_attributes & BACKGROUND_GREEN)
    uv_tty_default_bg_color |= 2;
 
  if (uv_tty_default_text_attributes & BACKGROUND_BLUE)
    uv_tty_default_bg_color |= 4;
 
  if (uv_tty_default_text_attributes & FOREGROUND_INTENSITY)
    uv_tty_default_fg_bright = 1;
 
  if (uv_tty_default_text_attributes & BACKGROUND_INTENSITY)
    uv_tty_default_bg_bright = 1;
 
  if (uv_tty_default_text_attributes & COMMON_LVB_REVERSE_VIDEO)
    uv_tty_default_inverse = 1;
 
  /* Save the cursor size and the cursor state. */
  uv_tty_default_cursor_info = *cursor_info;
 
  style_captured = 1;
}

References COMMON_LVB_REVERSE_VIDEO, uv_tty_default_bg_bright, uv_tty_default_bg_color, uv_tty_default_cursor_info, uv_tty_default_fg_bright, uv_tty_default_fg_color, uv_tty_default_inverse, and uv_tty_default_text_attributes.

Referenced by uv_tty_init().

uv_tty_clear()

static int uv_tty_clear ( uv_tty_t *  handle, int  dir, char  entire_screen, DWORD *  error  )

static

Definition at line 1315 of file tty.c.

                  {
  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) {
    /* Clear from current position */
    x1 = 0;
    x1r = 1;
  } else {
    /* Clear from column 0 */
    x1 = 0;
    x1r = 0;
  }
 
  if (dir == 1) {
    /* Clear to current position */
    x2 = 0;
    x2r = 1;
  } else {
    /* Clear to end of row. We pretend the console is 65536 characters wide,
     * uv_tty_make_real_coord will clip it to the actual console width. */
    x2 = 0xffff;
    x2r = 0;
  }
 
  if (!entire_screen) {
    /* Stay on our own row */
    y1 = y2 = 0;
    y1r = y2r = 1;
  } else {
    /* Apply columns direction to row */
    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) {
      /* The console may be resized - retry */
      goto retry;
    } else {
      *error = GetLastError();
      return -1;
    }
  }
 
  return 0;
}

References count, DWORD, test_evm::end, error(), handle, info(), L, start, uv_tty_make_real_coord(), x1, and x2.

Referenced by uv_tty_write_bufs().

uv_tty_close()

void uv_tty_close

(

uv_tty_t *

handle

)

Definition at line 2249 of file tty.c.

                                    {
  assert(handle->u.fd == -1 || handle->u.fd > 2);
  if (handle->flags & UV_HANDLE_READING)
    uv_tty_read_stop(handle);
 
  if (handle->u.fd == -1)
    CloseHandle(handle->handle);
  else
    close(handle->u.fd);
 
  handle->u.fd = -1;
  handle->handle = INVALID_HANDLE_VALUE;
  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);
  }
}

References assert(), close, handle, INVALID_HANDLE_VALUE, uv__handle_closing, UV_HANDLE_READABLE, UV_HANDLE_READING, UV_HANDLE_WRITABLE, uv_tty_read_stop(), and uv_want_endgame().

Referenced by uv_close().

uv_tty_emit_text()

static int uv_tty_emit_text ( uv_tty_t *  handle, WCHAR  buffer[], DWORD  length, DWORD *  error  )

static

Definition at line 1200 of file tty.c.

                  {
  DWORD written;
 
  if (*error != ERROR_SUCCESS) {
    return -1;
  }
 
  if (!WriteConsoleW(handle->handle,
                     (void*) buffer,
                     length,
                     &written,
                     NULL)) {
    *error = GetLastError();
    return -1;
  }
 
  return 0;
}

References DWORD, error(), handle, length, and NULL.

uv_tty_endgame()

void uv_tty_endgame	(	uv_loop_t *	loop,
		uv_tty_t *	handle
	)

Definition at line 2270 of file tty.c.

                                                       {
  if (!(handle->flags & UV_HANDLE_TTY_READABLE) &&
      handle->stream.conn.shutdown_req != NULL &&
      handle->stream.conn.write_reqs_pending == 0) {
    UNREGISTER_HANDLE_REQ(loop, handle, handle->stream.conn.shutdown_req);
 
    /* TTY shutdown is really just a no-op */
    if (handle->stream.conn.shutdown_req->cb) {
      if (handle->flags & UV_HANDLE_CLOSING) {
        handle->stream.conn.shutdown_req->cb(handle->stream.conn.shutdown_req, UV_ECANCELED);
      } else {
        handle->stream.conn.shutdown_req->cb(handle->stream.conn.shutdown_req, 0);
      }
    }
 
    handle->stream.conn.shutdown_req = NULL;
 
    DECREASE_PENDING_REQ_COUNT(handle);
    return;
  }
 
  if (handle->flags & UV_HANDLE_CLOSING &&
      handle->reqs_pending == 0) {
    /* The wait handle used for raw reading should be unregistered when the
     * wait callback runs. */
    assert(!(handle->flags & UV_HANDLE_TTY_READABLE) ||
           handle->tty.rd.read_raw_wait == NULL);
 
    assert(!(handle->flags & UV_HANDLE_CLOSED));
    uv__handle_close(handle);
  }
}

References assert(), DECREASE_PENDING_REQ_COUNT, handle, loop, NULL, UNREGISTER_HANDLE_REQ, uv__handle_close, UV_HANDLE_CLOSED, UV_HANDLE_CLOSING, and UV_HANDLE_TTY_READABLE.

Referenced by uv_process_endgames().

uv_tty_get_vterm_state()

int uv_tty_get_vterm_state

(

uv_tty_vtermstate_t *

state

)

Definition at line 2447 of file tty.c.

                                                       {
  uv_sem_wait(&uv_tty_output_lock);
  *state = uv__vterm_state;
  uv_sem_post(&uv_tty_output_lock);
  return 0;
}

References uv__vterm_state, uv_sem_post(), uv_sem_wait(), and uv_tty_output_lock.

uv_tty_get_winsize()

int uv_tty_get_winsize	(	uv_tty_t *	tty,
		int *	width,
		int *	height
	)

Definition at line 417 of file tty.c.

                                                               {
  CONSOLE_SCREEN_BUFFER_INFO info;
 
  if (!GetConsoleScreenBufferInfo(tty->handle, &info)) {
    return uv_translate_sys_error(GetLastError());
  }
 
  uv_sem_wait(&uv_tty_output_lock);
  uv_tty_update_virtual_window(&info);
  uv_sem_post(&uv_tty_output_lock);
 
  *width = uv_tty_virtual_width;
  *height = uv_tty_virtual_height;
 
  return 0;
}

References EINTR, err, height, info(), ioctl, TIOCGWINSZ, tty, UV__ERR, uv__stream_fd, uv_sem_post(), uv_sem_wait(), uv_translate_sys_error(), uv_tty_output_lock, uv_tty_update_virtual_window(), uv_tty_virtual_height, uv_tty_virtual_width, width, winsize::ws_col, and winsize::ws_row.

Referenced by main().

uv_tty_init()

int uv_tty_init	(	uv_loop_t *	loop,
		uv_tty_t *	tty,
		uv_file	fd,
		int	unused
	)

Definition at line 190 of file tty.c.

                                                                        {
  BOOL readable;
  DWORD NumberOfEvents;
  HANDLE handle;
  CONSOLE_SCREEN_BUFFER_INFO screen_buffer_info;
  CONSOLE_CURSOR_INFO cursor_info;
  (void)unused;
 
  uv__once_init();
  handle = (HANDLE) uv__get_osfhandle(fd);
  if (handle == INVALID_HANDLE_VALUE)
    return UV_EBADF;
 
  if (fd <= 2) {
    /* In order to avoid closing a stdio file descriptor 0-2, duplicate the
     * underlying OS handle and forget about the original fd.
     * We could also opt to use the original OS handle and just never close it,
     * but then there would be no reliable way to cancel pending read operations
     * upon close.
     */
    if (!DuplicateHandle(INVALID_HANDLE_VALUE,
                         handle,
                         INVALID_HANDLE_VALUE,
                         &handle,
                         0,
                         FALSE,
                         DUPLICATE_SAME_ACCESS))
      return uv_translate_sys_error(GetLastError());
    fd = -1;
  }
 
  readable = GetNumberOfConsoleInputEvents(handle, &NumberOfEvents);
  if (!readable) {
    /* Obtain the screen buffer info with the output handle. */
    if (!GetConsoleScreenBufferInfo(handle, &screen_buffer_info)) {
      return uv_translate_sys_error(GetLastError());
    }
 
    /* Obtain the cursor info with the output handle. */
    if (!GetConsoleCursorInfo(handle, &cursor_info)) {
      return uv_translate_sys_error(GetLastError());
    }
 
    /* Obtain the tty_output_lock because the virtual window state is shared
     * between all uv_tty_t handles. */
    uv_sem_wait(&uv_tty_output_lock);
 
    if (uv__need_check_vterm_state)
      uv__determine_vterm_state(handle);
 
    /* Remember the original console text attributes and cursor info. */
    uv_tty_capture_initial_style(&screen_buffer_info, &cursor_info);
 
    uv_tty_update_virtual_window(&screen_buffer_info);
 
    uv_sem_post(&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->u.fd = fd;
  tty->reqs_pending = 0;
  tty->flags |= UV_HANDLE_BOUND;
 
  if (readable) {
    /* Initialize TTY input specific fields. */
    tty->flags |= UV_HANDLE_TTY_READABLE | UV_HANDLE_READABLE;
    /* TODO: remove me in v2.x. */
    tty->tty.rd.unused_ = NULL;
    tty->tty.rd.read_line_buffer = uv_null_buf_;
    tty->tty.rd.read_raw_wait = NULL;
 
    /* Init keycode-to-vt100 mapper state. */
    tty->tty.rd.last_key_len = 0;
    tty->tty.rd.last_key_offset = 0;
    tty->tty.rd.last_utf16_high_surrogate = 0;
    memset(&tty->tty.rd.last_input_record, 0, sizeof tty->tty.rd.last_input_record);
  } else {
    /* TTY output specific fields. */
    tty->flags |= UV_HANDLE_WRITABLE;
 
    /* Init utf8-to-utf16 conversion state. */
    tty->tty.wr.utf8_bytes_left = 0;
    tty->tty.wr.utf8_codepoint = 0;
 
    /* Initialize eol conversion state */
    tty->tty.wr.previous_eol = 0;
 
    /* Init ANSI parser state. */
    tty->tty.wr.ansi_parser_state = ANSI_NORMAL;
  }
 
  return 0;
}

References ANSI_NORMAL, DWORD, EINTR, F_GETFL, F_SETFL, FALSE, fcntl, fd, flags, handle, HANDLE, INVALID_HANDLE_VALUE, loop, memset(), NULL, O_ACCMODE, O_NOCTTY, O_RDONLY, O_WRONLY, path, QUEUE_REMOVE, r, skip(), tty, type, uv__close(), uv__determine_vterm_state(), uv__dup2_cloexec(), UV__ERR, uv__get_osfhandle(), uv__need_check_vterm_state, uv__nonblock, uv__once_init(), uv__open_cloexec(), uv__stream_init(), uv__stream_open(), uv__tty_is_slave(), uv_connection_init(), UV_FILE, uv_guess_handle(), UV_HANDLE_BLOCKING_WRITES, UV_HANDLE_BOUND, UV_HANDLE_READABLE, UV_HANDLE_TTY_READABLE, UV_HANDLE_WRITABLE, uv_null_buf_, uv_sem_post(), uv_sem_wait(), uv_stream_init(), uv_translate_sys_error(), uv_tty_capture_initial_style(), UV_TTY_MODE_NORMAL, uv_tty_output_lock, uv_tty_update_virtual_window(), and UV_UNKNOWN_HANDLE.

Referenced by main().

uv_tty_line_read_thread()

static DWORD CALLBACK uv_tty_line_read_thread ( void *  data )

static

Definition at line 486 of file tty.c.

                                                          {
  uv_loop_t* loop;
  uv_tty_t* handle;
  uv_req_t* req;
  DWORD bytes, read_bytes;
  WCHAR utf16[MAX_INPUT_BUFFER_LENGTH / 3];
  DWORD chars, read_chars;
  LONG status;
  COORD pos;
  BOOL read_console_success;
 
  assert(data);
 
  req = (uv_req_t*) data;
  handle = (uv_tty_t*) req->data;
  loop = handle->loop;
 
  assert(handle->tty.rd.read_line_buffer.base != NULL);
  assert(handle->tty.rd.read_line_buffer.len > 0);
 
  /* ReadConsole can't handle big buffers. */
  if (handle->tty.rd.read_line_buffer.len < MAX_INPUT_BUFFER_LENGTH) {
    bytes = handle->tty.rd.read_line_buffer.len;
  } else {
    bytes = MAX_INPUT_BUFFER_LENGTH;
  }
 
  /* At last, unicode! One utf-16 codeunit never takes more than 3 utf-8
   * codeunits to encode. */
  chars = bytes / 3;
 
  status = InterlockedExchange(&uv__read_console_status, IN_PROGRESS);
  if (status == TRAP_REQUESTED) {
    SET_REQ_SUCCESS(req);
    InterlockedExchange(&uv__read_console_status, COMPLETED);
    req->u.io.overlapped.InternalHigh = 0;
    POST_COMPLETION_FOR_REQ(loop, req);
    return 0;
  }
 
  read_console_success = ReadConsoleW(handle->handle,
                                      (void*) utf16,
                                      chars,
                                      &read_chars,
                                      NULL);
 
  if (read_console_success) {
    read_bytes = WideCharToMultiByte(CP_UTF8,
                                     0,
                                     utf16,
                                     read_chars,
                                     handle->tty.rd.read_line_buffer.base,
                                     bytes,
                                     NULL,
                                     NULL);
    SET_REQ_SUCCESS(req);
    req->u.io.overlapped.InternalHigh = read_bytes;
  } else {
    SET_REQ_ERROR(req, GetLastError());
  }
 
  status = InterlockedExchange(&uv__read_console_status, COMPLETED);
 
  if (status ==  TRAP_REQUESTED) {
    /* If we canceled the read by sending a VK_RETURN event, restore the
       screen state to undo the visual effect of the VK_RETURN */
    if (read_console_success && InterlockedOr(&uv__restore_screen_state, 0)) {
      HANDLE active_screen_buffer;
      active_screen_buffer = CreateFileA("conout$",
                                         GENERIC_READ | GENERIC_WRITE,
                                         FILE_SHARE_READ | FILE_SHARE_WRITE,
                                         NULL,
                                         OPEN_EXISTING,
                                         FILE_ATTRIBUTE_NORMAL,
                                         NULL);
      if (active_screen_buffer != INVALID_HANDLE_VALUE) {
        pos = uv__saved_screen_state.dwCursorPosition;
 
        /* If the cursor was at the bottom line of the screen buffer, the
           VK_RETURN would have caused the buffer contents to scroll up by one
           line. The right position to reset the cursor to is therefore one line
           higher */
        if (pos.Y == uv__saved_screen_state.dwSize.Y - 1)
          pos.Y--;
 
        SetConsoleCursorPosition(active_screen_buffer, pos);
        CloseHandle(active_screen_buffer);
      }
    }
    uv_sem_post(&uv_tty_output_lock);
  }
  POST_COMPLETION_FOR_REQ(loop, req);
  return 0;
}

References assert(), bytes, COMPLETED, DWORD, handle, HANDLE, IN_PROGRESS, InterlockedExchange, InterlockedOr, INVALID_HANDLE_VALUE, LONG, loop, MAX_INPUT_BUFFER_LENGTH, NULL, pos, POST_COMPLETION_FOR_REQ, req, SET_REQ_ERROR, SET_REQ_SUCCESS, status, TRAP_REQUESTED, uv__read_console_status, uv__restore_screen_state, uv__saved_screen_state, uv_sem_post(), and uv_tty_output_lock.

Referenced by uv_tty_queue_read_line().

uv_tty_make_real_coord()

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  )

static

Definition at line 1163 of file tty.c.

                              {
  COORD result;
 
  uv_tty_update_virtual_window(info);
 
  /* Adjust y position */
  if (y_relative) {
    y = info->dwCursorPosition.Y + y;
  } else {
    y = uv_tty_virtual_offset + y;
  }
  /* Clip y to virtual client rectangle */
  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;
  }
 
  /* Adjust x */
  if (x_relative) {
    x = info->dwCursorPosition.X + x;
  }
  /* Clip 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;
}

References info(), uv_tty_update_virtual_window(), uv_tty_virtual_height, uv_tty_virtual_offset, uv_tty_virtual_width, and x.

Referenced by uv_tty_clear(), and uv_tty_move_caret().

uv_tty_move_caret()

static int uv_tty_move_caret ( uv_tty_t *  handle, int  x, unsigned char  x_relative, int  y, unsigned char  y_relative, DWORD *  error  )

static

Definition at line 1221 of file tty.c.

                                                   {
  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) {
      /* The console may be resized - retry */
      goto retry;
    } else {
      *error = GetLastError();
      return -1;
    }
  }
 
  return 0;
}

References error(), handle, info(), pos, uv_tty_make_real_coord(), and x.

Referenced by uv_tty_restore_state(), and uv_tty_write_bufs().

uv_tty_post_raw_read()

static void CALLBACK uv_tty_post_raw_read ( void *  data, BOOLEAN  didTimeout  )

static

Definition at line 435 of file tty.c.

                                                                          {
  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->tty.rd.read_raw_wait);
  handle->tty.rd.read_raw_wait = NULL;
 
  SET_REQ_SUCCESS(req);
  POST_COMPLETION_FOR_REQ(loop, req);
}

References assert(), handle, loop, NULL, POST_COMPLETION_FOR_REQ, req, and SET_REQ_SUCCESS.

Referenced by uv_tty_queue_read_raw().

uv_tty_queue_read()

static void uv_tty_queue_read ( uv_loop_t *  loop, uv_tty_t *  handle  )

static

Definition at line 622 of file tty.c.

                                                                 {
  if (handle->flags & UV_HANDLE_TTY_RAW) {
    uv_tty_queue_read_raw(loop, handle);
  } else {
    uv_tty_queue_read_line(loop, handle);
  }
}

References handle, loop, UV_HANDLE_TTY_RAW, uv_tty_queue_read_line(), and uv_tty_queue_read_raw().

Referenced by uv_process_tty_read_line_req(), uv_process_tty_read_raw_req(), and uv_tty_read_start().

uv_tty_queue_read_line()

static void uv_tty_queue_read_line ( uv_loop_t *  loop, uv_tty_t *  handle  )

static

Definition at line 582 of file tty.c.

                                                                      {
  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->u.io.overlapped, 0, sizeof(req->u.io.overlapped));
 
  handle->tty.rd.read_line_buffer = uv_buf_init(NULL, 0);
  handle->alloc_cb((uv_handle_t*) handle, 8192, &handle->tty.rd.read_line_buffer);
  if (handle->tty.rd.read_line_buffer.base == NULL ||
      handle->tty.rd.read_line_buffer.len == 0) {
    handle->read_cb((uv_stream_t*) handle,
                    UV_ENOBUFS,
                    &handle->tty.rd.read_line_buffer);
    return;
  }
  assert(handle->tty.rd.read_line_buffer.base != NULL);
 
  /* Reset flags  No locking is required since there cannot be a line read
     in progress. We are also relying on the memory barrier provided by
     QueueUserWorkItem*/
  uv__restore_screen_state = FALSE;
  uv__read_console_status = NOT_STARTED;
  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);
  }
 
  handle->flags |= UV_HANDLE_READ_PENDING;
  handle->reqs_pending++;
}

References assert(), FALSE, handle, INVALID_HANDLE_VALUE, loop, memset(), NOT_STARTED, NULL, r, req, SET_REQ_ERROR, uv__read_console_status, uv__restore_screen_state, uv_buf_init(), UV_HANDLE_READ_PENDING, UV_HANDLE_READING, uv_insert_pending_req(), and uv_tty_line_read_thread().

Referenced by uv_tty_queue_read().

uv_tty_queue_read_raw()

static void uv_tty_queue_read_raw ( uv_loop_t *  loop, uv_tty_t *  handle  )

static

Definition at line 455 of file tty.c.

                                                                     {
  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->tty.rd.read_line_buffer = uv_null_buf_;
 
  req = &handle->read_req;
  memset(&req->u.io.overlapped, 0, sizeof(req->u.io.overlapped));
 
  r = RegisterWaitForSingleObject(&handle->tty.rd.read_raw_wait,
                                  handle->handle,
                                  uv_tty_post_raw_read,
                                  (void*) req,
                                  INFINITE,
                                  WT_EXECUTEINWAITTHREAD | WT_EXECUTEONLYONCE);
  if (!r) {
    handle->tty.rd.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++;
}

References assert(), handle, INVALID_HANDLE_VALUE, loop, memset(), NULL, r, req, SET_REQ_ERROR, UV_HANDLE_READ_PENDING, UV_HANDLE_READING, uv_insert_pending_req(), uv_null_buf_, and uv_tty_post_raw_read().

Referenced by uv_tty_queue_read().

uv_tty_read_start()

int uv_tty_read_start	(	uv_tty_t *	handle,
		uv_alloc_cb	alloc_cb,
		uv_read_cb	read_cb
	)

Definition at line 1018 of file tty.c.

                        {
  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 reading was stopped and then started again, there could still be a read
   * request pending. */
  if (handle->flags & UV_HANDLE_READ_PENDING) {
    return 0;
  }
 
  /* Maybe the user stopped reading half-way while processing key events.
   * Short-circuit if this could be the case. */
  if (handle->tty.rd.last_key_len > 0) {
    SET_REQ_SUCCESS(&handle->read_req);
    uv_insert_pending_req(handle->loop, (uv_req_t*) &handle->read_req);
    /* Make sure no attempt is made to insert it again until it's handled. */
    handle->flags |= UV_HANDLE_READ_PENDING;
    handle->reqs_pending++;
    return 0;
  }
 
  uv_tty_queue_read(loop, handle);
 
  return 0;
}

References handle, INCREASE_ACTIVE_COUNT, loop, SET_REQ_SUCCESS, UV_HANDLE_READ_PENDING, UV_HANDLE_READING, UV_HANDLE_TTY_READABLE, uv_insert_pending_req(), and uv_tty_queue_read().

Referenced by uv_read_start(), and uv_tty_set_mode().

uv_tty_read_stop()

int uv_tty_read_stop

(

uv_tty_t *

handle

)

Definition at line 1054 of file tty.c.

                                       {
  INPUT_RECORD record;
  DWORD written, err;
 
  handle->flags &= ~UV_HANDLE_READING;
  DECREASE_ACTIVE_COUNT(handle->loop, handle);
 
  if (!(handle->flags & UV_HANDLE_READ_PENDING))
    return 0;
 
  if (handle->flags & UV_HANDLE_TTY_RAW) {
    /* Cancel raw read. Write some bullshit event to force the console wait to
     * return. */
    memset(&record, 0, sizeof record);
    record.EventType = FOCUS_EVENT;
    if (!WriteConsoleInputW(handle->handle, &record, 1, &written)) {
      return GetLastError();
    }
  } else if (!(handle->flags & UV_HANDLE_CANCELLATION_PENDING)) {
    /* Cancel line-buffered read if not already pending */
    err = uv__cancel_read_console(handle);
    if (err)
      return err;
 
    handle->flags |= UV_HANDLE_CANCELLATION_PENDING;
  }
 
  return 0;
}

References DECREASE_ACTIVE_COUNT, DWORD, err, handle, memset(), uv__cancel_read_console(), UV_HANDLE_CANCELLATION_PENDING, UV_HANDLE_READ_PENDING, UV_HANDLE_READING, and UV_HANDLE_TTY_RAW.

Referenced by uv_read_stop(), uv_tty_close(), and uv_tty_set_mode().

uv_tty_reset()

static int uv_tty_reset ( uv_tty_t *  handle, DWORD *  error  )

static

Definition at line 1251 of file tty.c.

                                                        {
  const COORD origin = {0, 0};
  const WORD char_attrs = uv_tty_default_text_attributes;
  CONSOLE_SCREEN_BUFFER_INFO screen_buffer_info;
  DWORD count, written;
 
  if (*error != ERROR_SUCCESS) {
    return -1;
  }
 
  /* Reset original text attributes. */
  if (!SetConsoleTextAttribute(handle->handle, char_attrs)) {
    *error = GetLastError();
    return -1;
  }
 
  /* Move the cursor position to (0, 0). */
  if (!SetConsoleCursorPosition(handle->handle, origin)) {
    *error = GetLastError();
    return -1;
  }
 
  /* Clear the screen buffer. */
 retry:
   if (!GetConsoleScreenBufferInfo(handle->handle, &screen_buffer_info)) {
     *error = GetLastError();
     return -1;
  }
 
  count = screen_buffer_info.dwSize.X * screen_buffer_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) {
      /* The console may be resized - retry */
      goto retry;
    } else {
      *error = GetLastError();
      return -1;
    }
  }
 
  /* Move the virtual window up to the top. */
  uv_tty_virtual_offset = 0;
  uv_tty_update_virtual_window(&screen_buffer_info);
 
  /* Reset the cursor size and the cursor state. */
  if (!SetConsoleCursorInfo(handle->handle, &uv_tty_default_cursor_info)) {
    *error = GetLastError();
    return -1;
  }
 
  return 0;
}

References count, DWORD, error(), handle, L, uv_tty_default_cursor_info, uv_tty_default_text_attributes, uv_tty_update_virtual_window(), and uv_tty_virtual_offset.

Referenced by uv_tty_write_bufs().

uv_tty_reset_mode()

int uv_tty_reset_mode

(

void

)

Definition at line 2324 of file tty.c.

                            {
  /* Not necessary to do anything. */
  return 0;
}

References err, orig_termios, orig_termios_fd, TCSANOW, termios_spinlock, and UV__ERR.

Referenced by main(), and update().

uv_tty_restore_state()

static int uv_tty_restore_state ( uv_tty_t *  handle, unsigned char  restore_attributes, DWORD *  error  )

static

Definition at line 1588 of file tty.c.

                                                    {
  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->tty.wr.saved_position.X,
                          0,
                          handle->tty.wr.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->tty.wr.saved_attributes;
 
    if (!SetConsoleTextAttribute(handle->handle, new_attributes)) {
      *error = GetLastError();
      return -1;
    }
  }
 
  return 0;
}

References error(), handle, info(), UV_HANDLE_TTY_SAVED_ATTRIBUTES, UV_HANDLE_TTY_SAVED_POSITION, and uv_tty_move_caret().

Referenced by uv_tty_write_bufs().

uv_tty_save_state()

static int uv_tty_save_state ( uv_tty_t *  handle, unsigned char  save_attributes, DWORD *  error  )

static

Definition at line 1559 of file tty.c.

                  {
  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->tty.wr.saved_position.X = info.dwCursorPosition.X;
  handle->tty.wr.saved_position.Y = info.dwCursorPosition.Y - uv_tty_virtual_offset;
  handle->flags |= UV_HANDLE_TTY_SAVED_POSITION;
 
  if (save_attributes) {
    handle->tty.wr.saved_attributes = info.wAttributes &
        (FOREGROUND_INTENSITY | BACKGROUND_INTENSITY);
    handle->flags |= UV_HANDLE_TTY_SAVED_ATTRIBUTES;
  }
 
  return 0;
}

References error(), handle, info(), UV_HANDLE_TTY_SAVED_ATTRIBUTES, UV_HANDLE_TTY_SAVED_POSITION, uv_tty_update_virtual_window(), and uv_tty_virtual_offset.

Referenced by uv_tty_write_bufs().

uv_tty_set_cursor_shape()

static int uv_tty_set_cursor_shape ( uv_tty_t *  handle, int  style, DWORD *  error  )

static

Definition at line 1648 of file tty.c.

                                                                              {
  CONSOLE_CURSOR_INFO cursor_info;
 
  if (!GetConsoleCursorInfo(handle->handle, &cursor_info)) {
    *error = GetLastError();
    return -1;
  }
 
  if (style == 0) {
    cursor_info.dwSize = uv_tty_default_cursor_info.dwSize;
  } else if (style <= 2) {
    cursor_info.dwSize = CURSOR_SIZE_LARGE;
  } else {
    cursor_info.dwSize = CURSOR_SIZE_SMALL;
  }
 
  if (!SetConsoleCursorInfo(handle->handle, &cursor_info)) {
    *error = GetLastError();
    return -1;
  }
 
  return 0;
}

References CURSOR_SIZE_LARGE, CURSOR_SIZE_SMALL, error(), handle, and uv_tty_default_cursor_info.

Referenced by uv_tty_write_bufs().

uv_tty_set_cursor_visibility()

static int uv_tty_set_cursor_visibility ( uv_tty_t *  handle, BOOL  visible, DWORD *  error  )

static

Definition at line 1628 of file tty.c.

                                                      {
  CONSOLE_CURSOR_INFO cursor_info;
 
  if (!GetConsoleCursorInfo(handle->handle, &cursor_info)) {
    *error = GetLastError();
    return -1;
  }
 
  cursor_info.bVisible = visible;
 
  if (!SetConsoleCursorInfo(handle->handle, &cursor_info)) {
    *error = GetLastError();
    return -1;
  }
 
  return 0;
}

References error(), and handle.

Referenced by uv_tty_write_bufs().

uv_tty_set_mode()

int uv_tty_set_mode	(	uv_tty_t *	tty,
		uv_tty_mode_t	mode
	)

Definition at line 350 of file tty.c.

                                                       {
  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;
  }
 
  switch (mode) {
    case UV_TTY_MODE_NORMAL:
      flags = ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT;
      break;
    case UV_TTY_MODE_RAW:
      flags = ENABLE_WINDOW_INPUT;
      break;
    case UV_TTY_MODE_IO:
      return UV_ENOTSUP;
    default:
      return UV_EINVAL;
  }
 
  /* If currently reading, stop, and restart reading. */
  if (tty->flags & UV_HANDLE_READING) {
    was_reading = 1;
    alloc_cb = tty->alloc_cb;
    read_cb = tty->read_cb;
    err = uv_tty_read_stop(tty);
    if (err) {
      return uv_translate_sys_error(err);
    }
  } else {
    was_reading = 0;
    alloc_cb = NULL;
    read_cb = NULL;
  }
 
  uv_sem_wait(&uv_tty_output_lock);
  if (!SetConsoleMode(tty->handle, flags)) {
    err = uv_translate_sys_error(GetLastError());
    uv_sem_post(&uv_tty_output_lock);
    return err;
  }
  uv_sem_post(&uv_tty_output_lock);
 
  /* Update flag. */
  tty->flags &= ~UV_HANDLE_TTY_RAW;
  tty->flags |= mode ? UV_HANDLE_TTY_RAW : 0;
 
  /* If we just stopped reading, restart. */
  if (was_reading) {
    err = uv_tty_read_start(tty, alloc_cb, read_cb);
    if (err) {
      return uv_translate_sys_error(err);
    }
  }
 
  return 0;
}

References BRKINT, CS8, DWORD, ECHO, err, fd, flags, ICANON, ICRNL, IEXTEN, INPCK, ISIG, ISTRIP, IXON, NULL, ONLCR, orig_termios, orig_termios_fd, TCSADRAIN, termios_spinlock, autogen_x86imm::tmp, tty, UV__ERR, uv__stream_fd, uv__tty_make_raw(), UV_HANDLE_READING, UV_HANDLE_TTY_RAW, UV_HANDLE_TTY_READABLE, uv_sem_post(), uv_sem_wait(), uv_translate_sys_error(), UV_TTY_MODE_IO, UV_TTY_MODE_NORMAL, UV_TTY_MODE_RAW, uv_tty_output_lock, uv_tty_read_start(), uv_tty_read_stop(), VMIN, and VTIME.

Referenced by main().

uv_tty_set_style()

static int uv_tty_set_style ( uv_tty_t *  handle, DWORD *  error  )

static

Definition at line 1403 of file tty.c.

                                                            {
  unsigned short argc = handle->tty.wr.ansi_csi_argc;
  unsigned short* argv = handle->tty.wr.ansi_csi_argv;
  int i;
  CONSOLE_SCREEN_BUFFER_INFO info;
 
  char fg_color = -1, bg_color = -1;
  char fg_bright = -1, bg_bright = -1;
  char inverse = -1;
 
  if (argc == 0) {
    /* Reset mode */
    fg_color = uv_tty_default_fg_color;
    bg_color = uv_tty_default_bg_color;
    fg_bright = uv_tty_default_fg_bright;
    bg_bright = uv_tty_default_bg_bright;
    inverse = uv_tty_default_inverse;
  }
 
  for (i = 0; i < argc; i++) {
    short arg = argv[i];
 
    if (arg == 0) {
      /* Reset mode */
      fg_color = uv_tty_default_fg_color;
      bg_color = uv_tty_default_bg_color;
      fg_bright = uv_tty_default_fg_bright;
      bg_bright = uv_tty_default_bg_bright;
      inverse = uv_tty_default_inverse;
 
    } else if (arg == 1) {
      /* Foreground bright on */
      fg_bright = 1;
 
    } else if (arg == 2) {
      /* Both bright off */
      fg_bright = 0;
      bg_bright = 0;
 
    } else if (arg == 5) {
      /* Background bright on */
      bg_bright = 1;
 
    } else if (arg == 7) {
      /* Inverse: on */
      inverse = 1;
 
    } else if (arg == 21 || arg == 22) {
      /* Foreground bright off */
      fg_bright = 0;
 
    } else if (arg == 25) {
      /* Background bright off */
      bg_bright = 0;
 
    } else if (arg == 27) {
      /* Inverse: off */
      inverse = 0;
 
    } else if (arg >= 30 && arg <= 37) {
      /* Set foreground color */
      fg_color = arg - 30;
 
    } else if (arg == 39) {
      /* Default text color */
      fg_color = uv_tty_default_fg_color;
      fg_bright = uv_tty_default_fg_bright;
 
    } else if (arg >= 40 && arg <= 47) {
      /* Set background color */
      bg_color = arg - 40;
 
    } else if (arg ==  49) {
      /* Default background color */
      bg_color = uv_tty_default_bg_color;
      bg_bright = uv_tty_default_bg_bright;
 
    } else if (arg >= 90 && arg <= 97) {
      /* Set bold foreground color */
      fg_bright = 1;
      fg_color = arg - 90;
 
    } else if (arg >= 100 && arg <= 107) {
      /* Set bold background color */
      bg_bright = 1;
      bg_color = arg - 100;
 
    }
  }
 
  if (fg_color == -1 && bg_color == -1 && fg_bright == -1 &&
      bg_bright == -1 && inverse == -1) {
    /* Nothing changed */
    return 0;
  }
 
  if (!GetConsoleScreenBufferInfo(handle->handle, &info)) {
    *error = GetLastError();
    return -1;
  }
 
  if ((info.wAttributes & COMMON_LVB_REVERSE_VIDEO) > 0) {
    FLIP_FGBG;
  }
 
  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 (inverse != -1) {
    if (inverse) {
      info.wAttributes |= COMMON_LVB_REVERSE_VIDEO;
    } else {
      info.wAttributes &= ~COMMON_LVB_REVERSE_VIDEO;
    }
  }
 
  if ((info.wAttributes & COMMON_LVB_REVERSE_VIDEO) > 0) {
    FLIP_FGBG;
  }
 
  if (!SetConsoleTextAttribute(handle->handle, info.wAttributes)) {
    *error = GetLastError();
    return -1;
  }
 
  return 0;
}

References argv, COMMON_LVB_REVERSE_VIDEO, error(), FLIP_FGBG, handle, i, info(), uv_tty_default_bg_bright, uv_tty_default_bg_color, uv_tty_default_fg_bright, uv_tty_default_fg_color, and uv_tty_default_inverse.

Referenced by uv_tty_write_bufs().

uv_tty_set_vterm_state()

void uv_tty_set_vterm_state

(

uv_tty_vtermstate_t

state

)

Definition at line 2440 of file tty.c.

                                                       {
  uv_sem_wait(&uv_tty_output_lock);
  uv__need_check_vterm_state = FALSE;
  uv__vterm_state = state;
  uv_sem_post(&uv_tty_output_lock);
}

References FALSE, uv__need_check_vterm_state, uv__vterm_state, uv_sem_post(), uv_sem_wait(), and uv_tty_output_lock.

uv_tty_update_virtual_window()

static void uv_tty_update_virtual_window ( CONSOLE_SCREEN_BUFFER_INFO *  info )

static

Definition at line 1140 of file tty.c.

                                                                           {
  uv_tty_virtual_width = info->dwSize.X;
  uv_tty_virtual_height = info->srWindow.Bottom - info->srWindow.Top + 1;
 
  /* Recompute virtual window offset row. */
  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) {
    /* If suddenly find the cursor outside of the virtual window, it must have
     * somehow scrolled. Update the virtual window offset. */
    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;
  }
}

References info(), uv_tty_virtual_height, uv_tty_virtual_offset, and uv_tty_virtual_width.

Referenced by uv_tty_get_winsize(), uv_tty_init(), uv_tty_make_real_coord(), uv_tty_reset(), and uv_tty_save_state().

uv_tty_write()

int uv_tty_write	(	uv_loop_t *	loop,
		uv_write_t *	req,
		uv_tty_t *	handle,
		const uv_buf_t	bufs[],
		unsigned int	nbufs,
		uv_write_cb	cb
	)

Definition at line 2182 of file tty.c.

                                 {
  DWORD error;
 
  UV_REQ_INIT(req, UV_WRITE);
  req->handle = (uv_stream_t*) handle;
  req->cb = cb;
 
  handle->reqs_pending++;
  handle->stream.conn.write_reqs_pending++;
  REGISTER_HANDLE_REQ(loop, handle, req);
 
  req->u.io.queued_bytes = 0;
 
  if (!uv_tty_write_bufs(handle, bufs, nbufs, &error)) {
    SET_REQ_SUCCESS(req);
  } else {
    SET_REQ_ERROR(req, error);
  }
 
  uv_insert_pending_req(loop, (uv_req_t*) req);
 
  return 0;
}

References bufs, cb, DWORD, error(), handle, loop, REGISTER_HANDLE_REQ, req, SET_REQ_ERROR, SET_REQ_SUCCESS, uv_insert_pending_req(), UV_REQ_INIT, and uv_tty_write_bufs().

Referenced by uv_write().

uv_tty_write_bufs()

static int uv_tty_write_bufs ( uv_tty_t *  handle, const uv_buf_t  bufs[], unsigned int  nbufs, DWORD *  error  )

static

Definition at line 1673 of file tty.c.

                                           {
  /* We can only write 8k characters at a time. Windows can't handle much more
   * characters in a single console write anyway. */
  WCHAR utf16_buf[MAX_CONSOLE_CHAR];
  DWORD utf16_buf_used = 0;
  unsigned 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)
 
#define ENSURE_BUFFER_SPACE(wchars_needed)                          \
  if (wchars_needed > ARRAY_SIZE(utf16_buf) - utf16_buf_used) {     \
    FLUSH_TEXT();                                                   \
  }
 
  /* Cache for fast access */
  unsigned char utf8_bytes_left = handle->tty.wr.utf8_bytes_left;
  unsigned int utf8_codepoint = handle->tty.wr.utf8_codepoint;
  unsigned char previous_eol = handle->tty.wr.previous_eol;
  unsigned short ansi_parser_state = handle->tty.wr.ansi_parser_state;
 
  /* Store the error here. If we encounter an error, stop trying to do i/o but
   * keep parsing the buffer so we leave the parser in a consistent state. */
  *error = ERROR_SUCCESS;
 
  uv_sem_wait(&uv_tty_output_lock);
 
  for (i = 0; i < nbufs; i++) {
    uv_buf_t buf = bufs[i];
    unsigned int j;
 
    for (j = 0; j < buf.len; j++) {
      unsigned char c = buf.base[j];
 
      /* Run the character through the utf8 decoder We happily accept non
       * shortest form encodings and invalid code points - there's no real harm
       * that can be done. */
      if (utf8_bytes_left == 0) {
        /* Read utf-8 start byte */
        DWORD first_zero_bit;
        unsigned char not_c = ~c;
#ifdef _MSC_VER /* msvc */
        if (_BitScanReverse(&first_zero_bit, not_c)) {
#else /* assume gcc */
        if (c != 0) {
          first_zero_bit = (sizeof(int) * 8) - 1 - __builtin_clz(not_c);
#endif
          if (first_zero_bit == 7) {
            /* Ascii - pass right through */
            utf8_codepoint = (unsigned int) c;
 
          } else if (first_zero_bit <= 5) {
            /* Multibyte sequence */
            utf8_codepoint = (0xff >> (8 - first_zero_bit)) & c;
            utf8_bytes_left = (char) (6 - first_zero_bit);
 
          } else {
            /* Invalid continuation */
            utf8_codepoint = UNICODE_REPLACEMENT_CHARACTER;
          }
 
        } else {
          /* 0xff -- invalid */
          utf8_codepoint = UNICODE_REPLACEMENT_CHARACTER;
        }
 
      } else if ((c & 0xc0) == 0x80) {
        /* Valid continuation of utf-8 multibyte sequence */
        utf8_bytes_left--;
        utf8_codepoint <<= 6;
        utf8_codepoint |= ((unsigned int) c & 0x3f);
 
      } else {
        /* Start byte where continuation was expected. */
        utf8_bytes_left = 0;
        utf8_codepoint = UNICODE_REPLACEMENT_CHARACTER;
        /* Patch buf offset so this character will be parsed again as a start
         * byte. */
        j--;
      }
 
      /* Maybe we need to parse more bytes to find a character. */
      if (utf8_bytes_left != 0) {
        continue;
      }
 
      /* Parse vt100/ansi escape codes */
      if (uv__vterm_state == UV_TTY_SUPPORTED) {
        /* Pass through escape codes if conhost supports them. */
      } else 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->tty.wr.ansi_csi_argc = 0;
            continue;
        }
 
      } else if (ansi_parser_state == ANSI_ESCAPE_SEEN) {
        switch (utf8_codepoint) {
          case '[':
            ansi_parser_state = ANSI_CSI;
            handle->tty.wr.ansi_csi_argc = 0;
            continue;
 
          case '^':
          case '_':
          case 'P':
          case ']':
            /* Not supported, but we'll have to parse until we see a stop code,
             * e. g. ESC \ or BEL. */
            ansi_parser_state = ANSI_ST_CONTROL;
            continue;
 
          case '\033':
            /* Ignore double escape. */
            continue;
 
          case 'c':
            /* Full console reset. */
            FLUSH_TEXT();
            uv_tty_reset(handle, error);
            ansi_parser_state = ANSI_NORMAL;
            continue;
 
          case '7':
            /* Save the cursor position and text attributes. */
            FLUSH_TEXT();
            uv_tty_save_state(handle, 1, error);
            ansi_parser_state = ANSI_NORMAL;
            continue;
 
          case '8':
            /* Restore the cursor position and text attributes */
            FLUSH_TEXT();
            uv_tty_restore_state(handle, 1, error);
            ansi_parser_state = ANSI_NORMAL;
            continue;
 
          default:
            if (utf8_codepoint >= '@' && utf8_codepoint <= '_') {
              /* Single-char control. */
              ansi_parser_state = ANSI_NORMAL;
              continue;
            } else {
              /* Invalid - proceed as normal, */
              ansi_parser_state = ANSI_NORMAL;
            }
        }
 
      } else if (ansi_parser_state == ANSI_IGNORE) {
        /* We're ignoring this command. Stop only on command character. */
        if (utf8_codepoint >= '@' && utf8_codepoint <= '~') {
          ansi_parser_state = ANSI_NORMAL;
        }
        continue;
 
      } else if (ansi_parser_state == ANSI_DECSCUSR) {
        /* So far we've the sequence `ESC [ arg space`, and we're waiting for
         * the final command byte. */
        if (utf8_codepoint >= '@' && utf8_codepoint <= '~') {
          /* Command byte */
          if (utf8_codepoint == 'q') {
            /* Change the cursor shape */
            int style = handle->tty.wr.ansi_csi_argc
              ? handle->tty.wr.ansi_csi_argv[0] : 1;
            if (style >= 0 && style <= 6) {
              FLUSH_TEXT();
              uv_tty_set_cursor_shape(handle, style, error);
            }
          }
 
          /* Sequence ended - go back to normal state. */
          ansi_parser_state = ANSI_NORMAL;
          continue;
        }
        /* Unexpected character, but sequence hasn't ended yet. Ignore the rest
         * of the sequence. */
        ansi_parser_state = ANSI_IGNORE;
 
      } else if (ansi_parser_state & ANSI_CSI) {
        /* So far we've seen `ESC [`, and we may or may not have already parsed
         * some of the arguments that follow. */
 
        if (utf8_codepoint >= '0' && utf8_codepoint <= '9') {
          /* Parse a numerical argument. */
          if (!(ansi_parser_state & ANSI_IN_ARG)) {
            /* We were not currently parsing a number, add a new one. */
            /* Check for that there are too many arguments. */
            if (handle->tty.wr.ansi_csi_argc >=
                ARRAY_SIZE(handle->tty.wr.ansi_csi_argv)) {
              ansi_parser_state = ANSI_IGNORE;
              continue;
            }
            ansi_parser_state |= ANSI_IN_ARG;
            handle->tty.wr.ansi_csi_argc++;
            handle->tty.wr.ansi_csi_argv[handle->tty.wr.ansi_csi_argc - 1] =
                (unsigned short) utf8_codepoint - '0';
            continue;
 
          } else {
            /* We were already parsing a number. Parse next digit. */
            uint32_t value = 10 *
                handle->tty.wr.ansi_csi_argv[handle->tty.wr.ansi_csi_argc - 1];
 
            /* Check for overflow. */
            if (value > UINT16_MAX) {
              ansi_parser_state = ANSI_IGNORE;
              continue;
            }
 
            handle->tty.wr.ansi_csi_argv[handle->tty.wr.ansi_csi_argc - 1] =
                (unsigned short) value + (utf8_codepoint - '0');
            continue;
          }
 
        } else if (utf8_codepoint == ';') {
          /* Denotes the end of an argument. */
          if (ansi_parser_state & ANSI_IN_ARG) {
            ansi_parser_state &= ~ANSI_IN_ARG;
            continue;
 
          } else {
            /* If ANSI_IN_ARG is not set, add another argument and default
             * it to 0. */
 
            /* Check for too many arguments */
            if (handle->tty.wr.ansi_csi_argc >=
 
                ARRAY_SIZE(handle->tty.wr.ansi_csi_argv)) {
              ansi_parser_state = ANSI_IGNORE;
              continue;
            }
 
            handle->tty.wr.ansi_csi_argc++;
            handle->tty.wr.ansi_csi_argv[handle->tty.wr.ansi_csi_argc - 1] = 0;
            continue;
          }
 
        } else if (utf8_codepoint == '?' &&
                   !(ansi_parser_state & ANSI_IN_ARG) &&
                   !(ansi_parser_state & ANSI_EXTENSION) &&
                   handle->tty.wr.ansi_csi_argc == 0) {
          /* Pass through '?' if it is the first character after CSI */
          /* This is an extension character from the VT100 codeset */
          /* that is supported and used by most ANSI terminals today. */
          ansi_parser_state |= ANSI_EXTENSION;
          continue;
 
        } else if (utf8_codepoint == ' ' &&
                   !(ansi_parser_state & ANSI_EXTENSION)) {
          /* We expect a command byte to follow after this space. The only
           * command that we current support is 'set cursor style'. */
          ansi_parser_state = ANSI_DECSCUSR;
          continue;
 
        } else if (utf8_codepoint >= '@' && utf8_codepoint <= '~') {
          /* Command byte */
          if (ansi_parser_state & ANSI_EXTENSION) {
            /* Sequence is `ESC [ ? args command`. */
            switch (utf8_codepoint) {
              case 'l':
                /* Hide the cursor */
                if (handle->tty.wr.ansi_csi_argc == 1 &&
                    handle->tty.wr.ansi_csi_argv[0] == 25) {
                  FLUSH_TEXT();
                  uv_tty_set_cursor_visibility(handle, 0, error);
                }
                break;
 
              case 'h':
                /* Show the cursor */
                if (handle->tty.wr.ansi_csi_argc == 1 &&
                    handle->tty.wr.ansi_csi_argv[0] == 25) {
                  FLUSH_TEXT();
                  uv_tty_set_cursor_visibility(handle, 1, error);
                }
                break;
            }
 
          } else {
            /* Sequence is `ESC [ args command`. */
            int x, y, d;
            switch (utf8_codepoint) {
              case 'A':
                /* cursor up */
                FLUSH_TEXT();
                y = -(handle->tty.wr.ansi_csi_argc
                  ? handle->tty.wr.ansi_csi_argv[0] : 1);
                uv_tty_move_caret(handle, 0, 1, y, 1, error);
                break;
 
              case 'B':
                /* cursor down */
                FLUSH_TEXT();
                y = handle->tty.wr.ansi_csi_argc
                  ? handle->tty.wr.ansi_csi_argv[0] : 1;
                uv_tty_move_caret(handle, 0, 1, y, 1, error);
                break;
 
              case 'C':
                /* cursor forward */
                FLUSH_TEXT();
                x = handle->tty.wr.ansi_csi_argc
                  ? handle->tty.wr.ansi_csi_argv[0] : 1;
                uv_tty_move_caret(handle, x, 1, 0, 1, error);
                break;
 
              case 'D':
                /* cursor back */
                FLUSH_TEXT();
                x = -(handle->tty.wr.ansi_csi_argc
                  ? handle->tty.wr.ansi_csi_argv[0] : 1);
                uv_tty_move_caret(handle, x, 1, 0, 1, error);
                break;
 
              case 'E':
                /* cursor next line */
                FLUSH_TEXT();
                y = handle->tty.wr.ansi_csi_argc
                  ? handle->tty.wr.ansi_csi_argv[0] : 1;
                uv_tty_move_caret(handle, 0, 0, y, 1, error);
                break;
 
              case 'F':
                /* cursor previous line */
                FLUSH_TEXT();
                y = -(handle->tty.wr.ansi_csi_argc
                  ? handle->tty.wr.ansi_csi_argv[0] : 1);
                uv_tty_move_caret(handle, 0, 0, y, 1, error);
                break;
 
              case 'G':
                /* cursor horizontal move absolute */
                FLUSH_TEXT();
                x = (handle->tty.wr.ansi_csi_argc >= 1 &&
                     handle->tty.wr.ansi_csi_argv[0])
                  ? handle->tty.wr.ansi_csi_argv[0] - 1 : 0;
                uv_tty_move_caret(handle, x, 0, 0, 1, error);
                break;
 
              case 'H':
              case 'f':
                /* cursor move absolute */
                FLUSH_TEXT();
                y = (handle->tty.wr.ansi_csi_argc >= 1 &&
                     handle->tty.wr.ansi_csi_argv[0])
                  ? handle->tty.wr.ansi_csi_argv[0] - 1 : 0;
                x = (handle->tty.wr.ansi_csi_argc >= 2 &&
                     handle->tty.wr.ansi_csi_argv[1])
                  ? handle->tty.wr.ansi_csi_argv[1] - 1 : 0;
                uv_tty_move_caret(handle, x, 0, y, 0, error);
                break;
 
              case 'J':
                /* Erase screen */
                FLUSH_TEXT();
                d = handle->tty.wr.ansi_csi_argc
                  ? handle->tty.wr.ansi_csi_argv[0] : 0;
                if (d >= 0 && d <= 2) {
                  uv_tty_clear(handle, d, 1, error);
                }
                break;
 
              case 'K':
                /* Erase line */
                FLUSH_TEXT();
                d = handle->tty.wr.ansi_csi_argc
                  ? handle->tty.wr.ansi_csi_argv[0] : 0;
                if (d >= 0 && d <= 2) {
                  uv_tty_clear(handle, d, 0, error);
                }
                break;
 
              case 'm':
                /* Set style */
                FLUSH_TEXT();
                uv_tty_set_style(handle, error);
                break;
 
              case 's':
                /* Save the cursor position. */
                FLUSH_TEXT();
                uv_tty_save_state(handle, 0, error);
                break;
 
              case 'u':
                /* Restore the cursor position */
                FLUSH_TEXT();
                uv_tty_restore_state(handle, 0, error);
                break;
            }
          }
 
          /* Sequence ended - go back to normal state. */
          ansi_parser_state = ANSI_NORMAL;
          continue;
 
        } else {
          /* We don't support commands that use private mode characters or
           * intermediaries. Ignore the rest of the sequence. */
          ansi_parser_state = ANSI_IGNORE;
          continue;
        }
 
      } else if (ansi_parser_state & ANSI_ST_CONTROL) {
        /* Unsupported control code.
         * Ignore everything until we see `BEL` or `ESC \`. */
        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))) {
            /* End of sequence */
            ansi_parser_state = ANSI_NORMAL;
          } else if (utf8_codepoint == '\033') {
            /* Escape character */
            ansi_parser_state |= ANSI_ESCAPE_SEEN;
          } else if (utf8_codepoint == '"') {
             /* String starting */
            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 {
        /* Inconsistent state */
        abort();
      }
 
      if (utf8_codepoint == 0x0a || utf8_codepoint == 0x0d) {
        /* EOL conversion - emit \r\n when we see \n. */
 
        if (utf8_codepoint == 0x0a && previous_eol != 0x0d) {
          /* \n was not preceded by \r; print \r\n. */
          ENSURE_BUFFER_SPACE(2);
          utf16_buf[utf16_buf_used++] = L'\r';
          utf16_buf[utf16_buf_used++] = L'\n';
        } else if (utf8_codepoint == 0x0d && previous_eol == 0x0a) {
          /* \n was followed by \r; do not print the \r, since the source was
           * either \r\n\r (so the second \r is redundant) or was \n\r (so the
           * \n was processed by the last case and an \r automatically
           * inserted). */
        } else {
          /* \r without \n; print \r as-is. */
          ENSURE_BUFFER_SPACE(1);
          utf16_buf[utf16_buf_used++] = (WCHAR) utf8_codepoint;
        }
 
        previous_eol = (char) utf8_codepoint;
 
      } else if (utf8_codepoint <= 0xffff) {
        /* Encode character into utf-16 buffer. */
        ENSURE_BUFFER_SPACE(1);
        utf16_buf[utf16_buf_used++] = (WCHAR) utf8_codepoint;
        previous_eol = 0;
      } else {
        ENSURE_BUFFER_SPACE(2);
        utf8_codepoint -= 0x10000;
        utf16_buf[utf16_buf_used++] = (WCHAR) (utf8_codepoint / 0x400 + 0xD800);
        utf16_buf[utf16_buf_used++] = (WCHAR) (utf8_codepoint % 0x400 + 0xDC00);
        previous_eol = 0;
      }
    }
  }
 
  /* Flush remaining characters */
  FLUSH_TEXT();
 
  /* Copy cached values back to struct. */
  handle->tty.wr.utf8_bytes_left = utf8_bytes_left;
  handle->tty.wr.utf8_codepoint = utf8_codepoint;
  handle->tty.wr.previous_eol = previous_eol;
  handle->tty.wr.ansi_parser_state = ansi_parser_state;
 
  uv_sem_post(&uv_tty_output_lock);
 
  if (*error == STATUS_SUCCESS) {
    return 0;
  } else {
    return -1;
  }
 
#undef FLUSH_TEXT
}

References ANSI_BACKSLASH_SEEN, ANSI_CSI, ANSI_DECSCUSR, ANSI_ESCAPE_SEEN, ANSI_EXTENSION, ANSI_IGNORE, ANSI_IN_ARG, ANSI_IN_STRING, ANSI_NORMAL, ANSI_ST_CONTROL, ARRAY_SIZE, bufs, c, d, DWORD, ENSURE_BUFFER_SPACE, error(), FLUSH_TEXT, handle, i, int, L, MAX_CONSOLE_CHAR, STATUS_SUCCESS, UINT16_MAX, UNICODE_REPLACEMENT_CHARACTER, uv__vterm_state, uv_sem_post(), uv_sem_wait(), uv_tty_clear(), uv_tty_move_caret(), uv_tty_output_lock, uv_tty_reset(), uv_tty_restore_state(), uv_tty_save_state(), uv_tty_set_cursor_shape(), uv_tty_set_cursor_visibility(), uv_tty_set_style(), UV_TTY_SUPPORTED, value, and x.

Referenced by uv__tty_try_write(), and uv_tty_write().

Variable Documentation

uv__need_check_vterm_state

BOOL uv__need_check_vterm_state = TRUE

static

Definition at line 162 of file tty.c.

Referenced by uv__determine_vterm_state(), uv_tty_init(), and uv_tty_set_vterm_state().

uv__read_console_status

volatile LONG uv__read_console_status = NOT_STARTED

static

Definition at line 87 of file tty.c.

Referenced by uv__cancel_read_console(), uv_tty_line_read_thread(), and uv_tty_queue_read_line().

uv__restore_screen_state

volatile LONG uv__restore_screen_state

static

Definition at line 88 of file tty.c.

Referenced by uv__cancel_read_console(), uv_tty_line_read_thread(), and uv_tty_queue_read_line().

uv__saved_screen_state

CONSOLE_SCREEN_BUFFER_INFO uv__saved_screen_state

static

Definition at line 89 of file tty.c.

Referenced by uv__cancel_read_console(), and uv_tty_line_read_thread().

uv__tty_console_handle

HANDLE uv__tty_console_handle = INVALID_HANDLE_VALUE

static

Definition at line 127 of file tty.c.

Referenced by uv__tty_console_signal_resize(), and uv_console_init().

uv__tty_console_height

int uv__tty_console_height = -1

static

Definition at line 128 of file tty.c.

Referenced by uv__tty_console_signal_resize(), and uv_console_init().

uv__tty_console_resize_mutex

uv_mutex_t uv__tty_console_resize_mutex

static

Definition at line 131 of file tty.c.

Referenced by uv__tty_console_signal_resize(), and uv_console_init().

uv__tty_console_resized

HANDLE uv__tty_console_resized = INVALID_HANDLE_VALUE

static

Definition at line 130 of file tty.c.

Referenced by uv__tty_console_resize_event(), uv__tty_console_resize_message_loop_thread(), and uv__tty_console_resize_watcher_thread().

uv__tty_console_width

int uv__tty_console_width = -1

static

Definition at line 129 of file tty.c.

Referenced by uv__tty_console_signal_resize(), and uv_console_init().

uv__vterm_state

uv_tty_vtermstate_t uv__vterm_state = UV_TTY_UNSUPPORTED

static

Definition at line 163 of file tty.c.

Referenced by uv__determine_vterm_state(), uv_tty_get_vterm_state(), uv_tty_set_vterm_state(), and uv_tty_write_bufs().

uv_null_buf_

const uv_buf_t uv_null_buf_ = { 0, NULL }

static

Definition at line 78 of file tty.c.

Referenced by uv_process_tty_read_line_req(), uv_process_tty_read_raw_req(), uv_tty_init(), and uv_tty_queue_read_raw().

uv_tty_default_bg_bright

char uv_tty_default_bg_bright = 0

static

Definition at line 156 of file tty.c.

Referenced by uv_tty_capture_initial_style(), and uv_tty_set_style().

uv_tty_default_bg_color

char uv_tty_default_bg_color = 0

static

Definition at line 154 of file tty.c.

Referenced by uv_tty_capture_initial_style(), and uv_tty_set_style().

uv_tty_default_cursor_info

CONSOLE_CURSOR_INFO uv_tty_default_cursor_info

static

Definition at line 159 of file tty.c.

Referenced by uv_tty_capture_initial_style(), uv_tty_reset(), and uv_tty_set_cursor_shape().

uv_tty_default_fg_bright

char uv_tty_default_fg_bright = 0

static

Definition at line 155 of file tty.c.

Referenced by uv_tty_capture_initial_style(), and uv_tty_set_style().

uv_tty_default_fg_color

char uv_tty_default_fg_color = 7

static

Definition at line 153 of file tty.c.

Referenced by uv_tty_capture_initial_style(), and uv_tty_set_style().

uv_tty_default_inverse

char uv_tty_default_inverse = 0

static

Definition at line 157 of file tty.c.

Referenced by uv_tty_capture_initial_style(), and uv_tty_set_style().

uv_tty_default_text_attributes

WORD uv_tty_default_text_attributes

static

Initial value:

=
    FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE

Definition at line 150 of file tty.c.

Referenced by uv_tty_capture_initial_style(), and uv_tty_reset().

uv_tty_output_lock

uv_sem_t uv_tty_output_lock

static

Definition at line 148 of file tty.c.

Referenced by uv__cancel_read_console(), uv_console_init(), uv_tty_get_vterm_state(), uv_tty_get_winsize(), uv_tty_init(), uv_tty_line_read_thread(), uv_tty_set_mode(), uv_tty_set_vterm_state(), and uv_tty_write_bufs().

uv_tty_virtual_height

int uv_tty_virtual_height = -1

static

Definition at line 119 of file tty.c.

Referenced by uv_tty_get_winsize(), uv_tty_make_real_coord(), and uv_tty_update_virtual_window().

uv_tty_virtual_offset

int uv_tty_virtual_offset = -1

static

Definition at line 118 of file tty.c.

Referenced by uv_tty_make_real_coord(), uv_tty_reset(), uv_tty_save_state(), and uv_tty_update_virtual_window().

uv_tty_virtual_width

int uv_tty_virtual_width = -1

static

Definition at line 120 of file tty.c.

Referenced by uv_tty_get_winsize(), uv_tty_make_real_coord(), and uv_tty_update_virtual_window().