gdb/main.c

   1 /* Top level stuff for GDB, the GNU debugger.
   2
   3    Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
   4    1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software
   5    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 2 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, write to the Free Software
  21    Foundation, Inc., 59 Temple Place - Suite 330,
  22    Boston, MA 02111-1307, USA.  */
  23
  24 #include "defs.h"
  25 #include "top.h"
  26 #include "target.h"
  27 #include "inferior.h"
  28 #include "symfile.h"
  29 #include "gdbcore.h"
  30
  31 #include "getopt.h"
  32
  33 #include <sys/types.h>
  34 #include "gdb_stat.h"
  35 #include <ctype.h>
  36
  37 #include "gdb_string.h"
  38 #include "event-loop.h"
  39 #include "ui-out.h"
  40
  41 #include "interps.h"
  42 #include "main.h"
  43
  44 /* If nonzero, display time usage both at startup and for each command.  */
  45
  46 int display_time;
  47
  48 /* If nonzero, display space usage both at startup and for each command.  */
  49
  50 int display_space;
  51
  52 /* Whether this is the async version or not.  The async version is
  53    invoked on the command line with the -nw --async options.  In this
  54    version, the usual command_loop is substituted by and event loop which
  55    processes UI events asynchronously. */
  56 int event_loop_p = 1;
  57
  58 /* The selected interpreter.  This will be used as a set command
  59    variable, so it should always be malloc'ed - since
  60    do_setshow_command will free it. */
  61 char *interpreter_p;
  62
  63 /* Whether xdb commands will be handled */
  64 int xdb_commands = 0;
  65
  66 /* Whether dbx commands will be handled */
  67 int dbx_commands = 0;
  68
  69 /* System root path, used to find libraries etc.  */
  70 char *gdb_sysroot = 0;
  71
  72 struct ui_file *gdb_stdout;
  73 struct ui_file *gdb_stderr;
  74 struct ui_file *gdb_stdlog;
  75 struct ui_file *gdb_stdtarg;
  76 struct ui_file *gdb_stdin;
  77 /* target IO streams */
  78 struct ui_file *gdb_stdtargin;
  79 struct ui_file *gdb_stdtargerr;
  80
  81 /* Whether to enable writing into executable and core files */
  82 extern int write_files;
  83
  84 static void print_gdb_help (struct ui_file *);
  85
  86 /* These two are used to set the external editor commands when gdb is farming
  87    out files to be edited by another program. */
  88
  89 extern char *external_editor_command;
  90
  91 /* Call command_loop.  If it happens to return, pass that through as a
  92    non-zero return status. */
  93
  94 static int
  95 captured_command_loop (void *data)
  96 {
  97   current_interp_command_loop ();
  98   /* FIXME: cagney/1999-11-05: A correct command_loop() implementaton
  99      would clean things up (restoring the cleanup chain) to the state
 100      they were just prior to the call.  Technically, this means that
 101      the do_cleanups() below is redundant.  Unfortunately, many FUNCs
 102      are not that well behaved.  do_cleanups should either be replaced
 103      with a do_cleanups call (to cover the problem) or an assertion
 104      check to detect bad FUNCs code. */
 105   do_cleanups (ALL_CLEANUPS);
 106   /* If the command_loop returned, normally (rather than threw an
 107      error) we try to quit. If the quit is aborted, catch_errors()
 108      which called this catch the signal and restart the command
 109      loop. */
 110   quit_command (NULL, instream == stdin);
 111   return 1;
 112 }
 113
 114 static int
 115 captured_main (void *data)
 116 {
 117   struct captured_main_args *context = data;
 118   int argc = context->argc;
 119   char **argv = context->argv;
 120   int count;
 121   static int quiet = 0;
 122   static int batch = 0;
 123   static int set_args = 0;
 124
 125   /* Pointers to various arguments from command line.  */
 126   char *symarg = NULL;
 127   char *execarg = NULL;
 128   char *corearg = NULL;
 129   char *cdarg = NULL;
 130   char *ttyarg = NULL;
 131
 132   /* These are static so that we can take their address in an initializer.  */
 133   static int print_help;
 134   static int print_version;
 135
 136   /* Pointers to all arguments of --command option.  */
 137   char **cmdarg;
 138   /* Allocated size of cmdarg.  */
 139   int cmdsize;
 140   /* Number of elements of cmdarg used.  */
 141   int ncmd;
 142
 143   /* Indices of all arguments of --directory option.  */
 144   char **dirarg;
 145   /* Allocated size.  */
 146   int dirsize;
 147   /* Number of elements used.  */
 148   int ndir;
 149
 150   struct stat homebuf, cwdbuf;
 151   char *homedir, *homeinit;
 152
 153   register int i;
 154
 155   long time_at_startup = get_run_time ();
 156
 157 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
 158   setlocale (LC_MESSAGES, "");
 159 #endif
 160 #if defined (HAVE_SETLOCALE)
 161   setlocale (LC_CTYPE, "");
 162 #endif
 163   bindtextdomain (PACKAGE, LOCALEDIR);
 164   textdomain (PACKAGE);
 165
 166   START_PROGRESS (argv[0], 0);
 167
 168   /* This needs to happen before the first use of malloc.  */
 169   init_malloc (NULL);
 170
 171 #ifdef HAVE_SBRK
 172   lim_at_start = (char *) sbrk (0);
 173 #endif
 174
 175 #if defined (ALIGN_STACK_ON_STARTUP)
 176   i = (int) &count & 0x3;
 177   if (i != 0)
 178     alloca (4 - i);
 179 #endif
 180
 181   cmdsize = 1;
 182   cmdarg = (char **) xmalloc (cmdsize * sizeof (*cmdarg));
 183   ncmd = 0;
 184   dirsize = 1;
 185   dirarg = (char **) xmalloc (dirsize * sizeof (*dirarg));
 186   ndir = 0;
 187
 188   quit_flag = 0;
 189   line = (char *) xmalloc (linesize);
 190   line[0] = '\0';               /* Terminate saved (now empty) cmd line */
 191   instream = stdin;
 192
 193   getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));
 194   current_directory = gdb_dirbuf;
 195
 196   gdb_stdout = stdio_fileopen (stdout);
 197   gdb_stderr = stdio_fileopen (stderr);
 198   gdb_stdlog = gdb_stderr;      /* for moment */
 199   gdb_stdtarg = gdb_stderr;     /* for moment */
 200   gdb_stdin = stdio_fileopen (stdin);
 201   gdb_stdtargerr = gdb_stderr;  /* for moment */
 202   gdb_stdtargin = gdb_stdin;    /* for moment */
 203
 204   /* initialize error() */
 205   error_init ();
 206
 207   /* Set the sysroot path.  */
 208 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
 209   gdb_sysroot = make_relative_prefix (argv[0], BINDIR, TARGET_SYSTEM_ROOT);
 210   if (gdb_sysroot)
 211     {
 212       struct stat s;
 213       int res = 0;
 214
 215       if (stat (gdb_sysroot, &s) == 0)
 216         if (S_ISDIR (s.st_mode))
 217           res = 1;
 218
 219       if (res == 0)
 220         {
 221           xfree (gdb_sysroot);
 222           gdb_sysroot = TARGET_SYSTEM_ROOT;
 223         }
 224     }
 225   else
 226     gdb_sysroot = TARGET_SYSTEM_ROOT;
 227 #else
 228 #if defined (TARGET_SYSTEM_ROOT)
 229   gdb_sysroot = TARGET_SYSTEM_ROOT;
 230 #else
 231   gdb_sysroot = "";
 232 #endif
 233 #endif
 234
 235   /* There will always be an interpreter.  Either the one passed into
 236      this captured main, or one specified by the user at start up, or
 237      the console.  Initialize the interpreter to the one requested by
 238      the application.  */
 239   interpreter_p = xstrdup (context->interpreter_p);
 240
 241   /* Parse arguments and options.  */
 242   {
 243     int c;
 244     /* When var field is 0, use flag field to record the equivalent
 245        short option (or arbitrary numbers starting at 10 for those
 246        with no equivalent).  */
 247     enum {
 248       OPT_SE = 10,
 249       OPT_CD,
 250       OPT_ANNOTATE,
 251       OPT_STATISTICS,
 252       OPT_TUI,
 253       OPT_NOWINDOWS,
 254       OPT_WINDOWS
 255     };
 256     static struct option long_options[] =
 257     {
 258       {"async", no_argument, &event_loop_p, 1},
 259       {"noasync", no_argument, &event_loop_p, 0},
 260 #if defined(TUI)
 261       {"tui", no_argument, 0, OPT_TUI},
 262 #endif
 263       {"xdb", no_argument, &xdb_commands, 1},
 264       {"dbx", no_argument, &dbx_commands, 1},
 265       {"readnow", no_argument, &readnow_symbol_files, 1},
 266       {"r", no_argument, &readnow_symbol_files, 1},
 267       {"mapped", no_argument, &mapped_symbol_files, 1},
 268       {"m", no_argument, &mapped_symbol_files, 1},
 269       {"quiet", no_argument, &quiet, 1},
 270       {"q", no_argument, &quiet, 1},
 271       {"silent", no_argument, &quiet, 1},
 272       {"nx", no_argument, &inhibit_gdbinit, 1},
 273       {"n", no_argument, &inhibit_gdbinit, 1},
 274       {"batch", no_argument, &batch, 1},
 275       {"epoch", no_argument, &epoch_interface, 1},
 276
 277     /* This is a synonym for "--annotate=1".  --annotate is now preferred,
 278        but keep this here for a long time because people will be running
 279        emacses which use --fullname.  */
 280       {"fullname", no_argument, 0, 'f'},
 281       {"f", no_argument, 0, 'f'},
 282
 283       {"annotate", required_argument, 0, OPT_ANNOTATE},
 284       {"help", no_argument, &print_help, 1},
 285       {"se", required_argument, 0, OPT_SE},
 286       {"symbols", required_argument, 0, 's'},
 287       {"s", required_argument, 0, 's'},
 288       {"exec", required_argument, 0, 'e'},
 289       {"e", required_argument, 0, 'e'},
 290       {"core", required_argument, 0, 'c'},
 291       {"c", required_argument, 0, 'c'},
 292       {"pid", required_argument, 0, 'p'},
 293       {"p", required_argument, 0, 'p'},
 294       {"command", required_argument, 0, 'x'},
 295       {"version", no_argument, &print_version, 1},
 296       {"x", required_argument, 0, 'x'},
 297 #ifdef GDBTK
 298       {"tclcommand", required_argument, 0, 'z'},
 299       {"enable-external-editor", no_argument, 0, 'y'},
 300       {"editor-command", required_argument, 0, 'w'},
 301 #endif
 302       {"ui", required_argument, 0, 'i'},
 303       {"interpreter", required_argument, 0, 'i'},
 304       {"i", required_argument, 0, 'i'},
 305       {"directory", required_argument, 0, 'd'},
 306       {"d", required_argument, 0, 'd'},
 307       {"cd", required_argument, 0, OPT_CD},
 308       {"tty", required_argument, 0, 't'},
 309       {"baud", required_argument, 0, 'b'},
 310       {"b", required_argument, 0, 'b'},
 311       {"nw", no_argument, NULL, OPT_NOWINDOWS},
 312       {"nowindows", no_argument, NULL, OPT_NOWINDOWS},
 313       {"w", no_argument, NULL, OPT_WINDOWS},
 314       {"windows", no_argument, NULL, OPT_WINDOWS},
 315       {"statistics", no_argument, 0, OPT_STATISTICS},
 316       {"write", no_argument, &write_files, 1},
 317       {"args", no_argument, &set_args, 1},
 318       {0, no_argument, 0, 0}
 319     };
 320
 321     while (1)
 322       {
 323         int option_index;
 324
 325         c = getopt_long_only (argc, argv, "",
 326                               long_options, &option_index);
 327         if (c == EOF || set_args)
 328           break;
 329
 330         /* Long option that takes an argument.  */
 331         if (c == 0 && long_options[option_index].flag == 0)
 332           c = long_options[option_index].val;
 333
 334         switch (c)
 335           {
 336           case 0:
 337             /* Long option that just sets a flag.  */
 338             break;
 339           case OPT_SE:
 340             symarg = optarg;
 341             execarg = optarg;
 342             break;
 343           case OPT_CD:
 344             cdarg = optarg;
 345             break;
 346           case OPT_ANNOTATE:
 347             /* FIXME: what if the syntax is wrong (e.g. not digits)?  */
 348             annotation_level = atoi (optarg);
 349             break;
 350           case OPT_STATISTICS:
 351             /* Enable the display of both time and space usage.  */
 352             display_time = 1;
 353             display_space = 1;
 354             break;
 355           case OPT_TUI:
 356             /* --tui is equivalent to -i=tui.  */
 357             xfree (interpreter_p);
 358             interpreter_p = xstrdup ("tui");
 359             break;
 360           case OPT_WINDOWS:
 361             /* FIXME: cagney/2003-03-01: Not sure if this option is
 362                actually useful, and if it is, what it should do.  */
 363             use_windows = 1;
 364             break;
 365           case OPT_NOWINDOWS:
 366             /* -nw is equivalent to -i=console.  */
 367             xfree (interpreter_p);
 368             interpreter_p = xstrdup (INTERP_CONSOLE);
 369             use_windows = 0;
 370             break;
 371           case 'f':
 372             annotation_level = 1;
 373 /* We have probably been invoked from emacs.  Disable window interface.  */
 374             use_windows = 0;
 375             break;
 376           case 's':
 377             symarg = optarg;
 378             break;
 379           case 'e':
 380             execarg = optarg;
 381             break;
 382           case 'c':
 383             corearg = optarg;
 384             break;
 385           case 'p':
 386             /* "corearg" is shared by "--core" and "--pid" */
 387             corearg = optarg;
 388             break;
 389           case 'x':
 390             cmdarg[ncmd++] = optarg;
 391             if (ncmd >= cmdsize)
 392               {
 393                 cmdsize *= 2;
 394                 cmdarg = (char **) xrealloc ((char *) cmdarg,
 395                                              cmdsize * sizeof (*cmdarg));
 396               }
 397             break;
 398 #ifdef GDBTK
 399           case 'z':
 400             {
 401 extern int gdbtk_test (char *);
 402               if (!gdbtk_test (optarg))
 403                 {
 404                   fprintf_unfiltered (gdb_stderr, _("%s: unable to load tclcommand file \"%s\""),
 405                                       argv[0], optarg);
 406                   exit (1);
 407                 }
 408               break;
 409             }
 410           case 'y':
 411             /* Backwards compatibility only.  */
 412             break;
 413           case 'w':
 414             {
 415               external_editor_command = xstrdup (optarg);
 416               break;
 417             }
 418 #endif /* GDBTK */
 419           case 'i':
 420             xfree (interpreter_p);
 421             interpreter_p = xstrdup (optarg);
 422             break;
 423           case 'd':
 424             dirarg[ndir++] = optarg;
 425             if (ndir >= dirsize)
 426               {
 427                 dirsize *= 2;
 428                 dirarg = (char **) xrealloc ((char *) dirarg,
 429                                              dirsize * sizeof (*dirarg));
 430               }
 431             break;
 432           case 't':
 433             ttyarg = optarg;
 434             break;
 435           case 'q':
 436             quiet = 1;
 437             break;
 438           case 'b':
 439             {
 440               int i;
 441               char *p;
 442
 443               i = strtol (optarg, &p, 0);
 444               if (i == 0 && p == optarg)
 445
 446                 /* Don't use *_filtered or warning() (which relies on
 447                    current_target) until after initialize_all_files(). */
 448
 449                 fprintf_unfiltered
 450                   (gdb_stderr,
 451                    _("warning: could not set baud rate to `%s'.\n"), optarg);
 452               else
 453                 baud_rate = i;
 454             }
 455             break;
 456           case 'l':
 457             {
 458               int i;
 459               char *p;
 460
 461               i = strtol (optarg, &p, 0);
 462               if (i == 0 && p == optarg)
 463
 464                 /* Don't use *_filtered or warning() (which relies on
 465                    current_target) until after initialize_all_files(). */
 466
 467                 fprintf_unfiltered
 468                   (gdb_stderr,
 469                  _("warning: could not set timeout limit to `%s'.\n"), optarg);
 470               else
 471                 remote_timeout = i;
 472             }
 473             break;
 474
 475           case '?':
 476             fprintf_unfiltered (gdb_stderr,
 477                         _("Use `%s --help' for a complete list of options.\n"),
 478                                 argv[0]);
 479             exit (1);
 480           }
 481       }
 482
 483     /* If --help or --version, disable window interface.  */
 484     if (print_help || print_version)
 485       {
 486         use_windows = 0;
 487       }
 488
 489     if (set_args)
 490       {
 491         /* The remaining options are the command-line options for the
 492            inferior.  The first one is the sym/exec file, and the rest
 493            are arguments.  */
 494         if (optind >= argc)
 495           {
 496             fprintf_unfiltered (gdb_stderr,
 497                                 _("%s: `--args' specified but no program specified\n"),
 498                                 argv[0]);
 499             exit (1);
 500           }
 501         symarg = argv[optind];
 502         execarg = argv[optind];
 503         ++optind;
 504         set_inferior_args_vector (argc - optind, &argv[optind]);
 505       }
 506     else
 507       {
 508         /* OK, that's all the options.  The other arguments are filenames.  */
 509         count = 0;
 510         for (; optind < argc; optind++)
 511           switch (++count)
 512             {
 513             case 1:
 514               symarg = argv[optind];
 515               execarg = argv[optind];
 516               break;
 517             case 2:
 518               /* The documentation says this can be a "ProcID" as well.
 519                  We will try it as both a corefile and a pid.  */
 520               corearg = argv[optind];
 521               break;
 522             case 3:
 523               fprintf_unfiltered (gdb_stderr,
 524                                   _("Excess command line arguments ignored. (%s%s)\n"),
 525                                   argv[optind], (optind == argc - 1) ? "" : " ...");
 526               break;
 527             }
 528       }
 529     if (batch)
 530       quiet = 1;
 531   }
 532
 533   /* Initialize all files.  Give the interpreter a chance to take
 534      control of the console via the init_ui_hook()) */
 535   gdb_init (argv[0]);
 536
 537   /* Do these (and anything which might call wrap_here or *_filtered)
 538      after initialize_all_files() but before the interpreter has been
 539      installed.  Otherwize the help/version messages will be eaten by
 540      the interpreter's output handler.  */
 541
 542   if (print_version)
 543     {
 544       print_gdb_version (gdb_stdout);
 545       wrap_here ("");
 546       printf_filtered ("\n");
 547       exit (0);
 548     }
 549
 550   if (print_help)
 551     {
 552       print_gdb_help (gdb_stdout);
 553       fputs_unfiltered ("\n", gdb_stdout);
 554       exit (0);
 555     }
 556
 557   /* FIXME: cagney/2003-02-03: The big hack (part 1 of 2) that lets
 558      GDB retain the old MI1 interpreter startup behavior.  Output the
 559      copyright message before the interpreter is installed.  That way
 560      it isn't encapsulated in MI output.  */
 561   if (!quiet && strcmp (interpreter_p, INTERP_MI1) == 0)
 562     {
 563       /* Print all the junk at the top, with trailing "..." if we are about
 564          to read a symbol file (possibly slowly).  */
 565       print_gdb_version (gdb_stdout);
 566       if (symarg)
 567         printf_filtered ("..");
 568       wrap_here ("");
 569       gdb_flush (gdb_stdout);   /* Force to screen during slow operations */
 570     }
 571
 572
 573   /* Install the default UI.  All the interpreters should have had a
 574      look at things by now.  Initialize the default interpreter. */
 575
 576   {
 577     /* Find it.  */
 578     struct interp *interp = interp_lookup (interpreter_p);
 579     if (interp == NULL)
 580       error ("Interpreter `%s' unrecognized", interpreter_p);
 581     /* Install it.  */
 582     if (!interp_set (interp))
 583       {
 584         fprintf_unfiltered (gdb_stderr,
 585                             "Interpreter `%s' failed to initialize.\n",
 586                             interpreter_p);
 587         exit (1);
 588       }
 589   }
 590
 591   /* FIXME: cagney/2003-02-03: The big hack (part 2 of 2) that lets
 592      GDB retain the old MI1 interpreter startup behavior.  Output the
 593      copyright message after the interpreter is installed when it is
 594      any sane interpreter.  */
 595   if (!quiet && !current_interp_named_p (INTERP_MI1))
 596     {
 597       /* Print all the junk at the top, with trailing "..." if we are about
 598          to read a symbol file (possibly slowly).  */
 599       print_gdb_version (gdb_stdout);
 600       if (symarg)
 601         printf_filtered ("..");
 602       wrap_here ("");
 603       gdb_flush (gdb_stdout);   /* Force to screen during slow operations */
 604     }
 605
 606   error_pre_print = "\n\n";
 607   quit_pre_print = error_pre_print;
 608
 609   /* We may get more than one warning, don't double space all of them... */
 610   warning_pre_print = _("\nwarning: ");
 611
 612   /* Read and execute $HOME/.gdbinit file, if it exists.  This is done
 613      *before* all the command line arguments are processed; it sets
 614      global parameters, which are independent of what file you are
 615      debugging or what directory you are in.  */
 616   homedir = getenv ("HOME");
 617   if (homedir)
 618     {
 619       homeinit = (char *) alloca (strlen (homedir) +
 620                                   strlen (gdbinit) + 10);
 621       strcpy (homeinit, homedir);
 622       strcat (homeinit, "/");
 623       strcat (homeinit, gdbinit);
 624
 625       if (!inhibit_gdbinit)
 626         {
 627           catch_command_errors (source_command, homeinit, 0, RETURN_MASK_ALL);
 628         }
 629
 630       /* Do stats; no need to do them elsewhere since we'll only
 631          need them if homedir is set.  Make sure that they are
 632          zero in case one of them fails (this guarantees that they
 633          won't match if either exists).  */
 634
 635       memset (&homebuf, 0, sizeof (struct stat));
 636       memset (&cwdbuf, 0, sizeof (struct stat));
 637
 638       stat (homeinit, &homebuf);
 639       stat (gdbinit, &cwdbuf);  /* We'll only need this if
 640                                    homedir was set.  */
 641     }
 642
 643   /* Now perform all the actions indicated by the arguments.  */
 644   if (cdarg != NULL)
 645     {
 646       catch_command_errors (cd_command, cdarg, 0, RETURN_MASK_ALL);
 647     }
 648
 649   for (i = 0; i < ndir; i++)
 650     catch_command_errors (directory_command, dirarg[i], 0, RETURN_MASK_ALL);
 651   xfree (dirarg);
 652
 653   if (execarg != NULL
 654       && symarg != NULL
 655       && strcmp (execarg, symarg) == 0)
 656     {
 657       /* The exec file and the symbol-file are the same.  If we can't
 658          open it, better only print one error message.
 659          catch_command_errors returns non-zero on success! */
 660       if (catch_command_errors (exec_file_attach, execarg, !batch, RETURN_MASK_ALL))
 661         catch_command_errors (symbol_file_add_main, symarg, 0, RETURN_MASK_ALL);
 662     }
 663   else
 664     {
 665       if (execarg != NULL)
 666         catch_command_errors (exec_file_attach, execarg, !batch, RETURN_MASK_ALL);
 667       if (symarg != NULL)
 668         catch_command_errors (symbol_file_add_main, symarg, 0, RETURN_MASK_ALL);
 669     }
 670
 671   /* After the symbol file has been read, print a newline to get us
 672      beyond the copyright line...  But errors should still set off
 673      the error message with a (single) blank line.  */
 674   if (!quiet)
 675     printf_filtered ("\n");
 676   error_pre_print = "\n";
 677   quit_pre_print = error_pre_print;
 678   warning_pre_print = _("\nwarning: ");
 679
 680   if (corearg != NULL)
 681     {
 682       /* corearg may be either a corefile or a pid.
 683          If its first character is a digit, try attach first
 684          and then corefile.  Otherwise try corefile first. */
 685
 686       if (isdigit (corearg[0]))
 687         {
 688           if (catch_command_errors (attach_command, corearg,
 689                                     !batch, RETURN_MASK_ALL) == 0)
 690             catch_command_errors (core_file_command, corearg,
 691                                   !batch, RETURN_MASK_ALL);
 692         }
 693       else /* Can't be a pid, better be a corefile. */
 694         catch_command_errors (core_file_command, corearg,
 695                               !batch, RETURN_MASK_ALL);
 696     }
 697
 698   if (ttyarg != NULL)
 699     catch_command_errors (tty_command, ttyarg, !batch, RETURN_MASK_ALL);
 700
 701   /* Error messages should no longer be distinguished with extra output. */
 702   error_pre_print = NULL;
 703   quit_pre_print = NULL;
 704   warning_pre_print = _("warning: ");
 705
 706   /* Read the .gdbinit file in the current directory, *if* it isn't
 707      the same as the $HOME/.gdbinit file (it should exist, also).  */
 708
 709   if (!homedir
 710       || memcmp ((char *) &homebuf, (char *) &cwdbuf, sizeof (struct stat)))
 711     if (!inhibit_gdbinit)
 712       {
 713         catch_command_errors (source_command, gdbinit, 0, RETURN_MASK_ALL);
 714       }
 715
 716   for (i = 0; i < ncmd; i++)
 717     {
 718 #if 0
 719       /* NOTE: cagney/1999-11-03: SET_TOP_LEVEL() was a macro that
 720          expanded into a call to setjmp().  */
 721       if (!SET_TOP_LEVEL ()) /* NB: This is #if 0'd out */
 722         {
 723           /* NOTE: I am commenting this out, because it is not clear
 724              where this feature is used. It is very old and
 725              undocumented. ezannoni: 1999-05-04 */
 726 #if 0
 727           if (cmdarg[i][0] == '-' && cmdarg[i][1] == '\0')
 728             read_command_file (stdin);
 729           else
 730 #endif
 731             source_command (cmdarg[i], !batch);
 732           do_cleanups (ALL_CLEANUPS);
 733         }
 734 #endif
 735       catch_command_errors (source_command, cmdarg[i], !batch, RETURN_MASK_ALL);
 736     }
 737   xfree (cmdarg);
 738
 739   /* Read in the old history after all the command files have been read. */
 740   init_history ();
 741
 742   if (batch)
 743     {
 744       /* We have hit the end of the batch file.  */
 745       exit (0);
 746     }
 747
 748   /* Do any host- or target-specific hacks.  This is used for i960 targets
 749      to force the user to set a nindy target and spec its parameters.  */
 750
 751 #ifdef BEFORE_MAIN_LOOP_HOOK
 752   BEFORE_MAIN_LOOP_HOOK;
 753 #endif
 754
 755   END_PROGRESS (argv[0]);
 756
 757   /* Show time and/or space usage.  */
 758
 759   if (display_time)
 760     {
 761       long init_time = get_run_time () - time_at_startup;
 762
 763       printf_unfiltered (_("Startup time: %ld.%06ld\n"),
 764                          init_time / 1000000, init_time % 1000000);
 765     }
 766
 767   if (display_space)
 768     {
 769 #ifdef HAVE_SBRK
 770       extern char **environ;
 771       char *lim = (char *) sbrk (0);
 772
 773       printf_unfiltered (_("Startup size: data size %ld\n"),
 774                          (long) (lim - (char *) &environ));
 775 #endif
 776     }
 777
 778 #if 0
 779   /* FIXME: cagney/1999-11-06: The original main loop was like: */
 780   while (1)
 781     {
 782       if (!SET_TOP_LEVEL ())
 783         {
 784           do_cleanups (ALL_CLEANUPS);   /* Do complete cleanup */
 785           /* GUIs generally have their own command loop, mainloop, or whatever.
 786              This is a good place to gain control because many error
 787              conditions will end up here via longjmp(). */
 788           if (command_loop_hook)
 789             command_loop_hook ();
 790           else
 791             command_loop ();
 792           quit_command ((char *) 0, instream == stdin);
 793         }
 794     }
 795   /* NOTE: If the command_loop() returned normally, the loop would
 796      attempt to exit by calling the function quit_command().  That
 797      function would either call exit() or throw an error returning
 798      control to SET_TOP_LEVEL. */
 799   /* NOTE: The function do_cleanups() was called once each time round
 800      the loop.  The usefulness of the call isn't clear.  If an error
 801      was thrown, everything would have already been cleaned up.  If
 802      command_loop() returned normally and quit_command() was called,
 803      either exit() or error() (again cleaning up) would be called. */
 804 #endif
 805   /* NOTE: cagney/1999-11-07: There is probably no reason for not
 806      moving this loop and the code found in captured_command_loop()
 807      into the command_loop() proper.  The main thing holding back that
 808      change - SET_TOP_LEVEL() - has been eliminated. */
 809   while (1)
 810     {
 811       catch_errors (captured_command_loop, 0, "", RETURN_MASK_ALL);
 812     }
 813   /* No exit -- exit is through quit_command.  */
 814 }
 815
 816 int
 817 gdb_main (struct captured_main_args *args)
 818 {
 819   use_windows = args->use_windows;
 820   catch_errors (captured_main, args, "", RETURN_MASK_ALL);
 821   /* The only way to end up here is by an error (normal exit is
 822      handled by quit_force()), hence always return an error status.  */
 823   return 1;
 824 }
 825
 826
 827 /* Don't use *_filtered for printing help.  We don't want to prompt
 828    for continue no matter how small the screen or how much we're going
 829    to print.  */
 830
 831 static void
 832 print_gdb_help (struct ui_file *stream)
 833 {
 834   fputs_unfiltered (_("\
 835 This is the GNU debugger.  Usage:\n\n\
 836     gdb [options] [executable-file [core-file or process-id]]\n\
 837     gdb [options] --args executable-file [inferior-arguments ...]\n\n\
 838 Options:\n\n\
 839 "), stream);
 840   fputs_unfiltered (_("\
 841   --args             Arguments after executable-file are passed to inferior\n\
 842 "), stream);
 843   fputs_unfiltered (_("\
 844   --[no]async        Enable (disable) asynchronous version of CLI\n\
 845 "), stream);
 846   fputs_unfiltered (_("\
 847   -b BAUDRATE        Set serial port baud rate used for remote debugging.\n\
 848   --batch            Exit after processing options.\n\
 849   --cd=DIR           Change current directory to DIR.\n\
 850   --command=FILE     Execute GDB commands from FILE.\n\
 851   --core=COREFILE    Analyze the core dump COREFILE.\n\
 852   --pid=PID          Attach to running process PID.\n\
 853 "), stream);
 854   fputs_unfiltered (_("\
 855   --dbx              DBX compatibility mode.\n\
 856   --directory=DIR    Search for source files in DIR.\n\
 857   --epoch            Output information used by epoch emacs-GDB interface.\n\
 858   --exec=EXECFILE    Use EXECFILE as the executable.\n\
 859   --fullname         Output information used by emacs-GDB interface.\n\
 860   --help             Print this message.\n\
 861 "), stream);
 862   fputs_unfiltered (_("\
 863   --interpreter=INTERP\n\
 864                      Select a specific interpreter / user interface\n\
 865 "), stream);
 866   fputs_unfiltered (_("\
 867   --mapped           Use mapped symbol files if supported on this system.\n\
 868   --nw               Do not use a window interface.\n\
 869   --nx               Do not read "), stream);
 870   fputs_unfiltered (gdbinit, stream);
 871   fputs_unfiltered (_(" file.\n\
 872   --quiet            Do not print version number on startup.\n\
 873   --readnow          Fully read symbol files on first access.\n\
 874 "), stream);
 875   fputs_unfiltered (_("\
 876   --se=FILE          Use FILE as symbol file and executable file.\n\
 877   --symbols=SYMFILE  Read symbols from SYMFILE.\n\
 878   --tty=TTY          Use TTY for input/output by the program being debugged.\n\
 879 "), stream);
 880 #if defined(TUI)
 881   fputs_unfiltered (_("\
 882   --tui              Use a terminal user interface.\n\
 883 "), stream);
 884 #endif
 885   fputs_unfiltered (_("\
 886   --version          Print version information and then exit.\n\
 887   -w                 Use a window interface.\n\
 888   --write            Set writing into executable and core files.\n\
 889   --xdb              XDB compatibility mode.\n\
 890 "), stream);
 891   fputs_unfiltered (_("\n\
 892 For more information, type \"help\" from within GDB, or consult the\n\
 893 GDB manual (available as on-line info or a printed manual).\n\
 894 Report bugs to \"bug-gdb@gnu.org\".\
 895 "), stream);
 896 }