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