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