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