1 /* Top level stuff for GDB, the GNU debugger.
3 Copyright (C) 1986-2016 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "cli/cli-cmds.h"
23 #include "cli/cli-script.h"
24 #include "cli/cli-setshow.h"
25 #include "cli/cli-decode.h"
31 #include "target-dcache.h"
32 #include "breakpoint.h"
34 #include "expression.h"
37 #include "terminal.h" /* For job_control. */
39 #include "completer.h"
45 #include "event-loop.h"
46 #include "gdbthread.h"
47 #include "extension.h"
51 #include "filenames.h"
54 #include "gdb_select.h"
56 /* readline include files. */
57 #include "readline/readline.h"
58 #include "readline/history.h"
60 /* readline defines this. */
63 #include <sys/types.h>
65 #include "event-top.h"
70 #include "tracepoint.h"
77 extern void initialize_all_files (void);
79 #define PROMPT(X) the_prompts.prompt_stack[the_prompts.top + X].prompt
80 #define PREFIX(X) the_prompts.prompt_stack[the_prompts.top + X].prefix
81 #define SUFFIX(X) the_prompts.prompt_stack[the_prompts.top + X].suffix
83 /* Default command line prompt. This is overriden in some configs. */
85 #ifndef DEFAULT_PROMPT
86 #define DEFAULT_PROMPT "(gdb) "
89 /* Initialization file name for gdb. This is host-dependent. */
91 const char gdbinit[] = GDBINIT;
93 int inhibit_gdbinit = 0;
95 extern char lang_frame_mismatch_warn[]; /* language.c */
97 /* Flag for whether we want to confirm potentially dangerous
98 operations. Default is yes. */
103 show_confirm (struct ui_file *file, int from_tty,
104 struct cmd_list_element *c, const char *value)
106 fprintf_filtered (file, _("Whether to confirm potentially "
107 "dangerous operations is %s.\n"),
111 /* stdio stream that command input is being read from. Set to stdin
112 normally. Set by source_command to the file we are sourcing. Set
113 to NULL if we are executing a user-defined command or interacting
118 /* Flag to indicate whether a user defined command is currently running. */
122 /* Current working directory. */
124 char *current_directory;
126 /* The directory name is actually stored here (usually). */
127 char gdb_dirbuf[1024];
129 /* The last command line executed on the console. Used for command
131 char *saved_command_line;
133 /* Nonzero if the current command is modified by "server ". This
134 affects things like recording into the command history, commands
135 repeating on RETURN, etc. This is so a user interface (emacs, GUI,
136 whatever) can issue its own commands and also send along commands
137 from the user, and have the user not notice that the user interface
138 is issuing commands too. */
141 /* Timeout limit for response from target. */
143 /* The default value has been changed many times over the years. It
144 was originally 5 seconds. But that was thought to be a long time
145 to sit and wait, so it was changed to 2 seconds. That was thought
146 to be plenty unless the connection was going through some terminal
147 server or multiplexer or other form of hairy serial connection.
149 In mid-1996, remote_timeout was moved from remote.c to top.c and
150 it began being used in other remote-* targets. It appears that the
151 default was changed to 20 seconds at that time, perhaps because the
152 Renesas E7000 ICE didn't always respond in a timely manner.
154 But if 5 seconds is a long time to sit and wait for retransmissions,
155 20 seconds is far worse. This demonstrates the difficulty of using
156 a single variable for all protocol timeouts.
158 As remote.c is used much more than remote-e7000.c, it was changed
159 back to 2 seconds in 1999. */
161 int remote_timeout = 2;
163 /* Non-zero tells remote* modules to output debugging info. */
165 int remote_debug = 0;
167 /* Sbrk location on entry to main. Used for statistics only. */
172 /* Hooks for alternate command interfaces. */
174 /* This hook is called from within gdb's many mini-event loops which
175 could steal control from a real user interface's event loop. It
176 returns non-zero if the user is requesting a detach, zero
179 int (*deprecated_ui_loop_hook) (int);
182 /* Called from print_frame_info to list the line we stopped in. */
184 void (*deprecated_print_frame_info_listing_hook) (struct symtab * s,
188 /* Replaces most of query. */
190 int (*deprecated_query_hook) (const char *, va_list);
192 /* Replaces most of warning. */
194 void (*deprecated_warning_hook) (const char *, va_list);
196 /* These three functions support getting lines of text from the user.
197 They are used in sequence. First deprecated_readline_begin_hook is
198 called with a text string that might be (for example) a message for
199 the user to type in a sequence of commands to be executed at a
200 breakpoint. If this function calls back to a GUI, it might take
201 this opportunity to pop up a text interaction window with this
202 message. Next, deprecated_readline_hook is called with a prompt
203 that is emitted prior to collecting the user input. It can be
204 called multiple times. Finally, deprecated_readline_end_hook is
205 called to notify the GUI that we are done with the interaction
206 window and it can close it. */
208 void (*deprecated_readline_begin_hook) (char *, ...);
209 char *(*deprecated_readline_hook) (const char *);
210 void (*deprecated_readline_end_hook) (void);
212 /* Called as appropriate to notify the interface that we have attached
213 to or detached from an already running process. */
215 void (*deprecated_attach_hook) (void);
216 void (*deprecated_detach_hook) (void);
218 /* Called during long calculations to allow GUI to repair window
219 damage, and to check for stop buttons, etc... */
221 void (*deprecated_interactive_hook) (void);
223 /* Called when going to wait for the target. Usually allows the GUI
224 to run while waiting for target events. */
226 ptid_t (*deprecated_target_wait_hook) (ptid_t ptid,
227 struct target_waitstatus *status,
230 /* Used by UI as a wrapper around command execution. May do various
231 things like enabling/disabling buttons, etc... */
233 void (*deprecated_call_command_hook) (struct cmd_list_element * c,
234 char *cmd, int from_tty);
236 /* Called when the current thread changes. Argument is thread id. */
238 void (*deprecated_context_hook) (int id);
240 /* Handler for SIGHUP. */
243 /* NOTE 1999-04-29: This function will be static again, once we modify
244 gdb to use the event loop as the default command loop and we merge
245 event-top.c into this file, top.c. */
249 /* Stop asking user for confirmation --- we're exiting. This
250 prevents asking the user dumb questions. */
252 quit_command ((char *) 0, 0);
254 #endif /* defined SIGHUP */
256 /* Line number we are currently in, in a file which is being sourced. */
257 /* NOTE 1999-04-29: This variable will be static again, once we modify
258 gdb to use the event loop as the default command loop and we merge
259 event-top.c into this file, top.c. */
260 /* static */ int source_line_number;
262 /* Name of the file we are sourcing. */
263 /* NOTE 1999-04-29: This variable will be static again, once we modify
264 gdb to use the event loop as the default command loop and we merge
265 event-top.c into this file, top.c. */
266 /* static */ const char *source_file_name;
268 /* Clean up on error during a "source" command (or execution of a
269 user-defined command). */
272 do_restore_instream_cleanup (void *stream)
274 /* Restore the previous input stream. */
275 instream = (FILE *) stream;
278 /* Read commands from STREAM. */
280 read_command_file (FILE *stream)
282 struct cleanup *cleanups;
284 cleanups = make_cleanup (do_restore_instream_cleanup, instream);
287 /* Read commands from `instream' and execute them until end of file
288 or error reading instream. */
290 while (instream != NULL && !feof (instream))
294 /* Get a command-line. This calls the readline package. */
295 command = command_line_input (NULL, 0, NULL);
298 command_handler (command);
301 do_cleanups (cleanups);
304 void (*pre_init_ui_hook) (void);
308 do_chdir_cleanup (void *old_dir)
316 prepare_execute_command (void)
319 struct cleanup *cleanup;
321 mark = value_mark ();
322 cleanup = make_cleanup_value_free_to_mark (mark);
324 /* With multiple threads running while the one we're examining is
325 stopped, the dcache can get stale without us being able to detect
326 it. For the duration of the command, though, use the dcache to
327 help things like backtrace. */
329 target_dcache_invalidate ();
334 /* Tell the user if the language has changed (except first time) after
335 executing a command. */
338 check_frame_language_change (void)
340 static int warned = 0;
341 struct frame_info *frame;
343 /* First make sure that a new frame has been selected, in case the
344 command or the hooks changed the program state. */
345 frame = deprecated_safe_get_selected_frame ();
346 if (current_language != expected_language)
348 if (language_mode == language_mode_auto && info_verbose)
350 language_info (1); /* Print what changed. */
355 /* Warn the user if the working language does not match the language
356 of the current frame. Only warn the user if we are actually
357 running the program, i.e. there is a stack. */
358 /* FIXME: This should be cacheing the frame and only running when
359 the frame changes. */
361 if (has_stack_frames ())
365 flang = get_frame_language (frame);
367 && flang != language_unknown
368 && flang != current_language->la_language)
370 printf_filtered ("%s\n", lang_frame_mismatch_warn);
379 wait_sync_command_done (void)
381 while (gdb_do_one_event () >= 0)
389 maybe_wait_sync_command_done (int was_sync)
391 /* If the interpreter is in sync mode (we're running a user
392 command's list, running command hooks or similars), and we
393 just ran a synchronous command that started the target, wait
394 for that command to end. */
395 if (!interpreter_async && !was_sync && sync_execution)
396 wait_sync_command_done ();
399 /* Execute the line P as a command, in the current user context.
400 Pass FROM_TTY as second argument to the defining function. */
403 execute_command (char *p, int from_tty)
405 struct cleanup *cleanup_if_error, *cleanup;
406 struct cmd_list_element *c;
409 cleanup_if_error = make_bpstat_clear_actions_cleanup ();
410 cleanup = prepare_execute_command ();
412 /* Force cleanup of any alloca areas if using C alloca instead of
416 /* This can happen when command_line_input hits end of file. */
419 do_cleanups (cleanup);
420 discard_cleanups (cleanup_if_error);
424 target_log_command (p);
426 while (*p == ' ' || *p == '\t')
432 int was_sync = sync_execution;
436 /* If trace-commands is set then this will print this command. */
437 print_command_trace (p);
439 c = lookup_cmd (&cmd, cmdlist, "", 0, 1);
442 /* Pass null arg rather than an empty one. */
445 /* FIXME: cagney/2002-02-02: The c->type test is pretty dodgy
446 while the is_complete_command(cfunc) test is just plain
447 bogus. They should both be replaced by a test of the form
448 c->strip_trailing_white_space_p. */
449 /* NOTE: cagney/2002-02-02: The function.cfunc in the below
450 can't be replaced with func. This is because it is the
451 cfunc, and not the func, that has the value that the
452 is_complete_command hack is testing for. */
453 /* Clear off trailing whitespace, except for set and complete
456 && c->type != set_cmd
457 && !is_complete_command (c))
459 p = arg + strlen (arg) - 1;
460 while (p >= arg && (*p == ' ' || *p == '\t'))
465 /* If this command has been pre-hooked, run the hook first. */
466 execute_cmd_pre_hook (c);
468 if (c->deprecated_warn_user)
469 deprecated_cmd_warning (line);
471 /* c->user_commands would be NULL in the case of a python command. */
472 if (c->theclass == class_user && c->user_commands)
473 execute_user_command (c, arg);
474 else if (c->type == set_cmd)
475 do_set_command (arg, from_tty, c);
476 else if (c->type == show_cmd)
477 do_show_command (arg, from_tty, c);
478 else if (!cmd_func_p (c))
479 error (_("That is not a command, just a help topic."));
480 else if (deprecated_call_command_hook)
481 deprecated_call_command_hook (c, arg, from_tty);
483 cmd_func (c, arg, from_tty);
485 maybe_wait_sync_command_done (was_sync);
487 /* If this command has been post-hooked, run the hook last. */
488 execute_cmd_post_hook (c);
492 check_frame_language_change ();
494 do_cleanups (cleanup);
495 discard_cleanups (cleanup_if_error);
498 /* Run execute_command for P and FROM_TTY. Capture its output into the
499 returned string, do not display it to the screen. BATCH_FLAG will be
500 temporarily set to true. */
503 execute_command_to_string (char *p, int from_tty)
505 struct ui_file *str_file;
506 struct cleanup *cleanup;
509 /* GDB_STDOUT should be better already restored during these
510 restoration callbacks. */
511 cleanup = set_batch_flag_and_make_cleanup_restore_page_info ();
513 make_cleanup_restore_integer (&interpreter_async);
514 interpreter_async = 0;
516 str_file = mem_fileopen ();
518 make_cleanup_ui_file_delete (str_file);
519 make_cleanup_restore_ui_file (&gdb_stdout);
520 make_cleanup_restore_ui_file (&gdb_stderr);
521 make_cleanup_restore_ui_file (&gdb_stdlog);
522 make_cleanup_restore_ui_file (&gdb_stdtarg);
523 make_cleanup_restore_ui_file (&gdb_stdtargerr);
525 if (ui_out_redirect (current_uiout, str_file) < 0)
526 warning (_("Current output protocol does not support redirection"));
528 make_cleanup_ui_out_redirect_pop (current_uiout);
530 gdb_stdout = str_file;
531 gdb_stderr = str_file;
532 gdb_stdlog = str_file;
533 gdb_stdtarg = str_file;
534 gdb_stdtargerr = str_file;
536 execute_command (p, from_tty);
538 retval = ui_file_xstrdup (str_file, NULL);
540 do_cleanups (cleanup);
546 /* When nonzero, cause dont_repeat to do nothing. This should only be
547 set via prevent_dont_repeat. */
549 static int suppress_dont_repeat = 0;
551 /* Commands call this if they do not want to be repeated by null lines. */
556 if (suppress_dont_repeat || server_command)
559 /* If we aren't reading from standard input, we are saving the last
560 thing read from stdin in line and don't want to delete it. Null
561 lines won't repeat here in any case. */
562 if (instream == stdin)
563 *saved_command_line = 0;
566 /* Prevent dont_repeat from working, and return a cleanup that
567 restores the previous state. */
570 prevent_dont_repeat (void)
572 struct cleanup *result = make_cleanup_restore_integer (&suppress_dont_repeat);
574 suppress_dont_repeat = 1;
579 /* Read a line from the stream "instream" without command line editing.
581 It prints PROMPT once at the start.
582 Action is compatible with "readline", e.g. space for the result is
583 malloc'd and should be freed by the caller.
585 A NULL return means end of file. */
588 gdb_readline_no_editing (const char *prompt)
590 struct buffer line_buffer;
591 /* Read from stdin if we are executing a user defined command. This
592 is the right thing for prompt_for_continue, at least. */
593 FILE *stream = instream != NULL ? instream : stdin;
594 int fd = fileno (stream);
596 buffer_init (&line_buffer);
600 /* Don't use a _filtered function here. It causes the assumed
601 character position to be off, since the newline we read from
602 the user is not accounted for. */
603 fputs_unfiltered (prompt, gdb_stdout);
604 gdb_flush (gdb_stdout);
615 /* Wait until at least one byte of data is available. Control-C
616 can interrupt interruptible_select, but not fgetc. */
618 FD_SET (fd, &readfds);
619 if (interruptible_select (fd + 1, &readfds, NULL, NULL, NULL) == -1)
623 /* If this was ctrl-c, the QUIT above handles it. */
626 perror_with_name (("select"));
633 if (line_buffer.used_size > 0)
634 /* The last line does not end with a newline. Return it, and
635 if we are called again fgetc will still return EOF and
636 we'll return NULL then. */
638 xfree (buffer_finish (&line_buffer));
644 if (line_buffer.used_size > 0
645 && line_buffer.buffer[line_buffer.used_size - 1] == '\r')
646 line_buffer.used_size--;
650 buffer_grow_char (&line_buffer, c);
653 buffer_grow_char (&line_buffer, '\0');
654 return buffer_finish (&line_buffer);
657 /* Variables which control command line editing and history
658 substitution. These variables are given default values at the end
660 static int command_editing_p;
662 /* NOTE 1999-04-29: This variable will be static again, once we modify
663 gdb to use the event loop as the default command loop and we merge
664 event-top.c into this file, top.c. */
666 /* static */ int history_expansion_p;
668 static int write_history_p;
670 show_write_history_p (struct ui_file *file, int from_tty,
671 struct cmd_list_element *c, const char *value)
673 fprintf_filtered (file, _("Saving of the history record on exit is %s.\n"),
677 /* The variable associated with the "set/show history size"
678 command. The value -1 means unlimited, and -2 means undefined. */
679 static int history_size_setshow_var = -2;
682 show_history_size (struct ui_file *file, int from_tty,
683 struct cmd_list_element *c, const char *value)
685 fprintf_filtered (file, _("The size of the command history is %s.\n"),
689 /* Variable associated with the "history remove-duplicates" option.
690 The value -1 means unlimited. */
691 static int history_remove_duplicates = 0;
694 show_history_remove_duplicates (struct ui_file *file, int from_tty,
695 struct cmd_list_element *c, const char *value)
697 fprintf_filtered (file,
698 _("The number of history entries to look back at for "
699 "duplicates is %s.\n"),
703 static char *history_filename;
705 show_history_filename (struct ui_file *file, int from_tty,
706 struct cmd_list_element *c, const char *value)
708 fprintf_filtered (file, _("The filename in which to record "
709 "the command history is \"%s\".\n"),
713 /* This is like readline(), but it has some gdb-specific behavior.
714 gdb may want readline in both the synchronous and async modes during
715 a single gdb invocation. At the ordinary top-level prompt we might
716 be using the async readline. That means we can't use
717 rl_pre_input_hook, since it doesn't work properly in async mode.
718 However, for a secondary prompt (" >", such as occurs during a
719 `define'), gdb wants a synchronous response.
721 We used to call readline() directly, running it in synchronous
722 mode. But mixing modes this way is not supported, and as of
723 readline 5.x it no longer works; the arrow keys come unbound during
724 the synchronous call. So we make a nested call into the event
725 loop. That's what gdb_readline_wrapper is for. */
727 /* A flag set as soon as gdb_readline_wrapper_line is called; we can't
728 rely on gdb_readline_wrapper_result, which might still be NULL if
729 the user types Control-D for EOF. */
730 static int gdb_readline_wrapper_done;
732 /* The result of the current call to gdb_readline_wrapper, once a newline
734 static char *gdb_readline_wrapper_result;
736 /* Any intercepted hook. Operate-and-get-next sets this, expecting it
737 to be called after the newline is processed (which will redisplay
738 the prompt). But in gdb_readline_wrapper we will not get a new
739 prompt until the next call, or until we return to the event loop.
740 So we disable this hook around the newline and restore it before we
742 static void (*saved_after_char_processing_hook) (void);
745 /* The number of nested readline secondary prompts that are currently
748 static int gdb_secondary_prompt_depth = 0;
753 gdb_in_secondary_prompt_p (void)
755 return gdb_secondary_prompt_depth > 0;
759 /* This function is called when readline has seen a complete line of
763 gdb_readline_wrapper_line (char *line)
765 gdb_assert (!gdb_readline_wrapper_done);
766 gdb_readline_wrapper_result = line;
767 gdb_readline_wrapper_done = 1;
769 /* Prevent operate-and-get-next from acting too early. */
770 saved_after_char_processing_hook = after_char_processing_hook;
771 after_char_processing_hook = NULL;
773 /* Prevent parts of the prompt from being redisplayed if annotations
774 are enabled, and readline's state getting out of sync. We'll
775 reinstall the callback handler, which puts the terminal in raw
776 mode (or in readline lingo, in prepped state), when we're next
777 ready to process user input, either in display_gdb_prompt, or if
778 we're handling an asynchronous target event and running in the
779 background, just before returning to the event loop to process
780 further input (or more target events). */
781 if (async_command_editing_p)
782 gdb_rl_callback_handler_remove ();
785 struct gdb_readline_wrapper_cleanup
787 void (*handler_orig) (char *);
788 int already_prompted_orig;
790 /* Whether the target was async. */
791 int target_is_async_orig;
795 gdb_readline_wrapper_cleanup (void *arg)
797 struct ui *ui = current_ui;
798 struct gdb_readline_wrapper_cleanup *cleanup
799 = (struct gdb_readline_wrapper_cleanup *) arg;
801 rl_already_prompted = cleanup->already_prompted_orig;
803 gdb_assert (ui->input_handler == gdb_readline_wrapper_line);
804 ui->input_handler = cleanup->handler_orig;
806 /* Don't restore our input handler in readline yet. That would make
807 readline prep the terminal (putting it in raw mode), while the
808 line we just read may trigger execution of a command that expects
809 the terminal in the default cooked/canonical mode, such as e.g.,
810 running Python's interactive online help utility. See
811 gdb_readline_wrapper_line for when we'll reinstall it. */
813 gdb_readline_wrapper_result = NULL;
814 gdb_readline_wrapper_done = 0;
815 gdb_secondary_prompt_depth--;
816 gdb_assert (gdb_secondary_prompt_depth >= 0);
818 after_char_processing_hook = saved_after_char_processing_hook;
819 saved_after_char_processing_hook = NULL;
821 if (cleanup->target_is_async_orig)
828 gdb_readline_wrapper (const char *prompt)
830 struct ui *ui = current_ui;
831 struct cleanup *back_to;
832 struct gdb_readline_wrapper_cleanup *cleanup;
835 cleanup = XNEW (struct gdb_readline_wrapper_cleanup);
836 cleanup->handler_orig = ui->input_handler;
837 ui->input_handler = gdb_readline_wrapper_line;
839 cleanup->already_prompted_orig = rl_already_prompted;
841 cleanup->target_is_async_orig = target_is_async_p ();
843 gdb_secondary_prompt_depth++;
844 back_to = make_cleanup (gdb_readline_wrapper_cleanup, cleanup);
846 if (cleanup->target_is_async_orig)
849 /* Display our prompt and prevent double prompt display. */
850 display_gdb_prompt (prompt);
851 rl_already_prompted = 1;
853 if (after_char_processing_hook)
854 (*after_char_processing_hook) ();
855 gdb_assert (after_char_processing_hook == NULL);
857 while (gdb_do_one_event () >= 0)
858 if (gdb_readline_wrapper_done)
861 retval = gdb_readline_wrapper_result;
862 do_cleanups (back_to);
867 /* The current saved history number from operate-and-get-next.
868 This is -1 if not valid. */
869 static int operate_saved_history = -1;
871 /* This is put on the appropriate hook and helps operate-and-get-next
874 gdb_rl_operate_and_get_next_completion (void)
876 int delta = where_history () - operate_saved_history;
878 /* The `key' argument to rl_get_previous_history is ignored. */
879 rl_get_previous_history (delta, 0);
880 operate_saved_history = -1;
882 /* readline doesn't automatically update the display for us. */
885 after_char_processing_hook = NULL;
886 rl_pre_input_hook = NULL;
889 /* This is a gdb-local readline command handler. It accepts the
890 current command line (like RET does) and, if this command was taken
891 from the history, arranges for the next command in the history to
892 appear on the command line when the prompt returns.
893 We ignore the arguments. */
895 gdb_rl_operate_and_get_next (int count, int key)
899 /* Use the async hook. */
900 after_char_processing_hook = gdb_rl_operate_and_get_next_completion;
902 /* Find the current line, and find the next line to use. */
903 where = where_history();
905 if ((history_is_stifled () && (history_length >= history_max_entries))
906 || (where >= history_length - 1))
907 operate_saved_history = where;
909 operate_saved_history = where + 1;
911 return rl_newline (1, key);
914 /* Number of user commands executed during this session. */
916 static int command_count = 0;
918 /* Add the user command COMMAND to the input history list. */
921 gdb_add_history (const char *command)
925 if (history_remove_duplicates != 0)
928 int lookbehind_threshold;
930 /* The lookbehind threshold for finding a duplicate history entry is
931 bounded by command_count because we can't meaningfully delete
932 history entries that are already stored in the history file since
933 the history file is appended to. */
934 if (history_remove_duplicates == -1
935 || history_remove_duplicates > command_count)
936 lookbehind_threshold = command_count;
938 lookbehind_threshold = history_remove_duplicates;
941 for (lookbehind = 0; lookbehind < lookbehind_threshold; lookbehind++)
943 HIST_ENTRY *temp = previous_history ();
948 if (strcmp (temp->line, command) == 0)
950 HIST_ENTRY *prev = remove_history (where_history ());
952 free_history_entry (prev);
959 add_history (command);
962 /* Safely append new history entries to the history file in a corruption-free
963 way using an intermediate local history file. */
966 gdb_safe_append_history (void)
968 int ret, saved_errno;
969 char *local_history_filename;
970 struct cleanup *old_chain;
972 local_history_filename
973 = xstrprintf ("%s-gdb%d~", history_filename, getpid ());
974 old_chain = make_cleanup (xfree, local_history_filename);
976 ret = rename (history_filename, local_history_filename);
978 if (ret < 0 && saved_errno != ENOENT)
980 warning (_("Could not rename %s to %s: %s"),
981 history_filename, local_history_filename,
982 safe_strerror (saved_errno));
988 /* If the rename failed with ENOENT then either the global history
989 file never existed in the first place or another GDB process is
990 currently appending to it (and has thus temporarily renamed it).
991 Since we can't distinguish between these two cases, we have to
992 conservatively assume the first case and therefore must write out
993 (not append) our known history to our local history file and try
994 to move it back anyway. Otherwise a global history file would
995 never get created! */
996 gdb_assert (saved_errno == ENOENT);
997 write_history (local_history_filename);
1001 append_history (command_count, local_history_filename);
1002 if (history_is_stifled ())
1003 history_truncate_file (local_history_filename, history_max_entries);
1006 ret = rename (local_history_filename, history_filename);
1007 saved_errno = errno;
1008 if (ret < 0 && saved_errno != EEXIST)
1009 warning (_("Could not rename %s to %s: %s"),
1010 local_history_filename, history_filename,
1011 safe_strerror (saved_errno));
1014 do_cleanups (old_chain);
1017 /* Read one line from the command input stream `instream' into a local
1018 static buffer. The buffer is made bigger as necessary. Returns
1019 the address of the start of the line.
1021 NULL is returned for end of file.
1023 *If* the instream == stdin & stdin is a terminal, the line read is
1024 copied into the global 'saved_command_line' so that it can be
1027 This routine either uses fancy command line editing or simple input
1028 as the user has requested. */
1031 command_line_input (const char *prompt_arg, int repeat, char *annotation_suffix)
1033 static struct buffer cmd_line_buffer;
1034 static int cmd_line_buffer_initialized;
1035 const char *prompt = prompt_arg;
1038 /* The annotation suffix must be non-NULL. */
1039 if (annotation_suffix == NULL)
1040 annotation_suffix = "";
1042 if (annotation_level > 1 && instream == stdin)
1047 = (char *) alloca ((prompt == NULL ? 0 : strlen (prompt))
1048 + strlen (annotation_suffix) + 40);
1050 local_prompt[0] = '\0';
1052 strcpy (local_prompt, prompt);
1053 strcat (local_prompt, "\n\032\032");
1054 strcat (local_prompt, annotation_suffix);
1055 strcat (local_prompt, "\n");
1057 prompt = local_prompt;
1060 if (!cmd_line_buffer_initialized)
1062 buffer_init (&cmd_line_buffer);
1063 cmd_line_buffer_initialized = 1;
1066 /* Starting a new command line. */
1067 cmd_line_buffer.used_size = 0;
1071 signal (STOP_SIGNAL, handle_stop_sig);
1078 /* Make sure that all output has been output. Some machines may
1079 let you get away with leaving out some of the gdb_flush, but
1082 gdb_flush (gdb_stdout);
1083 gdb_flush (gdb_stderr);
1085 if (source_file_name != NULL)
1086 ++source_line_number;
1088 if (annotation_level > 1 && instream == stdin)
1090 puts_unfiltered ("\n\032\032pre-");
1091 puts_unfiltered (annotation_suffix);
1092 puts_unfiltered ("\n");
1095 /* Don't use fancy stuff if not talking to stdin. */
1096 if (deprecated_readline_hook && input_from_terminal_p ())
1098 rl = (*deprecated_readline_hook) (prompt);
1100 else if (command_editing_p && input_from_terminal_p ())
1102 rl = gdb_readline_wrapper (prompt);
1106 rl = gdb_readline_no_editing (prompt);
1109 cmd = handle_line_of_input (&cmd_line_buffer, rl,
1110 repeat, annotation_suffix);
1111 if (cmd == (char *) EOF)
1124 signal (STOP_SIGNAL, SIG_DFL);
1130 /* Print the GDB banner. */
1132 print_gdb_version (struct ui_file *stream)
1134 /* From GNU coding standards, first line is meant to be easy for a
1135 program to parse, and is just canonical program name and version
1136 number, which starts after last space. */
1138 fprintf_filtered (stream, "GNU gdb %s%s\n", PKGVERSION, version);
1140 /* Second line is a copyright notice. */
1142 fprintf_filtered (stream,
1143 "Copyright (C) 2016 Free Software Foundation, Inc.\n");
1145 /* Following the copyright is a brief statement that the program is
1146 free software, that users are free to copy and change it on
1147 certain conditions, that it is covered by the GNU GPL, and that
1148 there is no warranty. */
1150 fprintf_filtered (stream, "\
1151 License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>\
1152 \nThis is free software: you are free to change and redistribute it.\n\
1153 There is NO WARRANTY, to the extent permitted by law. Type \"show copying\"\n\
1154 and \"show warranty\" for details.\n");
1156 /* After the required info we print the configuration information. */
1158 fprintf_filtered (stream, "This GDB was configured as \"");
1159 if (strcmp (host_name, target_name) != 0)
1161 fprintf_filtered (stream, "--host=%s --target=%s",
1162 host_name, target_name);
1166 fprintf_filtered (stream, "%s", host_name);
1168 fprintf_filtered (stream, "\".\n\
1169 Type \"show configuration\" for configuration details.");
1171 if (REPORT_BUGS_TO[0])
1173 fprintf_filtered (stream,
1174 _("\nFor bug reporting instructions, please see:\n"));
1175 fprintf_filtered (stream, "%s.\n", REPORT_BUGS_TO);
1177 fprintf_filtered (stream,
1178 _("Find the GDB manual and other documentation \
1179 resources online at:\n<http://www.gnu.org/software/gdb/documentation/>.\n"));
1180 fprintf_filtered (stream, _("For help, type \"help\".\n"));
1181 fprintf_filtered (stream, _("Type \"apropos word\" to search for \
1182 commands related to \"word\"."));
1185 /* Print the details of GDB build-time configuration. */
1187 print_gdb_configuration (struct ui_file *stream)
1189 fprintf_filtered (stream, _("\
1190 This GDB was configured as follows:\n\
1191 configure --host=%s --target=%s\n\
1192 "), host_name, target_name);
1193 fprintf_filtered (stream, _("\
1194 --with-auto-load-dir=%s\n\
1195 --with-auto-load-safe-path=%s\n\
1196 "), AUTO_LOAD_DIR, AUTO_LOAD_SAFE_PATH);
1198 fprintf_filtered (stream, _("\
1202 fprintf_filtered (stream, _("\
1207 fprintf_filtered (stream, _("\
1208 --with-gdb-datadir=%s%s\n\
1209 "), GDB_DATADIR, GDB_DATADIR_RELOCATABLE ? " (relocatable)" : "");
1211 fprintf_filtered (stream, _("\
1212 --with-iconv-bin=%s%s\n\
1213 "), ICONV_BIN, ICONV_BIN_RELOCATABLE ? " (relocatable)" : "");
1215 if (JIT_READER_DIR[0])
1216 fprintf_filtered (stream, _("\
1217 --with-jit-reader-dir=%s%s\n\
1218 "), JIT_READER_DIR, JIT_READER_DIR_RELOCATABLE ? " (relocatable)" : "");
1219 #if HAVE_LIBUNWIND_IA64_H
1220 fprintf_filtered (stream, _("\
1221 --with-libunwind-ia64\n\
1224 fprintf_filtered (stream, _("\
1225 --without-libunwind-ia64\n\
1229 fprintf_filtered (stream, _("\
1233 fprintf_filtered (stream, _("\
1237 #ifdef WITH_PYTHON_PATH
1238 fprintf_filtered (stream, _("\
1239 --with-python=%s%s\n\
1240 "), WITH_PYTHON_PATH, PYTHON_PATH_RELOCATABLE ? " (relocatable)" : "");
1243 fprintf_filtered (stream, _("\
1247 fprintf_filtered (stream, _("\
1252 fprintf_filtered (stream, _("\
1253 --with-relocated-sources=%s\n\
1257 fprintf_filtered (stream, _("\
1258 --with-separate-debug-dir=%s%s\n\
1259 "), DEBUGDIR, DEBUGDIR_RELOCATABLE ? " (relocatable)" : "");
1260 if (TARGET_SYSTEM_ROOT[0])
1261 fprintf_filtered (stream, _("\
1262 --with-sysroot=%s%s\n\
1263 "), TARGET_SYSTEM_ROOT, TARGET_SYSTEM_ROOT_RELOCATABLE ? " (relocatable)" : "");
1264 if (SYSTEM_GDBINIT[0])
1265 fprintf_filtered (stream, _("\
1266 --with-system-gdbinit=%s%s\n\
1267 "), SYSTEM_GDBINIT, SYSTEM_GDBINIT_RELOCATABLE ? " (relocatable)" : "");
1268 #if HAVE_LIBBABELTRACE
1269 fprintf_filtered (stream, _("\
1270 --with-babeltrace\n\
1273 fprintf_filtered (stream, _("\
1274 --without-babeltrace\n\
1277 /* We assume "relocatable" will be printed at least once, thus we always
1278 print this text. It's a reasonably safe assumption for now. */
1279 fprintf_filtered (stream, _("\n\
1280 (\"Relocatable\" means the directory can be moved with the GDB installation\n\
1281 tree, and GDB will still find it.)\n\
1286 /* The current top level prompt, settable with "set prompt", and/or
1287 with the python `gdb.prompt_hook' hook. */
1288 static char *top_prompt;
1290 /* Access method for the GDB prompt string. */
1298 /* Set method for the GDB prompt string. */
1301 set_prompt (const char *s)
1303 char *p = xstrdup (s);
1316 /* Callback for iterate_over_inferiors. Kills or detaches the given
1317 inferior, depending on how we originally gained control of it. */
1320 kill_or_detach (struct inferior *inf, void *args)
1322 struct qt_args *qt = (struct qt_args *) args;
1323 struct thread_info *thread;
1328 thread = any_thread_of_process (inf->pid);
1331 switch_to_thread (thread->ptid);
1333 /* Leave core files alone. */
1334 if (target_has_execution)
1336 if (inf->attach_flag)
1337 target_detach (qt->args, qt->from_tty);
1346 /* Callback for iterate_over_inferiors. Prints info about what GDB
1347 will do to each inferior on a "quit". ARG points to a struct
1348 ui_out where output is to be collected. */
1351 print_inferior_quit_action (struct inferior *inf, void *arg)
1353 struct ui_file *stb = (struct ui_file *) arg;
1358 if (inf->attach_flag)
1359 fprintf_filtered (stb,
1360 _("\tInferior %d [%s] will be detached.\n"), inf->num,
1361 target_pid_to_str (pid_to_ptid (inf->pid)));
1363 fprintf_filtered (stb,
1364 _("\tInferior %d [%s] will be killed.\n"), inf->num,
1365 target_pid_to_str (pid_to_ptid (inf->pid)));
1370 /* If necessary, make the user confirm that we should quit. Return
1371 non-zero if we should quit, zero if we shouldn't. */
1376 struct ui_file *stb;
1377 struct cleanup *old_chain;
1381 /* Don't even ask if we're only debugging a core file inferior. */
1382 if (!have_live_inferiors ())
1385 /* Build the query string as a single string. */
1386 stb = mem_fileopen ();
1387 old_chain = make_cleanup_ui_file_delete (stb);
1389 fprintf_filtered (stb, _("A debugging session is active.\n\n"));
1390 iterate_over_inferiors (print_inferior_quit_action, stb);
1391 fprintf_filtered (stb, _("\nQuit anyway? "));
1393 str = ui_file_xstrdup (stb, NULL);
1394 make_cleanup (xfree, str);
1396 qr = query ("%s", str);
1397 do_cleanups (old_chain);
1401 /* Prepare to exit GDB cleanly by undoing any changes made to the
1402 terminal so that we leave the terminal in the state we acquired it. */
1405 undo_terminal_modifications_before_exit (void)
1407 target_terminal_ours ();
1411 if (async_command_editing_p)
1412 gdb_disable_readline ();
1416 /* Quit without asking for confirmation. */
1419 quit_force (char *args, int from_tty)
1424 undo_terminal_modifications_before_exit ();
1426 /* An optional expression may be used to cause gdb to terminate with the
1427 value of that expression. */
1430 struct value *val = parse_and_eval (args);
1432 exit_code = (int) value_as_long (val);
1434 else if (return_child_result)
1435 exit_code = return_child_result_value;
1438 qt.from_tty = from_tty;
1440 /* We want to handle any quit errors and exit regardless. */
1442 /* Get out of tfind mode, and kill or detach all inferiors. */
1445 disconnect_tracing ();
1446 iterate_over_inferiors (kill_or_detach, &qt);
1448 CATCH (ex, RETURN_MASK_ALL)
1450 exception_print (gdb_stderr, ex);
1454 /* Give all pushed targets a chance to do minimal cleanup, and pop
1460 CATCH (ex, RETURN_MASK_ALL)
1462 exception_print (gdb_stderr, ex);
1466 /* Save the history information if it is appropriate to do so. */
1469 if (write_history_p && history_filename
1470 && input_from_terminal_p ())
1471 gdb_safe_append_history ();
1473 CATCH (ex, RETURN_MASK_ALL)
1475 exception_print (gdb_stderr, ex);
1479 /* Do any final cleanups before exiting. */
1482 do_final_cleanups (all_cleanups ());
1484 CATCH (ex, RETURN_MASK_ALL)
1486 exception_print (gdb_stderr, ex);
1493 /* Returns whether GDB is running on a terminal and input is
1494 currently coming from that terminal. */
1497 input_from_terminal_p (void)
1502 if (gdb_has_a_terminal () && instream == stdin)
1505 /* If INSTREAM is unset, and we are not in a user command, we
1506 must be in Insight. That's like having a terminal, for our
1508 if (instream == NULL && !in_user_command)
1515 dont_repeat_command (char *ignored, int from_tty)
1517 /* Can't call dont_repeat here because we're not necessarily reading
1519 *saved_command_line = 0;
1522 /* Functions to manipulate command line editing control variables. */
1524 /* Number of commands to print in each call to show_commands. */
1525 #define Hist_print 10
1527 show_commands (char *args, int from_tty)
1529 /* Index for history commands. Relative to history_base. */
1532 /* Number of the history entry which we are planning to display next.
1533 Relative to history_base. */
1536 /* Print out some of the commands from the command history. */
1540 if (args[0] == '+' && args[1] == '\0')
1541 /* "info editing +" should print from the stored position. */
1544 /* "info editing <exp>" should print around command number <exp>. */
1545 num = (parse_and_eval_long (args) - history_base) - Hist_print / 2;
1547 /* "show commands" means print the last Hist_print commands. */
1550 num = history_length - Hist_print;
1556 /* If there are at least Hist_print commands, we want to display the last
1557 Hist_print rather than, say, the last 6. */
1558 if (history_length - num < Hist_print)
1560 num = history_length - Hist_print;
1566 offset < num + Hist_print && offset < history_length;
1569 printf_filtered ("%5d %s\n", history_base + offset,
1570 (history_get (history_base + offset))->line);
1573 /* The next command we want to display is the next one that we haven't
1577 /* If the user repeats this command with return, it should do what
1578 "show commands +" does. This is unnecessary if arg is null,
1579 because "show commands +" is not useful after "show commands". */
1580 if (from_tty && args)
1587 /* Update the size of our command history file to HISTORY_SIZE.
1589 A HISTORY_SIZE of -1 stands for unlimited. */
1592 set_readline_history_size (int history_size)
1594 gdb_assert (history_size >= -1);
1596 if (history_size == -1)
1597 unstifle_history ();
1599 stifle_history (history_size);
1602 /* Called by do_setshow_command. */
1604 set_history_size_command (char *args, int from_tty, struct cmd_list_element *c)
1606 set_readline_history_size (history_size_setshow_var);
1610 set_history (char *args, int from_tty)
1612 printf_unfiltered (_("\"set history\" must be followed "
1613 "by the name of a history subcommand.\n"));
1614 help_list (sethistlist, "set history ", all_commands, gdb_stdout);
1618 show_history (char *args, int from_tty)
1620 cmd_show_list (showhistlist, from_tty, "");
1623 int info_verbose = 0; /* Default verbose msgs off. */
1625 /* Called by do_setshow_command. An elaborate joke. */
1627 set_verbose (char *args, int from_tty, struct cmd_list_element *c)
1629 const char *cmdname = "verbose";
1630 struct cmd_list_element *showcmd;
1632 showcmd = lookup_cmd_1 (&cmdname, showlist, NULL, 1);
1633 gdb_assert (showcmd != NULL && showcmd != CMD_LIST_AMBIGUOUS);
1637 c->doc = "Set verbose printing of informational messages.";
1638 showcmd->doc = "Show verbose printing of informational messages.";
1642 c->doc = "Set verbosity.";
1643 showcmd->doc = "Show verbosity.";
1647 /* Init the history buffer. Note that we are called after the init file(s)
1648 have been read so that the user can change the history file via his
1649 .gdbinit file (for instance). The GDBHISTFILE environment variable
1650 overrides all of this. */
1657 tmpenv = getenv ("GDBHISTSIZE");
1664 tmpenv = skip_spaces (tmpenv);
1666 var = strtol (tmpenv, &endptr, 10);
1667 saved_errno = errno;
1668 endptr = skip_spaces (endptr);
1670 /* If GDBHISTSIZE is non-numeric then ignore it. If GDBHISTSIZE is the
1671 empty string, a negative number or a huge positive number (larger than
1672 INT_MAX) then set the history size to unlimited. Otherwise set our
1673 history size to the number we have read. This behavior is consistent
1674 with how bash handles HISTSIZE. */
1675 if (*endptr != '\0')
1677 else if (*tmpenv == '\0'
1680 /* On targets where INT_MAX == LONG_MAX, we have to look at
1681 errno after calling strtol to distinguish between a value that
1682 is exactly INT_MAX and an overflowing value that was clamped
1684 || (var == INT_MAX && saved_errno == ERANGE))
1685 history_size_setshow_var = -1;
1687 history_size_setshow_var = var;
1690 /* If neither the init file nor GDBHISTSIZE has set a size yet, pick the
1692 if (history_size_setshow_var == -2)
1693 history_size_setshow_var = 256;
1695 set_readline_history_size (history_size_setshow_var);
1697 tmpenv = getenv ("GDBHISTFILE");
1699 history_filename = xstrdup (tmpenv);
1700 else if (!history_filename)
1702 /* We include the current directory so that if the user changes
1703 directories the file written will be the same as the one
1706 /* No leading dots in file names are allowed on MSDOS. */
1707 history_filename = concat (current_directory, "/_gdb_history",
1710 history_filename = concat (current_directory, "/.gdb_history",
1714 read_history (history_filename);
1718 show_prompt (struct ui_file *file, int from_tty,
1719 struct cmd_list_element *c, const char *value)
1721 fprintf_filtered (file, _("Gdb's prompt is \"%s\".\n"), value);
1725 show_async_command_editing_p (struct ui_file *file, int from_tty,
1726 struct cmd_list_element *c, const char *value)
1728 fprintf_filtered (file, _("Editing of command lines as "
1729 "they are typed is %s.\n"),
1734 show_annotation_level (struct ui_file *file, int from_tty,
1735 struct cmd_list_element *c, const char *value)
1737 fprintf_filtered (file, _("Annotation_level is %s.\n"), value);
1741 show_exec_done_display_p (struct ui_file *file, int from_tty,
1742 struct cmd_list_element *c, const char *value)
1744 fprintf_filtered (file, _("Notification of completion for "
1745 "asynchronous execution commands is %s.\n"),
1749 /* New values of the "data-directory" parameter are staged here. */
1750 static char *staged_gdb_datadir;
1752 /* "set" command for the gdb_datadir configuration variable. */
1755 set_gdb_datadir (char *args, int from_tty, struct cmd_list_element *c)
1757 set_gdb_data_directory (staged_gdb_datadir);
1758 observer_notify_gdb_datadir_changed ();
1761 /* "show" command for the gdb_datadir configuration variable. */
1764 show_gdb_datadir (struct ui_file *file, int from_tty,
1765 struct cmd_list_element *c, const char *value)
1767 fprintf_filtered (file, _("GDB's data directory is \"%s\".\n"),
1772 set_history_filename (char *args, int from_tty, struct cmd_list_element *c)
1774 /* We include the current directory so that if the user changes
1775 directories the file written will be the same as the one
1777 if (!IS_ABSOLUTE_PATH (history_filename))
1778 history_filename = reconcat (history_filename, current_directory, "/",
1779 history_filename, (char *) NULL);
1785 /* Initialize the prompt to a simple "(gdb) " prompt or to whatever
1786 the DEFAULT_PROMPT is. */
1787 set_prompt (DEFAULT_PROMPT);
1789 /* Set the important stuff up for command editing. */
1790 command_editing_p = 1;
1791 history_expansion_p = 0;
1792 write_history_p = 0;
1794 /* Setup important stuff for command line editing. */
1795 rl_completion_word_break_hook = gdb_completion_word_break_characters;
1796 rl_completion_entry_function = readline_line_completion_function;
1797 rl_completer_word_break_characters = default_word_break_characters ();
1798 rl_completer_quote_characters = get_gdb_completer_quote_characters ();
1799 rl_completion_display_matches_hook = cli_display_match_list;
1800 rl_readline_name = "gdb";
1801 rl_terminal_name = getenv ("TERM");
1803 /* The name for this defun comes from Bash, where it originated.
1804 15 is Control-o, the same binding this function has in Bash. */
1805 rl_add_defun ("operate-and-get-next", gdb_rl_operate_and_get_next, 15);
1807 add_setshow_string_cmd ("prompt", class_support,
1809 _("Set gdb's prompt"),
1810 _("Show gdb's prompt"),
1813 &setlist, &showlist);
1815 add_com ("dont-repeat", class_support, dont_repeat_command, _("\
1816 Don't repeat this command.\nPrimarily \
1817 used inside of user-defined commands that should not be repeated when\n\
1820 add_setshow_boolean_cmd ("editing", class_support,
1821 &async_command_editing_p, _("\
1822 Set editing of command lines as they are typed."), _("\
1823 Show editing of command lines as they are typed."), _("\
1824 Use \"on\" to enable the editing, and \"off\" to disable it.\n\
1825 Without an argument, command line editing is enabled. To edit, use\n\
1826 EMACS-like or VI-like commands like control-P or ESC."),
1827 set_async_editing_command,
1828 show_async_command_editing_p,
1829 &setlist, &showlist);
1831 add_setshow_boolean_cmd ("save", no_class, &write_history_p, _("\
1832 Set saving of the history record on exit."), _("\
1833 Show saving of the history record on exit."), _("\
1834 Use \"on\" to enable the saving, and \"off\" to disable it.\n\
1835 Without an argument, saving is enabled."),
1837 show_write_history_p,
1838 &sethistlist, &showhistlist);
1840 add_setshow_zuinteger_unlimited_cmd ("size", no_class,
1841 &history_size_setshow_var, _("\
1842 Set the size of the command history,"), _("\
1843 Show the size of the command history,"), _("\
1844 ie. the number of previous commands to keep a record of.\n\
1845 If set to \"unlimited\", the number of commands kept in the history\n\
1846 list is unlimited. This defaults to the value of the environment\n\
1847 variable \"GDBHISTSIZE\", or to 256 if this variable is not set."),
1848 set_history_size_command,
1850 &sethistlist, &showhistlist);
1852 add_setshow_zuinteger_unlimited_cmd ("remove-duplicates", no_class,
1853 &history_remove_duplicates, _("\
1854 Set how far back in history to look for and remove duplicate entries."), _("\
1855 Show how far back in history to look for and remove duplicate entries."), _("\
1856 If set to a nonzero value N, GDB will look back at the last N history entries\n\
1857 and remove the first history entry that is a duplicate of the most recent\n\
1858 entry, each time a new history entry is added.\n\
1859 If set to \"unlimited\", this lookbehind is unbounded.\n\
1860 Only history entries added during this session are considered for removal.\n\
1861 If set to 0, removal of duplicate history entries is disabled.\n\
1862 By default this option is set to 0."),
1864 show_history_remove_duplicates,
1865 &sethistlist, &showhistlist);
1867 add_setshow_filename_cmd ("filename", no_class, &history_filename, _("\
1868 Set the filename in which to record the command history"), _("\
1869 Show the filename in which to record the command history"), _("\
1870 (the list of previous commands of which a record is kept)."),
1871 set_history_filename,
1872 show_history_filename,
1873 &sethistlist, &showhistlist);
1875 add_setshow_boolean_cmd ("confirm", class_support, &confirm, _("\
1876 Set whether to confirm potentially dangerous operations."), _("\
1877 Show whether to confirm potentially dangerous operations."), NULL,
1880 &setlist, &showlist);
1882 add_setshow_zinteger_cmd ("annotate", class_obscure, &annotation_level, _("\
1883 Set annotation_level."), _("\
1884 Show annotation_level."), _("\
1885 0 == normal; 1 == fullname (for use when running under emacs)\n\
1886 2 == output annotated suitably for use by programs that control GDB."),
1888 show_annotation_level,
1889 &setlist, &showlist);
1891 add_setshow_boolean_cmd ("exec-done-display", class_support,
1892 &exec_done_display_p, _("\
1893 Set notification of completion for asynchronous execution commands."), _("\
1894 Show notification of completion for asynchronous execution commands."), _("\
1895 Use \"on\" to enable the notification, and \"off\" to disable it."),
1897 show_exec_done_display_p,
1898 &setlist, &showlist);
1900 add_setshow_filename_cmd ("data-directory", class_maintenance,
1901 &staged_gdb_datadir, _("Set GDB's data directory."),
1902 _("Show GDB's data directory."),
1904 When set, GDB uses the specified path to search for data files."),
1905 set_gdb_datadir, show_gdb_datadir,
1911 gdb_init (char *argv0)
1913 if (pre_init_ui_hook)
1914 pre_init_ui_hook ();
1916 /* Run the init function of each source file. */
1919 /* Make sure we return to the original directory upon exit, come
1920 what may, since the OS doesn't do that for us. */
1921 make_final_cleanup (do_chdir_cleanup, xstrdup (current_directory));
1924 init_cmd_lists (); /* This needs to be done first. */
1925 initialize_targets (); /* Setup target_terminal macros for utils.c. */
1926 initialize_utils (); /* Make errors and warnings possible. */
1930 /* Here is where we call all the _initialize_foo routines. */
1931 initialize_all_files ();
1933 /* This creates the current_program_space. Do this after all the
1934 _initialize_foo routines have had a chance to install their
1935 per-sspace data keys. Also do this before
1936 initialize_current_architecture is called, because it accesses
1937 exec_bfd of the current program space. */
1938 initialize_progspace ();
1939 initialize_inferiors ();
1940 initialize_current_architecture ();
1942 init_main (); /* But that omits this file! Do it now. */
1944 initialize_stdin_serial ();
1946 /* Take a snapshot of our tty state before readline/ncurses have had a chance
1948 set_initial_gdb_ttystate ();
1950 async_init_signals ();
1952 /* We need a default language for parsing expressions, so simple
1953 things like "set width 0" won't fail if no language is explicitly
1954 set in a config file or implicitly set by reading an executable
1956 set_language (language_c);
1957 expected_language = current_language; /* Don't warn about the change. */
1959 /* Python initialization, for example, can require various commands to be
1960 installed. For example "info pretty-printer" needs the "info"
1961 prefix to be installed. Keep things simple and just do final
1962 script initialization here. */
1963 finish_ext_lang_initialization ();