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