1 /* Top level stuff for GDB, the GNU debugger.
3 Copyright (C) 1986-2021 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"
42 #include "gdbsupport/version.h"
45 #include "gdbsupport/event-loop.h"
46 #include "gdbthread.h"
47 #include "extension.h"
49 #include "observable.h"
51 #include "filenames.h"
53 #include "gdbsupport/buffer.h"
54 #include "gdbsupport/gdb_select.h"
55 #include "gdbsupport/scope-exit.h"
57 #include "gdbsupport/pathstuff.h"
58 #include "cli/cli-style.h"
60 /* readline include files. */
61 #include "readline/readline.h"
62 #include "readline/history.h"
64 /* readline defines this. */
67 #include <sys/types.h>
69 #include "event-top.h"
74 #include "tracepoint.h"
85 extern void initialize_all_files (void);
87 static bool history_filename_empty (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 fprintf_filtered (file
, _("Whether to confirm potentially "
141 "dangerous operations is %s.\n"),
145 /* Current working directory. */
147 char *current_directory
;
149 /* The last command line executed on the console. Used for command
150 repetitions when the user enters an empty line. */
152 static char *saved_command_line
;
154 /* If not NULL, the arguments that should be passed if
155 saved_command_line is repeated. */
157 static const char *repeat_arguments
;
159 /* The previous last command line executed on the console. Used for command
160 repetitions when a command wants to relaunch the previously launched
161 command. We need this as when a command is running, saved_command_line
162 already contains the line of the currently executing command. */
164 static char *previous_saved_command_line
;
166 /* If not NULL, the arguments that should be passed if the
167 previous_saved_command_line is repeated. */
169 static const char *previous_repeat_arguments
;
171 /* Nonzero if the current command is modified by "server ". This
172 affects things like recording into the command history, commands
173 repeating on RETURN, etc. This is so a user interface (emacs, GUI,
174 whatever) can issue its own commands and also send along commands
175 from the user, and have the user not notice that the user interface
176 is issuing commands too. */
179 /* Timeout limit for response from target. */
181 /* The default value has been changed many times over the years. It
182 was originally 5 seconds. But that was thought to be a long time
183 to sit and wait, so it was changed to 2 seconds. That was thought
184 to be plenty unless the connection was going through some terminal
185 server or multiplexer or other form of hairy serial connection.
187 In mid-1996, remote_timeout was moved from remote.c to top.c and
188 it began being used in other remote-* targets. It appears that the
189 default was changed to 20 seconds at that time, perhaps because the
190 Renesas E7000 ICE didn't always respond in a timely manner.
192 But if 5 seconds is a long time to sit and wait for retransmissions,
193 20 seconds is far worse. This demonstrates the difficulty of using
194 a single variable for all protocol timeouts.
196 As remote.c is used much more than remote-e7000.c, it was changed
197 back to 2 seconds in 1999. */
199 int remote_timeout
= 2;
201 /* Sbrk location on entry to main. Used for statistics only. */
202 #ifdef HAVE_USEFUL_SBRK
206 /* Hooks for alternate command interfaces. */
208 /* This hook is called from within gdb's many mini-event loops which
209 could steal control from a real user interface's event loop. It
210 returns non-zero if the user is requesting a detach, zero
213 int (*deprecated_ui_loop_hook
) (int);
216 /* Called from print_frame_info to list the line we stopped in. */
218 void (*deprecated_print_frame_info_listing_hook
) (struct symtab
* s
,
222 /* Replaces most of query. */
224 int (*deprecated_query_hook
) (const char *, va_list);
226 /* Replaces most of warning. */
228 void (*deprecated_warning_hook
) (const char *, va_list);
230 /* These three functions support getting lines of text from the user.
231 They are used in sequence. First deprecated_readline_begin_hook is
232 called with a text string that might be (for example) a message for
233 the user to type in a sequence of commands to be executed at a
234 breakpoint. If this function calls back to a GUI, it might take
235 this opportunity to pop up a text interaction window with this
236 message. Next, deprecated_readline_hook is called with a prompt
237 that is emitted prior to collecting the user input. It can be
238 called multiple times. Finally, deprecated_readline_end_hook is
239 called to notify the GUI that we are done with the interaction
240 window and it can close it. */
242 void (*deprecated_readline_begin_hook
) (const char *, ...);
243 char *(*deprecated_readline_hook
) (const char *);
244 void (*deprecated_readline_end_hook
) (void);
246 /* Called as appropriate to notify the interface that we have attached
247 to or detached from an already running process. */
249 void (*deprecated_attach_hook
) (void);
250 void (*deprecated_detach_hook
) (void);
252 /* Called when going to wait for the target. Usually allows the GUI
253 to run while waiting for target events. */
255 ptid_t (*deprecated_target_wait_hook
) (ptid_t ptid
,
256 struct target_waitstatus
*status
,
259 /* Used by UI as a wrapper around command execution. May do various
260 things like enabling/disabling buttons, etc... */
262 void (*deprecated_call_command_hook
) (struct cmd_list_element
* c
,
263 const char *cmd
, int from_tty
);
265 /* Called when the current thread changes. Argument is thread id. */
267 void (*deprecated_context_hook
) (int id
);
269 /* The highest UI number ever assigned. */
270 static int highest_ui_num
;
274 ui::ui (FILE *instream_
, FILE *outstream_
, FILE *errstream_
)
276 num (++highest_ui_num
),
277 call_readline (nullptr),
278 input_handler (nullptr),
280 interp_info (nullptr),
282 secondary_prompt_depth (0),
283 stdin_stream (instream_
),
284 instream (instream_
),
285 outstream (outstream_
),
286 errstream (errstream_
),
287 input_fd (fileno (instream
)),
288 input_interactive_p (ISATTY (instream
)),
289 prompt_state (PROMPT_NEEDED
),
290 m_gdb_stdout (new stdio_file (outstream
)),
291 m_gdb_stdin (new stdio_file (instream
)),
292 m_gdb_stderr (new stderr_file (errstream
)),
293 m_gdb_stdlog (m_gdb_stderr
),
294 m_current_uiout (nullptr)
296 buffer_init (&line_buffer
);
304 for (last
= ui_list
; last
->next
!= NULL
; last
= last
->next
)
312 struct ui
*ui
, *uiprev
;
316 for (ui
= ui_list
; ui
!= NULL
; uiprev
= ui
, ui
= ui
->next
)
320 gdb_assert (ui
!= NULL
);
332 /* Open file named NAME for read/write, making sure not to make it the
333 controlling terminal. */
336 open_terminal_stream (const char *name
)
340 fd
= gdb_open_cloexec (name
, O_RDWR
| O_NOCTTY
, 0);
342 perror_with_name (_("opening terminal failed"));
344 return gdb_file_up (fdopen (fd
, "w+"));
347 /* Implementation of the "new-ui" command. */
350 new_ui_command (const char *args
, int from_tty
)
353 const char *interpreter_name
;
354 const char *tty_name
;
358 gdb_argv
argv (args
);
359 argc
= argv
.count ();
362 error (_("Usage: new-ui INTERPRETER TTY"));
364 interpreter_name
= argv
[0];
368 scoped_restore save_ui
= make_scoped_restore (¤t_ui
);
370 /* Open specified terminal. Note: we used to open it three times,
371 once for each of stdin/stdout/stderr, but that does not work
372 with Windows named pipes. */
373 gdb_file_up stream
= open_terminal_stream (tty_name
);
375 std::unique_ptr
<ui
> ui
376 (new struct ui (stream
.get (), stream
.get (), stream
.get ()));
380 current_ui
= ui
.get ();
382 set_top_level_interpreter (interpreter_name
);
384 interp_pre_command_loop (top_level_interpreter ());
386 /* Make sure the file is not closed. */
392 printf_unfiltered ("New UI allocated\n");
395 /* Handler for SIGHUP. */
398 /* NOTE 1999-04-29: This function will be static again, once we modify
399 gdb to use the event loop as the default command loop and we merge
400 event-top.c into this file, top.c. */
404 /* Stop asking user for confirmation --- we're exiting. This
405 prevents asking the user dumb questions. */
407 quit_command ((char *) 0, 0);
409 #endif /* defined SIGHUP */
411 /* Line number we are currently in, in a file which is being sourced. */
412 /* NOTE 1999-04-29: This variable will be static again, once we modify
413 gdb to use the event loop as the default command loop and we merge
414 event-top.c into this file, top.c. */
415 /* static */ int source_line_number
;
417 /* Name of the file we are sourcing. */
418 /* NOTE 1999-04-29: This variable will be static again, once we modify
419 gdb to use the event loop as the default command loop and we merge
420 event-top.c into this file, top.c. */
421 /* static */ std::string source_file_name
;
423 /* Read commands from STREAM. */
425 read_command_file (FILE *stream
)
427 struct ui
*ui
= current_ui
;
429 scoped_restore save_instream
430 = make_scoped_restore (&ui
->instream
, stream
);
432 /* Read commands from `instream' and execute them until end of file
433 or error reading instream. */
435 while (ui
->instream
!= NULL
&& !feof (ui
->instream
))
439 /* Get a command-line. This calls the readline package. */
440 command
= command_line_input (NULL
, NULL
);
443 command_handler (command
);
449 do_chdir_cleanup (void *old_dir
)
451 chdir ((const char *) old_dir
);
457 prepare_execute_command ()
459 /* With multiple threads running while the one we're examining is
460 stopped, the dcache can get stale without us being able to detect
461 it. For the duration of the command, though, use the dcache to
462 help things like backtrace. */
464 target_dcache_invalidate ();
466 return scoped_value_mark ();
469 /* Tell the user if the language has changed (except first time) after
470 executing a command. */
473 check_frame_language_change (void)
475 static int warned
= 0;
476 struct frame_info
*frame
;
478 /* First make sure that a new frame has been selected, in case the
479 command or the hooks changed the program state. */
480 frame
= deprecated_safe_get_selected_frame ();
481 if (current_language
!= expected_language
)
483 if (language_mode
== language_mode_auto
&& info_verbose
)
485 language_info (1); /* Print what changed. */
490 /* Warn the user if the working language does not match the language
491 of the current frame. Only warn the user if we are actually
492 running the program, i.e. there is a stack. */
493 /* FIXME: This should be cacheing the frame and only running when
494 the frame changes. */
496 if (has_stack_frames ())
500 flang
= get_frame_language (frame
);
502 && flang
!= language_unknown
503 && flang
!= current_language
->la_language
)
505 printf_filtered ("%s\n", _(lang_frame_mismatch_warn
));
514 wait_sync_command_done (void)
516 /* Processing events may change the current UI. */
517 scoped_restore save_ui
= make_scoped_restore (¤t_ui
);
518 struct ui
*ui
= current_ui
;
520 while (gdb_do_one_event () >= 0)
521 if (ui
->prompt_state
!= PROMPT_BLOCKED
)
528 maybe_wait_sync_command_done (int was_sync
)
530 /* If the interpreter is in sync mode (we're running a user
531 command's list, running command hooks or similars), and we
532 just ran a synchronous command that started the target, wait
533 for that command to end. */
534 if (!current_ui
->async
536 && current_ui
->prompt_state
== PROMPT_BLOCKED
)
537 wait_sync_command_done ();
543 set_repeat_arguments (const char *args
)
545 repeat_arguments
= args
;
548 /* Execute the line P as a command, in the current user context.
549 Pass FROM_TTY as second argument to the defining function. */
552 execute_command (const char *p
, int from_tty
)
554 struct cmd_list_element
*c
;
556 const char *cmd_start
= p
;
558 auto cleanup_if_error
= make_scope_exit (bpstat_clear_actions
);
559 scoped_value_mark cleanup
= prepare_execute_command ();
561 /* This can happen when command_line_input hits end of file. */
564 cleanup_if_error
.release ();
568 target_log_command (p
);
570 while (*p
== ' ' || *p
== '\t')
576 std::string default_args
;
577 std::string default_args_and_arg
;
578 int was_sync
= current_ui
->prompt_state
== PROMPT_BLOCKED
;
582 /* If trace-commands is set then this will print this command. */
583 print_command_trace ("%s", p
);
585 c
= lookup_cmd (&cmd
, cmdlist
, "", &default_args
, 0, 1);
588 scoped_restore save_repeat_args
589 = make_scoped_restore (&repeat_arguments
, nullptr);
590 const char *args_pointer
= p
;
592 if (!default_args
.empty ())
595 default_args_and_arg
= default_args
+ ' ' + p
;
597 default_args_and_arg
= default_args
;
598 arg
= default_args_and_arg
.c_str ();
602 /* Pass null arg rather than an empty one. */
603 arg
= *p
== '\0' ? nullptr : p
;
606 /* FIXME: cagney/2002-02-02: The c->type test is pretty dodgy
607 while the is_complete_command(cfunc) test is just plain
608 bogus. They should both be replaced by a test of the form
609 c->strip_trailing_white_space_p. */
610 /* NOTE: cagney/2002-02-02: The function.cfunc in the below
611 can't be replaced with func. This is because it is the
612 cfunc, and not the func, that has the value that the
613 is_complete_command hack is testing for. */
614 /* Clear off trailing whitespace, except for set and complete
616 std::string without_whitespace
;
618 && c
->type
!= set_cmd
619 && !is_complete_command (c
))
621 const char *old_end
= arg
+ strlen (arg
) - 1;
623 while (p
>= arg
&& (*p
== ' ' || *p
== '\t'))
627 without_whitespace
= std::string (arg
, p
+ 1);
628 arg
= without_whitespace
.c_str ();
632 /* If this command has been pre-hooked, run the hook first. */
633 execute_cmd_pre_hook (c
);
635 if (c
->deprecated_warn_user
)
636 deprecated_cmd_warning (line
, cmdlist
);
638 /* c->user_commands would be NULL in the case of a python command. */
639 if (c
->theclass
== class_user
&& c
->user_commands
)
640 execute_user_command (c
, arg
);
641 else if (c
->theclass
== class_user
642 && c
->prefixlist
&& !c
->allow_unknown
)
643 /* If this is a user defined prefix that does not allow unknown
644 (in other words, C is a prefix command and not a command
645 that can be followed by its args), report the list of
649 ("\"%.*s\" must be followed by the name of a subcommand.\n",
650 (int) strlen (c
->prefixname
) - 1, c
->prefixname
);
651 help_list (*c
->prefixlist
, c
->prefixname
, all_commands
, gdb_stdout
);
653 else if (c
->type
== set_cmd
)
654 do_set_command (arg
, from_tty
, c
);
655 else if (c
->type
== show_cmd
)
656 do_show_command (arg
, from_tty
, c
);
657 else if (!cmd_func_p (c
))
658 error (_("That is not a command, just a help topic."));
659 else if (deprecated_call_command_hook
)
660 deprecated_call_command_hook (c
, arg
, from_tty
);
662 cmd_func (c
, arg
, from_tty
);
664 maybe_wait_sync_command_done (was_sync
);
666 /* If this command has been post-hooked, run the hook last. */
667 execute_cmd_post_hook (c
);
669 if (repeat_arguments
!= NULL
&& cmd_start
== saved_command_line
)
671 gdb_assert (strlen (args_pointer
) >= strlen (repeat_arguments
));
672 strcpy (saved_command_line
+ (args_pointer
- cmd_start
),
677 /* Only perform the frame-language-change check if the command
678 we just finished executing did not resume the inferior's execution.
679 If it did resume the inferior, we will do that check after
680 the inferior stopped. */
681 if (has_stack_frames () && inferior_thread ()->state
!= THREAD_RUNNING
)
682 check_frame_language_change ();
684 cleanup_if_error
.release ();
687 /* Run execute_command for P and FROM_TTY. Sends its output to FILE,
688 do not display it to the screen. BATCH_FLAG will be
689 temporarily set to true. */
692 execute_command_to_ui_file (struct ui_file
*file
, const char *p
, int from_tty
)
694 /* GDB_STDOUT should be better already restored during these
695 restoration callbacks. */
696 set_batch_flag_and_restore_page_info save_page_info
;
698 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
701 current_uiout
->redirect (file
);
702 ui_out_redirect_pop
redirect_popper (current_uiout
);
704 scoped_restore save_stdout
705 = make_scoped_restore (&gdb_stdout
, file
);
706 scoped_restore save_stderr
707 = make_scoped_restore (&gdb_stderr
, file
);
708 scoped_restore save_stdlog
709 = make_scoped_restore (&gdb_stdlog
, file
);
710 scoped_restore save_stdtarg
711 = make_scoped_restore (&gdb_stdtarg
, file
);
712 scoped_restore save_stdtargerr
713 = make_scoped_restore (&gdb_stdtargerr
, file
);
715 execute_command (p
, from_tty
);
719 /* Run execute_command for P and FROM_TTY. Capture its output into the
720 returned string, do not display it to the screen. BATCH_FLAG will be
721 temporarily set to true. */
724 execute_command_to_string (const char *p
, int from_tty
,
727 string_file
str_file (term_out
);
729 execute_command_to_ui_file (&str_file
, p
, from_tty
);
730 return std::move (str_file
.string ());
734 /* When nonzero, cause dont_repeat to do nothing. This should only be
735 set via prevent_dont_repeat. */
737 static int suppress_dont_repeat
= 0;
744 struct ui
*ui
= current_ui
;
746 if (suppress_dont_repeat
|| server_command
)
749 /* If we aren't reading from standard input, we are saving the last
750 thing read from stdin in line and don't want to delete it. Null
751 lines won't repeat here in any case. */
752 if (ui
->instream
== ui
->stdin_stream
)
754 *saved_command_line
= 0;
755 repeat_arguments
= NULL
;
764 /* Do not repeat this command, as this command is a repeating command. */
767 /* We cannot free saved_command_line, as this line is being executed,
768 so swap it with previous_saved_command_line. */
769 std::swap (previous_saved_command_line
, saved_command_line
);
770 std::swap (previous_repeat_arguments
, repeat_arguments
);
772 const char *prev
= skip_spaces (get_saved_command_line ());
774 error (_("No previous command to relaunch"));
780 scoped_restore_tmpl
<int>
781 prevent_dont_repeat (void)
783 return make_scoped_restore (&suppress_dont_repeat
, 1);
789 get_saved_command_line ()
791 return saved_command_line
;
797 save_command_line (const char *cmd
)
799 xfree (previous_saved_command_line
);
800 previous_saved_command_line
= saved_command_line
;
801 previous_repeat_arguments
= repeat_arguments
;
802 saved_command_line
= xstrdup (cmd
);
803 repeat_arguments
= NULL
;
807 /* Read a line from the stream "instream" without command line editing.
809 It prints PROMPT once at the start.
810 Action is compatible with "readline", e.g. space for the result is
811 malloc'd and should be freed by the caller.
813 A NULL return means end of file. */
816 gdb_readline_no_editing (const char *prompt
)
818 struct buffer line_buffer
;
819 struct ui
*ui
= current_ui
;
820 /* Read from stdin if we are executing a user defined command. This
821 is the right thing for prompt_for_continue, at least. */
822 FILE *stream
= ui
->instream
!= NULL
? ui
->instream
: stdin
;
823 int fd
= fileno (stream
);
825 buffer_init (&line_buffer
);
829 /* Don't use a _filtered function here. It causes the assumed
830 character position to be off, since the newline we read from
831 the user is not accounted for. */
832 fputs_unfiltered (prompt
, gdb_stdout
);
833 gdb_flush (gdb_stdout
);
843 /* Wait until at least one byte of data is available. Control-C
844 can interrupt interruptible_select, but not fgetc. */
846 FD_SET (fd
, &readfds
);
847 if (interruptible_select (fd
+ 1, &readfds
, NULL
, NULL
, NULL
) == -1)
851 /* If this was ctrl-c, the QUIT above handles it. */
854 perror_with_name (("select"));
861 if (line_buffer
.used_size
> 0)
862 /* The last line does not end with a newline. Return it, and
863 if we are called again fgetc will still return EOF and
864 we'll return NULL then. */
866 xfree (buffer_finish (&line_buffer
));
872 if (line_buffer
.used_size
> 0
873 && line_buffer
.buffer
[line_buffer
.used_size
- 1] == '\r')
874 line_buffer
.used_size
--;
878 buffer_grow_char (&line_buffer
, c
);
881 buffer_grow_char (&line_buffer
, '\0');
882 return buffer_finish (&line_buffer
);
885 /* Variables which control command line editing and history
886 substitution. These variables are given default values at the end
888 static bool command_editing_p
;
890 /* NOTE 1999-04-29: This variable will be static again, once we modify
891 gdb to use the event loop as the default command loop and we merge
892 event-top.c into this file, top.c. */
894 /* static */ bool history_expansion_p
;
896 /* Should we write out the command history on exit? In order to write out
897 the history both this flag must be true, and the history_filename
898 variable must be set to something sensible. */
899 static bool write_history_p
;
901 /* Implement 'show history save'. */
903 show_write_history_p (struct ui_file
*file
, int from_tty
,
904 struct cmd_list_element
*c
, const char *value
)
906 if (!write_history_p
|| !history_filename_empty ())
907 fprintf_filtered (file
, _("Saving of the history record on exit is %s.\n"),
910 fprintf_filtered (file
, _("Saving of the history is disabled due to "
911 "the value of 'history filename'.\n"));
914 /* The variable associated with the "set/show history size"
915 command. The value -1 means unlimited, and -2 means undefined. */
916 static int history_size_setshow_var
= -2;
919 show_history_size (struct ui_file
*file
, int from_tty
,
920 struct cmd_list_element
*c
, const char *value
)
922 fprintf_filtered (file
, _("The size of the command history is %s.\n"),
926 /* Variable associated with the "history remove-duplicates" option.
927 The value -1 means unlimited. */
928 static int history_remove_duplicates
= 0;
931 show_history_remove_duplicates (struct ui_file
*file
, int from_tty
,
932 struct cmd_list_element
*c
, const char *value
)
934 fprintf_filtered (file
,
935 _("The number of history entries to look back at for "
936 "duplicates is %s.\n"),
940 /* The name of the file in which GDB history will be written. If this is
941 set to NULL, of the empty string then history will not be written. */
942 static char *history_filename
;
944 /* Return true if the history_filename is either NULL or the empty string,
945 indicating that we should not try to read, nor write out the history. */
947 history_filename_empty (void)
949 return (history_filename
== nullptr || *history_filename
== '\0');
952 /* Implement 'show history filename'. */
954 show_history_filename (struct ui_file
*file
, int from_tty
,
955 struct cmd_list_element
*c
, const char *value
)
957 if (!history_filename_empty ())
958 fprintf_filtered (file
, _("The filename in which to record "
959 "the command history is \"%ps\".\n"),
960 styled_string (file_name_style
.style (), value
));
962 fprintf_filtered (file
, _("There is no filename currently set for "
963 "recording the command history in.\n"));
966 /* This is like readline(), but it has some gdb-specific behavior.
967 gdb may want readline in both the synchronous and async modes during
968 a single gdb invocation. At the ordinary top-level prompt we might
969 be using the async readline. That means we can't use
970 rl_pre_input_hook, since it doesn't work properly in async mode.
971 However, for a secondary prompt (" >", such as occurs during a
972 `define'), gdb wants a synchronous response.
974 We used to call readline() directly, running it in synchronous
975 mode. But mixing modes this way is not supported, and as of
976 readline 5.x it no longer works; the arrow keys come unbound during
977 the synchronous call. So we make a nested call into the event
978 loop. That's what gdb_readline_wrapper is for. */
980 /* A flag set as soon as gdb_readline_wrapper_line is called; we can't
981 rely on gdb_readline_wrapper_result, which might still be NULL if
982 the user types Control-D for EOF. */
983 static int gdb_readline_wrapper_done
;
985 /* The result of the current call to gdb_readline_wrapper, once a newline
987 static char *gdb_readline_wrapper_result
;
989 /* Any intercepted hook. Operate-and-get-next sets this, expecting it
990 to be called after the newline is processed (which will redisplay
991 the prompt). But in gdb_readline_wrapper we will not get a new
992 prompt until the next call, or until we return to the event loop.
993 So we disable this hook around the newline and restore it before we
995 static void (*saved_after_char_processing_hook
) (void);
1001 gdb_in_secondary_prompt_p (struct ui
*ui
)
1003 return ui
->secondary_prompt_depth
> 0;
1007 /* This function is called when readline has seen a complete line of
1011 gdb_readline_wrapper_line (gdb::unique_xmalloc_ptr
<char> &&line
)
1013 gdb_assert (!gdb_readline_wrapper_done
);
1014 gdb_readline_wrapper_result
= line
.release ();
1015 gdb_readline_wrapper_done
= 1;
1017 /* Prevent operate-and-get-next from acting too early. */
1018 saved_after_char_processing_hook
= after_char_processing_hook
;
1019 after_char_processing_hook
= NULL
;
1021 /* Prevent parts of the prompt from being redisplayed if annotations
1022 are enabled, and readline's state getting out of sync. We'll
1023 reinstall the callback handler, which puts the terminal in raw
1024 mode (or in readline lingo, in prepped state), when we're next
1025 ready to process user input, either in display_gdb_prompt, or if
1026 we're handling an asynchronous target event and running in the
1027 background, just before returning to the event loop to process
1028 further input (or more target events). */
1029 if (current_ui
->command_editing
)
1030 gdb_rl_callback_handler_remove ();
1033 class gdb_readline_wrapper_cleanup
1036 gdb_readline_wrapper_cleanup ()
1037 : m_handler_orig (current_ui
->input_handler
),
1038 m_already_prompted_orig (current_ui
->command_editing
1039 ? rl_already_prompted
: 0),
1040 m_target_is_async_orig (target_is_async_p ()),
1041 m_save_ui (¤t_ui
)
1043 current_ui
->input_handler
= gdb_readline_wrapper_line
;
1044 current_ui
->secondary_prompt_depth
++;
1046 if (m_target_is_async_orig
)
1050 ~gdb_readline_wrapper_cleanup ()
1052 struct ui
*ui
= current_ui
;
1054 if (ui
->command_editing
)
1055 rl_already_prompted
= m_already_prompted_orig
;
1057 gdb_assert (ui
->input_handler
== gdb_readline_wrapper_line
);
1058 ui
->input_handler
= m_handler_orig
;
1060 /* Don't restore our input handler in readline yet. That would make
1061 readline prep the terminal (putting it in raw mode), while the
1062 line we just read may trigger execution of a command that expects
1063 the terminal in the default cooked/canonical mode, such as e.g.,
1064 running Python's interactive online help utility. See
1065 gdb_readline_wrapper_line for when we'll reinstall it. */
1067 gdb_readline_wrapper_result
= NULL
;
1068 gdb_readline_wrapper_done
= 0;
1069 ui
->secondary_prompt_depth
--;
1070 gdb_assert (ui
->secondary_prompt_depth
>= 0);
1072 after_char_processing_hook
= saved_after_char_processing_hook
;
1073 saved_after_char_processing_hook
= NULL
;
1075 if (m_target_is_async_orig
)
1079 DISABLE_COPY_AND_ASSIGN (gdb_readline_wrapper_cleanup
);
1083 void (*m_handler_orig
) (gdb::unique_xmalloc_ptr
<char> &&);
1084 int m_already_prompted_orig
;
1086 /* Whether the target was async. */
1087 int m_target_is_async_orig
;
1089 /* Processing events may change the current UI. */
1090 scoped_restore_tmpl
<struct ui
*> m_save_ui
;
1094 gdb_readline_wrapper (const char *prompt
)
1096 struct ui
*ui
= current_ui
;
1098 gdb_readline_wrapper_cleanup cleanup
;
1100 /* Display our prompt and prevent double prompt display. Don't pass
1101 down a NULL prompt, since that has special meaning for
1102 display_gdb_prompt -- it indicates a request to print the primary
1103 prompt, while we want a secondary prompt here. */
1104 display_gdb_prompt (prompt
!= NULL
? prompt
: "");
1105 if (ui
->command_editing
)
1106 rl_already_prompted
= 1;
1108 if (after_char_processing_hook
)
1109 (*after_char_processing_hook
) ();
1110 gdb_assert (after_char_processing_hook
== NULL
);
1112 while (gdb_do_one_event () >= 0)
1113 if (gdb_readline_wrapper_done
)
1116 return gdb_readline_wrapper_result
;
1120 /* The current saved history number from operate-and-get-next.
1121 This is -1 if not valid. */
1122 static int operate_saved_history
= -1;
1124 /* This is put on the appropriate hook and helps operate-and-get-next
1127 gdb_rl_operate_and_get_next_completion (void)
1129 int delta
= where_history () - operate_saved_history
;
1131 /* The `key' argument to rl_get_previous_history is ignored. */
1132 rl_get_previous_history (delta
, 0);
1133 operate_saved_history
= -1;
1135 /* readline doesn't automatically update the display for us. */
1138 after_char_processing_hook
= NULL
;
1139 rl_pre_input_hook
= NULL
;
1142 /* This is a gdb-local readline command handler. It accepts the
1143 current command line (like RET does) and, if this command was taken
1144 from the history, arranges for the next command in the history to
1145 appear on the command line when the prompt returns.
1146 We ignore the arguments. */
1148 gdb_rl_operate_and_get_next (int count
, int key
)
1152 /* Use the async hook. */
1153 after_char_processing_hook
= gdb_rl_operate_and_get_next_completion
;
1155 /* Find the current line, and find the next line to use. */
1156 where
= where_history();
1158 if ((history_is_stifled () && (history_length
>= history_max_entries
))
1159 || (where
>= history_length
- 1))
1160 operate_saved_history
= where
;
1162 operate_saved_history
= where
+ 1;
1164 return rl_newline (1, key
);
1167 /* Number of user commands executed during this session. */
1169 static int command_count
= 0;
1171 /* Add the user command COMMAND to the input history list. */
1174 gdb_add_history (const char *command
)
1178 if (history_remove_duplicates
!= 0)
1181 int lookbehind_threshold
;
1183 /* The lookbehind threshold for finding a duplicate history entry is
1184 bounded by command_count because we can't meaningfully delete
1185 history entries that are already stored in the history file since
1186 the history file is appended to. */
1187 if (history_remove_duplicates
== -1
1188 || history_remove_duplicates
> command_count
)
1189 lookbehind_threshold
= command_count
;
1191 lookbehind_threshold
= history_remove_duplicates
;
1194 for (lookbehind
= 0; lookbehind
< lookbehind_threshold
; lookbehind
++)
1196 HIST_ENTRY
*temp
= previous_history ();
1201 if (strcmp (temp
->line
, command
) == 0)
1203 HIST_ENTRY
*prev
= remove_history (where_history ());
1205 free_history_entry (prev
);
1212 add_history (command
);
1215 /* Safely append new history entries to the history file in a corruption-free
1216 way using an intermediate local history file. */
1219 gdb_safe_append_history (void)
1221 int ret
, saved_errno
;
1223 std::string local_history_filename
1224 = string_printf ("%s-gdb%ld~", history_filename
, (long) getpid ());
1226 ret
= rename (history_filename
, local_history_filename
.c_str ());
1227 saved_errno
= errno
;
1228 if (ret
< 0 && saved_errno
!= ENOENT
)
1230 warning (_("Could not rename %ps to %ps: %s"),
1231 styled_string (file_name_style
.style (), history_filename
),
1232 styled_string (file_name_style
.style (),
1233 local_history_filename
.c_str ()),
1234 safe_strerror (saved_errno
));
1240 /* If the rename failed with ENOENT then either the global history
1241 file never existed in the first place or another GDB process is
1242 currently appending to it (and has thus temporarily renamed it).
1243 Since we can't distinguish between these two cases, we have to
1244 conservatively assume the first case and therefore must write out
1245 (not append) our known history to our local history file and try
1246 to move it back anyway. Otherwise a global history file would
1247 never get created! */
1248 gdb_assert (saved_errno
== ENOENT
);
1249 write_history (local_history_filename
.c_str ());
1253 append_history (command_count
, local_history_filename
.c_str ());
1254 if (history_is_stifled ())
1255 history_truncate_file (local_history_filename
.c_str (),
1256 history_max_entries
);
1259 ret
= rename (local_history_filename
.c_str (), history_filename
);
1260 saved_errno
= errno
;
1261 if (ret
< 0 && saved_errno
!= EEXIST
)
1262 warning (_("Could not rename %s to %s: %s"),
1263 local_history_filename
.c_str (), history_filename
,
1264 safe_strerror (saved_errno
));
1268 /* Read one line from the command input stream `instream' into a local
1269 static buffer. The buffer is made bigger as necessary. Returns
1270 the address of the start of the line.
1272 NULL is returned for end of file.
1274 This routine either uses fancy command line editing or simple input
1275 as the user has requested. */
1278 command_line_input (const char *prompt_arg
, const char *annotation_suffix
)
1280 static struct buffer cmd_line_buffer
;
1281 static int cmd_line_buffer_initialized
;
1282 struct ui
*ui
= current_ui
;
1283 const char *prompt
= prompt_arg
;
1285 int from_tty
= ui
->instream
== ui
->stdin_stream
;
1287 /* The annotation suffix must be non-NULL. */
1288 if (annotation_suffix
== NULL
)
1289 annotation_suffix
= "";
1291 if (from_tty
&& annotation_level
> 1)
1296 = (char *) alloca ((prompt
== NULL
? 0 : strlen (prompt
))
1297 + strlen (annotation_suffix
) + 40);
1299 local_prompt
[0] = '\0';
1301 strcpy (local_prompt
, prompt
);
1302 strcat (local_prompt
, "\n\032\032");
1303 strcat (local_prompt
, annotation_suffix
);
1304 strcat (local_prompt
, "\n");
1306 prompt
= local_prompt
;
1309 if (!cmd_line_buffer_initialized
)
1311 buffer_init (&cmd_line_buffer
);
1312 cmd_line_buffer_initialized
= 1;
1315 /* Starting a new command line. */
1316 cmd_line_buffer
.used_size
= 0;
1320 signal (SIGTSTP
, handle_sigtstp
);
1325 gdb::unique_xmalloc_ptr
<char> rl
;
1327 /* Make sure that all output has been output. Some machines may
1328 let you get away with leaving out some of the gdb_flush, but
1331 gdb_flush (gdb_stdout
);
1332 gdb_flush (gdb_stderr
);
1334 if (!source_file_name
.empty ())
1335 ++source_line_number
;
1337 if (from_tty
&& annotation_level
> 1)
1339 puts_unfiltered ("\n\032\032pre-");
1340 puts_unfiltered (annotation_suffix
);
1341 puts_unfiltered ("\n");
1344 /* Don't use fancy stuff if not talking to stdin. */
1345 if (deprecated_readline_hook
1347 && input_interactive_p (current_ui
))
1349 rl
.reset ((*deprecated_readline_hook
) (prompt
));
1351 else if (command_editing_p
1353 && input_interactive_p (current_ui
))
1355 rl
.reset (gdb_readline_wrapper (prompt
));
1359 rl
.reset (gdb_readline_no_editing (prompt
));
1362 cmd
= handle_line_of_input (&cmd_line_buffer
, rl
.get (),
1363 0, annotation_suffix
);
1364 if (cmd
== (char *) EOF
)
1372 /* Got partial input. I.e., got a line that ends with a
1373 continuation character (backslash). Suppress printing the
1380 signal (SIGTSTP
, SIG_DFL
);
1388 print_gdb_version (struct ui_file
*stream
, bool interactive
)
1390 /* From GNU coding standards, first line is meant to be easy for a
1391 program to parse, and is just canonical program name and version
1392 number, which starts after last space. */
1394 std::string v_str
= string_printf ("GNU gdb %s%s", PKGVERSION
, version
);
1395 fprintf_filtered (stream
, "%ps\n",
1396 styled_string (version_style
.style (), v_str
.c_str ()));
1398 /* Second line is a copyright notice. */
1400 fprintf_filtered (stream
,
1401 "Copyright (C) 2021 Free Software Foundation, Inc.\n");
1403 /* Following the copyright is a brief statement that the program is
1404 free software, that users are free to copy and change it on
1405 certain conditions, that it is covered by the GNU GPL, and that
1406 there is no warranty. */
1408 fprintf_filtered (stream
, "\
1409 License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>\
1410 \nThis is free software: you are free to change and redistribute it.\n\
1411 There is NO WARRANTY, to the extent permitted by law.");
1416 fprintf_filtered (stream
, ("\nType \"show copying\" and "
1417 "\"show warranty\" for details.\n"));
1419 /* After the required info we print the configuration information. */
1421 fprintf_filtered (stream
, "This GDB was configured as \"");
1422 if (strcmp (host_name
, target_name
) != 0)
1424 fprintf_filtered (stream
, "--host=%s --target=%s",
1425 host_name
, target_name
);
1429 fprintf_filtered (stream
, "%s", host_name
);
1431 fprintf_filtered (stream
, "\".\n");
1433 fprintf_filtered (stream
, _("Type \"show configuration\" "
1434 "for configuration details.\n"));
1436 if (REPORT_BUGS_TO
[0])
1438 fprintf_filtered (stream
,
1439 _("For bug reporting instructions, please see:\n"));
1440 fprintf_filtered (stream
, "%s.\n", REPORT_BUGS_TO
);
1442 fprintf_filtered (stream
,
1443 _("Find the GDB manual and other documentation \
1444 resources online at:\n <http://www.gnu.org/software/gdb/documentation/>."));
1445 fprintf_filtered (stream
, "\n\n");
1446 fprintf_filtered (stream
, _("For help, type \"help\".\n"));
1447 fprintf_filtered (stream
,
1448 _("Type \"apropos word\" to search for commands \
1449 related to \"word\"."));
1452 /* Print the details of GDB build-time configuration. */
1454 print_gdb_configuration (struct ui_file
*stream
)
1456 fprintf_filtered (stream
, _("\
1457 This GDB was configured as follows:\n\
1458 configure --host=%s --target=%s\n\
1459 "), host_name
, target_name
);
1461 fprintf_filtered (stream
, _("\
1462 --with-auto-load-dir=%s\n\
1463 --with-auto-load-safe-path=%s\n\
1464 "), AUTO_LOAD_DIR
, AUTO_LOAD_SAFE_PATH
);
1467 fprintf_filtered (stream
, _("\
1471 fprintf_filtered (stream
, _("\
1477 fprintf_filtered (stream
, _("\
1478 --with-gdb-datadir=%s%s\n\
1479 "), GDB_DATADIR
, GDB_DATADIR_RELOCATABLE
? " (relocatable)" : "");
1482 fprintf_filtered (stream
, _("\
1483 --with-iconv-bin=%s%s\n\
1484 "), ICONV_BIN
, ICONV_BIN_RELOCATABLE
? " (relocatable)" : "");
1487 if (JIT_READER_DIR
[0])
1488 fprintf_filtered (stream
, _("\
1489 --with-jit-reader-dir=%s%s\n\
1490 "), JIT_READER_DIR
, JIT_READER_DIR_RELOCATABLE
? " (relocatable)" : "");
1492 #if HAVE_LIBUNWIND_IA64_H
1493 fprintf_filtered (stream
, _("\
1494 --with-libunwind-ia64\n\
1497 fprintf_filtered (stream
, _("\
1498 --without-libunwind-ia64\n\
1503 fprintf_filtered (stream
, _("\
1507 fprintf_filtered (stream
, _("\
1512 #if HAVE_LIBBABELTRACE
1513 fprintf_filtered (stream
, _("\
1514 --with-babeltrace\n\
1517 fprintf_filtered (stream
, _("\
1518 --without-babeltrace\n\
1523 fprintf_filtered (stream
, _("\
1527 fprintf_filtered (stream
, _("\
1528 --without-intel-pt\n\
1533 fprintf_filtered (stream
, _("\
1537 fprintf_filtered (stream
, _("\
1542 fprintf_filtered (stream
, _("\
1546 fprintf_filtered (stream
, _("\
1550 #ifdef WITH_PYTHON_PATH
1551 fprintf_filtered (stream
, _("\
1552 --with-python=%s%s\n\
1553 "), WITH_PYTHON_PATH
, PYTHON_PATH_RELOCATABLE
? " (relocatable)" : "");
1555 fprintf_filtered (stream
, _("\
1559 #ifdef WITH_PYTHON_LIBDIR
1560 fprintf_filtered (stream
, _("\
1561 --with-python-libdir=%s%s\n\
1562 "), WITH_PYTHON_LIBDIR
, PYTHON_LIBDIR_RELOCATABLE
? " (relocatable)" : "");
1564 fprintf_filtered (stream
, _("\
1565 --without-python-libdir\n\
1569 #if HAVE_LIBDEBUGINFOD
1570 fprintf_filtered (stream
, _("\
1571 --with-debuginfod\n\
1574 fprintf_filtered (stream
, _("\
1575 --without-debuginfod\n\
1580 fprintf_filtered (stream
, _("\
1584 fprintf_filtered (stream
, _("\
1589 #if HAVE_SOURCE_HIGHLIGHT
1590 fprintf_filtered (stream
, _("\
1591 --enable-source-highlight\n\
1594 fprintf_filtered (stream
, _("\
1595 --disable-source-highlight\n\
1600 fprintf_filtered (stream
, _("\
1601 --with-relocated-sources=%s\n\
1606 fprintf_filtered (stream
, _("\
1607 --with-separate-debug-dir=%s%s\n\
1608 "), DEBUGDIR
, DEBUGDIR_RELOCATABLE
? " (relocatable)" : "");
1610 if (TARGET_SYSTEM_ROOT
[0])
1611 fprintf_filtered (stream
, _("\
1612 --with-sysroot=%s%s\n\
1613 "), TARGET_SYSTEM_ROOT
, TARGET_SYSTEM_ROOT_RELOCATABLE
? " (relocatable)" : "");
1615 if (SYSTEM_GDBINIT
[0])
1616 fprintf_filtered (stream
, _("\
1617 --with-system-gdbinit=%s%s\n\
1618 "), SYSTEM_GDBINIT
, SYSTEM_GDBINIT_RELOCATABLE
? " (relocatable)" : "");
1620 if (SYSTEM_GDBINIT_DIR
[0])
1621 fprintf_filtered (stream
, _("\
1622 --with-system-gdbinit-dir=%s%s\n\
1623 "), SYSTEM_GDBINIT_DIR
, SYSTEM_GDBINIT_DIR_RELOCATABLE
? " (relocatable)" : "");
1625 /* We assume "relocatable" will be printed at least once, thus we always
1626 print this text. It's a reasonably safe assumption for now. */
1627 fprintf_filtered (stream
, _("\n\
1628 (\"Relocatable\" means the directory can be moved with the GDB installation\n\
1629 tree, and GDB will still find it.)\n\
1634 /* The current top level prompt, settable with "set prompt", and/or
1635 with the python `gdb.prompt_hook' hook. */
1636 static char *top_prompt
;
1638 /* Access method for the GDB prompt string. */
1646 /* Set method for the GDB prompt string. */
1649 set_prompt (const char *s
)
1651 char *p
= xstrdup (s
);
1658 /* Kills or detaches the given inferior, depending on how we originally
1659 gained control of it. */
1662 kill_or_detach (inferior
*inf
, int from_tty
)
1667 thread_info
*thread
= any_thread_of_inferior (inf
);
1670 switch_to_thread (thread
);
1672 /* Leave core files alone. */
1673 if (target_has_execution ())
1675 if (inf
->attach_flag
)
1676 target_detach (inf
, from_tty
);
1683 /* Prints info about what GDB will do to inferior INF on a "quit". OUT is
1684 where to collect the output. */
1687 print_inferior_quit_action (inferior
*inf
, ui_file
*out
)
1692 if (inf
->attach_flag
)
1693 fprintf_filtered (out
,
1694 _("\tInferior %d [%s] will be detached.\n"), inf
->num
,
1695 target_pid_to_str (ptid_t (inf
->pid
)).c_str ());
1697 fprintf_filtered (out
,
1698 _("\tInferior %d [%s] will be killed.\n"), inf
->num
,
1699 target_pid_to_str (ptid_t (inf
->pid
)).c_str ());
1702 /* If necessary, make the user confirm that we should quit. Return
1703 non-zero if we should quit, zero if we shouldn't. */
1708 /* Don't even ask if we're only debugging a core file inferior. */
1709 if (!have_live_inferiors ())
1712 /* Build the query string as a single string. */
1715 stb
.puts (_("A debugging session is active.\n\n"));
1717 for (inferior
*inf
: all_inferiors ())
1718 print_inferior_quit_action (inf
, &stb
);
1720 stb
.puts (_("\nQuit anyway? "));
1722 return query ("%s", stb
.c_str ());
1725 /* Prepare to exit GDB cleanly by undoing any changes made to the
1726 terminal so that we leave the terminal in the state we acquired it. */
1729 undo_terminal_modifications_before_exit (void)
1731 struct ui
*saved_top_level
= current_ui
;
1733 target_terminal::ours ();
1735 current_ui
= main_ui
;
1740 gdb_disable_readline ();
1742 current_ui
= saved_top_level
;
1746 /* Quit without asking for confirmation. */
1749 quit_force (int *exit_arg
, int from_tty
)
1753 undo_terminal_modifications_before_exit ();
1755 /* An optional expression may be used to cause gdb to terminate with the
1756 value of that expression. */
1758 exit_code
= *exit_arg
;
1759 else if (return_child_result
)
1760 exit_code
= return_child_result_value
;
1762 /* We want to handle any quit errors and exit regardless. */
1764 /* Get out of tfind mode, and kill or detach all inferiors. */
1767 disconnect_tracing ();
1768 for (inferior
*inf
: all_inferiors ())
1769 kill_or_detach (inf
, from_tty
);
1771 catch (const gdb_exception
&ex
)
1773 exception_print (gdb_stderr
, ex
);
1776 /* Give all pushed targets a chance to do minimal cleanup, and pop
1778 for (inferior
*inf
: all_inferiors ())
1780 switch_to_inferior_no_thread (inf
);
1785 catch (const gdb_exception
&ex
)
1787 exception_print (gdb_stderr
, ex
);
1791 /* Save the history information if it is appropriate to do so. */
1794 if (write_history_p
&& history_filename
)
1798 /* History is currently shared between all UIs. If there's
1799 any UI with a terminal, save history. */
1800 for (ui
*ui
: all_uis ())
1802 if (input_interactive_p (ui
))
1810 gdb_safe_append_history ();
1813 catch (const gdb_exception
&ex
)
1815 exception_print (gdb_stderr
, ex
);
1818 /* Destroy any values currently allocated now instead of leaving it
1819 to global destructors, because that may be too late. For
1820 example, the destructors of xmethod values call into the Python
1821 runtime, which is finalized via a final cleanup. */
1824 /* Do any final cleanups before exiting. */
1827 do_final_cleanups ();
1829 catch (const gdb_exception
&ex
)
1831 exception_print (gdb_stderr
, ex
);
1837 /* The value of the "interactive-mode" setting. */
1838 static enum auto_boolean interactive_mode
= AUTO_BOOLEAN_AUTO
;
1840 /* Implement the "show interactive-mode" option. */
1843 show_interactive_mode (struct ui_file
*file
, int from_tty
,
1844 struct cmd_list_element
*c
,
1847 if (interactive_mode
== AUTO_BOOLEAN_AUTO
)
1848 fprintf_filtered (file
, "Debugger's interactive mode "
1849 "is %s (currently %s).\n",
1850 value
, input_interactive_p (current_ui
) ? "on" : "off");
1852 fprintf_filtered (file
, "Debugger's interactive mode is %s.\n", value
);
1855 /* Returns whether GDB is running on an interactive terminal. */
1858 input_interactive_p (struct ui
*ui
)
1863 if (interactive_mode
!= AUTO_BOOLEAN_AUTO
)
1864 return interactive_mode
== AUTO_BOOLEAN_TRUE
;
1866 return ui
->input_interactive_p
;
1870 dont_repeat_command (const char *ignored
, int from_tty
)
1872 /* Can't call dont_repeat here because we're not necessarily reading
1874 *saved_command_line
= 0;
1877 /* Functions to manipulate command line editing control variables. */
1879 /* Number of commands to print in each call to show_commands. */
1880 #define Hist_print 10
1882 show_commands (const char *args
, int from_tty
)
1884 /* Index for history commands. Relative to history_base. */
1887 /* Number of the history entry which we are planning to display next.
1888 Relative to history_base. */
1891 /* Print out some of the commands from the command history. */
1895 if (args
[0] == '+' && args
[1] == '\0')
1896 /* "info editing +" should print from the stored position. */
1899 /* "info editing <exp>" should print around command number <exp>. */
1900 num
= (parse_and_eval_long (args
) - history_base
) - Hist_print
/ 2;
1902 /* "show commands" means print the last Hist_print commands. */
1905 num
= history_length
- Hist_print
;
1911 /* If there are at least Hist_print commands, we want to display the last
1912 Hist_print rather than, say, the last 6. */
1913 if (history_length
- num
< Hist_print
)
1915 num
= history_length
- Hist_print
;
1921 offset
< num
+ Hist_print
&& offset
< history_length
;
1924 printf_filtered ("%5d %s\n", history_base
+ offset
,
1925 (history_get (history_base
+ offset
))->line
);
1928 /* The next command we want to display is the next one that we haven't
1932 /* If the user repeats this command with return, it should do what
1933 "show commands +" does. This is unnecessary if arg is null,
1934 because "show commands +" is not useful after "show commands". */
1935 if (from_tty
&& args
)
1936 set_repeat_arguments ("+");
1939 /* Update the size of our command history file to HISTORY_SIZE.
1941 A HISTORY_SIZE of -1 stands for unlimited. */
1944 set_readline_history_size (int history_size
)
1946 gdb_assert (history_size
>= -1);
1948 if (history_size
== -1)
1949 unstifle_history ();
1951 stifle_history (history_size
);
1954 /* Called by do_setshow_command. */
1956 set_history_size_command (const char *args
,
1957 int from_tty
, struct cmd_list_element
*c
)
1959 set_readline_history_size (history_size_setshow_var
);
1962 bool info_verbose
= false; /* Default verbose msgs off. */
1964 /* Called by do_set_command. An elaborate joke. */
1966 set_verbose (const char *args
, int from_tty
, struct cmd_list_element
*c
)
1968 const char *cmdname
= "verbose";
1969 struct cmd_list_element
*showcmd
;
1971 showcmd
= lookup_cmd_1 (&cmdname
, showlist
, NULL
, NULL
, 1);
1972 gdb_assert (showcmd
!= NULL
&& showcmd
!= CMD_LIST_AMBIGUOUS
);
1974 if (c
->doc
&& c
->doc_allocated
)
1975 xfree ((char *) c
->doc
);
1976 if (showcmd
->doc
&& showcmd
->doc_allocated
)
1977 xfree ((char *) showcmd
->doc
);
1980 c
->doc
= _("Set verbose printing of informational messages.");
1981 showcmd
->doc
= _("Show verbose printing of informational messages.");
1985 c
->doc
= _("Set verbosity.");
1986 showcmd
->doc
= _("Show verbosity.");
1988 c
->doc_allocated
= 0;
1989 showcmd
->doc_allocated
= 0;
1992 /* Init the history buffer. Note that we are called after the init file(s)
1993 have been read so that the user can change the history file via his
1994 .gdbinit file (for instance). The GDBHISTFILE environment variable
1995 overrides all of this. */
2002 tmpenv
= getenv ("GDBHISTSIZE");
2009 tmpenv
= skip_spaces (tmpenv
);
2011 var
= strtol (tmpenv
, &endptr
, 10);
2012 saved_errno
= errno
;
2013 endptr
= skip_spaces (endptr
);
2015 /* If GDBHISTSIZE is non-numeric then ignore it. If GDBHISTSIZE is the
2016 empty string, a negative number or a huge positive number (larger than
2017 INT_MAX) then set the history size to unlimited. Otherwise set our
2018 history size to the number we have read. This behavior is consistent
2019 with how bash handles HISTSIZE. */
2020 if (*endptr
!= '\0')
2022 else if (*tmpenv
== '\0'
2025 /* On targets where INT_MAX == LONG_MAX, we have to look at
2026 errno after calling strtol to distinguish between a value that
2027 is exactly INT_MAX and an overflowing value that was clamped
2029 || (var
== INT_MAX
&& saved_errno
== ERANGE
))
2030 history_size_setshow_var
= -1;
2032 history_size_setshow_var
= var
;
2035 /* If neither the init file nor GDBHISTSIZE has set a size yet, pick the
2037 if (history_size_setshow_var
== -2)
2038 history_size_setshow_var
= 256;
2040 set_readline_history_size (history_size_setshow_var
);
2042 tmpenv
= getenv ("GDBHISTFILE");
2043 if (tmpenv
!= nullptr)
2044 history_filename
= xstrdup (tmpenv
);
2045 else if (history_filename
== nullptr)
2047 /* We include the current directory so that if the user changes
2048 directories the file written will be the same as the one
2051 /* No leading dots in file names are allowed on MSDOS. */
2052 const char *fname
= "_gdb_history";
2054 const char *fname
= ".gdb_history";
2057 gdb::unique_xmalloc_ptr
<char> temp (gdb_abspath (fname
));
2058 history_filename
= temp
.release ();
2061 if (!history_filename_empty ())
2062 read_history (history_filename
);
2066 show_prompt (struct ui_file
*file
, int from_tty
,
2067 struct cmd_list_element
*c
, const char *value
)
2069 fprintf_filtered (file
, _("Gdb's prompt is \"%s\".\n"), value
);
2072 /* "set editing" command. */
2075 set_editing (const char *args
, int from_tty
, struct cmd_list_element
*c
)
2077 change_line_handler (set_editing_cmd_var
);
2078 /* Update the control variable so that MI's =cmd-param-changed event
2079 shows the correct value. */
2080 set_editing_cmd_var
= current_ui
->command_editing
;
2084 show_editing (struct ui_file
*file
, int from_tty
,
2085 struct cmd_list_element
*c
, const char *value
)
2087 fprintf_filtered (file
, _("Editing of command lines as "
2088 "they are typed is %s.\n"),
2089 current_ui
->command_editing
? _("on") : _("off"));
2093 show_annotation_level (struct ui_file
*file
, int from_tty
,
2094 struct cmd_list_element
*c
, const char *value
)
2096 fprintf_filtered (file
, _("Annotation_level is %s.\n"), value
);
2100 show_exec_done_display_p (struct ui_file
*file
, int from_tty
,
2101 struct cmd_list_element
*c
, const char *value
)
2103 fprintf_filtered (file
, _("Notification of completion for "
2104 "asynchronous execution commands is %s.\n"),
2108 /* New values of the "data-directory" parameter are staged here. */
2109 static char *staged_gdb_datadir
;
2111 /* "set" command for the gdb_datadir configuration variable. */
2114 set_gdb_datadir (const char *args
, int from_tty
, struct cmd_list_element
*c
)
2116 set_gdb_data_directory (staged_gdb_datadir
);
2117 gdb::observers::gdb_datadir_changed
.notify ();
2120 /* "show" command for the gdb_datadir configuration variable. */
2123 show_gdb_datadir (struct ui_file
*file
, int from_tty
,
2124 struct cmd_list_element
*c
, const char *value
)
2126 fprintf_filtered (file
, _("GDB's data directory is \"%ps\".\n"),
2127 styled_string (file_name_style
.style (),
2128 gdb_datadir
.c_str ()));
2131 /* Implement 'set history filename'. */
2134 set_history_filename (const char *args
,
2135 int from_tty
, struct cmd_list_element
*c
)
2137 /* We include the current directory so that if the user changes
2138 directories the file written will be the same as the one
2140 if (!history_filename_empty () && !IS_ABSOLUTE_PATH (history_filename
))
2142 gdb::unique_xmalloc_ptr
<char> temp (gdb_abspath (history_filename
));
2144 xfree (history_filename
);
2145 history_filename
= temp
.release ();
2150 init_gdb_version_vars (void)
2152 struct internalvar
*major_version_var
= create_internalvar ("_gdb_major");
2153 struct internalvar
*minor_version_var
= create_internalvar ("_gdb_minor");
2154 int vmajor
= 0, vminor
= 0, vrevision
= 0;
2155 sscanf (version
, "%d.%d.%d", &vmajor
, &vminor
, &vrevision
);
2156 set_internalvar_integer (major_version_var
, vmajor
);
2157 set_internalvar_integer (minor_version_var
, vminor
+ (vrevision
> 0));
2163 struct cmd_list_element
*c
;
2165 /* Initialize the prompt to a simple "(gdb) " prompt or to whatever
2166 the DEFAULT_PROMPT is. */
2167 set_prompt (DEFAULT_PROMPT
);
2169 /* Set the important stuff up for command editing. */
2170 command_editing_p
= 1;
2171 history_expansion_p
= 0;
2172 write_history_p
= 0;
2174 /* Setup important stuff for command line editing. */
2175 rl_completion_word_break_hook
= gdb_completion_word_break_characters
;
2176 rl_attempted_completion_function
= gdb_rl_attempted_completion_function
;
2177 set_rl_completer_word_break_characters (default_word_break_characters ());
2178 rl_completer_quote_characters
= get_gdb_completer_quote_characters ();
2179 rl_completion_display_matches_hook
= cli_display_match_list
;
2180 rl_readline_name
= "gdb";
2181 rl_terminal_name
= getenv ("TERM");
2183 /* The name for this defun comes from Bash, where it originated.
2184 15 is Control-o, the same binding this function has in Bash. */
2185 rl_add_defun ("operate-and-get-next", gdb_rl_operate_and_get_next
, 15);
2187 add_setshow_string_cmd ("prompt", class_support
,
2189 _("Set gdb's prompt."),
2190 _("Show gdb's prompt."),
2193 &setlist
, &showlist
);
2195 add_com ("dont-repeat", class_support
, dont_repeat_command
, _("\
2196 Don't repeat this command.\nPrimarily \
2197 used inside of user-defined commands that should not be repeated when\n\
2200 add_setshow_boolean_cmd ("editing", class_support
,
2201 &set_editing_cmd_var
, _("\
2202 Set editing of command lines as they are typed."), _("\
2203 Show editing of command lines as they are typed."), _("\
2204 Use \"on\" to enable the editing, and \"off\" to disable it.\n\
2205 Without an argument, command line editing is enabled. To edit, use\n\
2206 EMACS-like or VI-like commands like control-P or ESC."),
2209 &setlist
, &showlist
);
2211 add_setshow_boolean_cmd ("save", no_class
, &write_history_p
, _("\
2212 Set saving of the history record on exit."), _("\
2213 Show saving of the history record on exit."), _("\
2214 Use \"on\" to enable the saving, and \"off\" to disable it.\n\
2215 Without an argument, saving is enabled."),
2217 show_write_history_p
,
2218 &sethistlist
, &showhistlist
);
2220 add_setshow_zuinteger_unlimited_cmd ("size", no_class
,
2221 &history_size_setshow_var
, _("\
2222 Set the size of the command history."), _("\
2223 Show the size of the command history."), _("\
2224 This is the number of previous commands to keep a record of.\n\
2225 If set to \"unlimited\", the number of commands kept in the history\n\
2226 list is unlimited. This defaults to the value of the environment\n\
2227 variable \"GDBHISTSIZE\", or to 256 if this variable is not set."),
2228 set_history_size_command
,
2230 &sethistlist
, &showhistlist
);
2232 add_setshow_zuinteger_unlimited_cmd ("remove-duplicates", no_class
,
2233 &history_remove_duplicates
, _("\
2234 Set how far back in history to look for and remove duplicate entries."), _("\
2235 Show how far back in history to look for and remove duplicate entries."), _("\
2236 If set to a nonzero value N, GDB will look back at the last N history entries\n\
2237 and remove the first history entry that is a duplicate of the most recent\n\
2238 entry, each time a new history entry is added.\n\
2239 If set to \"unlimited\", this lookbehind is unbounded.\n\
2240 Only history entries added during this session are considered for removal.\n\
2241 If set to 0, removal of duplicate history entries is disabled.\n\
2242 By default this option is set to 0."),
2244 show_history_remove_duplicates
,
2245 &sethistlist
, &showhistlist
);
2247 add_setshow_optional_filename_cmd ("filename", no_class
, &history_filename
, _("\
2248 Set the filename in which to record the command history."), _("\
2249 Show the filename in which to record the command history."), _("\
2250 (the list of previous commands of which a record is kept)."),
2251 set_history_filename
,
2252 show_history_filename
,
2253 &sethistlist
, &showhistlist
);
2255 add_setshow_boolean_cmd ("confirm", class_support
, &confirm
, _("\
2256 Set whether to confirm potentially dangerous operations."), _("\
2257 Show whether to confirm potentially dangerous operations."), NULL
,
2260 &setlist
, &showlist
);
2262 add_setshow_zinteger_cmd ("annotate", class_obscure
, &annotation_level
, _("\
2263 Set annotation_level."), _("\
2264 Show annotation_level."), _("\
2265 0 == normal; 1 == fullname (for use when running under emacs)\n\
2266 2 == output annotated suitably for use by programs that control GDB."),
2268 show_annotation_level
,
2269 &setlist
, &showlist
);
2271 add_setshow_boolean_cmd ("exec-done-display", class_support
,
2272 &exec_done_display_p
, _("\
2273 Set notification of completion for asynchronous execution commands."), _("\
2274 Show notification of completion for asynchronous execution commands."), _("\
2275 Use \"on\" to enable the notification, and \"off\" to disable it."),
2277 show_exec_done_display_p
,
2278 &setlist
, &showlist
);
2280 add_setshow_filename_cmd ("data-directory", class_maintenance
,
2281 &staged_gdb_datadir
, _("Set GDB's data directory."),
2282 _("Show GDB's data directory."),
2284 When set, GDB uses the specified path to search for data files."),
2285 set_gdb_datadir
, show_gdb_datadir
,
2289 add_setshow_auto_boolean_cmd ("interactive-mode", class_support
,
2290 &interactive_mode
, _("\
2291 Set whether GDB's standard input is a terminal."), _("\
2292 Show whether GDB's standard input is a terminal."), _("\
2293 If on, GDB assumes that standard input is a terminal. In practice, it\n\
2294 means that GDB should wait for the user to answer queries associated to\n\
2295 commands entered at the command prompt. If off, GDB assumes that standard\n\
2296 input is not a terminal, and uses the default answer to all queries.\n\
2297 If auto (the default), determine which mode to use based on the standard\n\
2300 show_interactive_mode
,
2301 &setlist
, &showlist
);
2303 c
= add_cmd ("new-ui", class_support
, new_ui_command
, _("\
2305 Usage: new-ui INTERPRETER TTY\n\
2306 The first argument is the name of the interpreter to run.\n\
2307 The second argument is the terminal the UI runs on."), &cmdlist
);
2308 set_cmd_completer (c
, interpreter_completer
);
2312 gdb_init (char *argv0
)
2314 saved_command_line
= xstrdup ("");
2315 previous_saved_command_line
= xstrdup ("");
2317 /* Run the init function of each source file. */
2320 /* Make sure we return to the original directory upon exit, come
2321 what may, since the OS doesn't do that for us. */
2322 make_final_cleanup (do_chdir_cleanup
, xstrdup (current_directory
));
2325 init_cmd_lists (); /* This needs to be done first. */
2329 /* Here is where we call all the _initialize_foo routines. */
2330 initialize_all_files ();
2332 /* This creates the current_program_space. Do this after all the
2333 _initialize_foo routines have had a chance to install their
2334 per-sspace data keys. Also do this before
2335 initialize_current_architecture is called, because it accesses
2336 exec_bfd of the current program space. */
2337 initialize_progspace ();
2338 initialize_inferiors ();
2339 initialize_current_architecture ();
2340 init_main (); /* But that omits this file! Do it now. */
2342 initialize_stdin_serial ();
2344 /* Take a snapshot of our tty state before readline/ncurses have had a chance
2346 set_initial_gdb_ttystate ();
2348 async_init_signals ();
2350 /* We need a default language for parsing expressions, so simple
2351 things like "set width 0" won't fail if no language is explicitly
2352 set in a config file or implicitly set by reading an executable
2354 set_language (language_c
);
2355 expected_language
= current_language
; /* Don't warn about the change. */
2357 /* Python initialization, for example, can require various commands to be
2358 installed. For example "info pretty-printer" needs the "info"
2359 prefix to be installed. Keep things simple and just do final
2360 script initialization here. */
2361 finish_ext_lang_initialization ();
2363 /* Create $_gdb_major and $_gdb_minor convenience variables. */
2364 init_gdb_version_vars ();