gdb/main.c

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