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