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