gdb/main.c

   1 /* Top level stuff for GDB, the GNU debugger.
   2    Copyright 1986-1995, 1999-2000 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place - Suite 330,
  19    Boston, MA 02111-1307, USA.  */
  20
  21 #include "defs.h"
  22 #include "top.h"
  23 #include "target.h"
  24 #include "inferior.h"
  25 #include "call-cmds.h"
  26
  27 #include "getopt.h"
  28
  29 #include <sys/types.h>
  30 #include "gdb_stat.h"
  31 #include <ctype.h>
  32
  33 #include "gdb_string.h"
  34 #include "event-loop.h"
  35 #include "ui-out.h"
  36 #if defined (TUI) || defined (GDBTK)
  37 /* FIXME: cagney/2000-01-31: This #include is to allow older code such
  38    as that found in the TUI to continue to build. */
  39 #include "tui/tui-file.h"
  40 #endif
  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 #ifdef UI_OUT
  57 /* Has an interpreter been specified and if so, which. */
  58 char *interpreter_p;
  59 #endif
  60
  61 /* Whether this is the command line version or not */
  62 int tui_version = 0;
  63
  64 /* Whether xdb commands will be handled */
  65 int xdb_commands = 0;
  66
  67 /* Whether dbx commands will be handled */
  68 int dbx_commands = 0;
  69
  70 struct ui_file *gdb_stdout;
  71 struct ui_file *gdb_stderr;
  72 struct ui_file *gdb_stdlog;
  73 struct ui_file *gdb_stdtarg;
  74
  75 /* Used to initialize error() - defined in utils.c */
  76
  77 extern void error_init (void);
  78
  79 /* Whether to enable writing into executable and core files */
  80 extern int write_files;
  81
  82 static void print_gdb_help (struct ui_file *);
  83
  84 /* These two are used to set the external editor commands when gdb is farming
  85    out files to be edited by another program. */
  86
  87 extern int enable_external_editor;
  88 extern char *external_editor_command;
  89
  90 #ifdef __CYGWIN__
  91 #include <windows.h>            /* for MAX_PATH */
  92 #include <sys/cygwin.h>         /* for cygwin32_conv_to_posix_path */
  93 #endif
  94
  95 /* Call command_loop.  If it happens to return, pass that through as a
  96    non-zero return status. */
  97
  98 static int
  99 captured_command_loop (void *data)
 100 {
 101   if (command_loop_hook == NULL)
 102     command_loop ();
 103   else
 104     command_loop_hook ();
 105   /* FIXME: cagney/1999-11-05: A correct command_loop() implementaton
 106      would clean things up (restoring the cleanup chain) to the state
 107      they were just prior to the call.  Technically, this means that
 108      the do_cleanups() below is redundant.  Unfortunatly, many FUNC's
 109      are not that well behaved.  do_cleanups should either be replaced
 110      with a do_cleanups call (to cover the problem) or an assertion
 111      check to detect bad FUNCs code. */
 112   do_cleanups (ALL_CLEANUPS);
 113   /* If the command_loop returned, normally (rather than threw an
 114      error) we try to quit. If the quit is aborted, catch_errors()
 115      which called this catch the signal and restart the command
 116      loop. */
 117   quit_command (NULL, instream == stdin);
 118   return 1;
 119 }
 120
 121 struct captured_main_args
 122   {
 123     int argc;
 124     char **argv;
 125   };
 126
 127 static int
 128 captured_main (void *data)
 129 {
 130   struct captured_main_args *context = data;
 131   int argc = context->argc;
 132   char **argv = context->argv;
 133   int count;
 134   static int quiet = 0;
 135   static int batch = 0;
 136
 137   /* Pointers to various arguments from command line.  */
 138   char *symarg = NULL;
 139   char *execarg = NULL;
 140   char *corearg = NULL;
 141   char *cdarg = NULL;
 142   char *ttyarg = NULL;
 143
 144   /* These are static so that we can take their address in an initializer.  */
 145   static int print_help;
 146   static int print_version;
 147
 148   /* Pointers to all arguments of --command option.  */
 149   char **cmdarg;
 150   /* Allocated size of cmdarg.  */
 151   int cmdsize;
 152   /* Number of elements of cmdarg used.  */
 153   int ncmd;
 154
 155   /* Indices of all arguments of --directory option.  */
 156   char **dirarg;
 157   /* Allocated size.  */
 158   int dirsize;
 159   /* Number of elements used.  */
 160   int ndir;
 161
 162   struct stat homebuf, cwdbuf;
 163   char *homedir, *homeinit;
 164
 165   register int i;
 166
 167   long time_at_startup = get_run_time ();
 168
 169   START_PROGRESS (argv[0], 0);
 170
 171 #ifdef MPW
 172   /* Do all Mac-specific setup. */
 173   mac_init ();
 174 #endif /* MPW */
 175
 176   /* This needs to happen before the first use of malloc.  */
 177   init_malloc ((PTR) NULL);
 178
 179 #if defined (ALIGN_STACK_ON_STARTUP)
 180   i = (int) &count & 0x3;
 181   if (i != 0)
 182     alloca (4 - i);
 183 #endif
 184
 185   cmdsize = 1;
 186   cmdarg = (char **) xmalloc (cmdsize * sizeof (*cmdarg));
 187   ncmd = 0;
 188   dirsize = 1;
 189   dirarg = (char **) xmalloc (dirsize * sizeof (*dirarg));
 190   ndir = 0;
 191
 192   quit_flag = 0;
 193   line = (char *) xmalloc (linesize);
 194   line[0] = '\0';               /* Terminate saved (now empty) cmd line */
 195   instream = stdin;
 196
 197   getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));
 198   current_directory = gdb_dirbuf;
 199
 200 #if defined (TUI) || defined (GDBTK)
 201   /* Older code uses the tui_file and fputs_unfiltered_hook().  It
 202      should be using a customized UI_FILE object and re-initializing
 203      within its own _initialize function.  */
 204   gdb_stdout = tui_fileopen (stdout);
 205   gdb_stderr = tui_fileopen (stderr);
 206   gdb_stdlog = gdb_stdout;      /* for moment */
 207   gdb_stdtarg = gdb_stderr;     /* for moment */
 208 #else
 209   gdb_stdout = stdio_fileopen (stdout);
 210   gdb_stderr = stdio_fileopen (stderr);
 211   gdb_stdlog = gdb_stderr;      /* for moment */
 212   gdb_stdtarg = gdb_stderr;     /* for moment */
 213 #endif
 214
 215   /* initialize error() */
 216   error_init ();
 217
 218   /* Parse arguments and options.  */
 219   {
 220     int c;
 221     /* When var field is 0, use flag field to record the equivalent
 222        short option (or arbitrary numbers starting at 10 for those
 223        with no equivalent).  */
 224     static struct option long_options[] =
 225     {
 226       {"async", no_argument, &event_loop_p, 1},
 227       {"noasync", no_argument, &event_loop_p, 0},
 228 #if defined(TUI)
 229       {"tui", no_argument, &tui_version, 1},
 230 #endif
 231       {"xdb", no_argument, &xdb_commands, 1},
 232       {"dbx", no_argument, &dbx_commands, 1},
 233       {"readnow", no_argument, &readnow_symbol_files, 1},
 234       {"r", no_argument, &readnow_symbol_files, 1},
 235       {"mapped", no_argument, &mapped_symbol_files, 1},
 236       {"m", no_argument, &mapped_symbol_files, 1},
 237       {"quiet", no_argument, &quiet, 1},
 238       {"q", no_argument, &quiet, 1},
 239       {"silent", no_argument, &quiet, 1},
 240       {"nx", no_argument, &inhibit_gdbinit, 1},
 241       {"n", no_argument, &inhibit_gdbinit, 1},
 242       {"batch", no_argument, &batch, 1},
 243       {"epoch", no_argument, &epoch_interface, 1},
 244
 245     /* This is a synonym for "--annotate=1".  --annotate is now preferred,
 246        but keep this here for a long time because people will be running
 247        emacses which use --fullname.  */
 248       {"fullname", no_argument, 0, 'f'},
 249       {"f", no_argument, 0, 'f'},
 250
 251       {"annotate", required_argument, 0, 12},
 252       {"help", no_argument, &print_help, 1},
 253       {"se", required_argument, 0, 10},
 254       {"symbols", required_argument, 0, 's'},
 255       {"s", required_argument, 0, 's'},
 256       {"exec", required_argument, 0, 'e'},
 257       {"e", required_argument, 0, 'e'},
 258       {"core", required_argument, 0, 'c'},
 259       {"c", required_argument, 0, 'c'},
 260       {"command", required_argument, 0, 'x'},
 261       {"version", no_argument, &print_version, 1},
 262       {"x", required_argument, 0, 'x'},
 263 #ifdef GDBTK
 264       {"tclcommand", required_argument, 0, 'z'},
 265       {"enable-external-editor", no_argument, 0, 'y'},
 266       {"editor-command", required_argument, 0, 'w'},
 267 #endif
 268 #ifdef UI_OUT
 269       {"ui", required_argument, 0, 'i'},
 270       {"interpreter", required_argument, 0, 'i'},
 271       {"i", required_argument, 0, 'i'},
 272 #endif
 273       {"directory", required_argument, 0, 'd'},
 274       {"d", required_argument, 0, 'd'},
 275       {"cd", required_argument, 0, 11},
 276       {"tty", required_argument, 0, 't'},
 277       {"baud", required_argument, 0, 'b'},
 278       {"b", required_argument, 0, 'b'},
 279       {"nw", no_argument, &use_windows, 0},
 280       {"nowindows", no_argument, &use_windows, 0},
 281       {"w", no_argument, &use_windows, 1},
 282       {"windows", no_argument, &use_windows, 1},
 283       {"statistics", no_argument, 0, 13},
 284       {"write", no_argument, &write_files, 1},
 285 /* Allow machine descriptions to add more options... */
 286 #ifdef ADDITIONAL_OPTIONS
 287       ADDITIONAL_OPTIONS
 288 #endif
 289       {0, no_argument, 0, 0}
 290     };
 291
 292     while (1)
 293       {
 294         int option_index;
 295
 296         c = getopt_long_only (argc, argv, "",
 297                               long_options, &option_index);
 298         if (c == EOF)
 299           break;
 300
 301         /* Long option that takes an argument.  */
 302         if (c == 0 && long_options[option_index].flag == 0)
 303           c = long_options[option_index].val;
 304
 305         switch (c)
 306           {
 307           case 0:
 308             /* Long option that just sets a flag.  */
 309             break;
 310           case 10:
 311             symarg = optarg;
 312             execarg = optarg;
 313             break;
 314           case 11:
 315             cdarg = optarg;
 316             break;
 317           case 12:
 318             /* FIXME: what if the syntax is wrong (e.g. not digits)?  */
 319             annotation_level = atoi (optarg);
 320             break;
 321           case 13:
 322             /* Enable the display of both time and space usage.  */
 323             display_time = 1;
 324             display_space = 1;
 325             break;
 326           case 'f':
 327             annotation_level = 1;
 328 /* We have probably been invoked from emacs.  Disable window interface.  */
 329             use_windows = 0;
 330             break;
 331           case 's':
 332             symarg = optarg;
 333             break;
 334           case 'e':
 335             execarg = optarg;
 336             break;
 337           case 'c':
 338             corearg = optarg;
 339             break;
 340           case 'x':
 341             cmdarg[ncmd++] = optarg;
 342             if (ncmd >= cmdsize)
 343               {
 344                 cmdsize *= 2;
 345                 cmdarg = (char **) xrealloc ((char *) cmdarg,
 346                                              cmdsize * sizeof (*cmdarg));
 347               }
 348             break;
 349 #ifdef GDBTK
 350           case 'z':
 351             {
 352 extern int gdbtk_test (char *);
 353               if (!gdbtk_test (optarg))
 354                 {
 355                   fprintf_unfiltered (gdb_stderr, "%s: unable to load tclcommand file \"%s\"",
 356                                       argv[0], optarg);
 357                   exit (1);
 358                 }
 359               break;
 360             }
 361           case 'y':
 362             {
 363               /*
 364                * This enables the edit/button in the main window, even
 365                * when IDE_ENABLED is set to false. In this case you must
 366                * use --tclcommand to specify a tcl/script to be called,
 367                * Tcl/Variable to store the edit/command is:
 368                * external_editor
 369                */
 370               enable_external_editor = 1;
 371               break;
 372             }
 373           case 'w':
 374             {
 375               /*
 376                * if editor command is enabled, both flags are set
 377                */
 378               enable_external_editor = 1;
 379               external_editor_command = xstrdup (optarg);
 380               break;
 381             }
 382 #endif /* GDBTK */
 383 #ifdef UI_OUT
 384           case 'i':
 385             interpreter_p = optarg;
 386             break;
 387 #endif
 388           case 'd':
 389             dirarg[ndir++] = optarg;
 390             if (ndir >= dirsize)
 391               {
 392                 dirsize *= 2;
 393                 dirarg = (char **) xrealloc ((char *) dirarg,
 394                                              dirsize * sizeof (*dirarg));
 395               }
 396             break;
 397           case 't':
 398             ttyarg = optarg;
 399             break;
 400           case 'q':
 401             quiet = 1;
 402             break;
 403           case 'b':
 404             {
 405               int i;
 406               char *p;
 407
 408               i = strtol (optarg, &p, 0);
 409               if (i == 0 && p == optarg)
 410
 411                 /* Don't use *_filtered or warning() (which relies on
 412                    current_target) until after initialize_all_files(). */
 413
 414                 fprintf_unfiltered
 415                   (gdb_stderr,
 416                    "warning: could not set baud rate to `%s'.\n", optarg);
 417               else
 418                 baud_rate = i;
 419             }
 420           case 'l':
 421             {
 422               int i;
 423               char *p;
 424
 425               i = strtol (optarg, &p, 0);
 426               if (i == 0 && p == optarg)
 427
 428                 /* Don't use *_filtered or warning() (which relies on
 429                    current_target) until after initialize_all_files(). */
 430
 431                 fprintf_unfiltered
 432                   (gdb_stderr,
 433                  "warning: could not set timeout limit to `%s'.\n", optarg);
 434               else
 435                 remote_timeout = i;
 436             }
 437             break;
 438
 439 #ifdef ADDITIONAL_OPTION_CASES
 440             ADDITIONAL_OPTION_CASES
 441 #endif
 442           case '?':
 443             fprintf_unfiltered (gdb_stderr,
 444                         "Use `%s --help' for a complete list of options.\n",
 445                                 argv[0]);
 446             exit (1);
 447           }
 448       }
 449
 450     /* If --help or --version, disable window interface.  */
 451     if (print_help || print_version)
 452       {
 453         use_windows = 0;
 454 #ifdef TUI
 455         /* Disable the TUI as well.  */
 456         tui_version = 0;
 457 #endif
 458       }
 459
 460 #ifdef TUI
 461     /* An explicit --tui flag overrides the default UI, which is the
 462        window system.  */
 463     if (tui_version)
 464       use_windows = 0;
 465 #endif
 466
 467     /* OK, that's all the options.  The other arguments are filenames.  */
 468     count = 0;
 469     for (; optind < argc; optind++)
 470       switch (++count)
 471         {
 472         case 1:
 473           symarg = argv[optind];
 474           execarg = argv[optind];
 475           break;
 476         case 2:
 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 __CYGWIN32__
 538   {
 539     char *tmp = getenv ("HOME");
 540
 541     if (tmp != NULL)
 542       {
 543         homedir = (char *) alloca (MAX_PATH + 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   free ((PTR) 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_command, execarg, !batch, RETURN_MASK_ALL))
 596         catch_command_errors (symbol_file_command, symarg, 0, RETURN_MASK_ALL);
 597     }
 598   else
 599     {
 600       if (execarg != NULL)
 601         catch_command_errors (exec_file_command, execarg, !batch, RETURN_MASK_ALL);
 602       if (symarg != NULL)
 603         catch_command_errors (symbol_file_command, 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   free ((PTR) 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   /* The default command loop.
 710      The WIN32 Gui calls this main to set up gdb's state, and
 711      has its own command loop. */
 712 #if !defined _WIN32 || defined __GNUC__
 713   /* GUIs generally have their own command loop, mainloop, or
 714      whatever.  This is a good place to gain control because many
 715      error conditions will end up here via longjmp(). */
 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 #endif
 752   /* No exit -- exit is through quit_command.  */
 753 }
 754
 755 int
 756 main (int argc, char **argv)
 757 {
 758   struct captured_main_args args;
 759   args.argc = argc;
 760   args.argv = argv;
 761   catch_errors (captured_main, &args, "", RETURN_MASK_ALL);
 762   return 0;
 763 }
 764
 765
 766 /* Don't use *_filtered for printing help.  We don't want to prompt
 767    for continue no matter how small the screen or how much we're going
 768    to print.  */
 769
 770 static void
 771 print_gdb_help (struct ui_file *stream)
 772 {
 773   fputs_unfiltered ("\
 774 This is the GNU debugger.  Usage:\n\n\
 775     gdb [options] [executable-file [core-file or process-id]]\n\n\
 776 Options:\n\n\
 777 ", stream);
 778   fputs_unfiltered ("\
 779   --[no]async        Enable (disable) asynchronous version of CLI\n\
 780 ", stream);
 781   fputs_unfiltered ("\
 782   -b BAUDRATE        Set serial port baud rate used for remote debugging.\n\
 783   --batch            Exit after processing options.\n\
 784   --cd=DIR           Change current directory to DIR.\n\
 785   --command=FILE     Execute GDB commands from FILE.\n\
 786   --core=COREFILE    Analyze the core dump COREFILE.\n\
 787 ", stream);
 788   fputs_unfiltered ("\
 789   --dbx              DBX compatibility mode.\n\
 790   --directory=DIR    Search for source files in DIR.\n\
 791   --epoch            Output information used by epoch emacs-GDB interface.\n\
 792   --exec=EXECFILE    Use EXECFILE as the executable.\n\
 793   --fullname         Output information used by emacs-GDB interface.\n\
 794   --help             Print this message.\n\
 795 ", stream);
 796   fputs_unfiltered ("\
 797   --interpreter=INTERP\n\
 798                      Select a specific interpreter / user interface\n\
 799 ", stream);
 800   fputs_unfiltered ("\
 801   --mapped           Use mapped symbol files if supported on this system.\n\
 802   --nw               Do not use a window interface.\n\
 803   --nx               Do not read ", stream);
 804   fputs_unfiltered (gdbinit, stream);
 805   fputs_unfiltered (" file.\n\
 806   --quiet            Do not print version number on startup.\n\
 807   --readnow          Fully read symbol files on first access.\n\
 808 ", stream);
 809   fputs_unfiltered ("\
 810   --se=FILE          Use FILE as symbol file and executable file.\n\
 811   --symbols=SYMFILE  Read symbols from SYMFILE.\n\
 812   --tty=TTY          Use TTY for input/output by the program being debugged.\n\
 813 ", stream);
 814 #if defined(TUI)
 815   fputs_unfiltered ("\
 816   --tui              Use a terminal user interface.\n\
 817 ", stream);
 818 #endif
 819   fputs_unfiltered ("\
 820   --version          Print version information and then exit.\n\
 821   -w                 Use a window interface.\n\
 822   --write            Set writing into executable and core files.\n\
 823   --xdb              XDB compatibility mode.\n\
 824 ", stream);
 825 #ifdef ADDITIONAL_OPTION_HELP
 826   fputs_unfiltered (ADDITIONAL_OPTION_HELP, stream);
 827 #endif
 828   fputs_unfiltered ("\n\
 829 For more information, type \"help\" from within GDB, or consult the\n\
 830 GDB manual (available as on-line info or a printed manual).\n\
 831 Report bugs to \"bug-gdb@gnu.org\".\
 832 ", stream);
 833 }