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