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
43 (gdb::function_view
<const char * ()> read_next_line_func
,
44 struct command_line
*current_cmd
,
45 gdb::function_view
<void (const char *)> validator
);
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)
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);
377 /* See cli-script.h. */
380 execute_control_commands (struct command_line
*cmdlines
, int from_tty
)
382 /* Set the instream to 0, indicating execution of a
383 user-defined function. */
384 scoped_restore restore_instream
385 = make_scoped_restore (¤t_ui
->instream
, nullptr);
386 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
387 scoped_restore save_nesting
388 = make_scoped_restore (&command_nest_depth
, command_nest_depth
+ 1);
392 enum command_control_type ret
= execute_control_command (cmdlines
,
394 if (ret
!= simple_control
&& ret
!= break_control
)
396 warning (_("Error executing canned sequence of commands."));
399 cmdlines
= cmdlines
->next
;
403 /* See cli-script.h. */
406 execute_control_commands_to_string (struct command_line
*commands
,
409 /* GDB_STDOUT should be better already restored during these
410 restoration callbacks. */
411 set_batch_flag_and_restore_page_info save_page_info
;
413 string_file str_file
;
416 current_uiout
->redirect (&str_file
);
417 ui_out_redirect_pop
redirect_popper (current_uiout
);
419 scoped_restore save_stdout
420 = make_scoped_restore (&gdb_stdout
, &str_file
);
421 scoped_restore save_stderr
422 = make_scoped_restore (&gdb_stderr
, &str_file
);
423 scoped_restore save_stdlog
424 = make_scoped_restore (&gdb_stdlog
, &str_file
);
425 scoped_restore save_stdtarg
426 = make_scoped_restore (&gdb_stdtarg
, &str_file
);
427 scoped_restore save_stdtargerr
428 = make_scoped_restore (&gdb_stdtargerr
, &str_file
);
430 execute_control_commands (commands
, from_tty
);
433 return std::move (str_file
.string ());
437 execute_user_command (struct cmd_list_element
*c
, const char *args
)
439 counted_command_line cmdlines_copy
;
440 extern unsigned int max_user_call_depth
;
442 /* Ensure that the user commands can't be deleted while they are
444 cmdlines_copy
= c
->user_commands
;
445 if (cmdlines_copy
== 0)
448 struct command_line
*cmdlines
= cmdlines_copy
.get ();
450 scoped_user_args_level
push_user_args (args
);
452 if (user_args_stack
.size () > max_user_call_depth
)
453 error (_("Max user call depth exceeded -- command aborted."));
455 execute_control_commands (cmdlines
, 0);
458 /* This function is called every time GDB prints a prompt. It ensures
459 that errors and the like do not confuse the command tracing. */
462 reset_command_nest_depth (void)
464 command_nest_depth
= 1;
467 suppress_next_print_command_trace
= 0;
470 /* Print the command, prefixed with '+' to represent the call depth.
471 This is slightly complicated because this function may be called
472 from execute_command and execute_control_command. Unfortunately
473 execute_command also prints the top level control commands.
474 In these cases execute_command will call execute_control_command
475 via while_command or if_command. Inner levels of 'if' and 'while'
476 are dealt with directly. Therefore we can use these functions
477 to determine whether the command has been printed already or not. */
478 ATTRIBUTE_PRINTF (1, 2)
480 print_command_trace (const char *fmt
, ...)
484 if (suppress_next_print_command_trace
)
486 suppress_next_print_command_trace
= 0;
490 if (!source_verbose
&& !trace_commands
)
493 for (i
=0; i
< command_nest_depth
; i
++)
494 printf_filtered ("+");
498 va_start (args
, fmt
);
499 vprintf_filtered (fmt
, args
);
501 puts_filtered ("\n");
504 /* Helper for execute_control_command. */
506 static enum command_control_type
507 execute_control_command_1 (struct command_line
*cmd
, int from_tty
)
509 struct command_line
*current
;
511 struct value
*val_mark
;
513 enum command_control_type ret
;
515 /* Start by assuming failure, if a problem is detected, the code
516 below will simply "break" out of the switch. */
517 ret
= invalid_control
;
519 switch (cmd
->control_type
)
523 /* A simple command, execute it and return. */
524 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
525 execute_command (new_line
.c_str (), from_tty
);
526 ret
= cmd
->control_type
;
530 case continue_control
:
531 print_command_trace ("loop_continue");
533 /* Return for "continue", and "break" so we can either
534 continue the loop at the top, or break out. */
535 ret
= cmd
->control_type
;
539 print_command_trace ("loop_break");
541 /* Return for "continue", and "break" so we can either
542 continue the loop at the top, or break out. */
543 ret
= cmd
->control_type
;
548 print_command_trace ("while %s", cmd
->line
);
550 /* Parse the loop control expression for the while statement. */
551 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
552 expression_up expr
= parse_expression (new_line
.c_str ());
554 ret
= simple_control
;
557 /* Keep iterating so long as the expression is true. */
564 /* Evaluate the expression. */
565 val_mark
= value_mark ();
566 val
= evaluate_expression (expr
.get ());
567 cond_result
= value_true (val
);
568 value_free_to_mark (val_mark
);
570 /* If the value is false, then break out of the loop. */
574 /* Execute the body of the while statement. */
575 current
= cmd
->body_list_0
.get ();
578 scoped_restore save_nesting
579 = make_scoped_restore (&command_nest_depth
, command_nest_depth
+ 1);
580 ret
= execute_control_command_1 (current
, from_tty
);
582 /* If we got an error, or a "break" command, then stop
584 if (ret
== invalid_control
|| ret
== break_control
)
590 /* If we got a "continue" command, then restart the loop
592 if (ret
== continue_control
)
595 /* Get the next statement. */
596 current
= current
->next
;
600 /* Reset RET so that we don't recurse the break all the way down. */
601 if (ret
== break_control
)
602 ret
= simple_control
;
609 print_command_trace ("if %s", cmd
->line
);
611 /* Parse the conditional for the if statement. */
612 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
613 expression_up expr
= parse_expression (new_line
.c_str ());
616 ret
= simple_control
;
618 /* Evaluate the conditional. */
619 val_mark
= value_mark ();
620 val
= evaluate_expression (expr
.get ());
622 /* Choose which arm to take commands from based on the value
623 of the conditional expression. */
624 if (value_true (val
))
625 current
= cmd
->body_list_0
.get ();
626 else if (cmd
->body_list_1
!= nullptr)
627 current
= cmd
->body_list_1
.get ();
628 value_free_to_mark (val_mark
);
630 /* Execute commands in the given arm. */
633 scoped_restore save_nesting
634 = make_scoped_restore (&command_nest_depth
, command_nest_depth
+ 1);
635 ret
= execute_control_command_1 (current
, from_tty
);
637 /* If we got an error, get out. */
638 if (ret
!= simple_control
)
641 /* Get the next statement in the body. */
642 current
= current
->next
;
648 case commands_control
:
650 /* Breakpoint commands list, record the commands in the
651 breakpoint's command list and return. */
652 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
653 ret
= commands_from_control_command (new_line
.c_str (), cmd
);
657 case compile_control
:
658 eval_compile_command (cmd
, NULL
, cmd
->control_u
.compile
.scope
,
659 cmd
->control_u
.compile
.scope_data
);
660 ret
= simple_control
;
664 print_command_trace ("define %s", cmd
->line
);
665 do_define_command (cmd
->line
, 0, &cmd
->body_list_0
);
666 ret
= simple_control
;
672 eval_ext_lang_from_control_command (cmd
);
673 ret
= simple_control
;
678 warning (_("Invalid control type in canned commands structure."));
685 enum command_control_type
686 execute_control_command (struct command_line
*cmd
, int from_tty
)
688 /* Make sure we use the console uiout. It's possible that we are executing
689 breakpoint commands while running the MI interpreter. */
690 interp
*console
= interp_lookup (current_ui
, INTERP_CONSOLE
);
691 scoped_restore save_uiout
692 = make_scoped_restore (¤t_uiout
, console
->interp_ui_out ());
694 return execute_control_command_1 (cmd
, from_tty
);
697 /* Like execute_control_command, but first set
698 suppress_next_print_command_trace. */
700 enum command_control_type
701 execute_control_command_untraced (struct command_line
*cmd
)
703 suppress_next_print_command_trace
= 1;
704 return execute_control_command (cmd
);
708 /* "while" command support. Executes a body of statements while the
709 loop condition is nonzero. */
712 while_command (const char *arg
, int from_tty
)
715 counted_command_line command
= get_command_line (while_control
, arg
);
720 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
722 execute_control_command_untraced (command
.get ());
725 /* "if" command support. Execute either the true or false arm depending
726 on the value of the if conditional. */
729 if_command (const char *arg
, int from_tty
)
732 counted_command_line command
= get_command_line (if_control
, arg
);
737 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
739 execute_control_command_untraced (command
.get ());
742 /* Bind the incoming arguments for a user defined command to $arg0,
745 user_args::user_args (const char *command_line
)
749 if (command_line
== NULL
)
752 m_command_line
= command_line
;
753 p
= m_command_line
.c_str ();
757 const char *start_arg
;
762 /* Strip whitespace. */
763 while (*p
== ' ' || *p
== '\t')
766 /* P now points to an argument. */
769 /* Get to the end of this argument. */
772 if (((*p
== ' ' || *p
== '\t')) && !squote
&& !dquote
&& !bsquote
)
801 m_args
.emplace_back (start_arg
, p
- start_arg
);
805 /* Given character string P, return a point to the first argument
806 ($arg), or NULL if P contains no arguments. */
809 locate_arg (const char *p
)
811 while ((p
= strchr (p
, '$')))
813 if (startswith (p
, "$arg")
814 && (isdigit (p
[4]) || p
[4] == 'c'))
821 /* See cli-script.h. */
824 insert_user_defined_cmd_args (const char *line
)
826 /* If we are not in a user-defined command, treat $argc, $arg0, et
827 cetera as normal convenience variables. */
828 if (user_args_stack
.empty ())
831 const std::unique_ptr
<user_args
> &args
= user_args_stack
.back ();
832 return args
->insert_args (line
);
835 /* Insert the user defined arguments stored in user_args into the $arg
836 arguments found in line. */
839 user_args::insert_args (const char *line
) const
841 std::string new_line
;
844 while ((p
= locate_arg (line
)))
846 new_line
.append (line
, p
- line
);
850 new_line
+= std::to_string (m_args
.size ());
859 i
= strtoul (p
+ 4, &tmp
, 10);
860 if ((i
== 0 && tmp
== p
+ 4) || errno
!= 0)
862 else if (i
>= m_args
.size ())
863 error (_("Missing argument %ld in user function."), i
);
866 new_line
.append (m_args
[i
].data (), m_args
[i
].length ());
871 /* Don't forget the tail. */
872 new_line
.append (line
);
878 /* Read next line from stdin. Passed to read_command_line_1 and
879 recurse_read_control_structure whenever we need to read commands
883 read_next_line (void)
885 struct ui
*ui
= current_ui
;
886 char *prompt_ptr
, control_prompt
[256];
888 int from_tty
= ui
->instream
== ui
->stdin_stream
;
890 if (control_level
>= 254)
891 error (_("Control nesting too deep!"));
893 /* Set a prompt based on the nesting of the control commands. */
895 || (ui
->instream
== 0 && deprecated_readline_hook
!= NULL
))
897 for (i
= 0; i
< control_level
; i
++)
898 control_prompt
[i
] = ' ';
899 control_prompt
[i
] = '>';
900 control_prompt
[i
+ 1] = '\0';
901 prompt_ptr
= (char *) &control_prompt
[0];
906 return command_line_input (prompt_ptr
, 0, "commands");
909 /* Return true if CMD's name is NAME. */
912 command_name_equals (struct cmd_list_element
*cmd
, const char *name
)
915 && cmd
!= CMD_LIST_AMBIGUOUS
916 && strcmp (cmd
->name
, name
) == 0);
919 /* Given an input line P, skip the command and return a pointer to the
923 line_first_arg (const char *p
)
925 const char *first_arg
= p
+ find_command_name_length (p
);
927 return skip_spaces (first_arg
);
930 /* Process one input line. If the command is an "end", return such an
931 indication to the caller. If PARSE_COMMANDS is true, strip leading
932 whitespace (trailing whitespace is always stripped) in the line,
933 attempt to recognize GDB control commands, and also return an
934 indication if the command is an "else" or a nop.
936 Otherwise, only "end" is recognized. */
938 static enum misc_command_type
939 process_next_line (const char *p
, struct command_line
**command
,
941 gdb::function_view
<void (const char *)> validator
)
948 /* Not sure what to do here. */
952 /* Strip trailing whitespace. */
953 p_end
= p
+ strlen (p
);
954 while (p_end
> p
&& (p_end
[-1] == ' ' || p_end
[-1] == '\t'))
958 /* Strip leading whitespace. */
959 while (p_start
< p_end
&& (*p_start
== ' ' || *p_start
== '\t'))
962 /* 'end' is always recognized, regardless of parse_commands value.
963 We also permit whitespace before end and after. */
964 if (p_end
- p_start
== 3 && startswith (p_start
, "end"))
969 /* Resolve command abbreviations (e.g. 'ws' for 'while-stepping'). */
970 const char *cmd_name
= p
;
971 struct cmd_list_element
*cmd
972 = lookup_cmd_1 (&cmd_name
, cmdlist
, NULL
, 1);
973 cmd_name
= skip_spaces (cmd_name
);
974 bool inline_cmd
= *cmd_name
!= '\0';
976 /* If commands are parsed, we skip initial spaces. Otherwise,
977 which is the case for Python commands and documentation
978 (see the 'document' command), spaces are preserved. */
981 /* Blanks and comments don't really do anything, but we need to
982 distinguish them from else, end and other commands which can
984 if (p_end
== p
|| p
[0] == '#')
987 /* Is the else clause of an if control structure? */
988 if (p_end
- p
== 4 && startswith (p
, "else"))
991 /* Check for while, if, break, continue, etc and build a new
992 command line structure for them. */
993 if (command_name_equals (cmd
, "while-stepping"))
995 /* Because validate_actionline and encode_action lookup
996 command's line as command, we need the line to
997 include 'while-stepping'.
999 For 'ws' alias, the command will have 'ws', not expanded
1000 to 'while-stepping'. This is intentional -- we don't
1001 really want frontend to send a command list with 'ws',
1002 and next break-info returning command line with
1003 'while-stepping'. This should work, but might cause the
1004 breakpoint to be marked as changed while it's actually
1006 *command
= build_command_line (while_stepping_control
, p
);
1008 else if (command_name_equals (cmd
, "while"))
1010 *command
= build_command_line (while_control
, line_first_arg (p
));
1012 else if (command_name_equals (cmd
, "if"))
1014 *command
= build_command_line (if_control
, line_first_arg (p
));
1016 else if (command_name_equals (cmd
, "commands"))
1018 *command
= build_command_line (commands_control
, line_first_arg (p
));
1020 else if (command_name_equals (cmd
, "define"))
1021 *command
= build_command_line (define_control
, line_first_arg (p
));
1022 else if (command_name_equals (cmd
, "python") && !inline_cmd
)
1024 /* Note that we ignore the inline "python command" form
1026 *command
= build_command_line (python_control
, "");
1028 else if (command_name_equals (cmd
, "compile") && !inline_cmd
)
1030 /* Note that we ignore the inline "compile command" form
1032 *command
= build_command_line (compile_control
, "");
1033 (*command
)->control_u
.compile
.scope
= COMPILE_I_INVALID_SCOPE
;
1035 else if (command_name_equals (cmd
, "guile") && !inline_cmd
)
1037 /* Note that we ignore the inline "guile command" form here. */
1038 *command
= build_command_line (guile_control
, "");
1040 else if (p_end
- p
== 10 && startswith (p
, "loop_break"))
1041 *command
= new struct command_line (break_control
);
1042 else if (p_end
- p
== 13 && startswith (p
, "loop_continue"))
1043 *command
= new struct command_line (continue_control
);
1048 if (!parse_commands
|| not_handled
)
1050 /* A normal command. */
1051 *command
= new struct command_line (simple_control
,
1052 savestring (p
, p_end
- p
));
1059 validator ((*command
)->line
);
1061 CATCH (ex
, RETURN_MASK_ALL
)
1063 free_command_lines (command
);
1064 throw_exception (ex
);
1069 /* Nothing special. */
1073 /* Recursively read in the control structures and create a
1074 command_line structure from them. Use read_next_line_func to
1075 obtain lines of the command. */
1077 static enum command_control_type
1078 recurse_read_control_structure (gdb::function_view
<const char * ()> read_next_line_func
,
1079 struct command_line
*current_cmd
,
1080 gdb::function_view
<void (const char *)> validator
)
1082 enum misc_command_type val
;
1083 enum command_control_type ret
;
1084 struct command_line
*child_tail
, *next
;
1085 counted_command_line
*current_body
= ¤t_cmd
->body_list_0
;
1089 /* Sanity checks. */
1090 if (current_cmd
->control_type
== simple_control
)
1091 error (_("Recursed on a simple control type."));
1093 /* Read lines from the input stream and build control structures. */
1099 val
= process_next_line (read_next_line_func (), &next
,
1100 current_cmd
->control_type
!= python_control
1101 && current_cmd
->control_type
!= guile_control
1102 && current_cmd
->control_type
!= compile_control
,
1105 /* Just skip blanks and comments. */
1106 if (val
== nop_command
)
1109 if (val
== end_command
)
1111 if (multi_line_command_p (current_cmd
->control_type
))
1113 /* Success reading an entire canned sequence of commands. */
1114 ret
= simple_control
;
1119 ret
= invalid_control
;
1124 /* Not the end of a control structure. */
1125 if (val
== else_command
)
1127 if (current_cmd
->control_type
== if_control
1128 && current_body
== ¤t_cmd
->body_list_0
)
1130 current_body
= ¤t_cmd
->body_list_1
;
1136 ret
= invalid_control
;
1143 child_tail
->next
= next
;
1146 *current_body
= counted_command_line (next
, command_lines_deleter ());
1150 /* If the latest line is another control structure, then recurse
1152 if (multi_line_command_p (next
->control_type
))
1155 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1159 if (ret
!= simple_control
)
1169 /* Read lines from the input stream and accumulate them in a chain of
1170 struct command_line's, which is then returned. For input from a
1171 terminal, the special command "end" is used to mark the end of the
1172 input, and is not included in the returned chain of commands.
1174 If PARSE_COMMANDS is true, strip leading whitespace (trailing whitespace
1175 is always stripped) in the line and attempt to recognize GDB control
1176 commands. Otherwise, only "end" is recognized. */
1178 #define END_MESSAGE "End with a line saying just \"end\"."
1180 counted_command_line
1181 read_command_lines (const char *prompt_arg
, int from_tty
, int parse_commands
,
1182 gdb::function_view
<void (const char *)> validator
)
1184 if (from_tty
&& input_interactive_p (current_ui
))
1186 if (deprecated_readline_begin_hook
)
1188 /* Note - intentional to merge messages with no newline. */
1189 (*deprecated_readline_begin_hook
) ("%s %s\n", prompt_arg
,
1194 printf_unfiltered ("%s\n%s\n", prompt_arg
, END_MESSAGE
);
1195 gdb_flush (gdb_stdout
);
1200 /* Reading commands assumes the CLI behavior, so temporarily
1201 override the current interpreter with CLI. */
1202 counted_command_line
head (nullptr, command_lines_deleter ());
1203 if (current_interp_named_p (INTERP_CONSOLE
))
1204 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1208 scoped_restore_interp
interp_restorer (INTERP_CONSOLE
);
1210 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1214 if (from_tty
&& input_interactive_p (current_ui
)
1215 && deprecated_readline_end_hook
)
1217 (*deprecated_readline_end_hook
) ();
1222 /* Act the same way as read_command_lines, except that each new line is
1223 obtained using READ_NEXT_LINE_FUNC. */
1225 counted_command_line
1226 read_command_lines_1 (gdb::function_view
<const char * ()> read_next_line_func
,
1228 gdb::function_view
<void (const char *)> validator
)
1230 struct command_line
*tail
, *next
;
1231 counted_command_line
head (nullptr, command_lines_deleter ());
1232 enum command_control_type ret
;
1233 enum misc_command_type val
;
1241 val
= process_next_line (read_next_line_func (), &next
, parse_commands
,
1244 /* Ignore blank lines or comments. */
1245 if (val
== nop_command
)
1248 if (val
== end_command
)
1250 ret
= simple_control
;
1254 if (val
!= ok_command
)
1256 ret
= invalid_control
;
1260 if (multi_line_command_p (next
->control_type
))
1263 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1267 if (ret
== invalid_control
)
1277 head
= counted_command_line (next
, command_lines_deleter ());
1284 if (ret
== invalid_control
)
1290 /* Free a chain of struct command_line's. */
1293 free_command_lines (struct command_line
**lptr
)
1295 struct command_line
*l
= *lptr
;
1296 struct command_line
*next
;
1307 /* Validate that *COMNAME is a valid name for a command. Return the
1308 containing command list, in case it starts with a prefix command.
1309 The prefix must already exist. *COMNAME is advanced to point after
1310 any prefix, and a NUL character overwrites the space after the
1313 static struct cmd_list_element
**
1314 validate_comname (const char **comname
)
1316 struct cmd_list_element
**list
= &cmdlist
;
1317 const char *p
, *last_word
;
1320 error_no_arg (_("name of command to define"));
1322 /* Find the last word of the argument. */
1323 p
= *comname
+ strlen (*comname
);
1324 while (p
> *comname
&& isspace (p
[-1]))
1326 while (p
> *comname
&& !isspace (p
[-1]))
1330 /* Find the corresponding command list. */
1331 if (last_word
!= *comname
)
1333 struct cmd_list_element
*c
;
1335 /* Separate the prefix and the command. */
1336 std::string
prefix (*comname
, last_word
- 1);
1337 const char *tem
= prefix
.c_str ();
1339 c
= lookup_cmd (&tem
, cmdlist
, "", 0, 1);
1340 if (c
->prefixlist
== NULL
)
1341 error (_("\"%s\" is not a prefix command."), prefix
.c_str ());
1343 list
= c
->prefixlist
;
1344 *comname
= last_word
;
1350 if (!isalnum (*p
) && *p
!= '-' && *p
!= '_')
1351 error (_("Junk in argument list: \"%s\""), p
);
1358 /* This is just a placeholder in the command data structures. */
1360 user_defined_command (const char *ignore
, int from_tty
)
1364 /* Define a user-defined command. If COMMANDS is NULL, then this is a
1365 top-level call and the commands will be read using
1366 read_command_lines. Otherwise, it is a "define" command in an
1367 existing command and the commands are provided. In the
1368 non-top-level case, various prompts and warnings are disabled. */
1371 do_define_command (const char *comname
, int from_tty
,
1372 const counted_command_line
*commands
)
1380 struct cmd_list_element
*c
, *newc
, *hookc
= 0, **list
;
1381 const char *tem
, *comfull
;
1382 int hook_type
= CMD_NO_HOOK
;
1383 int hook_name_size
= 0;
1385 #define HOOK_STRING "hook-"
1387 #define HOOK_POST_STRING "hookpost-"
1388 #define HOOK_POST_LEN 9
1391 list
= validate_comname (&comname
);
1393 /* Look it up, and verify that we got an exact match. */
1395 c
= lookup_cmd (&tem
, *list
, "", -1, 1);
1396 if (c
&& strcmp (comname
, c
->name
) != 0)
1399 if (c
&& commands
== nullptr)
1403 if (c
->theclass
== class_user
|| c
->theclass
== class_alias
)
1404 q
= query (_("Redefine command \"%s\"? "), c
->name
);
1406 q
= query (_("Really redefine built-in command \"%s\"? "), c
->name
);
1408 error (_("Command \"%s\" not redefined."), c
->name
);
1411 /* If this new command is a hook, then mark the command which it
1412 is hooking. Note that we allow hooking `help' commands, so that
1413 we can hook the `stop' pseudo-command. */
1415 if (!strncmp (comname
, HOOK_STRING
, HOOK_LEN
))
1417 hook_type
= CMD_PRE_HOOK
;
1418 hook_name_size
= HOOK_LEN
;
1420 else if (!strncmp (comname
, HOOK_POST_STRING
, HOOK_POST_LEN
))
1422 hook_type
= CMD_POST_HOOK
;
1423 hook_name_size
= HOOK_POST_LEN
;
1426 if (hook_type
!= CMD_NO_HOOK
)
1428 /* Look up cmd it hooks, and verify that we got an exact match. */
1429 tem
= comname
+ hook_name_size
;
1430 hookc
= lookup_cmd (&tem
, *list
, "", -1, 0);
1431 if (hookc
&& strcmp (comname
+ hook_name_size
, hookc
->name
) != 0)
1433 if (!hookc
&& commands
== nullptr)
1435 warning (_("Your new `%s' command does not "
1436 "hook any existing command."),
1438 if (!query (_("Proceed? ")))
1439 error (_("Not confirmed."));
1443 comname
= xstrdup (comname
);
1445 counted_command_line cmds
;
1446 if (commands
== nullptr)
1449 = string_printf ("Type commands for definition of \"%s\".", comfull
);
1450 cmds
= read_command_lines (prompt
.c_str (), from_tty
, 1, 0);
1455 newc
= add_cmd (comname
, class_user
, user_defined_command
,
1456 (c
&& c
->theclass
== class_user
)
1457 ? c
->doc
: xstrdup ("User-defined."), list
);
1458 newc
->user_commands
= std::move (cmds
);
1460 /* If this new command is a hook, then mark both commands as being
1467 hookc
->hook_pre
= newc
; /* Target gets hooked. */
1468 newc
->hookee_pre
= hookc
; /* We are marked as hooking target cmd. */
1471 hookc
->hook_post
= newc
; /* Target gets hooked. */
1472 newc
->hookee_post
= hookc
; /* We are marked as hooking
1476 /* Should never come here as hookc would be 0. */
1477 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1483 define_command (const char *comname
, int from_tty
)
1485 do_define_command (comname
, from_tty
, nullptr);
1489 document_command (const char *comname
, int from_tty
)
1491 struct cmd_list_element
*c
, **list
;
1493 const char *comfull
;
1496 list
= validate_comname (&comname
);
1499 c
= lookup_cmd (&tem
, *list
, "", 0, 1);
1501 if (c
->theclass
!= class_user
)
1502 error (_("Command \"%s\" is built-in."), comfull
);
1504 std::string prompt
= string_printf ("Type documentation for \"%s\".",
1506 counted_command_line doclines
= read_command_lines (prompt
.c_str (),
1510 xfree ((char *) c
->doc
);
1513 struct command_line
*cl1
;
1517 for (cl1
= doclines
.get (); cl1
; cl1
= cl1
->next
)
1518 len
+= strlen (cl1
->line
) + 1;
1520 doc
= (char *) xmalloc (len
+ 1);
1523 for (cl1
= doclines
.get (); cl1
; cl1
= cl1
->next
)
1525 strcat (doc
, cl1
->line
);
1534 /* Used to implement source_command. */
1537 script_from_file (FILE *stream
, const char *file
)
1540 internal_error (__FILE__
, __LINE__
, _("called with NULL file pointer!"));
1542 scoped_restore restore_line_number
1543 = make_scoped_restore (&source_line_number
, 0);
1544 scoped_restore resotre_file
1545 = make_scoped_restore (&source_file_name
, file
);
1547 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
1551 read_command_file (stream
);
1553 CATCH (e
, RETURN_MASK_ERROR
)
1555 /* Re-throw the error, but with the file name information
1557 throw_error (e
.error
,
1558 _("%s:%d: Error in sourced command file:\n%s"),
1559 source_file_name
, source_line_number
, e
.message
);
1564 /* Print the definition of user command C to STREAM. Or, if C is a
1565 prefix command, show the definitions of all user commands under C
1566 (recursively). PREFIX and NAME combined are the name of the
1569 show_user_1 (struct cmd_list_element
*c
, const char *prefix
, const char *name
,
1570 struct ui_file
*stream
)
1572 struct command_line
*cmdlines
;
1574 if (c
->prefixlist
!= NULL
)
1576 const char *prefixname
= c
->prefixname
;
1578 for (c
= *c
->prefixlist
; c
!= NULL
; c
= c
->next
)
1579 if (c
->theclass
== class_user
|| c
->prefixlist
!= NULL
)
1580 show_user_1 (c
, prefixname
, c
->name
, gdb_stdout
);
1584 cmdlines
= c
->user_commands
.get ();
1585 fprintf_filtered (stream
, "User command \"%s%s\":\n", prefix
, name
);
1589 print_command_lines (current_uiout
, cmdlines
, 1);
1590 fputs_filtered ("\n", stream
);
1594 _initialize_cli_script (void)
1596 add_com ("document", class_support
, document_command
, _("\
1597 Document a user-defined command.\n\
1598 Give command name as argument. Give documentation on following lines.\n\
1599 End with a line of just \"end\"."));
1600 add_com ("define", class_support
, define_command
, _("\
1601 Define a new command name. Command name is argument.\n\
1602 Definition appears on following lines, one command per line.\n\
1603 End with a line of just \"end\".\n\
1604 Use the \"document\" command to give documentation for the new command.\n\
1605 Commands defined in this way may accept an unlimited number of arguments\n\
1606 accessed via $arg0 .. $argN. $argc tells how many arguments have\n\
1609 add_com ("while", class_support
, while_command
, _("\
1610 Execute nested commands WHILE the conditional expression is non zero.\n\
1611 The conditional expression must follow the word `while' and must in turn be\n\
1612 followed by a new line. The nested commands must be entered one per line,\n\
1613 and should be terminated by the word `end'."));
1615 add_com ("if", class_support
, if_command
, _("\
1616 Execute nested commands once IF the conditional expression is non zero.\n\
1617 The conditional expression must follow the word `if' and must in turn be\n\
1618 followed by a new line. The nested commands must be entered one per line,\n\
1619 and should be terminated by the word 'else' or `end'. If an else clause\n\
1620 is used, the same rules apply to its nested commands as to the first ones."));