/* Top level stuff for GDB, the GNU debugger.
- Copyright 1986, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 1998
- Free Software Foundation, Inc.
+ Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
+ 1996, 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
-This file is part of GDB.
+ 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
-(at your option) any later version.
+ 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
+ (at your option) any later version.
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ 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. */
+ 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. */
#include "defs.h"
#include "gdbcmd.h"
#include "call-cmds.h"
+#include "cli/cli-cmds.h"
+#include "cli/cli-script.h"
+#include "cli/cli-setshow.h"
#include "symtab.h"
#include "inferior.h"
-#include "signals.h"
+#include <signal.h>
#include "target.h"
#include "breakpoint.h"
#include "gdbtypes.h"
#include "expression.h"
#include "value.h"
#include "language.h"
-#include "terminal.h" /* For job_control. */
+#include "terminal.h" /* For job_control. */
#include "annotate.h"
+#include "completer.h"
#include "top.h"
-#include "event-loop.h"
+#include "version.h"
+#include "serial.h"
+#include "doublest.h"
/* readline include files */
#include <readline/readline.h>
#undef savestring
#include <sys/types.h>
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
+#include <setjmp.h>
+
+#include "event-top.h"
#include "gdb_string.h"
#include "gdb_stat.h"
#include <ctype.h>
-
-/* Prototypes for local functions */
-
-static void dont_repeat_command PARAMS ((char *, int));
-
-static void source_cleanup_lines PARAMS ((PTR));
-
-static void user_defined_command PARAMS ((char *, int));
-
-static void init_signals PARAMS ((void));
-
-#ifdef STOP_SIGNAL
-static void stop_sig PARAMS ((int));
-#endif
-
-static char * line_completion_function PARAMS ((char *, int, char *, int));
-
-static char * readline_line_completion_function PARAMS ((char *, int));
-
-/* NOTE 1999-04-29: this function will be static again, after we make the
- event loop be the default command loop for gdb, and we merge
- event-top.c into this file, top.c */
-/* static */ void command_loop_marker PARAMS ((int));
-
-static void while_command PARAMS ((char *, int));
-
-static void if_command PARAMS ((char *, int));
-
-static struct command_line *
-build_command_line PARAMS ((enum command_control_type, char *));
-
-static struct command_line *
-get_command_line PARAMS ((enum command_control_type, char *));
-
-static void realloc_body_list PARAMS ((struct command_line *, int));
-
-static enum misc_command_type read_next_line PARAMS ((struct command_line **));
-
-static enum command_control_type
-recurse_read_control_structure PARAMS ((struct command_line *));
-
-static struct cleanup * setup_user_args PARAMS ((char *));
-
-static char * locate_arg PARAMS ((char *));
-
-static char * insert_args PARAMS ((char *));
-
-static void arg_cleanup PARAMS ((void));
-
-static void init_main PARAMS ((void));
-
-static void init_cmd_lists PARAMS ((void));
-
-static void float_handler PARAMS ((int));
-
-static void init_signals PARAMS ((void));
-
-static void set_verbose PARAMS ((char *, int, struct cmd_list_element *));
-
-static void show_history PARAMS ((char *, int));
-
-static void set_history PARAMS ((char *, int));
-
-static void set_history_size_command PARAMS ((char *, int,
- struct cmd_list_element *));
-
-static void show_commands PARAMS ((char *, int));
-
-static void echo_command PARAMS ((char *, int));
-
-static void pwd_command PARAMS ((char *, int));
-
-static void show_version PARAMS ((char *, int));
-
-static void document_command PARAMS ((char *, int));
-
-static void define_command PARAMS ((char *, int));
-
-static void validate_comname PARAMS ((char *));
-
-static void help_command PARAMS ((char *, int));
-
-static void show_command PARAMS ((char *, int));
-
-static void info_command PARAMS ((char *, int));
-
-static void complete_command PARAMS ((char *, int));
-
-static void do_nothing PARAMS ((int));
-
-#ifdef SIGHUP
-/* NOTE 1999-04-29: This function will be static again, once we modify
- gdb to use the event loop as the default command loop and we merge
- event-top.c into this file, top.c */
-/* static */ int quit_cover PARAMS ((PTR));
-
-static void disconnect PARAMS ((int));
+#ifdef UI_OUT
+#include "ui-out.h"
+#include "cli-out.h"
#endif
-static void source_cleanup PARAMS ((FILE *));
+/* Default command line prompt. This is overriden in some configs. */
-/* If this definition isn't overridden by the header files, assume
- that isatty and fileno exist on this system. */
-#ifndef ISATTY
-#define ISATTY(FP) (isatty (fileno (FP)))
+#ifndef DEFAULT_PROMPT
+#define DEFAULT_PROMPT "(gdb) "
#endif
/* Initialization file name for gdb. This is overridden in some configs. */
int use_windows = 1;
-/* Version number of GDB, as a string. */
-
-extern char *version;
-
-/* Canonical host name as a string. */
-
-extern char *host_name;
-
-/* Canonical target name as a string. */
-
-extern char *target_name;
-
extern char lang_frame_mismatch_warn[]; /* language.c */
/* Flag for whether we want all the "from_tty" gubbish printed. */
-int caution = 1; /* Default is yes, sigh. */
-
-/* Define all cmd_list_elements. */
-
-/* Chain containing all defined commands. */
-
-struct cmd_list_element *cmdlist;
-
-/* Chain containing all defined info subcommands. */
-
-struct cmd_list_element *infolist;
-
-/* Chain containing all defined enable subcommands. */
-
-struct cmd_list_element *enablelist;
-
-/* Chain containing all defined disable subcommands. */
-
-struct cmd_list_element *disablelist;
-
-/* Chain containing all defined toggle subcommands. */
-
-struct cmd_list_element *togglelist;
-
-/* Chain containing all defined stop subcommands. */
-
-struct cmd_list_element *stoplist;
-
-/* Chain containing all defined delete subcommands. */
-
-struct cmd_list_element *deletelist;
-
-/* Chain containing all defined "enable breakpoint" subcommands. */
-
-struct cmd_list_element *enablebreaklist;
-
-/* Chain containing all defined set subcommands */
-
-struct cmd_list_element *setlist;
-
-/* Chain containing all defined unset subcommands */
-
-struct cmd_list_element *unsetlist;
-
-/* Chain containing all defined show subcommands. */
-
-struct cmd_list_element *showlist;
-
-/* Chain containing all defined \"set history\". */
-
-struct cmd_list_element *sethistlist;
-
-/* Chain containing all defined \"show history\". */
-
-struct cmd_list_element *showhistlist;
-
-/* Chain containing all defined \"unset history\". */
-
-struct cmd_list_element *unsethistlist;
-
-/* Chain containing all defined maintenance subcommands. */
-
-struct cmd_list_element *maintenancelist;
-
-/* Chain containing all defined "maintenance info" subcommands. */
-
-struct cmd_list_element *maintenanceinfolist;
-
-/* Chain containing all defined "maintenance print" subcommands. */
-
-struct cmd_list_element *maintenanceprintlist;
-
-struct cmd_list_element *setprintlist;
-
-struct cmd_list_element *showprintlist;
-
-struct cmd_list_element *setchecklist;
-
-struct cmd_list_element *showchecklist;
+int caution = 1; /* Default is yes, sigh. */
/* stdio stream that command input is being read from. Set to stdin normally.
Set by source_command to the file we are sourcing. Set to NULL if we are
The function receives two args: an input stream,
and a prompt string. */
-void (*window_hook) PARAMS ((FILE *, char *));
+void (*window_hook) (FILE *, char *);
int epoch_interface;
int xgdb_verbose;
/* gdb prints this when reading a command interactively */
-static char *gdb_prompt_string; /* the global prompt string */
-extern char *get_prompt PARAMS((void)); /* access function for prompt string */
+static char *gdb_prompt_string; /* the global prompt string */
/* Buffer used for reading command lines, and the size
allocated for it so far. */
int linesize = 100;
/* Nonzero if the current command is modified by "server ". This
- affects things like recording into the command history, comamnds
+ affects things like recording into the command history, commands
repeating on RETURN, etc. This is so a user interface (emacs, GUI,
whatever) can issue its own commands and also send along commands
from the user, and have the user not notice that the user interface
/* Timeout limit for response from target. */
-int remote_timeout = 20; /* Set default to 20 */
+/* The default value has been changed many times over the years. It
+ was originally 5 seconds. But that was thought to be a long time
+ to sit and wait, so it was changed to 2 seconds. That was thought
+ to be plenty unless the connection was going through some terminal
+ server or multiplexer or other form of hairy serial connection.
+
+ In mid-1996, remote_timeout was moved from remote.c to top.c and
+ it began being used in other remote-* targets. It appears that the
+ default was changed to 20 seconds at that time, perhaps because the
+ Hitachi E7000 ICE didn't always respond in a timely manner.
+
+ But if 5 seconds is a long time to sit and wait for retransmissions,
+ 20 seconds is far worse. This demonstrates the difficulty of using
+ a single variable for all protocol timeouts.
+
+ As remote.c is used much more than remote-e7000.c, it was changed
+ back to 2 seconds in 1999. */
+
+int remote_timeout = 2;
/* Non-zero tells remote* modules to output debugging info. */
int remote_debug = 0;
+/* Non-zero means the target is running. Note: this is different from
+ saying that there is an active target and we are stopped at a
+ breakpoint, for instance. This is a real indicator whether the
+ target is off and running, which gdb is doing something else. */
+int target_executing = 0;
+
/* Level of control structure. */
static int control_level;
-/* Structure for arguments to user defined functions. */
-#define MAXUSERARGS 10
-struct user_args
-{
- struct user_args *next;
- struct
- {
- char *arg;
- int len;
- } a[MAXUSERARGS];
- int count;
-} *user_args;
-
/* Signal to catch ^Z typed while reading a command: SIGTSTP or SIGCONT. */
#ifndef STOP_SIGNAL
#ifdef SIGTSTP
#define STOP_SIGNAL SIGTSTP
-static void stop_sig PARAMS ((int));
-#endif
-#endif
-
-/* Some System V have job control but not sigsetmask(). */
-#if !defined (HAVE_SIGSETMASK)
-#if !defined (USG)
-#define HAVE_SIGSETMASK 1
-#else
-#define HAVE_SIGSETMASK 0
-#endif
+static void stop_sig (int);
#endif
-
-#if 0 == (HAVE_SIGSETMASK)
-#define sigsetmask(n)
#endif
/* Hooks for alternate command interfaces. */
/* Called after most modules have been initialized, but before taking users
command file. */
-void (*init_ui_hook) PARAMS ((char *argv0));
+void (*init_ui_hook) (char *argv0);
/* This hook is called from within gdb's many mini-event loops which could
steal control from a real user interface's event loop. It returns
non-zero if the user is requesting a detach, zero otherwise. */
-int (*ui_loop_hook) PARAMS ((int));
+int (*ui_loop_hook) (int);
/* Called instead of command_loop at top level. Can be invoked via
return_to_top_level. */
-void (*command_loop_hook) PARAMS ((void));
-
+void (*command_loop_hook) (void);
-/* Called instead of fputs for all output. */
-
-void (*fputs_unfiltered_hook) PARAMS ((const char *linebuffer, GDB_FILE *stream));
-
-/* Called when the target says something to the host, which may
- want to appear in a different window. */
-
-void (*target_output_hook) PARAMS ((char *));
/* Called from print_frame_info to list the line we stopped in. */
-void (*print_frame_info_listing_hook) PARAMS ((struct symtab *s, int line,
- int stopline, int noerror));
+void (*print_frame_info_listing_hook) (struct symtab * s, int line,
+ int stopline, int noerror);
/* Replaces most of query. */
-int (*query_hook) PARAMS ((const char *, va_list));
+int (*query_hook) (const char *, va_list);
/* Replaces most of warning. */
-void (*warning_hook) PARAMS ((const char *, va_list));
-
-/* Called from gdb_flush to flush output. */
-
-void (*flush_hook) PARAMS ((GDB_FILE *stream));
+void (*warning_hook) (const char *, va_list);
/* These three functions support getting lines of text from the user. They
are used in sequence. First readline_begin_hook is called with a text
to notify the GUI that we are done with the interaction window and it
can close it. */
-void (*readline_begin_hook) PARAMS ((char *, ...));
-char * (*readline_hook) PARAMS ((char *));
-void (*readline_end_hook) PARAMS ((void));
+void (*readline_begin_hook) (char *, ...);
+char *(*readline_hook) (char *);
+void (*readline_end_hook) (void);
/* Called as appropriate to notify the interface of the specified breakpoint
conditions. */
-void (*create_breakpoint_hook) PARAMS ((struct breakpoint *bpt));
-void (*delete_breakpoint_hook) PARAMS ((struct breakpoint *bpt));
-void (*modify_breakpoint_hook) PARAMS ((struct breakpoint *bpt));
+void (*create_breakpoint_hook) (struct breakpoint * bpt);
+void (*delete_breakpoint_hook) (struct breakpoint * bpt);
+void (*modify_breakpoint_hook) (struct breakpoint * bpt);
+
+/* Called as appropriate to notify the interface that we have attached
+ to or detached from an already running process. */
+
+void (*attach_hook) (void);
+void (*detach_hook) (void);
/* Called during long calculations to allow GUI to repair window damage, and to
check for stop buttons, etc... */
-void (*interactive_hook) PARAMS ((void));
+void (*interactive_hook) (void);
/* Called when the registers have changed, as a hint to a GUI
to minimize window update. */
-void (*registers_changed_hook) PARAMS ((void));
+void (*registers_changed_hook) (void);
/* Tell the GUI someone changed the register REGNO. -1 means
that the caller does not know which register changed or
- that several registers have changed (see value_assign).*/
-void (*register_changed_hook) PARAMS ((int regno));
+ that several registers have changed (see value_assign). */
+void (*register_changed_hook) (int regno);
/* Tell the GUI someone changed LEN bytes of memory at ADDR */
-void (*memory_changed_hook) PARAMS ((CORE_ADDR addr, int len));
+void (*memory_changed_hook) (CORE_ADDR addr, int len);
/* Called when going to wait for the target. Usually allows the GUI to run
while waiting for target events. */
-int (*target_wait_hook) PARAMS ((int pid, struct target_waitstatus *status));
+ptid_t (*target_wait_hook) (ptid_t ptid,
+ struct target_waitstatus * status);
/* Used by UI as a wrapper around command execution. May do various things
like enabling/disabling buttons, etc... */
-void (*call_command_hook) PARAMS ((struct cmd_list_element *c, char *cmd,
- int from_tty));
+void (*call_command_hook) (struct cmd_list_element * c, char *cmd,
+ int from_tty);
+
+/* Called after a `set' command has finished. Is only run if the
+ `set' command succeeded. */
+
+void (*set_hook) (struct cmd_list_element * c);
/* Called when the current thread changes. Argument is thread id. */
-void (*context_hook) PARAMS ((int id));
+void (*context_hook) (int id);
/* Takes control from error (). Typically used to prevent longjmps out of the
middle of the GUI. Usually used in conjunction with a catch routine. */
-NORETURN void (*error_hook) PARAMS ((void)) ATTR_NORETURN;
-
+NORETURN void (*error_hook) (void) ATTR_NORETURN;
\f
-/* Where to go for return_to_top_level (RETURN_ERROR). */
-SIGJMP_BUF error_return;
-/* Where to go for return_to_top_level (RETURN_QUIT). */
-SIGJMP_BUF quit_return;
-/* Return for reason REASON. This generally gets back to the command
- loop, but can be caught via catch_errors. */
+/* One should use catch_errors rather than manipulating these
+ directly. */
+#if defined(HAVE_SIGSETJMP)
+#define SIGJMP_BUF sigjmp_buf
+#define SIGSETJMP(buf) sigsetjmp((buf), 1)
+#define SIGLONGJMP(buf,val) siglongjmp((buf), (val))
+#else
+#define SIGJMP_BUF jmp_buf
+#define SIGSETJMP(buf) setjmp(buf)
+#define SIGLONGJMP(buf,val) longjmp((buf), (val))
+#endif
+
+/* Where to go for return_to_top_level. */
+static SIGJMP_BUF *catch_return;
+
+/* Return for reason REASON to the nearest containing catch_errors(). */
NORETURN void
-return_to_top_level (reason)
- enum return_reason reason;
+return_to_top_level (enum return_reason reason)
{
quit_flag = 0;
immediate_quit = 0;
/* Perhaps it would be cleaner to do this via the cleanup chain (not sure
I can think of a reason why that is vital, though). */
- bpstat_clear_actions(stop_bpstat); /* Clear queued breakpoint commands */
+ bpstat_clear_actions (stop_bpstat); /* Clear queued breakpoint commands */
disable_current_display ();
do_cleanups (ALL_CLEANUPS);
+ if (event_loop_p && target_can_async_p () && !target_executing)
+ do_exec_cleanups (ALL_CLEANUPS);
+ if (event_loop_p && sync_execution)
+ do_exec_error_cleanups (ALL_CLEANUPS);
if (annotation_level > 1)
switch (reason)
break;
}
- (NORETURN void) SIGLONGJMP
- (reason == RETURN_ERROR ? error_return : quit_return, 1);
+ /* Jump to the containing catch_errors() call, communicating REASON
+ to that call via setjmp's return value. Note that REASON can't
+ be zero, by definition in defs.h. */
+
+ (NORETURN void) SIGLONGJMP (*catch_return, (int) reason);
}
/* Call FUNC with arg ARGS, catching any errors. If there is no
catch_errors. Note that quit should return to the command line
fairly quickly, even if some further processing is being done. */
+/* MAYBE: cagney/1999-11-05: catch_errors() in conjunction with
+ error() et.al. could maintain a set of flags that indicate the the
+ current state of each of the longjmp buffers. This would give the
+ longjmp code the chance to detect a longjmp botch (before it gets
+ to longjmperror()). Prior to 1999-11-05 this wasn't possible as
+ code also randomly used a SET_TOP_LEVEL macro that directly
+ initialize the longjmp buffers. */
+
+/* MAYBE: cagney/1999-11-05: Should the catch_errors and cleanups code
+ be consolidated into a single file instead of being distributed
+ between utils.c and top.c? */
+
int
-catch_errors (func, args, errstring, mask)
- catch_errors_ftype *func;
- PTR args;
- char *errstring;
- return_mask mask;
+catch_errors (catch_errors_ftype *func, void * args, char *errstring,
+ return_mask mask)
{
- SIGJMP_BUF saved_error;
- SIGJMP_BUF saved_quit;
- SIGJMP_BUF tmp_jmp;
+ SIGJMP_BUF *saved_catch;
+ SIGJMP_BUF catch;
int val;
struct cleanup *saved_cleanup_chain;
char *saved_error_pre_print;
char *saved_quit_pre_print;
- saved_cleanup_chain = save_cleanups ();
+ /* Return value from SIGSETJMP(): enum return_reason if error or
+ quit caught, 0 otherwise. */
+ int caught;
+
+ /* Override error/quit messages during FUNC. */
+
saved_error_pre_print = error_pre_print;
saved_quit_pre_print = quit_pre_print;
if (mask & RETURN_MASK_ERROR)
- {
- memcpy ((char *)saved_error, (char *)error_return, sizeof (SIGJMP_BUF));
- error_pre_print = errstring;
- }
+ error_pre_print = errstring;
if (mask & RETURN_MASK_QUIT)
- {
- memcpy (saved_quit, quit_return, sizeof (SIGJMP_BUF));
- quit_pre_print = errstring;
- }
+ quit_pre_print = errstring;
- if (SIGSETJMP (tmp_jmp) == 0)
- {
- if (mask & RETURN_MASK_ERROR)
- memcpy (error_return, tmp_jmp, sizeof (SIGJMP_BUF));
- if (mask & RETURN_MASK_QUIT)
- memcpy (quit_return, tmp_jmp, sizeof (SIGJMP_BUF));
- val = (*func) (args);
- }
+ /* Prevent error/quit during FUNC from calling cleanups established
+ prior to here. */
+
+ saved_cleanup_chain = save_cleanups ();
+
+ /* Call FUNC, catching error/quit events. */
+
+ saved_catch = catch_return;
+ catch_return = &catch;
+ caught = SIGSETJMP (catch);
+ if (!caught)
+ val = (*func) (args);
else
val = 0;
+ catch_return = saved_catch;
+
+ /* FIXME: cagney/1999-11-05: A correct FUNC implementation will
+ clean things up (restoring the cleanup chain) to the state they
+ were just prior to the call. Unfortunately, many FUNC's are not
+ that well behaved. This could be fixed by adding either a
+ do_cleanups call (to cover the problem) or an assertion check to
+ detect bad FUNCs code. */
+
+ /* Restore the cleanup chain and error/quit messages to their
+ original states. */
restore_cleanups (saved_cleanup_chain);
- if (mask & RETURN_MASK_ERROR)
- {
- memcpy (error_return, saved_error, sizeof (SIGJMP_BUF));
- error_pre_print = saved_error_pre_print;
- }
if (mask & RETURN_MASK_QUIT)
- {
- memcpy (quit_return, saved_quit, sizeof (SIGJMP_BUF));
- quit_pre_print = saved_quit_pre_print;
- }
- return val;
+ quit_pre_print = saved_quit_pre_print;
+ if (mask & RETURN_MASK_ERROR)
+ error_pre_print = saved_error_pre_print;
+
+ /* Return normally if no error/quit event occurred. */
+
+ if (!caught)
+ return val;
+
+ /* If the caller didn't request that the event be caught, relay the
+ event to the next containing catch_errors(). */
+
+ if (!(mask & RETURN_MASK (caught)))
+ return_to_top_level (caught);
+
+ /* Tell the caller that an event was caught.
+
+ FIXME: nsd/2000-02-22: When MASK is RETURN_MASK_ALL, the caller
+ can't tell what type of event occurred.
+
+ A possible fix is to add a new interface, catch_event(), that
+ returns enum return_reason after catching an error or a quit.
+
+ When returning normally, i.e. without catching an error or a
+ quit, catch_event() could return RETURN_NORMAL, which would be
+ added to enum return_reason. FUNC would return information
+ exclusively via ARGS.
+
+ Alternatively, normal catch_event() could return FUNC's return
+ value. The caller would need to be aware of potential overlap
+ with enum return_reason, which could be publicly restricted to
+ negative values to simplify return value processing in FUNC and
+ in the caller. */
+
+ return 0;
}
-/* Handler for SIGHUP. */
+struct captured_command_args
+ {
+ catch_command_errors_ftype *command;
+ char *arg;
+ int from_tty;
+ };
-#ifdef SIGHUP
-static void
-disconnect (signo)
-int signo;
+static int
+do_captured_command (void *data)
{
- catch_errors (quit_cover, NULL,
- "Could not kill the program being debugged", RETURN_MASK_ALL);
- signal (SIGHUP, SIG_DFL);
- kill (getpid (), SIGHUP);
+ struct captured_command_args *context = data;
+ context->command (context->arg, context->from_tty);
+ /* FIXME: cagney/1999-11-07: Technically this do_cleanups() call
+ isn't needed. Instead an assertion check could be made that
+ simply confirmed that the called function correctly cleaned up
+ after itself. Unfortunately, old code (prior to 1999-11-04) in
+ main.c was calling SET_TOP_LEVEL(), calling the command function,
+ and then *always* calling do_cleanups(). For the moment we
+ remain ``bug compatible'' with that old code.. */
+ do_cleanups (ALL_CLEANUPS);
+ return 1;
+}
+
+int
+catch_command_errors (catch_command_errors_ftype * command,
+ char *arg, int from_tty, return_mask mask)
+{
+ struct captured_command_args args;
+ args.command = command;
+ args.arg = arg;
+ args.from_tty = from_tty;
+ return catch_errors (do_captured_command, &args, "", mask);
}
+
+/* Handler for SIGHUP. */
+
+#ifdef SIGHUP
/* Just a little helper function for disconnect(). */
/* NOTE 1999-04-29: This function will be static again, once we modify
gdb to use the event loop as the default command loop and we merge
event-top.c into this file, top.c */
/* static */ int
-quit_cover (s)
- PTR s;
+quit_cover (void *s)
{
- caution = 0; /* Throw caution to the wind -- we're exiting.
- This prevents asking the user dumb questions. */
- quit_command((char *)0, 0);
+ caution = 0; /* Throw caution to the wind -- we're exiting.
+ This prevents asking the user dumb questions. */
+ quit_command ((char *) 0, 0);
return 0;
}
+
+static void
+disconnect (int signo)
+{
+ catch_errors (quit_cover, NULL,
+ "Could not kill the program being debugged", RETURN_MASK_ALL);
+ signal (SIGHUP, SIG_DFL);
+ kill (getpid (), SIGHUP);
+}
#endif /* defined SIGHUP */
\f
/* Line number we are currently in in a file which is being sourced. */
/* Clean up on error during a "source" command (or execution of a
user-defined command). */
-static void
-source_cleanup (stream)
- FILE *stream;
+void
+do_restore_instream_cleanup (void *stream)
{
/* Restore the previous input stream. */
instream = stream;
/* Read commands from STREAM. */
void
-read_command_file (stream)
- FILE *stream;
+read_command_file (FILE *stream)
{
struct cleanup *cleanups;
- cleanups = make_cleanup ((make_cleanup_func) source_cleanup, instream);
+ cleanups = make_cleanup (do_restore_instream_cleanup, instream);
instream = stream;
- command_loop ();
+ command_loop ();
do_cleanups (cleanups);
}
\f
-extern void init_proc PARAMS ((void));
-
-void (*pre_init_ui_hook) PARAMS ((void));
+void (*pre_init_ui_hook) (void);
+#ifdef __MSDOS__
void
-gdb_init (argv0)
- char *argv0;
+do_chdir_cleanup (void *old_dir)
{
- if (pre_init_ui_hook)
- pre_init_ui_hook ();
-
- /* Run the init function of each source file */
-
- getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));
- current_directory = gdb_dirbuf;
-
- init_cmd_lists (); /* This needs to be done first */
- initialize_targets (); /* Setup target_terminal macros for utils.c */
- initialize_utils (); /* Make errors and warnings possible */
- initialize_all_files ();
- init_main (); /* But that omits this file! Do it now */
-
- /* The signal handling mechanism is different depending whether or
- not the async version is run. NOTE: in the future we plan to make
- the event loop be the default engine of gdb, and this difference
- will disappear. */
- if (async_p)
- async_init_signals ();
- else
- init_signals ();
-
- /* We need a default language for parsing expressions, so simple things like
- "set width 0" won't fail if no language is explicitly set in a config file
- or implicitly set by reading an executable during startup. */
- set_language (language_c);
- expected_language = current_language; /* don't warn about the change. */
-
- /* All the interpreters should have had a look at things by now.
- Initialize the selected interpreter. */
- if (init_ui_hook)
- init_ui_hook (argv0);
+ chdir (old_dir);
+ xfree (old_dir);
}
+#endif
-/* Allocate, initialize a new command line structure for one of the
- control commands (if/while). */
+/* Execute the line P as a command.
+ Pass FROM_TTY as second argument to the defining function. */
-static struct command_line *
-build_command_line (type, args)
- enum command_control_type type;
- char *args;
+void
+execute_command (char *p, int from_tty)
{
- struct command_line *cmd;
-
- if (args == NULL)
- error ("if/while commands require arguments.\n");
-
- cmd = (struct command_line *)xmalloc (sizeof (struct command_line));
- cmd->next = NULL;
- cmd->control_type = type;
-
- cmd->body_count = 1;
- cmd->body_list
- = (struct command_line **)xmalloc (sizeof (struct command_line *)
- * cmd->body_count);
- memset (cmd->body_list, 0, sizeof (struct command_line *) * cmd->body_count);
- cmd->line = savestring (args, strlen (args));
- return cmd;
-}
-
-/* Build and return a new command structure for the control commands
- such as "if" and "while". */
+ register struct cmd_list_element *c;
+ register enum language flang;
+ static int warned = 0;
+ char *line;
+
+ free_all_values ();
-static struct command_line *
-get_command_line (type, arg)
- enum command_control_type type;
- char *arg;
-{
- struct command_line *cmd;
- struct cleanup *old_chain = NULL;
+ /* Force cleanup of any alloca areas if using C alloca instead of
+ a builtin alloca. */
+ alloca (0);
- /* Allocate and build a new command line structure. */
- cmd = build_command_line (type, arg);
+ /* This can happen when command_line_input hits end of file. */
+ if (p == NULL)
+ return;
- old_chain = make_cleanup ((make_cleanup_func) free_command_lines, &cmd);
+ serial_log_command (p);
- /* Read in the body of this command. */
- if (recurse_read_control_structure (cmd) == invalid_control)
+ while (*p == ' ' || *p == '\t')
+ p++;
+ if (*p)
{
- warning ("error reading in control structure\n");
- do_cleanups (old_chain);
- return NULL;
- }
+ char *arg;
+ line = p;
- discard_cleanups (old_chain);
- return cmd;
-}
+ c = lookup_cmd (&p, cmdlist, "", 0, 1);
-/* Recursively print a command (including full control structures). */
-void
-print_command_line (cmd, depth, stream)
- struct command_line *cmd;
- unsigned int depth;
- GDB_FILE *stream;
-{
- unsigned int i;
+ /* If the target is running, we allow only a limited set of
+ commands. */
+ if (event_loop_p && target_can_async_p () && target_executing)
+ if (!strcmp (c->name, "help")
+ && !strcmp (c->name, "pwd")
+ && !strcmp (c->name, "show")
+ && !strcmp (c->name, "stop"))
+ error ("Cannot execute this command while the target is running.");
- if (depth)
- {
- for (i = 0; i < depth; i++)
- fputs_filtered (" ", stream);
- }
+ /* Pass null arg rather than an empty one. */
+ arg = *p ? p : 0;
- /* A simple command, print it and return. */
- if (cmd->control_type == simple_control)
- {
- fputs_filtered (cmd->line, stream);
- fputs_filtered ("\n", stream);
- return;
- }
+ /* Clear off trailing whitespace, except for set and complete command. */
+ if (arg
+ && c->type != set_cmd
+ && !is_complete_command (c->function.cfunc))
+ {
+ p = arg + strlen (arg) - 1;
+ while (p >= arg && (*p == ' ' || *p == '\t'))
+ p--;
+ *(p + 1) = '\0';
+ }
- /* loop_continue to jump to the start of a while loop, print it
- and return. */
- if (cmd->control_type == continue_control)
- {
- fputs_filtered ("loop_continue\n", stream);
- return;
- }
+ /* If this command has been pre-hooked, run the hook first. */
+ if ((c->hook_pre) && (!c->hook_in))
+ {
+ c->hook_in = 1; /* Prevent recursive hooking */
+ execute_user_command (c->hook_pre, (char *) 0);
+ c->hook_in = 0; /* Allow hook to work again once it is complete */
+ }
- /* loop_break to break out of a while loop, print it and return. */
- if (cmd->control_type == break_control)
- {
- fputs_filtered ("loop_break\n", stream);
- return;
- }
-
- /* A while command. Recursively print its subcommands before returning. */
- if (cmd->control_type == while_control)
- {
- struct command_line *list;
- fputs_filtered ("while ", stream);
- fputs_filtered (cmd->line, stream);
- fputs_filtered ("\n", stream);
- list = *cmd->body_list;
- while (list)
- {
- print_command_line (list, depth + 1, stream);
- list = list->next;
- }
- }
-
- /* An if command. Recursively print both arms before returning. */
- if (cmd->control_type == if_control)
- {
- fputs_filtered ("if ", stream);
- fputs_filtered (cmd->line, stream);
- fputs_filtered ("\n", stream);
- /* The true arm. */
- print_command_line (cmd->body_list[0], depth + 1, stream);
-
- /* Show the false arm if it exists. */
- if (cmd->body_count == 2)
- {
- if (depth)
- {
- for (i = 0; i < depth; i++)
- fputs_filtered (" ", stream);
- }
- fputs_filtered ("else\n", stream);
- print_command_line (cmd->body_list[1], depth + 1, stream);
- }
- if (depth)
- {
- for (i = 0; i < depth; i++)
- fputs_filtered (" ", stream);
- }
- fputs_filtered ("end\n", stream);
- }
-}
-
-/* Execute the command in CMD. */
-
-enum command_control_type
-execute_control_command (cmd)
- struct command_line *cmd;
-{
- struct expression *expr;
- struct command_line *current;
- struct cleanup *old_chain = 0;
- value_ptr val;
- value_ptr val_mark;
- int loop;
- enum command_control_type ret;
- char *new_line;
-
- switch (cmd->control_type)
- {
- case simple_control:
- /* A simple command, execute it and return. */
- new_line = insert_args (cmd->line);
- if (!new_line)
- return invalid_control;
- old_chain = make_cleanup ((make_cleanup_func) free_current_contents,
- &new_line);
- execute_command (new_line, 0);
- ret = cmd->control_type;
- break;
-
- case continue_control:
- case break_control:
- /* Return for "continue", and "break" so we can either
- continue the loop at the top, or break out. */
- ret = cmd->control_type;
- break;
-
- case while_control:
- {
- /* Parse the loop control expression for the while statement. */
- new_line = insert_args (cmd->line);
- if (!new_line)
- return invalid_control;
- old_chain = make_cleanup ((make_cleanup_func) free_current_contents,
- &new_line);
- expr = parse_expression (new_line);
- make_cleanup ((make_cleanup_func) free_current_contents, &expr);
-
- ret = simple_control;
- loop = 1;
-
- /* Keep iterating so long as the expression is true. */
- while (loop == 1)
- {
- int cond_result;
-
- QUIT;
-
- /* Evaluate the expression. */
- val_mark = value_mark ();
- val = evaluate_expression (expr);
- cond_result = value_true (val);
- value_free_to_mark (val_mark);
-
- /* If the value is false, then break out of the loop. */
- if (!cond_result)
- break;
-
- /* Execute the body of the while statement. */
- current = *cmd->body_list;
- while (current)
- {
- ret = execute_control_command (current);
-
- /* If we got an error, or a "break" command, then stop
- looping. */
- if (ret == invalid_control || ret == break_control)
- {
- loop = 0;
- break;
- }
-
- /* If we got a "continue" command, then restart the loop
- at this point. */
- if (ret == continue_control)
- break;
-
- /* Get the next statement. */
- current = current->next;
- }
- }
-
- /* Reset RET so that we don't recurse the break all the way down. */
- if (ret == break_control)
- ret = simple_control;
-
- break;
- }
-
- case if_control:
- {
- new_line = insert_args (cmd->line);
- if (!new_line)
- return invalid_control;
- old_chain = make_cleanup ((make_cleanup_func) free_current_contents,
- &new_line);
- /* Parse the conditional for the if statement. */
- expr = parse_expression (new_line);
- make_cleanup ((make_cleanup_func) free_current_contents, &expr);
-
- current = NULL;
- ret = simple_control;
-
- /* Evaluate the conditional. */
- val_mark = value_mark ();
- val = evaluate_expression (expr);
-
- /* Choose which arm to take commands from based on the value of the
- conditional expression. */
- if (value_true (val))
- current = *cmd->body_list;
- else if (cmd->body_count == 2)
- current = *(cmd->body_list + 1);
- value_free_to_mark (val_mark);
-
- /* Execute commands in the given arm. */
- while (current)
- {
- ret = execute_control_command (current);
-
- /* If we got an error, get out. */
- if (ret != simple_control)
- break;
-
- /* Get the next statement in the body. */
- current = current->next;
- }
-
- break;
- }
-
- default:
- warning ("Invalid control type in command structure.");
- return invalid_control;
- }
-
- if (old_chain)
- do_cleanups (old_chain);
-
- return ret;
-}
-
-/* "while" command support. Executes a body of statements while the
- loop condition is nonzero. */
-
-static void
-while_command (arg, from_tty)
- char *arg;
- int from_tty;
-{
- struct command_line *command = NULL;
-
- control_level = 1;
- command = get_command_line (while_control, arg);
-
- if (command == NULL)
- return;
-
- execute_control_command (command);
- free_command_lines (&command);
-}
-
-/* "if" command support. Execute either the true or false arm depending
- on the value of the if conditional. */
-
-static void
-if_command (arg, from_tty)
- char *arg;
- int from_tty;
-{
- struct command_line *command = NULL;
-
- control_level = 1;
- command = get_command_line (if_control, arg);
-
- if (command == NULL)
- return;
-
- execute_control_command (command);
- free_command_lines (&command);
-}
-
-/* Cleanup */
-static void
-arg_cleanup ()
-{
- struct user_args *oargs = user_args;
- if (!user_args)
- fatal ("Internal error, arg_cleanup called with no user args.\n");
-
- user_args = user_args->next;
- free (oargs);
-}
-
-/* Bind the incomming arguments for a user defined command to
- $arg0, $arg1 ... $argMAXUSERARGS. */
-
-static struct cleanup *
-setup_user_args (p)
- char *p;
-{
- struct user_args *args;
- struct cleanup *old_chain;
- unsigned int arg_count = 0;
-
- args = (struct user_args *)xmalloc (sizeof (struct user_args));
- memset (args, 0, sizeof (struct user_args));
-
- args->next = user_args;
- user_args = args;
-
- old_chain = make_cleanup ((make_cleanup_func) arg_cleanup, 0);
-
- if (p == NULL)
- return old_chain;
-
- while (*p)
- {
- char *start_arg;
- int squote = 0;
- int dquote = 0;
- int bsquote = 0;
-
- if (arg_count >= MAXUSERARGS)
- {
- error ("user defined function may only have %d arguments.\n",
- MAXUSERARGS);
- return old_chain;
- }
-
- /* Strip whitespace. */
- while (*p == ' ' || *p == '\t')
- p++;
-
- /* P now points to an argument. */
- start_arg = p;
- user_args->a[arg_count].arg = p;
-
- /* Get to the end of this argument. */
- while (*p)
- {
- if (((*p == ' ' || *p == '\t')) && !squote && !dquote && !bsquote)
- break;
- else
- {
- if (bsquote)
- bsquote = 0;
- else if (*p == '\\')
- bsquote = 1;
- else if (squote)
- {
- if (*p == '\'')
- squote = 0;
- }
- else if (dquote)
- {
- if (*p == '"')
- dquote = 0;
- }
- else
- {
- if (*p == '\'')
- squote = 1;
- else if (*p == '"')
- dquote = 1;
- }
- p++;
- }
- }
-
- user_args->a[arg_count].len = p - start_arg;
- arg_count++;
- user_args->count++;
- }
- return old_chain;
-}
-
-/* Given character string P, return a point to the first argument ($arg),
- or NULL if P contains no arguments. */
-
-static char *
-locate_arg (p)
- char *p;
-{
- while ((p = strchr (p, '$')))
- {
- if (strncmp (p, "$arg", 4) == 0 && isdigit (p[4]))
- return p;
- p++;
- }
- return NULL;
-}
-
-/* Insert the user defined arguments stored in user_arg into the $arg
- arguments found in line, with the updated copy being placed into nline. */
-
-static char *
-insert_args (line)
- char *line;
-{
- char *p, *save_line, *new_line;
- unsigned len, i;
-
- /* First we need to know how much memory to allocate for the new line. */
- save_line = line;
- len = 0;
- while ((p = locate_arg (line)))
- {
- len += p - line;
- i = p[4] - '0';
-
- if (i >= user_args->count)
- {
- error ("Missing argument %d in user function.\n", i);
- return NULL;
- }
- len += user_args->a[i].len;
- line = p + 5;
- }
-
- /* Don't forget the tail. */
- len += strlen (line);
-
- /* Allocate space for the new line and fill it in. */
- new_line = (char *)xmalloc (len + 1);
- if (new_line == NULL)
- return NULL;
-
- /* Restore pointer to beginning of old line. */
- line = save_line;
-
- /* Save pointer to beginning of new line. */
- save_line = new_line;
-
- while ((p = locate_arg (line)))
- {
- int i, len;
-
- memcpy (new_line, line, p - line);
- new_line += p - line;
- i = p[4] - '0';
-
- len = user_args->a[i].len;
- if (len)
- {
- memcpy (new_line, user_args->a[i].arg, len);
- new_line += len;
- }
- line = p + 5;
- }
- /* Don't forget the tail. */
- strcpy (new_line, line);
-
- /* Return a pointer to the beginning of the new line. */
- return save_line;
-}
-
-void
-execute_user_command (c, args)
- struct cmd_list_element *c;
- char *args;
-{
- register struct command_line *cmdlines;
- struct cleanup *old_chain;
- enum command_control_type ret;
-
- old_chain = setup_user_args (args);
-
- cmdlines = c->user_commands;
- if (cmdlines == 0)
- /* Null command */
- return;
-
- /* Set the instream to 0, indicating execution of a
- user-defined function. */
- old_chain = make_cleanup ((make_cleanup_func) source_cleanup, instream);
- instream = (FILE *) 0;
- while (cmdlines)
- {
- ret = execute_control_command (cmdlines);
- if (ret != simple_control && ret != break_control)
- {
- warning ("Error in control structure.\n");
- break;
- }
- cmdlines = cmdlines->next;
- }
- do_cleanups (old_chain);
-}
-
-/* Execute the line P as a command.
- Pass FROM_TTY as second argument to the defining function. */
-
-void
-execute_command (p, from_tty)
- char *p;
- int from_tty;
-{
- register struct cmd_list_element *c;
- register enum language flang;
- static int warned = 0;
- /* FIXME: These should really be in an appropriate header file */
- extern void serial_log_command PARAMS ((const char *));
-
- free_all_values ();
-
- /* Force cleanup of any alloca areas if using C alloca instead of
- a builtin alloca. */
- alloca (0);
-
- /* This can happen when command_line_input hits end of file. */
- if (p == NULL)
- return;
-
- serial_log_command (p);
-
- while (*p == ' ' || *p == '\t') p++;
- if (*p)
- {
- char *arg;
-
- c = lookup_cmd (&p, cmdlist, "", 0, 1);
- /* Pass null arg rather than an empty one. */
- arg = *p ? p : 0;
-
- /* Clear off trailing whitespace, except for set and complete command. */
- if (arg && c->type != set_cmd && c->function.cfunc != complete_command)
- {
- p = arg + strlen (arg) - 1;
- while (p >= arg && (*p == ' ' || *p == '\t'))
- p--;
- *(p + 1) = '\0';
- }
-
- /* If this command has been hooked, run the hook first. */
- if (c->hook)
- execute_user_command (c->hook, (char *)0);
+ if (c->flags & DEPRECATED_WARN_USER)
+ deprecated_cmd_warning (&line);
if (c->class == class_user)
execute_user_command (c, arg);
call_command_hook (c, arg, from_tty & caution);
else
(*c->function.cfunc) (arg, from_tty & caution);
- }
+
+ /* If this command has been post-hooked, run the hook last. */
+ if ((c->hook_post) && (!c->hook_in))
+ {
+ c->hook_in = 1; /* Prevent recursive hooking */
+ execute_user_command (c->hook_post, (char *) 0);
+ c->hook_in = 0; /* allow hook to work again once it is complete */
+ }
+
+ }
/* Tell the user if the language has changed (except first time). */
if (current_language != expected_language)
- {
- if (language_mode == language_mode_auto) {
- language_info (1); /* Print what changed. */
+ {
+ if (language_mode == language_mode_auto)
+ {
+ language_info (1); /* Print what changed. */
+ }
+ warned = 0;
}
- warned = 0;
- }
/* Warn the user if the working language does not match the
language of the current frame. Only warn the user if we are
}
}
-/* ARGSUSED */
-/* NOTE 1999-04-29: This function will be static again, once we modify
- gdb to use the event loop as the default command loop and we merge
- event-top.c into this file, top.c */
-/* static */ void
-command_loop_marker (foo)
- int foo;
-{
-}
-
/* Read commands from `instream' and execute them
until end of file or error reading instream. */
void
-command_loop ()
+command_loop (void)
{
struct cleanup *old_chain;
char *command;
while (instream && !feof (instream))
{
-#if defined(TUI)
- extern int insert_mode;
-#endif
if (window_hook && instream == stdin)
(*window_hook) (instream, get_prompt ());
quit_flag = 0;
if (instream == stdin && stdin_is_tty)
reinitialize_more_filter ();
- old_chain = make_cleanup ((make_cleanup_func) command_loop_marker, 0);
-
-#if defined(TUI)
- /* A bit of paranoia: I want to make sure the "insert_mode" global
- * is clear except when it is being used for command-line editing
- * (see tuiIO.c, utils.c); otherwise normal output will
- * get messed up in the TUI. So clear it before/after
- * the command-line-input call. - RT
- */
- insert_mode = 0;
-#endif
+ old_chain = make_cleanup (null_cleanup, 0);
+
/* Get a command-line. This calls the readline package. */
- command = command_line_input (instream == stdin ?
+ command = command_line_input (instream == stdin ?
get_prompt () : (char *) NULL,
instream == stdin, "prompt");
-#if defined(TUI)
- insert_mode = 0;
-#endif
if (command == 0)
return;
}
}
+/* Read commands from `instream' and execute them until end of file or
+ error reading instream. This command loop doesnt care about any
+ such things as displaying time and space usage. If the user asks
+ for those, they won't work. */
+void
+simplified_command_loop (char *(*read_input_func) (char *),
+ void (*execute_command_func) (char *, int))
+{
+ struct cleanup *old_chain;
+ char *command;
+ int stdin_is_tty = ISATTY (stdin);
+
+ while (instream && !feof (instream))
+ {
+ quit_flag = 0;
+ if (instream == stdin && stdin_is_tty)
+ reinitialize_more_filter ();
+ old_chain = make_cleanup (null_cleanup, 0);
+
+ /* Get a command-line. */
+ command = (*read_input_func) (instream == stdin ?
+ get_prompt () : (char *) NULL);
+
+ if (command == 0)
+ return;
+
+ (*execute_command_func) (command, instream == stdin);
+
+ /* Do any commands attached to breakpoint we stopped at. */
+ bpstat_do_actions (&stop_bpstat);
+
+ do_cleanups (old_chain);
+ }
+}
+\f
+/* Commands call this if they do not want to be repeated by null lines. */
+
+void
+dont_repeat (void)
+{
+ if (server_command)
+ return;
+
+ /* If we aren't reading from standard input, we are saving the last
+ thing read from stdin in line and don't want to delete it. Null lines
+ won't repeat here in any case. */
+ if (instream == stdin)
+ *line = 0;
+}
+\f
+/* Read a line from the stream "instream" without command line editing.
+
+ It prints PROMPT_ARG once at the start.
+ Action is compatible with "readline", e.g. space for the result is
+ malloc'd and should be freed by the caller.
+
+ A NULL return means end of file. */
+char *
+gdb_readline (char *prompt_arg)
+{
+ int c;
+ char *result;
+ int input_index = 0;
+ int result_size = 80;
+
+ if (prompt_arg)
+ {
+ /* Don't use a _filtered function here. It causes the assumed
+ character position to be off, since the newline we read from
+ the user is not accounted for. */
+ fputs_unfiltered (prompt_arg, gdb_stdout);
+ /* OBSOLETE #ifdef MPW */
+ /* OBSOLETE Move to a new line so the entered line doesn't have a prompt */
+ /* OBSOLETE on the front of it. */
+ /* OBSOLETE fputs_unfiltered ("\n", gdb_stdout); */
+ /* OBSOLETE #endif *//* MPW */
+ gdb_flush (gdb_stdout);
+ }
+
+ result = (char *) xmalloc (result_size);
+
+ while (1)
+ {
+ /* Read from stdin if we are executing a user defined command.
+ This is the right thing for prompt_for_continue, at least. */
+ c = fgetc (instream ? instream : stdin);
+
+ if (c == EOF)
+ {
+ if (input_index > 0)
+ /* The last line does not end with a newline. Return it, and
+ if we are called again fgetc will still return EOF and
+ we'll return NULL then. */
+ break;
+ xfree (result);
+ return NULL;
+ }
+
+ if (c == '\n')
+#ifndef CRLF_SOURCE_FILES
+ break;
+#else
+ {
+ if (input_index > 0 && result[input_index - 1] == '\r')
+ input_index--;
+ break;
+ }
+#endif
+
+ result[input_index++] = c;
+ while (input_index >= result_size)
+ {
+ result_size *= 2;
+ result = (char *) xrealloc (result, result_size);
+ }
+ }
+
+ result[input_index++] = '\0';
+ return result;
+}
+
+/* Variables which control command line editing and history
+ substitution. These variables are given default values at the end
+ of this file. */
+static int command_editing_p;
+/* NOTE 1999-04-29: This variable will be static again, once we modify
+ gdb to use the event loop as the default command loop and we merge
+ event-top.c into this file, top.c */
+/* static */ int history_expansion_p;
+static int write_history_p;
+static int history_size;
+static char *history_filename;
+
+\f
+#ifdef STOP_SIGNAL
+static void
+stop_sig (int signo)
+{
+#if STOP_SIGNAL == SIGTSTP
+ signal (SIGTSTP, SIG_DFL);
+#if HAVE_SIGPROCMASK
+ {
+ sigset_t zero;
+
+ sigemptyset (&zero);
+ sigprocmask (SIG_SETMASK, &zero, 0);
+ }
+#elif HAVE_SIGSETMASK
+ sigsetmask (0);
+#endif
+ kill (getpid (), SIGTSTP);
+ signal (SIGTSTP, stop_sig);
+#else
+ signal (STOP_SIGNAL, stop_sig);
+#endif
+ printf_unfiltered ("%s", get_prompt ());
+ gdb_flush (gdb_stdout);
+
+ /* Forget about any previous command -- null line now will do nothing. */
+ dont_repeat ();
+}
+#endif /* STOP_SIGNAL */
+
+/* Initialize signal handlers. */
+static void
+float_handler (int signo)
+{
+ /* This message is based on ANSI C, section 4.7. Note that integer
+ divide by zero causes this, so "float" is a misnomer. */
+ signal (SIGFPE, float_handler);
+ error ("Erroneous arithmetic operation.");
+}
+
+static void
+do_nothing (int signo)
+{
+ /* Under System V the default disposition of a signal is reinstated after
+ the signal is caught and delivered to an application process. On such
+ systems one must restore the replacement signal handler if one wishes
+ to continue handling the signal in one's program. On BSD systems this
+ is not needed but it is harmless, and it simplifies the code to just do
+ it unconditionally. */
+ signal (signo, do_nothing);
+}
+
+static void
+init_signals (void)
+{
+ signal (SIGINT, request_quit);
+
+ /* If SIGTRAP was set to SIG_IGN, then the SIG_IGN will get passed
+ to the inferior and breakpoints will be ignored. */
+#ifdef SIGTRAP
+ signal (SIGTRAP, SIG_DFL);
+#endif
+
+ /* If we initialize SIGQUIT to SIG_IGN, then the SIG_IGN will get
+ passed to the inferior, which we don't want. It would be
+ possible to do a "signal (SIGQUIT, SIG_DFL)" after we fork, but
+ on BSD4.3 systems using vfork, that can affect the
+ GDB process as well as the inferior (the signal handling tables
+ might be in memory, shared between the two). Since we establish
+ a handler for SIGQUIT, when we call exec it will set the signal
+ to SIG_DFL for us. */
+ signal (SIGQUIT, do_nothing);
+#ifdef SIGHUP
+ if (signal (SIGHUP, do_nothing) != SIG_IGN)
+ signal (SIGHUP, disconnect);
+#endif
+ signal (SIGFPE, float_handler);
+
+#if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
+ signal (SIGWINCH, SIGWINCH_HANDLER);
+#endif
+}
+\f
+/* Read one line from the command input stream `instream'
+ into the local static buffer `linebuffer' (whose current length
+ is `linelength').
+ The buffer is made bigger as necessary.
+ Returns the address of the start of the line.
+
+ NULL is returned for end of file.
+
+ *If* the instream == stdin & stdin is a terminal, the line read
+ is copied into the file line saver (global var char *line,
+ length linesize) so that it can be duplicated.
+
+ This routine either uses fancy command line editing or
+ simple input as the user has requested. */
+
+char *
+command_line_input (char *prompt_arg, int repeat, char *annotation_suffix)
+{
+ static char *linebuffer = 0;
+ static unsigned linelength = 0;
+ register char *p;
+ char *p1;
+ char *rl;
+ char *local_prompt = prompt_arg;
+ char *nline;
+ char got_eof = 0;
+
+ /* The annotation suffix must be non-NULL. */
+ if (annotation_suffix == NULL)
+ annotation_suffix = "";
+
+ if (annotation_level > 1 && instream == stdin)
+ {
+ local_prompt = alloca ((prompt_arg == NULL ? 0 : strlen (prompt_arg))
+ + strlen (annotation_suffix) + 40);
+ if (prompt_arg == NULL)
+ local_prompt[0] = '\0';
+ else
+ strcpy (local_prompt, prompt_arg);
+ strcat (local_prompt, "\n\032\032");
+ strcat (local_prompt, annotation_suffix);
+ strcat (local_prompt, "\n");
+ }
+
+ if (linebuffer == 0)
+ {
+ linelength = 80;
+ linebuffer = (char *) xmalloc (linelength);
+ }
+
+ p = linebuffer;
+
+ /* Control-C quits instantly if typed while in this loop
+ since it should not wait until the user types a newline. */
+ immediate_quit++;
+#ifdef STOP_SIGNAL
+ if (job_control)
+ {
+ if (event_loop_p)
+ signal (STOP_SIGNAL, handle_stop_sig);
+ else
+ signal (STOP_SIGNAL, stop_sig);
+ }
+#endif
+
+ while (1)
+ {
+ /* Make sure that all output has been output. Some machines may let
+ you get away with leaving out some of the gdb_flush, but not all. */
+ wrap_here ("");
+ gdb_flush (gdb_stdout);
+ gdb_flush (gdb_stderr);
+
+ if (source_file_name != NULL)
+ {
+ ++source_line_number;
+ sprintf (source_error,
+ "%s%s:%d: Error in sourced command file:\n",
+ source_pre_error,
+ source_file_name,
+ source_line_number);
+ error_pre_print = source_error;
+ }
+
+ if (annotation_level > 1 && instream == stdin)
+ {
+ printf_unfiltered ("\n\032\032pre-");
+ printf_unfiltered (annotation_suffix);
+ printf_unfiltered ("\n");
+ }
+
+ /* Don't use fancy stuff if not talking to stdin. */
+ if (readline_hook && instream == NULL)
+ {
+ rl = (*readline_hook) (local_prompt);
+ }
+ else if (command_editing_p && instream == stdin && ISATTY (instream))
+ {
+ rl = readline (local_prompt);
+ }
+ else
+ {
+ rl = gdb_readline (local_prompt);
+ }
+
+ if (annotation_level > 1 && instream == stdin)
+ {
+ printf_unfiltered ("\n\032\032post-");
+ printf_unfiltered (annotation_suffix);
+ printf_unfiltered ("\n");
+ }
+
+ if (!rl || rl == (char *) EOF)
+ {
+ got_eof = 1;
+ break;
+ }
+ if (strlen (rl) + 1 + (p - linebuffer) > linelength)
+ {
+ linelength = strlen (rl) + 1 + (p - linebuffer);
+ nline = (char *) xrealloc (linebuffer, linelength);
+ p += nline - linebuffer;
+ linebuffer = nline;
+ }
+ p1 = rl;
+ /* Copy line. Don't copy null at end. (Leaves line alone
+ if this was just a newline) */
+ while (*p1)
+ *p++ = *p1++;
+
+ xfree (rl); /* Allocated in readline. */
+
+ if (p == linebuffer || *(p - 1) != '\\')
+ break;
+
+ p--; /* Put on top of '\'. */
+ local_prompt = (char *) 0;
+ }
+
+#ifdef STOP_SIGNAL
+ if (job_control)
+ signal (STOP_SIGNAL, SIG_DFL);
+#endif
+ immediate_quit--;
+
+ if (got_eof)
+ return NULL;
+
+#define SERVER_COMMAND_LENGTH 7
+ server_command =
+ (p - linebuffer > SERVER_COMMAND_LENGTH)
+ && STREQN (linebuffer, "server ", SERVER_COMMAND_LENGTH);
+ if (server_command)
+ {
+ /* Note that we don't set `line'. Between this and the check in
+ dont_repeat, this insures that repeating will still do the
+ right thing. */
+ *p = '\0';
+ return linebuffer + SERVER_COMMAND_LENGTH;
+ }
+
+ /* Do history expansion if that is wished. */
+ if (history_expansion_p && instream == stdin
+ && ISATTY (instream))
+ {
+ char *history_value;
+ int expanded;
+
+ *p = '\0'; /* Insert null now. */
+ expanded = history_expand (linebuffer, &history_value);
+ if (expanded)
+ {
+ /* Print the changes. */
+ printf_unfiltered ("%s\n", history_value);
+
+ /* If there was an error, call this function again. */
+ if (expanded < 0)
+ {
+ xfree (history_value);
+ return command_line_input (prompt_arg, repeat, annotation_suffix);
+ }
+ if (strlen (history_value) > linelength)
+ {
+ linelength = strlen (history_value) + 1;
+ linebuffer = (char *) xrealloc (linebuffer, linelength);
+ }
+ strcpy (linebuffer, history_value);
+ p = linebuffer + strlen (linebuffer);
+ xfree (history_value);
+ }
+ }
+
+ /* If we just got an empty line, and that is supposed
+ to repeat the previous command, return the value in the
+ global buffer. */
+ if (repeat && p == linebuffer)
+ return line;
+ for (p1 = linebuffer; *p1 == ' ' || *p1 == '\t'; p1++);
+ if (repeat && !*p1)
+ return line;
+
+ *p = 0;
+
+ /* Add line to history if appropriate. */
+ if (instream == stdin
+ && ISATTY (stdin) && *linebuffer)
+ add_history (linebuffer);
+
+ /* Note: lines consisting solely of comments are added to the command
+ history. This is useful when you type a command, and then
+ realize you don't want to execute it quite yet. You can comment
+ out the command and then later fetch it from the value history
+ and remove the '#'. The kill ring is probably better, but some
+ people are in the habit of commenting things out. */
+ if (*p1 == '#')
+ *p1 = '\0'; /* Found a comment. */
+
+ /* Save into global buffer if appropriate. */
+ if (repeat)
+ {
+ if (linelength > linesize)
+ {
+ line = xrealloc (line, linelength);
+ linesize = linelength;
+ }
+ strcpy (line, linebuffer);
+ return line;
+ }
+
+ return linebuffer;
+}
+\f
+/* Print the GDB banner. */
+void
+print_gdb_version (struct ui_file *stream)
+{
+ /* From GNU coding standards, first line is meant to be easy for a
+ program to parse, and is just canonical program name and version
+ number, which starts after last space. */
+
+#ifdef MI_OUT
+ /* Print it console style until a format is defined */
+ fprintf_filtered (stream, "GNU gdb %s (MI_OUT)\n", version);
+#else
+ fprintf_filtered (stream, "GNU gdb %s\n", version);
+#endif
+
+ /* Second line is a copyright notice. */
+
+ fprintf_filtered (stream, "Copyright 2001 Free Software Foundation, Inc.\n");
+
+ /* Following the copyright is a brief statement that the program is
+ free software, that users are free to copy and change it on
+ certain conditions, that it is covered by the GNU GPL, and that
+ there is no warranty. */
+
+ fprintf_filtered (stream, "\
+GDB is free software, covered by the GNU General Public License, and you are\n\
+welcome to change it and/or distribute copies of it under certain conditions.\n\
+Type \"show copying\" to see the conditions.\n\
+There is absolutely no warranty for GDB. Type \"show warranty\" for details.\n");
+
+ /* After the required info we print the configuration information. */
+
+ fprintf_filtered (stream, "This GDB was configured as \"");
+ if (!STREQ (host_name, target_name))
+ {
+ fprintf_filtered (stream, "--host=%s --target=%s", host_name, target_name);
+ }
+ else
+ {
+ fprintf_filtered (stream, "%s", host_name);
+ }
+ fprintf_filtered (stream, "\".");
+}
+\f
+/* get_prompt: access method for the GDB prompt string. */
+
+#define MAX_PROMPT_SIZE 256
+
+/*
+ * int get_prompt_1 (char * buf);
+ *
+ * Work-horse for get_prompt (called via catch_errors).
+ * Argument is buffer to hold the formatted prompt.
+ *
+ * Returns: 1 for success (use formatted prompt)
+ * 0 for failure (use gdb_prompt_string).
+ */
+
+static int gdb_prompt_escape;
+
+static int
+get_prompt_1 (void *data)
+{
+ char *formatted_prompt = data;
+ char *local_prompt;
+
+ if (event_loop_p)
+ local_prompt = PROMPT (0);
+ else
+ local_prompt = gdb_prompt_string;
+
+
+ if (gdb_prompt_escape == 0)
+ {
+ return 0; /* do no formatting */
+ }
+ else
+ /* formatted prompt */
+ {
+ char fmt[40], *promptp, *outp, *tmp;
+ value_ptr arg_val;
+ DOUBLEST doubleval;
+ LONGEST longval;
+ CORE_ADDR addrval;
+
+ int i, len;
+ struct type *arg_type, *elt_type;
+
+ promptp = local_prompt;
+ outp = formatted_prompt;
+
+ while (*promptp != '\0')
+ {
+ int available = MAX_PROMPT_SIZE - (outp - formatted_prompt) - 1;
+
+ if (*promptp != gdb_prompt_escape)
+ {
+ if (available >= 1) /* overflow protect */
+ *outp++ = *promptp++;
+ }
+ else
+ {
+ /* GDB prompt string contains escape char. Parse for arg.
+ Two consecutive escape chars followed by arg followed by
+ a comma means to insert the arg using a default format.
+ Otherwise a printf format string may be included between
+ the two escape chars. eg:
+ %%foo, insert foo using default format
+ %2.2f%foo, insert foo using "%2.2f" format
+ A mismatch between the format string and the data type
+ of "foo" is an error (which we don't know how to protect
+ against). */
+
+ fmt[0] = '\0'; /* assume null format string */
+ if (promptp[1] == gdb_prompt_escape) /* double esc char */
+ {
+ promptp += 2; /* skip past two escape chars. */
+ }
+ else
+ {
+ /* extract format string from between two esc chars */
+ i = 0;
+ do
+ {
+ fmt[i++] = *promptp++; /* copy format string */
+ }
+ while (i < sizeof (fmt) - 1 &&
+ *promptp != gdb_prompt_escape &&
+ *promptp != '\0');
+
+ if (*promptp != gdb_prompt_escape)
+ error ("Syntax error at prompt position %d",
+ promptp - local_prompt);
+ else
+ {
+ promptp++; /* skip second escape char */
+ fmt[i++] = '\0'; /* terminate the format string */
+ }
+ }
+
+ arg_val = parse_to_comma_and_eval (&promptp);
+ if (*promptp == ',')
+ promptp++; /* skip past the comma */
+ arg_type = check_typedef (VALUE_TYPE (arg_val));
+ switch (TYPE_CODE (arg_type))
+ {
+ case TYPE_CODE_ARRAY:
+ elt_type = check_typedef (TYPE_TARGET_TYPE (arg_type));
+ if (TYPE_LENGTH (arg_type) > 0 &&
+ TYPE_LENGTH (elt_type) == 1 &&
+ TYPE_CODE (elt_type) == TYPE_CODE_INT)
+ {
+ int len = TYPE_LENGTH (arg_type);
+
+ if (VALUE_LAZY (arg_val))
+ value_fetch_lazy (arg_val);
+ tmp = VALUE_CONTENTS (arg_val);
+
+ if (len > available)
+ len = available; /* overflow protect */
+
+ /* FIXME: how to protect GDB from crashing
+ from bad user-supplied format string? */
+ if (fmt[0] != 0)
+ sprintf (outp, fmt, tmp);
+ else
+ strncpy (outp, tmp, len);
+ outp[len] = '\0';
+ }
+ break;
+ case TYPE_CODE_PTR:
+ elt_type = check_typedef (TYPE_TARGET_TYPE (arg_type));
+ addrval = value_as_pointer (arg_val);
+
+ if (TYPE_LENGTH (elt_type) == 1 &&
+ TYPE_CODE (elt_type) == TYPE_CODE_INT &&
+ addrval != 0)
+ {
+ /* display it as a string */
+ char *default_fmt = "%s";
+ char *tmp;
+ int err = 0;
+
+ /* Limiting the number of bytes that the following call
+ will read protects us from sprintf overflow later. */
+ i = target_read_string (addrval, /* src */
+ &tmp, /* dest */
+ available, /* len */
+ &err);
+ if (err) /* read failed */
+ error ("%s on target_read", safe_strerror (err));
+
+ tmp[i] = '\0'; /* force-terminate string */
+ /* FIXME: how to protect GDB from crashing
+ from bad user-supplied format string? */
+ sprintf (outp, fmt[0] == 0 ? default_fmt : fmt,
+ tmp);
+ xfree (tmp);
+ }
+ else
+ {
+ /* display it as a pointer */
+ char *default_fmt = "0x%x";
+
+ /* FIXME: how to protect GDB from crashing
+ from bad user-supplied format string? */
+ if (available >= 16 /*? */ ) /* overflow protect */
+ sprintf (outp, fmt[0] == 0 ? default_fmt : fmt,
+ (long) addrval);
+ }
+ break;
+ case TYPE_CODE_FLT:
+ {
+ char *default_fmt = "%g";
+
+ doubleval = value_as_double (arg_val);
+ /* FIXME: how to protect GDB from crashing
+ from bad user-supplied format string? */
+ if (available >= 16 /*? */ ) /* overflow protect */
+ sprintf (outp, fmt[0] == 0 ? default_fmt : fmt,
+ (double) doubleval);
+ break;
+ }
+ case TYPE_CODE_INT:
+ {
+ char *default_fmt = "%d";
+
+ longval = value_as_long (arg_val);
+ /* FIXME: how to protect GDB from crashing
+ from bad user-supplied format string? */
+ if (available >= 16 /*? */ ) /* overflow protect */
+ sprintf (outp, fmt[0] == 0 ? default_fmt : fmt,
+ (long) longval);
+ break;
+ }
+ case TYPE_CODE_BOOL:
+ {
+ /* no default format for bool */
+ longval = value_as_long (arg_val);
+ if (available >= 8 /*? */ ) /* overflow protect */
+ {
+ if (longval)
+ strcpy (outp, "<true>");
+ else
+ strcpy (outp, "<false>");
+ }
+ break;
+ }
+ case TYPE_CODE_ENUM:
+ {
+ /* no default format for enum */
+ longval = value_as_long (arg_val);
+ len = TYPE_NFIELDS (arg_type);
+ /* find enum name if possible */
+ for (i = 0; i < len; i++)
+ if (TYPE_FIELD_BITPOS (arg_type, i) == longval)
+ break; /* match -- end loop */
+
+ if (i < len) /* enum name found */
+ {
+ char *name = TYPE_FIELD_NAME (arg_type, i);
+
+ strncpy (outp, name, available);
+ /* in casel available < strlen (name), */
+ outp[available] = '\0';
+ }
+ else
+ {
+ if (available >= 16 /*? */ ) /* overflow protect */
+ sprintf (outp, "%ld", (long) longval);
+ }
+ break;
+ }
+ case TYPE_CODE_VOID:
+ *outp = '\0';
+ break; /* void type -- no output */
+ default:
+ error ("bad data type at prompt position %d",
+ promptp - local_prompt);
+ break;
+ }
+ outp += strlen (outp);
+ }
+ }
+ *outp++ = '\0'; /* terminate prompt string */
+ return 1;
+ }
+}
+
+char *
+get_prompt (void)
+{
+ static char buf[MAX_PROMPT_SIZE];
+
+ if (catch_errors (get_prompt_1, buf, "bad formatted prompt: ",
+ RETURN_MASK_ALL))
+ {
+ return &buf[0]; /* successful formatted prompt */
+ }
+ else
+ {
+ /* Prompt could not be formatted. */
+ if (event_loop_p)
+ return PROMPT (0);
+ else
+ return gdb_prompt_string;
+ }
+}
+
+void
+set_prompt (char *s)
+{
+/* ??rehrauer: I don't know why this fails, since it looks as though
+ assignments to prompt are wrapped in calls to savestring...
+ if (prompt != NULL)
+ xfree (prompt);
+ */
+ if (event_loop_p)
+ PROMPT (0) = savestring (s, strlen (s));
+ else
+ gdb_prompt_string = savestring (s, strlen (s));
+}
+\f
+
+/* If necessary, make the user confirm that we should quit. Return
+ non-zero if we should quit, zero if we shouldn't. */
+
+int
+quit_confirm (void)
+{
+ if (! ptid_equal (inferior_ptid, null_ptid) && target_has_execution)
+ {
+ char *s;
+
+ /* This is something of a hack. But there's no reliable way to
+ see if a GUI is running. The `use_windows' variable doesn't
+ cut it. */
+ if (init_ui_hook)
+ s = "A debugging session is active.\nDo you still want to close the debugger?";
+ else if (attach_flag)
+ s = "The program is running. Quit anyway (and detach it)? ";
+ else
+ s = "The program is running. Exit anyway? ";
+
+ if (!query (s))
+ return 0;
+ }
+
+ return 1;
+}
+
+/* Quit without asking for confirmation. */
+
+void
+quit_force (char *args, int from_tty)
+{
+ int exit_code = 0;
+
+ /* An optional expression may be used to cause gdb to terminate with the
+ value of that expression. */
+ if (args)
+ {
+ value_ptr val = parse_and_eval (args);
+
+ exit_code = (int) value_as_long (val);
+ }
+
+ if (! ptid_equal (inferior_ptid, null_ptid) && target_has_execution)
+ {
+ if (attach_flag)
+ target_detach (args, from_tty);
+ else
+ target_kill ();
+ }
+
+ /* UDI wants this, to kill the TIP. */
+ target_close (1);
+
+ /* Save the history information if it is appropriate to do so. */
+ if (write_history_p && history_filename)
+ write_history (history_filename);
+
+ do_final_cleanups (ALL_CLEANUPS); /* Do any final cleanups before exiting */
+
+ exit (exit_code);
+}
+
+/* Returns whether GDB is running on a terminal and whether the user
+ desires that questions be asked of them on that terminal. */
+
+int
+input_from_terminal_p (void)
+{
+ return gdb_has_a_terminal () && (instream == stdin) & caution;
+}
+\f
+/* ARGSUSED */
+static void
+dont_repeat_command (char *ignored, int from_tty)
+{
+ *line = 0; /* Can't call dont_repeat here because we're not
+ necessarily reading from stdin. */
+}
+\f
+/* Functions to manipulate command line editing control variables. */
+
+/* Number of commands to print in each call to show_commands. */
+#define Hist_print 10
+void
+show_commands (char *args, int from_tty)
+{
+ /* Index for history commands. Relative to history_base. */
+ int offset;
+
+ /* Number of the history entry which we are planning to display next.
+ Relative to history_base. */
+ static int num = 0;
+
+ /* The first command in the history which doesn't exist (i.e. one more
+ than the number of the last command). Relative to history_base. */
+ int hist_len;
+
+ /* Print out some of the commands from the command history. */
+ /* First determine the length of the history list. */
+ hist_len = history_size;
+ for (offset = 0; offset < history_size; offset++)
+ {
+ if (!history_get (history_base + offset))
+ {
+ hist_len = offset;
+ break;
+ }
+ }
+
+ if (args)
+ {
+ if (args[0] == '+' && args[1] == '\0')
+ /* "info editing +" should print from the stored position. */
+ ;
+ else
+ /* "info editing <exp>" should print around command number <exp>. */
+ num = (parse_and_eval_long (args) - history_base) - Hist_print / 2;
+ }
+ /* "show commands" means print the last Hist_print commands. */
+ else
+ {
+ num = hist_len - Hist_print;
+ }
+
+ if (num < 0)
+ num = 0;
+
+ /* If there are at least Hist_print commands, we want to display the last
+ Hist_print rather than, say, the last 6. */
+ if (hist_len - num < Hist_print)
+ {
+ num = hist_len - Hist_print;
+ if (num < 0)
+ num = 0;
+ }
+
+ for (offset = num; offset < num + Hist_print && offset < hist_len; offset++)
+ {
+ printf_filtered ("%5d %s\n", history_base + offset,
+ (history_get (history_base + offset))->line);
+ }
+
+ /* The next command we want to display is the next one that we haven't
+ displayed yet. */
+ num += Hist_print;
+
+ /* If the user repeats this command with return, it should do what
+ "show commands +" does. This is unnecessary if arg is null,
+ because "show commands +" is not useful after "show commands". */
+ if (from_tty && args)
+ {
+ args[0] = '+';
+ args[1] = '\0';
+ }
+}
+
+/* Called by do_setshow_command. */
+/* ARGSUSED */
+static void
+set_history_size_command (char *args, int from_tty, struct cmd_list_element *c)
+{
+ if (history_size == INT_MAX)
+ unstifle_history ();
+ else if (history_size >= 0)
+ stifle_history (history_size);
+ else
+ {
+ history_size = INT_MAX;
+ error ("History size must be non-negative");
+ }
+}
+
+/* ARGSUSED */
+void
+set_history (char *args, int from_tty)
+{
+ printf_unfiltered ("\"set history\" must be followed by the name of a history subcommand.\n");
+ help_list (sethistlist, "set history ", -1, gdb_stdout);
+}
+
+/* ARGSUSED */
+void
+show_history (char *args, int from_tty)
+{
+ cmd_show_list (showhistlist, from_tty, "");
+}
+
+int info_verbose = 0; /* Default verbose msgs off */
+
+/* Called by do_setshow_command. An elaborate joke. */
+/* ARGSUSED */
+void
+set_verbose (char *args, int from_tty, struct cmd_list_element *c)
+{
+ char *cmdname = "verbose";
+ struct cmd_list_element *showcmd;
+
+ showcmd = lookup_cmd_1 (&cmdname, showlist, NULL, 1);
+
+ if (info_verbose)
+ {
+ c->doc = "Set verbose printing of informational messages.";
+ showcmd->doc = "Show verbose printing of informational messages.";
+ }
+ else
+ {
+ c->doc = "Set verbosity.";
+ showcmd->doc = "Show verbosity.";
+ }
+}
+
+/* Init the history buffer. Note that we are called after the init file(s)
+ * have been read so that the user can change the history file via his
+ * .gdbinit file (for instance). The GDBHISTFILE environment variable
+ * overrides all of this.
+ */
+
+void
+init_history (void)
+{
+ char *tmpenv;
+
+ tmpenv = getenv ("HISTSIZE");
+ if (tmpenv)
+ history_size = atoi (tmpenv);
+ else if (!history_size)
+ history_size = 256;
+
+ stifle_history (history_size);
+
+ tmpenv = getenv ("GDBHISTFILE");
+ if (tmpenv)
+ history_filename = savestring (tmpenv, strlen (tmpenv));
+ else if (!history_filename)
+ {
+ /* We include the current directory so that if the user changes
+ directories the file written will be the same as the one
+ that was read. */
+#ifdef __MSDOS__
+ /* No leading dots in file names are allowed on MSDOS. */
+ history_filename = concat (current_directory, "/_gdb_history", NULL);
+#else
+ history_filename = concat (current_directory, "/.gdb_history", NULL);
+#endif
+ }
+ read_history (history_filename);
+}
+
+static void
+init_main (void)
+{
+ struct cmd_list_element *c;
+
+ /* If we are running the asynchronous version,
+ we initialize the prompts differently. */
+ if (!event_loop_p)
+ {
+ gdb_prompt_string = savestring (DEFAULT_PROMPT, strlen (DEFAULT_PROMPT));
+ }
+ else
+ {
+ /* initialize the prompt stack to a simple "(gdb) " prompt or to
+ whatever the DEFAULT_PROMPT is. */
+ the_prompts.top = 0;
+ PREFIX (0) = "";
+ PROMPT (0) = savestring (DEFAULT_PROMPT, strlen (DEFAULT_PROMPT));
+ SUFFIX (0) = "";
+ /* Set things up for annotation_level > 1, if the user ever decides
+ to use it. */
+ async_annotation_suffix = "prompt";
+ /* Set the variable associated with the setshow prompt command. */
+ new_async_prompt = savestring (PROMPT (0), strlen (PROMPT (0)));
+
+ /* If gdb was started with --annotate=2, this is equivalent to
+ the user entering the command 'set annotate 2' at the gdb
+ prompt, so we need to do extra processing. */
+ if (annotation_level > 1)
+ set_async_annotation_level (NULL, 0, NULL);
+ }
+ gdb_prompt_escape = 0; /* default to none. */
+
+ /* Set the important stuff up for command editing. */
+ command_editing_p = 1;
+ history_expansion_p = 0;
+ write_history_p = 0;
+
+ /* Setup important stuff for command line editing. */
+ rl_completion_entry_function = (int (*)()) readline_line_completion_function;
+ rl_completer_word_break_characters =
+ get_gdb_completer_word_break_characters ();
+ rl_completer_quote_characters = get_gdb_completer_quote_characters ();
+ rl_readline_name = "gdb";
+
+ /* The set prompt command is different depending whether or not the
+ async version is run. NOTE: this difference is going to
+ disappear as we make the event loop be the default engine of
+ gdb. */
+ if (!event_loop_p)
+ {
+ add_show_from_set
+ (add_set_cmd ("prompt", class_support, var_string,
+ (char *) &gdb_prompt_string, "Set gdb's prompt",
+ &setlist),
+ &showlist);
+ }
+ else
+ {
+ c = add_set_cmd ("prompt", class_support, var_string,
+ (char *) &new_async_prompt, "Set gdb's prompt",
+ &setlist);
+ add_show_from_set (c, &showlist);
+ c->function.sfunc = set_async_prompt;
+ }
+
+ add_show_from_set
+ (add_set_cmd ("prompt-escape-char", class_support, var_zinteger,
+ (char *) &gdb_prompt_escape,
+ "Set escape character for formatting of gdb's prompt",
+ &setlist),
+ &showlist);
+
+ add_com ("dont-repeat", class_support, dont_repeat_command, "Don't repeat this command.\n\
+Primarily used inside of user-defined commands that should not be repeated when\n\
+hitting return.");
+
+ /* The set editing command is different depending whether or not the
+ async version is run. NOTE: this difference is going to disappear
+ as we make the event loop be the default engine of gdb. */
+ if (!event_loop_p)
+ {
+ add_show_from_set
+ (add_set_cmd ("editing", class_support, var_boolean, (char *) &command_editing_p,
+ "Set editing of command lines as they are typed.\n\
+Use \"on\" to enable the editing, and \"off\" to disable it.\n\
+Without an argument, command line editing is enabled. To edit, use\n\
+EMACS-like or VI-like commands like control-P or ESC.", &setlist),
+ &showlist);
+ }
+ else
+ {
+ c = add_set_cmd ("editing", class_support, var_boolean, (char *) &async_command_editing_p,
+ "Set editing of command lines as they are typed.\n\
+Use \"on\" to enable the editing, and \"off\" to disable it.\n\
+Without an argument, command line editing is enabled. To edit, use\n\
+EMACS-like or VI-like commands like control-P or ESC.", &setlist);
+
+ add_show_from_set (c, &showlist);
+ c->function.sfunc = set_async_editing_command;
+ }
+
+ add_show_from_set
+ (add_set_cmd ("save", no_class, var_boolean, (char *) &write_history_p,
+ "Set saving of the history record on exit.\n\
+Use \"on\" to enable the saving, and \"off\" to disable it.\n\
+Without an argument, saving is enabled.", &sethistlist),
+ &showhistlist);
+
+ c = add_set_cmd ("size", no_class, var_integer, (char *) &history_size,
+ "Set the size of the command history, \n\
+ie. the number of previous commands to keep a record of.", &sethistlist);
+ add_show_from_set (c, &showhistlist);
+ c->function.sfunc = set_history_size_command;
+
+ c = add_set_cmd ("filename", no_class, var_filename,
+ (char *) &history_filename,
+ "Set the filename in which to record the command history\n\
+ (the list of previous commands of which a record is kept).", &sethistlist);
+ c->completer = filename_completer;
+ add_show_from_set (c, &showhistlist);
+
+ add_show_from_set
+ (add_set_cmd ("confirm", class_support, var_boolean,
+ (char *) &caution,
+ "Set whether to confirm potentially dangerous operations.",
+ &setlist),
+ &showlist);
+
+ /* The set annotate command is different depending whether or not
+ the async version is run. NOTE: this difference is going to
+ disappear as we make the event loop be the default engine of
+ gdb. */
+ if (!event_loop_p)
+ {
+ c = add_set_cmd ("annotate", class_obscure, var_zinteger,
+ (char *) &annotation_level, "Set annotation_level.\n\
+0 == normal; 1 == fullname (for use when running under emacs)\n\
+2 == output annotated suitably for use by programs that control GDB.",
+ &setlist);
+ c = add_show_from_set (c, &showlist);
+ }
+ else
+ {
+ c = add_set_cmd ("annotate", class_obscure, var_zinteger,
+ (char *) &annotation_level, "Set annotation_level.\n\
+0 == normal; 1 == fullname (for use when running under emacs)\n\
+2 == output annotated suitably for use by programs that control GDB.",
+ &setlist);
+ add_show_from_set (c, &showlist);
+ c->function.sfunc = set_async_annotation_level;
+ }
+ if (event_loop_p)
+ {
+ add_show_from_set
+ (add_set_cmd ("exec-done-display", class_support, var_boolean, (char *) &exec_done_display_p,
+ "Set notification of completion for asynchronous execution commands.\n\
+Use \"on\" to enable the notification, and \"off\" to disable it.", &setlist),
+ &showlist);
+ }
+}
+
+void
+gdb_init (char *argv0)
+{
+ if (pre_init_ui_hook)
+ pre_init_ui_hook ();
+
+ /* Run the init function of each source file */
+
+ getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));
+ current_directory = gdb_dirbuf;
+
+#ifdef __MSDOS__
+ /* Make sure we return to the original directory upon exit, come
+ what may, since the OS doesn't do that for us. */
+ make_final_cleanup (do_chdir_cleanup, xstrdup (current_directory));
+#endif
+
+ init_cmd_lists (); /* This needs to be done first */
+ initialize_targets (); /* Setup target_terminal macros for utils.c */
+ initialize_utils (); /* Make errors and warnings possible */
+ initialize_all_files ();
+ initialize_current_architecture ();
+ init_cli_cmds();
+ init_main (); /* But that omits this file! Do it now */
+
+ /* The signal handling mechanism is different depending whether or
+ not the async version is run. NOTE: in the future we plan to make
+ the event loop be the default engine of gdb, and this difference
+ will disappear. */
+ if (event_loop_p)
+ async_init_signals ();
+ else
+ init_signals ();
+
+ /* We need a default language for parsing expressions, so simple things like
+ "set width 0" won't fail if no language is explicitly set in a config file
+ or implicitly set by reading an executable during startup. */
+ set_language (language_c);
+ expected_language = current_language; /* don't warn about the change. */
+
+#ifdef UI_OUT
+ /* Install the default UI */
+ if (!init_ui_hook)
+ {
+ uiout = cli_out_new (gdb_stdout);
+
+ /* All the interpreters should have had a look at things by now.
+ Initialize the selected interpreter. */
+ if (interpreter_p)
+ {
+ fprintf_unfiltered (gdb_stderr, "Interpreter `%s' unrecognized.\n",
+ interpreter_p);
+ exit (1);
+ }
+ }
+#endif
+
+ if (init_ui_hook)
+ init_ui_hook (argv0);
+}
projects / deliverable / binutils-gdb.git / blobdiff