/* General utility routines for GDB, the GNU debugger.
- Copyright (C) 1986-2018 Free Software Foundation, Inc.
+ Copyright (C) 1986-2020 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>
-
-#if !HAVE_DECL_MALLOC
-extern PTR malloc (); /* ARI: PTR */
-#endif
-#if !HAVE_DECL_REALLOC
-extern PTR realloc (); /* ARI: PTR */
-#endif
-#if !HAVE_DECL_FREE
-extern void free ();
-#endif
+#include "gdbsupport/pathstuff.h"
+#include "cli/cli-style.h"
+#include "gdbsupport/scope-exit.h"
+#include "gdbarch.h"
+#include "cli-out.h"
+#include "gdbsupport/gdb-safe-ctype.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". */
-
-static void
-do_free_section_addr_info (void *arg)
-{
- free_section_addr_info ((struct section_addr_info *) arg);
-}
-
-struct cleanup *
-make_cleanup_free_section_addr_info (struct section_addr_info *addrs)
-{
- return make_cleanup (do_free_section_addr_info, addrs);
-}
-
-/* Helper for make_cleanup_unpush_target. */
-
-static void
-do_unpush_target (void *arg)
-{
- struct target_ops *ops = (struct target_ops *) arg;
-
- unpush_target (ops);
-}
-
-/* Return a new cleanup that unpushes OPS. */
-
-struct cleanup *
-make_cleanup_unpush_target (struct target_ops *ops)
-{
- return make_cleanup (do_unpush_target, ops);
-}
-
-/* Helper for make_cleanup_value_free_to_mark. */
-
-static void
-do_value_free_to_mark (void *value)
-{
- value_free_to_mark ((struct value *) value);
-}
-
-/* Free all values allocated since MARK was obtained by value_mark
- (except for those released) when the cleanup is run. */
-
-struct cleanup *
-make_cleanup_value_free_to_mark (struct value *mark)
-{
- return make_cleanup (do_value_free_to_mark, mark);
-}
-
-/* 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. */
dump_core (void)
{
#ifdef HAVE_SETRLIMIT
- struct rlimit rlim = { RLIM_INFINITY, RLIM_INFINITY };
+ struct rlimit rlim = { (rlim_t) RLIM_INFINITY, (rlim_t) RLIM_INFINITY };
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
case LIMIT_CUR:
if (rlim.rlim_cur == 0)
return 0;
+ /* Fall through. */
case LIMIT_MAX:
if (rlim.rlim_max == 0)
/* Don't allow infinite error/warning recursion. */
{
- static char msg[] = "Recursive internal problem.\n";
+ static const char msg[] = "Recursive internal problem.\n";
switch (dejavu)
{
abort_with_message (msg);
default:
dejavu = 3;
- /* Newer GLIBC versions put the warn_unused_result attribute
- on write, but this is one of those rare cases where
- ignoring the return value is correct. Casting to (void)
- does not fix this problem. This is the solution suggested
- at http://gcc.gnu.org/bugzilla/show_bug.cgi?id=25509. */
+ /* Newer GLIBC versions put the warn_unused_result attribute
+ on write, but this is one of those rare cases where
+ ignoring the return value is correct. Casting to (void)
+ 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 (!confirm || !filtered_printing_initialized ())
quit_p = 1;
else
- quit_p = query (_("%s\nQuit this debugging session? "),
+ quit_p = query (_("%s\nQuit this debugging session? "),
reason.c_str ());
}
else if (problem->should_quit == internal_problem_yes)
va_end (ap);
}
-/* Dummy functions to keep add_prefix_cmd happy. */
-
-static void
-set_internal_problem_cmd (const char *args, int from_tty)
-{
-}
-
-static void
-show_internal_problem_cmd (const char *args, int from_tty)
-{
-}
-
/* When GDB reports an internal problem (error or warning) it gives
the user the opportunity to quit GDB and/or create a core file of
the current debug session. This function registers a few commands
show_doc = xstrprintf (_("Show what GDB does when %s is detected."),
problem->name);
- add_prefix_cmd (problem->name,
- class_maintenance, set_internal_problem_cmd, set_doc,
- set_cmd_list,
- concat ("maintenance set ", problem->name, " ",
- (char *) NULL),
- 0/*allow-unknown*/, &maintenance_set_cmdlist);
+ add_basic_prefix_cmd (problem->name, class_maintenance, set_doc,
+ set_cmd_list,
+ concat ("maintenance set ", problem->name, " ",
+ (char *) NULL),
+ 0/*allow-unknown*/, &maintenance_set_cmdlist);
- add_prefix_cmd (problem->name,
- class_maintenance, show_internal_problem_cmd, show_doc,
- show_cmd_list,
- concat ("maintenance show ", problem->name, " ",
- (char *) NULL),
- 0/*allow-unknown*/, &maintenance_show_cmdlist);
+ add_show_prefix_cmd (problem->name, class_maintenance, show_doc,
+ show_cmd_list,
+ concat ("maintenance show ", problem->name, " ",
+ (char *) NULL),
+ 0/*allow-unknown*/, &maintenance_show_cmdlist);
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. */
#else
if (job_control
/* If there is no terminal switching for this target, then we can't
- possibly get screwed by the lack of job control. */
+ possibly get screwed by the lack of job control. */
|| !target_supports_terminal_ours ())
throw_quit ("Quit");
else
quit ();
quit_handler ();
-
- if (deprecated_interactive_hook)
- deprecated_interactive_hook ();
}
\f
}
}
+/* See common/errors.h. */
+
+void
+flush_streams ()
+{
+ gdb_stdout->flush ();
+ gdb_stderr->flush ();
+}
+
/* My replacement for the read system call.
Used like `read' but keeps going if `read' returns too soon. */
return orglen;
}
+/* See utils.h. */
+
+ULONGEST
+uinteger_pow (ULONGEST v1, LONGEST v2)
+{
+ if (v2 < 0)
+ {
+ if (v1 == 0)
+ error (_("Attempt to raise 0 to negative power."));
+ else
+ return 0;
+ }
+ else
+ {
+ /* The Russian Peasant's Algorithm. */
+ ULONGEST v;
+
+ v = 1;
+ for (;;)
+ {
+ if (v2 & 1L)
+ v *= v1;
+ v2 >>= 1;
+ if (v2 == 0)
+ return v;
+ v1 *= v1;
+ }
+ }
+}
+
void
print_spaces (int n, struct ui_file *file)
{
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;
}
if (answer >= 'a')
answer -= 040;
/* Check answer. For the non-default, the user must specify
- the non-default explicitly. */
+ the non-default explicitly. */
if (answer == not_def_answer)
{
retval = !def_value;
break;
}
/* Otherwise, if a default was specified, the user may either
- specify the required input or have it default by entering
- nothing. */
+ specify the required input or have it default by entering
+ nothing. */
if (answer == def_answer
|| (defchar != '\0' && answer == '\0'))
{
while (++count < 3)
{
c = (**string_ptr);
- if (isdigit (c) && c != '8' && c != '9')
+ if (ISDIGIT (c) && c != '8' && c != '9')
{
(*string_ptr)++;
i *= 8;
character. */
static void
-printchar (int c, void (*do_fputs) (const char *, struct ui_file *),
- void (*do_fprintf) (struct ui_file *, const char *, ...)
- ATTRIBUTE_FPTR_PRINTF_2, struct ui_file *stream, int quoter)
+printchar (int c, do_fputc_ftype do_fputc, ui_file *stream, int quoter)
{
c &= 0xFF; /* Avoid sign bit follies */
(c >= 0x7F && c < 0xA0) || /* DEL, High controls */
(sevenbit_strings && c >= 0x80))
{ /* high order bit set */
+ do_fputc ('\\', stream);
+
switch (c)
{
case '\n':
- do_fputs ("\\n", stream);
+ do_fputc ('n', stream);
break;
case '\b':
- do_fputs ("\\b", stream);
+ do_fputc ('b', stream);
break;
case '\t':
- do_fputs ("\\t", stream);
+ do_fputc ('t', stream);
break;
case '\f':
- do_fputs ("\\f", stream);
+ do_fputc ('f', stream);
break;
case '\r':
- do_fputs ("\\r", stream);
+ do_fputc ('r', stream);
break;
case '\033':
- do_fputs ("\\e", stream);
+ do_fputc ('e', stream);
break;
case '\007':
- do_fputs ("\\a", stream);
+ do_fputc ('a', stream);
break;
default:
- do_fprintf (stream, "\\%.3o", (unsigned int) c);
- break;
+ {
+ do_fputc ('0' + ((c >> 6) & 0x7), stream);
+ do_fputc ('0' + ((c >> 3) & 0x7), stream);
+ do_fputc ('0' + ((c >> 0) & 0x7), stream);
+ break;
+ }
}
}
else
{
if (quoter != 0 && (c == '\\' || c == quoter))
- do_fputs ("\\", stream);
- do_fprintf (stream, "%c", c);
+ do_fputc ('\\', stream);
+ do_fputc (c, stream);
}
}
fputstr_filtered (const char *str, int quoter, struct ui_file *stream)
{
while (*str)
- printchar (*str++, fputs_filtered, fprintf_filtered, stream, quoter);
+ printchar (*str++, fputc_filtered, stream, quoter);
}
void
fputstr_unfiltered (const char *str, int quoter, struct ui_file *stream)
{
while (*str)
- printchar (*str++, fputs_unfiltered, fprintf_unfiltered, stream, quoter);
+ printchar (*str++, fputc_unfiltered, stream, quoter);
}
void
fputstrn_filtered (const char *str, int n, int quoter,
struct ui_file *stream)
{
- int i;
-
- for (i = 0; i < n; i++)
- printchar (str[i], fputs_filtered, fprintf_filtered, stream, quoter);
+ for (int i = 0; i < n; i++)
+ printchar (str[i], fputc_filtered, stream, quoter);
}
void
fputstrn_unfiltered (const char *str, int n, int quoter,
- struct ui_file *stream)
+ do_fputc_ftype do_fputc, struct ui_file *stream)
{
- int i;
-
- for (i = 0; i < n; i++)
- printchar (str[i], fputs_unfiltered, fprintf_unfiltered, stream, quoter);
+ for (int i = 0; i < n; i++)
+ printchar (str[i], do_fputc, stream, quoter);
}
\f
/* Current count of lines printed on this page, chars on this line. */
static unsigned int lines_printed, chars_printed;
+/* True if pagination is disabled for just one command. */
+
+static bool pagination_disabled_for_command;
+
/* Buffer and start column of buffered text, for doing smarter word-
wrapping. When someone calls wrap_here(), we start buffering output
that comes through fputs_filtered(). If we see a newline, we just
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. */
chars_per_line = cols;
/* Readline should have fetched the termcap entry for us.
- Only try to use tgetnum function if rl_get_screen_size
- did not return a useful value. */
+ Only try to use tgetnum function if rl_get_screen_size
+ did not return a useful value. */
if (((rows <= 0) && (tgetnum ((char *) "li") < 0))
/* Also disable paging if inside Emacs. $EMACS was used
before Emacs v25.1, $INSIDE_EMACS is used since then. */
|| 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;
}
/* If the output is not a terminal, don't paginate it. */
- if (!ui_file_isatty (gdb_stdout))
+ if (!gdb_stdout->isatty ())
lines_per_page = UINT_MAX;
#endif
}
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.
- if (cols <= 0)
- cols = INT_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 > 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
+ stream->puts (style.to_ansi ().c_str ());
+}
+
+/* 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
static void
prompt_for_continue (void)
{
- char *ignore;
char cont_prompt[120];
- struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
/* Used to add duration we waited for user to respond to
prompt_for_continue_wait_time. */
using namespace std::chrono;
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"));
strcpy (cont_prompt,
- "---Type <return> to continue, or q <return> to quit---");
+ "--Type <RET> for more, q to quit, "
+ "c to continue without paging--");
if (annotation_level > 1)
strcat (cont_prompt, "\n\032\032prompt-for-continue\n");
/* Call gdb_readline_wrapper, not readline, in order to keep an
event loop running. */
- ignore = gdb_readline_wrapper (cont_prompt);
- make_cleanup (xfree, ignore);
+ gdb::unique_xmalloc_ptr<char> ignore (gdb_readline_wrapper (cont_prompt));
/* Add time spend in this routine to prompt_for_continue_wait_time. */
prompt_for_continue_wait_time += steady_clock::now () - prompt_started;
if (ignore != NULL)
{
- char *p = ignore;
+ char *p = ignore.get ();
while (*p == ' ' || *p == '\t')
++p;
if (p[0] == 'q')
/* Do not call quit here; there is no possibility of SIGINT. */
throw_quit ("Quit");
+ if (p[0] == 'c')
+ disable_pagination = true;
}
/* Now we have to do this again, so that GDB will know that it doesn't
need to save the ---Type <return>--- line at the top of the screen. */
reinitialize_more_filter ();
+ pagination_disabled_for_command = disable_pagination;
dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
-
- do_cleanups (old_chain);
}
/* Initialize timer to keep track of how long we waited for the user. */
{
lines_printed = 0;
chars_printed = 0;
+ 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 ())
+ {
+ stream->puts (wrap_buffer.c_str ());
+ wrap_buffer.clear ();
+ }
+}
+
+/* See utils.h. */
+
+void
+gdb_flush (struct ui_file *stream)
+{
+ flush_wrap_buffer (stream);
+ stream->flush ();
}
/* Indicate that if the next sequence of characters overflows the line,
wrap_here (const char *indent)
{
/* This should have been allocated, but be paranoid anyway. */
- if (!wrap_buffer)
- internal_error (__FILE__, __LINE__,
- _("failed internal consistency check"));
+ gdb_assert (filter_initialized);
- 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;
}
}
/* Don't do any filtering if it is disabled. */
if (stream != gdb_stdout
|| !pagination_enabled
+ || pagination_disabled_for_command
|| batch_flag
|| (lines_per_page == UINT_MAX && chars_per_line == UINT_MAX)
|| top_level_interpreter () == NULL
- || interp_ui_out (top_level_interpreter ())->is_mi_like_p ())
+ || top_level_interpreter ()->interp_ui_out ()->is_mi_like_p ())
{
- fputs_unfiltered (linebuffer, stream);
+ flush_wrap_buffer (stream);
+ stream->puts (linebuffer);
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. */
lineptr = linebuffer;
while (*lineptr)
{
- /* Possible new page. */
- if (filter && (lines_printed >= lines_per_page - 1))
+ /* Possible new page. Note that PAGINATION_DISABLED_FOR_COMMAND
+ might be set during this loop, so we must continue to check
+ it here. */
+ if (filter && (lines_printed >= lines_per_page - 1)
+ && !pagination_disabled_for_command)
prompt_for_continue ();
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. */
+ 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. */
+ /* XXX: The ideal thing would be to call
+ 'stream->putc' here, but we can't because it
+ currently calls 'fputc_unfiltered', which ends up
+ calling us, which generates an infinite
+ recursion. */
+ stream->puts ("\n");
+ }
+ else
+ {
+ save_style = applied_style;
+ flush_wrap_buffer (stream);
+ }
- /* Possible new page. */
- if (lines_printed >= lines_per_page - 1)
- prompt_for_continue ();
+ /* 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 ();
+ 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. */
+ stream->puts (wrap_indent);
+ 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);
}
}
wrap_here ((char *) 0); /* Spit out chars, cancel
further wraps. */
lines_printed++;
- fputc_unfiltered ('\n', stream);
+ /* XXX: The ideal thing would be to call
+ 'stream->putc' here, but we can't because it
+ currently calls 'fputc_unfiltered', which ends up
+ calling us, which generates an infinite
+ recursion. */
+ stream->puts ("\n");
lineptr++;
}
}
+
+ buffer_clearer.release ();
}
void
fputs_maybe_filtered (linebuffer, stream, 1);
}
+void
+fputs_unfiltered (const char *linebuffer, struct ui_file *stream)
+{
+ fputs_maybe_filtered (linebuffer, stream, 0);
+}
+
+/* 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)
{
- char buf = c;
-
- ui_file_write (gdb_stdout, &buf, 1);
- return c;
+ return fputc_unfiltered (c, gdb_stdout);
}
/* Write character C to gdb_stdout using GDB's paging mechanism and return C.
int
fputc_unfiltered (int c, struct ui_file *stream)
{
- char buf = c;
+ char buf[2];
- ui_file_write (stream, &buf, 1);
+ buf[0] = c;
+ buf[1] = 0;
+ fputs_unfiltered (buf, stream);
return c;
}
switch (ch)
{
default:
- if (isprint (ch))
+ if (gdb_isprint (ch))
fputc_unfiltered (ch, gdb_stdlog);
else
/* 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, ...)
if (n > max_spaces)
{
- if (spaces)
- xfree (spaces);
+ xfree (spaces);
spaces = (char *) xmalloc (n + 1);
for (t = spaces + n; t != spaces;)
*--t = ' ';
static bool
valid_identifier_name_char (int ch)
{
- return (isalnum (ch) || ch == '_');
+ return (ISALNUM (ch) || ch == '_');
}
/* Skip to end of token, or to END, whatever comes first. Input is
cp_skip_operator_token (const char *token, const char *end)
{
const char *p = token;
- while (p != end && !isspace (*p) && *p != '(')
+ while (p != end && !ISSPACE (*p) && *p != '(')
{
if (valid_identifier_name_char (*p))
{
static void
skip_ws (const char *&string1, const char *&string2, const char *end_str2)
{
- while (isspace (*string1))
+ while (ISSPACE (*string1))
string1++;
- while (string2 < end_str2 && isspace (*string2))
+ while (string2 < end_str2 && ISSPACE (*string2))
string2++;
}
while (1)
{
if (skip_spaces
- || ((isspace (*string1) && !valid_identifier_name_char (*string2))
- || (isspace (*string2) && !valid_identifier_name_char (*string1))))
+ || ((ISSPACE (*string1) && !valid_identifier_name_char (*string2))
+ || (ISSPACE (*string2) && !valid_identifier_name_char (*string1))))
{
skip_ws (string1, string2, end_str2);
skip_spaces = false;
if (match_for_lcd != NULL && abi_start != string1)
match_for_lcd->mark_ignored_range (abi_start, string1);
- while (isspace (*string1))
+ while (ISSPACE (*string1))
string1++;
}
string1++;
string2++;
- while (isspace (*string1))
+ while (ISSPACE (*string1))
string1++;
- while (string2 < end_str2 && isspace (*string2))
+ while (string2 < end_str2 && ISSPACE (*string2))
string2++;
continue;
}
if (case_sensitivity == case_sensitive_on && *string1 != *string2)
break;
if (case_sensitivity == case_sensitive_off
- && (tolower ((unsigned char) *string1)
- != tolower ((unsigned char) *string2)))
+ && (TOLOWER ((unsigned char) *string1)
+ != TOLOWER ((unsigned char) *string2)))
break;
/* If we see any non-whitespace, non-identifier-name character
(any of "()<>*&" etc.), then skip spaces the next time
around. */
- if (!isspace (*string1) && !valid_identifier_name_char (*string1))
+ if (!ISSPACE (*string1) && !valid_identifier_name_char (*string1))
skip_spaces = true;
string1++;
while (*string1 != '\0' && *string2 != '\0')
{
- while (isspace (*string1))
+ while (ISSPACE (*string1))
string1++;
- while (isspace (*string2))
+ while (ISSPACE (*string2))
string2++;
switch (case_pass)
{
case case_sensitive_off:
- c1 = tolower ((unsigned char) *string1);
- c2 = tolower ((unsigned char) *string2);
+ c1 = TOLOWER ((unsigned char) *string1);
+ c2 = TOLOWER ((unsigned char) *string2);
break;
case case_sensitive_on:
c1 = *string1;
}
}
-/* A simple comparison function with opposite semantics to strcmp. */
+/* See utils.h. */
-int
+bool
streq (const char *lhs, const char *rhs)
{
return !strcmp (lhs, rhs);
}
+
+/* See utils.h. */
+
+int
+streq_hash (const void *lhs, const void *rhs)
+{
+ return streq ((const char *) lhs, (const char *) rhs);
+}
+
\f
/*
{
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
address_significant (gdbarch *gdbarch, CORE_ADDR addr)
{
- /* Truncate address to the significant bits of a target address,
- avoiding shifts larger or equal than the width of a CORE_ADDR.
- The local variable ADDR_BIT stops the compiler reporting a shift
- overflow when it won't occur. */
+ /* Clear insignificant bits of a target address and sign extend resulting
+ address, avoiding shifts larger or equal than the width of a CORE_ADDR.
+ The local variable ADDR_BIT stops the compiler reporting a shift overflow
+ when it won't occur. Skip updating of target address if current target
+ has not set gdbarch significant_addr_bit. */
int addr_bit = gdbarch_significant_addr_bit (gdbarch);
- if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
- addr &= ((CORE_ADDR) 1 << addr_bit) - 1;
+ if (addr_bit && (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT)))
+ {
+ CORE_ADDR sign = (CORE_ADDR) 1 << (addr_bit - 1);
+ addr &= ((CORE_ADDR) 1 << addr_bit) - 1;
+ addr = (addr ^ sign) - sign;
+ }
return addr;
}
{
CORE_ADDR addr = 0;
- if (my_string[0] == '0' && tolower (my_string[1]) == 'x')
+ if (my_string[0] == '0' && TOLOWER (my_string[1]) == 'x')
{
/* Assume that it is in hex. */
int i;
for (i = 2; my_string[i] != '\0'; i++)
{
- if (isdigit (my_string[i]))
+ if (ISDIGIT (my_string[i]))
addr = (my_string[i] - '0') + (addr * 16);
- else if (isxdigit (my_string[i]))
- addr = (tolower (my_string[i]) - 'a' + 0xa) + (addr * 16);
+ else if (ISXDIGIT (my_string[i]))
+ addr = (TOLOWER (my_string[i]) - 'a' + 0xa) + (addr * 16);
else
error (_("invalid hex \"%s\""), my_string);
}
for (i = 0; my_string[i] != '\0'; i++)
{
- if (isdigit (my_string[i]))
+ if (ISDIGIT (my_string[i]))
addr = (my_string[i] - '0') + (addr * 10);
else
error (_("invalid decimal \"%s\""), my_string);
return addr;
}
-gdb::unique_xmalloc_ptr<char>
-gdb_realpath (const char *filename)
-{
-/* On most hosts, we rely on canonicalize_file_name to compute
- the FILENAME's realpath.
-
- But the situation is slightly more complex on Windows, due to some
- versions of GCC which were reported to generate paths where
- backlashes (the directory separator) were doubled. For instance:
- c:\\some\\double\\slashes\\dir
- ... instead of ...
- c:\some\double\slashes\dir
- Those double-slashes were getting in the way when comparing paths,
- for instance when trying to insert a breakpoint as follow:
- (gdb) b c:/some/double/slashes/dir/foo.c:4
- No source file named c:/some/double/slashes/dir/foo.c:4.
- (gdb) b c:\some\double\slashes\dir\foo.c:4
- No source file named c:\some\double\slashes\dir\foo.c:4.
- To prevent this from happening, we need this function to always
- strip those extra backslashes. While canonicalize_file_name does
- perform this simplification, it only works when the path is valid.
- Since the simplification would be useful even if the path is not
- valid (one can always set a breakpoint on a file, even if the file
- does not exist locally), we rely instead on GetFullPathName to
- perform the canonicalization. */
-
-#if defined (_WIN32)
- {
- char buf[MAX_PATH];
- DWORD len = GetFullPathName (filename, MAX_PATH, buf, NULL);
-
- /* The file system is case-insensitive but case-preserving.
- So it is important we do not lowercase the path. Otherwise,
- we might not be able to display the original casing in a given
- path. */
- if (len > 0 && len < MAX_PATH)
- return gdb::unique_xmalloc_ptr<char> (xstrdup (buf));
- }
-#else
- {
- char *rp = canonicalize_file_name (filename);
-
- if (rp != NULL)
- return gdb::unique_xmalloc_ptr<char> (rp);
- }
-#endif
-
- /* This system is a lost cause, just dup the buffer. */
- return gdb::unique_xmalloc_ptr<char> (xstrdup (filename));
-}
-
#if GDB_SELF_TEST
static void
gdb_realpath_check_trailer ("", "");
}
-#endif /* GDB_SELF_TEST */
-
-/* Return a copy of FILENAME, with its directory prefix canonicalized
- by gdb_realpath. */
-
-gdb::unique_xmalloc_ptr<char>
-gdb_realpath_keepfile (const char *filename)
-{
- const char *base_name = lbasename (filename);
- char *dir_name;
- char *result;
-
- /* Extract the basename of filename, and return immediately
- a copy of filename if it does not contain any directory prefix. */
- if (base_name == filename)
- return gdb::unique_xmalloc_ptr<char> (xstrdup (filename));
-
- dir_name = (char *) alloca ((size_t) (base_name - filename + 2));
- /* Allocate enough space to store the dir_name + plus one extra
- character sometimes needed under Windows (see below), and
- then the closing \000 character. */
- strncpy (dir_name, filename, base_name - filename);
- dir_name[base_name - filename] = '\000';
-
-#ifdef HAVE_DOS_BASED_FILE_SYSTEM
- /* We need to be careful when filename is of the form 'd:foo', which
- is equivalent of d:./foo, which is totally different from d:/foo. */
- if (strlen (dir_name) == 2 && isalpha (dir_name[0]) && dir_name[1] == ':')
- {
- dir_name[2] = '.';
- dir_name[3] = '\000';
- }
-#endif
-
- /* Canonicalize the directory prefix, and build the resulting
- filename. If the dirname realpath already contains an ending
- directory separator, avoid doubling it. */
- gdb::unique_xmalloc_ptr<char> path_storage = gdb_realpath (dir_name);
- const char *real_path = path_storage.get ();
- if (IS_DIR_SEPARATOR (real_path[strlen (real_path) - 1]))
- result = concat (real_path, base_name, (char *) NULL);
- else
- result = concat (real_path, SLASH_STRING, base_name, (char *) NULL);
-
- return gdb::unique_xmalloc_ptr<char> (result);
-}
-
-/* Return PATH in absolute form, performing tilde-expansion if necessary.
- PATH cannot be NULL or the empty string.
- This does not resolve symlinks however, use gdb_realpath for that. */
+/* Test the gdb_argv::as_array_view method. */
-gdb::unique_xmalloc_ptr<char>
-gdb_abspath (const char *path)
+static void
+gdb_argv_as_array_view_test ()
{
- gdb_assert (path != NULL && path[0] != '\0');
+ {
+ gdb_argv argv;
- if (path[0] == '~')
- return gdb::unique_xmalloc_ptr<char> (tilde_expand (path));
+ gdb::array_view<char *> view = argv.as_array_view ();
- if (IS_ABSOLUTE_PATH (path))
- return gdb::unique_xmalloc_ptr<char> (xstrdup (path));
+ SELF_CHECK (view.data () == nullptr);
+ SELF_CHECK (view.size () == 0);
+ }
+ {
+ gdb_argv argv ("une bonne 50");
- /* Beware the // my son, the Emacs barfs, the botch that catch... */
- return gdb::unique_xmalloc_ptr<char>
- (concat (current_directory,
- IS_DIR_SEPARATOR (current_directory[strlen (current_directory) - 1])
- ? "" : SLASH_STRING,
- path, (char *) NULL));
-}
+ gdb::array_view<char *> view = argv.as_array_view ();
-ULONGEST
-align_up (ULONGEST v, int n)
-{
- /* Check that N is really a power of two. */
- gdb_assert (n && (n & (n-1)) == 0);
- return (v + n - 1) & -n;
+ SELF_CHECK (view.size () == 3);
+ SELF_CHECK (strcmp (view[0], "une") == 0);
+ SELF_CHECK (strcmp (view[1], "bonne") == 0);
+ SELF_CHECK (strcmp (view[2], "50") == 0);
+ }
}
-ULONGEST
-align_down (ULONGEST v, int n)
-{
- /* Check that N is really a power of two. */
- gdb_assert (n && (n & (n-1)) == 0);
- return (v & -n);
-}
+#endif /* GDB_SELF_TEST */
/* Allocation function for the libiberty hash table which uses an
obstack. The obstack is passed as DATA. */
{
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;
-}
-
-/* String compare function for qsort. */
-
-int
-compare_strings (const void *arg1, const void *arg2)
-{
- const char **s1 = (const char **) arg1;
- const char **s2 = (const char **) arg2;
-
- return strcmp (*s1, *s2);
-}
-
#define AMBIGUOUS_MESS1 ".\nMatching formats:"
#define AMBIGUOUS_MESS2 \
".\nUse \"set gnutarget format-name\" to specify the format."
-const char *
+std::string
gdb_bfd_errmsg (bfd_error_type error_tag, char **matching)
{
- char *ret, *retp;
- int ret_len;
char **p;
/* Check if errmsg just need simple return. */
if (error_tag != bfd_error_file_ambiguously_recognized || matching == NULL)
return bfd_errmsg (error_tag);
- ret_len = strlen (bfd_errmsg (error_tag)) + strlen (AMBIGUOUS_MESS1)
- + strlen (AMBIGUOUS_MESS2);
- for (p = matching; *p; p++)
- ret_len += strlen (*p) + 1;
- ret = (char *) xmalloc (ret_len + 1);
- retp = ret;
- make_cleanup (xfree, ret);
-
- strcpy (retp, bfd_errmsg (error_tag));
- retp += strlen (retp);
-
- strcpy (retp, AMBIGUOUS_MESS1);
- retp += strlen (retp);
+ std::string ret (bfd_errmsg (error_tag));
+ ret += AMBIGUOUS_MESS1;
for (p = matching; *p; p++)
{
- sprintf (retp, " %s", *p);
- retp += strlen (retp);
+ ret += " ";
+ ret += *p;
}
- xfree (matching);
+ ret += AMBIGUOUS_MESS2;
- strcpy (retp, AMBIGUOUS_MESS2);
+ xfree (matching);
return ret;
}
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);
-}
-
-
-/* Helper for make_cleanup_free_char_ptr_vec. */
-
-static void
-do_free_char_ptr_vec (void *arg)
-{
- VEC (char_ptr) *char_ptr_vec = (VEC (char_ptr) *) arg;
-
- free_char_ptr_vec (char_ptr_vec);
-}
-
-/* Make cleanup handler calling xfree for each element of CHAR_PTR_VEC and
- final VEC_free for CHAR_PTR_VEC itself.
-
- You must not modify CHAR_PTR_VEC after this cleanup registration as the
- CHAR_PTR_VEC base address may change on its updates. Contrary to VEC_free
- this function does not (cannot) clear the pointer. */
-
-struct cleanup *
-make_cleanup_free_char_ptr_vec (VEC (char_ptr) *char_ptr_vec)
-{
- return make_cleanup (do_free_char_ptr_vec, char_ptr_vec);
-}
-
-/* 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. */
if ((s == string || IS_DIR_SEPARATOR (s[-1])
|| s[-1] == DIRNAME_SEPARATOR)
- && (s[from_len] == '\0' || IS_DIR_SEPARATOR (s[from_len])
+ && (s[from_len] == '\0' || IS_DIR_SEPARATOR (s[from_len])
|| s[from_len] == DIRNAME_SEPARATOR))
{
char *string_new;
return p;
}
+/* See utils.h. */
+
+void
+copy_bitwise (gdb_byte *dest, ULONGEST dest_offset,
+ const gdb_byte *source, ULONGEST source_offset,
+ ULONGEST nbits, int bits_big_endian)
+{
+ unsigned int buf, avail;
+
+ if (nbits == 0)
+ return;
+
+ if (bits_big_endian)
+ {
+ /* Start from the end, then work backwards. */
+ dest_offset += nbits - 1;
+ dest += dest_offset / 8;
+ dest_offset = 7 - dest_offset % 8;
+ source_offset += nbits - 1;
+ source += source_offset / 8;
+ source_offset = 7 - source_offset % 8;
+ }
+ else
+ {
+ dest += dest_offset / 8;
+ dest_offset %= 8;
+ source += source_offset / 8;
+ source_offset %= 8;
+ }
+
+ /* Fill BUF with DEST_OFFSET bits from the destination and 8 -
+ SOURCE_OFFSET bits from the source. */
+ buf = *(bits_big_endian ? source-- : source++) >> source_offset;
+ buf <<= dest_offset;
+ buf |= *dest & ((1 << dest_offset) - 1);
+
+ /* NBITS: bits yet to be written; AVAIL: BUF's fill level. */
+ nbits += dest_offset;
+ avail = dest_offset + 8 - source_offset;
+
+ /* Flush 8 bits from BUF, if appropriate. */
+ if (nbits >= 8 && avail >= 8)
+ {
+ *(bits_big_endian ? dest-- : dest++) = buf;
+ buf >>= 8;
+ avail -= 8;
+ nbits -= 8;
+ }
+
+ /* Copy the middle part. */
+ if (nbits >= 8)
+ {
+ size_t len = nbits / 8;
+
+ /* Use a faster method for byte-aligned copies. */
+ if (avail == 0)
+ {
+ if (bits_big_endian)
+ {
+ dest -= len;
+ source -= len;
+ memcpy (dest + 1, source + 1, len);
+ }
+ else
+ {
+ memcpy (dest, source, len);
+ dest += len;
+ source += len;
+ }
+ }
+ else
+ {
+ while (len--)
+ {
+ buf |= *(bits_big_endian ? source-- : source++) << avail;
+ *(bits_big_endian ? dest-- : dest++) = buf;
+ buf >>= 8;
+ }
+ }
+ nbits %= 8;
+ }
+
+ /* Write the last byte. */
+ if (nbits)
+ {
+ if (avail < nbits)
+ buf |= *source << avail;
+
+ buf &= (1 << nbits) - 1;
+ *dest = (*dest & (~0U << nbits)) | buf;
+ }
+}
+
+void _initialize_utils ();
void
-_initialize_utils (void)
+_initialize_utils ()
{
+ 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);
#if GDB_SELF_TEST
selftests::register_test ("gdb_realpath", gdb_realpath_tests);
+ selftests::register_test ("gdb_argv_array_view", gdb_argv_as_array_view_test);
#endif
}