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, 2005
   5    Free Software Foundation, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 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 "exceptions.h"
  32 #include "getopt.h"
  33
  34 #include <sys/types.h>
  35 #include "gdb_stat.h"
  36 #include <ctype.h>
  37
  38 #include "gdb_string.h"
  39 #include "event-loop.h"
  40 #include "ui-out.h"
  41
  42 #include "interps.h"
  43 #include "main.h"
  44
  45 /* If nonzero, display time usage both at startup and for each command.  */
  46
  47 int display_time;
  48
  49 /* If nonzero, display space usage both at startup and for each command.  */
  50
  51 int display_space;
  52
  53 /* The selected interpreter.  This will be used as a set command
  54    variable, so it should always be malloc'ed - since
  55    do_setshow_command will free it. */
  56 char *interpreter_p;
  57
  58 /* Whether xdb commands will be handled */
  59 int xdb_commands = 0;
  60
  61 /* Whether dbx commands will be handled */
  62 int dbx_commands = 0;
  63
  64 /* System root path, used to find libraries etc.  */
  65 char *gdb_sysroot = 0;
  66
  67 struct ui_file *gdb_stdout;
  68 struct ui_file *gdb_stderr;
  69 struct ui_file *gdb_stdlog;
  70 struct ui_file *gdb_stdin;
  71 /* target IO streams */
  72 struct ui_file *gdb_stdtargin;
  73 struct ui_file *gdb_stdtarg;
  74 struct ui_file *gdb_stdtargerr;
  75
  76 /* Support for the --batch-silent option.  */
  77 int batch_silent = 0;
  78
  79 /* Support for --return-child-result option.
  80    Set the default to -1 to return error in the case
  81    that the program does not run or does not complete.  */
  82 int return_child_result = 0;
  83 int return_child_result_value = -1;
  84
  85 /* Whether to enable writing into executable and core files */
  86 extern int write_files;
  87
  88 static void print_gdb_help (struct ui_file *);
  89
  90 /* These two are used to set the external editor commands when gdb is farming
  91    out files to be edited by another program. */
  92
  93 extern char *external_editor_command;
  94
  95 /* Call command_loop.  If it happens to return, pass that through as a
  96    non-zero return status. */
  97
  98 static int
  99 captured_command_loop (void *data)
 100 {
 101   current_interp_command_loop ();
 102   /* FIXME: cagney/1999-11-05: A correct command_loop() implementaton
 103      would clean things up (restoring the cleanup chain) to the state
 104      they were just prior to the call.  Technically, this means that
 105      the do_cleanups() below is redundant.  Unfortunately, many FUNCs
 106      are not that well behaved.  do_cleanups should either be replaced
 107      with a do_cleanups call (to cover the problem) or an assertion
 108      check to detect bad FUNCs code. */
 109   do_cleanups (ALL_CLEANUPS);
 110   /* If the command_loop returned, normally (rather than threw an
 111      error) we try to quit. If the quit is aborted, catch_errors()
 112      which called this catch the signal and restart the command
 113      loop. */
 114   quit_command (NULL, instream == stdin);
 115   return 1;
 116 }
 117
 118 static int
 119 captured_main (void *data)
 120 {
 121   struct captured_main_args *context = data;
 122   int argc = context->argc;
 123   char **argv = context->argv;
 124   int count;
 125   static int quiet = 0;
 126   static int batch = 0;
 127   static int set_args = 0;
 128
 129   /* Pointers to various arguments from command line.  */
 130   char *symarg = NULL;
 131   char *execarg = NULL;
 132   char *corearg = NULL;
 133   char *cdarg = NULL;
 134   char *ttyarg = NULL;
 135
 136   /* These are static so that we can take their address in an initializer.  */
 137   static int print_help;
 138   static int print_version;
 139
 140   /* Pointers to all arguments of --command option.  */
 141   char **cmdarg;
 142   /* Allocated size of cmdarg.  */
 143   int cmdsize;
 144   /* Number of elements of cmdarg used.  */
 145   int ncmd;
 146
 147   /* Indices of all arguments of --directory option.  */
 148   char **dirarg;
 149   /* Allocated size.  */
 150   int dirsize;
 151   /* Number of elements used.  */
 152   int ndir;
 153
 154   struct stat homebuf, cwdbuf;
 155   char *homedir;
 156
 157   int i;
 158
 159   long time_at_startup = get_run_time ();
 160
 161 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
 162   setlocale (LC_MESSAGES, "");
 163 #endif
 164 #if defined (HAVE_SETLOCALE)
 165   setlocale (LC_CTYPE, "");
 166 #endif
 167   bindtextdomain (PACKAGE, LOCALEDIR);
 168   textdomain (PACKAGE);
 169
 170 #ifdef HAVE_SBRK
 171   lim_at_start = (char *) sbrk (0);
 172 #endif
 173
 174 #if defined (ALIGN_STACK_ON_STARTUP)
 175   i = (int) &count & 0x3;
 176   if (i != 0)
 177     alloca (4 - i);
 178 #endif
 179
 180   cmdsize = 1;
 181   cmdarg = (char **) xmalloc (cmdsize * sizeof (*cmdarg));
 182   ncmd = 0;
 183   dirsize = 1;
 184   dirarg = (char **) xmalloc (dirsize * sizeof (*dirarg));
 185   ndir = 0;
 186
 187   quit_flag = 0;
 188   line = (char *) xmalloc (linesize);
 189   line[0] = '\0';               /* Terminate saved (now empty) cmd line */
 190   instream = stdin;
 191
 192   getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));
 193   current_directory = gdb_dirbuf;
 194
 195   gdb_stdout = stdio_fileopen (stdout);
 196   gdb_stderr = stdio_fileopen (stderr);
 197   gdb_stdlog = gdb_stderr;      /* for moment */
 198   gdb_stdtarg = gdb_stderr;     /* for moment */
 199   gdb_stdin = stdio_fileopen (stdin);
 200   gdb_stdtargerr = gdb_stderr;  /* for moment */
 201   gdb_stdtargin = gdb_stdin;    /* for moment */
 202
 203   /* Set the sysroot path.  */
 204 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
 205   gdb_sysroot = make_relative_prefix (argv[0], BINDIR, TARGET_SYSTEM_ROOT);
 206   if (gdb_sysroot)
 207     {
 208       struct stat s;
 209       int res = 0;
 210
 211       if (stat (gdb_sysroot, &s) == 0)
 212         if (S_ISDIR (s.st_mode))
 213           res = 1;
 214
 215       if (res == 0)
 216         {
 217           xfree (gdb_sysroot);
 218           gdb_sysroot = TARGET_SYSTEM_ROOT;
 219         }
 220     }
 221   else
 222     gdb_sysroot = TARGET_SYSTEM_ROOT;
 223 #else
 224 #if defined (TARGET_SYSTEM_ROOT)
 225   gdb_sysroot = TARGET_SYSTEM_ROOT;
 226 #else
 227   gdb_sysroot = "";
 228 #endif
 229 #endif
 230
 231   /* There will always be an interpreter.  Either the one passed into
 232      this captured main, or one specified by the user at start up, or
 233      the console.  Initialize the interpreter to the one requested by
 234      the application.  */
 235   interpreter_p = xstrdup (context->interpreter_p);
 236
 237   /* Parse arguments and options.  */
 238   {
 239     int c;
 240     /* When var field is 0, use flag field to record the equivalent
 241        short option (or arbitrary numbers starting at 10 for those
 242        with no equivalent).  */
 243     enum {
 244       OPT_SE = 10,
 245       OPT_CD,
 246       OPT_ANNOTATE,
 247       OPT_STATISTICS,
 248       OPT_TUI,
 249       OPT_NOWINDOWS,
 250       OPT_WINDOWS
 251     };
 252     static struct option long_options[] =
 253     {
 254 #if defined(TUI)
 255       {"tui", no_argument, 0, OPT_TUI},
 256 #endif
 257       {"xdb", no_argument, &xdb_commands, 1},
 258       {"dbx", no_argument, &dbx_commands, 1},
 259       {"readnow", no_argument, &readnow_symbol_files, 1},
 260       {"r", no_argument, &readnow_symbol_files, 1},
 261       {"quiet", no_argument, &quiet, 1},
 262       {"q", no_argument, &quiet, 1},
 263       {"silent", no_argument, &quiet, 1},
 264       {"nx", no_argument, &inhibit_gdbinit, 1},
 265       {"n", no_argument, &inhibit_gdbinit, 1},
 266       {"batch-silent", no_argument, 0, 'B'},
 267       {"batch", no_argument, &batch, 1},
 268       {"epoch", no_argument, &epoch_interface, 1},
 269
 270     /* This is a synonym for "--annotate=1".  --annotate is now preferred,
 271        but keep this here for a long time because people will be running
 272        emacses which use --fullname.  */
 273       {"fullname", no_argument, 0, 'f'},
 274       {"f", no_argument, 0, 'f'},
 275
 276       {"annotate", required_argument, 0, OPT_ANNOTATE},
 277       {"help", no_argument, &print_help, 1},
 278       {"se", required_argument, 0, OPT_SE},
 279       {"symbols", required_argument, 0, 's'},
 280       {"s", required_argument, 0, 's'},
 281       {"exec", required_argument, 0, 'e'},
 282       {"e", required_argument, 0, 'e'},
 283       {"core", required_argument, 0, 'c'},
 284       {"c", required_argument, 0, 'c'},
 285       {"pid", required_argument, 0, 'p'},
 286       {"p", required_argument, 0, 'p'},
 287       {"command", required_argument, 0, 'x'},
 288       {"version", no_argument, &print_version, 1},
 289       {"x", required_argument, 0, 'x'},
 290 #ifdef GDBTK
 291       {"tclcommand", required_argument, 0, 'z'},
 292       {"enable-external-editor", no_argument, 0, 'y'},
 293       {"editor-command", required_argument, 0, 'w'},
 294 #endif
 295       {"ui", required_argument, 0, 'i'},
 296       {"interpreter", required_argument, 0, 'i'},
 297       {"i", required_argument, 0, 'i'},
 298       {"directory", required_argument, 0, 'd'},
 299       {"d", required_argument, 0, 'd'},
 300       {"cd", required_argument, 0, OPT_CD},
 301       {"tty", required_argument, 0, 't'},
 302       {"baud", required_argument, 0, 'b'},
 303       {"b", required_argument, 0, 'b'},
 304       {"nw", no_argument, NULL, OPT_NOWINDOWS},
 305       {"nowindows", no_argument, NULL, OPT_NOWINDOWS},
 306       {"w", no_argument, NULL, OPT_WINDOWS},
 307       {"windows", no_argument, NULL, OPT_WINDOWS},
 308       {"statistics", no_argument, 0, OPT_STATISTICS},
 309       {"write", no_argument, &write_files, 1},
 310       {"args", no_argument, &set_args, 1},
 311      {"l", required_argument, 0, 'l'},
 312       {"return-child-result", no_argument, &return_child_result, 1},
 313       {0, no_argument, 0, 0}
 314     };
 315
 316     while (1)
 317       {
 318         int option_index;
 319
 320         c = getopt_long_only (argc, argv, "",
 321                               long_options, &option_index);
 322         if (c == EOF || set_args)
 323           break;
 324
 325         /* Long option that takes an argument.  */
 326         if (c == 0 && long_options[option_index].flag == 0)
 327           c = long_options[option_index].val;
 328
 329         switch (c)
 330           {
 331           case 0:
 332             /* Long option that just sets a flag.  */
 333             break;
 334           case OPT_SE:
 335             symarg = optarg;
 336             execarg = optarg;
 337             break;
 338           case OPT_CD:
 339             cdarg = optarg;
 340             break;
 341           case OPT_ANNOTATE:
 342             /* FIXME: what if the syntax is wrong (e.g. not digits)?  */
 343             annotation_level = atoi (optarg);
 344             break;
 345           case OPT_STATISTICS:
 346             /* Enable the display of both time and space usage.  */
 347             display_time = 1;
 348             display_space = 1;
 349             break;
 350           case OPT_TUI:
 351             /* --tui is equivalent to -i=tui.  */
 352             xfree (interpreter_p);
 353             interpreter_p = xstrdup ("tui");
 354             break;
 355           case OPT_WINDOWS:
 356             /* FIXME: cagney/2003-03-01: Not sure if this option is
 357                actually useful, and if it is, what it should do.  */
 358             use_windows = 1;
 359             break;
 360           case OPT_NOWINDOWS:
 361             /* -nw is equivalent to -i=console.  */
 362             xfree (interpreter_p);
 363             interpreter_p = xstrdup (INTERP_CONSOLE);
 364             use_windows = 0;
 365             break;
 366           case 'f':
 367             annotation_level = 1;
 368 /* We have probably been invoked from emacs.  Disable window interface.  */
 369             use_windows = 0;
 370             break;
 371           case 's':
 372             symarg = optarg;
 373             break;
 374           case 'e':
 375             execarg = optarg;
 376             break;
 377           case 'c':
 378             corearg = optarg;
 379             break;
 380           case 'p':
 381             /* "corearg" is shared by "--core" and "--pid" */
 382             corearg = optarg;
 383             break;
 384           case 'x':
 385             cmdarg[ncmd++] = optarg;
 386             if (ncmd >= cmdsize)
 387               {
 388                 cmdsize *= 2;
 389                 cmdarg = (char **) xrealloc ((char *) cmdarg,
 390                                              cmdsize * sizeof (*cmdarg));
 391               }
 392             break;
 393           case 'B':
 394             batch = batch_silent = 1;
 395             gdb_stdout = ui_file_new();
 396             break;
 397 #ifdef GDBTK
 398           case 'z':
 399             {
 400 extern int gdbtk_test (char *);
 401               if (!gdbtk_test (optarg))
 402                 {
 403                   fprintf_unfiltered (gdb_stderr, _("%s: unable to load tclcommand file \"%s\""),
 404                                       argv[0], optarg);
 405                   exit (1);
 406                 }
 407               break;
 408             }
 409           case 'y':
 410             /* Backwards compatibility only.  */
 411             break;
 412           case 'w':
 413             {
 414               external_editor_command = xstrdup (optarg);
 415               break;
 416             }
 417 #endif /* GDBTK */
 418           case 'i':
 419             xfree (interpreter_p);
 420             interpreter_p = xstrdup (optarg);
 421             break;
 422           case 'd':
 423             dirarg[ndir++] = optarg;
 424             if (ndir >= dirsize)
 425               {
 426                 dirsize *= 2;
 427                 dirarg = (char **) xrealloc ((char *) dirarg,
 428                                              dirsize * sizeof (*dirarg));
 429               }
 430             break;
 431           case 't':
 432             ttyarg = optarg;
 433             break;
 434           case 'q':
 435             quiet = 1;
 436             break;
 437           case 'b':
 438             {
 439               int i;
 440               char *p;
 441
 442               i = strtol (optarg, &p, 0);
 443               if (i == 0 && p == optarg)
 444
 445                 /* Don't use *_filtered or warning() (which relies on
 446                    current_target) until after initialize_all_files(). */
 447
 448                 fprintf_unfiltered
 449                   (gdb_stderr,
 450                    _("warning: could not set baud rate to `%s'.\n"), optarg);
 451               else
 452                 baud_rate = i;
 453             }
 454             break;
 455           case 'l':
 456             {
 457               int i;
 458               char *p;
 459
 460               i = strtol (optarg, &p, 0);
 461               if (i == 0 && p == optarg)
 462
 463                 /* Don't use *_filtered or warning() (which relies on
 464                    current_target) until after initialize_all_files(). */
 465
 466                 fprintf_unfiltered
 467                   (gdb_stderr,
 468                  _("warning: could not set timeout limit to `%s'.\n"), optarg);
 469               else
 470                 remote_timeout = i;
 471             }
 472             break;
 473
 474           case '?':
 475             fprintf_unfiltered (gdb_stderr,
 476                         _("Use `%s --help' for a complete list of options.\n"),
 477                                 argv[0]);
 478             exit (1);
 479           }
 480       }
 481
 482     /* If --help or --version, disable window interface.  */
 483     if (print_help || print_version)
 484       {
 485         use_windows = 0;
 486       }
 487
 488     if (set_args)
 489       {
 490         /* The remaining options are the command-line options for the
 491            inferior.  The first one is the sym/exec file, and the rest
 492            are arguments.  */
 493         if (optind >= argc)
 494           {
 495             fprintf_unfiltered (gdb_stderr,
 496                                 _("%s: `--args' specified but no program specified\n"),
 497                                 argv[0]);
 498             exit (1);
 499           }
 500         symarg = argv[optind];
 501         execarg = argv[optind];
 502         ++optind;
 503         set_inferior_args_vector (argc - optind, &argv[optind]);
 504       }
 505     else
 506       {
 507         /* OK, that's all the options.  The other arguments are filenames.  */
 508         count = 0;
 509         for (; optind < argc; optind++)
 510           switch (++count)
 511             {
 512             case 1:
 513               symarg = argv[optind];
 514               execarg = argv[optind];
 515               break;
 516             case 2:
 517               /* The documentation says this can be a "ProcID" as well.
 518                  We will try it as both a corefile and a pid.  */
 519               corearg = argv[optind];
 520               break;
 521             case 3:
 522               fprintf_unfiltered (gdb_stderr,
 523                                   _("Excess command line arguments ignored. (%s%s)\n"),
 524                                   argv[optind], (optind == argc - 1) ? "" : " ...");
 525               break;
 526             }
 527       }
 528     if (batch)
 529       quiet = 1;
 530   }
 531
 532   /* Initialize all files.  Give the interpreter a chance to take
 533      control of the console via the deprecated_init_ui_hook ().  */
 534   gdb_init (argv[0]);
 535
 536   /* Do these (and anything which might call wrap_here or *_filtered)
 537      after initialize_all_files() but before the interpreter has been
 538      installed.  Otherwize the help/version messages will be eaten by
 539      the interpreter's output handler.  */
 540
 541   if (print_version)
 542     {
 543       print_gdb_version (gdb_stdout);
 544       wrap_here ("");
 545       printf_filtered ("\n");
 546       exit (0);
 547     }
 548
 549   if (print_help)
 550     {
 551       print_gdb_help (gdb_stdout);
 552       fputs_unfiltered ("\n", gdb_stdout);
 553       exit (0);
 554     }
 555
 556   /* FIXME: cagney/2003-02-03: The big hack (part 1 of 2) that lets
 557      GDB retain the old MI1 interpreter startup behavior.  Output the
 558      copyright message before the interpreter is installed.  That way
 559      it isn't encapsulated in MI output.  */
 560   if (!quiet && strcmp (interpreter_p, INTERP_MI1) == 0)
 561     {
 562       /* Print all the junk at the top, with trailing "..." if we are about
 563          to read a symbol file (possibly slowly).  */
 564       print_gdb_version (gdb_stdout);
 565       if (symarg)
 566         printf_filtered ("..");
 567       wrap_here ("");
 568       gdb_flush (gdb_stdout);   /* Force to screen during slow operations */
 569     }
 570
 571
 572   /* Install the default UI.  All the interpreters should have had a
 573      look at things by now.  Initialize the default interpreter. */
 574
 575   {
 576     /* Find it.  */
 577     struct interp *interp = interp_lookup (interpreter_p);
 578     if (interp == NULL)
 579       error (_("Interpreter `%s' unrecognized"), interpreter_p);
 580     /* Install it.  */
 581     if (!interp_set (interp))
 582       {
 583         fprintf_unfiltered (gdb_stderr,
 584                             "Interpreter `%s' failed to initialize.\n",
 585                             interpreter_p);
 586         exit (1);
 587       }
 588   }
 589
 590   /* FIXME: cagney/2003-02-03: The big hack (part 2 of 2) that lets
 591      GDB retain the old MI1 interpreter startup behavior.  Output the
 592      copyright message after the interpreter is installed when it is
 593      any sane interpreter.  */
 594   if (!quiet && !current_interp_named_p (INTERP_MI1))
 595     {
 596       /* Print all the junk at the top, with trailing "..." if we are about
 597          to read a symbol file (possibly slowly).  */
 598       print_gdb_version (gdb_stdout);
 599       if (symarg)
 600         printf_filtered ("..");
 601       wrap_here ("");
 602       gdb_flush (gdb_stdout);   /* Force to screen during slow operations */
 603     }
 604
 605   error_pre_print = "\n\n";
 606   quit_pre_print = error_pre_print;
 607
 608   /* We may get more than one warning, don't double space all of them... */
 609   warning_pre_print = _("\nwarning: ");
 610
 611   /* Read and execute $HOME/.gdbinit file, if it exists.  This is done
 612      *before* all the command line arguments are processed; it sets
 613      global parameters, which are independent of what file you are
 614      debugging or what directory you are in.  */
 615   homedir = getenv ("HOME");
 616   if (homedir)
 617     {
 618       char *homeinit = xstrprintf ("%s/%s", homedir, gdbinit);
 619
 620       if (!inhibit_gdbinit)
 621         {
 622           catch_command_errors (source_command, homeinit, 0, RETURN_MASK_ALL);
 623         }
 624
 625       /* Do stats; no need to do them elsewhere since we'll only
 626          need them if homedir is set.  Make sure that they are
 627          zero in case one of them fails (this guarantees that they
 628          won't match if either exists).  */
 629
 630       memset (&homebuf, 0, sizeof (struct stat));
 631       memset (&cwdbuf, 0, sizeof (struct stat));
 632
 633       stat (homeinit, &homebuf);
 634       stat (gdbinit, &cwdbuf);  /* We'll only need this if
 635                                    homedir was set.  */
 636       xfree (homeinit);
 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       quit_force (NULL, 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
 780              whatever.  This is a good place to gain control because
 781              many error conditions will end up here via longjmp().  */
 782           if (deprecated_command_loop_hook)
 783             deprecated_command_loop_hook ();
 784           else
 785             deprecated_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   -b BAUDRATE        Set serial port baud rate used for remote debugging.\n\
 839   --batch            Exit after processing options.\n\
 840   --batch-silent     As for --batch, but suppress all gdb stdout output.\n\
 841   --return-child-result\n\
 842                      GDB exit code will be the child's exit code.\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   -l TIMEOUT         Set timeout in seconds for remote debugging.\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 }