gdb/main.c

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