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