gdb/main.c

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