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