1 /* GDB CLI command scripting.
3 Copyright (C) 1986-2018 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "language.h" /* For value_true */
27 #include "breakpoint.h"
28 #include "cli/cli-cmds.h"
29 #include "cli/cli-decode.h"
30 #include "cli/cli-script.h"
32 #include "extension.h"
34 #include "compile/compile.h"
35 #include "common/gdb_string_view.h"
39 /* Prototypes for local functions. */
41 static enum command_control_type
42 recurse_read_control_structure (char * (*read_next_line_func
) (void),
43 struct command_line
*current_cmd
,
44 void (*validator
)(char *, void *),
47 static void do_define_command (const char *comname
, int from_tty
,
48 const counted_command_line
*commands
);
50 static char *read_next_line (void);
52 /* Level of control structure when reading. */
53 static int control_level
;
55 /* Level of control structure when executing. */
56 static int command_nest_depth
= 1;
58 /* This is to prevent certain commands being printed twice. */
59 static int suppress_next_print_command_trace
= 0;
61 /* Structure for arguments to user defined functions. */
66 /* Save the command line and store the locations of arguments passed
67 to the user defined function. */
68 explicit user_args (const char *line
);
70 /* Insert the stored user defined arguments into the $arg arguments
72 std::string
insert_args (const char *line
) const;
75 /* Disable copy/assignment. (Since the elements of A point inside
76 COMMAND, copying would need to reconstruct the A vector in the
78 user_args (const user_args
&) =delete;
79 user_args
&operator= (const user_args
&) =delete;
81 /* It is necessary to store a copy of the command line to ensure
82 that the arguments are not overwritten before they are used. */
83 std::string m_command_line
;
85 /* The arguments. Each element points inside M_COMMAND_LINE. */
86 std::vector
<gdb::string_view
> m_args
;
89 /* The stack of arguments passed to user defined functions. We need a
90 stack because user-defined functions can call other user-defined
92 static std::vector
<std::unique_ptr
<user_args
>> user_args_stack
;
94 /* An RAII-base class used to push/pop args on the user args
96 struct scoped_user_args_level
98 /* Parse the command line and push the arguments in the user args
100 explicit scoped_user_args_level (const char *line
)
102 user_args_stack
.emplace_back (new user_args (line
));
105 /* Pop the current user arguments from the stack. */
106 ~scoped_user_args_level ()
108 user_args_stack
.pop_back ();
113 /* Return non-zero if TYPE is a multi-line command (i.e., is terminated
117 multi_line_command_p (enum command_control_type type
)
123 case while_stepping_control
:
124 case commands_control
:
125 case compile_control
:
135 /* Allocate, initialize a new command line structure for one of the
136 control commands (if/while). */
138 static struct command_line
*
139 build_command_line (enum command_control_type type
, const char *args
)
141 if (args
== NULL
|| *args
== '\0')
143 if (type
== if_control
)
144 error (_("if command requires an argument."));
145 else if (type
== while_control
)
146 error (_("while command requires an argument."));
147 else if (type
== define_control
)
148 error (_("define command requires an argument."));
150 gdb_assert (args
!= NULL
);
152 return new struct command_line (type
, xstrdup (args
));
155 /* Build and return a new command structure for the control commands
156 such as "if" and "while". */
159 get_command_line (enum command_control_type type
, const char *arg
)
161 /* Allocate and build a new command line structure. */
162 counted_command_line
cmd (build_command_line (type
, arg
),
163 command_lines_deleter ());
165 /* Read in the body of this command. */
166 if (recurse_read_control_structure (read_next_line
, cmd
.get (), 0, 0)
169 warning (_("Error reading in canned sequence of commands."));
176 /* Recursively print a command (including full control structures). */
179 print_command_lines (struct ui_out
*uiout
, struct command_line
*cmd
,
182 struct command_line
*list
;
188 uiout
->spaces (2 * depth
);
190 /* A simple command, print it and continue. */
191 if (list
->control_type
== simple_control
)
193 uiout
->field_string (NULL
, list
->line
);
199 /* loop_continue to jump to the start of a while loop, print it
201 if (list
->control_type
== continue_control
)
203 uiout
->field_string (NULL
, "loop_continue");
209 /* loop_break to break out of a while loop, print it and
211 if (list
->control_type
== break_control
)
213 uiout
->field_string (NULL
, "loop_break");
219 /* A while command. Recursively print its subcommands and
221 if (list
->control_type
== while_control
222 || list
->control_type
== while_stepping_control
)
224 /* For while-stepping, the line includes the 'while-stepping'
225 token. See comment in process_next_line for explanation.
226 Here, take care not print 'while-stepping' twice. */
227 if (list
->control_type
== while_control
)
228 uiout
->field_fmt (NULL
, "while %s", list
->line
);
230 uiout
->field_string (NULL
, list
->line
);
232 print_command_lines (uiout
, list
->body_list_0
.get (), depth
+ 1);
234 uiout
->spaces (2 * depth
);
235 uiout
->field_string (NULL
, "end");
241 /* An if command. Recursively print both arms before
243 if (list
->control_type
== if_control
)
245 uiout
->field_fmt (NULL
, "if %s", list
->line
);
248 print_command_lines (uiout
, list
->body_list_0
.get (), depth
+ 1);
250 /* Show the false arm if it exists. */
251 if (list
->body_list_1
!= nullptr)
254 uiout
->spaces (2 * depth
);
255 uiout
->field_string (NULL
, "else");
257 print_command_lines (uiout
, list
->body_list_1
.get (), depth
+ 1);
261 uiout
->spaces (2 * depth
);
262 uiout
->field_string (NULL
, "end");
268 /* A commands command. Print the breakpoint commands and
270 if (list
->control_type
== commands_control
)
273 uiout
->field_fmt (NULL
, "commands %s", list
->line
);
275 uiout
->field_string (NULL
, "commands");
277 print_command_lines (uiout
, list
->body_list_0
.get (), depth
+ 1);
279 uiout
->spaces (2 * depth
);
280 uiout
->field_string (NULL
, "end");
286 if (list
->control_type
== python_control
)
288 uiout
->field_string (NULL
, "python");
290 /* Don't indent python code at all. */
291 print_command_lines (uiout
, list
->body_list_0
.get (), 0);
293 uiout
->spaces (2 * depth
);
294 uiout
->field_string (NULL
, "end");
300 if (list
->control_type
== compile_control
)
302 uiout
->field_string (NULL
, "compile expression");
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
== guile_control
)
315 uiout
->field_string (NULL
, "guile");
317 print_command_lines (uiout
, list
->body_list_0
.get (), depth
+ 1);
319 uiout
->spaces (2 * depth
);
320 uiout
->field_string (NULL
, "end");
326 /* Ignore illegal command type and try next. */
331 /* Handle pre-post hooks. */
333 class scoped_restore_hook_in
337 scoped_restore_hook_in (struct cmd_list_element
*c
)
342 ~scoped_restore_hook_in ()
347 scoped_restore_hook_in (const scoped_restore_hook_in
&) = delete;
348 scoped_restore_hook_in
&operator= (const scoped_restore_hook_in
&) = delete;
352 struct cmd_list_element
*m_cmd
;
356 execute_cmd_pre_hook (struct cmd_list_element
*c
)
358 if ((c
->hook_pre
) && (!c
->hook_in
))
360 scoped_restore_hook_in
restore_hook (c
);
361 c
->hook_in
= 1; /* Prevent recursive hooking. */
362 execute_user_command (c
->hook_pre
, nullptr);
367 execute_cmd_post_hook (struct cmd_list_element
*c
)
369 if ((c
->hook_post
) && (!c
->hook_in
))
371 scoped_restore_hook_in
restore_hook (c
);
372 c
->hook_in
= 1; /* Prevent recursive hooking. */
373 execute_user_command (c
->hook_post
, nullptr);
378 execute_user_command (struct cmd_list_element
*c
, const char *args
)
380 struct ui
*ui
= current_ui
;
381 counted_command_line cmdlines_copy
;
382 enum command_control_type ret
;
383 extern unsigned int max_user_call_depth
;
385 /* Ensure that the user commands can't be deleted while they are
387 cmdlines_copy
= c
->user_commands
;
388 if (cmdlines_copy
== 0)
391 struct command_line
*cmdlines
= cmdlines_copy
.get ();
393 scoped_user_args_level
push_user_args (args
);
395 if (user_args_stack
.size () > max_user_call_depth
)
396 error (_("Max user call depth exceeded -- command aborted."));
398 /* Set the instream to 0, indicating execution of a
399 user-defined function. */
400 scoped_restore restore_instream
401 = make_scoped_restore (&ui
->instream
, nullptr);
403 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
405 scoped_restore save_nesting
406 = make_scoped_restore (&command_nest_depth
, command_nest_depth
+ 1);
409 ret
= execute_control_command (cmdlines
);
410 if (ret
!= simple_control
&& ret
!= break_control
)
412 warning (_("Error executing canned sequence of commands."));
415 cmdlines
= cmdlines
->next
;
419 /* This function is called every time GDB prints a prompt. It ensures
420 that errors and the like do not confuse the command tracing. */
423 reset_command_nest_depth (void)
425 command_nest_depth
= 1;
428 suppress_next_print_command_trace
= 0;
431 /* Print the command, prefixed with '+' to represent the call depth.
432 This is slightly complicated because this function may be called
433 from execute_command and execute_control_command. Unfortunately
434 execute_command also prints the top level control commands.
435 In these cases execute_command will call execute_control_command
436 via while_command or if_command. Inner levels of 'if' and 'while'
437 are dealt with directly. Therefore we can use these functions
438 to determine whether the command has been printed already or not. */
439 ATTRIBUTE_PRINTF (1, 2)
441 print_command_trace (const char *fmt
, ...)
445 if (suppress_next_print_command_trace
)
447 suppress_next_print_command_trace
= 0;
451 if (!source_verbose
&& !trace_commands
)
454 for (i
=0; i
< command_nest_depth
; i
++)
455 printf_filtered ("+");
459 va_start (args
, fmt
);
460 vprintf_filtered (fmt
, args
);
462 puts_filtered ("\n");
465 /* Helper for execute_control_command. */
467 static enum command_control_type
468 execute_control_command_1 (struct command_line
*cmd
)
470 struct command_line
*current
;
472 struct value
*val_mark
;
474 enum command_control_type ret
;
476 /* Start by assuming failure, if a problem is detected, the code
477 below will simply "break" out of the switch. */
478 ret
= invalid_control
;
480 switch (cmd
->control_type
)
484 /* A simple command, execute it and return. */
485 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
486 execute_command (new_line
.c_str (), 0);
487 ret
= cmd
->control_type
;
491 case continue_control
:
492 print_command_trace ("loop_continue");
494 /* Return for "continue", and "break" so we can either
495 continue the loop at the top, or break out. */
496 ret
= cmd
->control_type
;
500 print_command_trace ("loop_break");
502 /* Return for "continue", and "break" so we can either
503 continue the loop at the top, or break out. */
504 ret
= cmd
->control_type
;
509 print_command_trace ("while %s", cmd
->line
);
511 /* Parse the loop control expression for the while statement. */
512 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
513 expression_up expr
= parse_expression (new_line
.c_str ());
515 ret
= simple_control
;
518 /* Keep iterating so long as the expression is true. */
525 /* Evaluate the expression. */
526 val_mark
= value_mark ();
527 val
= evaluate_expression (expr
.get ());
528 cond_result
= value_true (val
);
529 value_free_to_mark (val_mark
);
531 /* If the value is false, then break out of the loop. */
535 /* Execute the body of the while statement. */
536 current
= cmd
->body_list_0
.get ();
539 scoped_restore save_nesting
540 = make_scoped_restore (&command_nest_depth
, command_nest_depth
+ 1);
541 ret
= execute_control_command_1 (current
);
543 /* If we got an error, or a "break" command, then stop
545 if (ret
== invalid_control
|| ret
== break_control
)
551 /* If we got a "continue" command, then restart the loop
553 if (ret
== continue_control
)
556 /* Get the next statement. */
557 current
= current
->next
;
561 /* Reset RET so that we don't recurse the break all the way down. */
562 if (ret
== break_control
)
563 ret
= simple_control
;
570 print_command_trace ("if %s", cmd
->line
);
572 /* Parse the conditional for the if statement. */
573 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
574 expression_up expr
= parse_expression (new_line
.c_str ());
577 ret
= simple_control
;
579 /* Evaluate the conditional. */
580 val_mark
= value_mark ();
581 val
= evaluate_expression (expr
.get ());
583 /* Choose which arm to take commands from based on the value
584 of the conditional expression. */
585 if (value_true (val
))
586 current
= cmd
->body_list_0
.get ();
587 else if (cmd
->body_list_1
!= nullptr)
588 current
= cmd
->body_list_1
.get ();
589 value_free_to_mark (val_mark
);
591 /* Execute commands in the given arm. */
594 scoped_restore save_nesting
595 = make_scoped_restore (&command_nest_depth
, command_nest_depth
+ 1);
596 ret
= execute_control_command_1 (current
);
598 /* If we got an error, get out. */
599 if (ret
!= simple_control
)
602 /* Get the next statement in the body. */
603 current
= current
->next
;
609 case commands_control
:
611 /* Breakpoint commands list, record the commands in the
612 breakpoint's command list and return. */
613 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
614 ret
= commands_from_control_command (new_line
.c_str (), cmd
);
618 case compile_control
:
619 eval_compile_command (cmd
, NULL
, cmd
->control_u
.compile
.scope
,
620 cmd
->control_u
.compile
.scope_data
);
621 ret
= simple_control
;
625 print_command_trace ("define %s", cmd
->line
);
626 do_define_command (cmd
->line
, 0, &cmd
->body_list_0
);
627 ret
= simple_control
;
633 eval_ext_lang_from_control_command (cmd
);
634 ret
= simple_control
;
639 warning (_("Invalid control type in canned commands structure."));
646 enum command_control_type
647 execute_control_command (struct command_line
*cmd
)
649 /* Make sure we use the console uiout. It's possible that we are executing
650 breakpoint commands while running the MI interpreter. */
651 interp
*console
= interp_lookup (current_ui
, INTERP_CONSOLE
);
652 scoped_restore save_uiout
653 = make_scoped_restore (¤t_uiout
, interp_ui_out (console
));
655 return execute_control_command_1 (cmd
);
658 /* Like execute_control_command, but first set
659 suppress_next_print_command_trace. */
661 enum command_control_type
662 execute_control_command_untraced (struct command_line
*cmd
)
664 suppress_next_print_command_trace
= 1;
665 return execute_control_command (cmd
);
669 /* "while" command support. Executes a body of statements while the
670 loop condition is nonzero. */
673 while_command (const char *arg
, int from_tty
)
676 counted_command_line command
= get_command_line (while_control
, arg
);
681 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
683 execute_control_command_untraced (command
.get ());
686 /* "if" command support. Execute either the true or false arm depending
687 on the value of the if conditional. */
690 if_command (const char *arg
, int from_tty
)
693 counted_command_line command
= get_command_line (if_control
, arg
);
698 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
700 execute_control_command_untraced (command
.get ());
703 /* Bind the incoming arguments for a user defined command to $arg0,
706 user_args::user_args (const char *command_line
)
710 if (command_line
== NULL
)
713 m_command_line
= command_line
;
714 p
= m_command_line
.c_str ();
718 const char *start_arg
;
723 /* Strip whitespace. */
724 while (*p
== ' ' || *p
== '\t')
727 /* P now points to an argument. */
730 /* Get to the end of this argument. */
733 if (((*p
== ' ' || *p
== '\t')) && !squote
&& !dquote
&& !bsquote
)
762 m_args
.emplace_back (start_arg
, p
- start_arg
);
766 /* Given character string P, return a point to the first argument
767 ($arg), or NULL if P contains no arguments. */
770 locate_arg (const char *p
)
772 while ((p
= strchr (p
, '$')))
774 if (startswith (p
, "$arg")
775 && (isdigit (p
[4]) || p
[4] == 'c'))
782 /* See cli-script.h. */
785 insert_user_defined_cmd_args (const char *line
)
787 /* If we are not in a user-defined command, treat $argc, $arg0, et
788 cetera as normal convenience variables. */
789 if (user_args_stack
.empty ())
792 const std::unique_ptr
<user_args
> &args
= user_args_stack
.back ();
793 return args
->insert_args (line
);
796 /* Insert the user defined arguments stored in user_args into the $arg
797 arguments found in line. */
800 user_args::insert_args (const char *line
) const
802 std::string new_line
;
805 while ((p
= locate_arg (line
)))
807 new_line
.append (line
, p
- line
);
811 new_line
+= std::to_string (m_args
.size ());
820 i
= strtoul (p
+ 4, &tmp
, 10);
821 if ((i
== 0 && tmp
== p
+ 4) || errno
!= 0)
823 else if (i
>= m_args
.size ())
824 error (_("Missing argument %ld in user function."), i
);
827 new_line
.append (m_args
[i
].data (), m_args
[i
].length ());
832 /* Don't forget the tail. */
833 new_line
.append (line
);
839 /* Read next line from stdin. Passed to read_command_line_1 and
840 recurse_read_control_structure whenever we need to read commands
844 read_next_line (void)
846 struct ui
*ui
= current_ui
;
847 char *prompt_ptr
, control_prompt
[256];
849 int from_tty
= ui
->instream
== ui
->stdin_stream
;
851 if (control_level
>= 254)
852 error (_("Control nesting too deep!"));
854 /* Set a prompt based on the nesting of the control commands. */
856 || (ui
->instream
== 0 && deprecated_readline_hook
!= NULL
))
858 for (i
= 0; i
< control_level
; i
++)
859 control_prompt
[i
] = ' ';
860 control_prompt
[i
] = '>';
861 control_prompt
[i
+ 1] = '\0';
862 prompt_ptr
= (char *) &control_prompt
[0];
867 return command_line_input (prompt_ptr
, from_tty
, "commands");
870 /* Return true if CMD's name is NAME. */
873 command_name_equals (struct cmd_list_element
*cmd
, const char *name
)
876 && cmd
!= CMD_LIST_AMBIGUOUS
877 && strcmp (cmd
->name
, name
) == 0);
880 /* Given an input line P, skip the command and return a pointer to the
884 line_first_arg (const char *p
)
886 const char *first_arg
= p
+ find_command_name_length (p
);
888 return skip_spaces (first_arg
);
891 /* Process one input line. If the command is an "end", return such an
892 indication to the caller. If PARSE_COMMANDS is true, strip leading
893 whitespace (trailing whitespace is always stripped) in the line,
894 attempt to recognize GDB control commands, and also return an
895 indication if the command is an "else" or a nop.
897 Otherwise, only "end" is recognized. */
899 static enum misc_command_type
900 process_next_line (char *p
, struct command_line
**command
, int parse_commands
,
901 void (*validator
)(char *, void *), void *closure
)
907 /* Not sure what to do here. */
911 /* Strip trailing whitespace. */
912 p_end
= p
+ strlen (p
);
913 while (p_end
> p
&& (p_end
[-1] == ' ' || p_end
[-1] == '\t'))
917 /* Strip leading whitespace. */
918 while (p_start
< p_end
&& (*p_start
== ' ' || *p_start
== '\t'))
921 /* 'end' is always recognized, regardless of parse_commands value.
922 We also permit whitespace before end and after. */
923 if (p_end
- p_start
== 3 && startswith (p_start
, "end"))
928 /* Resolve command abbreviations (e.g. 'ws' for 'while-stepping'). */
929 const char *cmd_name
= p
;
930 struct cmd_list_element
*cmd
931 = lookup_cmd_1 (&cmd_name
, cmdlist
, NULL
, 1);
932 cmd_name
= skip_spaces (cmd_name
);
933 bool inline_cmd
= *cmd_name
!= '\0';
935 /* If commands are parsed, we skip initial spaces. Otherwise,
936 which is the case for Python commands and documentation
937 (see the 'document' command), spaces are preserved. */
940 /* Blanks and comments don't really do anything, but we need to
941 distinguish them from else, end and other commands which can
943 if (p_end
== p
|| p
[0] == '#')
946 /* Is the else clause of an if control structure? */
947 if (p_end
- p
== 4 && startswith (p
, "else"))
950 /* Check for while, if, break, continue, etc and build a new
951 command line structure for them. */
952 if (command_name_equals (cmd
, "while-stepping"))
954 /* Because validate_actionline and encode_action lookup
955 command's line as command, we need the line to
956 include 'while-stepping'.
958 For 'ws' alias, the command will have 'ws', not expanded
959 to 'while-stepping'. This is intentional -- we don't
960 really want frontend to send a command list with 'ws',
961 and next break-info returning command line with
962 'while-stepping'. This should work, but might cause the
963 breakpoint to be marked as changed while it's actually
965 *command
= build_command_line (while_stepping_control
, p
);
967 else if (command_name_equals (cmd
, "while"))
969 *command
= build_command_line (while_control
, line_first_arg (p
));
971 else if (command_name_equals (cmd
, "if"))
973 *command
= build_command_line (if_control
, line_first_arg (p
));
975 else if (command_name_equals (cmd
, "commands"))
977 *command
= build_command_line (commands_control
, line_first_arg (p
));
979 else if (command_name_equals (cmd
, "define"))
980 *command
= build_command_line (define_control
, line_first_arg (p
));
981 else if (command_name_equals (cmd
, "python") && !inline_cmd
)
983 /* Note that we ignore the inline "python command" form
985 *command
= build_command_line (python_control
, "");
987 else if (command_name_equals (cmd
, "compile") && !inline_cmd
)
989 /* Note that we ignore the inline "compile command" form
991 *command
= build_command_line (compile_control
, "");
992 (*command
)->control_u
.compile
.scope
= COMPILE_I_INVALID_SCOPE
;
994 else if (command_name_equals (cmd
, "guile") && !inline_cmd
)
996 /* Note that we ignore the inline "guile command" form here. */
997 *command
= build_command_line (guile_control
, "");
999 else if (p_end
- p
== 10 && startswith (p
, "loop_break"))
1000 *command
= new struct command_line (break_control
);
1001 else if (p_end
- p
== 13 && startswith (p
, "loop_continue"))
1002 *command
= new struct command_line (continue_control
);
1007 if (!parse_commands
|| not_handled
)
1009 /* A normal command. */
1010 *command
= new struct command_line (simple_control
,
1011 savestring (p
, p_end
- p
));
1019 validator ((*command
)->line
, closure
);
1021 CATCH (ex
, RETURN_MASK_ALL
)
1023 free_command_lines (command
);
1024 throw_exception (ex
);
1029 /* Nothing special. */
1033 /* Recursively read in the control structures and create a
1034 command_line structure from them. Use read_next_line_func to
1035 obtain lines of the command. */
1037 static enum command_control_type
1038 recurse_read_control_structure (char * (*read_next_line_func
) (void),
1039 struct command_line
*current_cmd
,
1040 void (*validator
)(char *, void *),
1043 enum misc_command_type val
;
1044 enum command_control_type ret
;
1045 struct command_line
**body_ptr
, *child_tail
, *next
;
1046 counted_command_line
*current_body
= ¤t_cmd
->body_list_0
;
1050 /* Sanity checks. */
1051 if (current_cmd
->control_type
== simple_control
)
1052 error (_("Recursed on a simple control type."));
1054 /* Read lines from the input stream and build control structures. */
1060 val
= process_next_line (read_next_line_func (), &next
,
1061 current_cmd
->control_type
!= python_control
1062 && current_cmd
->control_type
!= guile_control
1063 && current_cmd
->control_type
!= compile_control
,
1064 validator
, closure
);
1066 /* Just skip blanks and comments. */
1067 if (val
== nop_command
)
1070 if (val
== end_command
)
1072 if (multi_line_command_p (current_cmd
->control_type
))
1074 /* Success reading an entire canned sequence of commands. */
1075 ret
= simple_control
;
1080 ret
= invalid_control
;
1085 /* Not the end of a control structure. */
1086 if (val
== else_command
)
1088 if (current_cmd
->control_type
== if_control
1089 && current_body
== ¤t_cmd
->body_list_0
)
1091 current_body
= ¤t_cmd
->body_list_1
;
1097 ret
= invalid_control
;
1104 child_tail
->next
= next
;
1107 *current_body
= counted_command_line (next
, command_lines_deleter ());
1111 /* If the latest line is another control structure, then recurse
1113 if (multi_line_command_p (next
->control_type
))
1116 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1117 validator
, closure
);
1120 if (ret
!= simple_control
)
1130 /* Read lines from the input stream and accumulate them in a chain of
1131 struct command_line's, which is then returned. For input from a
1132 terminal, the special command "end" is used to mark the end of the
1133 input, and is not included in the returned chain of commands.
1135 If PARSE_COMMANDS is true, strip leading whitespace (trailing whitespace
1136 is always stripped) in the line and attempt to recognize GDB control
1137 commands. Otherwise, only "end" is recognized. */
1139 #define END_MESSAGE "End with a line saying just \"end\"."
1141 counted_command_line
1142 read_command_lines (const char *prompt_arg
, int from_tty
, int parse_commands
,
1143 void (*validator
)(char *, void *), void *closure
)
1145 if (from_tty
&& input_interactive_p (current_ui
))
1147 if (deprecated_readline_begin_hook
)
1149 /* Note - intentional to merge messages with no newline. */
1150 (*deprecated_readline_begin_hook
) ("%s %s\n", prompt_arg
,
1155 printf_unfiltered ("%s\n%s\n", prompt_arg
, END_MESSAGE
);
1156 gdb_flush (gdb_stdout
);
1161 /* Reading commands assumes the CLI behavior, so temporarily
1162 override the current interpreter with CLI. */
1163 counted_command_line
head (nullptr, command_lines_deleter ());
1164 if (current_interp_named_p (INTERP_CONSOLE
))
1165 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1166 validator
, closure
);
1169 scoped_restore_interp
interp_restorer (INTERP_CONSOLE
);
1171 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1172 validator
, closure
);
1175 if (from_tty
&& input_interactive_p (current_ui
)
1176 && deprecated_readline_end_hook
)
1178 (*deprecated_readline_end_hook
) ();
1183 /* Act the same way as read_command_lines, except that each new line is
1184 obtained using READ_NEXT_LINE_FUNC. */
1186 counted_command_line
1187 read_command_lines_1 (char * (*read_next_line_func
) (void), int parse_commands
,
1188 void (*validator
)(char *, void *), void *closure
)
1190 struct command_line
*tail
, *next
;
1191 counted_command_line
head (nullptr, command_lines_deleter ());
1192 enum command_control_type ret
;
1193 enum misc_command_type val
;
1201 val
= process_next_line (read_next_line_func (), &next
, parse_commands
,
1202 validator
, closure
);
1204 /* Ignore blank lines or comments. */
1205 if (val
== nop_command
)
1208 if (val
== end_command
)
1210 ret
= simple_control
;
1214 if (val
!= ok_command
)
1216 ret
= invalid_control
;
1220 if (multi_line_command_p (next
->control_type
))
1223 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1224 validator
, closure
);
1227 if (ret
== invalid_control
)
1237 head
= counted_command_line (next
, command_lines_deleter ());
1244 if (ret
== invalid_control
)
1250 /* Free a chain of struct command_line's. */
1253 free_command_lines (struct command_line
**lptr
)
1255 struct command_line
*l
= *lptr
;
1256 struct command_line
*next
;
1267 /* Validate that *COMNAME is a valid name for a command. Return the
1268 containing command list, in case it starts with a prefix command.
1269 The prefix must already exist. *COMNAME is advanced to point after
1270 any prefix, and a NUL character overwrites the space after the
1273 static struct cmd_list_element
**
1274 validate_comname (const char **comname
)
1276 struct cmd_list_element
**list
= &cmdlist
;
1277 const char *p
, *last_word
;
1280 error_no_arg (_("name of command to define"));
1282 /* Find the last word of the argument. */
1283 p
= *comname
+ strlen (*comname
);
1284 while (p
> *comname
&& isspace (p
[-1]))
1286 while (p
> *comname
&& !isspace (p
[-1]))
1290 /* Find the corresponding command list. */
1291 if (last_word
!= *comname
)
1293 struct cmd_list_element
*c
;
1295 /* Separate the prefix and the command. */
1296 std::string
prefix (*comname
, last_word
- 1);
1297 const char *tem
= prefix
.c_str ();
1299 c
= lookup_cmd (&tem
, cmdlist
, "", 0, 1);
1300 if (c
->prefixlist
== NULL
)
1301 error (_("\"%s\" is not a prefix command."), prefix
.c_str ());
1303 list
= c
->prefixlist
;
1304 *comname
= last_word
;
1310 if (!isalnum (*p
) && *p
!= '-' && *p
!= '_')
1311 error (_("Junk in argument list: \"%s\""), p
);
1318 /* This is just a placeholder in the command data structures. */
1320 user_defined_command (const char *ignore
, int from_tty
)
1324 /* Define a user-defined command. If COMMANDS is NULL, then this is a
1325 top-level call and the commands will be read using
1326 read_command_lines. Otherwise, it is a "define" command in an
1327 existing command and the commands are provided. In the
1328 non-top-level case, various prompts and warnings are disabled. */
1331 do_define_command (const char *comname
, int from_tty
,
1332 const counted_command_line
*commands
)
1340 struct cmd_list_element
*c
, *newc
, *hookc
= 0, **list
;
1341 const char *tem
, *comfull
;
1342 int hook_type
= CMD_NO_HOOK
;
1343 int hook_name_size
= 0;
1345 #define HOOK_STRING "hook-"
1347 #define HOOK_POST_STRING "hookpost-"
1348 #define HOOK_POST_LEN 9
1351 list
= validate_comname (&comname
);
1353 /* Look it up, and verify that we got an exact match. */
1355 c
= lookup_cmd (&tem
, *list
, "", -1, 1);
1356 if (c
&& strcmp (comname
, c
->name
) != 0)
1359 if (c
&& commands
== nullptr)
1363 if (c
->theclass
== class_user
|| c
->theclass
== class_alias
)
1364 q
= query (_("Redefine command \"%s\"? "), c
->name
);
1366 q
= query (_("Really redefine built-in command \"%s\"? "), c
->name
);
1368 error (_("Command \"%s\" not redefined."), c
->name
);
1371 /* If this new command is a hook, then mark the command which it
1372 is hooking. Note that we allow hooking `help' commands, so that
1373 we can hook the `stop' pseudo-command. */
1375 if (!strncmp (comname
, HOOK_STRING
, HOOK_LEN
))
1377 hook_type
= CMD_PRE_HOOK
;
1378 hook_name_size
= HOOK_LEN
;
1380 else if (!strncmp (comname
, HOOK_POST_STRING
, HOOK_POST_LEN
))
1382 hook_type
= CMD_POST_HOOK
;
1383 hook_name_size
= HOOK_POST_LEN
;
1386 if (hook_type
!= CMD_NO_HOOK
)
1388 /* Look up cmd it hooks, and verify that we got an exact match. */
1389 tem
= comname
+ hook_name_size
;
1390 hookc
= lookup_cmd (&tem
, *list
, "", -1, 0);
1391 if (hookc
&& strcmp (comname
+ hook_name_size
, hookc
->name
) != 0)
1393 if (!hookc
&& commands
== nullptr)
1395 warning (_("Your new `%s' command does not "
1396 "hook any existing command."),
1398 if (!query (_("Proceed? ")))
1399 error (_("Not confirmed."));
1403 comname
= xstrdup (comname
);
1405 counted_command_line cmds
;
1406 if (commands
== nullptr)
1409 = string_printf ("Type commands for definition of \"%s\".", comfull
);
1410 cmds
= read_command_lines (prompt
.c_str (), from_tty
, 1, 0, 0);
1415 newc
= add_cmd (comname
, class_user
, user_defined_command
,
1416 (c
&& c
->theclass
== class_user
)
1417 ? c
->doc
: xstrdup ("User-defined."), list
);
1418 newc
->user_commands
= std::move (cmds
);
1420 /* If this new command is a hook, then mark both commands as being
1427 hookc
->hook_pre
= newc
; /* Target gets hooked. */
1428 newc
->hookee_pre
= hookc
; /* We are marked as hooking target cmd. */
1431 hookc
->hook_post
= newc
; /* Target gets hooked. */
1432 newc
->hookee_post
= hookc
; /* We are marked as hooking
1436 /* Should never come here as hookc would be 0. */
1437 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1443 define_command (const char *comname
, int from_tty
)
1445 do_define_command (comname
, from_tty
, nullptr);
1449 document_command (const char *comname
, int from_tty
)
1451 struct cmd_list_element
*c
, **list
;
1453 const char *comfull
;
1456 list
= validate_comname (&comname
);
1459 c
= lookup_cmd (&tem
, *list
, "", 0, 1);
1461 if (c
->theclass
!= class_user
)
1462 error (_("Command \"%s\" is built-in."), comfull
);
1464 std::string prompt
= string_printf ("Type documentation for \"%s\".",
1466 counted_command_line doclines
= read_command_lines (prompt
.c_str (),
1470 xfree ((char *) c
->doc
);
1473 struct command_line
*cl1
;
1477 for (cl1
= doclines
.get (); cl1
; cl1
= cl1
->next
)
1478 len
+= strlen (cl1
->line
) + 1;
1480 doc
= (char *) xmalloc (len
+ 1);
1483 for (cl1
= doclines
.get (); cl1
; cl1
= cl1
->next
)
1485 strcat (doc
, cl1
->line
);
1494 /* Used to implement source_command. */
1497 script_from_file (FILE *stream
, const char *file
)
1500 internal_error (__FILE__
, __LINE__
, _("called with NULL file pointer!"));
1502 scoped_restore restore_line_number
1503 = make_scoped_restore (&source_line_number
, 0);
1504 scoped_restore resotre_file
1505 = make_scoped_restore (&source_file_name
, file
);
1507 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
1511 read_command_file (stream
);
1513 CATCH (e
, RETURN_MASK_ERROR
)
1515 /* Re-throw the error, but with the file name information
1517 throw_error (e
.error
,
1518 _("%s:%d: Error in sourced command file:\n%s"),
1519 source_file_name
, source_line_number
, e
.message
);
1524 /* Print the definition of user command C to STREAM. Or, if C is a
1525 prefix command, show the definitions of all user commands under C
1526 (recursively). PREFIX and NAME combined are the name of the
1529 show_user_1 (struct cmd_list_element
*c
, const char *prefix
, const char *name
,
1530 struct ui_file
*stream
)
1532 struct command_line
*cmdlines
;
1534 if (c
->prefixlist
!= NULL
)
1536 const char *prefixname
= c
->prefixname
;
1538 for (c
= *c
->prefixlist
; c
!= NULL
; c
= c
->next
)
1539 if (c
->theclass
== class_user
|| c
->prefixlist
!= NULL
)
1540 show_user_1 (c
, prefixname
, c
->name
, gdb_stdout
);
1544 cmdlines
= c
->user_commands
.get ();
1545 fprintf_filtered (stream
, "User command \"%s%s\":\n", prefix
, name
);
1549 print_command_lines (current_uiout
, cmdlines
, 1);
1550 fputs_filtered ("\n", stream
);
1554 _initialize_cli_script (void)
1556 add_com ("document", class_support
, document_command
, _("\
1557 Document a user-defined command.\n\
1558 Give command name as argument. Give documentation on following lines.\n\
1559 End with a line of just \"end\"."));
1560 add_com ("define", class_support
, define_command
, _("\
1561 Define a new command name. Command name is argument.\n\
1562 Definition appears on following lines, one command per line.\n\
1563 End with a line of just \"end\".\n\
1564 Use the \"document\" command to give documentation for the new command.\n\
1565 Commands defined in this way may have up to ten arguments."));
1567 add_com ("while", class_support
, while_command
, _("\
1568 Execute nested commands WHILE the conditional expression is non zero.\n\
1569 The conditional expression must follow the word `while' and must in turn be\n\
1570 followed by a new line. The nested commands must be entered one per line,\n\
1571 and should be terminated by the word `end'."));
1573 add_com ("if", class_support
, if_command
, _("\
1574 Execute nested commands once IF the conditional expression is non zero.\n\
1575 The conditional expression must follow the word `if' and must in turn be\n\
1576 followed by a new line. The nested commands must be entered one per line,\n\
1577 and should be terminated by the word 'else' or `end'. If an else clause\n\
1578 is used, the same rules apply to its nested commands as to the first ones."));