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