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