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