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