import winsup-2000-02-17 snapshot

1 files changed, 1387 insertions, 0 deletions

diff --git a/winsup/cygwin/fhandler_console.cc b/winsup/cygwin/fhandler_console.cc
new file mode 100644
index 0000000..188c79c
--- /dev/null
+++ b/winsup/cygwin/fhandler_console.cc
@@ -0,0 +1,1387 @@
+/* fhandler_console.cc
+
+   Copyright 1996, 1997, 1998, 1999, 2000 Cygnus Solutions.
+
+This file is part of Cygwin.
+
+This software is a copyrighted work licensed under the terms of the
+Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
+details. */
+
+/* FIXMES:
+   Should the constructor call tcinit() explicitly rather than having
+   it sprinkled throughout here? */
+
+#include <sys/termios.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <unistd.h>
+#include "winsup.h"
+#include <ctype.h>
+
+/*
+ * Scroll the screen context.
+ * x1, y1 - ul corner
+ * x2, y2 - dr corner
+ * xn, yn - new ul corner
+ * Negative values represents current screen dimensions
+ */
+static struct
+    {
+      short Top, Bottom;
+    } scroll_region = {0, -1};
+
+#define srTop (info.winTop + scroll_region.Top)
+#define srBottom ((scroll_region.Bottom < 0) ? info.winBottom : info.winTop + scroll_region.Bottom)
+
+#define use_tty ISSTATE (myself, PID_USETTY)
+
+const char * get_nonascii_key (INPUT_RECORD& input_rec);
+
+HANDLE console_shared_h;
+
+static tty_min NO_COPY *shared_console_info = NULL;
+
+/* Allocate and initialize the shared record for the current console.
+   Returns a pointer to shared_console_info. */
+static __inline tty_min *
+get_tty_stuff (int force = 0)
+{
+  if (shared_console_info && !force)
+    return shared_console_info;
+
+  shared_console_info = (tty_min *) open_shared (NULL, console_shared_h,
+						 sizeof (*shared_console_info),
+						 NULL);
+  ProtectHandle (console_shared_h);
+  shared_console_info->setntty (TTY_CONSOLE);
+  shared_console_info->setsid (myself->sid);
+  return shared_console_info;
+}
+
+/* Return the tty structure associated with a given tty number.  If the
+   tty number is < 0, just return a dummy record. */
+tty_min *
+tty_list::get_tty (int n)
+{
+  static tty_min nada;
+  if (n == TTY_CONSOLE)
+    return get_tty_stuff ();
+  else if (n >= 0)
+    return &cygwin_shared->tty.ttys[n];
+  else
+    return &nada;
+}
+
+
+/* Determine if a console is associated with this process prior to a spawn.
+   If it is, then we'll return 1.  If the console has been initialized, then
+   set it into a more friendly state for non-cygwin apps. */
+int __stdcall
+set_console_state_for_spawn ()
+{
+  HANDLE h = CreateFileA ("CONIN$", GENERIC_READ, FILE_SHARE_WRITE,
+			  &sec_none_nih, OPEN_EXISTING,
+			  FILE_ATTRIBUTE_NORMAL, NULL);
+
+  if (h == INVALID_HANDLE_VALUE || h == NULL)
+    return 0;
+
+  if (shared_console_info != NULL)
+    {
+#     define tc shared_console_info	/* ACK.  Temporarily define for use in TTYSETF macro */
+      SetConsoleMode (h, ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT | ENABLE_PROCESSED_INPUT);
+      TTYSETF (RSTCONS);
+#if 0
+      char ch;
+      DWORD n;
+      /* NOTE -- This ReadFile is apparently necessary for correct functioning on
+	 Windows NT 4.0.  Without this, the next ReadFile returns garbage.  */
+      (void) ReadFile (h, &ch, 0, &n, NULL);
+#endif
+#     undef tc
+    }
+
+  CloseHandle (h);
+  return 1;
+}
+
+int
+fhandler_console::read (void *pv, size_t buflen)
+{
+  if (!buflen)
+    return 0;
+
+  HANDLE h = get_io_handle ();
+  int copied_chars = 0;
+
+#define buf ((char *) pv)
+
+  int ch;
+  set_input_state ();
+  while (buflen)
+    if ((ch = get_readahead ()) < 0)
+      break;
+    else
+      {
+	buf[copied_chars++] = (unsigned char)(ch & 0xff);
+	buflen--;
+      }
+
+  if (copied_chars)
+    return copied_chars;
+
+  HANDLE w4[2];
+  DWORD nwait;
+
+  w4[0] = h;
+  nwait = 2;
+  w4[1] = signal_arrived;
+
+  for (;;)
+    {
+      int bgres;
+      if ((bgres = bg_check (SIGTTIN)) <= 0)
+	return bgres;
+
+      switch (WaitForMultipleObjects (nwait, w4, FALSE, INFINITE))
+	{
+	case WAIT_OBJECT_0:
+	  break;
+	case WAIT_OBJECT_0 + 1:
+	  set_sig_errno (EINTR);
+	  return -1;
+	default:
+	  __seterrno ();
+	  return -1;
+	}
+      DWORD nread;
+      INPUT_RECORD input_rec;
+      const char *toadd;
+
+      if (!ReadConsoleInput (h, &input_rec, 1, &nread))
+	{
+	  syscall_printf ("ReadConsoleInput failed, %E");
+	  __seterrno ();
+	  return -1;		/* seems to be failure */
+	}
+
+#define ich (input_rec.Event.KeyEvent.uChar.AsciiChar)
+
+      /* check if we're just disposing of this one */
+
+      if (input_rec.EventType == WINDOW_BUFFER_SIZE_EVENT)
+	{
+	  kill_pgrp (tc->getpgid (), SIGWINCH);
+	  continue;
+	}
+debug_printf ("ich %d, keydown %d, type %d", ich, input_rec.Event.KeyEvent.bKeyDown, input_rec.EventType);
+      if (input_rec.EventType != KEY_EVENT ||
+	  !input_rec.Event.KeyEvent.bKeyDown)
+	continue;
+
+      if (ich == 0)  /* arrow/function keys */
+	{
+	  toadd = get_nonascii_key (input_rec);
+	  if (!toadd)
+	    continue;
+	  nread = strlen (toadd);
+	}
+      else if (!(input_rec.Event.KeyEvent.dwControlKeyState & LEFT_ALT_PRESSED))
+	toadd = &ich;
+      else
+	{
+	  static char tmp[2];
+	  tmp[0] = '\033';
+	  tmp[1] = tolower (ich);
+	  toadd = tmp;
+	  nread = 2;
+	}
+
+      if (line_edit (toadd, nread))
+	break;
+#undef ich
+    }
+
+  while (buflen)
+    if ((ch = get_readahead ()) < 0)
+      break;
+    else
+      {
+	buf[copied_chars++] = (unsigned char)(ch & 0xff);
+	buflen--;
+      }
+#undef buf
+
+  return copied_chars;
+}
+
+static struct
+  {
+    SHORT winTop;
+    SHORT winBottom;
+    COORD dwWinSize;
+    COORD dwCursorPosition;
+    WORD wAttributes;
+  } info;
+
+BOOL
+fhandler_console::fillin_info (void)
+{
+  BOOL ret;
+  CONSOLE_SCREEN_BUFFER_INFO linfo;
+
+  if ((ret = GetConsoleScreenBufferInfo (get_output_handle(), &linfo)))
+    {
+      info.winTop = linfo.srWindow.Top;
+      info.winBottom = linfo.srWindow.Bottom;
+      info.dwWinSize.Y = 1 + linfo.srWindow.Bottom - linfo.srWindow.Top;
+      info.dwWinSize.X = 1 + linfo.srWindow.Right - linfo.srWindow.Left;
+      info.dwCursorPosition = linfo.dwCursorPosition;
+      info.wAttributes = linfo.wAttributes;
+    }
+  else
+    {
+      memset (&info, 0, sizeof info);
+      info.dwWinSize.Y = 25;
+      info.dwWinSize.X = 80;
+      info.winBottom = 24;
+    }
+
+  return ret;
+}
+
+void
+fhandler_console::scroll_screen (int x1, int y1, int x2, int y2, int xn, int yn)
+{
+  SMALL_RECT sr1, sr2;
+  CHAR_INFO fill;
+  COORD dest;
+
+  (void)fillin_info ();
+  sr1.Left = x1 >= 0 ? x1 : info.dwWinSize.X - 1;
+  if (y1 == 0)
+    sr1.Top = info.winTop;
+  else
+    sr1.Top = y1 > 0 ? y1 : info.winBottom;
+  sr1.Right = x2 >= 0 ? x2 : info.dwWinSize.X - 1;
+  if (y2 == 0)
+    sr1.Bottom = info.winTop;
+  else
+    sr1.Bottom = y2 > 0 ? y2 : info.winBottom;
+  sr2.Top = srTop;
+  sr2.Left = 0;
+  sr2.Bottom = srBottom;
+  sr2.Right = info.dwWinSize.X - 1;
+  if (sr1.Bottom > sr2.Bottom && sr1.Top <= sr2.Bottom)
+    sr1.Bottom = sr2.Bottom;
+  dest.X = xn >= 0 ? xn : info.dwWinSize.X - 1;
+  if (yn == 0)
+    dest.Y = info.winTop;
+  else
+    dest.Y = yn > 0 ? yn : info.winBottom;
+  fill.Char.AsciiChar = ' ';
+  fill.Attributes = default_color;
+  ScrollConsoleScreenBuffer (get_output_handle (), &sr1, &sr2, dest, &fill);
+
+  /* ScrollConsoleScreenBuffer on Windows 95 is buggy - when scroll distance
+   * is more than half of screen, filling doesn't work as expected */
+
+  if (sr1.Top != sr1.Bottom)
+    if (dest.Y <= sr1.Top)	/* forward scroll */
+      clear_screen (0, 1 + dest.Y + sr1.Bottom - sr1.Top, sr2.Right, sr2.Bottom);
+    else			/* reverse scroll */
+      clear_screen (0, sr1.Top, sr2.Right, dest.Y - 1);
+}
+
+int
+fhandler_console::open (const char *, int flags, mode_t)
+{
+  HANDLE h;
+
+  tcinit (get_tty_stuff ());
+
+  set_io_handle (INVALID_HANDLE_VALUE);
+  set_output_handle (INVALID_HANDLE_VALUE);
+
+  set_flags (flags);
+
+  /* Open the input handle as handle_ */
+  h = CreateFileA ("CONIN$", GENERIC_READ|GENERIC_WRITE,
+		   FILE_SHARE_READ | FILE_SHARE_WRITE, &sec_none,
+		   OPEN_EXISTING, 0, 0);
+
+  if (h == INVALID_HANDLE_VALUE)
+    {
+      __seterrno ();
+      return 0;
+    }
+  set_io_handle (h);
+  set_r_no_interrupt (1);	// Handled explicitly in read code
+
+  h = CreateFileA ("CONOUT$", GENERIC_READ|GENERIC_WRITE,
+		   FILE_SHARE_WRITE | FILE_SHARE_WRITE, &sec_none,
+		   OPEN_EXISTING, 0, 0);
+
+  if (h == INVALID_HANDLE_VALUE)
+    {
+      __seterrno ();
+      return 0;
+    }
+  set_output_handle (h);
+
+  if (fillin_info ())
+    default_color = info.wAttributes;
+
+  DWORD cflags;
+  if (GetConsoleMode (get_io_handle (), &cflags))
+    {
+      cflags |= ENABLE_PROCESSED_INPUT;
+      SetConsoleMode (get_io_handle (), ENABLE_WINDOW_INPUT | cflags);
+    }
+
+  TTYCLEARF (RSTCONS);
+  set_ctty (TTY_CONSOLE, flags);
+  debug_printf("opened conin$ %p, conout$ %p",
+		get_io_handle (), get_output_handle ());
+
+  return 1;
+}
+
+int
+fhandler_console::close (void)
+{
+  CloseHandle (get_io_handle ());
+  CloseHandle (get_output_handle ());
+  set_io_handle (INVALID_HANDLE_VALUE);
+  set_output_handle (INVALID_HANDLE_VALUE);
+  return 0;
+}
+
+/*
+ * Special console dup to duplicate input and output
+ * handles.
+ */
+
+int
+fhandler_console::dup (fhandler_base *child)
+{
+  fhandler_console *fhc = (fhandler_console *) child;
+
+  if (!fhc->open(get_name (), get_flags (), 0))
+    system_printf ("error opening console, %E");
+
+  fhc->state_ = state_;
+  fhc->default_color = default_color;
+
+  return 0;
+}
+
+int
+fhandler_console::ioctl (unsigned int cmd, void *buf)
+{
+  switch (cmd)
+    {
+      case TIOCGWINSZ:
+	int st;
+
+	st = fillin_info ();
+	if (st)
+	  {
+	    /* *not* the buffer size, the actual screen size... */
+	    /* based on Left Top Right Bottom of srWindow */
+	    ((struct winsize *) buf)->ws_row = info.dwWinSize.Y;
+	    ((struct winsize *) buf)->ws_col = info.dwWinSize.X;
+	    syscall_printf ("WINSZ: (row=%d,col=%d)",
+			   ((struct winsize *) buf)->ws_row,
+			   ((struct winsize *) buf)->ws_col);
+	    return 0;
+	  }
+	else
+	  {
+	    syscall_printf ("WINSZ failed");
+	    __seterrno ();
+	    return -1;
+	  }
+	return 0;
+      case TIOCSWINSZ:
+	(void) bg_check (SIGTTOU, 0);
+	return 0;
+    }
+
+  return fhandler_base::ioctl (cmd, buf);
+}
+
+int
+fhandler_console::tcflush (int queue)
+{
+  int res = 0;
+  if (queue == TCIFLUSH
+      || queue == TCIOFLUSH)
+    {
+      if (!FlushConsoleInputBuffer (get_io_handle ()))
+	{
+	  __seterrno ();
+	  res = -1;
+	}
+    }
+  return res;
+}
+
+int
+fhandler_console::output_tcsetattr (int, struct termios const *t)
+{
+  /* Ignore the optional_actions stuff, since all output is emitted
+     instantly */
+
+  /* Enable/disable LF -> CRLF conversions */
+  set_w_binary ((t->c_oflag & ONLCR) ? 0 : 1);
+
+  /* All the output bits we can ignore */
+
+  DWORD flags = ENABLE_PROCESSED_OUTPUT | ENABLE_WRAP_AT_EOL_OUTPUT;
+
+  int res = SetConsoleMode (get_output_handle (), flags) ? 0 : -1;
+  syscall_printf ("%d = tcsetattr (,%x) (ENABLE FLAGS %x) (lflag %x oflag %x)",
+		  res, t, flags, t->c_lflag, t->c_oflag);
+  return res;
+}
+
+int
+fhandler_console::input_tcsetattr (int, struct termios const *t)
+{
+  /* Ignore the optional_actions stuff, since all output is emitted
+     instantly */
+
+  DWORD oflags;
+
+  if (!GetConsoleMode (get_io_handle (), &oflags))
+    oflags = 0;
+  DWORD flags = 0;
+
+  /* Enable/disable LF -> CRLF conversions */
+  set_r_binary ((t->c_iflag & INLCR) ? 0 : 1);
+
+  /* There's some disparity between what we need and what's
+     available.  We've got ECHO and ICANON, they've
+     got ENABLE_ECHO_INPUT and ENABLE_LINE_INPUT. */
+
+  tc->ti = *t;
+
+  if (t->c_lflag & ECHO)
+    {
+      flags |= ENABLE_ECHO_INPUT;
+    }
+  if (t->c_lflag & ICANON)
+    {
+      flags |= ENABLE_LINE_INPUT;
+    }
+
+  if (flags & ENABLE_ECHO_INPUT
+      && !(flags & ENABLE_LINE_INPUT))
+    {
+      /* This is illegal, so turn off the echo here, and fake it
+	 when we read the characters */
+
+      flags &= ~ENABLE_ECHO_INPUT;
+    }
+
+  if (t->c_lflag & ISIG)
+    {
+      flags |= ENABLE_PROCESSED_INPUT;
+    }
+  /* What about ENABLE_WINDOW_INPUT
+     and ENABLE_MOUSE_INPUT   ? */
+
+  if (use_tty)
+    {
+      flags = 0; // ENABLE_PROCESSED_OUTPUT | ENABLE_WRAP_AT_EOL_OUTPUT;
+      tc->ti.c_iflag = 0;
+      tc->ti.c_lflag = 0;
+    }
+
+  flags |= ENABLE_WINDOW_INPUT;
+
+  int res;
+  if (flags == oflags)
+    res = 0;
+  else
+    {
+      res = SetConsoleMode (get_io_handle (), flags) ? 0 : -1;
+      if (res < 0)
+	__seterrno ();
+      syscall_printf ("%d = tcsetattr (,%x) enable flags %p, c_lflag %p iflag %p",
+		      res, t, flags, t->c_lflag, t->c_iflag);
+    }
+
+  TTYCLEARF (RSTCONS);
+  return res;
+}
+
+int
+fhandler_console::tcsetattr (int a, struct termios const *t)
+{
+  int res = output_tcsetattr (a, t);
+  if (res != 0)
+    return res;
+  return input_tcsetattr (a, t);
+}
+
+int
+fhandler_console::tcgetattr (struct termios *t)
+{
+  int res;
+  *t = tc->ti;
+
+  t->c_cflag |= CS8;
+
+#if 0
+  if (!get_r_binary ())
+    t->c_iflag |= IGNCR;
+  if (!get_w_binary ())
+    t->c_oflag |= ONLCR;
+#endif
+
+  DWORD flags;
+
+  if (!GetConsoleMode (get_io_handle (), &flags))
+    {
+      __seterrno ();
+      res = -1;
+    }
+  else
+    {
+      if (flags & ENABLE_ECHO_INPUT)
+	t->c_lflag |= ECHO;
+
+      if (flags & ENABLE_LINE_INPUT)
+	t->c_lflag |= ICANON;
+
+      if (flags & ENABLE_PROCESSED_INPUT)
+	t->c_lflag |= ISIG;
+
+      /* What about ENABLE_WINDOW_INPUT
+	 and ENABLE_MOUSE_INPUT   ? */
+
+      /* All the output bits we can ignore */
+      res = 0;
+    }
+  syscall_printf ("%d = tcgetattr (%p) enable flags %p, t->lflag %p, t->iflag %p",
+		 res, t, flags, t->c_lflag, t->c_iflag);
+  return res;
+}
+
+/*
+ * Constructor.
+ */
+
+fhandler_console::fhandler_console (const char *name) :
+  fhandler_termios (FH_CONSOLE, name, -1)
+{
+  set_cb (sizeof *this);
+  state_ = normal;
+  set_need_fork_fixup ();
+}
+
+/*
+ * Clear the screen context from x1/y1 to x2/y2 cell.
+ * Negative values represents current screen dimensions
+ */
+void
+fhandler_console::clear_screen (int x1, int y1, int x2, int y2)
+{
+  COORD tlc;
+  DWORD done;
+  int num;
+
+  (void)fillin_info ();
+
+  if (x1 < 0)
+    x1 = info.dwWinSize.X-1;
+  if (y1 < 0)
+    y1 = info.winBottom;
+  if (x2 < 0)
+    x2 = info.dwWinSize.X-1;
+  if (y2 < 0)
+    y2 = info.winBottom;
+
+  num = abs (y1 - y2) * info.dwWinSize.X + abs (x1 - x2) + 1;
+
+  if ((y2 * info.dwWinSize.X + x2) > (y1 * info.dwWinSize.X + x1))
+    {
+      tlc.X = x1;
+      tlc.Y = y1;
+    }
+  else
+    {
+      tlc.X = x2;
+      tlc.Y = y2;
+    }
+  FillConsoleOutputCharacterA (get_output_handle (), ' ',
+			       num,
+			       tlc,
+			       &done);
+  FillConsoleOutputAttribute (get_output_handle (),
+			       default_color,
+			       num,
+			       tlc,
+			       &done);
+}
+
+void
+fhandler_console::cursor_set (BOOL rel_to_top, int x, int y)
+{
+  COORD pos;
+
+  (void)fillin_info ();
+  if (y > info.winBottom)
+    y = info.winBottom;
+  else if (y < 0)
+    y = 0;
+  else if (rel_to_top)
+    y += info.winTop;
+
+  if (x > info.dwWinSize.X)
+    x = info.dwWinSize.X - 1;
+  else if (x < 0)
+    x = 0;
+
+  pos.X = x;
+  pos.Y = y;
+  SetConsoleCursorPosition (get_output_handle (), pos);
+}
+
+void
+fhandler_console::cursor_rel (int x, int y)
+{
+  fillin_info ();
+  x += info.dwCursorPosition.X;
+  y += info.dwCursorPosition.Y;
+  cursor_set (FALSE, x, y);
+}
+
+void
+fhandler_console::cursor_get (int *x, int *y)
+{
+  fillin_info ();
+  *y = info.dwCursorPosition.Y;
+  *x = info.dwCursorPosition.X;
+}
+
+#define BAK 1
+#define ESC 2
+#define NOR 0
+#define IGN 4
+#if 0
+#define ERR 5
+#else
+#define ERR NOR
+#endif
+#define DWN 6
+#define BEL 7
+#define TAB 8 /* We should't let the console deal with these */
+#define CR 13
+#define LF 10
+
+static const char base_chars[256] =
+{
+/*00 01 02 03 04 05 06 07 */ IGN, ERR, ERR, NOR, NOR, NOR, NOR, BEL,
+/*08 09 0A 0B 0C 0D 0E 0F */ BAK, TAB, DWN, ERR, ERR, CR,  ERR, IGN,
+/*10 11 12 13 14 15 16 17 */ NOR, NOR, ERR, ERR, ERR, ERR, ERR, ERR,
+/*18 19 1A 1B 1C 1D 1E 1F */ NOR, NOR, ERR, ESC, ERR, ERR, ERR, ERR,
+/*   !  "  #  $  %  &  '  */ NOR, NOR, NOR, NOR, NOR, NOR, NOR, NOR,
+/*(  )  *  +  ,  -  .  /  */ NOR, NOR, NOR, NOR, NOR, NOR, NOR, NOR,
+/*0  1  2  3  4  5  6  7  */ NOR, NOR, NOR, NOR, NOR, NOR, NOR, NOR,
+/*8  9  :  ;  <  =  >  ?  */ NOR, NOR, NOR, NOR, NOR, NOR, NOR, NOR,
+/*@  A  B  C  D  E  F  G  */ NOR, NOR, NOR, NOR, NOR, NOR, NOR, NOR,
+/*H  I  J  K  L  M  N  O  */ NOR, NOR, NOR, NOR, NOR, NOR, NOR, NOR,
+/*P  Q  R  S  T  U  V  W  */ NOR, NOR, NOR, NOR, NOR, NOR, NOR, NOR,
+/*X  Y  Z  [  \  ]  ^  _  */ NOR, NOR, NOR, NOR, NOR, NOR, NOR, NOR,
+/*`  a  b  c  d  e  f  g  */ NOR, NOR, NOR, NOR, NOR, NOR, NOR, NOR,
+/*h  i  j  k  l  m  n  o  */ NOR, NOR, NOR, NOR, NOR, NOR, NOR, NOR,
+/*p  q  r  s  t  u  v  w  */ NOR, NOR, NOR, NOR, NOR, NOR, NOR, NOR,
+/*x  y  z  {  |  }  ~  7F */ NOR, NOR, NOR, NOR, NOR, NOR, NOR, NOR,
+/*80 81 82 83 84 85 86 87 */ NOR, NOR, NOR, NOR, NOR, NOR, NOR, NOR,
+/*88 89 8A 8B 8C 8D 8E 8F */ NOR, NOR, NOR, NOR, NOR, NOR, NOR, NOR,
+/*90 91 92 93 94 95 96 97 */ NOR, NOR, NOR, NOR, NOR, NOR, NOR, NOR,
+/*98 99 9A 9B 9C 9D 9E 9F */ NOR, NOR, NOR, NOR, NOR, NOR, NOR, NOR,
+/*A0 A1 A2 A3 A4 A5 A6 A7 */ NOR, NOR, NOR, NOR, NOR, NOR, NOR, NOR,
+/*A8 A9 AA AB AC AD AE AF */ NOR, NOR, NOR, NOR, NOR, NOR, NOR, NOR,
+/*B0 B1 B2 B3 B4 B5 B6 B7 */ NOR, NOR, NOR, NOR, NOR, NOR, NOR, NOR,
+/*B8 B9 BA BB BC BD BE BF */ NOR, NOR, NOR, NOR, NOR, NOR, NOR, NOR,
+/*C0 C1 C2 C3 C4 C5 C6 C7 */ NOR, NOR, NOR, NOR, NOR, NOR, NOR, NOR,
+/*C8 C9 CA CB CC CD CE CF */ NOR, NOR, NOR, NOR, NOR, NOR, NOR, NOR,
+/*D0 D1 D2 D3 D4 D5 D6 D7 */ NOR, NOR, NOR, NOR, NOR, NOR, NOR, NOR,
+/*D8 D9 DA DB DC DD DE DF */ NOR, NOR, NOR, NOR, NOR, NOR, NOR, NOR,
+/*E0 E1 E2 E3 E4 E5 E6 E7 */ NOR, NOR, NOR, NOR, NOR, NOR, NOR, NOR,
+/*E8 E9 EA EB EC ED EE EF */ NOR, NOR, NOR, NOR, NOR, NOR, NOR, NOR,
+/*F0 F1 F2 F3 F4 F5 F6 F7 */ NOR, NOR, NOR, NOR, NOR, NOR, NOR, NOR,
+/*F8 F9 FA FB FC FD FE FF */ NOR, NOR, NOR, NOR, NOR, NOR, NOR, NOR };
+
+/*#define syscall_printf small_printf*/
+
+static int savex, savey; /* for CSI s, CSI u */
+
+void
+fhandler_console::char_command (char c)
+{
+  // Keep the background intensity with the colr since there doesn't seem
+  // to be a way to set this with termcap/terminfo.
+  static int fg = default_color & (FOREGROUND_BLUE | FOREGROUND_GREEN |
+				   FOREGROUND_RED),
+	     bg = default_color & (BACKGROUND_BLUE | BACKGROUND_GREEN |
+				   BACKGROUND_RED | BACKGROUND_INTENSITY),
+			 bold = default_color & FOREGROUND_INTENSITY;
+  int x, y;
+  char buf[40];
+
+  switch (c)
+    {
+    case 'm':   /* Set Graphics Rendition */
+       int i;
+
+       for (i = 0; i <= nargs_; i++)
+	 switch (args_[i])
+	   {
+	     case 0:    /* normal color */
+	       fg = default_color & (FOREGROUND_BLUE | FOREGROUND_GREEN |
+				     FOREGROUND_RED);
+	       bg = default_color & (BACKGROUND_BLUE | BACKGROUND_GREEN |
+				     BACKGROUND_RED | BACKGROUND_INTENSITY);
+	       bold = default_color & FOREGROUND_INTENSITY;
+	       break;
+	     case 1:    /* bold */
+	       fg = default_color & (FOREGROUND_BLUE | FOREGROUND_GREEN |
+				     FOREGROUND_RED);
+	       bg = default_color & (BACKGROUND_BLUE | BACKGROUND_GREEN |
+				     BACKGROUND_RED | BACKGROUND_INTENSITY);
+	       bold = FOREGROUND_INTENSITY;
+	       break;
+	     case 4:    /* underline - simulate with cyan */
+	       fg = FOREGROUND_BLUE | FOREGROUND_GREEN;
+	       bg = default_color & (BACKGROUND_BLUE | BACKGROUND_GREEN |
+				     BACKGROUND_RED | BACKGROUND_INTENSITY);
+	       bold = default_color & FOREGROUND_INTENSITY;
+	       break;
+	     case 5:    /* blink mode */
+	       fg = default_color & (FOREGROUND_BLUE | FOREGROUND_GREEN |
+				     FOREGROUND_RED);
+	       bg = default_color & (BACKGROUND_BLUE | BACKGROUND_GREEN |
+				     BACKGROUND_RED | BACKGROUND_INTENSITY);
+	       bold = default_color & FOREGROUND_INTENSITY;
+	       break;
+	     case 7:    /* reverse */
+	       fg = (default_color & BACKGROUND_BLUE) ? FOREGROUND_BLUE : 0;
+	       fg |= (default_color & BACKGROUND_GREEN) ? FOREGROUND_GREEN : 0;
+	       fg |= (default_color & BACKGROUND_RED) ? FOREGROUND_RED : 0;
+	       fg |= (default_color & BACKGROUND_INTENSITY) ?
+					     FOREGROUND_INTENSITY : 0;
+	       bg = (default_color & FOREGROUND_BLUE) ? BACKGROUND_BLUE : 0;
+	       bg |= (default_color & FOREGROUND_GREEN) ? BACKGROUND_GREEN : 0;
+	       bg |= (default_color & FOREGROUND_RED) ? BACKGROUND_RED : 0;
+	       bg |= (default_color & FOREGROUND_INTENSITY) ?
+					     BACKGROUND_INTENSITY : 0;
+	       break;
+	     case 8:    /* invisible */
+	       fg = (default_color & BACKGROUND_BLUE) ? FOREGROUND_BLUE : 0;
+	       fg |= (default_color & BACKGROUND_GREEN) ? FOREGROUND_GREEN : 0;
+	       fg |= (default_color & BACKGROUND_RED) ? FOREGROUND_RED : 0;
+	       bg = default_color & (BACKGROUND_BLUE | BACKGROUND_GREEN |
+				     BACKGROUND_RED | BACKGROUND_INTENSITY);
+	       bold = (default_color & BACKGROUND_INTENSITY) ?
+						   FOREGROUND_INTENSITY : 0;
+	       break;
+	     case 9:    /* dim */
+	       fg = default_color & (FOREGROUND_BLUE | FOREGROUND_GREEN |
+				     FOREGROUND_RED);
+	       bg = default_color & (BACKGROUND_BLUE | BACKGROUND_GREEN |
+				     BACKGROUND_RED | BACKGROUND_INTENSITY);
+	       bold = (fg == 0) ? FOREGROUND_INTENSITY : 0;
+	       break;
+	     case 30:		/* BLACK foreground */
+	       fg = 0;
+	       break;
+	     case 31:		/* RED foreground */
+	       fg = FOREGROUND_RED;
+	       break;
+	     case 32:		/* GREEN foreground */
+	       fg = FOREGROUND_GREEN;
+	       break;
+	     case 33:		/* YELLOW foreground */
+	       fg = FOREGROUND_RED | FOREGROUND_GREEN;
+	       break;
+	     case 34:		/* BLUE foreground */
+	       fg = FOREGROUND_BLUE;
+	       break;
+	     case 35:		/* MAGENTA foreground */
+	       fg = FOREGROUND_RED | FOREGROUND_BLUE;
+	       break;
+	     case 36:		/* CYAN foreground */
+	       fg = FOREGROUND_BLUE | FOREGROUND_GREEN;
+	       break;
+	     case 37:		/* WHITE foreg */
+	       fg = FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED;
+	       break;
+	     case 40:		/* BLACK background */
+	       bg = 0;
+	       break;
+	     case 41:		/* RED background */
+	       bg = BACKGROUND_RED;
+	       break;
+	     case 42:		/* GREEN background */
+	       bg = BACKGROUND_GREEN;
+	       break;
+	     case 43:		/* YELLOW background */
+	       bg = BACKGROUND_RED | BACKGROUND_GREEN;
+	       break;
+	     case 44:		/* BLUE background */
+	       bg = BACKGROUND_BLUE;
+	       break;
+	     case 45:		/* MAGENTA background */
+	       bg = BACKGROUND_RED | BACKGROUND_BLUE;
+	       break;
+	     case 46:		/* CYAN background */
+	       bg = BACKGROUND_BLUE | BACKGROUND_GREEN;
+	       break;
+	     case 47:    /* WHITE background */
+	       bg = BACKGROUND_BLUE | BACKGROUND_GREEN | BACKGROUND_RED;
+	       break;
+	     default:
+	       fg = default_color & (FOREGROUND_BLUE | FOREGROUND_GREEN |
+				     FOREGROUND_RED);
+	       bg = default_color & (BACKGROUND_BLUE | BACKGROUND_GREEN |
+				     BACKGROUND_RED | BACKGROUND_INTENSITY);
+	       bold = default_color & FOREGROUND_INTENSITY;
+	       break;
+	   }
+	 SetConsoleTextAttribute (get_output_handle (), fg | bg | bold);
+      break;
+    case 'h':
+    case 'l':
+      /* Ignore */
+      break;
+    case 'J':
+      switch (args_[0])
+	{
+	case 0:			/* Clear to end of screen */
+	  cursor_get (&x, &y);
+	  clear_screen (x, y, -1, -1);
+	  break;
+	case 1:			/* Clear from beginning of screen to cursor */
+	  cursor_get (&x, &y);
+	  clear_screen (0, 0, x, y);
+	  break;
+	case 2:			/* Clear screen */
+	  clear_screen (0, 0, -1, -1);
+	  cursor_set (TRUE, 0,0);
+	  break;
+	default:
+	  goto bad_escape;
+	}
+      break;
+
+    case 'A':
+      cursor_rel (0, -(args_[0] ? args_[0] : 1));
+      break;
+    case 'B':
+      cursor_rel (0, args_[0] ? args_[0] : 1);
+      break;
+    case 'C':
+      cursor_rel (args_[0] ? args_[0] : 1, 0);
+      break;
+    case 'D':
+      cursor_rel (-(args_[0] ? args_[0] : 1),0);
+      break;
+    case 'K':
+      switch (args_[0])
+	{
+	  case 0:		/* Clear to end of line */
+	    cursor_get (&x, &y);
+	    clear_screen (x, y, -1, y);
+	    break;
+	  case 2:		/* Clear line */
+	    cursor_get (&x, &y);
+	    clear_screen (0, y, -1, y);
+	    break;
+	  case 1:		/* Clear from bol to cursor */
+	    cursor_get (&x, &y);
+	    clear_screen (0, y, x, y);
+	    break;
+	  default:
+	    goto bad_escape;
+	}
+      break;
+    case 'H':
+    case 'f':
+      cursor_set (TRUE, (args_[1] ? args_[1] : 1) - 1,
+			(args_[0] ? args_[0] : 1) - 1);
+      break;
+    case 'G':   /* hpa - position cursor at column n - 1 */
+      cursor_get (&x, &y);
+      cursor_set (FALSE, (args_[0] ? args_[0] - 1 : 0), y);
+      break;
+    case 'd':   /* vpa - position cursor at line n */
+      cursor_get (&x, &y);
+      cursor_set (TRUE, x, (args_[0] ? args_[0] - 1 : 0));
+      break;
+    case 's':   /* Save cursor position */
+      cursor_get (&savex, &savey);
+      break;
+    case 'u':   /* Restore cursor position */
+      cursor_set (FALSE, savex, savey);
+      break;
+    case 'I':	/* TAB */
+      cursor_get (&x, &y);
+      cursor_set (FALSE, 8*(x/8+1), y);
+      break;
+    case 'L':				/* AL - insert blank lines */
+      args_[0] = args_[0] ? args_[0] : 1;
+      cursor_get (&x, &y);
+      scroll_screen (0, y, -1, -1, 0, y + args_[0]);
+      break;
+    case 'M':				/* DL - delete lines */
+      args_[0] = args_[0] ? args_[0] : 1;
+      cursor_get (&x, &y);
+      scroll_screen (0, y + args_[0], -1, -1, 0, y);
+      break;
+    case '@':				/* IC - insert chars */
+      args_[0] = args_[0] ? args_[0] : 1;
+      cursor_get (&x, &y);
+      scroll_screen (x, y, -1, y, x + args_[0], y);
+      break;
+    case 'P':				/* DC - delete chars */
+      args_[0] = args_[0] ? args_[0] : 1;
+      cursor_get (&x, &y);
+      scroll_screen (x + args_[0], y, -1, y, x, y);
+      break;
+    case 'S':				/* SF - Scroll forward */
+      args_[0] = args_[0] ? args_[0] : 1;
+      scroll_screen(0, args_[0], -1, -1, 0, 0);
+      break;
+    case 'T':				/* SR - Scroll down */
+      fillin_info ();
+      args_[0] = args_[0] ? args_[0] : 1;
+      scroll_screen (0, 0, -1, -1, 0, info.winTop + args_[0]);
+      break;
+    case 'X':				/* ec - erase chars */
+      args_[0] = args_[0] ? args_[0] : 1;
+      cursor_get (&x, &y);
+      scroll_screen (x + args_[0], y, -1, y, x, y);
+      scroll_screen (x, y, -1, y, x + args_[0], y);
+      break;
+    case 'Z':				/* Back tab */
+      cursor_get (&x, &y);
+      cursor_set (FALSE, ((8 * (x / 8 + 1)) - 8), y);
+      break;
+    case 'b':				/* Repeat char #1 #2 times */
+      while (args_[1]--)
+	WriteFile (get_output_handle (), &args_[0], 1, (DWORD *) &x, 0);
+      break;
+    case 'c':				/* u9 - Terminal enquire string */
+      strcpy (buf, "\033[?6c");
+      puts_readahead (buf);
+      break;
+    case 'n':
+      switch (args_[0])
+	{
+	case 6:				/* u7 - Cursor position request */
+	  cursor_get (&x, &y);
+	  y -= info.winTop;
+	  /* x -= info.winLeft;		// not available yet */
+	  __small_sprintf (buf, "\033[%d;%dR", y + 1, x + 1);
+	  puts_readahead (buf);
+	  break;
+    default:
+	  goto bad_escape;
+	}
+      break;
+    case 'r':				/* Set Scroll region */
+      scroll_region.Top = args_[0] ? args_[0] - 1 : 0;
+      scroll_region.Bottom = args_[1] ? args_[1] - 1 : -1;
+      cursor_set (TRUE, 0, 0);
+      break;
+    case 'g':				/* TAB set/clear */
+      break;
+    default:
+bad_escape:
+      break;
+    }
+}
+
+const unsigned char *
+fhandler_console::write_normal (const unsigned char *src,
+				const unsigned char *end)
+{
+  /* Scan forward to see what a char which needs special treatment */
+  DWORD done;
+  const unsigned char *found = src;
+
+  while (found < end)
+    {
+      if (base_chars[*found] != NOR)
+	break;
+      found++;
+    }
+  /* Print all the base ones out */
+  if (found != src)
+    {
+      if (! WriteFile (get_output_handle (), src,  found - src, &done, 0))
+	{
+	  debug_printf ("write failed, handle %p", get_output_handle ());
+	  __seterrno ();
+	  return 0;
+	}
+      src += done;
+    }
+  if (src < end)
+    {
+      int x, y;
+      switch (base_chars[*src])
+	{
+	case BEL:
+	  Beep (412, 100);
+	  break;
+	case ESC:
+	  state_ = gotesc;
+	  break;
+	case DWN:		/* WriteFile("\n") always adds CR... */
+	  cursor_get (&x, &y);
+	  if (y >= srBottom)
+	    {
+	      if (y < info.winBottom || scroll_region.Top)
+		{
+		  scroll_screen (0, srTop + 1, -1, srBottom, 0, srTop);
+		  y--;
+		}
+	      else
+		WriteFile (get_output_handle (), "\n", 1, &done, 0);
+	    }
+	  if (!get_w_binary ())
+	    x = 0;
+	  cursor_set (FALSE, x, y + 1);
+	  break;
+	case BAK:
+	  cursor_rel (-1, 0);
+	  break;
+	case IGN:
+	  cursor_rel (1, 0);
+	  break;
+	case CR:
+	  cursor_get (&x, &y);
+	  cursor_set (FALSE, 0, y);
+	  break;
+	case ERR:
+	  WriteFile (get_output_handle (), src, 1, &done, 0);
+	  break;
+	case TAB:
+	  cursor_get (&x, &y);
+	  cursor_set (FALSE, 8 * (x / 8 + 1), y);
+	  break;
+	}
+      src ++;
+    }
+  return src;
+}
+
+int
+fhandler_console::write (const void *vsrc, size_t len)
+{
+  /* Run and check for ansi sequences */
+  unsigned const char *src = (unsigned char *) vsrc;
+  unsigned const char *end = src + len;
+  static NO_COPY unsigned rarg;
+  static NO_COPY char my_title_buf[TITLESIZE + 1];
+
+  debug_printf ("%x, %d", vsrc, len);
+
+  while (src < end)
+    {
+      debug_printf ("at %d(%c) state is %d", *src, isprint (*src) ? *src : ' ',
+		    state_);
+      switch (state_)
+	{
+	case normal:
+	  src = write_normal (src, end);
+	  if (src == 0) /* write_normal fail */
+	    return -1;
+	  break;
+	case gotesc:
+	  if (*src == '[')
+	    {
+	      state_ = gotsquare;
+	      for (nargs_ = 0; nargs_ < MAXARGS; nargs_++)
+		args_[nargs_] = 0;
+	      nargs_ = 0;
+	    }
+	  else if (*src == ']')
+	    {
+	      rarg = 0;
+	      my_title_buf[0] = '\0';
+	      state_ = gotrsquare;
+	    }
+	  else if (*src == 'M')		/* Reverse Index */
+	    {
+	      fillin_info ();
+	      scroll_screen (0, 0, -1, -1, 0, info.winTop + 1);
+	      state_ = normal;
+	    }
+	  else if (*src == 'c')		/* Reset Linux terminal */
+	    {
+	      clear_screen (0, 0, -1, -1);
+	      cursor_set (TRUE, 0, 0);
+	      state_ = normal;
+	    }
+	  else if (*src == '8')		/* Restore cursor position */
+	    {
+	      cursor_set (FALSE, savex, savey);
+	      state_ = normal;
+	    }
+	  else if (*src == '7')		/* Save cursor position */
+	    {
+	      cursor_get (&savex, &savey);
+	      state_ = normal;
+	    }
+	  else if (*src == 'R')
+	      state_ = normal;
+	  else
+	    {
+	      state_ = normal;
+	    }
+	  src++;
+	  break;
+	case gotarg1:
+	  if (isdigit (*src))
+	    {
+	      args_[nargs_] = args_[nargs_] * 10 + *src - '0';
+	      src++;
+	    }
+	  else if (*src == ';')
+	    {
+	      src++;
+	      nargs_++;
+	      if (nargs_ >= MAXARGS)
+		nargs_--;
+	    }
+	  else
+	    {
+	      state_ = gotcommand;
+	    }
+	  break;
+	case gotcommand:
+	  char_command (*src++);
+	  state_ = normal;
+	  break;
+	case gotrsquare:
+	  if (isdigit(*src))
+	    rarg = rarg * 10 + (*src - '0');
+	  else if (*src == ';' && (rarg == 2 || rarg == 0))
+	    state_ = gettitle;
+	  else
+	    state_ = eattitle;
+	  src++;
+	  break;
+	case eattitle:
+	case gettitle:
+	  {
+	    int n = strlen (my_title_buf);
+	    if (*src < ' ' || *src >= '\177')
+	      {
+		if (*src == '\007' && state_ == gettitle)
+		  {
+		    if (old_title)
+		      strcpy (old_title, my_title_buf);
+		    set_console_title (my_title_buf);
+		  }
+		state_ = normal;
+	      }
+	    else if (n < TITLESIZE)
+	      {
+		my_title_buf[n++] = *src;
+		my_title_buf[n] = '\0';
+	      }
+	    src++;
+	    break;
+	  }
+	case gotsquare:
+	  if (*src == ';')
+	    {
+	      state_ = gotarg1;
+	      nargs_++;
+	      src++;
+	    }
+	  else if (isalpha (*src))
+	    {
+	      state_ = gotcommand;
+	    }
+	  else if (*src != '@' && !isalpha (*src) && !isdigit (*src))
+	    {
+	      /* ignore any extra chars between [ and first arg or command */
+	      src++;
+	    }
+	  else
+	    state_ = gotarg1;
+	  break;
+	}
+    }
+  syscall_printf ("%d = write_console (,..%d)", len, len);
+
+  return len;
+}
+
+static struct {
+  int vk;
+  const char *val[4];
+} keytable[] = {
+	       /* NORMAL */  /* SHIFT */    /* CTRL */       /* ALT */
+  {VK_LEFT,	{"\033[D",	NULL,		NULL,		NULL}},
+  {VK_RIGHT,	{"\033[C",	NULL,		NULL,		NULL}},
+  {VK_UP,	{"\033[A",	NULL,		NULL,		NULL}},
+  {VK_DOWN,	{"\033[B",	NULL,		NULL,		NULL}},
+  {VK_PRIOR,	{"\033[5~",	NULL,		NULL,		NULL}},
+  {VK_NEXT,	{"\033[6~",	NULL,		NULL,		NULL}},
+  {VK_HOME,	{"\033[1~",	NULL,		NULL,		NULL}},
+  {VK_END,	{"\033[4~",	NULL,		NULL,		NULL}},
+  {VK_INSERT,	{"\033[2~",	NULL,		NULL,		NULL}},
+  {VK_DELETE,	{"\033[3~",	NULL,		NULL,		NULL}},
+  {VK_F1,	{"\033[[A",	"\033[23~",	NULL,		NULL}},
+  {VK_F2,	{"\033[[B",	"\033[24~",	NULL,		NULL}},
+  {VK_F3,	{"\033[[C",	"\033[25~",	NULL,		NULL}},
+  {VK_F4,	{"\033[[D",	"\033[26~",	NULL,		NULL}},
+  {VK_F5,	{"\033[[E",	"\033[28~",	NULL,		NULL}},
+  {VK_F6,	{"\033[17~",	"\033[29~",	"\036",		NULL}},
+  {VK_F7,	{"\033[18~",	"\033[31~",	NULL,		NULL}},
+  {VK_F8,	{"\033[19~",	"\033[32~",	NULL,		NULL}},
+  {VK_F9,	{"\033[20~",	"\033[33~",	NULL,		NULL}},
+  {VK_F10,	{"\033[21~",	"\033[34~",	NULL,		NULL}},
+  {VK_F11,	{"\033[23~",	NULL,		NULL,		NULL}},
+  {VK_F12,	{"\033[24~",	NULL,		NULL,		NULL}},
+  {VK_NUMPAD5,	{"\033[G",	NULL,		NULL,		NULL}},
+  {'6',		{NULL,		NULL,		"\036",		NULL}},
+  {0,		{"",		NULL,		NULL,		NULL}}
+};
+
+const char *
+get_nonascii_key (INPUT_RECORD& input_rec)
+{
+#define NORMAL  0
+#define SHIFT	1
+#define CONTROL	2
+#define ALT	3
+  int modifier_index = NORMAL;
+
+  if (input_rec.Event.KeyEvent.dwControlKeyState & SHIFT_PRESSED)
+    modifier_index = SHIFT;
+  else if (input_rec.Event.KeyEvent.dwControlKeyState &
+		(LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED))
+    modifier_index = CONTROL;
+  else if (input_rec.Event.KeyEvent.dwControlKeyState &
+		(LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED))
+    modifier_index = ALT;
+
+  for (int i = 0; keytable[i].vk; i++)
+    if (input_rec.Event.KeyEvent.wVirtualKeyCode == keytable[i].vk)
+      return keytable[i].val[modifier_index];
+
+  return NULL;
+}
+
+void
+fhandler_console::init (HANDLE f, DWORD a, mode_t bin)
+{
+  this->fhandler_termios::init (f, bin, a);
+
+  /* Ensure both input and output console handles are open */
+  int mode = 0;
+
+  a &= GENERIC_READ | GENERIC_WRITE;
+  if (a == GENERIC_READ)
+    mode = O_RDONLY;
+  if (a == GENERIC_WRITE)
+    mode = O_WRONLY;
+  if (a == (GENERIC_READ | GENERIC_WRITE))
+    mode = O_RDWR;
+  open (0, mode);
+  if (f != INVALID_HANDLE_VALUE)
+    CloseHandle (f);	/* Reopened by open */
+
+  output_tcsetattr (0, &tc->ti);
+}
+
+int
+fhandler_console::igncr_enabled (void)
+{
+  return tc->ti.c_iflag & IGNCR;
+}
+
+void
+fhandler_console::set_close_on_exec (int val)
+{
+  this->fhandler_base::set_close_on_exec (val);
+  set_inheritance (output_handle, val);
+}
+
+void
+fhandler_console::fixup_after_fork (HANDLE parent)
+{
+  HANDLE h = get_handle ();
+  HANDLE oh = get_output_handle ();
+
+  /* Windows does not allow duplication of console handles between processes
+     so open the console explicitly. */
+
+  if (!open(get_name (), get_flags (), 0))
+    system_printf ("error opening console after fork, %E");
+
+  if (!get_close_on_exec ())
+    {
+      CloseHandle (h);
+      CloseHandle (oh);
+    }
+}
+
+void __stdcall
+set_console_title (char *title)
+{
+  int rc;
+  char buf[257];
+  strncpy(buf, title, sizeof(buf) - 1);
+  buf[sizeof(buf) - 1] = '\0';
+  if ((rc = WaitForSingleObject (title_mutex, 15000)) != WAIT_OBJECT_0)
+    sigproc_printf ("wait for title mutex failed rc %d, %E", rc);
+  SetConsoleTitle (buf);
+  ReleaseMutex (title_mutex);
+  debug_printf ("title '%s'", buf);
+}
+
+int
+fhandler_console::de_linearize (const char *buf, const char *unix_name,
+			        const char *win32_name)
+{
+  int res = fhandler_base::de_linearize (buf, unix_name, win32_name);
+  HANDLE h = get_handle ();
+  HANDLE oh = get_output_handle ();
+
+  if (!open(get_name (), get_flags (), 0))
+    {
+      int sawerr = 0;
+      if (!get_io_handle ())
+	{
+	  system_printf ("error opening input console handle after exec, errno %d, %E", get_errno ());
+	  sawerr = 1;
+	}
+      if (!get_output_handle ())
+	{
+	  system_printf ("error opening input console handle after exec, errno %d, %E", get_errno ());
+	  sawerr = 1;
+	}
+
+      if (!sawerr)
+	system_printf ("error opening console after exec, errno %d, %E", get_errno ());
+    }
+
+  CloseHandle (h);
+  CloseHandle (oh);
+  return res;
+}