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