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