1 /* GDB CLI command scripting.
3 Copyright (C) 1986-2021 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 "tracepoint.h"
29 #include "cli/cli-cmds.h"
30 #include "cli/cli-decode.h"
31 #include "cli/cli-script.h"
32 #include "cli/cli-style.h"
34 #include "extension.h"
36 #include "compile/compile.h"
37 #include "gdbsupport/gdb_string_view.h"
38 #include "python/python.h"
39 #include "guile/guile.h"
43 /* Prototypes for local functions. */
45 static enum command_control_type
46 recurse_read_control_structure
47 (gdb::function_view
<const char * ()> read_next_line_func
,
48 struct command_line
*current_cmd
,
49 gdb::function_view
<void (const char *)> validator
);
51 static void do_define_command (const char *comname
, int from_tty
,
52 const counted_command_line
*commands
);
54 static void do_document_command (const char *comname
, int from_tty
,
55 const counted_command_line
*commands
);
57 static const char *read_next_line ();
59 /* Level of control structure when reading. */
60 static int control_level
;
62 /* Level of control structure when executing. */
63 static int command_nest_depth
= 1;
65 /* This is to prevent certain commands being printed twice. */
66 static int suppress_next_print_command_trace
= 0;
68 /* Command element for the 'while' command. */
69 static cmd_list_element
*while_cmd_element
= nullptr;
71 /* Command element for the 'if' command. */
72 static cmd_list_element
*if_cmd_element
= nullptr;
74 /* Command element for the 'define' command. */
75 static cmd_list_element
*define_cmd_element
= nullptr;
77 /* Command element for the 'document' command. */
78 static cmd_list_element
*document_cmd_element
= nullptr;
80 /* Structure for arguments to user defined functions. */
85 /* Save the command line and store the locations of arguments passed
86 to the user defined function. */
87 explicit user_args (const char *line
);
89 /* Insert the stored user defined arguments into the $arg arguments
91 std::string
insert_args (const char *line
) const;
94 /* Disable copy/assignment. (Since the elements of A point inside
95 COMMAND, copying would need to reconstruct the A vector in the
97 user_args (const user_args
&) =delete;
98 user_args
&operator= (const user_args
&) =delete;
100 /* It is necessary to store a copy of the command line to ensure
101 that the arguments are not overwritten before they are used. */
102 std::string m_command_line
;
104 /* The arguments. Each element points inside M_COMMAND_LINE. */
105 std::vector
<gdb::string_view
> m_args
;
108 /* The stack of arguments passed to user defined functions. We need a
109 stack because user-defined functions can call other user-defined
111 static std::vector
<std::unique_ptr
<user_args
>> user_args_stack
;
113 /* An RAII-base class used to push/pop args on the user args
115 struct scoped_user_args_level
117 /* Parse the command line and push the arguments in the user args
119 explicit scoped_user_args_level (const char *line
)
121 user_args_stack
.emplace_back (new user_args (line
));
124 /* Pop the current user arguments from the stack. */
125 ~scoped_user_args_level ()
127 user_args_stack
.pop_back ();
132 /* Return non-zero if TYPE is a multi-line command (i.e., is terminated
136 multi_line_command_p (enum command_control_type type
)
142 case while_stepping_control
:
143 case commands_control
:
144 case compile_control
:
148 case document_control
:
155 /* Allocate, initialize a new command line structure for one of the
156 control commands (if/while). */
158 static command_line_up
159 build_command_line (enum command_control_type type
, const char *args
)
161 if (args
== NULL
|| *args
== '\0')
163 if (type
== if_control
)
164 error (_("if command requires an argument."));
165 else if (type
== while_control
)
166 error (_("while command requires an argument."));
167 else if (type
== define_control
)
168 error (_("define command requires an argument."));
169 else if (type
== document_control
)
170 error (_("document command requires an argument."));
172 gdb_assert (args
!= NULL
);
174 return command_line_up (new command_line (type
, xstrdup (args
)));
177 /* Build and return a new command structure for the control commands
178 such as "if" and "while". */
181 get_command_line (enum command_control_type type
, const char *arg
)
183 /* Allocate and build a new command line structure. */
184 counted_command_line
cmd (build_command_line (type
, arg
).release (),
185 command_lines_deleter ());
187 /* Read in the body of this command. */
188 if (recurse_read_control_structure (read_next_line
, cmd
.get (), 0)
191 warning (_("Error reading in canned sequence of commands."));
198 /* Recursively print a command (including full control structures). */
201 print_command_lines (struct ui_out
*uiout
, struct command_line
*cmd
,
204 struct command_line
*list
;
210 uiout
->spaces (2 * depth
);
212 /* A simple command, print it and continue. */
213 if (list
->control_type
== simple_control
)
215 uiout
->field_string (NULL
, list
->line
);
221 /* loop_continue to jump to the start of a while loop, print it
223 if (list
->control_type
== continue_control
)
225 uiout
->field_string (NULL
, "loop_continue");
231 /* loop_break to break out of a while loop, print it and
233 if (list
->control_type
== break_control
)
235 uiout
->field_string (NULL
, "loop_break");
241 /* A while command. Recursively print its subcommands and
243 if (list
->control_type
== while_control
244 || list
->control_type
== while_stepping_control
)
246 /* For while-stepping, the line includes the 'while-stepping'
247 token. See comment in process_next_line for explanation.
248 Here, take care not print 'while-stepping' twice. */
249 if (list
->control_type
== while_control
)
250 uiout
->field_fmt (NULL
, "while %s", list
->line
);
252 uiout
->field_string (NULL
, list
->line
);
254 print_command_lines (uiout
, list
->body_list_0
.get (), depth
+ 1);
256 uiout
->spaces (2 * depth
);
257 uiout
->field_string (NULL
, "end");
263 /* An if command. Recursively print both arms before
265 if (list
->control_type
== if_control
)
267 uiout
->field_fmt (NULL
, "if %s", list
->line
);
270 print_command_lines (uiout
, list
->body_list_0
.get (), depth
+ 1);
272 /* Show the false arm if it exists. */
273 if (list
->body_list_1
!= nullptr)
276 uiout
->spaces (2 * depth
);
277 uiout
->field_string (NULL
, "else");
279 print_command_lines (uiout
, list
->body_list_1
.get (), depth
+ 1);
283 uiout
->spaces (2 * depth
);
284 uiout
->field_string (NULL
, "end");
290 /* A commands command. Print the breakpoint commands and
292 if (list
->control_type
== commands_control
)
295 uiout
->field_fmt (NULL
, "commands %s", list
->line
);
297 uiout
->field_string (NULL
, "commands");
299 print_command_lines (uiout
, list
->body_list_0
.get (), depth
+ 1);
301 uiout
->spaces (2 * depth
);
302 uiout
->field_string (NULL
, "end");
308 if (list
->control_type
== python_control
)
310 uiout
->field_string (NULL
, "python");
312 /* Don't indent python code at all. */
313 print_command_lines (uiout
, list
->body_list_0
.get (), 0);
315 uiout
->spaces (2 * depth
);
316 uiout
->field_string (NULL
, "end");
322 if (list
->control_type
== compile_control
)
324 uiout
->field_string (NULL
, "compile expression");
326 print_command_lines (uiout
, list
->body_list_0
.get (), 0);
328 uiout
->spaces (2 * depth
);
329 uiout
->field_string (NULL
, "end");
335 if (list
->control_type
== guile_control
)
337 uiout
->field_string (NULL
, "guile");
339 print_command_lines (uiout
, list
->body_list_0
.get (), depth
+ 1);
341 uiout
->spaces (2 * depth
);
342 uiout
->field_string (NULL
, "end");
348 /* Ignore illegal command type and try next. */
353 /* Handle pre-post hooks. */
355 class scoped_restore_hook_in
359 scoped_restore_hook_in (struct cmd_list_element
*c
)
364 ~scoped_restore_hook_in ()
369 scoped_restore_hook_in (const scoped_restore_hook_in
&) = delete;
370 scoped_restore_hook_in
&operator= (const scoped_restore_hook_in
&) = delete;
374 struct cmd_list_element
*m_cmd
;
378 execute_cmd_pre_hook (struct cmd_list_element
*c
)
380 if ((c
->hook_pre
) && (!c
->hook_in
))
382 scoped_restore_hook_in
restore_hook (c
);
383 c
->hook_in
= 1; /* Prevent recursive hooking. */
384 execute_user_command (c
->hook_pre
, nullptr);
389 execute_cmd_post_hook (struct cmd_list_element
*c
)
391 if ((c
->hook_post
) && (!c
->hook_in
))
393 scoped_restore_hook_in
restore_hook (c
);
394 c
->hook_in
= 1; /* Prevent recursive hooking. */
395 execute_user_command (c
->hook_post
, nullptr);
399 /* See cli-script.h. */
402 execute_control_commands (struct command_line
*cmdlines
, int from_tty
)
404 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
405 scoped_restore save_nesting
406 = make_scoped_restore (&command_nest_depth
, command_nest_depth
+ 1);
410 enum command_control_type ret
= execute_control_command (cmdlines
,
412 if (ret
!= simple_control
&& ret
!= break_control
)
414 warning (_("Error executing canned sequence of commands."));
417 cmdlines
= cmdlines
->next
;
421 /* See cli-script.h. */
424 execute_control_commands_to_string (struct command_line
*commands
,
427 /* GDB_STDOUT should be better already restored during these
428 restoration callbacks. */
429 set_batch_flag_and_restore_page_info save_page_info
;
431 string_file str_file
;
434 current_uiout
->redirect (&str_file
);
435 ui_out_redirect_pop
redirect_popper (current_uiout
);
437 scoped_restore save_stdout
438 = make_scoped_restore (&gdb_stdout
, &str_file
);
439 scoped_restore save_stderr
440 = make_scoped_restore (&gdb_stderr
, &str_file
);
441 scoped_restore save_stdlog
442 = make_scoped_restore (&gdb_stdlog
, &str_file
);
443 scoped_restore save_stdtarg
444 = make_scoped_restore (&gdb_stdtarg
, &str_file
);
445 scoped_restore save_stdtargerr
446 = make_scoped_restore (&gdb_stdtargerr
, &str_file
);
448 execute_control_commands (commands
, from_tty
);
451 return std::move (str_file
.string ());
455 execute_user_command (struct cmd_list_element
*c
, const char *args
)
457 counted_command_line cmdlines_copy
;
459 /* Ensure that the user commands can't be deleted while they are
461 cmdlines_copy
= c
->user_commands
;
462 if (cmdlines_copy
== 0)
465 struct command_line
*cmdlines
= cmdlines_copy
.get ();
467 scoped_user_args_level
push_user_args (args
);
469 if (user_args_stack
.size () > max_user_call_depth
)
470 error (_("Max user call depth exceeded -- command aborted."));
472 /* Set the instream to nullptr, indicating execution of a
473 user-defined function. */
474 scoped_restore restore_instream
475 = make_scoped_restore (¤t_ui
->instream
, nullptr);
477 execute_control_commands (cmdlines
, 0);
480 /* This function is called every time GDB prints a prompt. It ensures
481 that errors and the like do not confuse the command tracing. */
484 reset_command_nest_depth (void)
486 command_nest_depth
= 1;
489 suppress_next_print_command_trace
= 0;
492 /* Print the command, prefixed with '+' to represent the call depth.
493 This is slightly complicated because this function may be called
494 from execute_command and execute_control_command. Unfortunately
495 execute_command also prints the top level control commands.
496 In these cases execute_command will call execute_control_command
497 via while_command or if_command. Inner levels of 'if' and 'while'
498 are dealt with directly. Therefore we can use these functions
499 to determine whether the command has been printed already or not. */
500 ATTRIBUTE_PRINTF (1, 2)
502 print_command_trace (const char *fmt
, ...)
506 if (suppress_next_print_command_trace
)
508 suppress_next_print_command_trace
= 0;
512 if (!source_verbose
&& !trace_commands
)
515 for (i
=0; i
< command_nest_depth
; i
++)
516 printf_filtered ("+");
520 va_start (args
, fmt
);
521 vprintf_filtered (fmt
, args
);
523 puts_filtered ("\n");
526 /* Helper for execute_control_command. */
528 static enum command_control_type
529 execute_control_command_1 (struct command_line
*cmd
, int from_tty
)
531 struct command_line
*current
;
533 struct value
*val_mark
;
535 enum command_control_type ret
;
537 /* Start by assuming failure, if a problem is detected, the code
538 below will simply "break" out of the switch. */
539 ret
= invalid_control
;
541 switch (cmd
->control_type
)
545 /* A simple command, execute it and return. */
546 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
547 execute_command (new_line
.c_str (), from_tty
);
548 ret
= cmd
->control_type
;
552 case continue_control
:
553 print_command_trace ("loop_continue");
555 /* Return for "continue", and "break" so we can either
556 continue the loop at the top, or break out. */
557 ret
= cmd
->control_type
;
561 print_command_trace ("loop_break");
563 /* Return for "continue", and "break" so we can either
564 continue the loop at the top, or break out. */
565 ret
= cmd
->control_type
;
570 print_command_trace ("while %s", cmd
->line
);
572 /* Parse the loop control expression for the while statement. */
573 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
574 expression_up expr
= parse_expression (new_line
.c_str ());
576 ret
= simple_control
;
579 /* Keep iterating so long as the expression is true. */
586 /* Evaluate the expression. */
587 val_mark
= value_mark ();
588 val
= evaluate_expression (expr
.get ());
589 cond_result
= value_true (val
);
590 value_free_to_mark (val_mark
);
592 /* If the value is false, then break out of the loop. */
596 /* Execute the body of the while statement. */
597 current
= cmd
->body_list_0
.get ();
600 scoped_restore save_nesting
601 = make_scoped_restore (&command_nest_depth
, command_nest_depth
+ 1);
602 ret
= execute_control_command_1 (current
, from_tty
);
604 /* If we got an error, or a "break" command, then stop
606 if (ret
== invalid_control
|| ret
== break_control
)
612 /* If we got a "continue" command, then restart the loop
614 if (ret
== continue_control
)
617 /* Get the next statement. */
618 current
= current
->next
;
622 /* Reset RET so that we don't recurse the break all the way down. */
623 if (ret
== break_control
)
624 ret
= simple_control
;
631 print_command_trace ("if %s", cmd
->line
);
633 /* Parse the conditional for the if statement. */
634 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
635 expression_up expr
= parse_expression (new_line
.c_str ());
638 ret
= simple_control
;
640 /* Evaluate the conditional. */
641 val_mark
= value_mark ();
642 val
= evaluate_expression (expr
.get ());
644 /* Choose which arm to take commands from based on the value
645 of the conditional expression. */
646 if (value_true (val
))
647 current
= cmd
->body_list_0
.get ();
648 else if (cmd
->body_list_1
!= nullptr)
649 current
= cmd
->body_list_1
.get ();
650 value_free_to_mark (val_mark
);
652 /* Execute commands in the given arm. */
655 scoped_restore save_nesting
656 = make_scoped_restore (&command_nest_depth
, command_nest_depth
+ 1);
657 ret
= execute_control_command_1 (current
, from_tty
);
659 /* If we got an error, get out. */
660 if (ret
!= simple_control
)
663 /* Get the next statement in the body. */
664 current
= current
->next
;
670 case commands_control
:
672 /* Breakpoint commands list, record the commands in the
673 breakpoint's command list and return. */
674 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
675 ret
= commands_from_control_command (new_line
.c_str (), cmd
);
679 case compile_control
:
680 eval_compile_command (cmd
, NULL
, cmd
->control_u
.compile
.scope
,
681 cmd
->control_u
.compile
.scope_data
);
682 ret
= simple_control
;
686 print_command_trace ("define %s", cmd
->line
);
687 do_define_command (cmd
->line
, 0, &cmd
->body_list_0
);
688 ret
= simple_control
;
691 case document_control
:
692 print_command_trace ("document %s", cmd
->line
);
693 do_document_command (cmd
->line
, 0, &cmd
->body_list_0
);
694 ret
= simple_control
;
700 eval_ext_lang_from_control_command (cmd
);
701 ret
= simple_control
;
706 warning (_("Invalid control type in canned commands structure."));
713 enum command_control_type
714 execute_control_command (struct command_line
*cmd
, int from_tty
)
716 if (!current_uiout
->is_mi_like_p ())
717 return execute_control_command_1 (cmd
, from_tty
);
719 /* Make sure we use the console uiout. It's possible that we are executing
720 breakpoint commands while running the MI interpreter. */
721 interp
*console
= interp_lookup (current_ui
, INTERP_CONSOLE
);
722 scoped_restore save_uiout
723 = make_scoped_restore (¤t_uiout
, console
->interp_ui_out ());
725 return execute_control_command_1 (cmd
, from_tty
);
728 /* Like execute_control_command, but first set
729 suppress_next_print_command_trace. */
731 enum command_control_type
732 execute_control_command_untraced (struct command_line
*cmd
)
734 suppress_next_print_command_trace
= 1;
735 return execute_control_command (cmd
);
739 /* "while" command support. Executes a body of statements while the
740 loop condition is nonzero. */
743 while_command (const char *arg
, int from_tty
)
746 counted_command_line command
= get_command_line (while_control
, arg
);
751 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
753 execute_control_command_untraced (command
.get ());
756 /* "if" command support. Execute either the true or false arm depending
757 on the value of the if conditional. */
760 if_command (const char *arg
, int from_tty
)
763 counted_command_line command
= get_command_line (if_control
, arg
);
768 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
770 execute_control_command_untraced (command
.get ());
773 /* Bind the incoming arguments for a user defined command to $arg0,
776 user_args::user_args (const char *command_line
)
780 if (command_line
== NULL
)
783 m_command_line
= command_line
;
784 p
= m_command_line
.c_str ();
788 const char *start_arg
;
793 /* Strip whitespace. */
794 while (*p
== ' ' || *p
== '\t')
797 /* P now points to an argument. */
800 /* Get to the end of this argument. */
803 if (((*p
== ' ' || *p
== '\t')) && !squote
&& !dquote
&& !bsquote
)
832 m_args
.emplace_back (start_arg
, p
- start_arg
);
836 /* Given character string P, return a point to the first argument
837 ($arg), or NULL if P contains no arguments. */
840 locate_arg (const char *p
)
842 while ((p
= strchr (p
, '$')))
844 if (startswith (p
, "$arg")
845 && (isdigit (p
[4]) || p
[4] == 'c'))
852 /* See cli-script.h. */
855 insert_user_defined_cmd_args (const char *line
)
857 /* If we are not in a user-defined command, treat $argc, $arg0, et
858 cetera as normal convenience variables. */
859 if (user_args_stack
.empty ())
862 const std::unique_ptr
<user_args
> &args
= user_args_stack
.back ();
863 return args
->insert_args (line
);
866 /* Insert the user defined arguments stored in user_args into the $arg
867 arguments found in line. */
870 user_args::insert_args (const char *line
) const
872 std::string new_line
;
875 while ((p
= locate_arg (line
)))
877 new_line
.append (line
, p
- line
);
881 new_line
+= std::to_string (m_args
.size ());
890 i
= strtoul (p
+ 4, &tmp
, 10);
891 if ((i
== 0 && tmp
== p
+ 4) || errno
!= 0)
893 else if (i
>= m_args
.size ())
894 error (_("Missing argument %ld in user function."), i
);
897 new_line
.append (m_args
[i
].data (), m_args
[i
].length ());
902 /* Don't forget the tail. */
903 new_line
.append (line
);
909 /* Read next line from stdin. Passed to read_command_line_1 and
910 recurse_read_control_structure whenever we need to read commands
916 struct ui
*ui
= current_ui
;
917 char *prompt_ptr
, control_prompt
[256];
919 int from_tty
= ui
->instream
== ui
->stdin_stream
;
921 if (control_level
>= 254)
922 error (_("Control nesting too deep!"));
924 /* Set a prompt based on the nesting of the control commands. */
926 || (ui
->instream
== 0 && deprecated_readline_hook
!= NULL
))
928 for (i
= 0; i
< control_level
; i
++)
929 control_prompt
[i
] = ' ';
930 control_prompt
[i
] = '>';
931 control_prompt
[i
+ 1] = '\0';
932 prompt_ptr
= (char *) &control_prompt
[0];
937 return command_line_input (prompt_ptr
, "commands");
940 /* Given an input line P, skip the command and return a pointer to the
944 line_first_arg (const char *p
)
946 const char *first_arg
= p
+ find_command_name_length (p
);
948 return skip_spaces (first_arg
);
951 /* Process one input line. If the command is an "end", return such an
952 indication to the caller. If PARSE_COMMANDS is true, strip leading
953 whitespace (trailing whitespace is always stripped) in the line,
954 attempt to recognize GDB control commands, and also return an
955 indication if the command is an "else" or a nop.
957 Otherwise, only "end" is recognized. */
959 static enum misc_command_type
960 process_next_line (const char *p
, command_line_up
*command
,
962 gdb::function_view
<void (const char *)> validator
)
969 /* Not sure what to do here. */
973 /* Strip trailing whitespace. */
974 p_end
= p
+ strlen (p
);
975 while (p_end
> p
&& (p_end
[-1] == ' ' || p_end
[-1] == '\t'))
979 /* Strip leading whitespace. */
980 while (p_start
< p_end
&& (*p_start
== ' ' || *p_start
== '\t'))
983 /* 'end' is always recognized, regardless of parse_commands value.
984 We also permit whitespace before end and after. */
985 if (p_end
- p_start
== 3 && startswith (p_start
, "end"))
990 /* Resolve command abbreviations (e.g. 'ws' for 'while-stepping'). */
991 const char *cmd_name
= p
;
992 struct cmd_list_element
*cmd
993 = lookup_cmd_1 (&cmd_name
, cmdlist
, NULL
, NULL
, 1);
994 cmd_name
= skip_spaces (cmd_name
);
995 bool inline_cmd
= *cmd_name
!= '\0';
997 /* If commands are parsed, we skip initial spaces. Otherwise,
998 which is the case for Python commands and documentation
999 (see the 'document' command), spaces are preserved. */
1002 /* Blanks and comments don't really do anything, but we need to
1003 distinguish them from else, end and other commands which can
1005 if (p_end
== p
|| p
[0] == '#')
1008 /* Is the else clause of an if control structure? */
1009 if (p_end
- p
== 4 && startswith (p
, "else"))
1010 return else_command
;
1012 /* Check for while, if, break, continue, etc and build a new
1013 command line structure for them. */
1014 if (cmd
== while_stepping_cmd_element
)
1016 /* Because validate_actionline and encode_action lookup
1017 command's line as command, we need the line to
1018 include 'while-stepping'.
1020 For 'ws' alias, the command will have 'ws', not expanded
1021 to 'while-stepping'. This is intentional -- we don't
1022 really want frontend to send a command list with 'ws',
1023 and next break-info returning command line with
1024 'while-stepping'. This should work, but might cause the
1025 breakpoint to be marked as changed while it's actually
1027 *command
= build_command_line (while_stepping_control
, p
);
1029 else if (cmd
== while_cmd_element
)
1030 *command
= build_command_line (while_control
, line_first_arg (p
));
1031 else if (cmd
== if_cmd_element
)
1032 *command
= build_command_line (if_control
, line_first_arg (p
));
1033 else if (cmd
== commands_cmd_element
)
1034 *command
= build_command_line (commands_control
, line_first_arg (p
));
1035 else if (cmd
== define_cmd_element
)
1036 *command
= build_command_line (define_control
, line_first_arg (p
));
1037 else if (cmd
== document_cmd_element
)
1038 *command
= build_command_line (document_control
, line_first_arg (p
));
1039 else if (cmd
== python_cmd_element
&& !inline_cmd
)
1041 /* Note that we ignore the inline "python command" form
1043 *command
= build_command_line (python_control
, "");
1045 else if (cmd
== compile_cmd_element
&& !inline_cmd
)
1047 /* Note that we ignore the inline "compile command" form
1049 *command
= build_command_line (compile_control
, "");
1050 (*command
)->control_u
.compile
.scope
= COMPILE_I_INVALID_SCOPE
;
1052 else if (cmd
== guile_cmd_element
&& !inline_cmd
)
1054 /* Note that we ignore the inline "guile command" form here. */
1055 *command
= build_command_line (guile_control
, "");
1057 else if (p_end
- p
== 10 && startswith (p
, "loop_break"))
1058 *command
= command_line_up (new command_line (break_control
));
1059 else if (p_end
- p
== 13 && startswith (p
, "loop_continue"))
1060 *command
= command_line_up (new command_line (continue_control
));
1065 if (!parse_commands
|| not_handled
)
1067 /* A normal command. */
1068 *command
= command_line_up (new command_line (simple_control
,
1069 savestring (p
, p_end
- p
)));
1073 validator ((*command
)->line
);
1075 /* Nothing special. */
1079 /* Recursively read in the control structures and create a
1080 command_line structure from them. Use read_next_line_func to
1081 obtain lines of the command. */
1083 static enum command_control_type
1084 recurse_read_control_structure (gdb::function_view
<const char * ()> read_next_line_func
,
1085 struct command_line
*current_cmd
,
1086 gdb::function_view
<void (const char *)> validator
)
1088 enum misc_command_type val
;
1089 enum command_control_type ret
;
1090 struct command_line
*child_tail
;
1091 counted_command_line
*current_body
= ¤t_cmd
->body_list_0
;
1092 command_line_up next
;
1094 child_tail
= nullptr;
1096 /* Sanity checks. */
1097 if (current_cmd
->control_type
== simple_control
)
1098 error (_("Recursed on a simple control type."));
1100 /* Read lines from the input stream and build control structures. */
1106 val
= process_next_line (read_next_line_func (), &next
,
1107 current_cmd
->control_type
!= python_control
1108 && current_cmd
->control_type
!= guile_control
1109 && current_cmd
->control_type
!= compile_control
,
1112 /* Just skip blanks and comments. */
1113 if (val
== nop_command
)
1116 if (val
== end_command
)
1118 if (multi_line_command_p (current_cmd
->control_type
))
1120 /* Success reading an entire canned sequence of commands. */
1121 ret
= simple_control
;
1126 ret
= invalid_control
;
1131 /* Not the end of a control structure. */
1132 if (val
== else_command
)
1134 if (current_cmd
->control_type
== if_control
1135 && current_body
== ¤t_cmd
->body_list_0
)
1137 current_body
= ¤t_cmd
->body_list_1
;
1138 child_tail
= nullptr;
1143 ret
= invalid_control
;
1148 /* Transfer ownership of NEXT to the command's body list. */
1149 if (child_tail
!= nullptr)
1151 child_tail
->next
= next
.release ();
1152 child_tail
= child_tail
->next
;
1156 child_tail
= next
.get ();
1157 *current_body
= counted_command_line (next
.release (),
1158 command_lines_deleter ());
1161 /* If the latest line is another control structure, then recurse
1163 if (multi_line_command_p (child_tail
->control_type
))
1166 ret
= recurse_read_control_structure (read_next_line_func
,
1171 if (ret
!= simple_control
)
1181 /* Read lines from the input stream and accumulate them in a chain of
1182 struct command_line's, which is then returned. For input from a
1183 terminal, the special command "end" is used to mark the end of the
1184 input, and is not included in the returned chain of commands.
1186 If PARSE_COMMANDS is true, strip leading whitespace (trailing whitespace
1187 is always stripped) in the line and attempt to recognize GDB control
1188 commands. Otherwise, only "end" is recognized. */
1190 #define END_MESSAGE "End with a line saying just \"end\"."
1192 counted_command_line
1193 read_command_lines (const char *prompt_arg
, int from_tty
, int parse_commands
,
1194 gdb::function_view
<void (const char *)> validator
)
1196 if (from_tty
&& input_interactive_p (current_ui
))
1198 if (deprecated_readline_begin_hook
)
1200 /* Note - intentional to merge messages with no newline. */
1201 (*deprecated_readline_begin_hook
) ("%s %s\n", prompt_arg
,
1205 printf_unfiltered ("%s\n%s\n", prompt_arg
, END_MESSAGE
);
1209 /* Reading commands assumes the CLI behavior, so temporarily
1210 override the current interpreter with CLI. */
1211 counted_command_line
head (nullptr, command_lines_deleter ());
1212 if (current_interp_named_p (INTERP_CONSOLE
))
1213 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1217 scoped_restore_interp
interp_restorer (INTERP_CONSOLE
);
1219 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1223 if (from_tty
&& input_interactive_p (current_ui
)
1224 && deprecated_readline_end_hook
)
1226 (*deprecated_readline_end_hook
) ();
1231 /* Act the same way as read_command_lines, except that each new line is
1232 obtained using READ_NEXT_LINE_FUNC. */
1234 counted_command_line
1235 read_command_lines_1 (gdb::function_view
<const char * ()> read_next_line_func
,
1237 gdb::function_view
<void (const char *)> validator
)
1239 struct command_line
*tail
;
1240 counted_command_line
head (nullptr, command_lines_deleter ());
1241 enum command_control_type ret
;
1242 enum misc_command_type val
;
1243 command_line_up next
;
1251 val
= process_next_line (read_next_line_func (), &next
, parse_commands
,
1254 /* Ignore blank lines or comments. */
1255 if (val
== nop_command
)
1258 if (val
== end_command
)
1260 ret
= simple_control
;
1264 if (val
!= ok_command
)
1266 ret
= invalid_control
;
1270 if (multi_line_command_p (next
->control_type
))
1273 ret
= recurse_read_control_structure (read_next_line_func
, next
.get (),
1277 if (ret
== invalid_control
)
1281 /* Transfer ownership of NEXT to the HEAD list. */
1284 tail
->next
= next
.release ();
1290 head
= counted_command_line (next
.release (),
1291 command_lines_deleter ());
1297 if (ret
== invalid_control
)
1303 /* Free a chain of struct command_line's. */
1306 free_command_lines (struct command_line
**lptr
)
1308 struct command_line
*l
= *lptr
;
1309 struct command_line
*next
;
1320 /* Validate that *COMNAME is a valid name for a command. Return the
1321 containing command list, in case it starts with a prefix command.
1322 The prefix must already exist. *COMNAME is advanced to point after
1323 any prefix, and a NUL character overwrites the space after the
1326 static struct cmd_list_element
**
1327 validate_comname (const char **comname
)
1329 struct cmd_list_element
**list
= &cmdlist
;
1330 const char *p
, *last_word
;
1333 error_no_arg (_("name of command to define"));
1335 /* Find the last word of the argument. */
1336 p
= *comname
+ strlen (*comname
);
1337 while (p
> *comname
&& isspace (p
[-1]))
1339 while (p
> *comname
&& !isspace (p
[-1]))
1343 /* Find the corresponding command list. */
1344 if (last_word
!= *comname
)
1346 struct cmd_list_element
*c
;
1348 /* Separate the prefix and the command. */
1349 std::string
prefix (*comname
, last_word
- 1);
1350 const char *tem
= prefix
.c_str ();
1352 c
= lookup_cmd (&tem
, cmdlist
, "", NULL
, 0, 1);
1353 if (!c
->is_prefix ())
1354 error (_("\"%s\" is not a prefix command."), prefix
.c_str ());
1356 list
= c
->subcommands
;
1357 *comname
= last_word
;
1363 if (!valid_cmd_char_p (*p
))
1364 error (_("Junk in argument list: \"%s\""), p
);
1371 /* This is just a placeholder in the command data structures. */
1373 user_defined_command (const char *ignore
, int from_tty
)
1377 /* Define a user-defined command. If COMMANDS is NULL, then this is a
1378 top-level call and the commands will be read using
1379 read_command_lines. Otherwise, it is a "define" command in an
1380 existing command and the commands are provided. In the
1381 non-top-level case, various prompts and warnings are disabled. */
1384 do_define_command (const char *comname
, int from_tty
,
1385 const counted_command_line
*commands
)
1393 struct cmd_list_element
*c
, *newc
, *hookc
= 0, **list
;
1394 const char *comfull
;
1395 int hook_type
= CMD_NO_HOOK
;
1396 int hook_name_size
= 0;
1398 #define HOOK_STRING "hook-"
1400 #define HOOK_POST_STRING "hookpost-"
1401 #define HOOK_POST_LEN 9
1404 list
= validate_comname (&comname
);
1406 c
= lookup_cmd_exact (comname
, *list
);
1408 if (c
&& commands
== nullptr)
1412 if (c
->theclass
== class_user
|| c
->theclass
== class_alias
)
1414 /* if C is a prefix command that was previously defined,
1415 tell the user its subcommands will be kept, and ask
1416 if ok to redefine the command. */
1417 if (c
->is_prefix ())
1418 q
= (c
->user_commands
.get () == nullptr
1419 || query (_("Keeping subcommands of prefix command \"%s\".\n"
1420 "Redefine command \"%s\"? "), c
->name
, c
->name
));
1422 q
= query (_("Redefine command \"%s\"? "), c
->name
);
1425 q
= query (_("Really redefine built-in command \"%s\"? "), c
->name
);
1427 error (_("Command \"%s\" not redefined."), c
->name
);
1430 /* If this new command is a hook, then mark the command which it
1431 is hooking. Note that we allow hooking `help' commands, so that
1432 we can hook the `stop' pseudo-command. */
1434 if (!strncmp (comname
, HOOK_STRING
, HOOK_LEN
))
1436 hook_type
= CMD_PRE_HOOK
;
1437 hook_name_size
= HOOK_LEN
;
1439 else if (!strncmp (comname
, HOOK_POST_STRING
, HOOK_POST_LEN
))
1441 hook_type
= CMD_POST_HOOK
;
1442 hook_name_size
= HOOK_POST_LEN
;
1445 if (hook_type
!= CMD_NO_HOOK
)
1447 /* Look up cmd it hooks. */
1448 hookc
= lookup_cmd_exact (comname
+ hook_name_size
, *list
,
1449 /* ignore_help_classes = */ false);
1450 if (!hookc
&& commands
== nullptr)
1452 warning (_("Your new `%s' command does not "
1453 "hook any existing command."),
1455 if (!query (_("Proceed? ")))
1456 error (_("Not confirmed."));
1460 comname
= xstrdup (comname
);
1462 counted_command_line cmds
;
1463 if (commands
== nullptr)
1466 = string_printf ("Type commands for definition of \"%s\".", comfull
);
1467 cmds
= read_command_lines (prompt
.c_str (), from_tty
, 1, 0);
1473 struct cmd_list_element
**c_subcommands
1474 = c
== nullptr ? nullptr : c
->subcommands
;
1476 newc
= add_cmd (comname
, class_user
, user_defined_command
,
1477 (c
!= nullptr && c
->theclass
== class_user
)
1478 ? c
->doc
: xstrdup ("User-defined."), list
);
1479 newc
->user_commands
= std::move (cmds
);
1481 /* If we define or re-define a command that was previously defined
1482 as a prefix, keep the prefix information. */
1483 if (c_subcommands
!= nullptr)
1485 newc
->subcommands
= c_subcommands
;
1486 /* allow_unknown: see explanation in equivalent logic in
1487 define_prefix_command (). */
1488 newc
->allow_unknown
= newc
->user_commands
.get () != nullptr;
1492 /* If this new command is a hook, then mark both commands as being
1499 hookc
->hook_pre
= newc
; /* Target gets hooked. */
1500 newc
->hookee_pre
= hookc
; /* We are marked as hooking target cmd. */
1503 hookc
->hook_post
= newc
; /* Target gets hooked. */
1504 newc
->hookee_post
= hookc
; /* We are marked as hooking
1508 /* Should never come here as hookc would be 0. */
1509 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1515 define_command (const char *comname
, int from_tty
)
1517 do_define_command (comname
, from_tty
, nullptr);
1520 /* Document a user-defined command. If COMMANDS is NULL, then this is a
1521 top-level call and the document will be read using read_command_lines.
1522 Otherwise, it is a "document" command in an existing command and the
1523 commands are provided. */
1525 do_document_command (const char *comname
, int from_tty
,
1526 const counted_command_line
*commands
)
1528 struct cmd_list_element
*c
, **list
;
1530 const char *comfull
;
1533 list
= validate_comname (&comname
);
1536 c
= lookup_cmd (&tem
, *list
, "", NULL
, 0, 1);
1538 if (c
->theclass
!= class_user
)
1539 error (_("Command \"%s\" is built-in."), comfull
);
1541 counted_command_line doclines
;
1543 if (commands
== nullptr)
1546 = string_printf ("Type documentation for \"%s\".", comfull
);
1547 doclines
= read_command_lines (prompt
.c_str (), from_tty
, 0, 0);
1550 doclines
= *commands
;
1552 xfree ((char *) c
->doc
);
1555 struct command_line
*cl1
;
1559 for (cl1
= doclines
.get (); cl1
; cl1
= cl1
->next
)
1560 len
+= strlen (cl1
->line
) + 1;
1562 doc
= (char *) xmalloc (len
+ 1);
1565 for (cl1
= doclines
.get (); cl1
; cl1
= cl1
->next
)
1567 strcat (doc
, cl1
->line
);
1577 document_command (const char *comname
, int from_tty
)
1579 do_document_command (comname
, from_tty
, nullptr);
1582 /* Implementation of the "define-prefix" command. */
1585 define_prefix_command (const char *comname
, int from_tty
)
1587 struct cmd_list_element
*c
, **list
;
1588 const char *comfull
;
1591 list
= validate_comname (&comname
);
1593 c
= lookup_cmd_exact (comname
, *list
);
1595 if (c
!= nullptr && c
->theclass
!= class_user
)
1596 error (_("Command \"%s\" is built-in."), comfull
);
1598 if (c
!= nullptr && c
->is_prefix ())
1600 /* c is already a user defined prefix command. */
1604 /* If the command does not exist at all, create it. */
1607 comname
= xstrdup (comname
);
1608 c
= add_cmd (comname
, class_user
, user_defined_command
,
1609 xstrdup ("User-defined."), list
);
1612 /* Allocate the c->subcommands, which marks the command as a prefix
1614 c
->subcommands
= new struct cmd_list_element
*;
1615 *(c
->subcommands
) = nullptr;
1616 /* If the prefix command C is not a command, then it must be followed
1617 by known subcommands. Otherwise, if C is also a normal command,
1618 it can be followed by C args that must not cause a 'subcommand'
1619 not recognised error, and thus we must allow unknown. */
1620 c
->allow_unknown
= c
->user_commands
.get () != nullptr;
1624 /* Used to implement source_command. */
1627 script_from_file (FILE *stream
, const char *file
)
1630 internal_error (__FILE__
, __LINE__
, _("called with NULL file pointer!"));
1632 scoped_restore restore_line_number
1633 = make_scoped_restore (&source_line_number
, 0);
1634 scoped_restore restore_file
1635 = make_scoped_restore
<std::string
, const std::string
&> (&source_file_name
,
1638 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
1642 read_command_file (stream
);
1644 catch (const gdb_exception_error
&e
)
1646 /* Re-throw the error, but with the file name information
1648 throw_error (e
.error
,
1649 _("%s:%d: Error in sourced command file:\n%s"),
1650 source_file_name
.c_str (), source_line_number
,
1655 /* Print the definition of user command C to STREAM. Or, if C is a
1656 prefix command, show the definitions of all user commands under C
1657 (recursively). PREFIX and NAME combined are the name of the
1660 show_user_1 (struct cmd_list_element
*c
, const char *prefix
, const char *name
,
1661 struct ui_file
*stream
)
1663 if (cli_user_command_p (c
))
1665 struct command_line
*cmdlines
= c
->user_commands
.get ();
1667 fprintf_filtered (stream
, "User %scommand \"",
1668 c
->is_prefix () ? "prefix" : "");
1669 fprintf_styled (stream
, title_style
.style (), "%s%s",
1671 fprintf_filtered (stream
, "\":\n");
1674 print_command_lines (current_uiout
, cmdlines
, 1);
1675 fputs_filtered ("\n", stream
);
1679 if (c
->is_prefix ())
1681 const std::string prefixname
= c
->prefixname ();
1683 for (c
= *c
->subcommands
; c
!= NULL
; c
= c
->next
)
1684 if (c
->theclass
== class_user
|| c
->is_prefix ())
1685 show_user_1 (c
, prefixname
.c_str (), c
->name
, gdb_stdout
);
1690 void _initialize_cli_script ();
1692 _initialize_cli_script ()
1694 struct cmd_list_element
*c
;
1696 /* "document", "define" and "define-prefix" use command_completer,
1697 as this helps the user to either type the command name and/or
1699 document_cmd_element
= add_com ("document", class_support
, document_command
,
1701 Document a user-defined command.\n\
1702 Give command name as argument. Give documentation on following lines.\n\
1703 End with a line of just \"end\"."));
1704 set_cmd_completer (document_cmd_element
, command_completer
);
1705 define_cmd_element
= add_com ("define", class_support
, define_command
, _("\
1706 Define a new command name. Command name is argument.\n\
1707 Definition appears on following lines, one command per line.\n\
1708 End with a line of just \"end\".\n\
1709 Use the \"document\" command to give documentation for the new command.\n\
1710 Commands defined in this way may accept an unlimited number of arguments\n\
1711 accessed via $arg0 .. $argN. $argc tells how many arguments have\n\
1713 set_cmd_completer (define_cmd_element
, command_completer
);
1714 c
= add_com ("define-prefix", class_support
, define_prefix_command
,
1716 Define or mark a command as a user-defined prefix command.\n\
1717 User defined prefix commands can be used as prefix commands for\n\
1718 other user defined commands.\n\
1719 If the command already exists, it is changed to a prefix command."));
1720 set_cmd_completer (c
, command_completer
);
1722 while_cmd_element
= add_com ("while", class_support
, while_command
, _("\
1723 Execute nested commands WHILE the conditional expression is non zero.\n\
1724 The conditional expression must follow the word `while' and must in turn be\n\
1725 followed by a new line. The nested commands must be entered one per line,\n\
1726 and should be terminated by the word `end'."));
1728 if_cmd_element
= add_com ("if", class_support
, if_command
, _("\
1729 Execute nested commands once IF the conditional expression is non zero.\n\
1730 The conditional expression must follow the word `if' and must in turn be\n\
1731 followed by a new line. The nested commands must be entered one per line,\n\
1732 and should be terminated by the word 'else' or `end'. If an else clause\n\
1733 is used, the same rules apply to its nested commands as to the first ones."));