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