#include "defs.h"
#include <ctype.h>
-#include "common/gdb_wait.h"
+#include "gdbsupport/gdb_wait.h"
#include "event-top.h"
#include "gdbthread.h"
#include "fnmatch.h"
#include "gdb_usleep.h"
#include "interps.h"
#include "gdb_regex.h"
-#include "common/job-control.h"
-#include "common/selftest.h"
-#include "common/gdb_optional.h"
+#include "gdbsupport/job-control.h"
+#include "gdbsupport/selftest.h"
+#include "gdbsupport/gdb_optional.h"
#include "cp-support.h"
#include <algorithm>
-#include "common/pathstuff.h"
+#include "gdbsupport/pathstuff.h"
#include "cli/cli-style.h"
-#include "common/scope-exit.h"
+#include "gdbsupport/scope-exit.h"
+#include "gdbarch.h"
void (*deprecated_error_begin_hook) (void);
/* A flag indicating whether to timestamp debugging messages. */
-static int debug_timestamp = 0;
+static bool debug_timestamp = false;
-/* Nonzero means that strings with character values >0x7F should be printed
- as octal escapes. Zero means just print the value (e.g. it's an
+/* True means that strings with character values >0x7F should be printed
+ as octal escapes. False means just print the value (e.g. it's an
international character, and the terminal or window can cope.) */
-int sevenbit_strings = 0;
+bool sevenbit_strings = false;
static void
show_sevenbit_strings (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
const char *warning_pre_print = "\nwarning: ";
-int pagination_enabled = 1;
+bool pagination_enabled = true;
static void
show_pagination_enabled (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
}
\f
-/* Cleanup utilities.
-
- These are not defined in cleanups.c (nor declared in cleanups.h)
- because while they use the "cleanup API" they are not part of the
- "cleanup API". */
-
-/* This function is useful for cleanups.
- Do
-
- foo = xmalloc (...);
- old_chain = make_cleanup (free_current_contents, &foo);
-
- to arrange to free the object thus allocated. */
-
-void
-free_current_contents (void *ptr)
-{
- void **location = (void **) ptr;
-
- if (location == NULL)
- internal_error (__FILE__, __LINE__,
- _("free_current_contents: NULL pointer"));
- if (*location != NULL)
- {
- xfree (*location);
- *location = NULL;
- }
-}
-\f
/* Print a warning message. The first argument STRING is the warning
/* Don't allow infinite error/warning recursion. */
{
- static char msg[] = "Recursive internal problem.\n";
+ static const char msg[] = "Recursive internal problem.\n";
switch (dejavu)
{
if (problem->user_settable_should_quit)
{
set_doc = xstrprintf (_("Set whether GDB should quit "
- "when an %s is detected"),
+ "when an %s is detected."),
problem->name);
show_doc = xstrprintf (_("Show whether GDB will quit "
- "when an %s is detected"),
+ "when an %s is detected."),
problem->name);
add_setshow_enum_cmd ("quit", class_maintenance,
internal_problem_modes,
if (problem->user_settable_should_dump_core)
{
set_doc = xstrprintf (_("Set whether GDB should create a core "
- "file of GDB when %s is detected"),
+ "file of GDB when %s is detected."),
problem->name);
show_doc = xstrprintf (_("Show whether GDB will create a core "
- "file of GDB when %s is detected"),
+ "file of GDB when %s is detected."),
problem->name);
add_setshow_enum_cmd ("corefile", class_maintenance,
internal_problem_modes,
quit ();
quit_handler ();
-
- if (deprecated_interactive_hook)
- deprecated_interactive_hook ();
}
\f
printf_filtered (_("(%s or %s) [answered %c; "
"input not from terminal]\n"),
y_string, n_string, def_answer);
- gdb_flush (gdb_stdout);
return def_value;
}
int rows = lines_per_page;
int cols = chars_per_line;
- if (rows <= 0)
- rows = INT_MAX;
+ /* If we get 0 or negative ROWS or COLS, treat as "infinite" size.
+ A negative number can be seen here with the "set width/height"
+ commands and either:
+
+ - the user specified "unlimited", which maps to UINT_MAX, or
+ - the user spedified some number between INT_MAX and UINT_MAX.
+
+ Cap "infinity" to approximately sqrt(INT_MAX) so that we don't
+ overflow in rl_set_screen_size, which multiplies rows and columns
+ to compute the number of characters on the screen. */
+
+ const int sqrt_int_max = INT_MAX >> (sizeof (int) * 8 / 2);
+
+ if (rows <= 0 || rows > sqrt_int_max)
+ {
+ rows = sqrt_int_max;
+ lines_per_page = UINT_MAX;
+ }
- if (cols <= 0)
- cols = INT_MAX;
+ if (cols <= 0 || cols > sqrt_int_max)
+ {
+ cols = sqrt_int_max;
+ chars_per_line = UINT_MAX;
+ }
/* Update Readline's idea of the terminal size. */
rl_set_screen_size (rows, cols);
fputs_unfiltered (style.to_ansi ().c_str (), stream);
}
-/* See utils.h. */
-
-bool
-can_emit_style_escape (struct ui_file *stream)
-{
- if (stream != gdb_stdout
- || !cli_styling
- || !ui_file_isatty (stream))
- return false;
- const char *term = getenv ("TERM");
- if (term == nullptr || !strcmp (term, "dumb"))
- return false;
- return true;
-}
-
/* Set the current output style. This will affect future uses of the
_filtered output functions. */
static void
set_output_style (struct ui_file *stream, const ui_file_style &style)
{
- if (!can_emit_style_escape (stream))
+ if (!stream->can_emit_style_escape ())
return;
- /* Note that we don't pass STREAM here, because we want to emit to
+ /* Note that we may not pass STREAM here, when we want to emit to
the wrap buffer, not directly to STREAM. */
- emit_style_escape (style);
+ if (stream == gdb_stdout)
+ stream = nullptr;
+ emit_style_escape (style, stream);
}
/* See utils.h. */
void
reset_terminal_style (struct ui_file *stream)
{
- if (can_emit_style_escape (stream))
+ if (stream->can_emit_style_escape ())
{
/* Force the setting, regardless of what we think the setting
might already be. */
bool disable_pagination = pagination_disabled_for_command;
/* Clear the current styling. */
- if (can_emit_style_escape (gdb_stdout))
+ if (gdb_stdout->can_emit_style_escape ())
emit_style_escape (ui_file_style (), gdb_stdout);
if (annotation_level > 1)
reinitialize_more_filter ();
pagination_disabled_for_command = disable_pagination;
- /* Restore the current styling. */
- if (can_emit_style_escape (gdb_stdout))
- emit_style_escape (applied_style);
-
dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
}
{
unsigned int save_chars = chars_printed;
+ /* If we change the style, below, we'll want to reset it
+ before continuing to print. If there is no wrap
+ column, then we'll only reset the style if the pager
+ prompt is given; and to avoid emitting style
+ sequences in the middle of a run of text, we track
+ this as well. */
+ ui_file_style save_style;
+ bool did_paginate = false;
+
chars_printed = 0;
lines_printed++;
if (wrap_column)
{
- if (can_emit_style_escape (stream))
+ save_style = wrap_style;
+ if (stream->can_emit_style_escape ())
emit_style_escape (ui_file_style (), stream);
/* If we aren't actually wrapping, don't output
newline -- if chars_per_line is right, we
fputc_unfiltered ('\n', stream);
}
else
- flush_wrap_buffer (stream);
+ {
+ save_style = applied_style;
+ flush_wrap_buffer (stream);
+ }
/* Possible new page. Note that
PAGINATION_DISABLED_FOR_COMMAND might be set during
this loop, so we must continue to check it here. */
if (lines_printed >= lines_per_page - 1
&& !pagination_disabled_for_command)
- prompt_for_continue ();
+ {
+ prompt_for_continue ();
+ did_paginate = true;
+ }
/* Now output indentation and wrapped string. */
if (wrap_column)
{
fputs_unfiltered (wrap_indent, stream);
- if (can_emit_style_escape (stream))
- emit_style_escape (wrap_style, stream);
+ if (stream->can_emit_style_escape ())
+ emit_style_escape (save_style, stream);
/* FIXME, this strlen is what prevents wrap_indent from
containing tabs. However, if we recurse to print it
and count its chars, we risk trouble if wrap_indent is
+ (save_chars - wrap_column);
wrap_column = 0; /* And disable fancy wrap */
}
+ else if (did_paginate && stream->can_emit_style_escape ())
+ emit_style_escape (save_style, stream);
}
}
}
}
+/* See utils.h. */
+
+void
+fputs_highlighted (const char *str, const compiled_regex &highlight,
+ struct ui_file *stream)
+{
+ regmatch_t pmatch;
+
+ while (*str && highlight.exec (str, 1, &pmatch, 0) == 0)
+ {
+ size_t n_highlight = pmatch.rm_eo - pmatch.rm_so;
+
+ /* Output the part before pmatch with current style. */
+ while (pmatch.rm_so > 0)
+ {
+ fputc_filtered (*str, stream);
+ pmatch.rm_so--;
+ str++;
+ }
+
+ /* Output pmatch with the highlight style. */
+ set_output_style (stream, highlight_style.style ());
+ while (n_highlight > 0)
+ {
+ fputc_filtered (*str, stream);
+ n_highlight--;
+ str++;
+ }
+ set_output_style (stream, ui_file_style ());
+ }
+
+ /* Output the trailing part of STR not matching HIGHLIGHT. */
+ if (*str)
+ fputs_filtered (str, stream);
+}
+
int
putchar_unfiltered (int c)
{
{
int match;
- if (template_string != (char *) NULL && string_to_compare != (char *) NULL
+ if (template_string != NULL && string_to_compare != NULL
&& strlen (string_to_compare) <= strlen (template_string))
match =
(startswith (template_string, string_to_compare));
projects / deliverable / binutils-gdb.git / blobdiff