Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
- 2009, 2010 Free Software Foundation, Inc.
+ 2009, 2010, 2011 Free Software Foundation, Inc.
This file is part of GDB.
#include <pc.h>
#endif
-/* SunOS's curses.h has a '#define reg register' in it. Thank you Sun. */
+/* SunOS's curses.h has a '#define reg register' in it. Thank you Sun. */
#ifdef reg
#undef reg
#endif
#include "gdb_obstack.h"
#include "gdbcore.h"
#include "top.h"
+#include "main.h"
#include "inferior.h" /* for signed_pointer_to_address */
#include "gdb_usleep.h"
#include "interps.h"
+#include "gdb_regex.h"
#if !HAVE_DECL_MALLOC
extern PTR malloc (); /* ARI: PTR */
/* Prototypes for local functions */
static void vfprintf_maybe_filtered (struct ui_file *, const char *,
- va_list, int) ATTR_FORMAT (printf, 2, 0);
+ va_list, int) ATTRIBUTE_PRINTF (2, 0);
static void fputs_maybe_filtered (const char *, struct ui_file *, int);
static struct cleanup *cleanup_chain; /* cleaned up after a failed command */
static struct cleanup *final_cleanup_chain; /* cleaned up when gdb exits */
-/* Nonzero if we have job control. */
+/* Nonzero if we have job control. */
int job_control;
show_demangle (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file, _("\
-Demangling of encoded C++/ObjC names when displaying symbols is %s.\n"),
+ fprintf_filtered (file,
+ _("Demangling of encoded C++/ObjC names "
+ "when displaying symbols is %s.\n"),
value);
}
show_asm_demangle (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file, _("\
-Demangling of C++/ObjC names in disassembly listings is %s.\n"),
+ fprintf_filtered (file,
+ _("Demangling of C++/ObjC names in "
+ "disassembly listings is %s.\n"),
value);
}
show_sevenbit_strings (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file, _("\
-Printing of 8-bit characters in strings as \\nnn is %s.\n"),
+ fprintf_filtered (file, _("Printing of 8-bit characters "
+ "in strings as \\nnn is %s.\n"),
value);
}
do_close_cleanup (void *arg)
{
int *fd = arg;
+
close (*fd);
}
make_cleanup_close (int fd)
{
int *saved_fd = xmalloc (sizeof (fd));
+
*saved_fd = fd;
return make_cleanup_dtor (do_close_cleanup, saved_fd, xfree);
}
do_fclose_cleanup (void *arg)
{
FILE *file = arg;
- fclose (arg);
+
+ fclose (file);
}
/* Return a new cleanup that closes FILE. */
do_obstack_free (void *arg)
{
struct obstack *ob = arg;
+
obstack_free (ob, NULL);
}
return make_my_cleanup (&cleanup_chain, do_ui_file_delete, arg);
}
+/* Helper function for make_cleanup_ui_out_redirect_pop. */
+
+static void
+do_ui_out_redirect_pop (void *arg)
+{
+ struct ui_out *uiout = arg;
+
+ if (ui_out_redirect (uiout, NULL) < 0)
+ warning (_("Cannot restore redirection of the current output protocol"));
+}
+
+/* Return a new cleanup that pops the last redirection by ui_out_redirect
+ with NULL parameter. */
+
+struct cleanup *
+make_cleanup_ui_out_redirect_pop (struct ui_out *uiout)
+{
+ return make_my_cleanup (&cleanup_chain, do_ui_out_redirect_pop, uiout);
+}
+
static void
do_free_section_addr_info (void *arg)
{
restore_integer (void *p)
{
struct restore_integer_closure *closure = p;
+
*(closure->variable) = closure->value;
}
-/* Remember the current value of *VARIABLE and make it restored when the cleanup
- is run. */
+/* Remember the current value of *VARIABLE and make it restored when
+ the cleanup is run. */
+
struct cleanup *
make_cleanup_restore_integer (int *variable)
{
struct restore_integer_closure *c =
xmalloc (sizeof (struct restore_integer_closure));
+
c->variable = variable;
c->value = *variable;
xfree);
}
+/* Remember the current value of *VARIABLE and make it restored when
+ the cleanup is run. */
+
+struct cleanup *
+make_cleanup_restore_uinteger (unsigned int *variable)
+{
+ return make_cleanup_restore_integer ((int *) variable);
+}
+
+/* Helper for make_cleanup_unpush_target. */
+
+static void
+do_unpush_target (void *arg)
+{
+ struct target_ops *ops = arg;
+
+ unpush_target (ops);
+}
+
+/* Return a new cleanup that unpushes OPS. */
+
+struct cleanup *
+make_cleanup_unpush_target (struct target_ops *ops)
+{
+ return make_my_cleanup (&cleanup_chain, do_unpush_target, ops);
+}
+
+struct restore_ui_file_closure
+{
+ struct ui_file **variable;
+ struct ui_file *value;
+};
+
+static void
+do_restore_ui_file (void *p)
+{
+ struct restore_ui_file_closure *closure = p;
+
+ *(closure->variable) = closure->value;
+}
+
+/* Remember the current value of *VARIABLE and make it restored when
+ the cleanup is run. */
+
+struct cleanup *
+make_cleanup_restore_ui_file (struct ui_file **variable)
+{
+ struct restore_ui_file_closure *c = XNEW (struct restore_ui_file_closure);
+
+ c->variable = variable;
+ c->value = *variable;
+
+ return make_cleanup_dtor (do_restore_ui_file, (void *) c, xfree);
+}
+
struct cleanup *
make_my_cleanup2 (struct cleanup **pmy_chain, make_cleanup_ftype *function,
void *arg, void (*free_arg) (void *))
struct cleanup *old_chain)
{
struct cleanup *ptr;
+
while ((ptr = *pmy_chain) != old_chain)
{
- *pmy_chain = ptr->next; /* Do this first incase recursion */
+ *pmy_chain = ptr->next; /* Do this first in case of recursion. */
(*ptr->function) (ptr->arg);
if (ptr->free_arg)
(*ptr->free_arg) (ptr->arg);
struct cleanup *old_chain)
{
struct cleanup *ptr;
+
while ((ptr = *pmy_chain) != old_chain)
{
*pmy_chain = ptr->next;
free_current_contents (void *ptr)
{
void **location = ptr;
+
if (location == NULL)
internal_error (__FILE__, __LINE__,
_("free_current_contents: NULL pointer"));
use the cleanup chain for handling normal cleanups as well as dealing
with cleanups that need to be done as a result of a call to error().
In such cases, we may not be certain where the first cleanup is, unless
- we have a do-nothing one to always use as the base. */
+ we have a do-nothing one to always use as the base. */
void
null_cleanup (void *arg)
{
}
+/* If nonzero, display time usage both at startup and for each command. */
+
+static int display_time;
+
+/* If nonzero, display space usage both at startup and for each command. */
+
+static int display_space;
+
+/* Records a run time and space usage to be used as a base for
+ reporting elapsed time or change in space. In addition,
+ the msg_type field indicates whether the saved time is from the
+ beginning of GDB execution (0) or the beginning of an individual
+ command execution (1). */
+struct cmd_stats
+{
+ int msg_type;
+ long start_time;
+ long start_space;
+};
+
+/* Set whether to display time statistics to NEW_VALUE (non-zero
+ means true). */
+void
+set_display_time (int new_value)
+{
+ display_time = new_value;
+}
+
+/* Set whether to display space statistics to NEW_VALUE (non-zero
+ means true). */
+void
+set_display_space (int new_value)
+{
+ display_space = new_value;
+}
+
+/* As indicated by display_time and display_space, report GDB's elapsed time
+ and space usage from the base time and space provided in ARG, which
+ must be a pointer to a struct cmd_stat. This function is intended
+ to be called as a cleanup. */
+static void
+report_command_stats (void *arg)
+{
+ struct cmd_stats *start_stats = (struct cmd_stats *) arg;
+ int msg_type = start_stats->msg_type;
+
+ if (display_time)
+ {
+ long cmd_time = get_run_time () - start_stats->start_time;
+
+ printf_unfiltered (msg_type == 0
+ ? _("Startup time: %ld.%06ld\n")
+ : _("Command execution time: %ld.%06ld\n"),
+ cmd_time / 1000000, cmd_time % 1000000);
+ }
+
+ if (display_space)
+ {
+#ifdef HAVE_SBRK
+ char *lim = (char *) sbrk (0);
+
+ long space_now = lim - lim_at_start;
+ long space_diff = space_now - start_stats->start_space;
+
+ printf_unfiltered (msg_type == 0
+ ? _("Space used: %ld (%c%ld during startup)\n")
+ : _("Space used: %ld (%c%ld for this command)\n"),
+ space_now,
+ (space_diff >= 0 ? '+' : '-'),
+ space_diff);
+#endif
+ }
+}
+
+/* Create a cleanup that reports time and space used since its
+ creation. Precise messages depend on MSG_TYPE:
+ 0: Initial time/space
+ 1: Individual command time/space. */
+struct cleanup *
+make_command_stats_cleanup (int msg_type)
+{
+ struct cmd_stats *new_stat = XMALLOC (struct cmd_stats);
+
+#ifdef HAVE_SBRK
+ char *lim = (char *) sbrk (0);
+ new_stat->start_space = lim - lim_at_start;
+#endif
+
+ new_stat->msg_type = msg_type;
+ new_stat->start_time = get_run_time ();
+
+ return make_cleanup_dtor (report_command_stats, new_stat, xfree);
+}
+
/* Continuations are implemented as cleanups internally. Inherit from
cleanups. */
struct continuation
void
do_all_inferior_continuations (void)
{
- struct cleanup *old_chain;
struct cleanup *as_cleanup;
struct inferior *inf = current_inferior ();
discard_all_inferior_continuations (struct inferior *inf)
{
struct cleanup *continuation_ptr = &inf->continuations->base;
+
discard_my_cleanups (&continuation_ptr, NULL);
inf->continuations = NULL;
}
restore_thread_cleanup (void *arg)
{
ptid_t *ptid_p = arg;
+
switch_to_thread (*ptid_p);
}
void *data)
{
struct cleanup *continuation_ptr = &thread->continuations->base;
+
discard_my_cleanups (&continuation_ptr, NULL);
thread->continuations = NULL;
return 0;
}
/* Walk down the cmd_continuation list, and execute all the
- continuations. There is a problem though. In some cases new
+ continuations. There is a problem though. In some cases new
continuations may be added while we are in the middle of this
- loop. If this happens they will be added in the front, and done
+ loop. If this happens they will be added in the front, and done
before we have a chance of exhausting those that were already
- there. We need to then save the beginning of the list in a pointer
+ there. We need to then save the beginning of the list in a pointer
and do the continuations from there on, instead of using the
- global beginning of list as our iteration pointer.*/
+ global beginning of list as our iteration pointer. */
static int
do_all_intermediate_continuations_thread_callback (struct thread_info *thread,
void *data)
void
do_all_intermediate_continuations (void)
{
- iterate_over_threads (do_all_intermediate_continuations_thread_callback, NULL);
+ iterate_over_threads (do_all_intermediate_continuations_thread_callback,
+ NULL);
}
/* Callback for iterate over threads. */
void *data)
{
struct cleanup *continuation_ptr = &thread->intermediate_continuations->base;
+
discard_my_cleanups (&continuation_ptr, NULL);
thread->intermediate_continuations = NULL;
return 0;
void
discard_all_intermediate_continuations (void)
{
- iterate_over_threads (discard_all_intermediate_continuations_thread_callback, NULL);
+ iterate_over_threads (discard_all_intermediate_continuations_thread_callback,
+ NULL);
}
\f
else
{
target_terminal_ours ();
- wrap_here (""); /* Force out any buffered output */
+ wrap_here (""); /* Force out any buffered output. */
gdb_flush (gdb_stdout);
if (warning_pre_print)
fputs_unfiltered (warning_pre_print, gdb_stderr);
warning (const char *string, ...)
{
va_list args;
+
va_start (args, string);
vwarning (string, args);
va_end (args);
The first argument STRING is the error message, used as a fprintf string,
and the remaining args are passed as arguments to it. */
-NORETURN void
+void
verror (const char *string, va_list args)
{
throw_verror (GENERIC_ERROR, string, args);
}
-NORETURN void
+void
error (const char *string, ...)
{
va_list args;
+
va_start (args, string);
throw_verror (GENERIC_ERROR, string, args);
va_end (args);
The first argument STRING is the error message, used as a fprintf string,
and the remaining args are passed as arguments to it. */
-NORETURN void
+void
vfatal (const char *string, va_list args)
{
throw_vfatal (string, args);
}
-NORETURN void
+void
fatal (const char *string, ...)
{
va_list args;
+
va_start (args, string);
throw_vfatal (string, args);
va_end (args);
}
-NORETURN void
+void
error_stream (struct ui_file *stream)
{
char *message = ui_file_xstrdup (stream, NULL);
+
make_cleanup (xfree, message);
error (("%s"), message);
}
abort (); /* NOTE: GDB has only three calls to abort(). */
}
-/* Check whether GDB will be able to dump core using the dump_core function. */
+/* Check whether GDB will be able to dump core using the dump_core
+ function. */
static int
can_dump_core (const char *reason)
if (rlim.rlim_max == 0)
{
fprintf_unfiltered (gdb_stderr,
- _("%s\nUnable to dump core, use `ulimit -c unlimited'"
- " before executing GDB next time.\n"), reason);
+ _("%s\nUnable to dump core, use `ulimit -c"
+ " unlimited' before executing GDB next time.\n"),
+ reason);
return 0;
}
#endif /* HAVE_GETRLIMIT */
internal_problem_no,
NULL
};
-static const char *internal_problem_mode = internal_problem_ask;
-/* Print a message reporting an internal error/warning. Ask the user
+/* Print a message reporting an internal error/warning. Ask the user
if they want to continue, dump core, or just exit. Return
something to indicate a quit. */
has been reported, and assuming GDB didn't quit, the caller can
either allow execution to resume or throw an error. */
-static void ATTR_FORMAT (printf, 4, 0)
+static void ATTRIBUTE_PRINTF (4, 0)
internal_vproblem (struct internal_problem *problem,
const char *file, int line, const char *fmt, va_list ap)
{
/* Don't allow infinite error/warning recursion. */
{
static char msg[] = "Recursive internal problem.\n";
+
switch (dejavu)
{
case 0:
so that the user knows that they are living on the edge. */
{
char *msg;
+
msg = xstrvprintf (fmt, ap);
- reason = xstrprintf ("\
-%s:%d: %s: %s\n\
-A problem internal to GDB has been detected,\n\
-further debugging may prove unreliable.", file, line, problem->name, msg);
+ reason = xstrprintf ("%s:%d: %s: %s\n"
+ "A problem internal to GDB has been detected,\n"
+ "further debugging may prove unreliable.",
+ file, line, problem->name, msg);
xfree (msg);
make_cleanup (xfree, reason);
}
"internal-error", internal_problem_ask, internal_problem_ask
};
-NORETURN void
+void
internal_verror (const char *file, int line, const char *fmt, va_list ap)
{
internal_vproblem (&internal_error_problem, file, line, fmt, ap);
deprecated_throw_reason (RETURN_ERROR);
}
-NORETURN void
+void
internal_error (const char *file, int line, const char *string, ...)
{
va_list ap;
+
va_start (ap, string);
internal_verror (file, line, string, ap);
va_end (ap);
internal_warning (const char *file, int line, const char *string, ...)
{
va_list ap;
+
va_start (ap, string);
internal_vwarning (file, line, string, ap);
va_end (ap);
add_prefix_cmd ((char*) problem->name,
class_maintenance, set_internal_problem_cmd, set_doc,
set_cmd_list,
- concat ("maintenance set ", problem->name, " ", NULL),
+ concat ("maintenance set ", problem->name, " ",
+ (char *) NULL),
0/*allow-unknown*/, &maintenance_set_cmdlist);
add_prefix_cmd ((char*) problem->name,
class_maintenance, show_internal_problem_cmd, show_doc,
show_cmd_list,
- concat ("maintenance show ", problem->name, " ", NULL),
+ concat ("maintenance show ", problem->name, " ",
+ (char *) NULL),
0/*allow-unknown*/, &maintenance_show_cmdlist);
- set_doc = xstrprintf (_("\
-Set whether GDB should quit when an %s is detected"),
+ set_doc = xstrprintf (_("Set whether GDB should quit "
+ "when an %s is detected"),
problem->name);
- show_doc = xstrprintf (_("\
-Show whether GDB will quit when an %s is detected"),
+ show_doc = xstrprintf (_("Show whether GDB will quit "
+ "when an %s is detected"),
problem->name);
add_setshow_enum_cmd ("quit", class_maintenance,
internal_problem_modes,
xfree (set_doc);
xfree (show_doc);
- set_doc = xstrprintf (_("\
-Set whether GDB should create a core file of GDB when %s is detected"),
+ set_doc = xstrprintf (_("Set whether GDB should create a core "
+ "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"),
+ show_doc = xstrprintf (_("Show whether GDB will create a core "
+ "file of GDB when %s is detected"),
problem->name);
add_setshow_enum_cmd ("corefile", class_maintenance,
internal_problem_modes,
as the file name for which the error was encountered.
Then return to command level. */
-NORETURN void
+void
perror_with_name (const char *string)
{
char *err;
/* I understand setting these is a matter of taste. Still, some people
may clear errno but not know about bfd_error. Doing this here is not
- unreasonable. */
+ unreasonable. */
bfd_set_error (bfd_error_no_error);
errno = 0;
\f
/* Called when a memory allocation fails, with the number of bytes of
- memory requested in SIZE. */
+ memory requested in SIZE. */
-NORETURN void
+void
nomem (long size)
{
if (size > 0)
\f
/* Like asprintf/vasprintf but get an internal_error if the call
- fails. */
+ fails. */
char *
xstrprintf (const char *format, ...)
{
char *ret;
va_list args;
+
va_start (args, format);
ret = xstrvprintf (format, args);
va_end (args);
xasprintf (char **ret, const char *format, ...)
{
va_list args;
+
va_start (args, format);
(*ret) = xstrvprintf (format, args);
va_end (args);
{
char *ret = NULL;
int status = vasprintf (&ret, format, ap);
+
/* NULL is returned when there was a memory allocation problem, or
any other error (for instance, a bad format string). A negative
status (the printed length) with a non-NULL buffer should never
savestring (const char *ptr, size_t size)
{
char *p = (char *) xmalloc (size + 1);
+
memcpy (p, ptr, size);
p[size] = 0;
return p;
}
\f
+/* A cleanup function that calls regfree. */
+
+static void
+do_regfree_cleanup (void *r)
+{
+ regfree (r);
+}
+
+/* Create a new cleanup that frees the compiled regular expression R. */
+
+struct cleanup *
+make_regfree_cleanup (regex_t *r)
+{
+ return make_cleanup (do_regfree_cleanup, r);
+}
+
+/* Return an xmalloc'd error message resulting from a regular
+ expression compilation failure. */
+
+char *
+get_regcomp_error (int code, regex_t *rx)
+{
+ size_t length = regerror (code, rx, NULL, 0);
+ char *result = xmalloc (length);
+
+ regerror (code, rx, result, length);
+ return result;
+}
+
+\f
+
/* This function supports the query, nquery, and yquery functions.
Ask user a y-or-n question and return 0 if answer is no, 1 if
answer is yes, or default the answer to the specified default
ARGS are the arguments passed along with the CTLSTR argument to
printf. */
-static int ATTR_FORMAT (printf, 1, 0)
+static int ATTRIBUTE_PRINTF (1, 0)
defaulted_query (const char *ctlstr, const char defchar, va_list args)
{
int answer;
wrap_here ("");
vfprintf_filtered (gdb_stdout, ctlstr, args);
- printf_filtered (_("(%s or %s) [answered %c; input not from terminal]\n"),
+ printf_filtered (_("(%s or %s) [answered %c; "
+ "input not from terminal]\n"),
y_string, n_string, def_answer);
gdb_flush (gdb_stdout);
while (1)
{
- wrap_here (""); /* Flush any buffered output */
+ wrap_here (""); /* Flush any buffered output. */
gdb_flush (gdb_stdout);
if (annotation_level > 1)
retval = def_value;
break;
}
- /* Eat rest of input line, to EOF or newline */
+ /* Eat rest of input line, to EOF or newline. */
if (answer != '\n')
do
{
function returns 1. Otherwise, the function returns 0. */
static int
-host_char_to_target (int c, int *target_c)
+host_char_to_target (struct gdbarch *gdbarch, int c, int *target_c)
{
struct obstack host_data;
char the_char = c;
obstack_init (&host_data);
cleanups = make_cleanup_obstack_free (&host_data);
- convert_between_encodings (target_charset (), host_charset (),
+ convert_between_encodings (target_charset (gdbarch), host_charset (),
&the_char, 1, 1, &host_data, translit_none);
if (obstack_object_size (&host_data) == 1)
after the zeros. A value of 0 does not mean end of string. */
int
-parse_escape (char **string_ptr)
+parse_escape (struct gdbarch *gdbarch, char **string_ptr)
{
- int target_char = -2; /* initialize to avoid GCC warnings */
+ int target_char = -2; /* Initialize to avoid GCC warnings. */
int c = *(*string_ptr)++;
+
switch (c)
{
case '\n':
break;
}
- if (!host_char_to_target (c, &target_char))
+ if (!host_char_to_target (gdbarch, c, &target_char))
error
("The escape sequence `\%c' is equivalent to plain `%c', which"
" has no equivalent\n" "in the `%s' character set.", c, c,
- target_charset ());
+ target_charset (gdbarch));
return target_char;
}
\f
/* Print the character C on STREAM as part of the contents of a literal
string whose delimiter is QUOTER. Note that this routine should only
be call for printing things which are independent of the language
- of the program being debugged. */
+ of the program being debugged. */
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)
{
-
c &= 0xFF; /* Avoid sign bit follies */
if (c < 0x20 || /* Low control chars */
/* Print the character C on STREAM as part of the contents of a
literal string whose delimiter is QUOTER. Note that these routines
should only be call for printing things which are independent of
- the language of the program being debugged. */
+ the language of the program being debugged. */
void
fputstr_filtered (const char *str, int quoter, struct ui_file *stream)
struct ui_file *stream)
{
int i;
+
for (i = 0; i < n; i++)
printchar (str[i], fputs_filtered, fprintf_filtered, stream, quoter);
}
struct ui_file *stream)
{
int i;
+
for (i = 0; i < n; i++)
printchar (str[i], fputs_unfiltered, fprintf_unfiltered, stream, quoter);
}
show_lines_per_page (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file, _("\
-Number of lines gdb thinks are in a page is %s.\n"),
+ fprintf_filtered (file,
+ _("Number of lines gdb thinks are in a page is %s.\n"),
value);
}
show_chars_per_line (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file, _("\
-Number of characters gdb thinks are in a line is %s.\n"),
+ fprintf_filtered (file,
+ _("Number of characters gdb thinks "
+ "are in a line is %s.\n"),
value);
}
void
init_page_info (void)
{
+ if (batch_flag)
+ {
+ lines_per_page = UINT_MAX;
+ chars_per_line = UINT_MAX;
+ }
+ else
#if defined(TUI)
if (!tui_get_command_dimension (&chars_per_line, &lines_per_page))
#endif
set_width ();
}
+/* Helper for make_cleanup_restore_page_info. */
+
+static void
+do_restore_page_info_cleanup (void *arg)
+{
+ set_screen_size ();
+ set_width ();
+}
+
+/* Provide cleanup for restoring the terminal size. */
+
+struct cleanup *
+make_cleanup_restore_page_info (void)
+{
+ struct cleanup *back_to;
+
+ back_to = make_cleanup (do_restore_page_info_cleanup, NULL);
+ make_cleanup_restore_uinteger (&lines_per_page);
+ make_cleanup_restore_uinteger (&chars_per_line);
+
+ return back_to;
+}
+
+/* Temporarily set BATCH_FLAG and the associated unlimited terminal size.
+ Provide cleanup for restoring the original state. */
+
+struct cleanup *
+set_batch_flag_and_make_cleanup_restore_page_info (void)
+{
+ struct cleanup *back_to = make_cleanup_restore_page_info ();
+
+ make_cleanup_restore_integer (&batch_flag);
+ batch_flag = 1;
+ init_page_info ();
+
+ return back_to;
+}
+
/* Set the screen size based on LINES_PER_PAGE and CHARS_PER_LINE. */
static void
if (ignore)
{
char *p = ignore;
+
while (*p == ' ' || *p == '\t')
++p;
if (p[0] == 'q')
need to save the ---Type <return>--- line at the top of the screen. */
reinitialize_more_filter ();
- dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
+ dont_repeat (); /* Forget prev cmd -- CR won't repeat it. */
}
/* Reinitialize filter; ie. tell it to reset to original values. */
}
/* Indicate that if the next sequence of characters overflows the line,
- a newline should be inserted here rather than when it hits the end.
+ 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
wrapped part on the next line. INDENT must remain accessible until
the next call to wrap_here() or until a newline is printed through
void
wrap_here (char *indent)
{
- /* This should have been allocated, but be paranoid anyway. */
+ /* This should have been allocated, but be paranoid anyway. */
if (!wrap_buffer)
- internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
+ internal_error (__FILE__, __LINE__,
+ _("failed internal consistency check"));
if (wrap_buffer[0])
{
}
wrap_pointer = wrap_buffer;
wrap_buffer[0] = '\0';
- if (chars_per_line == UINT_MAX) /* No line overflow checking */
+ if (chars_per_line == UINT_MAX) /* No line overflow checking. */
{
wrap_column = 0;
}
}
/* Print input string to gdb_stdout, filtered, with wrap,
- arranging strings in columns of n chars. String can be
+ arranging strings in columns of n chars. String can be
right or left justified in the column. Never prints
trailing spaces. String should never be longer than
width. FIXME: this could be useful for the EXAMINE
- command, which currently doesn't tabulate very well */
+ command, which currently doesn't tabulate very well. */
void
puts_filtered_tabular (char *string, int width, int right)
/* Ensure that whatever gets printed next, using the filtered output
- commands, starts at the beginning of the line. I.E. if there is
+ commands, starts at the beginning of the line. I.e. if there is
any pending output for the current line, flush it and start a new
- line. Otherwise do nothing. */
+ line. Otherwise do nothing. */
void
begin_line (void)
/* Don't do any filtering if it is disabled. */
if (stream != gdb_stdout
- || !pagination_enabled
+ || ! pagination_enabled
+ || ! input_from_terminal_p ()
|| (lines_per_page == UINT_MAX && chars_per_line == UINT_MAX)
+ || top_level_interpreter () == NULL
|| ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())))
{
fputs_unfiltered (linebuffer, stream);
if (lines_printed >= lines_per_page - 1)
prompt_for_continue ();
- /* Now output indentation and wrapped string */
+ /* 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 */
+ *wrap_pointer = '\0'; /* Null-terminate saved stuff, */
+ fputs_unfiltered (wrap_buffer, stream); /* and eject it. */
/* 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
- longer than (the user settable) chars_per_line.
+ longer than (the user settable) chars_per_line.
Note also that this can set chars_printed > chars_per_line
if we are printing a long string. */
chars_printed = strlen (wrap_indent)
if (*lineptr == '\n')
{
chars_printed = 0;
- wrap_here ((char *) 0); /* Spit out chars, cancel further wraps */
+ wrap_here ((char *) 0); /* Spit out chars, cancel
+ further wraps. */
lines_printed++;
fputc_unfiltered ('\n', stream);
lineptr++;
putchar_unfiltered (int c)
{
char buf = c;
+
ui_file_write (gdb_stdout, &buf, 1);
return c;
}
fputc_unfiltered (int c, struct ui_file *stream)
{
char buf = c;
+
ui_file_write (stream, &buf, 1);
return c;
}
fprintf_filtered (struct ui_file *stream, const char *format, ...)
{
va_list args;
+
va_start (args, format);
vfprintf_filtered (stream, format, args);
va_end (args);
fprintf_unfiltered (struct ui_file *stream, const char *format, ...)
{
va_list args;
+
va_start (args, format);
vfprintf_unfiltered (stream, format, args);
va_end (args);
...)
{
va_list args;
+
va_start (args, format);
print_spaces_filtered (spaces, stream);
printf_filtered (const char *format, ...)
{
va_list args;
+
va_start (args, format);
vfprintf_filtered (gdb_stdout, format, args);
va_end (args);
printf_unfiltered (const char *format, ...)
{
va_list args;
+
va_start (args, format);
vfprintf_unfiltered (gdb_stdout, format, args);
va_end (args);
printfi_filtered (int spaces, const char *format, ...)
{
va_list args;
+
va_start (args, format);
print_spaces_filtered (spaces, gdb_stdout);
vfprintf_filtered (gdb_stdout, format, args);
/* fprintf_symbol_filtered attempts to demangle NAME, a symbol in language
LANG, using demangling args ARG_MODE, and print it filtered to STREAM.
If the name is not mangled, or the language for the name is unknown, or
- demangling is off, the name is printed in its "raw" form. */
+ demangling is off, the name is printed in its "raw" form. */
void
fprintf_symbol_filtered (struct ui_file *stream, char *name,
As an extra hack, string1=="FOO(ARGS)" matches string2=="FOO".
This "feature" is useful when searching for matching C++ function names
(such as if the user types 'break FOO', where FOO is a mangled C++
- function). */
+ function). */
int
strcmp_iw (const char *string1, const char *string2)
subset_compare (char *string_to_compare, char *template_string)
{
int match;
+
if (template_string != (char *) NULL && string_to_compare != (char *) NULL
&& strlen (string_to_compare) <= strlen (template_string))
match =
show_debug_timestamp (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- fprintf_filtered (file, _("Timestamping debugging messages is %s.\n"), value);
+ fprintf_filtered (file, _("Timestamping debugging messages is %s.\n"),
+ value);
}
\f
void
initialize_utils (void)
{
- struct cmd_list_element *c;
-
add_setshow_uinteger_cmd ("width", class_support, &chars_per_line, _("\
Set number of characters gdb thinks are in a line."), _("\
Show number of characters gdb thinks are in a line."), NULL,
&setdebuglist, &showdebuglist);
}
-/* Machine specific function to handle SIGWINCH signal. */
+/* Machine specific function to handle SIGWINCH signal. */
#ifdef SIGWINCH_HANDLER_BODY
SIGWINCH_HANDLER_BODY
#endif
-/* print routines to handle variable size regs, etc. */
-/* temporary storage using circular buffer */
+/* Print routines to handle variable size regs, etc. */
+/* Temporary storage using circular buffer. */
#define NUMCELLS 16
#define CELLSIZE 50
static char *
{
static char buf[NUMCELLS][CELLSIZE];
static int cell = 0;
+
if (++cell >= NUMCELLS)
cell = 0;
return buf[cell];
/* Truncate address to the size 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. */
+ when it won't occur. */
/* NOTE: This assumes that the significant address information is
kept in the least significant bits of ADDR - the upper bits were
either zero or sign extended. Should gdbarch_address_to_pointer or
decimal2str (char *sign, ULONGEST addr, int width)
{
/* Steal code from valprint.c:print_decimal(). Should this worry
- about the real size of addr as the above does? */
+ about the real size of addr as the above does? */
unsigned long temp[3];
char *str = get_cell ();
-
int i = 0;
+
do
{
temp[i] = addr % (1000 * 1000 * 1000);
{
unsigned long temp[3];
char *str = get_cell ();
-
int i = 0;
+
do
{
temp[i] = addr % (0100000 * 0100000);
case 8:
{
unsigned long high = (unsigned long) (l >> thirty_two);
+
str = get_cell ();
if (high == 0)
xsnprintf (str, CELLSIZE, "%lx",
hex_string (LONGEST num)
{
char *result = get_cell ();
+
xsnprintf (result, CELLSIZE, "0x%s", phex_nz (num, sizeof (num)));
return result;
}
if (hex_len > width)
width = hex_len;
if (width + 2 >= CELLSIZE)
- internal_error (__FILE__, __LINE__,
- _("hex_string_custom: insufficient space to store result"));
+ internal_error (__FILE__, __LINE__, _("\
+hex_string_custom: insufficient space to store result"));
strcpy (result_end - width - 2, "0x");
memset (result_end - width, '0', width);
* otherwise VAL is interpreted as unsigned. If WIDTH is supplied,
* it is the minimum width (0-padded if needed). USE_C_FORMAT means
* to use C format in all cases. If it is false, then 'x'
- * and 'o' formats do not include a prefix (0x or leading 0). */
+ * and 'o' formats do not include a prefix (0x or leading 0). */
char *
int_string (LONGEST val, int radix, int is_signed, int width,
case 16:
{
char *result;
+
if (width == 0)
result = hex_string (val);
else
case 8:
{
char *result = octal2str (val, width);
+
if (use_c_format || val == 0)
return result;
else
core_addr_to_string (const CORE_ADDR addr)
{
char *str = get_cell ();
+
strcpy (str, "0x");
strcat (str, phex (addr, sizeof (addr)));
return str;
core_addr_to_string_nz (const CORE_ADDR addr)
{
char *str = get_cell ();
+
strcpy (str, "0x");
strcat (str, phex_nz (addr, sizeof (addr)));
return str;
{
/* Assume that it is in hex. */
int i;
+
for (i = 2; my_string[i] != '\0'; i++)
{
if (isdigit (my_string[i]))
{
/* Assume that it is in decimal. */
int i;
+
for (i = 0; my_string[i] != '\0'; i++)
{
if (isdigit (my_string[i]))
# endif
# if defined (USE_REALPATH)
const char *rp = realpath (filename, buf);
+
if (rp == NULL)
rp = filename;
return xstrdup (rp);
#if defined(HAVE_CANONICALIZE_FILE_NAME)
{
char *rp = canonicalize_file_name (filename);
+
if (rp == NULL)
return xstrdup (filename);
else
{
/* Find out the max path size. */
long path_max = pathconf ("/", _PC_PATH_MAX);
+
if (path_max > 0)
{
/* PATH_MAX is bounded. */
char *buf = alloca (path_max);
char *rp = realpath (filename, buf);
+
return xstrdup (rp ? rp : filename);
}
}
char *result;
/* Extract the basename of filename, and return immediately
- a copy of filename if it does not contain any directory prefix. */
+ a copy of filename if it does not contain any directory prefix. */
if (base_name == filename)
return xstrdup (filename);
dir_name = 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 */
+ then the closing \000 character. */
strncpy (dir_name, filename, base_name - filename);
dir_name[base_name - filename] = '\000';
#endif
/* Canonicalize the directory prefix, and build the resulting
- filename. If the dirname realpath already contains an ending
+ filename. If the dirname realpath already contains an ending
directory separator, avoid doubling it. */
real_path = gdb_realpath (dir_name);
if (IS_DIR_SEPARATOR (real_path[strlen (real_path) - 1]))
- result = concat (real_path, base_name, (char *)NULL);
+ result = concat (real_path, base_name, (char *) NULL);
else
- result = concat (real_path, SLASH_STRING, base_name, (char *)NULL);
+ result = concat (real_path, SLASH_STRING, base_name, (char *) NULL);
xfree (real_path);
return result;
{
unsigned int total = size * count;
void *ptr = obstack_alloc ((struct obstack *) data, total);
+
memset (ptr, 0, total);
return ptr;
}
gdb_buildargv (const char *s)
{
char **argv = buildargv (s);
+
if (s != NULL && argv == NULL)
nomem (0);
return argv;
}
#define AMBIGUOUS_MESS1 ".\nMatching formats:"
-#define AMBIGUOUS_MESS2 ".\nUse \"set gnutarget format-name\" to specify the format."
+#define AMBIGUOUS_MESS2 \
+ ".\nUse \"set gnutarget format-name\" to specify the format."
const char *
gdb_bfd_errmsg (bfd_error_type error_tag, char **matching)