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