/* General utility routines for GDB, the GNU debugger.
- Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
- 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
- Foundation, Inc.
+ 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 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "gdb_assert.h"
#include "gdb_string.h"
#include "event-top.h"
#include "exceptions.h"
+#include "gdbthread.h"
#ifdef TUI
#include "tui/tui.h" /* For tui_get_command_dimension. */
#include "annotate.h"
#include "filenames.h"
#include "symfile.h"
+#include "gdb_obstack.h"
+#include "gdbcore.h"
+#include "top.h"
#include "inferior.h" /* for signed_pointer_to_address */
#include "readline/readline.h"
-#ifdef NEED_DECLARATION_MALLOC
-extern PTR malloc (); /* OK: PTR */
+#include <sys/time.h>
+#include <time.h>
+
+#include "gdb_usleep.h"
+
+#if !HAVE_DECL_MALLOC
+extern PTR malloc (); /* ARI: PTR */
#endif
-#ifdef NEED_DECLARATION_REALLOC
-extern PTR realloc (); /* OK: PTR */
+#if !HAVE_DECL_REALLOC
+extern PTR realloc (); /* ARI: PTR */
#endif
-#ifdef NEED_DECLARATION_FREE
+#if !HAVE_DECL_FREE
extern void free ();
#endif
-/* Actually, we'll never have the decl, since we don't define _GNU_SOURCE. */
-#if defined(HAVE_CANONICALIZE_FILE_NAME) \
- && defined(NEED_DECLARATION_CANONICALIZE_FILE_NAME)
-extern char *canonicalize_file_name (const char *);
-#endif
/* readline defines this. */
#undef savestring
void (*deprecated_error_begin_hook) (void);
-/* Holds the last error message issued by gdb */
-
-static struct ui_file *gdb_lasterr;
-
/* Prototypes for local functions */
static void vfprintf_maybe_filtered (struct ui_file *, const char *,
- va_list, int);
+ va_list, int) ATTR_FORMAT (printf, 2, 0);
static void fputs_maybe_filtered (const char *, struct ui_file *, int);
static void set_screen_size (void);
static void set_width (void);
-static NORETURN void error_stream_1 (struct ui_file *stream,
- enum return_reason reason) ATTR_NORETURN;
+/* A flag indicating whether to timestamp debugging messages. */
+
+static int debug_timestamp = 0;
/* Chain of cleanup actions established with make_cleanup,
to be executed if an error happens. */
static struct cleanup *cleanup_chain; /* cleaned up after a failed command */
static struct cleanup *final_cleanup_chain; /* cleaned up when gdb exits */
-static struct cleanup *run_cleanup_chain; /* cleaned up on each 'run' */
-static struct cleanup *exec_cleanup_chain; /* cleaned up on each execution command */
-/* cleaned up on each error from within an execution command */
-static struct cleanup *exec_error_cleanup_chain;
-
-/* Pointer to what is left to do for an execution command after the
- target stops. Used only in asynchronous mode, by targets that
- support async execution. The finish and until commands use it. So
- does the target extended-remote command. */
-struct continuation *cmd_continuation;
-struct continuation *intermediate_continuation;
/* Nonzero if we have job control. */
C++/ObjC form rather than raw. */
int demangle = 1;
+static void
+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"),
+ value);
+}
/* Nonzero means that encoded C++/ObjC names should be printed out in their
C++/ObjC form even in assembler language displays. If this is set, but
DEMANGLE is zero, names are printed raw, i.e. DEMANGLE controls. */
int asm_demangle = 0;
+static void
+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"),
+ value);
+}
/* 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
international character, and the terminal or window can cope.) */
int sevenbit_strings = 0;
+static void
+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"),
+ value);
+}
/* String to be printed before error messages, if any. */
char *warning_pre_print = "\nwarning: ";
int pagination_enabled = 1;
+static void
+show_pagination_enabled (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("State of pagination is %s.\n"), value);
+}
+
\f
/* Add a new cleanup to the cleanup_chain,
}
struct cleanup *
-make_final_cleanup (make_cleanup_ftype *function, void *arg)
-{
- return make_my_cleanup (&final_cleanup_chain, function, arg);
-}
-
-struct cleanup *
-make_run_cleanup (make_cleanup_ftype *function, void *arg)
+make_cleanup_dtor (make_cleanup_ftype *function, void *arg,
+ void (*dtor) (void *))
{
- return make_my_cleanup (&run_cleanup_chain, function, arg);
+ return make_my_cleanup2 (&cleanup_chain,
+ function, arg, dtor);
}
struct cleanup *
-make_exec_cleanup (make_cleanup_ftype *function, void *arg)
-{
- return make_my_cleanup (&exec_cleanup_chain, function, arg);
-}
-
-struct cleanup *
-make_exec_error_cleanup (make_cleanup_ftype *function, void *arg)
+make_final_cleanup (make_cleanup_ftype *function, void *arg)
{
- return make_my_cleanup (&exec_error_cleanup_chain, function, arg);
+ return make_my_cleanup (&final_cleanup_chain, function, arg);
}
static void
{
int *fd = arg;
close (*fd);
- xfree (fd);
}
struct cleanup *
{
int *saved_fd = xmalloc (sizeof (fd));
*saved_fd = fd;
- return make_cleanup (do_close_cleanup, saved_fd);
+ return make_cleanup_dtor (do_close_cleanup, saved_fd, xfree);
+}
+
+/* Helper function which does the work for make_cleanup_fclose. */
+
+static void
+do_fclose_cleanup (void *arg)
+{
+ FILE *file = arg;
+ fclose (arg);
+}
+
+/* Return a new cleanup that closes FILE. */
+
+struct cleanup *
+make_cleanup_fclose (FILE *file)
+{
+ return make_cleanup (do_fclose_cleanup, file);
+}
+
+/* Helper function which does the work for make_cleanup_obstack_free. */
+
+static void
+do_obstack_free (void *arg)
+{
+ struct obstack *ob = arg;
+ obstack_free (ob, NULL);
+}
+
+/* Return a new cleanup that frees OBSTACK. */
+
+struct cleanup *
+make_cleanup_obstack_free (struct obstack *obstack)
+{
+ return make_cleanup (do_obstack_free, obstack);
}
static void
return make_my_cleanup (&cleanup_chain, do_free_section_addr_info, addrs);
}
+struct restore_integer_closure
+{
+ int *variable;
+ int value;
+};
+static void
+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. */
struct cleanup *
-make_my_cleanup (struct cleanup **pmy_chain, make_cleanup_ftype *function,
- void *arg)
+make_cleanup_restore_integer (int *variable)
+{
+ struct restore_integer_closure *c =
+ xmalloc (sizeof (struct restore_integer_closure));
+ c->variable = variable;
+ c->value = *variable;
+
+ return make_my_cleanup2 (&cleanup_chain, restore_integer, (void *)c,
+ xfree);
+}
+
+struct cleanup *
+make_my_cleanup2 (struct cleanup **pmy_chain, make_cleanup_ftype *function,
+ void *arg, void (*free_arg) (void *))
{
struct cleanup *new
= (struct cleanup *) xmalloc (sizeof (struct cleanup));
new->next = *pmy_chain;
new->function = function;
+ new->free_arg = free_arg;
new->arg = arg;
*pmy_chain = new;
return old_chain;
}
+struct cleanup *
+make_my_cleanup (struct cleanup **pmy_chain, make_cleanup_ftype *function,
+ void *arg)
+{
+ return make_my_cleanup2 (pmy_chain, function, arg, NULL);
+}
+
/* Discard cleanups and do the actions they describe
until we get back to the point OLD_CHAIN in the cleanup_chain. */
do_my_cleanups (&final_cleanup_chain, old_chain);
}
-void
-do_run_cleanups (struct cleanup *old_chain)
-{
- do_my_cleanups (&run_cleanup_chain, old_chain);
-}
-
-void
-do_exec_cleanups (struct cleanup *old_chain)
-{
- do_my_cleanups (&exec_cleanup_chain, old_chain);
-}
-
-void
-do_exec_error_cleanups (struct cleanup *old_chain)
-{
- do_my_cleanups (&exec_error_cleanup_chain, old_chain);
-}
-
static void
do_my_cleanups (struct cleanup **pmy_chain,
struct cleanup *old_chain)
{
*pmy_chain = ptr->next; /* Do this first incase recursion */
(*ptr->function) (ptr->arg);
+ if (ptr->free_arg)
+ (*ptr->free_arg) (ptr->arg);
xfree (ptr);
}
}
discard_my_cleanups (&final_cleanup_chain, old_chain);
}
-void
-discard_exec_error_cleanups (struct cleanup *old_chain)
-{
- discard_my_cleanups (&exec_error_cleanup_chain, old_chain);
-}
-
void
discard_my_cleanups (struct cleanup **pmy_chain,
struct cleanup *old_chain)
while ((ptr = *pmy_chain) != old_chain)
{
*pmy_chain = ptr->next;
+ if (ptr->free_arg)
+ (*ptr->free_arg) (ptr->arg);
xfree (ptr);
}
}
void **location = ptr;
if (location == NULL)
internal_error (__FILE__, __LINE__,
- "free_current_contents: NULL pointer");
+ _("free_current_contents: NULL pointer"));
if (*location != NULL)
{
xfree (*location);
{
}
-/* Add a continuation to the continuation list, the global list
- cmd_continuation. The new continuation will be added at the front.*/
+/* Continuations are implemented as cleanups internally. Inherit from
+ cleanups. */
+struct continuation
+{
+ struct cleanup base;
+};
+
+/* Add a continuation to the continuation list of THREAD. The new
+ continuation will be added at the front. */
void
-add_continuation (void (*continuation_hook) (struct continuation_arg *),
- struct continuation_arg *arg_list)
+add_continuation (struct thread_info *thread,
+ void (*continuation_hook) (void *), void *args,
+ void (*continuation_free_args) (void *))
{
- struct continuation *continuation_ptr;
+ struct cleanup *as_cleanup = &thread->continuations->base;
+ make_cleanup_ftype *continuation_hook_fn = continuation_hook;
- continuation_ptr =
- (struct continuation *) xmalloc (sizeof (struct continuation));
- continuation_ptr->continuation_hook = continuation_hook;
- continuation_ptr->arg_list = arg_list;
- continuation_ptr->next = cmd_continuation;
- cmd_continuation = continuation_ptr;
+ make_my_cleanup2 (&as_cleanup,
+ continuation_hook_fn,
+ args,
+ continuation_free_args);
+
+ thread->continuations = (struct continuation *) as_cleanup;
}
-/* Walk down the cmd_continuation list, and execute all the
- 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
- 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
- and do the continuations from there on, instead of using the
- global beginning of list as our iteration pointer.*/
+/* Add a continuation to the continuation list of INFERIOR. The new
+ continuation will be added at the front. */
+
void
-do_all_continuations (void)
+add_inferior_continuation (void (*continuation_hook) (void *), void *args,
+ void (*continuation_free_args) (void *))
+{
+ struct inferior *inf = current_inferior ();
+ struct cleanup *as_cleanup = &inf->continuations->base;
+ make_cleanup_ftype *continuation_hook_fn = continuation_hook;
+
+ make_my_cleanup2 (&as_cleanup,
+ continuation_hook_fn,
+ args,
+ continuation_free_args);
+
+ inf->continuations = (struct continuation *) as_cleanup;
+}
+
+/* Do all continuations of the current inferior. */
+
+void
+do_all_inferior_continuations (void)
{
- struct continuation *continuation_ptr;
- struct continuation *saved_continuation;
+ struct cleanup *old_chain;
+ struct cleanup *as_cleanup;
+ struct inferior *inf = current_inferior ();
+
+ if (inf->continuations == NULL)
+ return;
/* Copy the list header into another pointer, and set the global
list header to null, so that the global list can change as a side
- effect of invoking the continuations and the processing of
- the preexisting continuations will not be affected. */
- continuation_ptr = cmd_continuation;
- cmd_continuation = NULL;
+ effect of invoking the continuations and the processing of the
+ preexisting continuations will not be affected. */
- /* Work now on the list we have set aside. */
- while (continuation_ptr)
- {
- (continuation_ptr->continuation_hook) (continuation_ptr->arg_list);
- saved_continuation = continuation_ptr;
- continuation_ptr = continuation_ptr->next;
- xfree (saved_continuation);
- }
+ as_cleanup = &inf->continuations->base;
+ inf->continuations = NULL;
+
+ /* Work now on the list we have set aside. */
+ do_my_cleanups (&as_cleanup, NULL);
}
-/* Walk down the cmd_continuation list, and get rid of all the
- continuations. */
+/* Get rid of all the inferior-wide continuations of INF. */
+
void
-discard_all_continuations (void)
+discard_all_inferior_continuations (struct inferior *inf)
{
- struct continuation *continuation_ptr;
+ struct cleanup *continuation_ptr = &inf->continuations->base;
+ discard_my_cleanups (&continuation_ptr, NULL);
+ inf->continuations = NULL;
+}
- while (cmd_continuation)
- {
- continuation_ptr = cmd_continuation;
- cmd_continuation = continuation_ptr->next;
- xfree (continuation_ptr);
- }
+static void
+restore_thread_cleanup (void *arg)
+{
+ ptid_t *ptid_p = arg;
+ switch_to_thread (*ptid_p);
}
-/* Add a continuation to the continuation list, the global list
- intermediate_continuation. The new continuation will be added at the front.*/
+/* Walk down the continuation list of PTID, and execute all the
+ 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 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 and do the
+ continuations from there on, instead of using the global beginning
+ of list as our iteration pointer. */
+static void
+do_all_continuations_ptid (ptid_t ptid,
+ struct continuation **continuations_p)
+{
+ struct cleanup *old_chain;
+ ptid_t current_thread;
+ struct cleanup *as_cleanup;
+
+ if (*continuations_p == NULL)
+ return;
+
+ current_thread = inferior_ptid;
+
+ /* Restore selected thread on exit. Don't try to restore the frame
+ as well, because:
+
+ - When running continuations, the selected frame is always #0.
+
+ - The continuations may trigger symbol file loads, which may
+ change the frame layout (frame ids change), which would trigger
+ a warning if we used make_cleanup_restore_current_thread. */
+
+ old_chain = make_cleanup (restore_thread_cleanup, ¤t_thread);
+
+ /* Let the continuation see this thread as selected. */
+ switch_to_thread (ptid);
+
+ /* Copy the list header into another pointer, and set the global
+ list header to null, so that the global list can change as a side
+ effect of invoking the continuations and the processing of the
+ preexisting continuations will not be affected. */
+
+ as_cleanup = &(*continuations_p)->base;
+ *continuations_p = NULL;
+
+ /* Work now on the list we have set aside. */
+ do_my_cleanups (&as_cleanup, NULL);
+
+ do_cleanups (old_chain);
+}
+
+/* Callback for iterate over threads. */
+static int
+do_all_continuations_thread_callback (struct thread_info *thread, void *data)
+{
+ do_all_continuations_ptid (thread->ptid, &thread->continuations);
+ return 0;
+}
+
+/* Do all continuations of thread THREAD. */
void
-add_intermediate_continuation (void (*continuation_hook)
- (struct continuation_arg *),
- struct continuation_arg *arg_list)
+do_all_continuations_thread (struct thread_info *thread)
{
- struct continuation *continuation_ptr;
+ do_all_continuations_thread_callback (thread, NULL);
+}
- continuation_ptr =
- (struct continuation *) xmalloc (sizeof (struct continuation));
- continuation_ptr->continuation_hook = continuation_hook;
- continuation_ptr->arg_list = arg_list;
- continuation_ptr->next = intermediate_continuation;
- intermediate_continuation = continuation_ptr;
+/* Do all continuations of all threads. */
+void
+do_all_continuations (void)
+{
+ iterate_over_threads (do_all_continuations_thread_callback, NULL);
+}
+
+/* Callback for iterate over threads. */
+static int
+discard_all_continuations_thread_callback (struct thread_info *thread,
+ void *data)
+{
+ struct cleanup *continuation_ptr = &thread->continuations->base;
+ discard_my_cleanups (&continuation_ptr, NULL);
+ thread->continuations = NULL;
+ return 0;
+}
+
+/* Get rid of all the continuations of THREAD. */
+void
+discard_all_continuations_thread (struct thread_info *thread)
+{
+ discard_all_continuations_thread_callback (thread, NULL);
+}
+
+/* Get rid of all the continuations of all threads. */
+void
+discard_all_continuations (void)
+{
+ iterate_over_threads (discard_all_continuations_thread_callback, NULL);
+}
+
+
+/* Add a continuation to the intermediate continuation list of THREAD.
+ The new continuation will be added at the front. */
+void
+add_intermediate_continuation (struct thread_info *thread,
+ void (*continuation_hook)
+ (void *), void *args,
+ void (*continuation_free_args) (void *))
+{
+ struct cleanup *as_cleanup = &thread->intermediate_continuations->base;
+ make_cleanup_ftype *continuation_hook_fn = continuation_hook;
+
+ make_my_cleanup2 (&as_cleanup,
+ continuation_hook_fn,
+ args,
+ continuation_free_args);
+
+ thread->intermediate_continuations = (struct continuation *) as_cleanup;
}
/* Walk down the cmd_continuation list, and execute all the
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.*/
+static int
+do_all_intermediate_continuations_thread_callback (struct thread_info *thread,
+ void *data)
+{
+ do_all_continuations_ptid (thread->ptid,
+ &thread->intermediate_continuations);
+ return 0;
+}
+
+/* Do all intermediate continuations of thread THREAD. */
+void
+do_all_intermediate_continuations_thread (struct thread_info *thread)
+{
+ do_all_intermediate_continuations_thread_callback (thread, NULL);
+}
+
+/* Do all intermediate continuations of all threads. */
void
do_all_intermediate_continuations (void)
{
- struct continuation *continuation_ptr;
- struct continuation *saved_continuation;
+ iterate_over_threads (do_all_intermediate_continuations_thread_callback, NULL);
+}
- /* Copy the list header into another pointer, and set the global
- list header to null, so that the global list can change as a side
- effect of invoking the continuations and the processing of
- the preexisting continuations will not be affected. */
- continuation_ptr = intermediate_continuation;
- intermediate_continuation = NULL;
+/* Callback for iterate over threads. */
+static int
+discard_all_intermediate_continuations_thread_callback (struct thread_info *thread,
+ void *data)
+{
+ struct cleanup *continuation_ptr = &thread->intermediate_continuations->base;
+ discard_my_cleanups (&continuation_ptr, NULL);
+ thread->intermediate_continuations = NULL;
+ return 0;
+}
- /* Work now on the list we have set aside. */
- while (continuation_ptr)
- {
- (continuation_ptr->continuation_hook) (continuation_ptr->arg_list);
- saved_continuation = continuation_ptr;
- continuation_ptr = continuation_ptr->next;
- xfree (saved_continuation);
- }
+/* Get rid of all the intermediate continuations of THREAD. */
+void
+discard_all_intermediate_continuations_thread (struct thread_info *thread)
+{
+ discard_all_intermediate_continuations_thread_callback (thread, NULL);
}
-/* Walk down the cmd_continuation list, and get rid of all the
- continuations. */
+/* Get rid of all the intermediate continuations of all threads. */
void
discard_all_intermediate_continuations (void)
{
- struct continuation *continuation_ptr;
-
- while (intermediate_continuation)
- {
- continuation_ptr = intermediate_continuation;
- intermediate_continuation = continuation_ptr->next;
- xfree (continuation_ptr);
- }
+ iterate_over_threads (discard_all_intermediate_continuations_thread_callback, NULL);
}
\f
NORETURN void
verror (const char *string, va_list args)
{
- struct ui_file *tmp_stream = mem_fileopen ();
- make_cleanup_ui_file_delete (tmp_stream);
- vfprintf_unfiltered (tmp_stream, string, args);
- error_stream_1 (tmp_stream, RETURN_ERROR);
+ throw_verror (GENERIC_ERROR, string, args);
}
NORETURN void
{
va_list args;
va_start (args, string);
- verror (string, args);
+ throw_verror (GENERIC_ERROR, string, args);
va_end (args);
}
NORETURN void
vfatal (const char *string, va_list args)
{
- struct ui_file *tmp_stream = mem_fileopen ();
- make_cleanup_ui_file_delete (tmp_stream);
- vfprintf_unfiltered (tmp_stream, string, args);
- error_stream_1 (tmp_stream, RETURN_QUIT);
+ throw_vfatal (string, args);
}
NORETURN void
{
va_list args;
va_start (args, string);
- vfatal (string, args);
+ throw_vfatal (string, args);
va_end (args);
}
-static void
-do_write (void *data, const char *buffer, long length_buffer)
-{
- ui_file_write (data, buffer, length_buffer);
-}
-
-/* Cause a silent error to occur. Any error message is recorded
- though it is not issued. */
-NORETURN void
-error_silent (const char *string, ...)
-{
- va_list args;
- struct ui_file *tmp_stream = mem_fileopen ();
- va_start (args, string);
- make_cleanup_ui_file_delete (tmp_stream);
- vfprintf_unfiltered (tmp_stream, string, args);
- /* Copy the stream into the GDB_LASTERR buffer. */
- ui_file_rewind (gdb_lasterr);
- ui_file_put (tmp_stream, do_write, gdb_lasterr);
- va_end (args);
-
- throw_reason (RETURN_ERROR);
-}
-
-/* Output an error message including any pre-print text to gdb_stderr. */
-void
-error_output_message (char *pre_print, char *msg)
-{
- target_terminal_ours ();
- wrap_here (""); /* Force out any buffered output */
- gdb_flush (gdb_stdout);
- annotate_error_begin ();
- if (pre_print)
- fputs_filtered (pre_print, gdb_stderr);
- fputs_filtered (msg, gdb_stderr);
- fprintf_filtered (gdb_stderr, "\n");
-}
-
-static NORETURN void
-error_stream_1 (struct ui_file *stream, enum return_reason reason)
-{
- if (deprecated_error_begin_hook)
- deprecated_error_begin_hook ();
-
- /* Copy the stream into the GDB_LASTERR buffer. */
- ui_file_rewind (gdb_lasterr);
- ui_file_put (stream, do_write, gdb_lasterr);
-
- /* Write the message plus any error_pre_print to gdb_stderr. */
- target_terminal_ours ();
- wrap_here (""); /* Force out any buffered output */
- gdb_flush (gdb_stdout);
- annotate_error_begin ();
- if (error_pre_print)
- fputs_filtered (error_pre_print, gdb_stderr);
- ui_file_put (stream, do_write, gdb_stderr);
- fprintf_filtered (gdb_stderr, "\n");
-
- throw_reason (reason);
-}
-
NORETURN void
error_stream (struct ui_file *stream)
{
- error_stream_1 (stream, RETURN_ERROR);
+ char *message = ui_file_xstrdup (stream, NULL);
+ make_cleanup (xfree, message);
+ error (("%s"), message);
}
-/* Get the last error message issued by gdb */
+/* Allow the user to configure the debugger behavior with respect to
+ what to do when an internal problem is detected. */
-char *
-error_last_message (void)
+const char internal_problem_ask[] = "ask";
+const char internal_problem_yes[] = "yes";
+const char internal_problem_no[] = "no";
+static const char *internal_problem_modes[] =
{
- long len;
- return ui_file_xstrdup (gdb_lasterr, &len);
-}
-
-/* This is to be called by main() at the very beginning */
-
-void
-error_init (void)
-{
- gdb_lasterr = mem_fileopen ();
-}
+ internal_problem_ask,
+ internal_problem_yes,
+ internal_problem_no,
+ NULL
+};
+static const char *internal_problem_mode = internal_problem_ask;
/* Print a message reporting an internal error/warning. Ask the user
if they want to continue, dump core, or just exit. Return
struct internal_problem
{
const char *name;
- /* FIXME: cagney/2002-08-15: There should be ``maint set/show''
- commands available for controlling these variables. */
- enum auto_boolean should_quit;
- enum auto_boolean should_dump_core;
+ const char *should_quit;
+ const char *should_dump_core;
};
/* Report a problem, internal to GDB, to the user. Once the problem
has been reported, and assuming GDB didn't quit, the caller can
either allow execution to resume or throw an error. */
-static void
+static void ATTR_FORMAT (printf, 4, 0)
internal_vproblem (struct internal_problem *problem,
const char *file, int line, const char *fmt, va_list ap)
{
case 1:
dejavu = 2;
fputs_unfiltered (msg, gdb_stderr);
- abort (); /* NOTE: GDB has only three calls to abort(). */
+ abort (); /* NOTE: GDB has only four calls to abort(). */
default:
dejavu = 3;
- write (STDERR_FILENO, msg, sizeof (msg));
+ /* 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 four calls to abort(). */
exit (1);
}
}
make_cleanup (xfree, reason);
}
- switch (problem->should_quit)
+ if (problem->should_quit == internal_problem_ask)
{
- case AUTO_BOOLEAN_AUTO:
/* Default (yes/batch case) is to quit GDB. When in batch mode
- this lessens the likelhood of GDB going into an infinate
- loop. */
- quit_p = query ("%s\nQuit this debugging session? ", reason);
- break;
- case AUTO_BOOLEAN_TRUE:
- quit_p = 1;
- break;
- case AUTO_BOOLEAN_FALSE:
- quit_p = 0;
- break;
- default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ this lessens the likelihood of GDB going into an infinite
+ loop. */
+ if (caution == 0)
+ {
+ /* Emit the message and quit. */
+ fputs_unfiltered (reason, gdb_stderr);
+ fputs_unfiltered ("\n", gdb_stderr);
+ quit_p = 1;
+ }
+ else
+ quit_p = query (_("%s\nQuit this debugging session? "), reason);
}
+ else if (problem->should_quit == internal_problem_yes)
+ quit_p = 1;
+ else if (problem->should_quit == internal_problem_no)
+ quit_p = 0;
+ else
+ internal_error (__FILE__, __LINE__, _("bad switch"));
- switch (problem->should_dump_core)
+ if (problem->should_dump_core == internal_problem_ask)
{
- case AUTO_BOOLEAN_AUTO:
/* Default (yes/batch case) is to dump core. This leaves a GDB
`dropping' so that it is easier to see that something went
wrong in GDB. */
- dump_core_p = query ("%s\nCreate a core file of GDB? ", reason);
- break;
- break;
- case AUTO_BOOLEAN_TRUE:
- dump_core_p = 1;
- break;
- case AUTO_BOOLEAN_FALSE:
- dump_core_p = 0;
- break;
- default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ dump_core_p = query (_("%s\nCreate a core file of GDB? "), reason);
}
+ else if (problem->should_dump_core == internal_problem_yes)
+ dump_core_p = 1;
+ else if (problem->should_dump_core == internal_problem_no)
+ dump_core_p = 0;
+ else
+ internal_error (__FILE__, __LINE__, _("bad switch"));
if (quit_p)
{
if (dump_core_p)
- abort (); /* NOTE: GDB has only three calls to abort(). */
+ abort (); /* NOTE: GDB has only four calls to abort(). */
else
exit (1);
}
{
if (dump_core_p)
{
+#ifdef HAVE_WORKING_FORK
if (fork () == 0)
- abort (); /* NOTE: GDB has only three calls to abort(). */
+ abort (); /* NOTE: GDB has only four calls to abort(). */
+#endif
}
}
}
static struct internal_problem internal_error_problem = {
- "internal-error", AUTO_BOOLEAN_AUTO, AUTO_BOOLEAN_AUTO
+ "internal-error", internal_problem_ask, internal_problem_ask
};
NORETURN void
internal_verror (const char *file, int line, const char *fmt, va_list ap)
{
internal_vproblem (&internal_error_problem, file, line, fmt, ap);
- throw_reason (RETURN_ERROR);
+ deprecated_throw_reason (RETURN_ERROR);
}
NORETURN void
}
static struct internal_problem internal_warning_problem = {
- "internal-warning", AUTO_BOOLEAN_AUTO, AUTO_BOOLEAN_AUTO
+ "internal-warning", internal_problem_ask, internal_problem_ask
};
void
va_end (ap);
}
-/* The strerror() function can return NULL for errno values that are
- out of range. Provide a "safe" version that always returns a
- printable string. */
+/* Dummy functions to keep add_prefix_cmd happy. */
-char *
-safe_strerror (int errnum)
+static void
+set_internal_problem_cmd (char *args, int from_tty)
{
- char *msg;
- static char buf[32];
+}
- msg = strerror (errnum);
- if (msg == NULL)
- {
- sprintf (buf, "(undocumented errno %d)", errnum);
- msg = buf;
- }
- return (msg);
+static void
+show_internal_problem_cmd (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
+ that make it possible to specify that GDB should always or never
+ quit or create a core file, without asking. The commands look
+ like:
+
+ maint set PROBLEM-NAME quit ask|yes|no
+ maint show PROBLEM-NAME quit
+ maint set PROBLEM-NAME corefile ask|yes|no
+ maint show PROBLEM-NAME corefile
+
+ Where PROBLEM-NAME is currently "internal-error" or
+ "internal-warning". */
+
+static void
+add_internal_problem_command (struct internal_problem *problem)
+{
+ struct cmd_list_element **set_cmd_list;
+ struct cmd_list_element **show_cmd_list;
+ char *set_doc;
+ char *show_doc;
+
+ set_cmd_list = xmalloc (sizeof (*set_cmd_list));
+ show_cmd_list = xmalloc (sizeof (*set_cmd_list));
+ *set_cmd_list = NULL;
+ *show_cmd_list = NULL;
+
+ set_doc = xstrprintf (_("Configure what GDB does when %s is detected."),
+ problem->name);
+
+ show_doc = xstrprintf (_("Show what GDB does when %s is detected."),
+ problem->name);
+
+ add_prefix_cmd ((char*) problem->name,
+ class_maintenance, set_internal_problem_cmd, set_doc,
+ set_cmd_list,
+ concat ("maintenance set ", problem->name, " ", 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),
+ 0/*allow-unknown*/, &maintenance_show_cmdlist);
+
+ 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"),
+ problem->name);
+ add_setshow_enum_cmd ("quit", class_maintenance,
+ internal_problem_modes,
+ &problem->should_quit,
+ set_doc,
+ show_doc,
+ NULL, /* help_doc */
+ NULL, /* setfunc */
+ NULL, /* showfunc */
+ set_cmd_list,
+ show_cmd_list);
+
+ xfree (set_doc);
+ xfree (show_doc);
+
+ 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"),
+ problem->name);
+ add_setshow_enum_cmd ("corefile", class_maintenance,
+ internal_problem_modes,
+ &problem->should_dump_core,
+ set_doc,
+ show_doc,
+ NULL, /* help_doc */
+ NULL, /* setfunc */
+ NULL, /* showfunc */
+ set_cmd_list,
+ show_cmd_list);
+
+ xfree (set_doc);
+ xfree (show_doc);
}
/* Print the system error message for errno, and also mention STRING
bfd_set_error (bfd_error_no_error);
errno = 0;
- error ("%s.", combined);
+ error (_("%s."), combined);
}
/* Print the system error message for ERRCODE, and also mention STRING
void
quit (void)
{
- struct serial *gdb_stdout_serial = serial_fdopen (1);
-
- target_terminal_ours ();
-
- /* We want all output to appear now, before we print "Quit". We
- have 3 levels of buffering we have to flush (it's possible that
- some of these should be changed to flush the lower-level ones
- too): */
-
- /* 1. The _filtered buffer. */
- wrap_here ((char *) 0);
-
- /* 2. The stdio buffer. */
- gdb_flush (gdb_stdout);
- gdb_flush (gdb_stderr);
-
- /* 3. The system-level buffer. */
- serial_drain_output (gdb_stdout_serial);
- serial_un_fdopen (gdb_stdout_serial);
-
- annotate_error_begin ();
-
- /* Don't use *_filtered; we don't want to prompt the user to continue. */
- if (quit_pre_print)
- fputs_unfiltered (quit_pre_print, gdb_stderr);
-
#ifdef __MSDOS__
/* No steenking SIGINT will ever be coming our way when the
program is resumed. Don't lie. */
- fprintf_unfiltered (gdb_stderr, "Quit\n");
+ fatal ("Quit");
#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. */
|| current_target.to_terminal_ours == NULL)
- fprintf_unfiltered (gdb_stderr, "Quit\n");
+ fatal ("Quit");
else
- fprintf_unfiltered (gdb_stderr,
- "Quit (expect signal SIGINT when the program is resumed)\n");
+ fatal ("Quit (expect signal SIGINT when the program is resumed)");
#endif
- throw_reason (RETURN_QUIT);
}
-/* Control C comes here */
-void
-request_quit (int signo)
-{
- quit_flag = 1;
- /* Restore the signal handler. Harmless with BSD-style signals,
- needed for System V-style signals. */
- signal (signo, request_quit);
-
- if (immediate_quit)
- quit ();
-}
\f
/* Called when a memory allocation fails, with the number of bytes of
memory requested in SIZE. */
if (size > 0)
{
internal_error (__FILE__, __LINE__,
- "virtual memory exhausted: can't allocate %ld bytes.",
+ _("virtual memory exhausted: can't allocate %ld bytes."),
size);
}
else
{
- internal_error (__FILE__, __LINE__, "virtual memory exhausted.");
+ internal_error (__FILE__, __LINE__, _("virtual memory exhausted."));
}
}
/* NOTE: These are declared using PTR to ensure consistency with
"libiberty.h". xfree() is GDB local. */
-PTR /* OK: PTR */
+PTR /* ARI: PTR */
xmalloc (size_t size)
{
void *val;
if (size == 0)
size = 1;
- val = malloc (size); /* OK: malloc */
+ val = malloc (size); /* ARI: malloc */
if (val == NULL)
nomem (size);
return (val);
}
-PTR /* OK: PTR */
-xrealloc (PTR ptr, size_t size) /* OK: PTR */
+void *
+xzalloc (size_t size)
+{
+ return xcalloc (1, size);
+}
+
+PTR /* ARI: PTR */
+xrealloc (PTR ptr, size_t size) /* ARI: PTR */
{
void *val;
size = 1;
if (ptr != NULL)
- val = realloc (ptr, size); /* OK: realloc */
+ val = realloc (ptr, size); /* ARI: realloc */
else
- val = malloc (size); /* OK: malloc */
+ val = malloc (size); /* ARI: malloc */
if (val == NULL)
nomem (size);
return (val);
}
-PTR /* OK: PTR */
+PTR /* ARI: PTR */
xcalloc (size_t number, size_t size)
{
void *mem;
size = 1;
}
- mem = calloc (number, size); /* OK: xcalloc */
+ mem = calloc (number, size); /* ARI: xcalloc */
if (mem == NULL)
nomem (number * size);
xfree (void *ptr)
{
if (ptr != NULL)
- free (ptr); /* OK: free */
+ free (ptr); /* ARI: free */
}
\f
{
char *ret = NULL;
int status = vasprintf (&ret, format, ap);
- /* NULL is returned when there was a memory allocation problem. */
- if (ret == NULL)
- nomem (0);
- /* A negative status (the printed length) with a non-NULL buffer
- should never happen, but just to be sure. */
- if (status < 0)
- internal_error (__FILE__, __LINE__,
- "vasprintf call failed (errno %d)", errno);
+ /* 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
+ happen, but just to be sure. */
+ if (ret == NULL || status < 0)
+ internal_error (__FILE__, __LINE__, _("vasprintf call failed"));
+ return ret;
+}
+
+int
+xsnprintf (char *str, size_t size, const char *format, ...)
+{
+ va_list args;
+ int ret;
+
+ va_start (args, format);
+ ret = vsnprintf (str, size, format, args);
+ gdb_assert (ret < size);
+ va_end (args);
+
return ret;
}
\f
/* Make a copy of the string at PTR with SIZE characters
(and add a null character at the end in the copy).
- Uses malloc to get the space. Returns the address of the copy. */
-
-char *
-savestring (const char *ptr, size_t size)
-{
- char *p = (char *) xmalloc (size + 1);
- memcpy (p, ptr, size);
- p[size] = 0;
- return p;
-}
-
-void
-print_spaces (int n, struct ui_file *file)
-{
- fputs_unfiltered (n_spaces (n), file);
-}
-
-/* Print a host address. */
-
-void
-gdb_print_host_address (const void *addr, struct ui_file *stream)
-{
-
- /* We could use the %p conversion specifier to fprintf if we had any
- way of knowing whether this host supports it. But the following
- should work on the Alpha and on 32 bit machines. */
-
- fprintf_filtered (stream, "0x%lx", (unsigned long) addr);
-}
-
-/* Ask user a y-or-n question and return 1 iff answer is yes.
- Takes three args which are given to printf to print the question.
- The first, a control string, should end in "? ".
- It should not say how to answer, because we do that. */
-
-/* VARARGS */
-int
-query (const char *ctlstr, ...)
-{
- va_list args;
- int answer;
- int ans2;
- int retval;
-
- if (deprecated_query_hook)
- {
- va_start (args, ctlstr);
- return deprecated_query_hook (ctlstr, args);
- }
-
- /* Automatically answer "yes" if input is not from a terminal. */
- if (!input_from_terminal_p ())
- return 1;
-
- while (1)
- {
- wrap_here (""); /* Flush any buffered output */
- gdb_flush (gdb_stdout);
-
- if (annotation_level > 1)
- printf_filtered ("\n\032\032pre-query\n");
-
- va_start (args, ctlstr);
- vfprintf_filtered (gdb_stdout, ctlstr, args);
- va_end (args);
- printf_filtered ("(y or n) ");
-
- if (annotation_level > 1)
- printf_filtered ("\n\032\032query\n");
+ Uses malloc to get the space. Returns the address of the copy. */
- wrap_here ("");
- gdb_flush (gdb_stdout);
+char *
+savestring (const char *ptr, size_t size)
+{
+ char *p = (char *) xmalloc (size + 1);
+ memcpy (p, ptr, size);
+ p[size] = 0;
+ return p;
+}
- answer = fgetc (stdin);
- clearerr (stdin); /* in case of C-d */
- if (answer == EOF) /* C-d */
- {
- retval = 1;
- break;
- }
- /* Eat rest of input line, to EOF or newline */
- if (answer != '\n')
- do
- {
- ans2 = fgetc (stdin);
- clearerr (stdin);
- }
- while (ans2 != EOF && ans2 != '\n' && ans2 != '\r');
+void
+print_spaces (int n, struct ui_file *file)
+{
+ fputs_unfiltered (n_spaces (n), file);
+}
- if (answer >= 'a')
- answer -= 040;
- if (answer == 'Y')
- {
- retval = 1;
- break;
- }
- if (answer == 'N')
- {
- retval = 0;
- break;
- }
- printf_filtered ("Please answer y or n.\n");
- }
+/* Print a host address. */
- if (annotation_level > 1)
- printf_filtered ("\n\032\032post-query\n");
- return retval;
+void
+gdb_print_host_address (const void *addr, struct ui_file *stream)
+{
+ fprintf_filtered (stream, "%s", host_address_to_string (addr));
}
\f
-/* This function supports the nquery() and yquery() functions.
+/* 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.
- DEFCHAR is either 'y' or 'n' and refers to the default answer.
+ answer is yes, or default the answer to the specified default
+ (for yquery or nquery). DEFCHAR may be 'y' or 'n' to provide a
+ default answer, or '\0' for no default.
CTLSTR is the control string and should end in "? ". It should
not say how to answer, because we do that.
ARGS are the arguments passed along with the CTLSTR argument to
printf. */
-static int
+static int ATTR_FORMAT (printf, 1, 0)
defaulted_query (const char *ctlstr, const char defchar, va_list args)
{
int answer;
int retval;
int def_value;
char def_answer, not_def_answer;
- char *y_string, *n_string;
+ char *y_string, *n_string, *question;
/* Set up according to which answer is the default. */
- if (defchar == 'y')
+ if (defchar == '\0')
+ {
+ def_value = 1;
+ def_answer = 'Y';
+ not_def_answer = 'N';
+ y_string = "y";
+ n_string = "n";
+ }
+ else if (defchar == 'y')
{
def_value = 1;
def_answer = 'Y';
n_string = "[n]";
}
+ /* Automatically answer the default value if the user did not want
+ prompts or the command was issued with the server prefix. */
+ if (! caution || server_command)
+ return def_value;
+
+ /* If input isn't coming from the user directly, just say what
+ question we're asking, and then answer the default automatically. This
+ way, important error messages don't get lost when talking to GDB
+ over a pipe. */
+ if (! input_from_terminal_p ())
+ {
+ wrap_here ("");
+ vfprintf_filtered (gdb_stdout, ctlstr, args);
+
+ 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 (deprecated_query_hook)
{
return deprecated_query_hook (ctlstr, args);
}
- /* Automatically answer default value if input is not from a terminal. */
- if (!input_from_terminal_p ())
- return def_value;
+ /* Format the question outside of the loop, to avoid reusing args. */
+ question = xstrvprintf (ctlstr, args);
while (1)
{
gdb_flush (gdb_stdout);
if (annotation_level > 1)
- printf_filtered ("\n\032\032pre-query\n");
+ printf_filtered (("\n\032\032pre-query\n"));
- vfprintf_filtered (gdb_stdout, ctlstr, args);
- printf_filtered ("(%s or %s) ", y_string, n_string);
+ fputs_filtered (question, gdb_stdout);
+ printf_filtered (_("(%s or %s) "), y_string, n_string);
if (annotation_level > 1)
- printf_filtered ("\n\032\032query\n");
+ printf_filtered (("\n\032\032query\n"));
wrap_here ("");
gdb_flush (gdb_stdout);
answer = fgetc (stdin);
+
+ /* We expect fgetc to block until a character is read. But
+ this may not be the case if the terminal was opened with
+ the NONBLOCK flag. In that case, if there is nothing to
+ read on stdin, fgetc returns EOF, but also sets the error
+ condition flag on stdin and errno to EAGAIN. With a true
+ EOF, stdin's error condition flag is not set.
+
+ A situation where this behavior was observed is a pseudo
+ terminal on AIX. */
+ while (answer == EOF && ferror (stdin) && errno == EAGAIN)
+ {
+ /* Not a real EOF. Wait a little while and try again until
+ we read something. */
+ clearerr (stdin);
+ gdb_usleep (10000);
+ answer = fgetc (stdin);
+ }
+
clearerr (stdin); /* in case of C-d */
if (answer == EOF) /* C-d */
{
+ printf_filtered ("EOF [assumed %c]\n", def_answer);
retval = def_value;
break;
}
retval = !def_value;
break;
}
- /* Otherwise, for the default, the user may either specify
- the required input or have it default by entering nothing. */
- if (answer == def_answer || answer == '\n' ||
- answer == '\r' || answer == EOF)
+ /* Otherwise, if a default was specified, the user may either
+ specify the required input or have it default by entering
+ nothing. */
+ if (answer == def_answer
+ || (defchar != '\0' &&
+ (answer == '\n' || answer == '\r' || answer == EOF)))
{
retval = def_value;
break;
}
/* Invalid entries are not defaulted and require another selection. */
- printf_filtered ("Please answer %s or %s.\n",
+ printf_filtered (_("Please answer %s or %s.\n"),
y_string, n_string);
}
+ xfree (question);
if (annotation_level > 1)
- printf_filtered ("\n\032\032post-query\n");
+ printf_filtered (("\n\032\032post-query\n"));
return retval;
}
\f
va_end (args);
}
-/* Print an error message saying that we couldn't make sense of a
- \^mumble sequence in a string or character constant. START and END
- indicate a substring of some larger string that contains the
- erroneous backslash sequence, missing the initial backslash. */
-static NORETURN int
-no_control_char_error (const char *start, const char *end)
+/* Ask user a y-or-n question and return 1 iff answer is yes.
+ Takes three args which are given to printf to print the question.
+ The first, a control string, should end in "? ".
+ It should not say how to answer, because we do that. */
+
+int
+query (const char *ctlstr, ...)
+{
+ va_list args;
+
+ va_start (args, ctlstr);
+ return defaulted_query (ctlstr, '\0', args);
+ va_end (args);
+}
+
+/* A helper for parse_escape that converts a host character to a
+ target character. C is the host character. If conversion is
+ possible, then the target character is stored in *TARGET_C and the
+ function returns 1. Otherwise, the function returns 0. */
+
+static int
+host_char_to_target (int c, int *target_c)
{
- int len = end - start;
- char *copy = alloca (end - start + 1);
+ struct obstack host_data;
+ char the_char = c;
+ struct cleanup *cleanups;
+ int result = 0;
+
+ obstack_init (&host_data);
+ cleanups = make_cleanup_obstack_free (&host_data);
- memcpy (copy, start, len);
- copy[len] = '\0';
+ convert_between_encodings (target_charset (), host_charset (),
+ &the_char, 1, 1, &host_data, translit_none);
- error ("There is no control character `\\%s' in the `%s' character set.",
- copy, target_charset ());
+ if (obstack_object_size (&host_data) == 1)
+ {
+ result = 1;
+ *target_c = *(char *) obstack_base (&host_data);
+ }
+
+ do_cleanups (cleanups);
+ return result;
}
/* Parse a C escape sequence. STRING_PTR points to a variable
int
parse_escape (char **string_ptr)
{
- int target_char;
+ int target_char = -2; /* initialize to avoid GCC warnings */
int c = *(*string_ptr)++;
- if (c_parse_backslash (c, &target_char))
- return target_char;
- else
- switch (c)
- {
+ switch (c)
+ {
case '\n':
return -2;
case 0:
(*string_ptr)--;
return 0;
- case '^':
- {
- /* Remember where this escape sequence started, for reporting
- errors. */
- char *sequence_start_pos = *string_ptr - 1;
-
- c = *(*string_ptr)++;
-
- if (c == '?')
- {
- /* XXXCHARSET: What is `delete' in the host character set? */
- c = 0177;
-
- if (!host_char_to_target (c, &target_char))
- error ("There is no character corresponding to `Delete' "
- "in the target character set `%s'.", host_charset ());
-
- return target_char;
- }
- else if (c == '\\')
- target_char = parse_escape (string_ptr);
- else
- {
- if (!host_char_to_target (c, &target_char))
- no_control_char_error (sequence_start_pos, *string_ptr);
- }
-
- /* Now target_char is something like `c', and we want to find
- its control-character equivalent. */
- if (!target_char_to_control_char (target_char, &target_char))
- no_control_char_error (sequence_start_pos, *string_ptr);
-
- return target_char;
- }
-
- /* XXXCHARSET: we need to use isdigit and value-of-digit
- methods of the host character set here. */
case '0':
case '1':
case '6':
case '7':
{
- int i = c - '0';
+ int i = host_hex_value (c);
int count = 0;
while (++count < 3)
{
c = (**string_ptr);
- if (c >= '0' && c <= '7')
+ if (isdigit (c) && c != '8' && c != '9')
{
(*string_ptr)++;
i *= 8;
- i += c - '0';
+ i += host_hex_value (c);
}
else
{
}
return i;
}
- default:
- if (!host_char_to_target (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 ());
- return target_char;
- }
+
+ case 'a':
+ c = '\a';
+ break;
+ case 'b':
+ c = '\b';
+ break;
+ case 'f':
+ c = '\f';
+ break;
+ case 'n':
+ c = '\n';
+ break;
+ case 'r':
+ c = '\r';
+ break;
+ case 't':
+ c = '\t';
+ break;
+ case 'v':
+ c = '\v';
+ break;
+
+ default:
+ break;
+ }
+
+ if (!host_char_to_target (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 ());
+ return target_char;
}
\f
/* Print the character C on STREAM as part of the contents of a literal
static void
printchar (int c, void (*do_fputs) (const char *, struct ui_file *),
- void (*do_fprintf) (struct ui_file *, const char *, ...),
- struct ui_file *stream, int quoter)
+ void (*do_fprintf) (struct ui_file *, const char *, ...)
+ ATTRIBUTE_FPTR_PRINTF_2, struct ui_file *stream, int quoter)
{
c &= 0xFF; /* Avoid sign bit follies */
printchar (*str++, fputs_unfiltered, fprintf_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);
+}
+
void
fputstrn_unfiltered (const char *str, int n, int quoter,
struct ui_file *stream)
/* Number of lines per page or UINT_MAX if paging is disabled. */
static unsigned int lines_per_page;
+static void
+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"),
+ value);
+}
/* Number of chars per line or UINT_MAX if line folding is disabled. */
static unsigned int chars_per_line;
+static void
+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"),
+ value);
+}
/* Current count of lines printed on this page, chars on this line. */
static unsigned int lines_printed, chars_printed;
rows = INT_MAX;
if (cols <= 0)
- rl_get_screen_size (NULL, &cols);
+ cols = INT_MAX;
/* Update Readline's idea of the terminal size. */
rl_set_screen_size (rows, cols);
char cont_prompt[120];
if (annotation_level > 1)
- printf_unfiltered ("\n\032\032pre-prompt-for-continue\n");
+ printf_unfiltered (("\n\032\032pre-prompt-for-continue\n"));
strcpy (cont_prompt,
"---Type <return> to continue, or q <return> to quit---");
ignore = gdb_readline_wrapper (cont_prompt);
if (annotation_level > 1)
- printf_unfiltered ("\n\032\032post-prompt-for-continue\n");
+ printf_unfiltered (("\n\032\032post-prompt-for-continue\n"));
if (ignore)
{
{
/* 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])
{
linebuffer = xstrvprintf (format, args);
old_cleanups = make_cleanup (xfree, linebuffer);
- fputs_unfiltered (linebuffer, stream);
+ if (debug_timestamp && stream == gdb_stdlog)
+ {
+ struct timeval tm;
+ char *timestamp;
+ int len, need_nl;
+
+ gettimeofday (&tm, NULL);
+
+ len = strlen (linebuffer);
+ need_nl = (len > 0 && linebuffer[len - 1] != '\n');
+
+ timestamp = xstrprintf ("%ld:%ld %s%s",
+ (long) tm.tv_sec, (long) tm.tv_usec,
+ linebuffer,
+ need_nl ? "\n": "");
+ make_cleanup (xfree, timestamp);
+ fputs_unfiltered (timestamp, stream);
+ }
+ else
+ fputs_unfiltered (linebuffer, stream);
do_cleanups (old_cleanups);
}
return match;
}
-
-static void pagination_on_command (char *arg, int from_tty);
static void
pagination_on_command (char *arg, int from_tty)
{
pagination_enabled = 1;
}
-static void pagination_on_command (char *arg, int from_tty);
static void
pagination_off_command (char *arg, int from_tty)
{
pagination_enabled = 0;
}
+
+static void
+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);
+}
\f
void
{
struct cmd_list_element *c;
- c = add_set_cmd ("width", class_support, var_uinteger, &chars_per_line,
- "Set number of characters gdb thinks are in a line.",
- &setlist);
- deprecated_add_show_from_set (c, &showlist);
- set_cmd_sfunc (c, set_width_command);
+ 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,
+ set_width_command,
+ show_chars_per_line,
+ &setlist, &showlist);
- c = add_set_cmd ("height", class_support, var_uinteger, &lines_per_page,
- "Set number of lines gdb thinks are in a page.", &setlist);
- deprecated_add_show_from_set (c, &showlist);
- set_cmd_sfunc (c, set_height_command);
+ add_setshow_uinteger_cmd ("height", class_support, &lines_per_page, _("\
+Set number of lines gdb thinks are in a page."), _("\
+Show number of lines gdb thinks are in a page."), NULL,
+ set_height_command,
+ show_lines_per_page,
+ &setlist, &showlist);
init_page_info ();
- deprecated_add_show_from_set
- (add_set_cmd ("demangle", class_support, var_boolean,
- (char *) &demangle,
- "Set demangling of encoded C++/ObjC names when displaying symbols.",
- &setprintlist), &showprintlist);
-
- deprecated_add_show_from_set
- (add_set_cmd ("pagination", class_support,
- var_boolean, (char *) &pagination_enabled,
- "Set state of pagination.", &setlist), &showlist);
+ add_setshow_boolean_cmd ("demangle", class_support, &demangle, _("\
+Set demangling of encoded C++/ObjC names when displaying symbols."), _("\
+Show demangling of encoded C++/ObjC names when displaying symbols."), NULL,
+ NULL,
+ show_demangle,
+ &setprintlist, &showprintlist);
+
+ add_setshow_boolean_cmd ("pagination", class_support,
+ &pagination_enabled, _("\
+Set state of pagination."), _("\
+Show state of pagination."), NULL,
+ NULL,
+ show_pagination_enabled,
+ &setlist, &showlist);
if (xdb_commands)
{
add_com ("am", class_support, pagination_on_command,
- "Enable pagination");
+ _("Enable pagination"));
add_com ("sm", class_support, pagination_off_command,
- "Disable pagination");
+ _("Disable pagination"));
}
- deprecated_add_show_from_set
- (add_set_cmd ("sevenbit-strings", class_support, var_boolean,
- (char *) &sevenbit_strings,
- "Set printing of 8-bit characters in strings as \\nnn.",
- &setprintlist), &showprintlist);
-
- deprecated_add_show_from_set
- (add_set_cmd ("asm-demangle", class_support, var_boolean,
- (char *) &asm_demangle,
- "Set demangling of C++/ObjC names in disassembly listings.",
- &setprintlist), &showprintlist);
+ 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 ("asm-demangle", class_support, &asm_demangle, _("\
+Set demangling of C++/ObjC names in disassembly listings."), _("\
+Show demangling of C++/ObjC names in disassembly listings."), NULL,
+ NULL,
+ show_asm_demangle,
+ &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);
}
/* Machine specific function to handle SIGWINCH signal. */
return buf[cell];
}
-int
-strlen_paddr (void)
+const char *
+paddress (struct gdbarch *gdbarch, CORE_ADDR addr)
{
- return (TARGET_ADDR_BIT / 8 * 2);
-}
+ /* 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. */
+ /* 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
+ some ADDRESS_TO_PRINTABLE() be used to do the conversion? */
-char *
-paddr (CORE_ADDR addr)
-{
- return phex (addr, TARGET_ADDR_BIT / 8);
-}
+ int addr_bit = gdbarch_addr_bit (gdbarch);
-char *
-paddr_nz (CORE_ADDR addr)
-{
- return phex_nz (addr, TARGET_ADDR_BIT / 8);
+ if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
+ addr &= ((CORE_ADDR) 1 << addr_bit) - 1;
+ return hex_string (addr);
}
-static void
-decimal2str (char *paddr_str, char *sign, ULONGEST addr, int width)
+static char *
+decimal2str (char *sign, ULONGEST addr, int width)
{
- /* steal code from valprint.c:print_decimal(). Should this worry
+ /* Steal code from valprint.c:print_decimal(). Should this worry
about the real size of addr as the above does? */
unsigned long temp[3];
+ char *str = get_cell ();
+
int i = 0;
do
{
width -= 9;
}
while (addr != 0 && i < (sizeof (temp) / sizeof (temp[0])));
+
width += 9;
if (width < 0)
width = 0;
+
switch (i)
{
case 1:
- sprintf (paddr_str, "%s%0*lu", sign, width, temp[0]);
+ xsnprintf (str, CELLSIZE, "%s%0*lu", sign, width, temp[0]);
break;
case 2:
- sprintf (paddr_str, "%s%0*lu%09lu", sign, width, temp[1], temp[0]);
+ xsnprintf (str, CELLSIZE, "%s%0*lu%09lu", sign, width,
+ temp[1], temp[0]);
break;
case 3:
- sprintf (paddr_str, "%s%0*lu%09lu%09lu", sign, width,
- temp[2], temp[1], temp[0]);
+ xsnprintf (str, CELLSIZE, "%s%0*lu%09lu%09lu", sign, width,
+ temp[2], temp[1], temp[0]);
break;
default:
internal_error (__FILE__, __LINE__,
- "failed internal consistency check");
+ _("failed internal consistency check"));
}
+
+ return str;
}
-static void
-octal2str (char *paddr_str, ULONGEST addr, int width)
+static char *
+octal2str (ULONGEST addr, int width)
{
unsigned long temp[3];
+ char *str = get_cell ();
+
int i = 0;
do
{
width -= 10;
}
while (addr != 0 && i < (sizeof (temp) / sizeof (temp[0])));
+
width += 10;
if (width < 0)
width = 0;
+
switch (i)
{
case 1:
if (temp[0] == 0)
- sprintf (paddr_str, "%*o", width, 0);
+ xsnprintf (str, CELLSIZE, "%*o", width, 0);
else
- sprintf (paddr_str, "0%0*lo", width, temp[0]);
+ xsnprintf (str, CELLSIZE, "0%0*lo", width, temp[0]);
break;
case 2:
- sprintf (paddr_str, "0%0*lo%010lo", width, temp[1], temp[0]);
+ xsnprintf (str, CELLSIZE, "0%0*lo%010lo", width, temp[1], temp[0]);
break;
case 3:
- sprintf (paddr_str, "0%0*lo%010lo%010lo", width,
- temp[2], temp[1], temp[0]);
+ xsnprintf (str, CELLSIZE, "0%0*lo%010lo%010lo", width,
+ temp[2], temp[1], temp[0]);
break;
default:
internal_error (__FILE__, __LINE__,
- "failed internal consistency check");
+ _("failed internal consistency check"));
}
+
+ return str;
}
char *
-paddr_u (CORE_ADDR addr)
+pulongest (ULONGEST u)
{
- char *paddr_str = get_cell ();
- decimal2str (paddr_str, "", addr, 0);
- return paddr_str;
+ return decimal2str ("", u, 0);
}
char *
-paddr_d (LONGEST addr)
+plongest (LONGEST l)
{
- char *paddr_str = get_cell ();
- if (addr < 0)
- decimal2str (paddr_str, "-", -addr, 0);
+ if (l < 0)
+ return decimal2str ("-", -l, 0);
else
- decimal2str (paddr_str, "", addr, 0);
- return paddr_str;
+ return decimal2str ("", l, 0);
}
-/* eliminate warning from compiler on 32-bit systems */
+/* Eliminate warning from compiler on 32-bit systems. */
static int thirty_two = 32;
char *
phex (ULONGEST l, int sizeof_l)
{
char *str;
+
switch (sizeof_l)
{
case 8:
str = get_cell ();
- sprintf (str, "%08lx%08lx",
- (unsigned long) (l >> thirty_two),
- (unsigned long) (l & 0xffffffff));
+ xsnprintf (str, CELLSIZE, "%08lx%08lx",
+ (unsigned long) (l >> thirty_two),
+ (unsigned long) (l & 0xffffffff));
break;
case 4:
str = get_cell ();
- sprintf (str, "%08lx", (unsigned long) l);
+ xsnprintf (str, CELLSIZE, "%08lx", (unsigned long) l);
break;
case 2:
str = get_cell ();
- sprintf (str, "%04x", (unsigned short) (l & 0xffff));
+ xsnprintf (str, CELLSIZE, "%04x", (unsigned short) (l & 0xffff));
break;
default:
str = phex (l, sizeof (l));
break;
}
+
return str;
}
phex_nz (ULONGEST l, int sizeof_l)
{
char *str;
+
switch (sizeof_l)
{
case 8:
unsigned long high = (unsigned long) (l >> thirty_two);
str = get_cell ();
if (high == 0)
- sprintf (str, "%lx", (unsigned long) (l & 0xffffffff));
+ xsnprintf (str, CELLSIZE, "%lx",
+ (unsigned long) (l & 0xffffffff));
else
- sprintf (str, "%lx%08lx", high, (unsigned long) (l & 0xffffffff));
+ xsnprintf (str, CELLSIZE, "%lx%08lx", high,
+ (unsigned long) (l & 0xffffffff));
break;
}
case 4:
str = get_cell ();
- sprintf (str, "%lx", (unsigned long) l);
+ xsnprintf (str, CELLSIZE, "%lx", (unsigned long) l);
break;
case 2:
str = get_cell ();
- sprintf (str, "%x", (unsigned short) (l & 0xffff));
+ xsnprintf (str, CELLSIZE, "%x", (unsigned short) (l & 0xffff));
break;
default:
str = phex_nz (l, sizeof (l));
break;
}
+
return str;
}
hex_string (LONGEST num)
{
char *result = get_cell ();
- snprintf (result, CELLSIZE, "0x%s", phex_nz (num, sizeof (num)));
+ xsnprintf (result, CELLSIZE, "0x%s", phex_nz (num, sizeof (num)));
return result;
}
width = hex_len;
if (width + 2 >= CELLSIZE)
internal_error (__FILE__, __LINE__,
- "hex_string_custom: insufficient space to store result");
+ _("hex_string_custom: insufficient space to store result"));
strcpy (result_end - width - 2, "0x");
memset (result_end - width, '0', width);
}
case 10:
{
- char *result = get_cell ();
if (is_signed && val < 0)
- decimal2str (result, "-", -val, width);
+ return decimal2str ("-", -val, width);
else
- decimal2str (result, "", val, width);
- return result;
+ return decimal2str ("", val, width);
}
case 8:
{
- char *result = get_cell ();
- octal2str (result, val, width);
+ char *result = octal2str (val, width);
if (use_c_format || val == 0)
return result;
else
}
default:
internal_error (__FILE__, __LINE__,
- "failed internal consistency check");
+ _("failed internal consistency check"));
}
}
string_to_core_addr (const char *my_string)
{
CORE_ADDR addr = 0;
+
if (my_string[0] == '0' && tolower (my_string[1]) == 'x')
{
- /* Assume that it is in decimal. */
+ /* Assume that it is in hex. */
int i;
for (i = 2; my_string[i] != '\0'; i++)
{
else if (isxdigit (my_string[i]))
addr = (tolower (my_string[i]) - 'a' + 0xa) + (addr * 16);
else
- internal_error (__FILE__, __LINE__, "invalid hex");
+ error (_("invalid hex \"%s\""), my_string);
}
}
else
if (isdigit (my_string[i]))
addr = (my_string[i] - '0') + (addr * 10);
else
- internal_error (__FILE__, __LINE__, "invalid decimal");
+ error (_("invalid decimal \"%s\""), my_string);
}
}
+
return addr;
}
+const char *
+host_address_to_string (const void *addr)
+{
+ char *str = get_cell ();
+
+ xsnprintf (str, CELLSIZE, "0x%s", phex_nz ((uintptr_t) addr, sizeof (addr)));
+ return str;
+}
+
char *
gdb_realpath (const char *filename)
{
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, NULL);
+ result = concat (real_path, base_name, (char *)NULL);
else
- result = concat (real_path, SLASH_STRING, base_name, NULL);
+ result = concat (real_path, SLASH_STRING, base_name, (char *)NULL);
xfree (real_path);
return result;
unsigned long
gnu_debuglink_crc32 (unsigned long crc, unsigned char *buf, size_t len)
{
- static const unsigned long crc32_table[256] = {
+ static const unsigned int crc32_table[256] = {
0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
gdb_assert (n && (n & (n-1)) == 0);
return (v & -n);
}
+
+/* Allocation function for the libiberty hash table which uses an
+ obstack. The obstack is passed as DATA. */
+
+void *
+hashtab_obstack_allocate (void *data, size_t size, size_t count)
+{
+ unsigned int total = size * count;
+ void *ptr = obstack_alloc ((struct obstack *) data, total);
+ memset (ptr, 0, total);
+ return ptr;
+}
+
+/* Trivial deallocation function for the libiberty splay tree and hash
+ table - don't deallocate anything. Rely on later deletion of the
+ obstack. DATA will be the obstack, although it is not needed
+ here. */
+
+void
+dummy_obstack_deallocate (void *object, void *data)
+{
+ return;
+}
+
+/* The bit offset of the highest byte in a ULONGEST, for overflow
+ checking. */
+
+#define HIGH_BYTE_POSN ((sizeof (ULONGEST) - 1) * HOST_CHAR_BIT)
+
+/* True (non-zero) iff DIGIT is a valid digit in radix BASE,
+ where 2 <= BASE <= 36. */
+
+static int
+is_digit_in_base (unsigned char digit, int base)
+{
+ if (!isalnum (digit))
+ return 0;
+ if (base <= 10)
+ return (isdigit (digit) && digit < base + '0');
+ else
+ return (isdigit (digit) || tolower (digit) < base - 10 + 'a');
+}
+
+static int
+digit_to_int (unsigned char c)
+{
+ if (isdigit (c))
+ return c - '0';
+ else
+ return tolower (c) - 'a' + 10;
+}
+
+/* As for strtoul, but for ULONGEST results. */
+
+ULONGEST
+strtoulst (const char *num, const char **trailer, int base)
+{
+ unsigned int high_part;
+ ULONGEST result;
+ int minus = 0;
+ int i = 0;
+
+ /* Skip leading whitespace. */
+ while (isspace (num[i]))
+ i++;
+
+ /* Handle prefixes. */
+ if (num[i] == '+')
+ i++;
+ else if (num[i] == '-')
+ {
+ minus = 1;
+ i++;
+ }
+
+ if (base == 0 || base == 16)
+ {
+ if (num[i] == '0' && (num[i + 1] == 'x' || num[i + 1] == 'X'))
+ {
+ i += 2;
+ if (base == 0)
+ base = 16;
+ }
+ }
+
+ if (base == 0 && num[i] == '0')
+ base = 8;
+
+ if (base == 0)
+ base = 10;
+
+ if (base < 2 || base > 36)
+ {
+ errno = EINVAL;
+ return 0;
+ }
+
+ result = high_part = 0;
+ for (; is_digit_in_base (num[i], base); i += 1)
+ {
+ result = result * base + digit_to_int (num[i]);
+ high_part = high_part * base + (unsigned int) (result >> HIGH_BYTE_POSN);
+ result &= ((ULONGEST) 1 << HIGH_BYTE_POSN) - 1;
+ if (high_part > 0xff)
+ {
+ errno = ERANGE;
+ result = ~ (ULONGEST) 0;
+ high_part = 0;
+ minus = 0;
+ break;
+ }
+ }
+
+ if (trailer != NULL)
+ *trailer = &num[i];
+
+ result = result + ((ULONGEST) high_part << HIGH_BYTE_POSN);
+ if (minus)
+ return -result;
+ else
+ return result;
+}
+
+/* Simple, portable version of dirname that does not modify its
+ argument. */
+
+char *
+ldirname (const char *filename)
+{
+ const char *base = lbasename (filename);
+ char *dirname;
+
+ while (base > filename && IS_DIR_SEPARATOR (base[-1]))
+ --base;
+
+ if (base == filename)
+ return NULL;
+
+ dirname = xmalloc (base - filename + 2);
+ memcpy (dirname, filename, base - filename);
+
+ /* On DOS based file systems, convert "d:foo" to "d:.", so that we
+ create "d:./bar" later instead of the (different) "d:/bar". */
+ if (base - filename == 2 && IS_ABSOLUTE_PATH (base)
+ && !IS_DIR_SEPARATOR (filename[0]))
+ dirname[base++ - filename] = '.';
+
+ dirname[base - filename] = '\0';
+ return dirname;
+}
+
+/* Call libiberty's buildargv, and return the result.
+ If buildargv fails due to out-of-memory, call nomem.
+ Therefore, the returned value is guaranteed to be non-NULL,
+ unless the parameter itself is NULL. */
+
+char **
+gdb_buildargv (const char *s)
+{
+ char **argv = buildargv (s);
+ if (s != NULL && argv == NULL)
+ nomem (0);
+ return argv;
+}
+
+/* Provide a prototype to silence -Wmissing-prototypes. */
+extern initialize_file_ftype _initialize_utils;
+
+void
+_initialize_utils (void)
+{
+ add_internal_problem_command (&internal_error_problem);
+ add_internal_problem_command (&internal_warning_problem);
+}