1 /* Top level `main' program for GDB, the GNU debugger.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
23 #include "call-cmds.h"
28 #include "breakpoint.h"
30 #include "expression.h"
35 /* readline include files */
39 /* readline defines this. */
43 #include <sys/types.h>
52 #include <sys/param.h>
56 #ifdef SET_STACK_LIMIT_HUGE
58 #include <sys/resource.h>
60 int original_stack_limit
;
63 /* Prototypes for local functions */
66 symbol_completion_function
PARAMS ((char *, int));
69 command_loop
PARAMS ((void));
72 command_loop_marker
PARAMS ((int));
75 print_gdb_version
PARAMS ((FILE *));
78 quit_command
PARAMS ((char *, int));
81 initialize_main
PARAMS ((void));
84 initialize_history
PARAMS ((void));
87 initialize_cmd_lists
PARAMS ((void));
90 float_handler
PARAMS ((int));
93 source_command
PARAMS ((char *, int));
96 cd_command
PARAMS ((char *, int));
99 print_gnu_advertisement
PARAMS ((void));
102 init_signals
PARAMS ((void));
105 read_command_file
PARAMS ((FILE *));
108 set_verbose
PARAMS ((char *, int, struct cmd_list_element
*));
111 show_history
PARAMS ((char *, int));
114 set_history
PARAMS ((char *, int));
117 set_history_size_command
PARAMS ((char *, int, struct cmd_list_element
*));
120 show_commands
PARAMS ((char *, int));
123 echo_command
PARAMS ((char *, int));
126 pwd_command
PARAMS ((char *, int));
129 show_version
PARAMS ((char *, int));
132 document_command
PARAMS ((char *, int));
135 define_command
PARAMS ((char *, int));
138 validate_comname
PARAMS ((char *));
141 help_command
PARAMS ((char *, int));
144 show_command
PARAMS ((char *, int));
147 info_command
PARAMS ((char *, int));
150 do_nothing
PARAMS ((int));
153 quit_cover
PARAMS ((char *));
156 disconnect
PARAMS ((int));
159 source_cleanup
PARAMS ((FILE *));
161 /* If this definition isn't overridden by the header files, assume
162 that isatty and fileno exist on this system. */
164 #define ISATTY(FP) (isatty (fileno (FP)))
167 /* Initialization file name for gdb. This is overridden in some configs. */
169 #ifndef GDBINIT_FILENAME
170 #define GDBINIT_FILENAME ".gdbinit"
172 static char gdbinit
[] = GDBINIT_FILENAME
;
173 static int inhibit_gdbinit
= 0;
175 #define ALL_CLEANUPS ((struct cleanup *)0)
177 /* Version number of GDB, as a string. */
179 extern char *version
;
181 /* Canonical host name as a string. */
183 extern char *host_canonical
;
185 /* Canonical target name as a string. */
187 extern char *target_canonical
;
189 /* Message to be printed before the error message, when an error occurs. */
191 extern char *error_pre_print
;
193 /* Message to be printed before the warning message, when a warning occurs. */
195 extern char *warning_pre_print
;
197 extern char lang_frame_mismatch_warn
[]; /* language.c */
199 /* Whether GDB's stdin is on a terminal. */
201 extern int gdb_has_a_terminal
; /* inflow.c */
203 /* Flag for whether we want all the "from_tty" gubbish printed. */
205 int caution
= 1; /* Default is yes, sigh. */
208 * Define all cmd_list_element's
211 /* Chain containing all defined commands. */
213 struct cmd_list_element
*cmdlist
;
215 /* Chain containing all defined info subcommands. */
217 struct cmd_list_element
*infolist
;
219 /* Chain containing all defined enable subcommands. */
221 struct cmd_list_element
*enablelist
;
223 /* Chain containing all defined disable subcommands. */
225 struct cmd_list_element
*disablelist
;
227 /* Chain containing all defined delete subcommands. */
229 struct cmd_list_element
*deletelist
;
231 /* Chain containing all defined "enable breakpoint" subcommands. */
233 struct cmd_list_element
*enablebreaklist
;
235 /* Chain containing all defined set subcommands */
237 struct cmd_list_element
*setlist
;
239 /* Chain containing all defined unset subcommands */
241 struct cmd_list_element
*unsetlist
;
243 /* Chain containing all defined show subcommands. */
245 struct cmd_list_element
*showlist
;
247 /* Chain containing all defined \"set history\". */
249 struct cmd_list_element
*sethistlist
;
251 /* Chain containing all defined \"show history\". */
253 struct cmd_list_element
*showhistlist
;
255 /* Chain containing all defined \"unset history\". */
257 struct cmd_list_element
*unsethistlist
;
259 /* Chain containing all defined maintenance subcommands. */
262 struct cmd_list_element
*maintenancelist
;
265 /* Chain containing all defined "maintenance info" subcommands. */
268 struct cmd_list_element
*maintenanceinfolist
;
271 /* Chain containing all defined "maintenance print" subcommands. */
274 struct cmd_list_element
*maintenanceprintlist
;
277 struct cmd_list_element
*setprintlist
;
279 struct cmd_list_element
*showprintlist
;
281 struct cmd_list_element
*setchecklist
;
283 struct cmd_list_element
*showchecklist
;
285 /* stdio stream that command input is being read from. */
289 /* Current working directory. */
291 char *current_directory
;
293 /* The directory name is actually stored here (usually). */
294 static char dirbuf
[1024];
296 /* Function to call before reading a command, if nonzero.
297 The function receives two args: an input stream,
298 and a prompt string. */
300 void (*window_hook
) PARAMS ((FILE *, char *));
302 extern int mapped_symbol_files
;
303 extern int readnow_symbol_files
;
308 /* gdb prints this when reading a command interactively */
311 /* Buffer used for reading command lines, and the size
312 allocated for it so far. */
317 /* Baud rate specified for talking to serial target systems. Default
318 is left as a zero pointer, so targets can choose their own defaults. */
322 /* Signal to catch ^Z typed while reading a command: SIGTSTP or SIGCONT. */
326 #define STOP_SIGNAL SIGTSTP
327 static void stop_sig
PARAMS ((int));
331 /* Some System V have job control but not sigsetmask(). */
332 #if !defined (HAVE_SIGSETMASK)
333 #define HAVE_SIGSETMASK !defined (USG)
336 #if 0 == (HAVE_SIGSETMASK)
337 #define sigsetmask(n)
340 /* This is how `error' returns to command level. */
342 jmp_buf to_top_level
;
345 return_to_top_level ()
349 bpstat_clear_actions(stop_bpstat
); /* Clear queued breakpoint commands */
350 disable_current_display ();
351 do_cleanups (ALL_CLEANUPS
);
352 (NORETURN
void) longjmp (to_top_level
, 1);
355 /* Call FUNC with arg ARGS, catching any errors.
356 If there is no error, return the value returned by FUNC.
357 If there is an error, print ERRSTRING, print the specific error message,
361 catch_errors (func
, args
, errstring
)
362 int (*func
) PARAMS ((char *));
368 struct cleanup
*saved_cleanup_chain
;
369 char *saved_error_pre_print
;
371 saved_cleanup_chain
= save_cleanups ();
372 saved_error_pre_print
= error_pre_print
;
374 memcpy ((char *)saved
, (char *)to_top_level
, sizeof (jmp_buf));
375 error_pre_print
= errstring
;
377 if (setjmp (to_top_level
) == 0)
378 val
= (*func
) (args
);
382 restore_cleanups (saved_cleanup_chain
);
384 error_pre_print
= saved_error_pre_print
;
385 memcpy ((char *)to_top_level
, (char *)saved
, sizeof (jmp_buf));
389 /* Handler for SIGHUP. */
395 catch_errors (quit_cover
, NULL
,
396 "Could not kill the program being debugged");
397 signal (SIGHUP
, SIG_DFL
);
398 kill (getpid (), SIGHUP
);
401 /* Just a little helper function for disconnect(). */
407 caution
= 0; /* Throw caution to the wind -- we're exiting.
408 This prevents asking the user dumb questions. */
409 quit_command((char *)0, 0);
413 /* Clean up on error during a "source" command (or execution of a
414 user-defined command). */
417 source_cleanup (stream
)
420 /* Restore the previous input stream. */
424 /* Read commands from STREAM. */
426 read_command_file (stream
)
429 struct cleanup
*cleanups
;
431 cleanups
= make_cleanup (source_cleanup
, instream
);
434 do_cleanups (cleanups
);
443 static int quiet
= 0;
444 static int batch
= 0;
446 /* Pointers to various arguments from command line. */
448 char *execarg
= NULL
;
449 char *corearg
= NULL
;
453 /* Pointers to all arguments of +command option. */
455 /* Allocated size of cmdarg. */
457 /* Number of elements of cmdarg used. */
460 /* Indices of all arguments of +directory option. */
462 /* Allocated size. */
464 /* Number of elements used. */
467 struct stat homebuf
, cwdbuf
;
468 char *homedir
, *homeinit
;
472 /* This needs to happen before the first use of malloc. */
473 init_malloc ((PTR
) NULL
);
475 #if defined (ALIGN_STACK_ON_STARTUP)
476 i
= (int) &count
& 0x3;
481 /* If error() is called from initialization code, just exit */
482 if (setjmp (to_top_level
)) {
487 cmdarg
= (char **) xmalloc (cmdsize
* sizeof (*cmdarg
));
490 dirarg
= (char **) xmalloc (dirsize
* sizeof (*dirarg
));
494 line
= (char *) xmalloc (linesize
);
495 line
[0] = '\0'; /* Terminate saved (now empty) cmd line */
498 getcwd (dirbuf
, sizeof (dirbuf
));
499 current_directory
= dirbuf
;
501 #ifdef SET_STACK_LIMIT_HUGE
505 /* Set the stack limit huge so that alloca (particularly stringtab
506 * in dbxread.c) does not fail. */
507 getrlimit (RLIMIT_STACK
, &rlim
);
508 original_stack_limit
= rlim
.rlim_cur
;
509 rlim
.rlim_cur
= rlim
.rlim_max
;
510 setrlimit (RLIMIT_STACK
, &rlim
);
512 #endif /* SET_STACK_LIMIT_HUGE */
514 /* Parse arguments and options. */
517 static int print_help
;
518 /* When var field is 0, use flag field to record the equivalent
519 short option (or arbitrary numbers starting at 10 for those
520 with no equivalent). */
521 static struct option long_options
[] =
523 {"readnow", no_argument
, &readnow_symbol_files
, 1},
524 {"r", no_argument
, &readnow_symbol_files
, 1},
525 {"mapped", no_argument
, &mapped_symbol_files
, 1},
526 {"m", no_argument
, &mapped_symbol_files
, 1},
527 {"quiet", no_argument
, &quiet
, 1},
528 {"q", no_argument
, &quiet
, 1},
529 {"silent", no_argument
, &quiet
, 1},
530 {"nx", no_argument
, &inhibit_gdbinit
, 1},
531 {"n", no_argument
, &inhibit_gdbinit
, 1},
532 {"batch", no_argument
, &batch
, 1},
533 {"epoch", no_argument
, &epoch_interface
, 1},
534 {"fullname", no_argument
, &frame_file_full_name
, 1},
535 {"f", no_argument
, &frame_file_full_name
, 1},
536 {"help", no_argument
, &print_help
, 1},
537 {"se", required_argument
, 0, 10},
538 {"symbols", required_argument
, 0, 's'},
539 {"s", required_argument
, 0, 's'},
540 {"exec", required_argument
, 0, 'e'},
541 {"e", required_argument
, 0, 'e'},
542 {"core", required_argument
, 0, 'c'},
543 {"c", required_argument
, 0, 'c'},
544 {"command", required_argument
, 0, 'x'},
545 {"x", required_argument
, 0, 'x'},
546 {"directory", required_argument
, 0, 'd'},
547 {"cd", required_argument
, 0, 11},
548 {"tty", required_argument
, 0, 't'},
549 {"baud", required_argument
, 0, 'b'},
550 {"b", required_argument
, 0, 'b'},
551 /* Allow machine descriptions to add more options... */
552 #ifdef ADDITIONAL_OPTIONS
555 {0, no_argument
, 0, 0},
562 c
= getopt_long_only (argc
, argv
, "",
563 long_options
, &option_index
);
567 /* Long option that takes an argument. */
568 if (c
== 0 && long_options
[option_index
].flag
== 0)
569 c
= long_options
[option_index
].val
;
574 /* Long option that just sets a flag. */
593 cmdarg
[ncmd
++] = optarg
;
597 cmdarg
= (char **) xrealloc ((char *)cmdarg
,
598 cmdsize
* sizeof (*cmdarg
));
602 dirarg
[ndir
++] = optarg
;
606 dirarg
= (char **) xrealloc ((char *)dirarg
,
607 dirsize
* sizeof (*dirarg
));
619 #ifdef ADDITIONAL_OPTION_CASES
620 ADDITIONAL_OPTION_CASES
624 "Use `%s --help' for a complete list of options.\n",
632 print_gdb_version(stderr
);
634 This is the GNU debugger. Usage:\n\
635 gdb [options] [executable-file [core-file or process-id]]\n\
637 -help Print this message.\n\
638 -quiet Do not print version number on startup.\n\
639 -fullname Output information used by emacs-GDB interface.\n\
640 -epoch Output information used by epoch emacs-GDB interface.\n\
641 -batch Exit after processing options.\n\
642 -nx Do not read .gdbinit file.\n\
643 -tty=TTY Use TTY for input/output by the program being debugged.\n\
644 -cd=DIR Change current directory to DIR.\n\
645 -directory=DIR Search for source files in DIR.\n\
646 -command=FILE Execute GDB commands from FILE.\n\
647 -symbols=SYMFILE Read symbols from SYMFILE.\n\
648 -exec=EXECFILE Use EXECFILE as the executable.\n\
649 -se=FILE Use FILE as symbol file and executable file.\n\
650 -core=COREFILE Analyze the core dump COREFILE.\n\
651 -b BAUDRATE Set serial port baud rate used for remote debugging.\n\
652 -mapped Use mapped symbol files if supported on this system.\n\
653 -readnow Fully read symbol files on first access.\n\
655 #ifdef ADDITIONAL_OPTION_HELP
656 fputs (ADDITIONAL_OPTION_HELP
, stderr
);
659 For more information, type \"help\" from within GDB, or consult the\n\
660 GDB manual (available as on-line info or a printed manual).\n", stderr
);
661 /* Exiting after printing this message seems like
662 the most useful thing to do. */
666 /* OK, that's all the options. The other arguments are filenames. */
668 for (; optind
< argc
; optind
++)
672 symarg
= argv
[optind
];
673 execarg
= argv
[optind
];
676 corearg
= argv
[optind
];
680 "Excess command line arguments ignored. (%s%s)\n",
681 argv
[optind
], (optind
== argc
- 1) ? "" : " ...");
688 /* Run the init function of each source file */
690 initialize_cmd_lists (); /* This needs to be done first */
691 initialize_all_files ();
692 initialize_main (); /* But that omits this file! Do it now */
697 /* Print all the junk at the top, with trailing "..." if we are about
698 to read a symbol file (possibly slowly). */
699 print_gnu_advertisement ();
700 print_gdb_version (stdout
);
702 printf_filtered ("..");
704 fflush (stdout
); /* Force to screen during slow operations */
707 error_pre_print
= "\n\n";
708 /* We may get more than one warning, don't double space all of them... */
709 warning_pre_print
= "\nwarning: ";
711 /* We need a default language for parsing expressions, so simple things like
712 "set width 0" won't fail if no language is explicitly set in a config file
713 or implicitly set by reading an executable during startup. */
714 set_language (language_c
);
715 expected_language
= current_language
; /* don't warn about the change. */
717 /* Read and execute $HOME/.gdbinit file, if it exists. This is done
718 *before* all the command line arguments are processed; it sets
719 global parameters, which are independent of what file you are
720 debugging or what directory you are in. */
721 homedir
= getenv ("HOME");
724 homeinit
= (char *) alloca (strlen (getenv ("HOME")) +
725 strlen (gdbinit
) + 10);
726 strcpy (homeinit
, getenv ("HOME"));
727 strcat (homeinit
, "/");
728 strcat (homeinit
, gdbinit
);
729 if (!inhibit_gdbinit
&& access (homeinit
, R_OK
) == 0)
731 if (!setjmp (to_top_level
))
732 source_command (homeinit
, 0);
734 do_cleanups (ALL_CLEANUPS
);
736 /* Do stats; no need to do them elsewhere since we'll only
737 need them if homedir is set. Make sure that they are
738 zero in case one of them fails (this guarantees that they
739 won't match if either exists). */
741 memset (&homebuf
, 0, sizeof (struct stat
));
742 memset (&cwdbuf
, 0, sizeof (struct stat
));
744 stat (homeinit
, &homebuf
);
745 stat (gdbinit
, &cwdbuf
); /* We'll only need this if
749 /* Now perform all the actions indicated by the arguments. */
752 if (!setjmp (to_top_level
))
754 cd_command (cdarg
, 0);
758 do_cleanups (ALL_CLEANUPS
);
760 for (i
= 0; i
< ndir
; i
++)
761 if (!setjmp (to_top_level
))
762 directory_command (dirarg
[i
], 0);
764 do_cleanups (ALL_CLEANUPS
);
768 && STREQ (execarg
, symarg
))
770 /* The exec file and the symbol-file are the same. If we can't open
771 it, better only print one error message. */
772 if (!setjmp (to_top_level
))
774 exec_file_command (execarg
, !batch
);
775 symbol_file_command (symarg
, 0);
781 if (!setjmp (to_top_level
))
782 exec_file_command (execarg
, !batch
);
784 if (!setjmp (to_top_level
))
785 symbol_file_command (symarg
, 0);
787 do_cleanups (ALL_CLEANUPS
);
789 /* After the symbol file has been read, print a newline to get us
790 beyond the copyright line... But errors should still set off
791 the error message with a (single) blank line. */
793 printf_filtered ("\n");
794 error_pre_print
= "\n";
795 warning_pre_print
= "\nwarning: ";
798 if (!setjmp (to_top_level
))
799 core_file_command (corearg
, !batch
);
800 else if (isdigit (corearg
[0]) && !setjmp (to_top_level
))
801 attach_command (corearg
, !batch
);
802 do_cleanups (ALL_CLEANUPS
);
805 if (!setjmp (to_top_level
))
806 tty_command (ttyarg
, !batch
);
807 do_cleanups (ALL_CLEANUPS
);
809 #ifdef ADDITIONAL_OPTION_HANDLER
810 ADDITIONAL_OPTION_HANDLER
;
813 /* Error messages should no longer be distinguished with extra output. */
815 warning_pre_print
= "warning: ";
817 /* Read the .gdbinit file in the current directory, *if* it isn't
818 the same as the $HOME/.gdbinit file (it should exist, also). */
821 || memcmp ((char *) &homebuf
, (char *) &cwdbuf
, sizeof (struct stat
)))
822 if (!inhibit_gdbinit
&& access (gdbinit
, R_OK
) == 0)
824 if (!setjmp (to_top_level
))
825 source_command (gdbinit
, 0);
827 do_cleanups (ALL_CLEANUPS
);
829 for (i
= 0; i
< ncmd
; i
++)
831 if (!setjmp (to_top_level
))
833 if (cmdarg
[i
][0] == '-' && cmdarg
[i
][1] == '\0')
834 read_command_file (stdin
);
836 source_command (cmdarg
[i
], !batch
);
837 do_cleanups (ALL_CLEANUPS
);
842 /* Read in the old history after all the command files have been read. */
843 initialize_history();
847 /* We have hit the end of the batch file. */
851 /* Do any host- or target-specific hacks. This is used for i960 targets
852 to force the user to set a nindy target and spec its parameters. */
854 #ifdef BEFORE_MAIN_LOOP_HOOK
855 BEFORE_MAIN_LOOP_HOOK
;
858 /* The command loop. */
862 if (!setjmp (to_top_level
))
864 do_cleanups (ALL_CLEANUPS
); /* Do complete cleanup */
866 quit_command ((char *)0, instream
== stdin
);
869 /* No exit -- exit is through quit_command. */
873 execute_user_command (c
, args
)
874 struct cmd_list_element
*c
;
877 register struct command_line
*cmdlines
;
878 struct cleanup
*old_chain
;
881 error ("User-defined commands cannot take arguments.");
883 cmdlines
= c
->user_commands
;
888 /* Set the instream to 0, indicating execution of a
889 user-defined function. */
890 old_chain
= make_cleanup (source_cleanup
, instream
);
891 instream
= (FILE *) 0;
894 execute_command (cmdlines
->line
, 0);
895 cmdlines
= cmdlines
->next
;
897 do_cleanups (old_chain
);
900 /* Execute the line P as a command.
901 Pass FROM_TTY as second argument to the defining function. */
904 execute_command (p
, from_tty
)
908 register struct cmd_list_element
*c
;
909 register enum language flang
;
910 static int warned
= 0;
914 /* This can happen when command_line_input hits end of file. */
918 while (*p
== ' ' || *p
== '\t') p
++;
923 c
= lookup_cmd (&p
, cmdlist
, "", 0, 1);
924 /* Pass null arg rather than an empty one. */
927 /* If this command has been hooked, run the hook first. */
929 execute_user_command (c
->hook
, (char *)0);
931 if (c
->class == class_user
)
932 execute_user_command (c
, arg
);
933 else if (c
->type
== set_cmd
|| c
->type
== show_cmd
)
934 do_setshow_command (arg
, from_tty
& caution
, c
);
935 else if (c
->function
.cfunc
== NO_FUNCTION
)
936 error ("That is not a command, just a help topic.");
938 (*c
->function
.cfunc
) (arg
, from_tty
& caution
);
941 /* Tell the user if the language has changed (except first time). */
942 if (current_language
!= expected_language
)
944 if (language_mode
== language_mode_auto
) {
945 language_info (1); /* Print what changed. */
950 /* Warn the user if the working language does not match the
951 language of the current frame. Only warn the user if we are
952 actually running the program, i.e. there is a stack. */
953 /* FIXME: This should be cacheing the frame and only running when
954 the frame changes. */
955 if (target_has_stack
)
957 flang
= get_frame_language ();
959 && flang
!= language_unknown
960 && flang
!= current_language
->la_language
)
962 printf_filtered ("%s\n", lang_frame_mismatch_warn
);
970 command_loop_marker (foo
)
975 /* Read commands from `instream' and execute them
976 until end of file or error reading instream. */
980 struct cleanup
*old_chain
;
982 int stdin_is_tty
= ISATTY (stdin
);
984 while (!feof (instream
))
986 if (window_hook
&& instream
== stdin
)
987 (*window_hook
) (instream
, prompt
);
990 if (instream
== stdin
&& stdin_is_tty
)
991 reinitialize_more_filter ();
992 old_chain
= make_cleanup (command_loop_marker
, 0);
993 command
= command_line_input (instream
== stdin
? prompt
: (char *) NULL
,
997 execute_command (command
, instream
== stdin
);
998 /* Do any commands attached to breakpoint we stopped at. */
999 bpstat_do_actions (&stop_bpstat
);
1000 do_cleanups (old_chain
);
1004 /* Commands call this if they do not want to be repeated by null lines. */
1009 /* If we aren't reading from standard input, we are saving the last
1010 thing read from stdin in line and don't want to delete it. Null lines
1011 won't repeat here in any case. */
1012 if (instream
== stdin
)
1016 /* Read a line from the stream "instream" without command line editing.
1018 It prints PRROMPT once at the start.
1019 Action is compatible with "readline", e.g. space for the result is
1020 malloc'd and should be freed by the caller.
1022 A NULL return means end of file. */
1024 gdb_readline (prrompt
)
1029 int input_index
= 0;
1030 int result_size
= 80;
1034 /* Don't use a _filtered function here. It causes the assumed
1035 character position to be off, since the newline we read from
1036 the user is not accounted for. */
1037 fputs (prrompt
, stdout
);
1041 result
= (char *) xmalloc (result_size
);
1045 /* Read from stdin if we are executing a user defined command.
1046 This is the right thing for prompt_for_continue, at least. */
1047 c
= fgetc (instream
? instream
: stdin
);
1058 result
[input_index
++] = c
;
1059 while (input_index
>= result_size
)
1062 result
= (char *) xrealloc (result
, result_size
);
1066 result
[input_index
++] = '\0';
1070 /* Variables which control command line editing and history
1071 substitution. These variables are given default values at the end
1073 static int command_editing_p
;
1074 static int history_expansion_p
;
1075 static int write_history_p
;
1076 static int history_size
;
1077 static char *history_filename
;
1079 /* Variables which are necessary for fancy command line editing. */
1080 char *gdb_completer_word_break_characters
=
1081 " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,-";
1083 /* When completing on command names, we remove '-' from the list of
1084 word break characters, since we use it in command names. If the
1085 readline library sees one in any of the current completion strings,
1086 it thinks that the string needs to be quoted and automatically supplies
1088 char *gdb_completer_command_word_break_characters
=
1089 " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,";
1091 /* Characters that can be used to quote completion strings. Note that we
1092 can't include '"' because the gdb C parser treats such quoted sequences
1094 char *gdb_completer_quote_characters
=
1097 /* Functions that are used as part of the fancy command line editing. */
1099 /* This can be used for functions which don't want to complete on symbols
1100 but don't want to complete on anything else either. */
1103 noop_completer (text
)
1109 /* Generate symbol names one by one for the completer. Each time we are
1110 called return another potential completion to the caller.
1112 TEXT is what we expect the symbol to start with.
1114 MATCHES is the number of matches that have currently been collected from
1115 calling this completion function. When zero, then we need to initialize,
1116 otherwise the initialization has already taken place and we can just
1117 return the next potential completion string.
1119 Returns NULL if there are no more completions, else a pointer to a string
1120 which is a possible completion.
1122 RL_LINE_BUFFER is available to be looked at; it contains the entire text
1123 of the line. RL_POINT is the offset in that line of the cursor. You
1124 should pretend that the line ends at RL_POINT. */
1127 symbol_completion_function (text
, matches
)
1131 static char **list
= (char **)NULL
; /* Cache of completions */
1132 static int index
; /* Next cached completion */
1133 char *output
= NULL
;
1134 char *tmp_command
, *p
;
1135 struct cmd_list_element
*c
, *result_list
;
1136 extern char *rl_line_buffer
;
1137 extern int rl_point
;
1141 /* The caller is beginning to accumulate a new set of completions, so
1142 we need to find all of them now, and cache them for returning one at
1143 a time on future calls. */
1147 /* Free the storage used by LIST, but not by the strings inside.
1148 This is because rl_complete_internal () frees the strings. */
1154 /* Choose the default set of word break characters to break completions.
1155 If we later find out that we are doing completions on command strings
1156 (as opposed to strings supplied by the individual command completer
1157 functions, which can be any string) then we will switch to the
1158 special word break set for command strings, which leaves out the
1159 '-' character used in some commands. */
1161 rl_completer_word_break_characters
=
1162 gdb_completer_word_break_characters
;
1164 /* Decide whether to complete on a list of gdb commands or on symbols. */
1165 tmp_command
= (char *) alloca (rl_point
+ 1);
1168 strncpy (tmp_command
, rl_line_buffer
, rl_point
);
1169 tmp_command
[rl_point
] = '\0';
1173 /* An empty line we want to consider ambiguous; that is, it
1174 could be any command. */
1175 c
= (struct cmd_list_element
*) -1;
1180 c
= lookup_cmd_1 (&p
, cmdlist
, &result_list
, 1);
1183 /* Move p up to the next interesting thing. */
1184 while (*p
== ' ' || *p
== '\t')
1191 /* He's typed something unrecognizable. Sigh. */
1194 else if (c
== (struct cmd_list_element
*) -1)
1196 /* If we didn't recognize everything up to the thing that
1197 needs completing, and we don't know what command it is
1198 yet, we are in trouble. */
1200 if (p
+ strlen(text
) != tmp_command
+ rl_point
)
1202 /* This really should not produce an error. Better would
1203 be to pretend to hit RETURN here; this would produce a
1204 response like "Ambiguous command: foo, foobar, etc",
1205 and leave the line available for re-entry with ^P.
1206 Instead, this error blows away the user's typed input
1207 without any way to get it back. */
1208 error (" Unrecognized command.");
1211 /* He's typed something ambiguous. This is easier. */
1214 list
= complete_on_cmdlist (*result_list
->prefixlist
, text
);
1218 list
= complete_on_cmdlist (cmdlist
, text
);
1220 rl_completer_word_break_characters
=
1221 gdb_completer_command_word_break_characters
;
1225 /* If we've gotten this far, gdb has recognized a full
1226 command. There are several possibilities:
1228 1) We need to complete on the command.
1229 2) We need to complete on the possibilities coming after
1231 2) We need to complete the text of what comes after the
1236 /* Always (might be longer versions of thie command). */
1237 list
= complete_on_cmdlist (result_list
, text
);
1238 rl_completer_word_break_characters
=
1239 gdb_completer_command_word_break_characters
;
1241 else if (!*p
&& !*text
)
1245 list
= complete_on_cmdlist (*c
->prefixlist
, "");
1246 rl_completer_word_break_characters
=
1247 gdb_completer_command_word_break_characters
;
1251 list
= (*c
->completer
) ("");
1256 if (c
->prefixlist
&& !c
->allow_unknown
)
1258 /* Something like "info adsfkdj". But error() is not the
1259 proper response; just return no completions instead. */
1264 list
= (*c
->completer
) (text
);
1270 /* If we found a list of potential completions during initialization then
1271 dole them out one at a time. The vector of completions is NULL
1272 terminated, so after returning the last one, return NULL (and continue
1273 to do so) each time we are called after that, until a new list is
1278 output
= list
[index
];
1288 /* Skip over a possibly quoted word (as defined by the quote characters
1289 and word break characters the completer uses). Returns pointer to the
1290 location after the "word". */
1296 char quote_char
= '\0';
1299 for (scan
= str
; *scan
!= '\0'; scan
++)
1301 if (quote_char
!= '\0')
1303 /* Ignore everything until the matching close quote char */
1304 if (*scan
== quote_char
)
1306 /* Found matching close quote. */
1311 else if (strchr (gdb_completer_quote_characters
, *scan
))
1313 /* Found start of a quoted string. */
1316 else if (strchr (gdb_completer_word_break_characters
, *scan
))
1330 #if STOP_SIGNAL == SIGTSTP
1331 signal (SIGTSTP
, SIG_DFL
);
1333 kill (getpid (), SIGTSTP
);
1334 signal (SIGTSTP
, stop_sig
);
1336 signal (STOP_SIGNAL
, stop_sig
);
1338 printf ("%s", prompt
);
1341 /* Forget about any previous command -- null line now will do nothing. */
1344 #endif /* STOP_SIGNAL */
1346 /* Initialize signal handlers. */
1356 signal (SIGINT
, request_quit
);
1358 /* If we initialize SIGQUIT to SIG_IGN, then the SIG_IGN will get
1359 passed to the inferior, which we don't want. It would be
1360 possible to do a "signal (SIGQUIT, SIG_DFL)" after we fork, but
1361 on BSD4.3 systems using vfork, that can affect the
1362 GDB process as well as the inferior (the signal handling tables
1363 might be in memory, shared between the two). Since we establish
1364 a handler for SIGQUIT, when we call exec it will set the signal
1365 to SIG_DFL for us. */
1366 signal (SIGQUIT
, do_nothing
);
1367 if (signal (SIGHUP
, do_nothing
) != SIG_IGN
)
1368 signal (SIGHUP
, disconnect
);
1369 signal (SIGFPE
, float_handler
);
1371 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1372 signal (SIGWINCH
, SIGWINCH_HANDLER
);
1376 /* Read one line from the command input stream `instream'
1377 into the local static buffer `linebuffer' (whose current length
1379 The buffer is made bigger as necessary.
1380 Returns the address of the start of the line.
1382 NULL is returned for end of file.
1384 *If* the instream == stdin & stdin is a terminal, the line read
1385 is copied into the file line saver (global var char *line,
1386 length linesize) so that it can be duplicated.
1388 This routine either uses fancy command line editing or
1389 simple input as the user has requested. */
1392 command_line_input (prrompt
, repeat
)
1396 static char *linebuffer
= 0;
1397 static unsigned linelength
= 0;
1401 char *local_prompt
= prrompt
;
1406 if (linebuffer
== 0)
1409 linebuffer
= (char *) xmalloc (linelength
);
1414 /* Control-C quits instantly if typed while in this loop
1415 since it should not wait until the user types a newline. */
1418 signal (STOP_SIGNAL
, stop_sig
);
1423 /* Reports are that some Sys V's don't flush stdout/err on reads
1424 from stdin, when stdin/out are sockets rather than ttys. So we
1425 have to do it ourselves, to make emacs-gdb and xxgdb work.
1426 On other machines, doing this once per input should be a cheap nop. */
1430 /* Don't use fancy stuff if not talking to stdin. */
1431 if (command_editing_p
&& instream
== stdin
1432 && ISATTY (instream
))
1433 rl
= readline (local_prompt
);
1435 rl
= gdb_readline (local_prompt
);
1437 if (!rl
|| rl
== (char *) EOF
)
1442 if (strlen(rl
) + 1 + (p
- linebuffer
) > linelength
)
1444 linelength
= strlen(rl
) + 1 + (p
- linebuffer
);
1445 nline
= (char *) xrealloc (linebuffer
, linelength
);
1446 p
+= nline
- linebuffer
;
1450 /* Copy line. Don't copy null at end. (Leaves line alone
1451 if this was just a newline) */
1455 free (rl
); /* Allocated in readline. */
1457 if (p
== linebuffer
|| *(p
- 1) != '\\')
1460 p
--; /* Put on top of '\'. */
1461 local_prompt
= (char *) 0;
1465 signal (STOP_SIGNAL
, SIG_DFL
);
1472 /* Do history expansion if that is wished. */
1473 if (history_expansion_p
&& instream
== stdin
1474 && ISATTY (instream
))
1476 char *history_value
;
1479 *p
= '\0'; /* Insert null now. */
1480 expanded
= history_expand (linebuffer
, &history_value
);
1483 /* Print the changes. */
1484 printf ("%s\n", history_value
);
1486 /* If there was an error, call this function again. */
1489 free (history_value
);
1490 return command_line_input (prrompt
, repeat
);
1492 if (strlen (history_value
) > linelength
)
1494 linelength
= strlen (history_value
) + 1;
1495 linebuffer
= (char *) xrealloc (linebuffer
, linelength
);
1497 strcpy (linebuffer
, history_value
);
1498 p
= linebuffer
+ strlen(linebuffer
);
1499 free (history_value
);
1503 /* If we just got an empty line, and that is supposed
1504 to repeat the previous command, return the value in the
1508 if (p
== linebuffer
)
1511 while (*p1
== ' ' || *p1
== '\t')
1519 /* Add line to history if appropriate. */
1520 if (instream
== stdin
1521 && ISATTY (stdin
) && *linebuffer
)
1522 add_history (linebuffer
);
1524 /* Note: lines consisting soley of comments are added to the command
1525 history. This is useful when you type a command, and then
1526 realize you don't want to execute it quite yet. You can comment
1527 out the command and then later fetch it from the value history
1528 and remove the '#'. The kill ring is probably better, but some
1529 people are in the habit of commenting things out. */
1531 while ((c
= *p1
++) != '\0')
1534 while ((c
= *p1
++) != '"')
1536 /* Make sure an escaped '"' doesn't make us think the string
1544 while ((c
= *p1
++) != '\'')
1546 /* Make sure an escaped '\'' doesn't make us think the string
1555 /* Found a comment. */
1561 /* Save into global buffer if appropriate. */
1564 if (linelength
> linesize
)
1566 line
= xrealloc (line
, linelength
);
1567 linesize
= linelength
;
1569 strcpy (line
, linebuffer
);
1576 /* Read lines from the input stream
1577 and accumulate them in a chain of struct command_line's
1578 which is then returned. */
1580 struct command_line
*
1581 read_command_lines ()
1583 struct command_line
*first
= 0;
1584 register struct command_line
*next
, *tail
= 0;
1585 register char *p
, *p1
;
1586 struct cleanup
*old_chain
= 0;
1591 p
= command_line_input ((char *) NULL
, instream
== stdin
);
1593 /* Treat end of file like "end". */
1596 /* Remove leading and trailing blanks. */
1597 while (*p
== ' ' || *p
== '\t') p
++;
1598 p1
= p
+ strlen (p
);
1599 while (p1
!= p
&& (p1
[-1] == ' ' || p1
[-1] == '\t')) p1
--;
1601 /* Is this "end"? */
1602 if (p1
- p
== 3 && !strncmp (p
, "end", 3))
1605 /* No => add this line to the chain of command lines. */
1606 next
= (struct command_line
*) xmalloc (sizeof (struct command_line
));
1607 next
->line
= savestring (p
, p1
- p
);
1615 /* We just read the first line.
1616 From now on, arrange to throw away the lines we have
1617 if we quit or get an error while inside this function. */
1619 old_chain
= make_cleanup (free_command_lines
, &first
);
1626 /* Now we are about to return the chain to our caller,
1627 so freeing it becomes his responsibility. */
1629 discard_cleanups (old_chain
);
1633 /* Free a chain of struct command_line's. */
1636 free_command_lines (lptr
)
1637 struct command_line
**lptr
;
1639 register struct command_line
*l
= *lptr
;
1640 register struct command_line
*next
;
1651 /* Add an element to the list of info subcommands. */
1654 add_info (name
, fun
, doc
)
1656 void (*fun
) PARAMS ((char *, int));
1659 add_cmd (name
, no_class
, fun
, doc
, &infolist
);
1662 /* Add an alias to the list of info subcommands. */
1665 add_info_alias (name
, oldname
, abbrev_flag
)
1670 add_alias_cmd (name
, oldname
, 0, abbrev_flag
, &infolist
);
1673 /* The "info" command is defined as a prefix, with allow_unknown = 0.
1674 Therefore, its own definition is called only for "info" with no args. */
1678 info_command (arg
, from_tty
)
1682 printf ("\"info\" must be followed by the name of an info command.\n");
1683 help_list (infolist
, "info ", -1, stdout
);
1686 /* The "show" command with no arguments shows all the settings. */
1690 show_command (arg
, from_tty
)
1694 cmd_show_list (showlist
, from_tty
, "");
1697 /* Add an element to the list of commands. */
1700 add_com (name
, class, fun
, doc
)
1702 enum command_class
class;
1703 void (*fun
) PARAMS ((char *, int));
1706 add_cmd (name
, class, fun
, doc
, &cmdlist
);
1709 /* Add an alias or abbreviation command to the list of commands. */
1712 add_com_alias (name
, oldname
, class, abbrev_flag
)
1715 enum command_class
class;
1718 add_alias_cmd (name
, oldname
, class, abbrev_flag
, &cmdlist
);
1725 error ("Argument required (%s).", why
);
1730 help_command (command
, from_tty
)
1732 int from_tty
; /* Ignored */
1734 help_cmd (command
, stdout
);
1738 validate_comname (comname
)
1744 error_no_arg ("name of command to define");
1749 if (!isalnum(*p
) && *p
!= '-')
1750 error ("Junk in argument list: \"%s\"", p
);
1755 /* This is just a placeholder in the command data structures. */
1757 user_defined_command (ignore
, from_tty
)
1764 define_command (comname
, from_tty
)
1768 register struct command_line
*cmds
;
1769 register struct cmd_list_element
*c
, *newc
, *hookc
= 0;
1770 char *tem
= comname
;
1771 #define HOOK_STRING "hook-"
1774 validate_comname (comname
);
1776 /* Look it up, and verify that we got an exact match. */
1777 c
= lookup_cmd (&tem
, cmdlist
, "", -1, 1);
1778 if (c
&& !STREQ (comname
, c
->name
))
1783 if (c
->class == class_user
|| c
->class == class_alias
)
1784 tem
= "Redefine command \"%s\"? ";
1786 tem
= "Really redefine built-in command \"%s\"? ";
1787 if (!query (tem
, c
->name
))
1788 error ("Command \"%s\" not redefined.", c
->name
);
1791 /* If this new command is a hook, then mark the command which it
1792 is hooking. Note that we allow hooking `help' commands, so that
1793 we can hook the `stop' pseudo-command. */
1795 if (!strncmp (comname
, HOOK_STRING
, HOOK_LEN
))
1797 /* Look up cmd it hooks, and verify that we got an exact match. */
1798 tem
= comname
+HOOK_LEN
;
1799 hookc
= lookup_cmd (&tem
, cmdlist
, "", -1, 0);
1800 if (hookc
&& !STREQ (comname
+HOOK_LEN
, hookc
->name
))
1804 warning ("Your new `%s' command does not hook any existing command.",
1806 if (!query ("Proceed? ", (char *)0))
1807 error ("Not confirmed.");
1811 comname
= savestring (comname
, strlen (comname
));
1813 /* If the rest of the commands will be case insensitive, this one
1814 should behave in the same manner. */
1815 for (tem
= comname
; *tem
; tem
++)
1816 if (isupper(*tem
)) *tem
= tolower(*tem
);
1820 printf ("Type commands for definition of \"%s\".\n\
1821 End with a line saying just \"end\".\n", comname
);
1825 cmds
= read_command_lines ();
1827 if (c
&& c
->class == class_user
)
1828 free_command_lines (&c
->user_commands
);
1830 newc
= add_cmd (comname
, class_user
, user_defined_command
,
1831 (c
&& c
->class == class_user
)
1832 ? c
->doc
: savestring ("User-defined.", 13), &cmdlist
);
1833 newc
->user_commands
= cmds
;
1835 /* If this new command is a hook, then mark both commands as being
1839 hookc
->hook
= newc
; /* Target gets hooked. */
1840 newc
->hookee
= hookc
; /* We are marked as hooking target cmd. */
1845 document_command (comname
, from_tty
)
1849 struct command_line
*doclines
;
1850 register struct cmd_list_element
*c
;
1851 char *tem
= comname
;
1853 validate_comname (comname
);
1855 c
= lookup_cmd (&tem
, cmdlist
, "", 0, 1);
1857 if (c
->class != class_user
)
1858 error ("Command \"%s\" is built-in.", comname
);
1861 printf ("Type documentation for \"%s\".\n\
1862 End with a line saying just \"end\".\n", comname
);
1864 doclines
= read_command_lines ();
1866 if (c
->doc
) free (c
->doc
);
1869 register struct command_line
*cl1
;
1870 register int len
= 0;
1872 for (cl1
= doclines
; cl1
; cl1
= cl1
->next
)
1873 len
+= strlen (cl1
->line
) + 1;
1875 c
->doc
= (char *) xmalloc (len
+ 1);
1878 for (cl1
= doclines
; cl1
; cl1
= cl1
->next
)
1880 strcat (c
->doc
, cl1
->line
);
1882 strcat (c
->doc
, "\n");
1886 free_command_lines (&doclines
);
1890 print_gnu_advertisement()
1893 GDB is free software and you are welcome to distribute copies of it\n\
1894 under certain conditions; type \"show copying\" to see the conditions.\n\
1895 There is absolutely no warranty for GDB; type \"show warranty\" for details.\n\
1900 print_gdb_version (stream
)
1903 fprintf_filtered (stream
, "\
1904 GDB %s (%s", version
, host_canonical
);
1906 if (strcmp(host_canonical
, target_canonical
))
1907 fprintf_filtered (stream
, " --target %s", target_canonical
);
1909 fprintf_filtered (stream
, "), ");
1911 fprintf_filtered (stream
, "Copyright 1993 Free Software Foundation, Inc.");
1916 show_version (args
, from_tty
)
1921 print_gnu_advertisement ();
1922 print_gdb_version (stdout
);
1923 printf_filtered ("\n");
1927 /* xgdb calls this to reprint the usual GDB prompt. */
1932 printf ("%s", prompt
);
1937 quit_command (args
, from_tty
)
1941 if (inferior_pid
!= 0 && target_has_execution
)
1945 if (query ("The program is running. Quit anyway (and detach it)? "))
1946 target_detach (args
, from_tty
);
1948 error ("Not confirmed.");
1952 if (query ("The program is running. Quit anyway (and kill it)? "))
1955 error ("Not confirmed.");
1958 /* Save the history information if it is appropriate to do so. */
1959 if (write_history_p
&& history_filename
)
1960 write_history (history_filename
);
1964 /* Returns whether GDB is running on a terminal and whether the user
1965 desires that questions be asked of them on that terminal. */
1968 input_from_terminal_p ()
1970 return gdb_has_a_terminal
&& (instream
== stdin
) & caution
;
1975 pwd_command (args
, from_tty
)
1979 if (args
) error ("The \"pwd\" command does not take an argument: %s", args
);
1980 getcwd (dirbuf
, sizeof (dirbuf
));
1982 if (!STREQ (dirbuf
, current_directory
))
1983 printf ("Working directory %s\n (canonically %s).\n",
1984 current_directory
, dirbuf
);
1986 printf ("Working directory %s.\n", current_directory
);
1990 cd_command (dir
, from_tty
)
1997 /* If the new directory is absolute, repeat is a no-op; if relative,
1998 repeat might be useful but is more likely to be a mistake. */
2002 error_no_arg ("new working directory");
2004 dir
= tilde_expand (dir
);
2005 make_cleanup (free
, dir
);
2007 if (chdir (dir
) < 0)
2008 perror_with_name (dir
);
2011 dir
= savestring (dir
, len
- (len
> 1 && dir
[len
-1] == '/'));
2013 current_directory
= dir
;
2016 current_directory
= concat (current_directory
, "/", dir
, NULL
);
2020 /* Now simplify any occurrences of `.' and `..' in the pathname. */
2028 for (p
= current_directory
; *p
;)
2030 if (!strncmp (p
, "/./", 2)
2031 && (p
[2] == 0 || p
[2] == '/'))
2033 else if (!strncmp (p
, "/..", 3)
2034 && (p
[3] == 0 || p
[3] == '/')
2035 && p
!= current_directory
)
2038 while (q
!= current_directory
&& q
[-1] != '/') q
--;
2039 if (q
!= current_directory
)
2049 forget_cached_source_info ();
2052 pwd_command ((char *) 0, 1);
2057 source_command (args
, from_tty
)
2062 struct cleanup
*cleanups
;
2067 error ("source command requires pathname of file to source.");
2070 file
= tilde_expand (file
);
2071 make_cleanup (free
, file
);
2073 stream
= fopen (file
, FOPEN_RT
);
2075 perror_with_name (file
);
2077 cleanups
= make_cleanup (fclose
, stream
);
2079 read_command_file (stream
);
2081 do_cleanups (cleanups
);
2086 echo_command (text
, from_tty
)
2094 while ((c
= *p
++) != '\0')
2098 /* \ at end of argument is used after spaces
2099 so they won't be lost. */
2103 c
= parse_escape (&p
);
2105 printf_filtered ("%c", c
);
2108 printf_filtered ("%c", c
);
2111 /* Force this output to appear now. */
2117 /* Functions to manipulate command line editing control variables. */
2119 /* Number of commands to print in each call to show_commands. */
2120 #define Hist_print 10
2122 show_commands (args
, from_tty
)
2126 /* Index for history commands. Relative to history_base. */
2129 /* Number of the history entry which we are planning to display next.
2130 Relative to history_base. */
2133 /* The first command in the history which doesn't exist (i.e. one more
2134 than the number of the last command). Relative to history_base. */
2137 extern struct _hist_entry
*history_get
PARAMS ((int));
2138 extern int history_base
;
2140 /* Print out some of the commands from the command history. */
2141 /* First determine the length of the history list. */
2142 hist_len
= history_size
;
2143 for (offset
= 0; offset
< history_size
; offset
++)
2145 if (!history_get (history_base
+ offset
))
2154 if (args
[0] == '+' && args
[1] == '\0')
2155 /* "info editing +" should print from the stored position. */
2158 /* "info editing <exp>" should print around command number <exp>. */
2159 num
= (parse_and_eval_address (args
) - history_base
) - Hist_print
/ 2;
2161 /* "show commands" means print the last Hist_print commands. */
2164 num
= hist_len
- Hist_print
;
2170 /* If there are at least Hist_print commands, we want to display the last
2171 Hist_print rather than, say, the last 6. */
2172 if (hist_len
- num
< Hist_print
)
2174 num
= hist_len
- Hist_print
;
2179 for (offset
= num
; offset
< num
+ Hist_print
&& offset
< hist_len
; offset
++)
2181 printf_filtered ("%5d %s\n", history_base
+ offset
,
2182 (history_get (history_base
+ offset
))->line
);
2185 /* The next command we want to display is the next one that we haven't
2189 /* If the user repeats this command with return, it should do what
2190 "show commands +" does. This is unnecessary if arg is null,
2191 because "show commands +" is not useful after "show commands". */
2192 if (from_tty
&& args
)
2199 /* Called by do_setshow_command. */
2202 set_history_size_command (args
, from_tty
, c
)
2205 struct cmd_list_element
*c
;
2207 if (history_size
== INT_MAX
)
2208 unstifle_history ();
2209 else if (history_size
>= 0)
2210 stifle_history (history_size
);
2213 history_size
= INT_MAX
;
2214 error ("History size must be non-negative");
2220 set_history (args
, from_tty
)
2224 printf ("\"set history\" must be followed by the name of a history subcommand.\n");
2225 help_list (sethistlist
, "set history ", -1, stdout
);
2230 show_history (args
, from_tty
)
2234 cmd_show_list (showhistlist
, from_tty
, "");
2237 int info_verbose
= 0; /* Default verbose msgs off */
2239 /* Called by do_setshow_command. An elaborate joke. */
2242 set_verbose (args
, from_tty
, c
)
2245 struct cmd_list_element
*c
;
2247 char *cmdname
= "verbose";
2248 struct cmd_list_element
*showcmd
;
2250 showcmd
= lookup_cmd_1 (&cmdname
, showlist
, NULL
, 1);
2254 c
->doc
= "Set verbose printing of informational messages.";
2255 showcmd
->doc
= "Show verbose printing of informational messages.";
2259 c
->doc
= "Set verbosity.";
2260 showcmd
->doc
= "Show verbosity.";
2265 float_handler (signo
)
2268 /* This message is based on ANSI C, section 4.7. Note that integer
2269 divide by zero causes this, so "float" is a misnomer. */
2270 signal (SIGFPE
, float_handler
);
2271 error ("Erroneous arithmetic operation.");
2274 /* Return whether we are running a batch file or from terminal. */
2278 return !(instream
== stdin
&& ISATTY (stdin
));
2283 initialize_cmd_lists ()
2290 enablebreaklist
= NULL
;
2295 showhistlist
= NULL
;
2296 unsethistlist
= NULL
;
2297 #if MAINTENANCE_CMDS
2298 maintenancelist
= NULL
;
2299 maintenanceinfolist
= NULL
;
2300 maintenanceprintlist
= NULL
;
2302 setprintlist
= NULL
;
2303 showprintlist
= NULL
;
2304 setchecklist
= NULL
;
2305 showchecklist
= NULL
;
2308 /* Init the history buffer. Note that we are called after the init file(s)
2309 * have been read so that the user can change the history file via his
2310 * .gdbinit file (for instance). The GDBHISTFILE environment variable
2311 * overrides all of this.
2315 initialize_history()
2319 tmpenv
= getenv ("HISTSIZE");
2321 history_size
= atoi (tmpenv
);
2322 else if (!history_size
)
2325 stifle_history (history_size
);
2327 tmpenv
= getenv ("GDBHISTFILE");
2329 history_filename
= savestring (tmpenv
, strlen(tmpenv
));
2330 else if (!history_filename
) {
2331 /* We include the current directory so that if the user changes
2332 directories the file written will be the same as the one
2334 history_filename
= concat (current_directory
, "/.gdb_history", NULL
);
2336 read_history (history_filename
);
2342 struct cmd_list_element
*c
;
2344 #ifdef DEFAULT_PROMPT
2345 prompt
= savestring (DEFAULT_PROMPT
, strlen(DEFAULT_PROMPT
));
2347 prompt
= savestring ("(gdb) ", 6);
2350 /* Set the important stuff up for command editing. */
2351 command_editing_p
= 1;
2352 history_expansion_p
= 0;
2353 write_history_p
= 0;
2355 /* Setup important stuff for command line editing. */
2356 rl_completion_entry_function
= (int (*)()) symbol_completion_function
;
2357 rl_completer_word_break_characters
= gdb_completer_word_break_characters
;
2358 rl_completer_quote_characters
= gdb_completer_quote_characters
;
2359 rl_readline_name
= "gdb";
2361 /* Define the classes of commands.
2362 They will appear in the help list in the reverse of this order. */
2364 add_cmd ("internals", class_maintenance
, NO_FUNCTION
,
2365 "Maintenance commands.\n\
2366 Some gdb commands are provided just for use by gdb maintainers.\n\
2367 These commands are subject to frequent change, and may not be as\n\
2368 well documented as user commands.",
2370 add_cmd ("obscure", class_obscure
, NO_FUNCTION
, "Obscure features.", &cmdlist
);
2371 add_cmd ("aliases", class_alias
, NO_FUNCTION
, "Aliases of other commands.", &cmdlist
);
2372 add_cmd ("user-defined", class_user
, NO_FUNCTION
, "User-defined commands.\n\
2373 The commands in this class are those defined by the user.\n\
2374 Use the \"define\" command to define a command.", &cmdlist
);
2375 add_cmd ("support", class_support
, NO_FUNCTION
, "Support facilities.", &cmdlist
);
2376 add_cmd ("status", class_info
, NO_FUNCTION
, "Status inquiries.", &cmdlist
);
2377 add_cmd ("files", class_files
, NO_FUNCTION
, "Specifying and examining files.", &cmdlist
);
2378 add_cmd ("breakpoints", class_breakpoint
, NO_FUNCTION
, "Making program stop at certain points.", &cmdlist
);
2379 add_cmd ("data", class_vars
, NO_FUNCTION
, "Examining data.", &cmdlist
);
2380 add_cmd ("stack", class_stack
, NO_FUNCTION
, "Examining the stack.\n\
2381 The stack is made up of stack frames. Gdb assigns numbers to stack frames\n\
2382 counting from zero for the innermost (currently executing) frame.\n\n\
2383 At any time gdb identifies one frame as the \"selected\" frame.\n\
2384 Variable lookups are done with respect to the selected frame.\n\
2385 When the program being debugged stops, gdb selects the innermost frame.\n\
2386 The commands below can be used to select other frames by number or address.",
2388 add_cmd ("running", class_run
, NO_FUNCTION
, "Running the program.", &cmdlist
);
2390 add_com ("pwd", class_files
, pwd_command
,
2391 "Print working directory. This is used for your program as well.");
2392 add_com ("cd", class_files
, cd_command
,
2393 "Set working directory to DIR for debugger and program being debugged.\n\
2394 The change does not take effect for the program being debugged\n\
2395 until the next time it is started.");
2398 (add_set_cmd ("prompt", class_support
, var_string
, (char *)&prompt
,
2403 add_com ("echo", class_support
, echo_command
,
2404 "Print a constant string. Give string as argument.\n\
2405 C escape sequences may be used in the argument.\n\
2406 No newline is added at the end of the argument;\n\
2407 use \"\\n\" if you want a newline to be printed.\n\
2408 Since leading and trailing whitespace are ignored in command arguments,\n\
2409 if you want to print some you must use \"\\\" before leading whitespace\n\
2410 to be printed or after trailing whitespace.");
2411 add_com ("document", class_support
, document_command
,
2412 "Document a user-defined command.\n\
2413 Give command name as argument. Give documentation on following lines.\n\
2414 End with a line of just \"end\".");
2415 add_com ("define", class_support
, define_command
,
2416 "Define a new command name. Command name is argument.\n\
2417 Definition appears on following lines, one command per line.\n\
2418 End with a line of just \"end\".\n\
2419 Use the \"document\" command to give documentation for the new command.\n\
2420 Commands defined in this way do not take arguments.");
2423 add_com ("source", class_support
, source_command
,
2424 "Read commands from a file named FILE.\n\
2425 Note that the file \"" GDBINIT_FILENAME
"\" is read automatically in this way\n\
2426 when gdb is started.");
2428 /* Punt file name, we can't help it easily. */
2429 add_com ("source", class_support
, source_command
,
2430 "Read commands from a file named FILE.\n\
2431 Note that the file \".gdbinit\" is read automatically in this way\n\
2432 when gdb is started.");
2435 add_com ("quit", class_support
, quit_command
, "Exit gdb.");
2436 add_com ("help", class_support
, help_command
, "Print list of commands.");
2437 add_com_alias ("q", "quit", class_support
, 1);
2438 add_com_alias ("h", "help", class_support
, 1);
2441 c
= add_set_cmd ("verbose", class_support
, var_boolean
, (char *)&info_verbose
,
2444 add_show_from_set (c
, &showlist
);
2445 c
->function
.sfunc
= set_verbose
;
2446 set_verbose (NULL
, 0, c
);
2449 (add_set_cmd ("editing", class_support
, var_boolean
, (char *)&command_editing_p
,
2450 "Set editing of command lines as they are typed.\n\
2451 Use \"on\" to enable to enable the editing, and \"off\" to disable it.\n\
2452 Without an argument, command line editing is enabled. To edit, use\n\
2453 EMACS-like or VI-like commands like control-P or ESC.", &setlist
),
2456 add_prefix_cmd ("history", class_support
, set_history
,
2457 "Generic command for setting command history parameters.",
2458 &sethistlist
, "set history ", 0, &setlist
);
2459 add_prefix_cmd ("history", class_support
, show_history
,
2460 "Generic command for showing command history parameters.",
2461 &showhistlist
, "show history ", 0, &showlist
);
2464 (add_set_cmd ("expansion", no_class
, var_boolean
, (char *)&history_expansion_p
,
2465 "Set history expansion on command input.\n\
2466 Without an argument, history expansion is enabled.", &sethistlist
),
2470 (add_set_cmd ("save", no_class
, var_boolean
, (char *)&write_history_p
,
2471 "Set saving of the history record on exit.\n\
2472 Use \"on\" to enable to enable the saving, and \"off\" to disable it.\n\
2473 Without an argument, saving is enabled.", &sethistlist
),
2476 c
= add_set_cmd ("size", no_class
, var_integer
, (char *)&history_size
,
2477 "Set the size of the command history, \n\
2478 ie. the number of previous commands to keep a record of.", &sethistlist
);
2479 add_show_from_set (c
, &showhistlist
);
2480 c
->function
.sfunc
= set_history_size_command
;
2483 (add_set_cmd ("filename", no_class
, var_filename
, (char *)&history_filename
,
2484 "Set the filename in which to record the command history\n\
2485 (the list of previous commands of which a record is kept).", &sethistlist
),
2489 (add_set_cmd ("confirm", class_support
, var_boolean
,
2491 "Set whether to confirm potentially dangerous operations.",
2495 add_prefix_cmd ("info", class_info
, info_command
,
2496 "Generic command for showing things about the program being debugged.",
2497 &infolist
, "info ", 0, &cmdlist
);
2498 add_com_alias ("i", "info", class_info
, 1);
2500 add_prefix_cmd ("show", class_info
, show_command
,
2501 "Generic command for showing things about the debugger.",
2502 &showlist
, "show ", 0, &cmdlist
);
2503 /* Another way to get at the same thing. */
2504 add_info ("set", show_command
, "Show all GDB settings.");
2506 add_cmd ("commands", no_class
, show_commands
,
2507 "Show the the history of commands you typed.\n\
2508 You can supply a command number to start with, or a `+' to start after\n\
2509 the previous command number shown.",
2512 add_cmd ("version", no_class
, show_version
,
2513 "Show what version of GDB this is.", &showlist
);