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