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"
80 # include "tui/tui-io.h"
87 extern void initialize_all_files (void);
89 #define PROMPT(X) the_prompts.prompt_stack[the_prompts.top + X].prompt
90 #define PREFIX(X) the_prompts.prompt_stack[the_prompts.top + X].prefix
91 #define SUFFIX(X) the_prompts.prompt_stack[the_prompts.top + X].suffix
93 /* Default command line prompt. This is overridden in some configs. */
95 #ifndef DEFAULT_PROMPT
96 #define DEFAULT_PROMPT "(gdb) "
100 current_ui_gdb_stdout_ptr ()
102 return ¤t_ui
->m_gdb_stdout
;
106 current_ui_gdb_stdin_ptr ()
108 return ¤t_ui
->m_gdb_stdin
;
112 current_ui_gdb_stderr_ptr ()
114 return ¤t_ui
->m_gdb_stderr
;
118 current_ui_gdb_stdlog_ptr ()
120 return ¤t_ui
->m_gdb_stdlog
;
124 current_ui_current_uiout_ptr ()
126 return ¤t_ui
->m_current_uiout
;
129 int inhibit_gdbinit
= 0;
131 /* Flag for whether we want to confirm potentially dangerous
132 operations. Default is yes. */
137 show_confirm (struct ui_file
*file
, int from_tty
,
138 struct cmd_list_element
*c
, const char *value
)
140 gdb_printf (file
, _("Whether to confirm potentially "
141 "dangerous operations is %s.\n"),
145 /* The last command line executed on the console. Used for command
146 repetitions when the user enters an empty line. */
148 static char *saved_command_line
;
150 /* If not NULL, the arguments that should be passed if
151 saved_command_line is repeated. */
153 static const char *repeat_arguments
;
155 /* The previous last command line executed on the console. Used for command
156 repetitions when a command wants to relaunch the previously launched
157 command. We need this as when a command is running, saved_command_line
158 already contains the line of the currently executing command. */
160 static char *previous_saved_command_line
;
162 /* If not NULL, the arguments that should be passed if the
163 previous_saved_command_line is repeated. */
165 static const char *previous_repeat_arguments
;
167 /* Nonzero if the current command is modified by "server ". This
168 affects things like recording into the command history, commands
169 repeating on RETURN, etc. This is so a user interface (emacs, GUI,
170 whatever) can issue its own commands and also send along commands
171 from the user, and have the user not notice that the user interface
172 is issuing commands too. */
175 /* Timeout limit for response from target. */
177 /* The default value has been changed many times over the years. It
178 was originally 5 seconds. But that was thought to be a long time
179 to sit and wait, so it was changed to 2 seconds. That was thought
180 to be plenty unless the connection was going through some terminal
181 server or multiplexer or other form of hairy serial connection.
183 In mid-1996, remote_timeout was moved from remote.c to top.c and
184 it began being used in other remote-* targets. It appears that the
185 default was changed to 20 seconds at that time, perhaps because the
186 Renesas E7000 ICE didn't always respond in a timely manner.
188 But if 5 seconds is a long time to sit and wait for retransmissions,
189 20 seconds is far worse. This demonstrates the difficulty of using
190 a single variable for all protocol timeouts.
192 As remote.c is used much more than remote-e7000.c, it was changed
193 back to 2 seconds in 1999. */
195 int remote_timeout
= 2;
197 /* Sbrk location on entry to main. Used for statistics only. */
198 #ifdef HAVE_USEFUL_SBRK
202 /* Hooks for alternate command interfaces. */
204 /* This hook is called from within gdb's many mini-event loops which
205 could steal control from a real user interface's event loop. It
206 returns non-zero if the user is requesting a detach, zero
209 int (*deprecated_ui_loop_hook
) (int);
212 /* Called from print_frame_info to list the line we stopped in. */
214 void (*deprecated_print_frame_info_listing_hook
) (struct symtab
* s
,
218 /* Replaces most of query. */
220 int (*deprecated_query_hook
) (const char *, va_list);
222 /* Replaces most of warning. */
224 void (*deprecated_warning_hook
) (const char *, va_list);
226 /* These three functions support getting lines of text from the user.
227 They are used in sequence. First deprecated_readline_begin_hook is
228 called with a text string that might be (for example) a message for
229 the user to type in a sequence of commands to be executed at a
230 breakpoint. If this function calls back to a GUI, it might take
231 this opportunity to pop up a text interaction window with this
232 message. Next, deprecated_readline_hook is called with a prompt
233 that is emitted prior to collecting the user input. It can be
234 called multiple times. Finally, deprecated_readline_end_hook is
235 called to notify the GUI that we are done with the interaction
236 window and it can close it. */
238 void (*deprecated_readline_begin_hook
) (const char *, ...);
239 char *(*deprecated_readline_hook
) (const char *);
240 void (*deprecated_readline_end_hook
) (void);
242 /* Called as appropriate to notify the interface that we have attached
243 to or detached from an already running process. */
245 void (*deprecated_attach_hook
) (void);
246 void (*deprecated_detach_hook
) (void);
248 /* Used by UI as a wrapper around command execution. May do various
249 things like enabling/disabling buttons, etc... */
251 void (*deprecated_call_command_hook
) (struct cmd_list_element
* c
,
252 const char *cmd
, int from_tty
);
254 /* Called when the current thread changes. Argument is thread id. */
256 void (*deprecated_context_hook
) (int id
);
261 unbuffer_stream (FILE *stream
)
263 /* Unbuffer the input stream so that in gdb_readline_no_editing_callback,
264 the calls to fgetc fetch only one char at the time from STREAM.
266 This is important because gdb_readline_no_editing_callback will read
267 from STREAM up to the first '\n' character, after this GDB returns to
268 the event loop and relies on a select on STREAM indicating that more
271 If STREAM is buffered then the fgetc calls may have moved all the
272 pending input from the kernel into a local buffer, after which the
273 select will not indicate that more input is pending, and input after
274 the first '\n' will not be processed immediately.
276 Please ensure that any changes in this area run the MI tests with the
277 FORCE_SEPARATE_MI_TTY=1 flag being passed. */
280 /* With MS-Windows runtime, making stdin unbuffered when it's
281 connected to the terminal causes it to misbehave. */
282 if (!ISATTY (stream
))
283 setbuf (stream
, nullptr);
285 /* On GNU/Linux the issues described above can impact GDB even when
286 dealing with input from a terminal. For now we unbuffer the input
287 stream for everyone except MS-Windows. */
288 setbuf (stream
, nullptr);
292 /* Handler for SIGHUP. */
295 /* NOTE 1999-04-29: This function will be static again, once we modify
296 gdb to use the event loop as the default command loop and we merge
297 event-top.c into this file, top.c. */
301 /* Stop asking user for confirmation --- we're exiting. This
302 prevents asking the user dumb questions. */
304 quit_command ((char *) 0, 0);
306 #endif /* defined SIGHUP */
308 /* Line number we are currently in, in a file which is being sourced. */
309 /* NOTE 1999-04-29: This variable will be static again, once we modify
310 gdb to use the event loop as the default command loop and we merge
311 event-top.c into this file, top.c. */
312 /* static */ int source_line_number
;
314 /* Name of the file we are sourcing. */
315 /* NOTE 1999-04-29: This variable will be static again, once we modify
316 gdb to use the event loop as the default command loop and we merge
317 event-top.c into this file, top.c. */
318 /* static */ std::string source_file_name
;
320 /* Read commands from STREAM. */
322 read_command_file (FILE *stream
)
324 struct ui
*ui
= current_ui
;
326 unbuffer_stream (stream
);
328 scoped_restore save_instream
329 = make_scoped_restore (&ui
->instream
, stream
);
331 /* Read commands from `instream' and execute them until end of file
332 or error reading instream. */
334 while (ui
->instream
!= NULL
&& !feof (ui
->instream
))
336 /* Get a command-line. This calls the readline package. */
337 std::string command_buffer
;
339 = command_line_input (command_buffer
, nullptr, nullptr);
340 if (command
== nullptr)
342 command_handler (command
);
348 do_chdir_cleanup (void *old_dir
)
350 chdir ((const char *) old_dir
);
356 prepare_execute_command ()
358 /* With multiple threads running while the one we're examining is
359 stopped, the dcache can get stale without us being able to detect
360 it. For the duration of the command, though, use the dcache to
361 help things like backtrace. */
363 target_dcache_invalidate (current_program_space
->aspace
);
365 return scoped_value_mark ();
368 /* Tell the user if the language has changed (except first time) after
369 executing a command. */
372 check_frame_language_change (void)
374 static int warned
= 0;
375 frame_info_ptr frame
;
377 /* First make sure that a new frame has been selected, in case the
378 command or the hooks changed the program state. */
379 frame
= deprecated_safe_get_selected_frame ();
380 if (current_language
!= expected_language
)
382 if (language_mode
== language_mode_auto
&& info_verbose
)
384 /* Print what changed. */
390 /* Warn the user if the working language does not match the language
391 of the current frame. Only warn the user if we are actually
392 running the program, i.e. there is a stack. */
393 /* FIXME: This should be cacheing the frame and only running when
394 the frame changes. */
396 if (has_stack_frames ())
400 flang
= get_frame_language (frame
);
402 && flang
!= language_unknown
403 && flang
!= current_language
->la_language
)
405 gdb_printf ("%s\n", _(lang_frame_mismatch_warn
));
414 wait_sync_command_done (void)
416 /* Processing events may change the current UI. */
417 scoped_restore save_ui
= make_scoped_restore (¤t_ui
);
418 struct ui
*ui
= current_ui
;
420 /* We're about to wait until the target stops after having resumed
421 it so must force-commit resumptions, in case we're being called
422 in some context where a scoped_disable_commit_resumed object is
423 active. I.e., this function is a commit-resumed sync/flush
425 scoped_enable_commit_resumed
enable ("sync wait");
427 while (gdb_do_one_event () >= 0)
428 if (ui
->prompt_state
!= PROMPT_BLOCKED
)
435 maybe_wait_sync_command_done (int was_sync
)
437 /* If the interpreter is in sync mode (we're running a user
438 command's list, running command hooks or similars), and we
439 just ran a synchronous command that started the target, wait
440 for that command to end. */
441 if (!current_ui
->async
443 && current_ui
->prompt_state
== PROMPT_BLOCKED
)
444 wait_sync_command_done ();
450 set_repeat_arguments (const char *args
)
452 repeat_arguments
= args
;
455 /* Execute the line P as a command, in the current user context.
456 Pass FROM_TTY as second argument to the defining function. */
459 execute_command (const char *p
, int from_tty
)
461 struct cmd_list_element
*c
;
463 const char *cmd_start
= p
;
465 auto cleanup_if_error
= make_scope_exit (bpstat_clear_actions
);
466 scoped_value_mark cleanup
= prepare_execute_command ();
468 /* This can happen when command_line_input hits end of file. */
471 cleanup_if_error
.release ();
475 std::string cmd_copy
= p
;
477 target_log_command (p
);
479 while (*p
== ' ' || *p
== '\t')
485 std::string default_args
;
486 std::string default_args_and_arg
;
487 int was_sync
= current_ui
->prompt_state
== PROMPT_BLOCKED
;
491 /* If trace-commands is set then this will print this command. */
492 print_command_trace ("%s", p
);
494 c
= lookup_cmd (&cmd
, cmdlist
, "", &default_args
, 0, 1);
497 scoped_restore save_repeat_args
498 = make_scoped_restore (&repeat_arguments
, nullptr);
499 const char *args_pointer
= p
;
501 if (!default_args
.empty ())
504 default_args_and_arg
= default_args
+ ' ' + p
;
506 default_args_and_arg
= default_args
;
507 arg
= default_args_and_arg
.c_str ();
511 /* Pass null arg rather than an empty one. */
512 arg
= *p
== '\0' ? nullptr : p
;
515 /* FIXME: cagney/2002-02-02: The c->type test is pretty dodgy
516 while the is_complete_command(cfunc) test is just plain
517 bogus. They should both be replaced by a test of the form
518 c->strip_trailing_white_space_p. */
519 /* NOTE: cagney/2002-02-02: The function.cfunc in the below
520 can't be replaced with func. This is because it is the
521 cfunc, and not the func, that has the value that the
522 is_complete_command hack is testing for. */
523 /* Clear off trailing whitespace, except for set and complete
525 std::string without_whitespace
;
527 && c
->type
!= set_cmd
528 && !is_complete_command (c
))
530 const char *old_end
= arg
+ strlen (arg
) - 1;
532 while (p
>= arg
&& (*p
== ' ' || *p
== '\t'))
536 without_whitespace
= std::string (arg
, p
+ 1);
537 arg
= without_whitespace
.c_str ();
541 /* If this command has been pre-hooked, run the hook first. */
542 execute_cmd_pre_hook (c
);
544 if (c
->deprecated_warn_user
)
545 deprecated_cmd_warning (line
, cmdlist
);
547 /* c->user_commands would be NULL in the case of a python command. */
548 if (c
->theclass
== class_user
&& c
->user_commands
)
549 execute_user_command (c
, arg
);
550 else if (c
->theclass
== class_user
551 && c
->is_prefix () && !c
->allow_unknown
)
552 /* If this is a user defined prefix that does not allow unknown
553 (in other words, C is a prefix command and not a command
554 that can be followed by its args), report the list of
557 std::string prefixname
= c
->prefixname ();
558 std::string prefixname_no_space
559 = prefixname
.substr (0, prefixname
.length () - 1);
561 ("\"%s\" must be followed by the name of a subcommand.\n",
562 prefixname_no_space
.c_str ());
563 help_list (*c
->subcommands
, prefixname
.c_str (), all_commands
,
566 else if (c
->type
== set_cmd
)
567 do_set_command (arg
, from_tty
, c
);
568 else if (c
->type
== show_cmd
)
569 do_show_command (arg
, from_tty
, c
);
570 else if (c
->is_command_class_help ())
571 error (_("That is not a command, just a help topic."));
572 else if (deprecated_call_command_hook
)
573 deprecated_call_command_hook (c
, arg
, from_tty
);
575 cmd_func (c
, arg
, from_tty
);
577 maybe_wait_sync_command_done (was_sync
);
579 /* If this command has been post-hooked, run the hook last.
580 We need to lookup the command again since during its execution,
581 a command may redefine itself. In this case, C pointer
582 becomes invalid so we need to look it up again. */
583 const char *cmd2
= cmd_copy
.c_str ();
584 c
= lookup_cmd (&cmd2
, cmdlist
, "", nullptr, 1, 1);
586 execute_cmd_post_hook (c
);
588 if (repeat_arguments
!= NULL
&& cmd_start
== saved_command_line
)
590 gdb_assert (strlen (args_pointer
) >= strlen (repeat_arguments
));
591 strcpy (saved_command_line
+ (args_pointer
- cmd_start
),
596 /* Only perform the frame-language-change check if the command
597 we just finished executing did not resume the inferior's execution.
598 If it did resume the inferior, we will do that check after
599 the inferior stopped. */
600 if (has_stack_frames () && inferior_thread ()->state
!= THREAD_RUNNING
)
601 check_frame_language_change ();
603 cleanup_if_error
.release ();
609 execute_fn_to_ui_file (struct ui_file
*file
, std::function
<void(void)> fn
)
611 /* GDB_STDOUT should be better already restored during these
612 restoration callbacks. */
613 set_batch_flag_and_restore_page_info save_page_info
;
615 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
618 ui_out_redirect_pop
redirect_popper (current_uiout
, file
);
620 scoped_restore save_stdout
621 = make_scoped_restore (&gdb_stdout
, file
);
622 scoped_restore save_stderr
623 = make_scoped_restore (&gdb_stderr
, file
);
624 scoped_restore save_stdlog
625 = make_scoped_restore (&gdb_stdlog
, file
);
626 scoped_restore save_stdtarg
627 = make_scoped_restore (&gdb_stdtarg
, file
);
628 scoped_restore save_stdtargerr
629 = make_scoped_restore (&gdb_stdtargerr
, file
);
638 execute_fn_to_string (std::string
&res
, std::function
<void(void)> fn
,
641 string_file
str_file (term_out
);
645 execute_fn_to_ui_file (&str_file
, fn
);
650 res
= str_file
.release ();
655 res
= str_file
.release ();
661 execute_command_to_ui_file (struct ui_file
*file
,
662 const char *p
, int from_tty
)
664 execute_fn_to_ui_file (file
, [=]() { execute_command (p
, from_tty
); });
670 execute_command_to_string (std::string
&res
, const char *p
, int from_tty
,
673 execute_fn_to_string (res
, [=]() { execute_command (p
, from_tty
); },
680 execute_command_to_string (const char *p
, int from_tty
,
684 execute_fn_to_string (dummy
, [=]() { execute_command (p
, from_tty
); },
688 /* When nonzero, cause dont_repeat to do nothing. This should only be
689 set via prevent_dont_repeat. */
691 static int suppress_dont_repeat
= 0;
698 struct ui
*ui
= current_ui
;
700 if (suppress_dont_repeat
|| server_command
)
703 /* If we aren't reading from standard input, we are saving the last
704 thing read from stdin in line and don't want to delete it. Null
705 lines won't repeat here in any case. */
706 if (ui
->instream
== ui
->stdin_stream
)
708 *saved_command_line
= 0;
709 repeat_arguments
= NULL
;
718 /* Do not repeat this command, as this command is a repeating command. */
721 /* We cannot free saved_command_line, as this line is being executed,
722 so swap it with previous_saved_command_line. */
723 std::swap (previous_saved_command_line
, saved_command_line
);
724 std::swap (previous_repeat_arguments
, repeat_arguments
);
726 const char *prev
= skip_spaces (get_saved_command_line ());
728 error (_("No previous command to relaunch"));
734 scoped_restore_tmpl
<int>
735 prevent_dont_repeat (void)
737 return make_scoped_restore (&suppress_dont_repeat
, 1);
743 get_saved_command_line ()
745 return saved_command_line
;
751 save_command_line (const char *cmd
)
753 xfree (previous_saved_command_line
);
754 previous_saved_command_line
= saved_command_line
;
755 previous_repeat_arguments
= repeat_arguments
;
756 saved_command_line
= xstrdup (cmd
);
757 repeat_arguments
= NULL
;
761 /* Read a line from the stream "instream" without command line editing.
763 It prints PROMPT once at the start.
764 Action is compatible with "readline", e.g. space for the result is
765 malloc'd and should be freed by the caller.
767 A NULL return means end of file. */
769 static gdb::unique_xmalloc_ptr
<char>
770 gdb_readline_no_editing (const char *prompt
)
772 std::string line_buffer
;
773 struct ui
*ui
= current_ui
;
774 /* Read from stdin if we are executing a user defined command. This
775 is the right thing for prompt_for_continue, at least. */
776 FILE *stream
= ui
->instream
!= NULL
? ui
->instream
: stdin
;
777 int fd
= fileno (stream
);
781 /* Don't use a _filtered function here. It causes the assumed
782 character position to be off, since the newline we read from
783 the user is not accounted for. */
784 printf_unfiltered ("%s", prompt
);
785 gdb_flush (gdb_stdout
);
795 /* Wait until at least one byte of data is available. Control-C
796 can interrupt interruptible_select, but not fgetc. */
798 FD_SET (fd
, &readfds
);
799 if (interruptible_select (fd
+ 1, &readfds
, NULL
, NULL
, NULL
) == -1)
803 /* If this was ctrl-c, the QUIT above handles it. */
806 perror_with_name (("select"));
813 if (!line_buffer
.empty ())
814 /* The last line does not end with a newline. Return it, and
815 if we are called again fgetc will still return EOF and
816 we'll return NULL then. */
823 if (!line_buffer
.empty () && line_buffer
.back () == '\r')
824 line_buffer
.pop_back ();
831 return make_unique_xstrdup (line_buffer
.c_str ());
834 /* Variables which control command line editing and history
835 substitution. These variables are given default values at the end
837 static bool command_editing_p
;
839 /* NOTE 1999-04-29: This variable will be static again, once we modify
840 gdb to use the event loop as the default command loop and we merge
841 event-top.c into this file, top.c. */
843 /* static */ bool history_expansion_p
;
845 /* Should we write out the command history on exit? In order to write out
846 the history both this flag must be true, and the history_filename
847 variable must be set to something sensible. */
848 static bool write_history_p
;
850 /* The name of the file in which GDB history will be written. If this is
851 set to NULL, of the empty string then history will not be written. */
852 static std::string history_filename
;
854 /* Implement 'show history save'. */
856 show_write_history_p (struct ui_file
*file
, int from_tty
,
857 struct cmd_list_element
*c
, const char *value
)
859 if (!write_history_p
|| !history_filename
.empty ())
860 gdb_printf (file
, _("Saving of the history record on exit is %s.\n"),
863 gdb_printf (file
, _("Saving of the history is disabled due to "
864 "the value of 'history filename'.\n"));
867 /* The variable associated with the "set/show history size"
868 command. The value -1 means unlimited, and -2 means undefined. */
869 static int history_size_setshow_var
= -2;
872 show_history_size (struct ui_file
*file
, int from_tty
,
873 struct cmd_list_element
*c
, const char *value
)
875 gdb_printf (file
, _("The size of the command history is %s.\n"),
879 /* Variable associated with the "history remove-duplicates" option.
880 The value -1 means unlimited. */
881 static int history_remove_duplicates
= 0;
884 show_history_remove_duplicates (struct ui_file
*file
, int from_tty
,
885 struct cmd_list_element
*c
, const char *value
)
888 _("The number of history entries to look back at for "
889 "duplicates is %s.\n"),
893 /* Implement 'show history filename'. */
895 show_history_filename (struct ui_file
*file
, int from_tty
,
896 struct cmd_list_element
*c
, const char *value
)
898 if (!history_filename
.empty ())
899 gdb_printf (file
, _("The filename in which to record "
900 "the command history is \"%ps\".\n"),
901 styled_string (file_name_style
.style (), value
));
903 gdb_printf (file
, _("There is no filename currently set for "
904 "recording the command history in.\n"));
907 /* This is like readline(), but it has some gdb-specific behavior.
908 gdb may want readline in both the synchronous and async modes during
909 a single gdb invocation. At the ordinary top-level prompt we might
910 be using the async readline. That means we can't use
911 rl_pre_input_hook, since it doesn't work properly in async mode.
912 However, for a secondary prompt (" >", such as occurs during a
913 `define'), gdb wants a synchronous response.
915 We used to call readline() directly, running it in synchronous
916 mode. But mixing modes this way is not supported, and as of
917 readline 5.x it no longer works; the arrow keys come unbound during
918 the synchronous call. So we make a nested call into the event
919 loop. That's what gdb_readline_wrapper is for. */
921 /* A flag set as soon as gdb_readline_wrapper_line is called; we can't
922 rely on gdb_readline_wrapper_result, which might still be NULL if
923 the user types Control-D for EOF. */
924 static int gdb_readline_wrapper_done
;
926 /* The result of the current call to gdb_readline_wrapper, once a newline
928 static char *gdb_readline_wrapper_result
;
930 /* Any intercepted hook. Operate-and-get-next sets this, expecting it
931 to be called after the newline is processed (which will redisplay
932 the prompt). But in gdb_readline_wrapper we will not get a new
933 prompt until the next call, or until we return to the event loop.
934 So we disable this hook around the newline and restore it before we
936 static void (*saved_after_char_processing_hook
) (void);
942 gdb_in_secondary_prompt_p (struct ui
*ui
)
944 return ui
->secondary_prompt_depth
> 0;
948 /* This function is called when readline has seen a complete line of
952 gdb_readline_wrapper_line (gdb::unique_xmalloc_ptr
<char> &&line
)
954 gdb_assert (!gdb_readline_wrapper_done
);
955 gdb_readline_wrapper_result
= line
.release ();
956 gdb_readline_wrapper_done
= 1;
958 /* Prevent operate-and-get-next from acting too early. */
959 saved_after_char_processing_hook
= after_char_processing_hook
;
960 after_char_processing_hook
= NULL
;
964 tui_inject_newline_into_command_window ();
967 /* Prevent parts of the prompt from being redisplayed if annotations
968 are enabled, and readline's state getting out of sync. We'll
969 reinstall the callback handler, which puts the terminal in raw
970 mode (or in readline lingo, in prepped state), when we're next
971 ready to process user input, either in display_gdb_prompt, or if
972 we're handling an asynchronous target event and running in the
973 background, just before returning to the event loop to process
974 further input (or more target events). */
975 if (current_ui
->command_editing
)
976 gdb_rl_callback_handler_remove ();
979 class gdb_readline_wrapper_cleanup
982 gdb_readline_wrapper_cleanup ()
983 : m_handler_orig (current_ui
->input_handler
),
984 m_already_prompted_orig (current_ui
->command_editing
985 ? rl_already_prompted
: 0),
986 m_target_is_async_orig (target_is_async_p ()),
987 m_save_ui (¤t_ui
)
989 current_ui
->input_handler
= gdb_readline_wrapper_line
;
990 current_ui
->secondary_prompt_depth
++;
992 if (m_target_is_async_orig
)
993 target_async (false);
996 ~gdb_readline_wrapper_cleanup ()
998 struct ui
*ui
= current_ui
;
1000 if (ui
->command_editing
)
1001 rl_already_prompted
= m_already_prompted_orig
;
1003 gdb_assert (ui
->input_handler
== gdb_readline_wrapper_line
);
1004 ui
->input_handler
= m_handler_orig
;
1006 /* Don't restore our input handler in readline yet. That would make
1007 readline prep the terminal (putting it in raw mode), while the
1008 line we just read may trigger execution of a command that expects
1009 the terminal in the default cooked/canonical mode, such as e.g.,
1010 running Python's interactive online help utility. See
1011 gdb_readline_wrapper_line for when we'll reinstall it. */
1013 gdb_readline_wrapper_result
= NULL
;
1014 gdb_readline_wrapper_done
= 0;
1015 ui
->secondary_prompt_depth
--;
1016 gdb_assert (ui
->secondary_prompt_depth
>= 0);
1018 after_char_processing_hook
= saved_after_char_processing_hook
;
1019 saved_after_char_processing_hook
= NULL
;
1021 if (m_target_is_async_orig
)
1022 target_async (true);
1025 DISABLE_COPY_AND_ASSIGN (gdb_readline_wrapper_cleanup
);
1029 void (*m_handler_orig
) (gdb::unique_xmalloc_ptr
<char> &&);
1030 int m_already_prompted_orig
;
1032 /* Whether the target was async. */
1033 int m_target_is_async_orig
;
1035 /* Processing events may change the current UI. */
1036 scoped_restore_tmpl
<struct ui
*> m_save_ui
;
1040 gdb_readline_wrapper (const char *prompt
)
1042 struct ui
*ui
= current_ui
;
1044 gdb_readline_wrapper_cleanup cleanup
;
1046 /* Display our prompt and prevent double prompt display. Don't pass
1047 down a NULL prompt, since that has special meaning for
1048 display_gdb_prompt -- it indicates a request to print the primary
1049 prompt, while we want a secondary prompt here. */
1050 display_gdb_prompt (prompt
!= NULL
? prompt
: "");
1051 if (ui
->command_editing
)
1052 rl_already_prompted
= 1;
1054 if (after_char_processing_hook
)
1055 (*after_char_processing_hook
) ();
1056 gdb_assert (after_char_processing_hook
== NULL
);
1058 while (gdb_do_one_event () >= 0)
1059 if (gdb_readline_wrapper_done
)
1062 return gdb_readline_wrapper_result
;
1066 /* The current saved history number from operate-and-get-next.
1067 This is -1 if not valid. */
1068 static int operate_saved_history
= -1;
1070 /* This is put on the appropriate hook and helps operate-and-get-next
1073 gdb_rl_operate_and_get_next_completion (void)
1075 int delta
= where_history () - operate_saved_history
;
1077 /* The `key' argument to rl_get_previous_history is ignored. */
1078 rl_get_previous_history (delta
, 0);
1079 operate_saved_history
= -1;
1081 /* readline doesn't automatically update the display for us. */
1084 after_char_processing_hook
= NULL
;
1085 rl_pre_input_hook
= NULL
;
1088 /* This is a gdb-local readline command handler. It accepts the
1089 current command line (like RET does) and, if this command was taken
1090 from the history, arranges for the next command in the history to
1091 appear on the command line when the prompt returns.
1092 We ignore the arguments. */
1094 gdb_rl_operate_and_get_next (int count
, int key
)
1098 /* Use the async hook. */
1099 after_char_processing_hook
= gdb_rl_operate_and_get_next_completion
;
1101 /* Find the current line, and find the next line to use. */
1102 where
= where_history();
1104 if ((history_is_stifled () && (history_length
>= history_max_entries
))
1105 || (where
>= history_length
- 1))
1106 operate_saved_history
= where
;
1108 operate_saved_history
= where
+ 1;
1110 return rl_newline (1, key
);
1113 /* Number of user commands executed during this session. */
1115 static int command_count
= 0;
1117 /* Add the user command COMMAND to the input history list. */
1120 gdb_add_history (const char *command
)
1124 if (history_remove_duplicates
!= 0)
1127 int lookbehind_threshold
;
1129 /* The lookbehind threshold for finding a duplicate history entry is
1130 bounded by command_count because we can't meaningfully delete
1131 history entries that are already stored in the history file since
1132 the history file is appended to. */
1133 if (history_remove_duplicates
== -1
1134 || history_remove_duplicates
> command_count
)
1135 lookbehind_threshold
= command_count
;
1137 lookbehind_threshold
= history_remove_duplicates
;
1140 for (lookbehind
= 0; lookbehind
< lookbehind_threshold
; lookbehind
++)
1142 HIST_ENTRY
*temp
= previous_history ();
1147 if (strcmp (temp
->line
, command
) == 0)
1149 HIST_ENTRY
*prev
= remove_history (where_history ());
1151 free_history_entry (prev
);
1158 add_history (command
);
1161 /* Safely append new history entries to the history file in a corruption-free
1162 way using an intermediate local history file. */
1165 gdb_safe_append_history (void)
1167 int ret
, saved_errno
;
1169 std::string local_history_filename
1170 = string_printf ("%s-gdb%ld~", history_filename
.c_str (), (long) getpid ());
1172 ret
= rename (history_filename
.c_str (), local_history_filename
.c_str ());
1173 saved_errno
= errno
;
1174 if (ret
< 0 && saved_errno
!= ENOENT
)
1176 warning (_("Could not rename %ps to %ps: %s"),
1177 styled_string (file_name_style
.style (),
1178 history_filename
.c_str ()),
1179 styled_string (file_name_style
.style (),
1180 local_history_filename
.c_str ()),
1181 safe_strerror (saved_errno
));
1187 /* If the rename failed with ENOENT then either the global history
1188 file never existed in the first place or another GDB process is
1189 currently appending to it (and has thus temporarily renamed it).
1190 Since we can't distinguish between these two cases, we have to
1191 conservatively assume the first case and therefore must write out
1192 (not append) our known history to our local history file and try
1193 to move it back anyway. Otherwise a global history file would
1194 never get created! */
1195 gdb_assert (saved_errno
== ENOENT
);
1196 write_history (local_history_filename
.c_str ());
1200 append_history (command_count
, local_history_filename
.c_str ());
1201 if (history_is_stifled ())
1202 history_truncate_file (local_history_filename
.c_str (),
1203 history_max_entries
);
1206 ret
= rename (local_history_filename
.c_str (), history_filename
.c_str ());
1207 saved_errno
= errno
;
1208 if (ret
< 0 && saved_errno
!= EEXIST
)
1209 warning (_("Could not rename %s to %s: %s"),
1210 local_history_filename
.c_str (), history_filename
.c_str (),
1211 safe_strerror (saved_errno
));
1215 /* Read one line from the command input stream `instream'.
1217 CMD_LINE_BUFFER is a buffer that the function may use to store the result, if
1218 it needs to be dynamically-allocated. Otherwise, it is unused.string
1220 Return nullptr for end of file.
1222 This routine either uses fancy command line editing or simple input
1223 as the user has requested. */
1226 command_line_input (std::string
&cmd_line_buffer
, const char *prompt_arg
,
1227 const char *annotation_suffix
)
1229 struct ui
*ui
= current_ui
;
1230 const char *prompt
= prompt_arg
;
1232 int from_tty
= ui
->instream
== ui
->stdin_stream
;
1234 /* The annotation suffix must be non-NULL. */
1235 if (annotation_suffix
== NULL
)
1236 annotation_suffix
= "";
1238 if (from_tty
&& annotation_level
> 1)
1243 = (char *) alloca ((prompt
== NULL
? 0 : strlen (prompt
))
1244 + strlen (annotation_suffix
) + 40);
1246 local_prompt
[0] = '\0';
1248 strcpy (local_prompt
, prompt
);
1249 strcat (local_prompt
, "\n\032\032");
1250 strcat (local_prompt
, annotation_suffix
);
1251 strcat (local_prompt
, "\n");
1253 prompt
= local_prompt
;
1258 signal (SIGTSTP
, handle_sigtstp
);
1263 gdb::unique_xmalloc_ptr
<char> rl
;
1265 /* Make sure that all output has been output. Some machines may
1266 let you get away with leaving out some of the gdb_flush, but
1268 gdb_flush (gdb_stdout
);
1269 gdb_flush (gdb_stderr
);
1271 if (!source_file_name
.empty ())
1272 ++source_line_number
;
1274 if (from_tty
&& annotation_level
> 1)
1275 printf_unfiltered ("\n\032\032pre-%s\n", annotation_suffix
);
1277 /* Don't use fancy stuff if not talking to stdin. */
1278 if (deprecated_readline_hook
1280 && current_ui
->input_interactive_p ())
1282 rl
.reset ((*deprecated_readline_hook
) (prompt
));
1284 else if (command_editing_p
1286 && current_ui
->input_interactive_p ())
1288 rl
.reset (gdb_readline_wrapper (prompt
));
1292 rl
= gdb_readline_no_editing (prompt
);
1295 cmd
= handle_line_of_input (cmd_line_buffer
, rl
.get (),
1296 0, annotation_suffix
);
1297 if (cmd
== (char *) EOF
)
1305 /* Got partial input. I.e., got a line that ends with a
1306 continuation character (backslash). Suppress printing the
1313 signal (SIGTSTP
, SIG_DFL
);
1321 print_gdb_version (struct ui_file
*stream
, bool interactive
)
1323 /* From GNU coding standards, first line is meant to be easy for a
1324 program to parse, and is just canonical program name and version
1325 number, which starts after last space. */
1327 std::string v_str
= string_printf ("GNU gdb %s%s", PKGVERSION
, version
);
1328 gdb_printf (stream
, "%ps\n",
1329 styled_string (version_style
.style (), v_str
.c_str ()));
1331 /* Second line is a copyright notice. */
1334 "Copyright (C) 2023 Free Software Foundation, Inc.\n");
1336 /* Following the copyright is a brief statement that the program is
1337 free software, that users are free to copy and change it on
1338 certain conditions, that it is covered by the GNU GPL, and that
1339 there is no warranty. */
1341 gdb_printf (stream
, "\
1342 License GPLv3+: GNU GPL version 3 or later <%ps>\
1343 \nThis is free software: you are free to change and redistribute it.\n\
1344 There is NO WARRANTY, to the extent permitted by law.",
1345 styled_string (file_name_style
.style (),
1346 "http://gnu.org/licenses/gpl.html"));
1351 gdb_printf (stream
, ("\nType \"show copying\" and "
1352 "\"show warranty\" for details.\n"));
1354 /* After the required info we print the configuration information. */
1356 gdb_printf (stream
, "This GDB was configured as \"");
1357 if (strcmp (host_name
, target_name
) != 0)
1359 gdb_printf (stream
, "--host=%s --target=%s",
1360 host_name
, target_name
);
1364 gdb_printf (stream
, "%s", host_name
);
1366 gdb_printf (stream
, "\".\n");
1368 gdb_printf (stream
, _("Type \"show configuration\" "
1369 "for configuration details.\n"));
1371 if (REPORT_BUGS_TO
[0])
1374 _("For bug reporting instructions, please see:\n"));
1375 gdb_printf (stream
, "%ps.\n",
1376 styled_string (file_name_style
.style (),
1380 _("Find the GDB manual and other documentation \
1381 resources online at:\n <%ps>."),
1382 styled_string (file_name_style
.style (),
1383 "http://www.gnu.org/software/gdb/documentation/"));
1384 gdb_printf (stream
, "\n\n");
1385 gdb_printf (stream
, _("For help, type \"help\".\n"));
1387 _("Type \"apropos word\" to search for commands \
1388 related to \"word\"."));
1391 /* Print the details of GDB build-time configuration. */
1393 print_gdb_configuration (struct ui_file
*stream
)
1395 gdb_printf (stream
, _("\
1396 This GDB was configured as follows:\n\
1397 configure --host=%s --target=%s\n\
1398 "), host_name
, target_name
);
1400 gdb_printf (stream
, _("\
1401 --with-auto-load-dir=%s\n\
1402 --with-auto-load-safe-path=%s\n\
1403 "), AUTO_LOAD_DIR
, AUTO_LOAD_SAFE_PATH
);
1406 gdb_printf (stream
, _("\
1410 gdb_printf (stream
, _("\
1416 gdb_printf (stream
, _("\
1417 --with-gdb-datadir=%s%s\n\
1418 "), GDB_DATADIR
, GDB_DATADIR_RELOCATABLE
? " (relocatable)" : "");
1421 gdb_printf (stream
, _("\
1422 --with-iconv-bin=%s%s\n\
1423 "), ICONV_BIN
, ICONV_BIN_RELOCATABLE
? " (relocatable)" : "");
1426 if (JIT_READER_DIR
[0])
1427 gdb_printf (stream
, _("\
1428 --with-jit-reader-dir=%s%s\n\
1429 "), JIT_READER_DIR
, JIT_READER_DIR_RELOCATABLE
? " (relocatable)" : "");
1431 #if HAVE_LIBUNWIND_IA64_H
1432 gdb_printf (stream
, _("\
1433 --with-libunwind-ia64\n\
1436 gdb_printf (stream
, _("\
1437 --without-libunwind-ia64\n\
1442 gdb_printf (stream
, _("\
1446 gdb_printf (stream
, _("\
1451 #if HAVE_LIBBABELTRACE
1452 gdb_printf (stream
, _("\
1453 --with-babeltrace\n\
1456 gdb_printf (stream
, _("\
1457 --without-babeltrace\n\
1462 gdb_printf (stream
, _("\
1466 gdb_printf (stream
, _("\
1467 --without-intel-pt\n\
1472 gdb_printf (stream
, _("\
1476 gdb_printf (stream
, _("\
1480 #ifdef WITH_PYTHON_PATH
1481 gdb_printf (stream
, _("\
1482 --with-python=%s%s\n\
1483 "), WITH_PYTHON_PATH
, PYTHON_PATH_RELOCATABLE
? " (relocatable)" : "");
1485 gdb_printf (stream
, _("\
1489 #ifdef WITH_PYTHON_LIBDIR
1490 gdb_printf (stream
, _("\
1491 --with-python-libdir=%s%s\n\
1492 "), WITH_PYTHON_LIBDIR
, PYTHON_LIBDIR_RELOCATABLE
? " (relocatable)" : "");
1494 gdb_printf (stream
, _("\
1495 --without-python-libdir\n\
1499 #if HAVE_LIBDEBUGINFOD
1500 gdb_printf (stream
, _("\
1501 --with-debuginfod\n\
1504 gdb_printf (stream
, _("\
1505 --without-debuginfod\n\
1510 gdb_printf (stream
, _("\
1514 gdb_printf (stream
, _("\
1520 gdb_printf (stream
, _("\
1524 gdb_printf (stream
, _("\
1530 gdb_printf (stream
, _("\
1531 --with-amd-dbgapi\n\
1534 gdb_printf (stream
, _("\
1535 --without-amd-dbgapi\n\
1539 #if HAVE_SOURCE_HIGHLIGHT
1540 gdb_printf (stream
, _("\
1541 --enable-source-highlight\n\
1544 gdb_printf (stream
, _("\
1545 --disable-source-highlight\n\
1550 gdb_printf (stream
, _("\
1551 --enable-threading\n\
1554 gdb_printf (stream
, _("\
1555 --disable-threading\n\
1560 gdb_printf (stream
, _("\
1564 gdb_printf (stream
, _("\
1569 #ifdef HAVE_READLINE_READLINE_H
1570 gdb_printf (stream
, _("\
1571 --with-system-readline\n\
1574 gdb_printf (stream
, _("\
1575 --without-system-readline\n\
1580 gdb_printf (stream
, _("\
1581 --with-relocated-sources=%s\n\
1586 gdb_printf (stream
, _("\
1587 --with-separate-debug-dir=%s%s\n\
1588 "), DEBUGDIR
, DEBUGDIR_RELOCATABLE
? " (relocatable)" : "");
1590 #ifdef ADDITIONAL_DEBUG_DIRS
1591 gdb_printf (stream
, _ ("\
1592 --with-additional-debug-dirs=%s\n\
1593 "), ADDITIONAL_DEBUG_DIRS
);
1596 if (TARGET_SYSTEM_ROOT
[0])
1597 gdb_printf (stream
, _("\
1598 --with-sysroot=%s%s\n\
1599 "), TARGET_SYSTEM_ROOT
, TARGET_SYSTEM_ROOT_RELOCATABLE
? " (relocatable)" : "");
1601 if (SYSTEM_GDBINIT
[0])
1602 gdb_printf (stream
, _("\
1603 --with-system-gdbinit=%s%s\n\
1604 "), SYSTEM_GDBINIT
, SYSTEM_GDBINIT_RELOCATABLE
? " (relocatable)" : "");
1606 if (SYSTEM_GDBINIT_DIR
[0])
1607 gdb_printf (stream
, _("\
1608 --with-system-gdbinit-dir=%s%s\n\
1609 "), SYSTEM_GDBINIT_DIR
, SYSTEM_GDBINIT_DIR_RELOCATABLE
? " (relocatable)" : "");
1611 /* We assume "relocatable" will be printed at least once, thus we always
1612 print this text. It's a reasonably safe assumption for now. */
1613 gdb_printf (stream
, _("\n\
1614 (\"Relocatable\" means the directory can be moved with the GDB installation\n\
1615 tree, and GDB will still find it.)\n\
1620 /* The current top level prompt, settable with "set prompt", and/or
1621 with the python `gdb.prompt_hook' hook. */
1622 static std::string top_prompt
;
1624 /* Access method for the GDB prompt string. */
1632 /* Set method for the GDB prompt string. */
1635 set_prompt (const char *s
)
1641 /* Kills or detaches the given inferior, depending on how we originally
1642 gained control of it. */
1645 kill_or_detach (inferior
*inf
, int from_tty
)
1650 thread_info
*thread
= any_thread_of_inferior (inf
);
1653 switch_to_thread (thread
);
1655 /* Leave core files alone. */
1656 if (target_has_execution ())
1658 if (inf
->attach_flag
)
1659 target_detach (inf
, from_tty
);
1666 /* Prints info about what GDB will do to inferior INF on a "quit". OUT is
1667 where to collect the output. */
1670 print_inferior_quit_action (inferior
*inf
, ui_file
*out
)
1675 if (inf
->attach_flag
)
1677 _("\tInferior %d [%s] will be detached.\n"), inf
->num
,
1678 target_pid_to_str (ptid_t (inf
->pid
)).c_str ());
1681 _("\tInferior %d [%s] will be killed.\n"), inf
->num
,
1682 target_pid_to_str (ptid_t (inf
->pid
)).c_str ());
1685 /* If necessary, make the user confirm that we should quit. Return
1686 non-zero if we should quit, zero if we shouldn't. */
1691 /* Don't even ask if we're only debugging a core file inferior. */
1692 if (!have_live_inferiors ())
1695 /* Build the query string as a single string. */
1698 stb
.puts (_("A debugging session is active.\n\n"));
1700 for (inferior
*inf
: all_inferiors ())
1701 print_inferior_quit_action (inf
, &stb
);
1703 stb
.puts (_("\nQuit anyway? "));
1705 return query ("%s", stb
.c_str ());
1708 /* Prepare to exit GDB cleanly by undoing any changes made to the
1709 terminal so that we leave the terminal in the state we acquired it. */
1712 undo_terminal_modifications_before_exit (void)
1714 struct ui
*saved_top_level
= current_ui
;
1716 target_terminal::ours ();
1718 current_ui
= main_ui
;
1723 gdb_disable_readline ();
1725 current_ui
= saved_top_level
;
1729 /* Quit without asking for confirmation. */
1732 quit_force (int *exit_arg
, int from_tty
)
1736 /* Clear the quit flag and sync_quit_force_run so that a
1737 gdb_exception_forced_quit isn't inadvertently triggered by a QUIT
1738 check while running the various cleanup/exit code below. Note
1739 that the call to 'check_quit_flag' clears the quit flag as a side
1742 sync_quit_force_run
= false;
1744 /* An optional expression may be used to cause gdb to terminate with the
1745 value of that expression. */
1747 exit_code
= *exit_arg
;
1748 else if (return_child_result
)
1749 exit_code
= return_child_result_value
;
1751 gdb::observers::gdb_exiting
.notify (exit_code
);
1753 undo_terminal_modifications_before_exit ();
1755 /* We want to handle any quit errors and exit regardless. */
1757 /* Get out of tfind mode, and kill or detach all inferiors. */
1760 disconnect_tracing ();
1761 for (inferior
*inf
: all_inferiors ())
1762 kill_or_detach (inf
, from_tty
);
1764 catch (const gdb_exception
&ex
)
1766 exception_print (gdb_stderr
, ex
);
1769 /* Give all pushed targets a chance to do minimal cleanup, and pop
1771 for (inferior
*inf
: all_inferiors ())
1775 inf
->pop_all_targets ();
1777 catch (const gdb_exception
&ex
)
1779 exception_print (gdb_stderr
, ex
);
1783 /* Save the history information if it is appropriate to do so. */
1786 if (write_history_p
&& !history_filename
.empty ())
1790 /* History is currently shared between all UIs. If there's
1791 any UI with a terminal, save history. */
1792 for (ui
*ui
: all_uis ())
1794 if (ui
->input_interactive_p ())
1802 gdb_safe_append_history ();
1805 catch (const gdb_exception
&ex
)
1807 exception_print (gdb_stderr
, ex
);
1810 /* Destroy any values currently allocated now instead of leaving it
1811 to global destructors, because that may be too late. For
1812 example, the destructors of xmethod values call into the Python
1813 runtime, which is finalized via a final cleanup. */
1816 /* Do any final cleanups before exiting. */
1819 do_final_cleanups ();
1821 catch (const gdb_exception
&ex
)
1823 exception_print (gdb_stderr
, ex
);
1831 auto_boolean interactive_mode
= AUTO_BOOLEAN_AUTO
;
1833 /* Implement the "show interactive-mode" option. */
1836 show_interactive_mode (struct ui_file
*file
, int from_tty
,
1837 struct cmd_list_element
*c
,
1840 if (interactive_mode
== AUTO_BOOLEAN_AUTO
)
1841 gdb_printf (file
, "Debugger's interactive mode "
1842 "is %s (currently %s).\n",
1843 value
, current_ui
->input_interactive_p () ? "on" : "off");
1845 gdb_printf (file
, "Debugger's interactive mode is %s.\n", value
);
1849 dont_repeat_command (const char *ignored
, int from_tty
)
1851 /* Can't call dont_repeat here because we're not necessarily reading
1853 *saved_command_line
= 0;
1856 /* Functions to manipulate command line editing control variables. */
1858 /* Number of commands to print in each call to show_commands. */
1859 #define Hist_print 10
1861 show_commands (const char *args
, int from_tty
)
1863 /* Index for history commands. Relative to history_base. */
1866 /* Number of the history entry which we are planning to display next.
1867 Relative to history_base. */
1870 /* Print out some of the commands from the command history. */
1874 if (args
[0] == '+' && args
[1] == '\0')
1875 /* "info editing +" should print from the stored position. */
1878 /* "info editing <exp>" should print around command number <exp>. */
1879 num
= (parse_and_eval_long (args
) - history_base
) - Hist_print
/ 2;
1881 /* "show commands" means print the last Hist_print commands. */
1884 num
= history_length
- Hist_print
;
1890 /* If there are at least Hist_print commands, we want to display the last
1891 Hist_print rather than, say, the last 6. */
1892 if (history_length
- num
< Hist_print
)
1894 num
= history_length
- Hist_print
;
1900 offset
< num
+ Hist_print
&& offset
< history_length
;
1903 gdb_printf ("%5d %s\n", history_base
+ offset
,
1904 (history_get (history_base
+ offset
))->line
);
1907 /* The next command we want to display is the next one that we haven't
1911 /* If the user repeats this command with return, it should do what
1912 "show commands +" does. This is unnecessary if arg is null,
1913 because "show commands +" is not useful after "show commands". */
1914 if (from_tty
&& args
)
1915 set_repeat_arguments ("+");
1918 /* Update the size of our command history file to HISTORY_SIZE.
1920 A HISTORY_SIZE of -1 stands for unlimited. */
1923 set_readline_history_size (int history_size
)
1925 gdb_assert (history_size
>= -1);
1927 if (history_size
== -1)
1928 unstifle_history ();
1930 stifle_history (history_size
);
1933 /* Called by do_setshow_command. */
1935 set_history_size_command (const char *args
,
1936 int from_tty
, struct cmd_list_element
*c
)
1938 set_readline_history_size (history_size_setshow_var
);
1941 bool info_verbose
= false; /* Default verbose msgs off. */
1943 /* Called by do_set_command. An elaborate joke. */
1945 set_verbose (const char *args
, int from_tty
, struct cmd_list_element
*c
)
1947 const char *cmdname
= "verbose";
1948 struct cmd_list_element
*showcmd
;
1950 showcmd
= lookup_cmd_1 (&cmdname
, showlist
, NULL
, NULL
, 1);
1951 gdb_assert (showcmd
!= NULL
&& showcmd
!= CMD_LIST_AMBIGUOUS
);
1953 if (c
->doc
&& c
->doc_allocated
)
1954 xfree ((char *) c
->doc
);
1955 if (showcmd
->doc
&& showcmd
->doc_allocated
)
1956 xfree ((char *) showcmd
->doc
);
1959 c
->doc
= _("Set verbose printing of informational messages.");
1960 showcmd
->doc
= _("Show verbose printing of informational messages.");
1964 c
->doc
= _("Set verbosity.");
1965 showcmd
->doc
= _("Show verbosity.");
1967 c
->doc_allocated
= 0;
1968 showcmd
->doc_allocated
= 0;
1971 /* Init the history buffer. Note that we are called after the init file(s)
1972 have been read so that the user can change the history file via his
1973 .gdbinit file (for instance). The GDBHISTFILE environment variable
1974 overrides all of this. */
1981 tmpenv
= getenv ("GDBHISTSIZE");
1988 tmpenv
= skip_spaces (tmpenv
);
1990 var
= strtol (tmpenv
, &endptr
, 10);
1991 saved_errno
= errno
;
1992 endptr
= skip_spaces (endptr
);
1994 /* If GDBHISTSIZE is non-numeric then ignore it. If GDBHISTSIZE is the
1995 empty string, a negative number or a huge positive number (larger than
1996 INT_MAX) then set the history size to unlimited. Otherwise set our
1997 history size to the number we have read. This behavior is consistent
1998 with how bash handles HISTSIZE. */
1999 if (*endptr
!= '\0')
2001 else if (*tmpenv
== '\0'
2004 /* On targets where INT_MAX == LONG_MAX, we have to look at
2005 errno after calling strtol to distinguish between a value that
2006 is exactly INT_MAX and an overflowing value that was clamped
2008 || (var
== INT_MAX
&& saved_errno
== ERANGE
))
2009 history_size_setshow_var
= -1;
2011 history_size_setshow_var
= var
;
2014 /* If neither the init file nor GDBHISTSIZE has set a size yet, pick the
2016 if (history_size_setshow_var
== -2)
2017 history_size_setshow_var
= 256;
2019 set_readline_history_size (history_size_setshow_var
);
2021 if (!history_filename
.empty ())
2022 read_history (history_filename
.c_str ());
2026 show_prompt (struct ui_file
*file
, int from_tty
,
2027 struct cmd_list_element
*c
, const char *value
)
2029 gdb_printf (file
, _("Gdb's prompt is \"%s\".\n"), value
);
2032 /* "set editing" command. */
2035 set_editing (const char *args
, int from_tty
, struct cmd_list_element
*c
)
2037 change_line_handler (set_editing_cmd_var
);
2038 /* Update the control variable so that MI's =cmd-param-changed event
2039 shows the correct value. */
2040 set_editing_cmd_var
= current_ui
->command_editing
;
2044 show_editing (struct ui_file
*file
, int from_tty
,
2045 struct cmd_list_element
*c
, const char *value
)
2047 gdb_printf (file
, _("Editing of command lines as "
2048 "they are typed is %s.\n"),
2049 current_ui
->command_editing
? _("on") : _("off"));
2053 show_annotation_level (struct ui_file
*file
, int from_tty
,
2054 struct cmd_list_element
*c
, const char *value
)
2056 gdb_printf (file
, _("Annotation_level is %s.\n"), value
);
2060 show_exec_done_display_p (struct ui_file
*file
, int from_tty
,
2061 struct cmd_list_element
*c
, const char *value
)
2063 gdb_printf (file
, _("Notification of completion for "
2064 "asynchronous execution commands is %s.\n"),
2068 /* New values of the "data-directory" parameter are staged here.
2069 Extension languages, for example Python's gdb.parameter API, will read
2070 the value directory from this variable, so we must ensure that this
2071 always contains the correct value. */
2072 static std::string staged_gdb_datadir
;
2074 /* "set" command for the gdb_datadir configuration variable. */
2077 set_gdb_datadir (const char *args
, int from_tty
, struct cmd_list_element
*c
)
2079 set_gdb_data_directory (staged_gdb_datadir
.c_str ());
2081 /* SET_GDB_DATA_DIRECTORY will resolve relative paths in
2082 STAGED_GDB_DATADIR, so we now copy the value from GDB_DATADIR
2083 back into STAGED_GDB_DATADIR so the extension languages can read the
2085 staged_gdb_datadir
= gdb_datadir
;
2087 gdb::observers::gdb_datadir_changed
.notify ();
2090 /* "show" command for the gdb_datadir configuration variable. */
2093 show_gdb_datadir (struct ui_file
*file
, int from_tty
,
2094 struct cmd_list_element
*c
, const char *value
)
2096 gdb_printf (file
, _("GDB's data directory is \"%ps\".\n"),
2097 styled_string (file_name_style
.style (),
2098 gdb_datadir
.c_str ()));
2101 /* Implement 'set history filename'. */
2104 set_history_filename (const char *args
,
2105 int from_tty
, struct cmd_list_element
*c
)
2107 /* We include the current directory so that if the user changes
2108 directories the file written will be the same as the one
2110 if (!history_filename
.empty ()
2111 && !IS_ABSOLUTE_PATH (history_filename
.c_str ()))
2112 history_filename
= gdb_abspath (history_filename
.c_str ());
2115 /* Whether we're in quiet startup mode. */
2117 static bool startup_quiet
;
2124 return startup_quiet
;
2127 /* Show whether GDB should start up in quiet mode. */
2130 show_startup_quiet (struct ui_file
*file
, int from_tty
,
2131 struct cmd_list_element
*c
, const char *value
)
2133 gdb_printf (file
, _("Whether to start up quietly is %s.\n"),
2140 /* Initialize the prompt to a simple "(gdb) " prompt or to whatever
2141 the DEFAULT_PROMPT is. */
2142 set_prompt (DEFAULT_PROMPT
);
2144 /* Set the important stuff up for command editing. */
2145 command_editing_p
= 1;
2146 history_expansion_p
= 0;
2147 write_history_p
= 0;
2149 /* Setup important stuff for command line editing. */
2150 rl_completion_word_break_hook
= gdb_completion_word_break_characters
;
2151 rl_attempted_completion_function
= gdb_rl_attempted_completion_function
;
2152 set_rl_completer_word_break_characters (default_word_break_characters ());
2153 rl_completer_quote_characters
= get_gdb_completer_quote_characters ();
2154 rl_completion_display_matches_hook
= cli_display_match_list
;
2155 rl_readline_name
= "gdb";
2156 rl_terminal_name
= getenv ("TERM");
2157 rl_deprep_term_function
= gdb_rl_deprep_term_function
;
2159 /* The name for this defun comes from Bash, where it originated.
2160 15 is Control-o, the same binding this function has in Bash. */
2161 rl_add_defun ("operate-and-get-next", gdb_rl_operate_and_get_next
, 15);
2163 add_setshow_string_cmd ("prompt", class_support
,
2165 _("Set gdb's prompt."),
2166 _("Show gdb's prompt."),
2169 &setlist
, &showlist
);
2171 add_com ("dont-repeat", class_support
, dont_repeat_command
, _("\
2172 Don't repeat this command.\nPrimarily \
2173 used inside of user-defined commands that should not be repeated when\n\
2176 add_setshow_boolean_cmd ("editing", class_support
,
2177 &set_editing_cmd_var
, _("\
2178 Set editing of command lines as they are typed."), _("\
2179 Show editing of command lines as they are typed."), _("\
2180 Use \"on\" to enable the editing, and \"off\" to disable it.\n\
2181 Without an argument, command line editing is enabled. To edit, use\n\
2182 EMACS-like or VI-like commands like control-P or ESC."),
2185 &setlist
, &showlist
);
2187 add_setshow_boolean_cmd ("save", no_class
, &write_history_p
, _("\
2188 Set saving of the history record on exit."), _("\
2189 Show saving of the history record on exit."), _("\
2190 Use \"on\" to enable the saving, and \"off\" to disable it.\n\
2191 Without an argument, saving is enabled."),
2193 show_write_history_p
,
2194 &sethistlist
, &showhistlist
);
2196 add_setshow_zuinteger_unlimited_cmd ("size", no_class
,
2197 &history_size_setshow_var
, _("\
2198 Set the size of the command history."), _("\
2199 Show the size of the command history."), _("\
2200 This is the number of previous commands to keep a record of.\n\
2201 If set to \"unlimited\", the number of commands kept in the history\n\
2202 list is unlimited. This defaults to the value of the environment\n\
2203 variable \"GDBHISTSIZE\", or to 256 if this variable is not set."),
2204 set_history_size_command
,
2206 &sethistlist
, &showhistlist
);
2208 add_setshow_zuinteger_unlimited_cmd ("remove-duplicates", no_class
,
2209 &history_remove_duplicates
, _("\
2210 Set how far back in history to look for and remove duplicate entries."), _("\
2211 Show how far back in history to look for and remove duplicate entries."), _("\
2212 If set to a nonzero value N, GDB will look back at the last N history entries\n\
2213 and remove the first history entry that is a duplicate of the most recent\n\
2214 entry, each time a new history entry is added.\n\
2215 If set to \"unlimited\", this lookbehind is unbounded.\n\
2216 Only history entries added during this session are considered for removal.\n\
2217 If set to 0, removal of duplicate history entries is disabled.\n\
2218 By default this option is set to 0."),
2220 show_history_remove_duplicates
,
2221 &sethistlist
, &showhistlist
);
2223 add_setshow_optional_filename_cmd ("filename", no_class
, &history_filename
, _("\
2224 Set the filename in which to record the command history."), _("\
2225 Show the filename in which to record the command history."), _("\
2226 (the list of previous commands of which a record is kept)."),
2227 set_history_filename
,
2228 show_history_filename
,
2229 &sethistlist
, &showhistlist
);
2231 add_setshow_boolean_cmd ("confirm", class_support
, &confirm
, _("\
2232 Set whether to confirm potentially dangerous operations."), _("\
2233 Show whether to confirm potentially dangerous operations."), NULL
,
2236 &setlist
, &showlist
);
2238 add_setshow_zinteger_cmd ("annotate", class_obscure
, &annotation_level
, _("\
2239 Set annotation_level."), _("\
2240 Show annotation_level."), _("\
2241 0 == normal; 1 == fullname (for use when running under emacs)\n\
2242 2 == output annotated suitably for use by programs that control GDB."),
2244 show_annotation_level
,
2245 &setlist
, &showlist
);
2247 add_setshow_boolean_cmd ("exec-done-display", class_support
,
2248 &exec_done_display_p
, _("\
2249 Set notification of completion for asynchronous execution commands."), _("\
2250 Show notification of completion for asynchronous execution commands."), _("\
2251 Use \"on\" to enable the notification, and \"off\" to disable it."),
2253 show_exec_done_display_p
,
2254 &setlist
, &showlist
);
2256 add_setshow_filename_cmd ("data-directory", class_maintenance
,
2257 &staged_gdb_datadir
, _("Set GDB's data directory."),
2258 _("Show GDB's data directory."),
2260 When set, GDB uses the specified path to search for data files."),
2261 set_gdb_datadir
, show_gdb_datadir
,
2264 /* Prime the initial value for data-directory. */
2265 staged_gdb_datadir
= gdb_datadir
;
2267 add_setshow_auto_boolean_cmd ("interactive-mode", class_support
,
2268 &interactive_mode
, _("\
2269 Set whether GDB's standard input is a terminal."), _("\
2270 Show whether GDB's standard input is a terminal."), _("\
2271 If on, GDB assumes that standard input is a terminal. In practice, it\n\
2272 means that GDB should wait for the user to answer queries associated to\n\
2273 commands entered at the command prompt. If off, GDB assumes that standard\n\
2274 input is not a terminal, and uses the default answer to all queries.\n\
2275 If auto (the default), determine which mode to use based on the standard\n\
2278 show_interactive_mode
,
2279 &setlist
, &showlist
);
2281 add_setshow_boolean_cmd ("startup-quietly", class_support
,
2282 &startup_quiet
, _("\
2283 Set whether GDB should start up quietly."), _(" \
2284 Show whether GDB should start up quietly."), _("\
2285 This setting will not affect the current session. Instead this command\n\
2286 should be added to the .gdbearlyinit file in the users home directory to\n\
2287 affect future GDB sessions."),
2290 &setlist
, &showlist
);
2292 struct internalvar
*major_version_var
= create_internalvar ("_gdb_major");
2293 struct internalvar
*minor_version_var
= create_internalvar ("_gdb_minor");
2294 int vmajor
= 0, vminor
= 0, vrevision
= 0;
2295 sscanf (version
, "%d.%d.%d", &vmajor
, &vminor
, &vrevision
);
2296 set_internalvar_integer (major_version_var
, vmajor
);
2297 set_internalvar_integer (minor_version_var
, vminor
+ (vrevision
> 0));
2305 saved_command_line
= xstrdup ("");
2306 previous_saved_command_line
= xstrdup ("");
2308 /* Run the init function of each source file. */
2311 /* Make sure we return to the original directory upon exit, come
2312 what may, since the OS doesn't do that for us. */
2313 make_final_cleanup (do_chdir_cleanup
, xstrdup (current_directory
));
2318 /* Here is where we call all the _initialize_foo routines. */
2319 initialize_all_files ();
2321 /* This creates the current_program_space. Do this after all the
2322 _initialize_foo routines have had a chance to install their
2323 per-sspace data keys. Also do this before
2324 initialize_current_architecture is called, because it accesses
2325 exec_bfd of the current program space. */
2326 initialize_progspace ();
2327 initialize_inferiors ();
2328 initialize_current_architecture ();
2329 init_main (); /* But that omits this file! Do it now. */
2331 initialize_stdin_serial ();
2333 /* Take a snapshot of our tty state before readline/ncurses have had a chance
2335 set_initial_gdb_ttystate ();
2337 gdb_init_signals ();
2339 /* We need a default language for parsing expressions, so simple
2340 things like "set width 0" won't fail if no language is explicitly
2341 set in a config file or implicitly set by reading an executable
2343 set_language (language_c
);
2344 expected_language
= current_language
; /* Don't warn about the change. */
2347 void _initialize_top ();
2351 /* Determine a default value for the history filename. */
2352 const char *tmpenv
= getenv ("GDBHISTFILE");
2353 if (tmpenv
!= nullptr)
2354 history_filename
= tmpenv
;
2357 /* We include the current directory so that if the user changes
2358 directories the file written will be the same as the one
2361 /* No leading dots in file names are allowed on MSDOS. */
2362 const char *fname
= "_gdb_history";
2364 const char *fname
= ".gdb_history";
2367 history_filename
= gdb_abspath (fname
);