io-console 0.8.2 → 0.9.2

data/ext/io/console/console.c

@@ -4,7 +4,7 @@
  */
 
 static const char *const
-IO_CONSOLE_VERSION = "0.8.2";
+IO_CONSOLE_VERSION = "0.9.2";
 
 #include "ruby.h"
 #include "ruby/io.h"
@@ -56,6 +56,13 @@ typedef struct sgttyb conmode;
 #include <conio.h>
 typedef DWORD conmode;
 
+#ifndef ENABLE_WRAP_AT_EOL_OUTPUT
+# define ENABLE_WRAP_AT_EOL_OUTPUT 0x0002
+#endif
+#ifndef ENABLE_VIRTUAL_TERMINAL_PROCESSING
+# define ENABLE_VIRTUAL_TERMINAL_PROCESSING 0x0004
+#endif
+
 #define LAST_ERROR rb_w32_map_errno(GetLastError())
 #define SET_LAST_ERROR (errno = LAST_ERROR, 0)
 
@@ -81,7 +88,7 @@ getattr(int fd, conmode *t)
 
 #define CSI "\x1b\x5b"
 
-static ID id_getc, id_close;
+static ID id_getc, id_close, id_timeout;
 static ID id_gets, id_flush, id_chomp_bang;
 
 #ifndef HAVE_RB_INTERNED_STR_CSTR
@@ -89,6 +96,10 @@ static ID id_gets, id_flush, id_chomp_bang;
 # define rb_interned_str_cstr(str) rb_str_freeze(rb_usascii_str_new_cstr(str))
 #endif
 
+#if !defined(HAVE_RB_CATEGORY_WARN) || !defined(HAVE_CONST_RB_WARN_CATEGORY_DEPRECATED)
+# define rb_category_warn(category, ...) rb_warn(__VA_ARGS__)
+#endif
+
 #if defined HAVE_RUBY_FIBER_SCHEDULER_H
 # include "ruby/fiber/scheduler.h"
 #elif defined HAVE_RB_SCHEDULER_TIMEOUT
@@ -118,22 +129,6 @@ io_path_fallback(VALUE io)
 #define rb_io_path io_path_fallback
 #endif
 
-#ifndef HAVE_RB_IO_GET_WRITE_IO
-static VALUE
-io_get_write_io_fallback(VALUE io)
-{
-    rb_io_t *fptr;
-    GetOpenFile(io, fptr);
-    VALUE wio = fptr->tied_io_for_writing;
-    return wio ? wio : io;
-}
-#define rb_io_get_write_io io_get_write_io_fallback
-#endif
-
-#ifndef DHAVE_RB_SYSERR_FAIL_STR
-# define rb_syserr_fail_str(e, mesg) rb_exc_raise(rb_syserr_new_str(e, mesg))
-#endif
-
 #define sys_fail(io) do { \
     int err = errno; \
     rb_syserr_fail_str(err, rb_io_path(io)); \
@@ -550,7 +545,7 @@ nogvl_getch(void *p)
 
 /*
  * call-seq:
- *   io.getch(min: nil, time: nil, intr: nil) -> char
+ *   io.getch(min: nil, time: nil, intr: nil) -> char or nil
  *
  * Reads and returns a character in raw mode.
  *
@@ -635,6 +630,43 @@ console_getch(int argc, VALUE *argv, VALUE io)
 #endif
 }
 
+/*
+ * call-seq:
+ *   io.input_pending?          -> true or false
+ *
+ * Returns whether input can be read without blocking.
+ *
+ * You must require 'io/console' to use this method.
+ */
+static VALUE
+console_input_pending_p(VALUE io)
+{
+    rb_io_t *fptr;
+
+    GetOpenFile(io, fptr);
+    if (rb_io_read_pending(fptr)) return Qtrue;
+#ifdef _WIN32
+    {
+	DWORD mode;
+	HANDLE h = (HANDLE)rb_w32_get_osfhandle(GetReadFD(io));
+
+	if (GetConsoleMode(h, &mode)) return _kbhit() ? Qtrue : Qfalse;
+    }
+#endif
+#if defined HAVE_RB_IO_WAIT
+    return RTEST(rb_io_wait(io, RB_INT2NUM(RUBY_IO_READABLE), INT2FIX(0))) ? Qtrue : Qfalse;
+#else
+    {
+	struct timeval timeout = {0, 0};
+	int result;
+
+	result = rb_wait_for_single_fd(fptr->fd, RB_WAITFD_IN, &timeout);
+	if (result < 0) sys_fail(io);
+	return (result & RB_WAITFD_IN) ? Qtrue : Qfalse;
+    }
+#endif
+}
+
 /*
  * call-seq:
  *   io.noecho {|io| }
@@ -762,6 +794,70 @@ conmode_raw_new(int argc, VALUE *argv, VALUE obj)
     return conmode_new(rb_obj_class(obj), &t);
 }
 
+#ifdef _WIN32
+/*
+ * call-seq:
+ *   mode.virtual_terminal_processing? -> true or false
+ *
+ * Returns whether virtual terminal sequences are processed on output.
+ */
+static VALUE
+conmode_virtual_terminal_processing_p(VALUE obj)
+{
+    conmode *t = rb_check_typeddata(obj, &conmode_type);
+    return (*t & ENABLE_VIRTUAL_TERMINAL_PROCESSING) ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq:
+ *   mode.virtual_terminal_processing = enabled
+ *
+ * Enables or disables virtual terminal sequence processing in +mode+.
+ * Assign +mode+ to IO#console_mode= to apply the change.
+ */
+static VALUE
+conmode_set_virtual_terminal_processing(VALUE obj, VALUE enabled)
+{
+    conmode *t = rb_check_typeddata(obj, &conmode_type);
+    if (RTEST(enabled))
+	*t |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
+    else
+	*t &= ~ENABLE_VIRTUAL_TERMINAL_PROCESSING;
+    return obj;
+}
+
+/*
+ * call-seq:
+ *   mode.wrap_at_eol_output? -> true or false
+ *
+ * Returns whether output wraps at the end of a line.
+ */
+static VALUE
+conmode_wrap_at_eol_output_p(VALUE obj)
+{
+    conmode *t = rb_check_typeddata(obj, &conmode_type);
+    return (*t & ENABLE_WRAP_AT_EOL_OUTPUT) ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq:
+ *   mode.wrap_at_eol_output = enabled
+ *
+ * Enables or disables wrapping at the end of a line in +mode+.
+ * Assign +mode+ to IO#console_mode= to apply the change.
+ */
+static VALUE
+conmode_set_wrap_at_eol_output(VALUE obj, VALUE enabled)
+{
+    conmode *t = rb_check_typeddata(obj, &conmode_type);
+    if (RTEST(enabled))
+	*t |= ENABLE_WRAP_AT_EOL_OUTPUT;
+    else
+	*t &= ~ENABLE_WRAP_AT_EOL_OUTPUT;
+    return obj;
+}
+#endif
+
 /*
  * call-seq:
  *   io.console_mode       -> mode
@@ -861,7 +957,6 @@ console_set_winsize(VALUE io, VALUE size)
     int newrow, newcol;
     COORD oldsize;
     SMALL_RECT oldwindow;
-    BOOL ret;
 #endif
     VALUE row, col, xpixel, ypixel;
     const VALUE *sz;
@@ -963,12 +1058,207 @@ console_set_winsize(VALUE io, VALUE size)
 #endif
 
 #ifdef _WIN32
+enum console_input_handle_index {
+    console_input_handle,
+    console_input_wakeup,
+    console_input_handle_count
+};
+
+typedef struct {
+    HANDLE handles[console_input_handle_count];
+    INPUT_RECORD *records;
+    DWORD length;
+    DWORD count;
+    DWORD timeout;
+    DWORD wait_result;
+    DWORD error;
+    BOOL result;
+} read_console_input_args_t;
+
+static void *
+nogvl_read_console_input(void *ptr)
+{
+    read_console_input_args_t *args = ptr;
+
+    args->wait_result = WaitForMultipleObjects(console_input_handle_count,
+					       args->handles, FALSE, args->timeout);
+    if (args->wait_result == WAIT_OBJECT_0 + console_input_handle) {
+	args->result = ReadConsoleInputW(args->handles[console_input_handle],
+					 args->records, args->length, &args->count);
+	if (!args->result) args->error = GetLastError();
+    }
+    else if (args->wait_result == WAIT_FAILED) {
+	args->error = GetLastError();
+    }
+    return 0;
+}
+
+static void
+ubf_console_input(void *ptr)
+{
+    read_console_input_args_t *args = ptr;
+    SetEvent(args->handles[console_input_wakeup]);
+}
+
+static void
+console_input_event_set(VALUE event, const char *name, VALUE value)
+{
+    rb_hash_aset(event, ID2SYM(rb_intern(name)), value);
+}
+
+static VALUE
+console_input_event(const INPUT_RECORD *record)
+{
+    VALUE event = rb_hash_new();
+
+    switch (record->EventType) {
+      case KEY_EVENT:
+	console_input_event_set(event, "type", ID2SYM(rb_intern("key")));
+	console_input_event_set(event, "key_down", record->Event.KeyEvent.bKeyDown ? Qtrue : Qfalse);
+	console_input_event_set(event, "repeat_count", UINT2NUM(record->Event.KeyEvent.wRepeatCount));
+	console_input_event_set(event, "virtual_key_code", UINT2NUM(record->Event.KeyEvent.wVirtualKeyCode));
+	console_input_event_set(event, "virtual_scan_code", UINT2NUM(record->Event.KeyEvent.wVirtualScanCode));
+	console_input_event_set(event, "unicode_char", UINT2NUM(record->Event.KeyEvent.uChar.UnicodeChar));
+	console_input_event_set(event, "control_key_state", UINT2NUM(record->Event.KeyEvent.dwControlKeyState));
+	break;
+      case MOUSE_EVENT:
+	console_input_event_set(event, "type", ID2SYM(rb_intern("mouse")));
+	console_input_event_set(event, "position", rb_assoc_new(
+	    INT2NUM(record->Event.MouseEvent.dwMousePosition.Y),
+	    INT2NUM(record->Event.MouseEvent.dwMousePosition.X)));
+	console_input_event_set(event, "button_state", UINT2NUM(record->Event.MouseEvent.dwButtonState));
+	console_input_event_set(event, "control_key_state", UINT2NUM(record->Event.MouseEvent.dwControlKeyState));
+	console_input_event_set(event, "event_flags", UINT2NUM(record->Event.MouseEvent.dwEventFlags));
+	break;
+      case WINDOW_BUFFER_SIZE_EVENT:
+	console_input_event_set(event, "type", ID2SYM(rb_intern("window_buffer_size")));
+	console_input_event_set(event, "size", rb_assoc_new(
+	    INT2NUM(record->Event.WindowBufferSizeEvent.dwSize.Y),
+	    INT2NUM(record->Event.WindowBufferSizeEvent.dwSize.X)));
+	break;
+      case MENU_EVENT:
+	console_input_event_set(event, "type", ID2SYM(rb_intern("menu")));
+	console_input_event_set(event, "command_id", UINT2NUM(record->Event.MenuEvent.dwCommandId));
+	break;
+      case FOCUS_EVENT:
+	console_input_event_set(event, "type", ID2SYM(rb_intern("focus")));
+	console_input_event_set(event, "set_focus", record->Event.FocusEvent.bSetFocus ? Qtrue : Qfalse);
+	break;
+      default:
+	console_input_event_set(event, "type", UINT2NUM(record->EventType));
+	break;
+    }
+
+    return event;
+}
+
+static VALUE
+console_input_events_read(VALUE vargs)
+{
+    read_console_input_args_t *args = (read_console_input_args_t *)vargs;
+    VALUE events;
+    DWORD i;
+
+    rb_thread_call_without_gvl(nogvl_read_console_input, args,
+			       ubf_console_input, args);
+    if (args->wait_result == WAIT_TIMEOUT) return rb_ary_new();
+    if (args->wait_result != WAIT_OBJECT_0 + console_input_handle ||
+	!args->result) {
+	rb_syserr_fail(rb_w32_map_errno(args->error), 0);
+    }
+
+    events = rb_ary_new_capa(args->count);
+    for (i = 0; i < args->count; ++i) {
+	rb_ary_push(events, console_input_event(&args->records[i]));
+    }
+    return events;
+}
+
+static VALUE
+console_input_events_ensure(VALUE vargs)
+{
+    read_console_input_args_t *args = (read_console_input_args_t *)vargs;
+
+    CloseHandle(args->handles[console_input_wakeup]);
+    xfree(args->records);
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   io.console_input_events([max_events], timeout: nil)   -> array
+ *
+ * Reads up to +max_events+ console input events, preserving their order.
+ * The default is one event.  Blocks until at least one event is available,
+ * or for +timeout+ seconds if specified.  Returns an empty Array on timeout.
+ *
+ * Each event is returned as a Hash.  The +:type+ and remaining keys are:
+ *
+ * - +:key+ : +:key_down+, +:repeat_count+, +:virtual_key_code+,
+ *   +:virtual_scan_code+, +:unicode_char+, and +:control_key_state+.
+ * - +:mouse+ : +:position+ ([row, column]), +:button_state+,
+ *   +:control_key_state+, and +:event_flags+.
+ * - +:window_buffer_size+ : +:size+ ([rows, columns]).
+ * - +:menu+ : +:command_id+.
+ * - +:focus+ : +:set_focus+.
+ *
+ * This method is Windows only.
+ *
+ * You must require 'io/console' to use this method.
+ */
+static VALUE
+console_input_events(int argc, VALUE *argv, VALUE io)
+{
+    VALUE vmax = Qnil, vopts = Qnil, vtimeout = Qundef;
+    VALUE values[1];
+    ID keywords[1] = {id_timeout};
+    DWORD max_events = 1;
+    read_console_input_args_t args;
+
+    rb_scan_args(argc, argv, "01:", &vmax, &vopts);
+    if (rb_get_kwargs(vopts, keywords, 0, 1, values)) {
+	vtimeout = values[0];
+    }
+    if (!NIL_P(vmax)) {
+	max_events = NUM2UINT(vmax);
+	if (max_events == 0) rb_raise(rb_eArgError, "max_events must be positive");
+    }
+
+    args.timeout = INFINITE;
+    if (!NIL_OR_UNDEF_P(vtimeout)) {
+	struct timeval timeout = rb_time_interval(vtimeout);
+	uint64_t milliseconds = (uint64_t)timeout.tv_sec * 1000;
+	milliseconds += ((uint64_t)timeout.tv_usec + 999) / 1000;
+	args.timeout = milliseconds < INFINITE ? (DWORD)milliseconds : INFINITE - 1;
+    }
+
+    args.handles[console_input_handle] =
+	(HANDLE)rb_w32_get_osfhandle(GetReadFD(io));
+    args.records = ALLOC_N(INPUT_RECORD, max_events);
+    args.handles[console_input_wakeup] = CreateEvent(NULL, FALSE, FALSE, NULL);
+    if (!args.handles[console_input_wakeup]) {
+	int error = LAST_ERROR;
+	xfree(args.records);
+	rb_syserr_fail(error, 0);
+    }
+    args.length = max_events;
+    args.count = 0;
+    args.wait_result = WAIT_FAILED;
+    args.error = ERROR_SUCCESS;
+    args.result = FALSE;
+    return rb_ensure(console_input_events_read, (VALUE)&args,
+		     console_input_events_ensure, (VALUE)&args);
+}
+
 /*
  * call-seq:
  *   io.check_winsize_changed { ... }   -> io
  *
  * Yields while console input events are queued.
  *
+ * Deprecated because it discards queued input events other than window buffer
+ * size changes.  Use IO#console_input_events instead to preserve all events.
+ *
  * This method is Windows only.
  *
  * You must require 'io/console' to use this method.
@@ -979,6 +1269,9 @@ console_check_winsize_changed(VALUE io)
     HANDLE h;
     DWORD num;
 
+    rb_category_warn(RB_WARN_CATEGORY_DEPRECATED,
+		     "IO#check_winsize_changed is deprecated; "
+		     "use IO#console_input_events instead");
     h = (HANDLE)rb_w32_get_osfhandle(GetReadFD(io));
     while (GetNumberOfConsoleInputEvents(h, &num) && num > 0) {
 	INPUT_RECORD rec;
@@ -991,6 +1284,7 @@ console_check_winsize_changed(VALUE io)
     return io;
 }
 #else
+#define console_input_events rb_f_notimplement
 #define console_check_winsize_changed rb_f_notimplement
 #endif
 
@@ -1291,6 +1585,54 @@ console_cursor_pos(VALUE io)
 #endif
 }
 
+static VALUE
+console_cursor_visibility(VALUE io, int visible)
+{
+#ifdef _WIN32
+    HANDLE h = (HANDLE)rb_w32_get_osfhandle(GetWriteFD(io));
+    CONSOLE_CURSOR_INFO info;
+
+    if (!GetConsoleCursorInfo(h, &info)) {
+	rb_syserr_fail(LAST_ERROR, 0);
+    }
+    info.bVisible = visible;
+    if (!SetConsoleCursorInfo(h, &info)) {
+	rb_syserr_fail(LAST_ERROR, 0);
+    }
+#else
+    rb_io_write(io, rb_str_new_cstr(visible ? CSI "?25h" : CSI "?25l"));
+#endif
+    return io;
+}
+
+/*
+ * call-seq:
+ *   io.hide_cursor             -> io
+ *
+ * Hides the cursor.
+ *
+ * You must require 'io/console' to use this method.
+ */
+static VALUE
+console_hide_cursor(VALUE io)
+{
+    return console_cursor_visibility(io, 0);
+}
+
+/*
+ * call-seq:
+ *   io.show_cursor             -> io
+ *
+ * Shows the cursor.
+ *
+ * You must require 'io/console' to use this method.
+ */
+static VALUE
+console_show_cursor(VALUE io)
+{
+    return console_cursor_visibility(io, 1);
+}
+
 /*
  * call-seq:
  *   io.goto(line, column)      -> io
@@ -1710,7 +2052,7 @@ console_dev(int argc, VALUE *argv, VALUE klass)
         Check_Type(sym = argv[0], T_SYMBOL);
     }
 
-    // Force the class to be File.
+    /* Force the class to be File. */
     if (klass == rb_cIO) klass = rb_cFile;
 
     if (console_dev_get(klass, &con)) {
@@ -1777,7 +2119,7 @@ console_dev(int argc, VALUE *argv, VALUE klass)
 
 /*
  * call-seq:
- *   io.getch(min: nil, time: nil, intr: nil) -> char
+ *   io.getch(min: nil, time: nil, intr: nil) -> char or nil
  *
  * See IO#getch.
  */
@@ -1931,6 +2273,103 @@ console_ttyname(VALUE io)
 # define console_ttyname rb_f_notimplement
 #endif
 
+typedef enum {
+    platform_default,
+#if defined _WIN32
+    platform_cygwin,
+    platform_msys,
+#endif
+    platform_any,
+
+    platform_default_bit = 1U << platform_default,
+#if defined _WIN32
+    platform_cygwin_bit = 1U << platform_cygwin,
+    platform_msys_bit = 1U << platform_msys,
+#endif
+    platform_any_bit = (1U << platform_any) - 1 /* all bits */
+} console_platform_t;
+
+/*
+ * call-seq:
+ *   io.tty?([mode, ...])	-> true or false
+ *
+ * Returns +true+ if the stream is associated with a terminal device (tty),
+ * +false+ otherwise.
+ *
+ * If one or more +type+s are given, returns +true+ if the stream is
+ * associated with any of the specified tty types.
+ *
+ * - +nil+ : Returns the result of the default tty check, as if no type were
+ *   given.  It can be combined with other types.
+ * - +:any+ : Returns +true+ for any known kind of tty, including the
+ *   default tty.
+ * - +:cygwin+ : Returns +true+ for cygwin tty, on Windows.
+ * - +:msys+ : Returns +true+ for msys2 tty, on Windows.
+ */
+static VALUE
+console_platform_tty_p(int argc, VALUE *argv, VALUE io)
+{
+    VALUE ret = Qfalse;
+    int mode = 0;
+
+    if (argc > 0) {
+	int i;
+	for (i = 0; i < argc; ++i) {
+	    VALUE m = argv[i];
+	    if (NIL_P(m)) {
+		mode |= platform_default_bit;
+		continue;
+	    }
+	    Check_Type(m, T_SYMBOL);
+	    if (m == ID2SYM(rb_intern("any"))) {
+		mode |= platform_any_bit;
+	    }
+#if defined _WIN32
+	    else if (m == ID2SYM(rb_intern("cygwin"))) {
+		mode |= platform_cygwin_bit;
+	    }
+	    else if (m == ID2SYM(rb_intern("msys"))) {
+		mode |= platform_msys_bit;
+	    }
+#endif
+	    else {
+		rb_raise(rb_eArgError, "unknown tty type: %+" PRIsVALUE, m);
+	    }
+	}
+    }
+    if ((mode & platform_default_bit) || (mode == 0)) {
+	ret = rb_call_super(0, 0);
+    }
+    if ((mode & ~platform_default_bit) && !RTEST(ret)) {
+#if defined _WIN32
+	if (mode & (platform_cygwin_bit | platform_msys_bit)) {
+	    struct {
+		FILE_NAME_INFO info;
+		WCHAR rest[MAX_PATH];
+	    } buffer;
+
+	    HANDLE h = (HANDLE)rb_w32_get_osfhandle(GetReadFD(io));
+	    if ((GetFileType(h) == FILE_TYPE_PIPE) &&
+		GetFileInformationByHandleEx(h, FileNameInfo, &buffer, sizeof(buffer))) {
+		WCHAR *const name = buffer.info.FileName;
+		DWORD len = buffer.info.FileNameLength / sizeof(WCHAR);
+		name[len] = L'\0';
+# define tty_pipe_p(type) \
+		(memcmp(name, L"\\" #type "-", sizeof(L"\\" #type)) == 0 && \
+		 wcsstr(&name[rb_strlen_lit("\\" #type "-")], L"-pty") != NULL)
+		if (!ret && (mode & platform_cygwin_bit)) {
+		    ret = tty_pipe_p(cygwin);
+		}
+		if (!ret && (mode & platform_msys_bit)) {
+		    ret = tty_pipe_p(msys);
+		}
+	    }
+	}
+#endif
+    }
+    return ret;
+}
+
 /*
  * IO console methods
  */
@@ -1952,6 +2391,7 @@ Init_console(void)
     id_flush = rb_intern("flush");
     id_chomp_bang = rb_intern("chomp!");
     id_close = rb_intern("close");
+    id_timeout = rb_intern("timeout");
 #define init_rawmode_opt_id(name) \
     rawmode_opt_ids[kwd_##name] = rb_intern(#name)
     init_rawmode_opt_id(min);
@@ -1966,11 +2406,31 @@ Init_console(void)
 void
 InitVM_console(void)
 {
+    /* :nodoc: */
+    VALUE mConsole = rb_define_module_under(rb_cIO, "Console");
+#ifdef _WIN32
+    /* :nodoc: */
+    VALUE mWindows = rb_define_module_under(mConsole, "Windows");
+#define define_win32_const(name) rb_define_const(mWindows, #name, UINT2NUM(name))
+    EACH_VK(define_win32_const,;);
+    define_win32_const(RIGHT_ALT_PRESSED);
+    define_win32_const(LEFT_ALT_PRESSED);
+    define_win32_const(RIGHT_CTRL_PRESSED);
+    define_win32_const(LEFT_CTRL_PRESSED);
+    define_win32_const(SHIFT_PRESSED);
+    define_win32_const(NUMLOCK_ON);
+    define_win32_const(SCROLLLOCK_ON);
+    define_win32_const(CAPSLOCK_ON);
+    define_win32_const(ENHANCED_KEY);
+#undef define_win32_const
+#endif
+
     rb_define_method(rb_cIO, "raw", console_raw, -1);
     rb_define_method(rb_cIO, "raw!", console_set_raw, -1);
     rb_define_method(rb_cIO, "cooked", console_cooked, 0);
     rb_define_method(rb_cIO, "cooked!", console_set_cooked, 0);
     rb_define_method(rb_cIO, "getch", console_getch, -1);
+    rb_define_method(rb_cIO, "input_pending?", console_input_pending_p, 0);
     rb_define_method(rb_cIO, "echo=", console_set_echo, 1);
     rb_define_method(rb_cIO, "echo?", console_echo_p, 0);
     rb_define_method(rb_cIO, "console_mode", console_conmode_get, 0);
@@ -1985,6 +2445,8 @@ InitVM_console(void)
     rb_define_method(rb_cIO, "goto", console_goto, 2);
     rb_define_method(rb_cIO, "cursor", console_cursor_pos, 0);
     rb_define_method(rb_cIO, "cursor=", console_cursor_set, 1);
+    rb_define_method(rb_cIO, "hide_cursor", console_hide_cursor, 0);
+    rb_define_method(rb_cIO, "show_cursor", console_show_cursor, 0);
     rb_define_method(rb_cIO, "cursor_up", console_cursor_up, 1);
     rb_define_method(rb_cIO, "cursor_down", console_cursor_down, 1);
     rb_define_method(rb_cIO, "cursor_left", console_cursor_left, 1);
@@ -1996,27 +2458,58 @@ InitVM_console(void)
     rb_define_method(rb_cIO, "scroll_backward", console_scroll_backward, 1);
     rb_define_method(rb_cIO, "clear_screen", console_clear_screen, 0);
     rb_define_method(rb_cIO, "pressed?", console_key_pressed_p, 1);
+    rb_define_method(rb_cIO, "console_input_events", console_input_events, -1);
     rb_define_method(rb_cIO, "check_winsize_changed", console_check_winsize_changed, 0);
     rb_define_method(rb_cIO, "getpass", console_getpass, -1);
     rb_define_method(rb_cIO, "ttyname", console_ttyname, 0);
+    {
+	/* :nodoc: */
+	VALUE platform = rb_define_module_under(rb_cIO, "platform_tty");
+	{
+	    VALUE rb_cIO = platform;
+	    rb_define_method(rb_cIO, "tty?", console_platform_tty_p, -1);
+	    rb_define_method(rb_cIO, "isatty", console_platform_tty_p, -1);
+	}
+#ifdef HAVE_RB_PREPEND_MODULE
+	rb_prepend_module(rb_cIO, platform);
+#else
+	rb_funcall(rb_cIO, rb_intern_const("prepend"), 1, platform);
+#endif
+    }
     rb_define_singleton_method(rb_cIO, "console", console_dev, -1);
     {
-	/* :stopdoc: */
+	/* :nodoc: */
 	VALUE mReadable = rb_define_module_under(rb_cIO, "generic_readable");
-	/* :startdoc: */
 	rb_define_method(mReadable, "getch", io_getch, -1);
 	rb_define_method(mReadable, "getpass", io_getpass, -1);
     }
     {
-	/* :stopdoc: */
-        cConmode = rb_define_class_under(rb_cIO, "ConsoleMode", rb_cObject);
-        rb_define_const(cConmode, "VERSION", rb_obj_freeze(rb_str_new_cstr(IO_CONSOLE_VERSION)));
+	/* :nodoc: */
+	VALUE version = rb_obj_freeze(rb_str_new_cstr(IO_CONSOLE_VERSION));
+	ID cid, deprecate_constant = rb_intern_const("deprecate_constant");
+	rb_define_const(mConsole, "VERSION", version);
+	/* :nodoc: */
+	cConmode = rb_define_class_under(mConsole, "Mode", rb_cObject);
+
+	/* old internal names; do not use */
+	cid = rb_intern_const("ConsoleMode");
+	rb_const_set(rb_cIO, cid, cConmode);
+	rb_funcall(rb_cIO, deprecate_constant, 1, ID2SYM(cid));
+	cid = rb_intern_const("VERSION");
+	rb_const_set(cConmode, cid, version);
+	rb_funcall(cConmode, deprecate_constant, 1, ID2SYM(cid));
+
         rb_define_alloc_func(cConmode, conmode_alloc);
         rb_undef_method(cConmode, "initialize");
         rb_define_method(cConmode, "initialize_copy", conmode_init_copy, 1);
         rb_define_method(cConmode, "echo=", conmode_set_echo, 1);
         rb_define_method(cConmode, "raw!", conmode_set_raw, -1);
         rb_define_method(cConmode, "raw", conmode_raw_new, -1);
-	/* :startdoc: */
+#ifdef _WIN32
+        rb_define_method(cConmode, "virtual_terminal_processing?", conmode_virtual_terminal_processing_p, 0);
+        rb_define_method(cConmode, "virtual_terminal_processing=", conmode_set_virtual_terminal_processing, 1);
+        rb_define_method(cConmode, "wrap_at_eol_output?", conmode_wrap_at_eol_output_p, 0);
+        rb_define_method(cConmode, "wrap_at_eol_output=", conmode_set_wrap_at_eol_output, 1);
+#endif
     }
 }