gdb/main.c

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