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