X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Ftop.c;h=5d644dc00b4e4fc44b8f17dfa1223c0e63572004;hb=46711df821e6955e5fdc91e2d939356e048aa64b;hp=1f2a21724666ec20997477c48c527b5d46070e46;hpb=0f71a2f66f83f4c7ac139fa8d33ab882362fe861;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/top.c b/gdb/top.c index 1f2a217246..5d644dc00b 100644 --- a/gdb/top.c +++ b/gdb/top.c @@ -1,39 +1,46 @@ /* 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 #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 @@ -43,118 +50,22 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #undef savestring #include -#ifdef HAVE_UNISTD_H -#include -#endif +#include + +#include "event-top.h" #include "gdb_string.h" #include "gdb_stat.h" #include - -/* 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. */ @@ -171,101 +82,11 @@ int inhibit_gdbinit = 0; 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 @@ -284,14 +105,13 @@ char gdb_dirbuf[1024]; 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. */ @@ -300,7 +120,7 @@ char *line; 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 @@ -316,48 +136,46 @@ int baud_rate = -1; /* 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. */ @@ -365,44 +183,31 @@ static void stop_sig PARAMS ((int)); /* 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 @@ -415,77 +220,101 @@ void (*flush_hook) PARAMS ((GDB_FILE *stream)); 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; -/* 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) @@ -498,8 +327,11 @@ return_to_top_level (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 @@ -521,89 +353,169 @@ return_to_top_level (reason) 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 */ /* Line number we are currently in in a file which is being sourced. */ @@ -636,9 +548,8 @@ static int source_error_allocated; /* 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; @@ -646,641 +557,92 @@ source_cleanup (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); } -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); @@ -1292,16 +654,26 @@ execute_command (p, from_tty) 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 @@ -1322,21 +694,11 @@ execute_command (p, from_tty) } } -/* 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; @@ -1350,33 +712,18 @@ command_loop () 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; @@ -1422,3 +769,1246 @@ command_loop () } } +/* 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); + } +} + +/* 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; +} + +/* 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; + + +#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 +} + +/* 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; +} + +/* 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, "\"."); +} + +/* 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, ""); + else + strcpy (outp, ""); + } + 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)); +} + + +/* 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; +} + +/* 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. */ +} + +/* 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 " should print around command number . */ + 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); +}