1 /* GDB CLI command scripting.
3 Copyright (C) 1986-2018 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"
35 #include "common/gdb_string_view.h"
39 /* Prototypes for local functions. */
41 static enum command_control_type
42 recurse_read_control_structure (char * (*read_next_line_func
) (void),
43 struct command_line
*current_cmd
,
44 void (*validator
)(char *, void *),
47 static char *read_next_line (void);
49 /* Level of control structure when reading. */
50 static int control_level
;
52 /* Level of control structure when executing. */
53 static int command_nest_depth
= 1;
55 /* This is to prevent certain commands being printed twice. */
56 static int suppress_next_print_command_trace
= 0;
58 /* Structure for arguments to user defined functions. */
63 /* Save the command line and store the locations of arguments passed
64 to the user defined function. */
65 explicit user_args (const char *line
);
67 /* Insert the stored user defined arguments into the $arg arguments
69 std::string
insert_args (const char *line
) const;
72 /* Disable copy/assignment. (Since the elements of A point inside
73 COMMAND, copying would need to reconstruct the A vector in the
75 user_args (const user_args
&) =delete;
76 user_args
&operator= (const user_args
&) =delete;
78 /* It is necessary to store a copy of the command line to ensure
79 that the arguments are not overwritten before they are used. */
80 std::string m_command_line
;
82 /* The arguments. Each element points inside M_COMMAND_LINE. */
83 std::vector
<gdb::string_view
> m_args
;
86 /* The stack of arguments passed to user defined functions. We need a
87 stack because user-defined functions can call other user-defined
89 static std::vector
<std::unique_ptr
<user_args
>> user_args_stack
;
91 /* An RAII-base class used to push/pop args on the user args
93 struct scoped_user_args_level
95 /* Parse the command line and push the arguments in the user args
97 explicit scoped_user_args_level (const char *line
)
99 user_args_stack
.emplace_back (new user_args (line
));
102 /* Pop the current user arguments from the stack. */
103 ~scoped_user_args_level ()
105 user_args_stack
.pop_back ();
110 /* Return non-zero if TYPE is a multi-line command (i.e., is terminated
114 multi_line_command_p (enum command_control_type type
)
120 case while_stepping_control
:
121 case commands_control
:
122 case compile_control
:
131 /* Allocate, initialize a new command line structure for one of the
132 control commands (if/while). */
134 static struct command_line
*
135 build_command_line (enum command_control_type type
, const char *args
)
137 if ((args
== NULL
|| *args
== '\0')
138 && (type
== if_control
|| type
== while_control
))
139 error (_("if/while commands require arguments."));
140 gdb_assert (args
!= NULL
);
142 return new struct command_line (type
, xstrdup (args
));
145 /* Build and return a new command structure for the control commands
146 such as "if" and "while". */
149 get_command_line (enum command_control_type type
, const char *arg
)
151 /* Allocate and build a new command line structure. */
152 counted_command_line
cmd (build_command_line (type
, arg
),
153 command_lines_deleter ());
155 /* Read in the body of this command. */
156 if (recurse_read_control_structure (read_next_line
, cmd
.get (), 0, 0)
159 warning (_("Error reading in canned sequence of commands."));
166 /* Recursively print a command (including full control structures). */
169 print_command_lines (struct ui_out
*uiout
, struct command_line
*cmd
,
172 struct command_line
*list
;
178 uiout
->spaces (2 * depth
);
180 /* A simple command, print it and continue. */
181 if (list
->control_type
== simple_control
)
183 uiout
->field_string (NULL
, list
->line
);
189 /* loop_continue to jump to the start of a while loop, print it
191 if (list
->control_type
== continue_control
)
193 uiout
->field_string (NULL
, "loop_continue");
199 /* loop_break to break out of a while loop, print it and
201 if (list
->control_type
== break_control
)
203 uiout
->field_string (NULL
, "loop_break");
209 /* A while command. Recursively print its subcommands and
211 if (list
->control_type
== while_control
212 || list
->control_type
== while_stepping_control
)
214 /* For while-stepping, the line includes the 'while-stepping'
215 token. See comment in process_next_line for explanation.
216 Here, take care not print 'while-stepping' twice. */
217 if (list
->control_type
== while_control
)
218 uiout
->field_fmt (NULL
, "while %s", list
->line
);
220 uiout
->field_string (NULL
, list
->line
);
222 print_command_lines (uiout
, list
->body_list_0
.get (), depth
+ 1);
224 uiout
->spaces (2 * depth
);
225 uiout
->field_string (NULL
, "end");
231 /* An if command. Recursively print both arms before
233 if (list
->control_type
== if_control
)
235 uiout
->field_fmt (NULL
, "if %s", list
->line
);
238 print_command_lines (uiout
, list
->body_list_0
.get (), depth
+ 1);
240 /* Show the false arm if it exists. */
241 if (list
->body_list_1
!= nullptr)
244 uiout
->spaces (2 * depth
);
245 uiout
->field_string (NULL
, "else");
247 print_command_lines (uiout
, list
->body_list_1
.get (), depth
+ 1);
251 uiout
->spaces (2 * depth
);
252 uiout
->field_string (NULL
, "end");
258 /* A commands command. Print the breakpoint commands and
260 if (list
->control_type
== commands_control
)
263 uiout
->field_fmt (NULL
, "commands %s", list
->line
);
265 uiout
->field_string (NULL
, "commands");
267 print_command_lines (uiout
, list
->body_list_0
.get (), depth
+ 1);
269 uiout
->spaces (2 * depth
);
270 uiout
->field_string (NULL
, "end");
276 if (list
->control_type
== python_control
)
278 uiout
->field_string (NULL
, "python");
280 /* Don't indent python code at all. */
281 print_command_lines (uiout
, list
->body_list_0
.get (), 0);
283 uiout
->spaces (2 * depth
);
284 uiout
->field_string (NULL
, "end");
290 if (list
->control_type
== compile_control
)
292 uiout
->field_string (NULL
, "compile expression");
294 print_command_lines (uiout
, list
->body_list_0
.get (), 0);
296 uiout
->spaces (2 * depth
);
297 uiout
->field_string (NULL
, "end");
303 if (list
->control_type
== guile_control
)
305 uiout
->field_string (NULL
, "guile");
307 print_command_lines (uiout
, list
->body_list_0
.get (), depth
+ 1);
309 uiout
->spaces (2 * depth
);
310 uiout
->field_string (NULL
, "end");
316 /* Ignore illegal command type and try next. */
321 /* Handle pre-post hooks. */
323 class scoped_restore_hook_in
327 scoped_restore_hook_in (struct cmd_list_element
*c
)
332 ~scoped_restore_hook_in ()
337 scoped_restore_hook_in (const scoped_restore_hook_in
&) = delete;
338 scoped_restore_hook_in
&operator= (const scoped_restore_hook_in
&) = delete;
342 struct cmd_list_element
*m_cmd
;
346 execute_cmd_pre_hook (struct cmd_list_element
*c
)
348 if ((c
->hook_pre
) && (!c
->hook_in
))
350 scoped_restore_hook_in
restore_hook (c
);
351 c
->hook_in
= 1; /* Prevent recursive hooking. */
352 execute_user_command (c
->hook_pre
, nullptr);
357 execute_cmd_post_hook (struct cmd_list_element
*c
)
359 if ((c
->hook_post
) && (!c
->hook_in
))
361 scoped_restore_hook_in
restore_hook (c
);
362 c
->hook_in
= 1; /* Prevent recursive hooking. */
363 execute_user_command (c
->hook_post
, nullptr);
368 execute_user_command (struct cmd_list_element
*c
, const char *args
)
370 struct ui
*ui
= current_ui
;
371 counted_command_line cmdlines_copy
;
372 enum command_control_type ret
;
373 extern unsigned int max_user_call_depth
;
375 /* Ensure that the user commands can't be deleted while they are
377 cmdlines_copy
= c
->user_commands
;
378 if (cmdlines_copy
== 0)
381 struct command_line
*cmdlines
= cmdlines_copy
.get ();
383 scoped_user_args_level
push_user_args (args
);
385 if (user_args_stack
.size () > max_user_call_depth
)
386 error (_("Max user call depth exceeded -- command aborted."));
388 /* Set the instream to 0, indicating execution of a
389 user-defined function. */
390 scoped_restore restore_instream
391 = make_scoped_restore (&ui
->instream
, nullptr);
393 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
395 scoped_restore save_nesting
396 = make_scoped_restore (&command_nest_depth
, command_nest_depth
+ 1);
399 ret
= execute_control_command (cmdlines
);
400 if (ret
!= simple_control
&& ret
!= break_control
)
402 warning (_("Error executing canned sequence of commands."));
405 cmdlines
= cmdlines
->next
;
409 /* This function is called every time GDB prints a prompt. It ensures
410 that errors and the like do not confuse the command tracing. */
413 reset_command_nest_depth (void)
415 command_nest_depth
= 1;
418 suppress_next_print_command_trace
= 0;
421 /* Print the command, prefixed with '+' to represent the call depth.
422 This is slightly complicated because this function may be called
423 from execute_command and execute_control_command. Unfortunately
424 execute_command also prints the top level control commands.
425 In these cases execute_command will call execute_control_command
426 via while_command or if_command. Inner levels of 'if' and 'while'
427 are dealt with directly. Therefore we can use these functions
428 to determine whether the command has been printed already or not. */
429 ATTRIBUTE_PRINTF (1, 2)
431 print_command_trace (const char *fmt
, ...)
435 if (suppress_next_print_command_trace
)
437 suppress_next_print_command_trace
= 0;
441 if (!source_verbose
&& !trace_commands
)
444 for (i
=0; i
< command_nest_depth
; i
++)
445 printf_filtered ("+");
449 va_start (args
, fmt
);
450 vprintf_filtered (fmt
, args
);
452 puts_filtered ("\n");
455 /* Helper for execute_control_command. */
457 static enum command_control_type
458 execute_control_command_1 (struct command_line
*cmd
)
460 struct command_line
*current
;
462 struct value
*val_mark
;
464 enum command_control_type ret
;
466 /* Start by assuming failure, if a problem is detected, the code
467 below will simply "break" out of the switch. */
468 ret
= invalid_control
;
470 switch (cmd
->control_type
)
474 /* A simple command, execute it and return. */
475 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
476 execute_command (new_line
.c_str (), 0);
477 ret
= cmd
->control_type
;
481 case continue_control
:
482 print_command_trace ("loop_continue");
484 /* Return for "continue", and "break" so we can either
485 continue the loop at the top, or break out. */
486 ret
= cmd
->control_type
;
490 print_command_trace ("loop_break");
492 /* Return for "continue", and "break" so we can either
493 continue the loop at the top, or break out. */
494 ret
= cmd
->control_type
;
499 print_command_trace ("while %s", cmd
->line
);
501 /* Parse the loop control expression for the while statement. */
502 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
503 expression_up expr
= parse_expression (new_line
.c_str ());
505 ret
= simple_control
;
508 /* Keep iterating so long as the expression is true. */
515 /* Evaluate the expression. */
516 val_mark
= value_mark ();
517 val
= evaluate_expression (expr
.get ());
518 cond_result
= value_true (val
);
519 value_free_to_mark (val_mark
);
521 /* If the value is false, then break out of the loop. */
525 /* Execute the body of the while statement. */
526 current
= cmd
->body_list_0
.get ();
529 scoped_restore save_nesting
530 = make_scoped_restore (&command_nest_depth
, command_nest_depth
+ 1);
531 ret
= execute_control_command_1 (current
);
533 /* If we got an error, or a "break" command, then stop
535 if (ret
== invalid_control
|| ret
== break_control
)
541 /* If we got a "continue" command, then restart the loop
543 if (ret
== continue_control
)
546 /* Get the next statement. */
547 current
= current
->next
;
551 /* Reset RET so that we don't recurse the break all the way down. */
552 if (ret
== break_control
)
553 ret
= simple_control
;
560 print_command_trace ("if %s", cmd
->line
);
562 /* Parse the conditional for the if statement. */
563 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
564 expression_up expr
= parse_expression (new_line
.c_str ());
567 ret
= simple_control
;
569 /* Evaluate the conditional. */
570 val_mark
= value_mark ();
571 val
= evaluate_expression (expr
.get ());
573 /* Choose which arm to take commands from based on the value
574 of the conditional expression. */
575 if (value_true (val
))
576 current
= cmd
->body_list_0
.get ();
577 else if (cmd
->body_list_1
!= nullptr)
578 current
= cmd
->body_list_1
.get ();
579 value_free_to_mark (val_mark
);
581 /* Execute commands in the given arm. */
584 scoped_restore save_nesting
585 = make_scoped_restore (&command_nest_depth
, command_nest_depth
+ 1);
586 ret
= execute_control_command_1 (current
);
588 /* If we got an error, get out. */
589 if (ret
!= simple_control
)
592 /* Get the next statement in the body. */
593 current
= current
->next
;
599 case commands_control
:
601 /* Breakpoint commands list, record the commands in the
602 breakpoint's command list and return. */
603 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
604 ret
= commands_from_control_command (new_line
.c_str (), cmd
);
608 case compile_control
:
609 eval_compile_command (cmd
, NULL
, cmd
->control_u
.compile
.scope
,
610 cmd
->control_u
.compile
.scope_data
);
611 ret
= simple_control
;
617 eval_ext_lang_from_control_command (cmd
);
618 ret
= simple_control
;
623 warning (_("Invalid control type in canned commands structure."));
630 enum command_control_type
631 execute_control_command (struct command_line
*cmd
)
633 /* Make sure we use the console uiout. It's possible that we are executing
634 breakpoint commands while running the MI interpreter. */
635 interp
*console
= interp_lookup (current_ui
, INTERP_CONSOLE
);
636 scoped_restore save_uiout
637 = make_scoped_restore (¤t_uiout
, interp_ui_out (console
));
639 return execute_control_command_1 (cmd
);
642 /* Like execute_control_command, but first set
643 suppress_next_print_command_trace. */
645 enum command_control_type
646 execute_control_command_untraced (struct command_line
*cmd
)
648 suppress_next_print_command_trace
= 1;
649 return execute_control_command (cmd
);
653 /* "while" command support. Executes a body of statements while the
654 loop condition is nonzero. */
657 while_command (const char *arg
, int from_tty
)
660 counted_command_line command
= get_command_line (while_control
, arg
);
665 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
667 execute_control_command_untraced (command
.get ());
670 /* "if" command support. Execute either the true or false arm depending
671 on the value of the if conditional. */
674 if_command (const char *arg
, int from_tty
)
677 counted_command_line command
= get_command_line (if_control
, arg
);
682 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
684 execute_control_command_untraced (command
.get ());
687 /* Bind the incoming arguments for a user defined command to $arg0,
690 user_args::user_args (const char *command_line
)
694 if (command_line
== NULL
)
697 m_command_line
= command_line
;
698 p
= m_command_line
.c_str ();
702 const char *start_arg
;
707 /* Strip whitespace. */
708 while (*p
== ' ' || *p
== '\t')
711 /* P now points to an argument. */
714 /* Get to the end of this argument. */
717 if (((*p
== ' ' || *p
== '\t')) && !squote
&& !dquote
&& !bsquote
)
746 m_args
.emplace_back (start_arg
, p
- start_arg
);
750 /* Given character string P, return a point to the first argument
751 ($arg), or NULL if P contains no arguments. */
754 locate_arg (const char *p
)
756 while ((p
= strchr (p
, '$')))
758 if (startswith (p
, "$arg")
759 && (isdigit (p
[4]) || p
[4] == 'c'))
766 /* See cli-script.h. */
769 insert_user_defined_cmd_args (const char *line
)
771 /* If we are not in a user-defined command, treat $argc, $arg0, et
772 cetera as normal convenience variables. */
773 if (user_args_stack
.empty ())
776 const std::unique_ptr
<user_args
> &args
= user_args_stack
.back ();
777 return args
->insert_args (line
);
780 /* Insert the user defined arguments stored in user_args into the $arg
781 arguments found in line. */
784 user_args::insert_args (const char *line
) const
786 std::string new_line
;
789 while ((p
= locate_arg (line
)))
791 new_line
.append (line
, p
- line
);
795 new_line
+= std::to_string (m_args
.size ());
804 i
= strtoul (p
+ 4, &tmp
, 10);
805 if ((i
== 0 && tmp
== p
+ 4) || errno
!= 0)
807 else if (i
>= m_args
.size ())
808 error (_("Missing argument %ld in user function."), i
);
811 new_line
.append (m_args
[i
].data (), m_args
[i
].length ());
816 /* Don't forget the tail. */
817 new_line
.append (line
);
823 /* Read next line from stdin. Passed to read_command_line_1 and
824 recurse_read_control_structure whenever we need to read commands
828 read_next_line (void)
830 struct ui
*ui
= current_ui
;
831 char *prompt_ptr
, control_prompt
[256];
833 int from_tty
= ui
->instream
== ui
->stdin_stream
;
835 if (control_level
>= 254)
836 error (_("Control nesting too deep!"));
838 /* Set a prompt based on the nesting of the control commands. */
840 || (ui
->instream
== 0 && deprecated_readline_hook
!= NULL
))
842 for (i
= 0; i
< control_level
; i
++)
843 control_prompt
[i
] = ' ';
844 control_prompt
[i
] = '>';
845 control_prompt
[i
+ 1] = '\0';
846 prompt_ptr
= (char *) &control_prompt
[0];
851 return command_line_input (prompt_ptr
, from_tty
, "commands");
854 /* Return true if CMD's name is NAME. */
857 command_name_equals (struct cmd_list_element
*cmd
, const char *name
)
860 && cmd
!= CMD_LIST_AMBIGUOUS
861 && strcmp (cmd
->name
, name
) == 0);
864 /* Given an input line P, skip the command and return a pointer to the
868 line_first_arg (const char *p
)
870 const char *first_arg
= p
+ find_command_name_length (p
);
872 return skip_spaces (first_arg
);
875 /* Process one input line. If the command is an "end", return such an
876 indication to the caller. If PARSE_COMMANDS is true, strip leading
877 whitespace (trailing whitespace is always stripped) in the line,
878 attempt to recognize GDB control commands, and also return an
879 indication if the command is an "else" or a nop.
881 Otherwise, only "end" is recognized. */
883 static enum misc_command_type
884 process_next_line (char *p
, struct command_line
**command
, int parse_commands
,
885 void (*validator
)(char *, void *), void *closure
)
891 /* Not sure what to do here. */
895 /* Strip trailing whitespace. */
896 p_end
= p
+ strlen (p
);
897 while (p_end
> p
&& (p_end
[-1] == ' ' || p_end
[-1] == '\t'))
901 /* Strip leading whitespace. */
902 while (p_start
< p_end
&& (*p_start
== ' ' || *p_start
== '\t'))
905 /* 'end' is always recognized, regardless of parse_commands value.
906 We also permit whitespace before end and after. */
907 if (p_end
- p_start
== 3 && startswith (p_start
, "end"))
912 /* Resolve command abbreviations (e.g. 'ws' for 'while-stepping'). */
913 const char *cmd_name
= p
;
914 struct cmd_list_element
*cmd
915 = lookup_cmd_1 (&cmd_name
, cmdlist
, NULL
, 1);
916 cmd_name
= skip_spaces (cmd_name
);
917 bool inline_cmd
= *cmd_name
!= '\0';
919 /* If commands are parsed, we skip initial spaces. Otherwise,
920 which is the case for Python commands and documentation
921 (see the 'document' command), spaces are preserved. */
924 /* Blanks and comments don't really do anything, but we need to
925 distinguish them from else, end and other commands which can
927 if (p_end
== p
|| p
[0] == '#')
930 /* Is the else clause of an if control structure? */
931 if (p_end
- p
== 4 && startswith (p
, "else"))
934 /* Check for while, if, break, continue, etc and build a new
935 command line structure for them. */
936 if (command_name_equals (cmd
, "while-stepping"))
938 /* Because validate_actionline and encode_action lookup
939 command's line as command, we need the line to
940 include 'while-stepping'.
942 For 'ws' alias, the command will have 'ws', not expanded
943 to 'while-stepping'. This is intentional -- we don't
944 really want frontend to send a command list with 'ws',
945 and next break-info returning command line with
946 'while-stepping'. This should work, but might cause the
947 breakpoint to be marked as changed while it's actually
949 *command
= build_command_line (while_stepping_control
, p
);
951 else if (command_name_equals (cmd
, "while"))
953 *command
= build_command_line (while_control
, line_first_arg (p
));
955 else if (command_name_equals (cmd
, "if"))
957 *command
= build_command_line (if_control
, line_first_arg (p
));
959 else if (command_name_equals (cmd
, "commands"))
961 *command
= build_command_line (commands_control
, line_first_arg (p
));
963 else if (command_name_equals (cmd
, "python") && !inline_cmd
)
965 /* Note that we ignore the inline "python command" form
967 *command
= build_command_line (python_control
, "");
969 else if (command_name_equals (cmd
, "compile") && !inline_cmd
)
971 /* Note that we ignore the inline "compile command" form
973 *command
= build_command_line (compile_control
, "");
974 (*command
)->control_u
.compile
.scope
= COMPILE_I_INVALID_SCOPE
;
976 else if (command_name_equals (cmd
, "guile") && !inline_cmd
)
978 /* Note that we ignore the inline "guile command" form here. */
979 *command
= build_command_line (guile_control
, "");
981 else if (p_end
- p
== 10 && startswith (p
, "loop_break"))
982 *command
= new struct command_line (break_control
);
983 else if (p_end
- p
== 13 && startswith (p
, "loop_continue"))
984 *command
= new struct command_line (continue_control
);
989 if (!parse_commands
|| not_handled
)
991 /* A normal command. */
992 *command
= new struct command_line (simple_control
,
993 savestring (p
, p_end
- p
));
1001 validator ((*command
)->line
, closure
);
1003 CATCH (ex
, RETURN_MASK_ALL
)
1005 free_command_lines (command
);
1006 throw_exception (ex
);
1011 /* Nothing special. */
1015 /* Recursively read in the control structures and create a
1016 command_line structure from them. Use read_next_line_func to
1017 obtain lines of the command. */
1019 static enum command_control_type
1020 recurse_read_control_structure (char * (*read_next_line_func
) (void),
1021 struct command_line
*current_cmd
,
1022 void (*validator
)(char *, void *),
1025 enum misc_command_type val
;
1026 enum command_control_type ret
;
1027 struct command_line
**body_ptr
, *child_tail
, *next
;
1028 counted_command_line
*current_body
= ¤t_cmd
->body_list_0
;
1032 /* Sanity checks. */
1033 if (current_cmd
->control_type
== simple_control
)
1034 error (_("Recursed on a simple control type."));
1036 /* Read lines from the input stream and build control structures. */
1042 val
= process_next_line (read_next_line_func (), &next
,
1043 current_cmd
->control_type
!= python_control
1044 && current_cmd
->control_type
!= guile_control
1045 && current_cmd
->control_type
!= compile_control
,
1046 validator
, closure
);
1048 /* Just skip blanks and comments. */
1049 if (val
== nop_command
)
1052 if (val
== end_command
)
1054 if (multi_line_command_p (current_cmd
->control_type
))
1056 /* Success reading an entire canned sequence of commands. */
1057 ret
= simple_control
;
1062 ret
= invalid_control
;
1067 /* Not the end of a control structure. */
1068 if (val
== else_command
)
1070 if (current_cmd
->control_type
== if_control
1071 && current_body
== ¤t_cmd
->body_list_0
)
1073 current_body
= ¤t_cmd
->body_list_1
;
1079 ret
= invalid_control
;
1086 child_tail
->next
= next
;
1089 *current_body
= counted_command_line (next
, command_lines_deleter ());
1093 /* If the latest line is another control structure, then recurse
1095 if (multi_line_command_p (next
->control_type
))
1098 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1099 validator
, closure
);
1102 if (ret
!= simple_control
)
1112 /* Read lines from the input stream and accumulate them in a chain of
1113 struct command_line's, which is then returned. For input from a
1114 terminal, the special command "end" is used to mark the end of the
1115 input, and is not included in the returned chain of commands.
1117 If PARSE_COMMANDS is true, strip leading whitespace (trailing whitespace
1118 is always stripped) in the line and attempt to recognize GDB control
1119 commands. Otherwise, only "end" is recognized. */
1121 #define END_MESSAGE "End with a line saying just \"end\"."
1123 counted_command_line
1124 read_command_lines (char *prompt_arg
, int from_tty
, int parse_commands
,
1125 void (*validator
)(char *, void *), void *closure
)
1127 if (from_tty
&& input_interactive_p (current_ui
))
1129 if (deprecated_readline_begin_hook
)
1131 /* Note - intentional to merge messages with no newline. */
1132 (*deprecated_readline_begin_hook
) ("%s %s\n", prompt_arg
,
1137 printf_unfiltered ("%s\n%s\n", prompt_arg
, END_MESSAGE
);
1138 gdb_flush (gdb_stdout
);
1143 /* Reading commands assumes the CLI behavior, so temporarily
1144 override the current interpreter with CLI. */
1145 counted_command_line
head (nullptr, command_lines_deleter ());
1146 if (current_interp_named_p (INTERP_CONSOLE
))
1147 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1148 validator
, closure
);
1151 scoped_restore_interp
interp_restorer (INTERP_CONSOLE
);
1153 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1154 validator
, closure
);
1157 if (from_tty
&& input_interactive_p (current_ui
)
1158 && deprecated_readline_end_hook
)
1160 (*deprecated_readline_end_hook
) ();
1165 /* Act the same way as read_command_lines, except that each new line is
1166 obtained using READ_NEXT_LINE_FUNC. */
1168 counted_command_line
1169 read_command_lines_1 (char * (*read_next_line_func
) (void), int parse_commands
,
1170 void (*validator
)(char *, void *), void *closure
)
1172 struct command_line
*tail
, *next
;
1173 counted_command_line
head (nullptr, command_lines_deleter ());
1174 enum command_control_type ret
;
1175 enum misc_command_type val
;
1183 val
= process_next_line (read_next_line_func (), &next
, parse_commands
,
1184 validator
, closure
);
1186 /* Ignore blank lines or comments. */
1187 if (val
== nop_command
)
1190 if (val
== end_command
)
1192 ret
= simple_control
;
1196 if (val
!= ok_command
)
1198 ret
= invalid_control
;
1202 if (multi_line_command_p (next
->control_type
))
1205 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1206 validator
, closure
);
1209 if (ret
== invalid_control
)
1219 head
= counted_command_line (next
, command_lines_deleter ());
1226 if (ret
== invalid_control
)
1232 /* Free a chain of struct command_line's. */
1235 free_command_lines (struct command_line
**lptr
)
1237 struct command_line
*l
= *lptr
;
1238 struct command_line
*next
;
1249 /* Validate that *COMNAME is a valid name for a command. Return the
1250 containing command list, in case it starts with a prefix command.
1251 The prefix must already exist. *COMNAME is advanced to point after
1252 any prefix, and a NUL character overwrites the space after the
1255 static struct cmd_list_element
**
1256 validate_comname (const char **comname
)
1258 struct cmd_list_element
**list
= &cmdlist
;
1259 const char *p
, *last_word
;
1262 error_no_arg (_("name of command to define"));
1264 /* Find the last word of the argument. */
1265 p
= *comname
+ strlen (*comname
);
1266 while (p
> *comname
&& isspace (p
[-1]))
1268 while (p
> *comname
&& !isspace (p
[-1]))
1272 /* Find the corresponding command list. */
1273 if (last_word
!= *comname
)
1275 struct cmd_list_element
*c
;
1277 /* Separate the prefix and the command. */
1278 std::string
prefix (*comname
, last_word
- 1);
1279 const char *tem
= prefix
.c_str ();
1281 c
= lookup_cmd (&tem
, cmdlist
, "", 0, 1);
1282 if (c
->prefixlist
== NULL
)
1283 error (_("\"%s\" is not a prefix command."), prefix
.c_str ());
1285 list
= c
->prefixlist
;
1286 *comname
= last_word
;
1292 if (!isalnum (*p
) && *p
!= '-' && *p
!= '_')
1293 error (_("Junk in argument list: \"%s\""), p
);
1300 /* This is just a placeholder in the command data structures. */
1302 user_defined_command (const char *ignore
, int from_tty
)
1307 define_command (const char *comname
, int from_tty
)
1309 #define MAX_TMPBUF 128
1316 struct cmd_list_element
*c
, *newc
, *hookc
= 0, **list
;
1317 const char *tem
, *comfull
;
1318 char tmpbuf
[MAX_TMPBUF
];
1319 int hook_type
= CMD_NO_HOOK
;
1320 int hook_name_size
= 0;
1322 #define HOOK_STRING "hook-"
1324 #define HOOK_POST_STRING "hookpost-"
1325 #define HOOK_POST_LEN 9
1328 list
= validate_comname (&comname
);
1330 /* Look it up, and verify that we got an exact match. */
1332 c
= lookup_cmd (&tem
, *list
, "", -1, 1);
1333 if (c
&& strcmp (comname
, c
->name
) != 0)
1340 if (c
->theclass
== class_user
|| c
->theclass
== class_alias
)
1341 q
= query (_("Redefine command \"%s\"? "), c
->name
);
1343 q
= query (_("Really redefine built-in command \"%s\"? "), c
->name
);
1345 error (_("Command \"%s\" not redefined."), c
->name
);
1348 /* If this new command is a hook, then mark the command which it
1349 is hooking. Note that we allow hooking `help' commands, so that
1350 we can hook the `stop' pseudo-command. */
1352 if (!strncmp (comname
, HOOK_STRING
, HOOK_LEN
))
1354 hook_type
= CMD_PRE_HOOK
;
1355 hook_name_size
= HOOK_LEN
;
1357 else if (!strncmp (comname
, HOOK_POST_STRING
, HOOK_POST_LEN
))
1359 hook_type
= CMD_POST_HOOK
;
1360 hook_name_size
= HOOK_POST_LEN
;
1363 if (hook_type
!= CMD_NO_HOOK
)
1365 /* Look up cmd it hooks, and verify that we got an exact match. */
1366 tem
= comname
+ hook_name_size
;
1367 hookc
= lookup_cmd (&tem
, *list
, "", -1, 0);
1368 if (hookc
&& strcmp (comname
+ hook_name_size
, hookc
->name
) != 0)
1372 warning (_("Your new `%s' command does not "
1373 "hook any existing command."),
1375 if (!query (_("Proceed? ")))
1376 error (_("Not confirmed."));
1380 comname
= xstrdup (comname
);
1382 xsnprintf (tmpbuf
, sizeof (tmpbuf
),
1383 "Type commands for definition of \"%s\".", comfull
);
1384 counted_command_line cmds
= read_command_lines (tmpbuf
, from_tty
, 1, 0, 0);
1386 newc
= add_cmd (comname
, class_user
, user_defined_command
,
1387 (c
&& c
->theclass
== class_user
)
1388 ? c
->doc
: xstrdup ("User-defined."), list
);
1389 newc
->user_commands
= std::move (cmds
);
1391 /* If this new command is a hook, then mark both commands as being
1398 hookc
->hook_pre
= newc
; /* Target gets hooked. */
1399 newc
->hookee_pre
= hookc
; /* We are marked as hooking target cmd. */
1402 hookc
->hook_post
= newc
; /* Target gets hooked. */
1403 newc
->hookee_post
= hookc
; /* We are marked as hooking
1407 /* Should never come here as hookc would be 0. */
1408 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1414 document_command (const char *comname
, int from_tty
)
1416 struct cmd_list_element
*c
, **list
;
1418 const char *comfull
;
1422 list
= validate_comname (&comname
);
1425 c
= lookup_cmd (&tem
, *list
, "", 0, 1);
1427 if (c
->theclass
!= class_user
)
1428 error (_("Command \"%s\" is built-in."), comfull
);
1430 xsnprintf (tmpbuf
, sizeof (tmpbuf
), "Type documentation for \"%s\".",
1432 counted_command_line doclines
= read_command_lines (tmpbuf
, from_tty
,
1436 xfree ((char *) c
->doc
);
1439 struct command_line
*cl1
;
1443 for (cl1
= doclines
.get (); cl1
; cl1
= cl1
->next
)
1444 len
+= strlen (cl1
->line
) + 1;
1446 doc
= (char *) xmalloc (len
+ 1);
1449 for (cl1
= doclines
.get (); cl1
; cl1
= cl1
->next
)
1451 strcat (doc
, cl1
->line
);
1460 /* Used to implement source_command. */
1463 script_from_file (FILE *stream
, const char *file
)
1466 internal_error (__FILE__
, __LINE__
, _("called with NULL file pointer!"));
1468 scoped_restore restore_line_number
1469 = make_scoped_restore (&source_line_number
, 0);
1470 scoped_restore resotre_file
1471 = make_scoped_restore (&source_file_name
, file
);
1473 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
1477 read_command_file (stream
);
1479 CATCH (e
, RETURN_MASK_ERROR
)
1481 /* Re-throw the error, but with the file name information
1483 throw_error (e
.error
,
1484 _("%s:%d: Error in sourced command file:\n%s"),
1485 source_file_name
, source_line_number
, e
.message
);
1490 /* Print the definition of user command C to STREAM. Or, if C is a
1491 prefix command, show the definitions of all user commands under C
1492 (recursively). PREFIX and NAME combined are the name of the
1495 show_user_1 (struct cmd_list_element
*c
, const char *prefix
, const char *name
,
1496 struct ui_file
*stream
)
1498 struct command_line
*cmdlines
;
1500 if (c
->prefixlist
!= NULL
)
1502 const char *prefixname
= c
->prefixname
;
1504 for (c
= *c
->prefixlist
; c
!= NULL
; c
= c
->next
)
1505 if (c
->theclass
== class_user
|| c
->prefixlist
!= NULL
)
1506 show_user_1 (c
, prefixname
, c
->name
, gdb_stdout
);
1510 cmdlines
= c
->user_commands
.get ();
1511 fprintf_filtered (stream
, "User command \"%s%s\":\n", prefix
, name
);
1515 print_command_lines (current_uiout
, cmdlines
, 1);
1516 fputs_filtered ("\n", stream
);
1520 _initialize_cli_script (void)
1522 add_com ("document", class_support
, document_command
, _("\
1523 Document a user-defined command.\n\
1524 Give command name as argument. Give documentation on following lines.\n\
1525 End with a line of just \"end\"."));
1526 add_com ("define", class_support
, define_command
, _("\
1527 Define a new command name. Command name is argument.\n\
1528 Definition appears on following lines, one command per line.\n\
1529 End with a line of just \"end\".\n\
1530 Use the \"document\" command to give documentation for the new command.\n\
1531 Commands defined in this way may have up to ten arguments."));
1533 add_com ("while", class_support
, while_command
, _("\
1534 Execute nested commands WHILE the conditional expression is non zero.\n\
1535 The conditional expression must follow the word `while' and must in turn be\n\
1536 followed by a new line. The nested commands must be entered one per line,\n\
1537 and should be terminated by the word `end'."));
1539 add_com ("if", class_support
, if_command
, _("\
1540 Execute nested commands once IF the conditional expression is non zero.\n\
1541 The conditional expression must follow the word `if' and must in turn be\n\
1542 followed by a new line. The nested commands must be entered one per line,\n\
1543 and should be terminated by the word 'else' or `end'. If an else clause\n\
1544 is used, the same rules apply to its nested commands as to the first ones."));