1 /* Top level stuff for GDB, the GNU debugger.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994
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"
32 #include "terminal.h" /* For job_control. */
37 /* readline include files */
41 /* readline defines this. */
44 #include <sys/types.h>
46 /* What is this for? X_OK? */
54 #include <sys/param.h>
58 /* Prototypes for local functions */
61 symbol_completion_function
PARAMS ((char *, int));
64 command_loop_marker
PARAMS ((int));
67 init_main
PARAMS ((void));
70 init_cmd_lists
PARAMS ((void));
73 float_handler
PARAMS ((int));
76 init_signals
PARAMS ((void));
79 set_verbose
PARAMS ((char *, int, struct cmd_list_element
*));
82 show_history
PARAMS ((char *, int));
85 set_history
PARAMS ((char *, int));
88 set_history_size_command
PARAMS ((char *, int, struct cmd_list_element
*));
91 show_commands
PARAMS ((char *, int));
94 echo_command
PARAMS ((char *, int));
97 pwd_command
PARAMS ((char *, int));
100 show_version
PARAMS ((char *, int));
103 document_command
PARAMS ((char *, int));
106 define_command
PARAMS ((char *, int));
109 validate_comname
PARAMS ((char *));
112 help_command
PARAMS ((char *, int));
115 show_command
PARAMS ((char *, int));
118 info_command
PARAMS ((char *, int));
121 complete_command
PARAMS ((char *, int));
124 do_nothing
PARAMS ((int));
127 quit_cover
PARAMS ((char *));
130 disconnect
PARAMS ((int));
133 source_cleanup
PARAMS ((FILE *));
135 /* If this definition isn't overridden by the header files, assume
136 that isatty and fileno exist on this system. */
138 #define ISATTY(FP) (isatty (fileno (FP)))
141 /* Initialization file name for gdb. This is overridden in some configs. */
143 #ifndef GDBINIT_FILENAME
144 #define GDBINIT_FILENAME ".gdbinit"
146 char gdbinit
[] = GDBINIT_FILENAME
;
147 int inhibit_gdbinit
= 0;
149 /* Version number of GDB, as a string. */
151 extern char *version
;
153 /* Canonical host name as a string. */
155 extern char *host_name
;
157 /* Canonical target name as a string. */
159 extern char *target_name
;
161 extern char lang_frame_mismatch_warn
[]; /* language.c */
163 /* Flag for whether we want all the "from_tty" gubbish printed. */
165 int caution
= 1; /* Default is yes, sigh. */
168 * Define all cmd_list_element's
171 /* Chain containing all defined commands. */
173 struct cmd_list_element
*cmdlist
;
175 /* Chain containing all defined info subcommands. */
177 struct cmd_list_element
*infolist
;
179 /* Chain containing all defined enable subcommands. */
181 struct cmd_list_element
*enablelist
;
183 /* Chain containing all defined disable subcommands. */
185 struct cmd_list_element
*disablelist
;
187 /* Chain containing all defined delete subcommands. */
189 struct cmd_list_element
*deletelist
;
191 /* Chain containing all defined "enable breakpoint" subcommands. */
193 struct cmd_list_element
*enablebreaklist
;
195 /* Chain containing all defined set subcommands */
197 struct cmd_list_element
*setlist
;
199 /* Chain containing all defined unset subcommands */
201 struct cmd_list_element
*unsetlist
;
203 /* Chain containing all defined show subcommands. */
205 struct cmd_list_element
*showlist
;
207 /* Chain containing all defined \"set history\". */
209 struct cmd_list_element
*sethistlist
;
211 /* Chain containing all defined \"show history\". */
213 struct cmd_list_element
*showhistlist
;
215 /* Chain containing all defined \"unset history\". */
217 struct cmd_list_element
*unsethistlist
;
219 /* Chain containing all defined maintenance subcommands. */
222 struct cmd_list_element
*maintenancelist
;
225 /* Chain containing all defined "maintenance info" subcommands. */
228 struct cmd_list_element
*maintenanceinfolist
;
231 /* Chain containing all defined "maintenance print" subcommands. */
234 struct cmd_list_element
*maintenanceprintlist
;
237 struct cmd_list_element
*setprintlist
;
239 struct cmd_list_element
*showprintlist
;
241 struct cmd_list_element
*setchecklist
;
243 struct cmd_list_element
*showchecklist
;
245 /* stdio stream that command input is being read from. Set to stdin normally.
246 Set by source_command to the file we are sourcing. Set to NULL if we are
247 executing a user-defined command. */
251 /* Current working directory. */
253 char *current_directory
;
255 /* The directory name is actually stored here (usually). */
258 /* Function to call before reading a command, if nonzero.
259 The function receives two args: an input stream,
260 and a prompt string. */
262 void (*window_hook
) PARAMS ((FILE *, char *));
267 /* gdb prints this when reading a command interactively */
270 /* Buffer used for reading command lines, and the size
271 allocated for it so far. */
276 /* Nonzero if the current command is modified by "server ". This
277 affects things like recording into the command history, comamnds
278 repeating on RETURN, etc. This is so a user interface (emacs, GUI,
279 whatever) can issue its own commands and also send along commands
280 from the user, and have the user not notice that the user interface
281 is issuing commands too. */
284 /* Baud rate specified for talking to serial target systems. Default
285 is left as -1, so targets can choose their own defaults. */
286 /* FIXME: This means that "show remotebaud" and gr_files_info can print -1
287 or (unsigned int)-1. This is a Bad User Interface. */
291 /* Non-zero tells remote* modules to output debugging info. */
293 int remote_debug
= 0;
295 /* Signal to catch ^Z typed while reading a command: SIGTSTP or SIGCONT. */
299 #define STOP_SIGNAL SIGTSTP
300 static void stop_sig
PARAMS ((int));
304 /* Some System V have job control but not sigsetmask(). */
305 #if !defined (HAVE_SIGSETMASK)
307 #define HAVE_SIGSETMASK 1
309 #define HAVE_SIGSETMASK 0
313 #if 0 == (HAVE_SIGSETMASK)
314 #define sigsetmask(n)
317 /* Where to go for return_to_top_level (RETURN_ERROR). */
318 jmp_buf error_return
;
319 /* Where to go for return_to_top_level (RETURN_QUIT). */
322 /* Return for reason REASON. This generally gets back to the command
323 loop, but can be caught via catch_errors. */
326 return_to_top_level (reason
)
327 enum return_reason reason
;
332 /* Perhaps it would be cleaner to do this via the cleanup chain (not sure
333 I can think of a reason why that is vital, though). */
334 bpstat_clear_actions(stop_bpstat
); /* Clear queued breakpoint commands */
336 disable_current_display ();
337 do_cleanups (ALL_CLEANUPS
);
339 if (annotation_level
> 1)
350 (NORETURN
void) longjmp
351 (reason
== RETURN_ERROR
? error_return
: quit_return
, 1);
354 /* Call FUNC with arg ARGS, catching any errors. If there is no
355 error, return the value returned by FUNC. If there is an error,
356 print ERRSTRING, print the specific error message, then return
359 Must not be called with immediate_quit in effect (bad things might
360 happen, say we got a signal in the middle of a memcpy to quit_return).
361 This is an OK restriction; with very few exceptions immediate_quit can
362 be replaced by judicious use of QUIT.
364 MASK specifies what to catch; it is normally set to
365 RETURN_MASK_ALL, if for no other reason than that the code which
366 calls catch_errors might not be set up to deal with a quit which
367 isn't caught. But if the code can deal with it, it generally
368 should be RETURN_MASK_ERROR, unless for some reason it is more
369 useful to abort only the portion of the operation inside the
370 catch_errors. Note that quit should return to the command line
371 fairly quickly, even if some further processing is being done. */
374 catch_errors (func
, args
, errstring
, mask
)
375 int (*func
) PARAMS ((char *));
384 struct cleanup
*saved_cleanup_chain
;
385 char *saved_error_pre_print
;
387 saved_cleanup_chain
= save_cleanups ();
388 saved_error_pre_print
= error_pre_print
;
390 if (mask
& RETURN_MASK_ERROR
)
391 memcpy ((char *)saved_error
, (char *)error_return
, sizeof (jmp_buf));
392 if (mask
& RETURN_MASK_QUIT
)
393 memcpy (saved_quit
, quit_return
, sizeof (jmp_buf));
394 error_pre_print
= errstring
;
396 if (setjmp (tmp_jmp
) == 0)
398 if (mask
& RETURN_MASK_ERROR
)
399 memcpy (error_return
, tmp_jmp
, sizeof (jmp_buf));
400 if (mask
& RETURN_MASK_QUIT
)
401 memcpy (quit_return
, tmp_jmp
, sizeof (jmp_buf));
402 val
= (*func
) (args
);
407 restore_cleanups (saved_cleanup_chain
);
409 error_pre_print
= saved_error_pre_print
;
410 if (mask
& RETURN_MASK_ERROR
)
411 memcpy (error_return
, saved_error
, sizeof (jmp_buf));
412 if (mask
& RETURN_MASK_QUIT
)
413 memcpy (quit_return
, saved_quit
, sizeof (jmp_buf));
417 /* Handler for SIGHUP. */
423 catch_errors (quit_cover
, NULL
,
424 "Could not kill the program being debugged", RETURN_MASK_ALL
);
425 signal (SIGHUP
, SIG_DFL
);
426 kill (getpid (), SIGHUP
);
429 /* Just a little helper function for disconnect(). */
435 caution
= 0; /* Throw caution to the wind -- we're exiting.
436 This prevents asking the user dumb questions. */
437 quit_command((char *)0, 0);
441 /* Line number we are currently in in a file which is being sourced. */
442 static int source_line_number
;
444 /* Name of the file we are sourcing. */
445 static char *source_file_name
;
447 /* Buffer containing the error_pre_print used by the source stuff.
449 static char *source_error
;
450 static int source_error_allocated
;
452 /* Something to glom on to the start of error_pre_print if source_file_name
454 static char *source_pre_error
;
456 /* Clean up on error during a "source" command (or execution of a
457 user-defined command). */
460 source_cleanup (stream
)
463 /* Restore the previous input stream. */
467 /* Read commands from STREAM. */
469 read_command_file (stream
)
472 struct cleanup
*cleanups
;
474 cleanups
= make_cleanup (source_cleanup
, instream
);
477 do_cleanups (cleanups
);
480 extern void init_proc ();
485 /* Run the init function of each source file */
487 init_cmd_lists (); /* This needs to be done first */
488 initialize_all_files ();
489 init_main (); /* But that omits this file! Do it now */
494 /* We need a default language for parsing expressions, so simple things like
495 "set width 0" won't fail if no language is explicitly set in a config file
496 or implicitly set by reading an executable during startup. */
497 set_language (language_c
);
498 expected_language
= current_language
; /* don't warn about the change. */
502 execute_user_command (c
, args
)
503 struct cmd_list_element
*c
;
506 register struct command_line
*cmdlines
;
507 struct cleanup
*old_chain
;
510 error ("User-defined commands cannot take arguments.");
512 cmdlines
= c
->user_commands
;
517 /* Set the instream to 0, indicating execution of a
518 user-defined function. */
519 old_chain
= make_cleanup (source_cleanup
, instream
);
520 instream
= (FILE *) 0;
523 execute_command (cmdlines
->line
, 0);
524 cmdlines
= cmdlines
->next
;
526 do_cleanups (old_chain
);
529 /* Execute the line P as a command.
530 Pass FROM_TTY as second argument to the defining function. */
533 execute_command (p
, from_tty
)
537 register struct cmd_list_element
*c
;
538 register enum language flang
;
539 static int warned
= 0;
543 /* This can happen when command_line_input hits end of file. */
547 while (*p
== ' ' || *p
== '\t') p
++;
552 c
= lookup_cmd (&p
, cmdlist
, "", 0, 1);
553 /* Pass null arg rather than an empty one. */
556 /* If this command has been hooked, run the hook first. */
558 execute_user_command (c
->hook
, (char *)0);
560 if (c
->class == class_user
)
561 execute_user_command (c
, arg
);
562 else if (c
->type
== set_cmd
|| c
->type
== show_cmd
)
563 do_setshow_command (arg
, from_tty
& caution
, c
);
564 else if (c
->function
.cfunc
== NO_FUNCTION
)
565 error ("That is not a command, just a help topic.");
567 (*c
->function
.cfunc
) (arg
, from_tty
& caution
);
570 /* Tell the user if the language has changed (except first time). */
571 if (current_language
!= expected_language
)
573 if (language_mode
== language_mode_auto
) {
574 language_info (1); /* Print what changed. */
579 /* Warn the user if the working language does not match the
580 language of the current frame. Only warn the user if we are
581 actually running the program, i.e. there is a stack. */
582 /* FIXME: This should be cacheing the frame and only running when
583 the frame changes. */
584 if (target_has_stack
)
586 flang
= get_frame_language ();
588 && flang
!= language_unknown
589 && flang
!= current_language
->la_language
)
591 printf_filtered ("%s\n", lang_frame_mismatch_warn
);
599 command_loop_marker (foo
)
604 /* Read commands from `instream' and execute them
605 until end of file or error reading instream. */
609 struct cleanup
*old_chain
;
611 int stdin_is_tty
= ISATTY (stdin
);
613 while (!feof (instream
))
615 if (window_hook
&& instream
== stdin
)
616 (*window_hook
) (instream
, prompt
);
619 if (instream
== stdin
&& stdin_is_tty
)
620 reinitialize_more_filter ();
621 old_chain
= make_cleanup (command_loop_marker
, 0);
622 command
= command_line_input (instream
== stdin
? prompt
: (char *) NULL
,
623 instream
== stdin
, "prompt");
626 execute_command (command
, instream
== stdin
);
627 /* Do any commands attached to breakpoint we stopped at. */
628 bpstat_do_actions (&stop_bpstat
);
629 do_cleanups (old_chain
);
633 /* Commands call this if they do not want to be repeated by null lines. */
641 /* If we aren't reading from standard input, we are saving the last
642 thing read from stdin in line and don't want to delete it. Null lines
643 won't repeat here in any case. */
644 if (instream
== stdin
)
648 /* Read a line from the stream "instream" without command line editing.
650 It prints PRROMPT once at the start.
651 Action is compatible with "readline", e.g. space for the result is
652 malloc'd and should be freed by the caller.
654 A NULL return means end of file. */
656 gdb_readline (prrompt
)
662 int result_size
= 80;
666 /* Don't use a _filtered function here. It causes the assumed
667 character position to be off, since the newline we read from
668 the user is not accounted for. */
669 fputs_unfiltered (prrompt
, gdb_stdout
);
670 /* start-sanitize-mpw */
672 /* Move to a new line so the entered line doesn't have a prompt
673 on the front of it. */
674 fputs_unfiltered ("\n", gdb_stdout
);
676 /* end-sanitize-mpw */
677 gdb_flush (gdb_stdout
);
680 result
= (char *) xmalloc (result_size
);
684 /* Read from stdin if we are executing a user defined command.
685 This is the right thing for prompt_for_continue, at least. */
686 c
= fgetc (instream
? instream
: stdin
);
691 /* The last line does not end with a newline. Return it, and
692 if we are called again fgetc will still return EOF and
693 we'll return NULL then. */
702 result
[input_index
++] = c
;
703 while (input_index
>= result_size
)
706 result
= (char *) xrealloc (result
, result_size
);
710 result
[input_index
++] = '\0';
714 /* Variables which control command line editing and history
715 substitution. These variables are given default values at the end
717 static int command_editing_p
;
718 static int history_expansion_p
;
719 static int write_history_p
;
720 static int history_size
;
721 static char *history_filename
;
723 /* readline uses the word breaks for two things:
724 (1) In figuring out where to point the TEXT parameter to the
725 rl_completion_entry_function. Since we don't use TEXT for much,
726 it doesn't matter a lot what the word breaks are for this purpose, but
727 it does affect how much stuff M-? lists.
728 (2) If one of the matches contains a word break character, readline
729 will quote it. That's why we switch between
730 gdb_completer_word_break_characters and
731 gdb_completer_command_word_break_characters. I'm not sure when
732 we need this behavior (perhaps for funky characters in C++ symbols?). */
734 /* Variables which are necessary for fancy command line editing. */
735 char *gdb_completer_word_break_characters
=
736 " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,-";
738 /* When completing on command names, we remove '-' from the list of
739 word break characters, since we use it in command names. If the
740 readline library sees one in any of the current completion strings,
741 it thinks that the string needs to be quoted and automatically supplies
743 char *gdb_completer_command_word_break_characters
=
744 " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,";
746 /* Characters that can be used to quote completion strings. Note that we
747 can't include '"' because the gdb C parser treats such quoted sequences
749 char *gdb_completer_quote_characters
=
752 /* Functions that are used as part of the fancy command line editing. */
754 /* This can be used for functions which don't want to complete on symbols
755 but don't want to complete on anything else either. */
758 noop_completer (text
, prefix
)
765 /* Complete on filenames. */
767 filename_completer (text
, word
)
772 extern char *filename_completion_function ();
776 int return_val_alloced
;
779 /* Small for testing. */
780 return_val_alloced
= 1;
781 return_val
= (char **) xmalloc (return_val_alloced
* sizeof (char *));
787 p
= filename_completion_function (text
, subsequent_name
);
788 if (return_val_used
>= return_val_alloced
)
790 return_val_alloced
*= 2;
792 (char **) xrealloc (return_val
,
793 return_val_alloced
* sizeof (char *));
797 return_val
[return_val_used
++] = p
;
800 /* Like emacs, don't complete on old versions. Especially useful
801 in the "source" command. */
802 if (p
[strlen (p
) - 1] == '~')
808 /* Return exactly p. */
809 return_val
[return_val_used
++] = p
;
810 else if (word
> text
)
812 /* Return some portion of p. */
813 q
= xmalloc (strlen (p
) + 5);
814 strcpy (q
, p
+ (word
- text
));
815 return_val
[return_val_used
++] = q
;
820 /* Return some of TEXT plus p. */
821 q
= xmalloc (strlen (p
) + (text
- word
) + 5);
822 strncpy (q
, word
, text
- word
);
823 q
[text
- word
] = '\0';
825 return_val
[return_val_used
++] = q
;
832 /* There is no way to do this just long enough to affect quote inserting
833 without also affecting the next completion. This should be fixed in
835 /* Insure that readline does the right thing
836 with respect to inserting quotes. */
837 rl_completer_word_break_characters
= "";
842 /* Here are some useful test cases for completion. FIXME: These should
843 be put in the test suite. They should be tested with both M-? and TAB.
845 "show output-" "radix"
846 "show output" "-radix"
847 "p" ambiguous (commands starting with p--path, print, printf, etc.)
848 "p " ambiguous (all symbols)
849 "info t foo" no completions
850 "info t " no completions
851 "info t" ambiguous ("info target", "info terminal", etc.)
852 "info ajksdlfk" no completions
853 "info ajksdlfk " no completions
855 "info " ambiguous (all info commands)
856 "p \"a" no completions (string constant)
857 "p 'a" ambiguous (all symbols starting with a)
858 "p b-a" ambiguous (all symbols starting with a)
859 "p b-" ambiguous (all symbols)
860 "file Make" "file" (word break hard to screw up here)
861 "file ../gdb.stabs/we" "ird" (needs to not break word at slash)
864 /* Generate completions one by one for the completer. Each time we are
865 called return another potential completion to the caller. The function
866 is misnamed; it just completes on commands or passes the buck to the
867 command's completer function; the stuff specific to symbol completion
868 is in make_symbol_completion_list.
870 TEXT is readline's idea of the "word" we are looking at; we don't really
871 like readline's ideas about word breaking so we ignore it.
873 MATCHES is the number of matches that have currently been collected from
874 calling this completion function. When zero, then we need to initialize,
875 otherwise the initialization has already taken place and we can just
876 return the next potential completion string.
878 Returns NULL if there are no more completions, else a pointer to a string
879 which is a possible completion.
881 RL_LINE_BUFFER is available to be looked at; it contains the entire text
882 of the line. RL_POINT is the offset in that line of the cursor. You
883 should pretend that the line ends at RL_POINT. */
886 symbol_completion_function (text
, matches
)
890 static char **list
= (char **)NULL
; /* Cache of completions */
891 static int index
; /* Next cached completion */
893 char *tmp_command
, *p
;
894 /* Pointer within tmp_command which corresponds to text. */
896 struct cmd_list_element
*c
, *result_list
;
900 /* The caller is beginning to accumulate a new set of completions, so
901 we need to find all of them now, and cache them for returning one at
902 a time on future calls. */
906 /* Free the storage used by LIST, but not by the strings inside.
907 This is because rl_complete_internal () frees the strings. */
913 /* Choose the default set of word break characters to break completions.
914 If we later find out that we are doing completions on command strings
915 (as opposed to strings supplied by the individual command completer
916 functions, which can be any string) then we will switch to the
917 special word break set for command strings, which leaves out the
918 '-' character used in some commands. */
920 rl_completer_word_break_characters
=
921 gdb_completer_word_break_characters
;
923 /* Decide whether to complete on a list of gdb commands or on symbols. */
924 tmp_command
= (char *) alloca (rl_point
+ 1);
927 strncpy (tmp_command
, rl_line_buffer
, rl_point
);
928 tmp_command
[rl_point
] = '\0';
929 /* Since text always contains some number of characters leading up
930 to rl_point, we can find the equivalent position in tmp_command
931 by subtracting that many characters from the end of tmp_command. */
932 word
= tmp_command
+ rl_point
- strlen (text
);
936 /* An empty line we want to consider ambiguous; that is, it
937 could be any command. */
938 c
= (struct cmd_list_element
*) -1;
943 c
= lookup_cmd_1 (&p
, cmdlist
, &result_list
, 1);
946 /* Move p up to the next interesting thing. */
947 while (*p
== ' ' || *p
== '\t')
954 /* It is an unrecognized command. So there are no
955 possible completions. */
958 else if (c
== (struct cmd_list_element
*) -1)
962 /* lookup_cmd_1 advances p up to the first ambiguous thing, but
963 doesn't advance over that thing itself. Do so now. */
965 while (*q
&& (isalnum (*q
) || *q
== '-' || *q
== '_'))
967 if (q
!= tmp_command
+ rl_point
)
969 /* There is something beyond the ambiguous
970 command, so there are no possible completions. For
971 example, "info t " or "info t foo" does not complete
972 to anything, because "info t" can be "info target" or
978 /* We're trying to complete on the command which was ambiguous.
979 This we can deal with. */
982 list
= complete_on_cmdlist (*result_list
->prefixlist
, p
,
987 list
= complete_on_cmdlist (cmdlist
, p
, word
);
989 /* Insure that readline does the right thing with respect to
991 rl_completer_word_break_characters
=
992 gdb_completer_command_word_break_characters
;
997 /* We've recognized a full command. */
999 if (p
== tmp_command
+ rl_point
)
1001 /* There is no non-whitespace in the line beyond the command. */
1003 if (p
[-1] == ' ' || p
[-1] == '\t')
1005 /* The command is followed by whitespace; we need to complete
1006 on whatever comes after command. */
1009 /* It is a prefix command; what comes after it is
1010 a subcommand (e.g. "info "). */
1011 list
= complete_on_cmdlist (*c
->prefixlist
, p
, word
);
1013 /* Insure that readline does the right thing
1014 with respect to inserting quotes. */
1015 rl_completer_word_break_characters
=
1016 gdb_completer_command_word_break_characters
;
1020 /* It is a normal command; what comes after it is
1021 completed by the command's completer function. */
1022 list
= (*c
->completer
) (p
, word
);
1027 /* The command is not followed by whitespace; we need to
1028 complete on the command itself. e.g. "p" which is a
1029 command itself but also can complete to "print", "ptype"
1033 /* Find the command we are completing on. */
1035 while (q
> tmp_command
)
1037 if (isalnum (q
[-1]) || q
[-1] == '-' || q
[-1] == '_')
1043 list
= complete_on_cmdlist (result_list
, q
, word
);
1045 /* Insure that readline does the right thing
1046 with respect to inserting quotes. */
1047 rl_completer_word_break_characters
=
1048 gdb_completer_command_word_break_characters
;
1053 /* There is non-whitespace beyond the command. */
1055 if (c
->prefixlist
&& !c
->allow_unknown
)
1057 /* It is an unrecognized subcommand of a prefix command,
1058 e.g. "info adsfkdj". */
1063 /* It is a normal command. */
1064 list
= (*c
->completer
) (p
, word
);
1070 /* If we found a list of potential completions during initialization then
1071 dole them out one at a time. The vector of completions is NULL
1072 terminated, so after returning the last one, return NULL (and continue
1073 to do so) each time we are called after that, until a new list is
1078 output
= list
[index
];
1086 /* Can't do this because readline hasn't yet checked the word breaks
1087 for figuring out whether to insert a quote. */
1089 /* Make sure the word break characters are set back to normal for the
1090 next time that readline tries to complete something. */
1091 rl_completer_word_break_characters
=
1092 gdb_completer_word_break_characters
;
1098 /* Skip over a possibly quoted word (as defined by the quote characters
1099 and word break characters the completer uses). Returns pointer to the
1100 location after the "word". */
1106 char quote_char
= '\0';
1109 for (scan
= str
; *scan
!= '\0'; scan
++)
1111 if (quote_char
!= '\0')
1113 /* Ignore everything until the matching close quote char */
1114 if (*scan
== quote_char
)
1116 /* Found matching close quote. */
1121 else if (strchr (gdb_completer_quote_characters
, *scan
))
1123 /* Found start of a quoted string. */
1126 else if (strchr (gdb_completer_word_break_characters
, *scan
))
1140 #if STOP_SIGNAL == SIGTSTP
1141 signal (SIGTSTP
, SIG_DFL
);
1143 kill (getpid (), SIGTSTP
);
1144 signal (SIGTSTP
, stop_sig
);
1146 signal (STOP_SIGNAL
, stop_sig
);
1148 printf_unfiltered ("%s", prompt
);
1149 gdb_flush (gdb_stdout
);
1151 /* Forget about any previous command -- null line now will do nothing. */
1154 #endif /* STOP_SIGNAL */
1156 /* Initialize signal handlers. */
1166 signal (SIGINT
, request_quit
);
1168 /* If we initialize SIGQUIT to SIG_IGN, then the SIG_IGN will get
1169 passed to the inferior, which we don't want. It would be
1170 possible to do a "signal (SIGQUIT, SIG_DFL)" after we fork, but
1171 on BSD4.3 systems using vfork, that can affect the
1172 GDB process as well as the inferior (the signal handling tables
1173 might be in memory, shared between the two). Since we establish
1174 a handler for SIGQUIT, when we call exec it will set the signal
1175 to SIG_DFL for us. */
1176 signal (SIGQUIT
, do_nothing
);
1177 if (signal (SIGHUP
, do_nothing
) != SIG_IGN
)
1178 signal (SIGHUP
, disconnect
);
1179 signal (SIGFPE
, float_handler
);
1181 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1182 signal (SIGWINCH
, SIGWINCH_HANDLER
);
1186 /* Read one line from the command input stream `instream'
1187 into the local static buffer `linebuffer' (whose current length
1189 The buffer is made bigger as necessary.
1190 Returns the address of the start of the line.
1192 NULL is returned for end of file.
1194 *If* the instream == stdin & stdin is a terminal, the line read
1195 is copied into the file line saver (global var char *line,
1196 length linesize) so that it can be duplicated.
1198 This routine either uses fancy command line editing or
1199 simple input as the user has requested. */
1202 command_line_input (prrompt
, repeat
, annotation_suffix
)
1205 char *annotation_suffix
;
1207 static char *linebuffer
= 0;
1208 static unsigned linelength
= 0;
1212 char *local_prompt
= prrompt
;
1217 if (annotation_level
> 1 && instream
== stdin
)
1219 local_prompt
= alloca ((prrompt
== NULL
? 0 : strlen (prrompt
))
1220 + strlen (annotation_suffix
) + 40);
1221 if (prrompt
== NULL
)
1222 local_prompt
[0] = '\0';
1224 strcpy (local_prompt
, prrompt
);
1225 strcat (local_prompt
, "\n\032\032");
1226 strcat (local_prompt
, annotation_suffix
);
1227 strcat (local_prompt
, "\n");
1230 if (linebuffer
== 0)
1233 linebuffer
= (char *) xmalloc (linelength
);
1238 /* Control-C quits instantly if typed while in this loop
1239 since it should not wait until the user types a newline. */
1243 signal (STOP_SIGNAL
, stop_sig
);
1248 /* Make sure that all output has been output. Some machines may let
1249 you get away with leaving out some of the gdb_flush, but not all. */
1251 gdb_flush (gdb_stdout
);
1252 gdb_flush (gdb_stderr
);
1254 if (source_file_name
!= NULL
)
1256 ++source_line_number
;
1257 sprintf (source_error
,
1258 "%s%s:%d: Error in sourced command file:\n",
1261 source_line_number
);
1262 error_pre_print
= source_error
;
1265 if (annotation_level
> 1 && instream
== stdin
)
1267 printf_unfiltered ("\n\032\032pre-");
1268 printf_unfiltered (annotation_suffix
);
1269 printf_unfiltered ("\n");
1272 /* Don't use fancy stuff if not talking to stdin. */
1273 if (command_editing_p
&& instream
== stdin
1274 && ISATTY (instream
))
1275 rl
= readline (local_prompt
);
1277 rl
= gdb_readline (local_prompt
);
1279 if (annotation_level
> 1 && instream
== stdin
)
1281 printf_unfiltered ("\n\032\032post-");
1282 printf_unfiltered (annotation_suffix
);
1283 printf_unfiltered ("\n");
1286 if (!rl
|| rl
== (char *) EOF
)
1291 if (strlen(rl
) + 1 + (p
- linebuffer
) > linelength
)
1293 linelength
= strlen(rl
) + 1 + (p
- linebuffer
);
1294 nline
= (char *) xrealloc (linebuffer
, linelength
);
1295 p
+= nline
- linebuffer
;
1299 /* Copy line. Don't copy null at end. (Leaves line alone
1300 if this was just a newline) */
1304 free (rl
); /* Allocated in readline. */
1306 if (p
== linebuffer
|| *(p
- 1) != '\\')
1309 p
--; /* Put on top of '\'. */
1310 local_prompt
= (char *) 0;
1315 signal (STOP_SIGNAL
, SIG_DFL
);
1322 #define SERVER_COMMAND_LENGTH 7
1324 (p
- linebuffer
> SERVER_COMMAND_LENGTH
)
1325 && STREQN (linebuffer
, "server ", SERVER_COMMAND_LENGTH
);
1328 /* Note that we don't set `line'. Between this and the check in
1329 dont_repeat, this insures that repeating will still do the
1332 return linebuffer
+ SERVER_COMMAND_LENGTH
;
1335 /* Do history expansion if that is wished. */
1336 if (history_expansion_p
&& instream
== stdin
1337 && ISATTY (instream
))
1339 char *history_value
;
1342 *p
= '\0'; /* Insert null now. */
1343 expanded
= history_expand (linebuffer
, &history_value
);
1346 /* Print the changes. */
1347 printf_unfiltered ("%s\n", history_value
);
1349 /* If there was an error, call this function again. */
1352 free (history_value
);
1353 return command_line_input (prrompt
, repeat
, annotation_suffix
);
1355 if (strlen (history_value
) > linelength
)
1357 linelength
= strlen (history_value
) + 1;
1358 linebuffer
= (char *) xrealloc (linebuffer
, linelength
);
1360 strcpy (linebuffer
, history_value
);
1361 p
= linebuffer
+ strlen(linebuffer
);
1362 free (history_value
);
1366 /* If we just got an empty line, and that is supposed
1367 to repeat the previous command, return the value in the
1371 if (p
== linebuffer
)
1374 while (*p1
== ' ' || *p1
== '\t')
1382 /* Add line to history if appropriate. */
1383 if (instream
== stdin
1384 && ISATTY (stdin
) && *linebuffer
)
1385 add_history (linebuffer
);
1387 /* Note: lines consisting solely of comments are added to the command
1388 history. This is useful when you type a command, and then
1389 realize you don't want to execute it quite yet. You can comment
1390 out the command and then later fetch it from the value history
1391 and remove the '#'. The kill ring is probably better, but some
1392 people are in the habit of commenting things out. */
1394 while ((c
= *p1
++) != '\0')
1397 while ((c
= *p1
++) != '"')
1399 /* Make sure an escaped '"' doesn't make us think the string
1407 while ((c
= *p1
++) != '\'')
1409 /* Make sure an escaped '\'' doesn't make us think the string
1418 /* Found a comment. */
1424 /* Save into global buffer if appropriate. */
1427 if (linelength
> linesize
)
1429 line
= xrealloc (line
, linelength
);
1430 linesize
= linelength
;
1432 strcpy (line
, linebuffer
);
1439 /* Read lines from the input stream
1440 and accumulate them in a chain of struct command_line's
1441 which is then returned. */
1443 struct command_line
*
1444 read_command_lines ()
1446 struct command_line
*first
= 0;
1447 register struct command_line
*next
, *tail
= 0;
1448 register char *p
, *p1
;
1449 struct cleanup
*old_chain
= 0;
1454 p
= command_line_input ((char *) NULL
, instream
== stdin
, "commands");
1456 /* Treat end of file like "end". */
1459 /* Remove leading and trailing blanks. */
1460 while (*p
== ' ' || *p
== '\t') p
++;
1461 p1
= p
+ strlen (p
);
1462 while (p1
!= p
&& (p1
[-1] == ' ' || p1
[-1] == '\t')) p1
--;
1464 /* Is this "end"? */
1465 if (p1
- p
== 3 && !strncmp (p
, "end", 3))
1468 /* No => add this line to the chain of command lines. */
1469 next
= (struct command_line
*) xmalloc (sizeof (struct command_line
));
1470 next
->line
= savestring (p
, p1
- p
);
1478 /* We just read the first line.
1479 From now on, arrange to throw away the lines we have
1480 if we quit or get an error while inside this function. */
1482 old_chain
= make_cleanup (free_command_lines
, &first
);
1489 /* Now we are about to return the chain to our caller,
1490 so freeing it becomes his responsibility. */
1492 discard_cleanups (old_chain
);
1496 /* Free a chain of struct command_line's. */
1499 free_command_lines (lptr
)
1500 struct command_line
**lptr
;
1502 register struct command_line
*l
= *lptr
;
1503 register struct command_line
*next
;
1514 /* Add an element to the list of info subcommands. */
1517 add_info (name
, fun
, doc
)
1519 void (*fun
) PARAMS ((char *, int));
1522 add_cmd (name
, no_class
, fun
, doc
, &infolist
);
1525 /* Add an alias to the list of info subcommands. */
1528 add_info_alias (name
, oldname
, abbrev_flag
)
1533 add_alias_cmd (name
, oldname
, 0, abbrev_flag
, &infolist
);
1536 /* The "info" command is defined as a prefix, with allow_unknown = 0.
1537 Therefore, its own definition is called only for "info" with no args. */
1541 info_command (arg
, from_tty
)
1545 printf_unfiltered ("\"info\" must be followed by the name of an info command.\n");
1546 help_list (infolist
, "info ", -1, gdb_stdout
);
1549 /* The "complete" command is used by Emacs to implement completion. */
1553 complete_command (arg
, from_tty
)
1564 rl_line_buffer
[0] = '\0';
1569 strcpy (rl_line_buffer
, arg
);
1570 rl_point
= strlen (arg
);
1573 for (completion
= symbol_completion_function (rl_line_buffer
, i
= 0);
1575 completion
= symbol_completion_function (rl_line_buffer
, ++i
))
1576 printf_unfiltered ("%s\n", completion
);
1579 /* The "show" command with no arguments shows all the settings. */
1583 show_command (arg
, from_tty
)
1587 cmd_show_list (showlist
, from_tty
, "");
1590 /* Add an element to the list of commands. */
1593 add_com (name
, class, fun
, doc
)
1595 enum command_class
class;
1596 void (*fun
) PARAMS ((char *, int));
1599 add_cmd (name
, class, fun
, doc
, &cmdlist
);
1602 /* Add an alias or abbreviation command to the list of commands. */
1605 add_com_alias (name
, oldname
, class, abbrev_flag
)
1608 enum command_class
class;
1611 add_alias_cmd (name
, oldname
, class, abbrev_flag
, &cmdlist
);
1618 error ("Argument required (%s).", why
);
1623 help_command (command
, from_tty
)
1625 int from_tty
; /* Ignored */
1627 help_cmd (command
, gdb_stdout
);
1631 validate_comname (comname
)
1637 error_no_arg ("name of command to define");
1642 if (!isalnum(*p
) && *p
!= '-')
1643 error ("Junk in argument list: \"%s\"", p
);
1648 /* This is just a placeholder in the command data structures. */
1650 user_defined_command (ignore
, from_tty
)
1657 define_command (comname
, from_tty
)
1661 register struct command_line
*cmds
;
1662 register struct cmd_list_element
*c
, *newc
, *hookc
= 0;
1663 char *tem
= comname
;
1664 #define HOOK_STRING "hook-"
1667 validate_comname (comname
);
1669 /* Look it up, and verify that we got an exact match. */
1670 c
= lookup_cmd (&tem
, cmdlist
, "", -1, 1);
1671 if (c
&& !STREQ (comname
, c
->name
))
1676 if (c
->class == class_user
|| c
->class == class_alias
)
1677 tem
= "Redefine command \"%s\"? ";
1679 tem
= "Really redefine built-in command \"%s\"? ";
1680 if (!query (tem
, c
->name
))
1681 error ("Command \"%s\" not redefined.", c
->name
);
1684 /* If this new command is a hook, then mark the command which it
1685 is hooking. Note that we allow hooking `help' commands, so that
1686 we can hook the `stop' pseudo-command. */
1688 if (!strncmp (comname
, HOOK_STRING
, HOOK_LEN
))
1690 /* Look up cmd it hooks, and verify that we got an exact match. */
1691 tem
= comname
+HOOK_LEN
;
1692 hookc
= lookup_cmd (&tem
, cmdlist
, "", -1, 0);
1693 if (hookc
&& !STREQ (comname
+HOOK_LEN
, hookc
->name
))
1697 warning ("Your new `%s' command does not hook any existing command.",
1699 if (!query ("Proceed? ", (char *)0))
1700 error ("Not confirmed.");
1704 comname
= savestring (comname
, strlen (comname
));
1706 /* If the rest of the commands will be case insensitive, this one
1707 should behave in the same manner. */
1708 for (tem
= comname
; *tem
; tem
++)
1709 if (isupper(*tem
)) *tem
= tolower(*tem
);
1713 printf_unfiltered ("Type commands for definition of \"%s\".\n\
1714 End with a line saying just \"end\".\n", comname
);
1715 gdb_flush (gdb_stdout
);
1718 cmds
= read_command_lines ();
1720 if (c
&& c
->class == class_user
)
1721 free_command_lines (&c
->user_commands
);
1723 newc
= add_cmd (comname
, class_user
, user_defined_command
,
1724 (c
&& c
->class == class_user
)
1725 ? c
->doc
: savestring ("User-defined.", 13), &cmdlist
);
1726 newc
->user_commands
= cmds
;
1728 /* If this new command is a hook, then mark both commands as being
1732 hookc
->hook
= newc
; /* Target gets hooked. */
1733 newc
->hookee
= hookc
; /* We are marked as hooking target cmd. */
1738 document_command (comname
, from_tty
)
1742 struct command_line
*doclines
;
1743 register struct cmd_list_element
*c
;
1744 char *tem
= comname
;
1746 validate_comname (comname
);
1748 c
= lookup_cmd (&tem
, cmdlist
, "", 0, 1);
1750 if (c
->class != class_user
)
1751 error ("Command \"%s\" is built-in.", comname
);
1754 printf_unfiltered ("Type documentation for \"%s\".\n\
1755 End with a line saying just \"end\".\n", comname
);
1757 doclines
= read_command_lines ();
1759 if (c
->doc
) free (c
->doc
);
1762 register struct command_line
*cl1
;
1763 register int len
= 0;
1765 for (cl1
= doclines
; cl1
; cl1
= cl1
->next
)
1766 len
+= strlen (cl1
->line
) + 1;
1768 c
->doc
= (char *) xmalloc (len
+ 1);
1771 for (cl1
= doclines
; cl1
; cl1
= cl1
->next
)
1773 strcat (c
->doc
, cl1
->line
);
1775 strcat (c
->doc
, "\n");
1779 free_command_lines (&doclines
);
1783 print_gnu_advertisement ()
1785 printf_unfiltered ("\
1786 GDB is free software and you are welcome to distribute copies of it\n\
1787 under certain conditions; type \"show copying\" to see the conditions.\n\
1788 There is absolutely no warranty for GDB; type \"show warranty\" for details.\n\
1793 print_gdb_version (stream
)
1796 fprintf_filtered (stream
, "\
1797 GDB %s (%s", version
, host_name
);
1799 if (!STREQ (host_name
, target_name
))
1800 fprintf_filtered (stream
, " --target %s", target_name
);
1802 fprintf_filtered (stream
, "), ");
1804 fprintf_filtered (stream
, "Copyright 1994 Free Software Foundation, Inc.");
1809 show_version (args
, from_tty
)
1814 print_gnu_advertisement ();
1815 print_gdb_version (gdb_stdout
);
1816 printf_filtered ("\n");
1820 /* xgdb calls this to reprint the usual GDB prompt. Obsolete now that xgdb
1826 printf_unfiltered ("%s", prompt
);
1827 gdb_flush (gdb_stdout
);
1831 quit_command (args
, from_tty
)
1835 if (inferior_pid
!= 0 && target_has_execution
)
1839 if (query ("The program is running. Quit anyway (and detach it)? "))
1840 target_detach (args
, from_tty
);
1842 error ("Not confirmed.");
1846 if (query ("The program is running. Quit anyway (and kill it)? "))
1849 error ("Not confirmed.");
1852 /* UDI wants this, to kill the TIP. */
1855 /* Save the history information if it is appropriate to do so. */
1856 if (write_history_p
&& history_filename
)
1857 write_history (history_filename
);
1862 /* Returns whether GDB is running on a terminal and whether the user
1863 desires that questions be asked of them on that terminal. */
1866 input_from_terminal_p ()
1868 return gdb_has_a_terminal () && (instream
== stdin
) & caution
;
1873 pwd_command (args
, from_tty
)
1877 if (args
) error ("The \"pwd\" command does not take an argument: %s", args
);
1878 getcwd (dirbuf
, sizeof (dirbuf
));
1880 if (!STREQ (dirbuf
, current_directory
))
1881 printf_unfiltered ("Working directory %s\n (canonically %s).\n",
1882 current_directory
, dirbuf
);
1884 printf_unfiltered ("Working directory %s.\n", current_directory
);
1888 cd_command (dir
, from_tty
)
1893 /* Found something other than leading repetitions of "/..". */
1894 int found_real_path
;
1897 /* If the new directory is absolute, repeat is a no-op; if relative,
1898 repeat might be useful but is more likely to be a mistake. */
1902 error_no_arg ("new working directory");
1904 dir
= tilde_expand (dir
);
1905 make_cleanup (free
, dir
);
1907 if (chdir (dir
) < 0)
1908 perror_with_name (dir
);
1911 dir
= savestring (dir
, len
- (len
> 1 && dir
[len
-1] == '/'));
1913 current_directory
= dir
;
1916 if (current_directory
[0] == '/' && current_directory
[1] == '\0')
1917 current_directory
= concat (current_directory
, dir
, NULL
);
1919 current_directory
= concat (current_directory
, "/", dir
, NULL
);
1923 /* Now simplify any occurrences of `.' and `..' in the pathname. */
1925 found_real_path
= 0;
1926 for (p
= current_directory
; *p
;)
1928 if (p
[0] == '/' && p
[1] == '.' && (p
[2] == 0 || p
[2] == '/'))
1930 else if (p
[0] == '/' && p
[1] == '.' && p
[2] == '.'
1931 && (p
[3] == 0 || p
[3] == '/'))
1933 if (found_real_path
)
1935 /* Search backwards for the directory just before the "/.."
1936 and obliterate it and the "/..". */
1938 while (q
!= current_directory
&& q
[-1] != '/')
1941 if (q
== current_directory
)
1942 /* current_directory is
1943 a relative pathname ("can't happen"--leave it alone). */
1947 strcpy (q
- 1, p
+ 3);
1952 /* We are dealing with leading repetitions of "/..", for example
1953 "/../..", which is the Mach super-root. */
1958 found_real_path
= 1;
1963 forget_cached_source_info ();
1966 pwd_command ((char *) 0, 1);
1969 struct source_cleanup_lines_args
{
1972 char *old_pre_error
;
1973 char *old_error_pre_print
;
1977 source_cleanup_lines (args
)
1980 struct source_cleanup_lines_args
*p
=
1981 (struct source_cleanup_lines_args
*)args
;
1982 source_line_number
= p
->old_line
;
1983 source_file_name
= p
->old_file
;
1984 source_pre_error
= p
->old_pre_error
;
1985 error_pre_print
= p
->old_error_pre_print
;
1990 source_command (args
, from_tty
)
1995 struct cleanup
*old_cleanups
;
1997 struct source_cleanup_lines_args old_lines
;
2002 error ("source command requires pathname of file to source.");
2005 file
= tilde_expand (file
);
2006 old_cleanups
= make_cleanup (free
, file
);
2008 stream
= fopen (file
, FOPEN_RT
);
2010 perror_with_name (file
);
2012 make_cleanup (fclose
, stream
);
2014 old_lines
.old_line
= source_line_number
;
2015 old_lines
.old_file
= source_file_name
;
2016 old_lines
.old_pre_error
= source_pre_error
;
2017 old_lines
.old_error_pre_print
= error_pre_print
;
2018 make_cleanup (source_cleanup_lines
, &old_lines
);
2019 source_line_number
= 0;
2020 source_file_name
= file
;
2021 source_pre_error
= error_pre_print
== NULL
? "" : error_pre_print
;
2022 source_pre_error
= savestring (source_pre_error
, strlen (source_pre_error
));
2023 make_cleanup (free
, source_pre_error
);
2024 /* This will get set every time we read a line. So it won't stay "" for
2026 error_pre_print
= "";
2028 needed_length
= strlen (source_file_name
) + strlen (source_pre_error
) + 80;
2029 if (source_error_allocated
< needed_length
)
2031 source_error_allocated
*= 2;
2032 if (source_error_allocated
< needed_length
)
2033 source_error_allocated
= needed_length
;
2034 if (source_error
== NULL
)
2035 source_error
= xmalloc (source_error_allocated
);
2037 source_error
= xrealloc (source_error
, source_error_allocated
);
2040 read_command_file (stream
);
2042 do_cleanups (old_cleanups
);
2047 echo_command (text
, from_tty
)
2055 while ((c
= *p
++) != '\0')
2059 /* \ at end of argument is used after spaces
2060 so they won't be lost. */
2064 c
= parse_escape (&p
);
2066 printf_filtered ("%c", c
);
2069 printf_filtered ("%c", c
);
2072 /* Force this output to appear now. */
2074 gdb_flush (gdb_stdout
);
2078 /* Functions to manipulate command line editing control variables. */
2080 /* Number of commands to print in each call to show_commands. */
2081 #define Hist_print 10
2083 show_commands (args
, from_tty
)
2087 /* Index for history commands. Relative to history_base. */
2090 /* Number of the history entry which we are planning to display next.
2091 Relative to history_base. */
2094 /* The first command in the history which doesn't exist (i.e. one more
2095 than the number of the last command). Relative to history_base. */
2098 extern HIST_ENTRY
*history_get
PARAMS ((int));
2100 /* Print out some of the commands from the command history. */
2101 /* First determine the length of the history list. */
2102 hist_len
= history_size
;
2103 for (offset
= 0; offset
< history_size
; offset
++)
2105 if (!history_get (history_base
+ offset
))
2114 if (args
[0] == '+' && args
[1] == '\0')
2115 /* "info editing +" should print from the stored position. */
2118 /* "info editing <exp>" should print around command number <exp>. */
2119 num
= (parse_and_eval_address (args
) - history_base
) - Hist_print
/ 2;
2121 /* "show commands" means print the last Hist_print commands. */
2124 num
= hist_len
- Hist_print
;
2130 /* If there are at least Hist_print commands, we want to display the last
2131 Hist_print rather than, say, the last 6. */
2132 if (hist_len
- num
< Hist_print
)
2134 num
= hist_len
- Hist_print
;
2139 for (offset
= num
; offset
< num
+ Hist_print
&& offset
< hist_len
; offset
++)
2141 printf_filtered ("%5d %s\n", history_base
+ offset
,
2142 (history_get (history_base
+ offset
))->line
);
2145 /* The next command we want to display is the next one that we haven't
2149 /* If the user repeats this command with return, it should do what
2150 "show commands +" does. This is unnecessary if arg is null,
2151 because "show commands +" is not useful after "show commands". */
2152 if (from_tty
&& args
)
2159 /* Called by do_setshow_command. */
2162 set_history_size_command (args
, from_tty
, c
)
2165 struct cmd_list_element
*c
;
2167 if (history_size
== INT_MAX
)
2168 unstifle_history ();
2169 else if (history_size
>= 0)
2170 stifle_history (history_size
);
2173 history_size
= INT_MAX
;
2174 error ("History size must be non-negative");
2180 set_history (args
, from_tty
)
2184 printf_unfiltered ("\"set history\" must be followed by the name of a history subcommand.\n");
2185 help_list (sethistlist
, "set history ", -1, gdb_stdout
);
2190 show_history (args
, from_tty
)
2194 cmd_show_list (showhistlist
, from_tty
, "");
2197 int info_verbose
= 0; /* Default verbose msgs off */
2199 /* Called by do_setshow_command. An elaborate joke. */
2202 set_verbose (args
, from_tty
, c
)
2205 struct cmd_list_element
*c
;
2207 char *cmdname
= "verbose";
2208 struct cmd_list_element
*showcmd
;
2210 showcmd
= lookup_cmd_1 (&cmdname
, showlist
, NULL
, 1);
2214 c
->doc
= "Set verbose printing of informational messages.";
2215 showcmd
->doc
= "Show verbose printing of informational messages.";
2219 c
->doc
= "Set verbosity.";
2220 showcmd
->doc
= "Show verbosity.";
2225 float_handler (signo
)
2228 /* This message is based on ANSI C, section 4.7. Note that integer
2229 divide by zero causes this, so "float" is a misnomer. */
2230 signal (SIGFPE
, float_handler
);
2231 error ("Erroneous arithmetic operation.");
2234 /* Return whether we are running a batch file or from terminal. */
2238 return !(instream
== stdin
&& ISATTY (stdin
));
2250 enablebreaklist
= NULL
;
2255 showhistlist
= NULL
;
2256 unsethistlist
= NULL
;
2257 #if MAINTENANCE_CMDS
2258 maintenancelist
= NULL
;
2259 maintenanceinfolist
= NULL
;
2260 maintenanceprintlist
= NULL
;
2262 setprintlist
= NULL
;
2263 showprintlist
= NULL
;
2264 setchecklist
= NULL
;
2265 showchecklist
= NULL
;
2268 /* Init the history buffer. Note that we are called after the init file(s)
2269 * have been read so that the user can change the history file via his
2270 * .gdbinit file (for instance). The GDBHISTFILE environment variable
2271 * overrides all of this.
2279 tmpenv
= getenv ("HISTSIZE");
2281 history_size
= atoi (tmpenv
);
2282 else if (!history_size
)
2285 stifle_history (history_size
);
2287 tmpenv
= getenv ("GDBHISTFILE");
2289 history_filename
= savestring (tmpenv
, strlen(tmpenv
));
2290 else if (!history_filename
) {
2291 /* We include the current directory so that if the user changes
2292 directories the file written will be the same as the one
2294 history_filename
= concat (current_directory
, "/.gdb_history", NULL
);
2296 read_history (history_filename
);
2302 struct cmd_list_element
*c
;
2304 #ifdef DEFAULT_PROMPT
2305 prompt
= savestring (DEFAULT_PROMPT
, strlen(DEFAULT_PROMPT
));
2307 prompt
= savestring ("(gdb) ", 6);
2310 /* Set the important stuff up for command editing. */
2311 command_editing_p
= 1;
2312 history_expansion_p
= 0;
2313 write_history_p
= 0;
2315 /* Setup important stuff for command line editing. */
2316 rl_completion_entry_function
= (int (*)()) symbol_completion_function
;
2317 rl_completer_word_break_characters
= gdb_completer_word_break_characters
;
2318 rl_completer_quote_characters
= gdb_completer_quote_characters
;
2319 rl_readline_name
= "gdb";
2321 /* Define the classes of commands.
2322 They will appear in the help list in the reverse of this order. */
2324 add_cmd ("internals", class_maintenance
, NO_FUNCTION
,
2325 "Maintenance commands.\n\
2326 Some gdb commands are provided just for use by gdb maintainers.\n\
2327 These commands are subject to frequent change, and may not be as\n\
2328 well documented as user commands.",
2330 add_cmd ("obscure", class_obscure
, NO_FUNCTION
, "Obscure features.", &cmdlist
);
2331 add_cmd ("aliases", class_alias
, NO_FUNCTION
, "Aliases of other commands.", &cmdlist
);
2332 add_cmd ("user-defined", class_user
, NO_FUNCTION
, "User-defined commands.\n\
2333 The commands in this class are those defined by the user.\n\
2334 Use the \"define\" command to define a command.", &cmdlist
);
2335 add_cmd ("support", class_support
, NO_FUNCTION
, "Support facilities.", &cmdlist
);
2336 add_cmd ("status", class_info
, NO_FUNCTION
, "Status inquiries.", &cmdlist
);
2337 add_cmd ("files", class_files
, NO_FUNCTION
, "Specifying and examining files.", &cmdlist
);
2338 add_cmd ("breakpoints", class_breakpoint
, NO_FUNCTION
, "Making program stop at certain points.", &cmdlist
);
2339 add_cmd ("data", class_vars
, NO_FUNCTION
, "Examining data.", &cmdlist
);
2340 add_cmd ("stack", class_stack
, NO_FUNCTION
, "Examining the stack.\n\
2341 The stack is made up of stack frames. Gdb assigns numbers to stack frames\n\
2342 counting from zero for the innermost (currently executing) frame.\n\n\
2343 At any time gdb identifies one frame as the \"selected\" frame.\n\
2344 Variable lookups are done with respect to the selected frame.\n\
2345 When the program being debugged stops, gdb selects the innermost frame.\n\
2346 The commands below can be used to select other frames by number or address.",
2348 add_cmd ("running", class_run
, NO_FUNCTION
, "Running the program.", &cmdlist
);
2350 add_com ("pwd", class_files
, pwd_command
,
2351 "Print working directory. This is used for your program as well.");
2352 c
= add_cmd ("cd", class_files
, cd_command
,
2353 "Set working directory to DIR for debugger and program being debugged.\n\
2354 The change does not take effect for the program being debugged\n\
2355 until the next time it is started.", &cmdlist
);
2356 c
->completer
= filename_completer
;
2359 (add_set_cmd ("prompt", class_support
, var_string
, (char *)&prompt
,
2364 add_com ("echo", class_support
, echo_command
,
2365 "Print a constant string. Give string as argument.\n\
2366 C escape sequences may be used in the argument.\n\
2367 No newline is added at the end of the argument;\n\
2368 use \"\\n\" if you want a newline to be printed.\n\
2369 Since leading and trailing whitespace are ignored in command arguments,\n\
2370 if you want to print some you must use \"\\\" before leading whitespace\n\
2371 to be printed or after trailing whitespace.");
2372 add_com ("document", class_support
, document_command
,
2373 "Document a user-defined command.\n\
2374 Give command name as argument. Give documentation on following lines.\n\
2375 End with a line of just \"end\".");
2376 add_com ("define", class_support
, define_command
,
2377 "Define a new command name. Command name is argument.\n\
2378 Definition appears on following lines, one command per line.\n\
2379 End with a line of just \"end\".\n\
2380 Use the \"document\" command to give documentation for the new command.\n\
2381 Commands defined in this way do not take arguments.");
2384 c
= add_cmd ("source", class_support
, source_command
,
2385 "Read commands from a file named FILE.\n\
2386 Note that the file \"" GDBINIT_FILENAME
"\" is read automatically in this way\n\
2387 when gdb is started.", &cmdlist
);
2389 /* Punt file name, we can't help it easily. */
2390 c
= add_cmd ("source", class_support
, source_command
,
2391 "Read commands from a file named FILE.\n\
2392 Note that the file \".gdbinit\" is read automatically in this way\n\
2393 when gdb is started.", &cmdlist
);
2395 c
->completer
= filename_completer
;
2397 add_com ("quit", class_support
, quit_command
, "Exit gdb.");
2398 add_com ("help", class_support
, help_command
, "Print list of commands.");
2399 add_com_alias ("q", "quit", class_support
, 1);
2400 add_com_alias ("h", "help", class_support
, 1);
2403 c
= add_set_cmd ("verbose", class_support
, var_boolean
, (char *)&info_verbose
,
2406 add_show_from_set (c
, &showlist
);
2407 c
->function
.sfunc
= set_verbose
;
2408 set_verbose (NULL
, 0, c
);
2411 (add_set_cmd ("editing", class_support
, var_boolean
, (char *)&command_editing_p
,
2412 "Set editing of command lines as they are typed.\n\
2413 Use \"on\" to enable to enable the editing, and \"off\" to disable it.\n\
2414 Without an argument, command line editing is enabled. To edit, use\n\
2415 EMACS-like or VI-like commands like control-P or ESC.", &setlist
),
2418 add_prefix_cmd ("history", class_support
, set_history
,
2419 "Generic command for setting command history parameters.",
2420 &sethistlist
, "set history ", 0, &setlist
);
2421 add_prefix_cmd ("history", class_support
, show_history
,
2422 "Generic command for showing command history parameters.",
2423 &showhistlist
, "show history ", 0, &showlist
);
2426 (add_set_cmd ("expansion", no_class
, var_boolean
, (char *)&history_expansion_p
,
2427 "Set history expansion on command input.\n\
2428 Without an argument, history expansion is enabled.", &sethistlist
),
2432 (add_set_cmd ("save", no_class
, var_boolean
, (char *)&write_history_p
,
2433 "Set saving of the history record on exit.\n\
2434 Use \"on\" to enable to enable the saving, and \"off\" to disable it.\n\
2435 Without an argument, saving is enabled.", &sethistlist
),
2438 c
= add_set_cmd ("size", no_class
, var_integer
, (char *)&history_size
,
2439 "Set the size of the command history, \n\
2440 ie. the number of previous commands to keep a record of.", &sethistlist
);
2441 add_show_from_set (c
, &showhistlist
);
2442 c
->function
.sfunc
= set_history_size_command
;
2445 (add_set_cmd ("filename", no_class
, var_filename
, (char *)&history_filename
,
2446 "Set the filename in which to record the command history\n\
2447 (the list of previous commands of which a record is kept).", &sethistlist
),
2451 (add_set_cmd ("confirm", class_support
, var_boolean
,
2453 "Set whether to confirm potentially dangerous operations.",
2457 add_prefix_cmd ("info", class_info
, info_command
,
2458 "Generic command for showing things about the program being debugged.",
2459 &infolist
, "info ", 0, &cmdlist
);
2460 add_com_alias ("i", "info", class_info
, 1);
2462 add_com ("complete", class_obscure
, complete_command
,
2463 "List the completions for the rest of the line as a command.");
2465 add_prefix_cmd ("show", class_info
, show_command
,
2466 "Generic command for showing things about the debugger.",
2467 &showlist
, "show ", 0, &cmdlist
);
2468 /* Another way to get at the same thing. */
2469 add_info ("set", show_command
, "Show all GDB settings.");
2471 add_cmd ("commands", no_class
, show_commands
,
2472 "Show the the history of commands you typed.\n\
2473 You can supply a command number to start with, or a `+' to start after\n\
2474 the previous command number shown.",
2477 add_cmd ("version", no_class
, show_version
,
2478 "Show what version of GDB this is.", &showlist
);
2480 /* If target is open when baud changes, it doesn't take effect until the
2481 next open (I think, not sure). */
2482 add_show_from_set (add_set_cmd ("remotebaud", no_class
,
2483 var_zinteger
, (char *)&baud_rate
,
2484 "Set baud rate for remote serial I/O.\n\
2485 This value is used to set the speed of the serial port when debugging\n\
2486 using remote targets.", &setlist
),
2490 add_set_cmd ("remotedebug", no_class
, var_zinteger
, (char *)&remote_debug
,
2491 "Set debugging of remote protocol.\n\
2492 When enabled, each packet sent or received with the remote target\n\
2493 is displayed.", &setlist
),