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