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