1 /* GDB CLI command scripting.
3 Copyright (C) 1986-2022 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/>. */
26 #include "breakpoint.h"
27 #include "tracepoint.h"
28 #include "cli/cli-cmds.h"
29 #include "cli/cli-decode.h"
30 #include "cli/cli-script.h"
31 #include "cli/cli-style.h"
33 #include "extension.h"
35 #include "compile/compile.h"
36 #include "gdbsupport/gdb_string_view.h"
37 #include "python/python.h"
38 #include "guile/guile.h"
42 /* Prototypes for local functions. */
44 static enum command_control_type
45 recurse_read_control_structure
46 (gdb::function_view
<const char * ()> read_next_line_func
,
47 struct command_line
*current_cmd
,
48 gdb::function_view
<void (const char *)> validator
);
50 static void do_define_command (const char *comname
, int from_tty
,
51 const counted_command_line
*commands
);
53 static void do_document_command (const char *comname
, int from_tty
,
54 const counted_command_line
*commands
);
56 static const char *read_next_line ();
58 /* Level of control structure when reading. */
59 static int control_level
;
61 /* Level of control structure when executing. */
62 static int command_nest_depth
= 1;
64 /* This is to prevent certain commands being printed twice. */
65 static int suppress_next_print_command_trace
= 0;
67 /* Command element for the 'while' command. */
68 static cmd_list_element
*while_cmd_element
= nullptr;
70 /* Command element for the 'if' command. */
71 static cmd_list_element
*if_cmd_element
= nullptr;
73 /* Command element for the 'define' command. */
74 static cmd_list_element
*define_cmd_element
= nullptr;
76 /* Command element for the 'document' command. */
77 static cmd_list_element
*document_cmd_element
= nullptr;
79 /* Structure for arguments to user defined functions. */
84 /* Save the command line and store the locations of arguments passed
85 to the user defined function. */
86 explicit user_args (const char *line
);
88 /* Insert the stored user defined arguments into the $arg arguments
90 std::string
insert_args (const char *line
) const;
93 /* Disable copy/assignment. (Since the elements of A point inside
94 COMMAND, copying would need to reconstruct the A vector in the
96 user_args (const user_args
&) =delete;
97 user_args
&operator= (const user_args
&) =delete;
99 /* It is necessary to store a copy of the command line to ensure
100 that the arguments are not overwritten before they are used. */
101 std::string m_command_line
;
103 /* The arguments. Each element points inside M_COMMAND_LINE. */
104 std::vector
<gdb::string_view
> m_args
;
107 /* The stack of arguments passed to user defined functions. We need a
108 stack because user-defined functions can call other user-defined
110 static std::vector
<std::unique_ptr
<user_args
>> user_args_stack
;
112 /* An RAII-base class used to push/pop args on the user args
114 struct scoped_user_args_level
116 /* Parse the command line and push the arguments in the user args
118 explicit scoped_user_args_level (const char *line
)
120 user_args_stack
.emplace_back (new user_args (line
));
123 /* Pop the current user arguments from the stack. */
124 ~scoped_user_args_level ()
126 user_args_stack
.pop_back ();
131 /* Return non-zero if TYPE is a multi-line command (i.e., is terminated
135 multi_line_command_p (enum command_control_type type
)
141 case while_stepping_control
:
142 case commands_control
:
143 case compile_control
:
147 case document_control
:
154 /* Allocate, initialize a new command line structure for one of the
155 control commands (if/while). */
157 static command_line_up
158 build_command_line (enum command_control_type type
, const char *args
)
160 if (args
== NULL
|| *args
== '\0')
162 if (type
== if_control
)
163 error (_("if command requires an argument."));
164 else if (type
== while_control
)
165 error (_("while command requires an argument."));
166 else if (type
== define_control
)
167 error (_("define command requires an argument."));
168 else if (type
== document_control
)
169 error (_("document command requires an argument."));
171 gdb_assert (args
!= NULL
);
173 return command_line_up (new command_line (type
, xstrdup (args
)));
176 /* Build and return a new command structure for the control commands
177 such as "if" and "while". */
180 get_command_line (enum command_control_type type
, const char *arg
)
182 /* Allocate and build a new command line structure. */
183 counted_command_line
cmd (build_command_line (type
, arg
).release (),
184 command_lines_deleter ());
186 /* Read in the body of this command. */
187 if (recurse_read_control_structure (read_next_line
, cmd
.get (), 0)
190 warning (_("Error reading in canned sequence of commands."));
197 /* Recursively print a command (including full control structures). */
200 print_command_lines (struct ui_out
*uiout
, struct command_line
*cmd
,
203 struct command_line
*list
;
209 uiout
->spaces (2 * depth
);
211 /* A simple command, print it and continue. */
212 if (list
->control_type
== simple_control
)
214 uiout
->field_string (NULL
, list
->line
);
220 /* loop_continue to jump to the start of a while loop, print it
222 if (list
->control_type
== continue_control
)
224 uiout
->field_string (NULL
, "loop_continue");
230 /* loop_break to break out of a while loop, print it and
232 if (list
->control_type
== break_control
)
234 uiout
->field_string (NULL
, "loop_break");
240 /* A while command. Recursively print its subcommands and
242 if (list
->control_type
== while_control
243 || list
->control_type
== while_stepping_control
)
245 /* For while-stepping, the line includes the 'while-stepping'
246 token. See comment in process_next_line for explanation.
247 Here, take care not print 'while-stepping' twice. */
248 if (list
->control_type
== while_control
)
249 uiout
->field_fmt (NULL
, "while %s", list
->line
);
251 uiout
->field_string (NULL
, list
->line
);
253 print_command_lines (uiout
, list
->body_list_0
.get (), depth
+ 1);
255 uiout
->spaces (2 * depth
);
256 uiout
->field_string (NULL
, "end");
262 /* An if command. Recursively print both arms before
264 if (list
->control_type
== if_control
)
266 uiout
->field_fmt (NULL
, "if %s", list
->line
);
269 print_command_lines (uiout
, list
->body_list_0
.get (), depth
+ 1);
271 /* Show the false arm if it exists. */
272 if (list
->body_list_1
!= nullptr)
275 uiout
->spaces (2 * depth
);
276 uiout
->field_string (NULL
, "else");
278 print_command_lines (uiout
, list
->body_list_1
.get (), depth
+ 1);
282 uiout
->spaces (2 * depth
);
283 uiout
->field_string (NULL
, "end");
289 /* A commands command. Print the breakpoint commands and
291 if (list
->control_type
== commands_control
)
294 uiout
->field_fmt (NULL
, "commands %s", list
->line
);
296 uiout
->field_string (NULL
, "commands");
298 print_command_lines (uiout
, list
->body_list_0
.get (), depth
+ 1);
300 uiout
->spaces (2 * depth
);
301 uiout
->field_string (NULL
, "end");
307 if (list
->control_type
== python_control
)
309 uiout
->field_string (NULL
, "python");
311 /* Don't indent python code at all. */
312 print_command_lines (uiout
, list
->body_list_0
.get (), 0);
314 uiout
->spaces (2 * depth
);
315 uiout
->field_string (NULL
, "end");
321 if (list
->control_type
== compile_control
)
323 uiout
->field_string (NULL
, "compile expression");
325 print_command_lines (uiout
, list
->body_list_0
.get (), 0);
327 uiout
->spaces (2 * depth
);
328 uiout
->field_string (NULL
, "end");
334 if (list
->control_type
== guile_control
)
336 uiout
->field_string (NULL
, "guile");
338 print_command_lines (uiout
, list
->body_list_0
.get (), depth
+ 1);
340 uiout
->spaces (2 * depth
);
341 uiout
->field_string (NULL
, "end");
347 /* Ignore illegal command type and try next. */
352 /* Handle pre-post hooks. */
354 class scoped_restore_hook_in
358 scoped_restore_hook_in (struct cmd_list_element
*c
)
363 ~scoped_restore_hook_in ()
368 scoped_restore_hook_in (const scoped_restore_hook_in
&) = delete;
369 scoped_restore_hook_in
&operator= (const scoped_restore_hook_in
&) = delete;
373 struct cmd_list_element
*m_cmd
;
377 execute_cmd_pre_hook (struct cmd_list_element
*c
)
379 if ((c
->hook_pre
) && (!c
->hook_in
))
381 scoped_restore_hook_in
restore_hook (c
);
382 c
->hook_in
= 1; /* Prevent recursive hooking. */
383 execute_user_command (c
->hook_pre
, nullptr);
388 execute_cmd_post_hook (struct cmd_list_element
*c
)
390 if ((c
->hook_post
) && (!c
->hook_in
))
392 scoped_restore_hook_in
restore_hook (c
);
393 c
->hook_in
= 1; /* Prevent recursive hooking. */
394 execute_user_command (c
->hook_post
, nullptr);
398 /* See cli-script.h. */
401 execute_control_commands (struct command_line
*cmdlines
, int from_tty
)
403 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
404 scoped_restore save_nesting
405 = make_scoped_restore (&command_nest_depth
, command_nest_depth
+ 1);
409 enum command_control_type ret
= execute_control_command (cmdlines
,
411 if (ret
!= simple_control
&& ret
!= break_control
)
413 warning (_("Error executing canned sequence of commands."));
416 cmdlines
= cmdlines
->next
;
420 /* See cli-script.h. */
423 execute_control_commands_to_string (struct command_line
*commands
,
426 /* GDB_STDOUT should be better already restored during these
427 restoration callbacks. */
428 set_batch_flag_and_restore_page_info save_page_info
;
430 string_file str_file
;
433 current_uiout
->redirect (&str_file
);
434 ui_out_redirect_pop
redirect_popper (current_uiout
);
436 scoped_restore save_stdout
437 = make_scoped_restore (&gdb_stdout
, &str_file
);
438 scoped_restore save_stderr
439 = make_scoped_restore (&gdb_stderr
, &str_file
);
440 scoped_restore save_stdlog
441 = make_scoped_restore (&gdb_stdlog
, &str_file
);
442 scoped_restore save_stdtarg
443 = make_scoped_restore (&gdb_stdtarg
, &str_file
);
444 scoped_restore save_stdtargerr
445 = make_scoped_restore (&gdb_stdtargerr
, &str_file
);
447 execute_control_commands (commands
, from_tty
);
450 return std::move (str_file
.string ());
454 execute_user_command (struct cmd_list_element
*c
, const char *args
)
456 counted_command_line cmdlines_copy
;
458 /* Ensure that the user commands can't be deleted while they are
460 cmdlines_copy
= c
->user_commands
;
461 if (cmdlines_copy
== 0)
464 struct command_line
*cmdlines
= cmdlines_copy
.get ();
466 scoped_user_args_level
push_user_args (args
);
468 if (user_args_stack
.size () > max_user_call_depth
)
469 error (_("Max user call depth exceeded -- command aborted."));
471 /* Set the instream to nullptr, indicating execution of a
472 user-defined function. */
473 scoped_restore restore_instream
474 = make_scoped_restore (¤t_ui
->instream
, nullptr);
476 execute_control_commands (cmdlines
, 0);
479 /* This function is called every time GDB prints a prompt. It ensures
480 that errors and the like do not confuse the command tracing. */
483 reset_command_nest_depth (void)
485 command_nest_depth
= 1;
488 suppress_next_print_command_trace
= 0;
491 /* Print the command, prefixed with '+' to represent the call depth.
492 This is slightly complicated because this function may be called
493 from execute_command and execute_control_command. Unfortunately
494 execute_command also prints the top level control commands.
495 In these cases execute_command will call execute_control_command
496 via while_command or if_command. Inner levels of 'if' and 'while'
497 are dealt with directly. Therefore we can use these functions
498 to determine whether the command has been printed already or not. */
499 ATTRIBUTE_PRINTF (1, 2)
501 print_command_trace (const char *fmt
, ...)
505 if (suppress_next_print_command_trace
)
507 suppress_next_print_command_trace
= 0;
511 if (!source_verbose
&& !trace_commands
)
514 for (i
=0; i
< command_nest_depth
; i
++)
515 printf_filtered ("+");
519 va_start (args
, fmt
);
520 vprintf_filtered (fmt
, args
);
522 puts_filtered ("\n");
525 /* Helper for execute_control_command. */
527 static enum command_control_type
528 execute_control_command_1 (struct command_line
*cmd
, int from_tty
)
530 struct command_line
*current
;
532 struct value
*val_mark
;
534 enum command_control_type ret
;
536 /* Start by assuming failure, if a problem is detected, the code
537 below will simply "break" out of the switch. */
538 ret
= invalid_control
;
540 switch (cmd
->control_type
)
544 /* A simple command, execute it and return. */
545 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
546 execute_command (new_line
.c_str (), from_tty
);
547 ret
= cmd
->control_type
;
551 case continue_control
:
552 print_command_trace ("loop_continue");
554 /* Return for "continue", and "break" so we can either
555 continue the loop at the top, or break out. */
556 ret
= cmd
->control_type
;
560 print_command_trace ("loop_break");
562 /* Return for "continue", and "break" so we can either
563 continue the loop at the top, or break out. */
564 ret
= cmd
->control_type
;
569 print_command_trace ("while %s", cmd
->line
);
571 /* Parse the loop control expression for the while statement. */
572 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
573 expression_up expr
= parse_expression (new_line
.c_str ());
575 ret
= simple_control
;
578 /* Keep iterating so long as the expression is true. */
585 /* Evaluate the expression. */
586 val_mark
= value_mark ();
587 val
= evaluate_expression (expr
.get ());
588 cond_result
= value_true (val
);
589 value_free_to_mark (val_mark
);
591 /* If the value is false, then break out of the loop. */
595 /* Execute the body of the while statement. */
596 current
= cmd
->body_list_0
.get ();
599 scoped_restore save_nesting
600 = make_scoped_restore (&command_nest_depth
, command_nest_depth
+ 1);
601 ret
= execute_control_command_1 (current
, from_tty
);
603 /* If we got an error, or a "break" command, then stop
605 if (ret
== invalid_control
|| ret
== break_control
)
611 /* If we got a "continue" command, then restart the loop
613 if (ret
== continue_control
)
616 /* Get the next statement. */
617 current
= current
->next
;
621 /* Reset RET so that we don't recurse the break all the way down. */
622 if (ret
== break_control
)
623 ret
= simple_control
;
630 print_command_trace ("if %s", cmd
->line
);
632 /* Parse the conditional for the if statement. */
633 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
634 expression_up expr
= parse_expression (new_line
.c_str ());
637 ret
= simple_control
;
639 /* Evaluate the conditional. */
640 val_mark
= value_mark ();
641 val
= evaluate_expression (expr
.get ());
643 /* Choose which arm to take commands from based on the value
644 of the conditional expression. */
645 if (value_true (val
))
646 current
= cmd
->body_list_0
.get ();
647 else if (cmd
->body_list_1
!= nullptr)
648 current
= cmd
->body_list_1
.get ();
649 value_free_to_mark (val_mark
);
651 /* Execute commands in the given arm. */
654 scoped_restore save_nesting
655 = make_scoped_restore (&command_nest_depth
, command_nest_depth
+ 1);
656 ret
= execute_control_command_1 (current
, from_tty
);
658 /* If we got an error, get out. */
659 if (ret
!= simple_control
)
662 /* Get the next statement in the body. */
663 current
= current
->next
;
669 case commands_control
:
671 /* Breakpoint commands list, record the commands in the
672 breakpoint's command list and return. */
673 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
674 ret
= commands_from_control_command (new_line
.c_str (), cmd
);
678 case compile_control
:
679 eval_compile_command (cmd
, NULL
, cmd
->control_u
.compile
.scope
,
680 cmd
->control_u
.compile
.scope_data
);
681 ret
= simple_control
;
685 print_command_trace ("define %s", cmd
->line
);
686 do_define_command (cmd
->line
, 0, &cmd
->body_list_0
);
687 ret
= simple_control
;
690 case document_control
:
691 print_command_trace ("document %s", cmd
->line
);
692 do_document_command (cmd
->line
, 0, &cmd
->body_list_0
);
693 ret
= simple_control
;
699 eval_ext_lang_from_control_command (cmd
);
700 ret
= simple_control
;
705 warning (_("Invalid control type in canned commands structure."));
712 enum command_control_type
713 execute_control_command (struct command_line
*cmd
, int from_tty
)
715 if (!current_uiout
->is_mi_like_p ())
716 return execute_control_command_1 (cmd
, from_tty
);
718 /* Make sure we use the console uiout. It's possible that we are executing
719 breakpoint commands while running the MI interpreter. */
720 interp
*console
= interp_lookup (current_ui
, INTERP_CONSOLE
);
721 scoped_restore save_uiout
722 = make_scoped_restore (¤t_uiout
, console
->interp_ui_out ());
724 return execute_control_command_1 (cmd
, from_tty
);
727 /* Like execute_control_command, but first set
728 suppress_next_print_command_trace. */
730 enum command_control_type
731 execute_control_command_untraced (struct command_line
*cmd
)
733 suppress_next_print_command_trace
= 1;
734 return execute_control_command (cmd
);
738 /* "while" command support. Executes a body of statements while the
739 loop condition is nonzero. */
742 while_command (const char *arg
, int from_tty
)
745 counted_command_line command
= get_command_line (while_control
, arg
);
750 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
752 execute_control_command_untraced (command
.get ());
755 /* "if" command support. Execute either the true or false arm depending
756 on the value of the if conditional. */
759 if_command (const char *arg
, int from_tty
)
762 counted_command_line command
= get_command_line (if_control
, arg
);
767 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
769 execute_control_command_untraced (command
.get ());
772 /* Bind the incoming arguments for a user defined command to $arg0,
775 user_args::user_args (const char *command_line
)
779 if (command_line
== NULL
)
782 m_command_line
= command_line
;
783 p
= m_command_line
.c_str ();
787 const char *start_arg
;
792 /* Strip whitespace. */
793 while (*p
== ' ' || *p
== '\t')
796 /* P now points to an argument. */
799 /* Get to the end of this argument. */
802 if (((*p
== ' ' || *p
== '\t')) && !squote
&& !dquote
&& !bsquote
)
831 m_args
.emplace_back (start_arg
, p
- start_arg
);
835 /* Given character string P, return a point to the first argument
836 ($arg), or NULL if P contains no arguments. */
839 locate_arg (const char *p
)
841 while ((p
= strchr (p
, '$')))
843 if (startswith (p
, "$arg")
844 && (isdigit (p
[4]) || p
[4] == 'c'))
851 /* See cli-script.h. */
854 insert_user_defined_cmd_args (const char *line
)
856 /* If we are not in a user-defined command, treat $argc, $arg0, et
857 cetera as normal convenience variables. */
858 if (user_args_stack
.empty ())
861 const std::unique_ptr
<user_args
> &args
= user_args_stack
.back ();
862 return args
->insert_args (line
);
865 /* Insert the user defined arguments stored in user_args into the $arg
866 arguments found in line. */
869 user_args::insert_args (const char *line
) const
871 std::string new_line
;
874 while ((p
= locate_arg (line
)))
876 new_line
.append (line
, p
- line
);
880 new_line
+= std::to_string (m_args
.size ());
889 i
= strtoul (p
+ 4, &tmp
, 10);
890 if ((i
== 0 && tmp
== p
+ 4) || errno
!= 0)
892 else if (i
>= m_args
.size ())
893 error (_("Missing argument %ld in user function."), i
);
896 new_line
.append (m_args
[i
].data (), m_args
[i
].length ());
901 /* Don't forget the tail. */
902 new_line
.append (line
);
908 /* Read next line from stdin. Passed to read_command_line_1 and
909 recurse_read_control_structure whenever we need to read commands
915 struct ui
*ui
= current_ui
;
916 char *prompt_ptr
, control_prompt
[256];
918 int from_tty
= ui
->instream
== ui
->stdin_stream
;
920 if (control_level
>= 254)
921 error (_("Control nesting too deep!"));
923 /* Set a prompt based on the nesting of the control commands. */
925 || (ui
->instream
== 0 && deprecated_readline_hook
!= NULL
))
927 for (i
= 0; i
< control_level
; i
++)
928 control_prompt
[i
] = ' ';
929 control_prompt
[i
] = '>';
930 control_prompt
[i
+ 1] = '\0';
931 prompt_ptr
= (char *) &control_prompt
[0];
936 return command_line_input (prompt_ptr
, "commands");
939 /* Given an input line P, skip the command and return a pointer to the
943 line_first_arg (const char *p
)
945 const char *first_arg
= p
+ find_command_name_length (p
);
947 return skip_spaces (first_arg
);
950 /* Process one input line. If the command is an "end", return such an
951 indication to the caller. If PARSE_COMMANDS is true, strip leading
952 whitespace (trailing whitespace is always stripped) in the line,
953 attempt to recognize GDB control commands, and also return an
954 indication if the command is an "else" or a nop.
956 Otherwise, only "end" is recognized. */
958 static enum misc_command_type
959 process_next_line (const char *p
, command_line_up
*command
,
961 gdb::function_view
<void (const char *)> validator
)
968 /* Not sure what to do here. */
972 /* Strip trailing whitespace. */
973 p_end
= p
+ strlen (p
);
974 while (p_end
> p
&& (p_end
[-1] == ' ' || p_end
[-1] == '\t'))
978 /* Strip leading whitespace. */
979 while (p_start
< p_end
&& (*p_start
== ' ' || *p_start
== '\t'))
982 /* 'end' is always recognized, regardless of parse_commands value.
983 We also permit whitespace before end and after. */
984 if (p_end
- p_start
== 3 && startswith (p_start
, "end"))
989 /* Resolve command abbreviations (e.g. 'ws' for 'while-stepping'). */
990 const char *cmd_name
= p
;
991 struct cmd_list_element
*cmd
992 = lookup_cmd_1 (&cmd_name
, cmdlist
, NULL
, NULL
, 1);
993 cmd_name
= skip_spaces (cmd_name
);
994 bool inline_cmd
= *cmd_name
!= '\0';
996 /* If commands are parsed, we skip initial spaces. Otherwise,
997 which is the case for Python commands and documentation
998 (see the 'document' command), spaces are preserved. */
1001 /* Blanks and comments don't really do anything, but we need to
1002 distinguish them from else, end and other commands which can
1004 if (p_end
== p
|| p
[0] == '#')
1007 /* Is the else clause of an if control structure? */
1008 if (p_end
- p
== 4 && startswith (p
, "else"))
1009 return else_command
;
1011 /* Check for while, if, break, continue, etc and build a new
1012 command line structure for them. */
1013 if (cmd
== while_stepping_cmd_element
)
1015 /* Because validate_actionline and encode_action lookup
1016 command's line as command, we need the line to
1017 include 'while-stepping'.
1019 For 'ws' alias, the command will have 'ws', not expanded
1020 to 'while-stepping'. This is intentional -- we don't
1021 really want frontend to send a command list with 'ws',
1022 and next break-info returning command line with
1023 'while-stepping'. This should work, but might cause the
1024 breakpoint to be marked as changed while it's actually
1026 *command
= build_command_line (while_stepping_control
, p
);
1028 else if (cmd
== while_cmd_element
)
1029 *command
= build_command_line (while_control
, line_first_arg (p
));
1030 else if (cmd
== if_cmd_element
)
1031 *command
= build_command_line (if_control
, line_first_arg (p
));
1032 else if (cmd
== commands_cmd_element
)
1033 *command
= build_command_line (commands_control
, line_first_arg (p
));
1034 else if (cmd
== define_cmd_element
)
1035 *command
= build_command_line (define_control
, line_first_arg (p
));
1036 else if (cmd
== document_cmd_element
)
1037 *command
= build_command_line (document_control
, line_first_arg (p
));
1038 else if (cmd
== python_cmd_element
&& !inline_cmd
)
1040 /* Note that we ignore the inline "python command" form
1042 *command
= build_command_line (python_control
, "");
1044 else if (cmd
== compile_cmd_element
&& !inline_cmd
)
1046 /* Note that we ignore the inline "compile command" form
1048 *command
= build_command_line (compile_control
, "");
1049 (*command
)->control_u
.compile
.scope
= COMPILE_I_INVALID_SCOPE
;
1051 else if (cmd
== guile_cmd_element
&& !inline_cmd
)
1053 /* Note that we ignore the inline "guile command" form here. */
1054 *command
= build_command_line (guile_control
, "");
1056 else if (p_end
- p
== 10 && startswith (p
, "loop_break"))
1057 *command
= command_line_up (new command_line (break_control
));
1058 else if (p_end
- p
== 13 && startswith (p
, "loop_continue"))
1059 *command
= command_line_up (new command_line (continue_control
));
1064 if (!parse_commands
|| not_handled
)
1066 /* A normal command. */
1067 *command
= command_line_up (new command_line (simple_control
,
1068 savestring (p
, p_end
- p
)));
1072 validator ((*command
)->line
);
1074 /* Nothing special. */
1078 /* Recursively read in the control structures and create a
1079 command_line structure from them. Use read_next_line_func to
1080 obtain lines of the command. */
1082 static enum command_control_type
1083 recurse_read_control_structure (gdb::function_view
<const char * ()> read_next_line_func
,
1084 struct command_line
*current_cmd
,
1085 gdb::function_view
<void (const char *)> validator
)
1087 enum misc_command_type val
;
1088 enum command_control_type ret
;
1089 struct command_line
*child_tail
;
1090 counted_command_line
*current_body
= ¤t_cmd
->body_list_0
;
1091 command_line_up next
;
1093 child_tail
= nullptr;
1095 /* Sanity checks. */
1096 if (current_cmd
->control_type
== simple_control
)
1097 error (_("Recursed on a simple control type."));
1099 /* Read lines from the input stream and build control structures. */
1105 val
= process_next_line (read_next_line_func (), &next
,
1106 current_cmd
->control_type
!= python_control
1107 && current_cmd
->control_type
!= guile_control
1108 && current_cmd
->control_type
!= compile_control
,
1111 /* Just skip blanks and comments. */
1112 if (val
== nop_command
)
1115 if (val
== end_command
)
1117 if (multi_line_command_p (current_cmd
->control_type
))
1119 /* Success reading an entire canned sequence of commands. */
1120 ret
= simple_control
;
1125 ret
= invalid_control
;
1130 /* Not the end of a control structure. */
1131 if (val
== else_command
)
1133 if (current_cmd
->control_type
== if_control
1134 && current_body
== ¤t_cmd
->body_list_0
)
1136 current_body
= ¤t_cmd
->body_list_1
;
1137 child_tail
= nullptr;
1142 ret
= invalid_control
;
1147 /* Transfer ownership of NEXT to the command's body list. */
1148 if (child_tail
!= nullptr)
1150 child_tail
->next
= next
.release ();
1151 child_tail
= child_tail
->next
;
1155 child_tail
= next
.get ();
1156 *current_body
= counted_command_line (next
.release (),
1157 command_lines_deleter ());
1160 /* If the latest line is another control structure, then recurse
1162 if (multi_line_command_p (child_tail
->control_type
))
1165 ret
= recurse_read_control_structure (read_next_line_func
,
1170 if (ret
!= simple_control
)
1180 /* Read lines from the input stream and accumulate them in a chain of
1181 struct command_line's, which is then returned. For input from a
1182 terminal, the special command "end" is used to mark the end of the
1183 input, and is not included in the returned chain of commands.
1185 If PARSE_COMMANDS is true, strip leading whitespace (trailing whitespace
1186 is always stripped) in the line and attempt to recognize GDB control
1187 commands. Otherwise, only "end" is recognized. */
1189 #define END_MESSAGE "End with a line saying just \"end\"."
1191 counted_command_line
1192 read_command_lines (const char *prompt_arg
, int from_tty
, int parse_commands
,
1193 gdb::function_view
<void (const char *)> validator
)
1195 if (from_tty
&& input_interactive_p (current_ui
))
1197 if (deprecated_readline_begin_hook
)
1199 /* Note - intentional to merge messages with no newline. */
1200 (*deprecated_readline_begin_hook
) ("%s %s\n", prompt_arg
,
1204 printf_unfiltered ("%s\n%s\n", prompt_arg
, END_MESSAGE
);
1208 /* Reading commands assumes the CLI behavior, so temporarily
1209 override the current interpreter with CLI. */
1210 counted_command_line
head (nullptr, command_lines_deleter ());
1211 if (current_interp_named_p (INTERP_CONSOLE
))
1212 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1216 scoped_restore_interp
interp_restorer (INTERP_CONSOLE
);
1218 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1222 if (from_tty
&& input_interactive_p (current_ui
)
1223 && deprecated_readline_end_hook
)
1225 (*deprecated_readline_end_hook
) ();
1230 /* Act the same way as read_command_lines, except that each new line is
1231 obtained using READ_NEXT_LINE_FUNC. */
1233 counted_command_line
1234 read_command_lines_1 (gdb::function_view
<const char * ()> read_next_line_func
,
1236 gdb::function_view
<void (const char *)> validator
)
1238 struct command_line
*tail
;
1239 counted_command_line
head (nullptr, command_lines_deleter ());
1240 enum command_control_type ret
;
1241 enum misc_command_type val
;
1242 command_line_up next
;
1250 val
= process_next_line (read_next_line_func (), &next
, parse_commands
,
1253 /* Ignore blank lines or comments. */
1254 if (val
== nop_command
)
1257 if (val
== end_command
)
1259 ret
= simple_control
;
1263 if (val
!= ok_command
)
1265 ret
= invalid_control
;
1269 if (multi_line_command_p (next
->control_type
))
1272 ret
= recurse_read_control_structure (read_next_line_func
, next
.get (),
1276 if (ret
== invalid_control
)
1280 /* Transfer ownership of NEXT to the HEAD list. */
1283 tail
->next
= next
.release ();
1289 head
= counted_command_line (next
.release (),
1290 command_lines_deleter ());
1296 if (ret
== invalid_control
)
1302 /* Free a chain of struct command_line's. */
1305 free_command_lines (struct command_line
**lptr
)
1307 struct command_line
*l
= *lptr
;
1308 struct command_line
*next
;
1319 /* Validate that *COMNAME is a valid name for a command. Return the
1320 containing command list, in case it starts with a prefix command.
1321 The prefix must already exist. *COMNAME is advanced to point after
1322 any prefix, and a NUL character overwrites the space after the
1325 static struct cmd_list_element
**
1326 validate_comname (const char **comname
)
1328 struct cmd_list_element
**list
= &cmdlist
;
1329 const char *p
, *last_word
;
1332 error_no_arg (_("name of command to define"));
1334 /* Find the last word of the argument. */
1335 p
= *comname
+ strlen (*comname
);
1336 while (p
> *comname
&& isspace (p
[-1]))
1338 while (p
> *comname
&& !isspace (p
[-1]))
1342 /* Find the corresponding command list. */
1343 if (last_word
!= *comname
)
1345 struct cmd_list_element
*c
;
1347 /* Separate the prefix and the command. */
1348 std::string
prefix (*comname
, last_word
- 1);
1349 const char *tem
= prefix
.c_str ();
1351 c
= lookup_cmd (&tem
, cmdlist
, "", NULL
, 0, 1);
1352 if (!c
->is_prefix ())
1353 error (_("\"%s\" is not a prefix command."), prefix
.c_str ());
1355 list
= c
->subcommands
;
1356 *comname
= last_word
;
1362 if (!valid_cmd_char_p (*p
))
1363 error (_("Junk in argument list: \"%s\""), p
);
1370 /* This is just a placeholder in the command data structures. */
1372 user_defined_command (const char *ignore
, int from_tty
)
1376 /* Define a user-defined command. If COMMANDS is NULL, then this is a
1377 top-level call and the commands will be read using
1378 read_command_lines. Otherwise, it is a "define" command in an
1379 existing command and the commands are provided. In the
1380 non-top-level case, various prompts and warnings are disabled. */
1383 do_define_command (const char *comname
, int from_tty
,
1384 const counted_command_line
*commands
)
1392 struct cmd_list_element
*c
, *newc
, *hookc
= 0, **list
;
1393 const char *comfull
;
1394 int hook_type
= CMD_NO_HOOK
;
1395 int hook_name_size
= 0;
1397 #define HOOK_STRING "hook-"
1399 #define HOOK_POST_STRING "hookpost-"
1400 #define HOOK_POST_LEN 9
1403 list
= validate_comname (&comname
);
1405 c
= lookup_cmd_exact (comname
, *list
);
1407 if (c
&& commands
== nullptr)
1411 if (c
->theclass
== class_user
|| c
->theclass
== class_alias
)
1413 /* if C is a prefix command that was previously defined,
1414 tell the user its subcommands will be kept, and ask
1415 if ok to redefine the command. */
1416 if (c
->is_prefix ())
1417 q
= (c
->user_commands
.get () == nullptr
1418 || query (_("Keeping subcommands of prefix command \"%s\".\n"
1419 "Redefine command \"%s\"? "), c
->name
, c
->name
));
1421 q
= query (_("Redefine command \"%s\"? "), c
->name
);
1424 q
= query (_("Really redefine built-in command \"%s\"? "), c
->name
);
1426 error (_("Command \"%s\" not redefined."), c
->name
);
1429 /* If this new command is a hook, then mark the command which it
1430 is hooking. Note that we allow hooking `help' commands, so that
1431 we can hook the `stop' pseudo-command. */
1433 if (!strncmp (comname
, HOOK_STRING
, HOOK_LEN
))
1435 hook_type
= CMD_PRE_HOOK
;
1436 hook_name_size
= HOOK_LEN
;
1438 else if (!strncmp (comname
, HOOK_POST_STRING
, HOOK_POST_LEN
))
1440 hook_type
= CMD_POST_HOOK
;
1441 hook_name_size
= HOOK_POST_LEN
;
1444 if (hook_type
!= CMD_NO_HOOK
)
1446 /* Look up cmd it hooks. */
1447 hookc
= lookup_cmd_exact (comname
+ hook_name_size
, *list
,
1448 /* ignore_help_classes = */ false);
1449 if (!hookc
&& commands
== nullptr)
1451 warning (_("Your new `%s' command does not "
1452 "hook any existing command."),
1454 if (!query (_("Proceed? ")))
1455 error (_("Not confirmed."));
1459 comname
= xstrdup (comname
);
1461 counted_command_line cmds
;
1462 if (commands
== nullptr)
1465 = string_printf ("Type commands for definition of \"%s\".", comfull
);
1466 cmds
= read_command_lines (prompt
.c_str (), from_tty
, 1, 0);
1472 struct cmd_list_element
**c_subcommands
1473 = c
== nullptr ? nullptr : c
->subcommands
;
1475 newc
= add_cmd (comname
, class_user
, user_defined_command
,
1476 (c
!= nullptr && c
->theclass
== class_user
)
1477 ? c
->doc
: xstrdup ("User-defined."), list
);
1478 newc
->user_commands
= std::move (cmds
);
1480 /* If we define or re-define a command that was previously defined
1481 as a prefix, keep the prefix information. */
1482 if (c_subcommands
!= nullptr)
1484 newc
->subcommands
= c_subcommands
;
1485 /* allow_unknown: see explanation in equivalent logic in
1486 define_prefix_command (). */
1487 newc
->allow_unknown
= newc
->user_commands
.get () != nullptr;
1491 /* If this new command is a hook, then mark both commands as being
1498 hookc
->hook_pre
= newc
; /* Target gets hooked. */
1499 newc
->hookee_pre
= hookc
; /* We are marked as hooking target cmd. */
1502 hookc
->hook_post
= newc
; /* Target gets hooked. */
1503 newc
->hookee_post
= hookc
; /* We are marked as hooking
1507 /* Should never come here as hookc would be 0. */
1508 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1514 define_command (const char *comname
, int from_tty
)
1516 do_define_command (comname
, from_tty
, nullptr);
1519 /* Document a user-defined command. If COMMANDS is NULL, then this is a
1520 top-level call and the document will be read using read_command_lines.
1521 Otherwise, it is a "document" command in an existing command and the
1522 commands are provided. */
1524 do_document_command (const char *comname
, int from_tty
,
1525 const counted_command_line
*commands
)
1527 struct cmd_list_element
*c
, **list
;
1529 const char *comfull
;
1532 list
= validate_comname (&comname
);
1535 c
= lookup_cmd (&tem
, *list
, "", NULL
, 0, 1);
1537 if (c
->theclass
!= class_user
)
1538 error (_("Command \"%s\" is built-in."), comfull
);
1540 counted_command_line doclines
;
1542 if (commands
== nullptr)
1545 = string_printf ("Type documentation for \"%s\".", comfull
);
1546 doclines
= read_command_lines (prompt
.c_str (), from_tty
, 0, 0);
1549 doclines
= *commands
;
1551 xfree ((char *) c
->doc
);
1554 struct command_line
*cl1
;
1558 for (cl1
= doclines
.get (); cl1
; cl1
= cl1
->next
)
1559 len
+= strlen (cl1
->line
) + 1;
1561 doc
= (char *) xmalloc (len
+ 1);
1564 for (cl1
= doclines
.get (); cl1
; cl1
= cl1
->next
)
1566 strcat (doc
, cl1
->line
);
1576 document_command (const char *comname
, int from_tty
)
1578 do_document_command (comname
, from_tty
, nullptr);
1581 /* Implementation of the "define-prefix" command. */
1584 define_prefix_command (const char *comname
, int from_tty
)
1586 struct cmd_list_element
*c
, **list
;
1587 const char *comfull
;
1590 list
= validate_comname (&comname
);
1592 c
= lookup_cmd_exact (comname
, *list
);
1594 if (c
!= nullptr && c
->theclass
!= class_user
)
1595 error (_("Command \"%s\" is built-in."), comfull
);
1597 if (c
!= nullptr && c
->is_prefix ())
1599 /* c is already a user defined prefix command. */
1603 /* If the command does not exist at all, create it. */
1606 comname
= xstrdup (comname
);
1607 c
= add_cmd (comname
, class_user
, user_defined_command
,
1608 xstrdup ("User-defined."), list
);
1611 /* Allocate the c->subcommands, which marks the command as a prefix
1613 c
->subcommands
= new struct cmd_list_element
*;
1614 *(c
->subcommands
) = nullptr;
1615 /* If the prefix command C is not a command, then it must be followed
1616 by known subcommands. Otherwise, if C is also a normal command,
1617 it can be followed by C args that must not cause a 'subcommand'
1618 not recognised error, and thus we must allow unknown. */
1619 c
->allow_unknown
= c
->user_commands
.get () != nullptr;
1623 /* Used to implement source_command. */
1626 script_from_file (FILE *stream
, const char *file
)
1629 internal_error (__FILE__
, __LINE__
, _("called with NULL file pointer!"));
1631 scoped_restore restore_line_number
1632 = make_scoped_restore (&source_line_number
, 0);
1633 scoped_restore restore_file
1634 = make_scoped_restore
<std::string
, const std::string
&> (&source_file_name
,
1637 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
1641 read_command_file (stream
);
1643 catch (const gdb_exception_error
&e
)
1645 /* Re-throw the error, but with the file name information
1647 throw_error (e
.error
,
1648 _("%s:%d: Error in sourced command file:\n%s"),
1649 source_file_name
.c_str (), source_line_number
,
1654 /* Print the definition of user command C to STREAM. Or, if C is a
1655 prefix command, show the definitions of all user commands under C
1656 (recursively). PREFIX and NAME combined are the name of the
1659 show_user_1 (struct cmd_list_element
*c
, const char *prefix
, const char *name
,
1660 struct ui_file
*stream
)
1662 if (cli_user_command_p (c
))
1664 struct command_line
*cmdlines
= c
->user_commands
.get ();
1666 fprintf_filtered (stream
, "User %scommand \"",
1667 c
->is_prefix () ? "prefix" : "");
1668 fprintf_styled (stream
, title_style
.style (), "%s%s",
1670 fprintf_filtered (stream
, "\":\n");
1673 print_command_lines (current_uiout
, cmdlines
, 1);
1674 fputs_filtered ("\n", stream
);
1678 if (c
->is_prefix ())
1680 const std::string prefixname
= c
->prefixname ();
1682 for (c
= *c
->subcommands
; c
!= NULL
; c
= c
->next
)
1683 if (c
->theclass
== class_user
|| c
->is_prefix ())
1684 show_user_1 (c
, prefixname
.c_str (), c
->name
, gdb_stdout
);
1689 void _initialize_cli_script ();
1691 _initialize_cli_script ()
1693 struct cmd_list_element
*c
;
1695 /* "document", "define" and "define-prefix" use command_completer,
1696 as this helps the user to either type the command name and/or
1698 document_cmd_element
= add_com ("document", class_support
, document_command
,
1700 Document a user-defined command.\n\
1701 Give command name as argument. Give documentation on following lines.\n\
1702 End with a line of just \"end\"."));
1703 set_cmd_completer (document_cmd_element
, command_completer
);
1704 define_cmd_element
= add_com ("define", class_support
, define_command
, _("\
1705 Define a new command name. Command name is argument.\n\
1706 Definition appears on following lines, one command per line.\n\
1707 End with a line of just \"end\".\n\
1708 Use the \"document\" command to give documentation for the new command.\n\
1709 Commands defined in this way may accept an unlimited number of arguments\n\
1710 accessed via $arg0 .. $argN. $argc tells how many arguments have\n\
1712 set_cmd_completer (define_cmd_element
, command_completer
);
1713 c
= add_com ("define-prefix", class_support
, define_prefix_command
,
1715 Define or mark a command as a user-defined prefix command.\n\
1716 User defined prefix commands can be used as prefix commands for\n\
1717 other user defined commands.\n\
1718 If the command already exists, it is changed to a prefix command."));
1719 set_cmd_completer (c
, command_completer
);
1721 while_cmd_element
= 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 if_cmd_element
= 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."));