contrib/gdb-7/gdb/main.c

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