1 /* GDB CLI command scripting.
3 Copyright (C) 1986-2017 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 3 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, see <http://www.gnu.org/licenses/>. */
22 #include "language.h" /* For value_true */
27 #include "breakpoint.h"
28 #include "cli/cli-cmds.h"
29 #include "cli/cli-decode.h"
30 #include "cli/cli-script.h"
32 #include "extension.h"
34 #include "compile/compile.h"
38 /* Prototypes for local functions. */
40 static enum command_control_type
41 recurse_read_control_structure (char * (*read_next_line_func
) (void),
42 struct command_line
*current_cmd
,
43 void (*validator
)(char *, void *),
46 static char *read_next_line (void);
48 /* Level of control structure when reading. */
49 static int control_level
;
51 /* Level of control structure when executing. */
52 static int command_nest_depth
= 1;
54 /* This is to prevent certain commands being printed twice. */
55 static int suppress_next_print_command_trace
= 0;
57 /* A non-owning slice of a string. */
61 string_view (const char *str_
, size_t len_
)
62 : str (str_
), len (len_
)
69 /* Structure for arguments to user defined functions. */
74 /* Save the command line and store the locations of arguments passed
75 to the user defined function. */
76 explicit user_args (const char *line
);
78 /* Insert the stored user defined arguments into the $arg arguments
80 std::string
insert_args (const char *line
) const;
83 /* Disable copy/assignment. (Since the elements of A point inside
84 COMMAND, copying would need to reconstruct the A vector in the
86 user_args (const user_args
&) =delete;
87 user_args
&operator= (const user_args
&) =delete;
89 /* It is necessary to store a copy of the command line to ensure
90 that the arguments are not overwritten before they are used. */
91 std::string m_command_line
;
93 /* The arguments. Each element points inside M_COMMAND_LINE. */
94 std::vector
<string_view
> m_args
;
97 /* The stack of arguments passed to user defined functions. We need a
98 stack because user-defined functions can call other user-defined
100 static std::vector
<std::unique_ptr
<user_args
>> user_args_stack
;
102 /* An RAII-base class used to push/pop args on the user args
104 struct scoped_user_args_level
106 /* Parse the command line and push the arguments in the user args
108 explicit scoped_user_args_level (const char *line
)
110 user_args_stack
.emplace_back (new user_args (line
));
113 /* Pop the current user arguments from the stack. */
114 ~scoped_user_args_level ()
116 user_args_stack
.pop_back ();
121 /* Return non-zero if TYPE is a multi-line command (i.e., is terminated
125 multi_line_command_p (enum command_control_type type
)
131 case while_stepping_control
:
132 case commands_control
:
133 case compile_control
:
142 /* Allocate, initialize a new command line structure for one of the
143 control commands (if/while). */
145 static struct command_line
*
146 build_command_line (enum command_control_type type
, const char *args
)
148 struct command_line
*cmd
;
150 if (args
== NULL
&& (type
== if_control
|| type
== while_control
))
151 error (_("if/while commands require arguments."));
152 gdb_assert (args
!= NULL
);
154 cmd
= XNEW (struct command_line
);
156 cmd
->control_type
= type
;
159 cmd
->body_list
= XCNEWVEC (struct command_line
*, cmd
->body_count
);
160 cmd
->line
= xstrdup (args
);
165 /* Build and return a new command structure for the control commands
166 such as "if" and "while". */
168 struct command_line
*
169 get_command_line (enum command_control_type type
, char *arg
)
171 struct command_line
*cmd
;
172 struct cleanup
*old_chain
= NULL
;
174 /* Allocate and build a new command line structure. */
175 cmd
= build_command_line (type
, arg
);
177 old_chain
= make_cleanup_free_command_lines (&cmd
);
179 /* Read in the body of this command. */
180 if (recurse_read_control_structure (read_next_line
, cmd
, 0, 0)
183 warning (_("Error reading in canned sequence of commands."));
184 do_cleanups (old_chain
);
188 discard_cleanups (old_chain
);
192 /* Recursively print a command (including full control structures). */
195 print_command_lines (struct ui_out
*uiout
, struct command_line
*cmd
,
198 struct command_line
*list
;
204 uiout
->spaces (2 * depth
);
206 /* A simple command, print it and continue. */
207 if (list
->control_type
== simple_control
)
209 uiout
->field_string (NULL
, list
->line
);
215 /* loop_continue to jump to the start of a while loop, print it
217 if (list
->control_type
== continue_control
)
219 uiout
->field_string (NULL
, "loop_continue");
225 /* loop_break to break out of a while loop, print it and
227 if (list
->control_type
== break_control
)
229 uiout
->field_string (NULL
, "loop_break");
235 /* A while command. Recursively print its subcommands and
237 if (list
->control_type
== while_control
238 || list
->control_type
== while_stepping_control
)
240 /* For while-stepping, the line includes the 'while-stepping'
241 token. See comment in process_next_line for explanation.
242 Here, take care not print 'while-stepping' twice. */
243 if (list
->control_type
== while_control
)
244 uiout
->field_fmt (NULL
, "while %s", list
->line
);
246 uiout
->field_string (NULL
, list
->line
);
248 print_command_lines (uiout
, *list
->body_list
, depth
+ 1);
250 uiout
->spaces (2 * depth
);
251 uiout
->field_string (NULL
, "end");
257 /* An if command. Recursively print both arms before
259 if (list
->control_type
== if_control
)
261 uiout
->field_fmt (NULL
, "if %s", list
->line
);
264 print_command_lines (uiout
, list
->body_list
[0], depth
+ 1);
266 /* Show the false arm if it exists. */
267 if (list
->body_count
== 2)
270 uiout
->spaces (2 * depth
);
271 uiout
->field_string (NULL
, "else");
273 print_command_lines (uiout
, list
->body_list
[1], depth
+ 1);
277 uiout
->spaces (2 * depth
);
278 uiout
->field_string (NULL
, "end");
284 /* A commands command. Print the breakpoint commands and
286 if (list
->control_type
== commands_control
)
289 uiout
->field_fmt (NULL
, "commands %s", list
->line
);
291 uiout
->field_string (NULL
, "commands");
293 print_command_lines (uiout
, *list
->body_list
, depth
+ 1);
295 uiout
->spaces (2 * depth
);
296 uiout
->field_string (NULL
, "end");
302 if (list
->control_type
== python_control
)
304 uiout
->field_string (NULL
, "python");
306 /* Don't indent python code at all. */
307 print_command_lines (uiout
, *list
->body_list
, 0);
309 uiout
->spaces (2 * depth
);
310 uiout
->field_string (NULL
, "end");
316 if (list
->control_type
== compile_control
)
318 uiout
->field_string (NULL
, "compile expression");
320 print_command_lines (uiout
, *list
->body_list
, 0);
322 uiout
->spaces (2 * depth
);
323 uiout
->field_string (NULL
, "end");
329 if (list
->control_type
== guile_control
)
331 uiout
->field_string (NULL
, "guile");
333 print_command_lines (uiout
, *list
->body_list
, depth
+ 1);
335 uiout
->spaces (2 * depth
);
336 uiout
->field_string (NULL
, "end");
342 /* Ignore illegal command type and try next. */
347 /* Handle pre-post hooks. */
350 clear_hook_in_cleanup (void *data
)
352 struct cmd_list_element
*c
= (struct cmd_list_element
*) data
;
354 c
->hook_in
= 0; /* Allow hook to work again once it is complete. */
358 execute_cmd_pre_hook (struct cmd_list_element
*c
)
360 if ((c
->hook_pre
) && (!c
->hook_in
))
362 struct cleanup
*cleanups
= make_cleanup (clear_hook_in_cleanup
, c
);
363 c
->hook_in
= 1; /* Prevent recursive hooking. */
364 execute_user_command (c
->hook_pre
, (char *) 0);
365 do_cleanups (cleanups
);
370 execute_cmd_post_hook (struct cmd_list_element
*c
)
372 if ((c
->hook_post
) && (!c
->hook_in
))
374 struct cleanup
*cleanups
= make_cleanup (clear_hook_in_cleanup
, c
);
376 c
->hook_in
= 1; /* Prevent recursive hooking. */
377 execute_user_command (c
->hook_post
, (char *) 0);
378 do_cleanups (cleanups
);
382 /* Execute the command in CMD. */
384 do_restore_user_call_depth (void * call_depth
)
386 int *depth
= (int *) call_depth
;
395 execute_user_command (struct cmd_list_element
*c
, char *args
)
397 struct ui
*ui
= current_ui
;
398 struct command_line
*cmdlines
;
399 struct cleanup
*old_chain
;
400 enum command_control_type ret
;
401 static int user_call_depth
= 0;
402 extern unsigned int max_user_call_depth
;
404 cmdlines
= c
->user_commands
;
409 scoped_user_args_level
push_user_args (args
);
411 if (++user_call_depth
> max_user_call_depth
)
412 error (_("Max user call depth exceeded -- command aborted."));
414 old_chain
= make_cleanup (do_restore_user_call_depth
, &user_call_depth
);
416 /* Set the instream to 0, indicating execution of a
417 user-defined function. */
418 make_cleanup (do_restore_instream_cleanup
, ui
->instream
);
421 /* Also set the global in_user_command, so that NULL instream is
422 not confused with Insight. */
425 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
427 command_nest_depth
++;
430 ret
= execute_control_command (cmdlines
);
431 if (ret
!= simple_control
&& ret
!= break_control
)
433 warning (_("Error executing canned sequence of commands."));
436 cmdlines
= cmdlines
->next
;
438 command_nest_depth
--;
439 do_cleanups (old_chain
);
442 /* This function is called every time GDB prints a prompt. It ensures
443 that errors and the like do not confuse the command tracing. */
446 reset_command_nest_depth (void)
448 command_nest_depth
= 1;
451 suppress_next_print_command_trace
= 0;
454 /* Print the command, prefixed with '+' to represent the call depth.
455 This is slightly complicated because this function may be called
456 from execute_command and execute_control_command. Unfortunately
457 execute_command also prints the top level control commands.
458 In these cases execute_command will call execute_control_command
459 via while_command or if_command. Inner levels of 'if' and 'while'
460 are dealt with directly. Therefore we can use these functions
461 to determine whether the command has been printed already or not. */
463 print_command_trace (const char *cmd
)
467 if (suppress_next_print_command_trace
)
469 suppress_next_print_command_trace
= 0;
473 if (!source_verbose
&& !trace_commands
)
476 for (i
=0; i
< command_nest_depth
; i
++)
477 printf_filtered ("+");
479 printf_filtered ("%s\n", cmd
);
482 enum command_control_type
483 execute_control_command (struct command_line
*cmd
)
485 struct command_line
*current
;
487 struct value
*val_mark
;
489 enum command_control_type ret
;
491 /* Start by assuming failure, if a problem is detected, the code
492 below will simply "break" out of the switch. */
493 ret
= invalid_control
;
495 switch (cmd
->control_type
)
499 /* A simple command, execute it and return. */
500 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
501 execute_command (&new_line
[0], 0);
502 ret
= cmd
->control_type
;
506 case continue_control
:
507 print_command_trace ("loop_continue");
509 /* Return for "continue", and "break" so we can either
510 continue the loop at the top, or break out. */
511 ret
= cmd
->control_type
;
515 print_command_trace ("loop_break");
517 /* Return for "continue", and "break" so we can either
518 continue the loop at the top, or break out. */
519 ret
= cmd
->control_type
;
524 int len
= strlen (cmd
->line
) + 7;
525 char *buffer
= (char *) alloca (len
);
527 xsnprintf (buffer
, len
, "while %s", cmd
->line
);
528 print_command_trace (buffer
);
530 /* Parse the loop control expression for the while statement. */
531 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
532 expression_up expr
= parse_expression (new_line
.c_str ());
534 ret
= simple_control
;
537 /* Keep iterating so long as the expression is true. */
544 /* Evaluate the expression. */
545 val_mark
= value_mark ();
546 val
= evaluate_expression (expr
.get ());
547 cond_result
= value_true (val
);
548 value_free_to_mark (val_mark
);
550 /* If the value is false, then break out of the loop. */
554 /* Execute the body of the while statement. */
555 current
= *cmd
->body_list
;
558 command_nest_depth
++;
559 ret
= execute_control_command (current
);
560 command_nest_depth
--;
562 /* If we got an error, or a "break" command, then stop
564 if (ret
== invalid_control
|| ret
== break_control
)
570 /* If we got a "continue" command, then restart the loop
572 if (ret
== continue_control
)
575 /* Get the next statement. */
576 current
= current
->next
;
580 /* Reset RET so that we don't recurse the break all the way down. */
581 if (ret
== break_control
)
582 ret
= simple_control
;
589 int len
= strlen (cmd
->line
) + 4;
590 char *buffer
= (char *) alloca (len
);
592 xsnprintf (buffer
, len
, "if %s", cmd
->line
);
593 print_command_trace (buffer
);
595 /* Parse the conditional for the if statement. */
596 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
597 expression_up expr
= parse_expression (new_line
.c_str ());
600 ret
= simple_control
;
602 /* Evaluate the conditional. */
603 val_mark
= value_mark ();
604 val
= evaluate_expression (expr
.get ());
606 /* Choose which arm to take commands from based on the value
607 of the conditional expression. */
608 if (value_true (val
))
609 current
= *cmd
->body_list
;
610 else if (cmd
->body_count
== 2)
611 current
= *(cmd
->body_list
+ 1);
612 value_free_to_mark (val_mark
);
614 /* Execute commands in the given arm. */
617 command_nest_depth
++;
618 ret
= execute_control_command (current
);
619 command_nest_depth
--;
621 /* If we got an error, get out. */
622 if (ret
!= simple_control
)
625 /* Get the next statement in the body. */
626 current
= current
->next
;
632 case commands_control
:
634 /* Breakpoint commands list, record the commands in the
635 breakpoint's command list and return. */
636 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
637 ret
= commands_from_control_command (new_line
.c_str (), cmd
);
641 case compile_control
:
642 eval_compile_command (cmd
, NULL
, cmd
->control_u
.compile
.scope
,
643 cmd
->control_u
.compile
.scope_data
);
644 ret
= simple_control
;
650 eval_ext_lang_from_control_command (cmd
);
651 ret
= simple_control
;
656 warning (_("Invalid control type in canned commands structure."));
663 /* Like execute_control_command, but first set
664 suppress_next_print_command_trace. */
666 enum command_control_type
667 execute_control_command_untraced (struct command_line
*cmd
)
669 suppress_next_print_command_trace
= 1;
670 return execute_control_command (cmd
);
674 /* "while" command support. Executes a body of statements while the
675 loop condition is nonzero. */
678 while_command (char *arg
, int from_tty
)
680 struct command_line
*command
= NULL
;
683 command
= get_command_line (while_control
, arg
);
688 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
690 execute_control_command_untraced (command
);
691 free_command_lines (&command
);
694 /* "if" command support. Execute either the true or false arm depending
695 on the value of the if conditional. */
698 if_command (char *arg
, int from_tty
)
700 struct command_line
*command
= NULL
;
701 struct cleanup
*old_chain
;
704 command
= get_command_line (if_control
, arg
);
709 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
711 execute_control_command_untraced (command
);
712 free_command_lines (&command
);
715 /* Bind the incoming arguments for a user defined command to $arg0,
718 user_args::user_args (const char *command_line
)
722 if (command_line
== NULL
)
725 m_command_line
= command_line
;
726 p
= m_command_line
.c_str ();
730 const char *start_arg
;
735 /* Strip whitespace. */
736 while (*p
== ' ' || *p
== '\t')
739 /* P now points to an argument. */
742 /* Get to the end of this argument. */
745 if (((*p
== ' ' || *p
== '\t')) && !squote
&& !dquote
&& !bsquote
)
774 m_args
.emplace_back (start_arg
, p
- start_arg
);
778 /* Given character string P, return a point to the first argument
779 ($arg), or NULL if P contains no arguments. */
782 locate_arg (const char *p
)
784 while ((p
= strchr (p
, '$')))
786 if (startswith (p
, "$arg")
787 && (isdigit (p
[4]) || p
[4] == 'c'))
794 /* See cli-script.h. */
797 insert_user_defined_cmd_args (const char *line
)
799 /* If we are not in a user-defined command, treat $argc, $arg0, et
800 cetera as normal convenience variables. */
801 if (user_args_stack
.empty ())
804 const std::unique_ptr
<user_args
> &args
= user_args_stack
.back ();
805 return args
->insert_args (line
);
808 /* Insert the user defined arguments stored in user_args into the $arg
809 arguments found in line. */
812 user_args::insert_args (const char *line
) const
814 std::string new_line
;
817 while ((p
= locate_arg (line
)))
819 new_line
.append (line
, p
- line
);
823 new_line
+= std::to_string (m_args
.size ());
832 i
= strtoul (p
+ 4, &tmp
, 10);
833 if ((i
== 0 && tmp
== p
+ 4) || errno
!= 0)
835 else if (i
>= m_args
.size ())
836 error (_("Missing argument %ld in user function."), i
);
839 new_line
.append (m_args
[i
].str
, m_args
[i
].len
);
844 /* Don't forget the tail. */
845 new_line
.append (line
);
851 /* Expand the body_list of COMMAND so that it can hold NEW_LENGTH
852 code bodies. This is typically used when we encounter an "else"
853 clause for an "if" command. */
856 realloc_body_list (struct command_line
*command
, int new_length
)
859 struct command_line
**body_list
;
861 n
= command
->body_count
;
867 body_list
= XCNEWVEC (struct command_line
*, new_length
);
869 memcpy (body_list
, command
->body_list
, sizeof (struct command_line
*) * n
);
871 xfree (command
->body_list
);
872 command
->body_list
= body_list
;
873 command
->body_count
= new_length
;
876 /* Read next line from stdin. Passed to read_command_line_1 and
877 recurse_read_control_structure whenever we need to read commands
881 read_next_line (void)
883 struct ui
*ui
= current_ui
;
884 char *prompt_ptr
, control_prompt
[256];
886 int from_tty
= ui
->instream
== ui
->stdin_stream
;
888 if (control_level
>= 254)
889 error (_("Control nesting too deep!"));
891 /* Set a prompt based on the nesting of the control commands. */
893 || (ui
->instream
== 0 && deprecated_readline_hook
!= NULL
))
895 for (i
= 0; i
< control_level
; i
++)
896 control_prompt
[i
] = ' ';
897 control_prompt
[i
] = '>';
898 control_prompt
[i
+ 1] = '\0';
899 prompt_ptr
= (char *) &control_prompt
[0];
904 return command_line_input (prompt_ptr
, from_tty
, "commands");
907 /* Return true if CMD's name is NAME. */
910 command_name_equals (struct cmd_list_element
*cmd
, const char *name
)
913 && cmd
!= CMD_LIST_AMBIGUOUS
914 && strcmp (cmd
->name
, name
) == 0);
917 /* Given an input line P, skip the command and return a pointer to the
921 line_first_arg (const char *p
)
923 const char *first_arg
= p
+ find_command_name_length (p
);
925 return skip_spaces_const (first_arg
);
928 /* Process one input line. If the command is an "end", return such an
929 indication to the caller. If PARSE_COMMANDS is true, strip leading
930 whitespace (trailing whitespace is always stripped) in the line,
931 attempt to recognize GDB control commands, and also return an
932 indication if the command is an "else" or a nop.
934 Otherwise, only "end" is recognized. */
936 static enum misc_command_type
937 process_next_line (char *p
, struct command_line
**command
, int parse_commands
,
938 void (*validator
)(char *, void *), void *closure
)
944 /* Not sure what to do here. */
948 /* Strip trailing whitespace. */
949 p_end
= p
+ strlen (p
);
950 while (p_end
> p
&& (p_end
[-1] == ' ' || p_end
[-1] == '\t'))
954 /* Strip leading whitespace. */
955 while (p_start
< p_end
&& (*p_start
== ' ' || *p_start
== '\t'))
958 /* 'end' is always recognized, regardless of parse_commands value.
959 We also permit whitespace before end and after. */
960 if (p_end
- p_start
== 3 && startswith (p_start
, "end"))
965 /* Resolve command abbreviations (e.g. 'ws' for 'while-stepping'). */
966 const char *cmd_name
= p
;
967 struct cmd_list_element
*cmd
968 = lookup_cmd_1 (&cmd_name
, cmdlist
, NULL
, 1);
970 /* If commands are parsed, we skip initial spaces. Otherwise,
971 which is the case for Python commands and documentation
972 (see the 'document' command), spaces are preserved. */
975 /* Blanks and comments don't really do anything, but we need to
976 distinguish them from else, end and other commands which can
978 if (p_end
== p
|| p
[0] == '#')
981 /* Is the else clause of an if control structure? */
982 if (p_end
- p
== 4 && startswith (p
, "else"))
985 /* Check for while, if, break, continue, etc and build a new
986 command line structure for them. */
987 if (command_name_equals (cmd
, "while-stepping"))
989 /* Because validate_actionline and encode_action lookup
990 command's line as command, we need the line to
991 include 'while-stepping'.
993 For 'ws' alias, the command will have 'ws', not expanded
994 to 'while-stepping'. This is intentional -- we don't
995 really want frontend to send a command list with 'ws',
996 and next break-info returning command line with
997 'while-stepping'. This should work, but might cause the
998 breakpoint to be marked as changed while it's actually
1000 *command
= build_command_line (while_stepping_control
, p
);
1002 else if (command_name_equals (cmd
, "while"))
1004 *command
= build_command_line (while_control
, line_first_arg (p
));
1006 else if (command_name_equals (cmd
, "if"))
1008 *command
= build_command_line (if_control
, line_first_arg (p
));
1010 else if (command_name_equals (cmd
, "commands"))
1012 *command
= build_command_line (commands_control
, line_first_arg (p
));
1014 else if (command_name_equals (cmd
, "python"))
1016 /* Note that we ignore the inline "python command" form
1018 *command
= build_command_line (python_control
, "");
1020 else if (command_name_equals (cmd
, "compile"))
1022 /* Note that we ignore the inline "compile command" form
1024 *command
= build_command_line (compile_control
, "");
1025 (*command
)->control_u
.compile
.scope
= COMPILE_I_INVALID_SCOPE
;
1028 else if (command_name_equals (cmd
, "guile"))
1030 /* Note that we ignore the inline "guile command" form here. */
1031 *command
= build_command_line (guile_control
, "");
1033 else if (p_end
- p
== 10 && startswith (p
, "loop_break"))
1035 *command
= XNEW (struct command_line
);
1036 (*command
)->next
= NULL
;
1037 (*command
)->line
= NULL
;
1038 (*command
)->control_type
= break_control
;
1039 (*command
)->body_count
= 0;
1040 (*command
)->body_list
= NULL
;
1042 else if (p_end
- p
== 13 && startswith (p
, "loop_continue"))
1044 *command
= XNEW (struct command_line
);
1045 (*command
)->next
= NULL
;
1046 (*command
)->line
= NULL
;
1047 (*command
)->control_type
= continue_control
;
1048 (*command
)->body_count
= 0;
1049 (*command
)->body_list
= NULL
;
1055 if (!parse_commands
|| not_handled
)
1057 /* A normal command. */
1058 *command
= XNEW (struct command_line
);
1059 (*command
)->next
= NULL
;
1060 (*command
)->line
= savestring (p
, p_end
- p
);
1061 (*command
)->control_type
= simple_control
;
1062 (*command
)->body_count
= 0;
1063 (*command
)->body_list
= NULL
;
1071 validator ((*command
)->line
, closure
);
1073 CATCH (ex
, RETURN_MASK_ALL
)
1076 throw_exception (ex
);
1081 /* Nothing special. */
1085 /* Recursively read in the control structures and create a
1086 command_line structure from them. Use read_next_line_func to
1087 obtain lines of the command. */
1089 static enum command_control_type
1090 recurse_read_control_structure (char * (*read_next_line_func
) (void),
1091 struct command_line
*current_cmd
,
1092 void (*validator
)(char *, void *),
1095 int current_body
, i
;
1096 enum misc_command_type val
;
1097 enum command_control_type ret
;
1098 struct command_line
**body_ptr
, *child_tail
, *next
;
1103 /* Sanity checks. */
1104 if (current_cmd
->control_type
== simple_control
)
1105 error (_("Recursed on a simple control type."));
1107 if (current_body
> current_cmd
->body_count
)
1108 error (_("Allocated body is smaller than this command type needs."));
1110 /* Read lines from the input stream and build control structures. */
1116 val
= process_next_line (read_next_line_func (), &next
,
1117 current_cmd
->control_type
!= python_control
1118 && current_cmd
->control_type
!= guile_control
1119 && current_cmd
->control_type
!= compile_control
,
1120 validator
, closure
);
1122 /* Just skip blanks and comments. */
1123 if (val
== nop_command
)
1126 if (val
== end_command
)
1128 if (multi_line_command_p (current_cmd
->control_type
))
1130 /* Success reading an entire canned sequence of commands. */
1131 ret
= simple_control
;
1136 ret
= invalid_control
;
1141 /* Not the end of a control structure. */
1142 if (val
== else_command
)
1144 if (current_cmd
->control_type
== if_control
1145 && current_body
== 1)
1147 realloc_body_list (current_cmd
, 2);
1154 ret
= invalid_control
;
1161 child_tail
->next
= next
;
1165 body_ptr
= current_cmd
->body_list
;
1166 for (i
= 1; i
< current_body
; i
++)
1175 /* If the latest line is another control structure, then recurse
1177 if (multi_line_command_p (next
->control_type
))
1180 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1181 validator
, closure
);
1184 if (ret
!= simple_control
)
1195 restore_interp (void *arg
)
1197 interp_set_temp (interp_name ((struct interp
*)arg
));
1200 /* Read lines from the input stream and accumulate them in a chain of
1201 struct command_line's, which is then returned. For input from a
1202 terminal, the special command "end" is used to mark the end of the
1203 input, and is not included in the returned chain of commands.
1205 If PARSE_COMMANDS is true, strip leading whitespace (trailing whitespace
1206 is always stripped) in the line and attempt to recognize GDB control
1207 commands. Otherwise, only "end" is recognized. */
1209 #define END_MESSAGE "End with a line saying just \"end\"."
1211 struct command_line
*
1212 read_command_lines (char *prompt_arg
, int from_tty
, int parse_commands
,
1213 void (*validator
)(char *, void *), void *closure
)
1215 struct command_line
*head
;
1217 if (from_tty
&& input_interactive_p (current_ui
))
1219 if (deprecated_readline_begin_hook
)
1221 /* Note - intentional to merge messages with no newline. */
1222 (*deprecated_readline_begin_hook
) ("%s %s\n", prompt_arg
,
1227 printf_unfiltered ("%s\n%s\n", prompt_arg
, END_MESSAGE
);
1228 gdb_flush (gdb_stdout
);
1233 /* Reading commands assumes the CLI behavior, so temporarily
1234 override the current interpreter with CLI. */
1235 if (current_interp_named_p (INTERP_CONSOLE
))
1236 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1237 validator
, closure
);
1240 struct interp
*old_interp
= interp_set_temp (INTERP_CONSOLE
);
1241 struct cleanup
*old_chain
= make_cleanup (restore_interp
, old_interp
);
1243 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1244 validator
, closure
);
1245 do_cleanups (old_chain
);
1248 if (from_tty
&& input_interactive_p (current_ui
)
1249 && deprecated_readline_end_hook
)
1251 (*deprecated_readline_end_hook
) ();
1256 /* Act the same way as read_command_lines, except that each new line is
1257 obtained using READ_NEXT_LINE_FUNC. */
1259 struct command_line
*
1260 read_command_lines_1 (char * (*read_next_line_func
) (void), int parse_commands
,
1261 void (*validator
)(char *, void *), void *closure
)
1263 struct command_line
*head
, *tail
, *next
;
1264 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1265 enum command_control_type ret
;
1266 enum misc_command_type val
;
1274 val
= process_next_line (read_next_line_func (), &next
, parse_commands
,
1275 validator
, closure
);
1277 /* Ignore blank lines or comments. */
1278 if (val
== nop_command
)
1281 if (val
== end_command
)
1283 ret
= simple_control
;
1287 if (val
!= ok_command
)
1289 ret
= invalid_control
;
1293 if (multi_line_command_p (next
->control_type
))
1296 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1297 validator
, closure
);
1300 if (ret
== invalid_control
)
1311 make_cleanup_free_command_lines (&head
);
1318 if (ret
!= invalid_control
)
1319 discard_cleanups (old_chain
);
1321 do_cleanups (old_chain
);
1326 /* Free a chain of struct command_line's. */
1329 free_command_lines (struct command_line
**lptr
)
1331 struct command_line
*l
= *lptr
;
1332 struct command_line
*next
;
1333 struct command_line
**blist
;
1338 if (l
->body_count
> 0)
1340 blist
= l
->body_list
;
1341 for (i
= 0; i
< l
->body_count
; i
++, blist
++)
1342 free_command_lines (blist
);
1353 do_free_command_lines_cleanup (void *arg
)
1355 free_command_lines ((struct command_line
**) arg
);
1359 make_cleanup_free_command_lines (struct command_line
**arg
)
1361 return make_cleanup (do_free_command_lines_cleanup
, arg
);
1364 struct command_line
*
1365 copy_command_lines (struct command_line
*cmds
)
1367 struct command_line
*result
= NULL
;
1371 result
= XNEW (struct command_line
);
1373 result
->next
= copy_command_lines (cmds
->next
);
1374 result
->line
= xstrdup (cmds
->line
);
1375 result
->control_type
= cmds
->control_type
;
1376 result
->body_count
= cmds
->body_count
;
1377 if (cmds
->body_count
> 0)
1381 result
->body_list
= XNEWVEC (struct command_line
*, cmds
->body_count
);
1383 for (i
= 0; i
< cmds
->body_count
; i
++)
1384 result
->body_list
[i
] = copy_command_lines (cmds
->body_list
[i
]);
1387 result
->body_list
= NULL
;
1393 /* Validate that *COMNAME is a valid name for a command. Return the
1394 containing command list, in case it starts with a prefix command.
1395 The prefix must already exist. *COMNAME is advanced to point after
1396 any prefix, and a NUL character overwrites the space after the
1399 static struct cmd_list_element
**
1400 validate_comname (char **comname
)
1402 struct cmd_list_element
**list
= &cmdlist
;
1403 char *p
, *last_word
;
1406 error_no_arg (_("name of command to define"));
1408 /* Find the last word of the argument. */
1409 p
= *comname
+ strlen (*comname
);
1410 while (p
> *comname
&& isspace (p
[-1]))
1412 while (p
> *comname
&& !isspace (p
[-1]))
1416 /* Find the corresponding command list. */
1417 if (last_word
!= *comname
)
1419 struct cmd_list_element
*c
;
1421 const char *tem
= *comname
;
1423 /* Separate the prefix and the command. */
1424 saved_char
= last_word
[-1];
1425 last_word
[-1] = '\0';
1427 c
= lookup_cmd (&tem
, cmdlist
, "", 0, 1);
1428 if (c
->prefixlist
== NULL
)
1429 error (_("\"%s\" is not a prefix command."), *comname
);
1431 list
= c
->prefixlist
;
1432 last_word
[-1] = saved_char
;
1433 *comname
= last_word
;
1439 if (!isalnum (*p
) && *p
!= '-' && *p
!= '_')
1440 error (_("Junk in argument list: \"%s\""), p
);
1447 /* This is just a placeholder in the command data structures. */
1449 user_defined_command (char *ignore
, int from_tty
)
1454 define_command (char *comname
, int from_tty
)
1456 #define MAX_TMPBUF 128
1463 struct command_line
*cmds
;
1464 struct cmd_list_element
*c
, *newc
, *hookc
= 0, **list
;
1465 char *tem
, *comfull
;
1467 char tmpbuf
[MAX_TMPBUF
];
1468 int hook_type
= CMD_NO_HOOK
;
1469 int hook_name_size
= 0;
1471 #define HOOK_STRING "hook-"
1473 #define HOOK_POST_STRING "hookpost-"
1474 #define HOOK_POST_LEN 9
1477 list
= validate_comname (&comname
);
1479 /* Look it up, and verify that we got an exact match. */
1481 c
= lookup_cmd (&tem_c
, *list
, "", -1, 1);
1482 if (c
&& strcmp (comname
, c
->name
) != 0)
1489 if (c
->theclass
== class_user
|| c
->theclass
== class_alias
)
1490 q
= query (_("Redefine command \"%s\"? "), c
->name
);
1492 q
= query (_("Really redefine built-in command \"%s\"? "), c
->name
);
1494 error (_("Command \"%s\" not redefined."), c
->name
);
1497 /* If this new command is a hook, then mark the command which it
1498 is hooking. Note that we allow hooking `help' commands, so that
1499 we can hook the `stop' pseudo-command. */
1501 if (!strncmp (comname
, HOOK_STRING
, HOOK_LEN
))
1503 hook_type
= CMD_PRE_HOOK
;
1504 hook_name_size
= HOOK_LEN
;
1506 else if (!strncmp (comname
, HOOK_POST_STRING
, HOOK_POST_LEN
))
1508 hook_type
= CMD_POST_HOOK
;
1509 hook_name_size
= HOOK_POST_LEN
;
1512 if (hook_type
!= CMD_NO_HOOK
)
1514 /* Look up cmd it hooks, and verify that we got an exact match. */
1515 tem_c
= comname
+ hook_name_size
;
1516 hookc
= lookup_cmd (&tem_c
, *list
, "", -1, 0);
1517 if (hookc
&& strcmp (comname
+ hook_name_size
, hookc
->name
) != 0)
1521 warning (_("Your new `%s' command does not "
1522 "hook any existing command."),
1524 if (!query (_("Proceed? ")))
1525 error (_("Not confirmed."));
1529 comname
= xstrdup (comname
);
1531 /* If the rest of the commands will be case insensitive, this one
1532 should behave in the same manner. */
1533 for (tem
= comname
; *tem
; tem
++)
1535 *tem
= tolower (*tem
);
1537 xsnprintf (tmpbuf
, sizeof (tmpbuf
),
1538 "Type commands for definition of \"%s\".", comfull
);
1539 cmds
= read_command_lines (tmpbuf
, from_tty
, 1, 0, 0);
1541 if (c
&& c
->theclass
== class_user
)
1542 free_command_lines (&c
->user_commands
);
1544 newc
= add_cmd (comname
, class_user
, user_defined_command
,
1545 (c
&& c
->theclass
== class_user
)
1546 ? c
->doc
: xstrdup ("User-defined."), list
);
1547 newc
->user_commands
= cmds
;
1549 /* If this new command is a hook, then mark both commands as being
1556 hookc
->hook_pre
= newc
; /* Target gets hooked. */
1557 newc
->hookee_pre
= hookc
; /* We are marked as hooking target cmd. */
1560 hookc
->hook_post
= newc
; /* Target gets hooked. */
1561 newc
->hookee_post
= hookc
; /* We are marked as hooking
1565 /* Should never come here as hookc would be 0. */
1566 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1572 document_command (char *comname
, int from_tty
)
1574 struct command_line
*doclines
;
1575 struct cmd_list_element
*c
, **list
;
1581 list
= validate_comname (&comname
);
1584 c
= lookup_cmd (&tem
, *list
, "", 0, 1);
1586 if (c
->theclass
!= class_user
)
1587 error (_("Command \"%s\" is built-in."), comfull
);
1589 xsnprintf (tmpbuf
, sizeof (tmpbuf
), "Type documentation for \"%s\".",
1591 doclines
= read_command_lines (tmpbuf
, from_tty
, 0, 0, 0);
1594 xfree ((char *) c
->doc
);
1597 struct command_line
*cl1
;
1601 for (cl1
= doclines
; cl1
; cl1
= cl1
->next
)
1602 len
+= strlen (cl1
->line
) + 1;
1604 doc
= (char *) xmalloc (len
+ 1);
1607 for (cl1
= doclines
; cl1
; cl1
= cl1
->next
)
1609 strcat (doc
, cl1
->line
);
1617 free_command_lines (&doclines
);
1620 struct source_cleanup_lines_args
1623 const char *old_file
;
1627 source_cleanup_lines (void *args
)
1629 struct source_cleanup_lines_args
*p
=
1630 (struct source_cleanup_lines_args
*) args
;
1632 source_line_number
= p
->old_line
;
1633 source_file_name
= p
->old_file
;
1636 /* Used to implement source_command. */
1639 script_from_file (FILE *stream
, const char *file
)
1641 struct cleanup
*old_cleanups
;
1642 struct source_cleanup_lines_args old_lines
;
1645 internal_error (__FILE__
, __LINE__
, _("called with NULL file pointer!"));
1647 old_lines
.old_line
= source_line_number
;
1648 old_lines
.old_file
= source_file_name
;
1649 old_cleanups
= make_cleanup (source_cleanup_lines
, &old_lines
);
1650 source_line_number
= 0;
1651 source_file_name
= file
;
1654 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
1658 read_command_file (stream
);
1660 CATCH (e
, RETURN_MASK_ERROR
)
1662 /* Re-throw the error, but with the file name information
1664 throw_error (e
.error
,
1665 _("%s:%d: Error in sourced command file:\n%s"),
1666 source_file_name
, source_line_number
, e
.message
);
1671 do_cleanups (old_cleanups
);
1674 /* Print the definition of user command C to STREAM. Or, if C is a
1675 prefix command, show the definitions of all user commands under C
1676 (recursively). PREFIX and NAME combined are the name of the
1679 show_user_1 (struct cmd_list_element
*c
, const char *prefix
, const char *name
,
1680 struct ui_file
*stream
)
1682 struct command_line
*cmdlines
;
1684 if (c
->prefixlist
!= NULL
)
1686 const char *prefixname
= c
->prefixname
;
1688 for (c
= *c
->prefixlist
; c
!= NULL
; c
= c
->next
)
1689 if (c
->theclass
== class_user
|| c
->prefixlist
!= NULL
)
1690 show_user_1 (c
, prefixname
, c
->name
, gdb_stdout
);
1694 cmdlines
= c
->user_commands
;
1695 fprintf_filtered (stream
, "User command \"%s%s\":\n", prefix
, name
);
1699 print_command_lines (current_uiout
, cmdlines
, 1);
1700 fputs_filtered ("\n", stream
);
1705 initialize_file_ftype _initialize_cli_script
;
1708 _initialize_cli_script (void)
1710 add_com ("document", class_support
, document_command
, _("\
1711 Document a user-defined command.\n\
1712 Give command name as argument. Give documentation on following lines.\n\
1713 End with a line of just \"end\"."));
1714 add_com ("define", class_support
, define_command
, _("\
1715 Define a new command name. Command name is argument.\n\
1716 Definition appears on following lines, one command per line.\n\
1717 End with a line of just \"end\".\n\
1718 Use the \"document\" command to give documentation for the new command.\n\
1719 Commands defined in this way may have up to ten arguments."));
1721 add_com ("while", class_support
, while_command
, _("\
1722 Execute nested commands WHILE the conditional expression is non zero.\n\
1723 The conditional expression must follow the word `while' and must in turn be\n\
1724 followed by a new line. The nested commands must be entered one per line,\n\
1725 and should be terminated by the word `end'."));
1727 add_com ("if", class_support
, if_command
, _("\
1728 Execute nested commands once IF the conditional expression is non zero.\n\
1729 The conditional expression must follow the word `if' and must in turn be\n\
1730 followed by a new line. The nested commands must be entered one per line,\n\
1731 and should be terminated by the word 'else' or `end'. If an else clause\n\
1732 is used, the same rules apply to its nested commands as to the first ones."));