gdb/main.c

   1 /* Top level stuff for GDB, the GNU debugger.
   2
   3    Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
   4    1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
   5    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 2 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, write to the Free Software
  21    Foundation, Inc., 59 Temple Place - Suite 330,
  22    Boston, MA 02111-1307, USA.  */
  23
  24 #include "defs.h"
  25 #include "top.h"
  26 #include "target.h"
  27 #include "inferior.h"
  28 #include "symfile.h"
  29 #include "gdbcore.h"
  30
  31 #include "exceptions.h"
  32 #include "getopt.h"
  33
  34 #include <sys/types.h>
  35 #include "gdb_stat.h"
  36 #include <ctype.h>
  37
  38 #include "gdb_string.h"
  39 #include "event-loop.h"
  40 #include "ui-out.h"
  41
  42 #include "interps.h"
  43 #include "main.h"
  44
  45 /* If nonzero, display time usage both at startup and for each command.  */
  46
  47 int display_time;
  48
  49 /* If nonzero, display space usage both at startup and for each command.  */
  50
  51 int display_space;
  52
  53 /* The selected interpreter.  This will be used as a set command
  54    variable, so it should always be malloc'ed - since
  55    do_setshow_command will free it. */
  56 char *interpreter_p;
  57
  58 /* Whether xdb commands will be handled */
  59 int xdb_commands = 0;
  60
  61 /* Whether dbx commands will be handled */
  62 int dbx_commands = 0;
  63
  64 /* System root path, used to find libraries etc.  */
  65 char *gdb_sysroot = 0;
  66
  67 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 /* Support for the --batch-silent option.  */
  77 int batch_silent = 0;
  78
  79 /* Support for --return-child-result option.
  80    Set the default to -1 to return error in the case
  81    that the program does not run or does not complete.  */
  82 int return_child_result = 0;
  83 int return_child_result_value = -1;
  84
  85 /* Whether to enable writing into executable and core files */
  86 extern int write_files;
  87
  88 static void print_gdb_help (struct ui_file *);
  89
  90 /* These two are used to set the external editor commands when gdb is farming
  91    out files to be edited by another program. */
  92
  93 extern char *external_editor_command;
  94
  95 /* Call command_loop.  If it happens to return, pass that through as a
  96    non-zero return status. */
  97
  98 static int
  99 captured_command_loop (void *data)
 100 {
 101   current_interp_command_loop ();
 102   /* FIXME: cagney/1999-11-05: A correct command_loop() implementaton
 103      would clean things up (restoring the cleanup chain) to the state
 104      they were just prior to the call.  Technically, this means that
 105      the do_cleanups() below is redundant.  Unfortunately, many FUNCs
 106      are not that well behaved.  do_cleanups should either be replaced
 107      with a do_cleanups call (to cover the problem) or an assertion
 108      check to detect bad FUNCs code. */
 109   do_cleanups (ALL_CLEANUPS);
 110   /* If the command_loop returned, normally (rather than threw an
 111      error) we try to quit. If the quit is aborted, catch_errors()
 112      which called this catch the signal and restart the command
 113      loop. */
 114   quit_command (NULL, instream == stdin);
 115   return 1;
 116 }
 117
 118 static int
 119 captured_main (void *data)
 120 {
 121   struct captured_main_args *context = data;
 122   int argc = context->argc;
 123   char **argv = context->argv;
 124   int count;
 125   static int quiet = 0;
 126   static int batch = 0;
 127   static int set_args = 0;
 128
 129   /* Pointers to various arguments from command line.  */
 130   char *symarg = NULL;
 131   char *execarg = NULL;
 132   char *corearg = NULL;
 133   char *cdarg = NULL;
 134   char *ttyarg = NULL;
 135
 136   /* These are static so that we can take their address in an initializer.  */
 137   static int print_help;
 138   static int print_version;
 139
 140   /* Pointers to all arguments of --command option.  */
 141   char **cmdarg;
 142   /* Allocated size of cmdarg.  */
 143   int cmdsize;
 144   /* Number of elements of cmdarg used.  */
 145   int ncmd;
 146
 147   /* Indices of all arguments of --directory option.  */
 148   char **dirarg;
 149   /* Allocated size.  */
 150   int dirsize;
 151   /* Number of elements used.  */
 152   int ndir;
 153
 154   struct stat homebuf, cwdbuf;
 155   char *homedir;
 156
 157   int i;
 158
 159   long time_at_startup = get_run_time ();
 160
 161 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
 162   setlocale (LC_MESSAGES, "");
 163 #endif
 164 #if defined (HAVE_SETLOCALE)
 165   setlocale (LC_CTYPE, "");
 166 #endif
 167   bindtextdomain (PACKAGE, LOCALEDIR);
 168   textdomain (PACKAGE);
 169
 170 #ifdef HAVE_SBRK
 171   lim_at_start = (char *) sbrk (0);
 172 #endif
 173
 174 #if defined (ALIGN_STACK_ON_STARTUP)
 175   i = (int) &count & 0x3;
 176   if (i != 0)
 177     alloca (4 - i);
 178 #endif
 179
 180   cmdsize = 1;
 181   cmdarg = (char **) xmalloc (cmdsize * sizeof (*cmdarg));
 182   ncmd = 0;
 183   dirsize = 1;
 184   dirarg = (char **) xmalloc (dirsize * sizeof (*dirarg));
 185   ndir = 0;
 186
 187   quit_flag = 0;
 188   line = (char *) xmalloc (linesize);
 189   line[0] = '\0';               /* Terminate saved (now empty) cmd line */
 190   instream = stdin;
 191
 192   getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));
 193   current_directory = gdb_dirbuf;
 194
 195   gdb_stdout = stdio_fileopen (stdout);
 196   gdb_stderr = stdio_fileopen (stderr);
 197   gdb_stdlog = gdb_stderr;      /* for moment */
 198   gdb_stdtarg = gdb_stderr;     /* for moment */
 199   gdb_stdin = stdio_fileopen (stdin);
 200   gdb_stdtargerr = gdb_stderr;  /* for moment */
 201   gdb_stdtargin = gdb_stdin;    /* for moment */
 202
 203   /* Set the sysroot path.  */
 204 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
 205   gdb_sysroot = make_relative_prefix (argv[0], BINDIR, TARGET_SYSTEM_ROOT);
 206   if (gdb_sysroot)
 207     {
 208       struct stat s;
 209       int res = 0;
 210
 211       if (stat (gdb_sysroot, &s) == 0)
 212         if (S_ISDIR (s.st_mode))
 213           res = 1;
 214
 215       if (res == 0)
 216         {
 217           xfree (gdb_sysroot);
 218           gdb_sysroot = TARGET_SYSTEM_ROOT;
 219         }
 220     }
 221   else
 222     gdb_sysroot = TARGET_SYSTEM_ROOT;
 223 #else
 224 #if defined (TARGET_SYSTEM_ROOT)
 225   gdb_sysroot = TARGET_SYSTEM_ROOT;
 226 #else
 227   gdb_sysroot = "";
 228 #endif
 229 #endif
 230
 231   /* There will always be an interpreter.  Either the one passed into
 232      this captured main, or one specified by the user at start up, or
 233      the console.  Initialize the interpreter to the one requested by
 234      the application.  */
 235   interpreter_p = xstrdup (context->interpreter_p);
 236
 237   /* Parse arguments and options.  */
 238   {
 239     int c;
 240     /* When var field is 0, use flag field to record the equivalent
 241        short option (or arbitrary numbers starting at 10 for those
 242        with no equivalent).  */
 243     enum {
 244       OPT_SE = 10,
 245       OPT_CD,
 246       OPT_ANNOTATE,
 247       OPT_STATISTICS,
 248       OPT_TUI,
 249       OPT_NOWINDOWS,
 250       OPT_WINDOWS
 251     };
 252     static struct option long_options[] =
 253     {
 254 #if defined(TUI)
 255       {"tui", no_argument, 0, OPT_TUI},
 256 #endif
 257       {"xdb", no_argument, &xdb_commands, 1},
 258       {"dbx", no_argument, &dbx_commands, 1},
 259       {"readnow", no_argument, &readnow_symbol_files, 1},
 260       {"r", no_argument, &readnow_symbol_files, 1},
 261       {"quiet", no_argument, &quiet, 1},
 262       {"q", no_argument, &quiet, 1},
 263       {"silent", no_argument, &quiet, 1},
 264       {"nx", no_argument, &inhibit_gdbinit, 1},
 265       {"n", no_argument, &inhibit_gdbinit, 1},
 266       {"batch-silent", no_argument, 0, 'B'},
 267       {"batch", no_argument, &batch, 1},
 268       {"epoch", no_argument, &epoch_interface, 1},
 269
 270     /* This is a synonym for "--annotate=1".  --annotate is now preferred,
 271        but keep this here for a long time because people will be running
 272        emacses which use --fullname.  */
 273       {"fullname", no_argument, 0, 'f'},
 274       {"f", no_argument, 0, 'f'},
 275
 276       {"annotate", required_argument, 0, OPT_ANNOTATE},
 277       {"help", no_argument, &print_help, 1},
 278       {"se", required_argument, 0, OPT_SE},
 279       {"symbols", required_argument, 0, 's'},
 280       {"s", required_argument, 0, 's'},
 281       {"exec", required_argument, 0, 'e'},
 282       {"e", required_argument, 0, 'e'},
 283       {"core", required_argument, 0, 'c'},
 284       {"c", required_argument, 0, 'c'},
 285       {"pid", required_argument, 0, 'p'},
 286       {"p", required_argument, 0, 'p'},
 287       {"command", required_argument, 0, 'x'},
 288       {"version", no_argument, &print_version, 1},
 289       {"x", required_argument, 0, 'x'},
 290 #ifdef GDBTK
 291       {"tclcommand", required_argument, 0, 'z'},
 292       {"enable-external-editor", no_argument, 0, 'y'},
 293       {"editor-command", required_argument, 0, 'w'},
 294 #endif
 295       {"ui", required_argument, 0, 'i'},
 296       {"interpreter", required_argument, 0, 'i'},
 297       {"i", required_argument, 0, 'i'},
 298       {"directory", required_argument, 0, 'd'},
 299       {"d", required_argument, 0, 'd'},
 300       {"cd", required_argument, 0, OPT_CD},
 301       {"tty", required_argument, 0, 't'},
 302       {"baud", required_argument, 0, 'b'},
 303       {"b", required_argument, 0, 'b'},
 304       {"nw", no_argument, NULL, OPT_NOWINDOWS},
 305       {"nowindows", no_argument, NULL, OPT_NOWINDOWS},
 306       {"w", no_argument, NULL, OPT_WINDOWS},
 307       {"windows", no_argument, NULL, OPT_WINDOWS},
 308       {"statistics", no_argument, 0, OPT_STATISTICS},
 309       {"write", no_argument, &write_files, 1},
 310       {"args", no_argument, &set_args, 1},
 311      {"l", required_argument, 0, 'l'},
 312       {"return-child-result", no_argument, &return_child_result, 1},
 313       {0, no_argument, 0, 0}
 314     };
 315
 316     while (1)
 317       {
 318         int option_index;
 319
 320         c = getopt_long_only (argc, argv, "",
 321                               long_options, &option_index);
 322         if (c == EOF || set_args)
 323           break;
 324
 325         /* Long option that takes an argument.  */
 326         if (c == 0 && long_options[option_index].flag == 0)
 327           c = long_options[option_index].val;
 328
 329         switch (c)
 330           {
 331           case 0:
 332             /* Long option that just sets a flag.  */
 333             break;
 334           case OPT_SE:
 335             symarg = optarg;
 336             execarg = optarg;
 337             break;
 338           case OPT_CD:
 339             cdarg = optarg;
 340             break;
 341           case OPT_ANNOTATE:
 342             /* FIXME: what if the syntax is wrong (e.g. not digits)?  */
 343             annotation_level = atoi (optarg);
 344             break;
 345           case OPT_STATISTICS:
 346             /* Enable the display of both time and space usage.  */
 347             display_time = 1;
 348             display_space = 1;
 349             break;
 350           case OPT_TUI:
 351             /* --tui is equivalent to -i=tui.  */
 352             xfree (interpreter_p);
 353             interpreter_p = xstrdup (INTERP_TUI);
 354             break;
 355           case OPT_WINDOWS:
 356             /* FIXME: cagney/2003-03-01: Not sure if this option is
 357                actually useful, and if it is, what it should do.  */
 358 #ifdef GDBTK
 359             /* --windows is equivalent to -i=insight.  */
 360             xfree (interpreter_p);
 361             interpreter_p = xstrdup (INTERP_INSIGHT);
 362 #endif
 363             use_windows = 1;
 364             break;
 365           case OPT_NOWINDOWS:
 366             /* -nw is equivalent to -i=console.  */
 367             xfree (interpreter_p);
 368             interpreter_p = xstrdup (INTERP_CONSOLE);
 369             use_windows = 0;
 370             break;
 371           case 'f':
 372             annotation_level = 1;
 373 /* We have probably been invoked from emacs.  Disable window interface.  */
 374             use_windows = 0;
 375             break;
 376           case 's':
 377             symarg = optarg;
 378             break;
 379           case 'e':
 380             execarg = optarg;
 381             break;
 382           case 'c':
 383             corearg = optarg;
 384             break;
 385           case 'p':
 386             /* "corearg" is shared by "--core" and "--pid" */
 387             corearg = optarg;
 388             break;
 389           case 'x':
 390             cmdarg[ncmd++] = optarg;
 391             if (ncmd >= cmdsize)
 392               {
 393                 cmdsize *= 2;
 394                 cmdarg = (char **) xrealloc ((char *) cmdarg,
 395                                              cmdsize * sizeof (*cmdarg));
 396               }
 397             break;
 398           case 'B':
 399             batch = batch_silent = 1;
 400             gdb_stdout = ui_file_new();
 401             break;
 402 #ifdef GDBTK
 403           case 'z':
 404             {
 405 extern int gdbtk_test (char *);
 406               if (!gdbtk_test (optarg))
 407                 {
 408                   fprintf_unfiltered (gdb_stderr, _("%s: unable to load tclcommand file \"%s\""),
 409                                       argv[0], optarg);
 410                   exit (1);
 411                 }
 412               break;
 413             }
 414           case 'y':
 415             /* Backwards compatibility only.  */
 416             break;
 417           case 'w':
 418             {
 419               external_editor_command = xstrdup (optarg);
 420               break;
 421             }
 422 #endif /* GDBTK */
 423           case 'i':
 424             xfree (interpreter_p);
 425             interpreter_p = xstrdup (optarg);
 426             break;
 427           case 'd':
 428             dirarg[ndir++] = optarg;
 429             if (ndir >= dirsize)
 430               {
 431                 dirsize *= 2;
 432                 dirarg = (char **) xrealloc ((char *) dirarg,
 433                                              dirsize * sizeof (*dirarg));
 434               }
 435             break;
 436           case 't':
 437             ttyarg = optarg;
 438             break;
 439           case 'q':
 440             quiet = 1;
 441             break;
 442           case 'b':
 443             {
 444               int i;
 445               char *p;
 446
 447               i = strtol (optarg, &p, 0);
 448               if (i == 0 && p == optarg)
 449
 450                 /* Don't use *_filtered or warning() (which relies on
 451                    current_target) until after initialize_all_files(). */
 452
 453                 fprintf_unfiltered
 454                   (gdb_stderr,
 455                    _("warning: could not set baud rate to `%s'.\n"), optarg);
 456               else
 457                 baud_rate = i;
 458             }
 459             break;
 460           case 'l':
 461             {
 462               int i;
 463               char *p;
 464
 465               i = strtol (optarg, &p, 0);
 466               if (i == 0 && p == optarg)
 467
 468                 /* Don't use *_filtered or warning() (which relies on
 469                    current_target) until after initialize_all_files(). */
 470
 471                 fprintf_unfiltered
 472                   (gdb_stderr,
 473                  _("warning: could not set timeout limit to `%s'.\n"), optarg);
 474               else
 475                 remote_timeout = i;
 476             }
 477             break;
 478
 479           case '?':
 480             fprintf_unfiltered (gdb_stderr,
 481                         _("Use `%s --help' for a complete list of options.\n"),
 482                                 argv[0]);
 483             exit (1);
 484           }
 485       }
 486
 487     /* If --help or --version, disable window interface.  */
 488     if (print_help || print_version)
 489       {
 490         use_windows = 0;
 491       }
 492
 493     if (set_args)
 494       {
 495         /* The remaining options are the command-line options for the
 496            inferior.  The first one is the sym/exec file, and the rest
 497            are arguments.  */
 498         if (optind >= argc)
 499           {
 500             fprintf_unfiltered (gdb_stderr,
 501                                 _("%s: `--args' specified but no program specified\n"),
 502                                 argv[0]);
 503             exit (1);
 504           }
 505         symarg = argv[optind];
 506         execarg = argv[optind];
 507         ++optind;
 508         set_inferior_args_vector (argc - optind, &argv[optind]);
 509       }
 510     else
 511       {
 512         /* OK, that's all the options.  The other arguments are filenames.  */
 513         count = 0;
 514         for (; optind < argc; optind++)
 515           switch (++count)
 516             {
 517             case 1:
 518               symarg = argv[optind];
 519               execarg = argv[optind];
 520               break;
 521             case 2:
 522               /* The documentation says this can be a "ProcID" as well.
 523                  We will try it as both a corefile and a pid.  */
 524               corearg = argv[optind];
 525               break;
 526             case 3:
 527               fprintf_unfiltered (gdb_stderr,
 528                                   _("Excess command line arguments ignored. (%s%s)\n"),
 529                                   argv[optind], (optind == argc - 1) ? "" : " ...");
 530               break;
 531             }
 532       }
 533     if (batch)
 534       quiet = 1;
 535   }
 536
 537   /* Initialize all files.  Give the interpreter a chance to take
 538      control of the console via the deprecated_init_ui_hook ().  */
 539   gdb_init (argv[0]);
 540
 541   /* Do these (and anything which might call wrap_here or *_filtered)
 542      after initialize_all_files() but before the interpreter has been
 543      installed.  Otherwize the help/version messages will be eaten by
 544      the interpreter's output handler.  */
 545
 546   if (print_version)
 547     {
 548       print_gdb_version (gdb_stdout);
 549       wrap_here ("");
 550       printf_filtered ("\n");
 551       exit (0);
 552     }
 553
 554   if (print_help)
 555     {
 556       print_gdb_help (gdb_stdout);
 557       fputs_unfiltered ("\n", gdb_stdout);
 558       exit (0);
 559     }
 560
 561   /* FIXME: cagney/2003-02-03: The big hack (part 1 of 2) that lets
 562      GDB retain the old MI1 interpreter startup behavior.  Output the
 563      copyright message before the interpreter is installed.  That way
 564      it isn't encapsulated in MI output.  */
 565   if (!quiet && strcmp (interpreter_p, INTERP_MI1) == 0)
 566     {
 567       /* Print all the junk at the top, with trailing "..." if we are about
 568          to read a symbol file (possibly slowly).  */
 569       print_gdb_version (gdb_stdout);
 570       if (symarg)
 571         printf_filtered ("..");
 572       wrap_here ("");
 573       gdb_flush (gdb_stdout);   /* Force to screen during slow operations */
 574     }
 575
 576
 577   /* Install the default UI.  All the interpreters should have had a
 578      look at things by now.  Initialize the default interpreter. */
 579
 580   {
 581     /* Find it.  */
 582     struct interp *interp = interp_lookup (interpreter_p);
 583     if (interp == NULL)
 584       error (_("Interpreter `%s' unrecognized"), interpreter_p);
 585     /* Install it.  */
 586     if (!interp_set (interp))
 587       {
 588         fprintf_unfiltered (gdb_stderr,
 589                             "Interpreter `%s' failed to initialize.\n",
 590                             interpreter_p);
 591         exit (1);
 592       }
 593   }
 594
 595   /* FIXME: cagney/2003-02-03: The big hack (part 2 of 2) that lets
 596      GDB retain the old MI1 interpreter startup behavior.  Output the
 597      copyright message after the interpreter is installed when it is
 598      any sane interpreter.  */
 599   if (!quiet && !current_interp_named_p (INTERP_MI1))
 600     {
 601       /* Print all the junk at the top, with trailing "..." if we are about
 602          to read a symbol file (possibly slowly).  */
 603       print_gdb_version (gdb_stdout);
 604       if (symarg)
 605         printf_filtered ("..");
 606       wrap_here ("");
 607       gdb_flush (gdb_stdout);   /* Force to screen during slow operations */
 608     }
 609
 610   error_pre_print = "\n\n";
 611   quit_pre_print = error_pre_print;
 612
 613   /* We may get more than one warning, don't double space all of them... */
 614   warning_pre_print = _("\nwarning: ");
 615
 616   /* Read and execute $HOME/.gdbinit file, if it exists.  This is done
 617      *before* all the command line arguments are processed; it sets
 618      global parameters, which are independent of what file you are
 619      debugging or what directory you are in.  */
 620   homedir = getenv ("HOME");
 621   if (homedir)
 622     {
 623       char *homeinit = xstrprintf ("%s/%s", homedir, gdbinit);
 624
 625       if (!inhibit_gdbinit)
 626         {
 627           catch_command_errors (source_command, homeinit, 0, RETURN_MASK_ALL);
 628         }
 629
 630       /* Do stats; no need to do them elsewhere since we'll only
 631          need them if homedir is set.  Make sure that they are
 632          zero in case one of them fails (this guarantees that they
 633          won't match if either exists).  */
 634
 635       memset (&homebuf, 0, sizeof (struct stat));
 636       memset (&cwdbuf, 0, sizeof (struct stat));
 637
 638       stat (homeinit, &homebuf);
 639       stat (gdbinit, &cwdbuf);  /* We'll only need this if
 640                                    homedir was set.  */
 641       xfree (homeinit);
 642     }
 643
 644   /* Now perform all the actions indicated by the arguments.  */
 645   if (cdarg != NULL)
 646     {
 647       catch_command_errors (cd_command, cdarg, 0, RETURN_MASK_ALL);
 648     }
 649
 650   for (i = 0; i < ndir; i++)
 651     catch_command_errors (directory_command, dirarg[i], 0, RETURN_MASK_ALL);
 652   xfree (dirarg);
 653
 654   if (execarg != NULL
 655       && symarg != NULL
 656       && strcmp (execarg, symarg) == 0)
 657     {
 658       /* The exec file and the symbol-file are the same.  If we can't
 659          open it, better only print one error message.
 660          catch_command_errors returns non-zero on success! */
 661       if (catch_command_errors (exec_file_attach, execarg, !batch, RETURN_MASK_ALL))
 662         catch_command_errors (symbol_file_add_main, symarg, 0, RETURN_MASK_ALL);
 663     }
 664   else
 665     {
 666       if (execarg != NULL)
 667         catch_command_errors (exec_file_attach, execarg, !batch, RETURN_MASK_ALL);
 668       if (symarg != NULL)
 669         catch_command_errors (symbol_file_add_main, symarg, 0, RETURN_MASK_ALL);
 670     }
 671
 672   /* After the symbol file has been read, print a newline to get us
 673      beyond the copyright line...  But errors should still set off
 674      the error message with a (single) blank line.  */
 675   if (!quiet)
 676     printf_filtered ("\n");
 677   error_pre_print = "\n";
 678   quit_pre_print = error_pre_print;
 679   warning_pre_print = _("\nwarning: ");
 680
 681   if (corearg != NULL)
 682     {
 683       /* corearg may be either a corefile or a pid.
 684          If its first character is a digit, try attach first
 685          and then corefile.  Otherwise try corefile first. */
 686
 687       if (isdigit (corearg[0]))
 688         {
 689           if (catch_command_errors (attach_command, corearg,
 690                                     !batch, RETURN_MASK_ALL) == 0)
 691             catch_command_errors (core_file_command, corearg,
 692                                   !batch, RETURN_MASK_ALL);
 693         }
 694       else /* Can't be a pid, better be a corefile. */
 695         catch_command_errors (core_file_command, corearg,
 696                               !batch, RETURN_MASK_ALL);
 697     }
 698
 699   if (ttyarg != NULL)
 700     catch_command_errors (tty_command, ttyarg, !batch, RETURN_MASK_ALL);
 701
 702   /* Error messages should no longer be distinguished with extra output. */
 703   error_pre_print = NULL;
 704   quit_pre_print = NULL;
 705   warning_pre_print = _("warning: ");
 706
 707   /* Read the .gdbinit file in the current directory, *if* it isn't
 708      the same as the $HOME/.gdbinit file (it should exist, also).  */
 709
 710   if (!homedir
 711       || memcmp ((char *) &homebuf, (char *) &cwdbuf, sizeof (struct stat)))
 712     if (!inhibit_gdbinit)
 713       {
 714         catch_command_errors (source_command, gdbinit, 0, RETURN_MASK_ALL);
 715       }
 716
 717   for (i = 0; i < ncmd; i++)
 718     {
 719 #if 0
 720       /* NOTE: cagney/1999-11-03: SET_TOP_LEVEL() was a macro that
 721          expanded into a call to setjmp().  */
 722       if (!SET_TOP_LEVEL ()) /* NB: This is #if 0'd out */
 723         {
 724           /* NOTE: I am commenting this out, because it is not clear
 725              where this feature is used. It is very old and
 726              undocumented. ezannoni: 1999-05-04 */
 727 #if 0
 728           if (cmdarg[i][0] == '-' && cmdarg[i][1] == '\0')
 729             read_command_file (stdin);
 730           else
 731 #endif
 732             source_command (cmdarg[i], !batch);
 733           do_cleanups (ALL_CLEANUPS);
 734         }
 735 #endif
 736       catch_command_errors (source_command, cmdarg[i], !batch, RETURN_MASK_ALL);
 737     }
 738   xfree (cmdarg);
 739
 740   /* Read in the old history after all the command files have been read. */
 741   init_history ();
 742
 743   if (batch)
 744     {
 745       /* We have hit the end of the batch file.  */
 746       quit_force (NULL, 0);
 747     }
 748
 749   /* Do any host- or target-specific hacks.  This is used for i960 targets
 750      to force the user to set a nindy target and spec its parameters.  */
 751
 752 #ifdef BEFORE_MAIN_LOOP_HOOK
 753   BEFORE_MAIN_LOOP_HOOK;
 754 #endif
 755
 756   /* Show time and/or space usage.  */
 757
 758   if (display_time)
 759     {
 760       long init_time = get_run_time () - time_at_startup;
 761
 762       printf_unfiltered (_("Startup time: %ld.%06ld\n"),
 763                          init_time / 1000000, init_time % 1000000);
 764     }
 765
 766   if (display_space)
 767     {
 768 #ifdef HAVE_SBRK
 769       extern char **environ;
 770       char *lim = (char *) sbrk (0);
 771
 772       printf_unfiltered (_("Startup size: data size %ld\n"),
 773                          (long) (lim - (char *) &environ));
 774 #endif
 775     }
 776
 777 #if 0
 778   /* FIXME: cagney/1999-11-06: The original main loop was like: */
 779   while (1)
 780     {
 781       if (!SET_TOP_LEVEL ())
 782         {
 783           do_cleanups (ALL_CLEANUPS);   /* Do complete cleanup */
 784           /* GUIs generally have their own command loop, mainloop, or
 785              whatever.  This is a good place to gain control because
 786              many error conditions will end up here via longjmp().  */
 787           if (deprecated_command_loop_hook)
 788             deprecated_command_loop_hook ();
 789           else
 790             deprecated_command_loop ();
 791           quit_command ((char *) 0, instream == stdin);
 792         }
 793     }
 794   /* NOTE: If the command_loop() returned normally, the loop would
 795      attempt to exit by calling the function quit_command().  That
 796      function would either call exit() or throw an error returning
 797      control to SET_TOP_LEVEL. */
 798   /* NOTE: The function do_cleanups() was called once each time round
 799      the loop.  The usefulness of the call isn't clear.  If an error
 800      was thrown, everything would have already been cleaned up.  If
 801      command_loop() returned normally and quit_command() was called,
 802      either exit() or error() (again cleaning up) would be called. */
 803 #endif
 804   /* NOTE: cagney/1999-11-07: There is probably no reason for not
 805      moving this loop and the code found in captured_command_loop()
 806      into the command_loop() proper.  The main thing holding back that
 807      change - SET_TOP_LEVEL() - has been eliminated. */
 808   while (1)
 809     {
 810       catch_errors (captured_command_loop, 0, "", RETURN_MASK_ALL);
 811     }
 812   /* No exit -- exit is through quit_command.  */
 813 }
 814
 815 int
 816 gdb_main (struct captured_main_args *args)
 817 {
 818   use_windows = args->use_windows;
 819   catch_errors (captured_main, args, "", RETURN_MASK_ALL);
 820   /* The only way to end up here is by an error (normal exit is
 821      handled by quit_force()), hence always return an error status.  */
 822   return 1;
 823 }
 824
 825
 826 /* Don't use *_filtered for printing help.  We don't want to prompt
 827    for continue no matter how small the screen or how much we're going
 828    to print.  */
 829
 830 static void
 831 print_gdb_help (struct ui_file *stream)
 832 {
 833   fputs_unfiltered (_("\
 834 This is the GNU debugger.  Usage:\n\n\
 835     gdb [options] [executable-file [core-file or process-id]]\n\
 836     gdb [options] --args executable-file [inferior-arguments ...]\n\n\
 837 Options:\n\n\
 838 "), stream);
 839   fputs_unfiltered (_("\
 840   --args             Arguments after executable-file are passed to inferior\n\
 841 "), stream);
 842   fputs_unfiltered (_("\
 843   -b BAUDRATE        Set serial port baud rate used for remote debugging.\n\
 844   --batch            Exit after processing options.\n\
 845   --batch-silent     As for --batch, but suppress all gdb stdout output.\n\
 846   --return-child-result\n\
 847                      GDB exit code will be the child's exit code.\n\
 848   --cd=DIR           Change current directory to DIR.\n\
 849   --command=FILE     Execute GDB commands from FILE.\n\
 850   --core=COREFILE    Analyze the core dump COREFILE.\n\
 851   --pid=PID          Attach to running process PID.\n\
 852 "), stream);
 853   fputs_unfiltered (_("\
 854   --dbx              DBX compatibility mode.\n\
 855   --directory=DIR    Search for source files in DIR.\n\
 856   --epoch            Output information used by epoch emacs-GDB interface.\n\
 857   --exec=EXECFILE    Use EXECFILE as the executable.\n\
 858   --fullname         Output information used by emacs-GDB interface.\n\
 859   --help             Print this message.\n\
 860 "), stream);
 861   fputs_unfiltered (_("\
 862   --interpreter=INTERP\n\
 863                      Select a specific interpreter / user interface\n\
 864 "), stream);
 865   fputs_unfiltered (_("\
 866   -l TIMEOUT         Set timeout in seconds for remote debugging.\n\
 867   --nw               Do not use a window interface.\n\
 868   --nx               Do not read "), stream);
 869   fputs_unfiltered (gdbinit, stream);
 870   fputs_unfiltered (_(" file.\n\
 871   --quiet            Do not print version number on startup.\n\
 872   --readnow          Fully read symbol files on first access.\n\
 873 "), stream);
 874   fputs_unfiltered (_("\
 875   --se=FILE          Use FILE as symbol file and executable file.\n\
 876   --symbols=SYMFILE  Read symbols from SYMFILE.\n\
 877   --tty=TTY          Use TTY for input/output by the program being debugged.\n\
 878 "), stream);
 879 #if defined(TUI)
 880   fputs_unfiltered (_("\
 881   --tui              Use a terminal user interface.\n\
 882 "), stream);
 883 #endif
 884   fputs_unfiltered (_("\
 885   --version          Print version information and then exit.\n\
 886   -w                 Use a window interface.\n\
 887   --write            Set writing into executable and core files.\n\
 888   --xdb              XDB compatibility mode.\n\
 889 "), stream);
 890   fputs_unfiltered (_("\n\
 891 For more information, type \"help\" from within GDB, or consult the\n\
 892 GDB manual (available as on-line info or a printed manual).\n\
 893 Report bugs to \"bug-gdb@gnu.org\".\
 894 "), stream);
 895 }