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