/* Host support routines for MinGW, for GDB, the GNU debugger.
- Copyright (C) 2006, 2007 Free Software Foundation, Inc.
+ Copyright (C) 2006-2020 Free Software Foundation, Inc.
This file is part of GDB.
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
+#include "main.h"
#include "serial.h"
+#include "gdbsupport/event-loop.h"
-#include "gdb_assert.h"
-#include "gdb_select.h"
-#include "gdb_string.h"
+#include "gdbsupport/gdb_select.h"
#include <windows.h>
-/* The strerror() function can return NULL for errno values that are
- out of range. Provide a "safe" version that always returns a
- printable string.
-
- The Windows runtime implementation of strerror never returns NULL,
- but does return a useless string for anything above sys_nerr;
- unfortunately this includes all socket-related error codes.
- This replacement tries to find a system-provided error message. */
+/* Return an absolute file name of the running GDB, if possible, or
+ ARGV0 if not. The return value is in malloc'ed storage. */
char *
-safe_strerror (int errnum)
+windows_get_absolute_argv0 (const char *argv0)
{
- static char *buffer;
- int len;
-
- if (errnum >= 0 && errnum < sys_nerr)
- return strerror (errnum);
-
- if (buffer)
- {
- LocalFree (buffer);
- buffer = NULL;
- }
-
- if (FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER
- | FORMAT_MESSAGE_FROM_SYSTEM,
- NULL, errnum,
- MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
- (LPTSTR) &buffer, 0, NULL) == 0)
- {
- static char buf[32];
- xsnprintf (buf, sizeof buf, "(undocumented errno %d)", errnum);
- return buf;
- }
+ char full_name[PATH_MAX];
- /* Windows error messages end with a period and a CR-LF; strip that
- out. */
- len = strlen (buffer);
- if (len > 3 && strcmp (buffer + len - 3, ".\r\n") == 0)
- buffer[len - 3] = '\0';
-
- return buffer;
+ if (GetModuleFileName (NULL, full_name, PATH_MAX))
+ return xstrdup (full_name);
+ return xstrdup (argv0);
}
/* Wrapper for select. On Windows systems, where the select interface
HANDLE h;
DWORD event;
DWORD num_handles;
+ /* SCBS contains serial control objects corresponding to file
+ descriptors in READFDS and WRITEFDS. */
+ struct serial *scbs[MAXIMUM_WAIT_OBJECTS];
+ /* The number of valid entries in SCBS. */
+ size_t num_scbs;
int fd;
int num_ready;
- int indx;
+ size_t indx;
+
+ if (n == 0)
+ {
+ /* The MS API says that the first argument to
+ WaitForMultipleObjects cannot be zero. That's why we just
+ use a regular Sleep here. */
+ if (timeout != NULL)
+ Sleep (timeout->tv_sec * 1000 + timeout->tv_usec / 1000);
+
+ return 0;
+ }
num_ready = 0;
num_handles = 0;
+ num_scbs = 0;
for (fd = 0; fd < n; ++fd)
{
HANDLE read = NULL, except = NULL;
if ((!readfds || !FD_ISSET (fd, readfds))
&& (!exceptfds || !FD_ISSET (fd, exceptfds)))
continue;
- h = (HANDLE) _get_osfhandle (fd);
scb = serial_for_fd (fd);
if (scb)
- serial_wait_handle (scb, &read, &except);
+ {
+ serial_wait_handle (scb, &read, &except);
+ scbs[num_scbs++] = scb;
+ }
if (read == NULL)
- read = h;
+ read = (HANDLE) _get_osfhandle (fd);
if (except == NULL)
{
if (!never_handle)
handles[num_handles++] = except;
}
}
- /* If we don't need to wait for any handles, we are done. */
- if (!num_handles)
- {
- if (timeout)
- Sleep (timeout->tv_sec * 1000 + timeout->tv_usec / 1000);
- return 0;
- }
+ gdb_assert (num_handles <= MAXIMUM_WAIT_OBJECTS);
event = WaitForMultipleObjects (num_handles,
handles,
mutexes, that should never occur. */
gdb_assert (!(WAIT_ABANDONED_0 <= event
&& event < WAIT_ABANDONED_0 + num_handles));
+ /* We no longer need the helper threads to check for activity. */
+ for (indx = 0; indx < num_scbs; ++indx)
+ serial_done_wait_handle (scbs[indx]);
if (event == WAIT_FAILED)
return -1;
if (event == WAIT_TIMEOUT)
for (fd = 0, indx = 0; fd < n; ++fd)
{
HANDLE fd_h;
- struct serial *scb;
if ((!readfds || !FD_ISSET (fd, readfds))
&& (!exceptfds || !FD_ISSET (fd, exceptfds)))
else
num_ready++;
}
-
- /* We created at least one event handle for this fd. Let the
- device know we are finished with it. */
- scb = serial_for_fd (fd);
- if (scb)
- serial_done_wait_handle (scb);
}
return num_ready;
}
+
+/* Map COLOR's RGB triplet, with 8 bits per component, into 16 Windows
+ console colors, where each component has just 1 bit, plus a single
+ intensity bit which affects all 3 components. */
+static int
+rgb_to_16colors (const ui_file_style::color &color)
+{
+ uint8_t rgb[3];
+ color.get_rgb (rgb);
+
+ int retval = 0;
+ for (int i = 0; i < 3; i++)
+ {
+ /* Subdivide 256 possible values of each RGB component into 3
+ regions: no color, normal color, bright color. 256 / 3 = 85,
+ but ui-style.c follows xterm and uses 92 for R and G
+ components of the bright-blue color, so we bias the divisor a
+ bit to have the bright colors between 9 and 15 identical to
+ what ui-style.c expects. */
+ int bits = rgb[i] / 93;
+ retval |= ((bits > 0) << (2 - i)) | ((bits > 1) << 3);
+ }
+
+ return retval;
+}
+
+/* Zero if not yet initialized, 1 if stdout is a console device, else -1. */
+static int mingw_console_initialized;
+
+/* Handle to stdout . */
+static HANDLE hstdout = INVALID_HANDLE_VALUE;
+
+/* Text attribute to use for normal text (the "none" pseudo-color). */
+static SHORT norm_attr;
+
+/* The most recently applied style. */
+static ui_file_style last_style;
+
+/* Alternative for the libc 'fputs' which handles embedded SGR
+ sequences in support of styling. */
+
+int
+gdb_console_fputs (const char *linebuf, FILE *fstream)
+{
+ if (!mingw_console_initialized)
+ {
+ hstdout = (HANDLE)_get_osfhandle (fileno (fstream));
+ DWORD cmode;
+ CONSOLE_SCREEN_BUFFER_INFO csbi;
+
+ if (hstdout != INVALID_HANDLE_VALUE
+ && GetConsoleMode (hstdout, &cmode) != 0
+ && GetConsoleScreenBufferInfo (hstdout, &csbi))
+ {
+ norm_attr = csbi.wAttributes;
+ mingw_console_initialized = 1;
+ }
+ else if (hstdout != INVALID_HANDLE_VALUE)
+ mingw_console_initialized = -1; /* valid, but not a console device */
+ }
+ /* If our stdout is not a console device, let the default 'fputs'
+ handle the task. */
+ if (mingw_console_initialized <= 0)
+ return 0;
+
+ /* Mapping between 8 ANSI colors and Windows console attributes. */
+ static int fg_color[] = {
+ 0, /* black */
+ FOREGROUND_RED, /* red */
+ FOREGROUND_GREEN, /* green */
+ FOREGROUND_GREEN | FOREGROUND_RED, /* yellow */
+ FOREGROUND_BLUE, /* blue */
+ FOREGROUND_BLUE | FOREGROUND_RED, /* magenta */
+ FOREGROUND_BLUE | FOREGROUND_GREEN, /* cyan */
+ FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE /* gray */
+ };
+ static int bg_color[] = {
+ 0, /* black */
+ BACKGROUND_RED, /* red */
+ BACKGROUND_GREEN, /* green */
+ BACKGROUND_GREEN | BACKGROUND_RED, /* yellow */
+ BACKGROUND_BLUE, /* blue */
+ BACKGROUND_BLUE | BACKGROUND_RED, /* magenta */
+ BACKGROUND_BLUE | BACKGROUND_GREEN, /* cyan */
+ BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE /* gray */
+ };
+
+ ui_file_style style = last_style;
+ unsigned char c;
+ size_t n_read;
+
+ for ( ; (c = *linebuf) != 0; linebuf += n_read)
+ {
+ if (c == '\033')
+ {
+ fflush (fstream);
+ bool parsed = style.parse (linebuf, &n_read);
+ if (n_read <= 0) /* should never happen */
+ n_read = 1;
+ if (!parsed)
+ {
+ /* This means we silently swallow SGR sequences we
+ cannot parse. */
+ continue;
+ }
+ /* Colors. */
+ const ui_file_style::color &fg = style.get_foreground ();
+ const ui_file_style::color &bg = style.get_background ();
+ int fgcolor, bgcolor, bright, inverse;
+ if (fg.is_none ())
+ fgcolor = norm_attr & 15;
+ else if (fg.is_basic ())
+ fgcolor = fg_color[fg.get_value () & 15];
+ else
+ fgcolor = rgb_to_16colors (fg);
+ if (bg.is_none ())
+ bgcolor = norm_attr & (15 << 4);
+ else if (bg.is_basic ())
+ bgcolor = bg_color[bg.get_value () & 15];
+ else
+ bgcolor = rgb_to_16colors (bg) << 4;
+
+ /* Intensity. */
+ switch (style.get_intensity ())
+ {
+ case ui_file_style::NORMAL:
+ case ui_file_style::DIM:
+ bright = 0;
+ break;
+ case ui_file_style::BOLD:
+ bright = 1;
+ break;
+ default:
+ gdb_assert_not_reached ("invalid intensity");
+ }
+
+ /* Inverse video. */
+ if (style.is_reverse ())
+ inverse = 1;
+ else
+ inverse = 0;
+
+ /* Construct the attribute. */
+ if (inverse)
+ {
+ int t = fgcolor;
+ fgcolor = (bgcolor >> 4);
+ bgcolor = (t << 4);
+ }
+ if (bright)
+ fgcolor |= FOREGROUND_INTENSITY;
+
+ SHORT attr = (bgcolor & (15 << 4)) | (fgcolor & 15);
+
+ /* Apply the attribute. */
+ SetConsoleTextAttribute (hstdout, attr);
+ }
+ else
+ {
+ /* When we are about to write newline, we need to clear to
+ EOL with the normal attribute, to avoid spilling the
+ colors to the next screen line. We assume here that no
+ non-default attribute extends beyond the newline. */
+ if (c == '\n')
+ {
+ DWORD nchars;
+ COORD start_pos;
+ DWORD written;
+ CONSOLE_SCREEN_BUFFER_INFO csbi;
+
+ fflush (fstream);
+ GetConsoleScreenBufferInfo (hstdout, &csbi);
+
+ if (csbi.wAttributes != norm_attr)
+ {
+ start_pos = csbi.dwCursorPosition;
+ nchars = csbi.dwSize.X - start_pos.X;
+
+ FillConsoleOutputAttribute (hstdout, norm_attr, nchars,
+ start_pos, &written);
+ FillConsoleOutputCharacter (hstdout, ' ', nchars,
+ start_pos, &written);
+ }
+ }
+ fputc (c, fstream);
+ n_read = 1;
+ }
+ }
+
+ last_style = style;
+ return 1;
+}
projects / deliverable / binutils-gdb.git / blobdiff