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