1450 lines
36 KiB
C++
1450 lines
36 KiB
C++
/* 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. */
|
|
|
|
#include "winsup.h"
|
|
#include <sys/termios.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <fcntl.h>
|
|
#include <errno.h>
|
|
#include <unistd.h>
|
|
#include <wingdi.h>
|
|
#include <winuser.h>
|
|
#include <wincon.h>
|
|
#include <ctype.h>
|
|
#include <sys/cygwin.h>
|
|
#include "cygerrno.h"
|
|
#include "fhandler.h"
|
|
#include "sync.h"
|
|
#include "sigproc.h"
|
|
#include "pinfo.h"
|
|
#include "shared_info.h"
|
|
#include "security.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&, char *);
|
|
|
|
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;
|
|
}
|
|
|
|
void
|
|
fhandler_console::set_cursor_maybe ()
|
|
{
|
|
CONSOLE_SCREEN_BUFFER_INFO now;
|
|
static CONSOLE_SCREEN_BUFFER_INFO last = {{0, 0}, {-1, -1}, 0, {0, 0}, {0, 0}};
|
|
|
|
if (!GetConsoleScreenBufferInfo (get_output_handle(), &now))
|
|
return;
|
|
|
|
if (last.dwCursorPosition.X != now.dwCursorPosition.X ||
|
|
last.dwCursorPosition.Y != now.dwCursorPosition.Y)
|
|
{
|
|
SetConsoleCursorPosition (get_output_handle (), now.dwCursorPosition);
|
|
last.dwCursorPosition = now.dwCursorPosition;
|
|
}
|
|
}
|
|
|
|
int
|
|
fhandler_console::read (void *pv, size_t buflen)
|
|
{
|
|
if (!buflen)
|
|
return 0;
|
|
|
|
HANDLE h = get_io_handle ();
|
|
|
|
#define buf ((char *) pv)
|
|
|
|
int ch;
|
|
set_input_state ();
|
|
|
|
int copied_chars = get_readahead_into_buffer (buf, buflen);
|
|
|
|
if (copied_chars)
|
|
return copied_chars;
|
|
|
|
HANDLE w4[2];
|
|
DWORD nwait;
|
|
char tmp[17];
|
|
|
|
w4[0] = h;
|
|
if (iscygthread ())
|
|
nwait = 1;
|
|
else
|
|
{
|
|
w4[1] = signal_arrived;
|
|
nwait = 2;
|
|
}
|
|
|
|
for (;;)
|
|
{
|
|
int bgres;
|
|
if ((bgres = bg_check (SIGTTIN)) <= 0)
|
|
return bgres;
|
|
|
|
set_cursor_maybe (); /* to make cursor appear on the screen immediately */
|
|
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)
|
|
#define wch (input_rec.Event.KeyEvent.uChar.UnicodeChar)
|
|
|
|
/* check if we're just disposing of this one */
|
|
|
|
if (input_rec.EventType == WINDOW_BUFFER_SIZE_EVENT)
|
|
{
|
|
kill_pgrp (tc->getpgid (), SIGWINCH);
|
|
continue;
|
|
}
|
|
if (input_rec.EventType != KEY_EVENT ||
|
|
!input_rec.Event.KeyEvent.bKeyDown)
|
|
continue;
|
|
|
|
if (wch == 0 ||
|
|
/* arrow/function keys */
|
|
(input_rec.Event.KeyEvent.dwControlKeyState & ENHANCED_KEY))
|
|
{
|
|
toadd = get_nonascii_key (input_rec, tmp);
|
|
if (!toadd)
|
|
continue;
|
|
nread = strlen (toadd);
|
|
}
|
|
else
|
|
{
|
|
tmp[1] = ich;
|
|
/* Need this check since US code page seems to have a bug when
|
|
converting a CTRL-U. */
|
|
if ((unsigned char)ich > 0x7f)
|
|
OemToCharBuff (tmp + 1, tmp + 1, 1);
|
|
if (!(input_rec.Event.KeyEvent.dwControlKeyState & LEFT_ALT_PRESSED))
|
|
toadd = tmp + 1;
|
|
else
|
|
{
|
|
tmp[0] = '\033';
|
|
tmp[1] = tolower (tmp[1]);
|
|
toadd = tmp;
|
|
nread++;
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
int
|
|
fhandler_console::tcsetpgrp (pid_t pid)
|
|
{
|
|
tc->pgid = pid;
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
fhandler_console::set_input_state ()
|
|
{
|
|
if (TTYISSETF (RSTCONS))
|
|
input_tcsetattr (0, &tc->ti);
|
|
}
|
|
|
|
|
|
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);
|
|
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)
|
|
{
|
|
char buf[256];
|
|
int len = found - src;
|
|
do {
|
|
int l2 = min (256, len);
|
|
CharToOemBuff ((LPCSTR)src, buf, l2);
|
|
if (! WriteFile (get_output_handle (), buf, l2, &done, 0))
|
|
{
|
|
debug_printf ("write failed, handle %p", get_output_handle ());
|
|
__seterrno ();
|
|
return 0;
|
|
}
|
|
len -= done;
|
|
src += done;
|
|
} while (len > 0);
|
|
}
|
|
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}},
|
|
{VK_CLEAR, {"\033[G", NULL, NULL, NULL}},
|
|
{'6', {NULL, NULL, "\036", NULL}},
|
|
{0, {"", NULL, NULL, NULL}}
|
|
};
|
|
|
|
const char *
|
|
get_nonascii_key (INPUT_RECORD& input_rec, char *tmp)
|
|
{
|
|
#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];
|
|
|
|
if (input_rec.Event.KeyEvent.uChar.AsciiChar)
|
|
{
|
|
tmp[0] = input_rec.Event.KeyEvent.uChar.AsciiChar;
|
|
tmp[1] = '\0';
|
|
return tmp;
|
|
}
|
|
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)
|
|
{
|
|
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);
|
|
}
|
|
|
|
void
|
|
fhandler_console::fixup_after_exec (HANDLE)
|
|
{
|
|
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;
|
|
}
|