gdb/main.c

   1 /* Top level stuff for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
   4    1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007
   5    Free Software Foundation, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  22    Boston, MA 02110-1301, USA.  */
  23
  24 #include "defs.h"
  25 #include "top.h"
  26 #include "target.h"
  27 #include "inferior.h"
  28 #include "symfile.h"
  29 #include "gdbcore.h"
  30
  31 #include "exceptions.h"
  32 #include "getopt.h"
  33
  34 #include <sys/types.h>
  35 #include "gdb_stat.h"
  36 #include <ctype.h>
  37
  38 #include "gdb_string.h"
  39 #include "event-loop.h"
  40 #include "ui-out.h"
  41
  42 #include "interps.h"
  43 #include "main.h"
  44
  45 /* If nonzero, display time usage both at startup and for each command.  */
  46
  47 int display_time;
  48
  49 /* If nonzero, display space usage both at startup and for each command.  */
  50
  51 int display_space;
  52
  53 /* The selected interpreter.  This will be used as a set command
  54    variable, so it should always be malloc'ed - since
  55    do_setshow_command will free it. */
  56 char *interpreter_p;
  57
  58 /* Whether xdb commands will be handled */
  59 int xdb_commands = 0;
  60
  61 /* Whether dbx commands will be handled */
  62 int dbx_commands = 0;
  63
  64 /* System root path, used to find libraries etc.  */
  65 char *gdb_sysroot = 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_stdin;
  71 /* target IO streams */
  72 struct ui_file *gdb_stdtargin;
  73 struct ui_file *gdb_stdtarg;
  74 struct ui_file *gdb_stdtargerr;
  75
  76 /* Support for the --batch-silent option.  */
  77 int batch_silent = 0;
  78
  79 /* Support for --return-child-result option.
  80    Set the default to -1 to return error in the case
  81    that the program does not run or does not complete.  */
  82 int return_child_result = 0;
  83 int return_child_result_value = -1;
  84
  85 /* Whether to enable writing into executable and core files */
  86 extern int write_files;
  87
  88 static void print_gdb_help (struct ui_file *);
  89
  90 /* These two are used to set the external editor commands when gdb is farming
  91    out files to be edited by another program. */
  92
  93 extern char *external_editor_command;
  94
  95 /* Call command_loop.  If it happens to return, pass that through as a
  96    non-zero return status. */
  97
  98 static int
  99 captured_command_loop (void *data)
 100 {
 101   current_interp_command_loop ();
 102   /* FIXME: cagney/1999-11-05: A correct command_loop() implementaton
 103      would clean things up (restoring the cleanup chain) to the state
 104      they were just prior to the call.  Technically, this means that
 105      the do_cleanups() below is redundant.  Unfortunately, many FUNCs
 106      are not that well behaved.  do_cleanups should either be replaced
 107      with a do_cleanups call (to cover the problem) or an assertion
 108      check to detect bad FUNCs code. */
 109   do_cleanups (ALL_CLEANUPS);
 110   /* If the command_loop returned, normally (rather than threw an
 111      error) we try to quit. If the quit is aborted, catch_errors()
 112      which called this catch the signal and restart the command
 113      loop. */
 114   quit_command (NULL, instream == stdin);
 115   return 1;
 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   struct cmdarg {
 142     enum {
 143       CMDARG_FILE,
 144       CMDARG_COMMAND
 145     } type;
 146     char *string;
 147   } *cmdarg;
 148   /* Allocated size of cmdarg.  */
 149   int cmdsize;
 150   /* Number of elements of cmdarg used.  */
 151   int ncmd;
 152
 153   /* Indices of all arguments of --directory option.  */
 154   char **dirarg;
 155   /* Allocated size.  */
 156   int dirsize;
 157   /* Number of elements used.  */
 158   int ndir;
 159
 160   struct stat homebuf, cwdbuf;
 161   char *homedir;
 162
 163   int i;
 164
 165   long time_at_startup = get_run_time ();
 166
 167 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
 168   setlocale (LC_MESSAGES, "");
 169 #endif
 170 #if defined (HAVE_SETLOCALE)
 171   setlocale (LC_CTYPE, "");
 172 #endif
 173   bindtextdomain (PACKAGE, LOCALEDIR);
 174   textdomain (PACKAGE);
 175
 176 #ifdef HAVE_SBRK
 177   lim_at_start = (char *) sbrk (0);
 178 #endif
 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 = (struct cmdarg *) 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   gdb_stdout = stdio_fileopen (stdout);
 202   gdb_stderr = stdio_fileopen (stderr);
 203   gdb_stdlog = gdb_stderr;      /* for moment */
 204   gdb_stdtarg = gdb_stderr;     /* for moment */
 205   gdb_stdin = stdio_fileopen (stdin);
 206   gdb_stdtargerr = gdb_stderr;  /* for moment */
 207   gdb_stdtargin = gdb_stdin;    /* for moment */
 208
 209   /* Set the sysroot path.  */
 210 #ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
 211   gdb_sysroot = make_relative_prefix (argv[0], BINDIR, TARGET_SYSTEM_ROOT);
 212   if (gdb_sysroot)
 213     {
 214       struct stat s;
 215       int res = 0;
 216
 217       if (stat (gdb_sysroot, &s) == 0)
 218         if (S_ISDIR (s.st_mode))
 219           res = 1;
 220
 221       if (res == 0)
 222         {
 223           xfree (gdb_sysroot);
 224           gdb_sysroot = xstrdup (TARGET_SYSTEM_ROOT);
 225         }
 226     }
 227   else
 228     gdb_sysroot = xstrdup (TARGET_SYSTEM_ROOT);
 229 #else
 230   gdb_sysroot = xstrdup (TARGET_SYSTEM_ROOT);
 231 #endif
 232
 233   /* Canonicalize the sysroot path.  */
 234   if (*gdb_sysroot)
 235     {
 236       char *canon_sysroot = lrealpath (gdb_sysroot);
 237       if (canon_sysroot)
 238         {
 239           xfree (gdb_sysroot);
 240           gdb_sysroot = canon_sysroot;
 241         }
 242     }
 243
 244 #ifdef DEBUGDIR_RELOCATABLE
 245   debug_file_directory = make_relative_prefix (argv[0], BINDIR, DEBUGDIR);
 246   if (debug_file_directory)
 247     {
 248       struct stat s;
 249       int res = 0;
 250
 251       if (stat (debug_file_directory, &s) == 0)
 252         if (S_ISDIR (s.st_mode))
 253           res = 1;
 254
 255       if (res == 0)
 256         {
 257           xfree (debug_file_directory);
 258           debug_file_directory = xstrdup (DEBUGDIR);
 259         }
 260     }
 261   else
 262     debug_file_directory = xstrdup (DEBUGDIR);
 263 #else
 264   debug_file_directory = xstrdup (DEBUGDIR);
 265 #endif
 266
 267   /* Canonicalize the debugfile path.  */
 268   if (*debug_file_directory)
 269     {
 270       char *canon_debug = lrealpath (debug_file_directory);
 271       if (canon_debug)
 272         {
 273           xfree (debug_file_directory);
 274           debug_file_directory = canon_debug;
 275         }
 276     }
 277
 278   /* There will always be an interpreter.  Either the one passed into
 279      this captured main, or one specified by the user at start up, or
 280      the console.  Initialize the interpreter to the one requested by
 281      the application.  */
 282   interpreter_p = xstrdup (context->interpreter_p);
 283
 284   /* Parse arguments and options.  */
 285   {
 286     int c;
 287     /* When var field is 0, use flag field to record the equivalent
 288        short option (or arbitrary numbers starting at 10 for those
 289        with no equivalent).  */
 290     enum {
 291       OPT_SE = 10,
 292       OPT_CD,
 293       OPT_ANNOTATE,
 294       OPT_STATISTICS,
 295       OPT_TUI,
 296       OPT_NOWINDOWS,
 297       OPT_WINDOWS
 298     };
 299     static struct option long_options[] =
 300     {
 301 #if defined(TUI)
 302       {"tui", no_argument, 0, OPT_TUI},
 303 #endif
 304       {"xdb", no_argument, &xdb_commands, 1},
 305       {"dbx", no_argument, &dbx_commands, 1},
 306       {"readnow", no_argument, &readnow_symbol_files, 1},
 307       {"r", no_argument, &readnow_symbol_files, 1},
 308       {"quiet", no_argument, &quiet, 1},
 309       {"q", no_argument, &quiet, 1},
 310       {"silent", no_argument, &quiet, 1},
 311       {"nx", no_argument, &inhibit_gdbinit, 1},
 312       {"n", no_argument, &inhibit_gdbinit, 1},
 313       {"batch-silent", no_argument, 0, 'B'},
 314       {"batch", no_argument, &batch, 1},
 315       {"epoch", no_argument, &epoch_interface, 1},
 316
 317     /* This is a synonym for "--annotate=1".  --annotate is now preferred,
 318        but keep this here for a long time because people will be running
 319        emacses which use --fullname.  */
 320       {"fullname", no_argument, 0, 'f'},
 321       {"f", no_argument, 0, 'f'},
 322
 323       {"annotate", required_argument, 0, OPT_ANNOTATE},
 324       {"help", no_argument, &print_help, 1},
 325       {"se", required_argument, 0, OPT_SE},
 326       {"symbols", required_argument, 0, 's'},
 327       {"s", required_argument, 0, 's'},
 328       {"exec", required_argument, 0, 'e'},
 329       {"e", required_argument, 0, 'e'},
 330       {"core", required_argument, 0, 'c'},
 331       {"c", required_argument, 0, 'c'},
 332       {"pid", required_argument, 0, 'p'},
 333       {"p", required_argument, 0, 'p'},
 334       {"command", required_argument, 0, 'x'},
 335       {"eval-command", required_argument, 0, 'X'},
 336       {"version", no_argument, &print_version, 1},
 337       {"x", required_argument, 0, 'x'},
 338       {"ex", required_argument, 0, 'X'},
 339 #ifdef GDBTK
 340       {"tclcommand", required_argument, 0, 'z'},
 341       {"enable-external-editor", no_argument, 0, 'y'},
 342       {"editor-command", required_argument, 0, 'w'},
 343 #endif
 344       {"ui", required_argument, 0, 'i'},
 345       {"interpreter", required_argument, 0, 'i'},
 346       {"i", required_argument, 0, 'i'},
 347       {"directory", required_argument, 0, 'd'},
 348       {"d", required_argument, 0, 'd'},
 349       {"cd", required_argument, 0, OPT_CD},
 350       {"tty", required_argument, 0, 't'},
 351       {"baud", required_argument, 0, 'b'},
 352       {"b", required_argument, 0, 'b'},
 353       {"nw", no_argument, NULL, OPT_NOWINDOWS},
 354       {"nowindows", no_argument, NULL, OPT_NOWINDOWS},
 355       {"w", no_argument, NULL, OPT_WINDOWS},
 356       {"windows", no_argument, NULL, OPT_WINDOWS},
 357       {"statistics", no_argument, 0, OPT_STATISTICS},
 358       {"write", no_argument, &write_files, 1},
 359       {"args", no_argument, &set_args, 1},
 360      {"l", required_argument, 0, 'l'},
 361       {"return-child-result", no_argument, &return_child_result, 1},
 362       {0, no_argument, 0, 0}
 363     };
 364
 365     while (1)
 366       {
 367         int option_index;
 368
 369         c = getopt_long_only (argc, argv, "",
 370                               long_options, &option_index);
 371         if (c == EOF || set_args)
 372           break;
 373
 374         /* Long option that takes an argument.  */
 375         if (c == 0 && long_options[option_index].flag == 0)
 376           c = long_options[option_index].val;
 377
 378         switch (c)
 379           {
 380           case 0:
 381             /* Long option that just sets a flag.  */
 382             break;
 383           case OPT_SE:
 384             symarg = optarg;
 385             execarg = optarg;
 386             break;
 387           case OPT_CD:
 388             cdarg = optarg;
 389             break;
 390           case OPT_ANNOTATE:
 391             /* FIXME: what if the syntax is wrong (e.g. not digits)?  */
 392             annotation_level = atoi (optarg);
 393             break;
 394           case OPT_STATISTICS:
 395             /* Enable the display of both time and space usage.  */
 396             display_time = 1;
 397             display_space = 1;
 398             break;
 399           case OPT_TUI:
 400             /* --tui is equivalent to -i=tui.  */
 401             xfree (interpreter_p);
 402             interpreter_p = xstrdup (INTERP_TUI);
 403             break;
 404           case OPT_WINDOWS:
 405             /* FIXME: cagney/2003-03-01: Not sure if this option is
 406                actually useful, and if it is, what it should do.  */
 407 #ifdef GDBTK
 408             /* --windows is equivalent to -i=insight.  */
 409             xfree (interpreter_p);
 410             interpreter_p = xstrdup (INTERP_INSIGHT);
 411 #endif
 412             use_windows = 1;
 413             break;
 414           case OPT_NOWINDOWS:
 415             /* -nw is equivalent to -i=console.  */
 416             xfree (interpreter_p);
 417             interpreter_p = xstrdup (INTERP_CONSOLE);
 418             use_windows = 0;
 419             break;
 420           case 'f':
 421             annotation_level = 1;
 422 /* We have probably been invoked from emacs.  Disable window interface.  */
 423             use_windows = 0;
 424             break;
 425           case 's':
 426             symarg = optarg;
 427             break;
 428           case 'e':
 429             execarg = optarg;
 430             break;
 431           case 'c':
 432             corearg = optarg;
 433             break;
 434           case 'p':
 435             /* "corearg" is shared by "--core" and "--pid" */
 436             corearg = optarg;
 437             break;
 438           case 'x':
 439             cmdarg[ncmd].type = CMDARG_FILE;
 440             cmdarg[ncmd++].string = optarg;
 441             if (ncmd >= cmdsize)
 442               {
 443                 cmdsize *= 2;
 444                 cmdarg = xrealloc ((char *) cmdarg,
 445                                    cmdsize * sizeof (*cmdarg));
 446               }
 447             break;
 448           case 'X':
 449             cmdarg[ncmd].type = CMDARG_COMMAND;
 450             cmdarg[ncmd++].string = optarg;
 451             if (ncmd >= cmdsize)
 452               {
 453                 cmdsize *= 2;
 454                 cmdarg = xrealloc ((char *) cmdarg,
 455                                    cmdsize * sizeof (*cmdarg));
 456               }
 457             break;
 458           case 'B':
 459             batch = batch_silent = 1;
 460             gdb_stdout = ui_file_new();
 461             break;
 462 #ifdef GDBTK
 463           case 'z':
 464             {
 465 extern int gdbtk_test (char *);
 466               if (!gdbtk_test (optarg))
 467                 {
 468                   fprintf_unfiltered (gdb_stderr, _("%s: unable to load tclcommand file \"%s\""),
 469                                       argv[0], optarg);
 470                   exit (1);
 471                 }
 472               break;
 473             }
 474           case 'y':
 475             /* Backwards compatibility only.  */
 476             break;
 477           case 'w':
 478             {
 479               external_editor_command = xstrdup (optarg);
 480               break;
 481             }
 482 #endif /* GDBTK */
 483           case 'i':
 484             xfree (interpreter_p);
 485             interpreter_p = xstrdup (optarg);
 486             break;
 487           case 'd':
 488             dirarg[ndir++] = optarg;
 489             if (ndir >= dirsize)
 490               {
 491                 dirsize *= 2;
 492                 dirarg = (char **) xrealloc ((char *) dirarg,
 493                                              dirsize * sizeof (*dirarg));
 494               }
 495             break;
 496           case 't':
 497             ttyarg = optarg;
 498             break;
 499           case 'q':
 500             quiet = 1;
 501             break;
 502           case 'b':
 503             {
 504               int i;
 505               char *p;
 506
 507               i = strtol (optarg, &p, 0);
 508               if (i == 0 && p == optarg)
 509
 510                 /* Don't use *_filtered or warning() (which relies on
 511                    current_target) until after initialize_all_files(). */
 512
 513                 fprintf_unfiltered
 514                   (gdb_stderr,
 515                    _("warning: could not set baud rate to `%s'.\n"), optarg);
 516               else
 517                 baud_rate = i;
 518             }
 519             break;
 520           case 'l':
 521             {
 522               int i;
 523               char *p;
 524
 525               i = strtol (optarg, &p, 0);
 526               if (i == 0 && p == optarg)
 527
 528                 /* Don't use *_filtered or warning() (which relies on
 529                    current_target) until after initialize_all_files(). */
 530
 531                 fprintf_unfiltered
 532                   (gdb_stderr,
 533                  _("warning: could not set timeout limit to `%s'.\n"), optarg);
 534               else
 535                 remote_timeout = i;
 536             }
 537             break;
 538
 539           case '?':
 540             fprintf_unfiltered (gdb_stderr,
 541                         _("Use `%s --help' for a complete list of options.\n"),
 542                                 argv[0]);
 543             exit (1);
 544           }
 545       }
 546
 547     /* If --help or --version, disable window interface.  */
 548     if (print_help || print_version)
 549       {
 550         use_windows = 0;
 551       }
 552
 553     if (set_args)
 554       {
 555         /* The remaining options are the command-line options for the
 556            inferior.  The first one is the sym/exec file, and the rest
 557            are arguments.  */
 558         if (optind >= argc)
 559           {
 560             fprintf_unfiltered (gdb_stderr,
 561                                 _("%s: `--args' specified but no program specified\n"),
 562                                 argv[0]);
 563             exit (1);
 564           }
 565         symarg = argv[optind];
 566         execarg = argv[optind];
 567         ++optind;
 568         set_inferior_args_vector (argc - optind, &argv[optind]);
 569       }
 570     else
 571       {
 572         /* OK, that's all the options.  The other arguments are filenames.  */
 573         count = 0;
 574         for (; optind < argc; optind++)
 575           switch (++count)
 576             {
 577             case 1:
 578               symarg = argv[optind];
 579               execarg = argv[optind];
 580               break;
 581             case 2:
 582               /* The documentation says this can be a "ProcID" as well.
 583                  We will try it as both a corefile and a pid.  */
 584               corearg = argv[optind];
 585               break;
 586             case 3:
 587               fprintf_unfiltered (gdb_stderr,
 588                                   _("Excess command line arguments ignored. (%s%s)\n"),
 589                                   argv[optind], (optind == argc - 1) ? "" : " ...");
 590               break;
 591             }
 592       }
 593     if (batch)
 594       quiet = 1;
 595   }
 596
 597   /* Initialize all files.  Give the interpreter a chance to take
 598      control of the console via the deprecated_init_ui_hook ().  */
 599   gdb_init (argv[0]);
 600
 601   /* Do these (and anything which might call wrap_here or *_filtered)
 602      after initialize_all_files() but before the interpreter has been
 603      installed.  Otherwize the help/version messages will be eaten by
 604      the interpreter's output handler.  */
 605
 606   if (print_version)
 607     {
 608       print_gdb_version (gdb_stdout);
 609       wrap_here ("");
 610       printf_filtered ("\n");
 611       exit (0);
 612     }
 613
 614   if (print_help)
 615     {
 616       print_gdb_help (gdb_stdout);
 617       fputs_unfiltered ("\n", gdb_stdout);
 618       exit (0);
 619     }
 620
 621   /* FIXME: cagney/2003-02-03: The big hack (part 1 of 2) that lets
 622      GDB retain the old MI1 interpreter startup behavior.  Output the
 623      copyright message before the interpreter is installed.  That way
 624      it isn't encapsulated in MI output.  */
 625   if (!quiet && strcmp (interpreter_p, INTERP_MI1) == 0)
 626     {
 627       /* Print all the junk at the top, with trailing "..." if we are about
 628          to read a symbol file (possibly slowly).  */
 629       print_gdb_version (gdb_stdout);
 630       if (symarg)
 631         printf_filtered ("..");
 632       wrap_here ("");
 633       printf_filtered ("\n");
 634       gdb_flush (gdb_stdout);   /* Force to screen during slow operations */
 635     }
 636
 637
 638   /* Install the default UI.  All the interpreters should have had a
 639      look at things by now.  Initialize the default interpreter. */
 640
 641   {
 642     /* Find it.  */
 643     struct interp *interp = interp_lookup (interpreter_p);
 644     if (interp == NULL)
 645       error (_("Interpreter `%s' unrecognized"), interpreter_p);
 646     /* Install it.  */
 647     if (!interp_set (interp))
 648       {
 649         fprintf_unfiltered (gdb_stderr,
 650                             "Interpreter `%s' failed to initialize.\n",
 651                             interpreter_p);
 652         exit (1);
 653       }
 654   }
 655
 656   /* FIXME: cagney/2003-02-03: The big hack (part 2 of 2) that lets
 657      GDB retain the old MI1 interpreter startup behavior.  Output the
 658      copyright message after the interpreter is installed when it is
 659      any sane interpreter.  */
 660   if (!quiet && !current_interp_named_p (INTERP_MI1))
 661     {
 662       /* Print all the junk at the top, with trailing "..." if we are about
 663          to read a symbol file (possibly slowly).  */
 664       print_gdb_version (gdb_stdout);
 665       if (symarg)
 666         printf_filtered ("..");
 667       wrap_here ("");
 668       printf_filtered ("\n");
 669       gdb_flush (gdb_stdout);   /* Force to screen during slow operations */
 670     }
 671
 672   /* Set off error and warning messages with a blank line.  */
 673   error_pre_print = "\n";
 674   quit_pre_print = error_pre_print;
 675   warning_pre_print = _("\nwarning: ");
 676
 677   /* Read and execute $HOME/.gdbinit file, if it exists.  This is done
 678      *before* all the command line arguments are processed; it sets
 679      global parameters, which are independent of what file you are
 680      debugging or what directory you are in.  */
 681   homedir = getenv ("HOME");
 682   if (homedir)
 683     {
 684       char *homeinit = xstrprintf ("%s/%s", homedir, gdbinit);
 685
 686       if (!inhibit_gdbinit)
 687         {
 688           catch_command_errors (source_script, homeinit, 0, RETURN_MASK_ALL);
 689         }
 690
 691       /* Do stats; no need to do them elsewhere since we'll only
 692          need them if homedir is set.  Make sure that they are
 693          zero in case one of them fails (this guarantees that they
 694          won't match if either exists).  */
 695
 696       memset (&homebuf, 0, sizeof (struct stat));
 697       memset (&cwdbuf, 0, sizeof (struct stat));
 698
 699       stat (homeinit, &homebuf);
 700       stat (gdbinit, &cwdbuf);  /* We'll only need this if
 701                                    homedir was set.  */
 702       xfree (homeinit);
 703     }
 704
 705   /* Now perform all the actions indicated by the arguments.  */
 706   if (cdarg != NULL)
 707     {
 708       catch_command_errors (cd_command, cdarg, 0, RETURN_MASK_ALL);
 709     }
 710
 711   for (i = 0; i < ndir; i++)
 712     catch_command_errors (directory_switch, dirarg[i], 0, RETURN_MASK_ALL);
 713   xfree (dirarg);
 714
 715   if (execarg != NULL
 716       && symarg != NULL
 717       && strcmp (execarg, symarg) == 0)
 718     {
 719       /* The exec file and the symbol-file are the same.  If we can't
 720          open it, better only print one error message.
 721          catch_command_errors returns non-zero on success! */
 722       if (catch_command_errors (exec_file_attach, execarg, !batch, RETURN_MASK_ALL))
 723         catch_command_errors (symbol_file_add_main, symarg, 0, RETURN_MASK_ALL);
 724     }
 725   else
 726     {
 727       if (execarg != NULL)
 728         catch_command_errors (exec_file_attach, execarg, !batch, RETURN_MASK_ALL);
 729       if (symarg != NULL)
 730         catch_command_errors (symbol_file_add_main, symarg, 0, RETURN_MASK_ALL);
 731     }
 732
 733   if (corearg != NULL)
 734     {
 735       /* corearg may be either a corefile or a pid.
 736          If its first character is a digit, try attach first
 737          and then corefile.  Otherwise try corefile first. */
 738
 739       if (isdigit (corearg[0]))
 740         {
 741           if (catch_command_errors (attach_command, corearg,
 742                                     !batch, RETURN_MASK_ALL) == 0)
 743             catch_command_errors (core_file_command, corearg,
 744                                   !batch, RETURN_MASK_ALL);
 745         }
 746       else /* Can't be a pid, better be a corefile. */
 747         catch_command_errors (core_file_command, corearg,
 748                               !batch, RETURN_MASK_ALL);
 749     }
 750
 751   if (ttyarg != NULL)
 752     catch_command_errors (tty_command, ttyarg, !batch, RETURN_MASK_ALL);
 753
 754   /* Error messages should no longer be distinguished with extra output. */
 755   error_pre_print = NULL;
 756   quit_pre_print = NULL;
 757   warning_pre_print = _("warning: ");
 758
 759   /* Read the .gdbinit file in the current directory, *if* it isn't
 760      the same as the $HOME/.gdbinit file (it should exist, also).  */
 761
 762   if (!homedir
 763       || memcmp ((char *) &homebuf, (char *) &cwdbuf, sizeof (struct stat)))
 764     if (!inhibit_gdbinit)
 765       {
 766         catch_command_errors (source_script, gdbinit, 0, RETURN_MASK_ALL);
 767       }
 768
 769   for (i = 0; i < ncmd; i++)
 770     {
 771 #if 0
 772       /* NOTE: cagney/1999-11-03: SET_TOP_LEVEL() was a macro that
 773          expanded into a call to setjmp().  */
 774       if (!SET_TOP_LEVEL ()) /* NB: This is #if 0'd out */
 775         {
 776           /* NOTE: I am commenting this out, because it is not clear
 777              where this feature is used. It is very old and
 778              undocumented. ezannoni: 1999-05-04 */
 779 #if 0
 780           if (cmdarg[i][0] == '-' && cmdarg[i][1] == '\0')
 781             read_command_file (stdin);
 782           else
 783 #endif
 784             source_script (cmdarg[i], !batch);
 785           do_cleanups (ALL_CLEANUPS);
 786         }
 787 #endif
 788       if (cmdarg[i].type == CMDARG_FILE)
 789         catch_command_errors (source_script, cmdarg[i].string,
 790                               !batch, RETURN_MASK_ALL);
 791       else  /* cmdarg[i].type == CMDARG_COMMAND */
 792         catch_command_errors (execute_command, cmdarg[i].string,
 793                               !batch, RETURN_MASK_ALL);
 794     }
 795   xfree (cmdarg);
 796
 797   /* Read in the old history after all the command files have been read. */
 798   init_history ();
 799
 800   if (batch)
 801     {
 802       /* We have hit the end of the batch file.  */
 803       quit_force (NULL, 0);
 804     }
 805
 806   /* Do any host- or target-specific hacks.  This is used for i960 targets
 807      to force the user to set a nindy target and spec its parameters.  */
 808
 809 #ifdef BEFORE_MAIN_LOOP_HOOK
 810   BEFORE_MAIN_LOOP_HOOK;
 811 #endif
 812
 813   /* Show time and/or space usage.  */
 814
 815   if (display_time)
 816     {
 817       long init_time = get_run_time () - time_at_startup;
 818
 819       printf_unfiltered (_("Startup time: %ld.%06ld\n"),
 820                          init_time / 1000000, init_time % 1000000);
 821     }
 822
 823   if (display_space)
 824     {
 825 #ifdef HAVE_SBRK
 826       extern char **environ;
 827       char *lim = (char *) sbrk (0);
 828
 829       printf_unfiltered (_("Startup size: data size %ld\n"),
 830                          (long) (lim - (char *) &environ));
 831 #endif
 832     }
 833
 834 #if 0
 835   /* FIXME: cagney/1999-11-06: The original main loop was like: */
 836   while (1)
 837     {
 838       if (!SET_TOP_LEVEL ())
 839         {
 840           do_cleanups (ALL_CLEANUPS);   /* Do complete cleanup */
 841           /* GUIs generally have their own command loop, mainloop, or
 842              whatever.  This is a good place to gain control because
 843              many error conditions will end up here via longjmp().  */
 844           if (deprecated_command_loop_hook)
 845             deprecated_command_loop_hook ();
 846           else
 847             deprecated_command_loop ();
 848           quit_command ((char *) 0, instream == stdin);
 849         }
 850     }
 851   /* NOTE: If the command_loop() returned normally, the loop would
 852      attempt to exit by calling the function quit_command().  That
 853      function would either call exit() or throw an error returning
 854      control to SET_TOP_LEVEL. */
 855   /* NOTE: The function do_cleanups() was called once each time round
 856      the loop.  The usefulness of the call isn't clear.  If an error
 857      was thrown, everything would have already been cleaned up.  If
 858      command_loop() returned normally and quit_command() was called,
 859      either exit() or error() (again cleaning up) would be called. */
 860 #endif
 861   /* NOTE: cagney/1999-11-07: There is probably no reason for not
 862      moving this loop and the code found in captured_command_loop()
 863      into the command_loop() proper.  The main thing holding back that
 864      change - SET_TOP_LEVEL() - has been eliminated. */
 865   while (1)
 866     {
 867       catch_errors (captured_command_loop, 0, "", RETURN_MASK_ALL);
 868     }
 869   /* No exit -- exit is through quit_command.  */
 870 }
 871
 872 int
 873 gdb_main (struct captured_main_args *args)
 874 {
 875   use_windows = args->use_windows;
 876   catch_errors (captured_main, args, "", RETURN_MASK_ALL);
 877   /* The only way to end up here is by an error (normal exit is
 878      handled by quit_force()), hence always return an error status.  */
 879   return 1;
 880 }
 881
 882
 883 /* Don't use *_filtered for printing help.  We don't want to prompt
 884    for continue no matter how small the screen or how much we're going
 885    to print.  */
 886
 887 static void
 888 print_gdb_help (struct ui_file *stream)
 889 {
 890   fputs_unfiltered (_("\
 891 This is the GNU debugger.  Usage:\n\n\
 892     gdb [options] [executable-file [core-file or process-id]]\n\
 893     gdb [options] --args executable-file [inferior-arguments ...]\n\n\
 894 Options:\n\n\
 895 "), stream);
 896   fputs_unfiltered (_("\
 897   --args             Arguments after executable-file are passed to inferior\n\
 898 "), stream);
 899   fputs_unfiltered (_("\
 900   -b BAUDRATE        Set serial port baud rate used for remote debugging.\n\
 901   --batch            Exit after processing options.\n\
 902   --batch-silent     As for --batch, but suppress all gdb stdout output.\n\
 903   --return-child-result\n\
 904                      GDB exit code will be the child's exit code.\n\
 905   --cd=DIR           Change current directory to DIR.\n\
 906   --command=FILE, -x Execute GDB commands from FILE.\n\
 907   --eval-command=COMMAND, -ex\n\
 908                      Execute a single GDB command.\n\
 909                      May be used multiple times and in conjunction\n\
 910                      with --command.\n\
 911   --core=COREFILE    Analyze the core dump COREFILE.\n\
 912   --pid=PID          Attach to running process PID.\n\
 913 "), stream);
 914   fputs_unfiltered (_("\
 915   --dbx              DBX compatibility mode.\n\
 916   --directory=DIR    Search for source files in DIR.\n\
 917   --epoch            Output information used by epoch emacs-GDB interface.\n\
 918   --exec=EXECFILE    Use EXECFILE as the executable.\n\
 919   --fullname         Output information used by emacs-GDB interface.\n\
 920   --help             Print this message.\n\
 921 "), stream);
 922   fputs_unfiltered (_("\
 923   --interpreter=INTERP\n\
 924                      Select a specific interpreter / user interface\n\
 925 "), stream);
 926   fputs_unfiltered (_("\
 927   -l TIMEOUT         Set timeout in seconds for remote debugging.\n\
 928   --nw               Do not use a window interface.\n\
 929   --nx               Do not read "), stream);
 930   fputs_unfiltered (gdbinit, stream);
 931   fputs_unfiltered (_(" file.\n\
 932   --quiet            Do not print version number on startup.\n\
 933   --readnow          Fully read symbol files on first access.\n\
 934 "), stream);
 935   fputs_unfiltered (_("\
 936   --se=FILE          Use FILE as symbol file and executable file.\n\
 937   --symbols=SYMFILE  Read symbols from SYMFILE.\n\
 938   --tty=TTY          Use TTY for input/output by the program being debugged.\n\
 939 "), stream);
 940 #if defined(TUI)
 941   fputs_unfiltered (_("\
 942   --tui              Use a terminal user interface.\n\
 943 "), stream);
 944 #endif
 945   fputs_unfiltered (_("\
 946   --version          Print version information and then exit.\n\
 947   -w                 Use a window interface.\n\
 948   --write            Set writing into executable and core files.\n\
 949   --xdb              XDB compatibility mode.\n\
 950 "), stream);
 951   fputs_unfiltered (_("\n\
 952 For more information, type \"help\" from within GDB, or consult the\n\
 953 GDB manual (available as on-line info or a printed manual).\n\
 954 Report bugs to \"bug-gdb@gnu.org\".\
 955 "), stream);
 956 }