1 /* Top level stuff for GDB, the GNU debugger.
3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
4 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
26 #include "call-cmds.h"
27 #include "cli/cli-cmds.h"
28 #include "cli/cli-script.h"
29 #include "cli/cli-setshow.h"
34 #include "breakpoint.h"
36 #include "expression.h"
39 #include "terminal.h" /* For job_control. */
41 #include "completer.h"
46 #include "gdb_assert.h"
48 /* readline include files */
49 #include <readline/readline.h>
50 #include <readline/history.h>
52 /* readline defines this. */
55 #include <sys/types.h>
59 #include "event-top.h"
60 #include "gdb_string.h"
66 /* Default command line prompt. This is overriden in some configs. */
68 #ifndef DEFAULT_PROMPT
69 #define DEFAULT_PROMPT "(gdb) "
72 /* Initialization file name for gdb. This is overridden in some configs. */
74 #ifndef GDBINIT_FILENAME
75 #define GDBINIT_FILENAME ".gdbinit"
77 char gdbinit
[] = GDBINIT_FILENAME
;
79 int inhibit_gdbinit
= 0;
81 /* If nonzero, and GDB has been configured to be able to use windows,
82 attempt to open them upon startup. */
86 extern char lang_frame_mismatch_warn
[]; /* language.c */
88 /* Flag for whether we want all the "from_tty" gubbish printed. */
90 int caution
= 1; /* Default is yes, sigh. */
92 /* stdio stream that command input is being read from. Set to stdin normally.
93 Set by source_command to the file we are sourcing. Set to NULL if we are
94 executing a user-defined command or interacting via a GUI. */
98 /* Current working directory. */
100 char *current_directory
;
102 /* The directory name is actually stored here (usually). */
103 char gdb_dirbuf
[1024];
105 /* Function to call before reading a command, if nonzero.
106 The function receives two args: an input stream,
107 and a prompt string. */
109 void (*window_hook
) (FILE *, char *);
114 /* gdb prints this when reading a command interactively */
115 static char *gdb_prompt_string
; /* the global prompt string */
117 /* Buffer used for reading command lines, and the size
118 allocated for it so far. */
123 /* Nonzero if the current command is modified by "server ". This
124 affects things like recording into the command history, commands
125 repeating on RETURN, etc. This is so a user interface (emacs, GUI,
126 whatever) can issue its own commands and also send along commands
127 from the user, and have the user not notice that the user interface
128 is issuing commands too. */
131 /* Baud rate specified for talking to serial target systems. Default
132 is left as -1, so targets can choose their own defaults. */
133 /* FIXME: This means that "show remotebaud" and gr_files_info can print -1
134 or (unsigned int)-1. This is a Bad User Interface. */
138 /* Timeout limit for response from target. */
140 /* The default value has been changed many times over the years. It
141 was originally 5 seconds. But that was thought to be a long time
142 to sit and wait, so it was changed to 2 seconds. That was thought
143 to be plenty unless the connection was going through some terminal
144 server or multiplexer or other form of hairy serial connection.
146 In mid-1996, remote_timeout was moved from remote.c to top.c and
147 it began being used in other remote-* targets. It appears that the
148 default was changed to 20 seconds at that time, perhaps because the
149 Hitachi E7000 ICE didn't always respond in a timely manner.
151 But if 5 seconds is a long time to sit and wait for retransmissions,
152 20 seconds is far worse. This demonstrates the difficulty of using
153 a single variable for all protocol timeouts.
155 As remote.c is used much more than remote-e7000.c, it was changed
156 back to 2 seconds in 1999. */
158 int remote_timeout
= 2;
160 /* Non-zero tells remote* modules to output debugging info. */
162 int remote_debug
= 0;
164 /* Non-zero means the target is running. Note: this is different from
165 saying that there is an active target and we are stopped at a
166 breakpoint, for instance. This is a real indicator whether the
167 target is off and running, which gdb is doing something else. */
168 int target_executing
= 0;
170 /* Level of control structure. */
171 static int control_level
;
173 /* Signal to catch ^Z typed while reading a command: SIGTSTP or SIGCONT. */
177 #define STOP_SIGNAL SIGTSTP
178 static void stop_sig (int);
182 /* Hooks for alternate command interfaces. */
184 /* Called after most modules have been initialized, but before taking users
187 If the UI fails to initialize and it wants GDB to continue
188 using the default UI, then it should clear this hook before returning. */
190 void (*init_ui_hook
) (char *argv0
);
192 /* This hook is called from within gdb's many mini-event loops which could
193 steal control from a real user interface's event loop. It returns
194 non-zero if the user is requesting a detach, zero otherwise. */
196 int (*ui_loop_hook
) (int);
198 /* Called instead of command_loop at top level. Can be invoked via
199 throw_exception(). */
201 void (*command_loop_hook
) (void);
204 /* Called from print_frame_info to list the line we stopped in. */
206 void (*print_frame_info_listing_hook
) (struct symtab
* s
, int line
,
207 int stopline
, int noerror
);
208 /* Replaces most of query. */
210 int (*query_hook
) (const char *, va_list);
212 /* Replaces most of warning. */
214 void (*warning_hook
) (const char *, va_list);
216 /* These three functions support getting lines of text from the user. They
217 are used in sequence. First readline_begin_hook is called with a text
218 string that might be (for example) a message for the user to type in a
219 sequence of commands to be executed at a breakpoint. If this function
220 calls back to a GUI, it might take this opportunity to pop up a text
221 interaction window with this message. Next, readline_hook is called
222 with a prompt that is emitted prior to collecting the user input.
223 It can be called multiple times. Finally, readline_end_hook is called
224 to notify the GUI that we are done with the interaction window and it
227 void (*readline_begin_hook
) (char *, ...);
228 char *(*readline_hook
) (char *);
229 void (*readline_end_hook
) (void);
231 /* Called as appropriate to notify the interface of the specified breakpoint
234 void (*create_breakpoint_hook
) (struct breakpoint
* bpt
);
235 void (*delete_breakpoint_hook
) (struct breakpoint
* bpt
);
236 void (*modify_breakpoint_hook
) (struct breakpoint
* bpt
);
238 /* Called as appropriate to notify the interface that we have attached
239 to or detached from an already running process. */
241 void (*attach_hook
) (void);
242 void (*detach_hook
) (void);
244 /* Called during long calculations to allow GUI to repair window damage, and to
245 check for stop buttons, etc... */
247 void (*interactive_hook
) (void);
249 /* Called when the registers have changed, as a hint to a GUI
250 to minimize window update. */
252 void (*registers_changed_hook
) (void);
254 /* Tell the GUI someone changed the register REGNO. -1 means
255 that the caller does not know which register changed or
256 that several registers have changed (see value_assign). */
257 void (*register_changed_hook
) (int regno
);
259 /* Tell the GUI someone changed LEN bytes of memory at ADDR */
260 void (*memory_changed_hook
) (CORE_ADDR addr
, int len
);
262 /* Called when going to wait for the target. Usually allows the GUI to run
263 while waiting for target events. */
265 ptid_t (*target_wait_hook
) (ptid_t ptid
,
266 struct target_waitstatus
* status
);
268 /* Used by UI as a wrapper around command execution. May do various things
269 like enabling/disabling buttons, etc... */
271 void (*call_command_hook
) (struct cmd_list_element
* c
, char *cmd
,
274 /* Called after a `set' command has finished. Is only run if the
275 `set' command succeeded. */
277 void (*set_hook
) (struct cmd_list_element
* c
);
279 /* Called when the current thread changes. Argument is thread id. */
281 void (*context_hook
) (int id
);
283 /* Takes control from error (). Typically used to prevent longjmps out of the
284 middle of the GUI. Usually used in conjunction with a catch routine. */
286 NORETURN
void (*error_hook
) (void) ATTR_NORETURN
;
289 /* One should use catch_errors rather than manipulating these
291 #if defined(HAVE_SIGSETJMP)
292 #define SIGJMP_BUF sigjmp_buf
293 #define SIGSETJMP(buf) sigsetjmp((buf), 1)
294 #define SIGLONGJMP(buf,val) siglongjmp((buf), (val))
296 #define SIGJMP_BUF jmp_buf
297 #define SIGSETJMP(buf) setjmp(buf)
298 #define SIGLONGJMP(buf,val) longjmp((buf), (val))
301 /* Where to go for throw_exception(). */
302 static SIGJMP_BUF
*catch_return
;
304 /* Return for reason REASON to the nearest containing catch_errors(). */
307 throw_exception (enum return_reason reason
)
312 /* Perhaps it would be cleaner to do this via the cleanup chain (not sure
313 I can think of a reason why that is vital, though). */
314 bpstat_clear_actions (stop_bpstat
); /* Clear queued breakpoint commands */
316 disable_current_display ();
317 do_cleanups (ALL_CLEANUPS
);
318 if (event_loop_p
&& target_can_async_p () && !target_executing
)
319 do_exec_cleanups (ALL_CLEANUPS
);
320 if (event_loop_p
&& sync_execution
)
321 do_exec_error_cleanups (ALL_CLEANUPS
);
323 if (annotation_level
> 1)
334 /* Jump to the containing catch_errors() call, communicating REASON
335 to that call via setjmp's return value. Note that REASON can't
336 be zero, by definition in defs.h. */
338 (NORETURN
void) SIGLONGJMP (*catch_return
, (int) reason
);
341 /* Call FUNC() with args FUNC_UIOUT and FUNC_ARGS, catching any
342 errors. Set FUNC_CAUGHT to an ``enum return_reason'' if the
343 function is aborted (using throw_exception() or zero if the
344 function returns normally. Set FUNC_VAL to the value returned by
345 the function or 0 if the function was aborted.
347 Must not be called with immediate_quit in effect (bad things might
348 happen, say we got a signal in the middle of a memcpy to quit_return).
349 This is an OK restriction; with very few exceptions immediate_quit can
350 be replaced by judicious use of QUIT.
352 MASK specifies what to catch; it is normally set to
353 RETURN_MASK_ALL, if for no other reason than that the code which
354 calls catch_errors might not be set up to deal with a quit which
355 isn't caught. But if the code can deal with it, it generally
356 should be RETURN_MASK_ERROR, unless for some reason it is more
357 useful to abort only the portion of the operation inside the
358 catch_errors. Note that quit should return to the command line
359 fairly quickly, even if some further processing is being done. */
361 /* MAYBE: cagney/1999-11-05: catch_errors() in conjunction with
362 error() et.al. could maintain a set of flags that indicate the the
363 current state of each of the longjmp buffers. This would give the
364 longjmp code the chance to detect a longjmp botch (before it gets
365 to longjmperror()). Prior to 1999-11-05 this wasn't possible as
366 code also randomly used a SET_TOP_LEVEL macro that directly
367 initialize the longjmp buffers. */
369 /* MAYBE: cagney/1999-11-05: Should the catch_errors and cleanups code
370 be consolidated into a single file instead of being distributed
371 between utils.c and top.c? */
374 catcher (catch_exceptions_ftype
*func
,
375 struct ui_out
*func_uiout
,
378 enum return_reason
*func_caught
,
382 SIGJMP_BUF
*saved_catch
;
384 struct cleanup
*saved_cleanup_chain
;
385 char *saved_error_pre_print
;
386 char *saved_quit_pre_print
;
387 struct ui_out
*saved_uiout
;
389 /* Return value from SIGSETJMP(): enum return_reason if error or
390 quit caught, 0 otherwise. */
393 /* Return value from FUNC(): Hopefully non-zero. Explicitly set to
394 zero if an error quit was caught. */
397 /* Override error/quit messages during FUNC. */
399 saved_error_pre_print
= error_pre_print
;
400 saved_quit_pre_print
= quit_pre_print
;
402 if (mask
& RETURN_MASK_ERROR
)
403 error_pre_print
= errstring
;
404 if (mask
& RETURN_MASK_QUIT
)
405 quit_pre_print
= errstring
;
407 /* Override the global ``struct ui_out'' builder. */
412 /* Prevent error/quit during FUNC from calling cleanups established
415 saved_cleanup_chain
= save_cleanups ();
417 /* Call FUNC, catching error/quit events. */
419 saved_catch
= catch_return
;
420 catch_return
= &catch;
421 caught
= SIGSETJMP (catch);
423 val
= (*func
) (func_uiout
, func_args
);
426 catch_return
= saved_catch
;
428 /* FIXME: cagney/1999-11-05: A correct FUNC implementation will
429 clean things up (restoring the cleanup chain) to the state they
430 were just prior to the call. Unfortunately, many FUNC's are not
431 that well behaved. This could be fixed by adding either a
432 do_cleanups call (to cover the problem) or an assertion check to
433 detect bad FUNCs code. */
435 /* Restore the cleanup chain, the error/quit messages, and the uiout
436 builder, to their original states. */
438 restore_cleanups (saved_cleanup_chain
);
442 if (mask
& RETURN_MASK_QUIT
)
443 quit_pre_print
= saved_quit_pre_print
;
444 if (mask
& RETURN_MASK_ERROR
)
445 error_pre_print
= saved_error_pre_print
;
447 /* Return normally if no error/quit event occurred or this catcher
448 can handle this exception. The caller analyses the func return
451 if (!caught
|| (mask
& RETURN_MASK (caught
)))
454 *func_caught
= caught
;
458 /* The caller didn't request that the event be caught, relay the
459 event to the next containing catch_errors(). */
461 throw_exception (caught
);
465 catch_exceptions (struct ui_out
*uiout
,
466 catch_exceptions_ftype
*func
,
472 enum return_reason caught
;
473 catcher (func
, uiout
, func_args
, &val
, &caught
, errstring
, mask
);
474 gdb_assert (val
>= 0);
475 gdb_assert (caught
<= 0);
481 struct catch_errors_args
483 catch_errors_ftype
*func
;
488 do_catch_errors (struct ui_out
*uiout
, void *data
)
490 struct catch_errors_args
*args
= data
;
491 return args
->func (args
->func_args
);
495 catch_errors (catch_errors_ftype
*func
, void *func_args
, char *errstring
,
499 enum return_reason caught
;
500 struct catch_errors_args args
;
502 args
.func_args
= func_args
;
503 catcher (do_catch_errors
, uiout
, &args
, &val
, &caught
, errstring
, mask
);
509 struct captured_command_args
511 catch_command_errors_ftype
*command
;
517 do_captured_command (void *data
)
519 struct captured_command_args
*context
= data
;
520 context
->command (context
->arg
, context
->from_tty
);
521 /* FIXME: cagney/1999-11-07: Technically this do_cleanups() call
522 isn't needed. Instead an assertion check could be made that
523 simply confirmed that the called function correctly cleaned up
524 after itself. Unfortunately, old code (prior to 1999-11-04) in
525 main.c was calling SET_TOP_LEVEL(), calling the command function,
526 and then *always* calling do_cleanups(). For the moment we
527 remain ``bug compatible'' with that old code.. */
528 do_cleanups (ALL_CLEANUPS
);
533 catch_command_errors (catch_command_errors_ftype
* command
,
534 char *arg
, int from_tty
, return_mask mask
)
536 struct captured_command_args args
;
537 args
.command
= command
;
539 args
.from_tty
= from_tty
;
540 return catch_errors (do_captured_command
, &args
, "", mask
);
544 /* Handler for SIGHUP. */
547 /* Just a little helper function for disconnect(). */
549 /* NOTE 1999-04-29: This function will be static again, once we modify
550 gdb to use the event loop as the default command loop and we merge
551 event-top.c into this file, top.c */
555 caution
= 0; /* Throw caution to the wind -- we're exiting.
556 This prevents asking the user dumb questions. */
557 quit_command ((char *) 0, 0);
562 disconnect (int signo
)
564 catch_errors (quit_cover
, NULL
,
565 "Could not kill the program being debugged", RETURN_MASK_ALL
);
566 signal (SIGHUP
, SIG_DFL
);
567 kill (getpid (), SIGHUP
);
569 #endif /* defined SIGHUP */
571 /* Line number we are currently in in a file which is being sourced. */
572 /* NOTE 1999-04-29: This variable will be static again, once we modify
573 gdb to use the event loop as the default command loop and we merge
574 event-top.c into this file, top.c */
575 /* static */ int source_line_number
;
577 /* Name of the file we are sourcing. */
578 /* NOTE 1999-04-29: This variable will be static again, once we modify
579 gdb to use the event loop as the default command loop and we merge
580 event-top.c into this file, top.c */
581 /* static */ char *source_file_name
;
583 /* Buffer containing the error_pre_print used by the source stuff.
585 /* NOTE 1999-04-29: This variable will be static again, once we modify
586 gdb to use the event loop as the default command loop and we merge
587 event-top.c into this file, top.c */
588 /* static */ char *source_error
;
589 static int source_error_allocated
;
591 /* Something to glom on to the start of error_pre_print if source_file_name
593 /* NOTE 1999-04-29: This variable will be static again, once we modify
594 gdb to use the event loop as the default command loop and we merge
595 event-top.c into this file, top.c */
596 /* static */ char *source_pre_error
;
598 /* Clean up on error during a "source" command (or execution of a
599 user-defined command). */
602 do_restore_instream_cleanup (void *stream
)
604 /* Restore the previous input stream. */
608 /* Read commands from STREAM. */
610 read_command_file (FILE *stream
)
612 struct cleanup
*cleanups
;
614 cleanups
= make_cleanup (do_restore_instream_cleanup
, instream
);
617 do_cleanups (cleanups
);
620 void (*pre_init_ui_hook
) (void);
624 do_chdir_cleanup (void *old_dir
)
631 /* Execute the line P as a command.
632 Pass FROM_TTY as second argument to the defining function. */
635 execute_command (char *p
, int from_tty
)
637 register struct cmd_list_element
*c
;
638 register enum language flang
;
639 static int warned
= 0;
644 /* Force cleanup of any alloca areas if using C alloca instead of
648 /* This can happen when command_line_input hits end of file. */
652 serial_log_command (p
);
654 while (*p
== ' ' || *p
== '\t')
661 c
= lookup_cmd (&p
, cmdlist
, "", 0, 1);
663 /* If the target is running, we allow only a limited set of
665 if (event_loop_p
&& target_can_async_p () && target_executing
)
666 if (!strcmp (c
->name
, "help")
667 && !strcmp (c
->name
, "pwd")
668 && !strcmp (c
->name
, "show")
669 && !strcmp (c
->name
, "stop"))
670 error ("Cannot execute this command while the target is running.");
672 /* Pass null arg rather than an empty one. */
675 /* FIXME: cagney/2002-02-02: The c->type test is pretty dodgy
676 while the is_complete_command(cfunc) test is just plain
677 bogus. They should both be replaced by a test of the form
678 c->strip_trailing_white_space_p. */
679 /* NOTE: cagney/2002-02-02: The function.cfunc in the below
680 can't be replaced with func. This is because it is the
681 cfunc, and not the func, that has the value that the
682 is_complete_command hack is testing for. */
683 /* Clear off trailing whitespace, except for set and complete
686 && c
->type
!= set_cmd
687 && !is_complete_command (c
))
689 p
= arg
+ strlen (arg
) - 1;
690 while (p
>= arg
&& (*p
== ' ' || *p
== '\t'))
695 /* If this command has been pre-hooked, run the hook first. */
696 execute_cmd_pre_hook (c
);
698 if (c
->flags
& DEPRECATED_WARN_USER
)
699 deprecated_cmd_warning (&line
);
701 if (c
->class == class_user
)
702 execute_user_command (c
, arg
);
703 else if (c
->type
== set_cmd
|| c
->type
== show_cmd
)
704 do_setshow_command (arg
, from_tty
& caution
, c
);
705 else if (c
->func
== NULL
)
706 error ("That is not a command, just a help topic.");
707 else if (call_command_hook
)
708 call_command_hook (c
, arg
, from_tty
& caution
);
710 (*c
->func
) (c
, arg
, from_tty
& caution
);
712 /* If this command has been post-hooked, run the hook last. */
713 execute_cmd_post_hook (c
);
717 /* Tell the user if the language has changed (except first time). */
718 if (current_language
!= expected_language
)
720 if (language_mode
== language_mode_auto
)
722 language_info (1); /* Print what changed. */
727 /* Warn the user if the working language does not match the
728 language of the current frame. Only warn the user if we are
729 actually running the program, i.e. there is a stack. */
730 /* FIXME: This should be cacheing the frame and only running when
731 the frame changes. */
733 if (target_has_stack
)
735 flang
= get_frame_language ();
737 && flang
!= language_unknown
738 && flang
!= current_language
->la_language
)
740 printf_filtered ("%s\n", lang_frame_mismatch_warn
);
746 /* Read commands from `instream' and execute them
747 until end of file or error reading instream. */
752 struct cleanup
*old_chain
;
754 int stdin_is_tty
= ISATTY (stdin
);
755 long time_at_cmd_start
;
757 long space_at_cmd_start
= 0;
759 extern int display_time
;
760 extern int display_space
;
762 while (instream
&& !feof (instream
))
764 if (window_hook
&& instream
== stdin
)
765 (*window_hook
) (instream
, get_prompt ());
768 if (instream
== stdin
&& stdin_is_tty
)
769 reinitialize_more_filter ();
770 old_chain
= make_cleanup (null_cleanup
, 0);
772 /* Get a command-line. This calls the readline package. */
773 command
= command_line_input (instream
== stdin
?
774 get_prompt () : (char *) NULL
,
775 instream
== stdin
, "prompt");
779 time_at_cmd_start
= get_run_time ();
784 extern char **environ
;
785 char *lim
= (char *) sbrk (0);
787 space_at_cmd_start
= (long) (lim
- (char *) &environ
);
791 execute_command (command
, instream
== stdin
);
792 /* Do any commands attached to breakpoint we stopped at. */
793 bpstat_do_actions (&stop_bpstat
);
794 do_cleanups (old_chain
);
798 long cmd_time
= get_run_time () - time_at_cmd_start
;
800 printf_unfiltered ("Command execution time: %ld.%06ld\n",
801 cmd_time
/ 1000000, cmd_time
% 1000000);
807 extern char **environ
;
808 char *lim
= (char *) sbrk (0);
809 long space_now
= lim
- (char *) &environ
;
810 long space_diff
= space_now
- space_at_cmd_start
;
812 printf_unfiltered ("Space used: %ld (%c%ld for this command)\n",
814 (space_diff
>= 0 ? '+' : '-'),
821 /* Read commands from `instream' and execute them until end of file or
822 error reading instream. This command loop doesnt care about any
823 such things as displaying time and space usage. If the user asks
824 for those, they won't work. */
826 simplified_command_loop (char *(*read_input_func
) (char *),
827 void (*execute_command_func
) (char *, int))
829 struct cleanup
*old_chain
;
831 int stdin_is_tty
= ISATTY (stdin
);
833 while (instream
&& !feof (instream
))
836 if (instream
== stdin
&& stdin_is_tty
)
837 reinitialize_more_filter ();
838 old_chain
= make_cleanup (null_cleanup
, 0);
840 /* Get a command-line. */
841 command
= (*read_input_func
) (instream
== stdin
?
842 get_prompt () : (char *) NULL
);
847 (*execute_command_func
) (command
, instream
== stdin
);
849 /* Do any commands attached to breakpoint we stopped at. */
850 bpstat_do_actions (&stop_bpstat
);
852 do_cleanups (old_chain
);
856 /* Commands call this if they do not want to be repeated by null lines. */
864 /* If we aren't reading from standard input, we are saving the last
865 thing read from stdin in line and don't want to delete it. Null lines
866 won't repeat here in any case. */
867 if (instream
== stdin
)
871 /* Read a line from the stream "instream" without command line editing.
873 It prints PROMPT_ARG once at the start.
874 Action is compatible with "readline", e.g. space for the result is
875 malloc'd and should be freed by the caller.
877 A NULL return means end of file. */
879 gdb_readline (char *prompt_arg
)
884 int result_size
= 80;
888 /* Don't use a _filtered function here. It causes the assumed
889 character position to be off, since the newline we read from
890 the user is not accounted for. */
891 fputs_unfiltered (prompt_arg
, gdb_stdout
);
892 gdb_flush (gdb_stdout
);
895 result
= (char *) xmalloc (result_size
);
899 /* Read from stdin if we are executing a user defined command.
900 This is the right thing for prompt_for_continue, at least. */
901 c
= fgetc (instream
? instream
: stdin
);
906 /* The last line does not end with a newline. Return it, and
907 if we are called again fgetc will still return EOF and
908 we'll return NULL then. */
915 #ifndef CRLF_SOURCE_FILES
919 if (input_index
> 0 && result
[input_index
- 1] == '\r')
925 result
[input_index
++] = c
;
926 while (input_index
>= result_size
)
929 result
= (char *) xrealloc (result
, result_size
);
933 result
[input_index
++] = '\0';
937 /* Variables which control command line editing and history
938 substitution. These variables are given default values at the end
940 static int command_editing_p
;
941 /* NOTE 1999-04-29: This variable will be static again, once we modify
942 gdb to use the event loop as the default command loop and we merge
943 event-top.c into this file, top.c */
944 /* static */ int history_expansion_p
;
945 static int write_history_p
;
946 static int history_size
;
947 static char *history_filename
;
954 #if STOP_SIGNAL == SIGTSTP
955 signal (SIGTSTP
, SIG_DFL
);
961 sigprocmask (SIG_SETMASK
, &zero
, 0);
963 #elif HAVE_SIGSETMASK
966 kill (getpid (), SIGTSTP
);
967 signal (SIGTSTP
, stop_sig
);
969 signal (STOP_SIGNAL
, stop_sig
);
971 printf_unfiltered ("%s", get_prompt ());
972 gdb_flush (gdb_stdout
);
974 /* Forget about any previous command -- null line now will do nothing. */
977 #endif /* STOP_SIGNAL */
979 /* Initialize signal handlers. */
981 float_handler (int signo
)
983 /* This message is based on ANSI C, section 4.7. Note that integer
984 divide by zero causes this, so "float" is a misnomer. */
985 signal (SIGFPE
, float_handler
);
986 error ("Erroneous arithmetic operation.");
990 do_nothing (int signo
)
992 /* Under System V the default disposition of a signal is reinstated after
993 the signal is caught and delivered to an application process. On such
994 systems one must restore the replacement signal handler if one wishes
995 to continue handling the signal in one's program. On BSD systems this
996 is not needed but it is harmless, and it simplifies the code to just do
997 it unconditionally. */
998 signal (signo
, do_nothing
);
1004 signal (SIGINT
, request_quit
);
1006 /* If SIGTRAP was set to SIG_IGN, then the SIG_IGN will get passed
1007 to the inferior and breakpoints will be ignored. */
1009 signal (SIGTRAP
, SIG_DFL
);
1012 /* If we initialize SIGQUIT to SIG_IGN, then the SIG_IGN will get
1013 passed to the inferior, which we don't want. It would be
1014 possible to do a "signal (SIGQUIT, SIG_DFL)" after we fork, but
1015 on BSD4.3 systems using vfork, that can affect the
1016 GDB process as well as the inferior (the signal handling tables
1017 might be in memory, shared between the two). Since we establish
1018 a handler for SIGQUIT, when we call exec it will set the signal
1019 to SIG_DFL for us. */
1020 signal (SIGQUIT
, do_nothing
);
1022 if (signal (SIGHUP
, do_nothing
) != SIG_IGN
)
1023 signal (SIGHUP
, disconnect
);
1025 signal (SIGFPE
, float_handler
);
1027 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1028 signal (SIGWINCH
, SIGWINCH_HANDLER
);
1032 /* The current saved history number from operate-and-get-next.
1033 This is -1 if not valid. */
1034 static int operate_saved_history
= -1;
1036 /* This is put on the appropriate hook and helps operate-and-get-next
1039 gdb_rl_operate_and_get_next_completion ()
1041 int delta
= where_history () - operate_saved_history
;
1042 /* The `key' argument to rl_get_previous_history is ignored. */
1043 rl_get_previous_history (delta
, 0);
1044 operate_saved_history
= -1;
1046 /* readline doesn't automatically update the display for us. */
1049 after_char_processing_hook
= NULL
;
1050 rl_pre_input_hook
= NULL
;
1053 /* This is a gdb-local readline command handler. It accepts the
1054 current command line (like RET does) and, if this command was taken
1055 from the history, arranges for the next command in the history to
1056 appear on the command line when the prompt returns.
1057 We ignore the arguments. */
1059 gdb_rl_operate_and_get_next (int count
, int key
)
1063 /* Use the async hook. */
1064 after_char_processing_hook
= gdb_rl_operate_and_get_next_completion
;
1068 /* This hook only works correctly when we are using the
1069 synchronous readline. */
1070 rl_pre_input_hook
= (Function
*) gdb_rl_operate_and_get_next_completion
;
1073 /* Add 1 because we eventually want the next line. */
1074 operate_saved_history
= where_history () + 1;
1075 return rl_newline (1, key
);
1078 /* Read one line from the command input stream `instream'
1079 into the local static buffer `linebuffer' (whose current length
1081 The buffer is made bigger as necessary.
1082 Returns the address of the start of the line.
1084 NULL is returned for end of file.
1086 *If* the instream == stdin & stdin is a terminal, the line read
1087 is copied into the file line saver (global var char *line,
1088 length linesize) so that it can be duplicated.
1090 This routine either uses fancy command line editing or
1091 simple input as the user has requested. */
1094 command_line_input (char *prompt_arg
, int repeat
, char *annotation_suffix
)
1096 static char *linebuffer
= 0;
1097 static unsigned linelength
= 0;
1101 char *local_prompt
= prompt_arg
;
1105 /* The annotation suffix must be non-NULL. */
1106 if (annotation_suffix
== NULL
)
1107 annotation_suffix
= "";
1109 if (annotation_level
> 1 && instream
== stdin
)
1111 local_prompt
= alloca ((prompt_arg
== NULL
? 0 : strlen (prompt_arg
))
1112 + strlen (annotation_suffix
) + 40);
1113 if (prompt_arg
== NULL
)
1114 local_prompt
[0] = '\0';
1116 strcpy (local_prompt
, prompt_arg
);
1117 strcat (local_prompt
, "\n\032\032");
1118 strcat (local_prompt
, annotation_suffix
);
1119 strcat (local_prompt
, "\n");
1122 if (linebuffer
== 0)
1125 linebuffer
= (char *) xmalloc (linelength
);
1130 /* Control-C quits instantly if typed while in this loop
1131 since it should not wait until the user types a newline. */
1137 signal (STOP_SIGNAL
, handle_stop_sig
);
1139 signal (STOP_SIGNAL
, stop_sig
);
1145 /* Make sure that all output has been output. Some machines may let
1146 you get away with leaving out some of the gdb_flush, but not all. */
1148 gdb_flush (gdb_stdout
);
1149 gdb_flush (gdb_stderr
);
1151 if (source_file_name
!= NULL
)
1153 ++source_line_number
;
1154 sprintf (source_error
,
1155 "%s%s:%d: Error in sourced command file:\n",
1158 source_line_number
);
1159 error_pre_print
= source_error
;
1162 if (annotation_level
> 1 && instream
== stdin
)
1164 printf_unfiltered ("\n\032\032pre-");
1165 printf_unfiltered (annotation_suffix
);
1166 printf_unfiltered ("\n");
1169 /* Don't use fancy stuff if not talking to stdin. */
1170 if (readline_hook
&& instream
== NULL
)
1172 rl
= (*readline_hook
) (local_prompt
);
1174 else if (command_editing_p
&& instream
== stdin
&& ISATTY (instream
))
1176 rl
= readline (local_prompt
);
1180 rl
= gdb_readline (local_prompt
);
1183 if (annotation_level
> 1 && instream
== stdin
)
1185 printf_unfiltered ("\n\032\032post-");
1186 printf_unfiltered (annotation_suffix
);
1187 printf_unfiltered ("\n");
1190 if (!rl
|| rl
== (char *) EOF
)
1195 if (strlen (rl
) + 1 + (p
- linebuffer
) > linelength
)
1197 linelength
= strlen (rl
) + 1 + (p
- linebuffer
);
1198 nline
= (char *) xrealloc (linebuffer
, linelength
);
1199 p
+= nline
- linebuffer
;
1203 /* Copy line. Don't copy null at end. (Leaves line alone
1204 if this was just a newline) */
1208 xfree (rl
); /* Allocated in readline. */
1210 if (p
== linebuffer
|| *(p
- 1) != '\\')
1213 p
--; /* Put on top of '\'. */
1214 local_prompt
= (char *) 0;
1219 signal (STOP_SIGNAL
, SIG_DFL
);
1226 #define SERVER_COMMAND_LENGTH 7
1228 (p
- linebuffer
> SERVER_COMMAND_LENGTH
)
1229 && STREQN (linebuffer
, "server ", SERVER_COMMAND_LENGTH
);
1232 /* Note that we don't set `line'. Between this and the check in
1233 dont_repeat, this insures that repeating will still do the
1236 return linebuffer
+ SERVER_COMMAND_LENGTH
;
1239 /* Do history expansion if that is wished. */
1240 if (history_expansion_p
&& instream
== stdin
1241 && ISATTY (instream
))
1243 char *history_value
;
1246 *p
= '\0'; /* Insert null now. */
1247 expanded
= history_expand (linebuffer
, &history_value
);
1250 /* Print the changes. */
1251 printf_unfiltered ("%s\n", history_value
);
1253 /* If there was an error, call this function again. */
1256 xfree (history_value
);
1257 return command_line_input (prompt_arg
, repeat
, annotation_suffix
);
1259 if (strlen (history_value
) > linelength
)
1261 linelength
= strlen (history_value
) + 1;
1262 linebuffer
= (char *) xrealloc (linebuffer
, linelength
);
1264 strcpy (linebuffer
, history_value
);
1265 p
= linebuffer
+ strlen (linebuffer
);
1266 xfree (history_value
);
1270 /* If we just got an empty line, and that is supposed
1271 to repeat the previous command, return the value in the
1273 if (repeat
&& p
== linebuffer
)
1275 for (p1
= linebuffer
; *p1
== ' ' || *p1
== '\t'; p1
++);
1281 /* Add line to history if appropriate. */
1282 if (instream
== stdin
1283 && ISATTY (stdin
) && *linebuffer
)
1284 add_history (linebuffer
);
1286 /* Note: lines consisting solely of comments are added to the command
1287 history. This is useful when you type a command, and then
1288 realize you don't want to execute it quite yet. You can comment
1289 out the command and then later fetch it from the value history
1290 and remove the '#'. The kill ring is probably better, but some
1291 people are in the habit of commenting things out. */
1293 *p1
= '\0'; /* Found a comment. */
1295 /* Save into global buffer if appropriate. */
1298 if (linelength
> linesize
)
1300 line
= xrealloc (line
, linelength
);
1301 linesize
= linelength
;
1303 strcpy (line
, linebuffer
);
1310 /* Print the GDB banner. */
1312 print_gdb_version (struct ui_file
*stream
)
1314 /* From GNU coding standards, first line is meant to be easy for a
1315 program to parse, and is just canonical program name and version
1316 number, which starts after last space. */
1318 fprintf_filtered (stream
, "GNU gdb %s\n", version
);
1320 /* Second line is a copyright notice. */
1322 fprintf_filtered (stream
, "Copyright 2002 Free Software Foundation, Inc.\n");
1324 /* Following the copyright is a brief statement that the program is
1325 free software, that users are free to copy and change it on
1326 certain conditions, that it is covered by the GNU GPL, and that
1327 there is no warranty. */
1329 fprintf_filtered (stream
, "\
1330 GDB is free software, covered by the GNU General Public License, and you are\n\
1331 welcome to change it and/or distribute copies of it under certain conditions.\n\
1332 Type \"show copying\" to see the conditions.\n\
1333 There is absolutely no warranty for GDB. Type \"show warranty\" for details.\n");
1335 /* After the required info we print the configuration information. */
1337 fprintf_filtered (stream
, "This GDB was configured as \"");
1338 if (!STREQ (host_name
, target_name
))
1340 fprintf_filtered (stream
, "--host=%s --target=%s", host_name
, target_name
);
1344 fprintf_filtered (stream
, "%s", host_name
);
1346 fprintf_filtered (stream
, "\".");
1349 /* get_prompt: access method for the GDB prompt string. */
1351 #define MAX_PROMPT_SIZE 256
1354 * int get_prompt_1 (char * buf);
1356 * Work-horse for get_prompt (called via catch_errors).
1357 * Argument is buffer to hold the formatted prompt.
1359 * Returns: 1 for success (use formatted prompt)
1360 * 0 for failure (use gdb_prompt_string).
1363 static int gdb_prompt_escape
;
1366 get_prompt_1 (void *data
)
1368 char *formatted_prompt
= data
;
1372 local_prompt
= PROMPT (0);
1374 local_prompt
= gdb_prompt_string
;
1377 if (gdb_prompt_escape
== 0)
1379 return 0; /* do no formatting */
1382 /* formatted prompt */
1384 char fmt
[40], *promptp
, *outp
, *tmp
;
1385 struct value
*arg_val
;
1391 struct type
*arg_type
, *elt_type
;
1393 promptp
= local_prompt
;
1394 outp
= formatted_prompt
;
1396 while (*promptp
!= '\0')
1398 int available
= MAX_PROMPT_SIZE
- (outp
- formatted_prompt
) - 1;
1400 if (*promptp
!= gdb_prompt_escape
)
1402 if (available
>= 1) /* overflow protect */
1403 *outp
++ = *promptp
++;
1407 /* GDB prompt string contains escape char. Parse for arg.
1408 Two consecutive escape chars followed by arg followed by
1409 a comma means to insert the arg using a default format.
1410 Otherwise a printf format string may be included between
1411 the two escape chars. eg:
1412 %%foo, insert foo using default format
1413 %2.2f%foo, insert foo using "%2.2f" format
1414 A mismatch between the format string and the data type
1415 of "foo" is an error (which we don't know how to protect
1418 fmt
[0] = '\0'; /* assume null format string */
1419 if (promptp
[1] == gdb_prompt_escape
) /* double esc char */
1421 promptp
+= 2; /* skip past two escape chars. */
1425 /* extract format string from between two esc chars */
1429 fmt
[i
++] = *promptp
++; /* copy format string */
1431 while (i
< sizeof (fmt
) - 1 &&
1432 *promptp
!= gdb_prompt_escape
&&
1435 if (*promptp
!= gdb_prompt_escape
)
1436 error ("Syntax error at prompt position %d",
1437 promptp
- local_prompt
);
1440 promptp
++; /* skip second escape char */
1441 fmt
[i
++] = '\0'; /* terminate the format string */
1445 arg_val
= parse_to_comma_and_eval (&promptp
);
1446 if (*promptp
== ',')
1447 promptp
++; /* skip past the comma */
1448 arg_type
= check_typedef (VALUE_TYPE (arg_val
));
1449 switch (TYPE_CODE (arg_type
))
1451 case TYPE_CODE_ARRAY
:
1452 elt_type
= check_typedef (TYPE_TARGET_TYPE (arg_type
));
1453 if (TYPE_LENGTH (arg_type
) > 0 &&
1454 TYPE_LENGTH (elt_type
) == 1 &&
1455 TYPE_CODE (elt_type
) == TYPE_CODE_INT
)
1457 int len
= TYPE_LENGTH (arg_type
);
1459 if (VALUE_LAZY (arg_val
))
1460 value_fetch_lazy (arg_val
);
1461 tmp
= VALUE_CONTENTS (arg_val
);
1463 if (len
> available
)
1464 len
= available
; /* overflow protect */
1466 /* FIXME: how to protect GDB from crashing
1467 from bad user-supplied format string? */
1469 sprintf (outp
, fmt
, tmp
);
1471 strncpy (outp
, tmp
, len
);
1476 elt_type
= check_typedef (TYPE_TARGET_TYPE (arg_type
));
1477 addrval
= value_as_address (arg_val
);
1479 if (TYPE_LENGTH (elt_type
) == 1 &&
1480 TYPE_CODE (elt_type
) == TYPE_CODE_INT
&&
1483 /* display it as a string */
1484 char *default_fmt
= "%s";
1488 /* Limiting the number of bytes that the following call
1489 will read protects us from sprintf overflow later. */
1490 i
= target_read_string (addrval
, /* src */
1492 available
, /* len */
1494 if (err
) /* read failed */
1495 error ("%s on target_read", safe_strerror (err
));
1497 tmp
[i
] = '\0'; /* force-terminate string */
1498 /* FIXME: how to protect GDB from crashing
1499 from bad user-supplied format string? */
1500 sprintf (outp
, fmt
[0] == 0 ? default_fmt
: fmt
,
1506 /* display it as a pointer */
1507 char *default_fmt
= "0x%x";
1509 /* FIXME: how to protect GDB from crashing
1510 from bad user-supplied format string? */
1511 if (available
>= 16 /*? */ ) /* overflow protect */
1512 sprintf (outp
, fmt
[0] == 0 ? default_fmt
: fmt
,
1518 char *default_fmt
= "%g";
1520 doubleval
= value_as_double (arg_val
);
1521 /* FIXME: how to protect GDB from crashing
1522 from bad user-supplied format string? */
1523 if (available
>= 16 /*? */ ) /* overflow protect */
1524 sprintf (outp
, fmt
[0] == 0 ? default_fmt
: fmt
,
1525 (double) doubleval
);
1530 char *default_fmt
= "%d";
1532 longval
= value_as_long (arg_val
);
1533 /* FIXME: how to protect GDB from crashing
1534 from bad user-supplied format string? */
1535 if (available
>= 16 /*? */ ) /* overflow protect */
1536 sprintf (outp
, fmt
[0] == 0 ? default_fmt
: fmt
,
1540 case TYPE_CODE_BOOL
:
1542 /* no default format for bool */
1543 longval
= value_as_long (arg_val
);
1544 if (available
>= 8 /*? */ ) /* overflow protect */
1547 strcpy (outp
, "<true>");
1549 strcpy (outp
, "<false>");
1553 case TYPE_CODE_ENUM
:
1555 /* no default format for enum */
1556 longval
= value_as_long (arg_val
);
1557 len
= TYPE_NFIELDS (arg_type
);
1558 /* find enum name if possible */
1559 for (i
= 0; i
< len
; i
++)
1560 if (TYPE_FIELD_BITPOS (arg_type
, i
) == longval
)
1561 break; /* match -- end loop */
1563 if (i
< len
) /* enum name found */
1565 char *name
= TYPE_FIELD_NAME (arg_type
, i
);
1567 strncpy (outp
, name
, available
);
1568 /* in casel available < strlen (name), */
1569 outp
[available
] = '\0';
1573 if (available
>= 16 /*? */ ) /* overflow protect */
1574 sprintf (outp
, "%ld", (long) longval
);
1578 case TYPE_CODE_VOID
:
1580 break; /* void type -- no output */
1582 error ("bad data type at prompt position %d",
1583 promptp
- local_prompt
);
1586 outp
+= strlen (outp
);
1589 *outp
++ = '\0'; /* terminate prompt string */
1597 static char buf
[MAX_PROMPT_SIZE
];
1599 if (catch_errors (get_prompt_1
, buf
, "bad formatted prompt: ",
1602 return &buf
[0]; /* successful formatted prompt */
1606 /* Prompt could not be formatted. */
1610 return gdb_prompt_string
;
1615 set_prompt (char *s
)
1617 /* ??rehrauer: I don't know why this fails, since it looks as though
1618 assignments to prompt are wrapped in calls to savestring...
1623 PROMPT (0) = savestring (s
, strlen (s
));
1625 gdb_prompt_string
= savestring (s
, strlen (s
));
1629 /* If necessary, make the user confirm that we should quit. Return
1630 non-zero if we should quit, zero if we shouldn't. */
1635 if (! ptid_equal (inferior_ptid
, null_ptid
) && target_has_execution
)
1639 /* This is something of a hack. But there's no reliable way to
1640 see if a GUI is running. The `use_windows' variable doesn't
1643 s
= "A debugging session is active.\nDo you still want to close the debugger?";
1644 else if (attach_flag
)
1645 s
= "The program is running. Quit anyway (and detach it)? ";
1647 s
= "The program is running. Exit anyway? ";
1656 /* Quit without asking for confirmation. */
1659 quit_force (char *args
, int from_tty
)
1663 /* An optional expression may be used to cause gdb to terminate with the
1664 value of that expression. */
1667 struct value
*val
= parse_and_eval (args
);
1669 exit_code
= (int) value_as_long (val
);
1672 if (! ptid_equal (inferior_ptid
, null_ptid
) && target_has_execution
)
1675 target_detach (args
, from_tty
);
1680 /* UDI wants this, to kill the TIP. */
1683 /* Save the history information if it is appropriate to do so. */
1684 if (write_history_p
&& history_filename
)
1685 write_history (history_filename
);
1687 do_final_cleanups (ALL_CLEANUPS
); /* Do any final cleanups before exiting */
1692 /* Returns whether GDB is running on a terminal and whether the user
1693 desires that questions be asked of them on that terminal. */
1696 input_from_terminal_p (void)
1698 return gdb_has_a_terminal () && (instream
== stdin
) & caution
;
1703 dont_repeat_command (char *ignored
, int from_tty
)
1705 *line
= 0; /* Can't call dont_repeat here because we're not
1706 necessarily reading from stdin. */
1709 /* Functions to manipulate command line editing control variables. */
1711 /* Number of commands to print in each call to show_commands. */
1712 #define Hist_print 10
1714 show_commands (char *args
, int from_tty
)
1716 /* Index for history commands. Relative to history_base. */
1719 /* Number of the history entry which we are planning to display next.
1720 Relative to history_base. */
1723 /* The first command in the history which doesn't exist (i.e. one more
1724 than the number of the last command). Relative to history_base. */
1727 /* Print out some of the commands from the command history. */
1728 /* First determine the length of the history list. */
1729 hist_len
= history_size
;
1730 for (offset
= 0; offset
< history_size
; offset
++)
1732 if (!history_get (history_base
+ offset
))
1741 if (args
[0] == '+' && args
[1] == '\0')
1742 /* "info editing +" should print from the stored position. */
1745 /* "info editing <exp>" should print around command number <exp>. */
1746 num
= (parse_and_eval_long (args
) - history_base
) - Hist_print
/ 2;
1748 /* "show commands" means print the last Hist_print commands. */
1751 num
= hist_len
- Hist_print
;
1757 /* If there are at least Hist_print commands, we want to display the last
1758 Hist_print rather than, say, the last 6. */
1759 if (hist_len
- num
< Hist_print
)
1761 num
= hist_len
- Hist_print
;
1766 for (offset
= num
; offset
< num
+ Hist_print
&& offset
< hist_len
; offset
++)
1768 printf_filtered ("%5d %s\n", history_base
+ offset
,
1769 (history_get (history_base
+ offset
))->line
);
1772 /* The next command we want to display is the next one that we haven't
1776 /* If the user repeats this command with return, it should do what
1777 "show commands +" does. This is unnecessary if arg is null,
1778 because "show commands +" is not useful after "show commands". */
1779 if (from_tty
&& args
)
1786 /* Called by do_setshow_command. */
1789 set_history_size_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1791 if (history_size
== INT_MAX
)
1792 unstifle_history ();
1793 else if (history_size
>= 0)
1794 stifle_history (history_size
);
1797 history_size
= INT_MAX
;
1798 error ("History size must be non-negative");
1804 set_history (char *args
, int from_tty
)
1806 printf_unfiltered ("\"set history\" must be followed by the name of a history subcommand.\n");
1807 help_list (sethistlist
, "set history ", -1, gdb_stdout
);
1812 show_history (char *args
, int from_tty
)
1814 cmd_show_list (showhistlist
, from_tty
, "");
1817 int info_verbose
= 0; /* Default verbose msgs off */
1819 /* Called by do_setshow_command. An elaborate joke. */
1822 set_verbose (char *args
, int from_tty
, struct cmd_list_element
*c
)
1824 char *cmdname
= "verbose";
1825 struct cmd_list_element
*showcmd
;
1827 showcmd
= lookup_cmd_1 (&cmdname
, showlist
, NULL
, 1);
1831 c
->doc
= "Set verbose printing of informational messages.";
1832 showcmd
->doc
= "Show verbose printing of informational messages.";
1836 c
->doc
= "Set verbosity.";
1837 showcmd
->doc
= "Show verbosity.";
1841 /* Init the history buffer. Note that we are called after the init file(s)
1842 * have been read so that the user can change the history file via his
1843 * .gdbinit file (for instance). The GDBHISTFILE environment variable
1844 * overrides all of this.
1852 tmpenv
= getenv ("HISTSIZE");
1854 history_size
= atoi (tmpenv
);
1855 else if (!history_size
)
1858 stifle_history (history_size
);
1860 tmpenv
= getenv ("GDBHISTFILE");
1862 history_filename
= savestring (tmpenv
, strlen (tmpenv
));
1863 else if (!history_filename
)
1865 /* We include the current directory so that if the user changes
1866 directories the file written will be the same as the one
1869 /* No leading dots in file names are allowed on MSDOS. */
1870 history_filename
= concat (current_directory
, "/_gdb_history", NULL
);
1872 history_filename
= concat (current_directory
, "/.gdb_history", NULL
);
1875 read_history (history_filename
);
1881 struct cmd_list_element
*c
;
1883 /* If we are running the asynchronous version,
1884 we initialize the prompts differently. */
1887 gdb_prompt_string
= savestring (DEFAULT_PROMPT
, strlen (DEFAULT_PROMPT
));
1891 /* initialize the prompt stack to a simple "(gdb) " prompt or to
1892 whatever the DEFAULT_PROMPT is. */
1893 the_prompts
.top
= 0;
1895 PROMPT (0) = savestring (DEFAULT_PROMPT
, strlen (DEFAULT_PROMPT
));
1897 /* Set things up for annotation_level > 1, if the user ever decides
1899 async_annotation_suffix
= "prompt";
1900 /* Set the variable associated with the setshow prompt command. */
1901 new_async_prompt
= savestring (PROMPT (0), strlen (PROMPT (0)));
1903 /* If gdb was started with --annotate=2, this is equivalent to
1904 the user entering the command 'set annotate 2' at the gdb
1905 prompt, so we need to do extra processing. */
1906 if (annotation_level
> 1)
1907 set_async_annotation_level (NULL
, 0, NULL
);
1909 gdb_prompt_escape
= 0; /* default to none. */
1911 /* Set the important stuff up for command editing. */
1912 command_editing_p
= 1;
1913 history_expansion_p
= 0;
1914 write_history_p
= 0;
1916 /* Setup important stuff for command line editing. */
1917 rl_completion_entry_function
= (int (*)()) readline_line_completion_function
;
1918 rl_completer_word_break_characters
=
1919 get_gdb_completer_word_break_characters ();
1920 rl_completer_quote_characters
= get_gdb_completer_quote_characters ();
1921 rl_readline_name
= "gdb";
1923 /* The name for this defun comes from Bash, where it originated.
1924 15 is Control-o, the same binding this function has in Bash. */
1925 rl_add_defun ("operate-and-get-next", gdb_rl_operate_and_get_next
, 15);
1927 /* The set prompt command is different depending whether or not the
1928 async version is run. NOTE: this difference is going to
1929 disappear as we make the event loop be the default engine of
1934 (add_set_cmd ("prompt", class_support
, var_string
,
1935 (char *) &gdb_prompt_string
, "Set gdb's prompt",
1941 c
= add_set_cmd ("prompt", class_support
, var_string
,
1942 (char *) &new_async_prompt
, "Set gdb's prompt",
1944 add_show_from_set (c
, &showlist
);
1945 set_cmd_sfunc (c
, set_async_prompt
);
1949 (add_set_cmd ("prompt-escape-char", class_support
, var_zinteger
,
1950 (char *) &gdb_prompt_escape
,
1951 "Set escape character for formatting of gdb's prompt",
1955 add_com ("dont-repeat", class_support
, dont_repeat_command
, "Don't repeat this command.\n\
1956 Primarily used inside of user-defined commands that should not be repeated when\n\
1959 /* The set editing command is different depending whether or not the
1960 async version is run. NOTE: this difference is going to disappear
1961 as we make the event loop be the default engine of gdb. */
1965 (add_set_cmd ("editing", class_support
, var_boolean
, (char *) &command_editing_p
,
1966 "Set editing of command lines as they are typed.\n\
1967 Use \"on\" to enable the editing, and \"off\" to disable it.\n\
1968 Without an argument, command line editing is enabled. To edit, use\n\
1969 EMACS-like or VI-like commands like control-P or ESC.", &setlist
),
1974 c
= add_set_cmd ("editing", class_support
, var_boolean
, (char *) &async_command_editing_p
,
1975 "Set editing of command lines as they are typed.\n\
1976 Use \"on\" to enable the editing, and \"off\" to disable it.\n\
1977 Without an argument, command line editing is enabled. To edit, use\n\
1978 EMACS-like or VI-like commands like control-P or ESC.", &setlist
);
1980 add_show_from_set (c
, &showlist
);
1981 set_cmd_sfunc (c
, set_async_editing_command
);
1985 (add_set_cmd ("save", no_class
, var_boolean
, (char *) &write_history_p
,
1986 "Set saving of the history record on exit.\n\
1987 Use \"on\" to enable the saving, and \"off\" to disable it.\n\
1988 Without an argument, saving is enabled.", &sethistlist
),
1991 c
= add_set_cmd ("size", no_class
, var_integer
, (char *) &history_size
,
1992 "Set the size of the command history, \n\
1993 ie. the number of previous commands to keep a record of.", &sethistlist
);
1994 add_show_from_set (c
, &showhistlist
);
1995 set_cmd_sfunc (c
, set_history_size_command
);
1997 c
= add_set_cmd ("filename", no_class
, var_filename
,
1998 (char *) &history_filename
,
1999 "Set the filename in which to record the command history\n\
2000 (the list of previous commands of which a record is kept).", &sethistlist
);
2001 set_cmd_completer (c
, filename_completer
);
2002 add_show_from_set (c
, &showhistlist
);
2005 (add_set_cmd ("confirm", class_support
, var_boolean
,
2007 "Set whether to confirm potentially dangerous operations.",
2011 /* The set annotate command is different depending whether or not
2012 the async version is run. NOTE: this difference is going to
2013 disappear as we make the event loop be the default engine of
2017 c
= add_set_cmd ("annotate", class_obscure
, var_zinteger
,
2018 (char *) &annotation_level
, "Set annotation_level.\n\
2019 0 == normal; 1 == fullname (for use when running under emacs)\n\
2020 2 == output annotated suitably for use by programs that control GDB.",
2022 c
= add_show_from_set (c
, &showlist
);
2026 c
= add_set_cmd ("annotate", class_obscure
, var_zinteger
,
2027 (char *) &annotation_level
, "Set annotation_level.\n\
2028 0 == normal; 1 == fullname (for use when running under emacs)\n\
2029 2 == output annotated suitably for use by programs that control GDB.",
2031 add_show_from_set (c
, &showlist
);
2032 set_cmd_sfunc (c
, set_async_annotation_level
);
2037 (add_set_cmd ("exec-done-display", class_support
, var_boolean
, (char *) &exec_done_display_p
,
2038 "Set notification of completion for asynchronous execution commands.\n\
2039 Use \"on\" to enable the notification, and \"off\" to disable it.", &setlist
),
2045 gdb_init (char *argv0
)
2047 if (pre_init_ui_hook
)
2048 pre_init_ui_hook ();
2050 /* Run the init function of each source file */
2052 getcwd (gdb_dirbuf
, sizeof (gdb_dirbuf
));
2053 current_directory
= gdb_dirbuf
;
2056 /* Make sure we return to the original directory upon exit, come
2057 what may, since the OS doesn't do that for us. */
2058 make_final_cleanup (do_chdir_cleanup
, xstrdup (current_directory
));
2061 init_cmd_lists (); /* This needs to be done first */
2062 initialize_targets (); /* Setup target_terminal macros for utils.c */
2063 initialize_utils (); /* Make errors and warnings possible */
2064 initialize_all_files ();
2065 initialize_current_architecture ();
2067 init_main (); /* But that omits this file! Do it now */
2069 /* The signal handling mechanism is different depending whether or
2070 not the async version is run. NOTE: in the future we plan to make
2071 the event loop be the default engine of gdb, and this difference
2074 async_init_signals ();
2078 /* We need a default language for parsing expressions, so simple things like
2079 "set width 0" won't fail if no language is explicitly set in a config file
2080 or implicitly set by reading an executable during startup. */
2081 set_language (language_c
);
2082 expected_language
= current_language
; /* don't warn about the change. */
2084 /* Allow another UI to initialize. If the UI fails to initialize, and
2085 it wants GDB to revert to the CLI, it should clear init_ui_hook. */
2087 init_ui_hook (argv0
);
2089 /* Install the default UI */
2092 uiout
= cli_out_new (gdb_stdout
);
2094 /* All the interpreters should have had a look at things by now.
2095 Initialize the selected interpreter. */
2098 fprintf_unfiltered (gdb_stderr
, "Interpreter `%s' unrecognized.\n",