1 /* Top level stuff for GDB, the GNU debugger.
3 Copyright (C) 1986-2020 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 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 /* Non-zero tells remote* modules to output debugging info. */
203 int remote_debug
= 0;
205 /* Sbrk location on entry to main. Used for statistics only. */
206 #ifdef HAVE_USEFUL_SBRK
210 /* Hooks for alternate command interfaces. */
212 /* This hook is called from within gdb's many mini-event loops which
213 could steal control from a real user interface's event loop. It
214 returns non-zero if the user is requesting a detach, zero
217 int (*deprecated_ui_loop_hook
) (int);
220 /* Called from print_frame_info to list the line we stopped in. */
222 void (*deprecated_print_frame_info_listing_hook
) (struct symtab
* s
,
226 /* Replaces most of query. */
228 int (*deprecated_query_hook
) (const char *, va_list);
230 /* Replaces most of warning. */
232 void (*deprecated_warning_hook
) (const char *, va_list);
234 /* These three functions support getting lines of text from the user.
235 They are used in sequence. First deprecated_readline_begin_hook is
236 called with a text string that might be (for example) a message for
237 the user to type in a sequence of commands to be executed at a
238 breakpoint. If this function calls back to a GUI, it might take
239 this opportunity to pop up a text interaction window with this
240 message. Next, deprecated_readline_hook is called with a prompt
241 that is emitted prior to collecting the user input. It can be
242 called multiple times. Finally, deprecated_readline_end_hook is
243 called to notify the GUI that we are done with the interaction
244 window and it can close it. */
246 void (*deprecated_readline_begin_hook
) (const char *, ...);
247 char *(*deprecated_readline_hook
) (const char *);
248 void (*deprecated_readline_end_hook
) (void);
250 /* Called as appropriate to notify the interface that we have attached
251 to or detached from an already running process. */
253 void (*deprecated_attach_hook
) (void);
254 void (*deprecated_detach_hook
) (void);
256 /* Called when going to wait for the target. Usually allows the GUI
257 to run while waiting for target events. */
259 ptid_t (*deprecated_target_wait_hook
) (ptid_t ptid
,
260 struct target_waitstatus
*status
,
263 /* Used by UI as a wrapper around command execution. May do various
264 things like enabling/disabling buttons, etc... */
266 void (*deprecated_call_command_hook
) (struct cmd_list_element
* c
,
267 const char *cmd
, int from_tty
);
269 /* Called when the current thread changes. Argument is thread id. */
271 void (*deprecated_context_hook
) (int id
);
275 ui::ui (FILE *instream_
, FILE *outstream_
, FILE *errstream_
)
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
);
447 void (*pre_init_ui_hook
) (void);
451 do_chdir_cleanup (void *old_dir
)
453 chdir ((const char *) old_dir
);
459 prepare_execute_command ()
461 /* With multiple threads running while the one we're examining is
462 stopped, the dcache can get stale without us being able to detect
463 it. For the duration of the command, though, use the dcache to
464 help things like backtrace. */
466 target_dcache_invalidate ();
468 return scoped_value_mark ();
471 /* Tell the user if the language has changed (except first time) after
472 executing a command. */
475 check_frame_language_change (void)
477 static int warned
= 0;
478 struct frame_info
*frame
;
480 /* First make sure that a new frame has been selected, in case the
481 command or the hooks changed the program state. */
482 frame
= deprecated_safe_get_selected_frame ();
483 if (current_language
!= expected_language
)
485 if (language_mode
== language_mode_auto
&& info_verbose
)
487 language_info (1); /* Print what changed. */
492 /* Warn the user if the working language does not match the language
493 of the current frame. Only warn the user if we are actually
494 running the program, i.e. there is a stack. */
495 /* FIXME: This should be cacheing the frame and only running when
496 the frame changes. */
498 if (has_stack_frames ())
502 flang
= get_frame_language (frame
);
504 && flang
!= language_unknown
505 && flang
!= current_language
->la_language
)
507 printf_filtered ("%s\n", _(lang_frame_mismatch_warn
));
516 wait_sync_command_done (void)
518 /* Processing events may change the current UI. */
519 scoped_restore save_ui
= make_scoped_restore (¤t_ui
);
520 struct ui
*ui
= current_ui
;
522 while (gdb_do_one_event () >= 0)
523 if (ui
->prompt_state
!= PROMPT_BLOCKED
)
530 maybe_wait_sync_command_done (int was_sync
)
532 /* If the interpreter is in sync mode (we're running a user
533 command's list, running command hooks or similars), and we
534 just ran a synchronous command that started the target, wait
535 for that command to end. */
536 if (!current_ui
->async
538 && current_ui
->prompt_state
== PROMPT_BLOCKED
)
539 wait_sync_command_done ();
545 set_repeat_arguments (const char *args
)
547 repeat_arguments
= args
;
550 /* Execute the line P as a command, in the current user context.
551 Pass FROM_TTY as second argument to the defining function. */
554 execute_command (const char *p
, int from_tty
)
556 struct cmd_list_element
*c
;
558 const char *cmd_start
= p
;
560 auto cleanup_if_error
= make_scope_exit (bpstat_clear_actions
);
561 scoped_value_mark cleanup
= prepare_execute_command ();
563 /* This can happen when command_line_input hits end of file. */
566 cleanup_if_error
.release ();
570 target_log_command (p
);
572 while (*p
== ' ' || *p
== '\t')
578 std::string default_args
;
579 std::string default_args_and_arg
;
580 int was_sync
= current_ui
->prompt_state
== PROMPT_BLOCKED
;
584 /* If trace-commands is set then this will print this command. */
585 print_command_trace ("%s", p
);
587 c
= lookup_cmd (&cmd
, cmdlist
, "", &default_args
, 0, 1);
590 scoped_restore save_repeat_args
591 = make_scoped_restore (&repeat_arguments
, nullptr);
592 const char *args_pointer
= p
;
594 if (!default_args
.empty ())
597 default_args_and_arg
= default_args
+ ' ' + p
;
599 default_args_and_arg
= default_args
;
600 arg
= default_args_and_arg
.c_str ();
604 /* Pass null arg rather than an empty one. */
605 arg
= *p
== '\0' ? nullptr : p
;
608 /* FIXME: cagney/2002-02-02: The c->type test is pretty dodgy
609 while the is_complete_command(cfunc) test is just plain
610 bogus. They should both be replaced by a test of the form
611 c->strip_trailing_white_space_p. */
612 /* NOTE: cagney/2002-02-02: The function.cfunc in the below
613 can't be replaced with func. This is because it is the
614 cfunc, and not the func, that has the value that the
615 is_complete_command hack is testing for. */
616 /* Clear off trailing whitespace, except for set and complete
618 std::string without_whitespace
;
620 && c
->type
!= set_cmd
621 && !is_complete_command (c
))
623 const char *old_end
= arg
+ strlen (arg
) - 1;
625 while (p
>= arg
&& (*p
== ' ' || *p
== '\t'))
629 without_whitespace
= std::string (arg
, p
+ 1);
630 arg
= without_whitespace
.c_str ();
634 /* If this command has been pre-hooked, run the hook first. */
635 execute_cmd_pre_hook (c
);
637 if (c
->deprecated_warn_user
)
638 deprecated_cmd_warning (line
);
640 /* c->user_commands would be NULL in the case of a python command. */
641 if (c
->theclass
== class_user
&& c
->user_commands
)
642 execute_user_command (c
, arg
);
643 else if (c
->theclass
== class_user
644 && c
->prefixlist
&& !c
->allow_unknown
)
645 /* If this is a user defined prefix that does not allow unknown
646 (in other words, C is a prefix command and not a command
647 that can be followed by its args), report the list of
651 ("\"%.*s\" must be followed by the name of a subcommand.\n",
652 (int) strlen (c
->prefixname
) - 1, c
->prefixname
);
653 help_list (*c
->prefixlist
, c
->prefixname
, all_commands
, gdb_stdout
);
655 else if (c
->type
== set_cmd
)
656 do_set_command (arg
, from_tty
, c
);
657 else if (c
->type
== show_cmd
)
658 do_show_command (arg
, from_tty
, c
);
659 else if (!cmd_func_p (c
))
660 error (_("That is not a command, just a help topic."));
661 else if (deprecated_call_command_hook
)
662 deprecated_call_command_hook (c
, arg
, from_tty
);
664 cmd_func (c
, arg
, from_tty
);
666 maybe_wait_sync_command_done (was_sync
);
668 /* If this command has been post-hooked, run the hook last. */
669 execute_cmd_post_hook (c
);
671 if (repeat_arguments
!= NULL
&& cmd_start
== saved_command_line
)
673 gdb_assert (strlen (args_pointer
) >= strlen (repeat_arguments
));
674 strcpy (saved_command_line
+ (args_pointer
- cmd_start
),
679 /* Only perform the frame-language-change check if the command
680 we just finished executing did not resume the inferior's execution.
681 If it did resume the inferior, we will do that check after
682 the inferior stopped. */
683 if (has_stack_frames () && inferior_thread ()->state
!= THREAD_RUNNING
)
684 check_frame_language_change ();
686 cleanup_if_error
.release ();
689 /* Run execute_command for P and FROM_TTY. Sends its output to FILE,
690 do not display it to the screen. BATCH_FLAG will be
691 temporarily set to true. */
694 execute_command_to_ui_file (struct ui_file
*file
, const char *p
, int from_tty
)
696 /* GDB_STDOUT should be better already restored during these
697 restoration callbacks. */
698 set_batch_flag_and_restore_page_info save_page_info
;
700 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
703 current_uiout
->redirect (file
);
704 ui_out_redirect_pop
redirect_popper (current_uiout
);
706 scoped_restore save_stdout
707 = make_scoped_restore (&gdb_stdout
, file
);
708 scoped_restore save_stderr
709 = make_scoped_restore (&gdb_stderr
, file
);
710 scoped_restore save_stdlog
711 = make_scoped_restore (&gdb_stdlog
, file
);
712 scoped_restore save_stdtarg
713 = make_scoped_restore (&gdb_stdtarg
, file
);
714 scoped_restore save_stdtargerr
715 = make_scoped_restore (&gdb_stdtargerr
, file
);
717 execute_command (p
, from_tty
);
721 /* Run execute_command for P and FROM_TTY. Capture its output into the
722 returned string, do not display it to the screen. BATCH_FLAG will be
723 temporarily set to true. */
726 execute_command_to_string (const char *p
, int from_tty
,
729 string_file
str_file (term_out
);
731 execute_command_to_ui_file (&str_file
, p
, from_tty
);
732 return std::move (str_file
.string ());
736 /* When nonzero, cause dont_repeat to do nothing. This should only be
737 set via prevent_dont_repeat. */
739 static int suppress_dont_repeat
= 0;
746 struct ui
*ui
= current_ui
;
748 if (suppress_dont_repeat
|| server_command
)
751 /* If we aren't reading from standard input, we are saving the last
752 thing read from stdin in line and don't want to delete it. Null
753 lines won't repeat here in any case. */
754 if (ui
->instream
== ui
->stdin_stream
)
756 *saved_command_line
= 0;
757 repeat_arguments
= NULL
;
766 /* Do not repeat this command, as this command is a repeating command. */
769 /* We cannot free saved_command_line, as this line is being executed,
770 so swap it with previous_saved_command_line. */
771 std::swap (previous_saved_command_line
, saved_command_line
);
772 std::swap (previous_repeat_arguments
, repeat_arguments
);
774 const char *prev
= skip_spaces (get_saved_command_line ());
776 error (_("No previous command to relaunch"));
782 scoped_restore_tmpl
<int>
783 prevent_dont_repeat (void)
785 return make_scoped_restore (&suppress_dont_repeat
, 1);
791 get_saved_command_line ()
793 return saved_command_line
;
799 save_command_line (const char *cmd
)
801 xfree (previous_saved_command_line
);
802 previous_saved_command_line
= saved_command_line
;
803 previous_repeat_arguments
= repeat_arguments
;
804 saved_command_line
= xstrdup (cmd
);
805 repeat_arguments
= NULL
;
809 /* Read a line from the stream "instream" without command line editing.
811 It prints PROMPT once at the start.
812 Action is compatible with "readline", e.g. space for the result is
813 malloc'd and should be freed by the caller.
815 A NULL return means end of file. */
818 gdb_readline_no_editing (const char *prompt
)
820 struct buffer line_buffer
;
821 struct ui
*ui
= current_ui
;
822 /* Read from stdin if we are executing a user defined command. This
823 is the right thing for prompt_for_continue, at least. */
824 FILE *stream
= ui
->instream
!= NULL
? ui
->instream
: stdin
;
825 int fd
= fileno (stream
);
827 buffer_init (&line_buffer
);
831 /* Don't use a _filtered function here. It causes the assumed
832 character position to be off, since the newline we read from
833 the user is not accounted for. */
834 fputs_unfiltered (prompt
, gdb_stdout
);
835 gdb_flush (gdb_stdout
);
845 /* Wait until at least one byte of data is available. Control-C
846 can interrupt interruptible_select, but not fgetc. */
848 FD_SET (fd
, &readfds
);
849 if (interruptible_select (fd
+ 1, &readfds
, NULL
, NULL
, NULL
) == -1)
853 /* If this was ctrl-c, the QUIT above handles it. */
856 perror_with_name (("select"));
863 if (line_buffer
.used_size
> 0)
864 /* The last line does not end with a newline. Return it, and
865 if we are called again fgetc will still return EOF and
866 we'll return NULL then. */
868 xfree (buffer_finish (&line_buffer
));
874 if (line_buffer
.used_size
> 0
875 && line_buffer
.buffer
[line_buffer
.used_size
- 1] == '\r')
876 line_buffer
.used_size
--;
880 buffer_grow_char (&line_buffer
, c
);
883 buffer_grow_char (&line_buffer
, '\0');
884 return buffer_finish (&line_buffer
);
887 /* Variables which control command line editing and history
888 substitution. These variables are given default values at the end
890 static bool command_editing_p
;
892 /* NOTE 1999-04-29: This variable will be static again, once we modify
893 gdb to use the event loop as the default command loop and we merge
894 event-top.c into this file, top.c. */
896 /* static */ bool history_expansion_p
;
898 /* Should we write out the command history on exit? In order to write out
899 the history both this flag must be true, and the history_filename
900 variable must be set to something sensible. */
901 static bool write_history_p
;
903 /* Implement 'show history save'. */
905 show_write_history_p (struct ui_file
*file
, int from_tty
,
906 struct cmd_list_element
*c
, const char *value
)
908 if (!write_history_p
|| !history_filename_empty ())
909 fprintf_filtered (file
, _("Saving of the history record on exit is %s.\n"),
912 fprintf_filtered (file
, _("Saving of the history is disabled due to "
913 "the value of 'history filename'.\n"));
916 /* The variable associated with the "set/show history size"
917 command. The value -1 means unlimited, and -2 means undefined. */
918 static int history_size_setshow_var
= -2;
921 show_history_size (struct ui_file
*file
, int from_tty
,
922 struct cmd_list_element
*c
, const char *value
)
924 fprintf_filtered (file
, _("The size of the command history is %s.\n"),
928 /* Variable associated with the "history remove-duplicates" option.
929 The value -1 means unlimited. */
930 static int history_remove_duplicates
= 0;
933 show_history_remove_duplicates (struct ui_file
*file
, int from_tty
,
934 struct cmd_list_element
*c
, const char *value
)
936 fprintf_filtered (file
,
937 _("The number of history entries to look back at for "
938 "duplicates is %s.\n"),
942 /* The name of the file in which GDB history will be written. If this is
943 set to NULL, of the empty string then history will not be written. */
944 static char *history_filename
;
946 /* Return true if the history_filename is either NULL or the empty string,
947 indicating that we should not try to read, nor write out the history. */
949 history_filename_empty (void)
951 return (history_filename
== nullptr || *history_filename
== '\0');
954 /* Implement 'show history filename'. */
956 show_history_filename (struct ui_file
*file
, int from_tty
,
957 struct cmd_list_element
*c
, const char *value
)
959 if (!history_filename_empty ())
960 fprintf_filtered (file
, _("The filename in which to record "
961 "the command history is \"%ps\".\n"),
962 styled_string (file_name_style
.style (), value
));
964 fprintf_filtered (file
, _("There is no filename currently set for "
965 "recording the command history in.\n"));
968 /* This is like readline(), but it has some gdb-specific behavior.
969 gdb may want readline in both the synchronous and async modes during
970 a single gdb invocation. At the ordinary top-level prompt we might
971 be using the async readline. That means we can't use
972 rl_pre_input_hook, since it doesn't work properly in async mode.
973 However, for a secondary prompt (" >", such as occurs during a
974 `define'), gdb wants a synchronous response.
976 We used to call readline() directly, running it in synchronous
977 mode. But mixing modes this way is not supported, and as of
978 readline 5.x it no longer works; the arrow keys come unbound during
979 the synchronous call. So we make a nested call into the event
980 loop. That's what gdb_readline_wrapper is for. */
982 /* A flag set as soon as gdb_readline_wrapper_line is called; we can't
983 rely on gdb_readline_wrapper_result, which might still be NULL if
984 the user types Control-D for EOF. */
985 static int gdb_readline_wrapper_done
;
987 /* The result of the current call to gdb_readline_wrapper, once a newline
989 static char *gdb_readline_wrapper_result
;
991 /* Any intercepted hook. Operate-and-get-next sets this, expecting it
992 to be called after the newline is processed (which will redisplay
993 the prompt). But in gdb_readline_wrapper we will not get a new
994 prompt until the next call, or until we return to the event loop.
995 So we disable this hook around the newline and restore it before we
997 static void (*saved_after_char_processing_hook
) (void);
1003 gdb_in_secondary_prompt_p (struct ui
*ui
)
1005 return ui
->secondary_prompt_depth
> 0;
1009 /* This function is called when readline has seen a complete line of
1013 gdb_readline_wrapper_line (gdb::unique_xmalloc_ptr
<char> &&line
)
1015 gdb_assert (!gdb_readline_wrapper_done
);
1016 gdb_readline_wrapper_result
= line
.release ();
1017 gdb_readline_wrapper_done
= 1;
1019 /* Prevent operate-and-get-next from acting too early. */
1020 saved_after_char_processing_hook
= after_char_processing_hook
;
1021 after_char_processing_hook
= NULL
;
1023 /* Prevent parts of the prompt from being redisplayed if annotations
1024 are enabled, and readline's state getting out of sync. We'll
1025 reinstall the callback handler, which puts the terminal in raw
1026 mode (or in readline lingo, in prepped state), when we're next
1027 ready to process user input, either in display_gdb_prompt, or if
1028 we're handling an asynchronous target event and running in the
1029 background, just before returning to the event loop to process
1030 further input (or more target events). */
1031 if (current_ui
->command_editing
)
1032 gdb_rl_callback_handler_remove ();
1035 class gdb_readline_wrapper_cleanup
1038 gdb_readline_wrapper_cleanup ()
1039 : m_handler_orig (current_ui
->input_handler
),
1040 m_already_prompted_orig (current_ui
->command_editing
1041 ? rl_already_prompted
: 0),
1042 m_target_is_async_orig (target_is_async_p ()),
1043 m_save_ui (¤t_ui
)
1045 current_ui
->input_handler
= gdb_readline_wrapper_line
;
1046 current_ui
->secondary_prompt_depth
++;
1048 if (m_target_is_async_orig
)
1052 ~gdb_readline_wrapper_cleanup ()
1054 struct ui
*ui
= current_ui
;
1056 if (ui
->command_editing
)
1057 rl_already_prompted
= m_already_prompted_orig
;
1059 gdb_assert (ui
->input_handler
== gdb_readline_wrapper_line
);
1060 ui
->input_handler
= m_handler_orig
;
1062 /* Don't restore our input handler in readline yet. That would make
1063 readline prep the terminal (putting it in raw mode), while the
1064 line we just read may trigger execution of a command that expects
1065 the terminal in the default cooked/canonical mode, such as e.g.,
1066 running Python's interactive online help utility. See
1067 gdb_readline_wrapper_line for when we'll reinstall it. */
1069 gdb_readline_wrapper_result
= NULL
;
1070 gdb_readline_wrapper_done
= 0;
1071 ui
->secondary_prompt_depth
--;
1072 gdb_assert (ui
->secondary_prompt_depth
>= 0);
1074 after_char_processing_hook
= saved_after_char_processing_hook
;
1075 saved_after_char_processing_hook
= NULL
;
1077 if (m_target_is_async_orig
)
1081 DISABLE_COPY_AND_ASSIGN (gdb_readline_wrapper_cleanup
);
1085 void (*m_handler_orig
) (gdb::unique_xmalloc_ptr
<char> &&);
1086 int m_already_prompted_orig
;
1088 /* Whether the target was async. */
1089 int m_target_is_async_orig
;
1091 /* Processing events may change the current UI. */
1092 scoped_restore_tmpl
<struct ui
*> m_save_ui
;
1096 gdb_readline_wrapper (const char *prompt
)
1098 struct ui
*ui
= current_ui
;
1100 gdb_readline_wrapper_cleanup cleanup
;
1102 /* Display our prompt and prevent double prompt display. Don't pass
1103 down a NULL prompt, since that has special meaning for
1104 display_gdb_prompt -- it indicates a request to print the primary
1105 prompt, while we want a secondary prompt here. */
1106 display_gdb_prompt (prompt
!= NULL
? prompt
: "");
1107 if (ui
->command_editing
)
1108 rl_already_prompted
= 1;
1110 if (after_char_processing_hook
)
1111 (*after_char_processing_hook
) ();
1112 gdb_assert (after_char_processing_hook
== NULL
);
1114 while (gdb_do_one_event () >= 0)
1115 if (gdb_readline_wrapper_done
)
1118 return gdb_readline_wrapper_result
;
1122 /* The current saved history number from operate-and-get-next.
1123 This is -1 if not valid. */
1124 static int operate_saved_history
= -1;
1126 /* This is put on the appropriate hook and helps operate-and-get-next
1129 gdb_rl_operate_and_get_next_completion (void)
1131 int delta
= where_history () - operate_saved_history
;
1133 /* The `key' argument to rl_get_previous_history is ignored. */
1134 rl_get_previous_history (delta
, 0);
1135 operate_saved_history
= -1;
1137 /* readline doesn't automatically update the display for us. */
1140 after_char_processing_hook
= NULL
;
1141 rl_pre_input_hook
= NULL
;
1144 /* This is a gdb-local readline command handler. It accepts the
1145 current command line (like RET does) and, if this command was taken
1146 from the history, arranges for the next command in the history to
1147 appear on the command line when the prompt returns.
1148 We ignore the arguments. */
1150 gdb_rl_operate_and_get_next (int count
, int key
)
1154 /* Use the async hook. */
1155 after_char_processing_hook
= gdb_rl_operate_and_get_next_completion
;
1157 /* Find the current line, and find the next line to use. */
1158 where
= where_history();
1160 if ((history_is_stifled () && (history_length
>= history_max_entries
))
1161 || (where
>= history_length
- 1))
1162 operate_saved_history
= where
;
1164 operate_saved_history
= where
+ 1;
1166 return rl_newline (1, key
);
1169 /* Number of user commands executed during this session. */
1171 static int command_count
= 0;
1173 /* Add the user command COMMAND to the input history list. */
1176 gdb_add_history (const char *command
)
1180 if (history_remove_duplicates
!= 0)
1183 int lookbehind_threshold
;
1185 /* The lookbehind threshold for finding a duplicate history entry is
1186 bounded by command_count because we can't meaningfully delete
1187 history entries that are already stored in the history file since
1188 the history file is appended to. */
1189 if (history_remove_duplicates
== -1
1190 || history_remove_duplicates
> command_count
)
1191 lookbehind_threshold
= command_count
;
1193 lookbehind_threshold
= history_remove_duplicates
;
1196 for (lookbehind
= 0; lookbehind
< lookbehind_threshold
; lookbehind
++)
1198 HIST_ENTRY
*temp
= previous_history ();
1203 if (strcmp (temp
->line
, command
) == 0)
1205 HIST_ENTRY
*prev
= remove_history (where_history ());
1207 free_history_entry (prev
);
1214 add_history (command
);
1217 /* Safely append new history entries to the history file in a corruption-free
1218 way using an intermediate local history file. */
1221 gdb_safe_append_history (void)
1223 int ret
, saved_errno
;
1225 std::string local_history_filename
1226 = string_printf ("%s-gdb%ld~", history_filename
, (long) getpid ());
1228 ret
= rename (history_filename
, local_history_filename
.c_str ());
1229 saved_errno
= errno
;
1230 if (ret
< 0 && saved_errno
!= ENOENT
)
1232 warning (_("Could not rename %ps to %ps: %s"),
1233 styled_string (file_name_style
.style (), history_filename
),
1234 styled_string (file_name_style
.style (),
1235 local_history_filename
.c_str ()),
1236 safe_strerror (saved_errno
));
1242 /* If the rename failed with ENOENT then either the global history
1243 file never existed in the first place or another GDB process is
1244 currently appending to it (and has thus temporarily renamed it).
1245 Since we can't distinguish between these two cases, we have to
1246 conservatively assume the first case and therefore must write out
1247 (not append) our known history to our local history file and try
1248 to move it back anyway. Otherwise a global history file would
1249 never get created! */
1250 gdb_assert (saved_errno
== ENOENT
);
1251 write_history (local_history_filename
.c_str ());
1255 append_history (command_count
, local_history_filename
.c_str ());
1256 if (history_is_stifled ())
1257 history_truncate_file (local_history_filename
.c_str (),
1258 history_max_entries
);
1261 ret
= rename (local_history_filename
.c_str (), history_filename
);
1262 saved_errno
= errno
;
1263 if (ret
< 0 && saved_errno
!= EEXIST
)
1264 warning (_("Could not rename %s to %s: %s"),
1265 local_history_filename
.c_str (), history_filename
,
1266 safe_strerror (saved_errno
));
1270 /* Read one line from the command input stream `instream' into a local
1271 static buffer. The buffer is made bigger as necessary. Returns
1272 the address of the start of the line.
1274 NULL is returned for end of file.
1276 This routine either uses fancy command line editing or simple input
1277 as the user has requested. */
1280 command_line_input (const char *prompt_arg
, const char *annotation_suffix
)
1282 static struct buffer cmd_line_buffer
;
1283 static int cmd_line_buffer_initialized
;
1284 struct ui
*ui
= current_ui
;
1285 const char *prompt
= prompt_arg
;
1287 int from_tty
= ui
->instream
== ui
->stdin_stream
;
1289 /* The annotation suffix must be non-NULL. */
1290 if (annotation_suffix
== NULL
)
1291 annotation_suffix
= "";
1293 if (from_tty
&& annotation_level
> 1)
1298 = (char *) alloca ((prompt
== NULL
? 0 : strlen (prompt
))
1299 + strlen (annotation_suffix
) + 40);
1301 local_prompt
[0] = '\0';
1303 strcpy (local_prompt
, prompt
);
1304 strcat (local_prompt
, "\n\032\032");
1305 strcat (local_prompt
, annotation_suffix
);
1306 strcat (local_prompt
, "\n");
1308 prompt
= local_prompt
;
1311 if (!cmd_line_buffer_initialized
)
1313 buffer_init (&cmd_line_buffer
);
1314 cmd_line_buffer_initialized
= 1;
1317 /* Starting a new command line. */
1318 cmd_line_buffer
.used_size
= 0;
1322 signal (SIGTSTP
, handle_sigtstp
);
1327 gdb::unique_xmalloc_ptr
<char> rl
;
1329 /* Make sure that all output has been output. Some machines may
1330 let you get away with leaving out some of the gdb_flush, but
1333 gdb_flush (gdb_stdout
);
1334 gdb_flush (gdb_stderr
);
1336 if (!source_file_name
.empty ())
1337 ++source_line_number
;
1339 if (from_tty
&& annotation_level
> 1)
1341 puts_unfiltered ("\n\032\032pre-");
1342 puts_unfiltered (annotation_suffix
);
1343 puts_unfiltered ("\n");
1346 /* Don't use fancy stuff if not talking to stdin. */
1347 if (deprecated_readline_hook
1349 && input_interactive_p (current_ui
))
1351 rl
.reset ((*deprecated_readline_hook
) (prompt
));
1353 else if (command_editing_p
1355 && input_interactive_p (current_ui
))
1357 rl
.reset (gdb_readline_wrapper (prompt
));
1361 rl
.reset (gdb_readline_no_editing (prompt
));
1364 cmd
= handle_line_of_input (&cmd_line_buffer
, rl
.get (),
1365 0, annotation_suffix
);
1366 if (cmd
== (char *) EOF
)
1374 /* Got partial input. I.e., got a line that ends with a
1375 continuation character (backslash). Suppress printing the
1382 signal (SIGTSTP
, SIG_DFL
);
1390 print_gdb_version (struct ui_file
*stream
, bool interactive
)
1392 /* From GNU coding standards, first line is meant to be easy for a
1393 program to parse, and is just canonical program name and version
1394 number, which starts after last space. */
1396 ui_file_style style
;
1399 ui_file_style nstyle
= { ui_file_style::MAGENTA
, ui_file_style::NONE
,
1400 ui_file_style::BOLD
};
1403 fprintf_styled (stream
, style
, "GNU gdb %s%s\n", PKGVERSION
, version
);
1405 /* Second line is a copyright notice. */
1407 fprintf_filtered (stream
,
1408 "Copyright (C) 2020 Free Software Foundation, Inc.\n");
1410 /* Following the copyright is a brief statement that the program is
1411 free software, that users are free to copy and change it on
1412 certain conditions, that it is covered by the GNU GPL, and that
1413 there is no warranty. */
1415 fprintf_filtered (stream
, "\
1416 License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>\
1417 \nThis is free software: you are free to change and redistribute it.\n\
1418 There is NO WARRANTY, to the extent permitted by law.");
1423 fprintf_filtered (stream
, ("\nType \"show copying\" and "
1424 "\"show warranty\" for details.\n"));
1426 /* After the required info we print the configuration information. */
1428 fprintf_filtered (stream
, "This GDB was configured as \"");
1429 if (strcmp (host_name
, target_name
) != 0)
1431 fprintf_filtered (stream
, "--host=%s --target=%s",
1432 host_name
, target_name
);
1436 fprintf_filtered (stream
, "%s", host_name
);
1438 fprintf_filtered (stream
, "\".\n");
1440 fprintf_filtered (stream
, _("Type \"show configuration\" "
1441 "for configuration details.\n"));
1443 if (REPORT_BUGS_TO
[0])
1445 fprintf_filtered (stream
,
1446 _("For bug reporting instructions, please see:\n"));
1447 fprintf_filtered (stream
, "%s.\n", REPORT_BUGS_TO
);
1449 fprintf_filtered (stream
,
1450 _("Find the GDB manual and other documentation \
1451 resources online at:\n <http://www.gnu.org/software/gdb/documentation/>."));
1452 fprintf_filtered (stream
, "\n\n");
1453 fprintf_filtered (stream
, _("For help, type \"help\".\n"));
1454 fprintf_filtered (stream
,
1455 _("Type \"apropos word\" to search for commands \
1456 related to \"word\"."));
1459 /* Print the details of GDB build-time configuration. */
1461 print_gdb_configuration (struct ui_file
*stream
)
1463 fprintf_filtered (stream
, _("\
1464 This GDB was configured as follows:\n\
1465 configure --host=%s --target=%s\n\
1466 "), host_name
, target_name
);
1468 fprintf_filtered (stream
, _("\
1469 --with-auto-load-dir=%s\n\
1470 --with-auto-load-safe-path=%s\n\
1471 "), AUTO_LOAD_DIR
, AUTO_LOAD_SAFE_PATH
);
1474 fprintf_filtered (stream
, _("\
1478 fprintf_filtered (stream
, _("\
1484 fprintf_filtered (stream
, _("\
1485 --with-gdb-datadir=%s%s\n\
1486 "), GDB_DATADIR
, GDB_DATADIR_RELOCATABLE
? " (relocatable)" : "");
1489 fprintf_filtered (stream
, _("\
1490 --with-iconv-bin=%s%s\n\
1491 "), ICONV_BIN
, ICONV_BIN_RELOCATABLE
? " (relocatable)" : "");
1494 if (JIT_READER_DIR
[0])
1495 fprintf_filtered (stream
, _("\
1496 --with-jit-reader-dir=%s%s\n\
1497 "), JIT_READER_DIR
, JIT_READER_DIR_RELOCATABLE
? " (relocatable)" : "");
1499 #if HAVE_LIBUNWIND_IA64_H
1500 fprintf_filtered (stream
, _("\
1501 --with-libunwind-ia64\n\
1504 fprintf_filtered (stream
, _("\
1505 --without-libunwind-ia64\n\
1510 fprintf_filtered (stream
, _("\
1514 fprintf_filtered (stream
, _("\
1519 #if HAVE_LIBBABELTRACE
1520 fprintf_filtered (stream
, _("\
1521 --with-babeltrace\n\
1524 fprintf_filtered (stream
, _("\
1525 --without-babeltrace\n\
1530 fprintf_filtered (stream
, _("\
1534 fprintf_filtered (stream
, _("\
1535 --without-intel-pt\n\
1540 fprintf_filtered (stream
, _("\
1544 fprintf_filtered (stream
, _("\
1549 fprintf_filtered (stream
, _("\
1553 fprintf_filtered (stream
, _("\
1557 #ifdef WITH_PYTHON_PATH
1558 fprintf_filtered (stream
, _("\
1559 --with-python=%s%s\n\
1560 "), WITH_PYTHON_PATH
, PYTHON_PATH_RELOCATABLE
? " (relocatable)" : "");
1562 fprintf_filtered (stream
, _("\
1566 #ifdef WITH_PYTHON_LIBDIR
1567 fprintf_filtered (stream
, _("\
1568 --with-python-libdir=%s%s\n\
1569 "), WITH_PYTHON_LIBDIR
, PYTHON_LIBDIR_RELOCATABLE
? " (relocatable)" : "");
1571 fprintf_filtered (stream
, _("\
1572 --without-python-libdir\n\
1576 #if HAVE_LIBDEBUGINFOD
1577 fprintf_filtered (stream
, _("\
1578 --with-debuginfod\n\
1581 fprintf_filtered (stream
, _("\
1582 --without-debuginfod\n\
1587 fprintf_filtered (stream
, _("\
1591 fprintf_filtered (stream
, _("\
1596 #if HAVE_SOURCE_HIGHLIGHT
1597 fprintf_filtered (stream
, _("\
1598 --enable-source-highlight\n\
1601 fprintf_filtered (stream
, _("\
1602 --disable-source-highlight\n\
1607 fprintf_filtered (stream
, _("\
1608 --with-relocated-sources=%s\n\
1613 fprintf_filtered (stream
, _("\
1614 --with-separate-debug-dir=%s%s\n\
1615 "), DEBUGDIR
, DEBUGDIR_RELOCATABLE
? " (relocatable)" : "");
1617 if (TARGET_SYSTEM_ROOT
[0])
1618 fprintf_filtered (stream
, _("\
1619 --with-sysroot=%s%s\n\
1620 "), TARGET_SYSTEM_ROOT
, TARGET_SYSTEM_ROOT_RELOCATABLE
? " (relocatable)" : "");
1622 if (SYSTEM_GDBINIT
[0])
1623 fprintf_filtered (stream
, _("\
1624 --with-system-gdbinit=%s%s\n\
1625 "), SYSTEM_GDBINIT
, SYSTEM_GDBINIT_RELOCATABLE
? " (relocatable)" : "");
1627 if (SYSTEM_GDBINIT_DIR
[0])
1628 fprintf_filtered (stream
, _("\
1629 --with-system-gdbinit-dir=%s%s\n\
1630 "), SYSTEM_GDBINIT_DIR
, SYSTEM_GDBINIT_DIR_RELOCATABLE
? " (relocatable)" : "");
1632 /* We assume "relocatable" will be printed at least once, thus we always
1633 print this text. It's a reasonably safe assumption for now. */
1634 fprintf_filtered (stream
, _("\n\
1635 (\"Relocatable\" means the directory can be moved with the GDB installation\n\
1636 tree, and GDB will still find it.)\n\
1641 /* The current top level prompt, settable with "set prompt", and/or
1642 with the python `gdb.prompt_hook' hook. */
1643 static char *top_prompt
;
1645 /* Access method for the GDB prompt string. */
1653 /* Set method for the GDB prompt string. */
1656 set_prompt (const char *s
)
1658 char *p
= xstrdup (s
);
1665 /* Kills or detaches the given inferior, depending on how we originally
1666 gained control of it. */
1669 kill_or_detach (inferior
*inf
, int from_tty
)
1674 thread_info
*thread
= any_thread_of_inferior (inf
);
1677 switch_to_thread (thread
);
1679 /* Leave core files alone. */
1680 if (target_has_execution
)
1682 if (inf
->attach_flag
)
1683 target_detach (inf
, from_tty
);
1690 /* Prints info about what GDB will do to inferior INF on a "quit". OUT is
1691 where to collect the output. */
1694 print_inferior_quit_action (inferior
*inf
, ui_file
*out
)
1699 if (inf
->attach_flag
)
1700 fprintf_filtered (out
,
1701 _("\tInferior %d [%s] will be detached.\n"), inf
->num
,
1702 target_pid_to_str (ptid_t (inf
->pid
)).c_str ());
1704 fprintf_filtered (out
,
1705 _("\tInferior %d [%s] will be killed.\n"), inf
->num
,
1706 target_pid_to_str (ptid_t (inf
->pid
)).c_str ());
1709 /* If necessary, make the user confirm that we should quit. Return
1710 non-zero if we should quit, zero if we shouldn't. */
1715 /* Don't even ask if we're only debugging a core file inferior. */
1716 if (!have_live_inferiors ())
1719 /* Build the query string as a single string. */
1722 stb
.puts (_("A debugging session is active.\n\n"));
1724 for (inferior
*inf
: all_inferiors ())
1725 print_inferior_quit_action (inf
, &stb
);
1727 stb
.puts (_("\nQuit anyway? "));
1729 return query ("%s", stb
.c_str ());
1732 /* Prepare to exit GDB cleanly by undoing any changes made to the
1733 terminal so that we leave the terminal in the state we acquired it. */
1736 undo_terminal_modifications_before_exit (void)
1738 struct ui
*saved_top_level
= current_ui
;
1740 target_terminal::ours ();
1742 current_ui
= main_ui
;
1747 gdb_disable_readline ();
1749 current_ui
= saved_top_level
;
1753 /* Quit without asking for confirmation. */
1756 quit_force (int *exit_arg
, int from_tty
)
1760 undo_terminal_modifications_before_exit ();
1762 /* An optional expression may be used to cause gdb to terminate with the
1763 value of that expression. */
1765 exit_code
= *exit_arg
;
1766 else if (return_child_result
)
1767 exit_code
= return_child_result_value
;
1769 /* We want to handle any quit errors and exit regardless. */
1771 /* Get out of tfind mode, and kill or detach all inferiors. */
1774 disconnect_tracing ();
1775 for (inferior
*inf
: all_inferiors ())
1776 kill_or_detach (inf
, from_tty
);
1778 catch (const gdb_exception
&ex
)
1780 exception_print (gdb_stderr
, ex
);
1783 /* Give all pushed targets a chance to do minimal cleanup, and pop
1785 for (inferior
*inf
: all_inferiors ())
1787 switch_to_inferior_no_thread (inf
);
1792 catch (const gdb_exception
&ex
)
1794 exception_print (gdb_stderr
, ex
);
1798 /* Save the history information if it is appropriate to do so. */
1801 if (write_history_p
&& history_filename
)
1805 /* History is currently shared between all UIs. If there's
1806 any UI with a terminal, save history. */
1807 for (ui
*ui
: all_uis ())
1809 if (input_interactive_p (ui
))
1817 gdb_safe_append_history ();
1820 catch (const gdb_exception
&ex
)
1822 exception_print (gdb_stderr
, ex
);
1825 /* Destroy any values currently allocated now instead of leaving it
1826 to global destructors, because that may be too late. For
1827 example, the destructors of xmethod values call into the Python
1828 runtime, which is finalized via a final cleanup. */
1831 /* Do any final cleanups before exiting. */
1834 do_final_cleanups ();
1836 catch (const gdb_exception
&ex
)
1838 exception_print (gdb_stderr
, ex
);
1844 /* The value of the "interactive-mode" setting. */
1845 static enum auto_boolean interactive_mode
= AUTO_BOOLEAN_AUTO
;
1847 /* Implement the "show interactive-mode" option. */
1850 show_interactive_mode (struct ui_file
*file
, int from_tty
,
1851 struct cmd_list_element
*c
,
1854 if (interactive_mode
== AUTO_BOOLEAN_AUTO
)
1855 fprintf_filtered (file
, "Debugger's interactive mode "
1856 "is %s (currently %s).\n",
1857 value
, input_interactive_p (current_ui
) ? "on" : "off");
1859 fprintf_filtered (file
, "Debugger's interactive mode is %s.\n", value
);
1862 /* Returns whether GDB is running on an interactive terminal. */
1865 input_interactive_p (struct ui
*ui
)
1870 if (interactive_mode
!= AUTO_BOOLEAN_AUTO
)
1871 return interactive_mode
== AUTO_BOOLEAN_TRUE
;
1873 return ui
->input_interactive_p
;
1877 dont_repeat_command (const char *ignored
, int from_tty
)
1879 /* Can't call dont_repeat here because we're not necessarily reading
1881 *saved_command_line
= 0;
1884 /* Functions to manipulate command line editing control variables. */
1886 /* Number of commands to print in each call to show_commands. */
1887 #define Hist_print 10
1889 show_commands (const char *args
, int from_tty
)
1891 /* Index for history commands. Relative to history_base. */
1894 /* Number of the history entry which we are planning to display next.
1895 Relative to history_base. */
1898 /* Print out some of the commands from the command history. */
1902 if (args
[0] == '+' && args
[1] == '\0')
1903 /* "info editing +" should print from the stored position. */
1906 /* "info editing <exp>" should print around command number <exp>. */
1907 num
= (parse_and_eval_long (args
) - history_base
) - Hist_print
/ 2;
1909 /* "show commands" means print the last Hist_print commands. */
1912 num
= history_length
- Hist_print
;
1918 /* If there are at least Hist_print commands, we want to display the last
1919 Hist_print rather than, say, the last 6. */
1920 if (history_length
- num
< Hist_print
)
1922 num
= history_length
- Hist_print
;
1928 offset
< num
+ Hist_print
&& offset
< history_length
;
1931 printf_filtered ("%5d %s\n", history_base
+ offset
,
1932 (history_get (history_base
+ offset
))->line
);
1935 /* The next command we want to display is the next one that we haven't
1939 /* If the user repeats this command with return, it should do what
1940 "show commands +" does. This is unnecessary if arg is null,
1941 because "show commands +" is not useful after "show commands". */
1942 if (from_tty
&& args
)
1943 set_repeat_arguments ("+");
1946 /* Update the size of our command history file to HISTORY_SIZE.
1948 A HISTORY_SIZE of -1 stands for unlimited. */
1951 set_readline_history_size (int history_size
)
1953 gdb_assert (history_size
>= -1);
1955 if (history_size
== -1)
1956 unstifle_history ();
1958 stifle_history (history_size
);
1961 /* Called by do_setshow_command. */
1963 set_history_size_command (const char *args
,
1964 int from_tty
, struct cmd_list_element
*c
)
1966 set_readline_history_size (history_size_setshow_var
);
1969 bool info_verbose
= false; /* Default verbose msgs off. */
1971 /* Called by do_set_command. An elaborate joke. */
1973 set_verbose (const char *args
, int from_tty
, struct cmd_list_element
*c
)
1975 const char *cmdname
= "verbose";
1976 struct cmd_list_element
*showcmd
;
1978 showcmd
= lookup_cmd_1 (&cmdname
, showlist
, NULL
, NULL
, 1);
1979 gdb_assert (showcmd
!= NULL
&& showcmd
!= CMD_LIST_AMBIGUOUS
);
1981 if (c
->doc
&& c
->doc_allocated
)
1982 xfree ((char *) c
->doc
);
1983 if (showcmd
->doc
&& showcmd
->doc_allocated
)
1984 xfree ((char *) showcmd
->doc
);
1987 c
->doc
= _("Set verbose printing of informational messages.");
1988 showcmd
->doc
= _("Show verbose printing of informational messages.");
1992 c
->doc
= _("Set verbosity.");
1993 showcmd
->doc
= _("Show verbosity.");
1995 c
->doc_allocated
= 0;
1996 showcmd
->doc_allocated
= 0;
1999 /* Init the history buffer. Note that we are called after the init file(s)
2000 have been read so that the user can change the history file via his
2001 .gdbinit file (for instance). The GDBHISTFILE environment variable
2002 overrides all of this. */
2009 tmpenv
= getenv ("GDBHISTSIZE");
2016 tmpenv
= skip_spaces (tmpenv
);
2018 var
= strtol (tmpenv
, &endptr
, 10);
2019 saved_errno
= errno
;
2020 endptr
= skip_spaces (endptr
);
2022 /* If GDBHISTSIZE is non-numeric then ignore it. If GDBHISTSIZE is the
2023 empty string, a negative number or a huge positive number (larger than
2024 INT_MAX) then set the history size to unlimited. Otherwise set our
2025 history size to the number we have read. This behavior is consistent
2026 with how bash handles HISTSIZE. */
2027 if (*endptr
!= '\0')
2029 else if (*tmpenv
== '\0'
2032 /* On targets where INT_MAX == LONG_MAX, we have to look at
2033 errno after calling strtol to distinguish between a value that
2034 is exactly INT_MAX and an overflowing value that was clamped
2036 || (var
== INT_MAX
&& saved_errno
== ERANGE
))
2037 history_size_setshow_var
= -1;
2039 history_size_setshow_var
= var
;
2042 /* If neither the init file nor GDBHISTSIZE has set a size yet, pick the
2044 if (history_size_setshow_var
== -2)
2045 history_size_setshow_var
= 256;
2047 set_readline_history_size (history_size_setshow_var
);
2049 tmpenv
= getenv ("GDBHISTFILE");
2050 if (tmpenv
!= nullptr)
2051 history_filename
= xstrdup (tmpenv
);
2052 else if (history_filename
== nullptr)
2054 /* We include the current directory so that if the user changes
2055 directories the file written will be the same as the one
2058 /* No leading dots in file names are allowed on MSDOS. */
2059 const char *fname
= "_gdb_history";
2061 const char *fname
= ".gdb_history";
2064 gdb::unique_xmalloc_ptr
<char> temp (gdb_abspath (fname
));
2065 history_filename
= temp
.release ();
2068 if (!history_filename_empty ())
2069 read_history (history_filename
);
2073 show_prompt (struct ui_file
*file
, int from_tty
,
2074 struct cmd_list_element
*c
, const char *value
)
2076 fprintf_filtered (file
, _("Gdb's prompt is \"%s\".\n"), value
);
2079 /* "set editing" command. */
2082 set_editing (const char *args
, int from_tty
, struct cmd_list_element
*c
)
2084 change_line_handler (set_editing_cmd_var
);
2085 /* Update the control variable so that MI's =cmd-param-changed event
2086 shows the correct value. */
2087 set_editing_cmd_var
= current_ui
->command_editing
;
2091 show_editing (struct ui_file
*file
, int from_tty
,
2092 struct cmd_list_element
*c
, const char *value
)
2094 fprintf_filtered (file
, _("Editing of command lines as "
2095 "they are typed is %s.\n"),
2096 current_ui
->command_editing
? _("on") : _("off"));
2100 show_annotation_level (struct ui_file
*file
, int from_tty
,
2101 struct cmd_list_element
*c
, const char *value
)
2103 fprintf_filtered (file
, _("Annotation_level is %s.\n"), value
);
2107 show_exec_done_display_p (struct ui_file
*file
, int from_tty
,
2108 struct cmd_list_element
*c
, const char *value
)
2110 fprintf_filtered (file
, _("Notification of completion for "
2111 "asynchronous execution commands is %s.\n"),
2115 /* New values of the "data-directory" parameter are staged here. */
2116 static char *staged_gdb_datadir
;
2118 /* "set" command for the gdb_datadir configuration variable. */
2121 set_gdb_datadir (const char *args
, int from_tty
, struct cmd_list_element
*c
)
2123 set_gdb_data_directory (staged_gdb_datadir
);
2124 gdb::observers::gdb_datadir_changed
.notify ();
2127 /* "show" command for the gdb_datadir configuration variable. */
2130 show_gdb_datadir (struct ui_file
*file
, int from_tty
,
2131 struct cmd_list_element
*c
, const char *value
)
2133 fprintf_filtered (file
, _("GDB's data directory is \"%ps\".\n"),
2134 styled_string (file_name_style
.style (),
2135 gdb_datadir
.c_str ()));
2138 /* Implement 'set history filename'. */
2141 set_history_filename (const char *args
,
2142 int from_tty
, struct cmd_list_element
*c
)
2144 /* We include the current directory so that if the user changes
2145 directories the file written will be the same as the one
2147 if (!history_filename_empty () && !IS_ABSOLUTE_PATH (history_filename
))
2149 gdb::unique_xmalloc_ptr
<char> temp (gdb_abspath (history_filename
));
2151 xfree (history_filename
);
2152 history_filename
= temp
.release ();
2157 init_gdb_version_vars (void)
2159 struct internalvar
*major_version_var
= create_internalvar ("_gdb_major");
2160 struct internalvar
*minor_version_var
= create_internalvar ("_gdb_minor");
2161 int vmajor
= 0, vminor
= 0, vrevision
= 0;
2162 sscanf (version
, "%d.%d.%d", &vmajor
, &vminor
, &vrevision
);
2163 set_internalvar_integer (major_version_var
, vmajor
);
2164 set_internalvar_integer (minor_version_var
, vminor
+ (vrevision
> 0));
2170 struct cmd_list_element
*c
;
2172 /* Initialize the prompt to a simple "(gdb) " prompt or to whatever
2173 the DEFAULT_PROMPT is. */
2174 set_prompt (DEFAULT_PROMPT
);
2176 /* Set the important stuff up for command editing. */
2177 command_editing_p
= 1;
2178 history_expansion_p
= 0;
2179 write_history_p
= 0;
2181 /* Setup important stuff for command line editing. */
2182 rl_completion_word_break_hook
= gdb_completion_word_break_characters
;
2183 rl_attempted_completion_function
= gdb_rl_attempted_completion_function
;
2184 set_rl_completer_word_break_characters (default_word_break_characters ());
2185 rl_completer_quote_characters
= get_gdb_completer_quote_characters ();
2186 rl_completion_display_matches_hook
= cli_display_match_list
;
2187 rl_readline_name
= "gdb";
2188 rl_terminal_name
= getenv ("TERM");
2190 /* The name for this defun comes from Bash, where it originated.
2191 15 is Control-o, the same binding this function has in Bash. */
2192 rl_add_defun ("operate-and-get-next", gdb_rl_operate_and_get_next
, 15);
2194 add_setshow_string_cmd ("prompt", class_support
,
2196 _("Set gdb's prompt."),
2197 _("Show gdb's prompt."),
2200 &setlist
, &showlist
);
2202 add_com ("dont-repeat", class_support
, dont_repeat_command
, _("\
2203 Don't repeat this command.\nPrimarily \
2204 used inside of user-defined commands that should not be repeated when\n\
2207 add_setshow_boolean_cmd ("editing", class_support
,
2208 &set_editing_cmd_var
, _("\
2209 Set editing of command lines as they are typed."), _("\
2210 Show editing of command lines as they are typed."), _("\
2211 Use \"on\" to enable the editing, and \"off\" to disable it.\n\
2212 Without an argument, command line editing is enabled. To edit, use\n\
2213 EMACS-like or VI-like commands like control-P or ESC."),
2216 &setlist
, &showlist
);
2218 add_setshow_boolean_cmd ("save", no_class
, &write_history_p
, _("\
2219 Set saving of the history record on exit."), _("\
2220 Show saving of the history record on exit."), _("\
2221 Use \"on\" to enable the saving, and \"off\" to disable it.\n\
2222 Without an argument, saving is enabled."),
2224 show_write_history_p
,
2225 &sethistlist
, &showhistlist
);
2227 add_setshow_zuinteger_unlimited_cmd ("size", no_class
,
2228 &history_size_setshow_var
, _("\
2229 Set the size of the command history."), _("\
2230 Show the size of the command history."), _("\
2231 This is the number of previous commands to keep a record of.\n\
2232 If set to \"unlimited\", the number of commands kept in the history\n\
2233 list is unlimited. This defaults to the value of the environment\n\
2234 variable \"GDBHISTSIZE\", or to 256 if this variable is not set."),
2235 set_history_size_command
,
2237 &sethistlist
, &showhistlist
);
2239 add_setshow_zuinteger_unlimited_cmd ("remove-duplicates", no_class
,
2240 &history_remove_duplicates
, _("\
2241 Set how far back in history to look for and remove duplicate entries."), _("\
2242 Show how far back in history to look for and remove duplicate entries."), _("\
2243 If set to a nonzero value N, GDB will look back at the last N history entries\n\
2244 and remove the first history entry that is a duplicate of the most recent\n\
2245 entry, each time a new history entry is added.\n\
2246 If set to \"unlimited\", this lookbehind is unbounded.\n\
2247 Only history entries added during this session are considered for removal.\n\
2248 If set to 0, removal of duplicate history entries is disabled.\n\
2249 By default this option is set to 0."),
2251 show_history_remove_duplicates
,
2252 &sethistlist
, &showhistlist
);
2254 add_setshow_optional_filename_cmd ("filename", no_class
, &history_filename
, _("\
2255 Set the filename in which to record the command history."), _("\
2256 Show the filename in which to record the command history."), _("\
2257 (the list of previous commands of which a record is kept)."),
2258 set_history_filename
,
2259 show_history_filename
,
2260 &sethistlist
, &showhistlist
);
2262 add_setshow_boolean_cmd ("confirm", class_support
, &confirm
, _("\
2263 Set whether to confirm potentially dangerous operations."), _("\
2264 Show whether to confirm potentially dangerous operations."), NULL
,
2267 &setlist
, &showlist
);
2269 add_setshow_zinteger_cmd ("annotate", class_obscure
, &annotation_level
, _("\
2270 Set annotation_level."), _("\
2271 Show annotation_level."), _("\
2272 0 == normal; 1 == fullname (for use when running under emacs)\n\
2273 2 == output annotated suitably for use by programs that control GDB."),
2275 show_annotation_level
,
2276 &setlist
, &showlist
);
2278 add_setshow_boolean_cmd ("exec-done-display", class_support
,
2279 &exec_done_display_p
, _("\
2280 Set notification of completion for asynchronous execution commands."), _("\
2281 Show notification of completion for asynchronous execution commands."), _("\
2282 Use \"on\" to enable the notification, and \"off\" to disable it."),
2284 show_exec_done_display_p
,
2285 &setlist
, &showlist
);
2287 add_setshow_filename_cmd ("data-directory", class_maintenance
,
2288 &staged_gdb_datadir
, _("Set GDB's data directory."),
2289 _("Show GDB's data directory."),
2291 When set, GDB uses the specified path to search for data files."),
2292 set_gdb_datadir
, show_gdb_datadir
,
2296 add_setshow_auto_boolean_cmd ("interactive-mode", class_support
,
2297 &interactive_mode
, _("\
2298 Set whether GDB's standard input is a terminal."), _("\
2299 Show whether GDB's standard input is a terminal."), _("\
2300 If on, GDB assumes that standard input is a terminal. In practice, it\n\
2301 means that GDB should wait for the user to answer queries associated to\n\
2302 commands entered at the command prompt. If off, GDB assumes that standard\n\
2303 input is not a terminal, and uses the default answer to all queries.\n\
2304 If auto (the default), determine which mode to use based on the standard\n\
2307 show_interactive_mode
,
2308 &setlist
, &showlist
);
2310 c
= add_cmd ("new-ui", class_support
, new_ui_command
, _("\
2312 Usage: new-ui INTERPRETER TTY\n\
2313 The first argument is the name of the interpreter to run.\n\
2314 The second argument is the terminal the UI runs on."), &cmdlist
);
2315 set_cmd_completer (c
, interpreter_completer
);
2319 gdb_init (char *argv0
)
2321 saved_command_line
= xstrdup ("");
2322 previous_saved_command_line
= xstrdup ("");
2324 if (pre_init_ui_hook
)
2325 pre_init_ui_hook ();
2327 /* Run the init function of each source file. */
2330 /* Make sure we return to the original directory upon exit, come
2331 what may, since the OS doesn't do that for us. */
2332 make_final_cleanup (do_chdir_cleanup
, xstrdup (current_directory
));
2335 init_cmd_lists (); /* This needs to be done first. */
2339 /* Here is where we call all the _initialize_foo routines. */
2340 initialize_all_files ();
2342 /* This creates the current_program_space. Do this after all the
2343 _initialize_foo routines have had a chance to install their
2344 per-sspace data keys. Also do this before
2345 initialize_current_architecture is called, because it accesses
2346 exec_bfd of the current program space. */
2347 initialize_progspace ();
2348 initialize_inferiors ();
2349 initialize_current_architecture ();
2350 init_main (); /* But that omits this file! Do it now. */
2352 initialize_stdin_serial ();
2354 /* Take a snapshot of our tty state before readline/ncurses have had a chance
2356 set_initial_gdb_ttystate ();
2358 async_init_signals ();
2360 /* We need a default language for parsing expressions, so simple
2361 things like "set width 0" won't fail if no language is explicitly
2362 set in a config file or implicitly set by reading an executable
2364 set_language (language_c
);
2365 expected_language
= current_language
; /* Don't warn about the change. */
2367 /* Python initialization, for example, can require various commands to be
2368 installed. For example "info pretty-printer" needs the "info"
2369 prefix to be installed. Keep things simple and just do final
2370 script initialization here. */
2371 finish_ext_lang_initialization ();
2373 /* Create $_gdb_major and $_gdb_minor convenience variables. */
2374 init_gdb_version_vars ();