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