1 /* GDB CLI command scripting.
3 Copyright (C) 1986-2023 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "breakpoint.h"
27 #include "tracepoint.h"
28 #include "cli/cli-cmds.h"
29 #include "cli/cli-decode.h"
30 #include "cli/cli-script.h"
31 #include "cli/cli-style.h"
34 #include "extension.h"
36 #include "compile/compile.h"
37 #include "gdbsupport/gdb_string_view.h"
38 #include "python/python.h"
39 #include "guile/guile.h"
43 /* Prototypes for local functions. */
45 static enum command_control_type
46 recurse_read_control_structure
47 (read_next_line_ftype read_next_line_func,
48 struct command_line *current_cmd,
49 gdb::function_view<void (const char *)> validator);
51 static void do_define_command (const char *comname, int from_tty,
52 const counted_command_line *commands);
54 static void do_document_command (const char *comname, int from_tty,
55 const counted_command_line *commands);
57 static const char *read_next_line (std::string &buffer);
59 /* Level of control structure when reading. */
60 static int control_level;
62 /* Level of control structure when executing. */
63 static int command_nest_depth = 1;
65 /* This is to prevent certain commands being printed twice. */
66 static int suppress_next_print_command_trace = 0;
68 /* Command element for the 'while' command. */
69 static cmd_list_element *while_cmd_element = nullptr;
71 /* Command element for the 'if' command. */
72 static cmd_list_element *if_cmd_element = nullptr;
74 /* Command element for the 'define' command. */
75 static cmd_list_element *define_cmd_element = nullptr;
77 /* Command element for the 'document' command. */
78 static cmd_list_element *document_cmd_element = nullptr;
80 /* Structure for arguments to user defined functions. */
85 /* Save the command line and store the locations of arguments passed
86 to the user defined function. */
87 explicit user_args (const char *line);
89 /* Insert the stored user defined arguments into the $arg arguments
91 std::string insert_args (const char *line) const;
94 /* Disable copy/assignment. (Since the elements of A point inside
95 COMMAND, copying would need to reconstruct the A vector in the
97 user_args (const user_args &) =delete;
98 user_args &operator= (const user_args &) =delete;
100 /* It is necessary to store a copy of the command line to ensure
101 that the arguments are not overwritten before they are used. */
102 std::string m_command_line;
104 /* The arguments. Each element points inside M_COMMAND_LINE. */
105 std::vector<gdb::string_view> m_args;
108 /* The stack of arguments passed to user defined functions. We need a
109 stack because user-defined functions can call other user-defined
111 static std::vector<std::unique_ptr<user_args>> user_args_stack;
113 /* An RAII-base class used to push/pop args on the user args
115 struct scoped_user_args_level
117 /* Parse the command line and push the arguments in the user args
119 explicit scoped_user_args_level (const char *line)
121 user_args_stack.emplace_back (new user_args (line));
124 /* Pop the current user arguments from the stack. */
125 ~scoped_user_args_level ()
127 user_args_stack.pop_back ();
132 /* Return non-zero if TYPE is a multi-line command (i.e., is terminated
136 multi_line_command_p (enum command_control_type type)
142 case while_stepping_control:
143 case commands_control:
144 case compile_control:
148 case document_control:
155 /* Allocate, initialize a new command line structure for one of the
156 control commands (if/while). */
158 static command_line_up
159 build_command_line (enum command_control_type type, const char *args)
161 if (args == NULL || *args == '\0')
163 if (type == if_control)
164 error (_("if command requires an argument."));
165 else if (type == while_control)
166 error (_("while command requires an argument."));
167 else if (type == define_control)
168 error (_("define command requires an argument."));
169 else if (type == document_control)
170 error (_("document command requires an argument."));
172 gdb_assert (args != NULL);
174 return command_line_up (new command_line (type, xstrdup (args)));
177 /* Build and return a new command structure for the control commands
178 such as "if" and "while". */
181 get_command_line (enum command_control_type type, const char *arg)
183 /* Allocate and build a new command line structure. */
184 counted_command_line cmd (build_command_line (type, arg).release (),
185 command_lines_deleter ());
187 /* Read in the body of this command. */
188 if (recurse_read_control_structure (read_next_line, cmd.get (), 0)
191 warning (_("Error reading in canned sequence of commands."));
198 /* Recursively print a command (including full control structures). */
201 print_command_lines (struct ui_out *uiout, struct command_line *cmd,
204 struct command_line *list;
210 uiout->spaces (2 * depth);
212 /* A simple command, print it and continue. */
213 if (list->control_type == simple_control)
215 uiout->field_string (NULL, list->line);
221 /* loop_continue to jump to the start of a while loop, print it
223 if (list->control_type == continue_control)
225 uiout->field_string (NULL, "loop_continue");
231 /* loop_break to break out of a while loop, print it and
233 if (list->control_type == break_control)
235 uiout->field_string (NULL, "loop_break");
241 /* A while command. Recursively print its subcommands and
243 if (list->control_type == while_control
244 || list->control_type == while_stepping_control)
246 /* For while-stepping, the line includes the 'while-stepping'
247 token. See comment in process_next_line for explanation.
248 Here, take care not print 'while-stepping' twice. */
249 if (list->control_type == while_control)
250 uiout->field_fmt (NULL, "while %s", list->line);
252 uiout->field_string (NULL, list->line);
254 print_command_lines (uiout, list->body_list_0.get (), depth + 1);
256 uiout->spaces (2 * depth);
257 uiout->field_string (NULL, "end");
263 /* An if command. Recursively print both arms before
265 if (list->control_type == if_control)
267 uiout->field_fmt (NULL, "if %s", list->line);
270 print_command_lines (uiout, list->body_list_0.get (), depth + 1);
272 /* Show the false arm if it exists. */
273 if (list->body_list_1 != nullptr)
276 uiout->spaces (2 * depth);
277 uiout->field_string (NULL, "else");
279 print_command_lines (uiout, list->body_list_1.get (), depth + 1);
283 uiout->spaces (2 * depth);
284 uiout->field_string (NULL, "end");
290 /* A commands command. Print the breakpoint commands and
292 if (list->control_type == commands_control)
295 uiout->field_fmt (NULL, "commands %s", list->line);
297 uiout->field_string (NULL, "commands");
299 print_command_lines (uiout, list->body_list_0.get (), depth + 1);
301 uiout->spaces (2 * depth);
302 uiout->field_string (NULL, "end");
308 if (list->control_type == python_control)
310 uiout->field_string (NULL, "python");
312 /* Don't indent python code at all. */
313 print_command_lines (uiout, list->body_list_0.get (), 0);
315 uiout->spaces (2 * depth);
316 uiout->field_string (NULL, "end");
322 if (list->control_type == compile_control)
324 uiout->field_string (NULL, "compile expression");
326 print_command_lines (uiout, list->body_list_0.get (), 0);
328 uiout->spaces (2 * depth);
329 uiout->field_string (NULL, "end");
335 if (list->control_type == guile_control)
337 uiout->field_string (NULL, "guile");
339 print_command_lines (uiout, list->body_list_0.get (), depth + 1);
341 uiout->spaces (2 * depth);
342 uiout->field_string (NULL, "end");
348 /* Ignore illegal command type and try next. */
353 /* Handle pre-post hooks. */
355 class scoped_restore_hook_in
359 scoped_restore_hook_in (struct cmd_list_element *c)
364 ~scoped_restore_hook_in ()
369 scoped_restore_hook_in (const scoped_restore_hook_in &) = delete;
370 scoped_restore_hook_in &operator= (const scoped_restore_hook_in &) = delete;
374 struct cmd_list_element *m_cmd;
378 execute_cmd_pre_hook (struct cmd_list_element *c)
380 if ((c->hook_pre) && (!c->hook_in))
382 scoped_restore_hook_in restore_hook (c);
383 c->hook_in = 1; /* Prevent recursive hooking. */
384 execute_user_command (c->hook_pre, nullptr);
389 execute_cmd_post_hook (struct cmd_list_element *c)
391 if ((c->hook_post) && (!c->hook_in))
393 scoped_restore_hook_in restore_hook (c);
394 c->hook_in = 1; /* Prevent recursive hooking. */
395 execute_user_command (c->hook_post, nullptr);
399 /* See cli-script.h. */
402 execute_control_commands (struct command_line *cmdlines, int from_tty)
404 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);
410 enum command_control_type ret = execute_control_command (cmdlines,
412 if (ret != simple_control && ret != break_control)
414 warning (_("Error executing canned sequence of commands."));
417 cmdlines = cmdlines->next;
421 /* See cli-script.h. */
424 execute_control_commands_to_string (struct command_line *commands,
429 execute_fn_to_string (result, [&] ()
431 execute_control_commands (commands, from_tty);
438 execute_user_command (struct cmd_list_element *c, const char *args)
440 counted_command_line cmdlines_copy;
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 /* Set the instream to nullptr, indicating execution of a
456 user-defined function. */
457 scoped_restore restore_instream
458 = make_scoped_restore (¤t_ui->instream, nullptr);
460 execute_control_commands (cmdlines, 0);
463 /* This function is called every time GDB prints a prompt. It ensures
464 that errors and the like do not confuse the command tracing. */
467 reset_command_nest_depth (void)
469 command_nest_depth = 1;
472 suppress_next_print_command_trace = 0;
475 /* Print the command, prefixed with '+' to represent the call depth.
476 This is slightly complicated because this function may be called
477 from execute_command and execute_control_command. Unfortunately
478 execute_command also prints the top level control commands.
479 In these cases execute_command will call execute_control_command
480 via while_command or if_command. Inner levels of 'if' and 'while'
481 are dealt with directly. Therefore we can use these functions
482 to determine whether the command has been printed already or not. */
483 ATTRIBUTE_PRINTF (1, 2)
485 print_command_trace (const char *fmt, ...)
489 if (suppress_next_print_command_trace)
491 suppress_next_print_command_trace = 0;
495 if (!source_verbose && !trace_commands)
498 for (i=0; i < command_nest_depth; i++)
503 va_start (args, fmt);
504 gdb_vprintf (fmt, args);
509 /* Helper for execute_control_command. */
511 static enum command_control_type
512 execute_control_command_1 (struct command_line *cmd, int from_tty)
514 struct command_line *current;
516 enum command_control_type ret;
518 /* Start by assuming failure, if a problem is detected, the code
519 below will simply "break" out of the switch. */
520 ret = invalid_control;
522 switch (cmd->control_type)
526 /* A simple command, execute it and return. */
527 std::string new_line = insert_user_defined_cmd_args (cmd->line);
528 execute_command (new_line.c_str (), from_tty);
529 ret = cmd->control_type;
533 case continue_control:
534 print_command_trace ("loop_continue");
536 /* Return for "continue", and "break" so we can either
537 continue the loop at the top, or break out. */
538 ret = cmd->control_type;
542 print_command_trace ("loop_break");
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;
551 print_command_trace ("while %s", cmd->line);
553 /* Parse the loop control expression for the while statement. */
554 std::string new_line = insert_user_defined_cmd_args (cmd->line);
555 expression_up expr = parse_expression (new_line.c_str ());
557 ret = simple_control;
560 /* Keep iterating so long as the expression is true. */
567 /* Evaluate the expression. */
569 scoped_value_mark mark;
570 value *val = evaluate_expression (expr.get ());
571 cond_result = value_true (val);
574 /* If the value is false, then break out of the loop. */
578 /* Execute the body of the while statement. */
579 current = cmd->body_list_0.get ();
582 scoped_restore save_nesting
583 = make_scoped_restore (&command_nest_depth, command_nest_depth + 1);
584 ret = execute_control_command_1 (current, from_tty);
586 /* If we got an error, or a "break" command, then stop
588 if (ret == invalid_control || ret == break_control)
594 /* If we got a "continue" command, then restart the loop
596 if (ret == continue_control)
599 /* Get the next statement. */
600 current = current->next;
604 /* Reset RET so that we don't recurse the break all the way down. */
605 if (ret == break_control)
606 ret = simple_control;
613 print_command_trace ("if %s", cmd->line);
615 /* Parse the conditional for the if statement. */
616 std::string new_line = insert_user_defined_cmd_args (cmd->line);
617 expression_up expr = parse_expression (new_line.c_str ());
620 ret = simple_control;
622 /* Evaluate the conditional. */
624 scoped_value_mark mark;
625 value *val = evaluate_expression (expr.get ());
627 /* Choose which arm to take commands from based on the value
628 of the conditional expression. */
629 if (value_true (val))
630 current = cmd->body_list_0.get ();
631 else if (cmd->body_list_1 != nullptr)
632 current = cmd->body_list_1.get ();
635 /* Execute commands in the given arm. */
638 scoped_restore save_nesting
639 = make_scoped_restore (&command_nest_depth, command_nest_depth + 1);
640 ret = execute_control_command_1 (current, from_tty);
642 /* If we got an error, get out. */
643 if (ret != simple_control)
646 /* Get the next statement in the body. */
647 current = current->next;
653 case commands_control:
655 /* Breakpoint commands list, record the commands in the
656 breakpoint's command list and return. */
657 std::string new_line = insert_user_defined_cmd_args (cmd->line);
658 ret = commands_from_control_command (new_line.c_str (), cmd);
662 case compile_control:
663 eval_compile_command (cmd, NULL, cmd->control_u.compile.scope,
664 cmd->control_u.compile.scope_data);
665 ret = simple_control;
669 print_command_trace ("define %s", cmd->line);
670 do_define_command (cmd->line, 0, &cmd->body_list_0);
671 ret = simple_control;
674 case document_control:
675 print_command_trace ("document %s", cmd->line);
676 do_document_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
897 read_next_line (std::string &buffer)
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 (buffer, 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, command_line_up *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, 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 == document_cmd_element)
1021 *command = build_command_line (document_control, line_first_arg (p));
1022 else if (cmd == python_cmd_element && !inline_cmd)
1024 /* Note that we ignore the inline "python command" form
1026 *command = build_command_line (python_control, "");
1028 else if (cmd == compile_cmd_element && !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 (cmd == guile_cmd_element && !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 = command_line_up (new command_line (break_control));
1042 else if (p_end - p == 13 && startswith (p, "loop_continue"))
1043 *command = command_line_up (new command_line (continue_control));
1048 if (!parse_commands || not_handled)
1050 /* A normal command. */
1051 *command = command_line_up (new command_line (simple_control,
1052 savestring (p, p_end - p)));
1056 validator ((*command)->line);
1058 /* Nothing special. */
1062 /* Recursively read in the control structures and create a
1063 command_line structure from them. Use read_next_line_func to
1064 obtain lines of the command. */
1066 static enum command_control_type
1067 recurse_read_control_structure (read_next_line_ftype read_next_line_func,
1068 struct command_line *current_cmd,
1069 gdb::function_view<void (const char *)> validator)
1071 enum misc_command_type val;
1072 enum command_control_type ret;
1073 struct command_line *child_tail;
1074 counted_command_line *current_body = ¤t_cmd->body_list_0;
1075 command_line_up next;
1077 child_tail = nullptr;
1079 /* Sanity checks. */
1080 if (current_cmd->control_type == simple_control)
1081 error (_("Recursed on a simple control type."));
1083 /* Read lines from the input stream and build control structures. */
1090 val = process_next_line (read_next_line_func (buffer), &next,
1091 current_cmd->control_type != python_control
1092 && current_cmd->control_type != guile_control
1093 && current_cmd->control_type != compile_control,
1096 /* Just skip blanks and comments. */
1097 if (val == nop_command)
1100 if (val == end_command)
1102 if (multi_line_command_p (current_cmd->control_type))
1104 /* Success reading an entire canned sequence of commands. */
1105 ret = simple_control;
1110 ret = invalid_control;
1115 /* Not the end of a control structure. */
1116 if (val == else_command)
1118 if (current_cmd->control_type == if_control
1119 && current_body == ¤t_cmd->body_list_0)
1121 current_body = ¤t_cmd->body_list_1;
1122 child_tail = nullptr;
1127 ret = invalid_control;
1132 /* Transfer ownership of NEXT to the command's body list. */
1133 if (child_tail != nullptr)
1135 child_tail->next = next.release ();
1136 child_tail = child_tail->next;
1140 child_tail = next.get ();
1141 *current_body = counted_command_line (next.release (),
1142 command_lines_deleter ());
1145 /* If the latest line is another control structure, then recurse
1147 if (multi_line_command_p (child_tail->control_type))
1150 ret = recurse_read_control_structure (read_next_line_func,
1155 if (ret != simple_control)
1165 /* Read lines from the input stream and accumulate them in a chain of
1166 struct command_line's, which is then returned. For input from a
1167 terminal, the special command "end" is used to mark the end of the
1168 input, and is not included in the returned chain of commands.
1170 If PARSE_COMMANDS is true, strip leading whitespace (trailing whitespace
1171 is always stripped) in the line and attempt to recognize GDB control
1172 commands. Otherwise, only "end" is recognized. */
1174 #define END_MESSAGE "End with a line saying just \"end\"."
1176 counted_command_line
1177 read_command_lines (const char *prompt_arg, int from_tty, int parse_commands,
1178 gdb::function_view<void (const char *)> validator)
1180 if (from_tty && current_ui->input_interactive_p ())
1182 if (deprecated_readline_begin_hook)
1184 /* Note - intentional to merge messages with no newline. */
1185 (*deprecated_readline_begin_hook) ("%s %s\n", prompt_arg,
1189 printf_unfiltered ("%s\n%s\n", prompt_arg, END_MESSAGE);
1193 /* Reading commands assumes the CLI behavior, so temporarily
1194 override the current interpreter with CLI. */
1195 counted_command_line head (nullptr, command_lines_deleter ());
1196 if (current_interp_named_p (INTERP_CONSOLE))
1197 head = read_command_lines_1 (read_next_line, parse_commands,
1201 scoped_restore_interp interp_restorer (INTERP_CONSOLE);
1203 head = read_command_lines_1 (read_next_line, parse_commands,
1207 if (from_tty && current_ui->input_interactive_p ()
1208 && deprecated_readline_end_hook)
1210 (*deprecated_readline_end_hook) ();
1215 /* Act the same way as read_command_lines, except that each new line is
1216 obtained using READ_NEXT_LINE_FUNC. */
1218 counted_command_line
1219 read_command_lines_1 (read_next_line_ftype read_next_line_func,
1221 gdb::function_view<void (const char *)> validator)
1223 struct command_line *tail;
1224 counted_command_line head (nullptr, command_lines_deleter ());
1225 enum command_control_type ret;
1226 enum misc_command_type val;
1227 command_line_up next;
1237 val = process_next_line (read_next_line_func (buffer), &next, parse_commands,
1240 /* Ignore blank lines or comments. */
1241 if (val == nop_command)
1244 if (val == end_command)
1246 ret = simple_control;
1250 if (val != ok_command)
1252 ret = invalid_control;
1256 if (multi_line_command_p (next->control_type))
1259 ret = recurse_read_control_structure (read_next_line_func, next.get (),
1263 if (ret == invalid_control)
1267 /* Transfer ownership of NEXT to the HEAD list. */
1270 tail->next = next.release ();
1276 head = counted_command_line (next.release (),
1277 command_lines_deleter ());
1283 if (ret == invalid_control)
1289 /* Free a chain of struct command_line's. */
1292 free_command_lines (struct command_line **lptr)
1294 struct command_line *l = *lptr;
1295 struct command_line *next;
1306 /* Validate that *COMNAME is a valid name for a command. Return the
1307 containing command list, in case it starts with a prefix command.
1308 The prefix must already exist. *COMNAME is advanced to point after
1309 any prefix, and a NUL character overwrites the space after the
1312 static struct cmd_list_element **
1313 validate_comname (const char **comname)
1315 struct cmd_list_element **list = &cmdlist;
1316 const char *p, *last_word;
1319 error_no_arg (_("name of command to define"));
1321 /* Find the last word of the argument. */
1322 p = *comname + strlen (*comname);
1323 while (p > *comname && isspace (p[-1]))
1325 while (p > *comname && !isspace (p[-1]))
1329 /* Find the corresponding command list. */
1330 if (last_word != *comname)
1332 struct cmd_list_element *c;
1334 /* Separate the prefix and the command. */
1335 std::string prefix (*comname, last_word - 1);
1336 const char *tem = prefix.c_str ();
1338 c = lookup_cmd (&tem, cmdlist, "", NULL, 0, 1);
1339 if (!c->is_prefix ())
1340 error (_("\"%s\" is not a prefix command."), prefix.c_str ());
1342 list = c->subcommands;
1343 *comname = last_word;
1349 if (!valid_cmd_char_p (*p))
1350 error (_("Junk in argument list: \"%s\""), p);
1357 /* This is just a placeholder in the command data structures. */
1359 user_defined_command (const char *ignore, int from_tty)
1363 /* Define a user-defined command. If COMMANDS is NULL, then this is a
1364 top-level call and the commands will be read using
1365 read_command_lines. Otherwise, it is a "define" command in an
1366 existing command and the commands are provided. In the
1367 non-top-level case, various prompts and warnings are disabled. */
1370 do_define_command (const char *comname, int from_tty,
1371 const counted_command_line *commands)
1379 struct cmd_list_element *c, *newc, *hookc = 0, **list;
1380 const char *comfull;
1381 int hook_type = CMD_NO_HOOK;
1382 int hook_name_size = 0;
1384 #define HOOK_STRING "hook-"
1386 #define HOOK_POST_STRING "hookpost-"
1387 #define HOOK_POST_LEN 9
1390 list = validate_comname (&comname);
1392 c = lookup_cmd_exact (comname, *list);
1394 if (c && commands == nullptr)
1398 if (c->theclass == class_user || c->theclass == class_alias)
1400 /* if C is a prefix command that was previously defined,
1401 tell the user its subcommands will be kept, and ask
1402 if ok to redefine the command. */
1403 if (c->is_prefix ())
1404 q = (c->user_commands.get () == nullptr
1405 || query (_("Keeping subcommands of prefix command \"%s\".\n"
1406 "Redefine command \"%s\"? "), c->name, c->name));
1408 q = query (_("Redefine command \"%s\"? "), c->name);
1411 q = query (_("Really redefine built-in command \"%s\"? "), c->name);
1413 error (_("Command \"%s\" not redefined."), c->name);
1416 /* If this new command is a hook, then mark the command which it
1417 is hooking. Note that we allow hooking `help' commands, so that
1418 we can hook the `stop' pseudo-command. */
1420 if (!strncmp (comname, HOOK_STRING, HOOK_LEN))
1422 hook_type = CMD_PRE_HOOK;
1423 hook_name_size = HOOK_LEN;
1425 else if (!strncmp (comname, HOOK_POST_STRING, HOOK_POST_LEN))
1427 hook_type = CMD_POST_HOOK;
1428 hook_name_size = HOOK_POST_LEN;
1431 if (hook_type != CMD_NO_HOOK)
1433 /* Look up cmd it hooks. */
1434 hookc = lookup_cmd_exact (comname + hook_name_size, *list,
1435 /* ignore_help_classes = */ false);
1436 if (!hookc && commands == nullptr)
1438 warning (_("Your new `%s' command does not "
1439 "hook any existing command."),
1441 if (!query (_("Proceed? ")))
1442 error (_("Not confirmed."));
1446 comname = xstrdup (comname);
1448 counted_command_line cmds;
1449 if (commands == nullptr)
1452 = string_printf ("Type commands for definition of \"%s\".", comfull);
1453 cmds = read_command_lines (prompt.c_str (), from_tty, 1, 0);
1459 struct cmd_list_element **c_subcommands
1460 = c == nullptr ? nullptr : c->subcommands;
1462 newc = add_cmd (comname, class_user, user_defined_command,
1463 (c != nullptr && c->theclass == class_user)
1464 ? c->doc : xstrdup ("User-defined."), list);
1465 newc->user_commands = std::move (cmds);
1467 /* If we define or re-define a command that was previously defined
1468 as a prefix, keep the prefix information. */
1469 if (c_subcommands != nullptr)
1471 newc->subcommands = c_subcommands;
1472 /* allow_unknown: see explanation in equivalent logic in
1473 define_prefix_command (). */
1474 newc->allow_unknown = newc->user_commands.get () != nullptr;
1478 /* If this new command is a hook, then mark both commands as being
1485 hookc->hook_pre = newc; /* Target gets hooked. */
1486 newc->hookee_pre = hookc; /* We are marked as hooking target cmd. */
1489 hookc->hook_post = newc; /* Target gets hooked. */
1490 newc->hookee_post = hookc; /* We are marked as hooking
1494 /* Should never come here as hookc would be 0. */
1495 internal_error (_("bad switch"));
1501 define_command (const char *comname, int from_tty)
1503 do_define_command (comname, from_tty, nullptr);
1506 /* Document a user-defined command or user defined alias. If COMMANDS is NULL,
1507 then this is a top-level call and the document will be read using
1508 read_command_lines. Otherwise, it is a "document" command in an existing
1509 command and the commands are provided. */
1511 do_document_command (const char *comname, int from_tty,
1512 const counted_command_line *commands)
1514 struct cmd_list_element *alias, *prefix_cmd, *c;
1515 const char *comfull;
1518 validate_comname (&comname);
1520 lookup_cmd_composition (comfull, &alias, &prefix_cmd, &c);
1522 error (_("Undefined command: \"%s\"."), comfull);
1524 if (c->theclass != class_user
1525 && (alias == nullptr || alias->theclass != class_alias))
1527 if (alias == nullptr)
1528 error (_("Command \"%s\" is built-in."), comfull);
1530 error (_("Alias \"%s\" is built-in."), comfull);
1533 /* If we found an alias of class_alias, the user is documenting this
1534 user-defined alias. */
1535 if (alias != nullptr)
1538 counted_command_line doclines;
1540 if (commands == nullptr)
1543 = string_printf ("Type documentation for \"%s\".", comfull);
1544 doclines = read_command_lines (prompt.c_str (), from_tty, 0, 0);
1547 doclines = *commands;
1549 if (c->doc_allocated)
1550 xfree ((char *) c->doc);
1553 struct command_line *cl1;
1557 for (cl1 = doclines.get (); cl1; cl1 = cl1->next)
1558 len += strlen (cl1->line) + 1;
1560 doc = (char *) xmalloc (len + 1);
1563 for (cl1 = doclines.get (); cl1; cl1 = cl1->next)
1565 strcat (doc, cl1->line);
1571 c->doc_allocated = 1;
1576 document_command (const char *comname, int from_tty)
1578 do_document_command (comname, from_tty, nullptr);
1581 /* Implementation of the "define-prefix" command. */
1584 define_prefix_command (const char *comname, int from_tty)
1586 struct cmd_list_element *c, **list;
1587 const char *comfull;
1590 list = validate_comname (&comname);
1592 c = lookup_cmd_exact (comname, *list);
1594 if (c != nullptr && c->theclass != class_user)
1595 error (_("Command \"%s\" is built-in."), comfull);
1597 if (c != nullptr && c->is_prefix ())
1599 /* c is already a user defined prefix command. */
1603 /* If the command does not exist at all, create it. */
1606 comname = xstrdup (comname);
1607 c = add_cmd (comname, class_user, user_defined_command,
1608 xstrdup ("User-defined."), list);
1611 /* Allocate the c->subcommands, which marks the command as a prefix
1613 c->subcommands = new struct cmd_list_element*;
1614 *(c->subcommands) = nullptr;
1615 /* If the prefix command C is not a command, then it must be followed
1616 by known subcommands. Otherwise, if C is also a normal command,
1617 it can be followed by C args that must not cause a 'subcommand'
1618 not recognised error, and thus we must allow unknown. */
1619 c->allow_unknown = c->user_commands.get () != nullptr;
1623 /* Used to implement source_command. */
1626 script_from_file (FILE *stream, const char *file)
1629 internal_error (_("called with NULL file pointer!"));
1631 scoped_restore restore_line_number
1632 = make_scoped_restore (&source_line_number, 0);
1633 scoped_restore restore_file
1634 = make_scoped_restore<std::string, const std::string &> (&source_file_name,
1637 scoped_restore save_async = make_scoped_restore (¤t_ui->async, 0);
1641 read_command_file (stream);
1643 catch (const gdb_exception_error &e)
1645 /* Re-throw the error, but with the file name information
1647 throw_error (e.error,
1648 _("%s:%d: Error in sourced command file:\n%s"),
1649 source_file_name.c_str (), source_line_number,
1654 /* Print the definition of user command C to STREAM. Or, if C is a
1655 prefix command, show the definitions of all user commands under C
1656 (recursively). PREFIX and NAME combined are the name of the
1659 show_user_1 (struct cmd_list_element *c, const char *prefix, const char *name,
1660 struct ui_file *stream)
1662 if (cli_user_command_p (c))
1664 struct command_line *cmdlines = c->user_commands.get ();
1666 gdb_printf (stream, "User %scommand \"",
1667 c->is_prefix () ? "prefix" : "");
1668 fprintf_styled (stream, title_style.style (), "%s%s",
1670 gdb_printf (stream, "\":\n");
1673 print_command_lines (current_uiout, cmdlines, 1);
1674 gdb_puts ("\n", stream);
1678 if (c->is_prefix ())
1680 const std::string prefixname = c->prefixname ();
1682 for (c = *c->subcommands; c != NULL; c = c->next)
1683 if (c->theclass == class_user || c->is_prefix ())
1684 show_user_1 (c, prefixname.c_str (), c->name, gdb_stdout);
1689 void _initialize_cli_script ();
1691 _initialize_cli_script ()
1693 struct cmd_list_element *c;
1695 /* "document", "define" and "define-prefix" use command_completer,
1696 as this helps the user to either type the command name and/or
1698 document_cmd_element = add_com ("document", class_support, document_command,
1700 Document a user-defined command or user-defined alias.\n\
1701 Give command or alias name as argument. Give documentation on following lines.\n\
1702 End with a line of just \"end\"."));
1703 set_cmd_completer (document_cmd_element, command_completer);
1704 define_cmd_element = add_com ("define", class_support, define_command, _("\
1705 Define a new command name. Command name is argument.\n\
1706 Definition appears on following lines, one command per line.\n\
1707 End with a line of just \"end\".\n\
1708 Use the \"document\" command to give documentation for the new command.\n\
1709 Commands defined in this way may accept an unlimited number of arguments\n\
1710 accessed via $arg0 .. $argN. $argc tells how many arguments have\n\
1712 set_cmd_completer (define_cmd_element, command_completer);
1713 c = add_com ("define-prefix", class_support, define_prefix_command,
1715 Define or mark a command as a user-defined prefix command.\n\
1716 User defined prefix commands can be used as prefix commands for\n\
1717 other user defined commands.\n\
1718 If the command already exists, it is changed to a prefix command."));
1719 set_cmd_completer (c, command_completer);
1721 while_cmd_element = add_com ("while", class_support, while_command, _("\
1722 Execute nested commands WHILE the conditional expression is non zero.\n\
1723 The conditional expression must follow the word `while' and must in turn be\n\
1724 followed by a new line. The nested commands must be entered one per line,\n\
1725 and should be terminated by the word `end'."));
1727 if_cmd_element = add_com ("if", class_support, if_command, _("\
1728 Execute nested commands once IF the conditional expression is non zero.\n\
1729 The conditional expression must follow the word `if' and must in turn be\n\
1730 followed by a new line. The nested commands must be entered one per line,\n\
1731 and should be terminated by the word 'else' or `end'. If an else clause\n\
1732 is used, the same rules apply to its nested commands as to the first ones."));