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