/* General utility routines for GDB, the GNU debugger.
- Copyright (C) 1986-2018 Free Software Foundation, Inc.
+ Copyright (C) 1986-2019 Free Software Foundation, Inc.
This file is part of GDB.
#include "defs.h"
#include <ctype.h>
-#include "gdb_wait.h"
+#include "gdbsupport/gdb_wait.h"
#include "event-top.h"
#include "gdbthread.h"
#include "fnmatch.h"
#include <chrono>
-#include "gdb_usleep.h"
#include "interps.h"
#include "gdb_regex.h"
-#include "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 "gdbsupport/scope-exit.h"
+#include "gdbarch.h"
+#include "cli-out.h"
void (*deprecated_error_begin_hook) (void);
/* Prototypes for local functions */
static void vfprintf_maybe_filtered (struct ui_file *, const char *,
- va_list, int) ATTRIBUTE_PRINTF (2, 0);
+ va_list, bool, bool)
+ ATTRIBUTE_PRINTF (2, 0);
static void fputs_maybe_filtered (const char *, struct ui_file *, int);
/* 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
else
fputs_unfiltered (msg, gdb_stderr);
- abort (); /* NOTE: GDB has only three calls to abort(). */
+ abort (); /* ARI: abort */
}
/* Dump core trying to increase the core soft limit to hard limit first. */
setrlimit (RLIMIT_CORE, &rlim);
#endif /* HAVE_SETRLIMIT */
- abort (); /* NOTE: GDB has only three calls to abort(). */
+ abort (); /* ARI: abort */
}
/* Check whether GDB will be able to dump core using the dump_core
/* Don't allow infinite error/warning recursion. */
{
- static char msg[] = "Recursive internal problem.\n";
+ static const char msg[] = "Recursive internal problem.\n";
switch (dejavu)
{
does not fix this problem. This is the solution suggested
at http://gcc.gnu.org/bugzilla/show_bug.cgi?id=25509. */
if (write (STDERR_FILENO, msg, sizeof (msg)) != sizeof (msg))
- abort (); /* NOTE: GDB has only three calls to abort(). */
+ abort (); /* ARI: abort */
exit (1);
}
}
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,
static std::string
perror_string (const char *prefix)
{
- char *err;
-
- err = safe_strerror (errno);
+ const char *err = safe_strerror (errno);
return std::string (prefix) + ": " + err;
}
void
print_sys_errmsg (const char *string, int errcode)
{
- char *err;
- char *combined;
-
- err = safe_strerror (errcode);
- combined = (char *) alloca (strlen (err) + strlen (string) + 3);
- strcpy (combined, string);
- strcat (combined, ": ");
- strcat (combined, err);
-
+ const char *err = safe_strerror (errcode);
/* We want anything which was printed on stdout to come out first, before
this message. */
gdb_flush (gdb_stdout);
- fprintf_unfiltered (gdb_stderr, "%s.\n", combined);
+ fprintf_unfiltered (gdb_stderr, "%s: %s.\n", string, err);
}
/* Control C eventually causes this to be called, at a convenient time. */
quit ();
quit_handler ();
-
- if (deprecated_interactive_hook)
- deprecated_interactive_hook ();
}
\f
fprintf_filtered (stream, "%s", host_address_to_string (addr));
}
-/* See utils.h. */
-
-char *
-make_hex_string (const gdb_byte *data, size_t length)
-{
- char *result = (char *) xmalloc (length * 2 + 1);
- char *p;
- size_t i;
-
- p = result;
- for (i = 0; i < length; ++i)
- p += xsnprintf (p, 3, "%02x", data[i]);
- *p = '\0';
- return result;
-}
-
\f
/* An RAII class that sets up to handle input and then tears down
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;
}
the end of the line, we spit out a newline, the indent, and then
the buffered output. */
-/* Malloc'd buffer with chars_per_line+2 bytes. Contains characters which
- are waiting to be output (they have already been counted in chars_printed).
- When wrap_buffer[0] is null, the buffer is empty. */
-static char *wrap_buffer;
+static bool filter_initialized = false;
-/* Pointer in wrap_buffer to the next character to fill. */
-static char *wrap_pointer;
+/* Contains characters which are waiting to be output (they have
+ already been counted in chars_printed). */
+static std::string wrap_buffer;
/* String to indent by if the wrap occurs. Must not be NULL if wrap_column
is non-zero. */
/* Column number on the screen where wrap_buffer begins, or 0 if wrapping
is not in effect. */
static int wrap_column;
+
+/* The style applied at the time that wrap_here was called. */
+static ui_file_style wrap_style;
\f
/* Initialize the number of lines per page and chars per line. */
|| getenv ("EMACS") || getenv ("INSIDE_EMACS"))
{
/* The number of lines per page is not mentioned in the terminal
- description or EMACS evironment variable is set. This probably
+ description or EMACS environment variable is set. This probably
means that paging is not useful, so disable paging. */
lines_per_page = UINT_MAX;
}
int
filtered_printing_initialized (void)
{
- return wrap_buffer != NULL;
+ return filter_initialized;
}
set_batch_flag_and_restore_page_info::set_batch_flag_and_restore_page_info ()
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 specified 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 (cols <= 0)
- cols = INT_MAX;
+ if (rows <= 0 || rows > sqrt_int_max)
+ {
+ rows = sqrt_int_max;
+ lines_per_page = UINT_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);
}
-/* Reinitialize WRAP_BUFFER according to the current value of
- CHARS_PER_LINE. */
+/* Reinitialize WRAP_BUFFER. */
static void
set_width (void)
if (chars_per_line == 0)
init_page_info ();
- if (!wrap_buffer)
- {
- wrap_buffer = (char *) xmalloc (chars_per_line + 2);
- wrap_buffer[0] = '\0';
- }
- else
- wrap_buffer = (char *) xrealloc (wrap_buffer, chars_per_line + 2);
- wrap_pointer = wrap_buffer; /* Start it at the beginning. */
+ wrap_buffer.clear ();
+ filter_initialized = true;
}
static void
set_width ();
}
+/* The currently applied style. */
+
+static ui_file_style applied_style;
+
+/* Emit an ANSI style escape for STYLE. If STREAM is nullptr, emit to
+ the wrap buffer; otherwise emit to STREAM. */
+
+static void
+emit_style_escape (const ui_file_style &style,
+ struct ui_file *stream = nullptr)
+{
+ applied_style = style;
+
+ if (stream == nullptr)
+ wrap_buffer.append (style.to_ansi ());
+ else
+ fputs_unfiltered (style.to_ansi ().c_str (), stream);
+}
+
+/* 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 (!stream->can_emit_style_escape ())
+ return;
+
+ /* Note that we may not pass STREAM here, when we want to emit to
+ the wrap buffer, not directly to STREAM. */
+ if (stream == gdb_stdout)
+ stream = nullptr;
+ emit_style_escape (style, stream);
+}
+
+/* See utils.h. */
+
+void
+reset_terminal_style (struct ui_file *stream)
+{
+ if (stream->can_emit_style_escape ())
+ {
+ /* Force the setting, regardless of what we think the setting
+ might already be. */
+ applied_style = ui_file_style ();
+ wrap_buffer.append (applied_style.to_ansi ());
+ }
+}
+
/* Wait, so the user can read what's on the screen. Prompt the user
to continue by pressing RETURN. 'q' is also provided because
telling users what to do in the prompt is more user-friendly than
steady_clock::time_point prompt_started = steady_clock::now ();
bool disable_pagination = pagination_disabled_for_command;
+ /* Clear the current styling. */
+ if (gdb_stdout->can_emit_style_escape ())
+ emit_style_escape (ui_file_style (), gdb_stdout);
+
if (annotation_level > 1)
printf_unfiltered (("\n\032\032pre-prompt-for-continue\n"));
pagination_disabled_for_command = false;
}
+/* Flush the wrap buffer to STREAM, if necessary. */
+
+static void
+flush_wrap_buffer (struct ui_file *stream)
+{
+ if (stream == gdb_stdout && !wrap_buffer.empty ())
+ {
+ fputs_unfiltered (wrap_buffer.c_str (), stream);
+ wrap_buffer.clear ();
+ }
+}
+
/* Indicate that if the next sequence of characters overflows the line,
a newline should be inserted here rather than when it hits the end.
If INDENT is non-null, it is a string to be printed to indent the
wrap_here (const char *indent)
{
/* This should have been allocated, but be paranoid anyway. */
- if (!wrap_buffer)
+ if (!filter_initialized)
internal_error (__FILE__, __LINE__,
_("failed internal consistency check"));
- if (wrap_buffer[0])
- {
- *wrap_pointer = '\0';
- fputs_unfiltered (wrap_buffer, gdb_stdout);
- }
- wrap_pointer = wrap_buffer;
- wrap_buffer[0] = '\0';
+ flush_wrap_buffer (gdb_stdout);
if (chars_per_line == UINT_MAX) /* No line overflow checking. */
{
wrap_column = 0;
wrap_indent = "";
else
wrap_indent = indent;
+ wrap_style = applied_style;
}
}
|| top_level_interpreter () == NULL
|| top_level_interpreter ()->interp_ui_out ()->is_mi_like_p ())
{
+ flush_wrap_buffer (stream);
fputs_unfiltered (linebuffer, stream);
return;
}
+ auto buffer_clearer
+ = make_scope_exit ([&] ()
+ {
+ wrap_buffer.clear ();
+ wrap_column = 0;
+ wrap_indent = "";
+ });
+
/* Go through and output each character. Show line extension
when this is necessary; prompt user for new page when this is
necessary. */
while (*lineptr && *lineptr != '\n')
{
+ int skip_bytes;
+
/* Print a single line. */
if (*lineptr == '\t')
{
- if (wrap_column)
- *wrap_pointer++ = '\t';
- else
- fputc_unfiltered ('\t', stream);
+ wrap_buffer.push_back ('\t');
/* Shifting right by 3 produces the number of tab stops
we have already passed, and then adding one and
shifting left 3 advances to the next tab stop. */
chars_printed = ((chars_printed >> 3) + 1) << 3;
lineptr++;
}
+ else if (*lineptr == '\033'
+ && skip_ansi_escape (lineptr, &skip_bytes))
+ {
+ wrap_buffer.append (lineptr, skip_bytes);
+ /* Note that we don't consider this a character, so we
+ don't increment chars_printed here. */
+ lineptr += skip_bytes;
+ }
else
{
- if (wrap_column)
- *wrap_pointer++ = *lineptr;
- else
- fputc_unfiltered (*lineptr, stream);
+ wrap_buffer.push_back (*lineptr);
chars_printed++;
lineptr++;
}
{
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 we aren't actually wrapping, don't output newline --
- if chars_per_line is right, we probably just overflowed
- anyway; if it's wrong, let us keep going. */
if (wrap_column)
- fputc_unfiltered ('\n', 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
+ probably just overflowed anyway; if it's wrong,
+ let us keep going. */
+ fputc_unfiltered ('\n', stream);
+ }
+ else
+ {
+ 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);
- *wrap_pointer = '\0'; /* Null-terminate saved stuff, */
- fputs_unfiltered (wrap_buffer, stream); /* and eject it. */
+ 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
if we are printing a long string. */
chars_printed = strlen (wrap_indent)
+ (save_chars - wrap_column);
- wrap_pointer = wrap_buffer; /* Reset buffer */
- wrap_buffer[0] = '\0';
wrap_column = 0; /* And disable fancy wrap */
}
+ else if (did_paginate && stream->can_emit_style_escape ())
+ emit_style_escape (save_style, stream);
}
}
lineptr++;
}
}
+
+ buffer_clearer.release ();
}
void
fputs_maybe_filtered (linebuffer, stream, 1);
}
+/* See utils.h. */
+
+void
+fputs_styled (const char *linebuffer, const ui_file_style &style,
+ struct ui_file *stream)
+{
+ /* This just makes it so we emit somewhat fewer escape
+ sequences. */
+ if (style.is_default ())
+ fputs_maybe_filtered (linebuffer, stream, 1);
+ else
+ {
+ set_output_style (stream, style);
+ fputs_maybe_filtered (linebuffer, stream, 1);
+ set_output_style (stream, ui_file_style ());
+ }
+}
+
+/* See utils.h. */
+
+void
+fputs_styled_unfiltered (const char *linebuffer, const ui_file_style &style,
+ struct ui_file *stream)
+{
+ /* This just makes it so we emit somewhat fewer escape
+ sequences. */
+ if (style.is_default ())
+ fputs_maybe_filtered (linebuffer, stream, 0);
+ else
+ {
+ set_output_style (stream, style);
+ fputs_maybe_filtered (linebuffer, stream, 0);
+ set_output_style (stream, ui_file_style ());
+ }
+}
+
+/* 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)
{
/* Print a variable number of ARGS using format FORMAT. If this
information is going to put the amount written (since the last call
to REINITIALIZE_MORE_FILTER or the last page break) over the page size,
- call prompt_for_continue to get the users permision to continue.
+ call prompt_for_continue to get the users permission to continue.
Unlike fprintf, this function does not return a value.
We implement three variants, vfprintf (takes a vararg list and stream),
fprintf (takes a stream to write on), and printf (the usual).
- Note also that a longjmp to top level may occur in this routine
- (since prompt_for_continue may do so) so this routine should not be
- called when cleanups are not in place. */
+ Note also that this may throw a quit (since prompt_for_continue may
+ do so). */
static void
vfprintf_maybe_filtered (struct ui_file *stream, const char *format,
- va_list args, int filter)
+ va_list args, bool filter, bool gdbfmt)
{
- std::string linebuffer = string_vprintf (format, args);
- fputs_maybe_filtered (linebuffer.c_str (), stream, filter);
+ if (gdbfmt)
+ {
+ ui_out_flags flags = disallow_ui_out_field;
+ if (!filter)
+ flags |= unfiltered_output;
+ cli_ui_out (stream, flags).vmessage (applied_style, format, args);
+ }
+ else
+ {
+ std::string str = string_vprintf (format, args);
+ fputs_maybe_filtered (str.c_str (), stream, filter);
+ }
}
void
vfprintf_filtered (struct ui_file *stream, const char *format, va_list args)
{
- vfprintf_maybe_filtered (stream, format, args, 1);
+ vfprintf_maybe_filtered (stream, format, args, true, true);
}
void
vfprintf_unfiltered (struct ui_file *stream, const char *format, va_list args)
{
- std::string linebuffer = string_vprintf (format, args);
if (debug_timestamp && stream == gdb_stdlog)
{
using namespace std::chrono;
int len, need_nl;
+ string_file sfile;
+ cli_ui_out (&sfile, 0).vmessage (ui_file_style (), format, args);
+ std::string linebuffer = std::move (sfile.string ());
+
steady_clock::time_point now = steady_clock::now ();
seconds s = duration_cast<seconds> (now.time_since_epoch ());
microseconds us = duration_cast<microseconds> (now.time_since_epoch () - s);
fputs_unfiltered (timestamp.c_str (), stream);
}
else
- fputs_unfiltered (linebuffer.c_str (), stream);
+ vfprintf_maybe_filtered (stream, format, args, false, true);
}
void
vprintf_filtered (const char *format, va_list args)
{
- vfprintf_maybe_filtered (gdb_stdout, format, args, 1);
+ vfprintf_maybe_filtered (gdb_stdout, format, args, true, false);
}
void
va_end (args);
}
+/* See utils.h. */
+
+void
+fprintf_styled (struct ui_file *stream, const ui_file_style &style,
+ const char *format, ...)
+{
+ va_list args;
+
+ set_output_style (stream, style);
+ va_start (args, format);
+ vfprintf_filtered (stream, format, args);
+ va_end (args);
+ set_output_style (stream, ui_file_style ());
+}
+
+/* See utils.h. */
+
+void
+vfprintf_styled (struct ui_file *stream, const ui_file_style &style,
+ const char *format, va_list args)
+{
+ set_output_style (stream, style);
+ vfprintf_filtered (stream, format, args);
+ set_output_style (stream, ui_file_style ());
+}
+
+/* See utils.h. */
+
+void
+vfprintf_styled_no_gdbfmt (struct ui_file *stream, const ui_file_style &style,
+ bool filter, const char *format, va_list args)
+{
+ std::string str = string_vprintf (format, args);
+ if (!str.empty ())
+ {
+ if (!style.is_default ())
+ set_output_style (stream, style);
+ fputs_maybe_filtered (str.c_str (), stream, filter);
+ if (!style.is_default ())
+ set_output_style (stream, ui_file_style ());
+ }
+}
void
printf_filtered (const char *format, ...)
{
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));
}
\f
-void
-initialize_utils (void)
-{
- add_setshow_uinteger_cmd ("width", class_support, &chars_per_line, _("\
-Set number of characters where GDB should wrap lines of its output."), _("\
-Show number of characters where GDB should wrap lines of its output."), _("\
-This affects where GDB wraps its output to fit the screen width.\n\
-Setting this to \"unlimited\" or zero prevents GDB from wrapping its output."),
- set_width_command,
- show_chars_per_line,
- &setlist, &showlist);
-
- add_setshow_uinteger_cmd ("height", class_support, &lines_per_page, _("\
-Set number of lines in a page for GDB output pagination."), _("\
-Show number of lines in a page for GDB output pagination."), _("\
-This affects the number of lines after which GDB will pause\n\
-its output and ask you whether to continue.\n\
-Setting this to \"unlimited\" or zero causes GDB never pause during output."),
- set_height_command,
- show_lines_per_page,
- &setlist, &showlist);
-
- add_setshow_boolean_cmd ("pagination", class_support,
- &pagination_enabled, _("\
-Set state of GDB output pagination."), _("\
-Show state of GDB output pagination."), _("\
-When pagination is ON, GDB pauses at end of each screenful of\n\
-its output and asks you whether to continue.\n\
-Turning pagination off is an alternative to \"set height unlimited\"."),
- NULL,
- show_pagination_enabled,
- &setlist, &showlist);
-
- add_setshow_boolean_cmd ("sevenbit-strings", class_support,
- &sevenbit_strings, _("\
-Set printing of 8-bit characters in strings as \\nnn."), _("\
-Show printing of 8-bit characters in strings as \\nnn."), NULL,
- NULL,
- show_sevenbit_strings,
- &setprintlist, &showprintlist);
-
- add_setshow_boolean_cmd ("timestamp", class_maintenance,
- &debug_timestamp, _("\
-Set timestamping of debugging messages."), _("\
-Show timestamping of debugging messages."), _("\
-When set, debugging messages will be marked with seconds and microseconds."),
- NULL,
- show_debug_timestamp,
- &setdebuglist, &showdebuglist);
-}
-
/* See utils.h. */
CORE_ADDR
{
char **argv = buildargv (s);
- if (s != NULL && argv == NULL)
- malloc_failure (0);
-
freeargv (m_argv);
m_argv = argv;
}
-int
-compare_positive_ints (const void *ap, const void *bp)
-{
- /* Because we know we're comparing two ints which are positive,
- there's no danger of overflow here. */
- return * (int *) ap - * (int *) bp;
-}
-
#define AMBIGUOUS_MESS1 ".\nMatching formats:"
#define AMBIGUOUS_MESS2 \
".\nUse \"set gnutarget format-name\" to specify the format."
return pid;
}
-/* Helper for make_bpstat_clear_actions_cleanup. */
-
-static void
-do_bpstat_clear_actions_cleanup (void *unused)
-{
- bpstat_clear_actions ();
-}
-
-/* Call bpstat_clear_actions for the case an exception is throw. You should
- discard_cleanups if no exception is caught. */
-
-struct cleanup *
-make_bpstat_clear_actions_cleanup (void)
-{
- return make_cleanup (do_bpstat_clear_actions_cleanup, NULL);
-}
-
-/* Substitute all occurences of string FROM by string TO in *STRINGP. *STRINGP
+/* Substitute all occurrences of string FROM by string TO in *STRINGP. *STRINGP
must come from xrealloc-compatible allocator and it may be updated. FROM
needs to be delimited by IS_DIR_SEPARATOR or DIRNAME_SEPARATOR (or be
located at the start or end of *STRINGP. */
void
_initialize_utils (void)
{
+ add_setshow_uinteger_cmd ("width", class_support, &chars_per_line, _("\
+Set number of characters where GDB should wrap lines of its output."), _("\
+Show number of characters where GDB should wrap lines of its output."), _("\
+This affects where GDB wraps its output to fit the screen width.\n\
+Setting this to \"unlimited\" or zero prevents GDB from wrapping its output."),
+ set_width_command,
+ show_chars_per_line,
+ &setlist, &showlist);
+
+ add_setshow_uinteger_cmd ("height", class_support, &lines_per_page, _("\
+Set number of lines in a page for GDB output pagination."), _("\
+Show number of lines in a page for GDB output pagination."), _("\
+This affects the number of lines after which GDB will pause\n\
+its output and ask you whether to continue.\n\
+Setting this to \"unlimited\" or zero causes GDB never pause during output."),
+ set_height_command,
+ show_lines_per_page,
+ &setlist, &showlist);
+
+ add_setshow_boolean_cmd ("pagination", class_support,
+ &pagination_enabled, _("\
+Set state of GDB output pagination."), _("\
+Show state of GDB output pagination."), _("\
+When pagination is ON, GDB pauses at end of each screenful of\n\
+its output and asks you whether to continue.\n\
+Turning pagination off is an alternative to \"set height unlimited\"."),
+ NULL,
+ show_pagination_enabled,
+ &setlist, &showlist);
+
+ add_setshow_boolean_cmd ("sevenbit-strings", class_support,
+ &sevenbit_strings, _("\
+Set printing of 8-bit characters in strings as \\nnn."), _("\
+Show printing of 8-bit characters in strings as \\nnn."), NULL,
+ NULL,
+ show_sevenbit_strings,
+ &setprintlist, &showprintlist);
+
+ add_setshow_boolean_cmd ("timestamp", class_maintenance,
+ &debug_timestamp, _("\
+Set timestamping of debugging messages."), _("\
+Show timestamping of debugging messages."), _("\
+When set, debugging messages will be marked with seconds and microseconds."),
+ NULL,
+ show_debug_timestamp,
+ &setdebuglist, &showdebuglist);
+
add_internal_problem_command (&internal_error_problem);
add_internal_problem_command (&internal_warning_problem);
add_internal_problem_command (&demangler_warning_problem);
projects / deliverable / binutils-gdb.git / blobdiff