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