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