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   static int quiet = 0;
 123   static int batch = 0;
 124   static int set_args = 0;
 125
 126   /* Pointers to various arguments from command line.  */
 127   char *symarg = NULL;
 128   char *execarg = NULL;
 129   char *pidarg = NULL;
 130   char *corearg = NULL;
 131   char *pid_or_core_arg = NULL;
 132   char *cdarg = NULL;
 133   char *ttyarg = NULL;
 134
 135   /* These are static so that we can take their address in an initializer.  */
 136   static int print_help;
 137   static int print_version;
 138
 139   /* Pointers to all arguments of --command option.  */
 140   struct cmdarg {
 141     enum {
 142       CMDARG_FILE,
 143       CMDARG_COMMAND
 144     } type;
 145     char *string;
 146   } *cmdarg;
 147   /* Allocated size of cmdarg.  */
 148   int cmdsize;
 149   /* Number of elements of cmdarg used.  */
 150   int ncmd;
 151
 152   /* Indices of all arguments of --directory option.  */
 153   char **dirarg;
 154   /* Allocated size.  */
 155   int dirsize;
 156   /* Number of elements used.  */
 157   int ndir;
 158
 159   struct stat homebuf, cwdbuf;
 160   char *homedir;
 161
 162   int i;
 163
 164   long time_at_startup = get_run_time ();
 165
 166 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
 167   setlocale (LC_MESSAGES, "");
 168 #endif
 169 #if defined (HAVE_SETLOCALE)
 170   setlocale (LC_CTYPE, "");
 171 #endif
 172   bindtextdomain (PACKAGE, LOCALEDIR);
 173   textdomain (PACKAGE);
 174
 175 #ifdef HAVE_SBRK
 176   lim_at_start = (char *) sbrk (0);
 177 #endif
 178
 179   cmdsize = 1;
 180   cmdarg = (struct cmdarg *) xmalloc (cmdsize * sizeof (*cmdarg));
 181   ncmd = 0;
 182   dirsize = 1;
 183   dirarg = (char **) xmalloc (dirsize * sizeof (*dirarg));
 184   ndir = 0;
 185
 186   quit_flag = 0;
 187   line = (char *) xmalloc (linesize);
 188   line[0] = '\0';               /* Terminate saved (now empty) cmd line */
 189   instream = stdin;
 190
 191   getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));
 192   current_directory = gdb_dirbuf;
 193
 194   gdb_stdout = stdio_fileopen (stdout);
 195   gdb_stderr = stdio_fileopen (stderr);
 196   gdb_stdlog = gdb_stderr;      /* for moment */
 197   gdb_stdtarg = gdb_stderr;     /* for moment */
 198   gdb_stdin = stdio_fileopen (stdin);
 199   gdb_stdtargerr = gdb_stderr;  /* for moment */
 200   gdb_stdtargin = gdb_stdin;    /* for moment */
 201
 202   /* Set the sysroot path.  */
 203 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
 204   gdb_sysroot = make_relative_prefix (argv[0], BINDIR, TARGET_SYSTEM_ROOT);
 205   if (gdb_sysroot)
 206     {
 207       struct stat s;
 208       int res = 0;
 209
 210       if (stat (gdb_sysroot, &s) == 0)
 211         if (S_ISDIR (s.st_mode))
 212           res = 1;
 213
 214       if (res == 0)
 215         {
 216           xfree (gdb_sysroot);
 217           gdb_sysroot = xstrdup (TARGET_SYSTEM_ROOT);
 218         }
 219     }
 220   else
 221     gdb_sysroot = xstrdup (TARGET_SYSTEM_ROOT);
 222 #else
 223   gdb_sysroot = xstrdup (TARGET_SYSTEM_ROOT);
 224 #endif
 225
 226   /* Canonicalize the sysroot path.  */
 227   if (*gdb_sysroot)
 228     {
 229       char *canon_sysroot = lrealpath (gdb_sysroot);
 230       if (canon_sysroot)
 231         {
 232           xfree (gdb_sysroot);
 233           gdb_sysroot = canon_sysroot;
 234         }
 235     }
 236
 237 #ifdef DEBUGDIR_RELOCATABLE
 238   debug_file_directory = make_relative_prefix (argv[0], BINDIR, DEBUGDIR);
 239   if (debug_file_directory)
 240     {
 241       struct stat s;
 242       int res = 0;
 243
 244       if (stat (debug_file_directory, &s) == 0)
 245         if (S_ISDIR (s.st_mode))
 246           res = 1;
 247
 248       if (res == 0)
 249         {
 250           xfree (debug_file_directory);
 251           debug_file_directory = xstrdup (DEBUGDIR);
 252         }
 253     }
 254   else
 255     debug_file_directory = xstrdup (DEBUGDIR);
 256 #else
 257   debug_file_directory = xstrdup (DEBUGDIR);
 258 #endif
 259
 260   /* Canonicalize the debugfile path.  */
 261   if (*debug_file_directory)
 262     {
 263       char *canon_debug = lrealpath (debug_file_directory);
 264       if (canon_debug)
 265         {
 266           xfree (debug_file_directory);
 267           debug_file_directory = canon_debug;
 268         }
 269     }
 270
 271   /* There will always be an interpreter.  Either the one passed into
 272      this captured main, or one specified by the user at start up, or
 273      the console.  Initialize the interpreter to the one requested by
 274      the application.  */
 275   interpreter_p = xstrdup (context->interpreter_p);
 276
 277   /* Parse arguments and options.  */
 278   {
 279     int c;
 280     /* When var field is 0, use flag field to record the equivalent
 281        short option (or arbitrary numbers starting at 10 for those
 282        with no equivalent).  */
 283     enum {
 284       OPT_SE = 10,
 285       OPT_CD,
 286       OPT_ANNOTATE,
 287       OPT_STATISTICS,
 288       OPT_TUI,
 289       OPT_NOWINDOWS,
 290       OPT_WINDOWS
 291     };
 292     static struct option long_options[] =
 293     {
 294       {"tui", no_argument, 0, OPT_TUI},
 295       {"xdb", no_argument, &xdb_commands, 1},
 296       {"dbx", no_argument, &dbx_commands, 1},
 297       {"readnow", no_argument, &readnow_symbol_files, 1},
 298       {"r", no_argument, &readnow_symbol_files, 1},
 299       {"quiet", no_argument, &quiet, 1},
 300       {"q", no_argument, &quiet, 1},
 301       {"silent", no_argument, &quiet, 1},
 302       {"nx", no_argument, &inhibit_gdbinit, 1},
 303       {"n", no_argument, &inhibit_gdbinit, 1},
 304       {"batch-silent", no_argument, 0, 'B'},
 305       {"batch", no_argument, &batch, 1},
 306       {"epoch", no_argument, &epoch_interface, 1},
 307
 308     /* This is a synonym for "--annotate=1".  --annotate is now preferred,
 309        but keep this here for a long time because people will be running
 310        emacses which use --fullname.  */
 311       {"fullname", no_argument, 0, 'f'},
 312       {"f", no_argument, 0, 'f'},
 313
 314       {"annotate", required_argument, 0, OPT_ANNOTATE},
 315       {"help", no_argument, &print_help, 1},
 316       {"se", required_argument, 0, OPT_SE},
 317       {"symbols", required_argument, 0, 's'},
 318       {"s", required_argument, 0, 's'},
 319       {"exec", required_argument, 0, 'e'},
 320       {"e", required_argument, 0, 'e'},
 321       {"core", required_argument, 0, 'c'},
 322       {"c", required_argument, 0, 'c'},
 323       {"pid", required_argument, 0, 'p'},
 324       {"p", required_argument, 0, 'p'},
 325       {"command", required_argument, 0, 'x'},
 326       {"eval-command", required_argument, 0, 'X'},
 327       {"version", no_argument, &print_version, 1},
 328       {"x", required_argument, 0, 'x'},
 329       {"ex", required_argument, 0, 'X'},
 330 #ifdef GDBTK
 331       {"tclcommand", required_argument, 0, 'z'},
 332       {"enable-external-editor", no_argument, 0, 'y'},
 333       {"editor-command", required_argument, 0, 'w'},
 334 #endif
 335       {"ui", required_argument, 0, 'i'},
 336       {"interpreter", required_argument, 0, 'i'},
 337       {"i", required_argument, 0, 'i'},
 338       {"directory", required_argument, 0, 'd'},
 339       {"d", required_argument, 0, 'd'},
 340       {"cd", required_argument, 0, OPT_CD},
 341       {"tty", required_argument, 0, 't'},
 342       {"baud", required_argument, 0, 'b'},
 343       {"b", required_argument, 0, 'b'},
 344       {"nw", no_argument, NULL, OPT_NOWINDOWS},
 345       {"nowindows", no_argument, NULL, OPT_NOWINDOWS},
 346       {"w", no_argument, NULL, OPT_WINDOWS},
 347       {"windows", no_argument, NULL, OPT_WINDOWS},
 348       {"statistics", no_argument, 0, OPT_STATISTICS},
 349       {"write", no_argument, &write_files, 1},
 350       {"args", no_argument, &set_args, 1},
 351      {"l", required_argument, 0, 'l'},
 352       {"return-child-result", no_argument, &return_child_result, 1},
 353       {0, no_argument, 0, 0}
 354     };
 355
 356     while (1)
 357       {
 358         int option_index;
 359
 360         c = getopt_long_only (argc, argv, "",
 361                               long_options, &option_index);
 362         if (c == EOF || set_args)
 363           break;
 364
 365         /* Long option that takes an argument.  */
 366         if (c == 0 && long_options[option_index].flag == 0)
 367           c = long_options[option_index].val;
 368
 369         switch (c)
 370           {
 371           case 0:
 372             /* Long option that just sets a flag.  */
 373             break;
 374           case OPT_SE:
 375             symarg = optarg;
 376             execarg = optarg;
 377             break;
 378           case OPT_CD:
 379             cdarg = optarg;
 380             break;
 381           case OPT_ANNOTATE:
 382             /* FIXME: what if the syntax is wrong (e.g. not digits)?  */
 383             annotation_level = atoi (optarg);
 384             break;
 385           case OPT_STATISTICS:
 386             /* Enable the display of both time and space usage.  */
 387             display_time = 1;
 388             display_space = 1;
 389             break;
 390           case OPT_TUI:
 391             /* --tui is equivalent to -i=tui.  */
 392 #ifdef TUI
 393             xfree (interpreter_p);
 394             interpreter_p = xstrdup (INTERP_TUI);
 395 #else
 396             fprintf_unfiltered (gdb_stderr,
 397                                 _("%s: TUI mode is not supported\n"),
 398                                 argv[0]);
 399             exit (1);
 400 #endif
 401             break;
 402           case OPT_WINDOWS:
 403             /* FIXME: cagney/2003-03-01: Not sure if this option is
 404                actually useful, and if it is, what it should do.  */
 405 #ifdef GDBTK
 406             /* --windows is equivalent to -i=insight.  */
 407             xfree (interpreter_p);
 408             interpreter_p = xstrdup (INTERP_INSIGHT);
 409 #endif
 410             use_windows = 1;
 411             break;
 412           case OPT_NOWINDOWS:
 413             /* -nw is equivalent to -i=console.  */
 414             xfree (interpreter_p);
 415             interpreter_p = xstrdup (INTERP_CONSOLE);
 416             use_windows = 0;
 417             break;
 418           case 'f':
 419             annotation_level = 1;
 420 /* We have probably been invoked from emacs.  Disable window interface.  */
 421             use_windows = 0;
 422             break;
 423           case 's':
 424             symarg = optarg;
 425             break;
 426           case 'e':
 427             execarg = optarg;
 428             break;
 429           case 'c':
 430             corearg = optarg;
 431             break;
 432           case 'p':
 433             pidarg = optarg;
 434             break;
 435           case 'x':
 436             cmdarg[ncmd].type = CMDARG_FILE;
 437             cmdarg[ncmd++].string = optarg;
 438             if (ncmd >= cmdsize)
 439               {
 440                 cmdsize *= 2;
 441                 cmdarg = xrealloc ((char *) cmdarg,
 442                                    cmdsize * sizeof (*cmdarg));
 443               }
 444             break;
 445           case 'X':
 446             cmdarg[ncmd].type = CMDARG_COMMAND;
 447             cmdarg[ncmd++].string = optarg;
 448             if (ncmd >= cmdsize)
 449               {
 450                 cmdsize *= 2;
 451                 cmdarg = xrealloc ((char *) cmdarg,
 452                                    cmdsize * sizeof (*cmdarg));
 453               }
 454             break;
 455           case 'B':
 456             batch = batch_silent = 1;
 457             gdb_stdout = ui_file_new();
 458             break;
 459 #ifdef GDBTK
 460           case 'z':
 461             {
 462 extern int gdbtk_test (char *);
 463               if (!gdbtk_test (optarg))
 464                 {
 465                   fprintf_unfiltered (gdb_stderr, _("%s: unable to load tclcommand file \"%s\""),
 466                                       argv[0], optarg);
 467                   exit (1);
 468                 }
 469               break;
 470             }
 471           case 'y':
 472             /* Backwards compatibility only.  */
 473             break;
 474           case 'w':
 475             {
 476               external_editor_command = xstrdup (optarg);
 477               break;
 478             }
 479 #endif /* GDBTK */
 480           case 'i':
 481             xfree (interpreter_p);
 482             interpreter_p = xstrdup (optarg);
 483             break;
 484           case 'd':
 485             dirarg[ndir++] = optarg;
 486             if (ndir >= dirsize)
 487               {
 488                 dirsize *= 2;
 489                 dirarg = (char **) xrealloc ((char *) dirarg,
 490                                              dirsize * sizeof (*dirarg));
 491               }
 492             break;
 493           case 't':
 494             ttyarg = optarg;
 495             break;
 496           case 'q':
 497             quiet = 1;
 498             break;
 499           case 'b':
 500             {
 501               int i;
 502               char *p;
 503
 504               i = strtol (optarg, &p, 0);
 505               if (i == 0 && p == optarg)
 506
 507                 /* Don't use *_filtered or warning() (which relies on
 508                    current_target) until after initialize_all_files(). */
 509
 510                 fprintf_unfiltered
 511                   (gdb_stderr,
 512                    _("warning: could not set baud rate to `%s'.\n"), optarg);
 513               else
 514                 baud_rate = i;
 515             }
 516             break;
 517           case 'l':
 518             {
 519               int i;
 520               char *p;
 521
 522               i = strtol (optarg, &p, 0);
 523               if (i == 0 && p == optarg)
 524
 525                 /* Don't use *_filtered or warning() (which relies on
 526                    current_target) until after initialize_all_files(). */
 527
 528                 fprintf_unfiltered
 529                   (gdb_stderr,
 530                  _("warning: could not set timeout limit to `%s'.\n"), optarg);
 531               else
 532                 remote_timeout = i;
 533             }
 534             break;
 535
 536           case '?':
 537             fprintf_unfiltered (gdb_stderr,
 538                         _("Use `%s --help' for a complete list of options.\n"),
 539                                 argv[0]);
 540             exit (1);
 541           }
 542       }
 543
 544     /* If --help or --version, disable window interface.  */
 545     if (print_help || print_version)
 546       {
 547         use_windows = 0;
 548       }
 549
 550     if (set_args)
 551       {
 552         /* The remaining options are the command-line options for the
 553            inferior.  The first one is the sym/exec file, and the rest
 554            are arguments.  */
 555         if (optind >= argc)
 556           {
 557             fprintf_unfiltered (gdb_stderr,
 558                                 _("%s: `--args' specified but no program specified\n"),
 559                                 argv[0]);
 560             exit (1);
 561           }
 562         symarg = argv[optind];
 563         execarg = argv[optind];
 564         ++optind;
 565         set_inferior_args_vector (argc - optind, &argv[optind]);
 566       }
 567     else
 568       {
 569         /* OK, that's all the options.  */
 570
 571         /* The first argument, if specified, is the name of the
 572            executable.  */
 573         if (optind < argc)
 574           {
 575             symarg = argv[optind];
 576             execarg = argv[optind];
 577             optind++;
 578           }
 579
 580         /* If the user hasn't already specified a PID or the name of a
 581            core file, then a second optional argument is allowed.  If
 582            present, this argument should be interpreted as either a
 583            PID or a core file, whichever works.  */
 584         if (pidarg == NULL && corearg == NULL && optind < argc)
 585           {
 586             pid_or_core_arg = argv[optind];
 587             optind++;
 588           }
 589
 590         /* Any argument left on the command line is unexpected and
 591            will be ignored.  Inform the user.  */
 592         if (optind < argc)
 593           fprintf_unfiltered (gdb_stderr, _("\
 594 Excess command line arguments ignored. (%s%s)\n"),
 595                               argv[optind],
 596                               (optind == argc - 1) ? "" : " ...");
 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, 1))
 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 && pidarg)
 739     error (_("\
 740 Can't attach to process and specify a core file at the same time."));
 741
 742   if (corearg != NULL)
 743     catch_command_errors (core_file_command, corearg,
 744                           !batch, RETURN_MASK_ALL);
 745   else if (pidarg != NULL)
 746     catch_command_errors (attach_command, pidarg,
 747                           !batch, RETURN_MASK_ALL);
 748   else if (pid_or_core_arg)
 749     {
 750       /* The user specified 'gdb program pid' or gdb program core'.
 751          If pid_or_core_arg's first character is a digit, try attach
 752          first and then corefile.  Otherwise try just corefile.  */
 753
 754       if (isdigit (pid_or_core_arg[0]))
 755         {
 756           if (catch_command_errors (attach_command, pid_or_core_arg,
 757                                     !batch, RETURN_MASK_ALL) == 0)
 758             catch_command_errors (core_file_command, pid_or_core_arg,
 759                                   !batch, RETURN_MASK_ALL);
 760         }
 761       else /* Can't be a pid, better be a corefile.  */
 762         catch_command_errors (core_file_command, pid_or_core_arg,
 763                               !batch, RETURN_MASK_ALL);
 764     }
 765
 766   if (ttyarg != NULL)
 767     catch_command_errors (tty_command, ttyarg, !batch, RETURN_MASK_ALL);
 768
 769   /* Error messages should no longer be distinguished with extra output. */
 770   error_pre_print = NULL;
 771   quit_pre_print = NULL;
 772   warning_pre_print = _("warning: ");
 773
 774   /* Read the .gdbinit file in the current directory, *if* it isn't
 775      the same as the $HOME/.gdbinit file (it should exist, also).  */
 776
 777   if (!homedir
 778       || memcmp ((char *) &homebuf, (char *) &cwdbuf, sizeof (struct stat)))
 779     if (!inhibit_gdbinit)
 780       {
 781         catch_command_errors (source_script, gdbinit, 0, RETURN_MASK_ALL);
 782       }
 783
 784   for (i = 0; i < ncmd; i++)
 785     {
 786 #if 0
 787       /* NOTE: cagney/1999-11-03: SET_TOP_LEVEL() was a macro that
 788          expanded into a call to setjmp().  */
 789       if (!SET_TOP_LEVEL ()) /* NB: This is #if 0'd out */
 790         {
 791           /* NOTE: I am commenting this out, because it is not clear
 792              where this feature is used. It is very old and
 793              undocumented. ezannoni: 1999-05-04 */
 794 #if 0
 795           if (cmdarg[i][0] == '-' && cmdarg[i][1] == '\0')
 796             read_command_file (stdin);
 797           else
 798 #endif
 799             source_script (cmdarg[i], !batch);
 800           do_cleanups (ALL_CLEANUPS);
 801         }
 802 #endif
 803       if (cmdarg[i].type == CMDARG_FILE)
 804         catch_command_errors (source_script, cmdarg[i].string,
 805                               !batch, RETURN_MASK_ALL);
 806       else  /* cmdarg[i].type == CMDARG_COMMAND */
 807         catch_command_errors (execute_command, cmdarg[i].string,
 808                               !batch, RETURN_MASK_ALL);
 809     }
 810   xfree (cmdarg);
 811
 812   /* Read in the old history after all the command files have been read. */
 813   init_history ();
 814
 815   if (batch)
 816     {
 817       /* We have hit the end of the batch file.  */
 818       quit_force (NULL, 0);
 819     }
 820
 821   /* Show time and/or space usage.  */
 822
 823   if (display_time)
 824     {
 825       long init_time = get_run_time () - time_at_startup;
 826
 827       printf_unfiltered (_("Startup time: %ld.%06ld\n"),
 828                          init_time / 1000000, init_time % 1000000);
 829     }
 830
 831   if (display_space)
 832     {
 833 #ifdef HAVE_SBRK
 834       extern char **environ;
 835       char *lim = (char *) sbrk (0);
 836
 837       printf_unfiltered (_("Startup size: data size %ld\n"),
 838                          (long) (lim - (char *) &environ));
 839 #endif
 840     }
 841
 842 #if 0
 843   /* FIXME: cagney/1999-11-06: The original main loop was like: */
 844   while (1)
 845     {
 846       if (!SET_TOP_LEVEL ())
 847         {
 848           do_cleanups (ALL_CLEANUPS);   /* Do complete cleanup */
 849           /* GUIs generally have their own command loop, mainloop, or
 850              whatever.  This is a good place to gain control because
 851              many error conditions will end up here via longjmp().  */
 852           if (deprecated_command_loop_hook)
 853             deprecated_command_loop_hook ();
 854           else
 855             deprecated_command_loop ();
 856           quit_command ((char *) 0, instream == stdin);
 857         }
 858     }
 859   /* NOTE: If the command_loop() returned normally, the loop would
 860      attempt to exit by calling the function quit_command().  That
 861      function would either call exit() or throw an error returning
 862      control to SET_TOP_LEVEL. */
 863   /* NOTE: The function do_cleanups() was called once each time round
 864      the loop.  The usefulness of the call isn't clear.  If an error
 865      was thrown, everything would have already been cleaned up.  If
 866      command_loop() returned normally and quit_command() was called,
 867      either exit() or error() (again cleaning up) would be called. */
 868 #endif
 869   /* NOTE: cagney/1999-11-07: There is probably no reason for not
 870      moving this loop and the code found in captured_command_loop()
 871      into the command_loop() proper.  The main thing holding back that
 872      change - SET_TOP_LEVEL() - has been eliminated. */
 873   while (1)
 874     {
 875       catch_errors (captured_command_loop, 0, "", RETURN_MASK_ALL);
 876     }
 877   /* No exit -- exit is through quit_command.  */
 878 }
 879
 880 int
 881 gdb_main (struct captured_main_args *args)
 882 {
 883   use_windows = args->use_windows;
 884   catch_errors (captured_main, args, "", RETURN_MASK_ALL);
 885   /* The only way to end up here is by an error (normal exit is
 886      handled by quit_force()), hence always return an error status.  */
 887   return 1;
 888 }
 889
 890
 891 /* Don't use *_filtered for printing help.  We don't want to prompt
 892    for continue no matter how small the screen or how much we're going
 893    to print.  */
 894
 895 static void
 896 print_gdb_help (struct ui_file *stream)
 897 {
 898   fputs_unfiltered (_("\
 899 This is the GNU debugger.  Usage:\n\n\
 900     gdb [options] [executable-file [core-file or process-id]]\n\
 901     gdb [options] --args executable-file [inferior-arguments ...]\n\n\
 902 Options:\n\n\
 903 "), stream);
 904   fputs_unfiltered (_("\
 905   --args             Arguments after executable-file are passed to inferior\n\
 906 "), stream);
 907   fputs_unfiltered (_("\
 908   -b BAUDRATE        Set serial port baud rate used for remote debugging.\n\
 909   --batch            Exit after processing options.\n\
 910   --batch-silent     As for --batch, but suppress all gdb stdout output.\n\
 911   --return-child-result\n\
 912                      GDB exit code will be the child's exit code.\n\
 913   --cd=DIR           Change current directory to DIR.\n\
 914   --command=FILE, -x Execute GDB commands from FILE.\n\
 915   --eval-command=COMMAND, -ex\n\
 916                      Execute a single GDB command.\n\
 917                      May be used multiple times and in conjunction\n\
 918                      with --command.\n\
 919   --core=COREFILE    Analyze the core dump COREFILE.\n\
 920   --pid=PID          Attach to running process PID.\n\
 921 "), stream);
 922   fputs_unfiltered (_("\
 923   --dbx              DBX compatibility mode.\n\
 924   --directory=DIR    Search for source files in DIR.\n\
 925   --epoch            Output information used by epoch emacs-GDB interface.\n\
 926   --exec=EXECFILE    Use EXECFILE as the executable.\n\
 927   --fullname         Output information used by emacs-GDB interface.\n\
 928   --help             Print this message.\n\
 929 "), stream);
 930   fputs_unfiltered (_("\
 931   --interpreter=INTERP\n\
 932                      Select a specific interpreter / user interface\n\
 933 "), stream);
 934   fputs_unfiltered (_("\
 935   -l TIMEOUT         Set timeout in seconds for remote debugging.\n\
 936   --nw               Do not use a window interface.\n\
 937   --nx               Do not read "), stream);
 938   fputs_unfiltered (gdbinit, stream);
 939   fputs_unfiltered (_(" file.\n\
 940   --quiet            Do not print version number on startup.\n\
 941   --readnow          Fully read symbol files on first access.\n\
 942 "), stream);
 943   fputs_unfiltered (_("\
 944   --se=FILE          Use FILE as symbol file and executable file.\n\
 945   --symbols=SYMFILE  Read symbols from SYMFILE.\n\
 946   --tty=TTY          Use TTY for input/output by the program being debugged.\n\
 947 "), stream);
 948 #if defined(TUI)
 949   fputs_unfiltered (_("\
 950   --tui              Use a terminal user interface.\n\
 951 "), stream);
 952 #endif
 953   fputs_unfiltered (_("\
 954   --version          Print version information and then exit.\n\
 955   -w                 Use a window interface.\n\
 956   --write            Set writing into executable and core files.\n\
 957   --xdb              XDB compatibility mode.\n\
 958 "), stream);
 959   fputs_unfiltered (_("\n\
 960 For more information, type \"help\" from within GDB, or consult the\n\
 961 GDB manual (available as on-line info or a printed manual).\n\
 962 "), stream);
 963   if (REPORT_BUGS_TO[0] && stream == gdb_stdout)
 964     fprintf_unfiltered (stream, _("\
 965 Report bugs to \"%s\".\n\
 966 "), REPORT_BUGS_TO);
 967 }