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