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
|| *args
== '\0')
151 && (type
== if_control
|| type
== while_control
))
152 error (_("if/while commands require arguments."));
153 gdb_assert (args
!= NULL
);
155 cmd
= XNEW (struct command_line
);
157 cmd
->control_type
= type
;
160 cmd
->body_list
= XCNEWVEC (struct command_line
*, cmd
->body_count
);
161 cmd
->line
= xstrdup (args
);
166 /* Build and return a new command structure for the control commands
167 such as "if" and "while". */
170 get_command_line (enum command_control_type type
, const char *arg
)
172 /* Allocate and build a new command line structure. */
173 command_line_up
cmd (build_command_line (type
, arg
));
175 /* Read in the body of this command. */
176 if (recurse_read_control_structure (read_next_line
, cmd
.get (), 0, 0)
179 warning (_("Error reading in canned sequence of commands."));
186 /* Recursively print a command (including full control structures). */
189 print_command_lines (struct ui_out
*uiout
, struct command_line
*cmd
,
192 struct command_line
*list
;
198 uiout
->spaces (2 * depth
);
200 /* A simple command, print it and continue. */
201 if (list
->control_type
== simple_control
)
203 uiout
->field_string (NULL
, list
->line
);
209 /* loop_continue to jump to the start of a while loop, print it
211 if (list
->control_type
== continue_control
)
213 uiout
->field_string (NULL
, "loop_continue");
219 /* loop_break to break out of a while loop, print it and
221 if (list
->control_type
== break_control
)
223 uiout
->field_string (NULL
, "loop_break");
229 /* A while command. Recursively print its subcommands and
231 if (list
->control_type
== while_control
232 || list
->control_type
== while_stepping_control
)
234 /* For while-stepping, the line includes the 'while-stepping'
235 token. See comment in process_next_line for explanation.
236 Here, take care not print 'while-stepping' twice. */
237 if (list
->control_type
== while_control
)
238 uiout
->field_fmt (NULL
, "while %s", list
->line
);
240 uiout
->field_string (NULL
, list
->line
);
242 print_command_lines (uiout
, *list
->body_list
, depth
+ 1);
244 uiout
->spaces (2 * depth
);
245 uiout
->field_string (NULL
, "end");
251 /* An if command. Recursively print both arms before
253 if (list
->control_type
== if_control
)
255 uiout
->field_fmt (NULL
, "if %s", list
->line
);
258 print_command_lines (uiout
, list
->body_list
[0], depth
+ 1);
260 /* Show the false arm if it exists. */
261 if (list
->body_count
== 2)
264 uiout
->spaces (2 * depth
);
265 uiout
->field_string (NULL
, "else");
267 print_command_lines (uiout
, list
->body_list
[1], depth
+ 1);
271 uiout
->spaces (2 * depth
);
272 uiout
->field_string (NULL
, "end");
278 /* A commands command. Print the breakpoint commands and
280 if (list
->control_type
== commands_control
)
283 uiout
->field_fmt (NULL
, "commands %s", list
->line
);
285 uiout
->field_string (NULL
, "commands");
287 print_command_lines (uiout
, *list
->body_list
, depth
+ 1);
289 uiout
->spaces (2 * depth
);
290 uiout
->field_string (NULL
, "end");
296 if (list
->control_type
== python_control
)
298 uiout
->field_string (NULL
, "python");
300 /* Don't indent python code at all. */
301 print_command_lines (uiout
, *list
->body_list
, 0);
303 uiout
->spaces (2 * depth
);
304 uiout
->field_string (NULL
, "end");
310 if (list
->control_type
== compile_control
)
312 uiout
->field_string (NULL
, "compile expression");
314 print_command_lines (uiout
, *list
->body_list
, 0);
316 uiout
->spaces (2 * depth
);
317 uiout
->field_string (NULL
, "end");
323 if (list
->control_type
== guile_control
)
325 uiout
->field_string (NULL
, "guile");
327 print_command_lines (uiout
, *list
->body_list
, depth
+ 1);
329 uiout
->spaces (2 * depth
);
330 uiout
->field_string (NULL
, "end");
336 /* Ignore illegal command type and try next. */
341 /* Handle pre-post hooks. */
343 class scoped_restore_hook_in
347 scoped_restore_hook_in (struct cmd_list_element
*c
)
352 ~scoped_restore_hook_in ()
357 scoped_restore_hook_in (const scoped_restore_hook_in
&) = delete;
358 scoped_restore_hook_in
&operator= (const scoped_restore_hook_in
&) = delete;
362 struct cmd_list_element
*m_cmd
;
366 execute_cmd_pre_hook (struct cmd_list_element
*c
)
368 if ((c
->hook_pre
) && (!c
->hook_in
))
370 scoped_restore_hook_in
restore_hook (c
);
371 c
->hook_in
= 1; /* Prevent recursive hooking. */
372 execute_user_command (c
->hook_pre
, (char *) 0);
377 execute_cmd_post_hook (struct cmd_list_element
*c
)
379 if ((c
->hook_post
) && (!c
->hook_in
))
381 scoped_restore_hook_in
restore_hook (c
);
382 c
->hook_in
= 1; /* Prevent recursive hooking. */
383 execute_user_command (c
->hook_post
, (char *) 0);
388 execute_user_command (struct cmd_list_element
*c
, char *args
)
390 struct ui
*ui
= current_ui
;
391 struct command_line
*cmdlines
;
392 enum command_control_type ret
;
393 extern unsigned int max_user_call_depth
;
395 cmdlines
= c
->user_commands
;
400 scoped_user_args_level
push_user_args (args
);
402 if (user_args_stack
.size () > max_user_call_depth
)
403 error (_("Max user call depth exceeded -- command aborted."));
405 /* Set the instream to 0, indicating execution of a
406 user-defined function. */
407 scoped_restore restore_instream
408 = make_scoped_restore (&ui
->instream
, nullptr);
410 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
412 scoped_restore save_nesting
413 = make_scoped_restore (&command_nest_depth
, command_nest_depth
+ 1);
416 ret
= execute_control_command (cmdlines
);
417 if (ret
!= simple_control
&& ret
!= break_control
)
419 warning (_("Error executing canned sequence of commands."));
422 cmdlines
= cmdlines
->next
;
426 /* This function is called every time GDB prints a prompt. It ensures
427 that errors and the like do not confuse the command tracing. */
430 reset_command_nest_depth (void)
432 command_nest_depth
= 1;
435 suppress_next_print_command_trace
= 0;
438 /* Print the command, prefixed with '+' to represent the call depth.
439 This is slightly complicated because this function may be called
440 from execute_command and execute_control_command. Unfortunately
441 execute_command also prints the top level control commands.
442 In these cases execute_command will call execute_control_command
443 via while_command or if_command. Inner levels of 'if' and 'while'
444 are dealt with directly. Therefore we can use these functions
445 to determine whether the command has been printed already or not. */
447 print_command_trace (const char *cmd
)
451 if (suppress_next_print_command_trace
)
453 suppress_next_print_command_trace
= 0;
457 if (!source_verbose
&& !trace_commands
)
460 for (i
=0; i
< command_nest_depth
; i
++)
461 printf_filtered ("+");
463 printf_filtered ("%s\n", cmd
);
466 enum command_control_type
467 execute_control_command (struct command_line
*cmd
)
469 struct command_line
*current
;
471 struct value
*val_mark
;
473 enum command_control_type ret
;
475 /* Start by assuming failure, if a problem is detected, the code
476 below will simply "break" out of the switch. */
477 ret
= invalid_control
;
479 switch (cmd
->control_type
)
483 /* A simple command, execute it and return. */
484 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
485 execute_command (&new_line
[0], 0);
486 ret
= cmd
->control_type
;
490 case continue_control
:
491 print_command_trace ("loop_continue");
493 /* Return for "continue", and "break" so we can either
494 continue the loop at the top, or break out. */
495 ret
= cmd
->control_type
;
499 print_command_trace ("loop_break");
501 /* Return for "continue", and "break" so we can either
502 continue the loop at the top, or break out. */
503 ret
= cmd
->control_type
;
508 int len
= strlen (cmd
->line
) + 7;
509 char *buffer
= (char *) alloca (len
);
511 xsnprintf (buffer
, len
, "while %s", cmd
->line
);
512 print_command_trace (buffer
);
514 /* Parse the loop control expression for the while statement. */
515 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
516 expression_up expr
= parse_expression (new_line
.c_str ());
518 ret
= simple_control
;
521 /* Keep iterating so long as the expression is true. */
528 /* Evaluate the expression. */
529 val_mark
= value_mark ();
530 val
= evaluate_expression (expr
.get ());
531 cond_result
= value_true (val
);
532 value_free_to_mark (val_mark
);
534 /* If the value is false, then break out of the loop. */
538 /* Execute the body of the while statement. */
539 current
= *cmd
->body_list
;
542 scoped_restore save_nesting
543 = make_scoped_restore (&command_nest_depth
, command_nest_depth
+ 1);
544 ret
= execute_control_command (current
);
546 /* If we got an error, or a "break" command, then stop
548 if (ret
== invalid_control
|| ret
== break_control
)
554 /* If we got a "continue" command, then restart the loop
556 if (ret
== continue_control
)
559 /* Get the next statement. */
560 current
= current
->next
;
564 /* Reset RET so that we don't recurse the break all the way down. */
565 if (ret
== break_control
)
566 ret
= simple_control
;
573 int len
= strlen (cmd
->line
) + 4;
574 char *buffer
= (char *) alloca (len
);
576 xsnprintf (buffer
, len
, "if %s", cmd
->line
);
577 print_command_trace (buffer
);
579 /* Parse the conditional for the if statement. */
580 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
581 expression_up expr
= parse_expression (new_line
.c_str ());
584 ret
= simple_control
;
586 /* Evaluate the conditional. */
587 val_mark
= value_mark ();
588 val
= evaluate_expression (expr
.get ());
590 /* Choose which arm to take commands from based on the value
591 of the conditional expression. */
592 if (value_true (val
))
593 current
= *cmd
->body_list
;
594 else if (cmd
->body_count
== 2)
595 current
= *(cmd
->body_list
+ 1);
596 value_free_to_mark (val_mark
);
598 /* Execute commands in the given arm. */
601 scoped_restore save_nesting
602 = make_scoped_restore (&command_nest_depth
, command_nest_depth
+ 1);
603 ret
= execute_control_command (current
);
605 /* If we got an error, get out. */
606 if (ret
!= simple_control
)
609 /* Get the next statement in the body. */
610 current
= current
->next
;
616 case commands_control
:
618 /* Breakpoint commands list, record the commands in the
619 breakpoint's command list and return. */
620 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
621 ret
= commands_from_control_command (new_line
.c_str (), cmd
);
625 case compile_control
:
626 eval_compile_command (cmd
, NULL
, cmd
->control_u
.compile
.scope
,
627 cmd
->control_u
.compile
.scope_data
);
628 ret
= simple_control
;
634 eval_ext_lang_from_control_command (cmd
);
635 ret
= simple_control
;
640 warning (_("Invalid control type in canned commands structure."));
647 /* Like execute_control_command, but first set
648 suppress_next_print_command_trace. */
650 enum command_control_type
651 execute_control_command_untraced (struct command_line
*cmd
)
653 suppress_next_print_command_trace
= 1;
654 return execute_control_command (cmd
);
658 /* "while" command support. Executes a body of statements while the
659 loop condition is nonzero. */
662 while_command (char *arg
, int from_tty
)
665 command_line_up command
= get_command_line (while_control
, arg
);
670 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
672 execute_control_command_untraced (command
.get ());
675 /* "if" command support. Execute either the true or false arm depending
676 on the value of the if conditional. */
679 if_command (char *arg
, int from_tty
)
682 command_line_up command
= get_command_line (if_control
, arg
);
687 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
689 execute_control_command_untraced (command
.get ());
692 /* Bind the incoming arguments for a user defined command to $arg0,
695 user_args::user_args (const char *command_line
)
699 if (command_line
== NULL
)
702 m_command_line
= command_line
;
703 p
= m_command_line
.c_str ();
707 const char *start_arg
;
712 /* Strip whitespace. */
713 while (*p
== ' ' || *p
== '\t')
716 /* P now points to an argument. */
719 /* Get to the end of this argument. */
722 if (((*p
== ' ' || *p
== '\t')) && !squote
&& !dquote
&& !bsquote
)
751 m_args
.emplace_back (start_arg
, p
- start_arg
);
755 /* Given character string P, return a point to the first argument
756 ($arg), or NULL if P contains no arguments. */
759 locate_arg (const char *p
)
761 while ((p
= strchr (p
, '$')))
763 if (startswith (p
, "$arg")
764 && (isdigit (p
[4]) || p
[4] == 'c'))
771 /* See cli-script.h. */
774 insert_user_defined_cmd_args (const char *line
)
776 /* If we are not in a user-defined command, treat $argc, $arg0, et
777 cetera as normal convenience variables. */
778 if (user_args_stack
.empty ())
781 const std::unique_ptr
<user_args
> &args
= user_args_stack
.back ();
782 return args
->insert_args (line
);
785 /* Insert the user defined arguments stored in user_args into the $arg
786 arguments found in line. */
789 user_args::insert_args (const char *line
) const
791 std::string new_line
;
794 while ((p
= locate_arg (line
)))
796 new_line
.append (line
, p
- line
);
800 new_line
+= std::to_string (m_args
.size ());
809 i
= strtoul (p
+ 4, &tmp
, 10);
810 if ((i
== 0 && tmp
== p
+ 4) || errno
!= 0)
812 else if (i
>= m_args
.size ())
813 error (_("Missing argument %ld in user function."), i
);
816 new_line
.append (m_args
[i
].str
, m_args
[i
].len
);
821 /* Don't forget the tail. */
822 new_line
.append (line
);
828 /* Expand the body_list of COMMAND so that it can hold NEW_LENGTH
829 code bodies. This is typically used when we encounter an "else"
830 clause for an "if" command. */
833 realloc_body_list (struct command_line
*command
, int new_length
)
836 struct command_line
**body_list
;
838 n
= command
->body_count
;
844 body_list
= XCNEWVEC (struct command_line
*, new_length
);
846 memcpy (body_list
, command
->body_list
, sizeof (struct command_line
*) * n
);
848 xfree (command
->body_list
);
849 command
->body_list
= body_list
;
850 command
->body_count
= new_length
;
853 /* Read next line from stdin. Passed to read_command_line_1 and
854 recurse_read_control_structure whenever we need to read commands
858 read_next_line (void)
860 struct ui
*ui
= current_ui
;
861 char *prompt_ptr
, control_prompt
[256];
863 int from_tty
= ui
->instream
== ui
->stdin_stream
;
865 if (control_level
>= 254)
866 error (_("Control nesting too deep!"));
868 /* Set a prompt based on the nesting of the control commands. */
870 || (ui
->instream
== 0 && deprecated_readline_hook
!= NULL
))
872 for (i
= 0; i
< control_level
; i
++)
873 control_prompt
[i
] = ' ';
874 control_prompt
[i
] = '>';
875 control_prompt
[i
+ 1] = '\0';
876 prompt_ptr
= (char *) &control_prompt
[0];
881 return command_line_input (prompt_ptr
, from_tty
, "commands");
884 /* Return true if CMD's name is NAME. */
887 command_name_equals (struct cmd_list_element
*cmd
, const char *name
)
890 && cmd
!= CMD_LIST_AMBIGUOUS
891 && strcmp (cmd
->name
, name
) == 0);
894 /* Given an input line P, skip the command and return a pointer to the
898 line_first_arg (const char *p
)
900 const char *first_arg
= p
+ find_command_name_length (p
);
902 return skip_spaces (first_arg
);
905 /* Process one input line. If the command is an "end", return such an
906 indication to the caller. If PARSE_COMMANDS is true, strip leading
907 whitespace (trailing whitespace is always stripped) in the line,
908 attempt to recognize GDB control commands, and also return an
909 indication if the command is an "else" or a nop.
911 Otherwise, only "end" is recognized. */
913 static enum misc_command_type
914 process_next_line (char *p
, struct command_line
**command
, int parse_commands
,
915 void (*validator
)(char *, void *), void *closure
)
921 /* Not sure what to do here. */
925 /* Strip trailing whitespace. */
926 p_end
= p
+ strlen (p
);
927 while (p_end
> p
&& (p_end
[-1] == ' ' || p_end
[-1] == '\t'))
931 /* Strip leading whitespace. */
932 while (p_start
< p_end
&& (*p_start
== ' ' || *p_start
== '\t'))
935 /* 'end' is always recognized, regardless of parse_commands value.
936 We also permit whitespace before end and after. */
937 if (p_end
- p_start
== 3 && startswith (p_start
, "end"))
942 /* Resolve command abbreviations (e.g. 'ws' for 'while-stepping'). */
943 const char *cmd_name
= p
;
944 struct cmd_list_element
*cmd
945 = lookup_cmd_1 (&cmd_name
, cmdlist
, NULL
, 1);
946 cmd_name
= skip_spaces (cmd_name
);
947 bool inline_cmd
= *cmd_name
!= '\0';
949 /* If commands are parsed, we skip initial spaces. Otherwise,
950 which is the case for Python commands and documentation
951 (see the 'document' command), spaces are preserved. */
954 /* Blanks and comments don't really do anything, but we need to
955 distinguish them from else, end and other commands which can
957 if (p_end
== p
|| p
[0] == '#')
960 /* Is the else clause of an if control structure? */
961 if (p_end
- p
== 4 && startswith (p
, "else"))
964 /* Check for while, if, break, continue, etc and build a new
965 command line structure for them. */
966 if (command_name_equals (cmd
, "while-stepping"))
968 /* Because validate_actionline and encode_action lookup
969 command's line as command, we need the line to
970 include 'while-stepping'.
972 For 'ws' alias, the command will have 'ws', not expanded
973 to 'while-stepping'. This is intentional -- we don't
974 really want frontend to send a command list with 'ws',
975 and next break-info returning command line with
976 'while-stepping'. This should work, but might cause the
977 breakpoint to be marked as changed while it's actually
979 *command
= build_command_line (while_stepping_control
, p
);
981 else if (command_name_equals (cmd
, "while"))
983 *command
= build_command_line (while_control
, line_first_arg (p
));
985 else if (command_name_equals (cmd
, "if"))
987 *command
= build_command_line (if_control
, line_first_arg (p
));
989 else if (command_name_equals (cmd
, "commands"))
991 *command
= build_command_line (commands_control
, line_first_arg (p
));
993 else if (command_name_equals (cmd
, "python") && !inline_cmd
)
995 /* Note that we ignore the inline "python command" form
997 *command
= build_command_line (python_control
, "");
999 else if (command_name_equals (cmd
, "compile") && !inline_cmd
)
1001 /* Note that we ignore the inline "compile command" form
1003 *command
= build_command_line (compile_control
, "");
1004 (*command
)->control_u
.compile
.scope
= COMPILE_I_INVALID_SCOPE
;
1006 else if (command_name_equals (cmd
, "guile") && !inline_cmd
)
1008 /* Note that we ignore the inline "guile command" form here. */
1009 *command
= build_command_line (guile_control
, "");
1011 else if (p_end
- p
== 10 && startswith (p
, "loop_break"))
1013 *command
= XNEW (struct command_line
);
1014 (*command
)->next
= NULL
;
1015 (*command
)->line
= NULL
;
1016 (*command
)->control_type
= break_control
;
1017 (*command
)->body_count
= 0;
1018 (*command
)->body_list
= NULL
;
1020 else if (p_end
- p
== 13 && startswith (p
, "loop_continue"))
1022 *command
= XNEW (struct command_line
);
1023 (*command
)->next
= NULL
;
1024 (*command
)->line
= NULL
;
1025 (*command
)->control_type
= continue_control
;
1026 (*command
)->body_count
= 0;
1027 (*command
)->body_list
= NULL
;
1033 if (!parse_commands
|| not_handled
)
1035 /* A normal command. */
1036 *command
= XNEW (struct command_line
);
1037 (*command
)->next
= NULL
;
1038 (*command
)->line
= savestring (p
, p_end
- p
);
1039 (*command
)->control_type
= simple_control
;
1040 (*command
)->body_count
= 0;
1041 (*command
)->body_list
= NULL
;
1049 validator ((*command
)->line
, closure
);
1051 CATCH (ex
, RETURN_MASK_ALL
)
1054 throw_exception (ex
);
1059 /* Nothing special. */
1063 /* Recursively read in the control structures and create a
1064 command_line structure from them. Use read_next_line_func to
1065 obtain lines of the command. */
1067 static enum command_control_type
1068 recurse_read_control_structure (char * (*read_next_line_func
) (void),
1069 struct command_line
*current_cmd
,
1070 void (*validator
)(char *, void *),
1073 int current_body
, i
;
1074 enum misc_command_type val
;
1075 enum command_control_type ret
;
1076 struct command_line
**body_ptr
, *child_tail
, *next
;
1081 /* Sanity checks. */
1082 if (current_cmd
->control_type
== simple_control
)
1083 error (_("Recursed on a simple control type."));
1085 if (current_body
> current_cmd
->body_count
)
1086 error (_("Allocated body is smaller than this command type needs."));
1088 /* Read lines from the input stream and build control structures. */
1094 val
= process_next_line (read_next_line_func (), &next
,
1095 current_cmd
->control_type
!= python_control
1096 && current_cmd
->control_type
!= guile_control
1097 && current_cmd
->control_type
!= compile_control
,
1098 validator
, closure
);
1100 /* Just skip blanks and comments. */
1101 if (val
== nop_command
)
1104 if (val
== end_command
)
1106 if (multi_line_command_p (current_cmd
->control_type
))
1108 /* Success reading an entire canned sequence of commands. */
1109 ret
= simple_control
;
1114 ret
= invalid_control
;
1119 /* Not the end of a control structure. */
1120 if (val
== else_command
)
1122 if (current_cmd
->control_type
== if_control
1123 && current_body
== 1)
1125 realloc_body_list (current_cmd
, 2);
1132 ret
= invalid_control
;
1139 child_tail
->next
= next
;
1143 body_ptr
= current_cmd
->body_list
;
1144 for (i
= 1; i
< current_body
; i
++)
1153 /* If the latest line is another control structure, then recurse
1155 if (multi_line_command_p (next
->control_type
))
1158 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1159 validator
, closure
);
1162 if (ret
!= simple_control
)
1172 /* Read lines from the input stream and accumulate them in a chain of
1173 struct command_line's, which is then returned. For input from a
1174 terminal, the special command "end" is used to mark the end of the
1175 input, and is not included in the returned chain of commands.
1177 If PARSE_COMMANDS is true, strip leading whitespace (trailing whitespace
1178 is always stripped) in the line and attempt to recognize GDB control
1179 commands. Otherwise, only "end" is recognized. */
1181 #define END_MESSAGE "End with a line saying just \"end\"."
1184 read_command_lines (char *prompt_arg
, int from_tty
, int parse_commands
,
1185 void (*validator
)(char *, void *), void *closure
)
1187 if (from_tty
&& input_interactive_p (current_ui
))
1189 if (deprecated_readline_begin_hook
)
1191 /* Note - intentional to merge messages with no newline. */
1192 (*deprecated_readline_begin_hook
) ("%s %s\n", prompt_arg
,
1197 printf_unfiltered ("%s\n%s\n", prompt_arg
, END_MESSAGE
);
1198 gdb_flush (gdb_stdout
);
1203 /* Reading commands assumes the CLI behavior, so temporarily
1204 override the current interpreter with CLI. */
1205 command_line_up head
;
1206 if (current_interp_named_p (INTERP_CONSOLE
))
1207 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1208 validator
, closure
);
1211 scoped_restore_interp
interp_restorer (INTERP_CONSOLE
);
1213 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1214 validator
, closure
);
1217 if (from_tty
&& input_interactive_p (current_ui
)
1218 && deprecated_readline_end_hook
)
1220 (*deprecated_readline_end_hook
) ();
1225 /* Act the same way as read_command_lines, except that each new line is
1226 obtained using READ_NEXT_LINE_FUNC. */
1229 read_command_lines_1 (char * (*read_next_line_func
) (void), int parse_commands
,
1230 void (*validator
)(char *, void *), void *closure
)
1232 struct command_line
*tail
, *next
;
1233 command_line_up head
;
1234 enum command_control_type ret
;
1235 enum misc_command_type val
;
1243 val
= process_next_line (read_next_line_func (), &next
, parse_commands
,
1244 validator
, closure
);
1246 /* Ignore blank lines or comments. */
1247 if (val
== nop_command
)
1250 if (val
== end_command
)
1252 ret
= simple_control
;
1256 if (val
!= ok_command
)
1258 ret
= invalid_control
;
1262 if (multi_line_command_p (next
->control_type
))
1265 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1266 validator
, closure
);
1269 if (ret
== invalid_control
)
1286 if (ret
== invalid_control
)
1292 /* Free a chain of struct command_line's. */
1295 free_command_lines (struct command_line
**lptr
)
1297 struct command_line
*l
= *lptr
;
1298 struct command_line
*next
;
1299 struct command_line
**blist
;
1304 if (l
->body_count
> 0)
1306 blist
= l
->body_list
;
1307 for (i
= 0; i
< l
->body_count
; i
++, blist
++)
1308 free_command_lines (blist
);
1319 copy_command_lines (struct command_line
*cmds
)
1321 struct command_line
*result
= NULL
;
1325 result
= XNEW (struct command_line
);
1327 result
->next
= copy_command_lines (cmds
->next
).release ();
1328 result
->line
= xstrdup (cmds
->line
);
1329 result
->control_type
= cmds
->control_type
;
1330 result
->body_count
= cmds
->body_count
;
1331 if (cmds
->body_count
> 0)
1335 result
->body_list
= XNEWVEC (struct command_line
*, cmds
->body_count
);
1337 for (i
= 0; i
< cmds
->body_count
; i
++)
1338 result
->body_list
[i
]
1339 = copy_command_lines (cmds
->body_list
[i
]).release ();
1342 result
->body_list
= NULL
;
1345 return command_line_up (result
);
1348 /* Validate that *COMNAME is a valid name for a command. Return the
1349 containing command list, in case it starts with a prefix command.
1350 The prefix must already exist. *COMNAME is advanced to point after
1351 any prefix, and a NUL character overwrites the space after the
1354 static struct cmd_list_element
**
1355 validate_comname (char **comname
)
1357 struct cmd_list_element
**list
= &cmdlist
;
1358 char *p
, *last_word
;
1361 error_no_arg (_("name of command to define"));
1363 /* Find the last word of the argument. */
1364 p
= *comname
+ strlen (*comname
);
1365 while (p
> *comname
&& isspace (p
[-1]))
1367 while (p
> *comname
&& !isspace (p
[-1]))
1371 /* Find the corresponding command list. */
1372 if (last_word
!= *comname
)
1374 struct cmd_list_element
*c
;
1376 const char *tem
= *comname
;
1378 /* Separate the prefix and the command. */
1379 saved_char
= last_word
[-1];
1380 last_word
[-1] = '\0';
1382 c
= lookup_cmd (&tem
, cmdlist
, "", 0, 1);
1383 if (c
->prefixlist
== NULL
)
1384 error (_("\"%s\" is not a prefix command."), *comname
);
1386 list
= c
->prefixlist
;
1387 last_word
[-1] = saved_char
;
1388 *comname
= last_word
;
1394 if (!isalnum (*p
) && *p
!= '-' && *p
!= '_')
1395 error (_("Junk in argument list: \"%s\""), p
);
1402 /* This is just a placeholder in the command data structures. */
1404 user_defined_command (const char *ignore
, int from_tty
)
1409 define_command (char *comname
, int from_tty
)
1411 #define MAX_TMPBUF 128
1418 struct cmd_list_element
*c
, *newc
, *hookc
= 0, **list
;
1419 char *tem
, *comfull
;
1421 char tmpbuf
[MAX_TMPBUF
];
1422 int hook_type
= CMD_NO_HOOK
;
1423 int hook_name_size
= 0;
1425 #define HOOK_STRING "hook-"
1427 #define HOOK_POST_STRING "hookpost-"
1428 #define HOOK_POST_LEN 9
1431 list
= validate_comname (&comname
);
1433 /* Look it up, and verify that we got an exact match. */
1435 c
= lookup_cmd (&tem_c
, *list
, "", -1, 1);
1436 if (c
&& strcmp (comname
, c
->name
) != 0)
1443 if (c
->theclass
== class_user
|| c
->theclass
== class_alias
)
1444 q
= query (_("Redefine command \"%s\"? "), c
->name
);
1446 q
= query (_("Really redefine built-in command \"%s\"? "), c
->name
);
1448 error (_("Command \"%s\" not redefined."), c
->name
);
1451 /* If this new command is a hook, then mark the command which it
1452 is hooking. Note that we allow hooking `help' commands, so that
1453 we can hook the `stop' pseudo-command. */
1455 if (!strncmp (comname
, HOOK_STRING
, HOOK_LEN
))
1457 hook_type
= CMD_PRE_HOOK
;
1458 hook_name_size
= HOOK_LEN
;
1460 else if (!strncmp (comname
, HOOK_POST_STRING
, HOOK_POST_LEN
))
1462 hook_type
= CMD_POST_HOOK
;
1463 hook_name_size
= HOOK_POST_LEN
;
1466 if (hook_type
!= CMD_NO_HOOK
)
1468 /* Look up cmd it hooks, and verify that we got an exact match. */
1469 tem_c
= comname
+ hook_name_size
;
1470 hookc
= lookup_cmd (&tem_c
, *list
, "", -1, 0);
1471 if (hookc
&& strcmp (comname
+ hook_name_size
, hookc
->name
) != 0)
1475 warning (_("Your new `%s' command does not "
1476 "hook any existing command."),
1478 if (!query (_("Proceed? ")))
1479 error (_("Not confirmed."));
1483 comname
= xstrdup (comname
);
1485 xsnprintf (tmpbuf
, sizeof (tmpbuf
),
1486 "Type commands for definition of \"%s\".", comfull
);
1487 command_line_up cmds
= read_command_lines (tmpbuf
, from_tty
, 1, 0, 0);
1489 if (c
&& c
->theclass
== class_user
)
1490 free_command_lines (&c
->user_commands
);
1492 newc
= add_cmd (comname
, class_user
, user_defined_command
,
1493 (c
&& c
->theclass
== class_user
)
1494 ? c
->doc
: xstrdup ("User-defined."), list
);
1495 newc
->user_commands
= cmds
.release ();
1497 /* If this new command is a hook, then mark both commands as being
1504 hookc
->hook_pre
= newc
; /* Target gets hooked. */
1505 newc
->hookee_pre
= hookc
; /* We are marked as hooking target cmd. */
1508 hookc
->hook_post
= newc
; /* Target gets hooked. */
1509 newc
->hookee_post
= hookc
; /* We are marked as hooking
1513 /* Should never come here as hookc would be 0. */
1514 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1520 document_command (char *comname
, int from_tty
)
1522 struct cmd_list_element
*c
, **list
;
1528 list
= validate_comname (&comname
);
1531 c
= lookup_cmd (&tem
, *list
, "", 0, 1);
1533 if (c
->theclass
!= class_user
)
1534 error (_("Command \"%s\" is built-in."), comfull
);
1536 xsnprintf (tmpbuf
, sizeof (tmpbuf
), "Type documentation for \"%s\".",
1538 command_line_up doclines
= read_command_lines (tmpbuf
, from_tty
, 0, 0, 0);
1541 xfree ((char *) c
->doc
);
1544 struct command_line
*cl1
;
1548 for (cl1
= doclines
.get (); cl1
; cl1
= cl1
->next
)
1549 len
+= strlen (cl1
->line
) + 1;
1551 doc
= (char *) xmalloc (len
+ 1);
1554 for (cl1
= doclines
.get (); cl1
; cl1
= cl1
->next
)
1556 strcat (doc
, cl1
->line
);
1565 /* Used to implement source_command. */
1568 script_from_file (FILE *stream
, const char *file
)
1571 internal_error (__FILE__
, __LINE__
, _("called with NULL file pointer!"));
1573 scoped_restore restore_line_number
1574 = make_scoped_restore (&source_line_number
, 0);
1575 scoped_restore resotre_file
1576 = make_scoped_restore (&source_file_name
, file
);
1578 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
1582 read_command_file (stream
);
1584 CATCH (e
, RETURN_MASK_ERROR
)
1586 /* Re-throw the error, but with the file name information
1588 throw_error (e
.error
,
1589 _("%s:%d: Error in sourced command file:\n%s"),
1590 source_file_name
, source_line_number
, e
.message
);
1595 /* Print the definition of user command C to STREAM. Or, if C is a
1596 prefix command, show the definitions of all user commands under C
1597 (recursively). PREFIX and NAME combined are the name of the
1600 show_user_1 (struct cmd_list_element
*c
, const char *prefix
, const char *name
,
1601 struct ui_file
*stream
)
1603 struct command_line
*cmdlines
;
1605 if (c
->prefixlist
!= NULL
)
1607 const char *prefixname
= c
->prefixname
;
1609 for (c
= *c
->prefixlist
; c
!= NULL
; c
= c
->next
)
1610 if (c
->theclass
== class_user
|| c
->prefixlist
!= NULL
)
1611 show_user_1 (c
, prefixname
, c
->name
, gdb_stdout
);
1615 cmdlines
= c
->user_commands
;
1616 fprintf_filtered (stream
, "User command \"%s%s\":\n", prefix
, name
);
1620 print_command_lines (current_uiout
, cmdlines
, 1);
1621 fputs_filtered ("\n", stream
);
1625 _initialize_cli_script (void)
1627 add_com ("document", class_support
, document_command
, _("\
1628 Document a user-defined command.\n\
1629 Give command name as argument. Give documentation on following lines.\n\
1630 End with a line of just \"end\"."));
1631 add_com ("define", class_support
, define_command
, _("\
1632 Define a new command name. Command name is argument.\n\
1633 Definition appears on following lines, one command per line.\n\
1634 End with a line of just \"end\".\n\
1635 Use the \"document\" command to give documentation for the new command.\n\
1636 Commands defined in this way may have up to ten arguments."));
1638 add_com ("while", class_support
, while_command
, _("\
1639 Execute nested commands WHILE the conditional expression is non zero.\n\
1640 The conditional expression must follow the word `while' and must in turn be\n\
1641 followed by a new line. The nested commands must be entered one per line,\n\
1642 and should be terminated by the word `end'."));
1644 add_com ("if", class_support
, if_command
, _("\
1645 Execute nested commands once IF the conditional expression is non zero.\n\
1646 The conditional expression must follow the word `if' and must in turn be\n\
1647 followed by a new line. The nested commands must be entered one per line,\n\
1648 and should be terminated by the word 'else' or `end'. If an else clause\n\
1649 is used, the same rules apply to its nested commands as to the first ones."));