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