Avoid internal errors when stepping outside 'main' on MinGW
[deliverable/binutils-gdb.git] / gdb / top.c
CommitLineData
c906108c 1/* Top level stuff for GDB, the GNU debugger.
a752853e 2
e2882c85 3 Copyright (C) 1986-2018 Free Software Foundation, Inc.
c906108c 4
c5aa993b 5 This file is part of GDB.
c906108c 6
c5aa993b
JM
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
a9762ec7 9 the Free Software Foundation; either version 3 of the License, or
c5aa993b 10 (at your option) any later version.
c906108c 11
c5aa993b
JM
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.
c906108c 16
c5aa993b 17 You should have received a copy of the GNU General Public License
a9762ec7 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c
SS
19
20#include "defs.h"
21#include "gdbcmd.h"
210661e7
EZ
22#include "cli/cli-cmds.h"
23#include "cli/cli-script.h"
24#include "cli/cli-setshow.h"
18a642a1 25#include "cli/cli-decode.h"
c906108c
SS
26#include "symtab.h"
27#include "inferior.h"
45741a9c 28#include "infrun.h"
042be3a9 29#include <signal.h>
c906108c 30#include "target.h"
68c765e2 31#include "target-dcache.h"
c906108c
SS
32#include "breakpoint.h"
33#include "gdbtypes.h"
34#include "expression.h"
35#include "value.h"
36#include "language.h"
c5aa993b 37#include "terminal.h" /* For job_control. */
15652511 38#include "job-control.h"
c906108c 39#include "annotate.h"
c5f0f3d0 40#include "completer.h"
c906108c 41#include "top.h"
d4f3574e 42#include "version.h"
210661e7 43#include "serial.h"
f17517ea 44#include "main.h"
2e03ee74 45#include "event-loop.h"
8ea051c5 46#include "gdbthread.h"
6dddc817 47#include "extension.h"
b4a14fd0 48#include "interps.h"
76727919 49#include "observable.h"
bd712aed 50#include "maint.h"
97c85fc6 51#include "filenames.h"
06096720 52#include "frame.h"
7a3bde34 53#include "buffer.h"
3212b858 54#include "gdb_select.h"
c906108c 55
371d5dec 56/* readline include files. */
dbda9972
AC
57#include "readline/readline.h"
58#include "readline/history.h"
c906108c
SS
59
60/* readline defines this. */
61#undef savestring
62
63#include <sys/types.h>
c906108c 64
c2c6d25f 65#include "event-top.h"
53ce3c39 66#include <sys/stat.h>
c906108c 67#include <ctype.h>
8b93c638
JM
68#include "ui-out.h"
69#include "cli-out.h"
2f9d54cf 70#include "tracepoint.h"
93d6eb10 71#include "inf-loop.h"
c906108c 72
18206ca3
PP
73#if defined(TUI)
74# include "tui/tui.h"
75#endif
76
60eb5395
PA
77#ifndef O_NOCTTY
78# define O_NOCTTY 0
79#endif
80
ca7b0bbc
TT
81extern void initialize_all_files (void);
82
95298e72
PM
83#define PROMPT(X) the_prompts.prompt_stack[the_prompts.top + X].prompt
84#define PREFIX(X) the_prompts.prompt_stack[the_prompts.top + X].prefix
85#define SUFFIX(X) the_prompts.prompt_stack[the_prompts.top + X].suffix
86
371d5dec 87/* Default command line prompt. This is overriden in some configs. */
104c1213
JM
88
89#ifndef DEFAULT_PROMPT
90#define DEFAULT_PROMPT "(gdb) "
c906108c
SS
91#endif
92
79aa2fe8
PA
93/* Generate a function that exports a pointer to a field of the
94 current UI. */
95
96#define gen_ret_current_ui_field_ptr(type, name) \
97type * \
98current_ui_## name ## _ptr (void) \
99{ \
100 return &current_ui->m_ ## name; \
101}
102
103gen_ret_current_ui_field_ptr (struct ui_file *, gdb_stdout)
104gen_ret_current_ui_field_ptr (struct ui_file *, gdb_stdin)
105gen_ret_current_ui_field_ptr (struct ui_file *, gdb_stderr)
106gen_ret_current_ui_field_ptr (struct ui_file *, gdb_stdlog)
b6dcde57 107gen_ret_current_ui_field_ptr (struct ui_out *, current_uiout)
79aa2fe8 108
e655c1a2 109/* Initialization file name for gdb. This is host-dependent. */
eaae3919 110
e655c1a2 111const char gdbinit[] = GDBINIT;
c906108c
SS
112
113int inhibit_gdbinit = 0;
114
c906108c
SS
115extern char lang_frame_mismatch_warn[]; /* language.c */
116
050a2e1d
PA
117/* Flag for whether we want to confirm potentially dangerous
118 operations. Default is yes. */
119
e360902b 120int confirm = 1;
c906108c 121
920d2a44 122static void
e360902b 123show_confirm (struct ui_file *file, int from_tty,
920d2a44
AC
124 struct cmd_list_element *c, const char *value)
125{
3e43a32a
MS
126 fprintf_filtered (file, _("Whether to confirm potentially "
127 "dangerous operations is %s.\n"),
920d2a44
AC
128 value);
129}
c906108c 130
c906108c
SS
131/* Current working directory. */
132
133char *current_directory;
134
2669cade
PA
135/* The last command line executed on the console. Used for command
136 repetitions. */
dc7eb48e 137char *saved_command_line;
c906108c
SS
138
139/* Nonzero if the current command is modified by "server ". This
c2d11a7d 140 affects things like recording into the command history, commands
c906108c
SS
141 repeating on RETURN, etc. This is so a user interface (emacs, GUI,
142 whatever) can issue its own commands and also send along commands
143 from the user, and have the user not notice that the user interface
144 is issuing commands too. */
145int server_command;
146
371d5dec 147/* Timeout limit for response from target. */
c906108c 148
ce808e91
AC
149/* The default value has been changed many times over the years. It
150 was originally 5 seconds. But that was thought to be a long time
151 to sit and wait, so it was changed to 2 seconds. That was thought
152 to be plenty unless the connection was going through some terminal
153 server or multiplexer or other form of hairy serial connection.
154
155 In mid-1996, remote_timeout was moved from remote.c to top.c and
156 it began being used in other remote-* targets. It appears that the
157 default was changed to 20 seconds at that time, perhaps because the
85a453d5 158 Renesas E7000 ICE didn't always respond in a timely manner.
ce808e91
AC
159
160 But if 5 seconds is a long time to sit and wait for retransmissions,
161 20 seconds is far worse. This demonstrates the difficulty of using
162 a single variable for all protocol timeouts.
163
164 As remote.c is used much more than remote-e7000.c, it was changed
371d5dec 165 back to 2 seconds in 1999. */
ce808e91
AC
166
167int remote_timeout = 2;
c906108c
SS
168
169/* Non-zero tells remote* modules to output debugging info. */
170
171int remote_debug = 0;
172
6dd77b81 173/* Sbrk location on entry to main. Used for statistics only. */
6242c6a6 174#ifdef HAVE_USEFUL_SBRK
6dd77b81
RH
175char *lim_at_start;
176#endif
177
c906108c
SS
178/* Hooks for alternate command interfaces. */
179
371d5dec
MS
180/* This hook is called from within gdb's many mini-event loops which
181 could steal control from a real user interface's event loop. It
182 returns non-zero if the user is requesting a detach, zero
183 otherwise. */
7a292a7a 184
98bbd631 185int (*deprecated_ui_loop_hook) (int);
c906108c 186
c906108c 187
c906108c
SS
188/* Called from print_frame_info to list the line we stopped in. */
189
371d5dec
MS
190void (*deprecated_print_frame_info_listing_hook) (struct symtab * s,
191 int line,
192 int stopline,
193 int noerror);
c906108c
SS
194/* Replaces most of query. */
195
9a4105ab 196int (*deprecated_query_hook) (const char *, va_list);
c906108c
SS
197
198/* Replaces most of warning. */
199
9a4105ab 200void (*deprecated_warning_hook) (const char *, va_list);
c906108c 201
9a4105ab
AC
202/* These three functions support getting lines of text from the user.
203 They are used in sequence. First deprecated_readline_begin_hook is
204 called with a text string that might be (for example) a message for
205 the user to type in a sequence of commands to be executed at a
206 breakpoint. If this function calls back to a GUI, it might take
207 this opportunity to pop up a text interaction window with this
208 message. Next, deprecated_readline_hook is called with a prompt
209 that is emitted prior to collecting the user input. It can be
210 called multiple times. Finally, deprecated_readline_end_hook is
211 called to notify the GUI that we are done with the interaction
212 window and it can close it. */
c906108c 213
a121b7c1 214void (*deprecated_readline_begin_hook) (const char *, ...);
38bcc89d 215char *(*deprecated_readline_hook) (const char *);
9a4105ab 216void (*deprecated_readline_end_hook) (void);
c906108c 217
6426a772 218/* Called as appropriate to notify the interface that we have attached
371d5dec 219 to or detached from an already running process. */
6426a772 220
9a4105ab
AC
221void (*deprecated_attach_hook) (void);
222void (*deprecated_detach_hook) (void);
6426a772 223
371d5dec
MS
224/* Called during long calculations to allow GUI to repair window
225 damage, and to check for stop buttons, etc... */
c906108c 226
9a4105ab 227void (*deprecated_interactive_hook) (void);
c906108c 228
371d5dec
MS
229/* Called when going to wait for the target. Usually allows the GUI
230 to run while waiting for target events. */
c906108c 231
9a4105ab 232ptid_t (*deprecated_target_wait_hook) (ptid_t ptid,
47608cb1
PA
233 struct target_waitstatus *status,
234 int options);
c906108c 235
371d5dec
MS
236/* Used by UI as a wrapper around command execution. May do various
237 things like enabling/disabling buttons, etc... */
c906108c 238
371d5dec 239void (*deprecated_call_command_hook) (struct cmd_list_element * c,
95a6b0a1 240 const char *cmd, int from_tty);
c906108c
SS
241
242/* Called when the current thread changes. Argument is thread id. */
243
9a4105ab 244void (*deprecated_context_hook) (int id);
c906108c 245
98d9f24e
PA
246/* The highest UI number ever assigned. */
247static int highest_ui_num;
248
249/* See top.h. */
250
895b8f30
TT
251ui::ui (FILE *instream_, FILE *outstream_, FILE *errstream_)
252 : next (nullptr),
253 num (++highest_ui_num),
254 call_readline (nullptr),
255 input_handler (nullptr),
256 command_editing (0),
257 interp_info (nullptr),
258 async (0),
259 secondary_prompt_depth (0),
260 stdin_stream (instream_),
261 instream (instream_),
262 outstream (outstream_),
263 errstream (errstream_),
264 input_fd (fileno (instream)),
265 input_interactive_p (ISATTY (instream)),
266 prompt_state (PROMPT_NEEDED),
267 m_gdb_stdout (new stdio_file (outstream)),
268 m_gdb_stdin (new stdio_file (instream)),
269 m_gdb_stderr (new stderr_file (errstream)),
270 m_gdb_stdlog (m_gdb_stderr),
271 m_current_uiout (nullptr)
98d9f24e 272{
895b8f30 273 buffer_init (&line_buffer);
98d9f24e
PA
274
275 if (ui_list == NULL)
895b8f30 276 ui_list = this;
98d9f24e
PA
277 else
278 {
279 struct ui *last;
280
281 for (last = ui_list; last->next != NULL; last = last->next)
282 ;
895b8f30 283 last->next = this;
98d9f24e 284 }
07169ff7
PA
285}
286
895b8f30 287ui::~ui ()
07169ff7
PA
288{
289 struct ui *ui, *uiprev;
290
291 uiprev = NULL;
292
293 for (ui = ui_list; ui != NULL; uiprev = ui, ui = ui->next)
895b8f30 294 if (ui == this)
07169ff7
PA
295 break;
296
297 gdb_assert (ui != NULL);
298
299 if (uiprev != NULL)
895b8f30 300 uiprev->next = next;
07169ff7 301 else
895b8f30 302 ui_list = next;
07169ff7 303
895b8f30
TT
304 delete m_gdb_stdin;
305 delete m_gdb_stdout;
306 delete m_gdb_stderr;
8194e927
SM
307}
308
60eb5395
PA
309/* Open file named NAME for read/write, making sure not to make it the
310 controlling terminal. */
311
6e7bc05c 312static gdb_file_up
60eb5395
PA
313open_terminal_stream (const char *name)
314{
315 int fd;
316
6e7bc05c 317 fd = gdb_open_cloexec (name, O_RDWR | O_NOCTTY, 0);
60eb5395
PA
318 if (fd < 0)
319 perror_with_name (_("opening terminal failed"));
320
6e7bc05c 321 return gdb_file_up (fdopen (fd, "w+"));
60eb5395
PA
322}
323
324/* Implementation of the "new-ui" command. */
325
326static void
32faf971 327new_ui_command (const char *args, int from_tty)
60eb5395 328{
6e7bc05c 329 gdb_file_up stream[3];
60eb5395 330 int i;
60eb5395 331 int argc;
60eb5395
PA
332 const char *interpreter_name;
333 const char *tty_name;
60eb5395
PA
334
335 dont_repeat ();
336
773a1edc
TT
337 gdb_argv argv (args);
338 argc = argv.count ();
60eb5395
PA
339
340 if (argc < 2)
65e65158 341 error (_("Usage: new-ui INTERPRETER TTY"));
60eb5395
PA
342
343 interpreter_name = argv[0];
344 tty_name = argv[1];
345
4b6749b9
TT
346 {
347 scoped_restore save_ui = make_scoped_restore (&current_ui);
8194e927 348
4b6749b9
TT
349 /* Open specified terminal, once for each of
350 stdin/stdout/stderr. */
351 for (i = 0; i < 3; i++)
6e7bc05c 352 stream[i] = open_terminal_stream (tty_name);
60eb5395 353
895b8f30
TT
354 std::unique_ptr<ui> ui
355 (new struct ui (stream[0].get (), stream[1].get (), stream[2].get ()));
60eb5395 356
4b6749b9 357 ui->async = 1;
60eb5395 358
895b8f30 359 current_ui = ui.get ();
60eb5395 360
4b6749b9 361 set_top_level_interpreter (interpreter_name);
60eb5395 362
4b6749b9 363 interp_pre_command_loop (top_level_interpreter ());
60eb5395 364
6e7bc05c
TT
365 /* Make sure the files are not closed. */
366 stream[0].release ();
367 stream[1].release ();
368 stream[2].release ();
369
895b8f30 370 ui.release ();
4b6749b9 371 }
60eb5395
PA
372
373 printf_unfiltered ("New UI allocated\n");
374}
375
c906108c
SS
376/* Handler for SIGHUP. */
377
378#ifdef SIGHUP
392a587b 379/* NOTE 1999-04-29: This function will be static again, once we modify
cd0fc7c3 380 gdb to use the event loop as the default command loop and we merge
c378eb4e 381 event-top.c into this file, top.c. */
b2cd6b29
JM
382/* static */ void
383quit_cover (void)
c906108c 384{
e360902b
PA
385 /* Stop asking user for confirmation --- we're exiting. This
386 prevents asking the user dumb questions. */
387 confirm = 0;
c5aa993b 388 quit_command ((char *) 0, 0);
c906108c
SS
389}
390#endif /* defined SIGHUP */
391\f
7a9dd1b2 392/* Line number we are currently in, in a file which is being sourced. */
392a587b 393/* NOTE 1999-04-29: This variable will be static again, once we modify
cd0fc7c3 394 gdb to use the event loop as the default command loop and we merge
c378eb4e 395 event-top.c into this file, top.c. */
cd0fc7c3 396/* static */ int source_line_number;
c906108c
SS
397
398/* Name of the file we are sourcing. */
392a587b 399/* NOTE 1999-04-29: This variable will be static again, once we modify
cd0fc7c3 400 gdb to use the event loop as the default command loop and we merge
c378eb4e 401 event-top.c into this file, top.c. */
05159abe 402/* static */ const char *source_file_name;
c906108c 403
c906108c
SS
404/* Read commands from STREAM. */
405void
fba45db2 406read_command_file (FILE *stream)
c906108c 407{
f38d3ad1 408 struct ui *ui = current_ui;
c906108c 409
3c9ebddd
TT
410 scoped_restore save_instream
411 = make_scoped_restore (&ui->instream, stream);
faa4ebe1
PA
412
413 /* Read commands from `instream' and execute them until end of file
414 or error reading instream. */
415
f38d3ad1 416 while (ui->instream != NULL && !feof (ui->instream))
faa4ebe1
PA
417 {
418 char *command;
419
420 /* Get a command-line. This calls the readline package. */
89fbedf3 421 command = command_line_input (NULL, NULL);
faa4ebe1
PA
422 if (command == NULL)
423 break;
424 command_handler (command);
425 }
c906108c
SS
426}
427\f
507f3c78 428void (*pre_init_ui_hook) (void);
c906108c 429
e41a3b1a 430#ifdef __MSDOS__
70976b65 431static void
e41a3b1a
AC
432do_chdir_cleanup (void *old_dir)
433{
f515a1d6 434 chdir ((const char *) old_dir);
b8c9b27d 435 xfree (old_dir);
e41a3b1a
AC
436}
437#endif
438
54f70bc1
TT
439scoped_value_mark
440prepare_execute_command ()
4e5d721f 441{
371d5dec
MS
442 /* With multiple threads running while the one we're examining is
443 stopped, the dcache can get stale without us being able to detect
444 it. For the duration of the command, though, use the dcache to
445 help things like backtrace. */
4e5d721f
DE
446 if (non_stop)
447 target_dcache_invalidate ();
028d0ed5 448
54f70bc1 449 return scoped_value_mark ();
4e5d721f
DE
450}
451
77cce10f
PA
452/* Tell the user if the language has changed (except first time) after
453 executing a command. */
454
455void
456check_frame_language_change (void)
457{
458 static int warned = 0;
7ff38b1c 459 struct frame_info *frame;
77cce10f
PA
460
461 /* First make sure that a new frame has been selected, in case the
462 command or the hooks changed the program state. */
7ff38b1c 463 frame = deprecated_safe_get_selected_frame ();
77cce10f
PA
464 if (current_language != expected_language)
465 {
466 if (language_mode == language_mode_auto && info_verbose)
467 {
468 language_info (1); /* Print what changed. */
469 }
470 warned = 0;
471 }
472
473 /* Warn the user if the working language does not match the language
474 of the current frame. Only warn the user if we are actually
475 running the program, i.e. there is a stack. */
476 /* FIXME: This should be cacheing the frame and only running when
477 the frame changes. */
478
479 if (has_stack_frames ())
480 {
481 enum language flang;
482
7ff38b1c 483 flang = get_frame_language (frame);
77cce10f
PA
484 if (!warned
485 && flang != language_unknown
486 && flang != current_language->la_language)
487 {
488 printf_filtered ("%s\n", lang_frame_mismatch_warn);
489 warned = 1;
490 }
491 }
492}
493
98880d46
PA
494/* See top.h. */
495
0b333c5e
PA
496void
497wait_sync_command_done (void)
498{
4295e285 499 /* Processing events may change the current UI. */
4b6749b9 500 scoped_restore save_ui = make_scoped_restore (&current_ui);
4295e285
PA
501 struct ui *ui = current_ui;
502
0b333c5e 503 while (gdb_do_one_event () >= 0)
4295e285 504 if (ui->prompt_state != PROMPT_BLOCKED)
0b333c5e
PA
505 break;
506}
507
508/* See top.h. */
509
98880d46
PA
510void
511maybe_wait_sync_command_done (int was_sync)
512{
513 /* If the interpreter is in sync mode (we're running a user
514 command's list, running command hooks or similars), and we
515 just ran a synchronous command that started the target, wait
516 for that command to end. */
3b12939d
PA
517 if (!current_ui->async
518 && !was_sync
519 && current_ui->prompt_state == PROMPT_BLOCKED)
0b333c5e 520 wait_sync_command_done ();
98880d46
PA
521}
522
85c4be7c
TT
523/* If not NULL, the arguments that should be passed if the current
524 command is repeated. */
525
526static const char *repeat_arguments;
527
528/* See command.h. */
529
530void
531set_repeat_arguments (const char *args)
532{
533 repeat_arguments = args;
534}
535
648bf667 536/* Execute the line P as a command, in the current user context.
d318976c 537 Pass FROM_TTY as second argument to the defining function. */
c906108c 538
d318976c 539void
95a6b0a1 540execute_command (const char *p, int from_tty)
c906108c 541{
54f70bc1 542 struct cleanup *cleanup_if_error;
52f0bd74 543 struct cmd_list_element *c;
95a6b0a1
TT
544 const char *line;
545 const char *cmd_start = p;
4e5d721f 546
353d1d73 547 cleanup_if_error = make_bpstat_clear_actions_cleanup ();
54f70bc1 548 scoped_value_mark cleanup = prepare_execute_command ();
c906108c 549
d318976c
FN
550 /* Force cleanup of any alloca areas if using C alloca instead of
551 a builtin alloca. */
552 alloca (0);
c906108c 553
d318976c
FN
554 /* This can happen when command_line_input hits end of file. */
555 if (p == NULL)
5fe41fbf 556 {
5ae85e44 557 discard_cleanups (cleanup_if_error);
5fe41fbf
TT
558 return;
559 }
c906108c 560
49d03eab 561 target_log_command (p);
8b93c638 562
d318976c
FN
563 while (*p == ' ' || *p == '\t')
564 p++;
565 if (*p)
8b93c638 566 {
6f937416 567 const char *cmd = p;
95a6b0a1 568 const char *arg;
3b12939d 569 int was_sync = current_ui->prompt_state == PROMPT_BLOCKED;
90e28950 570
d318976c 571 line = p;
8b93c638 572
16026cd7 573 /* If trace-commands is set then this will print this command. */
1263a9d5 574 print_command_trace ("%s", p);
16026cd7 575
6f937416 576 c = lookup_cmd (&cmd, cmdlist, "", 0, 1);
95a6b0a1 577 p = cmd;
8b93c638 578
85c4be7c
TT
579 scoped_restore save_repeat_args
580 = make_scoped_restore (&repeat_arguments, nullptr);
95a6b0a1 581 const char *args_pointer = p;
85c4be7c 582
d318976c
FN
583 /* Pass null arg rather than an empty one. */
584 arg = *p ? p : 0;
8b93c638 585
9f60d481
AC
586 /* FIXME: cagney/2002-02-02: The c->type test is pretty dodgy
587 while the is_complete_command(cfunc) test is just plain
588 bogus. They should both be replaced by a test of the form
589 c->strip_trailing_white_space_p. */
590 /* NOTE: cagney/2002-02-02: The function.cfunc in the below
591 can't be replaced with func. This is because it is the
592 cfunc, and not the func, that has the value that the
593 is_complete_command hack is testing for. */
594 /* Clear off trailing whitespace, except for set and complete
595 command. */
95a6b0a1 596 std::string without_whitespace;
d318976c
FN
597 if (arg
598 && c->type != set_cmd
bbaca940 599 && !is_complete_command (c))
8b93c638 600 {
95a6b0a1
TT
601 const char *old_end = arg + strlen (arg) - 1;
602 p = old_end;
d318976c
FN
603 while (p >= arg && (*p == ' ' || *p == '\t'))
604 p--;
95a6b0a1
TT
605 if (p != old_end)
606 {
607 without_whitespace = std::string (arg, p + 1);
608 arg = without_whitespace.c_str ();
609 }
8b93c638
JM
610 }
611
371d5dec 612 /* If this command has been pre-hooked, run the hook first. */
5913bcb0 613 execute_cmd_pre_hook (c);
c906108c 614
1f2bdf09 615 if (c->deprecated_warn_user)
6f937416 616 deprecated_cmd_warning (line);
c906108c 617
7d74f244 618 /* c->user_commands would be NULL in the case of a python command. */
fe978cb0 619 if (c->theclass == class_user && c->user_commands)
d318976c 620 execute_user_command (c, arg);
5b9afe8a
YQ
621 else if (c->type == set_cmd)
622 do_set_command (arg, from_tty, c);
623 else if (c->type == show_cmd)
624 do_show_command (arg, from_tty, c);
f436dd25 625 else if (!cmd_func_p (c))
8a3fe4f8 626 error (_("That is not a command, just a help topic."));
9a4105ab 627 else if (deprecated_call_command_hook)
050a2e1d 628 deprecated_call_command_hook (c, arg, from_tty);
d318976c 629 else
050a2e1d 630 cmd_func (c, arg, from_tty);
b4a14fd0 631
98880d46 632 maybe_wait_sync_command_done (was_sync);
b4a14fd0 633
371d5dec 634 /* If this command has been post-hooked, run the hook last. */
5913bcb0 635 execute_cmd_post_hook (c);
c906108c 636
95a6b0a1 637 if (repeat_arguments != NULL && cmd_start == saved_command_line)
85c4be7c
TT
638 {
639 gdb_assert (strlen (args_pointer) >= strlen (repeat_arguments));
95a6b0a1
TT
640 strcpy (saved_command_line + (args_pointer - cmd_start),
641 repeat_arguments);
85c4be7c 642 }
c906108c
SS
643 }
644
0ca1fc29
JB
645 /* Only perform the frame-language-change check if the command
646 we just finished executing did not resume the inferior's execution.
647 If it did resume the inferior, we will do that check after
648 the inferior stopped. */
00431a78 649 if (has_stack_frames () && inferior_thread ()->state != THREAD_RUNNING)
0ca1fc29 650 check_frame_language_change ();
028d0ed5 651
353d1d73 652 discard_cleanups (cleanup_if_error);
c906108c
SS
653}
654
5da1313b
JK
655/* Run execute_command for P and FROM_TTY. Capture its output into the
656 returned string, do not display it to the screen. BATCH_FLAG will be
657 temporarily set to true. */
658
db1ec11f 659std::string
95a6b0a1 660execute_command_to_string (const char *p, int from_tty)
5da1313b 661{
5da1313b
JK
662 /* GDB_STDOUT should be better already restored during these
663 restoration callbacks. */
b95de2b7 664 set_batch_flag_and_restore_page_info save_page_info;
5da1313b 665
b7b633e9 666 scoped_restore save_async = make_scoped_restore (&current_ui->async, 0);
b4a14fd0 667
d7e74731 668 string_file str_file;
5da1313b 669
ca5909c7
TT
670 {
671 current_uiout->redirect (&str_file);
672 ui_out_redirect_pop redirect_popper (current_uiout);
673
674 scoped_restore save_stdout
675 = make_scoped_restore (&gdb_stdout, &str_file);
676 scoped_restore save_stderr
677 = make_scoped_restore (&gdb_stderr, &str_file);
678 scoped_restore save_stdlog
679 = make_scoped_restore (&gdb_stdlog, &str_file);
680 scoped_restore save_stdtarg
681 = make_scoped_restore (&gdb_stdtarg, &str_file);
682 scoped_restore save_stdtargerr
683 = make_scoped_restore (&gdb_stdtargerr, &str_file);
684
685 execute_command (p, from_tty);
686 }
5da1313b 687
d7e74731 688 return std::move (str_file.string ());
5da1313b
JK
689}
690
d318976c 691\f
47a80e90
TT
692/* When nonzero, cause dont_repeat to do nothing. This should only be
693 set via prevent_dont_repeat. */
694
695static int suppress_dont_repeat = 0;
696
d318976c 697/* Commands call this if they do not want to be repeated by null lines. */
9e0b60a8 698
d318976c
FN
699void
700dont_repeat (void)
9e0b60a8 701{
f38d3ad1
PA
702 struct ui *ui = current_ui;
703
47a80e90 704 if (suppress_dont_repeat || server_command)
d318976c 705 return;
9e0b60a8 706
d318976c 707 /* If we aren't reading from standard input, we are saving the last
371d5dec
MS
708 thing read from stdin in line and don't want to delete it. Null
709 lines won't repeat here in any case. */
268a799a 710 if (ui->instream == ui->stdin_stream)
dc7eb48e 711 *saved_command_line = 0;
9e0b60a8 712}
47a80e90
TT
713
714/* Prevent dont_repeat from working, and return a cleanup that
715 restores the previous state. */
716
1ac32117 717scoped_restore_tmpl<int>
47a80e90
TT
718prevent_dont_repeat (void)
719{
1ac32117 720 return make_scoped_restore (&suppress_dont_repeat, 1);
47a80e90
TT
721}
722
d318976c
FN
723\f
724/* Read a line from the stream "instream" without command line editing.
9e0b60a8 725
7a3bde34 726 It prints PROMPT once at the start.
d318976c
FN
727 Action is compatible with "readline", e.g. space for the result is
728 malloc'd and should be freed by the caller.
9e0b60a8 729
d318976c 730 A NULL return means end of file. */
c5c136ea
PA
731
732static char *
7a3bde34 733gdb_readline_no_editing (const char *prompt)
9e0b60a8 734{
7a3bde34 735 struct buffer line_buffer;
f38d3ad1 736 struct ui *ui = current_ui;
3212b858
PA
737 /* Read from stdin if we are executing a user defined command. This
738 is the right thing for prompt_for_continue, at least. */
f38d3ad1 739 FILE *stream = ui->instream != NULL ? ui->instream : stdin;
3212b858 740 int fd = fileno (stream);
9e0b60a8 741
7a3bde34
PA
742 buffer_init (&line_buffer);
743
744 if (prompt != NULL)
9e0b60a8 745 {
d318976c
FN
746 /* Don't use a _filtered function here. It causes the assumed
747 character position to be off, since the newline we read from
748 the user is not accounted for. */
7a3bde34 749 fputs_unfiltered (prompt, gdb_stdout);
9e0b60a8
JM
750 gdb_flush (gdb_stdout);
751 }
752
9e0b60a8
JM
753 while (1)
754 {
7a3bde34 755 int c;
3212b858 756 fd_set readfds;
7a3bde34 757
3212b858
PA
758 QUIT;
759
760 /* Wait until at least one byte of data is available. Control-C
f0881b37 761 can interrupt interruptible_select, but not fgetc. */
3212b858
PA
762 FD_ZERO (&readfds);
763 FD_SET (fd, &readfds);
f0881b37 764 if (interruptible_select (fd + 1, &readfds, NULL, NULL, NULL) == -1)
3212b858
PA
765 {
766 if (errno == EINTR)
767 {
768 /* If this was ctrl-c, the QUIT above handles it. */
769 continue;
770 }
771 perror_with_name (("select"));
772 }
773
774 c = fgetc (stream);
9e0b60a8 775
d318976c 776 if (c == EOF)
9e0b60a8 777 {
7a3bde34 778 if (line_buffer.used_size > 0)
d318976c
FN
779 /* The last line does not end with a newline. Return it, and
780 if we are called again fgetc will still return EOF and
781 we'll return NULL then. */
9e0b60a8 782 break;
7a3bde34 783 xfree (buffer_finish (&line_buffer));
d318976c 784 return NULL;
9e0b60a8 785 }
c5aa993b 786
d318976c 787 if (c == '\n')
9e0b60a8 788 {
7a3bde34
PA
789 if (line_buffer.used_size > 0
790 && line_buffer.buffer[line_buffer.used_size - 1] == '\r')
791 line_buffer.used_size--;
d318976c 792 break;
9e0b60a8 793 }
9e0b60a8 794
7a3bde34 795 buffer_grow_char (&line_buffer, c);
9e0b60a8
JM
796 }
797
7a3bde34
PA
798 buffer_grow_char (&line_buffer, '\0');
799 return buffer_finish (&line_buffer);
9e0b60a8
JM
800}
801
d318976c
FN
802/* Variables which control command line editing and history
803 substitution. These variables are given default values at the end
804 of this file. */
805static int command_editing_p;
920d2a44 806
d318976c
FN
807/* NOTE 1999-04-29: This variable will be static again, once we modify
808 gdb to use the event loop as the default command loop and we merge
c378eb4e 809 event-top.c into this file, top.c. */
920d2a44 810
d318976c 811/* static */ int history_expansion_p;
920d2a44 812
d318976c 813static int write_history_p;
920d2a44
AC
814static void
815show_write_history_p (struct ui_file *file, int from_tty,
816 struct cmd_list_element *c, const char *value)
817{
818 fprintf_filtered (file, _("Saving of the history record on exit is %s.\n"),
819 value);
820}
821
840a9a1f 822/* The variable associated with the "set/show history size"
ebfd00d2
PP
823 command. The value -1 means unlimited, and -2 means undefined. */
824static int history_size_setshow_var = -2;
840a9a1f 825
920d2a44
AC
826static void
827show_history_size (struct ui_file *file, int from_tty,
828 struct cmd_list_element *c, const char *value)
829{
830 fprintf_filtered (file, _("The size of the command history is %s.\n"),
831 value);
832}
833
fc637f04
PP
834/* Variable associated with the "history remove-duplicates" option.
835 The value -1 means unlimited. */
836static int history_remove_duplicates = 0;
837
838static void
839show_history_remove_duplicates (struct ui_file *file, int from_tty,
840 struct cmd_list_element *c, const char *value)
841{
842 fprintf_filtered (file,
843 _("The number of history entries to look back at for "
844 "duplicates is %s.\n"),
845 value);
846}
847
d318976c 848static char *history_filename;
920d2a44
AC
849static void
850show_history_filename (struct ui_file *file, int from_tty,
851 struct cmd_list_element *c, const char *value)
852{
3e43a32a
MS
853 fprintf_filtered (file, _("The filename in which to record "
854 "the command history is \"%s\".\n"),
920d2a44
AC
855 value);
856}
9e0b60a8 857
b4f5539f 858/* This is like readline(), but it has some gdb-specific behavior.
2e03ee74 859 gdb may want readline in both the synchronous and async modes during
b4f5539f
TT
860 a single gdb invocation. At the ordinary top-level prompt we might
861 be using the async readline. That means we can't use
862 rl_pre_input_hook, since it doesn't work properly in async mode.
863 However, for a secondary prompt (" >", such as occurs during a
2e03ee74
DJ
864 `define'), gdb wants a synchronous response.
865
866 We used to call readline() directly, running it in synchronous
867 mode. But mixing modes this way is not supported, and as of
868 readline 5.x it no longer works; the arrow keys come unbound during
869 the synchronous call. So we make a nested call into the event
870 loop. That's what gdb_readline_wrapper is for. */
871
872/* A flag set as soon as gdb_readline_wrapper_line is called; we can't
873 rely on gdb_readline_wrapper_result, which might still be NULL if
874 the user types Control-D for EOF. */
875static int gdb_readline_wrapper_done;
876
877/* The result of the current call to gdb_readline_wrapper, once a newline
878 is seen. */
879static char *gdb_readline_wrapper_result;
880
881/* Any intercepted hook. Operate-and-get-next sets this, expecting it
882 to be called after the newline is processed (which will redisplay
883 the prompt). But in gdb_readline_wrapper we will not get a new
884 prompt until the next call, or until we return to the event loop.
885 So we disable this hook around the newline and restore it before we
886 return. */
887static void (*saved_after_char_processing_hook) (void);
888
948578a9 889
948578a9
PP
890/* See top.h. */
891
892int
dbf30ca3 893gdb_in_secondary_prompt_p (struct ui *ui)
948578a9 894{
dbf30ca3 895 return ui->secondary_prompt_depth > 0;
948578a9
PP
896}
897
898
2e03ee74
DJ
899/* This function is called when readline has seen a complete line of
900 text. */
901
902static void
903gdb_readline_wrapper_line (char *line)
904{
905 gdb_assert (!gdb_readline_wrapper_done);
906 gdb_readline_wrapper_result = line;
907 gdb_readline_wrapper_done = 1;
908
909 /* Prevent operate-and-get-next from acting too early. */
910 saved_after_char_processing_hook = after_char_processing_hook;
911 after_char_processing_hook = NULL;
1b05479a
DJ
912
913 /* Prevent parts of the prompt from being redisplayed if annotations
0017922d 914 are enabled, and readline's state getting out of sync. We'll
d3d4baed
PA
915 reinstall the callback handler, which puts the terminal in raw
916 mode (or in readline lingo, in prepped state), when we're next
917 ready to process user input, either in display_gdb_prompt, or if
918 we're handling an asynchronous target event and running in the
919 background, just before returning to the event loop to process
920 further input (or more target events). */
3c216924 921 if (current_ui->command_editing)
d3d4baed 922 gdb_rl_callback_handler_remove ();
2e03ee74
DJ
923}
924
1dbeed45 925class gdb_readline_wrapper_cleanup
2e03ee74 926{
1dbeed45
TT
927public:
928 gdb_readline_wrapper_cleanup ()
929 : m_handler_orig (current_ui->input_handler),
930 m_already_prompted_orig (current_ui->command_editing
931 ? rl_already_prompted : 0),
932 m_target_is_async_orig (target_is_async_p ()),
933 m_save_ui (&current_ui)
934 {
935 current_ui->input_handler = gdb_readline_wrapper_line;
936 current_ui->secondary_prompt_depth++;
2e03ee74 937
1dbeed45
TT
938 if (m_target_is_async_orig)
939 target_async (0);
940 }
2e03ee74 941
1dbeed45
TT
942 ~gdb_readline_wrapper_cleanup ()
943 {
944 struct ui *ui = current_ui;
0017922d 945
1dbeed45
TT
946 if (ui->command_editing)
947 rl_already_prompted = m_already_prompted_orig;
0017922d 948
1dbeed45
TT
949 gdb_assert (ui->input_handler == gdb_readline_wrapper_line);
950 ui->input_handler = m_handler_orig;
2e03ee74 951
1dbeed45
TT
952 /* Don't restore our input handler in readline yet. That would make
953 readline prep the terminal (putting it in raw mode), while the
954 line we just read may trigger execution of a command that expects
955 the terminal in the default cooked/canonical mode, such as e.g.,
956 running Python's interactive online help utility. See
957 gdb_readline_wrapper_line for when we'll reinstall it. */
2e03ee74 958
1dbeed45
TT
959 gdb_readline_wrapper_result = NULL;
960 gdb_readline_wrapper_done = 0;
961 ui->secondary_prompt_depth--;
962 gdb_assert (ui->secondary_prompt_depth >= 0);
93d6eb10 963
1dbeed45
TT
964 after_char_processing_hook = saved_after_char_processing_hook;
965 saved_after_char_processing_hook = NULL;
2e03ee74 966
1dbeed45
TT
967 if (m_target_is_async_orig)
968 target_async (1);
969 }
2e03ee74 970
1dbeed45 971 DISABLE_COPY_AND_ASSIGN (gdb_readline_wrapper_cleanup);
2e03ee74 972
1dbeed45 973private:
2e03ee74 974
1dbeed45
TT
975 void (*m_handler_orig) (char *);
976 int m_already_prompted_orig;
93d6eb10 977
1dbeed45
TT
978 /* Whether the target was async. */
979 int m_target_is_async_orig;
2e03ee74 980
4295e285 981 /* Processing events may change the current UI. */
1dbeed45
TT
982 scoped_restore_tmpl<struct ui *> m_save_ui;
983};
984
985char *
986gdb_readline_wrapper (const char *prompt)
987{
988 struct ui *ui = current_ui;
4295e285 989
1dbeed45 990 gdb_readline_wrapper_cleanup cleanup;
93d6eb10 991
6e5d74e7
PA
992 /* Display our prompt and prevent double prompt display. Don't pass
993 down a NULL prompt, since that has special meaning for
994 display_gdb_prompt -- it indicates a request to print the primary
995 prompt, while we want a secondary prompt here. */
996 display_gdb_prompt (prompt != NULL ? prompt : "");
3c216924
PA
997 if (ui->command_editing)
998 rl_already_prompted = 1;
2e03ee74 999
362646f5 1000 if (after_char_processing_hook)
2e03ee74
DJ
1001 (*after_char_processing_hook) ();
1002 gdb_assert (after_char_processing_hook == NULL);
1003
e0dd0826 1004 while (gdb_do_one_event () >= 0)
2e03ee74
DJ
1005 if (gdb_readline_wrapper_done)
1006 break;
b4f5539f 1007
1dbeed45 1008 return gdb_readline_wrapper_result;
b4f5539f
TT
1009}
1010
9e0b60a8 1011\f
467d8519
TT
1012/* The current saved history number from operate-and-get-next.
1013 This is -1 if not valid. */
1014static int operate_saved_history = -1;
1015
1016/* This is put on the appropriate hook and helps operate-and-get-next
1017 do its work. */
b9362cc7 1018static void
5ae5f592 1019gdb_rl_operate_and_get_next_completion (void)
467d8519
TT
1020{
1021 int delta = where_history () - operate_saved_history;
5d502164 1022
467d8519
TT
1023 /* The `key' argument to rl_get_previous_history is ignored. */
1024 rl_get_previous_history (delta, 0);
1025 operate_saved_history = -1;
1026
1027 /* readline doesn't automatically update the display for us. */
12f4afab 1028 rl_redisplay ();
467d8519
TT
1029
1030 after_char_processing_hook = NULL;
1031 rl_pre_input_hook = NULL;
1032}
1033
1034/* This is a gdb-local readline command handler. It accepts the
1035 current command line (like RET does) and, if this command was taken
1036 from the history, arranges for the next command in the history to
1037 appear on the command line when the prompt returns.
1038 We ignore the arguments. */
1039static int
1040gdb_rl_operate_and_get_next (int count, int key)
1041{
b5686e99
MK
1042 int where;
1043
362646f5
AC
1044 /* Use the async hook. */
1045 after_char_processing_hook = gdb_rl_operate_and_get_next_completion;
467d8519 1046
b5686e99
MK
1047 /* Find the current line, and find the next line to use. */
1048 where = where_history();
1049
1fb2e2b5
PA
1050 if ((history_is_stifled () && (history_length >= history_max_entries))
1051 || (where >= history_length - 1))
b5686e99
MK
1052 operate_saved_history = where;
1053 else
1054 operate_saved_history = where + 1;
1055
467d8519
TT
1056 return rl_newline (1, key);
1057}
08b13bdd
PP
1058
1059/* Number of user commands executed during this session. */
1060
1061static int command_count = 0;
1062
1063/* Add the user command COMMAND to the input history list. */
1064
1065void
1066gdb_add_history (const char *command)
1067{
08b13bdd 1068 command_count++;
fc637f04
PP
1069
1070 if (history_remove_duplicates != 0)
1071 {
1072 int lookbehind;
1073 int lookbehind_threshold;
1074
1075 /* The lookbehind threshold for finding a duplicate history entry is
1076 bounded by command_count because we can't meaningfully delete
1077 history entries that are already stored in the history file since
1078 the history file is appended to. */
1079 if (history_remove_duplicates == -1
1080 || history_remove_duplicates > command_count)
1081 lookbehind_threshold = command_count;
1082 else
1083 lookbehind_threshold = history_remove_duplicates;
1084
1085 using_history ();
1086 for (lookbehind = 0; lookbehind < lookbehind_threshold; lookbehind++)
1087 {
1088 HIST_ENTRY *temp = previous_history ();
1089
1090 if (temp == NULL)
1091 break;
1092
1093 if (strcmp (temp->line, command) == 0)
1094 {
1095 HIST_ENTRY *prev = remove_history (where_history ());
1096 command_count--;
1097 free_history_entry (prev);
1098 break;
1099 }
1100 }
1101 using_history ();
1102 }
1103
1104 add_history (command);
08b13bdd
PP
1105}
1106
1107/* Safely append new history entries to the history file in a corruption-free
1108 way using an intermediate local history file. */
1109
1110static void
1111gdb_safe_append_history (void)
1112{
1113 int ret, saved_errno;
08b13bdd 1114
8cff8730
TT
1115 std::string local_history_filename
1116 = string_printf ("%s-gdb%ld~", history_filename, (long) getpid ());
08b13bdd 1117
8cff8730 1118 ret = rename (history_filename, local_history_filename.c_str ());
08b13bdd
PP
1119 saved_errno = errno;
1120 if (ret < 0 && saved_errno != ENOENT)
1121 {
1122 warning (_("Could not rename %s to %s: %s"),
8cff8730 1123 history_filename, local_history_filename.c_str (),
08b13bdd
PP
1124 safe_strerror (saved_errno));
1125 }
1126 else
1127 {
1128 if (ret < 0)
1129 {
1130 /* If the rename failed with ENOENT then either the global history
1131 file never existed in the first place or another GDB process is
1132 currently appending to it (and has thus temporarily renamed it).
1133 Since we can't distinguish between these two cases, we have to
1134 conservatively assume the first case and therefore must write out
1135 (not append) our known history to our local history file and try
1136 to move it back anyway. Otherwise a global history file would
1137 never get created! */
1138 gdb_assert (saved_errno == ENOENT);
8cff8730 1139 write_history (local_history_filename.c_str ());
08b13bdd
PP
1140 }
1141 else
1142 {
8cff8730 1143 append_history (command_count, local_history_filename.c_str ());
2093d2d3 1144 if (history_is_stifled ())
8cff8730
TT
1145 history_truncate_file (local_history_filename.c_str (),
1146 history_max_entries);
08b13bdd
PP
1147 }
1148
8cff8730 1149 ret = rename (local_history_filename.c_str (), history_filename);
08b13bdd
PP
1150 saved_errno = errno;
1151 if (ret < 0 && saved_errno != EEXIST)
1152 warning (_("Could not rename %s to %s: %s"),
8cff8730 1153 local_history_filename.c_str (), history_filename,
08b13bdd
PP
1154 safe_strerror (saved_errno));
1155 }
08b13bdd
PP
1156}
1157
b69d38af
PA
1158/* Read one line from the command input stream `instream' into a local
1159 static buffer. The buffer is made bigger as necessary. Returns
1160 the address of the start of the line.
9e0b60a8 1161
d318976c 1162 NULL is returned for end of file.
9e0b60a8 1163
b69d38af
PA
1164 This routine either uses fancy command line editing or simple input
1165 as the user has requested. */
10689f25 1166
d318976c 1167char *
89fbedf3 1168command_line_input (const char *prompt_arg, const char *annotation_suffix)
9e0b60a8 1169{
b69d38af
PA
1170 static struct buffer cmd_line_buffer;
1171 static int cmd_line_buffer_initialized;
f38d3ad1 1172 struct ui *ui = current_ui;
38bcc89d 1173 const char *prompt = prompt_arg;
b69d38af 1174 char *cmd;
268a799a 1175 int from_tty = ui->instream == ui->stdin_stream;
d318976c
FN
1176
1177 /* The annotation suffix must be non-NULL. */
1178 if (annotation_suffix == NULL)
1179 annotation_suffix = "";
9e0b60a8 1180
268a799a 1181 if (from_tty && annotation_level > 1)
d318976c 1182 {
38bcc89d
SM
1183 char *local_prompt;
1184
224c3ddb
SM
1185 local_prompt
1186 = (char *) alloca ((prompt == NULL ? 0 : strlen (prompt))
1187 + strlen (annotation_suffix) + 40);
38bcc89d 1188 if (prompt == NULL)
d318976c
FN
1189 local_prompt[0] = '\0';
1190 else
38bcc89d 1191 strcpy (local_prompt, prompt);
d318976c
FN
1192 strcat (local_prompt, "\n\032\032");
1193 strcat (local_prompt, annotation_suffix);
1194 strcat (local_prompt, "\n");
38bcc89d
SM
1195
1196 prompt = local_prompt;
d318976c 1197 }
9e0b60a8 1198
b69d38af 1199 if (!cmd_line_buffer_initialized)
9e0b60a8 1200 {
b69d38af
PA
1201 buffer_init (&cmd_line_buffer);
1202 cmd_line_buffer_initialized = 1;
9e0b60a8 1203 }
9e0b60a8 1204
b69d38af
PA
1205 /* Starting a new command line. */
1206 cmd_line_buffer.used_size = 0;
9e0b60a8 1207
6aa899ce 1208#ifdef SIGTSTP
d318976c 1209 if (job_control)
6aa899ce 1210 signal (SIGTSTP, handle_sigtstp);
d318976c
FN
1211#endif
1212
1213 while (1)
9e0b60a8 1214 {
b69d38af
PA
1215 char *rl;
1216
371d5dec
MS
1217 /* Make sure that all output has been output. Some machines may
1218 let you get away with leaving out some of the gdb_flush, but
1219 not all. */
d318976c
FN
1220 wrap_here ("");
1221 gdb_flush (gdb_stdout);
1222 gdb_flush (gdb_stderr);
1223
1224 if (source_file_name != NULL)
637537d0 1225 ++source_line_number;
d318976c 1226
268a799a 1227 if (from_tty && annotation_level > 1)
d318976c 1228 {
306d9ac5
DC
1229 puts_unfiltered ("\n\032\032pre-");
1230 puts_unfiltered (annotation_suffix);
1231 puts_unfiltered ("\n");
d318976c
FN
1232 }
1233
1234 /* Don't use fancy stuff if not talking to stdin. */
268a799a
PA
1235 if (deprecated_readline_hook
1236 && from_tty
1237 && input_interactive_p (current_ui))
d318976c 1238 {
38bcc89d 1239 rl = (*deprecated_readline_hook) (prompt);
d318976c 1240 }
268a799a
PA
1241 else if (command_editing_p
1242 && from_tty
1243 && input_interactive_p (current_ui))
d318976c 1244 {
38bcc89d 1245 rl = gdb_readline_wrapper (prompt);
d318976c 1246 }
9e0b60a8 1247 else
d318976c 1248 {
c5c136ea 1249 rl = gdb_readline_no_editing (prompt);
d318976c 1250 }
9e0b60a8 1251
b69d38af 1252 cmd = handle_line_of_input (&cmd_line_buffer, rl,
89fbedf3 1253 0, annotation_suffix);
b69d38af 1254 if (cmd == (char *) EOF)
d318976c 1255 {
b69d38af 1256 cmd = NULL;
d318976c 1257 break;
9e0b60a8 1258 }
b69d38af 1259 if (cmd != NULL)
d318976c 1260 break;
9e0b60a8 1261
6e5d74e7
PA
1262 /* Got partial input. I.e., got a line that ends with a
1263 continuation character (backslash). Suppress printing the
1264 prompt again. */
38bcc89d 1265 prompt = NULL;
d318976c 1266 }
9e0b60a8 1267
6aa899ce 1268#ifdef SIGTSTP
d318976c 1269 if (job_control)
6aa899ce 1270 signal (SIGTSTP, SIG_DFL);
d318976c 1271#endif
9e0b60a8 1272
b69d38af 1273 return cmd;
9e0b60a8
JM
1274}
1275\f
c61b06a1 1276/* See top.h. */
9e0b60a8 1277void
c61b06a1 1278print_gdb_version (struct ui_file *stream, bool interactive)
9e0b60a8
JM
1279{
1280 /* From GNU coding standards, first line is meant to be easy for a
1281 program to parse, and is just canonical program name and version
371d5dec 1282 number, which starts after last space. */
9e0b60a8 1283
c16158bc 1284 fprintf_filtered (stream, "GNU gdb %s%s\n", PKGVERSION, version);
9e0b60a8 1285
371d5dec 1286 /* Second line is a copyright notice. */
9e0b60a8 1287
3e43a32a 1288 fprintf_filtered (stream,
82e1e79a 1289 "Copyright (C) 2018 Free Software Foundation, Inc.\n");
9e0b60a8
JM
1290
1291 /* Following the copyright is a brief statement that the program is
1292 free software, that users are free to copy and change it on
1293 certain conditions, that it is covered by the GNU GPL, and that
371d5dec 1294 there is no warranty. */
9e0b60a8
JM
1295
1296 fprintf_filtered (stream, "\
3e43a32a
MS
1297License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>\
1298\nThis is free software: you are free to change and redistribute it.\n\
c61b06a1
TT
1299There is NO WARRANTY, to the extent permitted by law.");
1300
1301 if (!interactive)
1302 return;
1303
1304 fprintf_filtered (stream, ("\nType \"show copying\" and "
1305 "\"show warranty\" for details.\n"));
9e0b60a8 1306
371d5dec 1307 /* After the required info we print the configuration information. */
9e0b60a8
JM
1308
1309 fprintf_filtered (stream, "This GDB was configured as \"");
6314a349 1310 if (strcmp (host_name, target_name) != 0)
9e0b60a8 1311 {
3e43a32a
MS
1312 fprintf_filtered (stream, "--host=%s --target=%s",
1313 host_name, target_name);
9e0b60a8
JM
1314 }
1315 else
1316 {
1317 fprintf_filtered (stream, "%s", host_name);
1318 }
c61b06a1
TT
1319 fprintf_filtered (stream, "\".\n");
1320
1321 fprintf_filtered (stream, _("Type \"show configuration\" "
1322 "for configuration details.\n"));
c16158bc
JM
1323
1324 if (REPORT_BUGS_TO[0])
1325 {
6eaaf48b 1326 fprintf_filtered (stream,
c61b06a1 1327 _("For bug reporting instructions, please see:\n"));
1cf55f60 1328 fprintf_filtered (stream, "%s.\n", REPORT_BUGS_TO);
c16158bc 1329 }
1cf55f60
PM
1330 fprintf_filtered (stream,
1331 _("Find the GDB manual and other documentation \
c61b06a1
TT
1332resources online at:\n <http://www.gnu.org/software/gdb/documentation/>."));
1333 fprintf_filtered (stream, "\n\n");
1cf55f60
PM
1334 fprintf_filtered (stream, _("For help, type \"help\".\n"));
1335 fprintf_filtered (stream, _("Type \"apropos word\" to search for \
af4c453a 1336commands related to \"word\"."));
9e0b60a8 1337}
6eaaf48b
EZ
1338
1339/* Print the details of GDB build-time configuration. */
1340void
1341print_gdb_configuration (struct ui_file *stream)
1342{
1343 fprintf_filtered (stream, _("\
1344This GDB was configured as follows:\n\
1345 configure --host=%s --target=%s\n\
1346"), host_name, target_name);
1347 fprintf_filtered (stream, _("\
1348 --with-auto-load-dir=%s\n\
1349 --with-auto-load-safe-path=%s\n\
1350"), AUTO_LOAD_DIR, AUTO_LOAD_SAFE_PATH);
1351#if HAVE_LIBEXPAT
1352 fprintf_filtered (stream, _("\
1353 --with-expat\n\
1354"));
1355#else
1356 fprintf_filtered (stream, _("\
1357 --without-expat\n\
1358"));
1359#endif
1360 if (GDB_DATADIR[0])
1361 fprintf_filtered (stream, _("\
1362 --with-gdb-datadir=%s%s\n\
1363"), GDB_DATADIR, GDB_DATADIR_RELOCATABLE ? " (relocatable)" : "");
1364#ifdef ICONV_BIN
1365 fprintf_filtered (stream, _("\
1366 --with-iconv-bin=%s%s\n\
1367"), ICONV_BIN, ICONV_BIN_RELOCATABLE ? " (relocatable)" : "");
1368#endif
1369 if (JIT_READER_DIR[0])
1370 fprintf_filtered (stream, _("\
1371 --with-jit-reader-dir=%s%s\n\
1372"), JIT_READER_DIR, JIT_READER_DIR_RELOCATABLE ? " (relocatable)" : "");
1373#if HAVE_LIBUNWIND_IA64_H
1374 fprintf_filtered (stream, _("\
1375 --with-libunwind-ia64\n\
1376"));
1377#else
1378 fprintf_filtered (stream, _("\
1379 --without-libunwind-ia64\n\
1380"));
1381#endif
1382#if HAVE_LIBLZMA
1383 fprintf_filtered (stream, _("\
1384 --with-lzma\n\
1385"));
1386#else
1387 fprintf_filtered (stream, _("\
1388 --without-lzma\n\
1389"));
1390#endif
9bd8e0b0
EZ
1391#if HAVE_LIBBABELTRACE
1392 fprintf_filtered (stream, _("\
1393 --with-babeltrace\n\
1394"));
1395#else
1396 fprintf_filtered (stream, _("\
1397 --without-babeltrace\n\
1398"));
1399#endif
1400#if HAVE_LIBIPT
1401 fprintf_filtered (stream, _("\
1402 --with-intel-pt\n\
1403"));
1404#else
1405 fprintf_filtered (stream, _("\
1406 --without-intel-pt\n\
1407"));
1408#endif
1409#if HAVE_LIBMCHECK
1410 fprintf_filtered (stream, _("\
1411 --enable-libmcheck\n\
1412"));
1413#else
1414 fprintf_filtered (stream, _("\
1415 --disable-libmcheck\n\
1416"));
1417#endif
1418#if HAVE_LIBMPFR
1419 fprintf_filtered (stream, _("\
1420 --with-mpfr\n\
1421"));
1422#else
1423 fprintf_filtered (stream, _("\
1424 --without-mpfr\n\
1425"));
1426#endif
6eaaf48b
EZ
1427#ifdef WITH_PYTHON_PATH
1428 fprintf_filtered (stream, _("\
1429 --with-python=%s%s\n\
1430"), WITH_PYTHON_PATH, PYTHON_PATH_RELOCATABLE ? " (relocatable)" : "");
50c7c5b8
ДП
1431#else
1432 fprintf_filtered (stream, _("\
1433 --without-python\n\
1434"));
6eaaf48b 1435#endif
97d66cc6
EZ
1436#if HAVE_GUILE
1437 fprintf_filtered (stream, _("\
1438 --with-guile\n\
1439"));
1440#else
1441 fprintf_filtered (stream, _("\
1442 --without-guile\n\
1443"));
1444#endif
6eaaf48b
EZ
1445#ifdef RELOC_SRCDIR
1446 fprintf_filtered (stream, _("\
1447 --with-relocated-sources=%s\n\
1448"), RELOC_SRCDIR);
1449#endif
1450 if (DEBUGDIR[0])
1451 fprintf_filtered (stream, _("\
1452 --with-separate-debug-dir=%s%s\n\
1453"), DEBUGDIR, DEBUGDIR_RELOCATABLE ? " (relocatable)" : "");
1454 if (TARGET_SYSTEM_ROOT[0])
1455 fprintf_filtered (stream, _("\
1456 --with-sysroot=%s%s\n\
1457"), TARGET_SYSTEM_ROOT, TARGET_SYSTEM_ROOT_RELOCATABLE ? " (relocatable)" : "");
1458 if (SYSTEM_GDBINIT[0])
1459 fprintf_filtered (stream, _("\
1460 --with-system-gdbinit=%s%s\n\
1461"), SYSTEM_GDBINIT, SYSTEM_GDBINIT_RELOCATABLE ? " (relocatable)" : "");
48d1d6f5
EZ
1462 /* We assume "relocatable" will be printed at least once, thus we always
1463 print this text. It's a reasonably safe assumption for now. */
1464 fprintf_filtered (stream, _("\n\
1465(\"Relocatable\" means the directory can be moved with the GDB installation\n\
1466tree, and GDB will still find it.)\n\
1467"));
6eaaf48b 1468}
9e0b60a8 1469\f
95298e72 1470
ab821bc6
PA
1471/* The current top level prompt, settable with "set prompt", and/or
1472 with the python `gdb.prompt_hook' hook. */
1473static char *top_prompt;
9e0b60a8 1474
ab821bc6 1475/* Access method for the GDB prompt string. */
95298e72
PM
1476
1477char *
ab821bc6 1478get_prompt (void)
95298e72 1479{
ab821bc6 1480 return top_prompt;
95298e72
PM
1481}
1482
ab821bc6 1483/* Set method for the GDB prompt string. */
95298e72
PM
1484
1485void
ab821bc6 1486set_prompt (const char *s)
95298e72 1487{
ab821bc6 1488 char *p = xstrdup (s);
95298e72 1489
ab821bc6
PA
1490 xfree (top_prompt);
1491 top_prompt = p;
9e0b60a8 1492}
9e0b60a8 1493\f
c5aa993b 1494
b0abbc58 1495struct qt_args
9e0b60a8 1496{
b0abbc58
JJ
1497 int from_tty;
1498};
9e0b60a8 1499
54a012c9
PA
1500/* Callback for iterate_over_inferiors. Kills or detaches the given
1501 inferior, depending on how we originally gained control of it. */
1502
1503static int
1504kill_or_detach (struct inferior *inf, void *args)
1505{
19ba03f4 1506 struct qt_args *qt = (struct qt_args *) args;
54a012c9 1507
6c95b8df
PA
1508 if (inf->pid == 0)
1509 return 0;
1510
00431a78 1511 thread_info *thread = any_thread_of_inferior (inf);
b8fa0bfa 1512 if (thread != NULL)
9e0b60a8 1513 {
00431a78 1514 switch_to_thread (thread);
c35b1492
PA
1515
1516 /* Leave core files alone. */
1517 if (target_has_execution)
1518 {
1519 if (inf->attach_flag)
6e1e1966 1520 target_detach (inf, qt->from_tty);
c35b1492
PA
1521 else
1522 target_kill ();
1523 }
9e0b60a8
JM
1524 }
1525
54a012c9
PA
1526 return 0;
1527}
1528
b8fa0bfa
PA
1529/* Callback for iterate_over_inferiors. Prints info about what GDB
1530 will do to each inferior on a "quit". ARG points to a struct
1531 ui_out where output is to be collected. */
1532
1533static int
1534print_inferior_quit_action (struct inferior *inf, void *arg)
1535{
19ba03f4 1536 struct ui_file *stb = (struct ui_file *) arg;
b8fa0bfa 1537
6c95b8df
PA
1538 if (inf->pid == 0)
1539 return 0;
1540
b8fa0bfa
PA
1541 if (inf->attach_flag)
1542 fprintf_filtered (stb,
1543 _("\tInferior %d [%s] will be detached.\n"), inf->num,
f2907e49 1544 target_pid_to_str (ptid_t (inf->pid)));
b8fa0bfa
PA
1545 else
1546 fprintf_filtered (stb,
1547 _("\tInferior %d [%s] will be killed.\n"), inf->num,
f2907e49 1548 target_pid_to_str (ptid_t (inf->pid)));
b8fa0bfa
PA
1549
1550 return 0;
1551}
1552
1553/* If necessary, make the user confirm that we should quit. Return
1554 non-zero if we should quit, zero if we shouldn't. */
1555
1556int
1557quit_confirm (void)
1558{
b8fa0bfa
PA
1559 /* Don't even ask if we're only debugging a core file inferior. */
1560 if (!have_live_inferiors ())
1561 return 1;
1562
1563 /* Build the query string as a single string. */
d7e74731 1564 string_file stb;
b8fa0bfa 1565
d7e74731
PA
1566 stb.puts (_("A debugging session is active.\n\n"));
1567 iterate_over_inferiors (print_inferior_quit_action, &stb);
1568 stb.puts (_("\nQuit anyway? "));
7b01d34b 1569
d7e74731 1570 return query ("%s", stb.c_str ());
b8fa0bfa
PA
1571}
1572
18206ca3
PP
1573/* Prepare to exit GDB cleanly by undoing any changes made to the
1574 terminal so that we leave the terminal in the state we acquired it. */
1575
1576static void
1577undo_terminal_modifications_before_exit (void)
1578{
3c216924
PA
1579 struct ui *saved_top_level = current_ui;
1580
223ffa71 1581 target_terminal::ours ();
3c216924
PA
1582
1583 current_ui = main_ui;
1584
18206ca3
PP
1585#if defined(TUI)
1586 tui_disable ();
1587#endif
3c216924
PA
1588 gdb_disable_readline ();
1589
1590 current_ui = saved_top_level;
18206ca3
PP
1591}
1592
1593
b0abbc58
JJ
1594/* Quit without asking for confirmation. */
1595
1596void
36cf1806 1597quit_force (int *exit_arg, int from_tty)
b0abbc58
JJ
1598{
1599 int exit_code = 0;
365c70b1 1600 struct qt_args qt;
b0abbc58 1601
18206ca3
PP
1602 undo_terminal_modifications_before_exit ();
1603
b0abbc58 1604 /* An optional expression may be used to cause gdb to terminate with the
371d5dec 1605 value of that expression. */
36cf1806
TT
1606 if (exit_arg)
1607 exit_code = *exit_arg;
4b0ad762
AS
1608 else if (return_child_result)
1609 exit_code = return_child_result_value;
b0abbc58 1610
365c70b1
JJ
1611 qt.from_tty = from_tty;
1612
b0abbc58 1613 /* We want to handle any quit errors and exit regardless. */
2f9d54cf
PA
1614
1615 /* Get out of tfind mode, and kill or detach all inferiors. */
492d29ea 1616 TRY
2f9d54cf
PA
1617 {
1618 disconnect_tracing ();
1619 iterate_over_inferiors (kill_or_detach, &qt);
1620 }
492d29ea
PA
1621 CATCH (ex, RETURN_MASK_ALL)
1622 {
1623 exception_print (gdb_stderr, ex);
1624 }
1625 END_CATCH
2f9d54cf
PA
1626
1627 /* Give all pushed targets a chance to do minimal cleanup, and pop
1628 them all out. */
492d29ea 1629 TRY
2f9d54cf
PA
1630 {
1631 pop_all_targets ();
1632 }
492d29ea
PA
1633 CATCH (ex, RETURN_MASK_ALL)
1634 {
1635 exception_print (gdb_stderr, ex);
1636 }
1637 END_CATCH
2f9d54cf
PA
1638
1639 /* Save the history information if it is appropriate to do so. */
492d29ea 1640 TRY
2f9d54cf 1641 {
268a799a
PA
1642 if (write_history_p && history_filename)
1643 {
1644 struct ui *ui;
1645 int save = 0;
1646
1647 /* History is currently shared between all UIs. If there's
1648 any UI with a terminal, save history. */
1649 ALL_UIS (ui)
1650 {
1651 if (input_interactive_p (ui))
1652 {
1653 save = 1;
1654 break;
1655 }
1656 }
1657
1658 if (save)
1659 gdb_safe_append_history ();
1660 }
2f9d54cf 1661 }
492d29ea
PA
1662 CATCH (ex, RETURN_MASK_ALL)
1663 {
1664 exception_print (gdb_stderr, ex);
1665 }
1666 END_CATCH
2f9d54cf
PA
1667
1668 /* Do any final cleanups before exiting. */
492d29ea 1669 TRY
2f9d54cf
PA
1670 {
1671 do_final_cleanups (all_cleanups ());
1672 }
492d29ea
PA
1673 CATCH (ex, RETURN_MASK_ALL)
1674 {
1675 exception_print (gdb_stderr, ex);
1676 }
1677 END_CATCH
b0abbc58 1678
9e0b60a8
JM
1679 exit (exit_code);
1680}
1681
268a799a
PA
1682/* The value of the "interactive-mode" setting. */
1683static enum auto_boolean interactive_mode = AUTO_BOOLEAN_AUTO;
9e0b60a8 1684
268a799a
PA
1685/* Implement the "show interactive-mode" option. */
1686
1687static void
1688show_interactive_mode (struct ui_file *file, int from_tty,
1689 struct cmd_list_element *c,
1690 const char *value)
9e0b60a8 1691{
268a799a
PA
1692 if (interactive_mode == AUTO_BOOLEAN_AUTO)
1693 fprintf_filtered (file, "Debugger's interactive mode "
1694 "is %s (currently %s).\n",
d9de1fe3 1695 value, input_interactive_p (current_ui) ? "on" : "off");
268a799a
PA
1696 else
1697 fprintf_filtered (file, "Debugger's interactive mode is %s.\n", value);
1698}
1699
1700/* Returns whether GDB is running on an interactive terminal. */
f38d3ad1 1701
268a799a
PA
1702int
1703input_interactive_p (struct ui *ui)
1704{
c63a1f86
JK
1705 if (batch_flag)
1706 return 0;
1707
268a799a
PA
1708 if (interactive_mode != AUTO_BOOLEAN_AUTO)
1709 return interactive_mode == AUTO_BOOLEAN_TRUE;
698ba934 1710
268a799a 1711 return ui->input_interactive_p;
9e0b60a8
JM
1712}
1713\f
9e0b60a8 1714static void
0b39b52e 1715dont_repeat_command (const char *ignored, int from_tty)
9e0b60a8 1716{
dc7eb48e
PA
1717 /* Can't call dont_repeat here because we're not necessarily reading
1718 from stdin. */
1719 *saved_command_line = 0;
9e0b60a8
JM
1720}
1721\f
1722/* Functions to manipulate command line editing control variables. */
1723
1724/* Number of commands to print in each call to show_commands. */
1725#define Hist_print 10
d318976c 1726void
85c4be7c 1727show_commands (const char *args, int from_tty)
9e0b60a8
JM
1728{
1729 /* Index for history commands. Relative to history_base. */
1730 int offset;
1731
1732 /* Number of the history entry which we are planning to display next.
1733 Relative to history_base. */
1734 static int num = 0;
1735
9e0b60a8 1736 /* Print out some of the commands from the command history. */
9e0b60a8
JM
1737
1738 if (args)
1739 {
1740 if (args[0] == '+' && args[1] == '\0')
1741 /* "info editing +" should print from the stored position. */
1742 ;
1743 else
1744 /* "info editing <exp>" should print around command number <exp>. */
0e828ed1 1745 num = (parse_and_eval_long (args) - history_base) - Hist_print / 2;
9e0b60a8
JM
1746 }
1747 /* "show commands" means print the last Hist_print commands. */
1748 else
1749 {
840a9a1f 1750 num = history_length - Hist_print;
9e0b60a8
JM
1751 }
1752
1753 if (num < 0)
1754 num = 0;
1755
1756 /* If there are at least Hist_print commands, we want to display the last
1757 Hist_print rather than, say, the last 6. */
840a9a1f 1758 if (history_length - num < Hist_print)
9e0b60a8 1759 {
840a9a1f 1760 num = history_length - Hist_print;
9e0b60a8
JM
1761 if (num < 0)
1762 num = 0;
1763 }
1764
840a9a1f
PA
1765 for (offset = num;
1766 offset < num + Hist_print && offset < history_length;
1767 offset++)
9e0b60a8
JM
1768 {
1769 printf_filtered ("%5d %s\n", history_base + offset,
c5aa993b 1770 (history_get (history_base + offset))->line);
9e0b60a8
JM
1771 }
1772
1773 /* The next command we want to display is the next one that we haven't
1774 displayed yet. */
1775 num += Hist_print;
1776
1777 /* If the user repeats this command with return, it should do what
1778 "show commands +" does. This is unnecessary if arg is null,
1779 because "show commands +" is not useful after "show commands". */
1780 if (from_tty && args)
85c4be7c 1781 set_repeat_arguments ("+");
9e0b60a8
JM
1782}
1783
ebfd00d2 1784/* Update the size of our command history file to HISTORY_SIZE.
840a9a1f 1785
ebfd00d2 1786 A HISTORY_SIZE of -1 stands for unlimited. */
840a9a1f 1787
ebfd00d2
PP
1788static void
1789set_readline_history_size (int history_size)
1790{
1791 gdb_assert (history_size >= -1);
840a9a1f 1792
ebfd00d2 1793 if (history_size == -1)
840a9a1f 1794 unstifle_history ();
883b9c6c 1795 else
ebfd00d2
PP
1796 stifle_history (history_size);
1797}
1798
1799/* Called by do_setshow_command. */
1800static void
eb4c3f4a
TT
1801set_history_size_command (const char *args,
1802 int from_tty, struct cmd_list_element *c)
ebfd00d2
PP
1803{
1804 set_readline_history_size (history_size_setshow_var);
9e0b60a8
JM
1805}
1806
d318976c 1807void
981a3fb3 1808set_history (const char *args, int from_tty)
9e0b60a8 1809{
3e43a32a
MS
1810 printf_unfiltered (_("\"set history\" must be followed "
1811 "by the name of a history subcommand.\n"));
635c7e8a 1812 help_list (sethistlist, "set history ", all_commands, gdb_stdout);
9e0b60a8
JM
1813}
1814
d318976c 1815void
981a3fb3 1816show_history (const char *args, int from_tty)
9e0b60a8
JM
1817{
1818 cmd_show_list (showhistlist, from_tty, "");
1819}
1820
371d5dec 1821int info_verbose = 0; /* Default verbose msgs off. */
9e0b60a8
JM
1822
1823/* Called by do_setshow_command. An elaborate joke. */
d318976c 1824void
eb4c3f4a 1825set_verbose (const char *args, int from_tty, struct cmd_list_element *c)
9e0b60a8 1826{
6f937416 1827 const char *cmdname = "verbose";
9e0b60a8
JM
1828 struct cmd_list_element *showcmd;
1829
1830 showcmd = lookup_cmd_1 (&cmdname, showlist, NULL, 1);
1427fe5e 1831 gdb_assert (showcmd != NULL && showcmd != CMD_LIST_AMBIGUOUS);
9e0b60a8
JM
1832
1833 if (info_verbose)
1834 {
1835 c->doc = "Set verbose printing of informational messages.";
1836 showcmd->doc = "Show verbose printing of informational messages.";
1837 }
1838 else
1839 {
1840 c->doc = "Set verbosity.";
1841 showcmd->doc = "Show verbosity.";
1842 }
1843}
1844
9e0b60a8 1845/* Init the history buffer. Note that we are called after the init file(s)
371d5dec
MS
1846 have been read so that the user can change the history file via his
1847 .gdbinit file (for instance). The GDBHISTFILE environment variable
1848 overrides all of this. */
9e0b60a8
JM
1849
1850void
fba45db2 1851init_history (void)
9e0b60a8 1852{
b5a9bfbe 1853 const char *tmpenv;
9e0b60a8 1854
b58c513b 1855 tmpenv = getenv ("GDBHISTSIZE");
9e0b60a8 1856 if (tmpenv)
840a9a1f 1857 {
bc460514 1858 long var;
0fc26caf 1859 int saved_errno;
bc460514
PP
1860 char *endptr;
1861
1862 tmpenv = skip_spaces (tmpenv);
0fc26caf 1863 errno = 0;
bc460514 1864 var = strtol (tmpenv, &endptr, 10);
0fc26caf 1865 saved_errno = errno;
bc460514
PP
1866 endptr = skip_spaces (endptr);
1867
1868 /* If GDBHISTSIZE is non-numeric then ignore it. If GDBHISTSIZE is the
1869 empty string, a negative number or a huge positive number (larger than
1870 INT_MAX) then set the history size to unlimited. Otherwise set our
1871 history size to the number we have read. This behavior is consistent
1872 with how bash handles HISTSIZE. */
1873 if (*endptr != '\0')
1874 ;
1875 else if (*tmpenv == '\0'
1876 || var < 0
0fc26caf
PP
1877 || var > INT_MAX
1878 /* On targets where INT_MAX == LONG_MAX, we have to look at
1879 errno after calling strtol to distinguish between a value that
1880 is exactly INT_MAX and an overflowing value that was clamped
1881 to INT_MAX. */
1882 || (var == INT_MAX && saved_errno == ERANGE))
bc460514
PP
1883 history_size_setshow_var = -1;
1884 else
1885 history_size_setshow_var = var;
840a9a1f 1886 }
bc460514
PP
1887
1888 /* If neither the init file nor GDBHISTSIZE has set a size yet, pick the
1889 default. */
1890 if (history_size_setshow_var == -2)
840a9a1f 1891 history_size_setshow_var = 256;
9e0b60a8 1892
ebfd00d2 1893 set_readline_history_size (history_size_setshow_var);
9e0b60a8
JM
1894
1895 tmpenv = getenv ("GDBHISTFILE");
1896 if (tmpenv)
1b36a34b 1897 history_filename = xstrdup (tmpenv);
c5aa993b
JM
1898 else if (!history_filename)
1899 {
1900 /* We include the current directory so that if the user changes
1901 directories the file written will be the same as the one
1902 that was read. */
a0b3c4fd 1903#ifdef __MSDOS__
eb2f494a 1904 /* No leading dots in file names are allowed on MSDOS. */
1754f103
MK
1905 history_filename = concat (current_directory, "/_gdb_history",
1906 (char *)NULL);
a0b3c4fd 1907#else
1754f103
MK
1908 history_filename = concat (current_directory, "/.gdb_history",
1909 (char *)NULL);
a0b3c4fd 1910#endif
c5aa993b 1911 }
9e0b60a8
JM
1912 read_history (history_filename);
1913}
1914
920d2a44 1915static void
ab821bc6
PA
1916show_prompt (struct ui_file *file, int from_tty,
1917 struct cmd_list_element *c, const char *value)
920d2a44
AC
1918{
1919 fprintf_filtered (file, _("Gdb's prompt is \"%s\".\n"), value);
1920}
1921
3c216924
PA
1922/* "set editing" command. */
1923
1924static void
eb4c3f4a 1925set_editing (const char *args, int from_tty, struct cmd_list_element *c)
3c216924
PA
1926{
1927 change_line_handler (set_editing_cmd_var);
1928 /* Update the control variable so that MI's =cmd-param-changed event
1929 shows the correct value. */
1930 set_editing_cmd_var = current_ui->command_editing;
1931}
1932
920d2a44 1933static void
3c216924
PA
1934show_editing (struct ui_file *file, int from_tty,
1935 struct cmd_list_element *c, const char *value)
920d2a44 1936{
3e43a32a
MS
1937 fprintf_filtered (file, _("Editing of command lines as "
1938 "they are typed is %s.\n"),
3c216924 1939 current_ui->command_editing ? _("on") : _("off"));
920d2a44
AC
1940}
1941
1942static void
1943show_annotation_level (struct ui_file *file, int from_tty,
1944 struct cmd_list_element *c, const char *value)
1945{
1946 fprintf_filtered (file, _("Annotation_level is %s.\n"), value);
1947}
1948
1949static void
1950show_exec_done_display_p (struct ui_file *file, int from_tty,
1951 struct cmd_list_element *c, const char *value)
1952{
3e43a32a
MS
1953 fprintf_filtered (file, _("Notification of completion for "
1954 "asynchronous execution commands is %s.\n"),
920d2a44
AC
1955 value);
1956}
6dea1fbd 1957
8d551b02
DE
1958/* New values of the "data-directory" parameter are staged here. */
1959static char *staged_gdb_datadir;
1960
6dea1fbd
JK
1961/* "set" command for the gdb_datadir configuration variable. */
1962
1963static void
eb4c3f4a 1964set_gdb_datadir (const char *args, int from_tty, struct cmd_list_element *c)
6dea1fbd 1965{
8d551b02 1966 set_gdb_data_directory (staged_gdb_datadir);
76727919 1967 gdb::observers::gdb_datadir_changed.notify ();
6dea1fbd
JK
1968}
1969
8d551b02
DE
1970/* "show" command for the gdb_datadir configuration variable. */
1971
1972static void
1973show_gdb_datadir (struct ui_file *file, int from_tty,
1974 struct cmd_list_element *c, const char *value)
1975{
1976 fprintf_filtered (file, _("GDB's data directory is \"%s\".\n"),
1977 gdb_datadir);
1978}
1979
97c85fc6 1980static void
eb4c3f4a
TT
1981set_history_filename (const char *args,
1982 int from_tty, struct cmd_list_element *c)
97c85fc6
MB
1983{
1984 /* We include the current directory so that if the user changes
1985 directories the file written will be the same as the one
1986 that was read. */
1987 if (!IS_ABSOLUTE_PATH (history_filename))
1988 history_filename = reconcat (history_filename, current_directory, "/",
1989 history_filename, (char *) NULL);
1990}
1991
9e0b60a8 1992static void
fba45db2 1993init_main (void)
9e0b60a8 1994{
60eb5395
PA
1995 struct cmd_list_element *c;
1996
ab821bc6
PA
1997 /* Initialize the prompt to a simple "(gdb) " prompt or to whatever
1998 the DEFAULT_PROMPT is. */
1999 set_prompt (DEFAULT_PROMPT);
2000
9e0b60a8
JM
2001 /* Set the important stuff up for command editing. */
2002 command_editing_p = 1;
9e0b60a8 2003 history_expansion_p = 0;
452a569e 2004 write_history_p = 0;
9e0b60a8
JM
2005
2006 /* Setup important stuff for command line editing. */
67c296a2 2007 rl_completion_word_break_hook = gdb_completion_word_break_characters;
eb3ff9a5 2008 rl_attempted_completion_function = gdb_rl_attempted_completion_function;
67cb5b2d 2009 set_rl_completer_word_break_characters (default_word_break_characters ());
d318976c 2010 rl_completer_quote_characters = get_gdb_completer_quote_characters ();
82083d6d 2011 rl_completion_display_matches_hook = cli_display_match_list;
9e0b60a8 2012 rl_readline_name = "gdb";
7cb3ec5e 2013 rl_terminal_name = getenv ("TERM");
9e0b60a8 2014
467d8519
TT
2015 /* The name for this defun comes from Bash, where it originated.
2016 15 is Control-o, the same binding this function has in Bash. */
2017 rl_add_defun ("operate-and-get-next", gdb_rl_operate_and_get_next, 15);
2018
4d28ad1e 2019 add_setshow_string_cmd ("prompt", class_support,
ab821bc6 2020 &top_prompt,
3e43a32a
MS
2021 _("Set gdb's prompt"),
2022 _("Show gdb's prompt"),
ab821bc6
PA
2023 NULL, NULL,
2024 show_prompt,
4d28ad1e 2025 &setlist, &showlist);
9e0b60a8 2026
1bedd215 2027 add_com ("dont-repeat", class_support, dont_repeat_command, _("\
3e43a32a
MS
2028Don't repeat this command.\nPrimarily \
2029used inside of user-defined commands that should not be repeated when\n\
1bedd215 2030hitting return."));
9e0b60a8 2031
5bf193a2 2032 add_setshow_boolean_cmd ("editing", class_support,
3c216924 2033 &set_editing_cmd_var, _("\
5bf193a2
AC
2034Set editing of command lines as they are typed."), _("\
2035Show editing of command lines as they are typed."), _("\
9e0b60a8
JM
2036Use \"on\" to enable the editing, and \"off\" to disable it.\n\
2037Without an argument, command line editing is enabled. To edit, use\n\
5bf193a2 2038EMACS-like or VI-like commands like control-P or ESC."),
3c216924
PA
2039 set_editing,
2040 show_editing,
5bf193a2
AC
2041 &setlist, &showlist);
2042
2043 add_setshow_boolean_cmd ("save", no_class, &write_history_p, _("\
2044Set saving of the history record on exit."), _("\
2045Show saving of the history record on exit."), _("\
9e0b60a8 2046Use \"on\" to enable the saving, and \"off\" to disable it.\n\
5bf193a2
AC
2047Without an argument, saving is enabled."),
2048 NULL,
920d2a44 2049 show_write_history_p,
5bf193a2 2050 &sethistlist, &showhistlist);
9e0b60a8 2051
ebfd00d2
PP
2052 add_setshow_zuinteger_unlimited_cmd ("size", no_class,
2053 &history_size_setshow_var, _("\
4d28ad1e
AC
2054Set the size of the command history,"), _("\
2055Show the size of the command history,"), _("\
f81d1120
PA
2056ie. the number of previous commands to keep a record of.\n\
2057If set to \"unlimited\", the number of commands kept in the history\n\
2058list is unlimited. This defaults to the value of the environment\n\
b58c513b 2059variable \"GDBHISTSIZE\", or to 256 if this variable is not set."),
883b9c6c
YQ
2060 set_history_size_command,
2061 show_history_size,
2062 &sethistlist, &showhistlist);
4d28ad1e 2063
fc637f04
PP
2064 add_setshow_zuinteger_unlimited_cmd ("remove-duplicates", no_class,
2065 &history_remove_duplicates, _("\
2066Set how far back in history to look for and remove duplicate entries."), _("\
2067Show how far back in history to look for and remove duplicate entries."), _("\
2068If set to a nonzero value N, GDB will look back at the last N history entries\n\
2069and remove the first history entry that is a duplicate of the most recent\n\
2070entry, each time a new history entry is added.\n\
2071If set to \"unlimited\", this lookbehind is unbounded.\n\
2072Only history entries added during this session are considered for removal.\n\
2073If set to 0, removal of duplicate history entries is disabled.\n\
2074By default this option is set to 0."),
2075 NULL,
2076 show_history_remove_duplicates,
2077 &sethistlist, &showhistlist);
2078
4d28ad1e
AC
2079 add_setshow_filename_cmd ("filename", no_class, &history_filename, _("\
2080Set the filename in which to record the command history"), _("\
2081Show the filename in which to record the command history"), _("\
2082(the list of previous commands of which a record is kept)."),
97c85fc6 2083 set_history_filename,
920d2a44 2084 show_history_filename,
4d28ad1e 2085 &sethistlist, &showhistlist);
9e0b60a8 2086
e360902b 2087 add_setshow_boolean_cmd ("confirm", class_support, &confirm, _("\
5bf193a2
AC
2088Set whether to confirm potentially dangerous operations."), _("\
2089Show whether to confirm potentially dangerous operations."), NULL,
2090 NULL,
e360902b 2091 show_confirm,
5bf193a2 2092 &setlist, &showlist);
9e0b60a8 2093
85c07804
AC
2094 add_setshow_zinteger_cmd ("annotate", class_obscure, &annotation_level, _("\
2095Set annotation_level."), _("\
2096Show annotation_level."), _("\
9e0b60a8 20970 == normal; 1 == fullname (for use when running under emacs)\n\
85c07804 20982 == output annotated suitably for use by programs that control GDB."),
ab821bc6 2099 NULL,
920d2a44 2100 show_annotation_level,
85c07804 2101 &setlist, &showlist);
362646f5 2102
5bf193a2
AC
2103 add_setshow_boolean_cmd ("exec-done-display", class_support,
2104 &exec_done_display_p, _("\
2105Set notification of completion for asynchronous execution commands."), _("\
2106Show notification of completion for asynchronous execution commands."), _("\
2107Use \"on\" to enable the notification, and \"off\" to disable it."),
2108 NULL,
920d2a44 2109 show_exec_done_display_p,
5bf193a2 2110 &setlist, &showlist);
b14b1491
TT
2111
2112 add_setshow_filename_cmd ("data-directory", class_maintenance,
8d551b02 2113 &staged_gdb_datadir, _("Set GDB's data directory."),
b14b1491
TT
2114 _("Show GDB's data directory."),
2115 _("\
2116When set, GDB uses the specified path to search for data files."),
8d551b02 2117 set_gdb_datadir, show_gdb_datadir,
b14b1491
TT
2118 &setlist,
2119 &showlist);
268a799a
PA
2120
2121 add_setshow_auto_boolean_cmd ("interactive-mode", class_support,
2122 &interactive_mode, _("\
2123Set whether GDB's standard input is a terminal."), _("\
2124Show whether GDB's standard input is a terminal."), _("\
2125If on, GDB assumes that standard input is a terminal. In practice, it\n\
2126means that GDB should wait for the user to answer queries associated to\n\
2127commands entered at the command prompt. If off, GDB assumes that standard\n\
2128input is not a terminal, and uses the default answer to all queries.\n\
2129If auto (the default), determine which mode to use based on the standard\n\
2130input settings."),
2131 NULL,
2132 show_interactive_mode,
2133 &setlist, &showlist);
60eb5395
PA
2134
2135 c = add_cmd ("new-ui", class_support, new_ui_command, _("\
2136Create a new UI. It takes two arguments:\n\
2137The first argument is the name of the interpreter to run.\n\
2138The second argument is the terminal the UI runs on.\n"), &cmdlist);
2139 set_cmd_completer (c, interpreter_completer);
9e0b60a8 2140}
64cdedad
EZ
2141
2142void
2143gdb_init (char *argv0)
2144{
2145 if (pre_init_ui_hook)
2146 pre_init_ui_hook ();
2147
371d5dec 2148 /* Run the init function of each source file. */
64cdedad 2149
64cdedad
EZ
2150#ifdef __MSDOS__
2151 /* Make sure we return to the original directory upon exit, come
2152 what may, since the OS doesn't do that for us. */
2153 make_final_cleanup (do_chdir_cleanup, xstrdup (current_directory));
2154#endif
2155
371d5dec
MS
2156 init_cmd_lists (); /* This needs to be done first. */
2157 initialize_targets (); /* Setup target_terminal macros for utils.c. */
2158 initialize_utils (); /* Make errors and warnings possible. */
9dea9163 2159
24b73f8e
PP
2160 init_page_info ();
2161
9dea9163 2162 /* Here is where we call all the _initialize_foo routines. */
64cdedad 2163 initialize_all_files ();
9dea9163 2164
6c95b8df
PA
2165 /* This creates the current_program_space. Do this after all the
2166 _initialize_foo routines have had a chance to install their
2167 per-sspace data keys. Also do this before
2168 initialize_current_architecture is called, because it accesses
2169 exec_bfd of the current program space. */
2170 initialize_progspace ();
2171 initialize_inferiors ();
64cdedad
EZ
2172 initialize_current_architecture ();
2173 init_cli_cmds();
371d5dec 2174 init_main (); /* But that omits this file! Do it now. */
64cdedad 2175
0ea3f30e
DJ
2176 initialize_stdin_serial ();
2177
6a06d660
PP
2178 /* Take a snapshot of our tty state before readline/ncurses have had a chance
2179 to alter it. */
2180 set_initial_gdb_ttystate ();
2181
362646f5 2182 async_init_signals ();
64cdedad 2183
371d5dec
MS
2184 /* We need a default language for parsing expressions, so simple
2185 things like "set width 0" won't fail if no language is explicitly
2186 set in a config file or implicitly set by reading an executable
2187 during startup. */
64cdedad 2188 set_language (language_c);
371d5dec 2189 expected_language = current_language; /* Don't warn about the change. */
64cdedad 2190
6dddc817 2191 /* Python initialization, for example, can require various commands to be
371d5dec
MS
2192 installed. For example "info pretty-printer" needs the "info"
2193 prefix to be installed. Keep things simple and just do final
6dddc817
DE
2194 script initialization here. */
2195 finish_ext_lang_initialization ();
64cdedad 2196}
This page took 2.146182 seconds and 4 git commands to generate.