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