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