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"
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 const char *read_next_line ();
55 /* Level of control structure when reading. */
56 static int control_level
;
58 /* Level of control structure when executing. */
59 static int command_nest_depth
= 1;
61 /* This is to prevent certain commands being printed twice. */
62 static int suppress_next_print_command_trace
= 0;
64 /* Command element for the 'while' command. */
65 static cmd_list_element
*while_cmd_element
= nullptr;
67 /* Command element for the 'if' command. */
68 static cmd_list_element
*if_cmd_element
= nullptr;
70 /* Command element for the 'define' command. */
71 static cmd_list_element
*define_cmd_element
= nullptr;
73 /* Structure for arguments to user defined functions. */
78 /* Save the command line and store the locations of arguments passed
79 to the user defined function. */
80 explicit user_args (const char *line
);
82 /* Insert the stored user defined arguments into the $arg arguments
84 std::string
insert_args (const char *line
) const;
87 /* Disable copy/assignment. (Since the elements of A point inside
88 COMMAND, copying would need to reconstruct the A vector in the
90 user_args (const user_args
&) =delete;
91 user_args
&operator= (const user_args
&) =delete;
93 /* It is necessary to store a copy of the command line to ensure
94 that the arguments are not overwritten before they are used. */
95 std::string m_command_line
;
97 /* The arguments. Each element points inside M_COMMAND_LINE. */
98 std::vector
<gdb::string_view
> m_args
;
101 /* The stack of arguments passed to user defined functions. We need a
102 stack because user-defined functions can call other user-defined
104 static std::vector
<std::unique_ptr
<user_args
>> user_args_stack
;
106 /* An RAII-base class used to push/pop args on the user args
108 struct scoped_user_args_level
110 /* Parse the command line and push the arguments in the user args
112 explicit scoped_user_args_level (const char *line
)
114 user_args_stack
.emplace_back (new user_args (line
));
117 /* Pop the current user arguments from the stack. */
118 ~scoped_user_args_level ()
120 user_args_stack
.pop_back ();
125 /* Return non-zero if TYPE is a multi-line command (i.e., is terminated
129 multi_line_command_p (enum command_control_type type
)
135 case while_stepping_control
:
136 case commands_control
:
137 case compile_control
:
147 /* Allocate, initialize a new command line structure for one of the
148 control commands (if/while). */
150 static struct command_line
*
151 build_command_line (enum command_control_type type
, const char *args
)
153 if (args
== NULL
|| *args
== '\0')
155 if (type
== if_control
)
156 error (_("if command requires an argument."));
157 else if (type
== while_control
)
158 error (_("while command requires an argument."));
159 else if (type
== define_control
)
160 error (_("define command requires an argument."));
162 gdb_assert (args
!= NULL
);
164 return new struct command_line (type
, xstrdup (args
));
167 /* Build and return a new command structure for the control commands
168 such as "if" and "while". */
171 get_command_line (enum command_control_type type
, const char *arg
)
173 /* Allocate and build a new command line structure. */
174 counted_command_line
cmd (build_command_line (type
, arg
),
175 command_lines_deleter ());
177 /* Read in the body of this command. */
178 if (recurse_read_control_structure (read_next_line
, cmd
.get (), 0)
181 warning (_("Error reading in canned sequence of commands."));
188 /* Recursively print a command (including full control structures). */
191 print_command_lines (struct ui_out
*uiout
, struct command_line
*cmd
,
194 struct command_line
*list
;
200 uiout
->spaces (2 * depth
);
202 /* A simple command, print it and continue. */
203 if (list
->control_type
== simple_control
)
205 uiout
->field_string (NULL
, list
->line
);
211 /* loop_continue to jump to the start of a while loop, print it
213 if (list
->control_type
== continue_control
)
215 uiout
->field_string (NULL
, "loop_continue");
221 /* loop_break to break out of a while loop, print it and
223 if (list
->control_type
== break_control
)
225 uiout
->field_string (NULL
, "loop_break");
231 /* A while command. Recursively print its subcommands and
233 if (list
->control_type
== while_control
234 || list
->control_type
== while_stepping_control
)
236 /* For while-stepping, the line includes the 'while-stepping'
237 token. See comment in process_next_line for explanation.
238 Here, take care not print 'while-stepping' twice. */
239 if (list
->control_type
== while_control
)
240 uiout
->field_fmt (NULL
, "while %s", list
->line
);
242 uiout
->field_string (NULL
, list
->line
);
244 print_command_lines (uiout
, list
->body_list_0
.get (), depth
+ 1);
246 uiout
->spaces (2 * depth
);
247 uiout
->field_string (NULL
, "end");
253 /* An if command. Recursively print both arms before
255 if (list
->control_type
== if_control
)
257 uiout
->field_fmt (NULL
, "if %s", list
->line
);
260 print_command_lines (uiout
, list
->body_list_0
.get (), depth
+ 1);
262 /* Show the false arm if it exists. */
263 if (list
->body_list_1
!= nullptr)
266 uiout
->spaces (2 * depth
);
267 uiout
->field_string (NULL
, "else");
269 print_command_lines (uiout
, list
->body_list_1
.get (), depth
+ 1);
273 uiout
->spaces (2 * depth
);
274 uiout
->field_string (NULL
, "end");
280 /* A commands command. Print the breakpoint commands and
282 if (list
->control_type
== commands_control
)
285 uiout
->field_fmt (NULL
, "commands %s", list
->line
);
287 uiout
->field_string (NULL
, "commands");
289 print_command_lines (uiout
, list
->body_list_0
.get (), depth
+ 1);
291 uiout
->spaces (2 * depth
);
292 uiout
->field_string (NULL
, "end");
298 if (list
->control_type
== python_control
)
300 uiout
->field_string (NULL
, "python");
302 /* Don't indent python code at all. */
303 print_command_lines (uiout
, list
->body_list_0
.get (), 0);
305 uiout
->spaces (2 * depth
);
306 uiout
->field_string (NULL
, "end");
312 if (list
->control_type
== compile_control
)
314 uiout
->field_string (NULL
, "compile expression");
316 print_command_lines (uiout
, list
->body_list_0
.get (), 0);
318 uiout
->spaces (2 * depth
);
319 uiout
->field_string (NULL
, "end");
325 if (list
->control_type
== guile_control
)
327 uiout
->field_string (NULL
, "guile");
329 print_command_lines (uiout
, list
->body_list_0
.get (), depth
+ 1);
331 uiout
->spaces (2 * depth
);
332 uiout
->field_string (NULL
, "end");
338 /* Ignore illegal command type and try next. */
343 /* Handle pre-post hooks. */
345 class scoped_restore_hook_in
349 scoped_restore_hook_in (struct cmd_list_element
*c
)
354 ~scoped_restore_hook_in ()
359 scoped_restore_hook_in (const scoped_restore_hook_in
&) = delete;
360 scoped_restore_hook_in
&operator= (const scoped_restore_hook_in
&) = delete;
364 struct cmd_list_element
*m_cmd
;
368 execute_cmd_pre_hook (struct cmd_list_element
*c
)
370 if ((c
->hook_pre
) && (!c
->hook_in
))
372 scoped_restore_hook_in
restore_hook (c
);
373 c
->hook_in
= 1; /* Prevent recursive hooking. */
374 execute_user_command (c
->hook_pre
, nullptr);
379 execute_cmd_post_hook (struct cmd_list_element
*c
)
381 if ((c
->hook_post
) && (!c
->hook_in
))
383 scoped_restore_hook_in
restore_hook (c
);
384 c
->hook_in
= 1; /* Prevent recursive hooking. */
385 execute_user_command (c
->hook_post
, nullptr);
389 /* See cli-script.h. */
392 execute_control_commands (struct command_line
*cmdlines
, int from_tty
)
394 /* Set the instream to 0, indicating execution of a
395 user-defined function. */
396 scoped_restore restore_instream
397 = make_scoped_restore (¤t_ui
->instream
, nullptr);
398 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
399 scoped_restore save_nesting
400 = make_scoped_restore (&command_nest_depth
, command_nest_depth
+ 1);
404 enum command_control_type ret
= execute_control_command (cmdlines
,
406 if (ret
!= simple_control
&& ret
!= break_control
)
408 warning (_("Error executing canned sequence of commands."));
411 cmdlines
= cmdlines
->next
;
415 /* See cli-script.h. */
418 execute_control_commands_to_string (struct command_line
*commands
,
421 /* GDB_STDOUT should be better already restored during these
422 restoration callbacks. */
423 set_batch_flag_and_restore_page_info save_page_info
;
425 string_file str_file
;
428 current_uiout
->redirect (&str_file
);
429 ui_out_redirect_pop
redirect_popper (current_uiout
);
431 scoped_restore save_stdout
432 = make_scoped_restore (&gdb_stdout
, &str_file
);
433 scoped_restore save_stderr
434 = make_scoped_restore (&gdb_stderr
, &str_file
);
435 scoped_restore save_stdlog
436 = make_scoped_restore (&gdb_stdlog
, &str_file
);
437 scoped_restore save_stdtarg
438 = make_scoped_restore (&gdb_stdtarg
, &str_file
);
439 scoped_restore save_stdtargerr
440 = make_scoped_restore (&gdb_stdtargerr
, &str_file
);
442 execute_control_commands (commands
, from_tty
);
445 return std::move (str_file
.string ());
449 execute_user_command (struct cmd_list_element
*c
, const char *args
)
451 counted_command_line cmdlines_copy
;
453 /* Ensure that the user commands can't be deleted while they are
455 cmdlines_copy
= c
->user_commands
;
456 if (cmdlines_copy
== 0)
459 struct command_line
*cmdlines
= cmdlines_copy
.get ();
461 scoped_user_args_level
push_user_args (args
);
463 if (user_args_stack
.size () > max_user_call_depth
)
464 error (_("Max user call depth exceeded -- command aborted."));
466 execute_control_commands (cmdlines
, 0);
469 /* This function is called every time GDB prints a prompt. It ensures
470 that errors and the like do not confuse the command tracing. */
473 reset_command_nest_depth (void)
475 command_nest_depth
= 1;
478 suppress_next_print_command_trace
= 0;
481 /* Print the command, prefixed with '+' to represent the call depth.
482 This is slightly complicated because this function may be called
483 from execute_command and execute_control_command. Unfortunately
484 execute_command also prints the top level control commands.
485 In these cases execute_command will call execute_control_command
486 via while_command or if_command. Inner levels of 'if' and 'while'
487 are dealt with directly. Therefore we can use these functions
488 to determine whether the command has been printed already or not. */
489 ATTRIBUTE_PRINTF (1, 2)
491 print_command_trace (const char *fmt
, ...)
495 if (suppress_next_print_command_trace
)
497 suppress_next_print_command_trace
= 0;
501 if (!source_verbose
&& !trace_commands
)
504 for (i
=0; i
< command_nest_depth
; i
++)
505 printf_filtered ("+");
509 va_start (args
, fmt
);
510 vprintf_filtered (fmt
, args
);
512 puts_filtered ("\n");
515 /* Helper for execute_control_command. */
517 static enum command_control_type
518 execute_control_command_1 (struct command_line
*cmd
, int from_tty
)
520 struct command_line
*current
;
522 struct value
*val_mark
;
524 enum command_control_type ret
;
526 /* Start by assuming failure, if a problem is detected, the code
527 below will simply "break" out of the switch. */
528 ret
= invalid_control
;
530 switch (cmd
->control_type
)
534 /* A simple command, execute it and return. */
535 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
536 execute_command (new_line
.c_str (), from_tty
);
537 ret
= cmd
->control_type
;
541 case continue_control
:
542 print_command_trace ("loop_continue");
544 /* Return for "continue", and "break" so we can either
545 continue the loop at the top, or break out. */
546 ret
= cmd
->control_type
;
550 print_command_trace ("loop_break");
552 /* Return for "continue", and "break" so we can either
553 continue the loop at the top, or break out. */
554 ret
= cmd
->control_type
;
559 print_command_trace ("while %s", cmd
->line
);
561 /* Parse the loop control expression for the while statement. */
562 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
563 expression_up expr
= parse_expression (new_line
.c_str ());
565 ret
= simple_control
;
568 /* Keep iterating so long as the expression is true. */
575 /* Evaluate the expression. */
576 val_mark
= value_mark ();
577 val
= evaluate_expression (expr
.get ());
578 cond_result
= value_true (val
);
579 value_free_to_mark (val_mark
);
581 /* If the value is false, then break out of the loop. */
585 /* Execute the body of the while statement. */
586 current
= cmd
->body_list_0
.get ();
589 scoped_restore save_nesting
590 = make_scoped_restore (&command_nest_depth
, command_nest_depth
+ 1);
591 ret
= execute_control_command_1 (current
, from_tty
);
593 /* If we got an error, or a "break" command, then stop
595 if (ret
== invalid_control
|| ret
== break_control
)
601 /* If we got a "continue" command, then restart the loop
603 if (ret
== continue_control
)
606 /* Get the next statement. */
607 current
= current
->next
;
611 /* Reset RET so that we don't recurse the break all the way down. */
612 if (ret
== break_control
)
613 ret
= simple_control
;
620 print_command_trace ("if %s", cmd
->line
);
622 /* Parse the conditional for the if statement. */
623 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
624 expression_up expr
= parse_expression (new_line
.c_str ());
627 ret
= simple_control
;
629 /* Evaluate the conditional. */
630 val_mark
= value_mark ();
631 val
= evaluate_expression (expr
.get ());
633 /* Choose which arm to take commands from based on the value
634 of the conditional expression. */
635 if (value_true (val
))
636 current
= cmd
->body_list_0
.get ();
637 else if (cmd
->body_list_1
!= nullptr)
638 current
= cmd
->body_list_1
.get ();
639 value_free_to_mark (val_mark
);
641 /* Execute commands in the given arm. */
644 scoped_restore save_nesting
645 = make_scoped_restore (&command_nest_depth
, command_nest_depth
+ 1);
646 ret
= execute_control_command_1 (current
, from_tty
);
648 /* If we got an error, get out. */
649 if (ret
!= simple_control
)
652 /* Get the next statement in the body. */
653 current
= current
->next
;
659 case commands_control
:
661 /* Breakpoint commands list, record the commands in the
662 breakpoint's command list and return. */
663 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
664 ret
= commands_from_control_command (new_line
.c_str (), cmd
);
668 case compile_control
:
669 eval_compile_command (cmd
, NULL
, cmd
->control_u
.compile
.scope
,
670 cmd
->control_u
.compile
.scope_data
);
671 ret
= simple_control
;
675 print_command_trace ("define %s", cmd
->line
);
676 do_define_command (cmd
->line
, 0, &cmd
->body_list_0
);
677 ret
= simple_control
;
683 eval_ext_lang_from_control_command (cmd
);
684 ret
= simple_control
;
689 warning (_("Invalid control type in canned commands structure."));
696 enum command_control_type
697 execute_control_command (struct command_line
*cmd
, int from_tty
)
699 if (!current_uiout
->is_mi_like_p ())
700 return execute_control_command_1 (cmd
, from_tty
);
702 /* Make sure we use the console uiout. It's possible that we are executing
703 breakpoint commands while running the MI interpreter. */
704 interp
*console
= interp_lookup (current_ui
, INTERP_CONSOLE
);
705 scoped_restore save_uiout
706 = make_scoped_restore (¤t_uiout
, console
->interp_ui_out ());
708 return execute_control_command_1 (cmd
, from_tty
);
711 /* Like execute_control_command, but first set
712 suppress_next_print_command_trace. */
714 enum command_control_type
715 execute_control_command_untraced (struct command_line
*cmd
)
717 suppress_next_print_command_trace
= 1;
718 return execute_control_command (cmd
);
722 /* "while" command support. Executes a body of statements while the
723 loop condition is nonzero. */
726 while_command (const char *arg
, int from_tty
)
729 counted_command_line command
= get_command_line (while_control
, arg
);
734 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
736 execute_control_command_untraced (command
.get ());
739 /* "if" command support. Execute either the true or false arm depending
740 on the value of the if conditional. */
743 if_command (const char *arg
, int from_tty
)
746 counted_command_line command
= get_command_line (if_control
, arg
);
751 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
753 execute_control_command_untraced (command
.get ());
756 /* Bind the incoming arguments for a user defined command to $arg0,
759 user_args::user_args (const char *command_line
)
763 if (command_line
== NULL
)
766 m_command_line
= command_line
;
767 p
= m_command_line
.c_str ();
771 const char *start_arg
;
776 /* Strip whitespace. */
777 while (*p
== ' ' || *p
== '\t')
780 /* P now points to an argument. */
783 /* Get to the end of this argument. */
786 if (((*p
== ' ' || *p
== '\t')) && !squote
&& !dquote
&& !bsquote
)
815 m_args
.emplace_back (start_arg
, p
- start_arg
);
819 /* Given character string P, return a point to the first argument
820 ($arg), or NULL if P contains no arguments. */
823 locate_arg (const char *p
)
825 while ((p
= strchr (p
, '$')))
827 if (startswith (p
, "$arg")
828 && (isdigit (p
[4]) || p
[4] == 'c'))
835 /* See cli-script.h. */
838 insert_user_defined_cmd_args (const char *line
)
840 /* If we are not in a user-defined command, treat $argc, $arg0, et
841 cetera as normal convenience variables. */
842 if (user_args_stack
.empty ())
845 const std::unique_ptr
<user_args
> &args
= user_args_stack
.back ();
846 return args
->insert_args (line
);
849 /* Insert the user defined arguments stored in user_args into the $arg
850 arguments found in line. */
853 user_args::insert_args (const char *line
) const
855 std::string new_line
;
858 while ((p
= locate_arg (line
)))
860 new_line
.append (line
, p
- line
);
864 new_line
+= std::to_string (m_args
.size ());
873 i
= strtoul (p
+ 4, &tmp
, 10);
874 if ((i
== 0 && tmp
== p
+ 4) || errno
!= 0)
876 else if (i
>= m_args
.size ())
877 error (_("Missing argument %ld in user function."), i
);
880 new_line
.append (m_args
[i
].data (), m_args
[i
].length ());
885 /* Don't forget the tail. */
886 new_line
.append (line
);
892 /* Read next line from stdin. Passed to read_command_line_1 and
893 recurse_read_control_structure whenever we need to read commands
899 struct ui
*ui
= current_ui
;
900 char *prompt_ptr
, control_prompt
[256];
902 int from_tty
= ui
->instream
== ui
->stdin_stream
;
904 if (control_level
>= 254)
905 error (_("Control nesting too deep!"));
907 /* Set a prompt based on the nesting of the control commands. */
909 || (ui
->instream
== 0 && deprecated_readline_hook
!= NULL
))
911 for (i
= 0; i
< control_level
; i
++)
912 control_prompt
[i
] = ' ';
913 control_prompt
[i
] = '>';
914 control_prompt
[i
+ 1] = '\0';
915 prompt_ptr
= (char *) &control_prompt
[0];
920 return command_line_input (prompt_ptr
, "commands");
923 /* Given an input line P, skip the command and return a pointer to the
927 line_first_arg (const char *p
)
929 const char *first_arg
= p
+ find_command_name_length (p
);
931 return skip_spaces (first_arg
);
934 /* Process one input line. If the command is an "end", return such an
935 indication to the caller. If PARSE_COMMANDS is true, strip leading
936 whitespace (trailing whitespace is always stripped) in the line,
937 attempt to recognize GDB control commands, and also return an
938 indication if the command is an "else" or a nop.
940 Otherwise, only "end" is recognized. */
942 static enum misc_command_type
943 process_next_line (const char *p
, struct command_line
**command
,
945 gdb::function_view
<void (const char *)> validator
)
952 /* Not sure what to do here. */
956 /* Strip trailing whitespace. */
957 p_end
= p
+ strlen (p
);
958 while (p_end
> p
&& (p_end
[-1] == ' ' || p_end
[-1] == '\t'))
962 /* Strip leading whitespace. */
963 while (p_start
< p_end
&& (*p_start
== ' ' || *p_start
== '\t'))
966 /* 'end' is always recognized, regardless of parse_commands value.
967 We also permit whitespace before end and after. */
968 if (p_end
- p_start
== 3 && startswith (p_start
, "end"))
973 /* Resolve command abbreviations (e.g. 'ws' for 'while-stepping'). */
974 const char *cmd_name
= p
;
975 struct cmd_list_element
*cmd
976 = lookup_cmd_1 (&cmd_name
, cmdlist
, NULL
, 1);
977 cmd_name
= skip_spaces (cmd_name
);
978 bool inline_cmd
= *cmd_name
!= '\0';
980 /* If commands are parsed, we skip initial spaces. Otherwise,
981 which is the case for Python commands and documentation
982 (see the 'document' command), spaces are preserved. */
985 /* Blanks and comments don't really do anything, but we need to
986 distinguish them from else, end and other commands which can
988 if (p_end
== p
|| p
[0] == '#')
991 /* Is the else clause of an if control structure? */
992 if (p_end
- p
== 4 && startswith (p
, "else"))
995 /* Check for while, if, break, continue, etc and build a new
996 command line structure for them. */
997 if (cmd
== while_stepping_cmd_element
)
999 /* Because validate_actionline and encode_action lookup
1000 command's line as command, we need the line to
1001 include 'while-stepping'.
1003 For 'ws' alias, the command will have 'ws', not expanded
1004 to 'while-stepping'. This is intentional -- we don't
1005 really want frontend to send a command list with 'ws',
1006 and next break-info returning command line with
1007 'while-stepping'. This should work, but might cause the
1008 breakpoint to be marked as changed while it's actually
1010 *command
= build_command_line (while_stepping_control
, p
);
1012 else if (cmd
== while_cmd_element
)
1013 *command
= build_command_line (while_control
, line_first_arg (p
));
1014 else if (cmd
== if_cmd_element
)
1015 *command
= build_command_line (if_control
, line_first_arg (p
));
1016 else if (cmd
== commands_cmd_element
)
1017 *command
= build_command_line (commands_control
, line_first_arg (p
));
1018 else if (cmd
== define_cmd_element
)
1019 *command
= build_command_line (define_control
, line_first_arg (p
));
1020 else if (cmd
== python_cmd_element
&& !inline_cmd
)
1022 /* Note that we ignore the inline "python command" form
1024 *command
= build_command_line (python_control
, "");
1026 else if (cmd
== compile_cmd_element
&& !inline_cmd
)
1028 /* Note that we ignore the inline "compile command" form
1030 *command
= build_command_line (compile_control
, "");
1031 (*command
)->control_u
.compile
.scope
= COMPILE_I_INVALID_SCOPE
;
1033 else if (cmd
== guile_cmd_element
&& !inline_cmd
)
1035 /* Note that we ignore the inline "guile command" form here. */
1036 *command
= build_command_line (guile_control
, "");
1038 else if (p_end
- p
== 10 && startswith (p
, "loop_break"))
1039 *command
= new struct command_line (break_control
);
1040 else if (p_end
- p
== 13 && startswith (p
, "loop_continue"))
1041 *command
= new struct command_line (continue_control
);
1046 if (!parse_commands
|| not_handled
)
1048 /* A normal command. */
1049 *command
= new struct command_line (simple_control
,
1050 savestring (p
, p_end
- p
));
1057 validator ((*command
)->line
);
1059 catch (const gdb_exception
&ex
)
1061 free_command_lines (command
);
1066 /* Nothing special. */
1070 /* Recursively read in the control structures and create a
1071 command_line structure from them. Use read_next_line_func to
1072 obtain lines of the command. */
1074 static enum command_control_type
1075 recurse_read_control_structure (gdb::function_view
<const char * ()> read_next_line_func
,
1076 struct command_line
*current_cmd
,
1077 gdb::function_view
<void (const char *)> validator
)
1079 enum misc_command_type val
;
1080 enum command_control_type ret
;
1081 struct command_line
*child_tail
, *next
;
1082 counted_command_line
*current_body
= ¤t_cmd
->body_list_0
;
1086 /* Sanity checks. */
1087 if (current_cmd
->control_type
== simple_control
)
1088 error (_("Recursed on a simple control type."));
1090 /* Read lines from the input stream and build control structures. */
1096 val
= process_next_line (read_next_line_func (), &next
,
1097 current_cmd
->control_type
!= python_control
1098 && current_cmd
->control_type
!= guile_control
1099 && current_cmd
->control_type
!= compile_control
,
1102 /* Just skip blanks and comments. */
1103 if (val
== nop_command
)
1106 if (val
== end_command
)
1108 if (multi_line_command_p (current_cmd
->control_type
))
1110 /* Success reading an entire canned sequence of commands. */
1111 ret
= simple_control
;
1116 ret
= invalid_control
;
1121 /* Not the end of a control structure. */
1122 if (val
== else_command
)
1124 if (current_cmd
->control_type
== if_control
1125 && current_body
== ¤t_cmd
->body_list_0
)
1127 current_body
= ¤t_cmd
->body_list_1
;
1133 ret
= invalid_control
;
1140 child_tail
->next
= next
;
1143 *current_body
= counted_command_line (next
, command_lines_deleter ());
1147 /* If the latest line is another control structure, then recurse
1149 if (multi_line_command_p (next
->control_type
))
1152 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1156 if (ret
!= simple_control
)
1166 /* Read lines from the input stream and accumulate them in a chain of
1167 struct command_line's, which is then returned. For input from a
1168 terminal, the special command "end" is used to mark the end of the
1169 input, and is not included in the returned chain of commands.
1171 If PARSE_COMMANDS is true, strip leading whitespace (trailing whitespace
1172 is always stripped) in the line and attempt to recognize GDB control
1173 commands. Otherwise, only "end" is recognized. */
1175 #define END_MESSAGE "End with a line saying just \"end\"."
1177 counted_command_line
1178 read_command_lines (const char *prompt_arg
, int from_tty
, int parse_commands
,
1179 gdb::function_view
<void (const char *)> validator
)
1181 if (from_tty
&& input_interactive_p (current_ui
))
1183 if (deprecated_readline_begin_hook
)
1185 /* Note - intentional to merge messages with no newline. */
1186 (*deprecated_readline_begin_hook
) ("%s %s\n", prompt_arg
,
1190 printf_unfiltered ("%s\n%s\n", prompt_arg
, END_MESSAGE
);
1194 /* Reading commands assumes the CLI behavior, so temporarily
1195 override the current interpreter with CLI. */
1196 counted_command_line
head (nullptr, command_lines_deleter ());
1197 if (current_interp_named_p (INTERP_CONSOLE
))
1198 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1202 scoped_restore_interp
interp_restorer (INTERP_CONSOLE
);
1204 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1208 if (from_tty
&& input_interactive_p (current_ui
)
1209 && deprecated_readline_end_hook
)
1211 (*deprecated_readline_end_hook
) ();
1216 /* Act the same way as read_command_lines, except that each new line is
1217 obtained using READ_NEXT_LINE_FUNC. */
1219 counted_command_line
1220 read_command_lines_1 (gdb::function_view
<const char * ()> read_next_line_func
,
1222 gdb::function_view
<void (const char *)> validator
)
1224 struct command_line
*tail
, *next
;
1225 counted_command_line
head (nullptr, command_lines_deleter ());
1226 enum command_control_type ret
;
1227 enum misc_command_type val
;
1235 val
= process_next_line (read_next_line_func (), &next
, parse_commands
,
1238 /* Ignore blank lines or comments. */
1239 if (val
== nop_command
)
1242 if (val
== end_command
)
1244 ret
= simple_control
;
1248 if (val
!= ok_command
)
1250 ret
= invalid_control
;
1254 if (multi_line_command_p (next
->control_type
))
1257 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1261 if (ret
== invalid_control
)
1271 head
= counted_command_line (next
, command_lines_deleter ());
1278 if (ret
== invalid_control
)
1284 /* Free a chain of struct command_line's. */
1287 free_command_lines (struct command_line
**lptr
)
1289 struct command_line
*l
= *lptr
;
1290 struct command_line
*next
;
1301 /* Validate that *COMNAME is a valid name for a command. Return the
1302 containing command list, in case it starts with a prefix command.
1303 The prefix must already exist. *COMNAME is advanced to point after
1304 any prefix, and a NUL character overwrites the space after the
1307 static struct cmd_list_element
**
1308 validate_comname (const char **comname
)
1310 struct cmd_list_element
**list
= &cmdlist
;
1311 const char *p
, *last_word
;
1314 error_no_arg (_("name of command to define"));
1316 /* Find the last word of the argument. */
1317 p
= *comname
+ strlen (*comname
);
1318 while (p
> *comname
&& isspace (p
[-1]))
1320 while (p
> *comname
&& !isspace (p
[-1]))
1324 /* Find the corresponding command list. */
1325 if (last_word
!= *comname
)
1327 struct cmd_list_element
*c
;
1329 /* Separate the prefix and the command. */
1330 std::string
prefix (*comname
, last_word
- 1);
1331 const char *tem
= prefix
.c_str ();
1333 c
= lookup_cmd (&tem
, cmdlist
, "", 0, 1);
1334 if (c
->prefixlist
== NULL
)
1335 error (_("\"%s\" is not a prefix command."), prefix
.c_str ());
1337 list
= c
->prefixlist
;
1338 *comname
= last_word
;
1344 if (!isalnum (*p
) && *p
!= '-' && *p
!= '_')
1345 error (_("Junk in argument list: \"%s\""), p
);
1352 /* This is just a placeholder in the command data structures. */
1354 user_defined_command (const char *ignore
, int from_tty
)
1358 /* Define a user-defined command. If COMMANDS is NULL, then this is a
1359 top-level call and the commands will be read using
1360 read_command_lines. Otherwise, it is a "define" command in an
1361 existing command and the commands are provided. In the
1362 non-top-level case, various prompts and warnings are disabled. */
1365 do_define_command (const char *comname
, int from_tty
,
1366 const counted_command_line
*commands
)
1374 struct cmd_list_element
*c
, *newc
, *hookc
= 0, **list
;
1375 const char *tem
, *comfull
;
1376 int hook_type
= CMD_NO_HOOK
;
1377 int hook_name_size
= 0;
1379 #define HOOK_STRING "hook-"
1381 #define HOOK_POST_STRING "hookpost-"
1382 #define HOOK_POST_LEN 9
1385 list
= validate_comname (&comname
);
1387 /* Look it up, and verify that we got an exact match. */
1389 c
= lookup_cmd (&tem
, *list
, "", -1, 1);
1390 if (c
&& strcmp (comname
, c
->name
) != 0)
1393 if (c
&& commands
== nullptr)
1397 if (c
->theclass
== class_user
|| c
->theclass
== class_alias
)
1398 q
= query (_("Redefine command \"%s\"? "), c
->name
);
1400 q
= query (_("Really redefine built-in command \"%s\"? "), c
->name
);
1402 error (_("Command \"%s\" not redefined."), c
->name
);
1405 /* If this new command is a hook, then mark the command which it
1406 is hooking. Note that we allow hooking `help' commands, so that
1407 we can hook the `stop' pseudo-command. */
1409 if (!strncmp (comname
, HOOK_STRING
, HOOK_LEN
))
1411 hook_type
= CMD_PRE_HOOK
;
1412 hook_name_size
= HOOK_LEN
;
1414 else if (!strncmp (comname
, HOOK_POST_STRING
, HOOK_POST_LEN
))
1416 hook_type
= CMD_POST_HOOK
;
1417 hook_name_size
= HOOK_POST_LEN
;
1420 if (hook_type
!= CMD_NO_HOOK
)
1422 /* Look up cmd it hooks, and verify that we got an exact match. */
1423 tem
= comname
+ hook_name_size
;
1424 hookc
= lookup_cmd (&tem
, *list
, "", -1, 0);
1425 if (hookc
&& strcmp (comname
+ hook_name_size
, hookc
->name
) != 0)
1427 if (!hookc
&& commands
== nullptr)
1429 warning (_("Your new `%s' command does not "
1430 "hook any existing command."),
1432 if (!query (_("Proceed? ")))
1433 error (_("Not confirmed."));
1437 comname
= xstrdup (comname
);
1439 counted_command_line cmds
;
1440 if (commands
== nullptr)
1443 = string_printf ("Type commands for definition of \"%s\".", comfull
);
1444 cmds
= read_command_lines (prompt
.c_str (), from_tty
, 1, 0);
1449 newc
= add_cmd (comname
, class_user
, user_defined_command
,
1450 (c
&& c
->theclass
== class_user
)
1451 ? c
->doc
: xstrdup ("User-defined."), list
);
1452 newc
->user_commands
= std::move (cmds
);
1454 /* If this new command is a hook, then mark both commands as being
1461 hookc
->hook_pre
= newc
; /* Target gets hooked. */
1462 newc
->hookee_pre
= hookc
; /* We are marked as hooking target cmd. */
1465 hookc
->hook_post
= newc
; /* Target gets hooked. */
1466 newc
->hookee_post
= hookc
; /* We are marked as hooking
1470 /* Should never come here as hookc would be 0. */
1471 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1477 define_command (const char *comname
, int from_tty
)
1479 do_define_command (comname
, from_tty
, nullptr);
1483 document_command (const char *comname
, int from_tty
)
1485 struct cmd_list_element
*c
, **list
;
1487 const char *comfull
;
1490 list
= validate_comname (&comname
);
1493 c
= lookup_cmd (&tem
, *list
, "", 0, 1);
1495 if (c
->theclass
!= class_user
)
1496 error (_("Command \"%s\" is built-in."), comfull
);
1498 std::string prompt
= string_printf ("Type documentation for \"%s\".",
1500 counted_command_line doclines
= read_command_lines (prompt
.c_str (),
1504 xfree ((char *) c
->doc
);
1507 struct command_line
*cl1
;
1511 for (cl1
= doclines
.get (); cl1
; cl1
= cl1
->next
)
1512 len
+= strlen (cl1
->line
) + 1;
1514 doc
= (char *) xmalloc (len
+ 1);
1517 for (cl1
= doclines
.get (); cl1
; cl1
= cl1
->next
)
1519 strcat (doc
, cl1
->line
);
1528 /* Used to implement source_command. */
1531 script_from_file (FILE *stream
, const char *file
)
1534 internal_error (__FILE__
, __LINE__
, _("called with NULL file pointer!"));
1536 scoped_restore restore_line_number
1537 = make_scoped_restore (&source_line_number
, 0);
1538 scoped_restore restore_file
1539 = make_scoped_restore
<std::string
, const std::string
&> (&source_file_name
,
1542 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
1546 read_command_file (stream
);
1548 catch (const gdb_exception_error
&e
)
1550 /* Re-throw the error, but with the file name information
1552 throw_error (e
.error
,
1553 _("%s:%d: Error in sourced command file:\n%s"),
1554 source_file_name
.c_str (), source_line_number
,
1559 /* Print the definition of user command C to STREAM. Or, if C is a
1560 prefix command, show the definitions of all user commands under C
1561 (recursively). PREFIX and NAME combined are the name of the
1564 show_user_1 (struct cmd_list_element
*c
, const char *prefix
, const char *name
,
1565 struct ui_file
*stream
)
1567 struct command_line
*cmdlines
;
1569 if (c
->prefixlist
!= NULL
)
1571 const char *prefixname
= c
->prefixname
;
1573 for (c
= *c
->prefixlist
; c
!= NULL
; c
= c
->next
)
1574 if (c
->theclass
== class_user
|| c
->prefixlist
!= NULL
)
1575 show_user_1 (c
, prefixname
, c
->name
, gdb_stdout
);
1579 cmdlines
= c
->user_commands
.get ();
1580 fprintf_filtered (stream
, "User command \"%s%s\":\n", prefix
, name
);
1584 print_command_lines (current_uiout
, cmdlines
, 1);
1585 fputs_filtered ("\n", stream
);
1589 _initialize_cli_script (void)
1591 add_com ("document", class_support
, document_command
, _("\
1592 Document a user-defined command.\n\
1593 Give command name as argument. Give documentation on following lines.\n\
1594 End with a line of just \"end\"."));
1595 define_cmd_element
= add_com ("define", class_support
, define_command
, _("\
1596 Define a new command name. Command name is argument.\n\
1597 Definition appears on following lines, one command per line.\n\
1598 End with a line of just \"end\".\n\
1599 Use the \"document\" command to give documentation for the new command.\n\
1600 Commands defined in this way may accept an unlimited number of arguments\n\
1601 accessed via $arg0 .. $argN. $argc tells how many arguments have\n\
1604 while_cmd_element
= add_com ("while", class_support
, while_command
, _("\
1605 Execute nested commands WHILE the conditional expression is non zero.\n\
1606 The conditional expression must follow the word `while' and must in turn be\n\
1607 followed by a new line. The nested commands must be entered one per line,\n\
1608 and should be terminated by the word `end'."));
1610 if_cmd_element
= add_com ("if", class_support
, if_command
, _("\
1611 Execute nested commands once IF the conditional expression is non zero.\n\
1612 The conditional expression must follow the word `if' and must in turn be\n\
1613 followed by a new line. The nested commands must be entered one per line,\n\
1614 and should be terminated by the word 'else' or `end'. If an else clause\n\
1615 is used, the same rules apply to its nested commands as to the first ones."));