1 /* Top level stuff for GDB, the GNU debugger.
3 Copyright (C) 1986-2023 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"
38 #include "gdbsupport/job-control.h"
40 #include "completer.h"
43 #include "gdbsupport/version.h"
46 #include "gdbsupport/event-loop.h"
47 #include "gdbthread.h"
48 #include "extension.h"
50 #include "observable.h"
52 #include "filenames.h"
54 #include "gdbsupport/gdb_select.h"
55 #include "gdbsupport/scope-exit.h"
57 #include "gdbsupport/pathstuff.h"
58 #include "cli/cli-style.h"
61 /* readline include files. */
62 #include "readline/readline.h"
63 #include "readline/history.h"
65 /* readline defines this. */
68 #include <sys/types.h>
70 #include "event-top.h"
75 #include "tracepoint.h"
86 extern void initialize_all_files (void);
88 #define PROMPT(X) the_prompts.prompt_stack[the_prompts.top + X].prompt
89 #define PREFIX(X) the_prompts.prompt_stack[the_prompts.top + X].prefix
90 #define SUFFIX(X) the_prompts.prompt_stack[the_prompts.top + X].suffix
92 /* Default command line prompt. This is overridden in some configs. */
94 #ifndef DEFAULT_PROMPT
95 #define DEFAULT_PROMPT "(gdb) "
99 current_ui_gdb_stdout_ptr ()
101 return ¤t_ui
->m_gdb_stdout
;
105 current_ui_gdb_stdin_ptr ()
107 return ¤t_ui
->m_gdb_stdin
;
111 current_ui_gdb_stderr_ptr ()
113 return ¤t_ui
->m_gdb_stderr
;
117 current_ui_gdb_stdlog_ptr ()
119 return ¤t_ui
->m_gdb_stdlog
;
123 current_ui_current_uiout_ptr ()
125 return ¤t_ui
->m_current_uiout
;
128 int inhibit_gdbinit
= 0;
130 /* Flag for whether we want to confirm potentially dangerous
131 operations. Default is yes. */
136 show_confirm (struct ui_file
*file
, int from_tty
,
137 struct cmd_list_element
*c
, const char *value
)
139 gdb_printf (file
, _("Whether to confirm potentially "
140 "dangerous operations is %s.\n"),
144 /* The last command line executed on the console. Used for command
145 repetitions when the user enters an empty line. */
147 static char *saved_command_line
;
149 /* If not NULL, the arguments that should be passed if
150 saved_command_line is repeated. */
152 static const char *repeat_arguments
;
154 /* The previous last command line executed on the console. Used for command
155 repetitions when a command wants to relaunch the previously launched
156 command. We need this as when a command is running, saved_command_line
157 already contains the line of the currently executing command. */
159 static char *previous_saved_command_line
;
161 /* If not NULL, the arguments that should be passed if the
162 previous_saved_command_line is repeated. */
164 static const char *previous_repeat_arguments
;
166 /* Nonzero if the current command is modified by "server ". This
167 affects things like recording into the command history, commands
168 repeating on RETURN, etc. This is so a user interface (emacs, GUI,
169 whatever) can issue its own commands and also send along commands
170 from the user, and have the user not notice that the user interface
171 is issuing commands too. */
174 /* Timeout limit for response from target. */
176 /* The default value has been changed many times over the years. It
177 was originally 5 seconds. But that was thought to be a long time
178 to sit and wait, so it was changed to 2 seconds. That was thought
179 to be plenty unless the connection was going through some terminal
180 server or multiplexer or other form of hairy serial connection.
182 In mid-1996, remote_timeout was moved from remote.c to top.c and
183 it began being used in other remote-* targets. It appears that the
184 default was changed to 20 seconds at that time, perhaps because the
185 Renesas E7000 ICE didn't always respond in a timely manner.
187 But if 5 seconds is a long time to sit and wait for retransmissions,
188 20 seconds is far worse. This demonstrates the difficulty of using
189 a single variable for all protocol timeouts.
191 As remote.c is used much more than remote-e7000.c, it was changed
192 back to 2 seconds in 1999. */
194 int remote_timeout
= 2;
196 /* Sbrk location on entry to main. Used for statistics only. */
197 #ifdef HAVE_USEFUL_SBRK
201 /* Hooks for alternate command interfaces. */
203 /* This hook is called from within gdb's many mini-event loops which
204 could steal control from a real user interface's event loop. It
205 returns non-zero if the user is requesting a detach, zero
208 int (*deprecated_ui_loop_hook
) (int);
211 /* Called from print_frame_info to list the line we stopped in. */
213 void (*deprecated_print_frame_info_listing_hook
) (struct symtab
* s
,
217 /* Replaces most of query. */
219 int (*deprecated_query_hook
) (const char *, va_list);
221 /* Replaces most of warning. */
223 void (*deprecated_warning_hook
) (const char *, va_list);
225 /* These three functions support getting lines of text from the user.
226 They are used in sequence. First deprecated_readline_begin_hook is
227 called with a text string that might be (for example) a message for
228 the user to type in a sequence of commands to be executed at a
229 breakpoint. If this function calls back to a GUI, it might take
230 this opportunity to pop up a text interaction window with this
231 message. Next, deprecated_readline_hook is called with a prompt
232 that is emitted prior to collecting the user input. It can be
233 called multiple times. Finally, deprecated_readline_end_hook is
234 called to notify the GUI that we are done with the interaction
235 window and it can close it. */
237 void (*deprecated_readline_begin_hook
) (const char *, ...);
238 char *(*deprecated_readline_hook
) (const char *);
239 void (*deprecated_readline_end_hook
) (void);
241 /* Called as appropriate to notify the interface that we have attached
242 to or detached from an already running process. */
244 void (*deprecated_attach_hook
) (void);
245 void (*deprecated_detach_hook
) (void);
247 /* Used by UI as a wrapper around command execution. May do various
248 things like enabling/disabling buttons, etc... */
250 void (*deprecated_call_command_hook
) (struct cmd_list_element
* c
,
251 const char *cmd
, int from_tty
);
253 /* Called when the current thread changes. Argument is thread id. */
255 void (*deprecated_context_hook
) (int id
);
260 unbuffer_stream (FILE *stream
)
262 /* Unbuffer the input stream so that in gdb_readline_no_editing_callback,
263 the calls to fgetc fetch only one char at the time from STREAM.
265 This is important because gdb_readline_no_editing_callback will read
266 from STREAM up to the first '\n' character, after this GDB returns to
267 the event loop and relies on a select on STREAM indicating that more
270 If STREAM is buffered then the fgetc calls may have moved all the
271 pending input from the kernel into a local buffer, after which the
272 select will not indicate that more input is pending, and input after
273 the first '\n' will not be processed immediately.
275 Please ensure that any changes in this area run the MI tests with the
276 FORCE_SEPARATE_MI_TTY=1 flag being passed. */
279 /* With MS-Windows runtime, making stdin unbuffered when it's
280 connected to the terminal causes it to misbehave. */
281 if (!ISATTY (stream
))
282 setbuf (stream
, nullptr);
284 /* On GNU/Linux the issues described above can impact GDB even when
285 dealing with input from a terminal. For now we unbuffer the input
286 stream for everyone except MS-Windows. */
287 setbuf (stream
, nullptr);
291 /* Handler for SIGHUP. */
294 /* NOTE 1999-04-29: This function will be static again, once we modify
295 gdb to use the event loop as the default command loop and we merge
296 event-top.c into this file, top.c. */
300 /* Stop asking user for confirmation --- we're exiting. This
301 prevents asking the user dumb questions. */
303 quit_command ((char *) 0, 0);
305 #endif /* defined SIGHUP */
307 /* Line number we are currently in, in a file which is being sourced. */
308 /* NOTE 1999-04-29: This variable will be static again, once we modify
309 gdb to use the event loop as the default command loop and we merge
310 event-top.c into this file, top.c. */
311 /* static */ int source_line_number
;
313 /* Name of the file we are sourcing. */
314 /* NOTE 1999-04-29: This variable will be static again, once we modify
315 gdb to use the event loop as the default command loop and we merge
316 event-top.c into this file, top.c. */
317 /* static */ std::string source_file_name
;
319 /* Read commands from STREAM. */
321 read_command_file (FILE *stream
)
323 struct ui
*ui
= current_ui
;
325 unbuffer_stream (stream
);
327 scoped_restore save_instream
328 = make_scoped_restore (&ui
->instream
, stream
);
330 /* Read commands from `instream' and execute them until end of file
331 or error reading instream. */
333 while (ui
->instream
!= NULL
&& !feof (ui
->instream
))
335 /* Get a command-line. This calls the readline package. */
336 std::string command_buffer
;
338 = command_line_input (command_buffer
, nullptr, nullptr);
339 if (command
== nullptr)
341 command_handler (command
);
347 do_chdir_cleanup (void *old_dir
)
349 chdir ((const char *) old_dir
);
355 prepare_execute_command ()
357 /* With multiple threads running while the one we're examining is
358 stopped, the dcache can get stale without us being able to detect
359 it. For the duration of the command, though, use the dcache to
360 help things like backtrace. */
362 target_dcache_invalidate ();
364 return scoped_value_mark ();
367 /* Tell the user if the language has changed (except first time) after
368 executing a command. */
371 check_frame_language_change (void)
373 static int warned
= 0;
374 frame_info_ptr frame
;
376 /* First make sure that a new frame has been selected, in case the
377 command or the hooks changed the program state. */
378 frame
= deprecated_safe_get_selected_frame ();
379 if (current_language
!= expected_language
)
381 if (language_mode
== language_mode_auto
&& info_verbose
)
383 /* Print what changed. */
389 /* Warn the user if the working language does not match the language
390 of the current frame. Only warn the user if we are actually
391 running the program, i.e. there is a stack. */
392 /* FIXME: This should be cacheing the frame and only running when
393 the frame changes. */
395 if (has_stack_frames ())
399 flang
= get_frame_language (frame
);
401 && flang
!= language_unknown
402 && flang
!= current_language
->la_language
)
404 gdb_printf ("%s\n", _(lang_frame_mismatch_warn
));
413 wait_sync_command_done (void)
415 /* Processing events may change the current UI. */
416 scoped_restore save_ui
= make_scoped_restore (¤t_ui
);
417 struct ui
*ui
= current_ui
;
419 /* We're about to wait until the target stops after having resumed
420 it so must force-commit resumptions, in case we're being called
421 in some context where a scoped_disable_commit_resumed object is
422 active. I.e., this function is a commit-resumed sync/flush
424 scoped_enable_commit_resumed
enable ("sync wait");
426 while (gdb_do_one_event () >= 0)
427 if (ui
->prompt_state
!= PROMPT_BLOCKED
)
434 maybe_wait_sync_command_done (int was_sync
)
436 /* If the interpreter is in sync mode (we're running a user
437 command's list, running command hooks or similars), and we
438 just ran a synchronous command that started the target, wait
439 for that command to end. */
440 if (!current_ui
->async
442 && current_ui
->prompt_state
== PROMPT_BLOCKED
)
443 wait_sync_command_done ();
449 set_repeat_arguments (const char *args
)
451 repeat_arguments
= args
;
454 /* Execute the line P as a command, in the current user context.
455 Pass FROM_TTY as second argument to the defining function. */
458 execute_command (const char *p
, int from_tty
)
460 struct cmd_list_element
*c
;
462 const char *cmd_start
= p
;
464 auto cleanup_if_error
= make_scope_exit (bpstat_clear_actions
);
465 scoped_value_mark cleanup
= prepare_execute_command ();
467 /* This can happen when command_line_input hits end of file. */
470 cleanup_if_error
.release ();
474 std::string cmd_copy
= p
;
476 target_log_command (p
);
478 while (*p
== ' ' || *p
== '\t')
484 std::string default_args
;
485 std::string default_args_and_arg
;
486 int was_sync
= current_ui
->prompt_state
== PROMPT_BLOCKED
;
490 /* If trace-commands is set then this will print this command. */
491 print_command_trace ("%s", p
);
493 c
= lookup_cmd (&cmd
, cmdlist
, "", &default_args
, 0, 1);
496 scoped_restore save_repeat_args
497 = make_scoped_restore (&repeat_arguments
, nullptr);
498 const char *args_pointer
= p
;
500 if (!default_args
.empty ())
503 default_args_and_arg
= default_args
+ ' ' + p
;
505 default_args_and_arg
= default_args
;
506 arg
= default_args_and_arg
.c_str ();
510 /* Pass null arg rather than an empty one. */
511 arg
= *p
== '\0' ? nullptr : p
;
514 /* FIXME: cagney/2002-02-02: The c->type test is pretty dodgy
515 while the is_complete_command(cfunc) test is just plain
516 bogus. They should both be replaced by a test of the form
517 c->strip_trailing_white_space_p. */
518 /* NOTE: cagney/2002-02-02: The function.cfunc in the below
519 can't be replaced with func. This is because it is the
520 cfunc, and not the func, that has the value that the
521 is_complete_command hack is testing for. */
522 /* Clear off trailing whitespace, except for set and complete
524 std::string without_whitespace
;
526 && c
->type
!= set_cmd
527 && !is_complete_command (c
))
529 const char *old_end
= arg
+ strlen (arg
) - 1;
531 while (p
>= arg
&& (*p
== ' ' || *p
== '\t'))
535 without_whitespace
= std::string (arg
, p
+ 1);
536 arg
= without_whitespace
.c_str ();
540 /* If this command has been pre-hooked, run the hook first. */
541 execute_cmd_pre_hook (c
);
543 if (c
->deprecated_warn_user
)
544 deprecated_cmd_warning (line
, cmdlist
);
546 /* c->user_commands would be NULL in the case of a python command. */
547 if (c
->theclass
== class_user
&& c
->user_commands
)
548 execute_user_command (c
, arg
);
549 else if (c
->theclass
== class_user
550 && c
->is_prefix () && !c
->allow_unknown
)
551 /* If this is a user defined prefix that does not allow unknown
552 (in other words, C is a prefix command and not a command
553 that can be followed by its args), report the list of
556 std::string prefixname
= c
->prefixname ();
557 std::string prefixname_no_space
558 = prefixname
.substr (0, prefixname
.length () - 1);
560 ("\"%s\" must be followed by the name of a subcommand.\n",
561 prefixname_no_space
.c_str ());
562 help_list (*c
->subcommands
, prefixname
.c_str (), all_commands
,
565 else if (c
->type
== set_cmd
)
566 do_set_command (arg
, from_tty
, c
);
567 else if (c
->type
== show_cmd
)
568 do_show_command (arg
, from_tty
, c
);
569 else if (c
->is_command_class_help ())
570 error (_("That is not a command, just a help topic."));
571 else if (deprecated_call_command_hook
)
572 deprecated_call_command_hook (c
, arg
, from_tty
);
574 cmd_func (c
, arg
, from_tty
);
576 maybe_wait_sync_command_done (was_sync
);
578 /* If this command has been post-hooked, run the hook last.
579 We need to lookup the command again since during its execution,
580 a command may redefine itself. In this case, C pointer
581 becomes invalid so we need to look it up again. */
582 const char *cmd2
= cmd_copy
.c_str ();
583 c
= lookup_cmd (&cmd2
, cmdlist
, "", nullptr, 1, 1);
585 execute_cmd_post_hook (c
);
587 if (repeat_arguments
!= NULL
&& cmd_start
== saved_command_line
)
589 gdb_assert (strlen (args_pointer
) >= strlen (repeat_arguments
));
590 strcpy (saved_command_line
+ (args_pointer
- cmd_start
),
595 /* Only perform the frame-language-change check if the command
596 we just finished executing did not resume the inferior's execution.
597 If it did resume the inferior, we will do that check after
598 the inferior stopped. */
599 if (has_stack_frames () && inferior_thread ()->state
!= THREAD_RUNNING
)
600 check_frame_language_change ();
602 cleanup_if_error
.release ();
608 execute_fn_to_ui_file (struct ui_file
*file
, std::function
<void(void)> fn
)
610 /* GDB_STDOUT should be better already restored during these
611 restoration callbacks. */
612 set_batch_flag_and_restore_page_info save_page_info
;
614 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
617 ui_out_redirect_pop
redirect_popper (current_uiout
, file
);
619 scoped_restore save_stdout
620 = make_scoped_restore (&gdb_stdout
, file
);
621 scoped_restore save_stderr
622 = make_scoped_restore (&gdb_stderr
, file
);
623 scoped_restore save_stdlog
624 = make_scoped_restore (&gdb_stdlog
, file
);
625 scoped_restore save_stdtarg
626 = make_scoped_restore (&gdb_stdtarg
, file
);
627 scoped_restore save_stdtargerr
628 = make_scoped_restore (&gdb_stdtargerr
, file
);
637 execute_fn_to_string (std::string
&res
, std::function
<void(void)> fn
,
640 string_file
str_file (term_out
);
644 execute_fn_to_ui_file (&str_file
, fn
);
649 res
= std::move (str_file
.string ());
654 res
= std::move (str_file
.string ());
660 execute_command_to_ui_file (struct ui_file
*file
,
661 const char *p
, int from_tty
)
663 execute_fn_to_ui_file (file
, [=]() { execute_command (p
, from_tty
); });
669 execute_command_to_string (std::string
&res
, const char *p
, int from_tty
,
672 execute_fn_to_string (res
, [=]() { execute_command (p
, from_tty
); },
679 execute_command_to_string (const char *p
, int from_tty
,
683 execute_fn_to_string (dummy
, [=]() { execute_command (p
, from_tty
); },
687 /* When nonzero, cause dont_repeat to do nothing. This should only be
688 set via prevent_dont_repeat. */
690 static int suppress_dont_repeat
= 0;
697 struct ui
*ui
= current_ui
;
699 if (suppress_dont_repeat
|| server_command
)
702 /* If we aren't reading from standard input, we are saving the last
703 thing read from stdin in line and don't want to delete it. Null
704 lines won't repeat here in any case. */
705 if (ui
->instream
== ui
->stdin_stream
)
707 *saved_command_line
= 0;
708 repeat_arguments
= NULL
;
717 /* Do not repeat this command, as this command is a repeating command. */
720 /* We cannot free saved_command_line, as this line is being executed,
721 so swap it with previous_saved_command_line. */
722 std::swap (previous_saved_command_line
, saved_command_line
);
723 std::swap (previous_repeat_arguments
, repeat_arguments
);
725 const char *prev
= skip_spaces (get_saved_command_line ());
727 error (_("No previous command to relaunch"));
733 scoped_restore_tmpl
<int>
734 prevent_dont_repeat (void)
736 return make_scoped_restore (&suppress_dont_repeat
, 1);
742 get_saved_command_line ()
744 return saved_command_line
;
750 save_command_line (const char *cmd
)
752 xfree (previous_saved_command_line
);
753 previous_saved_command_line
= saved_command_line
;
754 previous_repeat_arguments
= repeat_arguments
;
755 saved_command_line
= xstrdup (cmd
);
756 repeat_arguments
= NULL
;
760 /* Read a line from the stream "instream" without command line editing.
762 It prints PROMPT once at the start.
763 Action is compatible with "readline", e.g. space for the result is
764 malloc'd and should be freed by the caller.
766 A NULL return means end of file. */
768 static gdb::unique_xmalloc_ptr
<char>
769 gdb_readline_no_editing (const char *prompt
)
771 std::string line_buffer
;
772 struct ui
*ui
= current_ui
;
773 /* Read from stdin if we are executing a user defined command. This
774 is the right thing for prompt_for_continue, at least. */
775 FILE *stream
= ui
->instream
!= NULL
? ui
->instream
: stdin
;
776 int fd
= fileno (stream
);
780 /* Don't use a _filtered function here. It causes the assumed
781 character position to be off, since the newline we read from
782 the user is not accounted for. */
783 printf_unfiltered ("%s", prompt
);
784 gdb_flush (gdb_stdout
);
794 /* Wait until at least one byte of data is available. Control-C
795 can interrupt interruptible_select, but not fgetc. */
797 FD_SET (fd
, &readfds
);
798 if (interruptible_select (fd
+ 1, &readfds
, NULL
, NULL
, NULL
) == -1)
802 /* If this was ctrl-c, the QUIT above handles it. */
805 perror_with_name (("select"));
812 if (!line_buffer
.empty ())
813 /* The last line does not end with a newline. Return it, and
814 if we are called again fgetc will still return EOF and
815 we'll return NULL then. */
822 if (!line_buffer
.empty () && line_buffer
.back () == '\r')
823 line_buffer
.pop_back ();
830 return make_unique_xstrdup (line_buffer
.c_str ());
833 /* Variables which control command line editing and history
834 substitution. These variables are given default values at the end
836 static bool command_editing_p
;
838 /* NOTE 1999-04-29: This variable will be static again, once we modify
839 gdb to use the event loop as the default command loop and we merge
840 event-top.c into this file, top.c. */
842 /* static */ bool history_expansion_p
;
844 /* Should we write out the command history on exit? In order to write out
845 the history both this flag must be true, and the history_filename
846 variable must be set to something sensible. */
847 static bool write_history_p
;
849 /* The name of the file in which GDB history will be written. If this is
850 set to NULL, of the empty string then history will not be written. */
851 static std::string history_filename
;
853 /* Implement 'show history save'. */
855 show_write_history_p (struct ui_file
*file
, int from_tty
,
856 struct cmd_list_element
*c
, const char *value
)
858 if (!write_history_p
|| !history_filename
.empty ())
859 gdb_printf (file
, _("Saving of the history record on exit is %s.\n"),
862 gdb_printf (file
, _("Saving of the history is disabled due to "
863 "the value of 'history filename'.\n"));
866 /* The variable associated with the "set/show history size"
867 command. The value -1 means unlimited, and -2 means undefined. */
868 static int history_size_setshow_var
= -2;
871 show_history_size (struct ui_file
*file
, int from_tty
,
872 struct cmd_list_element
*c
, const char *value
)
874 gdb_printf (file
, _("The size of the command history is %s.\n"),
878 /* Variable associated with the "history remove-duplicates" option.
879 The value -1 means unlimited. */
880 static int history_remove_duplicates
= 0;
883 show_history_remove_duplicates (struct ui_file
*file
, int from_tty
,
884 struct cmd_list_element
*c
, const char *value
)
887 _("The number of history entries to look back at for "
888 "duplicates is %s.\n"),
892 /* Implement 'show history filename'. */
894 show_history_filename (struct ui_file
*file
, int from_tty
,
895 struct cmd_list_element
*c
, const char *value
)
897 if (!history_filename
.empty ())
898 gdb_printf (file
, _("The filename in which to record "
899 "the command history is \"%ps\".\n"),
900 styled_string (file_name_style
.style (), value
));
902 gdb_printf (file
, _("There is no filename currently set for "
903 "recording the command history in.\n"));
906 /* This is like readline(), but it has some gdb-specific behavior.
907 gdb may want readline in both the synchronous and async modes during
908 a single gdb invocation. At the ordinary top-level prompt we might
909 be using the async readline. That means we can't use
910 rl_pre_input_hook, since it doesn't work properly in async mode.
911 However, for a secondary prompt (" >", such as occurs during a
912 `define'), gdb wants a synchronous response.
914 We used to call readline() directly, running it in synchronous
915 mode. But mixing modes this way is not supported, and as of
916 readline 5.x it no longer works; the arrow keys come unbound during
917 the synchronous call. So we make a nested call into the event
918 loop. That's what gdb_readline_wrapper is for. */
920 /* A flag set as soon as gdb_readline_wrapper_line is called; we can't
921 rely on gdb_readline_wrapper_result, which might still be NULL if
922 the user types Control-D for EOF. */
923 static int gdb_readline_wrapper_done
;
925 /* The result of the current call to gdb_readline_wrapper, once a newline
927 static char *gdb_readline_wrapper_result
;
929 /* Any intercepted hook. Operate-and-get-next sets this, expecting it
930 to be called after the newline is processed (which will redisplay
931 the prompt). But in gdb_readline_wrapper we will not get a new
932 prompt until the next call, or until we return to the event loop.
933 So we disable this hook around the newline and restore it before we
935 static void (*saved_after_char_processing_hook
) (void);
941 gdb_in_secondary_prompt_p (struct ui
*ui
)
943 return ui
->secondary_prompt_depth
> 0;
947 /* This function is called when readline has seen a complete line of
951 gdb_readline_wrapper_line (gdb::unique_xmalloc_ptr
<char> &&line
)
953 gdb_assert (!gdb_readline_wrapper_done
);
954 gdb_readline_wrapper_result
= line
.release ();
955 gdb_readline_wrapper_done
= 1;
957 /* Prevent operate-and-get-next from acting too early. */
958 saved_after_char_processing_hook
= after_char_processing_hook
;
959 after_char_processing_hook
= NULL
;
961 /* Prevent parts of the prompt from being redisplayed if annotations
962 are enabled, and readline's state getting out of sync. We'll
963 reinstall the callback handler, which puts the terminal in raw
964 mode (or in readline lingo, in prepped state), when we're next
965 ready to process user input, either in display_gdb_prompt, or if
966 we're handling an asynchronous target event and running in the
967 background, just before returning to the event loop to process
968 further input (or more target events). */
969 if (current_ui
->command_editing
)
970 gdb_rl_callback_handler_remove ();
973 class gdb_readline_wrapper_cleanup
976 gdb_readline_wrapper_cleanup ()
977 : m_handler_orig (current_ui
->input_handler
),
978 m_already_prompted_orig (current_ui
->command_editing
979 ? rl_already_prompted
: 0),
980 m_target_is_async_orig (target_is_async_p ()),
981 m_save_ui (¤t_ui
)
983 current_ui
->input_handler
= gdb_readline_wrapper_line
;
984 current_ui
->secondary_prompt_depth
++;
986 if (m_target_is_async_orig
)
987 target_async (false);
990 ~gdb_readline_wrapper_cleanup ()
992 struct ui
*ui
= current_ui
;
994 if (ui
->command_editing
)
995 rl_already_prompted
= m_already_prompted_orig
;
997 gdb_assert (ui
->input_handler
== gdb_readline_wrapper_line
);
998 ui
->input_handler
= m_handler_orig
;
1000 /* Don't restore our input handler in readline yet. That would make
1001 readline prep the terminal (putting it in raw mode), while the
1002 line we just read may trigger execution of a command that expects
1003 the terminal in the default cooked/canonical mode, such as e.g.,
1004 running Python's interactive online help utility. See
1005 gdb_readline_wrapper_line for when we'll reinstall it. */
1007 gdb_readline_wrapper_result
= NULL
;
1008 gdb_readline_wrapper_done
= 0;
1009 ui
->secondary_prompt_depth
--;
1010 gdb_assert (ui
->secondary_prompt_depth
>= 0);
1012 after_char_processing_hook
= saved_after_char_processing_hook
;
1013 saved_after_char_processing_hook
= NULL
;
1015 if (m_target_is_async_orig
)
1016 target_async (true);
1019 DISABLE_COPY_AND_ASSIGN (gdb_readline_wrapper_cleanup
);
1023 void (*m_handler_orig
) (gdb::unique_xmalloc_ptr
<char> &&);
1024 int m_already_prompted_orig
;
1026 /* Whether the target was async. */
1027 int m_target_is_async_orig
;
1029 /* Processing events may change the current UI. */
1030 scoped_restore_tmpl
<struct ui
*> m_save_ui
;
1034 gdb_readline_wrapper (const char *prompt
)
1036 struct ui
*ui
= current_ui
;
1038 gdb_readline_wrapper_cleanup cleanup
;
1040 /* Display our prompt and prevent double prompt display. Don't pass
1041 down a NULL prompt, since that has special meaning for
1042 display_gdb_prompt -- it indicates a request to print the primary
1043 prompt, while we want a secondary prompt here. */
1044 display_gdb_prompt (prompt
!= NULL
? prompt
: "");
1045 if (ui
->command_editing
)
1046 rl_already_prompted
= 1;
1048 if (after_char_processing_hook
)
1049 (*after_char_processing_hook
) ();
1050 gdb_assert (after_char_processing_hook
== NULL
);
1052 while (gdb_do_one_event () >= 0)
1053 if (gdb_readline_wrapper_done
)
1056 return gdb_readline_wrapper_result
;
1060 /* The current saved history number from operate-and-get-next.
1061 This is -1 if not valid. */
1062 static int operate_saved_history
= -1;
1064 /* This is put on the appropriate hook and helps operate-and-get-next
1067 gdb_rl_operate_and_get_next_completion (void)
1069 int delta
= where_history () - operate_saved_history
;
1071 /* The `key' argument to rl_get_previous_history is ignored. */
1072 rl_get_previous_history (delta
, 0);
1073 operate_saved_history
= -1;
1075 /* readline doesn't automatically update the display for us. */
1078 after_char_processing_hook
= NULL
;
1079 rl_pre_input_hook
= NULL
;
1082 /* This is a gdb-local readline command handler. It accepts the
1083 current command line (like RET does) and, if this command was taken
1084 from the history, arranges for the next command in the history to
1085 appear on the command line when the prompt returns.
1086 We ignore the arguments. */
1088 gdb_rl_operate_and_get_next (int count
, int key
)
1092 /* Use the async hook. */
1093 after_char_processing_hook
= gdb_rl_operate_and_get_next_completion
;
1095 /* Find the current line, and find the next line to use. */
1096 where
= where_history();
1098 if ((history_is_stifled () && (history_length
>= history_max_entries
))
1099 || (where
>= history_length
- 1))
1100 operate_saved_history
= where
;
1102 operate_saved_history
= where
+ 1;
1104 return rl_newline (1, key
);
1107 /* Number of user commands executed during this session. */
1109 static int command_count
= 0;
1111 /* Add the user command COMMAND to the input history list. */
1114 gdb_add_history (const char *command
)
1118 if (history_remove_duplicates
!= 0)
1121 int lookbehind_threshold
;
1123 /* The lookbehind threshold for finding a duplicate history entry is
1124 bounded by command_count because we can't meaningfully delete
1125 history entries that are already stored in the history file since
1126 the history file is appended to. */
1127 if (history_remove_duplicates
== -1
1128 || history_remove_duplicates
> command_count
)
1129 lookbehind_threshold
= command_count
;
1131 lookbehind_threshold
= history_remove_duplicates
;
1134 for (lookbehind
= 0; lookbehind
< lookbehind_threshold
; lookbehind
++)
1136 HIST_ENTRY
*temp
= previous_history ();
1141 if (strcmp (temp
->line
, command
) == 0)
1143 HIST_ENTRY
*prev
= remove_history (where_history ());
1145 free_history_entry (prev
);
1152 add_history (command
);
1155 /* Safely append new history entries to the history file in a corruption-free
1156 way using an intermediate local history file. */
1159 gdb_safe_append_history (void)
1161 int ret
, saved_errno
;
1163 std::string local_history_filename
1164 = string_printf ("%s-gdb%ld~", history_filename
.c_str (), (long) getpid ());
1166 ret
= rename (history_filename
.c_str (), local_history_filename
.c_str ());
1167 saved_errno
= errno
;
1168 if (ret
< 0 && saved_errno
!= ENOENT
)
1170 warning (_("Could not rename %ps to %ps: %s"),
1171 styled_string (file_name_style
.style (),
1172 history_filename
.c_str ()),
1173 styled_string (file_name_style
.style (),
1174 local_history_filename
.c_str ()),
1175 safe_strerror (saved_errno
));
1181 /* If the rename failed with ENOENT then either the global history
1182 file never existed in the first place or another GDB process is
1183 currently appending to it (and has thus temporarily renamed it).
1184 Since we can't distinguish between these two cases, we have to
1185 conservatively assume the first case and therefore must write out
1186 (not append) our known history to our local history file and try
1187 to move it back anyway. Otherwise a global history file would
1188 never get created! */
1189 gdb_assert (saved_errno
== ENOENT
);
1190 write_history (local_history_filename
.c_str ());
1194 append_history (command_count
, local_history_filename
.c_str ());
1195 if (history_is_stifled ())
1196 history_truncate_file (local_history_filename
.c_str (),
1197 history_max_entries
);
1200 ret
= rename (local_history_filename
.c_str (), history_filename
.c_str ());
1201 saved_errno
= errno
;
1202 if (ret
< 0 && saved_errno
!= EEXIST
)
1203 warning (_("Could not rename %s to %s: %s"),
1204 local_history_filename
.c_str (), history_filename
.c_str (),
1205 safe_strerror (saved_errno
));
1209 /* Read one line from the command input stream `instream'.
1211 CMD_LINE_BUFFER is a buffer that the function may use to store the result, if
1212 it needs to be dynamically-allocated. Otherwise, it is unused.string
1214 Return nullptr for end of file.
1216 This routine either uses fancy command line editing or simple input
1217 as the user has requested. */
1220 command_line_input (std::string
&cmd_line_buffer
, const char *prompt_arg
,
1221 const char *annotation_suffix
)
1223 struct ui
*ui
= current_ui
;
1224 const char *prompt
= prompt_arg
;
1226 int from_tty
= ui
->instream
== ui
->stdin_stream
;
1228 /* The annotation suffix must be non-NULL. */
1229 if (annotation_suffix
== NULL
)
1230 annotation_suffix
= "";
1232 if (from_tty
&& annotation_level
> 1)
1237 = (char *) alloca ((prompt
== NULL
? 0 : strlen (prompt
))
1238 + strlen (annotation_suffix
) + 40);
1240 local_prompt
[0] = '\0';
1242 strcpy (local_prompt
, prompt
);
1243 strcat (local_prompt
, "\n\032\032");
1244 strcat (local_prompt
, annotation_suffix
);
1245 strcat (local_prompt
, "\n");
1247 prompt
= local_prompt
;
1252 signal (SIGTSTP
, handle_sigtstp
);
1257 gdb::unique_xmalloc_ptr
<char> rl
;
1259 /* Make sure that all output has been output. Some machines may
1260 let you get away with leaving out some of the gdb_flush, but
1262 gdb_flush (gdb_stdout
);
1263 gdb_flush (gdb_stderr
);
1265 if (!source_file_name
.empty ())
1266 ++source_line_number
;
1268 if (from_tty
&& annotation_level
> 1)
1269 printf_unfiltered ("\n\032\032pre-%s\n", annotation_suffix
);
1271 /* Don't use fancy stuff if not talking to stdin. */
1272 if (deprecated_readline_hook
1274 && current_ui
->input_interactive_p ())
1276 rl
.reset ((*deprecated_readline_hook
) (prompt
));
1278 else if (command_editing_p
1280 && current_ui
->input_interactive_p ())
1282 rl
.reset (gdb_readline_wrapper (prompt
));
1286 rl
= gdb_readline_no_editing (prompt
);
1289 cmd
= handle_line_of_input (cmd_line_buffer
, rl
.get (),
1290 0, annotation_suffix
);
1291 if (cmd
== (char *) EOF
)
1299 /* Got partial input. I.e., got a line that ends with a
1300 continuation character (backslash). Suppress printing the
1307 signal (SIGTSTP
, SIG_DFL
);
1315 print_gdb_version (struct ui_file
*stream
, bool interactive
)
1317 /* From GNU coding standards, first line is meant to be easy for a
1318 program to parse, and is just canonical program name and version
1319 number, which starts after last space. */
1321 std::string v_str
= string_printf ("GNU gdb %s%s", PKGVERSION
, version
);
1322 gdb_printf (stream
, "%ps\n",
1323 styled_string (version_style
.style (), v_str
.c_str ()));
1325 /* Second line is a copyright notice. */
1328 "Copyright (C) 2023 Free Software Foundation, Inc.\n");
1330 /* Following the copyright is a brief statement that the program is
1331 free software, that users are free to copy and change it on
1332 certain conditions, that it is covered by the GNU GPL, and that
1333 there is no warranty. */
1335 gdb_printf (stream
, "\
1336 License GPLv3+: GNU GPL version 3 or later <%ps>\
1337 \nThis is free software: you are free to change and redistribute it.\n\
1338 There is NO WARRANTY, to the extent permitted by law.",
1339 styled_string (file_name_style
.style (),
1340 "http://gnu.org/licenses/gpl.html"));
1345 gdb_printf (stream
, ("\nType \"show copying\" and "
1346 "\"show warranty\" for details.\n"));
1348 /* After the required info we print the configuration information. */
1350 gdb_printf (stream
, "This GDB was configured as \"");
1351 if (strcmp (host_name
, target_name
) != 0)
1353 gdb_printf (stream
, "--host=%s --target=%s",
1354 host_name
, target_name
);
1358 gdb_printf (stream
, "%s", host_name
);
1360 gdb_printf (stream
, "\".\n");
1362 gdb_printf (stream
, _("Type \"show configuration\" "
1363 "for configuration details.\n"));
1365 if (REPORT_BUGS_TO
[0])
1368 _("For bug reporting instructions, please see:\n"));
1369 gdb_printf (stream
, "%ps.\n",
1370 styled_string (file_name_style
.style (),
1374 _("Find the GDB manual and other documentation \
1375 resources online at:\n <%ps>."),
1376 styled_string (file_name_style
.style (),
1377 "http://www.gnu.org/software/gdb/documentation/"));
1378 gdb_printf (stream
, "\n\n");
1379 gdb_printf (stream
, _("For help, type \"help\".\n"));
1381 _("Type \"apropos word\" to search for commands \
1382 related to \"word\"."));
1385 /* Print the details of GDB build-time configuration. */
1387 print_gdb_configuration (struct ui_file
*stream
)
1389 gdb_printf (stream
, _("\
1390 This GDB was configured as follows:\n\
1391 configure --host=%s --target=%s\n\
1392 "), host_name
, target_name
);
1394 gdb_printf (stream
, _("\
1395 --with-auto-load-dir=%s\n\
1396 --with-auto-load-safe-path=%s\n\
1397 "), AUTO_LOAD_DIR
, AUTO_LOAD_SAFE_PATH
);
1400 gdb_printf (stream
, _("\
1404 gdb_printf (stream
, _("\
1410 gdb_printf (stream
, _("\
1411 --with-gdb-datadir=%s%s\n\
1412 "), GDB_DATADIR
, GDB_DATADIR_RELOCATABLE
? " (relocatable)" : "");
1415 gdb_printf (stream
, _("\
1416 --with-iconv-bin=%s%s\n\
1417 "), ICONV_BIN
, ICONV_BIN_RELOCATABLE
? " (relocatable)" : "");
1420 if (JIT_READER_DIR
[0])
1421 gdb_printf (stream
, _("\
1422 --with-jit-reader-dir=%s%s\n\
1423 "), JIT_READER_DIR
, JIT_READER_DIR_RELOCATABLE
? " (relocatable)" : "");
1425 #if HAVE_LIBUNWIND_IA64_H
1426 gdb_printf (stream
, _("\
1427 --with-libunwind-ia64\n\
1430 gdb_printf (stream
, _("\
1431 --without-libunwind-ia64\n\
1436 gdb_printf (stream
, _("\
1440 gdb_printf (stream
, _("\
1445 #if HAVE_LIBBABELTRACE
1446 gdb_printf (stream
, _("\
1447 --with-babeltrace\n\
1450 gdb_printf (stream
, _("\
1451 --without-babeltrace\n\
1456 gdb_printf (stream
, _("\
1460 gdb_printf (stream
, _("\
1461 --without-intel-pt\n\
1466 gdb_printf (stream
, _("\
1470 gdb_printf (stream
, _("\
1474 #ifdef WITH_PYTHON_PATH
1475 gdb_printf (stream
, _("\
1476 --with-python=%s%s\n\
1477 "), WITH_PYTHON_PATH
, PYTHON_PATH_RELOCATABLE
? " (relocatable)" : "");
1479 gdb_printf (stream
, _("\
1483 #ifdef WITH_PYTHON_LIBDIR
1484 gdb_printf (stream
, _("\
1485 --with-python-libdir=%s%s\n\
1486 "), WITH_PYTHON_LIBDIR
, PYTHON_LIBDIR_RELOCATABLE
? " (relocatable)" : "");
1488 gdb_printf (stream
, _("\
1489 --without-python-libdir\n\
1493 #if HAVE_LIBDEBUGINFOD
1494 gdb_printf (stream
, _("\
1495 --with-debuginfod\n\
1498 gdb_printf (stream
, _("\
1499 --without-debuginfod\n\
1504 gdb_printf (stream
, _("\
1508 gdb_printf (stream
, _("\
1514 gdb_printf (stream
, _("\
1518 gdb_printf (stream
, _("\
1524 gdb_printf (stream
, _("\
1525 --with-amd-dbgapi\n\
1528 gdb_printf (stream
, _("\
1529 --without-amd-dbgapi\n\
1533 #if HAVE_SOURCE_HIGHLIGHT
1534 gdb_printf (stream
, _("\
1535 --enable-source-highlight\n\
1538 gdb_printf (stream
, _("\
1539 --disable-source-highlight\n\
1544 gdb_printf (stream
, _("\
1545 --enable-threading\n\
1548 gdb_printf (stream
, _("\
1549 --disable-threading\n\
1554 gdb_printf (stream
, _("\
1558 gdb_printf (stream
, _("\
1563 #ifdef HAVE_READLINE_READLINE_H
1564 gdb_printf (stream
, _("\
1565 --with-system-readline\n\
1568 gdb_printf (stream
, _("\
1569 --without-system-readline\n\
1574 gdb_printf (stream
, _("\
1575 --with-relocated-sources=%s\n\
1580 gdb_printf (stream
, _("\
1581 --with-separate-debug-dir=%s%s\n\
1582 "), DEBUGDIR
, DEBUGDIR_RELOCATABLE
? " (relocatable)" : "");
1584 if (TARGET_SYSTEM_ROOT
[0])
1585 gdb_printf (stream
, _("\
1586 --with-sysroot=%s%s\n\
1587 "), TARGET_SYSTEM_ROOT
, TARGET_SYSTEM_ROOT_RELOCATABLE
? " (relocatable)" : "");
1589 if (SYSTEM_GDBINIT
[0])
1590 gdb_printf (stream
, _("\
1591 --with-system-gdbinit=%s%s\n\
1592 "), SYSTEM_GDBINIT
, SYSTEM_GDBINIT_RELOCATABLE
? " (relocatable)" : "");
1594 if (SYSTEM_GDBINIT_DIR
[0])
1595 gdb_printf (stream
, _("\
1596 --with-system-gdbinit-dir=%s%s\n\
1597 "), SYSTEM_GDBINIT_DIR
, SYSTEM_GDBINIT_DIR_RELOCATABLE
? " (relocatable)" : "");
1599 /* We assume "relocatable" will be printed at least once, thus we always
1600 print this text. It's a reasonably safe assumption for now. */
1601 gdb_printf (stream
, _("\n\
1602 (\"Relocatable\" means the directory can be moved with the GDB installation\n\
1603 tree, and GDB will still find it.)\n\
1608 /* The current top level prompt, settable with "set prompt", and/or
1609 with the python `gdb.prompt_hook' hook. */
1610 static std::string top_prompt
;
1612 /* Access method for the GDB prompt string. */
1620 /* Set method for the GDB prompt string. */
1623 set_prompt (const char *s
)
1629 /* Kills or detaches the given inferior, depending on how we originally
1630 gained control of it. */
1633 kill_or_detach (inferior
*inf
, int from_tty
)
1638 thread_info
*thread
= any_thread_of_inferior (inf
);
1641 switch_to_thread (thread
);
1643 /* Leave core files alone. */
1644 if (target_has_execution ())
1646 if (inf
->attach_flag
)
1647 target_detach (inf
, from_tty
);
1654 /* Prints info about what GDB will do to inferior INF on a "quit". OUT is
1655 where to collect the output. */
1658 print_inferior_quit_action (inferior
*inf
, ui_file
*out
)
1663 if (inf
->attach_flag
)
1665 _("\tInferior %d [%s] will be detached.\n"), inf
->num
,
1666 target_pid_to_str (ptid_t (inf
->pid
)).c_str ());
1669 _("\tInferior %d [%s] will be killed.\n"), inf
->num
,
1670 target_pid_to_str (ptid_t (inf
->pid
)).c_str ());
1673 /* If necessary, make the user confirm that we should quit. Return
1674 non-zero if we should quit, zero if we shouldn't. */
1679 /* Don't even ask if we're only debugging a core file inferior. */
1680 if (!have_live_inferiors ())
1683 /* Build the query string as a single string. */
1686 stb
.puts (_("A debugging session is active.\n\n"));
1688 for (inferior
*inf
: all_inferiors ())
1689 print_inferior_quit_action (inf
, &stb
);
1691 stb
.puts (_("\nQuit anyway? "));
1693 return query ("%s", stb
.c_str ());
1696 /* Prepare to exit GDB cleanly by undoing any changes made to the
1697 terminal so that we leave the terminal in the state we acquired it. */
1700 undo_terminal_modifications_before_exit (void)
1702 struct ui
*saved_top_level
= current_ui
;
1704 target_terminal::ours ();
1706 current_ui
= main_ui
;
1711 gdb_disable_readline ();
1713 current_ui
= saved_top_level
;
1717 /* Quit without asking for confirmation. */
1720 quit_force (int *exit_arg
, int from_tty
)
1724 /* Clear the quit flag and sync_quit_force_run so that a
1725 gdb_exception_forced_quit isn't inadvertently triggered by a QUIT
1726 check while running the various cleanup/exit code below. Note
1727 that the call to 'check_quit_flag' clears the quit flag as a side
1730 sync_quit_force_run
= false;
1732 /* An optional expression may be used to cause gdb to terminate with the
1733 value of that expression. */
1735 exit_code
= *exit_arg
;
1736 else if (return_child_result
)
1737 exit_code
= return_child_result_value
;
1739 gdb::observers::gdb_exiting
.notify (exit_code
);
1741 undo_terminal_modifications_before_exit ();
1743 /* We want to handle any quit errors and exit regardless. */
1745 /* Get out of tfind mode, and kill or detach all inferiors. */
1748 disconnect_tracing ();
1749 for (inferior
*inf
: all_inferiors ())
1750 kill_or_detach (inf
, from_tty
);
1752 catch (const gdb_exception
&ex
)
1754 exception_print (gdb_stderr
, ex
);
1757 /* Give all pushed targets a chance to do minimal cleanup, and pop
1759 for (inferior
*inf
: all_inferiors ())
1763 inf
->pop_all_targets ();
1765 catch (const gdb_exception
&ex
)
1767 exception_print (gdb_stderr
, ex
);
1771 /* Save the history information if it is appropriate to do so. */
1774 if (write_history_p
&& !history_filename
.empty ())
1778 /* History is currently shared between all UIs. If there's
1779 any UI with a terminal, save history. */
1780 for (ui
*ui
: all_uis ())
1782 if (ui
->input_interactive_p ())
1790 gdb_safe_append_history ();
1793 catch (const gdb_exception
&ex
)
1795 exception_print (gdb_stderr
, ex
);
1798 /* Destroy any values currently allocated now instead of leaving it
1799 to global destructors, because that may be too late. For
1800 example, the destructors of xmethod values call into the Python
1801 runtime, which is finalized via a final cleanup. */
1804 /* Do any final cleanups before exiting. */
1807 do_final_cleanups ();
1809 catch (const gdb_exception
&ex
)
1811 exception_print (gdb_stderr
, ex
);
1819 auto_boolean interactive_mode
= AUTO_BOOLEAN_AUTO
;
1821 /* Implement the "show interactive-mode" option. */
1824 show_interactive_mode (struct ui_file
*file
, int from_tty
,
1825 struct cmd_list_element
*c
,
1828 if (interactive_mode
== AUTO_BOOLEAN_AUTO
)
1829 gdb_printf (file
, "Debugger's interactive mode "
1830 "is %s (currently %s).\n",
1831 value
, current_ui
->input_interactive_p () ? "on" : "off");
1833 gdb_printf (file
, "Debugger's interactive mode is %s.\n", value
);
1837 dont_repeat_command (const char *ignored
, int from_tty
)
1839 /* Can't call dont_repeat here because we're not necessarily reading
1841 *saved_command_line
= 0;
1844 /* Functions to manipulate command line editing control variables. */
1846 /* Number of commands to print in each call to show_commands. */
1847 #define Hist_print 10
1849 show_commands (const char *args
, int from_tty
)
1851 /* Index for history commands. Relative to history_base. */
1854 /* Number of the history entry which we are planning to display next.
1855 Relative to history_base. */
1858 /* Print out some of the commands from the command history. */
1862 if (args
[0] == '+' && args
[1] == '\0')
1863 /* "info editing +" should print from the stored position. */
1866 /* "info editing <exp>" should print around command number <exp>. */
1867 num
= (parse_and_eval_long (args
) - history_base
) - Hist_print
/ 2;
1869 /* "show commands" means print the last Hist_print commands. */
1872 num
= history_length
- Hist_print
;
1878 /* If there are at least Hist_print commands, we want to display the last
1879 Hist_print rather than, say, the last 6. */
1880 if (history_length
- num
< Hist_print
)
1882 num
= history_length
- Hist_print
;
1888 offset
< num
+ Hist_print
&& offset
< history_length
;
1891 gdb_printf ("%5d %s\n", history_base
+ offset
,
1892 (history_get (history_base
+ offset
))->line
);
1895 /* The next command we want to display is the next one that we haven't
1899 /* If the user repeats this command with return, it should do what
1900 "show commands +" does. This is unnecessary if arg is null,
1901 because "show commands +" is not useful after "show commands". */
1902 if (from_tty
&& args
)
1903 set_repeat_arguments ("+");
1906 /* Update the size of our command history file to HISTORY_SIZE.
1908 A HISTORY_SIZE of -1 stands for unlimited. */
1911 set_readline_history_size (int history_size
)
1913 gdb_assert (history_size
>= -1);
1915 if (history_size
== -1)
1916 unstifle_history ();
1918 stifle_history (history_size
);
1921 /* Called by do_setshow_command. */
1923 set_history_size_command (const char *args
,
1924 int from_tty
, struct cmd_list_element
*c
)
1926 set_readline_history_size (history_size_setshow_var
);
1929 bool info_verbose
= false; /* Default verbose msgs off. */
1931 /* Called by do_set_command. An elaborate joke. */
1933 set_verbose (const char *args
, int from_tty
, struct cmd_list_element
*c
)
1935 const char *cmdname
= "verbose";
1936 struct cmd_list_element
*showcmd
;
1938 showcmd
= lookup_cmd_1 (&cmdname
, showlist
, NULL
, NULL
, 1);
1939 gdb_assert (showcmd
!= NULL
&& showcmd
!= CMD_LIST_AMBIGUOUS
);
1941 if (c
->doc
&& c
->doc_allocated
)
1942 xfree ((char *) c
->doc
);
1943 if (showcmd
->doc
&& showcmd
->doc_allocated
)
1944 xfree ((char *) showcmd
->doc
);
1947 c
->doc
= _("Set verbose printing of informational messages.");
1948 showcmd
->doc
= _("Show verbose printing of informational messages.");
1952 c
->doc
= _("Set verbosity.");
1953 showcmd
->doc
= _("Show verbosity.");
1955 c
->doc_allocated
= 0;
1956 showcmd
->doc_allocated
= 0;
1959 /* Init the history buffer. Note that we are called after the init file(s)
1960 have been read so that the user can change the history file via his
1961 .gdbinit file (for instance). The GDBHISTFILE environment variable
1962 overrides all of this. */
1969 tmpenv
= getenv ("GDBHISTSIZE");
1976 tmpenv
= skip_spaces (tmpenv
);
1978 var
= strtol (tmpenv
, &endptr
, 10);
1979 saved_errno
= errno
;
1980 endptr
= skip_spaces (endptr
);
1982 /* If GDBHISTSIZE is non-numeric then ignore it. If GDBHISTSIZE is the
1983 empty string, a negative number or a huge positive number (larger than
1984 INT_MAX) then set the history size to unlimited. Otherwise set our
1985 history size to the number we have read. This behavior is consistent
1986 with how bash handles HISTSIZE. */
1987 if (*endptr
!= '\0')
1989 else if (*tmpenv
== '\0'
1992 /* On targets where INT_MAX == LONG_MAX, we have to look at
1993 errno after calling strtol to distinguish between a value that
1994 is exactly INT_MAX and an overflowing value that was clamped
1996 || (var
== INT_MAX
&& saved_errno
== ERANGE
))
1997 history_size_setshow_var
= -1;
1999 history_size_setshow_var
= var
;
2002 /* If neither the init file nor GDBHISTSIZE has set a size yet, pick the
2004 if (history_size_setshow_var
== -2)
2005 history_size_setshow_var
= 256;
2007 set_readline_history_size (history_size_setshow_var
);
2009 if (!history_filename
.empty ())
2010 read_history (history_filename
.c_str ());
2014 show_prompt (struct ui_file
*file
, int from_tty
,
2015 struct cmd_list_element
*c
, const char *value
)
2017 gdb_printf (file
, _("Gdb's prompt is \"%s\".\n"), value
);
2020 /* "set editing" command. */
2023 set_editing (const char *args
, int from_tty
, struct cmd_list_element
*c
)
2025 change_line_handler (set_editing_cmd_var
);
2026 /* Update the control variable so that MI's =cmd-param-changed event
2027 shows the correct value. */
2028 set_editing_cmd_var
= current_ui
->command_editing
;
2032 show_editing (struct ui_file
*file
, int from_tty
,
2033 struct cmd_list_element
*c
, const char *value
)
2035 gdb_printf (file
, _("Editing of command lines as "
2036 "they are typed is %s.\n"),
2037 current_ui
->command_editing
? _("on") : _("off"));
2041 show_annotation_level (struct ui_file
*file
, int from_tty
,
2042 struct cmd_list_element
*c
, const char *value
)
2044 gdb_printf (file
, _("Annotation_level is %s.\n"), value
);
2048 show_exec_done_display_p (struct ui_file
*file
, int from_tty
,
2049 struct cmd_list_element
*c
, const char *value
)
2051 gdb_printf (file
, _("Notification of completion for "
2052 "asynchronous execution commands is %s.\n"),
2056 /* New values of the "data-directory" parameter are staged here.
2057 Extension languages, for example Python's gdb.parameter API, will read
2058 the value directory from this variable, so we must ensure that this
2059 always contains the correct value. */
2060 static std::string staged_gdb_datadir
;
2062 /* "set" command for the gdb_datadir configuration variable. */
2065 set_gdb_datadir (const char *args
, int from_tty
, struct cmd_list_element
*c
)
2067 set_gdb_data_directory (staged_gdb_datadir
.c_str ());
2069 /* SET_GDB_DATA_DIRECTORY will resolve relative paths in
2070 STAGED_GDB_DATADIR, so we now copy the value from GDB_DATADIR
2071 back into STAGED_GDB_DATADIR so the extension languages can read the
2073 staged_gdb_datadir
= gdb_datadir
;
2075 gdb::observers::gdb_datadir_changed
.notify ();
2078 /* "show" command for the gdb_datadir configuration variable. */
2081 show_gdb_datadir (struct ui_file
*file
, int from_tty
,
2082 struct cmd_list_element
*c
, const char *value
)
2084 gdb_printf (file
, _("GDB's data directory is \"%ps\".\n"),
2085 styled_string (file_name_style
.style (),
2086 gdb_datadir
.c_str ()));
2089 /* Implement 'set history filename'. */
2092 set_history_filename (const char *args
,
2093 int from_tty
, struct cmd_list_element
*c
)
2095 /* We include the current directory so that if the user changes
2096 directories the file written will be the same as the one
2098 if (!history_filename
.empty ()
2099 && !IS_ABSOLUTE_PATH (history_filename
.c_str ()))
2100 history_filename
= gdb_abspath (history_filename
.c_str ());
2103 /* Whether we're in quiet startup mode. */
2105 static bool startup_quiet
;
2112 return startup_quiet
;
2115 /* Show whether GDB should start up in quiet mode. */
2118 show_startup_quiet (struct ui_file
*file
, int from_tty
,
2119 struct cmd_list_element
*c
, const char *value
)
2121 gdb_printf (file
, _("Whether to start up quietly is %s.\n"),
2128 /* Initialize the prompt to a simple "(gdb) " prompt or to whatever
2129 the DEFAULT_PROMPT is. */
2130 set_prompt (DEFAULT_PROMPT
);
2132 /* Set the important stuff up for command editing. */
2133 command_editing_p
= 1;
2134 history_expansion_p
= 0;
2135 write_history_p
= 0;
2137 /* Setup important stuff for command line editing. */
2138 rl_completion_word_break_hook
= gdb_completion_word_break_characters
;
2139 rl_attempted_completion_function
= gdb_rl_attempted_completion_function
;
2140 set_rl_completer_word_break_characters (default_word_break_characters ());
2141 rl_completer_quote_characters
= get_gdb_completer_quote_characters ();
2142 rl_completion_display_matches_hook
= cli_display_match_list
;
2143 rl_readline_name
= "gdb";
2144 rl_terminal_name
= getenv ("TERM");
2145 rl_deprep_term_function
= gdb_rl_deprep_term_function
;
2147 /* The name for this defun comes from Bash, where it originated.
2148 15 is Control-o, the same binding this function has in Bash. */
2149 rl_add_defun ("operate-and-get-next", gdb_rl_operate_and_get_next
, 15);
2151 add_setshow_string_cmd ("prompt", class_support
,
2153 _("Set gdb's prompt."),
2154 _("Show gdb's prompt."),
2157 &setlist
, &showlist
);
2159 add_com ("dont-repeat", class_support
, dont_repeat_command
, _("\
2160 Don't repeat this command.\nPrimarily \
2161 used inside of user-defined commands that should not be repeated when\n\
2164 add_setshow_boolean_cmd ("editing", class_support
,
2165 &set_editing_cmd_var
, _("\
2166 Set editing of command lines as they are typed."), _("\
2167 Show editing of command lines as they are typed."), _("\
2168 Use \"on\" to enable the editing, and \"off\" to disable it.\n\
2169 Without an argument, command line editing is enabled. To edit, use\n\
2170 EMACS-like or VI-like commands like control-P or ESC."),
2173 &setlist
, &showlist
);
2175 add_setshow_boolean_cmd ("save", no_class
, &write_history_p
, _("\
2176 Set saving of the history record on exit."), _("\
2177 Show saving of the history record on exit."), _("\
2178 Use \"on\" to enable the saving, and \"off\" to disable it.\n\
2179 Without an argument, saving is enabled."),
2181 show_write_history_p
,
2182 &sethistlist
, &showhistlist
);
2184 add_setshow_zuinteger_unlimited_cmd ("size", no_class
,
2185 &history_size_setshow_var
, _("\
2186 Set the size of the command history."), _("\
2187 Show the size of the command history."), _("\
2188 This is the number of previous commands to keep a record of.\n\
2189 If set to \"unlimited\", the number of commands kept in the history\n\
2190 list is unlimited. This defaults to the value of the environment\n\
2191 variable \"GDBHISTSIZE\", or to 256 if this variable is not set."),
2192 set_history_size_command
,
2194 &sethistlist
, &showhistlist
);
2196 add_setshow_zuinteger_unlimited_cmd ("remove-duplicates", no_class
,
2197 &history_remove_duplicates
, _("\
2198 Set how far back in history to look for and remove duplicate entries."), _("\
2199 Show how far back in history to look for and remove duplicate entries."), _("\
2200 If set to a nonzero value N, GDB will look back at the last N history entries\n\
2201 and remove the first history entry that is a duplicate of the most recent\n\
2202 entry, each time a new history entry is added.\n\
2203 If set to \"unlimited\", this lookbehind is unbounded.\n\
2204 Only history entries added during this session are considered for removal.\n\
2205 If set to 0, removal of duplicate history entries is disabled.\n\
2206 By default this option is set to 0."),
2208 show_history_remove_duplicates
,
2209 &sethistlist
, &showhistlist
);
2211 add_setshow_optional_filename_cmd ("filename", no_class
, &history_filename
, _("\
2212 Set the filename in which to record the command history."), _("\
2213 Show the filename in which to record the command history."), _("\
2214 (the list of previous commands of which a record is kept)."),
2215 set_history_filename
,
2216 show_history_filename
,
2217 &sethistlist
, &showhistlist
);
2219 add_setshow_boolean_cmd ("confirm", class_support
, &confirm
, _("\
2220 Set whether to confirm potentially dangerous operations."), _("\
2221 Show whether to confirm potentially dangerous operations."), NULL
,
2224 &setlist
, &showlist
);
2226 add_setshow_zinteger_cmd ("annotate", class_obscure
, &annotation_level
, _("\
2227 Set annotation_level."), _("\
2228 Show annotation_level."), _("\
2229 0 == normal; 1 == fullname (for use when running under emacs)\n\
2230 2 == output annotated suitably for use by programs that control GDB."),
2232 show_annotation_level
,
2233 &setlist
, &showlist
);
2235 add_setshow_boolean_cmd ("exec-done-display", class_support
,
2236 &exec_done_display_p
, _("\
2237 Set notification of completion for asynchronous execution commands."), _("\
2238 Show notification of completion for asynchronous execution commands."), _("\
2239 Use \"on\" to enable the notification, and \"off\" to disable it."),
2241 show_exec_done_display_p
,
2242 &setlist
, &showlist
);
2244 add_setshow_filename_cmd ("data-directory", class_maintenance
,
2245 &staged_gdb_datadir
, _("Set GDB's data directory."),
2246 _("Show GDB's data directory."),
2248 When set, GDB uses the specified path to search for data files."),
2249 set_gdb_datadir
, show_gdb_datadir
,
2252 /* Prime the initial value for data-directory. */
2253 staged_gdb_datadir
= gdb_datadir
;
2255 add_setshow_auto_boolean_cmd ("interactive-mode", class_support
,
2256 &interactive_mode
, _("\
2257 Set whether GDB's standard input is a terminal."), _("\
2258 Show whether GDB's standard input is a terminal."), _("\
2259 If on, GDB assumes that standard input is a terminal. In practice, it\n\
2260 means that GDB should wait for the user to answer queries associated to\n\
2261 commands entered at the command prompt. If off, GDB assumes that standard\n\
2262 input is not a terminal, and uses the default answer to all queries.\n\
2263 If auto (the default), determine which mode to use based on the standard\n\
2266 show_interactive_mode
,
2267 &setlist
, &showlist
);
2269 add_setshow_boolean_cmd ("startup-quietly", class_support
,
2270 &startup_quiet
, _("\
2271 Set whether GDB should start up quietly."), _(" \
2272 Show whether GDB should start up quietly."), _("\
2273 This setting will not affect the current session. Instead this command\n\
2274 should be added to the .gdbearlyinit file in the users home directory to\n\
2275 affect future GDB sessions."),
2278 &setlist
, &showlist
);
2280 struct internalvar
*major_version_var
= create_internalvar ("_gdb_major");
2281 struct internalvar
*minor_version_var
= create_internalvar ("_gdb_minor");
2282 int vmajor
= 0, vminor
= 0, vrevision
= 0;
2283 sscanf (version
, "%d.%d.%d", &vmajor
, &vminor
, &vrevision
);
2284 set_internalvar_integer (major_version_var
, vmajor
);
2285 set_internalvar_integer (minor_version_var
, vminor
+ (vrevision
> 0));
2293 saved_command_line
= xstrdup ("");
2294 previous_saved_command_line
= xstrdup ("");
2296 /* Run the init function of each source file. */
2299 /* Make sure we return to the original directory upon exit, come
2300 what may, since the OS doesn't do that for us. */
2301 make_final_cleanup (do_chdir_cleanup
, xstrdup (current_directory
));
2306 /* Here is where we call all the _initialize_foo routines. */
2307 initialize_all_files ();
2309 /* This creates the current_program_space. Do this after all the
2310 _initialize_foo routines have had a chance to install their
2311 per-sspace data keys. Also do this before
2312 initialize_current_architecture is called, because it accesses
2313 exec_bfd of the current program space. */
2314 initialize_progspace ();
2315 initialize_inferiors ();
2316 initialize_current_architecture ();
2317 init_main (); /* But that omits this file! Do it now. */
2319 initialize_stdin_serial ();
2321 /* Take a snapshot of our tty state before readline/ncurses have had a chance
2323 set_initial_gdb_ttystate ();
2325 gdb_init_signals ();
2327 /* We need a default language for parsing expressions, so simple
2328 things like "set width 0" won't fail if no language is explicitly
2329 set in a config file or implicitly set by reading an executable
2331 set_language (language_c
);
2332 expected_language
= current_language
; /* Don't warn about the change. */
2335 void _initialize_top ();
2339 /* Determine a default value for the history filename. */
2340 const char *tmpenv
= getenv ("GDBHISTFILE");
2341 if (tmpenv
!= nullptr)
2342 history_filename
= tmpenv
;
2345 /* We include the current directory so that if the user changes
2346 directories the file written will be the same as the one
2349 /* No leading dots in file names are allowed on MSDOS. */
2350 const char *fname
= "_gdb_history";
2352 const char *fname
= ".gdb_history";
2355 history_filename
= gdb_abspath (fname
);