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 int enable_external_editor;
  85 extern char *external_editor_command;
  86
  87 /* Call command_loop.  If it happens to return, pass that through as a
  88    non-zero return status. */
  89
  90 static int
  91 captured_command_loop (void *data)
  92 {
  93   if (command_loop_hook == NULL)
  94     command_loop ();
  95   else
  96     command_loop_hook ();
  97   /* FIXME: cagney/1999-11-05: A correct command_loop() implementaton
  98      would clean things up (restoring the cleanup chain) to the state
  99      they were just prior to the call.  Technically, this means that
 100      the do_cleanups() below is redundant.  Unfortunately, many FUNCs
 101      are not that well behaved.  do_cleanups should either be replaced
 102      with a do_cleanups call (to cover the problem) or an assertion
 103      check to detect bad FUNCs code. */
 104   do_cleanups (ALL_CLEANUPS);
 105   /* If the command_loop returned, normally (rather than threw an
 106      error) we try to quit. If the quit is aborted, catch_errors()
 107      which called this catch the signal and restart the command
 108      loop. */
 109   quit_command (NULL, instream == stdin);
 110   return 1;
 111 }
 112
 113 struct captured_main_args
 114   {
 115     int argc;
 116     char **argv;
 117   };
 118
 119 static int
 120 captured_main (void *data)
 121 {
 122   struct captured_main_args *context = data;
 123   int argc = context->argc;
 124   char **argv = context->argv;
 125   int count;
 126   static int quiet = 0;
 127   static int batch = 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 /* Allow machine descriptions to add more options... */
 268 #ifdef ADDITIONAL_OPTIONS
 269       ADDITIONAL_OPTIONS
 270 #endif
 271       {0, no_argument, 0, 0}
 272     };
 273
 274     while (1)
 275       {
 276         int option_index;
 277
 278         c = getopt_long_only (argc, argv, "",
 279                               long_options, &option_index);
 280         if (c == EOF)
 281           break;
 282
 283         /* Long option that takes an argument.  */
 284         if (c == 0 && long_options[option_index].flag == 0)
 285           c = long_options[option_index].val;
 286
 287         switch (c)
 288           {
 289           case 0:
 290             /* Long option that just sets a flag.  */
 291             break;
 292           case 10:
 293             symarg = optarg;
 294             execarg = optarg;
 295             break;
 296           case 11:
 297             cdarg = optarg;
 298             break;
 299           case 12:
 300             /* FIXME: what if the syntax is wrong (e.g. not digits)?  */
 301             annotation_level = atoi (optarg);
 302             break;
 303           case 13:
 304             /* Enable the display of both time and space usage.  */
 305             display_time = 1;
 306             display_space = 1;
 307             break;
 308           case 'f':
 309             annotation_level = 1;
 310 /* We have probably been invoked from emacs.  Disable window interface.  */
 311             use_windows = 0;
 312             break;
 313           case 's':
 314             symarg = optarg;
 315             break;
 316           case 'e':
 317             execarg = optarg;
 318             break;
 319           case 'c':
 320             corearg = optarg;
 321             break;
 322           case 'x':
 323             cmdarg[ncmd++] = optarg;
 324             if (ncmd >= cmdsize)
 325               {
 326                 cmdsize *= 2;
 327                 cmdarg = (char **) xrealloc ((char *) cmdarg,
 328                                              cmdsize * sizeof (*cmdarg));
 329               }
 330             break;
 331 #ifdef GDBTK
 332           case 'z':
 333             {
 334 extern int gdbtk_test (char *);
 335               if (!gdbtk_test (optarg))
 336                 {
 337                   fprintf_unfiltered (gdb_stderr, "%s: unable to load tclcommand file \"%s\"",
 338                                       argv[0], optarg);
 339                   exit (1);
 340                 }
 341               break;
 342             }
 343           case 'y':
 344             {
 345               /*
 346                * This enables the edit/button in the main window, even
 347                * when IDE_ENABLED is set to false. In this case you must
 348                * use --tclcommand to specify a tcl/script to be called,
 349                * Tcl/Variable to store the edit/command is:
 350                * external_editor
 351                */
 352               enable_external_editor = 1;
 353               break;
 354             }
 355           case 'w':
 356             {
 357               /*
 358                * if editor command is enabled, both flags are set
 359                */
 360               enable_external_editor = 1;
 361               external_editor_command = xstrdup (optarg);
 362               break;
 363             }
 364 #endif /* GDBTK */
 365 #ifdef UI_OUT
 366           case 'i':
 367             interpreter_p = optarg;
 368             break;
 369 #endif
 370           case 'd':
 371             dirarg[ndir++] = optarg;
 372             if (ndir >= dirsize)
 373               {
 374                 dirsize *= 2;
 375                 dirarg = (char **) xrealloc ((char *) dirarg,
 376                                              dirsize * sizeof (*dirarg));
 377               }
 378             break;
 379           case 't':
 380             ttyarg = optarg;
 381             break;
 382           case 'q':
 383             quiet = 1;
 384             break;
 385           case 'b':
 386             {
 387               int i;
 388               char *p;
 389
 390               i = strtol (optarg, &p, 0);
 391               if (i == 0 && p == optarg)
 392
 393                 /* Don't use *_filtered or warning() (which relies on
 394                    current_target) until after initialize_all_files(). */
 395
 396                 fprintf_unfiltered
 397                   (gdb_stderr,
 398                    "warning: could not set baud rate to `%s'.\n", optarg);
 399               else
 400                 baud_rate = i;
 401             }
 402           case 'l':
 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 timeout limit to `%s'.\n", optarg);
 416               else
 417                 remote_timeout = i;
 418             }
 419             break;
 420
 421 #ifdef ADDITIONAL_OPTION_CASES
 422             ADDITIONAL_OPTION_CASES
 423 #endif
 424           case '?':
 425             fprintf_unfiltered (gdb_stderr,
 426                         "Use `%s --help' for a complete list of options.\n",
 427                                 argv[0]);
 428             exit (1);
 429           }
 430       }
 431
 432     /* If --help or --version, disable window interface.  */
 433     if (print_help || print_version)
 434       {
 435         use_windows = 0;
 436 #ifdef TUI
 437         /* Disable the TUI as well.  */
 438         tui_version = 0;
 439 #endif
 440       }
 441
 442 #ifdef TUI
 443     /* An explicit --tui flag overrides the default UI, which is the
 444        window system.  */
 445     if (tui_version)
 446       use_windows = 0;
 447 #endif
 448
 449     /* OK, that's all the options.  The other arguments are filenames.  */
 450     count = 0;
 451     for (; optind < argc; optind++)
 452       switch (++count)
 453         {
 454         case 1:
 455           symarg = argv[optind];
 456           execarg = argv[optind];
 457           break;
 458         case 2:
 459           /* FIXME: The documentation says this can be a "ProcID". as well. */
 460           corearg = argv[optind];
 461           break;
 462         case 3:
 463           fprintf_unfiltered (gdb_stderr,
 464                           "Excess command line arguments ignored. (%s%s)\n",
 465                           argv[optind], (optind == argc - 1) ? "" : " ...");
 466           break;
 467         }
 468     if (batch)
 469       quiet = 1;
 470   }
 471
 472   /* Initialize all files.  Give the interpreter a chance to take
 473      control of the console via the init_ui_hook()) */
 474   gdb_init (argv[0]);
 475
 476   /* Do these (and anything which might call wrap_here or *_filtered)
 477      after initialize_all_files.  */
 478   if (print_version)
 479     {
 480       print_gdb_version (gdb_stdout);
 481       wrap_here ("");
 482       printf_filtered ("\n");
 483       exit (0);
 484     }
 485
 486   if (print_help)
 487     {
 488       print_gdb_help (gdb_stdout);
 489       fputs_unfiltered ("\n", gdb_stdout);
 490       exit (0);
 491     }
 492
 493   if (!quiet)
 494     {
 495       /* Print all the junk at the top, with trailing "..." if we are about
 496          to read a symbol file (possibly slowly).  */
 497       print_gdb_version (gdb_stdout);
 498       if (symarg)
 499         printf_filtered ("..");
 500       wrap_here ("");
 501       gdb_flush (gdb_stdout);   /* Force to screen during slow operations */
 502     }
 503
 504   error_pre_print = "\n\n";
 505   quit_pre_print = error_pre_print;
 506
 507   /* We may get more than one warning, don't double space all of them... */
 508   warning_pre_print = "\nwarning: ";
 509
 510   /* Read and execute $HOME/.gdbinit file, if it exists.  This is done
 511      *before* all the command line arguments are processed; it sets
 512      global parameters, which are independent of what file you are
 513      debugging or what directory you are in.  */
 514   homedir = getenv ("HOME");
 515   if (homedir)
 516     {
 517       homeinit = (char *) alloca (strlen (homedir) +
 518                                   strlen (gdbinit) + 10);
 519       strcpy (homeinit, homedir);
 520       strcat (homeinit, "/");
 521       strcat (homeinit, gdbinit);
 522
 523       if (!inhibit_gdbinit)
 524         {
 525           catch_command_errors (source_command, homeinit, 0, RETURN_MASK_ALL);
 526         }
 527
 528       /* Do stats; no need to do them elsewhere since we'll only
 529          need them if homedir is set.  Make sure that they are
 530          zero in case one of them fails (this guarantees that they
 531          won't match if either exists).  */
 532
 533       memset (&homebuf, 0, sizeof (struct stat));
 534       memset (&cwdbuf, 0, sizeof (struct stat));
 535
 536       stat (homeinit, &homebuf);
 537       stat (gdbinit, &cwdbuf);  /* We'll only need this if
 538                                    homedir was set.  */
 539     }
 540
 541   /* Now perform all the actions indicated by the arguments.  */
 542   if (cdarg != NULL)
 543     {
 544       catch_command_errors (cd_command, cdarg, 0, RETURN_MASK_ALL);
 545     }
 546
 547   for (i = 0; i < ndir; i++)
 548     catch_command_errors (directory_command, dirarg[i], 0, RETURN_MASK_ALL);
 549   xfree (dirarg);
 550
 551   if (execarg != NULL
 552       && symarg != NULL
 553       && STREQ (execarg, symarg))
 554     {
 555       /* The exec file and the symbol-file are the same.  If we can't
 556          open it, better only print one error message.
 557          catch_command_errors returns non-zero on success! */
 558       if (catch_command_errors (exec_file_attach, execarg, !batch, RETURN_MASK_ALL))
 559         catch_command_errors (symbol_file_add_main, symarg, 0, RETURN_MASK_ALL);
 560     }
 561   else
 562     {
 563       if (execarg != NULL)
 564         catch_command_errors (exec_file_attach, execarg, !batch, RETURN_MASK_ALL);
 565       if (symarg != NULL)
 566         catch_command_errors (symbol_file_add_main, symarg, 0, RETURN_MASK_ALL);
 567     }
 568
 569   /* After the symbol file has been read, print a newline to get us
 570      beyond the copyright line...  But errors should still set off
 571      the error message with a (single) blank line.  */
 572   if (!quiet)
 573     printf_filtered ("\n");
 574   error_pre_print = "\n";
 575   quit_pre_print = error_pre_print;
 576   warning_pre_print = "\nwarning: ";
 577
 578   if (corearg != NULL)
 579     {
 580       if (catch_command_errors (core_file_command, corearg, !batch, RETURN_MASK_ALL) == 0)
 581         {
 582           /* See if the core file is really a PID. */
 583           if (isdigit (corearg[0]))
 584             catch_command_errors (attach_command, corearg, !batch, RETURN_MASK_ALL);
 585         }
 586     }
 587
 588   if (ttyarg != NULL)
 589     catch_command_errors (tty_command, ttyarg, !batch, RETURN_MASK_ALL);
 590
 591 #ifdef ADDITIONAL_OPTION_HANDLER
 592   ADDITIONAL_OPTION_HANDLER;
 593 #endif
 594
 595   /* Error messages should no longer be distinguished with extra output. */
 596   error_pre_print = NULL;
 597   quit_pre_print = NULL;
 598   warning_pre_print = "warning: ";
 599
 600   /* Read the .gdbinit file in the current directory, *if* it isn't
 601      the same as the $HOME/.gdbinit file (it should exist, also).  */
 602
 603   if (!homedir
 604       || memcmp ((char *) &homebuf, (char *) &cwdbuf, sizeof (struct stat)))
 605     if (!inhibit_gdbinit)
 606       {
 607         catch_command_errors (source_command, gdbinit, 0, RETURN_MASK_ALL);
 608       }
 609
 610   for (i = 0; i < ncmd; i++)
 611     {
 612 #if 0
 613       /* NOTE: cagney/1999-11-03: SET_TOP_LEVEL() was a macro that
 614          expanded into a call to setjmp().  */
 615       if (!SET_TOP_LEVEL ()) /* NB: This is #if 0'd out */
 616         {
 617           /* NOTE: I am commenting this out, because it is not clear
 618              where this feature is used. It is very old and
 619              undocumented. ezannoni: 1999-05-04 */
 620 #if 0
 621           if (cmdarg[i][0] == '-' && cmdarg[i][1] == '\0')
 622             read_command_file (stdin);
 623           else
 624 #endif
 625             source_command (cmdarg[i], !batch);
 626           do_cleanups (ALL_CLEANUPS);
 627         }
 628 #endif
 629       catch_command_errors (source_command, cmdarg[i], !batch, RETURN_MASK_ALL);
 630     }
 631   xfree (cmdarg);
 632
 633   /* Read in the old history after all the command files have been read. */
 634   init_history ();
 635
 636   if (batch)
 637     {
 638       /* We have hit the end of the batch file.  */
 639       exit (0);
 640     }
 641
 642   /* Do any host- or target-specific hacks.  This is used for i960 targets
 643      to force the user to set a nindy target and spec its parameters.  */
 644
 645 #ifdef BEFORE_MAIN_LOOP_HOOK
 646   BEFORE_MAIN_LOOP_HOOK;
 647 #endif
 648
 649   END_PROGRESS (argv[0]);
 650
 651   /* Show time and/or space usage.  */
 652
 653   if (display_time)
 654     {
 655       long init_time = get_run_time () - time_at_startup;
 656
 657       printf_unfiltered ("Startup time: %ld.%06ld\n",
 658                          init_time / 1000000, init_time % 1000000);
 659     }
 660
 661   if (display_space)
 662     {
 663 #ifdef HAVE_SBRK
 664       extern char **environ;
 665       char *lim = (char *) sbrk (0);
 666
 667       printf_unfiltered ("Startup size: data size %ld\n",
 668                          (long) (lim - (char *) &environ));
 669 #endif
 670     }
 671
 672 #if 0
 673   /* FIXME: cagney/1999-11-06: The original main loop was like: */
 674   while (1)
 675     {
 676       if (!SET_TOP_LEVEL ())
 677         {
 678           do_cleanups (ALL_CLEANUPS);   /* Do complete cleanup */
 679           /* GUIs generally have their own command loop, mainloop, or whatever.
 680              This is a good place to gain control because many error
 681              conditions will end up here via longjmp(). */
 682           if (command_loop_hook)
 683             command_loop_hook ();
 684           else
 685             command_loop ();
 686           quit_command ((char *) 0, instream == stdin);
 687         }
 688     }
 689   /* NOTE: If the command_loop() returned normally, the loop would
 690      attempt to exit by calling the function quit_command().  That
 691      function would either call exit() or throw an error returning
 692      control to SET_TOP_LEVEL. */
 693   /* NOTE: The function do_cleanups() was called once each time round
 694      the loop.  The usefulness of the call isn't clear.  If an error
 695      was thrown, everything would have already been cleaned up.  If
 696      command_loop() returned normally and quit_command() was called,
 697      either exit() or error() (again cleaning up) would be called. */
 698 #endif
 699   /* NOTE: cagney/1999-11-07: There is probably no reason for not
 700      moving this loop and the code found in captured_command_loop()
 701      into the command_loop() proper.  The main thing holding back that
 702      change - SET_TOP_LEVEL() - has been eliminated. */
 703   while (1)
 704     {
 705       catch_errors (captured_command_loop, 0, "", RETURN_MASK_ALL);
 706     }
 707   /* No exit -- exit is through quit_command.  */
 708 }
 709
 710 int
 711 main (int argc, char **argv)
 712 {
 713   struct captured_main_args args;
 714   args.argc = argc;
 715   args.argv = argv;
 716   catch_errors (captured_main, &args, "", RETURN_MASK_ALL);
 717   return 0;
 718 }
 719
 720
 721 /* Don't use *_filtered for printing help.  We don't want to prompt
 722    for continue no matter how small the screen or how much we're going
 723    to print.  */
 724
 725 static void
 726 print_gdb_help (struct ui_file *stream)
 727 {
 728   fputs_unfiltered ("\
 729 This is the GNU debugger.  Usage:\n\n\
 730     gdb [options] [executable-file [core-file or process-id]]\n\n\
 731 Options:\n\n\
 732 ", stream);
 733   fputs_unfiltered ("\
 734   --[no]async        Enable (disable) asynchronous version of CLI\n\
 735 ", stream);
 736   fputs_unfiltered ("\
 737   -b BAUDRATE        Set serial port baud rate used for remote debugging.\n\
 738   --batch            Exit after processing options.\n\
 739   --cd=DIR           Change current directory to DIR.\n\
 740   --command=FILE     Execute GDB commands from FILE.\n\
 741   --core=COREFILE    Analyze the core dump COREFILE.\n\
 742 ", stream);
 743   fputs_unfiltered ("\
 744   --dbx              DBX compatibility mode.\n\
 745   --directory=DIR    Search for source files in DIR.\n\
 746   --epoch            Output information used by epoch emacs-GDB interface.\n\
 747   --exec=EXECFILE    Use EXECFILE as the executable.\n\
 748   --fullname         Output information used by emacs-GDB interface.\n\
 749   --help             Print this message.\n\
 750 ", stream);
 751   fputs_unfiltered ("\
 752   --interpreter=INTERP\n\
 753                      Select a specific interpreter / user interface\n\
 754 ", stream);
 755   fputs_unfiltered ("\
 756   --mapped           Use mapped symbol files if supported on this system.\n\
 757   --nw               Do not use a window interface.\n\
 758   --nx               Do not read ", stream);
 759   fputs_unfiltered (gdbinit, stream);
 760   fputs_unfiltered (" file.\n\
 761   --quiet            Do not print version number on startup.\n\
 762   --readnow          Fully read symbol files on first access.\n\
 763 ", stream);
 764   fputs_unfiltered ("\
 765   --se=FILE          Use FILE as symbol file and executable file.\n\
 766   --symbols=SYMFILE  Read symbols from SYMFILE.\n\
 767   --tty=TTY          Use TTY for input/output by the program being debugged.\n\
 768 ", stream);
 769 #if defined(TUI)
 770   fputs_unfiltered ("\
 771   --tui              Use a terminal user interface.\n\
 772 ", stream);
 773 #endif
 774   fputs_unfiltered ("\
 775   --version          Print version information and then exit.\n\
 776   -w                 Use a window interface.\n\
 777   --write            Set writing into executable and core files.\n\
 778   --xdb              XDB compatibility mode.\n\
 779 ", stream);
 780 #ifdef ADDITIONAL_OPTION_HELP
 781   fputs_unfiltered (ADDITIONAL_OPTION_HELP, stream);
 782 #endif
 783   fputs_unfiltered ("\n\
 784 For more information, type \"help\" from within GDB, or consult the\n\
 785 GDB manual (available as on-line info or a printed manual).\n\
 786 Report bugs to \"bug-gdb@gnu.org\".\
 787 ", stream);
 788 }