gdb/main.c

   1 /* Top level stuff for GDB, the GNU debugger.
   2
   3    Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
   4    1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 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 /* The selected interpreter.  This will be used as a set command
  53    variable, so it should always be malloc'ed - since
  54    do_setshow_command will free it. */
  55 char *interpreter_p;
  56
  57 /* Whether xdb commands will be handled */
  58 int xdb_commands = 0;
  59
  60 /* Whether dbx commands will be handled */
  61 int dbx_commands = 0;
  62
  63 /* System root path, used to find libraries etc.  */
  64 char *gdb_sysroot = 0;
  65
  66 struct ui_file *gdb_stdout;
  67 struct ui_file *gdb_stderr;
  68 struct ui_file *gdb_stdlog;
  69 struct ui_file *gdb_stdin;
  70 /* target IO streams */
  71 struct ui_file *gdb_stdtargin;
  72 struct ui_file *gdb_stdtarg;
  73 struct ui_file *gdb_stdtargerr;
  74
  75 /* Whether to enable writing into executable and core files */
  76 extern int write_files;
  77
  78 static void print_gdb_help (struct ui_file *);
  79
  80 /* These two are used to set the external editor commands when gdb is farming
  81    out files to be edited by another program. */
  82
  83 extern char *external_editor_command;
  84
  85 /* Call command_loop.  If it happens to return, pass that through as a
  86    non-zero return status. */
  87
  88 static int
  89 captured_command_loop (void *data)
  90 {
  91   current_interp_command_loop ();
  92   /* FIXME: cagney/1999-11-05: A correct command_loop() implementaton
  93      would clean things up (restoring the cleanup chain) to the state
  94      they were just prior to the call.  Technically, this means that
  95      the do_cleanups() below is redundant.  Unfortunately, many FUNCs
  96      are not that well behaved.  do_cleanups should either be replaced
  97      with a do_cleanups call (to cover the problem) or an assertion
  98      check to detect bad FUNCs code. */
  99   do_cleanups (ALL_CLEANUPS);
 100   /* If the command_loop returned, normally (rather than threw an
 101      error) we try to quit. If the quit is aborted, catch_errors()
 102      which called this catch the signal and restart the command
 103      loop. */
 104   quit_command (NULL, instream == stdin);
 105   return 1;
 106 }
 107
 108 static int
 109 captured_main (void *data)
 110 {
 111   struct captured_main_args *context = data;
 112   int argc = context->argc;
 113   char **argv = context->argv;
 114   int count;
 115   static int quiet = 0;
 116   static int batch = 0;
 117   static int set_args = 0;
 118
 119   /* Pointers to various arguments from command line.  */
 120   char *symarg = NULL;
 121   char *execarg = NULL;
 122   char *corearg = NULL;
 123   char *cdarg = NULL;
 124   char *ttyarg = NULL;
 125
 126   /* These are static so that we can take their address in an initializer.  */
 127   static int print_help;
 128   static int print_version;
 129
 130   /* Pointers to all arguments of --command option.  */
 131   char **cmdarg;
 132   /* Allocated size of cmdarg.  */
 133   int cmdsize;
 134   /* Number of elements of cmdarg used.  */
 135   int ncmd;
 136
 137   /* Indices of all arguments of --directory option.  */
 138   char **dirarg;
 139   /* Allocated size.  */
 140   int dirsize;
 141   /* Number of elements used.  */
 142   int ndir;
 143
 144   struct stat homebuf, cwdbuf;
 145   char *homedir, *homeinit;
 146
 147   int i;
 148
 149   long time_at_startup = get_run_time ();
 150
 151 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
 152   setlocale (LC_MESSAGES, "");
 153 #endif
 154 #if defined (HAVE_SETLOCALE)
 155   setlocale (LC_CTYPE, "");
 156 #endif
 157   bindtextdomain (PACKAGE, LOCALEDIR);
 158   textdomain (PACKAGE);
 159
 160 #ifdef HAVE_SBRK
 161   lim_at_start = (char *) sbrk (0);
 162 #endif
 163
 164 #if defined (ALIGN_STACK_ON_STARTUP)
 165   i = (int) &count & 0x3;
 166   if (i != 0)
 167     alloca (4 - i);
 168 #endif
 169
 170   cmdsize = 1;
 171   cmdarg = (char **) xmalloc (cmdsize * sizeof (*cmdarg));
 172   ncmd = 0;
 173   dirsize = 1;
 174   dirarg = (char **) xmalloc (dirsize * sizeof (*dirarg));
 175   ndir = 0;
 176
 177   quit_flag = 0;
 178   line = (char *) xmalloc (linesize);
 179   line[0] = '\0';               /* Terminate saved (now empty) cmd line */
 180   instream = stdin;
 181
 182   getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));
 183   current_directory = gdb_dirbuf;
 184
 185   gdb_stdout = stdio_fileopen (stdout);
 186   gdb_stderr = stdio_fileopen (stderr);
 187   gdb_stdlog = gdb_stderr;      /* for moment */
 188   gdb_stdtarg = gdb_stderr;     /* for moment */
 189   gdb_stdin = stdio_fileopen (stdin);
 190   gdb_stdtargerr = gdb_stderr;  /* for moment */
 191   gdb_stdtargin = gdb_stdin;    /* for moment */
 192
 193   /* initialize error() */
 194   error_init ();
 195
 196   /* Set the sysroot path.  */
 197 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
 198   gdb_sysroot = make_relative_prefix (argv[0], BINDIR, TARGET_SYSTEM_ROOT);
 199   if (gdb_sysroot)
 200     {
 201       struct stat s;
 202       int res = 0;
 203
 204       if (stat (gdb_sysroot, &s) == 0)
 205         if (S_ISDIR (s.st_mode))
 206           res = 1;
 207
 208       if (res == 0)
 209         {
 210           xfree (gdb_sysroot);
 211           gdb_sysroot = TARGET_SYSTEM_ROOT;
 212         }
 213     }
 214   else
 215     gdb_sysroot = TARGET_SYSTEM_ROOT;
 216 #else
 217 #if defined (TARGET_SYSTEM_ROOT)
 218   gdb_sysroot = TARGET_SYSTEM_ROOT;
 219 #else
 220   gdb_sysroot = "";
 221 #endif
 222 #endif
 223
 224   /* There will always be an interpreter.  Either the one passed into
 225      this captured main, or one specified by the user at start up, or
 226      the console.  Initialize the interpreter to the one requested by
 227      the application.  */
 228   interpreter_p = xstrdup (context->interpreter_p);
 229
 230   /* Parse arguments and options.  */
 231   {
 232     int c;
 233     /* When var field is 0, use flag field to record the equivalent
 234        short option (or arbitrary numbers starting at 10 for those
 235        with no equivalent).  */
 236     enum {
 237       OPT_SE = 10,
 238       OPT_CD,
 239       OPT_ANNOTATE,
 240       OPT_STATISTICS,
 241       OPT_TUI,
 242       OPT_NOWINDOWS,
 243       OPT_WINDOWS
 244     };
 245     static struct option long_options[] =
 246     {
 247 #if defined(TUI)
 248       {"tui", no_argument, 0, OPT_TUI},
 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       {"quiet", no_argument, &quiet, 1},
 255       {"q", no_argument, &quiet, 1},
 256       {"silent", no_argument, &quiet, 1},
 257       {"nx", no_argument, &inhibit_gdbinit, 1},
 258       {"n", no_argument, &inhibit_gdbinit, 1},
 259       {"batch", no_argument, &batch, 1},
 260       {"epoch", no_argument, &epoch_interface, 1},
 261
 262     /* This is a synonym for "--annotate=1".  --annotate is now preferred,
 263        but keep this here for a long time because people will be running
 264        emacses which use --fullname.  */
 265       {"fullname", no_argument, 0, 'f'},
 266       {"f", no_argument, 0, 'f'},
 267
 268       {"annotate", required_argument, 0, OPT_ANNOTATE},
 269       {"help", no_argument, &print_help, 1},
 270       {"se", required_argument, 0, OPT_SE},
 271       {"symbols", required_argument, 0, 's'},
 272       {"s", required_argument, 0, 's'},
 273       {"exec", required_argument, 0, 'e'},
 274       {"e", required_argument, 0, 'e'},
 275       {"core", required_argument, 0, 'c'},
 276       {"c", required_argument, 0, 'c'},
 277       {"pid", required_argument, 0, 'p'},
 278       {"p", required_argument, 0, 'p'},
 279       {"command", required_argument, 0, 'x'},
 280       {"version", no_argument, &print_version, 1},
 281       {"x", required_argument, 0, 'x'},
 282 #ifdef GDBTK
 283       {"tclcommand", required_argument, 0, 'z'},
 284       {"enable-external-editor", no_argument, 0, 'y'},
 285       {"editor-command", required_argument, 0, 'w'},
 286 #endif
 287       {"ui", required_argument, 0, 'i'},
 288       {"interpreter", required_argument, 0, 'i'},
 289       {"i", required_argument, 0, 'i'},
 290       {"directory", required_argument, 0, 'd'},
 291       {"d", required_argument, 0, 'd'},
 292       {"cd", required_argument, 0, OPT_CD},
 293       {"tty", required_argument, 0, 't'},
 294       {"baud", required_argument, 0, 'b'},
 295       {"b", required_argument, 0, 'b'},
 296       {"nw", no_argument, NULL, OPT_NOWINDOWS},
 297       {"nowindows", no_argument, NULL, OPT_NOWINDOWS},
 298       {"w", no_argument, NULL, OPT_WINDOWS},
 299       {"windows", no_argument, NULL, OPT_WINDOWS},
 300       {"statistics", no_argument, 0, OPT_STATISTICS},
 301       {"write", no_argument, &write_files, 1},
 302       {"args", no_argument, &set_args, 1},
 303      {"l", required_argument, 0, 'l'},
 304       {0, no_argument, 0, 0}
 305     };
 306
 307     while (1)
 308       {
 309         int option_index;
 310
 311         c = getopt_long_only (argc, argv, "",
 312                               long_options, &option_index);
 313         if (c == EOF || set_args)
 314           break;
 315
 316         /* Long option that takes an argument.  */
 317         if (c == 0 && long_options[option_index].flag == 0)
 318           c = long_options[option_index].val;
 319
 320         switch (c)
 321           {
 322           case 0:
 323             /* Long option that just sets a flag.  */
 324             break;
 325           case OPT_SE:
 326             symarg = optarg;
 327             execarg = optarg;
 328             break;
 329           case OPT_CD:
 330             cdarg = optarg;
 331             break;
 332           case OPT_ANNOTATE:
 333             /* FIXME: what if the syntax is wrong (e.g. not digits)?  */
 334             annotation_level = atoi (optarg);
 335             break;
 336           case OPT_STATISTICS:
 337             /* Enable the display of both time and space usage.  */
 338             display_time = 1;
 339             display_space = 1;
 340             break;
 341           case OPT_TUI:
 342             /* --tui is equivalent to -i=tui.  */
 343             xfree (interpreter_p);
 344             interpreter_p = xstrdup ("tui");
 345             break;
 346           case OPT_WINDOWS:
 347             /* FIXME: cagney/2003-03-01: Not sure if this option is
 348                actually useful, and if it is, what it should do.  */
 349             use_windows = 1;
 350             break;
 351           case OPT_NOWINDOWS:
 352             /* -nw is equivalent to -i=console.  */
 353             xfree (interpreter_p);
 354             interpreter_p = xstrdup (INTERP_CONSOLE);
 355             use_windows = 0;
 356             break;
 357           case 'f':
 358             annotation_level = 1;
 359 /* We have probably been invoked from emacs.  Disable window interface.  */
 360             use_windows = 0;
 361             break;
 362           case 's':
 363             symarg = optarg;
 364             break;
 365           case 'e':
 366             execarg = optarg;
 367             break;
 368           case 'c':
 369             corearg = optarg;
 370             break;
 371           case 'p':
 372             /* "corearg" is shared by "--core" and "--pid" */
 373             corearg = optarg;
 374             break;
 375           case 'x':
 376             cmdarg[ncmd++] = optarg;
 377             if (ncmd >= cmdsize)
 378               {
 379                 cmdsize *= 2;
 380                 cmdarg = (char **) xrealloc ((char *) cmdarg,
 381                                              cmdsize * sizeof (*cmdarg));
 382               }
 383             break;
 384 #ifdef GDBTK
 385           case 'z':
 386             {
 387 extern int gdbtk_test (char *);
 388               if (!gdbtk_test (optarg))
 389                 {
 390                   fprintf_unfiltered (gdb_stderr, _("%s: unable to load tclcommand file \"%s\""),
 391                                       argv[0], optarg);
 392                   exit (1);
 393                 }
 394               break;
 395             }
 396           case 'y':
 397             /* Backwards compatibility only.  */
 398             break;
 399           case 'w':
 400             {
 401               external_editor_command = xstrdup (optarg);
 402               break;
 403             }
 404 #endif /* GDBTK */
 405           case 'i':
 406             xfree (interpreter_p);
 407             interpreter_p = xstrdup (optarg);
 408             break;
 409           case 'd':
 410             dirarg[ndir++] = optarg;
 411             if (ndir >= dirsize)
 412               {
 413                 dirsize *= 2;
 414                 dirarg = (char **) xrealloc ((char *) dirarg,
 415                                              dirsize * sizeof (*dirarg));
 416               }
 417             break;
 418           case 't':
 419             ttyarg = optarg;
 420             break;
 421           case 'q':
 422             quiet = 1;
 423             break;
 424           case 'b':
 425             {
 426               int i;
 427               char *p;
 428
 429               i = strtol (optarg, &p, 0);
 430               if (i == 0 && p == optarg)
 431
 432                 /* Don't use *_filtered or warning() (which relies on
 433                    current_target) until after initialize_all_files(). */
 434
 435                 fprintf_unfiltered
 436                   (gdb_stderr,
 437                    _("warning: could not set baud rate to `%s'.\n"), optarg);
 438               else
 439                 baud_rate = i;
 440             }
 441             break;
 442           case 'l':
 443             {
 444               int i;
 445               char *p;
 446
 447               i = strtol (optarg, &p, 0);
 448               if (i == 0 && p == optarg)
 449
 450                 /* Don't use *_filtered or warning() (which relies on
 451                    current_target) until after initialize_all_files(). */
 452
 453                 fprintf_unfiltered
 454                   (gdb_stderr,
 455                  _("warning: could not set timeout limit to `%s'.\n"), optarg);
 456               else
 457                 remote_timeout = i;
 458             }
 459             break;
 460
 461           case '?':
 462             fprintf_unfiltered (gdb_stderr,
 463                         _("Use `%s --help' for a complete list of options.\n"),
 464                                 argv[0]);
 465             exit (1);
 466           }
 467       }
 468
 469     /* If --help or --version, disable window interface.  */
 470     if (print_help || print_version)
 471       {
 472         use_windows = 0;
 473       }
 474
 475     if (set_args)
 476       {
 477         /* The remaining options are the command-line options for the
 478            inferior.  The first one is the sym/exec file, and the rest
 479            are arguments.  */
 480         if (optind >= argc)
 481           {
 482             fprintf_unfiltered (gdb_stderr,
 483                                 _("%s: `--args' specified but no program specified\n"),
 484                                 argv[0]);
 485             exit (1);
 486           }
 487         symarg = argv[optind];
 488         execarg = argv[optind];
 489         ++optind;
 490         set_inferior_args_vector (argc - optind, &argv[optind]);
 491       }
 492     else
 493       {
 494         /* OK, that's all the options.  The other arguments are filenames.  */
 495         count = 0;
 496         for (; optind < argc; optind++)
 497           switch (++count)
 498             {
 499             case 1:
 500               symarg = argv[optind];
 501               execarg = argv[optind];
 502               break;
 503             case 2:
 504               /* The documentation says this can be a "ProcID" as well.
 505                  We will try it as both a corefile and a pid.  */
 506               corearg = argv[optind];
 507               break;
 508             case 3:
 509               fprintf_unfiltered (gdb_stderr,
 510                                   _("Excess command line arguments ignored. (%s%s)\n"),
 511                                   argv[optind], (optind == argc - 1) ? "" : " ...");
 512               break;
 513             }
 514       }
 515     if (batch)
 516       quiet = 1;
 517   }
 518
 519   /* Initialize all files.  Give the interpreter a chance to take
 520      control of the console via the deprecated_init_ui_hook().  */
 521   gdb_init (argv[0]);
 522
 523   /* Do these (and anything which might call wrap_here or *_filtered)
 524      after initialize_all_files() but before the interpreter has been
 525      installed.  Otherwize the help/version messages will be eaten by
 526      the interpreter's output handler.  */
 527
 528   if (print_version)
 529     {
 530       print_gdb_version (gdb_stdout);
 531       wrap_here ("");
 532       printf_filtered ("\n");
 533       exit (0);
 534     }
 535
 536   if (print_help)
 537     {
 538       print_gdb_help (gdb_stdout);
 539       fputs_unfiltered ("\n", gdb_stdout);
 540       exit (0);
 541     }
 542
 543   /* FIXME: cagney/2003-02-03: The big hack (part 1 of 2) that lets
 544      GDB retain the old MI1 interpreter startup behavior.  Output the
 545      copyright message before the interpreter is installed.  That way
 546      it isn't encapsulated in MI output.  */
 547   if (!quiet && strcmp (interpreter_p, INTERP_MI1) == 0)
 548     {
 549       /* Print all the junk at the top, with trailing "..." if we are about
 550          to read a symbol file (possibly slowly).  */
 551       print_gdb_version (gdb_stdout);
 552       if (symarg)
 553         printf_filtered ("..");
 554       wrap_here ("");
 555       gdb_flush (gdb_stdout);   /* Force to screen during slow operations */
 556     }
 557
 558
 559   /* Install the default UI.  All the interpreters should have had a
 560      look at things by now.  Initialize the default interpreter. */
 561
 562   {
 563     /* Find it.  */
 564     struct interp *interp = interp_lookup (interpreter_p);
 565     if (interp == NULL)
 566       error ("Interpreter `%s' unrecognized", interpreter_p);
 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       if (attach_flag)
 731         /* Either there was a problem executing the command in the
 732            batch file aborted early, or the batch file forgot to do an
 733            explicit detach.  Explicitly detach the inferior ensuring
 734            that there are no zombies.  */
 735         target_detach (NULL, 0);
 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   /* Show time and/or space usage.  */
 749
 750   if (display_time)
 751     {
 752       long init_time = get_run_time () - time_at_startup;
 753
 754       printf_unfiltered (_("Startup time: %ld.%06ld\n"),
 755                          init_time / 1000000, init_time % 1000000);
 756     }
 757
 758   if (display_space)
 759     {
 760 #ifdef HAVE_SBRK
 761       extern char **environ;
 762       char *lim = (char *) sbrk (0);
 763
 764       printf_unfiltered (_("Startup size: data size %ld\n"),
 765                          (long) (lim - (char *) &environ));
 766 #endif
 767     }
 768
 769 #if 0
 770   /* FIXME: cagney/1999-11-06: The original main loop was like: */
 771   while (1)
 772     {
 773       if (!SET_TOP_LEVEL ())
 774         {
 775           do_cleanups (ALL_CLEANUPS);   /* Do complete cleanup */
 776           /* GUIs generally have their own command loop, mainloop, or whatever.
 777              This is a good place to gain control because many error
 778              conditions will end up here via longjmp(). */
 779           if (deprecated_command_loop_hook)
 780             deprecated_command_loop_hook ();
 781           else
 782             deprecated_command_loop ();
 783           quit_command ((char *) 0, instream == stdin);
 784         }
 785     }
 786   /* NOTE: If the command_loop() returned normally, the loop would
 787      attempt to exit by calling the function quit_command().  That
 788      function would either call exit() or throw an error returning
 789      control to SET_TOP_LEVEL. */
 790   /* NOTE: The function do_cleanups() was called once each time round
 791      the loop.  The usefulness of the call isn't clear.  If an error
 792      was thrown, everything would have already been cleaned up.  If
 793      command_loop() returned normally and quit_command() was called,
 794      either exit() or error() (again cleaning up) would be called. */
 795 #endif
 796   /* NOTE: cagney/1999-11-07: There is probably no reason for not
 797      moving this loop and the code found in captured_command_loop()
 798      into the command_loop() proper.  The main thing holding back that
 799      change - SET_TOP_LEVEL() - has been eliminated. */
 800   while (1)
 801     {
 802       catch_errors (captured_command_loop, 0, "", RETURN_MASK_ALL);
 803     }
 804   /* No exit -- exit is through quit_command.  */
 805 }
 806
 807 int
 808 gdb_main (struct captured_main_args *args)
 809 {
 810   use_windows = args->use_windows;
 811   catch_errors (captured_main, args, "", RETURN_MASK_ALL);
 812   /* The only way to end up here is by an error (normal exit is
 813      handled by quit_force()), hence always return an error status.  */
 814   return 1;
 815 }
 816
 817
 818 /* Don't use *_filtered for printing help.  We don't want to prompt
 819    for continue no matter how small the screen or how much we're going
 820    to print.  */
 821
 822 static void
 823 print_gdb_help (struct ui_file *stream)
 824 {
 825   fputs_unfiltered (_("\
 826 This is the GNU debugger.  Usage:\n\n\
 827     gdb [options] [executable-file [core-file or process-id]]\n\
 828     gdb [options] --args executable-file [inferior-arguments ...]\n\n\
 829 Options:\n\n\
 830 "), stream);
 831   fputs_unfiltered (_("\
 832   --args             Arguments after executable-file are passed to inferior\n\
 833 "), stream);
 834   fputs_unfiltered (_("\
 835   --[no]async        Enable (disable) asynchronous version of CLI\n\
 836 "), stream);
 837   fputs_unfiltered (_("\
 838   -b BAUDRATE        Set serial port baud rate used for remote debugging.\n\
 839   --batch            Exit after processing options.\n\
 840   --cd=DIR           Change current directory to DIR.\n\
 841   --command=FILE     Execute GDB commands from FILE.\n\
 842   --core=COREFILE    Analyze the core dump COREFILE.\n\
 843   --pid=PID          Attach to running process PID.\n\
 844 "), stream);
 845   fputs_unfiltered (_("\
 846   --dbx              DBX compatibility mode.\n\
 847   --directory=DIR    Search for source files in DIR.\n\
 848   --epoch            Output information used by epoch emacs-GDB interface.\n\
 849   --exec=EXECFILE    Use EXECFILE as the executable.\n\
 850   --fullname         Output information used by emacs-GDB interface.\n\
 851   --help             Print this message.\n\
 852 "), stream);
 853   fputs_unfiltered (_("\
 854   --interpreter=INTERP\n\
 855                      Select a specific interpreter / user interface\n\
 856 "), stream);
 857   fputs_unfiltered (_("\
 858   -l TIMEOUT         Set timeout in seconds for remote debugging.\n\
 859   --mapped           Use mapped symbol files if supported on this system.\n\
 860   --nw               Do not use a window interface.\n\
 861   --nx               Do not read "), stream);
 862   fputs_unfiltered (gdbinit, stream);
 863   fputs_unfiltered (_(" file.\n\
 864   --quiet            Do not print version number on startup.\n\
 865   --readnow          Fully read symbol files on first access.\n\
 866 "), stream);
 867   fputs_unfiltered (_("\
 868   --se=FILE          Use FILE as symbol file and executable file.\n\
 869   --symbols=SYMFILE  Read symbols from SYMFILE.\n\
 870   --tty=TTY          Use TTY for input/output by the program being debugged.\n\
 871 "), stream);
 872 #if defined(TUI)
 873   fputs_unfiltered (_("\
 874   --tui              Use a terminal user interface.\n\
 875 "), stream);
 876 #endif
 877   fputs_unfiltered (_("\
 878   --version          Print version information and then exit.\n\
 879   -w                 Use a window interface.\n\
 880   --write            Set writing into executable and core files.\n\
 881   --xdb              XDB compatibility mode.\n\
 882 "), stream);
 883   fputs_unfiltered (_("\n\
 884 For more information, type \"help\" from within GDB, or consult the\n\
 885 GDB manual (available as on-line info or a printed manual).\n\
 886 Report bugs to \"bug-gdb@gnu.org\".\
 887 "), stream);
 888 }