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