GDB (xrefs)
Loading...
Searching...
No Matches
top.c
Go to the documentation of this file.
1/* Top level stuff for GDB, the GNU debugger.
2
3 Copyright (C) 1986-2023 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20#include "defs.h"
21#include "gdbcmd.h"
22#include "cli/cli-cmds.h"
23#include "cli/cli-script.h"
24#include "cli/cli-setshow.h"
25#include "cli/cli-decode.h"
26#include "symtab.h"
27#include "inferior.h"
28#include "infrun.h"
29#include <signal.h>
30#include "target.h"
31#include "target-dcache.h"
32#include "breakpoint.h"
33#include "gdbtypes.h"
34#include "expression.h"
35#include "value.h"
36#include "language.h"
37#include "terminal.h"
38#include "gdbsupport/job-control.h"
39#include "annotate.h"
40#include "completer.h"
41#include "top.h"
42#include "ui.h"
43#include "gdbsupport/version.h"
44#include "serial.h"
45#include "main.h"
46#include "gdbsupport/event-loop.h"
47#include "gdbthread.h"
48#include "extension.h"
49#include "interps.h"
50#include "observable.h"
51#include "maint.h"
52#include "filenames.h"
53#include "frame.h"
54#include "gdbsupport/gdb_select.h"
55#include "gdbsupport/scope-exit.h"
56#include "gdbarch.h"
57#include "gdbsupport/pathstuff.h"
58#include "cli/cli-style.h"
59#include "pager.h"
60
61/* readline include files. */
62#include "readline/readline.h"
63#include "readline/history.h"
64
65/* readline defines this. */
66#undef savestring
67
68#include <sys/types.h>
69
70#include "event-top.h"
71#include <sys/stat.h>
72#include <ctype.h>
73#include "ui-out.h"
74#include "cli-out.h"
75#include "tracepoint.h"
76#include "inf-loop.h"
77
78#if defined(TUI)
79# include "tui/tui.h"
80# include "tui/tui-io.h"
81#endif
82
83#ifndef O_NOCTTY
84# define O_NOCTTY 0
85#endif
86
87extern void initialize_all_files (void);
88
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
92
93/* Default command line prompt. This is overridden in some configs. */
94
95#ifndef DEFAULT_PROMPT
96#define DEFAULT_PROMPT "(gdb) "
97#endif
98
99struct ui_file **
104
105struct ui_file **
110
111struct ui_file **
116
117struct ui_file **
122
123struct ui_out **
128
130
131/* Flag for whether we want to confirm potentially dangerous
132 operations. Default is yes. */
133
134bool confirm = true;
135
136static void
137show_confirm (struct ui_file *file, int from_tty,
138 struct cmd_list_element *c, const char *value)
139{
140 gdb_printf (file, _("Whether to confirm potentially "
141 "dangerous operations is %s.\n"),
142 value);
143}
144
145/* The last command line executed on the console. Used for command
146 repetitions when the user enters an empty line. */
147
149
150/* If not NULL, the arguments that should be passed if
151 saved_command_line is repeated. */
152
153static const char *repeat_arguments;
154
155/* The previous last command line executed on the console. Used for command
156 repetitions when a command wants to relaunch the previously launched
157 command. We need this as when a command is running, saved_command_line
158 already contains the line of the currently executing command. */
159
161
162/* If not NULL, the arguments that should be passed if the
163 previous_saved_command_line is repeated. */
164
165static const char *previous_repeat_arguments;
166
167/* Nonzero if the current command is modified by "server ". This
168 affects things like recording into the command history, commands
169 repeating on RETURN, etc. This is so a user interface (emacs, GUI,
170 whatever) can issue its own commands and also send along commands
171 from the user, and have the user not notice that the user interface
172 is issuing commands too. */
174
175/* Timeout limit for response from target. */
176
177/* The default value has been changed many times over the years. It
178 was originally 5 seconds. But that was thought to be a long time
179 to sit and wait, so it was changed to 2 seconds. That was thought
180 to be plenty unless the connection was going through some terminal
181 server or multiplexer or other form of hairy serial connection.
182
183 In mid-1996, remote_timeout was moved from remote.c to top.c and
184 it began being used in other remote-* targets. It appears that the
185 default was changed to 20 seconds at that time, perhaps because the
186 Renesas E7000 ICE didn't always respond in a timely manner.
187
188 But if 5 seconds is a long time to sit and wait for retransmissions,
189 20 seconds is far worse. This demonstrates the difficulty of using
190 a single variable for all protocol timeouts.
191
192 As remote.c is used much more than remote-e7000.c, it was changed
193 back to 2 seconds in 1999. */
194
196
197/* Sbrk location on entry to main. Used for statistics only. */
198#ifdef HAVE_USEFUL_SBRK
199char *lim_at_start;
200#endif
201
202/* Hooks for alternate command interfaces. */
203
204/* This hook is called from within gdb's many mini-event loops which
205 could steal control from a real user interface's event loop. It
206 returns non-zero if the user is requesting a detach, zero
207 otherwise. */
208
210
211
212/* Called from print_frame_info to list the line we stopped in. */
213
215 int line,
216 int stopline,
217 int noerror);
218/* Replaces most of query. */
219
220int (*deprecated_query_hook) (const char *, va_list);
221
222/* Replaces most of warning. */
223
224void (*deprecated_warning_hook) (const char *, va_list);
225
226/* These three functions support getting lines of text from the user.
227 They are used in sequence. First deprecated_readline_begin_hook is
228 called with a text string that might be (for example) a message for
229 the user to type in a sequence of commands to be executed at a
230 breakpoint. If this function calls back to a GUI, it might take
231 this opportunity to pop up a text interaction window with this
232 message. Next, deprecated_readline_hook is called with a prompt
233 that is emitted prior to collecting the user input. It can be
234 called multiple times. Finally, deprecated_readline_end_hook is
235 called to notify the GUI that we are done with the interaction
236 window and it can close it. */
237
238void (*deprecated_readline_begin_hook) (const char *, ...);
239char *(*deprecated_readline_hook) (const char *);
241
242/* Called as appropriate to notify the interface that we have attached
243 to or detached from an already running process. */
244
247
248/* Used by UI as a wrapper around command execution. May do various
249 things like enabling/disabling buttons, etc... */
250
252 const char *cmd, int from_tty);
253
254/* Called when the current thread changes. Argument is thread id. */
255
256void (*deprecated_context_hook) (int id);
257
258/* See top.h. */
259
260void
261unbuffer_stream (FILE *stream)
262{
263 /* Unbuffer the input stream so that in gdb_readline_no_editing_callback,
264 the calls to fgetc fetch only one char at the time from STREAM.
265
266 This is important because gdb_readline_no_editing_callback will read
267 from STREAM up to the first '\n' character, after this GDB returns to
268 the event loop and relies on a select on STREAM indicating that more
269 input is pending.
270
271 If STREAM is buffered then the fgetc calls may have moved all the
272 pending input from the kernel into a local buffer, after which the
273 select will not indicate that more input is pending, and input after
274 the first '\n' will not be processed immediately.
275
276 Please ensure that any changes in this area run the MI tests with the
277 FORCE_SEPARATE_MI_TTY=1 flag being passed. */
278
279#ifdef __MINGW32__
280 /* With MS-Windows runtime, making stdin unbuffered when it's
281 connected to the terminal causes it to misbehave. */
282 if (!ISATTY (stream))
283 setbuf (stream, nullptr);
284#else
285 /* On GNU/Linux the issues described above can impact GDB even when
286 dealing with input from a terminal. For now we unbuffer the input
287 stream for everyone except MS-Windows. */
288 setbuf (stream, nullptr);
289#endif
290}
291
292/* Handler for SIGHUP. */
293
294#ifdef SIGHUP
295/* NOTE 1999-04-29: This function will be static again, once we modify
296 gdb to use the event loop as the default command loop and we merge
297 event-top.c into this file, top.c. */
298/* static */ void
299quit_cover (void)
300{
301 /* Stop asking user for confirmation --- we're exiting. This
302 prevents asking the user dumb questions. */
303 confirm = 0;
304 quit_command ((char *) 0, 0);
305}
306#endif /* defined SIGHUP */
307
308/* Line number we are currently in, in a file which is being sourced. */
309/* NOTE 1999-04-29: This variable will be static again, once we modify
310 gdb to use the event loop as the default command loop and we merge
311 event-top.c into this file, top.c. */
312/* static */ int source_line_number;
313
314/* Name of the file we are sourcing. */
315/* NOTE 1999-04-29: This variable will be static again, once we modify
316 gdb to use the event loop as the default command loop and we merge
317 event-top.c into this file, top.c. */
318/* static */ std::string source_file_name;
319
320/* Read commands from STREAM. */
321void
322read_command_file (FILE *stream)
323{
324 struct ui *ui = current_ui;
325
326 unbuffer_stream (stream);
327
328 scoped_restore save_instream
329 = make_scoped_restore (&ui->instream, stream);
330
331 /* Read commands from `instream' and execute them until end of file
332 or error reading instream. */
333
334 while (ui->instream != NULL && !feof (ui->instream))
335 {
336 /* Get a command-line. This calls the readline package. */
337 std::string command_buffer;
338 const char *command
339 = command_line_input (command_buffer, nullptr, nullptr);
340 if (command == nullptr)
341 break;
342 command_handler (command);
343 }
344}
345
346#ifdef __MSDOS__
347static void
348do_chdir_cleanup (void *old_dir)
349{
350 chdir ((const char *) old_dir);
351 xfree (old_dir);
352}
353#endif
354
357{
358 /* With multiple threads running while the one we're examining is
359 stopped, the dcache can get stale without us being able to detect
360 it. For the duration of the command, though, use the dcache to
361 help things like backtrace. */
362 if (non_stop)
364
365 return scoped_value_mark ();
366}
367
368/* Tell the user if the language has changed (except first time) after
369 executing a command. */
370
371void
373{
374 static int warned = 0;
375 frame_info_ptr frame;
376
377 /* First make sure that a new frame has been selected, in case the
378 command or the hooks changed the program state. */
381 {
383 {
384 /* Print what changed. */
385 language_info ();
386 }
387 warned = 0;
388 }
389
390 /* Warn the user if the working language does not match the language
391 of the current frame. Only warn the user if we are actually
392 running the program, i.e. there is a stack. */
393 /* FIXME: This should be cacheing the frame and only running when
394 the frame changes. */
395
396 if (has_stack_frames ())
397 {
398 enum language flang;
399
400 flang = get_frame_language (frame);
401 if (!warned
402 && flang != language_unknown
403 && flang != current_language->la_language)
404 {
406 warned = 1;
407 }
408 }
409}
410
411/* See top.h. */
412
413void
415{
416 /* Processing events may change the current UI. */
417 scoped_restore save_ui = make_scoped_restore (&current_ui);
418 struct ui *ui = current_ui;
419
420 /* We're about to wait until the target stops after having resumed
421 it so must force-commit resumptions, in case we're being called
422 in some context where a scoped_disable_commit_resumed object is
423 active. I.e., this function is a commit-resumed sync/flush
424 point. */
426
427 while (gdb_do_one_event () >= 0)
429 break;
430}
431
432/* See top.h. */
433
434void
436{
437 /* If the interpreter is in sync mode (we're running a user
438 command's list, running command hooks or similars), and we
439 just ran a synchronous command that started the target, wait
440 for that command to end. */
441 if (!current_ui->async
442 && !was_sync
445}
446
447/* See command.h. */
448
449void
450set_repeat_arguments (const char *args)
451{
452 repeat_arguments = args;
453}
454
455/* Execute the line P as a command, in the current user context.
456 Pass FROM_TTY as second argument to the defining function. */
457
458void
459execute_command (const char *p, int from_tty)
460{
461 struct cmd_list_element *c;
462 const char *line;
463 const char *cmd_start = p;
464
465 auto cleanup_if_error = make_scope_exit (bpstat_clear_actions);
467
468 /* This can happen when command_line_input hits end of file. */
469 if (p == NULL)
470 {
471 cleanup_if_error.release ();
472 return;
473 }
474
475 std::string cmd_copy = p;
476
478
479 while (*p == ' ' || *p == '\t')
480 p++;
481 if (*p)
482 {
483 const char *cmd = p;
484 const char *arg;
485 std::string default_args;
486 std::string default_args_and_arg;
487 int was_sync = current_ui->prompt_state == PROMPT_BLOCKED;
488
489 line = p;
490
491 /* If trace-commands is set then this will print this command. */
492 print_command_trace ("%s", p);
493
494 c = lookup_cmd (&cmd, cmdlist, "", &default_args, 0, 1);
495 p = cmd;
496
497 scoped_restore save_repeat_args
498 = make_scoped_restore (&repeat_arguments, nullptr);
499 const char *args_pointer = p;
500
501 if (!default_args.empty ())
502 {
503 if (*p != '\0')
504 default_args_and_arg = default_args + ' ' + p;
505 else
506 default_args_and_arg = default_args;
507 arg = default_args_and_arg.c_str ();
508 }
509 else
510 {
511 /* Pass null arg rather than an empty one. */
512 arg = *p == '\0' ? nullptr : p;
513 }
514
515 /* FIXME: cagney/2002-02-02: The c->type test is pretty dodgy
516 while the is_complete_command(cfunc) test is just plain
517 bogus. They should both be replaced by a test of the form
518 c->strip_trailing_white_space_p. */
519 /* NOTE: cagney/2002-02-02: The function.cfunc in the below
520 can't be replaced with func. This is because it is the
521 cfunc, and not the func, that has the value that the
522 is_complete_command hack is testing for. */
523 /* Clear off trailing whitespace, except for set and complete
524 command. */
525 std::string without_whitespace;
526 if (arg
527 && c->type != set_cmd
528 && !is_complete_command (c))
529 {
530 const char *old_end = arg + strlen (arg) - 1;
531 p = old_end;
532 while (p >= arg && (*p == ' ' || *p == '\t'))
533 p--;
534 if (p != old_end)
535 {
536 without_whitespace = std::string (arg, p + 1);
537 arg = without_whitespace.c_str ();
538 }
539 }
540
541 /* If this command has been pre-hooked, run the hook first. */
543
546
547 /* c->user_commands would be NULL in the case of a python command. */
548 if (c->theclass == class_user && c->user_commands)
549 execute_user_command (c, arg);
550 else if (c->theclass == class_user
551 && c->is_prefix () && !c->allow_unknown)
552 /* If this is a user defined prefix that does not allow unknown
553 (in other words, C is a prefix command and not a command
554 that can be followed by its args), report the list of
555 subcommands. */
556 {
557 std::string prefixname = c->prefixname ();
558 std::string prefixname_no_space
559 = prefixname.substr (0, prefixname.length () - 1);
561 ("\"%s\" must be followed by the name of a subcommand.\n",
562 prefixname_no_space.c_str ());
564 gdb_stdout);
565 }
566 else if (c->type == set_cmd)
567 do_set_command (arg, from_tty, c);
568 else if (c->type == show_cmd)
569 do_show_command (arg, from_tty, c);
570 else if (c->is_command_class_help ())
571 error (_("That is not a command, just a help topic."));
573 deprecated_call_command_hook (c, arg, from_tty);
574 else
575 cmd_func (c, arg, from_tty);
576
578
579 /* If this command has been post-hooked, run the hook last.
580 We need to lookup the command again since during its execution,
581 a command may redefine itself. In this case, C pointer
582 becomes invalid so we need to look it up again. */
583 const char *cmd2 = cmd_copy.c_str ();
584 c = lookup_cmd (&cmd2, cmdlist, "", nullptr, 1, 1);
585 if (c != nullptr)
587
588 if (repeat_arguments != NULL && cmd_start == saved_command_line)
589 {
590 gdb_assert (strlen (args_pointer) >= strlen (repeat_arguments));
591 strcpy (saved_command_line + (args_pointer - cmd_start),
593 }
594 }
595
596 /* Only perform the frame-language-change check if the command
597 we just finished executing did not resume the inferior's execution.
598 If it did resume the inferior, we will do that check after
599 the inferior stopped. */
600 if (has_stack_frames () && inferior_thread ()->state != THREAD_RUNNING)
602
603 cleanup_if_error.release ();
604}
605
606/* See gdbcmd.h. */
607
608void
609execute_fn_to_ui_file (struct ui_file *file, std::function<void(void)> fn)
610{
611 /* GDB_STDOUT should be better already restored during these
612 restoration callbacks. */
614
615 scoped_restore save_async = make_scoped_restore (&current_ui->async, 0);
616
617 {
618 ui_out_redirect_pop redirect_popper (current_uiout, file);
619
620 scoped_restore save_stdout
621 = make_scoped_restore (&gdb_stdout, file);
622 scoped_restore save_stderr
623 = make_scoped_restore (&gdb_stderr, file);
624 scoped_restore save_stdlog
625 = make_scoped_restore (&gdb_stdlog, file);
626 scoped_restore save_stdtarg
627 = make_scoped_restore (&gdb_stdtarg, file);
628 scoped_restore save_stdtargerr
629 = make_scoped_restore (&gdb_stdtargerr, file);
630
631 fn ();
632 }
633}
634
635/* See gdbcmd.h. */
636
637void
638execute_fn_to_string (std::string &res, std::function<void(void)> fn,
639 bool term_out)
640{
641 string_file str_file (term_out);
642
643 try
644 {
645 execute_fn_to_ui_file (&str_file, fn);
646 }
647 catch (...)
648 {
649 /* Finally. */
650 res = str_file.release ();
651 throw;
652 }
653
654 /* And finally. */
655 res = str_file.release ();
656}
657
658/* See gdbcmd.h. */
659
660void
662 const char *p, int from_tty)
663{
664 execute_fn_to_ui_file (file, [=]() { execute_command (p, from_tty); });
665}
666
667/* See gdbcmd.h. */
668
669void
670execute_command_to_string (std::string &res, const char *p, int from_tty,
671 bool term_out)
672{
673 execute_fn_to_string (res, [=]() { execute_command (p, from_tty); },
674 term_out);
675}
676
677/* See gdbcmd.h. */
678
679void
680execute_command_to_string (const char *p, int from_tty,
681 bool term_out)
682{
683 std::string dummy;
684 execute_fn_to_string (dummy, [=]() { execute_command (p, from_tty); },
685 term_out);
686}
687
688/* When nonzero, cause dont_repeat to do nothing. This should only be
689 set via prevent_dont_repeat. */
690
691static int suppress_dont_repeat = 0;
692
693/* See command.h */
694
695void
697{
698 struct ui *ui = current_ui;
699
701 return;
702
703 /* If we aren't reading from standard input, we are saving the last
704 thing read from stdin in line and don't want to delete it. Null
705 lines won't repeat here in any case. */
706 if (ui->instream == ui->stdin_stream)
707 {
709 repeat_arguments = NULL;
710 }
711}
712
713/* See command.h */
714
715const char *
717{
718 /* Do not repeat this command, as this command is a repeating command. */
719 dont_repeat ();
720
721 /* We cannot free saved_command_line, as this line is being executed,
722 so swap it with previous_saved_command_line. */
725
726 const char *prev = skip_spaces (get_saved_command_line ());
727 if (*prev == '\0')
728 error (_("No previous command to relaunch"));
729 return prev;
730}
731
732/* See command.h. */
733
734scoped_restore_tmpl<int>
736{
737 return make_scoped_restore (&suppress_dont_repeat, 1);
738}
739
740/* See command.h. */
741
742char *
747
748/* See command.h. */
749
750void
759
760
761/* Read a line from the stream "instream" without command line editing.
762
763 It prints PROMPT once at the start.
764 Action is compatible with "readline", e.g. space for the result is
765 malloc'd and should be freed by the caller.
766
767 A NULL return means end of file. */
768
769static gdb::unique_xmalloc_ptr<char>
770gdb_readline_no_editing (const char *prompt)
771{
772 std::string line_buffer;
773 struct ui *ui = current_ui;
774 /* Read from stdin if we are executing a user defined command. This
775 is the right thing for prompt_for_continue, at least. */
776 FILE *stream = ui->instream != NULL ? ui->instream : stdin;
777 int fd = fileno (stream);
778
779 if (prompt != NULL)
780 {
781 /* Don't use a _filtered function here. It causes the assumed
782 character position to be off, since the newline we read from
783 the user is not accounted for. */
784 printf_unfiltered ("%s", prompt);
786 }
787
788 while (1)
789 {
790 int c;
791 fd_set readfds;
792
793 QUIT;
794
795 /* Wait until at least one byte of data is available. Control-C
796 can interrupt interruptible_select, but not fgetc. */
797 FD_ZERO (&readfds);
798 FD_SET (fd, &readfds);
799 if (interruptible_select (fd + 1, &readfds, NULL, NULL, NULL) == -1)
800 {
801 if (errno == EINTR)
802 {
803 /* If this was ctrl-c, the QUIT above handles it. */
804 continue;
805 }
806 perror_with_name (("select"));
807 }
808
809 c = fgetc (stream);
810
811 if (c == EOF)
812 {
813 if (!line_buffer.empty ())
814 /* The last line does not end with a newline. Return it, and
815 if we are called again fgetc will still return EOF and
816 we'll return NULL then. */
817 break;
818 return NULL;
819 }
820
821 if (c == '\n')
822 {
823 if (!line_buffer.empty () && line_buffer.back () == '\r')
824 line_buffer.pop_back ();
825 break;
826 }
827
828 line_buffer += c;
829 }
830
831 return make_unique_xstrdup (line_buffer.c_str ());
832}
833
834/* Variables which control command line editing and history
835 substitution. These variables are given default values at the end
836 of this file. */
838
839/* NOTE 1999-04-29: This variable will be static again, once we modify
840 gdb to use the event loop as the default command loop and we merge
841 event-top.c into this file, top.c. */
842
843/* static */ bool history_expansion_p;
844
845/* Should we write out the command history on exit? In order to write out
846 the history both this flag must be true, and the history_filename
847 variable must be set to something sensible. */
848static bool write_history_p;
849
850/* The name of the file in which GDB history will be written. If this is
851 set to NULL, of the empty string then history will not be written. */
852static std::string history_filename;
853
854/* Implement 'show history save'. */
855static void
856show_write_history_p (struct ui_file *file, int from_tty,
857 struct cmd_list_element *c, const char *value)
858{
859 if (!write_history_p || !history_filename.empty ())
860 gdb_printf (file, _("Saving of the history record on exit is %s.\n"),
861 value);
862 else
863 gdb_printf (file, _("Saving of the history is disabled due to "
864 "the value of 'history filename'.\n"));
865}
866
867/* The variable associated with the "set/show history size"
868 command. The value -1 means unlimited, and -2 means undefined. */
870
871static void
872show_history_size (struct ui_file *file, int from_tty,
873 struct cmd_list_element *c, const char *value)
874{
875 gdb_printf (file, _("The size of the command history is %s.\n"),
876 value);
877}
878
879/* Variable associated with the "history remove-duplicates" option.
880 The value -1 means unlimited. */
882
883static void
884show_history_remove_duplicates (struct ui_file *file, int from_tty,
885 struct cmd_list_element *c, const char *value)
886{
887 gdb_printf (file,
888 _("The number of history entries to look back at for "
889 "duplicates is %s.\n"),
890 value);
891}
892
893/* Implement 'show history filename'. */
894static void
895show_history_filename (struct ui_file *file, int from_tty,
896 struct cmd_list_element *c, const char *value)
897{
898 if (!history_filename.empty ())
899 gdb_printf (file, _("The filename in which to record "
900 "the command history is \"%ps\".\n"),
902 else
903 gdb_printf (file, _("There is no filename currently set for "
904 "recording the command history in.\n"));
905}
906
907/* This is like readline(), but it has some gdb-specific behavior.
908 gdb may want readline in both the synchronous and async modes during
909 a single gdb invocation. At the ordinary top-level prompt we might
910 be using the async readline. That means we can't use
911 rl_pre_input_hook, since it doesn't work properly in async mode.
912 However, for a secondary prompt (" >", such as occurs during a
913 `define'), gdb wants a synchronous response.
914
915 We used to call readline() directly, running it in synchronous
916 mode. But mixing modes this way is not supported, and as of
917 readline 5.x it no longer works; the arrow keys come unbound during
918 the synchronous call. So we make a nested call into the event
919 loop. That's what gdb_readline_wrapper is for. */
920
921/* A flag set as soon as gdb_readline_wrapper_line is called; we can't
922 rely on gdb_readline_wrapper_result, which might still be NULL if
923 the user types Control-D for EOF. */
925
926/* The result of the current call to gdb_readline_wrapper, once a newline
927 is seen. */
929
930/* Any intercepted hook. Operate-and-get-next sets this, expecting it
931 to be called after the newline is processed (which will redisplay
932 the prompt). But in gdb_readline_wrapper we will not get a new
933 prompt until the next call, or until we return to the event loop.
934 So we disable this hook around the newline and restore it before we
935 return. */
937
938
939/* See top.h. */
940
941int
943{
944 return ui->secondary_prompt_depth > 0;
945}
946
947
948/* This function is called when readline has seen a complete line of
949 text. */
950
951static void
952gdb_readline_wrapper_line (gdb::unique_xmalloc_ptr<char> &&line)
953{
954 gdb_assert (!gdb_readline_wrapper_done);
955 gdb_readline_wrapper_result = line.release ();
957
958 /* Prevent operate-and-get-next from acting too early. */
961
962#if defined(TUI)
963 if (tui_active)
965#endif
966
967 /* Prevent parts of the prompt from being redisplayed if annotations
968 are enabled, and readline's state getting out of sync. We'll
969 reinstall the callback handler, which puts the terminal in raw
970 mode (or in readline lingo, in prepped state), when we're next
971 ready to process user input, either in display_gdb_prompt, or if
972 we're handling an asynchronous target event and running in the
973 background, just before returning to the event loop to process
974 further input (or more target events). */
977}
978
980{
981public:
995
997 {
998 struct ui *ui = current_ui;
999
1000 if (ui->command_editing)
1001 rl_already_prompted = m_already_prompted_orig;
1002
1005
1006 /* Don't restore our input handler in readline yet. That would make
1007 readline prep the terminal (putting it in raw mode), while the
1008 line we just read may trigger execution of a command that expects
1009 the terminal in the default cooked/canonical mode, such as e.g.,
1010 running Python's interactive online help utility. See
1011 gdb_readline_wrapper_line for when we'll reinstall it. */
1012
1016 gdb_assert (ui->secondary_prompt_depth >= 0);
1017
1020
1022 target_async (true);
1023 }
1024
1026
1027private:
1028
1029 void (*m_handler_orig) (gdb::unique_xmalloc_ptr<char> &&);
1031
1032 /* Whether the target was async. */
1034
1035 /* Processing events may change the current UI. */
1036 scoped_restore_tmpl<struct ui *> m_save_ui;
1037};
1038
1039char *
1040gdb_readline_wrapper (const char *prompt)
1041{
1042 struct ui *ui = current_ui;
1043
1045
1046 /* Display our prompt and prevent double prompt display. Don't pass
1047 down a NULL prompt, since that has special meaning for
1048 display_gdb_prompt -- it indicates a request to print the primary
1049 prompt, while we want a secondary prompt here. */
1050 display_gdb_prompt (prompt != NULL ? prompt : "");
1051 if (ui->command_editing)
1052 rl_already_prompted = 1;
1053
1055 (*after_char_processing_hook) ();
1056 gdb_assert (after_char_processing_hook == NULL);
1057
1058 while (gdb_do_one_event () >= 0)
1060 break;
1061
1063}
1064
1065
1066/* The current saved history number from operate-and-get-next.
1067 This is -1 if not valid. */
1069
1070/* This is put on the appropriate hook and helps operate-and-get-next
1071 do its work. */
1072static void
1074{
1075 int delta = where_history () - operate_saved_history;
1076
1077 /* The `key' argument to rl_get_previous_history is ignored. */
1078 rl_get_previous_history (delta, 0);
1080
1081 /* readline doesn't automatically update the display for us. */
1082 rl_redisplay ();
1083
1085 rl_pre_input_hook = NULL;
1086}
1087
1088/* This is a gdb-local readline command handler. It accepts the
1089 current command line (like RET does) and, if this command was taken
1090 from the history, arranges for the next command in the history to
1091 appear on the command line when the prompt returns.
1092 We ignore the arguments. */
1093static int
1095{
1096 int where;
1097
1098 /* Use the async hook. */
1100
1101 /* Find the current line, and find the next line to use. */
1102 where = where_history();
1103
1104 if ((history_is_stifled () && (history_length >= history_max_entries))
1105 || (where >= history_length - 1))
1106 operate_saved_history = where;
1107 else
1108 operate_saved_history = where + 1;
1109
1110 return rl_newline (1, key);
1111}
1112
1113/* Number of user commands executed during this session. */
1114
1115static int command_count = 0;
1116
1117/* Add the user command COMMAND to the input history list. */
1118
1119void
1120gdb_add_history (const char *command)
1121{
1122 command_count++;
1123
1125 {
1126 int lookbehind;
1127 int lookbehind_threshold;
1128
1129 /* The lookbehind threshold for finding a duplicate history entry is
1130 bounded by command_count because we can't meaningfully delete
1131 history entries that are already stored in the history file since
1132 the history file is appended to. */
1135 lookbehind_threshold = command_count;
1136 else
1137 lookbehind_threshold = history_remove_duplicates;
1138
1139 using_history ();
1140 for (lookbehind = 0; lookbehind < lookbehind_threshold; lookbehind++)
1141 {
1142 HIST_ENTRY *temp = previous_history ();
1143
1144 if (temp == NULL)
1145 break;
1146
1147 if (strcmp (temp->line, command) == 0)
1148 {
1149 HIST_ENTRY *prev = remove_history (where_history ());
1150 command_count--;
1151 free_history_entry (prev);
1152 break;
1153 }
1154 }
1155 using_history ();
1156 }
1157
1158 add_history (command);
1159}
1160
1161/* Safely append new history entries to the history file in a corruption-free
1162 way using an intermediate local history file. */
1163
1164static void
1166{
1167 int ret, saved_errno;
1168
1169 std::string local_history_filename
1170 = string_printf ("%s-gdb%ld~", history_filename.c_str (), (long) getpid ());
1171
1172 ret = rename (history_filename.c_str (), local_history_filename.c_str ());
1173 saved_errno = errno;
1174 if (ret < 0 && saved_errno != ENOENT)
1175 {
1176 warning (_("Could not rename %ps to %ps: %s"),
1178 history_filename.c_str ()),
1180 local_history_filename.c_str ()),
1181 safe_strerror (saved_errno));
1182 }
1183 else
1184 {
1185 if (ret < 0)
1186 {
1187 /* If the rename failed with ENOENT then either the global history
1188 file never existed in the first place or another GDB process is
1189 currently appending to it (and has thus temporarily renamed it).
1190 Since we can't distinguish between these two cases, we have to
1191 conservatively assume the first case and therefore must write out
1192 (not append) our known history to our local history file and try
1193 to move it back anyway. Otherwise a global history file would
1194 never get created! */
1195 gdb_assert (saved_errno == ENOENT);
1196 write_history (local_history_filename.c_str ());
1197 }
1198 else
1199 {
1200 append_history (command_count, local_history_filename.c_str ());
1201 if (history_is_stifled ())
1202 history_truncate_file (local_history_filename.c_str (),
1203 history_max_entries);
1204 }
1205
1206 ret = rename (local_history_filename.c_str (), history_filename.c_str ());
1207 saved_errno = errno;
1208 if (ret < 0 && saved_errno != EEXIST)
1209 warning (_("Could not rename %s to %s: %s"),
1210 local_history_filename.c_str (), history_filename.c_str (),
1211 safe_strerror (saved_errno));
1212 }
1213}
1214
1215/* Read one line from the command input stream `instream'.
1216
1217 CMD_LINE_BUFFER is a buffer that the function may use to store the result, if
1218 it needs to be dynamically-allocated. Otherwise, it is unused.string
1219
1220 Return nullptr for end of file.
1221
1222 This routine either uses fancy command line editing or simple input
1223 as the user has requested. */
1224
1225const char *
1226command_line_input (std::string &cmd_line_buffer, const char *prompt_arg,
1227 const char *annotation_suffix)
1228{
1229 struct ui *ui = current_ui;
1230 const char *prompt = prompt_arg;
1231 const char *cmd;
1232 int from_tty = ui->instream == ui->stdin_stream;
1233
1234 /* The annotation suffix must be non-NULL. */
1235 if (annotation_suffix == NULL)
1236 annotation_suffix = "";
1237
1238 if (from_tty && annotation_level > 1)
1239 {
1240 char *local_prompt;
1241
1242 local_prompt
1243 = (char *) alloca ((prompt == NULL ? 0 : strlen (prompt))
1244 + strlen (annotation_suffix) + 40);
1245 if (prompt == NULL)
1246 local_prompt[0] = '\0';
1247 else
1248 strcpy (local_prompt, prompt);
1249 strcat (local_prompt, "\n\032\032");
1250 strcat (local_prompt, annotation_suffix);
1251 strcat (local_prompt, "\n");
1252
1253 prompt = local_prompt;
1254 }
1255
1256#ifdef SIGTSTP
1257 if (job_control)
1258 signal (SIGTSTP, handle_sigtstp);
1259#endif
1260
1261 while (1)
1262 {
1263 gdb::unique_xmalloc_ptr<char> rl;
1264
1265 /* Make sure that all output has been output. Some machines may
1266 let you get away with leaving out some of the gdb_flush, but
1267 not all. */
1270
1271 if (!source_file_name.empty ())
1273
1274 if (from_tty && annotation_level > 1)
1275 printf_unfiltered ("\n\032\032pre-%s\n", annotation_suffix);
1276
1277 /* Don't use fancy stuff if not talking to stdin. */
1279 && from_tty
1281 {
1282 rl.reset ((*deprecated_readline_hook) (prompt));
1283 }
1284 else if (command_editing_p
1285 && from_tty
1287 {
1288 rl.reset (gdb_readline_wrapper (prompt));
1289 }
1290 else
1291 {
1292 rl = gdb_readline_no_editing (prompt);
1293 }
1294
1295 cmd = handle_line_of_input (cmd_line_buffer, rl.get (),
1296 0, annotation_suffix);
1297 if (cmd == (char *) EOF)
1298 {
1299 cmd = NULL;
1300 break;
1301 }
1302 if (cmd != NULL)
1303 break;
1304
1305 /* Got partial input. I.e., got a line that ends with a
1306 continuation character (backslash). Suppress printing the
1307 prompt again. */
1308 prompt = NULL;
1309 }
1310
1311#ifdef SIGTSTP
1312 if (job_control)
1313 signal (SIGTSTP, SIG_DFL);
1314#endif
1315
1316 return cmd;
1317}
1318
1319/* See top.h. */
1320void
1321print_gdb_version (struct ui_file *stream, bool interactive)
1322{
1323 /* From GNU coding standards, first line is meant to be easy for a
1324 program to parse, and is just canonical program name and version
1325 number, which starts after last space. */
1326
1327 std::string v_str = string_printf ("GNU gdb %s%s", PKGVERSION, version);
1328 gdb_printf (stream, "%ps\n",
1329 styled_string (version_style.style (), v_str.c_str ()));
1330
1331 /* Second line is a copyright notice. */
1332
1333 gdb_printf (stream,
1334 "Copyright (C) 2023 Free Software Foundation, Inc.\n");
1335
1336 /* Following the copyright is a brief statement that the program is
1337 free software, that users are free to copy and change it on
1338 certain conditions, that it is covered by the GNU GPL, and that
1339 there is no warranty. */
1340
1341 gdb_printf (stream, "\
1342License GPLv3+: GNU GPL version 3 or later <%ps>\
1343\nThis is free software: you are free to change and redistribute it.\n\
1344There is NO WARRANTY, to the extent permitted by law.",
1346 "http://gnu.org/licenses/gpl.html"));
1347
1348 if (!interactive)
1349 return;
1350
1351 gdb_printf (stream, ("\nType \"show copying\" and "
1352 "\"show warranty\" for details.\n"));
1353
1354 /* After the required info we print the configuration information. */
1355
1356 gdb_printf (stream, "This GDB was configured as \"");
1357 if (strcmp (host_name, target_name) != 0)
1358 {
1359 gdb_printf (stream, "--host=%s --target=%s",
1361 }
1362 else
1363 {
1364 gdb_printf (stream, "%s", host_name);
1365 }
1366 gdb_printf (stream, "\".\n");
1367
1368 gdb_printf (stream, _("Type \"show configuration\" "
1369 "for configuration details.\n"));
1370
1371 if (REPORT_BUGS_TO[0])
1372 {
1373 gdb_printf (stream,
1374 _("For bug reporting instructions, please see:\n"));
1375 gdb_printf (stream, "%ps.\n",
1378 }
1379 gdb_printf (stream,
1380 _("Find the GDB manual and other documentation \
1381resources online at:\n <%ps>."),
1383 "http://www.gnu.org/software/gdb/documentation/"));
1384 gdb_printf (stream, "\n\n");
1385 gdb_printf (stream, _("For help, type \"help\".\n"));
1386 gdb_printf (stream,
1387 _("Type \"apropos word\" to search for commands \
1388related to \"word\"."));
1389}
1390
1391/* Print the details of GDB build-time configuration. */
1392void
1394{
1395 gdb_printf (stream, _("\
1396This GDB was configured as follows:\n\
1397 configure --host=%s --target=%s\n\
1399
1400 gdb_printf (stream, _("\
1401 --with-auto-load-dir=%s\n\
1402 --with-auto-load-safe-path=%s\n\
1404
1405#if HAVE_LIBEXPAT
1406 gdb_printf (stream, _("\
1407 --with-expat\n\
1408"));
1409#else
1410 gdb_printf (stream, _("\
1411 --without-expat\n\
1412"));
1413#endif
1414
1415 if (GDB_DATADIR[0])
1416 gdb_printf (stream, _("\
1417 --with-gdb-datadir=%s%s\n\
1418"), GDB_DATADIR, GDB_DATADIR_RELOCATABLE ? " (relocatable)" : "");
1419
1420#ifdef ICONV_BIN
1421 gdb_printf (stream, _("\
1422 --with-iconv-bin=%s%s\n\
1423"), ICONV_BIN, ICONV_BIN_RELOCATABLE ? " (relocatable)" : "");
1424#endif
1425
1426 if (JIT_READER_DIR[0])
1427 gdb_printf (stream, _("\
1428 --with-jit-reader-dir=%s%s\n\
1429"), JIT_READER_DIR, JIT_READER_DIR_RELOCATABLE ? " (relocatable)" : "");
1430
1431#if HAVE_LIBUNWIND_IA64_H
1432 gdb_printf (stream, _("\
1433 --with-libunwind-ia64\n\
1434"));
1435#else
1436 gdb_printf (stream, _("\
1437 --without-libunwind-ia64\n\
1438"));
1439#endif
1440
1441#if HAVE_LIBLZMA
1442 gdb_printf (stream, _("\
1443 --with-lzma\n\
1444"));
1445#else
1446 gdb_printf (stream, _("\
1447 --without-lzma\n\
1448"));
1449#endif
1450
1451#if HAVE_LIBBABELTRACE
1452 gdb_printf (stream, _("\
1453 --with-babeltrace\n\
1454"));
1455#else
1456 gdb_printf (stream, _("\
1457 --without-babeltrace\n\
1458"));
1459#endif
1460
1461#if HAVE_LIBIPT
1462 gdb_printf (stream, _("\
1463 --with-intel-pt\n\
1464"));
1465#else
1466 gdb_printf (stream, _("\
1467 --without-intel-pt\n\
1468"));
1469#endif
1470
1471#if HAVE_LIBXXHASH
1472 gdb_printf (stream, _("\
1473 --with-xxhash\n\
1474"));
1475#else
1476 gdb_printf (stream, _("\
1477 --without-xxhash\n\
1478"));
1479#endif
1480#ifdef WITH_PYTHON_PATH
1481 gdb_printf (stream, _("\
1482 --with-python=%s%s\n\
1483"), WITH_PYTHON_PATH, PYTHON_PATH_RELOCATABLE ? " (relocatable)" : "");
1484#else
1485 gdb_printf (stream, _("\
1486 --without-python\n\
1487"));
1488#endif
1489#ifdef WITH_PYTHON_LIBDIR
1490 gdb_printf (stream, _("\
1491 --with-python-libdir=%s%s\n\
1492"), WITH_PYTHON_LIBDIR, PYTHON_LIBDIR_RELOCATABLE ? " (relocatable)" : "");
1493#else
1494 gdb_printf (stream, _("\
1495 --without-python-libdir\n\
1496"));
1497#endif
1498
1499#if HAVE_LIBDEBUGINFOD
1500 gdb_printf (stream, _("\
1501 --with-debuginfod\n\
1502"));
1503#else
1504 gdb_printf (stream, _("\
1505 --without-debuginfod\n\
1506"));
1507#endif
1508
1509#if HAVE_LIBCURSES
1510 gdb_printf (stream, _("\
1511 --with-curses\n\
1512"));
1513#else
1514 gdb_printf (stream, _("\
1515 --without-curses\n\
1516"));
1517#endif
1518
1519#if HAVE_GUILE
1520 gdb_printf (stream, _("\
1521 --with-guile\n\
1522"));
1523#else
1524 gdb_printf (stream, _("\
1525 --without-guile\n\
1526"));
1527#endif
1528
1529#if HAVE_AMD_DBGAPI
1530 gdb_printf (stream, _("\
1531 --with-amd-dbgapi\n\
1532"));
1533#else
1534 gdb_printf (stream, _("\
1535 --without-amd-dbgapi\n\
1536"));
1537#endif
1538
1539#if HAVE_SOURCE_HIGHLIGHT
1540 gdb_printf (stream, _("\
1541 --enable-source-highlight\n\
1542"));
1543#else
1544 gdb_printf (stream, _("\
1545 --disable-source-highlight\n\
1546"));
1547#endif
1548
1549#if CXX_STD_THREAD
1550 gdb_printf (stream, _("\
1551 --enable-threading\n\
1552"));
1553#else
1554 gdb_printf (stream, _("\
1555 --disable-threading\n\
1556"));
1557#endif
1558
1559#ifdef TUI
1560 gdb_printf (stream, _("\
1561 --enable-tui\n\
1562"));
1563#else
1564 gdb_printf (stream, _("\
1565 --disable-tui\n\
1566"));
1567#endif
1568
1569#ifdef HAVE_READLINE_READLINE_H
1570 gdb_printf (stream, _("\
1571 --with-system-readline\n\
1572"));
1573#else
1574 gdb_printf (stream, _("\
1575 --without-system-readline\n\
1576"));
1577#endif
1578
1579#ifdef RELOC_SRCDIR
1580 gdb_printf (stream, _("\
1581 --with-relocated-sources=%s\n\
1582"), RELOC_SRCDIR);
1583#endif
1584
1585 if (DEBUGDIR[0])
1586 gdb_printf (stream, _("\
1587 --with-separate-debug-dir=%s%s\n\
1588"), DEBUGDIR, DEBUGDIR_RELOCATABLE ? " (relocatable)" : "");
1589
1590#ifdef ADDITIONAL_DEBUG_DIRS
1591 gdb_printf (stream, _ ("\
1592 --with-additional-debug-dirs=%s\n\
1593"), ADDITIONAL_DEBUG_DIRS);
1594#endif
1595
1596 if (TARGET_SYSTEM_ROOT[0])
1597 gdb_printf (stream, _("\
1598 --with-sysroot=%s%s\n\
1599"), TARGET_SYSTEM_ROOT, TARGET_SYSTEM_ROOT_RELOCATABLE ? " (relocatable)" : "");
1600
1601 if (SYSTEM_GDBINIT[0])
1602 gdb_printf (stream, _("\
1603 --with-system-gdbinit=%s%s\n\
1604"), SYSTEM_GDBINIT, SYSTEM_GDBINIT_RELOCATABLE ? " (relocatable)" : "");
1605
1606 if (SYSTEM_GDBINIT_DIR[0])
1607 gdb_printf (stream, _("\
1608 --with-system-gdbinit-dir=%s%s\n\
1609"), SYSTEM_GDBINIT_DIR, SYSTEM_GDBINIT_DIR_RELOCATABLE ? " (relocatable)" : "");
1610
1611 /* We assume "relocatable" will be printed at least once, thus we always
1612 print this text. It's a reasonably safe assumption for now. */
1613 gdb_printf (stream, _("\n\
1614(\"Relocatable\" means the directory can be moved with the GDB installation\n\
1615tree, and GDB will still find it.)\n\
1616"));
1617}
1618
1619
1620/* The current top level prompt, settable with "set prompt", and/or
1621 with the python `gdb.prompt_hook' hook. */
1622static std::string top_prompt;
1623
1624/* Access method for the GDB prompt string. */
1625
1626const std::string &
1628{
1629 return top_prompt;
1630}
1631
1632/* Set method for the GDB prompt string. */
1633
1634void
1635set_prompt (const char *s)
1636{
1637 top_prompt = s;
1638}
1639
1640
1641/* Kills or detaches the given inferior, depending on how we originally
1642 gained control of it. */
1643
1644static void
1646{
1647 if (inf->pid == 0)
1648 return;
1649
1651 if (thread != NULL)
1652 {
1653 switch_to_thread (thread);
1654
1655 /* Leave core files alone. */
1656 if (target_has_execution ())
1657 {
1658 if (inf->attach_flag)
1659 target_detach (inf, from_tty);
1660 else
1661 target_kill ();
1662 }
1663 }
1664}
1665
1666/* Prints info about what GDB will do to inferior INF on a "quit". OUT is
1667 where to collect the output. */
1668
1669static void
1671{
1672 if (inf->pid == 0)
1673 return;
1674
1675 if (inf->attach_flag)
1676 gdb_printf (out,
1677 _("\tInferior %d [%s] will be detached.\n"), inf->num,
1678 target_pid_to_str (ptid_t (inf->pid)).c_str ());
1679 else
1680 gdb_printf (out,
1681 _("\tInferior %d [%s] will be killed.\n"), inf->num,
1682 target_pid_to_str (ptid_t (inf->pid)).c_str ());
1683}
1684
1685/* If necessary, make the user confirm that we should quit. Return
1686 non-zero if we should quit, zero if we shouldn't. */
1687
1688int
1690{
1691 /* Don't even ask if we're only debugging a core file inferior. */
1692 if (!have_live_inferiors ())
1693 return 1;
1694
1695 /* Build the query string as a single string. */
1696 string_file stb;
1697
1698 stb.puts (_("A debugging session is active.\n\n"));
1699
1700 for (inferior *inf : all_inferiors ())
1702
1703 stb.puts (_("\nQuit anyway? "));
1704
1705 return query ("%s", stb.c_str ());
1706}
1707
1708/* Prepare to exit GDB cleanly by undoing any changes made to the
1709 terminal so that we leave the terminal in the state we acquired it. */
1710
1711static void
1713{
1714 struct ui *saved_top_level = current_ui;
1715
1717
1719
1720#if defined(TUI)
1721 tui_disable ();
1722#endif
1724
1725 current_ui = saved_top_level;
1726}
1727
1728
1729/* Quit without asking for confirmation. */
1730
1731void
1732quit_force (int *exit_arg, int from_tty)
1733{
1734 int exit_code = 0;
1735
1736 /* Clear the quit flag and sync_quit_force_run so that a
1737 gdb_exception_forced_quit isn't inadvertently triggered by a QUIT
1738 check while running the various cleanup/exit code below. Note
1739 that the call to 'check_quit_flag' clears the quit flag as a side
1740 effect. */
1741 check_quit_flag ();
1742 sync_quit_force_run = false;
1743
1744 /* An optional expression may be used to cause gdb to terminate with the
1745 value of that expression. */
1746 if (exit_arg)
1747 exit_code = *exit_arg;
1748 else if (return_child_result)
1749 exit_code = return_child_result_value;
1750
1751 gdb::observers::gdb_exiting.notify (exit_code);
1752
1754
1755 /* We want to handle any quit errors and exit regardless. */
1756
1757 /* Get out of tfind mode, and kill or detach all inferiors. */
1758 try
1759 {
1761 for (inferior *inf : all_inferiors ())
1762 kill_or_detach (inf, from_tty);
1763 }
1764 catch (const gdb_exception &ex)
1765 {
1767 }
1768
1769 /* Give all pushed targets a chance to do minimal cleanup, and pop
1770 them all out. */
1771 for (inferior *inf : all_inferiors ())
1772 {
1773 try
1774 {
1775 inf->pop_all_targets ();
1776 }
1777 catch (const gdb_exception &ex)
1778 {
1780 }
1781 }
1782
1783 /* Save the history information if it is appropriate to do so. */
1784 try
1785 {
1786 if (write_history_p && !history_filename.empty ())
1787 {
1788 int save = 0;
1789
1790 /* History is currently shared between all UIs. If there's
1791 any UI with a terminal, save history. */
1792 for (ui *ui : all_uis ())
1793 {
1794 if (ui->input_interactive_p ())
1795 {
1796 save = 1;
1797 break;
1798 }
1799 }
1800
1801 if (save)
1803 }
1804 }
1805 catch (const gdb_exception &ex)
1806 {
1808 }
1809
1810 /* Destroy any values currently allocated now instead of leaving it
1811 to global destructors, because that may be too late. For
1812 example, the destructors of xmethod values call into the Python
1813 runtime, which is finalized via a final cleanup. */
1814 finalize_values ();
1815
1816 /* Do any final cleanups before exiting. */
1817 try
1818 {
1819 do_final_cleanups ();
1820 }
1821 catch (const gdb_exception &ex)
1822 {
1824 }
1825
1826 exit (exit_code);
1827}
1828
1829/* See top.h. */
1830
1832
1833/* Implement the "show interactive-mode" option. */
1834
1835static void
1836show_interactive_mode (struct ui_file *file, int from_tty,
1837 struct cmd_list_element *c,
1838 const char *value)
1839{
1841 gdb_printf (file, "Debugger's interactive mode "
1842 "is %s (currently %s).\n",
1843 value, current_ui->input_interactive_p () ? "on" : "off");
1844 else
1845 gdb_printf (file, "Debugger's interactive mode is %s.\n", value);
1846}
1847
1848static void
1849dont_repeat_command (const char *ignored, int from_tty)
1850{
1851 /* Can't call dont_repeat here because we're not necessarily reading
1852 from stdin. */
1853 *saved_command_line = 0;
1854}
1855
1856/* Functions to manipulate command line editing control variables. */
1857
1858/* Number of commands to print in each call to show_commands. */
1859#define Hist_print 10
1860void
1861show_commands (const char *args, int from_tty)
1862{
1863 /* Index for history commands. Relative to history_base. */
1864 int offset;
1865
1866 /* Number of the history entry which we are planning to display next.
1867 Relative to history_base. */
1868 static int num = 0;
1869
1870 /* Print out some of the commands from the command history. */
1871
1872 if (args)
1873 {
1874 if (args[0] == '+' && args[1] == '\0')
1875 /* "info editing +" should print from the stored position. */
1876 ;
1877 else
1878 /* "info editing <exp>" should print around command number <exp>. */
1879 num = (parse_and_eval_long (args) - history_base) - Hist_print / 2;
1880 }
1881 /* "show commands" means print the last Hist_print commands. */
1882 else
1883 {
1884 num = history_length - Hist_print;
1885 }
1886
1887 if (num < 0)
1888 num = 0;
1889
1890 /* If there are at least Hist_print commands, we want to display the last
1891 Hist_print rather than, say, the last 6. */
1892 if (history_length - num < Hist_print)
1893 {
1894 num = history_length - Hist_print;
1895 if (num < 0)
1896 num = 0;
1897 }
1898
1899 for (offset = num;
1900 offset < num + Hist_print && offset < history_length;
1901 offset++)
1902 {
1903 gdb_printf ("%5d %s\n", history_base + offset,
1904 (history_get (history_base + offset))->line);
1905 }
1906
1907 /* The next command we want to display is the next one that we haven't
1908 displayed yet. */
1909 num += Hist_print;
1910
1911 /* If the user repeats this command with return, it should do what
1912 "show commands +" does. This is unnecessary if arg is null,
1913 because "show commands +" is not useful after "show commands". */
1914 if (from_tty && args)
1916}
1917
1918/* Update the size of our command history file to HISTORY_SIZE.
1919
1920 A HISTORY_SIZE of -1 stands for unlimited. */
1921
1922static void
1924{
1925 gdb_assert (history_size >= -1);
1926
1927 if (history_size == -1)
1928 unstifle_history ();
1929 else
1930 stifle_history (history_size);
1931}
1932
1933/* Called by do_setshow_command. */
1934static void
1936 int from_tty, struct cmd_list_element *c)
1937{
1939}
1940
1941bool info_verbose = false; /* Default verbose msgs off. */
1942
1943/* Called by do_set_command. An elaborate joke. */
1944void
1945set_verbose (const char *args, int from_tty, struct cmd_list_element *c)
1946{
1947 const char *cmdname = "verbose";
1948 struct cmd_list_element *showcmd;
1949
1950 showcmd = lookup_cmd_1 (&cmdname, showlist, NULL, NULL, 1);
1951 gdb_assert (showcmd != NULL && showcmd != CMD_LIST_AMBIGUOUS);
1952
1953 if (c->doc && c->doc_allocated)
1954 xfree ((char *) c->doc);
1955 if (showcmd->doc && showcmd->doc_allocated)
1956 xfree ((char *) showcmd->doc);
1957 if (info_verbose)
1958 {
1959 c->doc = _("Set verbose printing of informational messages.");
1960 showcmd->doc = _("Show verbose printing of informational messages.");
1961 }
1962 else
1963 {
1964 c->doc = _("Set verbosity.");
1965 showcmd->doc = _("Show verbosity.");
1966 }
1967 c->doc_allocated = 0;
1968 showcmd->doc_allocated = 0;
1969}
1970
1971/* Init the history buffer. Note that we are called after the init file(s)
1972 have been read so that the user can change the history file via his
1973 .gdbinit file (for instance). The GDBHISTFILE environment variable
1974 overrides all of this. */
1975
1976void
1978{
1979 const char *tmpenv;
1980
1981 tmpenv = getenv ("GDBHISTSIZE");
1982 if (tmpenv)
1983 {
1984 long var;
1985 int saved_errno;
1986 char *endptr;
1987
1988 tmpenv = skip_spaces (tmpenv);
1989 errno = 0;
1990 var = strtol (tmpenv, &endptr, 10);
1991 saved_errno = errno;
1992 endptr = skip_spaces (endptr);
1993
1994 /* If GDBHISTSIZE is non-numeric then ignore it. If GDBHISTSIZE is the
1995 empty string, a negative number or a huge positive number (larger than
1996 INT_MAX) then set the history size to unlimited. Otherwise set our
1997 history size to the number we have read. This behavior is consistent
1998 with how bash handles HISTSIZE. */
1999 if (*endptr != '\0')
2000 ;
2001 else if (*tmpenv == '\0'
2002 || var < 0
2003 || var > INT_MAX
2004 /* On targets where INT_MAX == LONG_MAX, we have to look at
2005 errno after calling strtol to distinguish between a value that
2006 is exactly INT_MAX and an overflowing value that was clamped
2007 to INT_MAX. */
2008 || (var == INT_MAX && saved_errno == ERANGE))
2010 else
2012 }
2013
2014 /* If neither the init file nor GDBHISTSIZE has set a size yet, pick the
2015 default. */
2016 if (history_size_setshow_var == -2)
2018
2020
2021 if (!history_filename.empty ())
2022 read_history (history_filename.c_str ());
2023}
2024
2025static void
2026show_prompt (struct ui_file *file, int from_tty,
2027 struct cmd_list_element *c, const char *value)
2028{
2029 gdb_printf (file, _("Gdb's prompt is \"%s\".\n"), value);
2030}
2031
2032/* "set editing" command. */
2033
2034static void
2035set_editing (const char *args, int from_tty, struct cmd_list_element *c)
2036{
2038 /* Update the control variable so that MI's =cmd-param-changed event
2039 shows the correct value. */
2041}
2042
2043static void
2044show_editing (struct ui_file *file, int from_tty,
2045 struct cmd_list_element *c, const char *value)
2046{
2047 gdb_printf (file, _("Editing of command lines as "
2048 "they are typed is %s.\n"),
2049 current_ui->command_editing ? _("on") : _("off"));
2050}
2051
2052static void
2053show_annotation_level (struct ui_file *file, int from_tty,
2054 struct cmd_list_element *c, const char *value)
2055{
2056 gdb_printf (file, _("Annotation_level is %s.\n"), value);
2057}
2058
2059static void
2060show_exec_done_display_p (struct ui_file *file, int from_tty,
2061 struct cmd_list_element *c, const char *value)
2062{
2063 gdb_printf (file, _("Notification of completion for "
2064 "asynchronous execution commands is %s.\n"),
2065 value);
2066}
2067
2068/* New values of the "data-directory" parameter are staged here.
2069 Extension languages, for example Python's gdb.parameter API, will read
2070 the value directory from this variable, so we must ensure that this
2071 always contains the correct value. */
2072static std::string staged_gdb_datadir;
2073
2074/* "set" command for the gdb_datadir configuration variable. */
2075
2076static void
2077set_gdb_datadir (const char *args, int from_tty, struct cmd_list_element *c)
2078{
2080
2081 /* SET_GDB_DATA_DIRECTORY will resolve relative paths in
2082 STAGED_GDB_DATADIR, so we now copy the value from GDB_DATADIR
2083 back into STAGED_GDB_DATADIR so the extension languages can read the
2084 correct value. */
2086
2088}
2089
2090/* "show" command for the gdb_datadir configuration variable. */
2091
2092static void
2093show_gdb_datadir (struct ui_file *file, int from_tty,
2094 struct cmd_list_element *c, const char *value)
2095{
2096 gdb_printf (file, _("GDB's data directory is \"%ps\".\n"),
2098 gdb_datadir.c_str ()));
2099}
2100
2101/* Implement 'set history filename'. */
2102
2103static void
2104set_history_filename (const char *args,
2105 int from_tty, struct cmd_list_element *c)
2106{
2107 /* We include the current directory so that if the user changes
2108 directories the file written will be the same as the one
2109 that was read. */
2110 if (!history_filename.empty ()
2111 && !IS_ABSOLUTE_PATH (history_filename.c_str ()))
2112 history_filename = gdb_abspath (history_filename.c_str ());
2113}
2114
2115/* Whether we're in quiet startup mode. */
2116
2117static bool startup_quiet;
2118
2119/* See top.h. */
2120
2121bool
2123{
2124 return startup_quiet;
2125}
2126
2127/* Show whether GDB should start up in quiet mode. */
2128
2129static void
2130show_startup_quiet (struct ui_file *file, int from_tty,
2131 struct cmd_list_element *c, const char *value)
2132{
2133 gdb_printf (file, _("Whether to start up quietly is %s.\n"),
2134 value);
2135}
2136
2137static void
2139{
2140 /* Initialize the prompt to a simple "(gdb) " prompt or to whatever
2141 the DEFAULT_PROMPT is. */
2143
2144 /* Set the important stuff up for command editing. */
2147 write_history_p = 0;
2148
2149 /* Setup important stuff for command line editing. */
2150 rl_completion_word_break_hook = gdb_completion_word_break_characters;
2151 rl_attempted_completion_function = gdb_rl_attempted_completion_function;
2153 rl_completer_quote_characters = get_gdb_completer_quote_characters ();
2154 rl_completion_display_matches_hook = cli_display_match_list;
2155 rl_readline_name = "gdb";
2156 rl_terminal_name = getenv ("TERM");
2157 rl_deprep_term_function = gdb_rl_deprep_term_function;
2158
2159 /* The name for this defun comes from Bash, where it originated.
2160 15 is Control-o, the same binding this function has in Bash. */
2161 rl_add_defun ("operate-and-get-next", gdb_rl_operate_and_get_next, 15);
2162
2164 &top_prompt,
2165 _("Set gdb's prompt."),
2166 _("Show gdb's prompt."),
2167 NULL, NULL,
2169 &setlist, &showlist);
2170
2171 add_com ("dont-repeat", class_support, dont_repeat_command, _("\
2172Don't repeat this command.\nPrimarily \
2173used inside of user-defined commands that should not be repeated when\n\
2174hitting return."));
2175
2177 &set_editing_cmd_var, _("\
2178Set editing of command lines as they are typed."), _("\
2179Show editing of command lines as they are typed."), _("\
2180Use \"on\" to enable the editing, and \"off\" to disable it.\n\
2181Without an argument, command line editing is enabled. To edit, use\n\
2182EMACS-like or VI-like commands like control-P or ESC."),
2185 &setlist, &showlist);
2186
2188Set saving of the history record on exit."), _("\
2189Show saving of the history record on exit."), _("\
2190Use \"on\" to enable the saving, and \"off\" to disable it.\n\
2191Without an argument, saving is enabled."),
2192 NULL,
2195
2198Set the size of the command history."), _("\
2199Show the size of the command history."), _("\
2200This is the number of previous commands to keep a record of.\n\
2201If set to \"unlimited\", the number of commands kept in the history\n\
2202list is unlimited. This defaults to the value of the environment\n\
2203variable \"GDBHISTSIZE\", or to 256 if this variable is not set."),
2207
2208 add_setshow_zuinteger_unlimited_cmd ("remove-duplicates", no_class,
2210Set how far back in history to look for and remove duplicate entries."), _("\
2211Show how far back in history to look for and remove duplicate entries."), _("\
2212If set to a nonzero value N, GDB will look back at the last N history entries\n\
2213and remove the first history entry that is a duplicate of the most recent\n\
2214entry, each time a new history entry is added.\n\
2215If set to \"unlimited\", this lookbehind is unbounded.\n\
2216Only history entries added during this session are considered for removal.\n\
2217If set to 0, removal of duplicate history entries is disabled.\n\
2218By default this option is set to 0."),
2219 NULL,
2222
2224Set the filename in which to record the command history."), _("\
2225Show the filename in which to record the command history."), _("\
2226(the list of previous commands of which a record is kept)."),
2230
2232Set whether to confirm potentially dangerous operations."), _("\
2233Show whether to confirm potentially dangerous operations."), NULL,
2234 NULL,
2236 &setlist, &showlist);
2237
2239Set annotation_level."), _("\
2240Show annotation_level."), _("\
22410 == normal; 1 == fullname (for use when running under emacs)\n\
22422 == output annotated suitably for use by programs that control GDB."),
2243 NULL,
2245 &setlist, &showlist);
2246
2247 add_setshow_boolean_cmd ("exec-done-display", class_support,
2248 &exec_done_display_p, _("\
2249Set notification of completion for asynchronous execution commands."), _("\
2250Show notification of completion for asynchronous execution commands."), _("\
2251Use \"on\" to enable the notification, and \"off\" to disable it."),
2252 NULL,
2254 &setlist, &showlist);
2255
2257 &staged_gdb_datadir, _("Set GDB's data directory."),
2258 _("Show GDB's data directory."),
2259 _("\
2260When set, GDB uses the specified path to search for data files."),
2262 &setlist,
2263 &showlist);
2264 /* Prime the initial value for data-directory. */
2266
2267 add_setshow_auto_boolean_cmd ("interactive-mode", class_support,
2268 &interactive_mode, _("\
2269Set whether GDB's standard input is a terminal."), _("\
2270Show whether GDB's standard input is a terminal."), _("\
2271If on, GDB assumes that standard input is a terminal. In practice, it\n\
2272means that GDB should wait for the user to answer queries associated to\n\
2273commands entered at the command prompt. If off, GDB assumes that standard\n\
2274input is not a terminal, and uses the default answer to all queries.\n\
2275If auto (the default), determine which mode to use based on the standard\n\
2276input settings."),
2277 NULL,
2279 &setlist, &showlist);
2280
2281 add_setshow_boolean_cmd ("startup-quietly", class_support,
2282 &startup_quiet, _("\
2283Set whether GDB should start up quietly."), _(" \
2284Show whether GDB should start up quietly."), _("\
2285This setting will not affect the current session. Instead this command\n\
2286should be added to the .gdbearlyinit file in the users home directory to\n\
2287affect future GDB sessions."),
2288 NULL,
2290 &setlist, &showlist);
2291
2292 struct internalvar *major_version_var = create_internalvar ("_gdb_major");
2293 struct internalvar *minor_version_var = create_internalvar ("_gdb_minor");
2294 int vmajor = 0, vminor = 0, vrevision = 0;
2295 sscanf (version, "%d.%d.%d", &vmajor, &vminor, &vrevision);
2296 set_internalvar_integer (major_version_var, vmajor);
2297 set_internalvar_integer (minor_version_var, vminor + (vrevision > 0));
2298}
2299
2300/* See top.h. */
2301
2302void
2304{
2305 saved_command_line = xstrdup ("");
2306 previous_saved_command_line = xstrdup ("");
2307
2308 /* Run the init function of each source file. */
2309
2310#ifdef __MSDOS__
2311 /* Make sure we return to the original directory upon exit, come
2312 what may, since the OS doesn't do that for us. */
2313 make_final_cleanup (do_chdir_cleanup, xstrdup (current_directory));
2314#endif
2315
2316 init_page_info ();
2317
2318 /* Here is where we call all the _initialize_foo routines. */
2320
2321 /* This creates the current_program_space. Do this after all the
2322 _initialize_foo routines have had a chance to install their
2323 per-sspace data keys. Also do this before
2324 initialize_current_architecture is called, because it accesses
2325 exec_bfd of the current program space. */
2329 init_main (); /* But that omits this file! Do it now. */
2330
2332
2333 /* Take a snapshot of our tty state before readline/ncurses have had a chance
2334 to alter it. */
2336
2338
2339 /* We need a default language for parsing expressions, so simple
2340 things like "set width 0" won't fail if no language is explicitly
2341 set in a config file or implicitly set by reading an executable
2342 during startup. */
2344 expected_language = current_language; /* Don't warn about the change. */
2345}
2346
2347void _initialize_top ();
2348void
2350{
2351 /* Determine a default value for the history filename. */
2352 const char *tmpenv = getenv ("GDBHISTFILE");
2353 if (tmpenv != nullptr)
2354 history_filename = tmpenv;
2355 else
2356 {
2357 /* We include the current directory so that if the user changes
2358 directories the file written will be the same as the one
2359 that was read. */
2360#ifdef __MSDOS__
2361 /* No leading dots in file names are allowed on MSDOS. */
2362 const char *fname = "_gdb_history";
2363#else
2364 const char *fname = ".gdb_history";
2365#endif
2366
2367 history_filename = gdb_abspath (fname);
2368 }
2369}
void xfree(void *)
void initialize_current_architecture(void)
Definition arch-utils.c:688
void bpstat_clear_actions(void)
ui_file_style style() const
Definition cli-style.c:169
DISABLE_COPY_AND_ASSIGN(gdb_readline_wrapper_cleanup)
void(* m_handler_orig)(gdb::unique_xmalloc_ptr< char > &&)
Definition top.c:1029
scoped_restore_tmpl< struct ui * > m_save_ui
Definition top.c:1036
const char * c_str() const
Definition ui-file.h:222
std::string release()
Definition ui-file.h:204
static void ours()
Definition target.c:1070
virtual void puts(const char *str)
Definition ui-file.h:76
struct cmd_list_element * showlist
Definition cli-cmds.c:127
struct cmd_list_element * showhistlist
Definition cli-cmds.c:135
struct cmd_list_element * cmdlist
Definition cli-cmds.c:87
struct cmd_list_element * setlist
Definition cli-cmds.c:119
int is_complete_command(struct cmd_list_element *c)
Definition cli-cmds.c:456
struct cmd_list_element * sethistlist
Definition cli-cmds.c:131
void quit_command(const char *args, int from_tty)
Definition cli-cmds.c:477
set_show_commands add_setshow_filename_cmd(const char *name, enum command_class theclass, std::string *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition cli-decode.c:855
struct cmd_list_element * lookup_cmd(const char **line, struct cmd_list_element *list, const char *cmdtype, std::string *default_args, int allow_unknown, int ignore_help_classes)
set_show_commands add_setshow_zinteger_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
void deprecated_cmd_warning(const char *text, struct cmd_list_element *list)
set_show_commands add_setshow_optional_filename_cmd(const char *name, enum command_class theclass, std::string *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
struct cmd_list_element * lookup_cmd_1(const char **text, struct cmd_list_element *clist, struct cmd_list_element **result_list, std::string *default_args, int ignore_help_classes, bool lookup_for_completion_p)
set_show_commands add_setshow_string_cmd(const char *name, enum command_class theclass, std::string *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition cli-decode.c:903
void help_list(struct cmd_list_element *list, const char *cmdtype, enum command_class theclass, struct ui_file *stream)
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_simple_func_ftype *fun, const char *doc)
set_show_commands add_setshow_zuinteger_unlimited_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
void cmd_func(struct cmd_list_element *cmd, const char *args, int from_tty)
set_show_commands add_setshow_boolean_cmd(const char *name, enum command_class theclass, bool *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition cli-decode.c:809
set_show_commands add_setshow_auto_boolean_cmd(const char *name, enum command_class theclass, enum auto_boolean *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition cli-decode.c:752
@ set_cmd
Definition cli-decode.h:38
@ show_cmd
Definition cli-decode.h:39
void cli_display_match_list(char **matches, int len, int max)
Definition cli-out.c:526
void execute_cmd_pre_hook(struct cmd_list_element *c)
Definition cli-script.c:379
void print_command_trace(const char *fmt,...)
Definition cli-script.c:486
void execute_cmd_post_hook(struct cmd_list_element *c)
Definition cli-script.c:390
void execute_user_command(struct cmd_list_element *c, const char *args)
Definition cli-script.c:439
void do_show_command(const char *arg, int from_tty, struct cmd_list_element *c)
void do_set_command(const char *arg, int from_tty, struct cmd_list_element *c)
cli_style_option file_name_style
cli_style_option version_style
#define CMD_LIST_AMBIGUOUS
Definition command.h:539
@ class_user
Definition command.h:67
@ all_commands
Definition command.h:50
@ class_obscure
Definition command.h:64
@ class_maintenance
Definition command.h:65
@ class_support
Definition command.h:58
@ no_class
Definition command.h:53
char ** gdb_rl_attempted_completion_function(const char *text, int start, int end)
Definition completer.c:2329
char * gdb_completion_word_break_characters()
Definition completer.c:1938
const char * get_gdb_completer_quote_characters(void)
Definition completer.c:186
void set_rl_completer_word_break_characters(const char *break_chars)
Definition completer.c:1102
#define AUTO_LOAD_DIR
Definition config.h:11
#define WITH_PYTHON_PATH
Definition config.h:787
#define JIT_READER_DIR_RELOCATABLE
Definition config.h:619
#define JIT_READER_DIR
Definition config.h:615
#define PYTHON_LIBDIR_RELOCATABLE
Definition config.h:679
#define SYSTEM_GDBINIT_RELOCATABLE
Definition config.h:734
#define TARGET_SYSTEM_ROOT_RELOCATABLE
Definition config.h:740
#define SYSTEM_GDBINIT_DIR_RELOCATABLE
Definition config.h:730
#define GDB_DATADIR
Definition config.h:57
#define REPORT_BUGS_TO
Definition config.h:688
#define WITH_PYTHON_LIBDIR
Definition config.h:783
#define SYSTEM_GDBINIT
Definition config.h:723
#define GDB_DATADIR_RELOCATABLE
Definition config.h:61
#define TARGET_SYSTEM_ROOT
Definition config.h:737
#define DEBUGDIR_RELOCATABLE
Definition config.h:35
#define PYTHON_PATH_RELOCATABLE
Definition config.h:682
#define AUTO_LOAD_SAFE_PATH
Definition config.h:14
#define DEBUGDIR
Definition config.h:31
#define SYSTEM_GDBINIT_DIR
Definition config.h:726
#define PKGVERSION
Definition config.h:647
int check_quit_flag(void)
Definition extension.c:857
void initialize_inferiors(void)
Definition inferior.c:1079
#define ISATTY(FP)
Definition defs.h:570
void initialize_progspace(void)
Definition progspace.c:445
auto_boolean
Definition defs.h:247
@ AUTO_BOOLEAN_AUTO
Definition defs.h:250
int annotation_level
Definition stack.c:234
language
Definition defs.h:211
@ language_unknown
Definition defs.h:212
@ language_c
Definition defs.h:213
volatile bool sync_quit_force_run
Definition event-top.c:1145
#define QUIT
Definition defs.h:187
std::string gdb_datadir
Definition main.c:67
LONGEST parse_and_eval_long(const char *exp)
Definition eval.c:62
void gdb_rl_deprep_term_function(void)
Definition event-top.c:692
bool set_editing_cmd_var
Definition event-top.c:94
void display_gdb_prompt(const char *new_prompt)
Definition event-top.c:398
void(* after_char_processing_hook)(void)
Definition event-top.c:138
void command_handler(const char *command)
Definition event-top.c:537
const char * handle_line_of_input(std::string &cmd_line_buffer, const char *rl, int repeat, const char *annotation_suffix)
Definition event-top.c:605
bool exec_done_display_p
Definition event-top.c:98
void gdb_rl_callback_handler_remove(void)
Definition event-top.c:339
int interruptible_select(int n, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout)
Definition event-top.c:1103
void gdb_init_signals(void)
Definition event-top.c:991
void gdb_disable_readline(void)
Definition event-top.c:1319
void change_line_handler(int editing)
Definition event-top.c:291
void exception_print(struct ui_file *file, const struct gdb_exception &e)
Definition exceptions.c:106
frame_info_ptr deprecated_safe_get_selected_frame(void)
Definition frame.c:1907
bool has_stack_frames()
Definition frame.c:1859
enum language get_frame_language(frame_info_ptr frame)
Definition frame.c:3074
@ THREAD_RUNNING
Definition gdbthread.h:75
struct thread_info * inferior_thread(void)
Definition thread.c:85
void switch_to_thread(struct thread_info *thr)
Definition thread.c:1360
struct thread_info * any_thread_of_inferior(inferior *inf)
Definition thread.c:648
unsigned dummy
Definition go32-nat.c:8
int have_live_inferiors(void)
Definition inferior.c:462
all_inferiors_range all_inferiors(process_stratum_target *proc_target=nullptr)
Definition inferior.h:821
void initialize_stdin_serial(void)
Definition inflow.c:925
void set_initial_gdb_ttystate(void)
Definition inflow.c:143
bool non_stop
Definition infrun.c:226
const char lang_frame_mismatch_warn[]
Definition language.c:100
static void set_language(const char *language)
Definition language.c:140
const struct language_defn * current_language
Definition language.c:82
void language_info()
Definition language.c:375
const struct language_defn * expected_language
Definition language.c:88
const char * default_word_break_characters(void)
Definition language.c:553
language_mode
Definition language.h:717
@ language_mode_auto
Definition language.h:718
void set_gdb_data_directory(const char *new_datadir)
Definition main.c:113
int return_child_result_value
Definition main.c:93
struct ui_file * gdb_stdtarg
Definition main.c:80
struct ui_file * gdb_stdtargerr
Definition main.c:81
int return_child_result
Definition main.c:92
observable gdb_datadir_changed
observable< int > gdb_exiting
#define enable()
Definition ser-go32.c:239
unsigned int doc_allocated
Definition cli-decode.h:145
const char * doc
Definition cli-decode.h:193
gdb::optional< setting > var
Definition cli-decode.h:236
std::string prefixname() const
Definition cli-decode.c:132
std::string default_args
Definition cli-decode.h:210
struct cmd_list_element ** subcommands
Definition cli-decode.h:214
counted_command_line user_commands
Definition cli-decode.h:243
unsigned int deprecated_warn_user
Definition cli-decode.h:130
bool is_command_class_help() const
Definition cli-decode.h:100
__extension__ enum cmd_types type
Definition cli-decode.h:168
bool is_prefix() const
Definition cli-decode.h:94
unsigned int allow_unknown
Definition cli-decode.h:158
enum command_class theclass
Definition cli-decode.h:119
Definition gnu-nat.c:153
pid_t pid
Definition gnu-nat.c:165
enum language la_language
Definition language.h:275
Definition ui.h:55
struct ui_file * m_gdb_stdin
Definition ui.h:146
int command_editing
Definition ui.h:87
struct ui_file * m_gdb_stdlog
Definition ui.h:151
int num
Definition ui.h:66
void(* input_handler)(gdb::unique_xmalloc_ptr< char > &&)
Definition ui.h:82
struct ui_file * m_gdb_stdout
Definition ui.h:144
int async
Definition ui.h:106
enum prompt_state prompt_state
Definition ui.h:136
struct ui_file * m_gdb_stderr
Definition ui.h:148
bool input_interactive_p() const
Definition ui.c:97
FILE * stdin_stream
Definition ui.h:113
std::string line_buffer
Definition ui.h:70
struct ui_out * m_current_uiout
Definition ui.h:154
int secondary_prompt_depth
Definition ui.h:110
FILE * instream
Definition ui.h:119
Definition value.h:130
void target_dcache_invalidate(void)
bool target_is_async_p()
Definition target.c:402
void target_log_command(const char *p)
Definition target.c:841
void target_async(bool enable)
Definition target.c:4337
void target_detach(inferior *inf, int from_tty)
Definition target.c:2531
void target_kill(void)
Definition target.c:913
bool target_has_execution(inferior *inf)
Definition target.c:201
std::string target_pid_to_str(ptid_t ptid)
Definition target.c:2623
static void show_write_history_p(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition top.c:856
struct ui_file ** current_ui_gdb_stdout_ptr()
Definition top.c:100
static void show_startup_quiet(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition top.c:2130
void(* deprecated_readline_end_hook)(void)
Definition top.c:240
static bool command_editing_p
Definition top.c:837
void print_gdb_version(struct ui_file *stream, bool interactive)
Definition top.c:1321
void wait_sync_command_done(void)
Definition top.c:414
static void show_history_remove_duplicates(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition top.c:884
static int operate_saved_history
Definition top.c:1068
static void gdb_readline_wrapper_line(gdb::unique_xmalloc_ptr< char > &&line)
Definition top.c:952
int(* deprecated_query_hook)(const char *, va_list)
Definition top.c:220
static void kill_or_detach(inferior *inf, int from_tty)
Definition top.c:1645
int inhibit_gdbinit
Definition top.c:129
char * gdb_readline_wrapper(const char *prompt)
Definition top.c:1040
static gdb::unique_xmalloc_ptr< char > gdb_readline_no_editing(const char *prompt)
Definition top.c:770
static void show_exec_done_display_p(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition top.c:2060
scoped_restore_tmpl< int > prevent_dont_repeat(void)
Definition top.c:735
void quit_force(int *exit_arg, int from_tty)
Definition top.c:1732
#define Hist_print
Definition top.c:1859
void execute_command_to_string(std::string &res, const char *p, int from_tty, bool term_out)
Definition top.c:670
static void undo_terminal_modifications_before_exit(void)
Definition top.c:1712
static void set_gdb_datadir(const char *args, int from_tty, struct cmd_list_element *c)
Definition top.c:2077
#define DEFAULT_PROMPT
Definition top.c:96
static void dont_repeat_command(const char *ignored, int from_tty)
Definition top.c:1849
void unbuffer_stream(FILE *stream)
Definition top.c:261
int source_line_number
Definition top.c:312
void(* deprecated_print_frame_info_listing_hook)(struct symtab *s, int line, int stopline, int noerror)
Definition top.c:214
static void show_history_size(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition top.c:872
void init_history(void)
Definition top.c:1977
static void gdb_safe_append_history(void)
Definition top.c:1165
void print_gdb_configuration(struct ui_file *stream)
Definition top.c:1393
static bool startup_quiet
Definition top.c:2117
static void print_inferior_quit_action(inferior *inf, ui_file *out)
Definition top.c:1670
bool history_expansion_p
Definition top.c:843
bool info_verbose
Definition top.c:1941
char *(* deprecated_readline_hook)(const char *)
Definition top.c:239
void(* deprecated_detach_hook)(void)
Definition top.c:246
void _initialize_top()
Definition top.c:2349
void show_commands(const char *args, int from_tty)
Definition top.c:1861
static int history_remove_duplicates
Definition top.c:881
void set_prompt(const char *s)
Definition top.c:1635
bool server_command
Definition top.c:173
struct ui_file ** current_ui_gdb_stdin_ptr()
Definition top.c:106
static int gdb_readline_wrapper_done
Definition top.c:924
void(* deprecated_attach_hook)(void)
Definition top.c:245
void execute_fn_to_ui_file(struct ui_file *file, std::function< void(void)> fn)
Definition top.c:609
static std::string staged_gdb_datadir
Definition top.c:2072
static void set_editing(const char *args, int from_tty, struct cmd_list_element *c)
Definition top.c:2035
const std::string & get_prompt()
Definition top.c:1627
void execute_fn_to_string(std::string &res, std::function< void(void)> fn, bool term_out)
Definition top.c:638
int gdb_in_secondary_prompt_p(struct ui *ui)
Definition top.c:942
void read_command_file(FILE *stream)
Definition top.c:322
static void set_history_filename(const char *args, int from_tty, struct cmd_list_element *c)
Definition top.c:2104
void(* deprecated_warning_hook)(const char *, va_list)
Definition top.c:224
int quit_confirm(void)
Definition top.c:1689
void maybe_wait_sync_command_done(int was_sync)
Definition top.c:435
static std::string history_filename
Definition top.c:852
void save_command_line(const char *cmd)
Definition top.c:751
void(* deprecated_call_command_hook)(struct cmd_list_element *c, const char *cmd, int from_tty)
Definition top.c:251
struct ui_file ** current_ui_gdb_stderr_ptr()
Definition top.c:112
void set_verbose(const char *args, int from_tty, struct cmd_list_element *c)
Definition top.c:1945
static const char * previous_repeat_arguments
Definition top.c:165
static bool write_history_p
Definition top.c:848
const char * repeat_previous()
Definition top.c:716
static void show_annotation_level(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition top.c:2053
static char * previous_saved_command_line
Definition top.c:160
void execute_command_to_ui_file(struct ui_file *file, const char *p, int from_tty)
Definition top.c:661
static void show_prompt(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition top.c:2026
const char * command_line_input(std::string &cmd_line_buffer, const char *prompt_arg, const char *annotation_suffix)
Definition top.c:1226
auto_boolean interactive_mode
Definition top.c:1831
struct ui_file ** current_ui_gdb_stdlog_ptr()
Definition top.c:118
static std::string top_prompt
Definition top.c:1622
static int gdb_rl_operate_and_get_next(int count, int key)
Definition top.c:1094
static void show_editing(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition top.c:2044
static void set_history_size_command(const char *args, int from_tty, struct cmd_list_element *c)
Definition top.c:1935
static void(* saved_after_char_processing_hook)(void)
Definition top.c:936
static const char * repeat_arguments
Definition top.c:153
bool confirm
Definition top.c:134
void initialize_all_files(void)
Definition init.c:187
void(* deprecated_context_hook)(int id)
Definition top.c:256
static int suppress_dont_repeat
Definition top.c:691
void gdb_add_history(const char *command)
Definition top.c:1120
char * get_saved_command_line()
Definition top.c:743
static int command_count
Definition top.c:1115
static void gdb_rl_operate_and_get_next_completion(void)
Definition top.c:1073
int(* deprecated_ui_loop_hook)(int)
Definition top.c:209
int remote_timeout
Definition top.c:195
void dont_repeat(void)
Definition top.c:696
std::string source_file_name
Definition top.c:318
scoped_value_mark prepare_execute_command()
Definition top.c:356
static char * saved_command_line
Definition top.c:148
static void show_gdb_datadir(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition top.c:2093
void execute_command(const char *p, int from_tty)
Definition top.c:459
struct ui_out ** current_ui_current_uiout_ptr()
Definition top.c:124
static void show_confirm(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition top.c:137
void check_frame_language_change(void)
Definition top.c:372
static void show_history_filename(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition top.c:895
static char * gdb_readline_wrapper_result
Definition top.c:928
static void init_main(void)
Definition top.c:2138
void set_repeat_arguments(const char *args)
Definition top.c:450
static void set_readline_history_size(int history_size)
Definition top.c:1923
static void show_interactive_mode(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition top.c:1836
void(* deprecated_readline_begin_hook)(const char *,...)
Definition top.c:238
bool check_quiet_mode()
Definition top.c:2122
static int history_size_setshow_var
Definition top.c:869
void gdb_init()
Definition top.c:2303
char * lim_at_start
void quit_cover(void)
void disconnect_tracing(void)
void tui_inject_newline_into_command_window()
Definition tui-io.c:1048
void tui_disable(void)
Definition tui.c:523
bool tui_active
Definition tui.c:73
static styled_string_s * styled_string(const ui_file_style &style, const char *str, styled_string_s &&tmp={})
Definition ui-out.h:151
#define current_uiout
Definition ui-out.h:40
struct ui * main_ui
Definition ui.c:34
struct ui * current_ui
Definition ui.c:35
@ PROMPT_BLOCKED
Definition ui.h:35
static ui_range all_uis()
Definition ui.h:222
void init_page_info(void)
Definition utils.c:1124
int query(const char *ctlstr,...)
Definition utils.c:943
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1886
void gdb_flush(struct ui_file *stream)
Definition utils.c:1498
void printf_unfiltered(const char *format,...)
Definition utils.c:1922
#define gdb_stderr
Definition utils.h:187
#define gdb_stdlog
Definition utils.h:190
#define gdb_stdout
Definition utils.h:182
void finalize_values()
Definition value.c:4327
struct internalvar * create_internalvar(const char *name)
Definition value.c:1950
void set_internalvar_integer(struct internalvar *var, LONGEST l)
Definition value.c:2232
const char host_name[]
Definition version.c:3
const char version[]
Definition version.c:2
const char target_name[]
Definition version.c:4
#define nullptr
Definition x86-cpuid.h:28