1 /* Top level stuff for GDB, the GNU debugger.
2 Copyright 1986, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 1997
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
23 #include "call-cmds.h"
28 #include "breakpoint.h"
30 #include "expression.h"
33 #include "terminal.h" /* For job_control. */
38 /* readline include files */
42 /* readline defines this. */
45 #include <sys/types.h>
50 #include "gdb_string.h"
54 extern void initialize_utils
PARAMS ((void));
56 /* Prototypes for local functions */
58 static void dont_repeat_command
PARAMS ((char *, int));
60 static void source_cleanup_lines
PARAMS ((PTR
));
62 static void user_defined_command
PARAMS ((char *, int));
64 static void init_signals
PARAMS ((void));
67 static void stop_sig
PARAMS ((int));
70 static char * line_completion_function
PARAMS ((char *, int, char *, int));
72 static char * readline_line_completion_function
PARAMS ((char *, int));
74 static void command_loop_marker
PARAMS ((int));
76 static void while_command
PARAMS ((char *, int));
78 static void if_command
PARAMS ((char *, int));
80 static struct command_line
*
81 build_command_line
PARAMS ((enum command_control_type
, char *));
83 static struct command_line
*
84 get_command_line
PARAMS ((enum command_control_type
, char *));
86 static void realloc_body_list
PARAMS ((struct command_line
*, int));
88 static enum misc_command_type read_next_line
PARAMS ((struct command_line
**));
90 static enum command_control_type
91 recurse_read_control_structure
PARAMS ((struct command_line
*));
93 static struct cleanup
* setup_user_args
PARAMS ((char *));
95 static char * locate_arg
PARAMS ((char *));
97 static char * insert_args
PARAMS ((char *));
99 static void arg_cleanup
PARAMS ((void));
101 static void init_main
PARAMS ((void));
103 static void init_cmd_lists
PARAMS ((void));
105 static void float_handler
PARAMS ((int));
107 static void init_signals
PARAMS ((void));
109 static void set_verbose
PARAMS ((char *, int, struct cmd_list_element
*));
111 static void set_endian
PARAMS ((char *, int));
113 static void set_endian_big
PARAMS ((char *, int));
115 static void set_endian_little
PARAMS ((char *, int));
117 static void set_endian_auto
PARAMS ((char *, int));
119 static void show_endian
PARAMS ((char *, int));
121 static void set_architecture
PARAMS ((char *, int));
123 static void show_architecture
PARAMS ((char *, int));
125 static void info_architecture
PARAMS ((char *, int));
127 static void show_history
PARAMS ((char *, int));
129 static void set_history
PARAMS ((char *, int));
131 static void set_history_size_command
PARAMS ((char *, int,
132 struct cmd_list_element
*));
134 static void show_commands
PARAMS ((char *, int));
136 static void echo_command
PARAMS ((char *, int));
138 static void pwd_command
PARAMS ((char *, int));
140 static void show_version
PARAMS ((char *, int));
142 static void document_command
PARAMS ((char *, int));
144 static void define_command
PARAMS ((char *, int));
146 static void validate_comname
PARAMS ((char *));
148 static void help_command
PARAMS ((char *, int));
150 static void show_command
PARAMS ((char *, int));
152 static void info_command
PARAMS ((char *, int));
154 static void complete_command
PARAMS ((char *, int));
156 static void do_nothing
PARAMS ((int));
159 static int quit_cover
PARAMS ((char *));
161 static void disconnect
PARAMS ((int));
164 static void source_cleanup
PARAMS ((FILE *));
166 /* If this definition isn't overridden by the header files, assume
167 that isatty and fileno exist on this system. */
169 #define ISATTY(FP) (isatty (fileno (FP)))
172 /* Initialization file name for gdb. This is overridden in some configs. */
174 #ifndef GDBINIT_FILENAME
175 #define GDBINIT_FILENAME ".gdbinit"
177 char gdbinit
[] = GDBINIT_FILENAME
;
179 int inhibit_gdbinit
= 0;
181 /* If nonzero, and GDB has been configured to be able to use windows,
182 attempt to open them upon startup. */
186 /* Version number of GDB, as a string. */
188 extern char *version
;
190 /* Canonical host name as a string. */
192 extern char *host_name
;
194 /* Canonical target name as a string. */
196 extern char *target_name
;
198 extern char lang_frame_mismatch_warn
[]; /* language.c */
200 /* Flag for whether we want all the "from_tty" gubbish printed. */
202 int caution
= 1; /* Default is yes, sigh. */
204 /* Define all cmd_list_elements. */
206 /* Chain containing all defined commands. */
208 struct cmd_list_element
*cmdlist
;
210 /* Chain containing all defined info subcommands. */
212 struct cmd_list_element
*infolist
;
214 /* Chain containing all defined enable subcommands. */
216 struct cmd_list_element
*enablelist
;
218 /* Chain containing all defined disable subcommands. */
220 struct cmd_list_element
*disablelist
;
222 /* Chain containing all defined delete subcommands. */
224 struct cmd_list_element
*deletelist
;
226 /* Chain containing all defined "enable breakpoint" subcommands. */
228 struct cmd_list_element
*enablebreaklist
;
230 /* Chain containing all defined set subcommands */
232 struct cmd_list_element
*setlist
;
234 /* Chain containing all defined unset subcommands */
236 struct cmd_list_element
*unsetlist
;
238 /* Chain containing all defined show subcommands. */
240 struct cmd_list_element
*showlist
;
242 /* Chain containing the \"set endian\" commands. */
244 struct cmd_list_element
*endianlist
;
246 /* Chain containing all defined \"set history\". */
248 struct cmd_list_element
*sethistlist
;
250 /* Chain containing all defined \"show history\". */
252 struct cmd_list_element
*showhistlist
;
254 /* Chain containing all defined \"unset history\". */
256 struct cmd_list_element
*unsethistlist
;
258 /* Chain containing all defined maintenance subcommands. */
261 struct cmd_list_element
*maintenancelist
;
264 /* Chain containing all defined "maintenance info" subcommands. */
267 struct cmd_list_element
*maintenanceinfolist
;
270 /* Chain containing all defined "maintenance print" subcommands. */
273 struct cmd_list_element
*maintenanceprintlist
;
276 struct cmd_list_element
*setprintlist
;
278 struct cmd_list_element
*showprintlist
;
280 struct cmd_list_element
*setchecklist
;
282 struct cmd_list_element
*showchecklist
;
284 /* stdio stream that command input is being read from. Set to stdin normally.
285 Set by source_command to the file we are sourcing. Set to NULL if we are
286 executing a user-defined command or interacting via a GUI. */
290 /* Current working directory. */
292 char *current_directory
;
294 /* The directory name is actually stored here (usually). */
295 char gdb_dirbuf
[1024];
297 /* Function to call before reading a command, if nonzero.
298 The function receives two args: an input stream,
299 and a prompt string. */
301 void (*window_hook
) PARAMS ((FILE *, char *));
306 /* gdb prints this when reading a command interactively */
309 /* Buffer used for reading command lines, and the size
310 allocated for it so far. */
315 /* Nonzero if the current command is modified by "server ". This
316 affects things like recording into the command history, comamnds
317 repeating on RETURN, etc. This is so a user interface (emacs, GUI,
318 whatever) can issue its own commands and also send along commands
319 from the user, and have the user not notice that the user interface
320 is issuing commands too. */
323 /* Baud rate specified for talking to serial target systems. Default
324 is left as -1, so targets can choose their own defaults. */
325 /* FIXME: This means that "show remotebaud" and gr_files_info can print -1
326 or (unsigned int)-1. This is a Bad User Interface. */
330 /* Timeout limit for response from target. */
332 int remote_timeout
= 20; /* Set default to 20 */
334 /* Non-zero tells remote* modules to output debugging info. */
336 int remote_debug
= 0;
338 /* Level of control structure. */
339 static int control_level
;
341 /* Structure for arguments to user defined functions. */
342 #define MAXUSERARGS 10
345 struct user_args
*next
;
354 /* Signal to catch ^Z typed while reading a command: SIGTSTP or SIGCONT. */
358 #define STOP_SIGNAL SIGTSTP
359 static void stop_sig
PARAMS ((int));
363 /* Some System V have job control but not sigsetmask(). */
364 #if !defined (HAVE_SIGSETMASK)
366 #define HAVE_SIGSETMASK 1
368 #define HAVE_SIGSETMASK 0
372 #if 0 == (HAVE_SIGSETMASK)
373 #define sigsetmask(n)
376 /* Hooks for alternate command interfaces. */
378 /* Called after most modules have been initialized, but before taking users
381 void (*init_ui_hook
) PARAMS ((char *argv0
));
383 /* Called instead of command_loop at top level. Can be invoked via
384 return_to_top_level. */
386 void (*command_loop_hook
) PARAMS ((void));
389 /* Called instead of fputs for all output. */
391 void (*fputs_unfiltered_hook
) PARAMS ((const char *linebuffer
, FILE *stream
));
393 /* Called when the target says something to the host, which may
394 want to appear in a different window. */
396 void (*target_output_hook
) PARAMS ((char *));
398 /* Called from print_frame_info to list the line we stopped in. */
400 void (*print_frame_info_listing_hook
) PARAMS ((struct symtab
*s
, int line
,
401 int stopline
, int noerror
));
402 /* Replaces most of query. */
404 int (*query_hook
) PARAMS ((const char *, va_list));
406 /* Called from gdb_flush to flush output. */
408 void (*flush_hook
) PARAMS ((FILE *stream
));
410 /* These three functions support getting lines of text from the user. They
411 are used in sequence. First readline_begin_hook is called with a text
412 string that might be (for example) a message for the user to type in a
413 sequence of commands to be executed at a breakpoint. If this function
414 calls back to a GUI, it might take this opportunity to pop up a text
415 interaction window with this message. Next, readline_hook is called
416 with a prompt that is emitted prior to collecting the user input.
417 It can be called multiple times. Finally, readline_end_hook is called
418 to notify the GUI that we are done with the interaction window and it
421 void (*readline_begin_hook
) PARAMS ((char *, ...));
422 char * (*readline_hook
) PARAMS ((char *));
423 void (*readline_end_hook
) PARAMS ((void));
425 /* Called as appropriate to notify the interface of the specified breakpoint
428 void (*create_breakpoint_hook
) PARAMS ((struct breakpoint
*bpt
));
429 void (*delete_breakpoint_hook
) PARAMS ((struct breakpoint
*bpt
));
430 void (*modify_breakpoint_hook
) PARAMS ((struct breakpoint
*bpt
));
432 /* Called during long calculations to allow GUI to repair window damage, and to
433 check for stop buttons, etc... */
435 void (*interactive_hook
) PARAMS ((void));
437 /* Called when the registers have changed, as a hint to a GUI
438 to minimize window update. */
440 void (*registers_changed_hook
) PARAMS ((void));
442 /* tell the GUI someone changed the PC */
443 void (*pc_changed_hook
) PARAMS ((void));
445 /* Called when going to wait for the target. Usually allows the GUI to run
446 while waiting for target events. */
448 int (*target_wait_hook
) PARAMS ((int pid
, struct target_waitstatus
*status
));
450 /* Used by UI as a wrapper around command execution. May do various things
451 like enabling/disabling buttons, etc... */
453 void (*call_command_hook
) PARAMS ((struct cmd_list_element
*c
, char *cmd
,
457 /* Takes control from error (). Typically used to prevent longjmps out of the
458 middle of the GUI. Usually used in conjunction with a catch routine. */
460 NORETURN
void (*error_hook
) PARAMS ((void)) ATTR_NORETURN
;
463 /* Where to go for return_to_top_level (RETURN_ERROR). */
464 SIGJMP_BUF error_return
;
465 /* Where to go for return_to_top_level (RETURN_QUIT). */
466 SIGJMP_BUF quit_return
;
468 /* Return for reason REASON. This generally gets back to the command
469 loop, but can be caught via catch_errors. */
472 return_to_top_level (reason
)
473 enum return_reason reason
;
478 /* Perhaps it would be cleaner to do this via the cleanup chain (not sure
479 I can think of a reason why that is vital, though). */
480 bpstat_clear_actions(stop_bpstat
); /* Clear queued breakpoint commands */
482 disable_current_display ();
483 do_cleanups (ALL_CLEANUPS
);
485 if (annotation_level
> 1)
496 (NORETURN
void) SIGLONGJMP
497 (reason
== RETURN_ERROR
? error_return
: quit_return
, 1);
500 /* Call FUNC with arg ARGS, catching any errors. If there is no
501 error, return the value returned by FUNC. If there is an error,
502 print ERRSTRING, print the specific error message, then return
505 Must not be called with immediate_quit in effect (bad things might
506 happen, say we got a signal in the middle of a memcpy to quit_return).
507 This is an OK restriction; with very few exceptions immediate_quit can
508 be replaced by judicious use of QUIT.
510 MASK specifies what to catch; it is normally set to
511 RETURN_MASK_ALL, if for no other reason than that the code which
512 calls catch_errors might not be set up to deal with a quit which
513 isn't caught. But if the code can deal with it, it generally
514 should be RETURN_MASK_ERROR, unless for some reason it is more
515 useful to abort only the portion of the operation inside the
516 catch_errors. Note that quit should return to the command line
517 fairly quickly, even if some further processing is being done. */
520 catch_errors (func
, args
, errstring
, mask
)
521 int (*func
) PARAMS ((char *));
526 SIGJMP_BUF saved_error
;
527 SIGJMP_BUF saved_quit
;
530 struct cleanup
*saved_cleanup_chain
;
531 char *saved_error_pre_print
;
532 char *saved_quit_pre_print
;
534 saved_cleanup_chain
= save_cleanups ();
535 saved_error_pre_print
= error_pre_print
;
536 saved_quit_pre_print
= quit_pre_print
;
538 if (mask
& RETURN_MASK_ERROR
)
540 memcpy ((char *)saved_error
, (char *)error_return
, sizeof (SIGJMP_BUF
));
541 error_pre_print
= errstring
;
543 if (mask
& RETURN_MASK_QUIT
)
545 memcpy (saved_quit
, quit_return
, sizeof (SIGJMP_BUF
));
546 quit_pre_print
= errstring
;
549 if (SIGSETJMP (tmp_jmp
) == 0)
551 if (mask
& RETURN_MASK_ERROR
)
552 memcpy (error_return
, tmp_jmp
, sizeof (SIGJMP_BUF
));
553 if (mask
& RETURN_MASK_QUIT
)
554 memcpy (quit_return
, tmp_jmp
, sizeof (SIGJMP_BUF
));
555 val
= (*func
) (args
);
560 restore_cleanups (saved_cleanup_chain
);
562 if (mask
& RETURN_MASK_ERROR
)
564 memcpy (error_return
, saved_error
, sizeof (SIGJMP_BUF
));
565 error_pre_print
= saved_error_pre_print
;
567 if (mask
& RETURN_MASK_QUIT
)
569 memcpy (quit_return
, saved_quit
, sizeof (SIGJMP_BUF
));
570 quit_pre_print
= saved_quit_pre_print
;
575 /* Handler for SIGHUP. */
582 catch_errors (quit_cover
, NULL
,
583 "Could not kill the program being debugged", RETURN_MASK_ALL
);
584 signal (SIGHUP
, SIG_DFL
);
585 kill (getpid (), SIGHUP
);
588 /* Just a little helper function for disconnect(). */
594 caution
= 0; /* Throw caution to the wind -- we're exiting.
595 This prevents asking the user dumb questions. */
596 quit_command((char *)0, 0);
599 #endif /* defined SIGHUP */
601 /* Line number we are currently in in a file which is being sourced. */
602 static int source_line_number
;
604 /* Name of the file we are sourcing. */
605 static char *source_file_name
;
607 /* Buffer containing the error_pre_print used by the source stuff.
609 static char *source_error
;
610 static int source_error_allocated
;
612 /* Something to glom on to the start of error_pre_print if source_file_name
614 static char *source_pre_error
;
616 /* Clean up on error during a "source" command (or execution of a
617 user-defined command). */
620 source_cleanup (stream
)
623 /* Restore the previous input stream. */
627 /* Read commands from STREAM. */
629 read_command_file (stream
)
632 struct cleanup
*cleanups
;
634 cleanups
= make_cleanup (source_cleanup
, instream
);
637 do_cleanups (cleanups
);
640 extern void init_proc
PARAMS ((void));
642 void (*pre_init_ui_hook
) PARAMS ((void));
648 if (pre_init_ui_hook
)
651 /* Run the init function of each source file */
653 getcwd (gdb_dirbuf
, sizeof (gdb_dirbuf
));
654 current_directory
= gdb_dirbuf
;
656 init_cmd_lists (); /* This needs to be done first */
657 initialize_targets (); /* Setup target_terminal macros for utils.c */
658 initialize_utils (); /* Make errors and warnings possible */
659 initialize_all_files ();
660 init_main (); /* But that omits this file! Do it now */
665 /* We need a default language for parsing expressions, so simple things like
666 "set width 0" won't fail if no language is explicitly set in a config file
667 or implicitly set by reading an executable during startup. */
668 set_language (language_c
);
669 expected_language
= current_language
; /* don't warn about the change. */
672 init_ui_hook (argv0
);
675 /* Allocate, initialize a new command line structure for one of the
676 control commands (if/while). */
678 static struct command_line
*
679 build_command_line (type
, args
)
680 enum command_control_type type
;
683 struct command_line
*cmd
;
686 error ("if/while commands require arguments.\n");
688 cmd
= (struct command_line
*)xmalloc (sizeof (struct command_line
));
690 cmd
->control_type
= type
;
694 = (struct command_line
**)xmalloc (sizeof (struct command_line
*)
696 memset (cmd
->body_list
, 0, sizeof (struct command_line
*) * cmd
->body_count
);
697 cmd
->line
= savestring (args
, strlen (args
));
701 /* Build and return a new command structure for the control commands
702 such as "if" and "while". */
704 static struct command_line
*
705 get_command_line (type
, arg
)
706 enum command_control_type type
;
709 struct command_line
*cmd
;
710 struct cleanup
*old_chain
= NULL
;
712 /* Allocate and build a new command line structure. */
713 cmd
= build_command_line (type
, arg
);
715 old_chain
= make_cleanup (free_command_lines
, &cmd
);
717 /* Read in the body of this command. */
718 if (recurse_read_control_structure (cmd
) == invalid_control
)
720 warning ("error reading in control structure\n");
721 do_cleanups (old_chain
);
725 discard_cleanups (old_chain
);
729 /* Recursively print a command (including full control structures). */
731 print_command_line (cmd
, depth
)
732 struct command_line
*cmd
;
739 for (i
= 0; i
< depth
; i
++)
740 fputs_filtered (" ", gdb_stdout
);
743 /* A simple command, print it and return. */
744 if (cmd
->control_type
== simple_control
)
746 fputs_filtered (cmd
->line
, gdb_stdout
);
747 fputs_filtered ("\n", gdb_stdout
);
751 /* loop_continue to jump to the start of a while loop, print it
753 if (cmd
->control_type
== continue_control
)
755 fputs_filtered ("loop_continue\n", gdb_stdout
);
759 /* loop_break to break out of a while loop, print it and return. */
760 if (cmd
->control_type
== break_control
)
762 fputs_filtered ("loop_break\n", gdb_stdout
);
766 /* A while command. Recursively print its subcommands before returning. */
767 if (cmd
->control_type
== while_control
)
769 struct command_line
*list
;
770 fputs_filtered ("while ", gdb_stdout
);
771 fputs_filtered (cmd
->line
, gdb_stdout
);
772 fputs_filtered ("\n", gdb_stdout
);
773 list
= *cmd
->body_list
;
776 print_command_line (list
, depth
+ 1);
781 /* An if command. Recursively print both arms before returning. */
782 if (cmd
->control_type
== if_control
)
784 fputs_filtered ("if ", gdb_stdout
);
785 fputs_filtered (cmd
->line
, gdb_stdout
);
786 fputs_filtered ("\n", gdb_stdout
);
788 print_command_line (cmd
->body_list
[0], depth
+ 1);
790 /* Show the false arm if it exists. */
791 if (cmd
->body_count
== 2)
795 for (i
= 0; i
< depth
; i
++)
796 fputs_filtered (" ", gdb_stdout
);
798 fputs_filtered ("else\n", gdb_stdout
);
799 print_command_line (cmd
->body_list
[1], depth
+ 1);
803 for (i
= 0; i
< depth
; i
++)
804 fputs_filtered (" ", gdb_stdout
);
806 fputs_filtered ("end\n", gdb_stdout
);
810 /* Execute the command in CMD. */
812 enum command_control_type
813 execute_control_command (cmd
)
814 struct command_line
*cmd
;
816 struct expression
*expr
;
817 struct command_line
*current
;
818 struct cleanup
*old_chain
= 0;
822 enum command_control_type ret
;
825 switch (cmd
->control_type
)
828 /* A simple command, execute it and return. */
829 new_line
= insert_args (cmd
->line
);
831 return invalid_control
;
832 old_chain
= make_cleanup (free_current_contents
, &new_line
);
833 execute_command (new_line
, 0);
834 ret
= cmd
->control_type
;
837 case continue_control
:
839 /* Return for "continue", and "break" so we can either
840 continue the loop at the top, or break out. */
841 ret
= cmd
->control_type
;
846 /* Parse the loop control expression for the while statement. */
847 new_line
= insert_args (cmd
->line
);
849 return invalid_control
;
850 old_chain
= make_cleanup (free_current_contents
, &new_line
);
851 expr
= parse_expression (new_line
);
852 make_cleanup (free_current_contents
, &expr
);
854 ret
= simple_control
;
857 /* Keep iterating so long as the expression is true. */
864 /* Evaluate the expression. */
865 val_mark
= value_mark ();
866 val
= evaluate_expression (expr
);
867 cond_result
= value_true (val
);
868 value_free_to_mark (val_mark
);
870 /* If the value is false, then break out of the loop. */
874 /* Execute the body of the while statement. */
875 current
= *cmd
->body_list
;
878 ret
= execute_control_command (current
);
880 /* If we got an error, or a "break" command, then stop
882 if (ret
== invalid_control
|| ret
== break_control
)
888 /* If we got a "continue" command, then restart the loop
890 if (ret
== continue_control
)
893 /* Get the next statement. */
894 current
= current
->next
;
898 /* Reset RET so that we don't recurse the break all the way down. */
899 if (ret
== break_control
)
900 ret
= simple_control
;
907 new_line
= insert_args (cmd
->line
);
909 return invalid_control
;
910 old_chain
= make_cleanup (free_current_contents
, &new_line
);
911 /* Parse the conditional for the if statement. */
912 expr
= parse_expression (new_line
);
913 make_cleanup (free_current_contents
, &expr
);
916 ret
= simple_control
;
918 /* Evaluate the conditional. */
919 val_mark
= value_mark ();
920 val
= evaluate_expression (expr
);
922 /* Choose which arm to take commands from based on the value of the
923 conditional expression. */
924 if (value_true (val
))
925 current
= *cmd
->body_list
;
926 else if (cmd
->body_count
== 2)
927 current
= *(cmd
->body_list
+ 1);
928 value_free_to_mark (val_mark
);
930 /* Execute commands in the given arm. */
933 ret
= execute_control_command (current
);
935 /* If we got an error, get out. */
936 if (ret
!= simple_control
)
939 /* Get the next statement in the body. */
940 current
= current
->next
;
947 warning ("Invalid control type in command structure.");
948 return invalid_control
;
952 do_cleanups (old_chain
);
957 /* "while" command support. Executes a body of statements while the
958 loop condition is nonzero. */
961 while_command (arg
, from_tty
)
965 struct command_line
*command
= NULL
;
968 command
= get_command_line (while_control
, arg
);
973 execute_control_command (command
);
974 free_command_lines (&command
);
977 /* "if" command support. Execute either the true or false arm depending
978 on the value of the if conditional. */
981 if_command (arg
, from_tty
)
985 struct command_line
*command
= NULL
;
988 command
= get_command_line (if_control
, arg
);
993 execute_control_command (command
);
994 free_command_lines (&command
);
1001 struct user_args
*oargs
= user_args
;
1003 fatal ("Internal error, arg_cleanup called with no user args.\n");
1005 user_args
= user_args
->next
;
1009 /* Bind the incomming arguments for a user defined command to
1010 $arg0, $arg1 ... $argMAXUSERARGS. */
1012 static struct cleanup
*
1016 struct user_args
*args
;
1017 struct cleanup
*old_chain
;
1018 unsigned int arg_count
= 0;
1020 args
= (struct user_args
*)xmalloc (sizeof (struct user_args
));
1021 memset (args
, 0, sizeof (struct user_args
));
1023 args
->next
= user_args
;
1026 old_chain
= make_cleanup (arg_cleanup
, 0);
1038 if (arg_count
>= MAXUSERARGS
)
1040 error ("user defined function may only have %d arguments.\n",
1045 /* Strip whitespace. */
1046 while (*p
== ' ' || *p
== '\t')
1049 /* P now points to an argument. */
1051 user_args
->a
[arg_count
].arg
= p
;
1053 /* Get to the end of this argument. */
1056 if (((*p
== ' ' || *p
== '\t')) && !squote
&& !dquote
&& !bsquote
)
1062 else if (*p
== '\\')
1085 user_args
->a
[arg_count
].len
= p
- start_arg
;
1092 /* Given character string P, return a point to the first argument ($arg),
1093 or NULL if P contains no arguments. */
1099 while ((p
= strchr (p
, '$')))
1101 if (strncmp (p
, "$arg", 4) == 0 && isdigit (p
[4]))
1108 /* Insert the user defined arguments stored in user_arg into the $arg
1109 arguments found in line, with the updated copy being placed into nline. */
1115 char *p
, *save_line
, *new_line
;
1118 /* First we need to know how much memory to allocate for the new line. */
1121 while ((p
= locate_arg (line
)))
1126 if (i
>= user_args
->count
)
1128 error ("Missing argument %d in user function.\n", i
);
1131 len
+= user_args
->a
[i
].len
;
1135 /* Don't forget the tail. */
1136 len
+= strlen (line
);
1138 /* Allocate space for the new line and fill it in. */
1139 new_line
= (char *)xmalloc (len
+ 1);
1140 if (new_line
== NULL
)
1143 /* Restore pointer to beginning of old line. */
1146 /* Save pointer to beginning of new line. */
1147 save_line
= new_line
;
1149 while ((p
= locate_arg (line
)))
1153 memcpy (new_line
, line
, p
- line
);
1154 new_line
+= p
- line
;
1157 len
= user_args
->a
[i
].len
;
1160 memcpy (new_line
, user_args
->a
[i
].arg
, len
);
1165 /* Don't forget the tail. */
1166 strcpy (new_line
, line
);
1168 /* Return a pointer to the beginning of the new line. */
1173 execute_user_command (c
, args
)
1174 struct cmd_list_element
*c
;
1177 register struct command_line
*cmdlines
;
1178 struct cleanup
*old_chain
;
1179 enum command_control_type ret
;
1181 old_chain
= setup_user_args (args
);
1183 cmdlines
= c
->user_commands
;
1188 /* Set the instream to 0, indicating execution of a
1189 user-defined function. */
1190 old_chain
= make_cleanup (source_cleanup
, instream
);
1191 instream
= (FILE *) 0;
1194 ret
= execute_control_command (cmdlines
);
1195 if (ret
!= simple_control
&& ret
!= break_control
)
1197 warning ("Error in control structure.\n");
1200 cmdlines
= cmdlines
->next
;
1202 do_cleanups (old_chain
);
1205 /* Execute the line P as a command.
1206 Pass FROM_TTY as second argument to the defining function. */
1209 execute_command (p
, from_tty
)
1213 register struct cmd_list_element
*c
;
1214 register enum language flang
;
1215 static int warned
= 0;
1216 /* FIXME: These should really be in an appropriate header file */
1217 extern void serial_log_command
PARAMS ((const char *));
1221 /* Force cleanup of any alloca areas if using C alloca instead of
1222 a builtin alloca. */
1225 /* This can happen when command_line_input hits end of file. */
1229 serial_log_command (p
);
1231 while (*p
== ' ' || *p
== '\t') p
++;
1236 c
= lookup_cmd (&p
, cmdlist
, "", 0, 1);
1237 /* Pass null arg rather than an empty one. */
1240 /* Clear off trailing whitespace, except for set and complete command. */
1241 if (arg
&& c
->type
!= set_cmd
&& c
->function
.cfunc
!= complete_command
)
1243 p
= arg
+ strlen (arg
) - 1;
1244 while (p
>= arg
&& (*p
== ' ' || *p
== '\t'))
1249 /* If this command has been hooked, run the hook first. */
1251 execute_user_command (c
->hook
, (char *)0);
1253 if (c
->class == class_user
)
1254 execute_user_command (c
, arg
);
1255 else if (c
->type
== set_cmd
|| c
->type
== show_cmd
)
1256 do_setshow_command (arg
, from_tty
& caution
, c
);
1257 else if (c
->function
.cfunc
== NO_FUNCTION
)
1258 error ("That is not a command, just a help topic.");
1259 else if (call_command_hook
)
1260 call_command_hook (c
, arg
, from_tty
& caution
);
1262 (*c
->function
.cfunc
) (arg
, from_tty
& caution
);
1265 /* Tell the user if the language has changed (except first time). */
1266 if (current_language
!= expected_language
)
1268 if (language_mode
== language_mode_auto
) {
1269 language_info (1); /* Print what changed. */
1274 /* Warn the user if the working language does not match the
1275 language of the current frame. Only warn the user if we are
1276 actually running the program, i.e. there is a stack. */
1277 /* FIXME: This should be cacheing the frame and only running when
1278 the frame changes. */
1280 if (target_has_stack
)
1282 flang
= get_frame_language ();
1284 && flang
!= language_unknown
1285 && flang
!= current_language
->la_language
)
1287 printf_filtered ("%s\n", lang_frame_mismatch_warn
);
1295 command_loop_marker (foo
)
1300 /* Read commands from `instream' and execute them
1301 until end of file or error reading instream. */
1306 struct cleanup
*old_chain
;
1308 int stdin_is_tty
= ISATTY (stdin
);
1309 long time_at_cmd_start
;
1311 long space_at_cmd_start
;
1313 extern int display_time
;
1314 extern int display_space
;
1316 while (instream
&& !feof (instream
))
1318 if (window_hook
&& instream
== stdin
)
1319 (*window_hook
) (instream
, prompt
);
1322 if (instream
== stdin
&& stdin_is_tty
)
1323 reinitialize_more_filter ();
1324 old_chain
= make_cleanup (command_loop_marker
, 0);
1325 command
= command_line_input (instream
== stdin
? prompt
: (char *) NULL
,
1326 instream
== stdin
, "prompt");
1330 time_at_cmd_start
= get_run_time ();
1335 extern char **environ
;
1336 char *lim
= (char *) sbrk (0);
1338 space_at_cmd_start
= (long) (lim
- (char *) &environ
);
1342 execute_command (command
, instream
== stdin
);
1343 /* Do any commands attached to breakpoint we stopped at. */
1344 bpstat_do_actions (&stop_bpstat
);
1345 do_cleanups (old_chain
);
1349 long cmd_time
= get_run_time () - time_at_cmd_start
;
1351 printf_unfiltered ("Command execution time: %ld.%06ld\n",
1352 cmd_time
/ 1000000, cmd_time
% 1000000);
1358 extern char **environ
;
1359 char *lim
= (char *) sbrk (0);
1360 long space_now
= lim
- (char *) &environ
;
1361 long space_diff
= space_now
- space_at_cmd_start
;
1363 printf_unfiltered ("Space used: %ld (%c%ld for this command)\n",
1365 (space_diff
>= 0 ? '+' : '-'),
1372 /* Commands call this if they do not want to be repeated by null lines. */
1380 /* If we aren't reading from standard input, we are saving the last
1381 thing read from stdin in line and don't want to delete it. Null lines
1382 won't repeat here in any case. */
1383 if (instream
== stdin
)
1387 /* Read a line from the stream "instream" without command line editing.
1389 It prints PRROMPT once at the start.
1390 Action is compatible with "readline", e.g. space for the result is
1391 malloc'd and should be freed by the caller.
1393 A NULL return means end of file. */
1395 gdb_readline (prrompt
)
1400 int input_index
= 0;
1401 int result_size
= 80;
1405 /* Don't use a _filtered function here. It causes the assumed
1406 character position to be off, since the newline we read from
1407 the user is not accounted for. */
1408 fputs_unfiltered (prrompt
, gdb_stdout
);
1410 /* Move to a new line so the entered line doesn't have a prompt
1411 on the front of it. */
1412 fputs_unfiltered ("\n", gdb_stdout
);
1414 gdb_flush (gdb_stdout
);
1417 result
= (char *) xmalloc (result_size
);
1421 /* Read from stdin if we are executing a user defined command.
1422 This is the right thing for prompt_for_continue, at least. */
1423 c
= fgetc (instream
? instream
: stdin
);
1427 if (input_index
> 0)
1428 /* The last line does not end with a newline. Return it, and
1429 if we are called again fgetc will still return EOF and
1430 we'll return NULL then. */
1439 result
[input_index
++] = c
;
1440 while (input_index
>= result_size
)
1443 result
= (char *) xrealloc (result
, result_size
);
1447 result
[input_index
++] = '\0';
1451 /* Variables which control command line editing and history
1452 substitution. These variables are given default values at the end
1454 static int command_editing_p
;
1455 static int history_expansion_p
;
1456 static int write_history_p
;
1457 static int history_size
;
1458 static char *history_filename
;
1460 /* readline uses the word breaks for two things:
1461 (1) In figuring out where to point the TEXT parameter to the
1462 rl_completion_entry_function. Since we don't use TEXT for much,
1463 it doesn't matter a lot what the word breaks are for this purpose, but
1464 it does affect how much stuff M-? lists.
1465 (2) If one of the matches contains a word break character, readline
1466 will quote it. That's why we switch between
1467 gdb_completer_word_break_characters and
1468 gdb_completer_command_word_break_characters. I'm not sure when
1469 we need this behavior (perhaps for funky characters in C++ symbols?). */
1471 /* Variables which are necessary for fancy command line editing. */
1472 char *gdb_completer_word_break_characters
=
1473 " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,-";
1475 /* When completing on command names, we remove '-' from the list of
1476 word break characters, since we use it in command names. If the
1477 readline library sees one in any of the current completion strings,
1478 it thinks that the string needs to be quoted and automatically supplies
1480 char *gdb_completer_command_word_break_characters
=
1481 " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,";
1483 /* Characters that can be used to quote completion strings. Note that we
1484 can't include '"' because the gdb C parser treats such quoted sequences
1486 char *gdb_completer_quote_characters
=
1489 /* Functions that are used as part of the fancy command line editing. */
1491 /* This can be used for functions which don't want to complete on symbols
1492 but don't want to complete on anything else either. */
1495 noop_completer (text
, prefix
)
1502 /* Complete on filenames. */
1504 filename_completer (text
, word
)
1508 /* From readline. */
1509 extern char *filename_completion_function
PARAMS ((char *, int));
1510 int subsequent_name
;
1512 int return_val_used
;
1513 int return_val_alloced
;
1515 return_val_used
= 0;
1516 /* Small for testing. */
1517 return_val_alloced
= 1;
1518 return_val
= (char **) xmalloc (return_val_alloced
* sizeof (char *));
1520 subsequent_name
= 0;
1524 p
= filename_completion_function (text
, subsequent_name
);
1525 if (return_val_used
>= return_val_alloced
)
1527 return_val_alloced
*= 2;
1529 (char **) xrealloc (return_val
,
1530 return_val_alloced
* sizeof (char *));
1534 return_val
[return_val_used
++] = p
;
1537 /* Like emacs, don't complete on old versions. Especially useful
1538 in the "source" command. */
1539 if (p
[strlen (p
) - 1] == '~')
1545 /* Return exactly p. */
1546 return_val
[return_val_used
++] = p
;
1547 else if (word
> text
)
1549 /* Return some portion of p. */
1550 q
= xmalloc (strlen (p
) + 5);
1551 strcpy (q
, p
+ (word
- text
));
1552 return_val
[return_val_used
++] = q
;
1557 /* Return some of TEXT plus p. */
1558 q
= xmalloc (strlen (p
) + (text
- word
) + 5);
1559 strncpy (q
, word
, text
- word
);
1560 q
[text
- word
] = '\0';
1562 return_val
[return_val_used
++] = q
;
1566 subsequent_name
= 1;
1569 /* There is no way to do this just long enough to affect quote inserting
1570 without also affecting the next completion. This should be fixed in
1572 /* Insure that readline does the right thing
1573 with respect to inserting quotes. */
1574 rl_completer_word_break_characters
= "";
1579 /* Here are some useful test cases for completion. FIXME: These should
1580 be put in the test suite. They should be tested with both M-? and TAB.
1582 "show output-" "radix"
1583 "show output" "-radix"
1584 "p" ambiguous (commands starting with p--path, print, printf, etc.)
1585 "p " ambiguous (all symbols)
1586 "info t foo" no completions
1587 "info t " no completions
1588 "info t" ambiguous ("info target", "info terminal", etc.)
1589 "info ajksdlfk" no completions
1590 "info ajksdlfk " no completions
1592 "info " ambiguous (all info commands)
1593 "p \"a" no completions (string constant)
1594 "p 'a" ambiguous (all symbols starting with a)
1595 "p b-a" ambiguous (all symbols starting with a)
1596 "p b-" ambiguous (all symbols)
1597 "file Make" "file" (word break hard to screw up here)
1598 "file ../gdb.stabs/we" "ird" (needs to not break word at slash)
1601 /* Generate completions one by one for the completer. Each time we are
1602 called return another potential completion to the caller.
1603 line_completion just completes on commands or passes the buck to the
1604 command's completer function, the stuff specific to symbol completion
1605 is in make_symbol_completion_list.
1607 TEXT is the caller's idea of the "word" we are looking at.
1609 MATCHES is the number of matches that have currently been collected from
1610 calling this completion function. When zero, then we need to initialize,
1611 otherwise the initialization has already taken place and we can just
1612 return the next potential completion string.
1614 LINE_BUFFER is available to be looked at; it contains the entire text
1615 of the line. POINT is the offset in that line of the cursor. You
1616 should pretend that the line ends at POINT.
1618 Returns NULL if there are no more completions, else a pointer to a string
1619 which is a possible completion, it is the caller's responsibility to
1623 line_completion_function (text
, matches
, line_buffer
, point
)
1629 static char **list
= (char **)NULL
; /* Cache of completions */
1630 static int index
; /* Next cached completion */
1631 char *output
= NULL
;
1632 char *tmp_command
, *p
;
1633 /* Pointer within tmp_command which corresponds to text. */
1635 struct cmd_list_element
*c
, *result_list
;
1639 /* The caller is beginning to accumulate a new set of completions, so
1640 we need to find all of them now, and cache them for returning one at
1641 a time on future calls. */
1645 /* Free the storage used by LIST, but not by the strings inside.
1646 This is because rl_complete_internal () frees the strings. */
1652 /* Choose the default set of word break characters to break completions.
1653 If we later find out that we are doing completions on command strings
1654 (as opposed to strings supplied by the individual command completer
1655 functions, which can be any string) then we will switch to the
1656 special word break set for command strings, which leaves out the
1657 '-' character used in some commands. */
1659 rl_completer_word_break_characters
=
1660 gdb_completer_word_break_characters
;
1662 /* Decide whether to complete on a list of gdb commands or on symbols. */
1663 tmp_command
= (char *) alloca (point
+ 1);
1666 strncpy (tmp_command
, line_buffer
, point
);
1667 tmp_command
[point
] = '\0';
1668 /* Since text always contains some number of characters leading up
1669 to point, we can find the equivalent position in tmp_command
1670 by subtracting that many characters from the end of tmp_command. */
1671 word
= tmp_command
+ point
- strlen (text
);
1675 /* An empty line we want to consider ambiguous; that is, it
1676 could be any command. */
1677 c
= (struct cmd_list_element
*) -1;
1682 c
= lookup_cmd_1 (&p
, cmdlist
, &result_list
, 1);
1685 /* Move p up to the next interesting thing. */
1686 while (*p
== ' ' || *p
== '\t')
1693 /* It is an unrecognized command. So there are no
1694 possible completions. */
1697 else if (c
== (struct cmd_list_element
*) -1)
1701 /* lookup_cmd_1 advances p up to the first ambiguous thing, but
1702 doesn't advance over that thing itself. Do so now. */
1704 while (*q
&& (isalnum (*q
) || *q
== '-' || *q
== '_'))
1706 if (q
!= tmp_command
+ point
)
1708 /* There is something beyond the ambiguous
1709 command, so there are no possible completions. For
1710 example, "info t " or "info t foo" does not complete
1711 to anything, because "info t" can be "info target" or
1717 /* We're trying to complete on the command which was ambiguous.
1718 This we can deal with. */
1721 list
= complete_on_cmdlist (*result_list
->prefixlist
, p
,
1726 list
= complete_on_cmdlist (cmdlist
, p
, word
);
1728 /* Insure that readline does the right thing with respect to
1729 inserting quotes. */
1730 rl_completer_word_break_characters
=
1731 gdb_completer_command_word_break_characters
;
1736 /* We've recognized a full command. */
1738 if (p
== tmp_command
+ point
)
1740 /* There is no non-whitespace in the line beyond the command. */
1742 if (p
[-1] == ' ' || p
[-1] == '\t')
1744 /* The command is followed by whitespace; we need to complete
1745 on whatever comes after command. */
1748 /* It is a prefix command; what comes after it is
1749 a subcommand (e.g. "info "). */
1750 list
= complete_on_cmdlist (*c
->prefixlist
, p
, word
);
1752 /* Insure that readline does the right thing
1753 with respect to inserting quotes. */
1754 rl_completer_word_break_characters
=
1755 gdb_completer_command_word_break_characters
;
1759 list
= complete_on_enum (c
->enums
, p
, word
);
1760 rl_completer_word_break_characters
=
1761 gdb_completer_command_word_break_characters
;
1765 /* It is a normal command; what comes after it is
1766 completed by the command's completer function. */
1767 list
= (*c
->completer
) (p
, word
);
1772 /* The command is not followed by whitespace; we need to
1773 complete on the command itself. e.g. "p" which is a
1774 command itself but also can complete to "print", "ptype"
1778 /* Find the command we are completing on. */
1780 while (q
> tmp_command
)
1782 if (isalnum (q
[-1]) || q
[-1] == '-' || q
[-1] == '_')
1788 list
= complete_on_cmdlist (result_list
, q
, word
);
1790 /* Insure that readline does the right thing
1791 with respect to inserting quotes. */
1792 rl_completer_word_break_characters
=
1793 gdb_completer_command_word_break_characters
;
1798 /* There is non-whitespace beyond the command. */
1800 if (c
->prefixlist
&& !c
->allow_unknown
)
1802 /* It is an unrecognized subcommand of a prefix command,
1803 e.g. "info adsfkdj". */
1808 list
= complete_on_enum (c
->enums
, p
, word
);
1812 /* It is a normal command. */
1813 list
= (*c
->completer
) (p
, word
);
1819 /* If we found a list of potential completions during initialization then
1820 dole them out one at a time. The vector of completions is NULL
1821 terminated, so after returning the last one, return NULL (and continue
1822 to do so) each time we are called after that, until a new list is
1827 output
= list
[index
];
1835 /* Can't do this because readline hasn't yet checked the word breaks
1836 for figuring out whether to insert a quote. */
1838 /* Make sure the word break characters are set back to normal for the
1839 next time that readline tries to complete something. */
1840 rl_completer_word_break_characters
=
1841 gdb_completer_word_break_characters
;
1847 /* Line completion interface function for readline. */
1850 readline_line_completion_function (text
, matches
)
1854 return line_completion_function (text
, matches
, rl_line_buffer
, rl_point
);
1857 /* Skip over a possibly quoted word (as defined by the quote characters
1858 and word break characters the completer uses). Returns pointer to the
1859 location after the "word". */
1865 char quote_char
= '\0';
1868 for (scan
= str
; *scan
!= '\0'; scan
++)
1870 if (quote_char
!= '\0')
1872 /* Ignore everything until the matching close quote char */
1873 if (*scan
== quote_char
)
1875 /* Found matching close quote. */
1880 else if (strchr (gdb_completer_quote_characters
, *scan
))
1882 /* Found start of a quoted string. */
1885 else if (strchr (gdb_completer_word_break_characters
, *scan
))
1899 #if STOP_SIGNAL == SIGTSTP
1900 signal (SIGTSTP
, SIG_DFL
);
1902 kill (getpid (), SIGTSTP
);
1903 signal (SIGTSTP
, stop_sig
);
1905 signal (STOP_SIGNAL
, stop_sig
);
1907 printf_unfiltered ("%s", prompt
);
1908 gdb_flush (gdb_stdout
);
1910 /* Forget about any previous command -- null line now will do nothing. */
1913 #endif /* STOP_SIGNAL */
1915 /* Initialize signal handlers. */
1920 /* Under System V the default disposition of a signal is reinstated after
1921 the signal is caught and delivered to an application process. On such
1922 systems one must restore the replacement signal handler if one wishes
1923 to continue handling the signal in one's program. On BSD systems this
1924 is not needed but it is harmless, and it simplifies the code to just do
1925 it unconditionally. */
1926 signal (signo
, do_nothing
);
1932 signal (SIGINT
, request_quit
);
1934 /* If SIGTRAP was set to SIG_IGN, then the SIG_IGN will get passed
1935 to the inferior and breakpoints will be ignored. */
1937 signal (SIGTRAP
, SIG_DFL
);
1940 /* If we initialize SIGQUIT to SIG_IGN, then the SIG_IGN will get
1941 passed to the inferior, which we don't want. It would be
1942 possible to do a "signal (SIGQUIT, SIG_DFL)" after we fork, but
1943 on BSD4.3 systems using vfork, that can affect the
1944 GDB process as well as the inferior (the signal handling tables
1945 might be in memory, shared between the two). Since we establish
1946 a handler for SIGQUIT, when we call exec it will set the signal
1947 to SIG_DFL for us. */
1948 signal (SIGQUIT
, do_nothing
);
1950 if (signal (SIGHUP
, do_nothing
) != SIG_IGN
)
1951 signal (SIGHUP
, disconnect
);
1953 signal (SIGFPE
, float_handler
);
1955 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
1956 signal (SIGWINCH
, SIGWINCH_HANDLER
);
1960 /* Read one line from the command input stream `instream'
1961 into the local static buffer `linebuffer' (whose current length
1963 The buffer is made bigger as necessary.
1964 Returns the address of the start of the line.
1966 NULL is returned for end of file.
1968 *If* the instream == stdin & stdin is a terminal, the line read
1969 is copied into the file line saver (global var char *line,
1970 length linesize) so that it can be duplicated.
1972 This routine either uses fancy command line editing or
1973 simple input as the user has requested. */
1976 command_line_input (prrompt
, repeat
, annotation_suffix
)
1979 char *annotation_suffix
;
1981 static char *linebuffer
= 0;
1982 static unsigned linelength
= 0;
1986 char *local_prompt
= prrompt
;
1990 /* The annotation suffix must be non-NULL. */
1991 if (annotation_suffix
== NULL
)
1992 annotation_suffix
= "";
1994 if (annotation_level
> 1 && instream
== stdin
)
1996 local_prompt
= alloca ((prrompt
== NULL
? 0 : strlen (prrompt
))
1997 + strlen (annotation_suffix
) + 40);
1998 if (prrompt
== NULL
)
1999 local_prompt
[0] = '\0';
2001 strcpy (local_prompt
, prrompt
);
2002 strcat (local_prompt
, "\n\032\032");
2003 strcat (local_prompt
, annotation_suffix
);
2004 strcat (local_prompt
, "\n");
2007 if (linebuffer
== 0)
2010 linebuffer
= (char *) xmalloc (linelength
);
2015 /* Control-C quits instantly if typed while in this loop
2016 since it should not wait until the user types a newline. */
2020 signal (STOP_SIGNAL
, stop_sig
);
2025 /* Make sure that all output has been output. Some machines may let
2026 you get away with leaving out some of the gdb_flush, but not all. */
2028 gdb_flush (gdb_stdout
);
2029 gdb_flush (gdb_stderr
);
2031 if (source_file_name
!= NULL
)
2033 ++source_line_number
;
2034 sprintf (source_error
,
2035 "%s%s:%d: Error in sourced command file:\n",
2038 source_line_number
);
2039 error_pre_print
= source_error
;
2042 if (annotation_level
> 1 && instream
== stdin
)
2044 printf_unfiltered ("\n\032\032pre-");
2045 printf_unfiltered (annotation_suffix
);
2046 printf_unfiltered ("\n");
2049 /* Don't use fancy stuff if not talking to stdin. */
2050 if (readline_hook
&& instream
== NULL
)
2052 rl
= (*readline_hook
) (local_prompt
);
2054 else if (command_editing_p
&& instream
== stdin
&& ISATTY (instream
))
2056 rl
= readline (local_prompt
);
2060 rl
= gdb_readline (local_prompt
);
2063 if (annotation_level
> 1 && instream
== stdin
)
2065 printf_unfiltered ("\n\032\032post-");
2066 printf_unfiltered (annotation_suffix
);
2067 printf_unfiltered ("\n");
2070 if (!rl
|| rl
== (char *) EOF
)
2075 if (strlen(rl
) + 1 + (p
- linebuffer
) > linelength
)
2077 linelength
= strlen(rl
) + 1 + (p
- linebuffer
);
2078 nline
= (char *) xrealloc (linebuffer
, linelength
);
2079 p
+= nline
- linebuffer
;
2083 /* Copy line. Don't copy null at end. (Leaves line alone
2084 if this was just a newline) */
2088 free (rl
); /* Allocated in readline. */
2090 if (p
== linebuffer
|| *(p
- 1) != '\\')
2093 p
--; /* Put on top of '\'. */
2094 local_prompt
= (char *) 0;
2099 signal (STOP_SIGNAL
, SIG_DFL
);
2106 #define SERVER_COMMAND_LENGTH 7
2108 (p
- linebuffer
> SERVER_COMMAND_LENGTH
)
2109 && STREQN (linebuffer
, "server ", SERVER_COMMAND_LENGTH
);
2112 /* Note that we don't set `line'. Between this and the check in
2113 dont_repeat, this insures that repeating will still do the
2116 return linebuffer
+ SERVER_COMMAND_LENGTH
;
2119 /* Do history expansion if that is wished. */
2120 if (history_expansion_p
&& instream
== stdin
2121 && ISATTY (instream
))
2123 char *history_value
;
2126 *p
= '\0'; /* Insert null now. */
2127 expanded
= history_expand (linebuffer
, &history_value
);
2130 /* Print the changes. */
2131 printf_unfiltered ("%s\n", history_value
);
2133 /* If there was an error, call this function again. */
2136 free (history_value
);
2137 return command_line_input (prrompt
, repeat
, annotation_suffix
);
2139 if (strlen (history_value
) > linelength
)
2141 linelength
= strlen (history_value
) + 1;
2142 linebuffer
= (char *) xrealloc (linebuffer
, linelength
);
2144 strcpy (linebuffer
, history_value
);
2145 p
= linebuffer
+ strlen(linebuffer
);
2146 free (history_value
);
2150 /* If we just got an empty line, and that is supposed
2151 to repeat the previous command, return the value in the
2153 if (repeat
&& p
== linebuffer
)
2155 for (p1
= linebuffer
; *p1
== ' ' || *p1
== '\t'; p1
++) ;
2161 /* Add line to history if appropriate. */
2162 if (instream
== stdin
2163 && ISATTY (stdin
) && *linebuffer
)
2164 add_history (linebuffer
);
2166 /* Note: lines consisting solely of comments are added to the command
2167 history. This is useful when you type a command, and then
2168 realize you don't want to execute it quite yet. You can comment
2169 out the command and then later fetch it from the value history
2170 and remove the '#'. The kill ring is probably better, but some
2171 people are in the habit of commenting things out. */
2173 *p1
= '\0'; /* Found a comment. */
2175 /* Save into global buffer if appropriate. */
2178 if (linelength
> linesize
)
2180 line
= xrealloc (line
, linelength
);
2181 linesize
= linelength
;
2183 strcpy (line
, linebuffer
);
2191 /* Expand the body_list of COMMAND so that it can hold NEW_LENGTH
2192 code bodies. This is typically used when we encounter an "else"
2193 clause for an "if" command. */
2196 realloc_body_list (command
, new_length
)
2197 struct command_line
*command
;
2201 struct command_line
**body_list
;
2203 n
= command
->body_count
;
2205 /* Nothing to do? */
2206 if (new_length
<= n
)
2209 body_list
= (struct command_line
**)
2210 xmalloc (sizeof (struct command_line
*) * new_length
);
2212 memcpy (body_list
, command
->body_list
, sizeof (struct command_line
*) * n
);
2214 free (command
->body_list
);
2215 command
->body_list
= body_list
;
2216 command
->body_count
= new_length
;
2219 /* Read one line from the input stream. If the command is an "else" or
2220 "end", return such an indication to the caller. */
2222 static enum misc_command_type
2223 read_next_line (command
)
2224 struct command_line
**command
;
2226 char *p
, *p1
, *prompt_ptr
, control_prompt
[256];
2229 if (control_level
>= 254)
2230 error ("Control nesting too deep!\n");
2232 /* Set a prompt based on the nesting of the control commands. */
2233 if (instream
== stdin
|| (instream
== 0 && readline_hook
!= NULL
))
2235 for (i
= 0; i
< control_level
; i
++)
2236 control_prompt
[i
] = ' ';
2237 control_prompt
[i
] = '>';
2238 control_prompt
[i
+1] = '\0';
2239 prompt_ptr
= (char *)&control_prompt
[0];
2244 p
= command_line_input (prompt_ptr
, instream
== stdin
, "commands");
2246 /* Not sure what to do here. */
2250 /* Strip leading and trailing whitespace. */
2251 while (*p
== ' ' || *p
== '\t')
2254 p1
= p
+ strlen (p
);
2255 while (p1
!= p
&& (p1
[-1] == ' ' || p1
[-1] == '\t'))
2258 /* Blanks and comments don't really do anything, but we need to
2259 distinguish them from else, end and other commands which can be
2261 if (p1
== p
|| p
[0] == '#')
2264 /* Is this the end of a simple, while, or if control structure? */
2265 if (p1
- p
== 3 && !strncmp (p
, "end", 3))
2268 /* Is the else clause of an if control structure? */
2269 if (p1
- p
== 4 && !strncmp (p
, "else", 4))
2270 return else_command
;
2272 /* Check for while, if, break, continue, etc and build a new command
2273 line structure for them. */
2274 if (p1
- p
> 5 && !strncmp (p
, "while", 5))
2275 *command
= build_command_line (while_control
, p
+ 6);
2276 else if (p1
- p
> 2 && !strncmp (p
, "if", 2))
2277 *command
= build_command_line (if_control
, p
+ 3);
2278 else if (p1
- p
== 10 && !strncmp (p
, "loop_break", 10))
2280 *command
= (struct command_line
*)
2281 xmalloc (sizeof (struct command_line
));
2282 (*command
)->next
= NULL
;
2283 (*command
)->line
= NULL
;
2284 (*command
)->control_type
= break_control
;
2285 (*command
)->body_count
= 0;
2286 (*command
)->body_list
= NULL
;
2288 else if (p1
- p
== 13 && !strncmp (p
, "loop_continue", 13))
2290 *command
= (struct command_line
*)
2291 xmalloc (sizeof (struct command_line
));
2292 (*command
)->next
= NULL
;
2293 (*command
)->line
= NULL
;
2294 (*command
)->control_type
= continue_control
;
2295 (*command
)->body_count
= 0;
2296 (*command
)->body_list
= NULL
;
2300 /* A normal command. */
2301 *command
= (struct command_line
*)
2302 xmalloc (sizeof (struct command_line
));
2303 (*command
)->next
= NULL
;
2304 (*command
)->line
= savestring (p
, p1
- p
);
2305 (*command
)->control_type
= simple_control
;
2306 (*command
)->body_count
= 0;
2307 (*command
)->body_list
= NULL
;
2310 /* Nothing special. */
2314 /* Recursively read in the control structures and create a command_line
2315 structure from them.
2317 The parent_control parameter is the control structure in which the
2318 following commands are nested. */
2320 static enum command_control_type
2321 recurse_read_control_structure (current_cmd
)
2322 struct command_line
*current_cmd
;
2324 int current_body
, i
;
2325 enum misc_command_type val
;
2326 enum command_control_type ret
;
2327 struct command_line
**body_ptr
, *child_tail
, *next
;
2332 /* Sanity checks. */
2333 if (current_cmd
->control_type
== simple_control
)
2335 error ("Recursed on a simple control type\n");
2336 return invalid_control
;
2339 if (current_body
> current_cmd
->body_count
)
2341 error ("Allocated body is smaller than this command type needs\n");
2342 return invalid_control
;
2345 /* Read lines from the input stream and build control structures. */
2351 val
= read_next_line (&next
);
2353 /* Just skip blanks and comments. */
2354 if (val
== nop_command
)
2357 if (val
== end_command
)
2359 if (current_cmd
->control_type
== while_control
2360 || current_cmd
->control_type
== if_control
)
2362 /* Success reading an entire control structure. */
2363 ret
= simple_control
;
2368 ret
= invalid_control
;
2373 /* Not the end of a control structure. */
2374 if (val
== else_command
)
2376 if (current_cmd
->control_type
== if_control
2377 && current_body
== 1)
2379 realloc_body_list (current_cmd
, 2);
2386 ret
= invalid_control
;
2393 child_tail
->next
= next
;
2397 body_ptr
= current_cmd
->body_list
;
2398 for (i
= 1; i
< current_body
; i
++)
2407 /* If the latest line is another control structure, then recurse
2409 if (next
->control_type
== while_control
2410 || next
->control_type
== if_control
)
2413 ret
= recurse_read_control_structure (next
);
2416 if (ret
!= simple_control
)
2426 /* Read lines from the input stream and accumulate them in a chain of
2427 struct command_line's, which is then returned. For input from a
2428 terminal, the special command "end" is used to mark the end of the
2429 input, and is not included in the returned chain of commands. */
2431 #define END_MESSAGE "End with a line saying just \"end\"."
2433 struct command_line
*
2434 read_command_lines (prompt
, from_tty
)
2438 struct command_line
*head
, *tail
, *next
;
2439 struct cleanup
*old_chain
;
2440 enum command_control_type ret
;
2441 enum misc_command_type val
;
2443 if (readline_begin_hook
)
2445 /* Note - intentional to merge messages with no newline */
2446 (*readline_begin_hook
) ("%s %s\n", prompt
, END_MESSAGE
);
2448 else if (from_tty
&& input_from_terminal_p ())
2450 printf_unfiltered ("%s\n%s\n", prompt
, END_MESSAGE
);
2451 gdb_flush (gdb_stdout
);
2459 val
= read_next_line (&next
);
2461 /* Ignore blank lines or comments. */
2462 if (val
== nop_command
)
2465 if (val
== end_command
)
2467 ret
= simple_control
;
2471 if (val
!= ok_command
)
2473 ret
= invalid_control
;
2477 if (next
->control_type
== while_control
2478 || next
->control_type
== if_control
)
2481 ret
= recurse_read_control_structure (next
);
2484 if (ret
== invalid_control
)
2495 old_chain
= make_cleanup (free_command_lines
, &head
);
2504 if (ret
!= invalid_control
)
2506 discard_cleanups (old_chain
);
2509 do_cleanups (old_chain
);
2512 if (readline_end_hook
)
2514 (*readline_end_hook
) ();
2519 /* Free a chain of struct command_line's. */
2522 free_command_lines (lptr
)
2523 struct command_line
**lptr
;
2525 register struct command_line
*l
= *lptr
;
2526 register struct command_line
*next
;
2527 struct command_line
**blist
;
2532 if (l
->body_count
> 0)
2534 blist
= l
->body_list
;
2535 for (i
= 0; i
< l
->body_count
; i
++, blist
++)
2536 free_command_lines (blist
);
2545 /* Add an element to the list of info subcommands. */
2548 add_info (name
, fun
, doc
)
2550 void (*fun
) PARAMS ((char *, int));
2553 add_cmd (name
, no_class
, fun
, doc
, &infolist
);
2556 /* Add an alias to the list of info subcommands. */
2559 add_info_alias (name
, oldname
, abbrev_flag
)
2564 add_alias_cmd (name
, oldname
, 0, abbrev_flag
, &infolist
);
2567 /* The "info" command is defined as a prefix, with allow_unknown = 0.
2568 Therefore, its own definition is called only for "info" with no args. */
2572 info_command (arg
, from_tty
)
2576 printf_unfiltered ("\"info\" must be followed by the name of an info command.\n");
2577 help_list (infolist
, "info ", -1, gdb_stdout
);
2580 /* The "complete" command is used by Emacs to implement completion. */
2584 complete_command (arg
, from_tty
)
2596 argpoint
= strlen (arg
);
2598 for (completion
= line_completion_function (arg
, i
= 0, arg
, argpoint
);
2600 completion
= line_completion_function (arg
, ++i
, arg
, argpoint
))
2602 printf_unfiltered ("%s\n", completion
);
2607 /* The "show" command with no arguments shows all the settings. */
2611 show_command (arg
, from_tty
)
2615 cmd_show_list (showlist
, from_tty
, "");
2618 /* Add an element to the list of commands. */
2621 add_com (name
, class, fun
, doc
)
2623 enum command_class
class;
2624 void (*fun
) PARAMS ((char *, int));
2627 add_cmd (name
, class, fun
, doc
, &cmdlist
);
2630 /* Add an alias or abbreviation command to the list of commands. */
2633 add_com_alias (name
, oldname
, class, abbrev_flag
)
2636 enum command_class
class;
2639 add_alias_cmd (name
, oldname
, class, abbrev_flag
, &cmdlist
);
2646 error ("Argument required (%s).", why
);
2651 help_command (command
, from_tty
)
2653 int from_tty
; /* Ignored */
2655 help_cmd (command
, gdb_stdout
);
2659 validate_comname (comname
)
2665 error_no_arg ("name of command to define");
2670 if (!isalnum(*p
) && *p
!= '-' && *p
!= '_')
2671 error ("Junk in argument list: \"%s\"", p
);
2676 /* This is just a placeholder in the command data structures. */
2678 user_defined_command (ignore
, from_tty
)
2685 define_command (comname
, from_tty
)
2689 register struct command_line
*cmds
;
2690 register struct cmd_list_element
*c
, *newc
, *hookc
= 0;
2691 char *tem
= comname
;
2693 #define HOOK_STRING "hook-"
2696 validate_comname (comname
);
2698 /* Look it up, and verify that we got an exact match. */
2699 c
= lookup_cmd (&tem
, cmdlist
, "", -1, 1);
2700 if (c
&& !STREQ (comname
, c
->name
))
2705 if (c
->class == class_user
|| c
->class == class_alias
)
2706 tem
= "Redefine command \"%s\"? ";
2708 tem
= "Really redefine built-in command \"%s\"? ";
2709 if (!query (tem
, c
->name
))
2710 error ("Command \"%s\" not redefined.", c
->name
);
2713 /* If this new command is a hook, then mark the command which it
2714 is hooking. Note that we allow hooking `help' commands, so that
2715 we can hook the `stop' pseudo-command. */
2717 if (!strncmp (comname
, HOOK_STRING
, HOOK_LEN
))
2719 /* Look up cmd it hooks, and verify that we got an exact match. */
2720 tem
= comname
+HOOK_LEN
;
2721 hookc
= lookup_cmd (&tem
, cmdlist
, "", -1, 0);
2722 if (hookc
&& !STREQ (comname
+HOOK_LEN
, hookc
->name
))
2726 warning ("Your new `%s' command does not hook any existing command.",
2728 if (!query ("Proceed? "))
2729 error ("Not confirmed.");
2733 comname
= savestring (comname
, strlen (comname
));
2735 /* If the rest of the commands will be case insensitive, this one
2736 should behave in the same manner. */
2737 for (tem
= comname
; *tem
; tem
++)
2738 if (isupper(*tem
)) *tem
= tolower(*tem
);
2741 sprintf (tmpbuf
, "Type commands for definition of \"%s\".", comname
);
2742 cmds
= read_command_lines (tmpbuf
, from_tty
);
2744 if (c
&& c
->class == class_user
)
2745 free_command_lines (&c
->user_commands
);
2747 newc
= add_cmd (comname
, class_user
, user_defined_command
,
2748 (c
&& c
->class == class_user
)
2749 ? c
->doc
: savestring ("User-defined.", 13), &cmdlist
);
2750 newc
->user_commands
= cmds
;
2752 /* If this new command is a hook, then mark both commands as being
2756 hookc
->hook
= newc
; /* Target gets hooked. */
2757 newc
->hookee
= hookc
; /* We are marked as hooking target cmd. */
2762 document_command (comname
, from_tty
)
2766 struct command_line
*doclines
;
2767 register struct cmd_list_element
*c
;
2768 char *tem
= comname
;
2771 validate_comname (comname
);
2773 c
= lookup_cmd (&tem
, cmdlist
, "", 0, 1);
2775 if (c
->class != class_user
)
2776 error ("Command \"%s\" is built-in.", comname
);
2778 sprintf (tmpbuf
, "Type documentation for \"%s\".", comname
);
2779 doclines
= read_command_lines (tmpbuf
, from_tty
);
2781 if (c
->doc
) free (c
->doc
);
2784 register struct command_line
*cl1
;
2785 register int len
= 0;
2787 for (cl1
= doclines
; cl1
; cl1
= cl1
->next
)
2788 len
+= strlen (cl1
->line
) + 1;
2790 c
->doc
= (char *) xmalloc (len
+ 1);
2793 for (cl1
= doclines
; cl1
; cl1
= cl1
->next
)
2795 strcat (c
->doc
, cl1
->line
);
2797 strcat (c
->doc
, "\n");
2801 free_command_lines (&doclines
);
2805 print_gdb_version (stream
)
2808 /* From GNU coding standards, first line is meant to be easy for a
2809 program to parse, and is just canonical program name and version
2810 number, which starts after last space. */
2812 fprintf_filtered (stream
, "GNU gdb %s\n", version
);
2814 /* Second line is a copyright notice. */
2816 fprintf_filtered (stream
, "Copyright 1997 Free Software Foundation, Inc.\n");
2818 /* Following the copyright is a brief statement that the program is
2819 free software, that users are free to copy and change it on
2820 certain conditions, that it is covered by the GNU GPL, and that
2821 there is no warranty. */
2823 fprintf_filtered (stream
, "\
2824 GDB is free software, covered by the GNU General Public License, and you are\n\
2825 welcome to change it and/or distribute copies of it under certain conditions.\n\
2826 Type \"show copying\" to see the conditions.\n\
2827 There is absolutely no warranty for GDB. Type \"show warranty\" for details.\n");
2829 /* After the required info we print the configuration information. */
2831 fprintf_filtered (stream
, "This GDB was configured as \"");
2832 if (!STREQ (host_name
, target_name
))
2834 fprintf_filtered (stream
, "--host=%s --target=%s", host_name
, target_name
);
2838 fprintf_filtered (stream
, "%s", host_name
);
2840 fprintf_filtered (stream
, "\".");
2845 show_version (args
, from_tty
)
2850 print_gdb_version (gdb_stdout
);
2851 printf_filtered ("\n");
2855 /* xgdb calls this to reprint the usual GDB prompt. Obsolete now that xgdb
2861 printf_unfiltered ("%s", prompt
);
2862 gdb_flush (gdb_stdout
);
2865 /* This replaces the above for the frontends: it returns a pointer
2873 /* If necessary, make the user confirm that we should quit. Return
2874 non-zero if we should quit, zero if we shouldn't. */
2879 if (inferior_pid
!= 0 && target_has_execution
)
2883 /* This is something of a hack. But there's no reliable way to
2884 see if a GUI is running. The `use_windows' variable doesn't
2887 s
= "A debugging session is active.\nDo you still want to close the debugger?";
2888 else if (attach_flag
)
2889 s
= "The program is running. Quit anyway (and detach it)? ";
2891 s
= "The program is running. Exit anyway? ";
2900 /* Quit without asking for confirmation. */
2903 quit_force (args
, from_tty
)
2909 /* An optional expression may be used to cause gdb to terminate with the
2910 value of that expression. */
2913 value_ptr val
= parse_and_eval (args
);
2915 exit_code
= (int) value_as_long (val
);
2918 if (inferior_pid
!= 0 && target_has_execution
)
2921 target_detach (args
, from_tty
);
2926 /* UDI wants this, to kill the TIP. */
2929 /* Save the history information if it is appropriate to do so. */
2930 if (write_history_p
&& history_filename
)
2931 write_history (history_filename
);
2933 do_final_cleanups(ALL_CLEANUPS
); /* Do any final cleanups before exiting */
2938 /* Handle the quit command. */
2941 quit_command (args
, from_tty
)
2945 if (! quit_confirm ())
2946 error ("Not confirmed.");
2947 quit_force (args
, from_tty
);
2950 /* Returns whether GDB is running on a terminal and whether the user
2951 desires that questions be asked of them on that terminal. */
2954 input_from_terminal_p ()
2956 return gdb_has_a_terminal () && (instream
== stdin
) & caution
;
2961 pwd_command (args
, from_tty
)
2965 if (args
) error ("The \"pwd\" command does not take an argument: %s", args
);
2966 getcwd (gdb_dirbuf
, sizeof (gdb_dirbuf
));
2968 if (!STREQ (gdb_dirbuf
, current_directory
))
2969 printf_unfiltered ("Working directory %s\n (canonically %s).\n",
2970 current_directory
, gdb_dirbuf
);
2972 printf_unfiltered ("Working directory %s.\n", current_directory
);
2976 cd_command (dir
, from_tty
)
2981 /* Found something other than leading repetitions of "/..". */
2982 int found_real_path
;
2985 /* If the new directory is absolute, repeat is a no-op; if relative,
2986 repeat might be useful but is more likely to be a mistake. */
2990 error_no_arg ("new working directory");
2992 dir
= tilde_expand (dir
);
2993 make_cleanup (free
, dir
);
2995 if (chdir (dir
) < 0)
2996 perror_with_name (dir
);
2999 dir
= savestring (dir
, len
- (len
> 1 && SLASH_P(dir
[len
-1])));
3001 current_directory
= dir
;
3004 if (SLASH_P (current_directory
[0]) && current_directory
[1] == '\0')
3005 current_directory
= concat (current_directory
, dir
, NULL
);
3007 current_directory
= concat (current_directory
, SLASH_STRING
, dir
, NULL
);
3011 /* Now simplify any occurrences of `.' and `..' in the pathname. */
3013 found_real_path
= 0;
3014 for (p
= current_directory
; *p
;)
3016 if (SLASH_P (p
[0]) && p
[1] == '.' && (p
[2] == 0 || SLASH_P (p
[2])))
3018 else if (SLASH_P (p
[0]) && p
[1] == '.' && p
[2] == '.'
3019 && (p
[3] == 0 || SLASH_P (p
[3])))
3021 if (found_real_path
)
3023 /* Search backwards for the directory just before the "/.."
3024 and obliterate it and the "/..". */
3026 while (q
!= current_directory
&& ! SLASH_P (q
[-1]))
3029 if (q
== current_directory
)
3030 /* current_directory is
3031 a relative pathname ("can't happen"--leave it alone). */
3035 strcpy (q
- 1, p
+ 3);
3040 /* We are dealing with leading repetitions of "/..", for example
3041 "/../..", which is the Mach super-root. */
3046 found_real_path
= 1;
3051 forget_cached_source_info ();
3054 pwd_command ((char *) 0, 1);
3057 struct source_cleanup_lines_args
{
3060 char *old_pre_error
;
3061 char *old_error_pre_print
;
3065 source_cleanup_lines (args
)
3068 struct source_cleanup_lines_args
*p
=
3069 (struct source_cleanup_lines_args
*)args
;
3070 source_line_number
= p
->old_line
;
3071 source_file_name
= p
->old_file
;
3072 source_pre_error
= p
->old_pre_error
;
3073 error_pre_print
= p
->old_error_pre_print
;
3078 source_command (args
, from_tty
)
3083 struct cleanup
*old_cleanups
;
3085 struct source_cleanup_lines_args old_lines
;
3090 error ("source command requires pathname of file to source.");
3093 file
= tilde_expand (file
);
3094 old_cleanups
= make_cleanup (free
, file
);
3096 stream
= fopen (file
, FOPEN_RT
);
3099 perror_with_name (file
);
3103 make_cleanup (fclose
, stream
);
3105 old_lines
.old_line
= source_line_number
;
3106 old_lines
.old_file
= source_file_name
;
3107 old_lines
.old_pre_error
= source_pre_error
;
3108 old_lines
.old_error_pre_print
= error_pre_print
;
3109 make_cleanup (source_cleanup_lines
, &old_lines
);
3110 source_line_number
= 0;
3111 source_file_name
= file
;
3112 source_pre_error
= error_pre_print
== NULL
? "" : error_pre_print
;
3113 source_pre_error
= savestring (source_pre_error
, strlen (source_pre_error
));
3114 make_cleanup (free
, source_pre_error
);
3115 /* This will get set every time we read a line. So it won't stay "" for
3117 error_pre_print
= "";
3119 needed_length
= strlen (source_file_name
) + strlen (source_pre_error
) + 80;
3120 if (source_error_allocated
< needed_length
)
3122 source_error_allocated
*= 2;
3123 if (source_error_allocated
< needed_length
)
3124 source_error_allocated
= needed_length
;
3125 if (source_error
== NULL
)
3126 source_error
= xmalloc (source_error_allocated
);
3128 source_error
= xrealloc (source_error
, source_error_allocated
);
3131 read_command_file (stream
);
3133 do_cleanups (old_cleanups
);
3138 echo_command (text
, from_tty
)
3146 while ((c
= *p
++) != '\0')
3150 /* \ at end of argument is used after spaces
3151 so they won't be lost. */
3155 c
= parse_escape (&p
);
3157 printf_filtered ("%c", c
);
3160 printf_filtered ("%c", c
);
3163 /* Force this output to appear now. */
3165 gdb_flush (gdb_stdout
);
3170 dont_repeat_command (ignored
, from_tty
)
3174 *line
= 0; /* Can't call dont_repeat here because we're not
3175 necessarily reading from stdin. */
3178 /* Functions to manipulate the endianness of the target. */
3180 #ifdef TARGET_BYTE_ORDER_SELECTABLE
3181 #ifndef TARGET_BYTE_ORDER_DEFAULT
3182 #define TARGET_BYTE_ORDER_DEFAULT BIG_ENDIAN
3184 int target_byte_order
= TARGET_BYTE_ORDER_DEFAULT
;
3185 int target_byte_order_auto
= 1;
3187 static int target_byte_order_auto
= 0;
3190 /* Called if the user enters ``set endian'' without an argument. */
3192 set_endian (args
, from_tty
)
3196 printf_unfiltered ("\"set endian\" must be followed by \"auto\", \"big\" or \"little\".\n");
3197 show_endian (args
, from_tty
);
3200 /* Called by ``set endian big''. */
3202 set_endian_big (args
, from_tty
)
3206 #ifdef TARGET_BYTE_ORDER_SELECTABLE
3207 target_byte_order
= BIG_ENDIAN
;
3208 target_byte_order_auto
= 0;
3210 printf_unfiltered ("Byte order is not selectable.");
3211 show_endian (args
, from_tty
);
3215 /* Called by ``set endian little''. */
3217 set_endian_little (args
, from_tty
)
3221 #ifdef TARGET_BYTE_ORDER_SELECTABLE
3222 target_byte_order
= LITTLE_ENDIAN
;
3223 target_byte_order_auto
= 0;
3225 printf_unfiltered ("Byte order is not selectable.");
3226 show_endian (args
, from_tty
);
3230 /* Called by ``set endian auto''. */
3232 set_endian_auto (args
, from_tty
)
3236 #ifdef TARGET_BYTE_ORDER_SELECTABLE
3237 target_byte_order_auto
= 1;
3239 printf_unfiltered ("Byte order is not selectable.");
3240 show_endian (args
, from_tty
);
3244 /* Called by ``show endian''. */
3246 show_endian (args
, from_tty
)
3251 (target_byte_order_auto
3252 ? "The target endianness is set automatically (currently %s endian)\n"
3253 : "The target is assumed to be %s endian\n");
3254 printf_unfiltered ((char *) msg
, TARGET_BYTE_ORDER
== BIG_ENDIAN
? "big" : "little");
3257 /* Set the endianness from a BFD. */
3259 set_endian_from_file (abfd
)
3262 #ifdef TARGET_BYTE_ORDER_SELECTABLE
3265 if (bfd_big_endian (abfd
))
3268 want
= LITTLE_ENDIAN
;
3269 if (target_byte_order_auto
)
3270 target_byte_order
= want
;
3271 else if (target_byte_order
!= want
)
3272 warning ("%s endian file does not match %s endian target.",
3273 want
== BIG_ENDIAN
? "big" : "little",
3274 TARGET_BYTE_ORDER
== BIG_ENDIAN
? "big" : "little");
3276 #else /* ! defined (TARGET_BYTE_ORDER_SELECTABLE) */
3278 if (bfd_big_endian (abfd
)
3279 ? TARGET_BYTE_ORDER
!= BIG_ENDIAN
3280 : TARGET_BYTE_ORDER
== BIG_ENDIAN
)
3281 warning ("%s endian file does not match %s endian target.",
3282 bfd_big_endian (abfd
) ? "big" : "little",
3283 TARGET_BYTE_ORDER
== BIG_ENDIAN
? "big" : "little");
3285 #endif /* ! defined (TARGET_BYTE_ORDER_SELECTABLE) */
3288 /* Functions to manipulate the architecture of the target */
3290 int target_architecture_auto
= 1;
3291 extern const bfd_arch_info_type bfd_default_arch_struct
;
3292 const bfd_arch_info_type
*target_architecture
= &bfd_default_arch_struct
;
3293 int (*target_architecture_hook
) PARAMS ((const bfd_arch_info_type
*ap
));
3297 const bfd_arch_info_type
*arch
;
3299 /* FIXME: Is it compatible with gdb? */
3300 /* Check with the target on the setting */
3301 if (target_architecture_hook
!= NULL
3302 && !target_architecture_hook (arch
))
3303 printf_unfiltered ("Target does not support `%s' architecture.\n",
3304 arch
->printable_name
);
3307 target_architecture_auto
= 0;
3308 target_architecture
= arch
;
3313 /* Called if the user enters ``set architecture'' with or without an
3316 set_architecture (args
, from_tty
)
3322 printf_unfiltered ("\"set architecture\" must be followed by \"auto\" or an architecture name.\n");
3324 else if (strcmp (args
, "auto") == 0)
3326 target_architecture_auto
= 1;
3330 const bfd_arch_info_type
*arch
= bfd_scan_arch (args
);
3334 printf_unfiltered ("Architecture `%s' not reconized.\n", args
);
3338 /* Called if the user enters ``show architecture'' without an argument. */
3340 show_architecture (args
, from_tty
)
3345 arch
= target_architecture
->printable_name
;
3346 if (target_architecture_auto
)
3347 printf_filtered ("The target architecture is set automatically (currently %s)\n", arch
);
3349 printf_filtered ("The target architecture is assumed to be %s\n", arch
);
3352 /* Called if the user enters ``info architecture'' without an argument. */
3354 info_architecture (args
, from_tty
)
3358 enum bfd_architecture a
;
3359 printf_filtered ("Available architectures are:\n");
3360 for (a
= bfd_arch_obscure
+ 1; a
< bfd_arch_last
; a
++)
3362 const bfd_arch_info_type
*ap
= bfd_lookup_arch (a
, 0);
3367 printf_filtered (" %s", ap
->printable_name
);
3371 printf_filtered ("\n");
3376 /* Set the architecture from arch/machine */
3378 set_architecture_from_arch_mach (arch
, mach
)
3379 enum bfd_architecture arch
;
3382 const bfd_arch_info_type
*wanted
= bfd_lookup_arch (arch
, mach
);
3386 fatal ("hardwired architecture/machine not reconized");
3390 /* Set the architecture from a BFD */
3392 set_architecture_from_file (abfd
)
3395 const bfd_arch_info_type
*wanted
= bfd_get_arch_info (abfd
);
3396 if (target_architecture_auto
)
3398 if (target_architecture_hook
!= NULL
3399 && !target_architecture_hook (wanted
))
3400 warning ("Target may not support %s architecture",
3401 wanted
->printable_name
);
3402 target_architecture
= wanted
;
3404 else if (wanted
!= target_architecture
)
3406 warning ("%s architecture file may be incompatible with %s target.",
3407 wanted
->printable_name
,
3408 target_architecture
->printable_name
);
3412 /* Functions to manipulate command line editing control variables. */
3414 /* Number of commands to print in each call to show_commands. */
3415 #define Hist_print 10
3417 show_commands (args
, from_tty
)
3421 /* Index for history commands. Relative to history_base. */
3424 /* Number of the history entry which we are planning to display next.
3425 Relative to history_base. */
3428 /* The first command in the history which doesn't exist (i.e. one more
3429 than the number of the last command). Relative to history_base. */
3432 extern HIST_ENTRY
*history_get
PARAMS ((int));
3434 /* Print out some of the commands from the command history. */
3435 /* First determine the length of the history list. */
3436 hist_len
= history_size
;
3437 for (offset
= 0; offset
< history_size
; offset
++)
3439 if (!history_get (history_base
+ offset
))
3448 if (args
[0] == '+' && args
[1] == '\0')
3449 /* "info editing +" should print from the stored position. */
3452 /* "info editing <exp>" should print around command number <exp>. */
3453 num
= (parse_and_eval_address (args
) - history_base
) - Hist_print
/ 2;
3455 /* "show commands" means print the last Hist_print commands. */
3458 num
= hist_len
- Hist_print
;
3464 /* If there are at least Hist_print commands, we want to display the last
3465 Hist_print rather than, say, the last 6. */
3466 if (hist_len
- num
< Hist_print
)
3468 num
= hist_len
- Hist_print
;
3473 for (offset
= num
; offset
< num
+ Hist_print
&& offset
< hist_len
; offset
++)
3475 printf_filtered ("%5d %s\n", history_base
+ offset
,
3476 (history_get (history_base
+ offset
))->line
);
3479 /* The next command we want to display is the next one that we haven't
3483 /* If the user repeats this command with return, it should do what
3484 "show commands +" does. This is unnecessary if arg is null,
3485 because "show commands +" is not useful after "show commands". */
3486 if (from_tty
&& args
)
3493 /* Called by do_setshow_command. */
3496 set_history_size_command (args
, from_tty
, c
)
3499 struct cmd_list_element
*c
;
3501 if (history_size
== INT_MAX
)
3502 unstifle_history ();
3503 else if (history_size
>= 0)
3504 stifle_history (history_size
);
3507 history_size
= INT_MAX
;
3508 error ("History size must be non-negative");
3514 set_history (args
, from_tty
)
3518 printf_unfiltered ("\"set history\" must be followed by the name of a history subcommand.\n");
3519 help_list (sethistlist
, "set history ", -1, gdb_stdout
);
3524 show_history (args
, from_tty
)
3528 cmd_show_list (showhistlist
, from_tty
, "");
3531 int info_verbose
= 0; /* Default verbose msgs off */
3533 /* Called by do_setshow_command. An elaborate joke. */
3536 set_verbose (args
, from_tty
, c
)
3539 struct cmd_list_element
*c
;
3541 char *cmdname
= "verbose";
3542 struct cmd_list_element
*showcmd
;
3544 showcmd
= lookup_cmd_1 (&cmdname
, showlist
, NULL
, 1);
3548 c
->doc
= "Set verbose printing of informational messages.";
3549 showcmd
->doc
= "Show verbose printing of informational messages.";
3553 c
->doc
= "Set verbosity.";
3554 showcmd
->doc
= "Show verbosity.";
3559 float_handler (signo
)
3562 /* This message is based on ANSI C, section 4.7. Note that integer
3563 divide by zero causes this, so "float" is a misnomer. */
3564 signal (SIGFPE
, float_handler
);
3565 error ("Erroneous arithmetic operation.");
3577 enablebreaklist
= NULL
;
3583 showhistlist
= NULL
;
3584 unsethistlist
= NULL
;
3585 #if MAINTENANCE_CMDS
3586 maintenancelist
= NULL
;
3587 maintenanceinfolist
= NULL
;
3588 maintenanceprintlist
= NULL
;
3590 setprintlist
= NULL
;
3591 showprintlist
= NULL
;
3592 setchecklist
= NULL
;
3593 showchecklist
= NULL
;
3596 /* Init the history buffer. Note that we are called after the init file(s)
3597 * have been read so that the user can change the history file via his
3598 * .gdbinit file (for instance). The GDBHISTFILE environment variable
3599 * overrides all of this.
3607 tmpenv
= getenv ("HISTSIZE");
3609 history_size
= atoi (tmpenv
);
3610 else if (!history_size
)
3613 stifle_history (history_size
);
3615 tmpenv
= getenv ("GDBHISTFILE");
3617 history_filename
= savestring (tmpenv
, strlen(tmpenv
));
3618 else if (!history_filename
) {
3619 /* We include the current directory so that if the user changes
3620 directories the file written will be the same as the one
3622 history_filename
= concat (current_directory
, "/.gdb_history", NULL
);
3624 read_history (history_filename
);
3630 struct cmd_list_element
*c
;
3632 add_prefix_cmd ("endian", class_support
, set_endian
,
3633 "Set endianness of target.",
3634 &endianlist
, "set endian ", 0, &setlist
);
3635 add_cmd ("big", class_support
, set_endian_big
,
3636 "Set target as being big endian.", &endianlist
);
3637 add_cmd ("little", class_support
, set_endian_little
,
3638 "Set target as being little endian.", &endianlist
);
3639 add_cmd ("auto", class_support
, set_endian_auto
,
3640 "Select target endianness automatically.", &endianlist
);
3641 add_cmd ("endian", class_support
, show_endian
,
3642 "Show endianness of target.", &showlist
);
3644 add_cmd ("architecture", class_support
, set_architecture
,
3645 "Set architecture of target.", &setlist
);
3646 add_alias_cmd ("processor", "architecture", class_support
, 1, &setlist
);
3647 add_cmd ("architecture", class_support
, show_architecture
,
3648 "Show architecture of target.", &showlist
);
3649 add_cmd ("architecture", class_support
, info_architecture
,
3650 "List supported target architectures", &infolist
);
3653 #ifdef DEFAULT_PROMPT
3654 prompt
= savestring (DEFAULT_PROMPT
, strlen(DEFAULT_PROMPT
));
3656 prompt
= savestring ("(gdb) ", 6);
3659 /* Set the important stuff up for command editing. */
3660 command_editing_p
= 1;
3661 history_expansion_p
= 0;
3662 write_history_p
= 0;
3664 /* Setup important stuff for command line editing. */
3665 rl_completion_entry_function
= (int (*)()) readline_line_completion_function
;
3666 rl_completer_word_break_characters
= gdb_completer_word_break_characters
;
3667 rl_completer_quote_characters
= gdb_completer_quote_characters
;
3668 rl_readline_name
= "gdb";
3670 /* Define the classes of commands.
3671 They will appear in the help list in the reverse of this order. */
3673 add_cmd ("internals", class_maintenance
, NO_FUNCTION
,
3674 "Maintenance commands.\n\
3675 Some gdb commands are provided just for use by gdb maintainers.\n\
3676 These commands are subject to frequent change, and may not be as\n\
3677 well documented as user commands.",
3679 add_cmd ("obscure", class_obscure
, NO_FUNCTION
, "Obscure features.", &cmdlist
);
3680 add_cmd ("aliases", class_alias
, NO_FUNCTION
, "Aliases of other commands.", &cmdlist
);
3681 add_cmd ("user-defined", class_user
, NO_FUNCTION
, "User-defined commands.\n\
3682 The commands in this class are those defined by the user.\n\
3683 Use the \"define\" command to define a command.", &cmdlist
);
3684 add_cmd ("support", class_support
, NO_FUNCTION
, "Support facilities.", &cmdlist
);
3685 add_cmd ("status", class_info
, NO_FUNCTION
, "Status inquiries.", &cmdlist
);
3686 add_cmd ("files", class_files
, NO_FUNCTION
, "Specifying and examining files.", &cmdlist
);
3687 add_cmd ("breakpoints", class_breakpoint
, NO_FUNCTION
, "Making program stop at certain points.", &cmdlist
);
3688 add_cmd ("data", class_vars
, NO_FUNCTION
, "Examining data.", &cmdlist
);
3689 add_cmd ("stack", class_stack
, NO_FUNCTION
, "Examining the stack.\n\
3690 The stack is made up of stack frames. Gdb assigns numbers to stack frames\n\
3691 counting from zero for the innermost (currently executing) frame.\n\n\
3692 At any time gdb identifies one frame as the \"selected\" frame.\n\
3693 Variable lookups are done with respect to the selected frame.\n\
3694 When the program being debugged stops, gdb selects the innermost frame.\n\
3695 The commands below can be used to select other frames by number or address.",
3697 add_cmd ("running", class_run
, NO_FUNCTION
, "Running the program.", &cmdlist
);
3699 add_com ("pwd", class_files
, pwd_command
,
3700 "Print working directory. This is used for your program as well.");
3701 c
= add_cmd ("cd", class_files
, cd_command
,
3702 "Set working directory to DIR for debugger and program being debugged.\n\
3703 The change does not take effect for the program being debugged\n\
3704 until the next time it is started.", &cmdlist
);
3705 c
->completer
= filename_completer
;
3708 (add_set_cmd ("prompt", class_support
, var_string
, (char *)&prompt
,
3713 add_com ("echo", class_support
, echo_command
,
3714 "Print a constant string. Give string as argument.\n\
3715 C escape sequences may be used in the argument.\n\
3716 No newline is added at the end of the argument;\n\
3717 use \"\\n\" if you want a newline to be printed.\n\
3718 Since leading and trailing whitespace are ignored in command arguments,\n\
3719 if you want to print some you must use \"\\\" before leading whitespace\n\
3720 to be printed or after trailing whitespace.");
3721 add_com ("document", class_support
, document_command
,
3722 "Document a user-defined command.\n\
3723 Give command name as argument. Give documentation on following lines.\n\
3724 End with a line of just \"end\".");
3725 add_com ("define", class_support
, define_command
,
3726 "Define a new command name. Command name is argument.\n\
3727 Definition appears on following lines, one command per line.\n\
3728 End with a line of just \"end\".\n\
3729 Use the \"document\" command to give documentation for the new command.\n\
3730 Commands defined in this way may have up to ten arguments.");
3733 c
= add_cmd ("source", class_support
, source_command
,
3734 "Read commands from a file named FILE.\n\
3735 Note that the file \"" GDBINIT_FILENAME
"\" is read automatically in this way\n\
3736 when gdb is started.", &cmdlist
);
3738 /* Punt file name, we can't help it easily. */
3739 c
= add_cmd ("source", class_support
, source_command
,
3740 "Read commands from a file named FILE.\n\
3741 Note that the file \".gdbinit\" is read automatically in this way\n\
3742 when gdb is started.", &cmdlist
);
3744 c
->completer
= filename_completer
;
3746 add_com ("quit", class_support
, quit_command
, "Exit gdb.");
3747 add_com ("help", class_support
, help_command
, "Print list of commands.");
3748 add_com_alias ("q", "quit", class_support
, 1);
3749 add_com_alias ("h", "help", class_support
, 1);
3751 add_com ("dont-repeat", class_support
, dont_repeat_command
, "Don't repeat this command.\n\
3752 Primarily used inside of user-defined commands that should not be repeated when\n\
3755 c
= add_set_cmd ("verbose", class_support
, var_boolean
, (char *)&info_verbose
,
3758 add_show_from_set (c
, &showlist
);
3759 c
->function
.sfunc
= set_verbose
;
3760 set_verbose (NULL
, 0, c
);
3763 (add_set_cmd ("editing", class_support
, var_boolean
, (char *)&command_editing_p
,
3764 "Set editing of command lines as they are typed.\n\
3765 Use \"on\" to enable the editing, and \"off\" to disable it.\n\
3766 Without an argument, command line editing is enabled. To edit, use\n\
3767 EMACS-like or VI-like commands like control-P or ESC.", &setlist
),
3770 add_prefix_cmd ("history", class_support
, set_history
,
3771 "Generic command for setting command history parameters.",
3772 &sethistlist
, "set history ", 0, &setlist
);
3773 add_prefix_cmd ("history", class_support
, show_history
,
3774 "Generic command for showing command history parameters.",
3775 &showhistlist
, "show history ", 0, &showlist
);
3778 (add_set_cmd ("expansion", no_class
, var_boolean
, (char *)&history_expansion_p
,
3779 "Set history expansion on command input.\n\
3780 Without an argument, history expansion is enabled.", &sethistlist
),
3784 (add_set_cmd ("save", no_class
, var_boolean
, (char *)&write_history_p
,
3785 "Set saving of the history record on exit.\n\
3786 Use \"on\" to enable the saving, and \"off\" to disable it.\n\
3787 Without an argument, saving is enabled.", &sethistlist
),
3790 c
= add_set_cmd ("size", no_class
, var_integer
, (char *)&history_size
,
3791 "Set the size of the command history, \n\
3792 ie. the number of previous commands to keep a record of.", &sethistlist
);
3793 add_show_from_set (c
, &showhistlist
);
3794 c
->function
.sfunc
= set_history_size_command
;
3797 (add_set_cmd ("filename", no_class
, var_filename
, (char *)&history_filename
,
3798 "Set the filename in which to record the command history\n\
3799 (the list of previous commands of which a record is kept).", &sethistlist
),
3803 (add_set_cmd ("confirm", class_support
, var_boolean
,
3805 "Set whether to confirm potentially dangerous operations.",
3809 add_prefix_cmd ("info", class_info
, info_command
,
3810 "Generic command for showing things about the program being debugged.",
3811 &infolist
, "info ", 0, &cmdlist
);
3812 add_com_alias ("i", "info", class_info
, 1);
3814 add_com ("complete", class_obscure
, complete_command
,
3815 "List the completions for the rest of the line as a command.");
3817 add_prefix_cmd ("show", class_info
, show_command
,
3818 "Generic command for showing things about the debugger.",
3819 &showlist
, "show ", 0, &cmdlist
);
3820 /* Another way to get at the same thing. */
3821 add_info ("set", show_command
, "Show all GDB settings.");
3823 add_cmd ("commands", no_class
, show_commands
,
3824 "Show the history of commands you typed.\n\
3825 You can supply a command number to start with, or a `+' to start after\n\
3826 the previous command number shown.",
3829 add_cmd ("version", no_class
, show_version
,
3830 "Show what version of GDB this is.", &showlist
);
3832 add_com ("while", class_support
, while_command
,
3833 "Execute nested commands WHILE the conditional expression is non zero.\n\
3834 The conditional expression must follow the word `while' and must in turn be\n\
3835 followed by a new line. The nested commands must be entered one per line,\n\
3836 and should be terminated by the word `end'.");
3838 add_com ("if", class_support
, if_command
,
3839 "Execute nested commands once IF the conditional expression is non zero.\n\
3840 The conditional expression must follow the word `if' and must in turn be\n\
3841 followed by a new line. The nested commands must be entered one per line,\n\
3842 and should be terminated by the word 'else' or `end'. If an else clause\n\
3843 is used, the same rules apply to its nested commands as to the first ones.");
3845 /* If target is open when baud changes, it doesn't take effect until the
3846 next open (I think, not sure). */
3847 add_show_from_set (add_set_cmd ("remotebaud", no_class
,
3848 var_zinteger
, (char *)&baud_rate
,
3849 "Set baud rate for remote serial I/O.\n\
3850 This value is used to set the speed of the serial port when debugging\n\
3851 using remote targets.", &setlist
),
3855 add_set_cmd ("remotedebug", no_class
, var_zinteger
, (char *)&remote_debug
,
3856 "Set debugging of remote protocol.\n\
3857 When enabled, each packet sent or received with the remote target\n\
3858 is displayed.", &setlist
),
3862 add_set_cmd ("remotetimeout", no_class
, var_integer
, (char *)&remote_timeout
,
3863 "Set timeout limit to wait for target to respond.\n\
3864 This value is used to set the time limit for gdb to wait for a response\n\
3865 from he target.", &setlist
),
3868 c
= add_set_cmd ("annotate", class_obscure
, var_zinteger
,
3869 (char *)&annotation_level
, "Set annotation_level.\n\
3870 0 == normal; 1 == fullname (for use when running under emacs)\n\
3871 2 == output annotated suitably for use by programs that control GDB.",
3873 c
= add_show_from_set (c
, &showlist
);