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