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