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