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 #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   get_init_files (&system_gdbinit, &home_gdbinit, &local_gdbinit);
 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, 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 = 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 (set_args)
 637       {
 638         /* The remaining options are the command-line options for the
 639            inferior.  The first one is the sym/exec file, and the rest
 640            are arguments.  */
 641         if (optind >= argc)
 642           {
 643             fprintf_unfiltered (gdb_stderr,
 644                                 _("%s: `--args' specified but no program specified\n"),
 645                                 argv[0]);
 646             exit (1);
 647           }
 648         symarg = argv[optind];
 649         execarg = argv[optind];
 650         ++optind;
 651         set_inferior_args_vector (argc - optind, &argv[optind]);
 652       }
 653     else
 654       {
 655         /* OK, that's all the options.  */
 656
 657         /* The first argument, if specified, is the name of the
 658            executable.  */
 659         if (optind < argc)
 660           {
 661             symarg = argv[optind];
 662             execarg = argv[optind];
 663             optind++;
 664           }
 665
 666         /* If the user hasn't already specified a PID or the name of a
 667            core file, then a second optional argument is allowed.  If
 668            present, this argument should be interpreted as either a
 669            PID or a core file, whichever works.  */
 670         if (pidarg == NULL && corearg == NULL && optind < argc)
 671           {
 672             pid_or_core_arg = argv[optind];
 673             optind++;
 674           }
 675
 676         /* Any argument left on the command line is unexpected and
 677            will be ignored.  Inform the user.  */
 678         if (optind < argc)
 679           fprintf_unfiltered (gdb_stderr, _("\
 680 Excess command line arguments ignored. (%s%s)\n"),
 681                               argv[optind],
 682                               (optind == argc - 1) ? "" : " ...");
 683       }
 684     if (batch)
 685       quiet = 1;
 686   }
 687
 688   /* Initialize all files.  Give the interpreter a chance to take
 689      control of the console via the deprecated_init_ui_hook ().  */
 690   gdb_init (argv[0]);
 691
 692   /* Do these (and anything which might call wrap_here or *_filtered)
 693      after initialize_all_files() but before the interpreter has been
 694      installed.  Otherwize the help/version messages will be eaten by
 695      the interpreter's output handler.  */
 696
 697   if (print_version)
 698     {
 699       print_gdb_version (gdb_stdout);
 700       wrap_here ("");
 701       printf_filtered ("\n");
 702       exit (0);
 703     }
 704
 705   if (print_help)
 706     {
 707       print_gdb_help (gdb_stdout);
 708       fputs_unfiltered ("\n", gdb_stdout);
 709       exit (0);
 710     }
 711
 712   /* FIXME: cagney/2003-02-03: The big hack (part 1 of 2) that lets
 713      GDB retain the old MI1 interpreter startup behavior.  Output the
 714      copyright message before the interpreter is installed.  That way
 715      it isn't encapsulated in MI output.  */
 716   if (!quiet && strcmp (interpreter_p, INTERP_MI1) == 0)
 717     {
 718       /* Print all the junk at the top, with trailing "..." if we are about
 719          to read a symbol file (possibly slowly).  */
 720       print_gdb_version (gdb_stdout);
 721       if (symarg)
 722         printf_filtered ("..");
 723       wrap_here ("");
 724       printf_filtered ("\n");
 725       gdb_flush (gdb_stdout);   /* Force to screen during slow operations */
 726     }
 727
 728
 729   /* Install the default UI.  All the interpreters should have had a
 730      look at things by now.  Initialize the default interpreter. */
 731
 732   {
 733     /* Find it.  */
 734     struct interp *interp = interp_lookup (interpreter_p);
 735     if (interp == NULL)
 736       error (_("Interpreter `%s' unrecognized"), interpreter_p);
 737     /* Install it.  */
 738     if (!interp_set (interp, 1))
 739       {
 740         fprintf_unfiltered (gdb_stderr,
 741                             "Interpreter `%s' failed to initialize.\n",
 742                             interpreter_p);
 743         exit (1);
 744       }
 745   }
 746
 747   /* FIXME: cagney/2003-02-03: The big hack (part 2 of 2) that lets
 748      GDB retain the old MI1 interpreter startup behavior.  Output the
 749      copyright message after the interpreter is installed when it is
 750      any sane interpreter.  */
 751   if (!quiet && !current_interp_named_p (INTERP_MI1))
 752     {
 753       /* Print all the junk at the top, with trailing "..." if we are about
 754          to read a symbol file (possibly slowly).  */
 755       print_gdb_version (gdb_stdout);
 756       if (symarg)
 757         printf_filtered ("..");
 758       wrap_here ("");
 759       printf_filtered ("\n");
 760       gdb_flush (gdb_stdout);   /* Force to screen during slow operations */
 761     }
 762
 763   /* Set off error and warning messages with a blank line.  */
 764   error_pre_print = "\n";
 765   quit_pre_print = error_pre_print;
 766   warning_pre_print = _("\nwarning: ");
 767
 768   /* Read and execute the system-wide gdbinit file, if it exists.
 769      This is done *before* all the command line arguments are
 770      processed; it sets global parameters, which are independent of
 771      what file you are debugging or what directory you are in.  */
 772   if (system_gdbinit && !inhibit_gdbinit)
 773     catch_command_errors (source_script, system_gdbinit, 0, RETURN_MASK_ALL);
 774
 775   /* Read and execute $HOME/.gdbinit file, if it exists.  This is done
 776      *before* all the command line arguments are processed; it sets
 777      global parameters, which are independent of what file you are
 778      debugging or what directory you are in.  */
 779
 780   if (home_gdbinit && !inhibit_gdbinit)
 781     catch_command_errors (source_script, home_gdbinit, 0, RETURN_MASK_ALL);
 782
 783   /* Now perform all the actions indicated by the arguments.  */
 784   if (cdarg != NULL)
 785     {
 786       catch_command_errors (cd_command, cdarg, 0, RETURN_MASK_ALL);
 787     }
 788
 789   for (i = 0; i < ndir; i++)
 790     catch_command_errors (directory_switch, dirarg[i], 0, RETURN_MASK_ALL);
 791   xfree (dirarg);
 792
 793   if (execarg != NULL
 794       && symarg != NULL
 795       && strcmp (execarg, symarg) == 0)
 796     {
 797       /* The exec file and the symbol-file are the same.  If we can't
 798          open it, better only print one error message.
 799          catch_command_errors returns non-zero on success! */
 800       if (catch_command_errors (exec_file_attach, execarg, !batch, RETURN_MASK_ALL))
 801         catch_command_errors (symbol_file_add_main, symarg, 0, RETURN_MASK_ALL);
 802     }
 803   else
 804     {
 805       if (execarg != NULL)
 806         catch_command_errors (exec_file_attach, execarg, !batch, RETURN_MASK_ALL);
 807       if (symarg != NULL)
 808         catch_command_errors (symbol_file_add_main, symarg, 0, RETURN_MASK_ALL);
 809     }
 810
 811   if (corearg && pidarg)
 812     error (_("\
 813 Can't attach to process and specify a core file at the same time."));
 814
 815   if (corearg != NULL)
 816     catch_command_errors (core_file_command, corearg,
 817                           !batch, RETURN_MASK_ALL);
 818   else if (pidarg != NULL)
 819     catch_command_errors (attach_command, pidarg,
 820                           !batch, RETURN_MASK_ALL);
 821   else if (pid_or_core_arg)
 822     {
 823       /* The user specified 'gdb program pid' or gdb program core'.
 824          If pid_or_core_arg's first character is a digit, try attach
 825          first and then corefile.  Otherwise try just corefile.  */
 826
 827       if (isdigit (pid_or_core_arg[0]))
 828         {
 829           if (catch_command_errors (attach_command, pid_or_core_arg,
 830                                     !batch, RETURN_MASK_ALL) == 0)
 831             catch_command_errors (core_file_command, pid_or_core_arg,
 832                                   !batch, RETURN_MASK_ALL);
 833         }
 834       else /* Can't be a pid, better be a corefile.  */
 835         catch_command_errors (core_file_command, pid_or_core_arg,
 836                               !batch, RETURN_MASK_ALL);
 837     }
 838
 839   if (ttyarg != NULL)
 840     catch_command_errors (tty_command, ttyarg, !batch, RETURN_MASK_ALL);
 841
 842   /* Error messages should no longer be distinguished with extra output. */
 843   error_pre_print = NULL;
 844   quit_pre_print = NULL;
 845   warning_pre_print = _("warning: ");
 846
 847   /* Read the .gdbinit file in the current directory, *if* it isn't
 848      the same as the $HOME/.gdbinit file (it should exist, also).  */
 849   if (local_gdbinit && !inhibit_gdbinit)
 850     catch_command_errors (source_script, local_gdbinit, 0, RETURN_MASK_ALL);
 851
 852   for (i = 0; i < ncmd; i++)
 853     {
 854       if (cmdarg[i].type == CMDARG_FILE)
 855         catch_command_errors (source_script, cmdarg[i].string,
 856                               !batch, RETURN_MASK_ALL);
 857       else  /* cmdarg[i].type == CMDARG_COMMAND */
 858         catch_command_errors (execute_command, cmdarg[i].string,
 859                               !batch, RETURN_MASK_ALL);
 860     }
 861   xfree (cmdarg);
 862
 863   /* Read in the old history after all the command files have been read. */
 864   init_history ();
 865
 866   if (batch)
 867     {
 868       /* We have hit the end of the batch file.  */
 869       quit_force (NULL, 0);
 870     }
 871
 872   /* Show time and/or space usage.  */
 873
 874   if (display_time)
 875     {
 876       long init_time = get_run_time () - time_at_startup;
 877
 878       printf_unfiltered (_("Startup time: %ld.%06ld\n"),
 879                          init_time / 1000000, init_time % 1000000);
 880     }
 881
 882   if (display_space)
 883     {
 884 #ifdef HAVE_SBRK
 885       extern char **environ;
 886       char *lim = (char *) sbrk (0);
 887
 888       printf_unfiltered (_("Startup size: data size %ld\n"),
 889                          (long) (lim - (char *) &environ));
 890 #endif
 891     }
 892
 893   /* NOTE: cagney/1999-11-07: There is probably no reason for not
 894      moving this loop and the code found in captured_command_loop()
 895      into the command_loop() proper.  The main thing holding back that
 896      change - SET_TOP_LEVEL() - has been eliminated. */
 897   while (1)
 898     {
 899       catch_errors (captured_command_loop, 0, "", RETURN_MASK_ALL);
 900     }
 901   /* No exit -- exit is through quit_command.  */
 902 }
 903
 904 int
 905 gdb_main (struct captured_main_args *args)
 906 {
 907   use_windows = args->use_windows;
 908   catch_errors (captured_main, args, "", RETURN_MASK_ALL);
 909   /* The only way to end up here is by an error (normal exit is
 910      handled by quit_force()), hence always return an error status.  */
 911   return 1;
 912 }
 913
 914
 915 /* Don't use *_filtered for printing help.  We don't want to prompt
 916    for continue no matter how small the screen or how much we're going
 917    to print.  */
 918
 919 static void
 920 print_gdb_help (struct ui_file *stream)
 921 {
 922   char *system_gdbinit;
 923   char *home_gdbinit;
 924   char *local_gdbinit;
 925
 926   get_init_files (&system_gdbinit, &home_gdbinit, &local_gdbinit);
 927
 928   fputs_unfiltered (_("\
 929 This is the GNU debugger.  Usage:\n\n\
 930     gdb [options] [executable-file [core-file or process-id]]\n\
 931     gdb [options] --args executable-file [inferior-arguments ...]\n\n\
 932 Options:\n\n\
 933 "), stream);
 934   fputs_unfiltered (_("\
 935   --args             Arguments after executable-file are passed to inferior\n\
 936 "), stream);
 937   fputs_unfiltered (_("\
 938   -b BAUDRATE        Set serial port baud rate used for remote debugging.\n\
 939   --batch            Exit after processing options.\n\
 940   --batch-silent     As for --batch, but suppress all gdb stdout output.\n\
 941   --return-child-result\n\
 942                      GDB exit code will be the child's exit code.\n\
 943   --cd=DIR           Change current directory to DIR.\n\
 944   --command=FILE, -x Execute GDB commands from FILE.\n\
 945   --eval-command=COMMAND, -ex\n\
 946                      Execute a single GDB command.\n\
 947                      May be used multiple times and in conjunction\n\
 948                      with --command.\n\
 949   --core=COREFILE    Analyze the core dump COREFILE.\n\
 950   --pid=PID          Attach to running process PID.\n\
 951 "), stream);
 952   fputs_unfiltered (_("\
 953   --dbx              DBX compatibility mode.\n\
 954   --directory=DIR    Search for source files in DIR.\n\
 955   --epoch            Output information used by epoch emacs-GDB interface.\n\
 956   --exec=EXECFILE    Use EXECFILE as the executable.\n\
 957   --fullname         Output information used by emacs-GDB interface.\n\
 958   --help             Print this message.\n\
 959 "), stream);
 960   fputs_unfiltered (_("\
 961   --interpreter=INTERP\n\
 962                      Select a specific interpreter / user interface\n\
 963 "), stream);
 964   fputs_unfiltered (_("\
 965   -l TIMEOUT         Set timeout in seconds for remote debugging.\n\
 966   --nw               Do not use a window interface.\n\
 967   --nx               Do not read "), stream);
 968   fputs_unfiltered (gdbinit, stream);
 969   fputs_unfiltered (_(" file.\n\
 970   --quiet            Do not print version number on startup.\n\
 971   --readnow          Fully read symbol files on first access.\n\
 972 "), stream);
 973   fputs_unfiltered (_("\
 974   --se=FILE          Use FILE as symbol file and executable file.\n\
 975   --symbols=SYMFILE  Read symbols from SYMFILE.\n\
 976   --tty=TTY          Use TTY for input/output by the program being debugged.\n\
 977 "), stream);
 978 #if defined(TUI)
 979   fputs_unfiltered (_("\
 980   --tui              Use a terminal user interface.\n\
 981 "), stream);
 982 #endif
 983   fputs_unfiltered (_("\
 984   --version          Print version information and then exit.\n\
 985   -w                 Use a window interface.\n\
 986   --write            Set writing into executable and core files.\n\
 987   --xdb              XDB compatibility mode.\n\
 988 "), stream);
 989   fputs_unfiltered (_("\n\
 990 At startup, GDB reads the following init files and executes their commands:\n\
 991 "), stream);
 992   if (system_gdbinit)
 993     fprintf_unfiltered (stream, _("\
 994    * system-wide init file: %s\n\
 995 "), system_gdbinit);
 996   if (home_gdbinit)
 997     fprintf_unfiltered (stream, _("\
 998    * user-specific init file: %s\n\
 999 "), home_gdbinit);
1000   if (local_gdbinit)
1001     fprintf_unfiltered (stream, _("\
1002    * local init file: ./%s\n\
1003 "), local_gdbinit);
1004   fputs_unfiltered (_("\n\
1005 For more information, type \"help\" from within GDB, or consult the\n\
1006 GDB manual (available as on-line info or a printed manual).\n\
1007 "), stream);
1008   if (REPORT_BUGS_TO[0] && stream == gdb_stdout)
1009     fprintf_unfiltered (stream, _("\
1010 Report bugs to \"%s\".\n\
1011 "), REPORT_BUGS_TO);
1012 }