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 <windows.h>            /* for MAX_PATH */
  95 #include <sys/cygwin.h>         /* for cygwin32_conv_to_posix_path */
  96 #endif
  97
  98 /* Call command_loop.  If it happens to return, pass that through as a
  99    non-zero return status. */
 100
 101 static int
 102 captured_command_loop (void *data)
 103 {
 104   if (command_loop_hook == NULL)
 105     command_loop ();
 106   else
 107     command_loop_hook ();
 108   /* FIXME: cagney/1999-11-05: A correct command_loop() implementaton
 109      would clean things up (restoring the cleanup chain) to the state
 110      they were just prior to the call.  Technically, this means that
 111      the do_cleanups() below is redundant.  Unfortunately, many FUNCs
 112      are not that well behaved.  do_cleanups should either be replaced
 113      with a do_cleanups call (to cover the problem) or an assertion
 114      check to detect bad FUNCs code. */
 115   do_cleanups (ALL_CLEANUPS);
 116   /* If the command_loop returned, normally (rather than threw an
 117      error) we try to quit. If the quit is aborted, catch_errors()
 118      which called this catch the signal and restart the command
 119      loop. */
 120   quit_command (NULL, instream == stdin);
 121   return 1;
 122 }
 123
 124 struct captured_main_args
 125   {
 126     int argc;
 127     char **argv;
 128   };
 129
 130 static int
 131 captured_main (void *data)
 132 {
 133   struct captured_main_args *context = data;
 134   int argc = context->argc;
 135   char **argv = context->argv;
 136   int count;
 137   static int quiet = 0;
 138   static int batch = 0;
 139
 140   /* Pointers to various arguments from command line.  */
 141   char *symarg = NULL;
 142   char *execarg = NULL;
 143   char *corearg = NULL;
 144   char *cdarg = NULL;
 145   char *ttyarg = NULL;
 146
 147   /* These are static so that we can take their address in an initializer.  */
 148   static int print_help;
 149   static int print_version;
 150
 151   /* Pointers to all arguments of --command option.  */
 152   char **cmdarg;
 153   /* Allocated size of cmdarg.  */
 154   int cmdsize;
 155   /* Number of elements of cmdarg used.  */
 156   int ncmd;
 157
 158   /* Indices of all arguments of --directory option.  */
 159   char **dirarg;
 160   /* Allocated size.  */
 161   int dirsize;
 162   /* Number of elements used.  */
 163   int ndir;
 164
 165   struct stat homebuf, cwdbuf;
 166   char *homedir, *homeinit;
 167
 168   register int i;
 169
 170   long time_at_startup = get_run_time ();
 171
 172   START_PROGRESS (argv[0], 0);
 173
 174 #ifdef MPW
 175   /* Do all Mac-specific setup. */
 176   mac_init ();
 177 #endif /* MPW */
 178
 179   /* This needs to happen before the first use of malloc.  */
 180   init_malloc ((PTR) NULL);
 181
 182 #if defined (ALIGN_STACK_ON_STARTUP)
 183   i = (int) &count & 0x3;
 184   if (i != 0)
 185     alloca (4 - i);
 186 #endif
 187
 188   cmdsize = 1;
 189   cmdarg = (char **) xmalloc (cmdsize * sizeof (*cmdarg));
 190   ncmd = 0;
 191   dirsize = 1;
 192   dirarg = (char **) xmalloc (dirsize * sizeof (*dirarg));
 193   ndir = 0;
 194
 195   quit_flag = 0;
 196   line = (char *) xmalloc (linesize);
 197   line[0] = '\0';               /* Terminate saved (now empty) cmd line */
 198   instream = stdin;
 199
 200   getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));
 201   current_directory = gdb_dirbuf;
 202
 203 #if defined (TUI)
 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           /* FIXME: The documentation says this can be a "ProcID". as well. */
 478           corearg = argv[optind];
 479           break;
 480         case 3:
 481           fprintf_unfiltered (gdb_stderr,
 482                           "Excess command line arguments ignored. (%s%s)\n",
 483                           argv[optind], (optind == argc - 1) ? "" : " ...");
 484           break;
 485         }
 486     if (batch)
 487       quiet = 1;
 488   }
 489
 490 #if defined(TUI)
 491   /* Should this be moved to tui-top.c:_initialize_tui()? */
 492   if (tui_version)
 493     init_ui_hook = tuiInit;
 494 #endif
 495
 496   /* Initialize all files.  Give the interpreter a chance to take
 497      control of the console via the init_ui_hook()) */
 498   gdb_init (argv[0]);
 499
 500   /* Do these (and anything which might call wrap_here or *_filtered)
 501      after initialize_all_files.  */
 502   if (print_version)
 503     {
 504       print_gdb_version (gdb_stdout);
 505       wrap_here ("");
 506       printf_filtered ("\n");
 507       exit (0);
 508     }
 509
 510   if (print_help)
 511     {
 512       print_gdb_help (gdb_stdout);
 513       fputs_unfiltered ("\n", gdb_stdout);
 514       exit (0);
 515     }
 516
 517   if (!quiet)
 518     {
 519       /* Print all the junk at the top, with trailing "..." if we are about
 520          to read a symbol file (possibly slowly).  */
 521       print_gdb_version (gdb_stdout);
 522       if (symarg)
 523         printf_filtered ("..");
 524       wrap_here ("");
 525       gdb_flush (gdb_stdout);   /* Force to screen during slow operations */
 526     }
 527
 528   error_pre_print = "\n\n";
 529   quit_pre_print = error_pre_print;
 530
 531   /* We may get more than one warning, don't double space all of them... */
 532   warning_pre_print = "\nwarning: ";
 533
 534   /* Read and execute $HOME/.gdbinit file, if it exists.  This is done
 535      *before* all the command line arguments are processed; it sets
 536      global parameters, which are independent of what file you are
 537      debugging or what directory you are in.  */
 538 #ifdef __CYGWIN32__
 539   {
 540     char *tmp = getenv ("HOME");
 541
 542     if (tmp != NULL)
 543       {
 544         homedir = (char *) alloca (MAX_PATH + 1);
 545         cygwin32_conv_to_posix_path (tmp, homedir);
 546       }
 547     else
 548       homedir = NULL;
 549   }
 550 #else
 551   homedir = getenv ("HOME");
 552 #endif
 553   if (homedir)
 554     {
 555       homeinit = (char *) alloca (strlen (homedir) +
 556                                   strlen (gdbinit) + 10);
 557       strcpy (homeinit, homedir);
 558       strcat (homeinit, "/");
 559       strcat (homeinit, gdbinit);
 560
 561       if (!inhibit_gdbinit)
 562         {
 563           catch_command_errors (source_command, homeinit, 0, RETURN_MASK_ALL);
 564         }
 565
 566       /* Do stats; no need to do them elsewhere since we'll only
 567          need them if homedir is set.  Make sure that they are
 568          zero in case one of them fails (this guarantees that they
 569          won't match if either exists).  */
 570
 571       memset (&homebuf, 0, sizeof (struct stat));
 572       memset (&cwdbuf, 0, sizeof (struct stat));
 573
 574       stat (homeinit, &homebuf);
 575       stat (gdbinit, &cwdbuf);  /* We'll only need this if
 576                                    homedir was set.  */
 577     }
 578
 579   /* Now perform all the actions indicated by the arguments.  */
 580   if (cdarg != NULL)
 581     {
 582       catch_command_errors (cd_command, cdarg, 0, RETURN_MASK_ALL);
 583     }
 584
 585   for (i = 0; i < ndir; i++)
 586     catch_command_errors (directory_command, dirarg[i], 0, RETURN_MASK_ALL);
 587   xfree (dirarg);
 588
 589   if (execarg != NULL
 590       && symarg != NULL
 591       && STREQ (execarg, symarg))
 592     {
 593       /* The exec file and the symbol-file are the same.  If we can't
 594          open it, better only print one error message.
 595          catch_command_errors returns non-zero on success! */
 596       if (catch_command_errors (exec_file_attach, execarg, !batch, RETURN_MASK_ALL))
 597         catch_command_errors (symbol_file_add_main, symarg, 0, RETURN_MASK_ALL);
 598     }
 599   else
 600     {
 601       if (execarg != NULL)
 602         catch_command_errors (exec_file_attach, execarg, !batch, RETURN_MASK_ALL);
 603       if (symarg != NULL)
 604         catch_command_errors (symbol_file_add_main, symarg, 0, RETURN_MASK_ALL);
 605     }
 606
 607   /* After the symbol file has been read, print a newline to get us
 608      beyond the copyright line...  But errors should still set off
 609      the error message with a (single) blank line.  */
 610   if (!quiet)
 611     printf_filtered ("\n");
 612   error_pre_print = "\n";
 613   quit_pre_print = error_pre_print;
 614   warning_pre_print = "\nwarning: ";
 615
 616   if (corearg != NULL)
 617     {
 618       if (catch_command_errors (core_file_command, corearg, !batch, RETURN_MASK_ALL) == 0)
 619         {
 620           /* See if the core file is really a PID. */
 621           if (isdigit (corearg[0]))
 622             catch_command_errors (attach_command, corearg, !batch, RETURN_MASK_ALL);
 623         }
 624     }
 625
 626   if (ttyarg != NULL)
 627     catch_command_errors (tty_command, ttyarg, !batch, RETURN_MASK_ALL);
 628
 629 #ifdef ADDITIONAL_OPTION_HANDLER
 630   ADDITIONAL_OPTION_HANDLER;
 631 #endif
 632
 633   /* Error messages should no longer be distinguished with extra output. */
 634   error_pre_print = NULL;
 635   quit_pre_print = NULL;
 636   warning_pre_print = "warning: ";
 637
 638   /* Read the .gdbinit file in the current directory, *if* it isn't
 639      the same as the $HOME/.gdbinit file (it should exist, also).  */
 640
 641   if (!homedir
 642       || memcmp ((char *) &homebuf, (char *) &cwdbuf, sizeof (struct stat)))
 643     if (!inhibit_gdbinit)
 644       {
 645         catch_command_errors (source_command, gdbinit, 0, RETURN_MASK_ALL);
 646       }
 647
 648   for (i = 0; i < ncmd; i++)
 649     {
 650 #if 0
 651       /* NOTE: cagney/1999-11-03: SET_TOP_LEVEL() was a macro that
 652          expanded into a call to setjmp().  */
 653       if (!SET_TOP_LEVEL ()) /* NB: This is #if 0'd out */
 654         {
 655           /* NOTE: I am commenting this out, because it is not clear
 656              where this feature is used. It is very old and
 657              undocumented. ezannoni: 1999-05-04 */
 658 #if 0
 659           if (cmdarg[i][0] == '-' && cmdarg[i][1] == '\0')
 660             read_command_file (stdin);
 661           else
 662 #endif
 663             source_command (cmdarg[i], !batch);
 664           do_cleanups (ALL_CLEANUPS);
 665         }
 666 #endif
 667       catch_command_errors (source_command, cmdarg[i], !batch, RETURN_MASK_ALL);
 668     }
 669   xfree (cmdarg);
 670
 671   /* Read in the old history after all the command files have been read. */
 672   init_history ();
 673
 674   if (batch)
 675     {
 676       /* We have hit the end of the batch file.  */
 677       exit (0);
 678     }
 679
 680   /* Do any host- or target-specific hacks.  This is used for i960 targets
 681      to force the user to set a nindy target and spec its parameters.  */
 682
 683 #ifdef BEFORE_MAIN_LOOP_HOOK
 684   BEFORE_MAIN_LOOP_HOOK;
 685 #endif
 686
 687   END_PROGRESS (argv[0]);
 688
 689   /* Show time and/or space usage.  */
 690
 691   if (display_time)
 692     {
 693       long init_time = get_run_time () - time_at_startup;
 694
 695       printf_unfiltered ("Startup time: %ld.%06ld\n",
 696                          init_time / 1000000, init_time % 1000000);
 697     }
 698
 699   if (display_space)
 700     {
 701 #ifdef HAVE_SBRK
 702       extern char **environ;
 703       char *lim = (char *) sbrk (0);
 704
 705       printf_unfiltered ("Startup size: data size %ld\n",
 706                          (long) (lim - (char *) &environ));
 707 #endif
 708     }
 709
 710   /* The default command loop.
 711      The WIN32 Gui calls this main to set up gdb's state, and
 712      has its own command loop. */
 713 #if !defined _WIN32 || defined __GNUC__
 714   /* GUIs generally have their own command loop, mainloop, or
 715      whatever.  This is a good place to gain control because many
 716      error conditions will end up here via longjmp(). */
 717 #if 0
 718   /* FIXME: cagney/1999-11-06: The original main loop was like: */
 719   while (1)
 720     {
 721       if (!SET_TOP_LEVEL ())
 722         {
 723           do_cleanups (ALL_CLEANUPS);   /* Do complete cleanup */
 724           /* GUIs generally have their own command loop, mainloop, or whatever.
 725              This is a good place to gain control because many error
 726              conditions will end up here via longjmp(). */
 727           if (command_loop_hook)
 728             command_loop_hook ();
 729           else
 730             command_loop ();
 731           quit_command ((char *) 0, instream == stdin);
 732         }
 733     }
 734   /* NOTE: If the command_loop() returned normally, the loop would
 735      attempt to exit by calling the function quit_command().  That
 736      function would either call exit() or throw an error returning
 737      control to SET_TOP_LEVEL. */
 738   /* NOTE: The function do_cleanups() was called once each time round
 739      the loop.  The usefulness of the call isn't clear.  If an error
 740      was thrown, everything would have already been cleaned up.  If
 741      command_loop() returned normally and quit_command() was called,
 742      either exit() or error() (again cleaning up) would be called. */
 743 #endif
 744   /* NOTE: cagney/1999-11-07: There is probably no reason for not
 745      moving this loop and the code found in captured_command_loop()
 746      into the command_loop() proper.  The main thing holding back that
 747      change - SET_TOP_LEVEL() - has been eliminated. */
 748   while (1)
 749     {
 750       catch_errors (captured_command_loop, 0, "", RETURN_MASK_ALL);
 751     }
 752 #endif
 753   /* No exit -- exit is through quit_command.  */
 754 }
 755
 756 int
 757 main (int argc, char **argv)
 758 {
 759   struct captured_main_args args;
 760   args.argc = argc;
 761   args.argv = argv;
 762   catch_errors (captured_main, &args, "", RETURN_MASK_ALL);
 763   return 0;
 764 }
 765
 766
 767 /* Don't use *_filtered for printing help.  We don't want to prompt
 768    for continue no matter how small the screen or how much we're going
 769    to print.  */
 770
 771 static void
 772 print_gdb_help (struct ui_file *stream)
 773 {
 774   fputs_unfiltered ("\
 775 This is the GNU debugger.  Usage:\n\n\
 776     gdb [options] [executable-file [core-file or process-id]]\n\n\
 777 Options:\n\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 ", stream);
 789   fputs_unfiltered ("\
 790   --dbx              DBX compatibility mode.\n\
 791   --directory=DIR    Search for source files in DIR.\n\
 792   --epoch            Output information used by epoch emacs-GDB interface.\n\
 793   --exec=EXECFILE    Use EXECFILE as the executable.\n\
 794   --fullname         Output information used by emacs-GDB interface.\n\
 795   --help             Print this message.\n\
 796 ", stream);
 797   fputs_unfiltered ("\
 798   --interpreter=INTERP\n\
 799                      Select a specific interpreter / user interface\n\
 800 ", stream);
 801   fputs_unfiltered ("\
 802   --mapped           Use mapped symbol files if supported on this system.\n\
 803   --nw               Do not use a window interface.\n\
 804   --nx               Do not read ", stream);
 805   fputs_unfiltered (gdbinit, stream);
 806   fputs_unfiltered (" file.\n\
 807   --quiet            Do not print version number on startup.\n\
 808   --readnow          Fully read symbol files on first access.\n\
 809 ", stream);
 810   fputs_unfiltered ("\
 811   --se=FILE          Use FILE as symbol file and executable file.\n\
 812   --symbols=SYMFILE  Read symbols from SYMFILE.\n\
 813   --tty=TTY          Use TTY for input/output by the program being debugged.\n\
 814 ", stream);
 815 #if defined(TUI)
 816   fputs_unfiltered ("\
 817   --tui              Use a terminal user interface.\n\
 818 ", stream);
 819 #endif
 820   fputs_unfiltered ("\
 821   --version          Print version information and then exit.\n\
 822   -w                 Use a window interface.\n\
 823   --write            Set writing into executable and core files.\n\
 824   --xdb              XDB compatibility mode.\n\
 825 ", stream);
 826 #ifdef ADDITIONAL_OPTION_HELP
 827   fputs_unfiltered (ADDITIONAL_OPTION_HELP, stream);
 828 #endif
 829   fputs_unfiltered ("\n\
 830 For more information, type \"help\" from within GDB, or consult the\n\
 831 GDB manual (available as on-line info or a printed manual).\n\
 832 Report bugs to \"bug-gdb@gnu.org\".\
 833 ", stream);
 834 }