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