1 /* GDB CLI command scripting.
3 Copyright (C) 1986-2017 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"
38 /* Prototypes for local functions. */
40 static enum command_control_type
41 recurse_read_control_structure (char * (*read_next_line_func) (void),
42 struct command_line *current_cmd,
43 void (*validator)(char *, void *),
46 static char *read_next_line (void);
48 /* Level of control structure when reading. */
49 static int control_level;
51 /* Level of control structure when executing. */
52 static int command_nest_depth = 1;
54 /* This is to prevent certain commands being printed twice. */
55 static int suppress_next_print_command_trace = 0;
57 /* A non-owning slice of a string. */
61 string_view (const char *str_, size_t len_)
62 : str (str_), len (len_)
69 /* Structure for arguments to user defined functions. */
74 /* Save the command line and store the locations of arguments passed
75 to the user defined function. */
76 explicit user_args (const char *line);
78 /* Insert the stored user defined arguments into the $arg arguments
80 std::string insert_args (const char *line) const;
83 /* Disable copy/assignment. (Since the elements of A point inside
84 COMMAND, copying would need to reconstruct the A vector in the
86 user_args (const user_args &) =delete;
87 user_args &operator= (const user_args &) =delete;
89 /* It is necessary to store a copy of the command line to ensure
90 that the arguments are not overwritten before they are used. */
91 std::string m_command_line;
93 /* The arguments. Each element points inside M_COMMAND_LINE. */
94 std::vector<string_view> m_args;
97 /* The stack of arguments passed to user defined functions. We need a
98 stack because user-defined functions can call other user-defined
100 static std::vector<std::unique_ptr<user_args>> user_args_stack;
102 /* An RAII-base class used to push/pop args on the user args
104 struct scoped_user_args_level
106 /* Parse the command line and push the arguments in the user args
108 explicit scoped_user_args_level (const char *line)
110 user_args_stack.emplace_back (new user_args (line));
113 /* Pop the current user arguments from the stack. */
114 ~scoped_user_args_level ()
116 user_args_stack.pop_back ();
121 /* Return non-zero if TYPE is a multi-line command (i.e., is terminated
125 multi_line_command_p (enum command_control_type type)
131 case while_stepping_control:
132 case commands_control:
133 case compile_control:
142 /* Allocate, initialize a new command line structure for one of the
143 control commands (if/while). */
145 static struct command_line *
146 build_command_line (enum command_control_type type, const char *args)
148 struct command_line *cmd;
150 if (args == NULL && (type == if_control || type == while_control))
151 error (_("if/while commands require arguments."));
152 gdb_assert (args != NULL);
154 cmd = XNEW (struct command_line);
156 cmd->control_type = type;
159 cmd->body_list = XCNEWVEC (struct command_line *, cmd->body_count);
160 cmd->line = xstrdup (args);
165 /* Build and return a new command structure for the control commands
166 such as "if" and "while". */
169 get_command_line (enum command_control_type type, const char *arg)
171 /* Allocate and build a new command line structure. */
172 command_line_up cmd (build_command_line (type, arg));
174 /* Read in the body of this command. */
175 if (recurse_read_control_structure (read_next_line, cmd.get (), 0, 0)
178 warning (_("Error reading in canned sequence of commands."));
185 /* Recursively print a command (including full control structures). */
188 print_command_lines (struct ui_out *uiout, struct command_line *cmd,
191 struct command_line *list;
197 uiout->spaces (2 * depth);
199 /* A simple command, print it and continue. */
200 if (list->control_type == simple_control)
202 uiout->field_string (NULL, list->line);
208 /* loop_continue to jump to the start of a while loop, print it
210 if (list->control_type == continue_control)
212 uiout->field_string (NULL, "loop_continue");
218 /* loop_break to break out of a while loop, print it and
220 if (list->control_type == break_control)
222 uiout->field_string (NULL, "loop_break");
228 /* A while command. Recursively print its subcommands and
230 if (list->control_type == while_control
231 || list->control_type == while_stepping_control)
233 /* For while-stepping, the line includes the 'while-stepping'
234 token. See comment in process_next_line for explanation.
235 Here, take care not print 'while-stepping' twice. */
236 if (list->control_type == while_control)
237 uiout->field_fmt (NULL, "while %s", list->line);
239 uiout->field_string (NULL, list->line);
241 print_command_lines (uiout, *list->body_list, depth + 1);
243 uiout->spaces (2 * depth);
244 uiout->field_string (NULL, "end");
250 /* An if command. Recursively print both arms before
252 if (list->control_type == if_control)
254 uiout->field_fmt (NULL, "if %s", list->line);
257 print_command_lines (uiout, list->body_list[0], depth + 1);
259 /* Show the false arm if it exists. */
260 if (list->body_count == 2)
263 uiout->spaces (2 * depth);
264 uiout->field_string (NULL, "else");
266 print_command_lines (uiout, list->body_list[1], depth + 1);
270 uiout->spaces (2 * depth);
271 uiout->field_string (NULL, "end");
277 /* A commands command. Print the breakpoint commands and
279 if (list->control_type == commands_control)
282 uiout->field_fmt (NULL, "commands %s", list->line);
284 uiout->field_string (NULL, "commands");
286 print_command_lines (uiout, *list->body_list, depth + 1);
288 uiout->spaces (2 * depth);
289 uiout->field_string (NULL, "end");
295 if (list->control_type == python_control)
297 uiout->field_string (NULL, "python");
299 /* Don't indent python code at all. */
300 print_command_lines (uiout, *list->body_list, 0);
302 uiout->spaces (2 * depth);
303 uiout->field_string (NULL, "end");
309 if (list->control_type == compile_control)
311 uiout->field_string (NULL, "compile expression");
313 print_command_lines (uiout, *list->body_list, 0);
315 uiout->spaces (2 * depth);
316 uiout->field_string (NULL, "end");
322 if (list->control_type == guile_control)
324 uiout->field_string (NULL, "guile");
326 print_command_lines (uiout, *list->body_list, depth + 1);
328 uiout->spaces (2 * depth);
329 uiout->field_string (NULL, "end");
335 /* Ignore illegal command type and try next. */
340 /* Handle pre-post hooks. */
343 clear_hook_in_cleanup (void *data)
345 struct cmd_list_element *c = (struct cmd_list_element *) data;
347 c->hook_in = 0; /* Allow hook to work again once it is complete. */
351 execute_cmd_pre_hook (struct cmd_list_element *c)
353 if ((c->hook_pre) && (!c->hook_in))
355 struct cleanup *cleanups = make_cleanup (clear_hook_in_cleanup, c);
356 c->hook_in = 1; /* Prevent recursive hooking. */
357 execute_user_command (c->hook_pre, (char *) 0);
358 do_cleanups (cleanups);
363 execute_cmd_post_hook (struct cmd_list_element *c)
365 if ((c->hook_post) && (!c->hook_in))
367 struct cleanup *cleanups = make_cleanup (clear_hook_in_cleanup, c);
369 c->hook_in = 1; /* Prevent recursive hooking. */
370 execute_user_command (c->hook_post, (char *) 0);
371 do_cleanups (cleanups);
376 execute_user_command (struct cmd_list_element *c, char *args)
378 struct ui *ui = current_ui;
379 struct command_line *cmdlines;
380 struct cleanup *old_chain;
381 enum command_control_type ret;
382 extern unsigned int max_user_call_depth;
384 cmdlines = c->user_commands;
389 scoped_user_args_level push_user_args (args);
391 if (user_args_stack.size () > max_user_call_depth)
392 error (_("Max user call depth exceeded -- command aborted."));
394 /* Set the instream to 0, indicating execution of a
395 user-defined function. */
396 old_chain = make_cleanup (do_restore_instream_cleanup, ui->instream);
399 scoped_restore save_async = make_scoped_restore (¤t_ui->async, 0);
401 command_nest_depth++;
404 ret = execute_control_command (cmdlines);
405 if (ret != simple_control && ret != break_control)
407 warning (_("Error executing canned sequence of commands."));
410 cmdlines = cmdlines->next;
412 command_nest_depth--;
413 do_cleanups (old_chain);
416 /* This function is called every time GDB prints a prompt. It ensures
417 that errors and the like do not confuse the command tracing. */
420 reset_command_nest_depth (void)
422 command_nest_depth = 1;
425 suppress_next_print_command_trace = 0;
428 /* Print the command, prefixed with '+' to represent the call depth.
429 This is slightly complicated because this function may be called
430 from execute_command and execute_control_command. Unfortunately
431 execute_command also prints the top level control commands.
432 In these cases execute_command will call execute_control_command
433 via while_command or if_command. Inner levels of 'if' and 'while'
434 are dealt with directly. Therefore we can use these functions
435 to determine whether the command has been printed already or not. */
437 print_command_trace (const char *cmd)
441 if (suppress_next_print_command_trace)
443 suppress_next_print_command_trace = 0;
447 if (!source_verbose && !trace_commands)
450 for (i=0; i < command_nest_depth; i++)
451 printf_filtered ("+");
453 printf_filtered ("%s\n", cmd);
456 enum command_control_type
457 execute_control_command (struct command_line *cmd)
459 struct command_line *current;
461 struct value *val_mark;
463 enum command_control_type ret;
465 /* Start by assuming failure, if a problem is detected, the code
466 below will simply "break" out of the switch. */
467 ret = invalid_control;
469 switch (cmd->control_type)
473 /* A simple command, execute it and return. */
474 std::string new_line = insert_user_defined_cmd_args (cmd->line);
475 execute_command (&new_line[0], 0);
476 ret = cmd->control_type;
480 case continue_control:
481 print_command_trace ("loop_continue");
483 /* Return for "continue", and "break" so we can either
484 continue the loop at the top, or break out. */
485 ret = cmd->control_type;
489 print_command_trace ("loop_break");
491 /* Return for "continue", and "break" so we can either
492 continue the loop at the top, or break out. */
493 ret = cmd->control_type;
498 int len = strlen (cmd->line) + 7;
499 char *buffer = (char *) alloca (len);
501 xsnprintf (buffer, len, "while %s", cmd->line);
502 print_command_trace (buffer);
504 /* Parse the loop control expression for the while statement. */
505 std::string new_line = insert_user_defined_cmd_args (cmd->line);
506 expression_up expr = parse_expression (new_line.c_str ());
508 ret = simple_control;
511 /* Keep iterating so long as the expression is true. */
518 /* Evaluate the expression. */
519 val_mark = value_mark ();
520 val = evaluate_expression (expr.get ());
521 cond_result = value_true (val);
522 value_free_to_mark (val_mark);
524 /* If the value is false, then break out of the loop. */
528 /* Execute the body of the while statement. */
529 current = *cmd->body_list;
532 command_nest_depth++;
533 ret = execute_control_command (current);
534 command_nest_depth--;
536 /* If we got an error, or a "break" command, then stop
538 if (ret == invalid_control || ret == break_control)
544 /* If we got a "continue" command, then restart the loop
546 if (ret == continue_control)
549 /* Get the next statement. */
550 current = current->next;
554 /* Reset RET so that we don't recurse the break all the way down. */
555 if (ret == break_control)
556 ret = simple_control;
563 int len = strlen (cmd->line) + 4;
564 char *buffer = (char *) alloca (len);
566 xsnprintf (buffer, len, "if %s", cmd->line);
567 print_command_trace (buffer);
569 /* Parse the conditional for the if statement. */
570 std::string new_line = insert_user_defined_cmd_args (cmd->line);
571 expression_up expr = parse_expression (new_line.c_str ());
574 ret = simple_control;
576 /* Evaluate the conditional. */
577 val_mark = value_mark ();
578 val = evaluate_expression (expr.get ());
580 /* Choose which arm to take commands from based on the value
581 of the conditional expression. */
582 if (value_true (val))
583 current = *cmd->body_list;
584 else if (cmd->body_count == 2)
585 current = *(cmd->body_list + 1);
586 value_free_to_mark (val_mark);
588 /* Execute commands in the given arm. */
591 command_nest_depth++;
592 ret = execute_control_command (current);
593 command_nest_depth--;
595 /* If we got an error, get out. */
596 if (ret != simple_control)
599 /* Get the next statement in the body. */
600 current = current->next;
606 case commands_control:
608 /* Breakpoint commands list, record the commands in the
609 breakpoint's command list and return. */
610 std::string new_line = insert_user_defined_cmd_args (cmd->line);
611 ret = commands_from_control_command (new_line.c_str (), cmd);
615 case compile_control:
616 eval_compile_command (cmd, NULL, cmd->control_u.compile.scope,
617 cmd->control_u.compile.scope_data);
618 ret = simple_control;
624 eval_ext_lang_from_control_command (cmd);
625 ret = simple_control;
630 warning (_("Invalid control type in canned commands structure."));
637 /* Like execute_control_command, but first set
638 suppress_next_print_command_trace. */
640 enum command_control_type
641 execute_control_command_untraced (struct command_line *cmd)
643 suppress_next_print_command_trace = 1;
644 return execute_control_command (cmd);
648 /* "while" command support. Executes a body of statements while the
649 loop condition is nonzero. */
652 while_command (char *arg, int from_tty)
655 command_line_up command = get_command_line (while_control, arg);
660 scoped_restore save_async = make_scoped_restore (¤t_ui->async, 0);
662 execute_control_command_untraced (command.get ());
665 /* "if" command support. Execute either the true or false arm depending
666 on the value of the if conditional. */
669 if_command (char *arg, int from_tty)
672 command_line_up command = get_command_line (if_control, arg);
677 scoped_restore save_async = make_scoped_restore (¤t_ui->async, 0);
679 execute_control_command_untraced (command.get ());
682 /* Bind the incoming arguments for a user defined command to $arg0,
685 user_args::user_args (const char *command_line)
689 if (command_line == NULL)
692 m_command_line = command_line;
693 p = m_command_line.c_str ();
697 const char *start_arg;
702 /* Strip whitespace. */
703 while (*p == ' ' || *p == '\t')
706 /* P now points to an argument. */
709 /* Get to the end of this argument. */
712 if (((*p == ' ' || *p == '\t')) && !squote && !dquote && !bsquote)
741 m_args.emplace_back (start_arg, p - start_arg);
745 /* Given character string P, return a point to the first argument
746 ($arg), or NULL if P contains no arguments. */
749 locate_arg (const char *p)
751 while ((p = strchr (p, '$')))
753 if (startswith (p, "$arg")
754 && (isdigit (p[4]) || p[4] == 'c'))
761 /* See cli-script.h. */
764 insert_user_defined_cmd_args (const char *line)
766 /* If we are not in a user-defined command, treat $argc, $arg0, et
767 cetera as normal convenience variables. */
768 if (user_args_stack.empty ())
771 const std::unique_ptr<user_args> &args = user_args_stack.back ();
772 return args->insert_args (line);
775 /* Insert the user defined arguments stored in user_args into the $arg
776 arguments found in line. */
779 user_args::insert_args (const char *line) const
781 std::string new_line;
784 while ((p = locate_arg (line)))
786 new_line.append (line, p - line);
790 new_line += std::to_string (m_args.size ());
799 i = strtoul (p + 4, &tmp, 10);
800 if ((i == 0 && tmp == p + 4) || errno != 0)
802 else if (i >= m_args.size ())
803 error (_("Missing argument %ld in user function."), i);
806 new_line.append (m_args[i].str, m_args[i].len);
811 /* Don't forget the tail. */
812 new_line.append (line);
818 /* Expand the body_list of COMMAND so that it can hold NEW_LENGTH
819 code bodies. This is typically used when we encounter an "else"
820 clause for an "if" command. */
823 realloc_body_list (struct command_line *command, int new_length)
826 struct command_line **body_list;
828 n = command->body_count;
834 body_list = XCNEWVEC (struct command_line *, new_length);
836 memcpy (body_list, command->body_list, sizeof (struct command_line *) * n);
838 xfree (command->body_list);
839 command->body_list = body_list;
840 command->body_count = new_length;
843 /* Read next line from stdin. Passed to read_command_line_1 and
844 recurse_read_control_structure whenever we need to read commands
848 read_next_line (void)
850 struct ui *ui = current_ui;
851 char *prompt_ptr, control_prompt[256];
853 int from_tty = ui->instream == ui->stdin_stream;
855 if (control_level >= 254)
856 error (_("Control nesting too deep!"));
858 /* Set a prompt based on the nesting of the control commands. */
860 || (ui->instream == 0 && deprecated_readline_hook != NULL))
862 for (i = 0; i < control_level; i++)
863 control_prompt[i] = ' ';
864 control_prompt[i] = '>';
865 control_prompt[i + 1] = '\0';
866 prompt_ptr = (char *) &control_prompt[0];
871 return command_line_input (prompt_ptr, from_tty, "commands");
874 /* Return true if CMD's name is NAME. */
877 command_name_equals (struct cmd_list_element *cmd, const char *name)
880 && cmd != CMD_LIST_AMBIGUOUS
881 && strcmp (cmd->name, name) == 0);
884 /* Given an input line P, skip the command and return a pointer to the
888 line_first_arg (const char *p)
890 const char *first_arg = p + find_command_name_length (p);
892 return skip_spaces_const (first_arg);
895 /* Process one input line. If the command is an "end", return such an
896 indication to the caller. If PARSE_COMMANDS is true, strip leading
897 whitespace (trailing whitespace is always stripped) in the line,
898 attempt to recognize GDB control commands, and also return an
899 indication if the command is an "else" or a nop.
901 Otherwise, only "end" is recognized. */
903 static enum misc_command_type
904 process_next_line (char *p, struct command_line **command, int parse_commands,
905 void (*validator)(char *, void *), void *closure)
911 /* Not sure what to do here. */
915 /* Strip trailing whitespace. */
916 p_end = p + strlen (p);
917 while (p_end > p && (p_end[-1] == ' ' || p_end[-1] == '\t'))
921 /* Strip leading whitespace. */
922 while (p_start < p_end && (*p_start == ' ' || *p_start == '\t'))
925 /* 'end' is always recognized, regardless of parse_commands value.
926 We also permit whitespace before end and after. */
927 if (p_end - p_start == 3 && startswith (p_start, "end"))
932 /* Resolve command abbreviations (e.g. 'ws' for 'while-stepping'). */
933 const char *cmd_name = p;
934 struct cmd_list_element *cmd
935 = lookup_cmd_1 (&cmd_name, cmdlist, NULL, 1);
936 cmd_name = skip_spaces_const (cmd_name);
937 bool inline_cmd = *cmd_name != '\0';
939 /* If commands are parsed, we skip initial spaces. Otherwise,
940 which is the case for Python commands and documentation
941 (see the 'document' command), spaces are preserved. */
944 /* Blanks and comments don't really do anything, but we need to
945 distinguish them from else, end and other commands which can
947 if (p_end == p || p[0] == '#')
950 /* Is the else clause of an if control structure? */
951 if (p_end - p == 4 && startswith (p, "else"))
954 /* Check for while, if, break, continue, etc and build a new
955 command line structure for them. */
956 if (command_name_equals (cmd, "while-stepping"))
958 /* Because validate_actionline and encode_action lookup
959 command's line as command, we need the line to
960 include 'while-stepping'.
962 For 'ws' alias, the command will have 'ws', not expanded
963 to 'while-stepping'. This is intentional -- we don't
964 really want frontend to send a command list with 'ws',
965 and next break-info returning command line with
966 'while-stepping'. This should work, but might cause the
967 breakpoint to be marked as changed while it's actually
969 *command = build_command_line (while_stepping_control, p);
971 else if (command_name_equals (cmd, "while"))
973 *command = build_command_line (while_control, line_first_arg (p));
975 else if (command_name_equals (cmd, "if"))
977 *command = build_command_line (if_control, line_first_arg (p));
979 else if (command_name_equals (cmd, "commands"))
981 *command = build_command_line (commands_control, line_first_arg (p));
983 else if (command_name_equals (cmd, "python") && !inline_cmd)
985 /* Note that we ignore the inline "python command" form
987 *command = build_command_line (python_control, "");
989 else if (command_name_equals (cmd, "compile") && !inline_cmd)
991 /* Note that we ignore the inline "compile command" form
993 *command = build_command_line (compile_control, "");
994 (*command)->control_u.compile.scope = COMPILE_I_INVALID_SCOPE;
996 else if (command_name_equals (cmd, "guile") && !inline_cmd)
998 /* Note that we ignore the inline "guile command" form here. */
999 *command = build_command_line (guile_control, "");
1001 else if (p_end - p == 10 && startswith (p, "loop_break"))
1003 *command = XNEW (struct command_line);
1004 (*command)->next = NULL;
1005 (*command)->line = NULL;
1006 (*command)->control_type = break_control;
1007 (*command)->body_count = 0;
1008 (*command)->body_list = NULL;
1010 else if (p_end - p == 13 && startswith (p, "loop_continue"))
1012 *command = XNEW (struct command_line);
1013 (*command)->next = NULL;
1014 (*command)->line = NULL;
1015 (*command)->control_type = continue_control;
1016 (*command)->body_count = 0;
1017 (*command)->body_list = NULL;
1023 if (!parse_commands || not_handled)
1025 /* A normal command. */
1026 *command = XNEW (struct command_line);
1027 (*command)->next = NULL;
1028 (*command)->line = savestring (p, p_end - p);
1029 (*command)->control_type = simple_control;
1030 (*command)->body_count = 0;
1031 (*command)->body_list = NULL;
1039 validator ((*command)->line, closure);
1041 CATCH (ex, RETURN_MASK_ALL)
1044 throw_exception (ex);
1049 /* Nothing special. */
1053 /* Recursively read in the control structures and create a
1054 command_line structure from them. Use read_next_line_func to
1055 obtain lines of the command. */
1057 static enum command_control_type
1058 recurse_read_control_structure (char * (*read_next_line_func) (void),
1059 struct command_line *current_cmd,
1060 void (*validator)(char *, void *),
1063 int current_body, i;
1064 enum misc_command_type val;
1065 enum command_control_type ret;
1066 struct command_line **body_ptr, *child_tail, *next;
1071 /* Sanity checks. */
1072 if (current_cmd->control_type == simple_control)
1073 error (_("Recursed on a simple control type."));
1075 if (current_body > current_cmd->body_count)
1076 error (_("Allocated body is smaller than this command type needs."));
1078 /* Read lines from the input stream and build control structures. */
1084 val = process_next_line (read_next_line_func (), &next,
1085 current_cmd->control_type != python_control
1086 && current_cmd->control_type != guile_control
1087 && current_cmd->control_type != compile_control,
1088 validator, closure);
1090 /* Just skip blanks and comments. */
1091 if (val == nop_command)
1094 if (val == end_command)
1096 if (multi_line_command_p (current_cmd->control_type))
1098 /* Success reading an entire canned sequence of commands. */
1099 ret = simple_control;
1104 ret = invalid_control;
1109 /* Not the end of a control structure. */
1110 if (val == else_command)
1112 if (current_cmd->control_type == if_control
1113 && current_body == 1)
1115 realloc_body_list (current_cmd, 2);
1122 ret = invalid_control;
1129 child_tail->next = next;
1133 body_ptr = current_cmd->body_list;
1134 for (i = 1; i < current_body; i++)
1143 /* If the latest line is another control structure, then recurse
1145 if (multi_line_command_p (next->control_type))
1148 ret = recurse_read_control_structure (read_next_line_func, next,
1149 validator, closure);
1152 if (ret != simple_control)
1163 restore_interp (void *arg)
1165 interp_set_temp (interp_name ((struct interp *)arg));
1168 /* Read lines from the input stream and accumulate them in a chain of
1169 struct command_line's, which is then returned. For input from a
1170 terminal, the special command "end" is used to mark the end of the
1171 input, and is not included in the returned chain of commands.
1173 If PARSE_COMMANDS is true, strip leading whitespace (trailing whitespace
1174 is always stripped) in the line and attempt to recognize GDB control
1175 commands. Otherwise, only "end" is recognized. */
1177 #define END_MESSAGE "End with a line saying just \"end\"."
1180 read_command_lines (char *prompt_arg, int from_tty, int parse_commands,
1181 void (*validator)(char *, void *), void *closure)
1183 if (from_tty && input_interactive_p (current_ui))
1185 if (deprecated_readline_begin_hook)
1187 /* Note - intentional to merge messages with no newline. */
1188 (*deprecated_readline_begin_hook) ("%s %s\n", prompt_arg,
1193 printf_unfiltered ("%s\n%s\n", prompt_arg, END_MESSAGE);
1194 gdb_flush (gdb_stdout);
1199 /* Reading commands assumes the CLI behavior, so temporarily
1200 override the current interpreter with CLI. */
1201 command_line_up head;
1202 if (current_interp_named_p (INTERP_CONSOLE))
1203 head = read_command_lines_1 (read_next_line, parse_commands,
1204 validator, closure);
1207 struct interp *old_interp = interp_set_temp (INTERP_CONSOLE);
1208 struct cleanup *old_chain = make_cleanup (restore_interp, old_interp);
1210 head = read_command_lines_1 (read_next_line, parse_commands,
1211 validator, closure);
1212 do_cleanups (old_chain);
1215 if (from_tty && input_interactive_p (current_ui)
1216 && deprecated_readline_end_hook)
1218 (*deprecated_readline_end_hook) ();
1223 /* Act the same way as read_command_lines, except that each new line is
1224 obtained using READ_NEXT_LINE_FUNC. */
1227 read_command_lines_1 (char * (*read_next_line_func) (void), int parse_commands,
1228 void (*validator)(char *, void *), void *closure)
1230 struct command_line *tail, *next;
1231 command_line_up head;
1232 enum command_control_type ret;
1233 enum misc_command_type val;
1241 val = process_next_line (read_next_line_func (), &next, parse_commands,
1242 validator, closure);
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,
1264 validator, closure);
1267 if (ret == invalid_control)
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;
1297 struct command_line **blist;
1302 if (l->body_count > 0)
1304 blist = l->body_list;
1305 for (i = 0; i < l->body_count; i++, blist++)
1306 free_command_lines (blist);
1317 copy_command_lines (struct command_line *cmds)
1319 struct command_line *result = NULL;
1323 result = XNEW (struct command_line);
1325 result->next = copy_command_lines (cmds->next).release ();
1326 result->line = xstrdup (cmds->line);
1327 result->control_type = cmds->control_type;
1328 result->body_count = cmds->body_count;
1329 if (cmds->body_count > 0)
1333 result->body_list = XNEWVEC (struct command_line *, cmds->body_count);
1335 for (i = 0; i < cmds->body_count; i++)
1336 result->body_list[i]
1337 = copy_command_lines (cmds->body_list[i]).release ();
1340 result->body_list = NULL;
1343 return command_line_up (result);
1346 /* Validate that *COMNAME is a valid name for a command. Return the
1347 containing command list, in case it starts with a prefix command.
1348 The prefix must already exist. *COMNAME is advanced to point after
1349 any prefix, and a NUL character overwrites the space after the
1352 static struct cmd_list_element **
1353 validate_comname (char **comname)
1355 struct cmd_list_element **list = &cmdlist;
1356 char *p, *last_word;
1359 error_no_arg (_("name of command to define"));
1361 /* Find the last word of the argument. */
1362 p = *comname + strlen (*comname);
1363 while (p > *comname && isspace (p[-1]))
1365 while (p > *comname && !isspace (p[-1]))
1369 /* Find the corresponding command list. */
1370 if (last_word != *comname)
1372 struct cmd_list_element *c;
1374 const char *tem = *comname;
1376 /* Separate the prefix and the command. */
1377 saved_char = last_word[-1];
1378 last_word[-1] = '\0';
1380 c = lookup_cmd (&tem, cmdlist, "", 0, 1);
1381 if (c->prefixlist == NULL)
1382 error (_("\"%s\" is not a prefix command."), *comname);
1384 list = c->prefixlist;
1385 last_word[-1] = saved_char;
1386 *comname = last_word;
1392 if (!isalnum (*p) && *p != '-' && *p != '_')
1393 error (_("Junk in argument list: \"%s\""), p);
1400 /* This is just a placeholder in the command data structures. */
1402 user_defined_command (char *ignore, int from_tty)
1407 define_command (char *comname, int from_tty)
1409 #define MAX_TMPBUF 128
1416 struct cmd_list_element *c, *newc, *hookc = 0, **list;
1417 char *tem, *comfull;
1419 char tmpbuf[MAX_TMPBUF];
1420 int hook_type = CMD_NO_HOOK;
1421 int hook_name_size = 0;
1423 #define HOOK_STRING "hook-"
1425 #define HOOK_POST_STRING "hookpost-"
1426 #define HOOK_POST_LEN 9
1429 list = validate_comname (&comname);
1431 /* Look it up, and verify that we got an exact match. */
1433 c = lookup_cmd (&tem_c, *list, "", -1, 1);
1434 if (c && strcmp (comname, c->name) != 0)
1441 if (c->theclass == class_user || c->theclass == class_alias)
1442 q = query (_("Redefine command \"%s\"? "), c->name);
1444 q = query (_("Really redefine built-in command \"%s\"? "), c->name);
1446 error (_("Command \"%s\" not redefined."), c->name);
1449 /* If this new command is a hook, then mark the command which it
1450 is hooking. Note that we allow hooking `help' commands, so that
1451 we can hook the `stop' pseudo-command. */
1453 if (!strncmp (comname, HOOK_STRING, HOOK_LEN))
1455 hook_type = CMD_PRE_HOOK;
1456 hook_name_size = HOOK_LEN;
1458 else if (!strncmp (comname, HOOK_POST_STRING, HOOK_POST_LEN))
1460 hook_type = CMD_POST_HOOK;
1461 hook_name_size = HOOK_POST_LEN;
1464 if (hook_type != CMD_NO_HOOK)
1466 /* Look up cmd it hooks, and verify that we got an exact match. */
1467 tem_c = comname + hook_name_size;
1468 hookc = lookup_cmd (&tem_c, *list, "", -1, 0);
1469 if (hookc && strcmp (comname + hook_name_size, hookc->name) != 0)
1473 warning (_("Your new `%s' command does not "
1474 "hook any existing command."),
1476 if (!query (_("Proceed? ")))
1477 error (_("Not confirmed."));
1481 comname = xstrdup (comname);
1483 /* If the rest of the commands will be case insensitive, this one
1484 should behave in the same manner. */
1485 for (tem = comname; *tem; tem++)
1487 *tem = tolower (*tem);
1489 xsnprintf (tmpbuf, sizeof (tmpbuf),
1490 "Type commands for definition of \"%s\".", comfull);
1491 command_line_up cmds = read_command_lines (tmpbuf, from_tty, 1, 0, 0);
1493 if (c && c->theclass == class_user)
1494 free_command_lines (&c->user_commands);
1496 newc = add_cmd (comname, class_user, user_defined_command,
1497 (c && c->theclass == class_user)
1498 ? c->doc : xstrdup ("User-defined."), list);
1499 newc->user_commands = cmds.release ();
1501 /* If this new command is a hook, then mark both commands as being
1508 hookc->hook_pre = newc; /* Target gets hooked. */
1509 newc->hookee_pre = hookc; /* We are marked as hooking target cmd. */
1512 hookc->hook_post = newc; /* Target gets hooked. */
1513 newc->hookee_post = hookc; /* We are marked as hooking
1517 /* Should never come here as hookc would be 0. */
1518 internal_error (__FILE__, __LINE__, _("bad switch"));
1524 document_command (char *comname, int from_tty)
1526 struct cmd_list_element *c, **list;
1532 list = validate_comname (&comname);
1535 c = lookup_cmd (&tem, *list, "", 0, 1);
1537 if (c->theclass != class_user)
1538 error (_("Command \"%s\" is built-in."), comfull);
1540 xsnprintf (tmpbuf, sizeof (tmpbuf), "Type documentation for \"%s\".",
1542 command_line_up doclines = read_command_lines (tmpbuf, from_tty, 0, 0, 0);
1545 xfree ((char *) c->doc);
1548 struct command_line *cl1;
1552 for (cl1 = doclines.get (); cl1; cl1 = cl1->next)
1553 len += strlen (cl1->line) + 1;
1555 doc = (char *) xmalloc (len + 1);
1558 for (cl1 = doclines.get (); cl1; cl1 = cl1->next)
1560 strcat (doc, cl1->line);
1569 /* Used to implement source_command. */
1572 script_from_file (FILE *stream, const char *file)
1575 internal_error (__FILE__, __LINE__, _("called with NULL file pointer!"));
1577 scoped_restore restore_line_number
1578 = make_scoped_restore (&source_line_number, 0);
1579 scoped_restore resotre_file
1580 = make_scoped_restore (&source_file_name, file);
1582 scoped_restore save_async = make_scoped_restore (¤t_ui->async, 0);
1586 read_command_file (stream);
1588 CATCH (e, RETURN_MASK_ERROR)
1590 /* Re-throw the error, but with the file name information
1592 throw_error (e.error,
1593 _("%s:%d: Error in sourced command file:\n%s"),
1594 source_file_name, source_line_number, e.message);
1599 /* Print the definition of user command C to STREAM. Or, if C is a
1600 prefix command, show the definitions of all user commands under C
1601 (recursively). PREFIX and NAME combined are the name of the
1604 show_user_1 (struct cmd_list_element *c, const char *prefix, const char *name,
1605 struct ui_file *stream)
1607 struct command_line *cmdlines;
1609 if (c->prefixlist != NULL)
1611 const char *prefixname = c->prefixname;
1613 for (c = *c->prefixlist; c != NULL; c = c->next)
1614 if (c->theclass == class_user || c->prefixlist != NULL)
1615 show_user_1 (c, prefixname, c->name, gdb_stdout);
1619 cmdlines = c->user_commands;
1620 fprintf_filtered (stream, "User command \"%s%s\":\n", prefix, name);
1624 print_command_lines (current_uiout, cmdlines, 1);
1625 fputs_filtered ("\n", stream);
1630 initialize_file_ftype _initialize_cli_script;
1633 _initialize_cli_script (void)
1635 add_com ("document", class_support, document_command, _("\
1636 Document a user-defined command.\n\
1637 Give command name as argument. Give documentation on following lines.\n\
1638 End with a line of just \"end\"."));
1639 add_com ("define", class_support, define_command, _("\
1640 Define a new command name. Command name is argument.\n\
1641 Definition appears on following lines, one command per line.\n\
1642 End with a line of just \"end\".\n\
1643 Use the \"document\" command to give documentation for the new command.\n\
1644 Commands defined in this way may have up to ten arguments."));
1646 add_com ("while", class_support, while_command, _("\
1647 Execute nested commands WHILE the conditional expression is non zero.\n\
1648 The conditional expression must follow the word `while' and must in turn be\n\
1649 followed by a new line. The nested commands must be entered one per line,\n\
1650 and should be terminated by the word `end'."));
1652 add_com ("if", class_support, if_command, _("\
1653 Execute nested commands once IF the conditional expression is non zero.\n\
1654 The conditional expression must follow the word `if' and must in turn be\n\
1655 followed by a new line. The nested commands must be entered one per line,\n\
1656 and should be terminated by the word 'else' or `end'. If an else clause\n\
1657 is used, the same rules apply to its nested commands as to the first ones."));