GDB (xrefs)
/tmp/gdb-7.10/gdb/main.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 "top.h"
22 #include "target.h"
23 #include "inferior.h"
24 #include "symfile.h"
25 #include "gdbcore.h"
26 #include "getopt.h"
27 
28 #include <sys/types.h>
29 #include <sys/stat.h>
30 #include <ctype.h>
31 #include "event-loop.h"
32 #include "ui-out.h"
33 
34 #include "interps.h"
35 #include "main.h"
36 #include "source.h"
37 #include "cli/cli-cmds.h"
38 #include "objfiles.h"
39 #include "auto-load.h"
40 #include "maint.h"
41 
42 #include "filenames.h"
43 #include "filestuff.h"
44 #include <signal.h>
45 #include "event-top.h"
46 #include "infrun.h"
47 
48 /* The selected interpreter. This will be used as a set command
49  variable, so it should always be malloc'ed - since
50  do_setshow_command will free it. */
52 
53 /* Whether dbx commands will be handled. */
54 int dbx_commands = 0;
55 
56 /* System root path, used to find libraries etc. */
57 char *gdb_sysroot = 0;
58 
59 /* GDB datadir, used to store data files. */
60 char *gdb_datadir = 0;
61 
62 /* Non-zero if GDB_DATADIR was provided on the command line.
63  This doesn't track whether data-directory is set later from the
64  command line, but we don't reread system.gdbinit when that happens. */
65 static int gdb_datadir_provided = 0;
66 
67 /* If gdb was configured with --with-python=/path,
68  the possibly relocated path to python's lib directory. */
69 char *python_libdir = 0;
70 
75 /* Target IO streams. */
79 
80 /* True if --batch or --batch-silent was seen. */
81 int batch_flag = 0;
82 
83 /* Support for the --batch-silent option. */
84 int batch_silent = 0;
85 
86 /* Support for --return-child-result option.
87  Set the default to -1 to return error in the case
88  that the program does not run or does not complete. */
91 
92 
93 /* GDB as it has been invoked from the command line (i.e. argv[0]). */
94 static char *gdb_program_name;
95 
96 /* Return read only pointer to GDB_PROGRAM_NAME. */
97 const char *
99 {
100  return gdb_program_name;
101 }
102 
103 static void print_gdb_help (struct ui_file *);
104 
105 /* Set the data-directory parameter to NEW_DATADIR.
106  If NEW_DATADIR is not a directory then a warning is printed.
107  We don't signal an error for backward compatibility. */
108 
109 void
110 set_gdb_data_directory (const char *new_datadir)
111 {
112  struct stat st;
113 
114  if (stat (new_datadir, &st) < 0)
115  {
116  int save_errno = errno;
117 
118  fprintf_unfiltered (gdb_stderr, "Warning: ");
119  print_sys_errmsg (new_datadir, save_errno);
120  }
121  else if (!S_ISDIR (st.st_mode))
122  warning (_("%s is not a directory."), new_datadir);
123 
124  xfree (gdb_datadir);
125  gdb_datadir = gdb_realpath (new_datadir);
126 
127  /* gdb_realpath won't return an absolute path if the path doesn't exist,
128  but we still want to record an absolute path here. If the user entered
129  "../foo" and "../foo" doesn't exist then we'll record $(pwd)/../foo which
130  isn't canonical, but that's ok. */
131  if (!IS_ABSOLUTE_PATH (gdb_datadir))
132  {
133  char *abs_datadir = gdb_abspath (gdb_datadir);
134 
135  xfree (gdb_datadir);
136  gdb_datadir = abs_datadir;
137  }
138 }
139 
140 /* Relocate a file or directory. PROGNAME is the name by which gdb
141  was invoked (i.e., argv[0]). INITIAL is the default value for the
142  file or directory. FLAG is true if the value is relocatable, false
143  otherwise. Returns a newly allocated string; this may return NULL
144  under the same conditions as make_relative_prefix. */
145 
146 static char *
147 relocate_path (const char *progname, const char *initial, int flag)
148 {
149  if (flag)
150  return make_relative_prefix (progname, BINDIR, initial);
151  return xstrdup (initial);
152 }
153 
154 /* Like relocate_path, but specifically checks for a directory.
155  INITIAL is relocated according to the rules of relocate_path. If
156  the result is a directory, it is used; otherwise, INITIAL is used.
157  The chosen directory is then canonicalized using lrealpath. This
158  function always returns a newly-allocated string. */
159 
160 char *
161 relocate_gdb_directory (const char *initial, int flag)
162 {
163  char *dir;
164 
165  dir = relocate_path (gdb_program_name, initial, flag);
166  if (dir)
167  {
168  struct stat s;
169 
170  if (*dir == '\0' || stat (dir, &s) != 0 || !S_ISDIR (s.st_mode))
171  {
172  xfree (dir);
173  dir = NULL;
174  }
175  }
176  if (!dir)
177  dir = xstrdup (initial);
178 
179  /* Canonicalize the directory. */
180  if (*dir)
181  {
182  char *canon_sysroot = lrealpath (dir);
183 
184  if (canon_sysroot)
185  {
186  xfree (dir);
187  dir = canon_sysroot;
188  }
189  }
190 
191  return dir;
192 }
193 
194 /* Compute the locations of init files that GDB should source and
195  return them in SYSTEM_GDBINIT, HOME_GDBINIT, LOCAL_GDBINIT. If
196  there is no system gdbinit (resp. home gdbinit and local gdbinit)
197  to be loaded, then SYSTEM_GDBINIT (resp. HOME_GDBINIT and
198  LOCAL_GDBINIT) is set to NULL. */
199 static void
200 get_init_files (const char **system_gdbinit,
201  const char **home_gdbinit,
202  const char **local_gdbinit)
203 {
204  static const char *sysgdbinit = NULL;
205  static char *homeinit = NULL;
206  static const char *localinit = NULL;
207  static int initialized = 0;
208 
209  if (!initialized)
210  {
211  struct stat homebuf, cwdbuf, s;
212  char *homedir;
213 
214  if (SYSTEM_GDBINIT[0])
215  {
216  int datadir_len = strlen (GDB_DATADIR);
217  int sys_gdbinit_len = strlen (SYSTEM_GDBINIT);
218  char *relocated_sysgdbinit;
219 
220  /* If SYSTEM_GDBINIT lives in data-directory, and data-directory
221  has been provided, search for SYSTEM_GDBINIT there. */
223  && datadir_len < sys_gdbinit_len
224  && filename_ncmp (SYSTEM_GDBINIT, GDB_DATADIR, datadir_len) == 0
225  && IS_DIR_SEPARATOR (SYSTEM_GDBINIT[datadir_len]))
226  {
227  /* Append the part of SYSTEM_GDBINIT that follows GDB_DATADIR
228  to gdb_datadir. */
229  char *tmp_sys_gdbinit = xstrdup (SYSTEM_GDBINIT + datadir_len);
230  char *p;
231 
232  for (p = tmp_sys_gdbinit; IS_DIR_SEPARATOR (*p); ++p)
233  continue;
234  relocated_sysgdbinit = concat (gdb_datadir, SLASH_STRING, p,
235  NULL);
236  xfree (tmp_sys_gdbinit);
237  }
238  else
239  {
240  relocated_sysgdbinit = relocate_path (gdb_program_name,
243  }
244  if (relocated_sysgdbinit && stat (relocated_sysgdbinit, &s) == 0)
245  sysgdbinit = relocated_sysgdbinit;
246  else
247  xfree (relocated_sysgdbinit);
248  }
249 
250  homedir = getenv ("HOME");
251 
252  /* If the .gdbinit file in the current directory is the same as
253  the $HOME/.gdbinit file, it should not be sourced. homebuf
254  and cwdbuf are used in that purpose. Make sure that the stats
255  are zero in case one of them fails (this guarantees that they
256  won't match if either exists). */
257 
258  memset (&homebuf, 0, sizeof (struct stat));
259  memset (&cwdbuf, 0, sizeof (struct stat));
260 
261  if (homedir)
262  {
263  homeinit = xstrprintf ("%s/%s", homedir, gdbinit);
264  if (stat (homeinit, &homebuf) != 0)
265  {
266  xfree (homeinit);
267  homeinit = NULL;
268  }
269  }
270 
271  if (stat (gdbinit, &cwdbuf) == 0)
272  {
273  if (!homeinit
274  || memcmp ((char *) &homebuf, (char *) &cwdbuf,
275  sizeof (struct stat)))
276  localinit = gdbinit;
277  }
278 
279  initialized = 1;
280  }
281 
282  *system_gdbinit = sysgdbinit;
283  *home_gdbinit = homeinit;
284  *local_gdbinit = localinit;
285 }
286 
287 /* Try to set up an alternate signal stack for SIGSEGV handlers.
288  This allows us to handle SIGSEGV signals generated when the
289  normal process stack is exhausted. If this stack is not set
290  up (sigaltstack is unavailable or fails) and a SIGSEGV is
291  generated when the normal stack is exhausted then the program
292  will behave as though no SIGSEGV handler was installed. */
293 
294 static void
296 {
297 #ifdef HAVE_SIGALTSTACK
298  stack_t ss;
299 
300  ss.ss_sp = xmalloc (SIGSTKSZ);
301  ss.ss_size = SIGSTKSZ;
302  ss.ss_flags = 0;
303 
304  sigaltstack(&ss, NULL);
305 #endif
306 }
307 
308 /* Call command_loop. If it happens to return, pass that through as a
309  non-zero return status. */
310 
311 static int
313 {
314  /* Top-level execution commands can be run in the background from
315  here on. */
316  interpreter_async = 1;
317 
319  /* FIXME: cagney/1999-11-05: A correct command_loop() implementaton
320  would clean things up (restoring the cleanup chain) to the state
321  they were just prior to the call. Technically, this means that
322  the do_cleanups() below is redundant. Unfortunately, many FUNCs
323  are not that well behaved. do_cleanups should either be replaced
324  with a do_cleanups call (to cover the problem) or an assertion
325  check to detect bad FUNCs code. */
327  /* If the command_loop returned, normally (rather than threw an
328  error) we try to quit. If the quit is aborted, catch_errors()
329  which called this catch the signal and restart the command
330  loop. */
331  quit_command (NULL, instream == stdin);
332  return 1;
333 }
334 
335 /* Handle command errors thrown from within
336  catch_command_errors/catch_command_errors_const. */
337 
338 static int
340 {
341  if (e.reason < 0)
342  {
343  exception_print (gdb_stderr, e);
344 
345  /* If any exception escaped to here, we better enable stdin.
346  Otherwise, any command that calls async_disable_stdin, and
347  then throws, will leave stdin inoperable. */
349  return 0;
350  }
351  return 1;
352 }
353 
354 /* Type of the command callback passed to catch_command_errors. */
355 
356 typedef void (catch_command_errors_ftype) (char *, int);
357 
358 /* Wrap calls to commands run before the event loop is started. */
359 
360 static int
362  char *arg, int from_tty)
363 {
364  TRY
365  {
366  int was_sync = sync_execution;
367 
368  command (arg, from_tty);
369 
370  maybe_wait_sync_command_done (was_sync);
371  }
373  {
374  return handle_command_errors (e);
375  }
376  END_CATCH
377 
378  return 1;
379 }
380 
381 /* Type of the command callback passed to catch_command_errors_const. */
382 
383 typedef void (catch_command_errors_const_ftype) (const char *, int);
384 
385 /* Like catch_command_errors, but works with const command and args. */
386 
387 static int
389  const char *arg, int from_tty)
390 {
391  TRY
392  {
393  int was_sync = sync_execution;
394 
395  command (arg, from_tty);
396 
397  maybe_wait_sync_command_done (was_sync);
398  }
400  {
401  return handle_command_errors (e);
402  }
403  END_CATCH
404 
405  return 1;
406 }
407 
408 /* Type of this option. */
410 {
411  /* Option type -x. */
413 
414  /* Option type -ex. */
416 
417  /* Option type -ix. */
419 
420  /* Option type -iex. */
422 };
423 
424 /* Arguments of --command option and its counterpart. */
425 typedef struct cmdarg {
426  /* Type of this option. */
428 
429  /* Value of this option - filename or the GDB command itself. String memory
430  is not owned by this structure despite it is 'const'. */
431  char *string;
432 } cmdarg_s;
433 
434 /* Define type VEC (cmdarg_s). */
436 
437 static int
438 captured_main (void *data)
439 {
440  struct captured_main_args *context = data;
441  int argc = context->argc;
442  char **argv = context->argv;
443  static int quiet = 0;
444  static int set_args = 0;
445  static int inhibit_home_gdbinit = 0;
446 
447  /* Pointers to various arguments from command line. */
448  char *symarg = NULL;
449  char *execarg = NULL;
450  char *pidarg = NULL;
451  char *corearg = NULL;
452  char *pid_or_core_arg = NULL;
453  char *cdarg = NULL;
454  char *ttyarg = NULL;
455 
456  /* These are static so that we can take their address in an
457  initializer. */
458  static int print_help;
459  static int print_version;
460  static int print_configuration;
461 
462  /* Pointers to all arguments of --command option. */
463  VEC (cmdarg_s) *cmdarg_vec = NULL;
464  struct cmdarg *cmdarg_p;
465 
466  /* Indices of all arguments of --directory option. */
467  char **dirarg;
468  /* Allocated size. */
469  int dirsize;
470  /* Number of elements used. */
471  int ndir;
472 
473  /* gdb init files. */
474  const char *system_gdbinit;
475  const char *home_gdbinit;
476  const char *local_gdbinit;
477 
478  int i;
479  int save_auto_load;
480  struct objfile *objfile;
481 
482  struct cleanup *pre_stat_chain;
483 
484 #ifdef HAVE_SBRK
485  /* Set this before calling make_command_stats_cleanup. */
486  lim_at_start = (char *) sbrk (0);
487 #endif
488 
489  pre_stat_chain = make_command_stats_cleanup (0);
490 
491 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
492  setlocale (LC_MESSAGES, "");
493 #endif
494 #if defined (HAVE_SETLOCALE)
495  setlocale (LC_CTYPE, "");
496 #endif
497  bindtextdomain (PACKAGE, LOCALEDIR);
499 
500  bfd_init ();
501  notice_open_fds ();
502 
503  make_cleanup (VEC_cleanup (cmdarg_s), &cmdarg_vec);
504  dirsize = 1;
505  dirarg = (char **) xmalloc (dirsize * sizeof (*dirarg));
506  ndir = 0;
507 
508  clear_quit_flag ();
510  saved_command_line[0] = '\0';
511  instream = stdin;
512 
513 #ifdef __MINGW32__
514  /* Ensure stderr is unbuffered. A Cygwin pty or pipe is implemented
515  as a Windows pipe, and Windows buffers on pipes. */
516  setvbuf (stderr, NULL, _IONBF, BUFSIZ);
517 #endif
518 
519  gdb_stdout = stdio_fileopen (stdout);
520  gdb_stderr = stderr_fileopen ();
521 
522  gdb_stdlog = gdb_stderr; /* for moment */
523  gdb_stdtarg = gdb_stderr; /* for moment */
524  gdb_stdin = stdio_fileopen (stdin);
525  gdb_stdtargerr = gdb_stderr; /* for moment */
526  gdb_stdtargin = gdb_stdin; /* for moment */
527 
528 #ifdef __MINGW32__
529  /* On Windows, argv[0] is not necessarily set to absolute form when
530  GDB is found along PATH, without which relocation doesn't work. */
532 #else
533  gdb_program_name = xstrdup (argv[0]);
534 #endif
535 
536  /* Prefix warning messages with the command name. */
537  warning_pre_print = xstrprintf ("%s: warning: ", gdb_program_name);
538 
539  if (! getcwd (gdb_dirbuf, sizeof (gdb_dirbuf)))
540  perror_warning_with_name (_("error finding working directory"));
541 
543 
544  /* Set the sysroot path. */
547 
548  if (gdb_sysroot == NULL || *gdb_sysroot == '\0')
549  {
550  xfree (gdb_sysroot);
552  }
553 
556 
559 
560 #ifdef WITH_PYTHON_PATH
561  {
562  /* For later use in helping Python find itself. */
563  char *tmp = concat (WITH_PYTHON_PATH, SLASH_STRING, "lib", NULL);
564 
566  xfree (tmp);
567  }
568 #endif
569 
570 #ifdef RELOC_SRCDIR
571  add_substitute_path_rule (RELOC_SRCDIR,
572  make_relative_prefix (gdb_program_name, BINDIR,
573  RELOC_SRCDIR));
574 #endif
575 
576  /* There will always be an interpreter. Either the one passed into
577  this captured main, or one specified by the user at start up, or
578  the console. Initialize the interpreter to the one requested by
579  the application. */
580  interpreter_p = xstrdup (context->interpreter_p);
581 
582  /* Parse arguments and options. */
583  {
584  int c;
585  /* When var field is 0, use flag field to record the equivalent
586  short option (or arbitrary numbers starting at 10 for those
587  with no equivalent). */
588  enum {
589  OPT_SE = 10,
590  OPT_CD,
591  OPT_ANNOTATE,
592  OPT_STATISTICS,
593  OPT_TUI,
594  OPT_NOWINDOWS,
595  OPT_WINDOWS,
596  OPT_IX,
597  OPT_IEX
598  };
599  static struct option long_options[] =
600  {
601  {"tui", no_argument, 0, OPT_TUI},
602  {"dbx", no_argument, &dbx_commands, 1},
603  {"readnow", no_argument, &readnow_symbol_files, 1},
604  {"r", no_argument, &readnow_symbol_files, 1},
605  {"quiet", no_argument, &quiet, 1},
606  {"q", no_argument, &quiet, 1},
607  {"silent", no_argument, &quiet, 1},
608  {"nh", no_argument, &inhibit_home_gdbinit, 1},
609  {"nx", no_argument, &inhibit_gdbinit, 1},
610  {"n", no_argument, &inhibit_gdbinit, 1},
611  {"batch-silent", no_argument, 0, 'B'},
612  {"batch", no_argument, &batch_flag, 1},
613 
614  /* This is a synonym for "--annotate=1". --annotate is now
615  preferred, but keep this here for a long time because people
616  will be running emacses which use --fullname. */
617  {"fullname", no_argument, 0, 'f'},
618  {"f", no_argument, 0, 'f'},
619 
620  {"annotate", required_argument, 0, OPT_ANNOTATE},
621  {"help", no_argument, &print_help, 1},
622  {"se", required_argument, 0, OPT_SE},
623  {"symbols", required_argument, 0, 's'},
624  {"s", required_argument, 0, 's'},
625  {"exec", required_argument, 0, 'e'},
626  {"e", required_argument, 0, 'e'},
627  {"core", required_argument, 0, 'c'},
628  {"c", required_argument, 0, 'c'},
629  {"pid", required_argument, 0, 'p'},
630  {"p", required_argument, 0, 'p'},
631  {"command", required_argument, 0, 'x'},
632  {"eval-command", required_argument, 0, 'X'},
633  {"version", no_argument, &print_version, 1},
634  {"configuration", no_argument, &print_configuration, 1},
635  {"x", required_argument, 0, 'x'},
636  {"ex", required_argument, 0, 'X'},
637  {"init-command", required_argument, 0, OPT_IX},
638  {"init-eval-command", required_argument, 0, OPT_IEX},
639  {"ix", required_argument, 0, OPT_IX},
640  {"iex", required_argument, 0, OPT_IEX},
641 #ifdef GDBTK
642  {"tclcommand", required_argument, 0, 'z'},
643  {"enable-external-editor", no_argument, 0, 'y'},
644  {"editor-command", required_argument, 0, 'w'},
645 #endif
646  {"ui", required_argument, 0, 'i'},
647  {"interpreter", required_argument, 0, 'i'},
648  {"i", required_argument, 0, 'i'},
649  {"directory", required_argument, 0, 'd'},
650  {"d", required_argument, 0, 'd'},
651  {"data-directory", required_argument, 0, 'D'},
652  {"D", required_argument, 0, 'D'},
653  {"cd", required_argument, 0, OPT_CD},
654  {"tty", required_argument, 0, 't'},
655  {"baud", required_argument, 0, 'b'},
656  {"b", required_argument, 0, 'b'},
657  {"nw", no_argument, NULL, OPT_NOWINDOWS},
658  {"nowindows", no_argument, NULL, OPT_NOWINDOWS},
659  {"w", no_argument, NULL, OPT_WINDOWS},
660  {"windows", no_argument, NULL, OPT_WINDOWS},
661  {"statistics", no_argument, 0, OPT_STATISTICS},
662  {"write", no_argument, &write_files, 1},
663  {"args", no_argument, &set_args, 1},
664  {"l", required_argument, 0, 'l'},
665  {"return-child-result", no_argument, &return_child_result, 1},
666  {0, no_argument, 0, 0}
667  };
668 
669  while (1)
670  {
671  int option_index;
672 
673  c = getopt_long_only (argc, argv, "",
674  long_options, &option_index);
675  if (c == EOF || set_args)
676  break;
677 
678  /* Long option that takes an argument. */
679  if (c == 0 && long_options[option_index].flag == 0)
680  c = long_options[option_index].val;
681 
682  switch (c)
683  {
684  case 0:
685  /* Long option that just sets a flag. */
686  break;
687  case OPT_SE:
688  symarg = optarg;
689  execarg = optarg;
690  break;
691  case OPT_CD:
692  cdarg = optarg;
693  break;
694  case OPT_ANNOTATE:
695  /* FIXME: what if the syntax is wrong (e.g. not digits)? */
696  annotation_level = atoi (optarg);
697  break;
698  case OPT_STATISTICS:
699  /* Enable the display of both time and space usage. */
702  break;
703  case OPT_TUI:
704  /* --tui is equivalent to -i=tui. */
705 #ifdef TUI
707  interpreter_p = xstrdup (INTERP_TUI);
708 #else
709  error (_("%s: TUI mode is not supported"), gdb_program_name);
710 #endif
711  break;
712  case OPT_WINDOWS:
713  /* FIXME: cagney/2003-03-01: Not sure if this option is
714  actually useful, and if it is, what it should do. */
715 #ifdef GDBTK
716  /* --windows is equivalent to -i=insight. */
718  interpreter_p = xstrdup (INTERP_INSIGHT);
719 #endif
720  break;
721  case OPT_NOWINDOWS:
722  /* -nw is equivalent to -i=console. */
724  interpreter_p = xstrdup (INTERP_CONSOLE);
725  break;
726  case 'f':
727  annotation_level = 1;
728  break;
729  case 's':
730  symarg = optarg;
731  break;
732  case 'e':
733  execarg = optarg;
734  break;
735  case 'c':
736  corearg = optarg;
737  break;
738  case 'p':
739  pidarg = optarg;
740  break;
741  case 'x':
742  {
743  struct cmdarg cmdarg = { CMDARG_FILE, optarg };
744 
745  VEC_safe_push (cmdarg_s, cmdarg_vec, &cmdarg);
746  }
747  break;
748  case 'X':
749  {
750  struct cmdarg cmdarg = { CMDARG_COMMAND, optarg };
751 
752  VEC_safe_push (cmdarg_s, cmdarg_vec, &cmdarg);
753  }
754  break;
755  case OPT_IX:
756  {
757  struct cmdarg cmdarg = { CMDARG_INIT_FILE, optarg };
758 
759  VEC_safe_push (cmdarg_s, cmdarg_vec, &cmdarg);
760  }
761  break;
762  case OPT_IEX:
763  {
764  struct cmdarg cmdarg = { CMDARG_INIT_COMMAND, optarg };
765 
766  VEC_safe_push (cmdarg_s, cmdarg_vec, &cmdarg);
767  }
768  break;
769  case 'B':
770  batch_flag = batch_silent = 1;
771  gdb_stdout = ui_file_new();
772  break;
773  case 'D':
774  if (optarg[0] == '\0')
775  error (_("%s: empty path for `--data-directory'"),
777  set_gdb_data_directory (optarg);
779  break;
780 #ifdef GDBTK
781  case 'z':
782  {
783  extern int gdbtk_test (char *);
784 
785  if (!gdbtk_test (optarg))
786  error (_("%s: unable to load tclcommand file \"%s\""),
787  gdb_program_name, optarg);
788  break;
789  }
790  case 'y':
791  /* Backwards compatibility only. */
792  break;
793  case 'w':
794  {
795  /* Set the external editor commands when gdb is farming out files
796  to be edited by another program. */
797  extern char *external_editor_command;
798 
799  external_editor_command = xstrdup (optarg);
800  break;
801  }
802 #endif /* GDBTK */
803  case 'i':
805  interpreter_p = xstrdup (optarg);
806  break;
807  case 'd':
808  dirarg[ndir++] = optarg;
809  if (ndir >= dirsize)
810  {
811  dirsize *= 2;
812  dirarg = (char **) xrealloc ((char *) dirarg,
813  dirsize * sizeof (*dirarg));
814  }
815  break;
816  case 't':
817  ttyarg = optarg;
818  break;
819  case 'q':
820  quiet = 1;
821  break;
822  case 'b':
823  {
824  int i;
825  char *p;
826 
827  i = strtol (optarg, &p, 0);
828  if (i == 0 && p == optarg)
829  warning (_("could not set baud rate to `%s'."),
830  optarg);
831  else
832  baud_rate = i;
833  }
834  break;
835  case 'l':
836  {
837  int i;
838  char *p;
839 
840  i = strtol (optarg, &p, 0);
841  if (i == 0 && p == optarg)
842  warning (_("could not set timeout limit to `%s'."),
843  optarg);
844  else
845  remote_timeout = i;
846  }
847  break;
848 
849  case '?':
850  error (_("Use `%s --help' for a complete list of options."),
852  }
853  }
854 
855  if (batch_flag)
856  quiet = 1;
857  }
858 
859  /* Try to set up an alternate signal stack for SIGSEGV handlers. */
861 
862  /* Initialize all files. */
864 
865  /* Now that gdb_init has created the initial inferior, we're in
866  position to set args for that inferior. */
867  if (set_args)
868  {
869  /* The remaining options are the command-line options for the
870  inferior. The first one is the sym/exec file, and the rest
871  are arguments. */
872  if (optind >= argc)
873  error (_("%s: `--args' specified but no program specified"),
875 
876  symarg = argv[optind];
877  execarg = argv[optind];
878  ++optind;
879  set_inferior_args_vector (argc - optind, &argv[optind]);
880  }
881  else
882  {
883  /* OK, that's all the options. */
884 
885  /* The first argument, if specified, is the name of the
886  executable. */
887  if (optind < argc)
888  {
889  symarg = argv[optind];
890  execarg = argv[optind];
891  optind++;
892  }
893 
894  /* If the user hasn't already specified a PID or the name of a
895  core file, then a second optional argument is allowed. If
896  present, this argument should be interpreted as either a
897  PID or a core file, whichever works. */
898  if (pidarg == NULL && corearg == NULL && optind < argc)
899  {
900  pid_or_core_arg = argv[optind];
901  optind++;
902  }
903 
904  /* Any argument left on the command line is unexpected and
905  will be ignored. Inform the user. */
906  if (optind < argc)
907  fprintf_unfiltered (gdb_stderr,
908  _("Excess command line "
909  "arguments ignored. (%s%s)\n"),
910  argv[optind],
911  (optind == argc - 1) ? "" : " ...");
912  }
913 
914  /* Lookup gdbinit files. Note that the gdbinit file name may be
915  overriden during file initialization, so get_init_files should be
916  called after gdb_init. */
917  get_init_files (&system_gdbinit, &home_gdbinit, &local_gdbinit);
918 
919  /* Do these (and anything which might call wrap_here or *_filtered)
920  after initialize_all_files() but before the interpreter has been
921  installed. Otherwize the help/version messages will be eaten by
922  the interpreter's output handler. */
923 
924  if (print_version)
925  {
926  print_gdb_version (gdb_stdout);
927  wrap_here ("");
928  printf_filtered ("\n");
929  exit (0);
930  }
931 
932  if (print_help)
933  {
934  print_gdb_help (gdb_stdout);
935  fputs_unfiltered ("\n", gdb_stdout);
936  exit (0);
937  }
938 
939  if (print_configuration)
940  {
941  print_gdb_configuration (gdb_stdout);
942  wrap_here ("");
943  printf_filtered ("\n");
944  exit (0);
945  }
946 
947  /* FIXME: cagney/2003-02-03: The big hack (part 1 of 2) that lets
948  GDB retain the old MI1 interpreter startup behavior. Output the
949  copyright message before the interpreter is installed. That way
950  it isn't encapsulated in MI output. */
951  if (!quiet && strcmp (interpreter_p, INTERP_MI1) == 0)
952  {
953  /* Print all the junk at the top, with trailing "..." if we are
954  about to read a symbol file (possibly slowly). */
955  print_gdb_version (gdb_stdout);
956  if (symarg)
957  printf_filtered ("..");
958  wrap_here ("");
959  printf_filtered ("\n");
960  gdb_flush (gdb_stdout); /* Force to screen during slow
961  operations. */
962  }
963 
964  /* Install the default UI. All the interpreters should have had a
965  look at things by now. Initialize the default interpreter. */
966 
967  {
968  /* Find it. */
970 
971  if (interp == NULL)
972  error (_("Interpreter `%s' unrecognized"), interpreter_p);
973  /* Install it. */
974  if (!interp_set (interp, 1))
975  error (_("Interpreter `%s' failed to initialize."), interpreter_p);
976  }
977 
978  /* FIXME: cagney/2003-02-03: The big hack (part 2 of 2) that lets
979  GDB retain the old MI1 interpreter startup behavior. Output the
980  copyright message after the interpreter is installed when it is
981  any sane interpreter. */
982  if (!quiet && !current_interp_named_p (INTERP_MI1))
983  {
984  /* Print all the junk at the top, with trailing "..." if we are
985  about to read a symbol file (possibly slowly). */
986  print_gdb_version (gdb_stdout);
987  if (symarg)
988  printf_filtered ("..");
989  wrap_here ("");
990  printf_filtered ("\n");
991  gdb_flush (gdb_stdout); /* Force to screen during slow
992  operations. */
993  }
994 
995  /* Set off error and warning messages with a blank line. */
997  warning_pre_print = _("\nwarning: ");
998 
999  /* Read and execute the system-wide gdbinit file, if it exists.
1000  This is done *before* all the command line arguments are
1001  processed; it sets global parameters, which are independent of
1002  what file you are debugging or what directory you are in. */
1003  if (system_gdbinit && !inhibit_gdbinit)
1004  catch_command_errors_const (source_script, system_gdbinit, 0);
1005 
1006  /* Read and execute $HOME/.gdbinit file, if it exists. This is done
1007  *before* all the command line arguments are processed; it sets
1008  global parameters, which are independent of what file you are
1009  debugging or what directory you are in. */
1010 
1011  if (home_gdbinit && !inhibit_gdbinit && !inhibit_home_gdbinit)
1012  catch_command_errors_const (source_script, home_gdbinit, 0);
1013 
1014  /* Process '-ix' and '-iex' options early. */
1015  for (i = 0; VEC_iterate (cmdarg_s, cmdarg_vec, i, cmdarg_p); i++)
1016  switch (cmdarg_p->type)
1017  {
1018  case CMDARG_INIT_FILE:
1020  !batch_flag);
1021  break;
1022  case CMDARG_INIT_COMMAND:
1024  !batch_flag);
1025  break;
1026  }
1027 
1028  /* Now perform all the actions indicated by the arguments. */
1029  if (cdarg != NULL)
1030  {
1031  catch_command_errors (cd_command, cdarg, 0);
1032  }
1033 
1034  for (i = 0; i < ndir; i++)
1035  catch_command_errors (directory_switch, dirarg[i], 0);
1036  xfree (dirarg);
1037 
1038  /* Skip auto-loading section-specified scripts until we've sourced
1039  local_gdbinit (which is often used to augment the source search
1040  path). */
1041  save_auto_load = global_auto_load;
1042  global_auto_load = 0;
1043 
1044  if (execarg != NULL
1045  && symarg != NULL
1046  && strcmp (execarg, symarg) == 0)
1047  {
1048  /* The exec file and the symbol-file are the same. If we can't
1049  open it, better only print one error message.
1050  catch_command_errors returns non-zero on success! */
1052  !batch_flag))
1054  !batch_flag);
1055  }
1056  else
1057  {
1058  if (execarg != NULL)
1060  !batch_flag);
1061  if (symarg != NULL)
1063  !batch_flag);
1064  }
1065 
1066  if (corearg && pidarg)
1067  error (_("Can't attach to process and specify "
1068  "a core file at the same time."));
1069 
1070  if (corearg != NULL)
1072  else if (pidarg != NULL)
1074  else if (pid_or_core_arg)
1075  {
1076  /* The user specified 'gdb program pid' or gdb program core'.
1077  If pid_or_core_arg's first character is a digit, try attach
1078  first and then corefile. Otherwise try just corefile. */
1079 
1080  if (isdigit (pid_or_core_arg[0]))
1081  {
1082  if (catch_command_errors (attach_command, pid_or_core_arg,
1083  !batch_flag) == 0)
1084  catch_command_errors (core_file_command, pid_or_core_arg,
1085  !batch_flag);
1086  }
1087  else /* Can't be a pid, better be a corefile. */
1088  catch_command_errors (core_file_command, pid_or_core_arg,
1089  !batch_flag);
1090  }
1091 
1092  if (ttyarg != NULL)
1093  set_inferior_io_terminal (ttyarg);
1094 
1095  /* Error messages should no longer be distinguished with extra output. */
1096  warning_pre_print = _("warning: ");
1097 
1098  /* Read the .gdbinit file in the current directory, *if* it isn't
1099  the same as the $HOME/.gdbinit file (it should exist, also). */
1100  if (local_gdbinit)
1101  {
1103 
1105  && file_is_auto_load_safe (local_gdbinit,
1106  _("auto-load: Loading .gdbinit "
1107  "file \"%s\".\n"),
1108  local_gdbinit))
1109  {
1111 
1112  catch_command_errors_const (source_script, local_gdbinit, 0);
1113  }
1114  }
1115 
1116  /* Now that all .gdbinit's have been read and all -d options have been
1117  processed, we can read any scripts mentioned in SYMARG.
1118  We wait until now because it is common to add to the source search
1119  path in local_gdbinit. */
1120  global_auto_load = save_auto_load;
1121  ALL_OBJFILES (objfile)
1123 
1124  /* Process '-x' and '-ex' options. */
1125  for (i = 0; VEC_iterate (cmdarg_s, cmdarg_vec, i, cmdarg_p); i++)
1126  switch (cmdarg_p->type)
1127  {
1128  case CMDARG_FILE:
1130  !batch_flag);
1131  break;
1132  case CMDARG_COMMAND:
1134  !batch_flag);
1135  break;
1136  }
1137 
1138  /* Read in the old history after all the command files have been
1139  read. */
1140  init_history ();
1141 
1142  if (batch_flag)
1143  {
1144  /* We have hit the end of the batch file. */
1145  quit_force (NULL, 0);
1146  }
1147 
1148  /* Show time and/or space usage. */
1149  do_cleanups (pre_stat_chain);
1150 
1151  /* NOTE: cagney/1999-11-07: There is probably no reason for not
1152  moving this loop and the code found in captured_command_loop()
1153  into the command_loop() proper. The main thing holding back that
1154  change - SET_TOP_LEVEL() - has been eliminated. */
1155  while (1)
1156  {
1158  }
1159  /* No exit -- exit is through quit_command. */
1160 }
1161 
1162 int
1164 {
1166  /* The only way to end up here is by an error (normal exit is
1167  handled by quit_force()), hence always return an error status. */
1168  return 1;
1169 }
1170 
1171 
1172 /* Don't use *_filtered for printing help. We don't want to prompt
1173  for continue no matter how small the screen or how much we're going
1174  to print. */
1175 
1176 static void
1177 print_gdb_help (struct ui_file *stream)
1178 {
1179  const char *system_gdbinit;
1180  const char *home_gdbinit;
1181  const char *local_gdbinit;
1182 
1183  get_init_files (&system_gdbinit, &home_gdbinit, &local_gdbinit);
1184 
1185  /* Note: The options in the list below are only approximately sorted
1186  in the alphabetical order, so as to group closely related options
1187  together. */
1188  fputs_unfiltered (_("\
1189 This is the GNU debugger. Usage:\n\n\
1190  gdb [options] [executable-file [core-file or process-id]]\n\
1191  gdb [options] --args executable-file [inferior-arguments ...]\n\n\
1192 "), stream);
1193  fputs_unfiltered (_("\
1194 Selection of debuggee and its files:\n\n\
1195  --args Arguments after executable-file are passed to inferior\n\
1196  --core=COREFILE Analyze the core dump COREFILE.\n\
1197  --exec=EXECFILE Use EXECFILE as the executable.\n\
1198  --pid=PID Attach to running process PID.\n\
1199  --directory=DIR Search for source files in DIR.\n\
1200  --se=FILE Use FILE as symbol file and executable file.\n\
1201  --symbols=SYMFILE Read symbols from SYMFILE.\n\
1202  --readnow Fully read symbol files on first access.\n\
1203  --write Set writing into executable and core files.\n\n\
1204 "), stream);
1205  fputs_unfiltered (_("\
1206 Initial commands and command files:\n\n\
1207  --command=FILE, -x Execute GDB commands from FILE.\n\
1208  --init-command=FILE, -ix\n\
1209  Like -x but execute commands before loading inferior.\n\
1210  --eval-command=COMMAND, -ex\n\
1211  Execute a single GDB command.\n\
1212  May be used multiple times and in conjunction\n\
1213  with --command.\n\
1214  --init-eval-command=COMMAND, -iex\n\
1215  Like -ex but before loading inferior.\n\
1216  --nh Do not read ~/.gdbinit.\n\
1217  --nx Do not read any .gdbinit files in any directory.\n\n\
1218 "), stream);
1219  fputs_unfiltered (_("\
1220 Output and user interface control:\n\n\
1221  --fullname Output information used by emacs-GDB interface.\n\
1222  --interpreter=INTERP\n\
1223  Select a specific interpreter / user interface\n\
1224  --tty=TTY Use TTY for input/output by the program being debugged.\n\
1225  -w Use the GUI interface.\n\
1226  --nw Do not use the GUI interface.\n\
1227 "), stream);
1228 #if defined(TUI)
1229  fputs_unfiltered (_("\
1230  --tui Use a terminal user interface.\n\
1231 "), stream);
1232 #endif
1233  fputs_unfiltered (_("\
1234  --dbx DBX compatibility mode.\n\
1235  -q, --quiet, --silent\n\
1236  Do not print version number on startup.\n\n\
1237 "), stream);
1238  fputs_unfiltered (_("\
1239 Operating modes:\n\n\
1240  --batch Exit after processing options.\n\
1241  --batch-silent Like --batch, but suppress all gdb stdout output.\n\
1242  --return-child-result\n\
1243  GDB exit code will be the child's exit code.\n\
1244  --configuration Print details about GDB configuration and then exit.\n\
1245  --help Print this message and then exit.\n\
1246  --version Print version information and then exit.\n\n\
1247 Remote debugging options:\n\n\
1248  -b BAUDRATE Set serial port baud rate used for remote debugging.\n\
1249  -l TIMEOUT Set timeout in seconds for remote debugging.\n\n\
1250 Other options:\n\n\
1251  --cd=DIR Change current directory to DIR.\n\
1252  --data-directory=DIR, -D\n\
1253  Set GDB's data-directory to DIR.\n\
1254 "), stream);
1255  fputs_unfiltered (_("\n\
1256 At startup, GDB reads the following init files and executes their commands:\n\
1257 "), stream);
1258  if (system_gdbinit)
1259  fprintf_unfiltered (stream, _("\
1260  * system-wide init file: %s\n\
1261 "), system_gdbinit);
1262  if (home_gdbinit)
1263  fprintf_unfiltered (stream, _("\
1264  * user-specific init file: %s\n\
1265 "), home_gdbinit);
1266  if (local_gdbinit)
1267  fprintf_unfiltered (stream, _("\
1268  * local init file (see also 'set auto-load local-gdbinit'): ./%s\n\
1269 "), local_gdbinit);
1270  fputs_unfiltered (_("\n\
1271 For more information, type \"help\" from within GDB, or consult the\n\
1272 GDB manual (available as on-line info or a printed manual).\n\
1273 "), stream);
1274  if (REPORT_BUGS_TO[0] && stream == gdb_stdout)
1275  fprintf_unfiltered (stream, _("\
1276 Report bugs to \"%s\".\n\
1277 "), REPORT_BUGS_TO);
1278 }
int gdb_main(struct captured_main_args *args)
Definition: main.c:1163
Definition: interps.c:48
char * gdb_sysroot
Definition: main.c:57
char * gdb_realpath(const char *filename)
Definition: utils.c:2840
void notice_open_fds(void)
Definition: filestuff.c:168
int saved_command_line_size
Definition: top.c:132
char * lim_at_start
Definition: top.c:170
static void get_init_files(const char **system_gdbinit, const char **home_gdbinit, const char **local_gdbinit)
Definition: main.c:200
char * gdb_abspath(const char *path)
Definition: utils.c:2945
FILE * instream
Definition: top.c:109
struct ui_file * gdb_stdin
Definition: main.c:74
void init_history(void)
Definition: top.c:1729
static char * gdb_program_name
Definition: main.c:94
static int gdb_datadir_provided
Definition: main.c:65
void fputs_unfiltered(const char *buf, struct ui_file *file)
Definition: ui-file.c:252
void xfree(void *)
Definition: common-utils.c:97
#define REPORT_BUGS_TO
Definition: config.h:676
#define textdomain(Domainname)
Definition: gdb_locale.h:38
struct cmdarg cmdarg_s
int remote_timeout
Definition: top.c:162
void clear_quit_flag(void)
Definition: extension.c:793
void warning(const char *fmt,...)
Definition: errors.c:26
#define GDB_DATADIR
Definition: config.h:45
#define INTERP_INSIGHT
Definition: interps.h:114
void( catch_command_errors_const_ftype)(const char *, int)
Definition: main.c:383
void async_enable_stdin(void)
Definition: event-top.c:442
#define INTERP_TUI
Definition: interps.h:113
int auto_load_local_gdbinit_loaded
Definition: auto-load.c:121
char * relocate_gdb_directory(const char *initial, int flag)
Definition: main.c:161
char ** argv
Definition: main.h:26
int inhibit_gdbinit
Definition: top.c:86
struct ui_file * gdb_stdout
Definition: main.c:71
struct ui_file * gdb_stdtargin
Definition: main.c:76
void print_sys_errmsg(const char *string, int errcode)
Definition: utils.c:1001
char * warning_pre_print
Definition: utils.c:141
void quit_force(char *args, int from_tty)
Definition: top.c:1497
void set_inferior_io_terminal(const char *terminal_name)
Definition: infcmd.c:150
int readnow_symbol_files
Definition: symfile.c:82
#define INTERP_MI1
Definition: interps.h:109
int catch_errors(catch_errors_ftype *func, void *func_args, char *errstring, return_mask mask)
Definition: exceptions.c:228
#define INTERP_CONSOLE
Definition: interps.h:108
void set_per_command_time(int new_value)
Definition: maint.c:783
#define VEC_safe_push(T, V, O)
Definition: vec.h:260
int batch_silent
Definition: main.c:84
#define VEC(T)
Definition: vec.h:398
void print_gdb_configuration(struct ui_file *stream)
Definition: top.c:1280
static int catch_command_errors(catch_command_errors_ftype *command, char *arg, int from_tty)
Definition: main.c:361
char * auto_load_local_gdbinit_pathname
Definition: auto-load.c:118
#define _(String)
Definition: gdb_locale.h:40
void core_file_command(char *filename, int from_tty)
Definition: corefile.c:68
void execute_command(char *, int)
Definition: top.c:388
char gdb_dirbuf[1024]
Definition: top.c:120
#define END_CATCH
char * debug_file_directory
Definition: symfile.c:1434
void printf_filtered(const char *format,...)
Definition: utils.c:2388
cmdarg_kind
Definition: main.c:409
#define WITH_PYTHON_PATH
Definition: config.h:767
char * interpreter_p
Definition: main.c:51
static char * relocate_path(const char *progname, const char *initial, int flag)
Definition: main.c:147
#define TARGET_SYSROOT_PREFIX
Definition: gdb_bfd.h:30
struct cleanup * all_cleanups(void)
Definition: cleanups.c:166
#define TARGET_SYSTEM_ROOT_RELOCATABLE
Definition: config.h:724
Definition: main.c:425
#define BINDIR
Definition: config.h:14
#define TRY
static int captured_main(void *data)
Definition: main.c:438
struct ui_file * stderr_fileopen(void)
Definition: ui-file.c:683
#define ALL_OBJFILES(obj)
Definition: objfiles.h:579
int interp_set(struct interp *interp, int top_level)
Definition: interps.c:128
#define VEC_iterate(T, V, I, P)
Definition: vec.h:165
#define SLASH_STRING
Definition: host-defs.h:58
static void print_gdb_help(struct ui_file *)
Definition: main.c:1177
void set_gdb_data_directory(const char *new_datadir)
Definition: main.c:110
int auto_load_local_gdbinit
Definition: auto-load.c:115
#define CATCH(EXCEPTION, MASK)
int write_files
Definition: exec.c:67
void load_auto_scripts_for_objfile(struct objfile *objfile)
Definition: auto-load.c:1194
int baud_rate
Definition: serial.c:639
struct ui_file * ui_file_new(void)
Definition: ui-file.c:57
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2361
void cd_command(char *dir, int from_tty)
Definition: cli-cmds.c:370
void exception_print(struct ui_file *file, struct gdb_exception e)
Definition: exceptions.c:109
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
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
#define GDB_DATADIR_RELOCATABLE
Definition: config.h:49
int annotation_level
Definition: stack.c:109
void( catch_command_errors_ftype)(char *, int)
Definition: main.c:356
int interpreter_async
Definition: interps.c:46
void add_substitute_path_rule(char *from, char *to)
Definition: source.c:1816
void source_script(const char *file, int from_tty)
Definition: cli-cmds.c:619
void perror_warning_with_name(const char *string)
Definition: utils.c:988
const char * get_gdb_program_name(void)
Definition: main.c:98
char * xstrprintf(const char *format,...)
Definition: common-utils.c:107
void wrap_here(char *indent)
Definition: utils.c:1930
int file_is_auto_load_safe(const char *filename, const char *debug_fmt,...)
Definition: auto-load.c:477
int batch_flag
Definition: main.c:81
int global_auto_load
Definition: auto-load.c:112
static void setup_alternate_signal_stack(void)
Definition: main.c:295
void * xmalloc(YYSIZE_T)
void maybe_wait_sync_command_done(int was_sync)
Definition: top.c:370
struct ui_file * gdb_stdlog
Definition: main.c:73
enum cmdarg_kind type
Definition: main.c:427
#define DEBUGDIR_RELOCATABLE
Definition: config.h:29
void symbol_file_add_main(const char *args, int from_tty)
Definition: symfile.c:1309
struct interp * interp_lookup(const char *name)
Definition: interps.c:210
#define SYSTEM_GDBINIT_RELOCATABLE
Definition: config.h:718
void set_inferior_args_vector(int argc, char **argv)
Definition: infcmd.c:218
PTR xrealloc(PTR ptr, size_t size)
Definition: common-utils.c:51
#define PYTHON_PATH_RELOCATABLE
Definition: config.h:670
char * current_directory
Definition: top.c:117
const char const char int
Definition: command.h:229
void exec_file_attach(const char *filename, int from_tty)
Definition: exec.c:195
int dbx_commands
Definition: main.c:54
void attach_command(char *args, int from_tty)
Definition: infcmd.c:2583
char * string
Definition: main.c:431
char * windows_get_absolute_argv0(const char *argv0)
Definition: mingw-hdep.c:42
#define bindtextdomain(Domainname, Dirname)
Definition: gdb_locale.h:39
char * gdb_datadir
Definition: main.c:60
const char * interpreter_p
Definition: main.h:27
struct cleanup * make_command_stats_cleanup(int msg_type)
Definition: maint.c:901
static int catch_command_errors_const(catch_command_errors_const_ftype *command, const char *arg, int from_tty)
Definition: main.c:388
struct ui_file * gdb_stderr
Definition: main.c:72
#define SYSTEM_GDBINIT
Definition: config.h:714
static int handle_command_errors(struct gdb_exception e)
Definition: main.c:339
#define TARGET_SYSTEM_ROOT
Definition: config.h:721
void quit_command(char *args, int from_tty)
Definition: cli-cmds.c:343
const char gdbinit[]
Definition: top.c:84
struct ui_file * gdb_stdtarg
Definition: main.c:77
void directory_switch(char *, int)
Definition: source.c:451
#define VEC_cleanup(T)
Definition: vec.h:187
void set_per_command_space(int new_value)
Definition: maint.c:792
static int captured_command_loop(void *data)
Definition: main.c:312
void gdb_init(char *argv0)
Definition: top.c:1991
struct ui_file * gdb_stdtargerr
Definition: main.c:78
#define PACKAGE
Definition: config.h:618
char * python_libdir
Definition: main.c:69
void gdb_flush(struct ui_file *file)
Definition: ui-file.c:192
struct ui_file * stdio_fileopen(FILE *file)
Definition: ui-file.c:717
char * saved_command_line
Definition: top.c:131
DEF_VEC_O(cmdarg_s)
void current_interp_command_loop(void)
Definition: interps.c:313
int current_interp_named_p(const char *interp_name)
Definition: interps.c:280
void error(const char *fmt,...)
Definition: errors.c:38
int return_child_result_value
Definition: main.c:90
#define DEBUGDIR
Definition: config.h:25
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
enum return_reason reason