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 /* Generate a function that exports a pointer to a field of the
92 #define gen_ret_current_ui_field_ptr(type, name) \
94 current_ui_## name ## _ptr (void) \
96 return ¤t_ui->m_ ## name; \
99 gen_ret_current_ui_field_ptr (struct ui_file
*, gdb_stdout
)
100 gen_ret_current_ui_field_ptr (struct ui_file
*, gdb_stdin
)
101 gen_ret_current_ui_field_ptr (struct ui_file
*, gdb_stderr
)
102 gen_ret_current_ui_field_ptr (struct ui_file
*, gdb_stdlog
)
103 gen_ret_current_ui_field_ptr (struct ui_out
*, current_uiout
)
105 /* Initialization file name for gdb. This is host-dependent. */
107 const char gdbinit
[] = GDBINIT
;
109 int inhibit_gdbinit
= 0;
111 extern char lang_frame_mismatch_warn
[]; /* language.c */
113 /* Flag for whether we want to confirm potentially dangerous
114 operations. Default is yes. */
119 show_confirm (struct ui_file
*file
, int from_tty
,
120 struct cmd_list_element
*c
, const char *value
)
122 fprintf_filtered (file
, _("Whether to confirm potentially "
123 "dangerous operations is %s.\n"),
127 /* Flag to indicate whether a user defined command is currently running. */
131 /* Current working directory. */
133 char *current_directory
;
135 /* The directory name is actually stored here (usually). */
136 char gdb_dirbuf
[1024];
138 /* The last command line executed on the console. Used for command
140 char *saved_command_line
;
142 /* Nonzero if the current command is modified by "server ". This
143 affects things like recording into the command history, commands
144 repeating on RETURN, etc. This is so a user interface (emacs, GUI,
145 whatever) can issue its own commands and also send along commands
146 from the user, and have the user not notice that the user interface
147 is issuing commands too. */
150 /* Timeout limit for response from target. */
152 /* The default value has been changed many times over the years. It
153 was originally 5 seconds. But that was thought to be a long time
154 to sit and wait, so it was changed to 2 seconds. That was thought
155 to be plenty unless the connection was going through some terminal
156 server or multiplexer or other form of hairy serial connection.
158 In mid-1996, remote_timeout was moved from remote.c to top.c and
159 it began being used in other remote-* targets. It appears that the
160 default was changed to 20 seconds at that time, perhaps because the
161 Renesas E7000 ICE didn't always respond in a timely manner.
163 But if 5 seconds is a long time to sit and wait for retransmissions,
164 20 seconds is far worse. This demonstrates the difficulty of using
165 a single variable for all protocol timeouts.
167 As remote.c is used much more than remote-e7000.c, it was changed
168 back to 2 seconds in 1999. */
170 int remote_timeout
= 2;
172 /* Non-zero tells remote* modules to output debugging info. */
174 int remote_debug
= 0;
176 /* Sbrk location on entry to main. Used for statistics only. */
181 /* Hooks for alternate command interfaces. */
183 /* This hook is called from within gdb's many mini-event loops which
184 could steal control from a real user interface's event loop. It
185 returns non-zero if the user is requesting a detach, zero
188 int (*deprecated_ui_loop_hook
) (int);
191 /* Called from print_frame_info to list the line we stopped in. */
193 void (*deprecated_print_frame_info_listing_hook
) (struct symtab
* s
,
197 /* Replaces most of query. */
199 int (*deprecated_query_hook
) (const char *, va_list);
201 /* Replaces most of warning. */
203 void (*deprecated_warning_hook
) (const char *, va_list);
205 /* These three functions support getting lines of text from the user.
206 They are used in sequence. First deprecated_readline_begin_hook is
207 called with a text string that might be (for example) a message for
208 the user to type in a sequence of commands to be executed at a
209 breakpoint. If this function calls back to a GUI, it might take
210 this opportunity to pop up a text interaction window with this
211 message. Next, deprecated_readline_hook is called with a prompt
212 that is emitted prior to collecting the user input. It can be
213 called multiple times. Finally, deprecated_readline_end_hook is
214 called to notify the GUI that we are done with the interaction
215 window and it can close it. */
217 void (*deprecated_readline_begin_hook
) (char *, ...);
218 char *(*deprecated_readline_hook
) (const char *);
219 void (*deprecated_readline_end_hook
) (void);
221 /* Called as appropriate to notify the interface that we have attached
222 to or detached from an already running process. */
224 void (*deprecated_attach_hook
) (void);
225 void (*deprecated_detach_hook
) (void);
227 /* Called during long calculations to allow GUI to repair window
228 damage, and to check for stop buttons, etc... */
230 void (*deprecated_interactive_hook
) (void);
232 /* Called when going to wait for the target. Usually allows the GUI
233 to run while waiting for target events. */
235 ptid_t (*deprecated_target_wait_hook
) (ptid_t ptid
,
236 struct target_waitstatus
*status
,
239 /* Used by UI as a wrapper around command execution. May do various
240 things like enabling/disabling buttons, etc... */
242 void (*deprecated_call_command_hook
) (struct cmd_list_element
* c
,
243 char *cmd
, int from_tty
);
245 /* Called when the current thread changes. Argument is thread id. */
247 void (*deprecated_context_hook
) (int id
);
249 /* The highest UI number ever assigned. */
250 static int highest_ui_num
;
255 new_ui (FILE *instream
, FILE *outstream
, FILE *errstream
)
259 ui
= XCNEW (struct ui
);
261 ui
->num
= ++highest_ui_num
;
262 ui
->stdin_stream
= instream
;
263 ui
->instream
= instream
;
264 ui
->outstream
= outstream
;
265 ui
->errstream
= errstream
;
267 ui
->input_fd
= fileno (ui
->instream
);
269 ui
->input_interactive_p
= ISATTY (ui
->instream
);
271 ui
->m_gdb_stdin
= stdio_fileopen (ui
->instream
);
272 ui
->m_gdb_stdout
= stdio_fileopen (ui
->outstream
);
273 ui
->m_gdb_stderr
= stderr_fileopen (ui
->errstream
);
274 ui
->m_gdb_stdlog
= ui
->m_gdb_stderr
;
276 ui
->prompt_state
= PROMPT_NEEDED
;
284 for (last
= ui_list
; last
->next
!= NULL
; last
= last
->next
)
293 free_ui (struct ui
*ui
)
295 ui_file_delete (ui
->m_gdb_stdin
);
296 ui_file_delete (ui
->m_gdb_stdout
);
297 ui_file_delete (ui
->m_gdb_stderr
);
303 delete_ui (struct ui
*todel
)
305 struct ui
*ui
, *uiprev
;
309 for (ui
= ui_list
; ui
!= NULL
; uiprev
= ui
, ui
= ui
->next
)
313 gdb_assert (ui
!= NULL
);
316 uiprev
->next
= ui
->next
;
323 /* Handler for SIGHUP. */
326 /* NOTE 1999-04-29: This function will be static again, once we modify
327 gdb to use the event loop as the default command loop and we merge
328 event-top.c into this file, top.c. */
332 /* Stop asking user for confirmation --- we're exiting. This
333 prevents asking the user dumb questions. */
335 quit_command ((char *) 0, 0);
337 #endif /* defined SIGHUP */
339 /* Line number we are currently in, in a file which is being sourced. */
340 /* NOTE 1999-04-29: This variable will be static again, once we modify
341 gdb to use the event loop as the default command loop and we merge
342 event-top.c into this file, top.c. */
343 /* static */ int source_line_number
;
345 /* Name of the file we are sourcing. */
346 /* NOTE 1999-04-29: This variable will be static again, once we modify
347 gdb to use the event loop as the default command loop and we merge
348 event-top.c into this file, top.c. */
349 /* static */ const char *source_file_name
;
351 /* Clean up on error during a "source" command (or execution of a
352 user-defined command). */
355 do_restore_instream_cleanup (void *stream
)
357 struct ui
*ui
= current_ui
;
359 /* Restore the previous input stream. */
360 ui
->instream
= (FILE *) stream
;
363 /* Read commands from STREAM. */
365 read_command_file (FILE *stream
)
367 struct ui
*ui
= current_ui
;
368 struct cleanup
*cleanups
;
370 cleanups
= make_cleanup (do_restore_instream_cleanup
, ui
->instream
);
371 ui
->instream
= stream
;
373 /* Read commands from `instream' and execute them until end of file
374 or error reading instream. */
376 while (ui
->instream
!= NULL
&& !feof (ui
->instream
))
380 /* Get a command-line. This calls the readline package. */
381 command
= command_line_input (NULL
, 0, NULL
);
384 command_handler (command
);
387 do_cleanups (cleanups
);
390 void (*pre_init_ui_hook
) (void);
394 do_chdir_cleanup (void *old_dir
)
402 prepare_execute_command (void)
405 struct cleanup
*cleanup
;
407 mark
= value_mark ();
408 cleanup
= make_cleanup_value_free_to_mark (mark
);
410 /* With multiple threads running while the one we're examining is
411 stopped, the dcache can get stale without us being able to detect
412 it. For the duration of the command, though, use the dcache to
413 help things like backtrace. */
415 target_dcache_invalidate ();
420 /* Tell the user if the language has changed (except first time) after
421 executing a command. */
424 check_frame_language_change (void)
426 static int warned
= 0;
427 struct frame_info
*frame
;
429 /* First make sure that a new frame has been selected, in case the
430 command or the hooks changed the program state. */
431 frame
= deprecated_safe_get_selected_frame ();
432 if (current_language
!= expected_language
)
434 if (language_mode
== language_mode_auto
&& info_verbose
)
436 language_info (1); /* Print what changed. */
441 /* Warn the user if the working language does not match the language
442 of the current frame. Only warn the user if we are actually
443 running the program, i.e. there is a stack. */
444 /* FIXME: This should be cacheing the frame and only running when
445 the frame changes. */
447 if (has_stack_frames ())
451 flang
= get_frame_language (frame
);
453 && flang
!= language_unknown
454 && flang
!= current_language
->la_language
)
456 printf_filtered ("%s\n", lang_frame_mismatch_warn
);
465 wait_sync_command_done (void)
467 while (gdb_do_one_event () >= 0)
468 if (current_ui
->prompt_state
!= PROMPT_BLOCKED
)
475 maybe_wait_sync_command_done (int was_sync
)
477 /* If the interpreter is in sync mode (we're running a user
478 command's list, running command hooks or similars), and we
479 just ran a synchronous command that started the target, wait
480 for that command to end. */
481 if (!current_ui
->async
483 && current_ui
->prompt_state
== PROMPT_BLOCKED
)
484 wait_sync_command_done ();
487 /* Execute the line P as a command, in the current user context.
488 Pass FROM_TTY as second argument to the defining function. */
491 execute_command (char *p
, int from_tty
)
493 struct cleanup
*cleanup_if_error
, *cleanup
;
494 struct cmd_list_element
*c
;
497 cleanup_if_error
= make_bpstat_clear_actions_cleanup ();
498 cleanup
= prepare_execute_command ();
500 /* Force cleanup of any alloca areas if using C alloca instead of
504 /* This can happen when command_line_input hits end of file. */
507 do_cleanups (cleanup
);
508 discard_cleanups (cleanup_if_error
);
512 target_log_command (p
);
514 while (*p
== ' ' || *p
== '\t')
520 int was_sync
= current_ui
->prompt_state
== PROMPT_BLOCKED
;
524 /* If trace-commands is set then this will print this command. */
525 print_command_trace (p
);
527 c
= lookup_cmd (&cmd
, cmdlist
, "", 0, 1);
530 /* Pass null arg rather than an empty one. */
533 /* FIXME: cagney/2002-02-02: The c->type test is pretty dodgy
534 while the is_complete_command(cfunc) test is just plain
535 bogus. They should both be replaced by a test of the form
536 c->strip_trailing_white_space_p. */
537 /* NOTE: cagney/2002-02-02: The function.cfunc in the below
538 can't be replaced with func. This is because it is the
539 cfunc, and not the func, that has the value that the
540 is_complete_command hack is testing for. */
541 /* Clear off trailing whitespace, except for set and complete
544 && c
->type
!= set_cmd
545 && !is_complete_command (c
))
547 p
= arg
+ strlen (arg
) - 1;
548 while (p
>= arg
&& (*p
== ' ' || *p
== '\t'))
553 /* If this command has been pre-hooked, run the hook first. */
554 execute_cmd_pre_hook (c
);
556 if (c
->deprecated_warn_user
)
557 deprecated_cmd_warning (line
);
559 /* c->user_commands would be NULL in the case of a python command. */
560 if (c
->theclass
== class_user
&& c
->user_commands
)
561 execute_user_command (c
, arg
);
562 else if (c
->type
== set_cmd
)
563 do_set_command (arg
, from_tty
, c
);
564 else if (c
->type
== show_cmd
)
565 do_show_command (arg
, from_tty
, c
);
566 else if (!cmd_func_p (c
))
567 error (_("That is not a command, just a help topic."));
568 else if (deprecated_call_command_hook
)
569 deprecated_call_command_hook (c
, arg
, from_tty
);
571 cmd_func (c
, arg
, from_tty
);
573 maybe_wait_sync_command_done (was_sync
);
575 /* If this command has been post-hooked, run the hook last. */
576 execute_cmd_post_hook (c
);
580 check_frame_language_change ();
582 do_cleanups (cleanup
);
583 discard_cleanups (cleanup_if_error
);
586 /* Run execute_command for P and FROM_TTY. Capture its output into the
587 returned string, do not display it to the screen. BATCH_FLAG will be
588 temporarily set to true. */
591 execute_command_to_string (char *p
, int from_tty
)
593 struct ui_file
*str_file
;
594 struct cleanup
*cleanup
;
597 /* GDB_STDOUT should be better already restored during these
598 restoration callbacks. */
599 cleanup
= set_batch_flag_and_make_cleanup_restore_page_info ();
601 make_cleanup_restore_integer (¤t_ui
->async
);
602 current_ui
->async
= 0;
604 str_file
= mem_fileopen ();
606 make_cleanup_ui_file_delete (str_file
);
607 make_cleanup_restore_ui_file (&gdb_stdout
);
608 make_cleanup_restore_ui_file (&gdb_stderr
);
609 make_cleanup_restore_ui_file (&gdb_stdlog
);
610 make_cleanup_restore_ui_file (&gdb_stdtarg
);
611 make_cleanup_restore_ui_file (&gdb_stdtargerr
);
613 if (ui_out_redirect (current_uiout
, str_file
) < 0)
614 warning (_("Current output protocol does not support redirection"));
616 make_cleanup_ui_out_redirect_pop (current_uiout
);
618 gdb_stdout
= str_file
;
619 gdb_stderr
= str_file
;
620 gdb_stdlog
= str_file
;
621 gdb_stdtarg
= str_file
;
622 gdb_stdtargerr
= str_file
;
624 execute_command (p
, from_tty
);
626 retval
= ui_file_xstrdup (str_file
, NULL
);
628 do_cleanups (cleanup
);
634 /* When nonzero, cause dont_repeat to do nothing. This should only be
635 set via prevent_dont_repeat. */
637 static int suppress_dont_repeat
= 0;
639 /* Commands call this if they do not want to be repeated by null lines. */
644 struct ui
*ui
= current_ui
;
646 if (suppress_dont_repeat
|| server_command
)
649 /* If we aren't reading from standard input, we are saving the last
650 thing read from stdin in line and don't want to delete it. Null
651 lines won't repeat here in any case. */
652 if (ui
->instream
== ui
->stdin_stream
)
653 *saved_command_line
= 0;
656 /* Prevent dont_repeat from working, and return a cleanup that
657 restores the previous state. */
660 prevent_dont_repeat (void)
662 struct cleanup
*result
= make_cleanup_restore_integer (&suppress_dont_repeat
);
664 suppress_dont_repeat
= 1;
669 /* Read a line from the stream "instream" without command line editing.
671 It prints PROMPT once at the start.
672 Action is compatible with "readline", e.g. space for the result is
673 malloc'd and should be freed by the caller.
675 A NULL return means end of file. */
678 gdb_readline_no_editing (const char *prompt
)
680 struct buffer line_buffer
;
681 struct ui
*ui
= current_ui
;
682 /* Read from stdin if we are executing a user defined command. This
683 is the right thing for prompt_for_continue, at least. */
684 FILE *stream
= ui
->instream
!= NULL
? ui
->instream
: stdin
;
685 int fd
= fileno (stream
);
687 buffer_init (&line_buffer
);
691 /* Don't use a _filtered function here. It causes the assumed
692 character position to be off, since the newline we read from
693 the user is not accounted for. */
694 fputs_unfiltered (prompt
, gdb_stdout
);
695 gdb_flush (gdb_stdout
);
706 /* Wait until at least one byte of data is available. Control-C
707 can interrupt interruptible_select, but not fgetc. */
709 FD_SET (fd
, &readfds
);
710 if (interruptible_select (fd
+ 1, &readfds
, NULL
, NULL
, NULL
) == -1)
714 /* If this was ctrl-c, the QUIT above handles it. */
717 perror_with_name (("select"));
724 if (line_buffer
.used_size
> 0)
725 /* The last line does not end with a newline. Return it, and
726 if we are called again fgetc will still return EOF and
727 we'll return NULL then. */
729 xfree (buffer_finish (&line_buffer
));
735 if (line_buffer
.used_size
> 0
736 && line_buffer
.buffer
[line_buffer
.used_size
- 1] == '\r')
737 line_buffer
.used_size
--;
741 buffer_grow_char (&line_buffer
, c
);
744 buffer_grow_char (&line_buffer
, '\0');
745 return buffer_finish (&line_buffer
);
748 /* Variables which control command line editing and history
749 substitution. These variables are given default values at the end
751 static int command_editing_p
;
753 /* NOTE 1999-04-29: This variable will be static again, once we modify
754 gdb to use the event loop as the default command loop and we merge
755 event-top.c into this file, top.c. */
757 /* static */ int history_expansion_p
;
759 static int write_history_p
;
761 show_write_history_p (struct ui_file
*file
, int from_tty
,
762 struct cmd_list_element
*c
, const char *value
)
764 fprintf_filtered (file
, _("Saving of the history record on exit is %s.\n"),
768 /* The variable associated with the "set/show history size"
769 command. The value -1 means unlimited, and -2 means undefined. */
770 static int history_size_setshow_var
= -2;
773 show_history_size (struct ui_file
*file
, int from_tty
,
774 struct cmd_list_element
*c
, const char *value
)
776 fprintf_filtered (file
, _("The size of the command history is %s.\n"),
780 /* Variable associated with the "history remove-duplicates" option.
781 The value -1 means unlimited. */
782 static int history_remove_duplicates
= 0;
785 show_history_remove_duplicates (struct ui_file
*file
, int from_tty
,
786 struct cmd_list_element
*c
, const char *value
)
788 fprintf_filtered (file
,
789 _("The number of history entries to look back at for "
790 "duplicates is %s.\n"),
794 static char *history_filename
;
796 show_history_filename (struct ui_file
*file
, int from_tty
,
797 struct cmd_list_element
*c
, const char *value
)
799 fprintf_filtered (file
, _("The filename in which to record "
800 "the command history is \"%s\".\n"),
804 /* This is like readline(), but it has some gdb-specific behavior.
805 gdb may want readline in both the synchronous and async modes during
806 a single gdb invocation. At the ordinary top-level prompt we might
807 be using the async readline. That means we can't use
808 rl_pre_input_hook, since it doesn't work properly in async mode.
809 However, for a secondary prompt (" >", such as occurs during a
810 `define'), gdb wants a synchronous response.
812 We used to call readline() directly, running it in synchronous
813 mode. But mixing modes this way is not supported, and as of
814 readline 5.x it no longer works; the arrow keys come unbound during
815 the synchronous call. So we make a nested call into the event
816 loop. That's what gdb_readline_wrapper is for. */
818 /* A flag set as soon as gdb_readline_wrapper_line is called; we can't
819 rely on gdb_readline_wrapper_result, which might still be NULL if
820 the user types Control-D for EOF. */
821 static int gdb_readline_wrapper_done
;
823 /* The result of the current call to gdb_readline_wrapper, once a newline
825 static char *gdb_readline_wrapper_result
;
827 /* Any intercepted hook. Operate-and-get-next sets this, expecting it
828 to be called after the newline is processed (which will redisplay
829 the prompt). But in gdb_readline_wrapper we will not get a new
830 prompt until the next call, or until we return to the event loop.
831 So we disable this hook around the newline and restore it before we
833 static void (*saved_after_char_processing_hook
) (void);
839 gdb_in_secondary_prompt_p (struct ui
*ui
)
841 return ui
->secondary_prompt_depth
> 0;
845 /* This function is called when readline has seen a complete line of
849 gdb_readline_wrapper_line (char *line
)
851 gdb_assert (!gdb_readline_wrapper_done
);
852 gdb_readline_wrapper_result
= line
;
853 gdb_readline_wrapper_done
= 1;
855 /* Prevent operate-and-get-next from acting too early. */
856 saved_after_char_processing_hook
= after_char_processing_hook
;
857 after_char_processing_hook
= NULL
;
859 /* Prevent parts of the prompt from being redisplayed if annotations
860 are enabled, and readline's state getting out of sync. We'll
861 reinstall the callback handler, which puts the terminal in raw
862 mode (or in readline lingo, in prepped state), when we're next
863 ready to process user input, either in display_gdb_prompt, or if
864 we're handling an asynchronous target event and running in the
865 background, just before returning to the event loop to process
866 further input (or more target events). */
867 if (current_ui
->command_editing
)
868 gdb_rl_callback_handler_remove ();
871 struct gdb_readline_wrapper_cleanup
873 void (*handler_orig
) (char *);
874 int already_prompted_orig
;
876 /* Whether the target was async. */
877 int target_is_async_orig
;
881 gdb_readline_wrapper_cleanup (void *arg
)
883 struct ui
*ui
= current_ui
;
884 struct gdb_readline_wrapper_cleanup
*cleanup
885 = (struct gdb_readline_wrapper_cleanup
*) arg
;
887 if (ui
->command_editing
)
888 rl_already_prompted
= cleanup
->already_prompted_orig
;
890 gdb_assert (ui
->input_handler
== gdb_readline_wrapper_line
);
891 ui
->input_handler
= cleanup
->handler_orig
;
893 /* Don't restore our input handler in readline yet. That would make
894 readline prep the terminal (putting it in raw mode), while the
895 line we just read may trigger execution of a command that expects
896 the terminal in the default cooked/canonical mode, such as e.g.,
897 running Python's interactive online help utility. See
898 gdb_readline_wrapper_line for when we'll reinstall it. */
900 gdb_readline_wrapper_result
= NULL
;
901 gdb_readline_wrapper_done
= 0;
902 ui
->secondary_prompt_depth
--;
903 gdb_assert (ui
->secondary_prompt_depth
>= 0);
905 after_char_processing_hook
= saved_after_char_processing_hook
;
906 saved_after_char_processing_hook
= NULL
;
908 if (cleanup
->target_is_async_orig
)
915 gdb_readline_wrapper (const char *prompt
)
917 struct ui
*ui
= current_ui
;
918 struct cleanup
*back_to
;
919 struct gdb_readline_wrapper_cleanup
*cleanup
;
922 cleanup
= XNEW (struct gdb_readline_wrapper_cleanup
);
923 cleanup
->handler_orig
= ui
->input_handler
;
924 ui
->input_handler
= gdb_readline_wrapper_line
;
926 if (ui
->command_editing
)
927 cleanup
->already_prompted_orig
= rl_already_prompted
;
929 cleanup
->already_prompted_orig
= 0;
931 cleanup
->target_is_async_orig
= target_is_async_p ();
933 ui
->secondary_prompt_depth
++;
934 back_to
= make_cleanup (gdb_readline_wrapper_cleanup
, cleanup
);
936 if (cleanup
->target_is_async_orig
)
939 /* Display our prompt and prevent double prompt display. */
940 display_gdb_prompt (prompt
);
941 if (ui
->command_editing
)
942 rl_already_prompted
= 1;
944 if (after_char_processing_hook
)
945 (*after_char_processing_hook
) ();
946 gdb_assert (after_char_processing_hook
== NULL
);
948 while (gdb_do_one_event () >= 0)
949 if (gdb_readline_wrapper_done
)
952 retval
= gdb_readline_wrapper_result
;
953 do_cleanups (back_to
);
958 /* The current saved history number from operate-and-get-next.
959 This is -1 if not valid. */
960 static int operate_saved_history
= -1;
962 /* This is put on the appropriate hook and helps operate-and-get-next
965 gdb_rl_operate_and_get_next_completion (void)
967 int delta
= where_history () - operate_saved_history
;
969 /* The `key' argument to rl_get_previous_history is ignored. */
970 rl_get_previous_history (delta
, 0);
971 operate_saved_history
= -1;
973 /* readline doesn't automatically update the display for us. */
976 after_char_processing_hook
= NULL
;
977 rl_pre_input_hook
= NULL
;
980 /* This is a gdb-local readline command handler. It accepts the
981 current command line (like RET does) and, if this command was taken
982 from the history, arranges for the next command in the history to
983 appear on the command line when the prompt returns.
984 We ignore the arguments. */
986 gdb_rl_operate_and_get_next (int count
, int key
)
990 /* Use the async hook. */
991 after_char_processing_hook
= gdb_rl_operate_and_get_next_completion
;
993 /* Find the current line, and find the next line to use. */
994 where
= where_history();
996 if ((history_is_stifled () && (history_length
>= history_max_entries
))
997 || (where
>= history_length
- 1))
998 operate_saved_history
= where
;
1000 operate_saved_history
= where
+ 1;
1002 return rl_newline (1, key
);
1005 /* Number of user commands executed during this session. */
1007 static int command_count
= 0;
1009 /* Add the user command COMMAND to the input history list. */
1012 gdb_add_history (const char *command
)
1016 if (history_remove_duplicates
!= 0)
1019 int lookbehind_threshold
;
1021 /* The lookbehind threshold for finding a duplicate history entry is
1022 bounded by command_count because we can't meaningfully delete
1023 history entries that are already stored in the history file since
1024 the history file is appended to. */
1025 if (history_remove_duplicates
== -1
1026 || history_remove_duplicates
> command_count
)
1027 lookbehind_threshold
= command_count
;
1029 lookbehind_threshold
= history_remove_duplicates
;
1032 for (lookbehind
= 0; lookbehind
< lookbehind_threshold
; lookbehind
++)
1034 HIST_ENTRY
*temp
= previous_history ();
1039 if (strcmp (temp
->line
, command
) == 0)
1041 HIST_ENTRY
*prev
= remove_history (where_history ());
1043 free_history_entry (prev
);
1050 add_history (command
);
1053 /* Safely append new history entries to the history file in a corruption-free
1054 way using an intermediate local history file. */
1057 gdb_safe_append_history (void)
1059 int ret
, saved_errno
;
1060 char *local_history_filename
;
1061 struct cleanup
*old_chain
;
1063 local_history_filename
1064 = xstrprintf ("%s-gdb%d~", history_filename
, getpid ());
1065 old_chain
= make_cleanup (xfree
, local_history_filename
);
1067 ret
= rename (history_filename
, local_history_filename
);
1068 saved_errno
= errno
;
1069 if (ret
< 0 && saved_errno
!= ENOENT
)
1071 warning (_("Could not rename %s to %s: %s"),
1072 history_filename
, local_history_filename
,
1073 safe_strerror (saved_errno
));
1079 /* If the rename failed with ENOENT then either the global history
1080 file never existed in the first place or another GDB process is
1081 currently appending to it (and has thus temporarily renamed it).
1082 Since we can't distinguish between these two cases, we have to
1083 conservatively assume the first case and therefore must write out
1084 (not append) our known history to our local history file and try
1085 to move it back anyway. Otherwise a global history file would
1086 never get created! */
1087 gdb_assert (saved_errno
== ENOENT
);
1088 write_history (local_history_filename
);
1092 append_history (command_count
, local_history_filename
);
1093 if (history_is_stifled ())
1094 history_truncate_file (local_history_filename
, history_max_entries
);
1097 ret
= rename (local_history_filename
, history_filename
);
1098 saved_errno
= errno
;
1099 if (ret
< 0 && saved_errno
!= EEXIST
)
1100 warning (_("Could not rename %s to %s: %s"),
1101 local_history_filename
, history_filename
,
1102 safe_strerror (saved_errno
));
1105 do_cleanups (old_chain
);
1108 /* Read one line from the command input stream `instream' into a local
1109 static buffer. The buffer is made bigger as necessary. Returns
1110 the address of the start of the line.
1112 NULL is returned for end of file.
1114 *If* input is from an interactive stream (stdin), the line read is
1115 copied into the global 'saved_command_line' so that it can be
1118 This routine either uses fancy command line editing or simple input
1119 as the user has requested. */
1122 command_line_input (const char *prompt_arg
, int repeat
, char *annotation_suffix
)
1124 static struct buffer cmd_line_buffer
;
1125 static int cmd_line_buffer_initialized
;
1126 struct ui
*ui
= current_ui
;
1127 const char *prompt
= prompt_arg
;
1129 int from_tty
= ui
->instream
== ui
->stdin_stream
;
1131 /* The annotation suffix must be non-NULL. */
1132 if (annotation_suffix
== NULL
)
1133 annotation_suffix
= "";
1135 if (from_tty
&& annotation_level
> 1)
1140 = (char *) alloca ((prompt
== NULL
? 0 : strlen (prompt
))
1141 + strlen (annotation_suffix
) + 40);
1143 local_prompt
[0] = '\0';
1145 strcpy (local_prompt
, prompt
);
1146 strcat (local_prompt
, "\n\032\032");
1147 strcat (local_prompt
, annotation_suffix
);
1148 strcat (local_prompt
, "\n");
1150 prompt
= local_prompt
;
1153 if (!cmd_line_buffer_initialized
)
1155 buffer_init (&cmd_line_buffer
);
1156 cmd_line_buffer_initialized
= 1;
1159 /* Starting a new command line. */
1160 cmd_line_buffer
.used_size
= 0;
1164 signal (STOP_SIGNAL
, handle_stop_sig
);
1171 /* Make sure that all output has been output. Some machines may
1172 let you get away with leaving out some of the gdb_flush, but
1175 gdb_flush (gdb_stdout
);
1176 gdb_flush (gdb_stderr
);
1178 if (source_file_name
!= NULL
)
1179 ++source_line_number
;
1181 if (from_tty
&& annotation_level
> 1)
1183 puts_unfiltered ("\n\032\032pre-");
1184 puts_unfiltered (annotation_suffix
);
1185 puts_unfiltered ("\n");
1188 /* Don't use fancy stuff if not talking to stdin. */
1189 if (deprecated_readline_hook
1191 && input_interactive_p (current_ui
))
1193 rl
= (*deprecated_readline_hook
) (prompt
);
1195 else if (command_editing_p
1197 && input_interactive_p (current_ui
))
1199 rl
= gdb_readline_wrapper (prompt
);
1203 rl
= gdb_readline_no_editing (prompt
);
1206 cmd
= handle_line_of_input (&cmd_line_buffer
, rl
,
1207 repeat
, annotation_suffix
);
1208 if (cmd
== (char *) EOF
)
1221 signal (STOP_SIGNAL
, SIG_DFL
);
1227 /* Print the GDB banner. */
1229 print_gdb_version (struct ui_file
*stream
)
1231 /* From GNU coding standards, first line is meant to be easy for a
1232 program to parse, and is just canonical program name and version
1233 number, which starts after last space. */
1235 fprintf_filtered (stream
, "GNU gdb %s%s\n", PKGVERSION
, version
);
1237 /* Second line is a copyright notice. */
1239 fprintf_filtered (stream
,
1240 "Copyright (C) 2016 Free Software Foundation, Inc.\n");
1242 /* Following the copyright is a brief statement that the program is
1243 free software, that users are free to copy and change it on
1244 certain conditions, that it is covered by the GNU GPL, and that
1245 there is no warranty. */
1247 fprintf_filtered (stream
, "\
1248 License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>\
1249 \nThis is free software: you are free to change and redistribute it.\n\
1250 There is NO WARRANTY, to the extent permitted by law. Type \"show copying\"\n\
1251 and \"show warranty\" for details.\n");
1253 /* After the required info we print the configuration information. */
1255 fprintf_filtered (stream
, "This GDB was configured as \"");
1256 if (strcmp (host_name
, target_name
) != 0)
1258 fprintf_filtered (stream
, "--host=%s --target=%s",
1259 host_name
, target_name
);
1263 fprintf_filtered (stream
, "%s", host_name
);
1265 fprintf_filtered (stream
, "\".\n\
1266 Type \"show configuration\" for configuration details.");
1268 if (REPORT_BUGS_TO
[0])
1270 fprintf_filtered (stream
,
1271 _("\nFor bug reporting instructions, please see:\n"));
1272 fprintf_filtered (stream
, "%s.\n", REPORT_BUGS_TO
);
1274 fprintf_filtered (stream
,
1275 _("Find the GDB manual and other documentation \
1276 resources online at:\n<http://www.gnu.org/software/gdb/documentation/>.\n"));
1277 fprintf_filtered (stream
, _("For help, type \"help\".\n"));
1278 fprintf_filtered (stream
, _("Type \"apropos word\" to search for \
1279 commands related to \"word\"."));
1282 /* Print the details of GDB build-time configuration. */
1284 print_gdb_configuration (struct ui_file
*stream
)
1286 fprintf_filtered (stream
, _("\
1287 This GDB was configured as follows:\n\
1288 configure --host=%s --target=%s\n\
1289 "), host_name
, target_name
);
1290 fprintf_filtered (stream
, _("\
1291 --with-auto-load-dir=%s\n\
1292 --with-auto-load-safe-path=%s\n\
1293 "), AUTO_LOAD_DIR
, AUTO_LOAD_SAFE_PATH
);
1295 fprintf_filtered (stream
, _("\
1299 fprintf_filtered (stream
, _("\
1304 fprintf_filtered (stream
, _("\
1305 --with-gdb-datadir=%s%s\n\
1306 "), GDB_DATADIR
, GDB_DATADIR_RELOCATABLE
? " (relocatable)" : "");
1308 fprintf_filtered (stream
, _("\
1309 --with-iconv-bin=%s%s\n\
1310 "), ICONV_BIN
, ICONV_BIN_RELOCATABLE
? " (relocatable)" : "");
1312 if (JIT_READER_DIR
[0])
1313 fprintf_filtered (stream
, _("\
1314 --with-jit-reader-dir=%s%s\n\
1315 "), JIT_READER_DIR
, JIT_READER_DIR_RELOCATABLE
? " (relocatable)" : "");
1316 #if HAVE_LIBUNWIND_IA64_H
1317 fprintf_filtered (stream
, _("\
1318 --with-libunwind-ia64\n\
1321 fprintf_filtered (stream
, _("\
1322 --without-libunwind-ia64\n\
1326 fprintf_filtered (stream
, _("\
1330 fprintf_filtered (stream
, _("\
1334 #ifdef WITH_PYTHON_PATH
1335 fprintf_filtered (stream
, _("\
1336 --with-python=%s%s\n\
1337 "), WITH_PYTHON_PATH
, PYTHON_PATH_RELOCATABLE
? " (relocatable)" : "");
1340 fprintf_filtered (stream
, _("\
1344 fprintf_filtered (stream
, _("\
1349 fprintf_filtered (stream
, _("\
1350 --with-relocated-sources=%s\n\
1354 fprintf_filtered (stream
, _("\
1355 --with-separate-debug-dir=%s%s\n\
1356 "), DEBUGDIR
, DEBUGDIR_RELOCATABLE
? " (relocatable)" : "");
1357 if (TARGET_SYSTEM_ROOT
[0])
1358 fprintf_filtered (stream
, _("\
1359 --with-sysroot=%s%s\n\
1360 "), TARGET_SYSTEM_ROOT
, TARGET_SYSTEM_ROOT_RELOCATABLE
? " (relocatable)" : "");
1361 if (SYSTEM_GDBINIT
[0])
1362 fprintf_filtered (stream
, _("\
1363 --with-system-gdbinit=%s%s\n\
1364 "), SYSTEM_GDBINIT
, SYSTEM_GDBINIT_RELOCATABLE
? " (relocatable)" : "");
1365 #if HAVE_LIBBABELTRACE
1366 fprintf_filtered (stream
, _("\
1367 --with-babeltrace\n\
1370 fprintf_filtered (stream
, _("\
1371 --without-babeltrace\n\
1374 /* We assume "relocatable" will be printed at least once, thus we always
1375 print this text. It's a reasonably safe assumption for now. */
1376 fprintf_filtered (stream
, _("\n\
1377 (\"Relocatable\" means the directory can be moved with the GDB installation\n\
1378 tree, and GDB will still find it.)\n\
1383 /* The current top level prompt, settable with "set prompt", and/or
1384 with the python `gdb.prompt_hook' hook. */
1385 static char *top_prompt
;
1387 /* Access method for the GDB prompt string. */
1395 /* Set method for the GDB prompt string. */
1398 set_prompt (const char *s
)
1400 char *p
= xstrdup (s
);
1413 /* Callback for iterate_over_inferiors. Kills or detaches the given
1414 inferior, depending on how we originally gained control of it. */
1417 kill_or_detach (struct inferior
*inf
, void *args
)
1419 struct qt_args
*qt
= (struct qt_args
*) args
;
1420 struct thread_info
*thread
;
1425 thread
= any_thread_of_process (inf
->pid
);
1428 switch_to_thread (thread
->ptid
);
1430 /* Leave core files alone. */
1431 if (target_has_execution
)
1433 if (inf
->attach_flag
)
1434 target_detach (qt
->args
, qt
->from_tty
);
1443 /* Callback for iterate_over_inferiors. Prints info about what GDB
1444 will do to each inferior on a "quit". ARG points to a struct
1445 ui_out where output is to be collected. */
1448 print_inferior_quit_action (struct inferior
*inf
, void *arg
)
1450 struct ui_file
*stb
= (struct ui_file
*) arg
;
1455 if (inf
->attach_flag
)
1456 fprintf_filtered (stb
,
1457 _("\tInferior %d [%s] will be detached.\n"), inf
->num
,
1458 target_pid_to_str (pid_to_ptid (inf
->pid
)));
1460 fprintf_filtered (stb
,
1461 _("\tInferior %d [%s] will be killed.\n"), inf
->num
,
1462 target_pid_to_str (pid_to_ptid (inf
->pid
)));
1467 /* If necessary, make the user confirm that we should quit. Return
1468 non-zero if we should quit, zero if we shouldn't. */
1473 struct ui_file
*stb
;
1474 struct cleanup
*old_chain
;
1478 /* Don't even ask if we're only debugging a core file inferior. */
1479 if (!have_live_inferiors ())
1482 /* Build the query string as a single string. */
1483 stb
= mem_fileopen ();
1484 old_chain
= make_cleanup_ui_file_delete (stb
);
1486 fprintf_filtered (stb
, _("A debugging session is active.\n\n"));
1487 iterate_over_inferiors (print_inferior_quit_action
, stb
);
1488 fprintf_filtered (stb
, _("\nQuit anyway? "));
1490 str
= ui_file_xstrdup (stb
, NULL
);
1491 make_cleanup (xfree
, str
);
1493 qr
= query ("%s", str
);
1494 do_cleanups (old_chain
);
1498 /* Prepare to exit GDB cleanly by undoing any changes made to the
1499 terminal so that we leave the terminal in the state we acquired it. */
1502 undo_terminal_modifications_before_exit (void)
1504 struct ui
*saved_top_level
= current_ui
;
1506 target_terminal_ours ();
1508 current_ui
= main_ui
;
1513 gdb_disable_readline ();
1515 current_ui
= saved_top_level
;
1519 /* Quit without asking for confirmation. */
1522 quit_force (char *args
, int from_tty
)
1527 undo_terminal_modifications_before_exit ();
1529 /* An optional expression may be used to cause gdb to terminate with the
1530 value of that expression. */
1533 struct value
*val
= parse_and_eval (args
);
1535 exit_code
= (int) value_as_long (val
);
1537 else if (return_child_result
)
1538 exit_code
= return_child_result_value
;
1541 qt
.from_tty
= from_tty
;
1543 /* We want to handle any quit errors and exit regardless. */
1545 /* Get out of tfind mode, and kill or detach all inferiors. */
1548 disconnect_tracing ();
1549 iterate_over_inferiors (kill_or_detach
, &qt
);
1551 CATCH (ex
, RETURN_MASK_ALL
)
1553 exception_print (gdb_stderr
, ex
);
1557 /* Give all pushed targets a chance to do minimal cleanup, and pop
1563 CATCH (ex
, RETURN_MASK_ALL
)
1565 exception_print (gdb_stderr
, ex
);
1569 /* Save the history information if it is appropriate to do so. */
1572 if (write_history_p
&& history_filename
)
1577 /* History is currently shared between all UIs. If there's
1578 any UI with a terminal, save history. */
1581 if (input_interactive_p (ui
))
1589 gdb_safe_append_history ();
1592 CATCH (ex
, RETURN_MASK_ALL
)
1594 exception_print (gdb_stderr
, ex
);
1598 /* Do any final cleanups before exiting. */
1601 do_final_cleanups (all_cleanups ());
1603 CATCH (ex
, RETURN_MASK_ALL
)
1605 exception_print (gdb_stderr
, ex
);
1612 /* The value of the "interactive-mode" setting. */
1613 static enum auto_boolean interactive_mode
= AUTO_BOOLEAN_AUTO
;
1615 /* Implement the "show interactive-mode" option. */
1618 show_interactive_mode (struct ui_file
*file
, int from_tty
,
1619 struct cmd_list_element
*c
,
1622 if (interactive_mode
== AUTO_BOOLEAN_AUTO
)
1623 fprintf_filtered (file
, "Debugger's interactive mode "
1624 "is %s (currently %s).\n",
1625 value
, gdb_has_a_terminal () ? "on" : "off");
1627 fprintf_filtered (file
, "Debugger's interactive mode is %s.\n", value
);
1630 /* Returns whether GDB is running on an interactive terminal. */
1633 input_interactive_p (struct ui
*ui
)
1638 if (interactive_mode
!= AUTO_BOOLEAN_AUTO
)
1639 return interactive_mode
== AUTO_BOOLEAN_TRUE
;
1641 return ui
->input_interactive_p
;
1645 dont_repeat_command (char *ignored
, int from_tty
)
1647 /* Can't call dont_repeat here because we're not necessarily reading
1649 *saved_command_line
= 0;
1652 /* Functions to manipulate command line editing control variables. */
1654 /* Number of commands to print in each call to show_commands. */
1655 #define Hist_print 10
1657 show_commands (char *args
, int from_tty
)
1659 /* Index for history commands. Relative to history_base. */
1662 /* Number of the history entry which we are planning to display next.
1663 Relative to history_base. */
1666 /* Print out some of the commands from the command history. */
1670 if (args
[0] == '+' && args
[1] == '\0')
1671 /* "info editing +" should print from the stored position. */
1674 /* "info editing <exp>" should print around command number <exp>. */
1675 num
= (parse_and_eval_long (args
) - history_base
) - Hist_print
/ 2;
1677 /* "show commands" means print the last Hist_print commands. */
1680 num
= history_length
- Hist_print
;
1686 /* If there are at least Hist_print commands, we want to display the last
1687 Hist_print rather than, say, the last 6. */
1688 if (history_length
- num
< Hist_print
)
1690 num
= history_length
- Hist_print
;
1696 offset
< num
+ Hist_print
&& offset
< history_length
;
1699 printf_filtered ("%5d %s\n", history_base
+ offset
,
1700 (history_get (history_base
+ offset
))->line
);
1703 /* The next command we want to display is the next one that we haven't
1707 /* If the user repeats this command with return, it should do what
1708 "show commands +" does. This is unnecessary if arg is null,
1709 because "show commands +" is not useful after "show commands". */
1710 if (from_tty
&& args
)
1717 /* Update the size of our command history file to HISTORY_SIZE.
1719 A HISTORY_SIZE of -1 stands for unlimited. */
1722 set_readline_history_size (int history_size
)
1724 gdb_assert (history_size
>= -1);
1726 if (history_size
== -1)
1727 unstifle_history ();
1729 stifle_history (history_size
);
1732 /* Called by do_setshow_command. */
1734 set_history_size_command (char *args
, int from_tty
, struct cmd_list_element
*c
)
1736 set_readline_history_size (history_size_setshow_var
);
1740 set_history (char *args
, int from_tty
)
1742 printf_unfiltered (_("\"set history\" must be followed "
1743 "by the name of a history subcommand.\n"));
1744 help_list (sethistlist
, "set history ", all_commands
, gdb_stdout
);
1748 show_history (char *args
, int from_tty
)
1750 cmd_show_list (showhistlist
, from_tty
, "");
1753 int info_verbose
= 0; /* Default verbose msgs off. */
1755 /* Called by do_setshow_command. An elaborate joke. */
1757 set_verbose (char *args
, int from_tty
, struct cmd_list_element
*c
)
1759 const char *cmdname
= "verbose";
1760 struct cmd_list_element
*showcmd
;
1762 showcmd
= lookup_cmd_1 (&cmdname
, showlist
, NULL
, 1);
1763 gdb_assert (showcmd
!= NULL
&& showcmd
!= CMD_LIST_AMBIGUOUS
);
1767 c
->doc
= "Set verbose printing of informational messages.";
1768 showcmd
->doc
= "Show verbose printing of informational messages.";
1772 c
->doc
= "Set verbosity.";
1773 showcmd
->doc
= "Show verbosity.";
1777 /* Init the history buffer. Note that we are called after the init file(s)
1778 have been read so that the user can change the history file via his
1779 .gdbinit file (for instance). The GDBHISTFILE environment variable
1780 overrides all of this. */
1787 tmpenv
= getenv ("GDBHISTSIZE");
1794 tmpenv
= skip_spaces (tmpenv
);
1796 var
= strtol (tmpenv
, &endptr
, 10);
1797 saved_errno
= errno
;
1798 endptr
= skip_spaces (endptr
);
1800 /* If GDBHISTSIZE is non-numeric then ignore it. If GDBHISTSIZE is the
1801 empty string, a negative number or a huge positive number (larger than
1802 INT_MAX) then set the history size to unlimited. Otherwise set our
1803 history size to the number we have read. This behavior is consistent
1804 with how bash handles HISTSIZE. */
1805 if (*endptr
!= '\0')
1807 else if (*tmpenv
== '\0'
1810 /* On targets where INT_MAX == LONG_MAX, we have to look at
1811 errno after calling strtol to distinguish between a value that
1812 is exactly INT_MAX and an overflowing value that was clamped
1814 || (var
== INT_MAX
&& saved_errno
== ERANGE
))
1815 history_size_setshow_var
= -1;
1817 history_size_setshow_var
= var
;
1820 /* If neither the init file nor GDBHISTSIZE has set a size yet, pick the
1822 if (history_size_setshow_var
== -2)
1823 history_size_setshow_var
= 256;
1825 set_readline_history_size (history_size_setshow_var
);
1827 tmpenv
= getenv ("GDBHISTFILE");
1829 history_filename
= xstrdup (tmpenv
);
1830 else if (!history_filename
)
1832 /* We include the current directory so that if the user changes
1833 directories the file written will be the same as the one
1836 /* No leading dots in file names are allowed on MSDOS. */
1837 history_filename
= concat (current_directory
, "/_gdb_history",
1840 history_filename
= concat (current_directory
, "/.gdb_history",
1844 read_history (history_filename
);
1848 show_prompt (struct ui_file
*file
, int from_tty
,
1849 struct cmd_list_element
*c
, const char *value
)
1851 fprintf_filtered (file
, _("Gdb's prompt is \"%s\".\n"), value
);
1854 /* "set editing" command. */
1857 set_editing (char *args
, int from_tty
, struct cmd_list_element
*c
)
1859 change_line_handler (set_editing_cmd_var
);
1860 /* Update the control variable so that MI's =cmd-param-changed event
1861 shows the correct value. */
1862 set_editing_cmd_var
= current_ui
->command_editing
;
1866 show_editing (struct ui_file
*file
, int from_tty
,
1867 struct cmd_list_element
*c
, const char *value
)
1869 fprintf_filtered (file
, _("Editing of command lines as "
1870 "they are typed is %s.\n"),
1871 current_ui
->command_editing
? _("on") : _("off"));
1875 show_annotation_level (struct ui_file
*file
, int from_tty
,
1876 struct cmd_list_element
*c
, const char *value
)
1878 fprintf_filtered (file
, _("Annotation_level is %s.\n"), value
);
1882 show_exec_done_display_p (struct ui_file
*file
, int from_tty
,
1883 struct cmd_list_element
*c
, const char *value
)
1885 fprintf_filtered (file
, _("Notification of completion for "
1886 "asynchronous execution commands is %s.\n"),
1890 /* New values of the "data-directory" parameter are staged here. */
1891 static char *staged_gdb_datadir
;
1893 /* "set" command for the gdb_datadir configuration variable. */
1896 set_gdb_datadir (char *args
, int from_tty
, struct cmd_list_element
*c
)
1898 set_gdb_data_directory (staged_gdb_datadir
);
1899 observer_notify_gdb_datadir_changed ();
1902 /* "show" command for the gdb_datadir configuration variable. */
1905 show_gdb_datadir (struct ui_file
*file
, int from_tty
,
1906 struct cmd_list_element
*c
, const char *value
)
1908 fprintf_filtered (file
, _("GDB's data directory is \"%s\".\n"),
1913 set_history_filename (char *args
, int from_tty
, struct cmd_list_element
*c
)
1915 /* We include the current directory so that if the user changes
1916 directories the file written will be the same as the one
1918 if (!IS_ABSOLUTE_PATH (history_filename
))
1919 history_filename
= reconcat (history_filename
, current_directory
, "/",
1920 history_filename
, (char *) NULL
);
1926 /* Initialize the prompt to a simple "(gdb) " prompt or to whatever
1927 the DEFAULT_PROMPT is. */
1928 set_prompt (DEFAULT_PROMPT
);
1930 /* Set the important stuff up for command editing. */
1931 command_editing_p
= 1;
1932 history_expansion_p
= 0;
1933 write_history_p
= 0;
1935 /* Setup important stuff for command line editing. */
1936 rl_completion_word_break_hook
= gdb_completion_word_break_characters
;
1937 rl_completion_entry_function
= readline_line_completion_function
;
1938 rl_completer_word_break_characters
= default_word_break_characters ();
1939 rl_completer_quote_characters
= get_gdb_completer_quote_characters ();
1940 rl_completion_display_matches_hook
= cli_display_match_list
;
1941 rl_readline_name
= "gdb";
1942 rl_terminal_name
= getenv ("TERM");
1944 /* The name for this defun comes from Bash, where it originated.
1945 15 is Control-o, the same binding this function has in Bash. */
1946 rl_add_defun ("operate-and-get-next", gdb_rl_operate_and_get_next
, 15);
1948 add_setshow_string_cmd ("prompt", class_support
,
1950 _("Set gdb's prompt"),
1951 _("Show gdb's prompt"),
1954 &setlist
, &showlist
);
1956 add_com ("dont-repeat", class_support
, dont_repeat_command
, _("\
1957 Don't repeat this command.\nPrimarily \
1958 used inside of user-defined commands that should not be repeated when\n\
1961 add_setshow_boolean_cmd ("editing", class_support
,
1962 &set_editing_cmd_var
, _("\
1963 Set editing of command lines as they are typed."), _("\
1964 Show editing of command lines as they are typed."), _("\
1965 Use \"on\" to enable the editing, and \"off\" to disable it.\n\
1966 Without an argument, command line editing is enabled. To edit, use\n\
1967 EMACS-like or VI-like commands like control-P or ESC."),
1970 &setlist
, &showlist
);
1972 add_setshow_boolean_cmd ("save", no_class
, &write_history_p
, _("\
1973 Set saving of the history record on exit."), _("\
1974 Show saving of the history record on exit."), _("\
1975 Use \"on\" to enable the saving, and \"off\" to disable it.\n\
1976 Without an argument, saving is enabled."),
1978 show_write_history_p
,
1979 &sethistlist
, &showhistlist
);
1981 add_setshow_zuinteger_unlimited_cmd ("size", no_class
,
1982 &history_size_setshow_var
, _("\
1983 Set the size of the command history,"), _("\
1984 Show the size of the command history,"), _("\
1985 ie. the number of previous commands to keep a record of.\n\
1986 If set to \"unlimited\", the number of commands kept in the history\n\
1987 list is unlimited. This defaults to the value of the environment\n\
1988 variable \"GDBHISTSIZE\", or to 256 if this variable is not set."),
1989 set_history_size_command
,
1991 &sethistlist
, &showhistlist
);
1993 add_setshow_zuinteger_unlimited_cmd ("remove-duplicates", no_class
,
1994 &history_remove_duplicates
, _("\
1995 Set how far back in history to look for and remove duplicate entries."), _("\
1996 Show how far back in history to look for and remove duplicate entries."), _("\
1997 If set to a nonzero value N, GDB will look back at the last N history entries\n\
1998 and remove the first history entry that is a duplicate of the most recent\n\
1999 entry, each time a new history entry is added.\n\
2000 If set to \"unlimited\", this lookbehind is unbounded.\n\
2001 Only history entries added during this session are considered for removal.\n\
2002 If set to 0, removal of duplicate history entries is disabled.\n\
2003 By default this option is set to 0."),
2005 show_history_remove_duplicates
,
2006 &sethistlist
, &showhistlist
);
2008 add_setshow_filename_cmd ("filename", no_class
, &history_filename
, _("\
2009 Set the filename in which to record the command history"), _("\
2010 Show the filename in which to record the command history"), _("\
2011 (the list of previous commands of which a record is kept)."),
2012 set_history_filename
,
2013 show_history_filename
,
2014 &sethistlist
, &showhistlist
);
2016 add_setshow_boolean_cmd ("confirm", class_support
, &confirm
, _("\
2017 Set whether to confirm potentially dangerous operations."), _("\
2018 Show whether to confirm potentially dangerous operations."), NULL
,
2021 &setlist
, &showlist
);
2023 add_setshow_zinteger_cmd ("annotate", class_obscure
, &annotation_level
, _("\
2024 Set annotation_level."), _("\
2025 Show annotation_level."), _("\
2026 0 == normal; 1 == fullname (for use when running under emacs)\n\
2027 2 == output annotated suitably for use by programs that control GDB."),
2029 show_annotation_level
,
2030 &setlist
, &showlist
);
2032 add_setshow_boolean_cmd ("exec-done-display", class_support
,
2033 &exec_done_display_p
, _("\
2034 Set notification of completion for asynchronous execution commands."), _("\
2035 Show notification of completion for asynchronous execution commands."), _("\
2036 Use \"on\" to enable the notification, and \"off\" to disable it."),
2038 show_exec_done_display_p
,
2039 &setlist
, &showlist
);
2041 add_setshow_filename_cmd ("data-directory", class_maintenance
,
2042 &staged_gdb_datadir
, _("Set GDB's data directory."),
2043 _("Show GDB's data directory."),
2045 When set, GDB uses the specified path to search for data files."),
2046 set_gdb_datadir
, show_gdb_datadir
,
2050 add_setshow_auto_boolean_cmd ("interactive-mode", class_support
,
2051 &interactive_mode
, _("\
2052 Set whether GDB's standard input is a terminal."), _("\
2053 Show whether GDB's standard input is a terminal."), _("\
2054 If on, GDB assumes that standard input is a terminal. In practice, it\n\
2055 means that GDB should wait for the user to answer queries associated to\n\
2056 commands entered at the command prompt. If off, GDB assumes that standard\n\
2057 input is not a terminal, and uses the default answer to all queries.\n\
2058 If auto (the default), determine which mode to use based on the standard\n\
2061 show_interactive_mode
,
2062 &setlist
, &showlist
);
2066 gdb_init (char *argv0
)
2068 if (pre_init_ui_hook
)
2069 pre_init_ui_hook ();
2071 /* Run the init function of each source file. */
2074 /* Make sure we return to the original directory upon exit, come
2075 what may, since the OS doesn't do that for us. */
2076 make_final_cleanup (do_chdir_cleanup
, xstrdup (current_directory
));
2079 init_cmd_lists (); /* This needs to be done first. */
2080 initialize_targets (); /* Setup target_terminal macros for utils.c. */
2081 initialize_utils (); /* Make errors and warnings possible. */
2085 /* Here is where we call all the _initialize_foo routines. */
2086 initialize_all_files ();
2088 /* This creates the current_program_space. Do this after all the
2089 _initialize_foo routines have had a chance to install their
2090 per-sspace data keys. Also do this before
2091 initialize_current_architecture is called, because it accesses
2092 exec_bfd of the current program space. */
2093 initialize_progspace ();
2094 initialize_inferiors ();
2095 initialize_current_architecture ();
2097 init_main (); /* But that omits this file! Do it now. */
2099 initialize_stdin_serial ();
2101 /* Take a snapshot of our tty state before readline/ncurses have had a chance
2103 set_initial_gdb_ttystate ();
2105 async_init_signals ();
2107 /* We need a default language for parsing expressions, so simple
2108 things like "set width 0" won't fail if no language is explicitly
2109 set in a config file or implicitly set by reading an executable
2111 set_language (language_c
);
2112 expected_language
= current_language
; /* Don't warn about the change. */
2114 /* Python initialization, for example, can require various commands to be
2115 installed. For example "info pretty-printer" needs the "info"
2116 prefix to be installed. Keep things simple and just do final
2117 script initialization here. */
2118 finish_ext_lang_initialization ();