1 /* GDB CLI command scripting.
3 Copyright (C) 1986-2019 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 const char *read_next_line ();
56 /* Level of control structure when reading. */
57 static int control_level
;
59 /* Level of control structure when executing. */
60 static int command_nest_depth
= 1;
62 /* This is to prevent certain commands being printed twice. */
63 static int suppress_next_print_command_trace
= 0;
65 /* Command element for the 'while' command. */
66 static cmd_list_element
*while_cmd_element
= nullptr;
68 /* Command element for the 'if' command. */
69 static cmd_list_element
*if_cmd_element
= nullptr;
71 /* Command element for the 'define' command. */
72 static cmd_list_element
*define_cmd_element
= nullptr;
74 /* Structure for arguments to user defined functions. */
79 /* Save the command line and store the locations of arguments passed
80 to the user defined function. */
81 explicit user_args (const char *line
);
83 /* Insert the stored user defined arguments into the $arg arguments
85 std::string
insert_args (const char *line
) const;
88 /* Disable copy/assignment. (Since the elements of A point inside
89 COMMAND, copying would need to reconstruct the A vector in the
91 user_args (const user_args
&) =delete;
92 user_args
&operator= (const user_args
&) =delete;
94 /* It is necessary to store a copy of the command line to ensure
95 that the arguments are not overwritten before they are used. */
96 std::string m_command_line
;
98 /* The arguments. Each element points inside M_COMMAND_LINE. */
99 std::vector
<gdb::string_view
> m_args
;
102 /* The stack of arguments passed to user defined functions. We need a
103 stack because user-defined functions can call other user-defined
105 static std::vector
<std::unique_ptr
<user_args
>> user_args_stack
;
107 /* An RAII-base class used to push/pop args on the user args
109 struct scoped_user_args_level
111 /* Parse the command line and push the arguments in the user args
113 explicit scoped_user_args_level (const char *line
)
115 user_args_stack
.emplace_back (new user_args (line
));
118 /* Pop the current user arguments from the stack. */
119 ~scoped_user_args_level ()
121 user_args_stack
.pop_back ();
126 /* Return non-zero if TYPE is a multi-line command (i.e., is terminated
130 multi_line_command_p (enum command_control_type type
)
136 case while_stepping_control
:
137 case commands_control
:
138 case compile_control
:
148 /* Allocate, initialize a new command line structure for one of the
149 control commands (if/while). */
151 static struct command_line
*
152 build_command_line (enum command_control_type type
, const char *args
)
154 if (args
== NULL
|| *args
== '\0')
156 if (type
== if_control
)
157 error (_("if command requires an argument."));
158 else if (type
== while_control
)
159 error (_("while command requires an argument."));
160 else if (type
== define_control
)
161 error (_("define command requires an argument."));
163 gdb_assert (args
!= NULL
);
165 return new struct command_line (type
, xstrdup (args
));
168 /* Build and return a new command structure for the control commands
169 such as "if" and "while". */
172 get_command_line (enum command_control_type type
, const char *arg
)
174 /* Allocate and build a new command line structure. */
175 counted_command_line
cmd (build_command_line (type
, arg
),
176 command_lines_deleter ());
178 /* Read in the body of this command. */
179 if (recurse_read_control_structure (read_next_line
, cmd
.get (), 0)
182 warning (_("Error reading in canned sequence of commands."));
189 /* Recursively print a command (including full control structures). */
192 print_command_lines (struct ui_out
*uiout
, struct command_line
*cmd
,
195 struct command_line
*list
;
201 uiout
->spaces (2 * depth
);
203 /* A simple command, print it and continue. */
204 if (list
->control_type
== simple_control
)
206 uiout
->field_string (NULL
, list
->line
);
212 /* loop_continue to jump to the start of a while loop, print it
214 if (list
->control_type
== continue_control
)
216 uiout
->field_string (NULL
, "loop_continue");
222 /* loop_break to break out of a while loop, print it and
224 if (list
->control_type
== break_control
)
226 uiout
->field_string (NULL
, "loop_break");
232 /* A while command. Recursively print its subcommands and
234 if (list
->control_type
== while_control
235 || list
->control_type
== while_stepping_control
)
237 /* For while-stepping, the line includes the 'while-stepping'
238 token. See comment in process_next_line for explanation.
239 Here, take care not print 'while-stepping' twice. */
240 if (list
->control_type
== while_control
)
241 uiout
->field_fmt (NULL
, "while %s", list
->line
);
243 uiout
->field_string (NULL
, list
->line
);
245 print_command_lines (uiout
, list
->body_list_0
.get (), depth
+ 1);
247 uiout
->spaces (2 * depth
);
248 uiout
->field_string (NULL
, "end");
254 /* An if command. Recursively print both arms before
256 if (list
->control_type
== if_control
)
258 uiout
->field_fmt (NULL
, "if %s", list
->line
);
261 print_command_lines (uiout
, list
->body_list_0
.get (), depth
+ 1);
263 /* Show the false arm if it exists. */
264 if (list
->body_list_1
!= nullptr)
267 uiout
->spaces (2 * depth
);
268 uiout
->field_string (NULL
, "else");
270 print_command_lines (uiout
, list
->body_list_1
.get (), depth
+ 1);
274 uiout
->spaces (2 * depth
);
275 uiout
->field_string (NULL
, "end");
281 /* A commands command. Print the breakpoint commands and
283 if (list
->control_type
== commands_control
)
286 uiout
->field_fmt (NULL
, "commands %s", list
->line
);
288 uiout
->field_string (NULL
, "commands");
290 print_command_lines (uiout
, list
->body_list_0
.get (), depth
+ 1);
292 uiout
->spaces (2 * depth
);
293 uiout
->field_string (NULL
, "end");
299 if (list
->control_type
== python_control
)
301 uiout
->field_string (NULL
, "python");
303 /* Don't indent python code at all. */
304 print_command_lines (uiout
, list
->body_list_0
.get (), 0);
306 uiout
->spaces (2 * depth
);
307 uiout
->field_string (NULL
, "end");
313 if (list
->control_type
== compile_control
)
315 uiout
->field_string (NULL
, "compile expression");
317 print_command_lines (uiout
, list
->body_list_0
.get (), 0);
319 uiout
->spaces (2 * depth
);
320 uiout
->field_string (NULL
, "end");
326 if (list
->control_type
== guile_control
)
328 uiout
->field_string (NULL
, "guile");
330 print_command_lines (uiout
, list
->body_list_0
.get (), depth
+ 1);
332 uiout
->spaces (2 * depth
);
333 uiout
->field_string (NULL
, "end");
339 /* Ignore illegal command type and try next. */
344 /* Handle pre-post hooks. */
346 class scoped_restore_hook_in
350 scoped_restore_hook_in (struct cmd_list_element
*c
)
355 ~scoped_restore_hook_in ()
360 scoped_restore_hook_in (const scoped_restore_hook_in
&) = delete;
361 scoped_restore_hook_in
&operator= (const scoped_restore_hook_in
&) = delete;
365 struct cmd_list_element
*m_cmd
;
369 execute_cmd_pre_hook (struct cmd_list_element
*c
)
371 if ((c
->hook_pre
) && (!c
->hook_in
))
373 scoped_restore_hook_in
restore_hook (c
);
374 c
->hook_in
= 1; /* Prevent recursive hooking. */
375 execute_user_command (c
->hook_pre
, nullptr);
380 execute_cmd_post_hook (struct cmd_list_element
*c
)
382 if ((c
->hook_post
) && (!c
->hook_in
))
384 scoped_restore_hook_in
restore_hook (c
);
385 c
->hook_in
= 1; /* Prevent recursive hooking. */
386 execute_user_command (c
->hook_post
, nullptr);
390 /* See cli-script.h. */
393 execute_control_commands (struct command_line
*cmdlines
, int from_tty
)
395 /* Set the instream to 0, indicating execution of a
396 user-defined function. */
397 scoped_restore restore_instream
398 = make_scoped_restore (¤t_ui
->instream
, nullptr);
399 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
400 scoped_restore save_nesting
401 = make_scoped_restore (&command_nest_depth
, command_nest_depth
+ 1);
405 enum command_control_type ret
= execute_control_command (cmdlines
,
407 if (ret
!= simple_control
&& ret
!= break_control
)
409 warning (_("Error executing canned sequence of commands."));
412 cmdlines
= cmdlines
->next
;
416 /* See cli-script.h. */
419 execute_control_commands_to_string (struct command_line
*commands
,
422 /* GDB_STDOUT should be better already restored during these
423 restoration callbacks. */
424 set_batch_flag_and_restore_page_info save_page_info
;
426 string_file str_file
;
429 current_uiout
->redirect (&str_file
);
430 ui_out_redirect_pop
redirect_popper (current_uiout
);
432 scoped_restore save_stdout
433 = make_scoped_restore (&gdb_stdout
, &str_file
);
434 scoped_restore save_stderr
435 = make_scoped_restore (&gdb_stderr
, &str_file
);
436 scoped_restore save_stdlog
437 = make_scoped_restore (&gdb_stdlog
, &str_file
);
438 scoped_restore save_stdtarg
439 = make_scoped_restore (&gdb_stdtarg
, &str_file
);
440 scoped_restore save_stdtargerr
441 = make_scoped_restore (&gdb_stdtargerr
, &str_file
);
443 execute_control_commands (commands
, from_tty
);
446 return std::move (str_file
.string ());
450 execute_user_command (struct cmd_list_element
*c
, const char *args
)
452 counted_command_line cmdlines_copy
;
454 /* Ensure that the user commands can't be deleted while they are
456 cmdlines_copy
= c
->user_commands
;
457 if (cmdlines_copy
== 0)
460 struct command_line
*cmdlines
= cmdlines_copy
.get ();
462 scoped_user_args_level
push_user_args (args
);
464 if (user_args_stack
.size () > max_user_call_depth
)
465 error (_("Max user call depth exceeded -- command aborted."));
467 execute_control_commands (cmdlines
, 0);
470 /* This function is called every time GDB prints a prompt. It ensures
471 that errors and the like do not confuse the command tracing. */
474 reset_command_nest_depth (void)
476 command_nest_depth
= 1;
479 suppress_next_print_command_trace
= 0;
482 /* Print the command, prefixed with '+' to represent the call depth.
483 This is slightly complicated because this function may be called
484 from execute_command and execute_control_command. Unfortunately
485 execute_command also prints the top level control commands.
486 In these cases execute_command will call execute_control_command
487 via while_command or if_command. Inner levels of 'if' and 'while'
488 are dealt with directly. Therefore we can use these functions
489 to determine whether the command has been printed already or not. */
490 ATTRIBUTE_PRINTF (1, 2)
492 print_command_trace (const char *fmt
, ...)
496 if (suppress_next_print_command_trace
)
498 suppress_next_print_command_trace
= 0;
502 if (!source_verbose
&& !trace_commands
)
505 for (i
=0; i
< command_nest_depth
; i
++)
506 printf_filtered ("+");
510 va_start (args
, fmt
);
511 vprintf_filtered (fmt
, args
);
513 puts_filtered ("\n");
516 /* Helper for execute_control_command. */
518 static enum command_control_type
519 execute_control_command_1 (struct command_line
*cmd
, int from_tty
)
521 struct command_line
*current
;
523 struct value
*val_mark
;
525 enum command_control_type ret
;
527 /* Start by assuming failure, if a problem is detected, the code
528 below will simply "break" out of the switch. */
529 ret
= invalid_control
;
531 switch (cmd
->control_type
)
535 /* A simple command, execute it and return. */
536 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
537 execute_command (new_line
.c_str (), from_tty
);
538 ret
= cmd
->control_type
;
542 case continue_control
:
543 print_command_trace ("loop_continue");
545 /* Return for "continue", and "break" so we can either
546 continue the loop at the top, or break out. */
547 ret
= cmd
->control_type
;
551 print_command_trace ("loop_break");
553 /* Return for "continue", and "break" so we can either
554 continue the loop at the top, or break out. */
555 ret
= cmd
->control_type
;
560 print_command_trace ("while %s", cmd
->line
);
562 /* Parse the loop control expression for the while statement. */
563 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
564 expression_up expr
= parse_expression (new_line
.c_str ());
566 ret
= simple_control
;
569 /* Keep iterating so long as the expression is true. */
576 /* Evaluate the expression. */
577 val_mark
= value_mark ();
578 val
= evaluate_expression (expr
.get ());
579 cond_result
= value_true (val
);
580 value_free_to_mark (val_mark
);
582 /* If the value is false, then break out of the loop. */
586 /* Execute the body of the while statement. */
587 current
= cmd
->body_list_0
.get ();
590 scoped_restore save_nesting
591 = make_scoped_restore (&command_nest_depth
, command_nest_depth
+ 1);
592 ret
= execute_control_command_1 (current
, from_tty
);
594 /* If we got an error, or a "break" command, then stop
596 if (ret
== invalid_control
|| ret
== break_control
)
602 /* If we got a "continue" command, then restart the loop
604 if (ret
== continue_control
)
607 /* Get the next statement. */
608 current
= current
->next
;
612 /* Reset RET so that we don't recurse the break all the way down. */
613 if (ret
== break_control
)
614 ret
= simple_control
;
621 print_command_trace ("if %s", cmd
->line
);
623 /* Parse the conditional for the if statement. */
624 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
625 expression_up expr
= parse_expression (new_line
.c_str ());
628 ret
= simple_control
;
630 /* Evaluate the conditional. */
631 val_mark
= value_mark ();
632 val
= evaluate_expression (expr
.get ());
634 /* Choose which arm to take commands from based on the value
635 of the conditional expression. */
636 if (value_true (val
))
637 current
= cmd
->body_list_0
.get ();
638 else if (cmd
->body_list_1
!= nullptr)
639 current
= cmd
->body_list_1
.get ();
640 value_free_to_mark (val_mark
);
642 /* Execute commands in the given arm. */
645 scoped_restore save_nesting
646 = make_scoped_restore (&command_nest_depth
, command_nest_depth
+ 1);
647 ret
= execute_control_command_1 (current
, from_tty
);
649 /* If we got an error, get out. */
650 if (ret
!= simple_control
)
653 /* Get the next statement in the body. */
654 current
= current
->next
;
660 case commands_control
:
662 /* Breakpoint commands list, record the commands in the
663 breakpoint's command list and return. */
664 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
665 ret
= commands_from_control_command (new_line
.c_str (), cmd
);
669 case compile_control
:
670 eval_compile_command (cmd
, NULL
, cmd
->control_u
.compile
.scope
,
671 cmd
->control_u
.compile
.scope_data
);
672 ret
= simple_control
;
676 print_command_trace ("define %s", cmd
->line
);
677 do_define_command (cmd
->line
, 0, &cmd
->body_list_0
);
678 ret
= simple_control
;
684 eval_ext_lang_from_control_command (cmd
);
685 ret
= simple_control
;
690 warning (_("Invalid control type in canned commands structure."));
697 enum command_control_type
698 execute_control_command (struct command_line
*cmd
, int from_tty
)
700 if (!current_uiout
->is_mi_like_p ())
701 return execute_control_command_1 (cmd
, from_tty
);
703 /* Make sure we use the console uiout. It's possible that we are executing
704 breakpoint commands while running the MI interpreter. */
705 interp
*console
= interp_lookup (current_ui
, INTERP_CONSOLE
);
706 scoped_restore save_uiout
707 = make_scoped_restore (¤t_uiout
, console
->interp_ui_out ());
709 return execute_control_command_1 (cmd
, from_tty
);
712 /* Like execute_control_command, but first set
713 suppress_next_print_command_trace. */
715 enum command_control_type
716 execute_control_command_untraced (struct command_line
*cmd
)
718 suppress_next_print_command_trace
= 1;
719 return execute_control_command (cmd
);
723 /* "while" command support. Executes a body of statements while the
724 loop condition is nonzero. */
727 while_command (const char *arg
, int from_tty
)
730 counted_command_line command
= get_command_line (while_control
, arg
);
735 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
737 execute_control_command_untraced (command
.get ());
740 /* "if" command support. Execute either the true or false arm depending
741 on the value of the if conditional. */
744 if_command (const char *arg
, int from_tty
)
747 counted_command_line command
= get_command_line (if_control
, arg
);
752 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
754 execute_control_command_untraced (command
.get ());
757 /* Bind the incoming arguments for a user defined command to $arg0,
760 user_args::user_args (const char *command_line
)
764 if (command_line
== NULL
)
767 m_command_line
= command_line
;
768 p
= m_command_line
.c_str ();
772 const char *start_arg
;
777 /* Strip whitespace. */
778 while (*p
== ' ' || *p
== '\t')
781 /* P now points to an argument. */
784 /* Get to the end of this argument. */
787 if (((*p
== ' ' || *p
== '\t')) && !squote
&& !dquote
&& !bsquote
)
816 m_args
.emplace_back (start_arg
, p
- start_arg
);
820 /* Given character string P, return a point to the first argument
821 ($arg), or NULL if P contains no arguments. */
824 locate_arg (const char *p
)
826 while ((p
= strchr (p
, '$')))
828 if (startswith (p
, "$arg")
829 && (isdigit (p
[4]) || p
[4] == 'c'))
836 /* See cli-script.h. */
839 insert_user_defined_cmd_args (const char *line
)
841 /* If we are not in a user-defined command, treat $argc, $arg0, et
842 cetera as normal convenience variables. */
843 if (user_args_stack
.empty ())
846 const std::unique_ptr
<user_args
> &args
= user_args_stack
.back ();
847 return args
->insert_args (line
);
850 /* Insert the user defined arguments stored in user_args into the $arg
851 arguments found in line. */
854 user_args::insert_args (const char *line
) const
856 std::string new_line
;
859 while ((p
= locate_arg (line
)))
861 new_line
.append (line
, p
- line
);
865 new_line
+= std::to_string (m_args
.size ());
874 i
= strtoul (p
+ 4, &tmp
, 10);
875 if ((i
== 0 && tmp
== p
+ 4) || errno
!= 0)
877 else if (i
>= m_args
.size ())
878 error (_("Missing argument %ld in user function."), i
);
881 new_line
.append (m_args
[i
].data (), m_args
[i
].length ());
886 /* Don't forget the tail. */
887 new_line
.append (line
);
893 /* Read next line from stdin. Passed to read_command_line_1 and
894 recurse_read_control_structure whenever we need to read commands
900 struct ui
*ui
= current_ui
;
901 char *prompt_ptr
, control_prompt
[256];
903 int from_tty
= ui
->instream
== ui
->stdin_stream
;
905 if (control_level
>= 254)
906 error (_("Control nesting too deep!"));
908 /* Set a prompt based on the nesting of the control commands. */
910 || (ui
->instream
== 0 && deprecated_readline_hook
!= NULL
))
912 for (i
= 0; i
< control_level
; i
++)
913 control_prompt
[i
] = ' ';
914 control_prompt
[i
] = '>';
915 control_prompt
[i
+ 1] = '\0';
916 prompt_ptr
= (char *) &control_prompt
[0];
921 return command_line_input (prompt_ptr
, "commands");
924 /* Given an input line P, skip the command and return a pointer to the
928 line_first_arg (const char *p
)
930 const char *first_arg
= p
+ find_command_name_length (p
);
932 return skip_spaces (first_arg
);
935 /* Process one input line. If the command is an "end", return such an
936 indication to the caller. If PARSE_COMMANDS is true, strip leading
937 whitespace (trailing whitespace is always stripped) in the line,
938 attempt to recognize GDB control commands, and also return an
939 indication if the command is an "else" or a nop.
941 Otherwise, only "end" is recognized. */
943 static enum misc_command_type
944 process_next_line (const char *p
, struct command_line
**command
,
946 gdb::function_view
<void (const char *)> validator
)
953 /* Not sure what to do here. */
957 /* Strip trailing whitespace. */
958 p_end
= p
+ strlen (p
);
959 while (p_end
> p
&& (p_end
[-1] == ' ' || p_end
[-1] == '\t'))
963 /* Strip leading whitespace. */
964 while (p_start
< p_end
&& (*p_start
== ' ' || *p_start
== '\t'))
967 /* 'end' is always recognized, regardless of parse_commands value.
968 We also permit whitespace before end and after. */
969 if (p_end
- p_start
== 3 && startswith (p_start
, "end"))
974 /* Resolve command abbreviations (e.g. 'ws' for 'while-stepping'). */
975 const char *cmd_name
= p
;
976 struct cmd_list_element
*cmd
977 = lookup_cmd_1 (&cmd_name
, cmdlist
, NULL
, 1);
978 cmd_name
= skip_spaces (cmd_name
);
979 bool inline_cmd
= *cmd_name
!= '\0';
981 /* If commands are parsed, we skip initial spaces. Otherwise,
982 which is the case for Python commands and documentation
983 (see the 'document' command), spaces are preserved. */
986 /* Blanks and comments don't really do anything, but we need to
987 distinguish them from else, end and other commands which can
989 if (p_end
== p
|| p
[0] == '#')
992 /* Is the else clause of an if control structure? */
993 if (p_end
- p
== 4 && startswith (p
, "else"))
996 /* Check for while, if, break, continue, etc and build a new
997 command line structure for them. */
998 if (cmd
== while_stepping_cmd_element
)
1000 /* Because validate_actionline and encode_action lookup
1001 command's line as command, we need the line to
1002 include 'while-stepping'.
1004 For 'ws' alias, the command will have 'ws', not expanded
1005 to 'while-stepping'. This is intentional -- we don't
1006 really want frontend to send a command list with 'ws',
1007 and next break-info returning command line with
1008 'while-stepping'. This should work, but might cause the
1009 breakpoint to be marked as changed while it's actually
1011 *command
= build_command_line (while_stepping_control
, p
);
1013 else if (cmd
== while_cmd_element
)
1014 *command
= build_command_line (while_control
, line_first_arg (p
));
1015 else if (cmd
== if_cmd_element
)
1016 *command
= build_command_line (if_control
, line_first_arg (p
));
1017 else if (cmd
== commands_cmd_element
)
1018 *command
= build_command_line (commands_control
, line_first_arg (p
));
1019 else if (cmd
== define_cmd_element
)
1020 *command
= build_command_line (define_control
, line_first_arg (p
));
1021 else if (cmd
== python_cmd_element
&& !inline_cmd
)
1023 /* Note that we ignore the inline "python command" form
1025 *command
= build_command_line (python_control
, "");
1027 else if (cmd
== compile_cmd_element
&& !inline_cmd
)
1029 /* Note that we ignore the inline "compile command" form
1031 *command
= build_command_line (compile_control
, "");
1032 (*command
)->control_u
.compile
.scope
= COMPILE_I_INVALID_SCOPE
;
1034 else if (cmd
== guile_cmd_element
&& !inline_cmd
)
1036 /* Note that we ignore the inline "guile command" form here. */
1037 *command
= build_command_line (guile_control
, "");
1039 else if (p_end
- p
== 10 && startswith (p
, "loop_break"))
1040 *command
= new struct command_line (break_control
);
1041 else if (p_end
- p
== 13 && startswith (p
, "loop_continue"))
1042 *command
= new struct command_line (continue_control
);
1047 if (!parse_commands
|| not_handled
)
1049 /* A normal command. */
1050 *command
= new struct command_line (simple_control
,
1051 savestring (p
, p_end
- p
));
1058 validator ((*command
)->line
);
1060 catch (const gdb_exception
&ex
)
1062 free_command_lines (command
);
1067 /* Nothing special. */
1071 /* Recursively read in the control structures and create a
1072 command_line structure from them. Use read_next_line_func to
1073 obtain lines of the command. */
1075 static enum command_control_type
1076 recurse_read_control_structure (gdb::function_view
<const char * ()> read_next_line_func
,
1077 struct command_line
*current_cmd
,
1078 gdb::function_view
<void (const char *)> validator
)
1080 enum misc_command_type val
;
1081 enum command_control_type ret
;
1082 struct command_line
*child_tail
, *next
;
1083 counted_command_line
*current_body
= ¤t_cmd
->body_list_0
;
1087 /* Sanity checks. */
1088 if (current_cmd
->control_type
== simple_control
)
1089 error (_("Recursed on a simple control type."));
1091 /* Read lines from the input stream and build control structures. */
1097 val
= process_next_line (read_next_line_func (), &next
,
1098 current_cmd
->control_type
!= python_control
1099 && current_cmd
->control_type
!= guile_control
1100 && current_cmd
->control_type
!= compile_control
,
1103 /* Just skip blanks and comments. */
1104 if (val
== nop_command
)
1107 if (val
== end_command
)
1109 if (multi_line_command_p (current_cmd
->control_type
))
1111 /* Success reading an entire canned sequence of commands. */
1112 ret
= simple_control
;
1117 ret
= invalid_control
;
1122 /* Not the end of a control structure. */
1123 if (val
== else_command
)
1125 if (current_cmd
->control_type
== if_control
1126 && current_body
== ¤t_cmd
->body_list_0
)
1128 current_body
= ¤t_cmd
->body_list_1
;
1134 ret
= invalid_control
;
1141 child_tail
->next
= next
;
1144 *current_body
= counted_command_line (next
, command_lines_deleter ());
1148 /* If the latest line is another control structure, then recurse
1150 if (multi_line_command_p (next
->control_type
))
1153 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1157 if (ret
!= simple_control
)
1167 /* Read lines from the input stream and accumulate them in a chain of
1168 struct command_line's, which is then returned. For input from a
1169 terminal, the special command "end" is used to mark the end of the
1170 input, and is not included in the returned chain of commands.
1172 If PARSE_COMMANDS is true, strip leading whitespace (trailing whitespace
1173 is always stripped) in the line and attempt to recognize GDB control
1174 commands. Otherwise, only "end" is recognized. */
1176 #define END_MESSAGE "End with a line saying just \"end\"."
1178 counted_command_line
1179 read_command_lines (const char *prompt_arg
, int from_tty
, int parse_commands
,
1180 gdb::function_view
<void (const char *)> validator
)
1182 if (from_tty
&& input_interactive_p (current_ui
))
1184 if (deprecated_readline_begin_hook
)
1186 /* Note - intentional to merge messages with no newline. */
1187 (*deprecated_readline_begin_hook
) ("%s %s\n", prompt_arg
,
1191 printf_unfiltered ("%s\n%s\n", prompt_arg
, END_MESSAGE
);
1195 /* Reading commands assumes the CLI behavior, so temporarily
1196 override the current interpreter with CLI. */
1197 counted_command_line
head (nullptr, command_lines_deleter ());
1198 if (current_interp_named_p (INTERP_CONSOLE
))
1199 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1203 scoped_restore_interp
interp_restorer (INTERP_CONSOLE
);
1205 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1209 if (from_tty
&& input_interactive_p (current_ui
)
1210 && deprecated_readline_end_hook
)
1212 (*deprecated_readline_end_hook
) ();
1217 /* Act the same way as read_command_lines, except that each new line is
1218 obtained using READ_NEXT_LINE_FUNC. */
1220 counted_command_line
1221 read_command_lines_1 (gdb::function_view
<const char * ()> read_next_line_func
,
1223 gdb::function_view
<void (const char *)> validator
)
1225 struct command_line
*tail
, *next
;
1226 counted_command_line
head (nullptr, command_lines_deleter ());
1227 enum command_control_type ret
;
1228 enum misc_command_type val
;
1236 val
= process_next_line (read_next_line_func (), &next
, parse_commands
,
1239 /* Ignore blank lines or comments. */
1240 if (val
== nop_command
)
1243 if (val
== end_command
)
1245 ret
= simple_control
;
1249 if (val
!= ok_command
)
1251 ret
= invalid_control
;
1255 if (multi_line_command_p (next
->control_type
))
1258 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1262 if (ret
== invalid_control
)
1272 head
= counted_command_line (next
, command_lines_deleter ());
1279 if (ret
== invalid_control
)
1285 /* Free a chain of struct command_line's. */
1288 free_command_lines (struct command_line
**lptr
)
1290 struct command_line
*l
= *lptr
;
1291 struct command_line
*next
;
1302 /* Validate that *COMNAME is a valid name for a command. Return the
1303 containing command list, in case it starts with a prefix command.
1304 The prefix must already exist. *COMNAME is advanced to point after
1305 any prefix, and a NUL character overwrites the space after the
1308 static struct cmd_list_element
**
1309 validate_comname (const char **comname
)
1311 struct cmd_list_element
**list
= &cmdlist
;
1312 const char *p
, *last_word
;
1315 error_no_arg (_("name of command to define"));
1317 /* Find the last word of the argument. */
1318 p
= *comname
+ strlen (*comname
);
1319 while (p
> *comname
&& isspace (p
[-1]))
1321 while (p
> *comname
&& !isspace (p
[-1]))
1325 /* Find the corresponding command list. */
1326 if (last_word
!= *comname
)
1328 struct cmd_list_element
*c
;
1330 /* Separate the prefix and the command. */
1331 std::string
prefix (*comname
, last_word
- 1);
1332 const char *tem
= prefix
.c_str ();
1334 c
= lookup_cmd (&tem
, cmdlist
, "", 0, 1);
1335 if (c
->prefixlist
== NULL
)
1336 error (_("\"%s\" is not a prefix command."), prefix
.c_str ());
1338 list
= c
->prefixlist
;
1339 *comname
= last_word
;
1345 if (!isalnum (*p
) && *p
!= '-' && *p
!= '_')
1346 error (_("Junk in argument list: \"%s\""), p
);
1353 /* This is just a placeholder in the command data structures. */
1355 user_defined_command (const char *ignore
, int from_tty
)
1359 /* Define a user-defined command. If COMMANDS is NULL, then this is a
1360 top-level call and the commands will be read using
1361 read_command_lines. Otherwise, it is a "define" command in an
1362 existing command and the commands are provided. In the
1363 non-top-level case, various prompts and warnings are disabled. */
1366 do_define_command (const char *comname
, int from_tty
,
1367 const counted_command_line
*commands
)
1375 struct cmd_list_element
*c
, *newc
, *hookc
= 0, **list
;
1376 const char *tem
, *comfull
;
1377 int hook_type
= CMD_NO_HOOK
;
1378 int hook_name_size
= 0;
1380 #define HOOK_STRING "hook-"
1382 #define HOOK_POST_STRING "hookpost-"
1383 #define HOOK_POST_LEN 9
1386 list
= validate_comname (&comname
);
1388 /* Look it up, and verify that we got an exact match. */
1390 c
= lookup_cmd (&tem
, *list
, "", -1, 1);
1391 if (c
&& strcmp (comname
, c
->name
) != 0)
1394 if (c
&& commands
== nullptr)
1398 if (c
->theclass
== class_user
|| c
->theclass
== class_alias
)
1400 /* if C is a prefix command that was previously defined,
1401 tell the user its subcommands will be kept, and ask
1402 if ok to redefine the command. */
1403 if (c
->prefixlist
!= nullptr)
1404 q
= (c
->user_commands
.get () == nullptr
1405 || query (_("Keeping subcommands of prefix command \"%s\".\n"
1406 "Redefine command \"%s\"? "), c
->name
, c
->name
));
1408 q
= query (_("Redefine command \"%s\"? "), c
->name
);
1411 q
= query (_("Really redefine built-in command \"%s\"? "), c
->name
);
1413 error (_("Command \"%s\" not redefined."), c
->name
);
1416 /* If this new command is a hook, then mark the command which it
1417 is hooking. Note that we allow hooking `help' commands, so that
1418 we can hook the `stop' pseudo-command. */
1420 if (!strncmp (comname
, HOOK_STRING
, HOOK_LEN
))
1422 hook_type
= CMD_PRE_HOOK
;
1423 hook_name_size
= HOOK_LEN
;
1425 else if (!strncmp (comname
, HOOK_POST_STRING
, HOOK_POST_LEN
))
1427 hook_type
= CMD_POST_HOOK
;
1428 hook_name_size
= HOOK_POST_LEN
;
1431 if (hook_type
!= CMD_NO_HOOK
)
1433 /* Look up cmd it hooks, and verify that we got an exact match. */
1434 tem
= comname
+ hook_name_size
;
1435 hookc
= lookup_cmd (&tem
, *list
, "", -1, 0);
1436 if (hookc
&& strcmp (comname
+ hook_name_size
, hookc
->name
) != 0)
1438 if (!hookc
&& commands
== nullptr)
1440 warning (_("Your new `%s' command does not "
1441 "hook any existing command."),
1443 if (!query (_("Proceed? ")))
1444 error (_("Not confirmed."));
1448 comname
= xstrdup (comname
);
1450 counted_command_line cmds
;
1451 if (commands
== nullptr)
1454 = string_printf ("Type commands for definition of \"%s\".", comfull
);
1455 cmds
= read_command_lines (prompt
.c_str (), from_tty
, 1, 0);
1461 struct cmd_list_element
**c_prefixlist
1462 = c
== nullptr ? nullptr : c
->prefixlist
;
1463 const char *c_prefixname
= c
== nullptr ? nullptr : c
->prefixname
;
1465 newc
= add_cmd (comname
, class_user
, user_defined_command
,
1466 (c
!= nullptr && c
->theclass
== class_user
)
1467 ? c
->doc
: xstrdup ("User-defined."), list
);
1468 newc
->user_commands
= std::move (cmds
);
1470 /* If we define or re-define a command that was previously defined
1471 as a prefix, keep the prefix information. */
1472 if (c_prefixlist
!= nullptr)
1474 newc
->prefixlist
= c_prefixlist
;
1475 newc
->prefixname
= c_prefixname
;
1476 /* allow_unknown: see explanation in equivalent logic in
1477 define_prefix_command (). */
1478 newc
->allow_unknown
= newc
->user_commands
.get () != nullptr;
1482 /* If this new command is a hook, then mark both commands as being
1489 hookc
->hook_pre
= newc
; /* Target gets hooked. */
1490 newc
->hookee_pre
= hookc
; /* We are marked as hooking target cmd. */
1493 hookc
->hook_post
= newc
; /* Target gets hooked. */
1494 newc
->hookee_post
= hookc
; /* We are marked as hooking
1498 /* Should never come here as hookc would be 0. */
1499 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1505 define_command (const char *comname
, int from_tty
)
1507 do_define_command (comname
, from_tty
, nullptr);
1511 document_command (const char *comname
, int from_tty
)
1513 struct cmd_list_element
*c
, **list
;
1515 const char *comfull
;
1518 list
= validate_comname (&comname
);
1521 c
= lookup_cmd (&tem
, *list
, "", 0, 1);
1523 if (c
->theclass
!= class_user
)
1524 error (_("Command \"%s\" is built-in."), comfull
);
1526 std::string prompt
= string_printf ("Type documentation for \"%s\".",
1528 counted_command_line doclines
= read_command_lines (prompt
.c_str (),
1532 xfree ((char *) c
->doc
);
1535 struct command_line
*cl1
;
1539 for (cl1
= doclines
.get (); cl1
; cl1
= cl1
->next
)
1540 len
+= strlen (cl1
->line
) + 1;
1542 doc
= (char *) xmalloc (len
+ 1);
1545 for (cl1
= doclines
.get (); cl1
; cl1
= cl1
->next
)
1547 strcat (doc
, cl1
->line
);
1556 /* Implementation of the "define-prefix" command. */
1559 define_prefix_command (const char *comname
, int from_tty
)
1561 struct cmd_list_element
*c
, **list
;
1563 const char *comfull
;
1566 list
= validate_comname (&comname
);
1568 /* Look it up, and verify that we got an exact match. */
1570 c
= lookup_cmd (&tem
, *list
, "", -1, 1);
1571 if (c
!= nullptr && strcmp (comname
, c
->name
) != 0)
1574 if (c
!= nullptr && c
->theclass
!= class_user
)
1575 error (_("Command \"%s\" is built-in."), comfull
);
1577 if (c
!= nullptr && c
->prefixlist
!= nullptr)
1579 /* c is already a user defined prefix command. */
1583 /* If the command does not exist at all, create it. */
1586 comname
= xstrdup (comname
);
1587 c
= add_cmd (comname
, class_user
, user_defined_command
,
1588 xstrdup ("User-defined."), list
);
1591 /* Allocate the c->prefixlist, which marks the command as a prefix
1593 c
->prefixlist
= new struct cmd_list_element
*;
1594 *(c
->prefixlist
) = nullptr;
1595 c
->prefixname
= xstrprintf ("%s ", comfull
);
1596 /* If the prefix command C is not a command, then it must be followed
1597 by known subcommands. Otherwise, if C is also a normal command,
1598 it can be followed by C args that must not cause a 'subcommand'
1599 not recognised error, and thus we must allow unknown. */
1600 c
->allow_unknown
= c
->user_commands
.get () != nullptr;
1604 /* Used to implement source_command. */
1607 script_from_file (FILE *stream
, const char *file
)
1610 internal_error (__FILE__
, __LINE__
, _("called with NULL file pointer!"));
1612 scoped_restore restore_line_number
1613 = make_scoped_restore (&source_line_number
, 0);
1614 scoped_restore restore_file
1615 = make_scoped_restore
<std::string
, const std::string
&> (&source_file_name
,
1618 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
1622 read_command_file (stream
);
1624 catch (const gdb_exception_error
&e
)
1626 /* Re-throw the error, but with the file name information
1628 throw_error (e
.error
,
1629 _("%s:%d: Error in sourced command file:\n%s"),
1630 source_file_name
.c_str (), source_line_number
,
1635 /* Print the definition of user command C to STREAM. Or, if C is a
1636 prefix command, show the definitions of all user commands under C
1637 (recursively). PREFIX and NAME combined are the name of the
1640 show_user_1 (struct cmd_list_element
*c
, const char *prefix
, const char *name
,
1641 struct ui_file
*stream
)
1643 if (cli_user_command_p (c
))
1645 struct command_line
*cmdlines
= c
->user_commands
.get ();
1647 fprintf_filtered (stream
, "User %scommand \"",
1648 c
->prefixlist
== NULL
? "" : "prefix ");
1649 fprintf_styled (stream
, title_style
.style (), "%s%s",
1651 fprintf_filtered (stream
, "\":\n");
1654 print_command_lines (current_uiout
, cmdlines
, 1);
1655 fputs_filtered ("\n", stream
);
1659 if (c
->prefixlist
!= NULL
)
1661 const char *prefixname
= c
->prefixname
;
1663 for (c
= *c
->prefixlist
; c
!= NULL
; c
= c
->next
)
1664 if (c
->theclass
== class_user
|| c
->prefixlist
!= NULL
)
1665 show_user_1 (c
, prefixname
, c
->name
, gdb_stdout
);
1671 _initialize_cli_script (void)
1673 struct cmd_list_element
*c
;
1675 /* "document", "define" and "define-prefix" use command_completer,
1676 as this helps the user to either type the command name and/or
1678 c
= add_com ("document", class_support
, document_command
, _("\
1679 Document a user-defined command.\n\
1680 Give command name as argument. Give documentation on following lines.\n\
1681 End with a line of just \"end\"."));
1682 set_cmd_completer (c
, command_completer
);
1683 define_cmd_element
= add_com ("define", class_support
, define_command
, _("\
1684 Define a new command name. Command name is argument.\n\
1685 Definition appears on following lines, one command per line.\n\
1686 End with a line of just \"end\".\n\
1687 Use the \"document\" command to give documentation for the new command.\n\
1688 Commands defined in this way may accept an unlimited number of arguments\n\
1689 accessed via $arg0 .. $argN. $argc tells how many arguments have\n\
1691 set_cmd_completer (define_cmd_element
, command_completer
);
1692 c
= add_com ("define-prefix", class_support
, define_prefix_command
,
1694 Define or mark a command as a user-defined prefix command.\n\
1695 User defined prefix commands can be used as prefix commands for\n\
1696 other user defined commands.\n\
1697 If the command already exists, it is changed to a prefix command."));
1698 set_cmd_completer (c
, command_completer
);
1700 while_cmd_element
= add_com ("while", class_support
, while_command
, _("\
1701 Execute nested commands WHILE the conditional expression is non zero.\n\
1702 The conditional expression must follow the word `while' and must in turn be\n\
1703 followed by a new line. The nested commands must be entered one per line,\n\
1704 and should be terminated by the word `end'."));
1706 if_cmd_element
= add_com ("if", class_support
, if_command
, _("\
1707 Execute nested commands once IF the conditional expression is non zero.\n\
1708 The conditional expression must follow the word `if' and must in turn be\n\
1709 followed by a new line. The nested commands must be entered one per line,\n\
1710 and should be terminated by the word 'else' or `end'. If an else clause\n\
1711 is used, the same rules apply to its nested commands as to the first ones."));