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