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