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    2009 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   gdb_stdout = stdio_fileopen (stdout);
 192   gdb_stderr = stdio_fileopen (stderr);
 193   gdb_stdlog = gdb_stderr;      /* for moment */
 194   gdb_stdtarg = gdb_stderr;     /* for moment */
 195   gdb_stdin = stdio_fileopen (stdin);
 196   gdb_stdtargerr = gdb_stderr;  /* for moment */
 197   gdb_stdtargin = gdb_stdin;    /* for moment */
 198
 199   if (! getcwd (gdb_dirbuf, sizeof (gdb_dirbuf)))
 200     /* Don't use *_filtered or warning() (which relies on
 201        current_target) until after initialize_all_files(). */
 202     fprintf_unfiltered (gdb_stderr,
 203                         _("%s: warning: error finding working directory: %s\n"),
 204                         argv[0], safe_strerror (errno));
 205
 206   current_directory = gdb_dirbuf;
 207
 208   /* Set the sysroot path.  */
 209 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
 210   gdb_sysroot = make_relative_prefix (argv[0], BINDIR, TARGET_SYSTEM_ROOT);
 211   if (gdb_sysroot)
 212     {
 213       struct stat s;
 214       int res = 0;
 215
 216       if (stat (gdb_sysroot, &s) == 0)
 217         if (S_ISDIR (s.st_mode))
 218           res = 1;
 219
 220       if (res == 0)
 221         {
 222           xfree (gdb_sysroot);
 223           gdb_sysroot = xstrdup (TARGET_SYSTEM_ROOT);
 224         }
 225     }
 226   else
 227     gdb_sysroot = xstrdup (TARGET_SYSTEM_ROOT);
 228 #else
 229   gdb_sysroot = xstrdup (TARGET_SYSTEM_ROOT);
 230 #endif
 231
 232   /* Canonicalize the sysroot path.  */
 233   if (*gdb_sysroot)
 234     {
 235       char *canon_sysroot = lrealpath (gdb_sysroot);
 236       if (canon_sysroot)
 237         {
 238           xfree (gdb_sysroot);
 239           gdb_sysroot = canon_sysroot;
 240         }
 241     }
 242
 243 #ifdef DEBUGDIR_RELOCATABLE
 244   debug_file_directory = make_relative_prefix (argv[0], BINDIR, DEBUGDIR);
 245   if (debug_file_directory)
 246     {
 247       struct stat s;
 248       int res = 0;
 249
 250       if (stat (debug_file_directory, &s) == 0)
 251         if (S_ISDIR (s.st_mode))
 252           res = 1;
 253
 254       if (res == 0)
 255         {
 256           xfree (debug_file_directory);
 257           debug_file_directory = xstrdup (DEBUGDIR);
 258         }
 259     }
 260   else
 261     debug_file_directory = xstrdup (DEBUGDIR);
 262 #else
 263   debug_file_directory = xstrdup (DEBUGDIR);
 264 #endif
 265
 266   /* Canonicalize the debugfile path.  */
 267   if (*debug_file_directory)
 268     {
 269       char *canon_debug = lrealpath (debug_file_directory);
 270       if (canon_debug)
 271         {
 272           xfree (debug_file_directory);
 273           debug_file_directory = canon_debug;
 274         }
 275     }
 276
 277   /* There will always be an interpreter.  Either the one passed into
 278      this captured main, or one specified by the user at start up, or
 279      the console.  Initialize the interpreter to the one requested by
 280      the application.  */
 281   interpreter_p = xstrdup (context->interpreter_p);
 282
 283   /* Parse arguments and options.  */
 284   {
 285     int c;
 286     /* When var field is 0, use flag field to record the equivalent
 287        short option (or arbitrary numbers starting at 10 for those
 288        with no equivalent).  */
 289     enum {
 290       OPT_SE = 10,
 291       OPT_CD,
 292       OPT_ANNOTATE,
 293       OPT_STATISTICS,
 294       OPT_TUI,
 295       OPT_NOWINDOWS,
 296       OPT_WINDOWS
 297     };
 298     static struct option long_options[] =
 299     {
 300       {"tui", no_argument, 0, OPT_TUI},
 301       {"xdb", no_argument, &xdb_commands, 1},
 302       {"dbx", no_argument, &dbx_commands, 1},
 303       {"readnow", no_argument, &readnow_symbol_files, 1},
 304       {"r", no_argument, &readnow_symbol_files, 1},
 305       {"quiet", no_argument, &quiet, 1},
 306       {"q", no_argument, &quiet, 1},
 307       {"silent", no_argument, &quiet, 1},
 308       {"nx", no_argument, &inhibit_gdbinit, 1},
 309       {"n", no_argument, &inhibit_gdbinit, 1},
 310       {"batch-silent", no_argument, 0, 'B'},
 311       {"batch", no_argument, &batch, 1},
 312       {"epoch", no_argument, &epoch_interface, 1},
 313
 314     /* This is a synonym for "--annotate=1".  --annotate is now preferred,
 315        but keep this here for a long time because people will be running
 316        emacses which use --fullname.  */
 317       {"fullname", no_argument, 0, 'f'},
 318       {"f", no_argument, 0, 'f'},
 319
 320       {"annotate", required_argument, 0, OPT_ANNOTATE},
 321       {"help", no_argument, &print_help, 1},
 322       {"se", required_argument, 0, OPT_SE},
 323       {"symbols", required_argument, 0, 's'},
 324       {"s", required_argument, 0, 's'},
 325       {"exec", required_argument, 0, 'e'},
 326       {"e", required_argument, 0, 'e'},
 327       {"core", required_argument, 0, 'c'},
 328       {"c", required_argument, 0, 'c'},
 329       {"pid", required_argument, 0, 'p'},
 330       {"p", required_argument, 0, 'p'},
 331       {"command", required_argument, 0, 'x'},
 332       {"eval-command", required_argument, 0, 'X'},
 333       {"version", no_argument, &print_version, 1},
 334       {"x", required_argument, 0, 'x'},
 335       {"ex", required_argument, 0, 'X'},
 336 #ifdef GDBTK
 337       {"tclcommand", required_argument, 0, 'z'},
 338       {"enable-external-editor", no_argument, 0, 'y'},
 339       {"editor-command", required_argument, 0, 'w'},
 340 #endif
 341       {"ui", required_argument, 0, 'i'},
 342       {"interpreter", required_argument, 0, 'i'},
 343       {"i", required_argument, 0, 'i'},
 344       {"directory", required_argument, 0, 'd'},
 345       {"d", required_argument, 0, 'd'},
 346       {"cd", required_argument, 0, OPT_CD},
 347       {"tty", required_argument, 0, 't'},
 348       {"baud", required_argument, 0, 'b'},
 349       {"b", required_argument, 0, 'b'},
 350       {"nw", no_argument, NULL, OPT_NOWINDOWS},
 351       {"nowindows", no_argument, NULL, OPT_NOWINDOWS},
 352       {"w", no_argument, NULL, OPT_WINDOWS},
 353       {"windows", no_argument, NULL, OPT_WINDOWS},
 354       {"statistics", no_argument, 0, OPT_STATISTICS},
 355       {"write", no_argument, &write_files, 1},
 356       {"args", no_argument, &set_args, 1},
 357      {"l", required_argument, 0, 'l'},
 358       {"return-child-result", no_argument, &return_child_result, 1},
 359       {0, no_argument, 0, 0}
 360     };
 361
 362     while (1)
 363       {
 364         int option_index;
 365
 366         c = getopt_long_only (argc, argv, "",
 367                               long_options, &option_index);
 368         if (c == EOF || set_args)
 369           break;
 370
 371         /* Long option that takes an argument.  */
 372         if (c == 0 && long_options[option_index].flag == 0)
 373           c = long_options[option_index].val;
 374
 375         switch (c)
 376           {
 377           case 0:
 378             /* Long option that just sets a flag.  */
 379             break;
 380           case OPT_SE:
 381             symarg = optarg;
 382             execarg = optarg;
 383             break;
 384           case OPT_CD:
 385             cdarg = optarg;
 386             break;
 387           case OPT_ANNOTATE:
 388             /* FIXME: what if the syntax is wrong (e.g. not digits)?  */
 389             annotation_level = atoi (optarg);
 390             break;
 391           case OPT_STATISTICS:
 392             /* Enable the display of both time and space usage.  */
 393             display_time = 1;
 394             display_space = 1;
 395             break;
 396           case OPT_TUI:
 397             /* --tui is equivalent to -i=tui.  */
 398 #ifdef TUI
 399             xfree (interpreter_p);
 400             interpreter_p = xstrdup (INTERP_TUI);
 401 #else
 402             fprintf_unfiltered (gdb_stderr,
 403                                 _("%s: TUI mode is not supported\n"),
 404                                 argv[0]);
 405             exit (1);
 406 #endif
 407             break;
 408           case OPT_WINDOWS:
 409             /* FIXME: cagney/2003-03-01: Not sure if this option is
 410                actually useful, and if it is, what it should do.  */
 411 #ifdef GDBTK
 412             /* --windows is equivalent to -i=insight.  */
 413             xfree (interpreter_p);
 414             interpreter_p = xstrdup (INTERP_INSIGHT);
 415 #endif
 416             use_windows = 1;
 417             break;
 418           case OPT_NOWINDOWS:
 419             /* -nw is equivalent to -i=console.  */
 420             xfree (interpreter_p);
 421             interpreter_p = xstrdup (INTERP_CONSOLE);
 422             use_windows = 0;
 423             break;
 424           case 'f':
 425             annotation_level = 1;
 426 /* We have probably been invoked from emacs.  Disable window interface.  */
 427             use_windows = 0;
 428             break;
 429           case 's':
 430             symarg = optarg;
 431             break;
 432           case 'e':
 433             execarg = optarg;
 434             break;
 435           case 'c':
 436             corearg = optarg;
 437             break;
 438           case 'p':
 439             pidarg = 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.  */
 576
 577         /* The first argument, if specified, is the name of the
 578            executable.  */
 579         if (optind < argc)
 580           {
 581             symarg = argv[optind];
 582             execarg = argv[optind];
 583             optind++;
 584           }
 585
 586         /* If the user hasn't already specified a PID or the name of a
 587            core file, then a second optional argument is allowed.  If
 588            present, this argument should be interpreted as either a
 589            PID or a core file, whichever works.  */
 590         if (pidarg == NULL && corearg == NULL && optind < argc)
 591           {
 592             pid_or_core_arg = argv[optind];
 593             optind++;
 594           }
 595
 596         /* Any argument left on the command line is unexpected and
 597            will be ignored.  Inform the user.  */
 598         if (optind < argc)
 599           fprintf_unfiltered (gdb_stderr, _("\
 600 Excess command line arguments ignored. (%s%s)\n"),
 601                               argv[optind],
 602                               (optind == argc - 1) ? "" : " ...");
 603       }
 604     if (batch)
 605       quiet = 1;
 606   }
 607
 608   /* Initialize all files.  Give the interpreter a chance to take
 609      control of the console via the deprecated_init_ui_hook ().  */
 610   gdb_init (argv[0]);
 611
 612   /* Do these (and anything which might call wrap_here or *_filtered)
 613      after initialize_all_files() but before the interpreter has been
 614      installed.  Otherwize the help/version messages will be eaten by
 615      the interpreter's output handler.  */
 616
 617   if (print_version)
 618     {
 619       print_gdb_version (gdb_stdout);
 620       wrap_here ("");
 621       printf_filtered ("\n");
 622       exit (0);
 623     }
 624
 625   if (print_help)
 626     {
 627       print_gdb_help (gdb_stdout);
 628       fputs_unfiltered ("\n", gdb_stdout);
 629       exit (0);
 630     }
 631
 632   /* FIXME: cagney/2003-02-03: The big hack (part 1 of 2) that lets
 633      GDB retain the old MI1 interpreter startup behavior.  Output the
 634      copyright message before the interpreter is installed.  That way
 635      it isn't encapsulated in MI output.  */
 636   if (!quiet && strcmp (interpreter_p, INTERP_MI1) == 0)
 637     {
 638       /* Print all the junk at the top, with trailing "..." if we are about
 639          to read a symbol file (possibly slowly).  */
 640       print_gdb_version (gdb_stdout);
 641       if (symarg)
 642         printf_filtered ("..");
 643       wrap_here ("");
 644       printf_filtered ("\n");
 645       gdb_flush (gdb_stdout);   /* Force to screen during slow operations */
 646     }
 647
 648
 649   /* Install the default UI.  All the interpreters should have had a
 650      look at things by now.  Initialize the default interpreter. */
 651
 652   {
 653     /* Find it.  */
 654     struct interp *interp = interp_lookup (interpreter_p);
 655     if (interp == NULL)
 656       error (_("Interpreter `%s' unrecognized"), interpreter_p);
 657     /* Install it.  */
 658     if (!interp_set (interp, 1))
 659       {
 660         fprintf_unfiltered (gdb_stderr,
 661                             "Interpreter `%s' failed to initialize.\n",
 662                             interpreter_p);
 663         exit (1);
 664       }
 665   }
 666
 667   /* FIXME: cagney/2003-02-03: The big hack (part 2 of 2) that lets
 668      GDB retain the old MI1 interpreter startup behavior.  Output the
 669      copyright message after the interpreter is installed when it is
 670      any sane interpreter.  */
 671   if (!quiet && !current_interp_named_p (INTERP_MI1))
 672     {
 673       /* Print all the junk at the top, with trailing "..." if we are about
 674          to read a symbol file (possibly slowly).  */
 675       print_gdb_version (gdb_stdout);
 676       if (symarg)
 677         printf_filtered ("..");
 678       wrap_here ("");
 679       printf_filtered ("\n");
 680       gdb_flush (gdb_stdout);   /* Force to screen during slow operations */
 681     }
 682
 683   /* Set off error and warning messages with a blank line.  */
 684   error_pre_print = "\n";
 685   quit_pre_print = error_pre_print;
 686   warning_pre_print = _("\nwarning: ");
 687
 688   /* Read and execute $HOME/.gdbinit file, if it exists.  This is done
 689      *before* all the command line arguments are processed; it sets
 690      global parameters, which are independent of what file you are
 691      debugging or what directory you are in.  */
 692   homedir = getenv ("HOME");
 693   if (homedir)
 694     {
 695       char *homeinit = xstrprintf ("%s/%s", homedir, gdbinit);
 696
 697       if (!inhibit_gdbinit)
 698         {
 699           catch_command_errors (source_script, homeinit, 0, RETURN_MASK_ALL);
 700         }
 701
 702       /* Do stats; no need to do them elsewhere since we'll only
 703          need them if homedir is set.  Make sure that they are
 704          zero in case one of them fails (this guarantees that they
 705          won't match if either exists).  */
 706
 707       memset (&homebuf, 0, sizeof (struct stat));
 708       memset (&cwdbuf, 0, sizeof (struct stat));
 709
 710       stat (homeinit, &homebuf);
 711       stat (gdbinit, &cwdbuf);  /* We'll only need this if
 712                                    homedir was set.  */
 713       xfree (homeinit);
 714     }
 715
 716   /* Now perform all the actions indicated by the arguments.  */
 717   if (cdarg != NULL)
 718     {
 719       catch_command_errors (cd_command, cdarg, 0, RETURN_MASK_ALL);
 720     }
 721
 722   for (i = 0; i < ndir; i++)
 723     catch_command_errors (directory_switch, dirarg[i], 0, RETURN_MASK_ALL);
 724   xfree (dirarg);
 725
 726   if (execarg != NULL
 727       && symarg != NULL
 728       && strcmp (execarg, symarg) == 0)
 729     {
 730       /* The exec file and the symbol-file are the same.  If we can't
 731          open it, better only print one error message.
 732          catch_command_errors returns non-zero on success! */
 733       if (catch_command_errors (exec_file_attach, execarg, !batch, RETURN_MASK_ALL))
 734         catch_command_errors (symbol_file_add_main, symarg, 0, RETURN_MASK_ALL);
 735     }
 736   else
 737     {
 738       if (execarg != NULL)
 739         catch_command_errors (exec_file_attach, execarg, !batch, RETURN_MASK_ALL);
 740       if (symarg != NULL)
 741         catch_command_errors (symbol_file_add_main, symarg, 0, RETURN_MASK_ALL);
 742     }
 743
 744   if (corearg && pidarg)
 745     error (_("\
 746 Can't attach to process and specify a core file at the same time."));
 747
 748   if (corearg != NULL)
 749     catch_command_errors (core_file_command, corearg,
 750                           !batch, RETURN_MASK_ALL);
 751   else if (pidarg != NULL)
 752     catch_command_errors (attach_command, pidarg,
 753                           !batch, RETURN_MASK_ALL);
 754   else if (pid_or_core_arg)
 755     {
 756       /* The user specified 'gdb program pid' or gdb program core'.
 757          If pid_or_core_arg's first character is a digit, try attach
 758          first and then corefile.  Otherwise try just corefile.  */
 759
 760       if (isdigit (pid_or_core_arg[0]))
 761         {
 762           if (catch_command_errors (attach_command, pid_or_core_arg,
 763                                     !batch, RETURN_MASK_ALL) == 0)
 764             catch_command_errors (core_file_command, pid_or_core_arg,
 765                                   !batch, RETURN_MASK_ALL);
 766         }
 767       else /* Can't be a pid, better be a corefile.  */
 768         catch_command_errors (core_file_command, pid_or_core_arg,
 769                               !batch, RETURN_MASK_ALL);
 770     }
 771
 772   if (ttyarg != NULL)
 773     catch_command_errors (tty_command, ttyarg, !batch, RETURN_MASK_ALL);
 774
 775   /* Error messages should no longer be distinguished with extra output. */
 776   error_pre_print = NULL;
 777   quit_pre_print = NULL;
 778   warning_pre_print = _("warning: ");
 779
 780   /* Read the .gdbinit file in the current directory, *if* it isn't
 781      the same as the $HOME/.gdbinit file (it should exist, also).  */
 782
 783   if (!homedir
 784       || memcmp ((char *) &homebuf, (char *) &cwdbuf, sizeof (struct stat)))
 785     if (!inhibit_gdbinit)
 786       {
 787         catch_command_errors (source_script, gdbinit, 0, RETURN_MASK_ALL);
 788       }
 789
 790   for (i = 0; i < ncmd; i++)
 791     {
 792       if (cmdarg[i].type == CMDARG_FILE)
 793         catch_command_errors (source_script, cmdarg[i].string,
 794                               !batch, RETURN_MASK_ALL);
 795       else  /* cmdarg[i].type == CMDARG_COMMAND */
 796         catch_command_errors (execute_command, cmdarg[i].string,
 797                               !batch, RETURN_MASK_ALL);
 798     }
 799   xfree (cmdarg);
 800
 801   /* Read in the old history after all the command files have been read. */
 802   init_history ();
 803
 804   if (batch)
 805     {
 806       /* We have hit the end of the batch file.  */
 807       quit_force (NULL, 0);
 808     }
 809
 810   /* Show time and/or space usage.  */
 811
 812   if (display_time)
 813     {
 814       long init_time = get_run_time () - time_at_startup;
 815
 816       printf_unfiltered (_("Startup time: %ld.%06ld\n"),
 817                          init_time / 1000000, init_time % 1000000);
 818     }
 819
 820   if (display_space)
 821     {
 822 #ifdef HAVE_SBRK
 823       extern char **environ;
 824       char *lim = (char *) sbrk (0);
 825
 826       printf_unfiltered (_("Startup size: data size %ld\n"),
 827                          (long) (lim - (char *) &environ));
 828 #endif
 829     }
 830
 831   /* NOTE: cagney/1999-11-07: There is probably no reason for not
 832      moving this loop and the code found in captured_command_loop()
 833      into the command_loop() proper.  The main thing holding back that
 834      change - SET_TOP_LEVEL() - has been eliminated. */
 835   while (1)
 836     {
 837       catch_errors (captured_command_loop, 0, "", RETURN_MASK_ALL);
 838     }
 839   /* No exit -- exit is through quit_command.  */
 840 }
 841
 842 int
 843 gdb_main (struct captured_main_args *args)
 844 {
 845   use_windows = args->use_windows;
 846   catch_errors (captured_main, args, "", RETURN_MASK_ALL);
 847   /* The only way to end up here is by an error (normal exit is
 848      handled by quit_force()), hence always return an error status.  */
 849   return 1;
 850 }
 851
 852
 853 /* Don't use *_filtered for printing help.  We don't want to prompt
 854    for continue no matter how small the screen or how much we're going
 855    to print.  */
 856
 857 static void
 858 print_gdb_help (struct ui_file *stream)
 859 {
 860   fputs_unfiltered (_("\
 861 This is the GNU debugger.  Usage:\n\n\
 862     gdb [options] [executable-file [core-file or process-id]]\n\
 863     gdb [options] --args executable-file [inferior-arguments ...]\n\n\
 864 Options:\n\n\
 865 "), stream);
 866   fputs_unfiltered (_("\
 867   --args             Arguments after executable-file are passed to inferior\n\
 868 "), stream);
 869   fputs_unfiltered (_("\
 870   -b BAUDRATE        Set serial port baud rate used for remote debugging.\n\
 871   --batch            Exit after processing options.\n\
 872   --batch-silent     As for --batch, but suppress all gdb stdout output.\n\
 873   --return-child-result\n\
 874                      GDB exit code will be the child's exit code.\n\
 875   --cd=DIR           Change current directory to DIR.\n\
 876   --command=FILE, -x Execute GDB commands from FILE.\n\
 877   --eval-command=COMMAND, -ex\n\
 878                      Execute a single GDB command.\n\
 879                      May be used multiple times and in conjunction\n\
 880                      with --command.\n\
 881   --core=COREFILE    Analyze the core dump COREFILE.\n\
 882   --pid=PID          Attach to running process PID.\n\
 883 "), stream);
 884   fputs_unfiltered (_("\
 885   --dbx              DBX compatibility mode.\n\
 886   --directory=DIR    Search for source files in DIR.\n\
 887   --epoch            Output information used by epoch emacs-GDB interface.\n\
 888   --exec=EXECFILE    Use EXECFILE as the executable.\n\
 889   --fullname         Output information used by emacs-GDB interface.\n\
 890   --help             Print this message.\n\
 891 "), stream);
 892   fputs_unfiltered (_("\
 893   --interpreter=INTERP\n\
 894                      Select a specific interpreter / user interface\n\
 895 "), stream);
 896   fputs_unfiltered (_("\
 897   -l TIMEOUT         Set timeout in seconds for remote debugging.\n\
 898   --nw               Do not use a window interface.\n\
 899   --nx               Do not read "), stream);
 900   fputs_unfiltered (gdbinit, stream);
 901   fputs_unfiltered (_(" file.\n\
 902   --quiet            Do not print version number on startup.\n\
 903   --readnow          Fully read symbol files on first access.\n\
 904 "), stream);
 905   fputs_unfiltered (_("\
 906   --se=FILE          Use FILE as symbol file and executable file.\n\
 907   --symbols=SYMFILE  Read symbols from SYMFILE.\n\
 908   --tty=TTY          Use TTY for input/output by the program being debugged.\n\
 909 "), stream);
 910 #if defined(TUI)
 911   fputs_unfiltered (_("\
 912   --tui              Use a terminal user interface.\n\
 913 "), stream);
 914 #endif
 915   fputs_unfiltered (_("\
 916   --version          Print version information and then exit.\n\
 917   -w                 Use a window interface.\n\
 918   --write            Set writing into executable and core files.\n\
 919   --xdb              XDB compatibility mode.\n\
 920 "), stream);
 921   fputs_unfiltered (_("\n\
 922 For more information, type \"help\" from within GDB, or consult the\n\
 923 GDB manual (available as on-line info or a printed manual).\n\
 924 "), stream);
 925   if (REPORT_BUGS_TO[0] && stream == gdb_stdout)
 926     fprintf_unfiltered (stream, _("\
 927 Report bugs to \"%s\".\n\
 928 "), REPORT_BUGS_TO);
 929 }