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