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