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
 519                window interface.  */
 520             use_windows = 0;
 521             break;
 522           case 's':
 523             symarg = optarg;
 524             break;
 525           case 'e':
 526             execarg = optarg;
 527             break;
 528           case 'c':
 529             corearg = optarg;
 530             break;
 531           case 'p':
 532             pidarg = optarg;
 533             break;
 534           case 'x':
 535             cmdarg[ncmd].type = CMDARG_FILE;
 536             cmdarg[ncmd++].string = optarg;
 537             if (ncmd >= cmdsize)
 538               {
 539                 cmdsize *= 2;
 540                 cmdarg = xrealloc ((char *) cmdarg,
 541                                    cmdsize * sizeof (*cmdarg));
 542               }
 543             break;
 544           case 'X':
 545             cmdarg[ncmd].type = CMDARG_COMMAND;
 546             cmdarg[ncmd++].string = optarg;
 547             if (ncmd >= cmdsize)
 548               {
 549                 cmdsize *= 2;
 550                 cmdarg = xrealloc ((char *) cmdarg,
 551                                    cmdsize * sizeof (*cmdarg));
 552               }
 553             break;
 554           case 'B':
 555             batch_flag = batch_silent = 1;
 556             gdb_stdout = ui_file_new();
 557             break;
 558           case 'D':
 559             xfree (gdb_datadir);
 560             gdb_datadir = xstrdup (optarg);
 561             break;
 562 #ifdef GDBTK
 563           case 'z':
 564             {
 565               extern int gdbtk_test (char *);
 566
 567               if (!gdbtk_test (optarg))
 568                 {
 569                   fprintf_unfiltered (gdb_stderr,
 570                                       _("%s: unable to load "
 571                                         "tclcommand file \"%s\""),
 572                                       argv[0], optarg);
 573                   exit (1);
 574                 }
 575               break;
 576             }
 577           case 'y':
 578             /* Backwards compatibility only.  */
 579             break;
 580           case 'w':
 581             {
 582               external_editor_command = xstrdup (optarg);
 583               break;
 584             }
 585 #endif /* GDBTK */
 586           case 'i':
 587             xfree (interpreter_p);
 588             interpreter_p = xstrdup (optarg);
 589             break;
 590           case 'd':
 591             dirarg[ndir++] = optarg;
 592             if (ndir >= dirsize)
 593               {
 594                 dirsize *= 2;
 595                 dirarg = (char **) xrealloc ((char *) dirarg,
 596                                              dirsize * sizeof (*dirarg));
 597               }
 598             break;
 599           case 't':
 600             ttyarg = optarg;
 601             break;
 602           case 'q':
 603             quiet = 1;
 604             break;
 605           case 'b':
 606             {
 607               int i;
 608               char *p;
 609
 610               i = strtol (optarg, &p, 0);
 611               if (i == 0 && p == optarg)
 612
 613                 /* Don't use *_filtered or warning() (which relies on
 614                    current_target) until after initialize_all_files().  */
 615
 616                 fprintf_unfiltered
 617                   (gdb_stderr,
 618                    _("warning: could not set baud rate to `%s'.\n"), optarg);
 619               else
 620                 baud_rate = i;
 621             }
 622             break;
 623           case 'l':
 624             {
 625               int i;
 626               char *p;
 627
 628               i = strtol (optarg, &p, 0);
 629               if (i == 0 && p == optarg)
 630
 631                 /* Don't use *_filtered or warning() (which relies on
 632                    current_target) until after initialize_all_files().  */
 633
 634                 fprintf_unfiltered (gdb_stderr,
 635                                     _("warning: could not set "
 636                                       "timeout limit to `%s'.\n"), optarg);
 637               else
 638                 remote_timeout = i;
 639             }
 640             break;
 641
 642           case '?':
 643             fprintf_unfiltered (gdb_stderr,
 644                                 _("Use `%s --help' for a "
 645                                   "complete list of options.\n"),
 646                                 argv[0]);
 647             exit (1);
 648           }
 649       }
 650
 651     /* If --help or --version, disable window interface.  */
 652     if (print_help || print_version)
 653       {
 654         use_windows = 0;
 655       }
 656
 657     if (batch_flag)
 658       quiet = 1;
 659   }
 660
 661   /* Initialize all files.  Give the interpreter a chance to take
 662      control of the console via the deprecated_init_ui_hook ().  */
 663   gdb_init (argv[0]);
 664
 665   /* Now that gdb_init has created the initial inferior, we're in
 666      position to set args for that inferior.  */
 667   if (set_args)
 668     {
 669       /* The remaining options are the command-line options for the
 670          inferior.  The first one is the sym/exec file, and the rest
 671          are arguments.  */
 672       if (optind >= argc)
 673         {
 674           fprintf_unfiltered (gdb_stderr,
 675                               _("%s: `--args' specified but "
 676                                 "no program specified\n"),
 677                               argv[0]);
 678           exit (1);
 679         }
 680       symarg = argv[optind];
 681       execarg = argv[optind];
 682       ++optind;
 683       set_inferior_args_vector (argc - optind, &argv[optind]);
 684     }
 685   else
 686     {
 687       /* OK, that's all the options.  */
 688
 689       /* The first argument, if specified, is the name of the
 690          executable.  */
 691       if (optind < argc)
 692         {
 693           symarg = argv[optind];
 694           execarg = argv[optind];
 695           optind++;
 696         }
 697
 698       /* If the user hasn't already specified a PID or the name of a
 699          core file, then a second optional argument is allowed.  If
 700          present, this argument should be interpreted as either a
 701          PID or a core file, whichever works.  */
 702       if (pidarg == NULL && corearg == NULL && optind < argc)
 703         {
 704           pid_or_core_arg = argv[optind];
 705           optind++;
 706         }
 707
 708       /* Any argument left on the command line is unexpected and
 709          will be ignored.  Inform the user.  */
 710       if (optind < argc)
 711         fprintf_unfiltered (gdb_stderr,
 712                             _("Excess command line "
 713                               "arguments ignored. (%s%s)\n"),
 714                             argv[optind],
 715                             (optind == argc - 1) ? "" : " ...");
 716     }
 717
 718   /* Lookup gdbinit files.  Note that the gdbinit file name may be
 719      overriden during file initialization, so get_init_files should be
 720      called after gdb_init.  */
 721   get_init_files (&system_gdbinit, &home_gdbinit, &local_gdbinit);
 722
 723   /* Do these (and anything which might call wrap_here or *_filtered)
 724      after initialize_all_files() but before the interpreter has been
 725      installed.  Otherwize the help/version messages will be eaten by
 726      the interpreter's output handler.  */
 727
 728   if (print_version)
 729     {
 730       print_gdb_version (gdb_stdout);
 731       wrap_here ("");
 732       printf_filtered ("\n");
 733       exit (0);
 734     }
 735
 736   if (print_help)
 737     {
 738       print_gdb_help (gdb_stdout);
 739       fputs_unfiltered ("\n", gdb_stdout);
 740       exit (0);
 741     }
 742
 743   /* FIXME: cagney/2003-02-03: The big hack (part 1 of 2) that lets
 744      GDB retain the old MI1 interpreter startup behavior.  Output the
 745      copyright message before the interpreter is installed.  That way
 746      it isn't encapsulated in MI output.  */
 747   if (!quiet && strcmp (interpreter_p, INTERP_MI1) == 0)
 748     {
 749       /* Print all the junk at the top, with trailing "..." if we are
 750          about to read a symbol file (possibly slowly).  */
 751       print_gdb_version (gdb_stdout);
 752       if (symarg)
 753         printf_filtered ("..");
 754       wrap_here ("");
 755       printf_filtered ("\n");
 756       gdb_flush (gdb_stdout);   /* Force to screen during slow
 757                                    operations.  */
 758     }
 759
 760   /* Install the default UI.  All the interpreters should have had a
 761      look at things by now.  Initialize the default interpreter.  */
 762
 763   {
 764     /* Find it.  */
 765     struct interp *interp = interp_lookup (interpreter_p);
 766
 767     if (interp == NULL)
 768       error (_("Interpreter `%s' unrecognized"), interpreter_p);
 769     /* Install it.  */
 770     if (!interp_set (interp, 1))
 771       {
 772         fprintf_unfiltered (gdb_stderr,
 773                             "Interpreter `%s' failed to initialize.\n",
 774                             interpreter_p);
 775         exit (1);
 776       }
 777   }
 778
 779   /* FIXME: cagney/2003-02-03: The big hack (part 2 of 2) that lets
 780      GDB retain the old MI1 interpreter startup behavior.  Output the
 781      copyright message after the interpreter is installed when it is
 782      any sane interpreter.  */
 783   if (!quiet && !current_interp_named_p (INTERP_MI1))
 784     {
 785       /* Print all the junk at the top, with trailing "..." if we are
 786          about to read a symbol file (possibly slowly).  */
 787       print_gdb_version (gdb_stdout);
 788       if (symarg)
 789         printf_filtered ("..");
 790       wrap_here ("");
 791       printf_filtered ("\n");
 792       gdb_flush (gdb_stdout);   /* Force to screen during slow
 793                                    operations.  */
 794     }
 795
 796   /* Set off error and warning messages with a blank line.  */
 797   error_pre_print = "\n";
 798   quit_pre_print = error_pre_print;
 799   warning_pre_print = _("\nwarning: ");
 800
 801   /* Read and execute the system-wide gdbinit file, if it exists.
 802      This is done *before* all the command line arguments are
 803      processed; it sets global parameters, which are independent of
 804      what file you are debugging or what directory you are in.  */
 805   if (system_gdbinit && !inhibit_gdbinit)
 806     catch_command_errors (source_script, system_gdbinit, 0, RETURN_MASK_ALL);
 807
 808   /* Read and execute $HOME/.gdbinit file, if it exists.  This is done
 809      *before* all the command line arguments are processed; it sets
 810      global parameters, which are independent of what file you are
 811      debugging or what directory you are in.  */
 812
 813   if (home_gdbinit && !inhibit_gdbinit)
 814     catch_command_errors (source_script, home_gdbinit, 0, RETURN_MASK_ALL);
 815
 816   /* Now perform all the actions indicated by the arguments.  */
 817   if (cdarg != NULL)
 818     {
 819       catch_command_errors (cd_command, cdarg, 0, RETURN_MASK_ALL);
 820     }
 821
 822   for (i = 0; i < ndir; i++)
 823     catch_command_errors (directory_switch, dirarg[i], 0, RETURN_MASK_ALL);
 824   xfree (dirarg);
 825
 826   /* Skip auto-loading section-specified scripts until we've sourced
 827      local_gdbinit (which is often used to augment the source search
 828      path).  */
 829   save_auto_load = gdbpy_global_auto_load;
 830   gdbpy_global_auto_load = 0;
 831
 832   if (execarg != NULL
 833       && symarg != NULL
 834       && strcmp (execarg, symarg) == 0)
 835     {
 836       /* The exec file and the symbol-file are the same.  If we can't
 837          open it, better only print one error message.
 838          catch_command_errors returns non-zero on success!  */
 839       if (catch_command_errors (exec_file_attach, execarg,
 840                                 !batch_flag, RETURN_MASK_ALL))
 841         catch_command_errors (symbol_file_add_main, symarg,
 842                               !batch_flag, RETURN_MASK_ALL);
 843     }
 844   else
 845     {
 846       if (execarg != NULL)
 847         catch_command_errors (exec_file_attach, execarg,
 848                               !batch_flag, RETURN_MASK_ALL);
 849       if (symarg != NULL)
 850         catch_command_errors (symbol_file_add_main, symarg,
 851                               !batch_flag, RETURN_MASK_ALL);
 852     }
 853
 854   if (corearg && pidarg)
 855     error (_("Can't attach to process and specify "
 856              "a core file at the same time."));
 857
 858   if (corearg != NULL)
 859     catch_command_errors (core_file_command, corearg,
 860                           !batch_flag, RETURN_MASK_ALL);
 861   else if (pidarg != NULL)
 862     catch_command_errors (attach_command, pidarg,
 863                           !batch_flag, RETURN_MASK_ALL);
 864   else if (pid_or_core_arg)
 865     {
 866       /* The user specified 'gdb program pid' or gdb program core'.
 867          If pid_or_core_arg's first character is a digit, try attach
 868          first and then corefile.  Otherwise try just corefile.  */
 869
 870       if (isdigit (pid_or_core_arg[0]))
 871         {
 872           if (catch_command_errors (attach_command, pid_or_core_arg,
 873                                     !batch_flag, RETURN_MASK_ALL) == 0)
 874             catch_command_errors (core_file_command, pid_or_core_arg,
 875                                   !batch_flag, RETURN_MASK_ALL);
 876         }
 877       else /* Can't be a pid, better be a corefile.  */
 878         catch_command_errors (core_file_command, pid_or_core_arg,
 879                               !batch_flag, RETURN_MASK_ALL);
 880     }
 881
 882   if (ttyarg != NULL)
 883     set_inferior_io_terminal (ttyarg);
 884
 885   /* Error messages should no longer be distinguished with extra output.  */
 886   error_pre_print = NULL;
 887   quit_pre_print = NULL;
 888   warning_pre_print = _("warning: ");
 889
 890   /* Read the .gdbinit file in the current directory, *if* it isn't
 891      the same as the $HOME/.gdbinit file (it should exist, also).  */
 892   if (local_gdbinit && !inhibit_gdbinit)
 893     catch_command_errors (source_script, local_gdbinit, 0, RETURN_MASK_ALL);
 894
 895   /* Now that all .gdbinit's have been read and all -d options have been
 896      processed, we can read any scripts mentioned in SYMARG.
 897      We wait until now because it is common to add to the source search
 898      path in local_gdbinit.  */
 899   gdbpy_global_auto_load = save_auto_load;
 900   ALL_OBJFILES (objfile)
 901     load_auto_scripts_for_objfile (objfile);
 902
 903   for (i = 0; i < ncmd; i++)
 904     {
 905       if (cmdarg[i].type == CMDARG_FILE)
 906         catch_command_errors (source_script, cmdarg[i].string,
 907                               !batch_flag, RETURN_MASK_ALL);
 908       else  /* cmdarg[i].type == CMDARG_COMMAND */
 909         catch_command_errors (execute_command, cmdarg[i].string,
 910                               !batch_flag, RETURN_MASK_ALL);
 911     }
 912   xfree (cmdarg);
 913
 914   /* Read in the old history after all the command files have been
 915      read.  */
 916   init_history ();
 917
 918   if (batch_flag)
 919     {
 920       /* We have hit the end of the batch file.  */
 921       quit_force (NULL, 0);
 922     }
 923
 924   /* Show time and/or space usage.  */
 925   do_cleanups (pre_stat_chain);
 926
 927   /* NOTE: cagney/1999-11-07: There is probably no reason for not
 928      moving this loop and the code found in captured_command_loop()
 929      into the command_loop() proper.  The main thing holding back that
 930      change - SET_TOP_LEVEL() - has been eliminated.  */
 931   while (1)
 932     {
 933       catch_errors (captured_command_loop, 0, "", RETURN_MASK_ALL);
 934     }
 935   /* No exit -- exit is through quit_command.  */
 936 }
 937
 938 int
 939 gdb_main (struct captured_main_args *args)
 940 {
 941   use_windows = args->use_windows;
 942   catch_errors (captured_main, args, "", RETURN_MASK_ALL);
 943   /* The only way to end up here is by an error (normal exit is
 944      handled by quit_force()), hence always return an error status.  */
 945   return 1;
 946 }
 947
 948
 949 /* Don't use *_filtered for printing help.  We don't want to prompt
 950    for continue no matter how small the screen or how much we're going
 951    to print.  */
 952
 953 static void
 954 print_gdb_help (struct ui_file *stream)
 955 {
 956   char *system_gdbinit;
 957   char *home_gdbinit;
 958   char *local_gdbinit;
 959
 960   get_init_files (&system_gdbinit, &home_gdbinit, &local_gdbinit);
 961
 962   fputs_unfiltered (_("\
 963 This is the GNU debugger.  Usage:\n\n\
 964     gdb [options] [executable-file [core-file or process-id]]\n\
 965     gdb [options] --args executable-file [inferior-arguments ...]\n\n\
 966 Options:\n\n\
 967 "), stream);
 968   fputs_unfiltered (_("\
 969   --args             Arguments after executable-file are passed to inferior\n\
 970 "), stream);
 971   fputs_unfiltered (_("\
 972   -b BAUDRATE        Set serial port baud rate used for remote debugging.\n\
 973   --batch            Exit after processing options.\n\
 974   --batch-silent     As for --batch, but suppress all gdb stdout output.\n\
 975   --return-child-result\n\
 976                      GDB exit code will be the child's exit code.\n\
 977   --cd=DIR           Change current directory to DIR.\n\
 978   --command=FILE, -x Execute GDB commands from FILE.\n\
 979   --eval-command=COMMAND, -ex\n\
 980                      Execute a single GDB command.\n\
 981                      May be used multiple times and in conjunction\n\
 982                      with --command.\n\
 983   --core=COREFILE    Analyze the core dump COREFILE.\n\
 984   --pid=PID          Attach to running process PID.\n\
 985 "), stream);
 986   fputs_unfiltered (_("\
 987   --dbx              DBX compatibility mode.\n\
 988   --directory=DIR    Search for source files in DIR.\n\
 989   --epoch            Output information used by epoch emacs-GDB interface.\n\
 990   --exec=EXECFILE    Use EXECFILE as the executable.\n\
 991   --fullname         Output information used by emacs-GDB interface.\n\
 992   --help             Print this message.\n\
 993 "), stream);
 994   fputs_unfiltered (_("\
 995   --interpreter=INTERP\n\
 996                      Select a specific interpreter / user interface\n\
 997 "), stream);
 998   fputs_unfiltered (_("\
 999   -l TIMEOUT         Set timeout in seconds for remote debugging.\n\
1000   --nw               Do not use a window interface.\n\
1001   --nx               Do not read "), stream);
1002   fputs_unfiltered (gdbinit, stream);
1003   fputs_unfiltered (_(" file.\n\
1004   --quiet            Do not print version number on startup.\n\
1005   --readnow          Fully read symbol files on first access.\n\
1006 "), stream);
1007   fputs_unfiltered (_("\
1008   --se=FILE          Use FILE as symbol file and executable file.\n\
1009   --symbols=SYMFILE  Read symbols from SYMFILE.\n\
1010   --tty=TTY          Use TTY for input/output by the program being debugged.\n\
1011 "), stream);
1012 #if defined(TUI)
1013   fputs_unfiltered (_("\
1014   --tui              Use a terminal user interface.\n\
1015 "), stream);
1016 #endif
1017   fputs_unfiltered (_("\
1018   --version          Print version information and then exit.\n\
1019   -w                 Use a window interface.\n\
1020   --write            Set writing into executable and core files.\n\
1021   --xdb              XDB compatibility mode.\n\
1022 "), stream);
1023   fputs_unfiltered (_("\n\
1024 At startup, GDB reads the following init files and executes their commands:\n\
1025 "), stream);
1026   if (system_gdbinit)
1027     fprintf_unfiltered (stream, _("\
1028    * system-wide init file: %s\n\
1029 "), system_gdbinit);
1030   if (home_gdbinit)
1031     fprintf_unfiltered (stream, _("\
1032    * user-specific init file: %s\n\
1033 "), home_gdbinit);
1034   if (local_gdbinit)
1035     fprintf_unfiltered (stream, _("\
1036    * local init file: ./%s\n\
1037 "), local_gdbinit);
1038   fputs_unfiltered (_("\n\
1039 For more information, type \"help\" from within GDB, or consult the\n\
1040 GDB manual (available as on-line info or a printed manual).\n\
1041 "), stream);
1042   if (REPORT_BUGS_TO[0] && stream == gdb_stdout)
1043     fprintf_unfiltered (stream, _("\
1044 Report bugs to \"%s\".\n\
1045 "), REPORT_BUGS_TO);
1046 }