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 /* Whether to enable writing into executable and core files */
  80 extern int write_files;
  81
  82 static void print_gdb_help (struct ui_file *);
  83
  84 /* These two are used to set the external editor commands when gdb is farming
  85    out files to be edited by another program. */
  86
  87 extern char *external_editor_command;
  88
  89 /* Call command_loop.  If it happens to return, pass that through as a
  90    non-zero return status. */
  91
  92 static int
  93 captured_command_loop (void *data)
  94 {
  95   current_interp_command_loop ();
  96   /* FIXME: cagney/1999-11-05: A correct command_loop() implementaton
  97      would clean things up (restoring the cleanup chain) to the state
  98      they were just prior to the call.  Technically, this means that
  99      the do_cleanups() below is redundant.  Unfortunately, many FUNCs
 100      are not that well behaved.  do_cleanups should either be replaced
 101      with a do_cleanups call (to cover the problem) or an assertion
 102      check to detect bad FUNCs code. */
 103   do_cleanups (ALL_CLEANUPS);
 104   /* If the command_loop returned, normally (rather than threw an
 105      error) we try to quit. If the quit is aborted, catch_errors()
 106      which called this catch the signal and restart the command
 107      loop. */
 108   quit_command (NULL, instream == stdin);
 109   return 1;
 110 }
 111
 112 static int
 113 captured_main (void *data)
 114 {
 115   struct captured_main_args *context = data;
 116   int argc = context->argc;
 117   char **argv = context->argv;
 118   int count;
 119   static int quiet = 0;
 120   static int batch = 0;
 121   static int set_args = 0;
 122
 123   /* Pointers to various arguments from command line.  */
 124   char *symarg = NULL;
 125   char *execarg = NULL;
 126   char *corearg = NULL;
 127   char *cdarg = NULL;
 128   char *ttyarg = NULL;
 129
 130   /* These are static so that we can take their address in an initializer.  */
 131   static int print_help;
 132   static int print_version;
 133
 134   /* Pointers to all arguments of --command option.  */
 135   char **cmdarg;
 136   /* Allocated size of cmdarg.  */
 137   int cmdsize;
 138   /* Number of elements of cmdarg used.  */
 139   int ncmd;
 140
 141   /* Indices of all arguments of --directory option.  */
 142   char **dirarg;
 143   /* Allocated size.  */
 144   int dirsize;
 145   /* Number of elements used.  */
 146   int ndir;
 147
 148   struct stat homebuf, cwdbuf;
 149   char *homedir;
 150
 151   int i;
 152
 153   long time_at_startup = get_run_time ();
 154
 155 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
 156   setlocale (LC_MESSAGES, "");
 157 #endif
 158 #if defined (HAVE_SETLOCALE)
 159   setlocale (LC_CTYPE, "");
 160 #endif
 161   bindtextdomain (PACKAGE, LOCALEDIR);
 162   textdomain (PACKAGE);
 163
 164 #ifdef HAVE_SBRK
 165   lim_at_start = (char *) sbrk (0);
 166 #endif
 167
 168 #if defined (ALIGN_STACK_ON_STARTUP)
 169   i = (int) &count & 0x3;
 170   if (i != 0)
 171     alloca (4 - i);
 172 #endif
 173
 174   cmdsize = 1;
 175   cmdarg = (char **) xmalloc (cmdsize * sizeof (*cmdarg));
 176   ncmd = 0;
 177   dirsize = 1;
 178   dirarg = (char **) xmalloc (dirsize * sizeof (*dirarg));
 179   ndir = 0;
 180
 181   quit_flag = 0;
 182   line = (char *) xmalloc (linesize);
 183   line[0] = '\0';               /* Terminate saved (now empty) cmd line */
 184   instream = stdin;
 185
 186   getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));
 187   current_directory = gdb_dirbuf;
 188
 189   gdb_stdout = stdio_fileopen (stdout);
 190   gdb_stderr = stdio_fileopen (stderr);
 191   gdb_stdlog = gdb_stderr;      /* for moment */
 192   gdb_stdtarg = gdb_stderr;     /* for moment */
 193   gdb_stdin = stdio_fileopen (stdin);
 194   gdb_stdtargerr = gdb_stderr;  /* for moment */
 195   gdb_stdtargin = gdb_stdin;    /* for moment */
 196
 197   /* Set the sysroot path.  */
 198 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
 199   gdb_sysroot = make_relative_prefix (argv[0], BINDIR, TARGET_SYSTEM_ROOT);
 200   if (gdb_sysroot)
 201     {
 202       struct stat s;
 203       int res = 0;
 204
 205       if (stat (gdb_sysroot, &s) == 0)
 206         if (S_ISDIR (s.st_mode))
 207           res = 1;
 208
 209       if (res == 0)
 210         {
 211           xfree (gdb_sysroot);
 212           gdb_sysroot = TARGET_SYSTEM_ROOT;
 213         }
 214     }
 215   else
 216     gdb_sysroot = TARGET_SYSTEM_ROOT;
 217 #else
 218 #if defined (TARGET_SYSTEM_ROOT)
 219   gdb_sysroot = TARGET_SYSTEM_ROOT;
 220 #else
 221   gdb_sysroot = "";
 222 #endif
 223 #endif
 224
 225   /* There will always be an interpreter.  Either the one passed into
 226      this captured main, or one specified by the user at start up, or
 227      the console.  Initialize the interpreter to the one requested by
 228      the application.  */
 229   interpreter_p = xstrdup (context->interpreter_p);
 230
 231   /* Parse arguments and options.  */
 232   {
 233     int c;
 234     /* When var field is 0, use flag field to record the equivalent
 235        short option (or arbitrary numbers starting at 10 for those
 236        with no equivalent).  */
 237     enum {
 238       OPT_SE = 10,
 239       OPT_CD,
 240       OPT_ANNOTATE,
 241       OPT_STATISTICS,
 242       OPT_TUI,
 243       OPT_NOWINDOWS,
 244       OPT_WINDOWS
 245     };
 246     static struct option long_options[] =
 247     {
 248 #if defined(TUI)
 249       {"tui", no_argument, 0, OPT_TUI},
 250 #endif
 251       {"xdb", no_argument, &xdb_commands, 1},
 252       {"dbx", no_argument, &dbx_commands, 1},
 253       {"readnow", no_argument, &readnow_symbol_files, 1},
 254       {"r", no_argument, &readnow_symbol_files, 1},
 255       {"quiet", no_argument, &quiet, 1},
 256       {"q", no_argument, &quiet, 1},
 257       {"silent", no_argument, &quiet, 1},
 258       {"nx", no_argument, &inhibit_gdbinit, 1},
 259       {"n", no_argument, &inhibit_gdbinit, 1},
 260       {"batch-silent", no_argument, 0, 'B'},
 261       {"batch", no_argument, &batch, 1},
 262       {"epoch", no_argument, &epoch_interface, 1},
 263
 264     /* This is a synonym for "--annotate=1".  --annotate is now preferred,
 265        but keep this here for a long time because people will be running
 266        emacses which use --fullname.  */
 267       {"fullname", no_argument, 0, 'f'},
 268       {"f", no_argument, 0, 'f'},
 269
 270       {"annotate", required_argument, 0, OPT_ANNOTATE},
 271       {"help", no_argument, &print_help, 1},
 272       {"se", required_argument, 0, OPT_SE},
 273       {"symbols", required_argument, 0, 's'},
 274       {"s", required_argument, 0, 's'},
 275       {"exec", required_argument, 0, 'e'},
 276       {"e", required_argument, 0, 'e'},
 277       {"core", required_argument, 0, 'c'},
 278       {"c", required_argument, 0, 'c'},
 279       {"pid", required_argument, 0, 'p'},
 280       {"p", required_argument, 0, 'p'},
 281       {"command", required_argument, 0, 'x'},
 282       {"version", no_argument, &print_version, 1},
 283       {"x", required_argument, 0, 'x'},
 284 #ifdef GDBTK
 285       {"tclcommand", required_argument, 0, 'z'},
 286       {"enable-external-editor", no_argument, 0, 'y'},
 287       {"editor-command", required_argument, 0, 'w'},
 288 #endif
 289       {"ui", required_argument, 0, 'i'},
 290       {"interpreter", required_argument, 0, 'i'},
 291       {"i", required_argument, 0, 'i'},
 292       {"directory", required_argument, 0, 'd'},
 293       {"d", required_argument, 0, 'd'},
 294       {"cd", required_argument, 0, OPT_CD},
 295       {"tty", required_argument, 0, 't'},
 296       {"baud", required_argument, 0, 'b'},
 297       {"b", required_argument, 0, 'b'},
 298       {"nw", no_argument, NULL, OPT_NOWINDOWS},
 299       {"nowindows", no_argument, NULL, OPT_NOWINDOWS},
 300       {"w", no_argument, NULL, OPT_WINDOWS},
 301       {"windows", no_argument, NULL, OPT_WINDOWS},
 302       {"statistics", no_argument, 0, OPT_STATISTICS},
 303       {"write", no_argument, &write_files, 1},
 304       {"args", no_argument, &set_args, 1},
 305      {"l", required_argument, 0, 'l'},
 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           case 'B':
 387             batch = batch_silent = 1;
 388             gdb_stdout = ui_file_new();
 389             break;
 390 #ifdef GDBTK
 391           case 'z':
 392             {
 393 extern int gdbtk_test (char *);
 394               if (!gdbtk_test (optarg))
 395                 {
 396                   fprintf_unfiltered (gdb_stderr, _("%s: unable to load tclcommand file \"%s\""),
 397                                       argv[0], optarg);
 398                   exit (1);
 399                 }
 400               break;
 401             }
 402           case 'y':
 403             /* Backwards compatibility only.  */
 404             break;
 405           case 'w':
 406             {
 407               external_editor_command = xstrdup (optarg);
 408               break;
 409             }
 410 #endif /* GDBTK */
 411           case 'i':
 412             xfree (interpreter_p);
 413             interpreter_p = xstrdup (optarg);
 414             break;
 415           case 'd':
 416             dirarg[ndir++] = optarg;
 417             if (ndir >= dirsize)
 418               {
 419                 dirsize *= 2;
 420                 dirarg = (char **) xrealloc ((char *) dirarg,
 421                                              dirsize * sizeof (*dirarg));
 422               }
 423             break;
 424           case 't':
 425             ttyarg = optarg;
 426             break;
 427           case 'q':
 428             quiet = 1;
 429             break;
 430           case 'b':
 431             {
 432               int i;
 433               char *p;
 434
 435               i = strtol (optarg, &p, 0);
 436               if (i == 0 && p == optarg)
 437
 438                 /* Don't use *_filtered or warning() (which relies on
 439                    current_target) until after initialize_all_files(). */
 440
 441                 fprintf_unfiltered
 442                   (gdb_stderr,
 443                    _("warning: could not set baud rate to `%s'.\n"), optarg);
 444               else
 445                 baud_rate = i;
 446             }
 447             break;
 448           case 'l':
 449             {
 450               int i;
 451               char *p;
 452
 453               i = strtol (optarg, &p, 0);
 454               if (i == 0 && p == optarg)
 455
 456                 /* Don't use *_filtered or warning() (which relies on
 457                    current_target) until after initialize_all_files(). */
 458
 459                 fprintf_unfiltered
 460                   (gdb_stderr,
 461                  _("warning: could not set timeout limit to `%s'.\n"), optarg);
 462               else
 463                 remote_timeout = i;
 464             }
 465             break;
 466
 467           case '?':
 468             fprintf_unfiltered (gdb_stderr,
 469                         _("Use `%s --help' for a complete list of options.\n"),
 470                                 argv[0]);
 471             exit (1);
 472           }
 473       }
 474
 475     /* If --help or --version, disable window interface.  */
 476     if (print_help || print_version)
 477       {
 478         use_windows = 0;
 479       }
 480
 481     if (set_args)
 482       {
 483         /* The remaining options are the command-line options for the
 484            inferior.  The first one is the sym/exec file, and the rest
 485            are arguments.  */
 486         if (optind >= argc)
 487           {
 488             fprintf_unfiltered (gdb_stderr,
 489                                 _("%s: `--args' specified but no program specified\n"),
 490                                 argv[0]);
 491             exit (1);
 492           }
 493         symarg = argv[optind];
 494         execarg = argv[optind];
 495         ++optind;
 496         set_inferior_args_vector (argc - optind, &argv[optind]);
 497       }
 498     else
 499       {
 500         /* OK, that's all the options.  The other arguments are filenames.  */
 501         count = 0;
 502         for (; optind < argc; optind++)
 503           switch (++count)
 504             {
 505             case 1:
 506               symarg = argv[optind];
 507               execarg = argv[optind];
 508               break;
 509             case 2:
 510               /* The documentation says this can be a "ProcID" as well.
 511                  We will try it as both a corefile and a pid.  */
 512               corearg = argv[optind];
 513               break;
 514             case 3:
 515               fprintf_unfiltered (gdb_stderr,
 516                                   _("Excess command line arguments ignored. (%s%s)\n"),
 517                                   argv[optind], (optind == argc - 1) ? "" : " ...");
 518               break;
 519             }
 520       }
 521     if (batch)
 522       quiet = 1;
 523   }
 524
 525   /* Initialize all files.  Give the interpreter a chance to take
 526      control of the console via the deprecated_init_ui_hook ().  */
 527   gdb_init (argv[0]);
 528
 529   /* Do these (and anything which might call wrap_here or *_filtered)
 530      after initialize_all_files() but before the interpreter has been
 531      installed.  Otherwize the help/version messages will be eaten by
 532      the interpreter's output handler.  */
 533
 534   if (print_version)
 535     {
 536       print_gdb_version (gdb_stdout);
 537       wrap_here ("");
 538       printf_filtered ("\n");
 539       exit (0);
 540     }
 541
 542   if (print_help)
 543     {
 544       print_gdb_help (gdb_stdout);
 545       fputs_unfiltered ("\n", gdb_stdout);
 546       exit (0);
 547     }
 548
 549   /* FIXME: cagney/2003-02-03: The big hack (part 1 of 2) that lets
 550      GDB retain the old MI1 interpreter startup behavior.  Output the
 551      copyright message before the interpreter is installed.  That way
 552      it isn't encapsulated in MI output.  */
 553   if (!quiet && strcmp (interpreter_p, INTERP_MI1) == 0)
 554     {
 555       /* Print all the junk at the top, with trailing "..." if we are about
 556          to read a symbol file (possibly slowly).  */
 557       print_gdb_version (gdb_stdout);
 558       if (symarg)
 559         printf_filtered ("..");
 560       wrap_here ("");
 561       gdb_flush (gdb_stdout);   /* Force to screen during slow operations */
 562     }
 563
 564
 565   /* Install the default UI.  All the interpreters should have had a
 566      look at things by now.  Initialize the default interpreter. */
 567
 568   {
 569     /* Find it.  */
 570     struct interp *interp = interp_lookup (interpreter_p);
 571     if (interp == NULL)
 572       error (_("Interpreter `%s' unrecognized"), interpreter_p);
 573     /* Install it.  */
 574     if (!interp_set (interp))
 575       {
 576         fprintf_unfiltered (gdb_stderr,
 577                             "Interpreter `%s' failed to initialize.\n",
 578                             interpreter_p);
 579         exit (1);
 580       }
 581   }
 582
 583   /* FIXME: cagney/2003-02-03: The big hack (part 2 of 2) that lets
 584      GDB retain the old MI1 interpreter startup behavior.  Output the
 585      copyright message after the interpreter is installed when it is
 586      any sane interpreter.  */
 587   if (!quiet && !current_interp_named_p (INTERP_MI1))
 588     {
 589       /* Print all the junk at the top, with trailing "..." if we are about
 590          to read a symbol file (possibly slowly).  */
 591       print_gdb_version (gdb_stdout);
 592       if (symarg)
 593         printf_filtered ("..");
 594       wrap_here ("");
 595       gdb_flush (gdb_stdout);   /* Force to screen during slow operations */
 596     }
 597
 598   error_pre_print = "\n\n";
 599   quit_pre_print = error_pre_print;
 600
 601   /* We may get more than one warning, don't double space all of them... */
 602   warning_pre_print = _("\nwarning: ");
 603
 604   /* Read and execute $HOME/.gdbinit file, if it exists.  This is done
 605      *before* all the command line arguments are processed; it sets
 606      global parameters, which are independent of what file you are
 607      debugging or what directory you are in.  */
 608   homedir = getenv ("HOME");
 609   if (homedir)
 610     {
 611       char *homeinit = xstrprintf ("%s/%s", homedir, 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       xfree (homeinit);
 630     }
 631
 632   /* Now perform all the actions indicated by the arguments.  */
 633   if (cdarg != NULL)
 634     {
 635       catch_command_errors (cd_command, cdarg, 0, RETURN_MASK_ALL);
 636     }
 637
 638   for (i = 0; i < ndir; i++)
 639     catch_command_errors (directory_command, dirarg[i], 0, RETURN_MASK_ALL);
 640   xfree (dirarg);
 641
 642   if (execarg != NULL
 643       && symarg != NULL
 644       && strcmp (execarg, symarg) == 0)
 645     {
 646       /* The exec file and the symbol-file are the same.  If we can't
 647          open it, better only print one error message.
 648          catch_command_errors returns non-zero on success! */
 649       if (catch_command_errors (exec_file_attach, execarg, !batch, RETURN_MASK_ALL))
 650         catch_command_errors (symbol_file_add_main, symarg, 0, RETURN_MASK_ALL);
 651     }
 652   else
 653     {
 654       if (execarg != NULL)
 655         catch_command_errors (exec_file_attach, execarg, !batch, RETURN_MASK_ALL);
 656       if (symarg != NULL)
 657         catch_command_errors (symbol_file_add_main, symarg, 0, RETURN_MASK_ALL);
 658     }
 659
 660   /* After the symbol file has been read, print a newline to get us
 661      beyond the copyright line...  But errors should still set off
 662      the error message with a (single) blank line.  */
 663   if (!quiet)
 664     printf_filtered ("\n");
 665   error_pre_print = "\n";
 666   quit_pre_print = error_pre_print;
 667   warning_pre_print = _("\nwarning: ");
 668
 669   if (corearg != NULL)
 670     {
 671       /* corearg may be either a corefile or a pid.
 672          If its first character is a digit, try attach first
 673          and then corefile.  Otherwise try corefile first. */
 674
 675       if (isdigit (corearg[0]))
 676         {
 677           if (catch_command_errors (attach_command, corearg,
 678                                     !batch, RETURN_MASK_ALL) == 0)
 679             catch_command_errors (core_file_command, corearg,
 680                                   !batch, RETURN_MASK_ALL);
 681         }
 682       else /* Can't be a pid, better be a corefile. */
 683         catch_command_errors (core_file_command, corearg,
 684                               !batch, RETURN_MASK_ALL);
 685     }
 686
 687   if (ttyarg != NULL)
 688     catch_command_errors (tty_command, ttyarg, !batch, RETURN_MASK_ALL);
 689
 690   /* Error messages should no longer be distinguished with extra output. */
 691   error_pre_print = NULL;
 692   quit_pre_print = NULL;
 693   warning_pre_print = _("warning: ");
 694
 695   /* Read the .gdbinit file in the current directory, *if* it isn't
 696      the same as the $HOME/.gdbinit file (it should exist, also).  */
 697
 698   if (!homedir
 699       || memcmp ((char *) &homebuf, (char *) &cwdbuf, sizeof (struct stat)))
 700     if (!inhibit_gdbinit)
 701       {
 702         catch_command_errors (source_command, gdbinit, 0, RETURN_MASK_ALL);
 703       }
 704
 705   for (i = 0; i < ncmd; i++)
 706     {
 707 #if 0
 708       /* NOTE: cagney/1999-11-03: SET_TOP_LEVEL() was a macro that
 709          expanded into a call to setjmp().  */
 710       if (!SET_TOP_LEVEL ()) /* NB: This is #if 0'd out */
 711         {
 712           /* NOTE: I am commenting this out, because it is not clear
 713              where this feature is used. It is very old and
 714              undocumented. ezannoni: 1999-05-04 */
 715 #if 0
 716           if (cmdarg[i][0] == '-' && cmdarg[i][1] == '\0')
 717             read_command_file (stdin);
 718           else
 719 #endif
 720             source_command (cmdarg[i], !batch);
 721           do_cleanups (ALL_CLEANUPS);
 722         }
 723 #endif
 724       catch_command_errors (source_command, cmdarg[i], !batch, RETURN_MASK_ALL);
 725     }
 726   xfree (cmdarg);
 727
 728   /* Read in the old history after all the command files have been read. */
 729   init_history ();
 730
 731   if (batch)
 732     {
 733       if (attach_flag)
 734         /* Either there was a problem executing the command in the
 735            batch file aborted early, or the batch file forgot to do an
 736            explicit detach.  Explicitly detach the inferior ensuring
 737            that there are no zombies.  */
 738         target_detach (NULL, 0);
 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
 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   --cd=DIR           Change current directory to DIR.\n\
 842   --command=FILE     Execute GDB commands from FILE.\n\
 843   --core=COREFILE    Analyze the core dump COREFILE.\n\
 844   --pid=PID          Attach to running process PID.\n\
 845 "), stream);
 846   fputs_unfiltered (_("\
 847   --dbx              DBX compatibility mode.\n\
 848   --directory=DIR    Search for source files in DIR.\n\
 849   --epoch            Output information used by epoch emacs-GDB interface.\n\
 850   --exec=EXECFILE    Use EXECFILE as the executable.\n\
 851   --fullname         Output information used by emacs-GDB interface.\n\
 852   --help             Print this message.\n\
 853 "), stream);
 854   fputs_unfiltered (_("\
 855   --interpreter=INTERP\n\
 856                      Select a specific interpreter / user interface\n\
 857 "), stream);
 858   fputs_unfiltered (_("\
 859   -l TIMEOUT         Set timeout in seconds for remote debugging.\n\
 860   --nw               Do not use a window interface.\n\
 861   --nx               Do not read "), stream);
 862   fputs_unfiltered (gdbinit, stream);
 863   fputs_unfiltered (_(" file.\n\
 864   --quiet            Do not print version number on startup.\n\
 865   --readnow          Fully read symbol files on first access.\n\
 866 "), stream);
 867   fputs_unfiltered (_("\
 868   --se=FILE          Use FILE as symbol file and executable file.\n\
 869   --symbols=SYMFILE  Read symbols from SYMFILE.\n\
 870   --tty=TTY          Use TTY for input/output by the program being debugged.\n\
 871 "), stream);
 872 #if defined(TUI)
 873   fputs_unfiltered (_("\
 874   --tui              Use a terminal user interface.\n\
 875 "), stream);
 876 #endif
 877   fputs_unfiltered (_("\
 878   --version          Print version information and then exit.\n\
 879   -w                 Use a window interface.\n\
 880   --write            Set writing into executable and core files.\n\
 881   --xdb              XDB compatibility mode.\n\
 882 "), stream);
 883   fputs_unfiltered (_("\n\
 884 For more information, type \"help\" from within GDB, or consult the\n\
 885 GDB manual (available as on-line info or a printed manual).\n\
 886 Report bugs to \"bug-gdb@gnu.org\".\
 887 "), stream);
 888 }