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 enum command_control_type ret
;
381 extern unsigned int max_user_call_depth
;
383 cmdlines
= c
->user_commands
;
388 scoped_user_args_level
push_user_args (args
);
390 if (user_args_stack
.size () > max_user_call_depth
)
391 error (_("Max user call depth exceeded -- command aborted."));
393 /* Set the instream to 0, indicating execution of a
394 user-defined function. */
395 scoped_restore restore_instream
396 = make_scoped_restore (&ui
->instream
, nullptr);
398 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
400 scoped_restore save_nesting
401 = make_scoped_restore (&command_nest_depth
, command_nest_depth
+ 1);
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
;
414 /* This function is called every time GDB prints a prompt. It ensures
415 that errors and the like do not confuse the command tracing. */
418 reset_command_nest_depth (void)
420 command_nest_depth
= 1;
423 suppress_next_print_command_trace
= 0;
426 /* Print the command, prefixed with '+' to represent the call depth.
427 This is slightly complicated because this function may be called
428 from execute_command and execute_control_command. Unfortunately
429 execute_command also prints the top level control commands.
430 In these cases execute_command will call execute_control_command
431 via while_command or if_command. Inner levels of 'if' and 'while'
432 are dealt with directly. Therefore we can use these functions
433 to determine whether the command has been printed already or not. */
435 print_command_trace (const char *cmd
)
439 if (suppress_next_print_command_trace
)
441 suppress_next_print_command_trace
= 0;
445 if (!source_verbose
&& !trace_commands
)
448 for (i
=0; i
< command_nest_depth
; i
++)
449 printf_filtered ("+");
451 printf_filtered ("%s\n", cmd
);
454 enum command_control_type
455 execute_control_command (struct command_line
*cmd
)
457 struct command_line
*current
;
459 struct value
*val_mark
;
461 enum command_control_type ret
;
463 /* Start by assuming failure, if a problem is detected, the code
464 below will simply "break" out of the switch. */
465 ret
= invalid_control
;
467 switch (cmd
->control_type
)
471 /* A simple command, execute it and return. */
472 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
473 execute_command (&new_line
[0], 0);
474 ret
= cmd
->control_type
;
478 case continue_control
:
479 print_command_trace ("loop_continue");
481 /* Return for "continue", and "break" so we can either
482 continue the loop at the top, or break out. */
483 ret
= cmd
->control_type
;
487 print_command_trace ("loop_break");
489 /* Return for "continue", and "break" so we can either
490 continue the loop at the top, or break out. */
491 ret
= cmd
->control_type
;
496 int len
= strlen (cmd
->line
) + 7;
497 char *buffer
= (char *) alloca (len
);
499 xsnprintf (buffer
, len
, "while %s", cmd
->line
);
500 print_command_trace (buffer
);
502 /* Parse the loop control expression for the while statement. */
503 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
504 expression_up expr
= parse_expression (new_line
.c_str ());
506 ret
= simple_control
;
509 /* Keep iterating so long as the expression is true. */
516 /* Evaluate the expression. */
517 val_mark
= value_mark ();
518 val
= evaluate_expression (expr
.get ());
519 cond_result
= value_true (val
);
520 value_free_to_mark (val_mark
);
522 /* If the value is false, then break out of the loop. */
526 /* Execute the body of the while statement. */
527 current
= *cmd
->body_list
;
530 scoped_restore save_nesting
531 = make_scoped_restore (&command_nest_depth
, command_nest_depth
+ 1);
532 ret
= execute_control_command (current
);
534 /* If we got an error, or a "break" command, then stop
536 if (ret
== invalid_control
|| ret
== break_control
)
542 /* If we got a "continue" command, then restart the loop
544 if (ret
== continue_control
)
547 /* Get the next statement. */
548 current
= current
->next
;
552 /* Reset RET so that we don't recurse the break all the way down. */
553 if (ret
== break_control
)
554 ret
= simple_control
;
561 int len
= strlen (cmd
->line
) + 4;
562 char *buffer
= (char *) alloca (len
);
564 xsnprintf (buffer
, len
, "if %s", cmd
->line
);
565 print_command_trace (buffer
);
567 /* Parse the conditional for the if statement. */
568 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
569 expression_up expr
= parse_expression (new_line
.c_str ());
572 ret
= simple_control
;
574 /* Evaluate the conditional. */
575 val_mark
= value_mark ();
576 val
= evaluate_expression (expr
.get ());
578 /* Choose which arm to take commands from based on the value
579 of the conditional expression. */
580 if (value_true (val
))
581 current
= *cmd
->body_list
;
582 else if (cmd
->body_count
== 2)
583 current
= *(cmd
->body_list
+ 1);
584 value_free_to_mark (val_mark
);
586 /* Execute commands in the given arm. */
589 scoped_restore save_nesting
590 = make_scoped_restore (&command_nest_depth
, command_nest_depth
+ 1);
591 ret
= execute_control_command (current
);
593 /* If we got an error, get out. */
594 if (ret
!= simple_control
)
597 /* Get the next statement in the body. */
598 current
= current
->next
;
604 case commands_control
:
606 /* Breakpoint commands list, record the commands in the
607 breakpoint's command list and return. */
608 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
609 ret
= commands_from_control_command (new_line
.c_str (), cmd
);
613 case compile_control
:
614 eval_compile_command (cmd
, NULL
, cmd
->control_u
.compile
.scope
,
615 cmd
->control_u
.compile
.scope_data
);
616 ret
= simple_control
;
622 eval_ext_lang_from_control_command (cmd
);
623 ret
= simple_control
;
628 warning (_("Invalid control type in canned commands structure."));
635 /* Like execute_control_command, but first set
636 suppress_next_print_command_trace. */
638 enum command_control_type
639 execute_control_command_untraced (struct command_line
*cmd
)
641 suppress_next_print_command_trace
= 1;
642 return execute_control_command (cmd
);
646 /* "while" command support. Executes a body of statements while the
647 loop condition is nonzero. */
650 while_command (char *arg
, int from_tty
)
653 command_line_up command
= get_command_line (while_control
, arg
);
658 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
660 execute_control_command_untraced (command
.get ());
663 /* "if" command support. Execute either the true or false arm depending
664 on the value of the if conditional. */
667 if_command (char *arg
, int from_tty
)
670 command_line_up command
= get_command_line (if_control
, arg
);
675 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
677 execute_control_command_untraced (command
.get ());
680 /* Bind the incoming arguments for a user defined command to $arg0,
683 user_args::user_args (const char *command_line
)
687 if (command_line
== NULL
)
690 m_command_line
= command_line
;
691 p
= m_command_line
.c_str ();
695 const char *start_arg
;
700 /* Strip whitespace. */
701 while (*p
== ' ' || *p
== '\t')
704 /* P now points to an argument. */
707 /* Get to the end of this argument. */
710 if (((*p
== ' ' || *p
== '\t')) && !squote
&& !dquote
&& !bsquote
)
739 m_args
.emplace_back (start_arg
, p
- start_arg
);
743 /* Given character string P, return a point to the first argument
744 ($arg), or NULL if P contains no arguments. */
747 locate_arg (const char *p
)
749 while ((p
= strchr (p
, '$')))
751 if (startswith (p
, "$arg")
752 && (isdigit (p
[4]) || p
[4] == 'c'))
759 /* See cli-script.h. */
762 insert_user_defined_cmd_args (const char *line
)
764 /* If we are not in a user-defined command, treat $argc, $arg0, et
765 cetera as normal convenience variables. */
766 if (user_args_stack
.empty ())
769 const std::unique_ptr
<user_args
> &args
= user_args_stack
.back ();
770 return args
->insert_args (line
);
773 /* Insert the user defined arguments stored in user_args into the $arg
774 arguments found in line. */
777 user_args::insert_args (const char *line
) const
779 std::string new_line
;
782 while ((p
= locate_arg (line
)))
784 new_line
.append (line
, p
- line
);
788 new_line
+= std::to_string (m_args
.size ());
797 i
= strtoul (p
+ 4, &tmp
, 10);
798 if ((i
== 0 && tmp
== p
+ 4) || errno
!= 0)
800 else if (i
>= m_args
.size ())
801 error (_("Missing argument %ld in user function."), i
);
804 new_line
.append (m_args
[i
].str
, m_args
[i
].len
);
809 /* Don't forget the tail. */
810 new_line
.append (line
);
816 /* Expand the body_list of COMMAND so that it can hold NEW_LENGTH
817 code bodies. This is typically used when we encounter an "else"
818 clause for an "if" command. */
821 realloc_body_list (struct command_line
*command
, int new_length
)
824 struct command_line
**body_list
;
826 n
= command
->body_count
;
832 body_list
= XCNEWVEC (struct command_line
*, new_length
);
834 memcpy (body_list
, command
->body_list
, sizeof (struct command_line
*) * n
);
836 xfree (command
->body_list
);
837 command
->body_list
= body_list
;
838 command
->body_count
= new_length
;
841 /* Read next line from stdin. Passed to read_command_line_1 and
842 recurse_read_control_structure whenever we need to read commands
846 read_next_line (void)
848 struct ui
*ui
= current_ui
;
849 char *prompt_ptr
, control_prompt
[256];
851 int from_tty
= ui
->instream
== ui
->stdin_stream
;
853 if (control_level
>= 254)
854 error (_("Control nesting too deep!"));
856 /* Set a prompt based on the nesting of the control commands. */
858 || (ui
->instream
== 0 && deprecated_readline_hook
!= NULL
))
860 for (i
= 0; i
< control_level
; i
++)
861 control_prompt
[i
] = ' ';
862 control_prompt
[i
] = '>';
863 control_prompt
[i
+ 1] = '\0';
864 prompt_ptr
= (char *) &control_prompt
[0];
869 return command_line_input (prompt_ptr
, from_tty
, "commands");
872 /* Return true if CMD's name is NAME. */
875 command_name_equals (struct cmd_list_element
*cmd
, const char *name
)
878 && cmd
!= CMD_LIST_AMBIGUOUS
879 && strcmp (cmd
->name
, name
) == 0);
882 /* Given an input line P, skip the command and return a pointer to the
886 line_first_arg (const char *p
)
888 const char *first_arg
= p
+ find_command_name_length (p
);
890 return skip_spaces_const (first_arg
);
893 /* Process one input line. If the command is an "end", return such an
894 indication to the caller. If PARSE_COMMANDS is true, strip leading
895 whitespace (trailing whitespace is always stripped) in the line,
896 attempt to recognize GDB control commands, and also return an
897 indication if the command is an "else" or a nop.
899 Otherwise, only "end" is recognized. */
901 static enum misc_command_type
902 process_next_line (char *p
, struct command_line
**command
, int parse_commands
,
903 void (*validator
)(char *, void *), void *closure
)
909 /* Not sure what to do here. */
913 /* Strip trailing whitespace. */
914 p_end
= p
+ strlen (p
);
915 while (p_end
> p
&& (p_end
[-1] == ' ' || p_end
[-1] == '\t'))
919 /* Strip leading whitespace. */
920 while (p_start
< p_end
&& (*p_start
== ' ' || *p_start
== '\t'))
923 /* 'end' is always recognized, regardless of parse_commands value.
924 We also permit whitespace before end and after. */
925 if (p_end
- p_start
== 3 && startswith (p_start
, "end"))
930 /* Resolve command abbreviations (e.g. 'ws' for 'while-stepping'). */
931 const char *cmd_name
= p
;
932 struct cmd_list_element
*cmd
933 = lookup_cmd_1 (&cmd_name
, cmdlist
, NULL
, 1);
934 cmd_name
= skip_spaces_const (cmd_name
);
935 bool inline_cmd
= *cmd_name
!= '\0';
937 /* If commands are parsed, we skip initial spaces. Otherwise,
938 which is the case for Python commands and documentation
939 (see the 'document' command), spaces are preserved. */
942 /* Blanks and comments don't really do anything, but we need to
943 distinguish them from else, end and other commands which can
945 if (p_end
== p
|| p
[0] == '#')
948 /* Is the else clause of an if control structure? */
949 if (p_end
- p
== 4 && startswith (p
, "else"))
952 /* Check for while, if, break, continue, etc and build a new
953 command line structure for them. */
954 if (command_name_equals (cmd
, "while-stepping"))
956 /* Because validate_actionline and encode_action lookup
957 command's line as command, we need the line to
958 include 'while-stepping'.
960 For 'ws' alias, the command will have 'ws', not expanded
961 to 'while-stepping'. This is intentional -- we don't
962 really want frontend to send a command list with 'ws',
963 and next break-info returning command line with
964 'while-stepping'. This should work, but might cause the
965 breakpoint to be marked as changed while it's actually
967 *command
= build_command_line (while_stepping_control
, p
);
969 else if (command_name_equals (cmd
, "while"))
971 *command
= build_command_line (while_control
, line_first_arg (p
));
973 else if (command_name_equals (cmd
, "if"))
975 *command
= build_command_line (if_control
, line_first_arg (p
));
977 else if (command_name_equals (cmd
, "commands"))
979 *command
= build_command_line (commands_control
, line_first_arg (p
));
981 else if (command_name_equals (cmd
, "python") && !inline_cmd
)
983 /* Note that we ignore the inline "python command" form
985 *command
= build_command_line (python_control
, "");
987 else if (command_name_equals (cmd
, "compile") && !inline_cmd
)
989 /* Note that we ignore the inline "compile command" form
991 *command
= build_command_line (compile_control
, "");
992 (*command
)->control_u
.compile
.scope
= COMPILE_I_INVALID_SCOPE
;
994 else if (command_name_equals (cmd
, "guile") && !inline_cmd
)
996 /* Note that we ignore the inline "guile command" form here. */
997 *command
= build_command_line (guile_control
, "");
999 else if (p_end
- p
== 10 && startswith (p
, "loop_break"))
1001 *command
= XNEW (struct command_line
);
1002 (*command
)->next
= NULL
;
1003 (*command
)->line
= NULL
;
1004 (*command
)->control_type
= break_control
;
1005 (*command
)->body_count
= 0;
1006 (*command
)->body_list
= NULL
;
1008 else if (p_end
- p
== 13 && startswith (p
, "loop_continue"))
1010 *command
= XNEW (struct command_line
);
1011 (*command
)->next
= NULL
;
1012 (*command
)->line
= NULL
;
1013 (*command
)->control_type
= continue_control
;
1014 (*command
)->body_count
= 0;
1015 (*command
)->body_list
= NULL
;
1021 if (!parse_commands
|| not_handled
)
1023 /* A normal command. */
1024 *command
= XNEW (struct command_line
);
1025 (*command
)->next
= NULL
;
1026 (*command
)->line
= savestring (p
, p_end
- p
);
1027 (*command
)->control_type
= simple_control
;
1028 (*command
)->body_count
= 0;
1029 (*command
)->body_list
= NULL
;
1037 validator ((*command
)->line
, closure
);
1039 CATCH (ex
, RETURN_MASK_ALL
)
1042 throw_exception (ex
);
1047 /* Nothing special. */
1051 /* Recursively read in the control structures and create a
1052 command_line structure from them. Use read_next_line_func to
1053 obtain lines of the command. */
1055 static enum command_control_type
1056 recurse_read_control_structure (char * (*read_next_line_func
) (void),
1057 struct command_line
*current_cmd
,
1058 void (*validator
)(char *, void *),
1061 int current_body
, i
;
1062 enum misc_command_type val
;
1063 enum command_control_type ret
;
1064 struct command_line
**body_ptr
, *child_tail
, *next
;
1069 /* Sanity checks. */
1070 if (current_cmd
->control_type
== simple_control
)
1071 error (_("Recursed on a simple control type."));
1073 if (current_body
> current_cmd
->body_count
)
1074 error (_("Allocated body is smaller than this command type needs."));
1076 /* Read lines from the input stream and build control structures. */
1082 val
= process_next_line (read_next_line_func (), &next
,
1083 current_cmd
->control_type
!= python_control
1084 && current_cmd
->control_type
!= guile_control
1085 && current_cmd
->control_type
!= compile_control
,
1086 validator
, closure
);
1088 /* Just skip blanks and comments. */
1089 if (val
== nop_command
)
1092 if (val
== end_command
)
1094 if (multi_line_command_p (current_cmd
->control_type
))
1096 /* Success reading an entire canned sequence of commands. */
1097 ret
= simple_control
;
1102 ret
= invalid_control
;
1107 /* Not the end of a control structure. */
1108 if (val
== else_command
)
1110 if (current_cmd
->control_type
== if_control
1111 && current_body
== 1)
1113 realloc_body_list (current_cmd
, 2);
1120 ret
= invalid_control
;
1127 child_tail
->next
= next
;
1131 body_ptr
= current_cmd
->body_list
;
1132 for (i
= 1; i
< current_body
; i
++)
1141 /* If the latest line is another control structure, then recurse
1143 if (multi_line_command_p (next
->control_type
))
1146 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1147 validator
, closure
);
1150 if (ret
!= simple_control
)
1161 restore_interp (void *arg
)
1163 interp_set_temp (interp_name ((struct interp
*)arg
));
1166 /* Read lines from the input stream and accumulate them in a chain of
1167 struct command_line's, which is then returned. For input from a
1168 terminal, the special command "end" is used to mark the end of the
1169 input, and is not included in the returned chain of commands.
1171 If PARSE_COMMANDS is true, strip leading whitespace (trailing whitespace
1172 is always stripped) in the line and attempt to recognize GDB control
1173 commands. Otherwise, only "end" is recognized. */
1175 #define END_MESSAGE "End with a line saying just \"end\"."
1178 read_command_lines (char *prompt_arg
, int from_tty
, int parse_commands
,
1179 void (*validator
)(char *, void *), void *closure
)
1181 if (from_tty
&& input_interactive_p (current_ui
))
1183 if (deprecated_readline_begin_hook
)
1185 /* Note - intentional to merge messages with no newline. */
1186 (*deprecated_readline_begin_hook
) ("%s %s\n", prompt_arg
,
1191 printf_unfiltered ("%s\n%s\n", prompt_arg
, END_MESSAGE
);
1192 gdb_flush (gdb_stdout
);
1197 /* Reading commands assumes the CLI behavior, so temporarily
1198 override the current interpreter with CLI. */
1199 command_line_up head
;
1200 if (current_interp_named_p (INTERP_CONSOLE
))
1201 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1202 validator
, closure
);
1205 struct interp
*old_interp
= interp_set_temp (INTERP_CONSOLE
);
1206 struct cleanup
*old_chain
= make_cleanup (restore_interp
, old_interp
);
1208 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1209 validator
, closure
);
1210 do_cleanups (old_chain
);
1213 if (from_tty
&& input_interactive_p (current_ui
)
1214 && deprecated_readline_end_hook
)
1216 (*deprecated_readline_end_hook
) ();
1221 /* Act the same way as read_command_lines, except that each new line is
1222 obtained using READ_NEXT_LINE_FUNC. */
1225 read_command_lines_1 (char * (*read_next_line_func
) (void), int parse_commands
,
1226 void (*validator
)(char *, void *), void *closure
)
1228 struct command_line
*tail
, *next
;
1229 command_line_up head
;
1230 enum command_control_type ret
;
1231 enum misc_command_type val
;
1239 val
= process_next_line (read_next_line_func (), &next
, parse_commands
,
1240 validator
, closure
);
1242 /* Ignore blank lines or comments. */
1243 if (val
== nop_command
)
1246 if (val
== end_command
)
1248 ret
= simple_control
;
1252 if (val
!= ok_command
)
1254 ret
= invalid_control
;
1258 if (multi_line_command_p (next
->control_type
))
1261 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1262 validator
, closure
);
1265 if (ret
== invalid_control
)
1282 if (ret
== invalid_control
)
1288 /* Free a chain of struct command_line's. */
1291 free_command_lines (struct command_line
**lptr
)
1293 struct command_line
*l
= *lptr
;
1294 struct command_line
*next
;
1295 struct command_line
**blist
;
1300 if (l
->body_count
> 0)
1302 blist
= l
->body_list
;
1303 for (i
= 0; i
< l
->body_count
; i
++, blist
++)
1304 free_command_lines (blist
);
1315 copy_command_lines (struct command_line
*cmds
)
1317 struct command_line
*result
= NULL
;
1321 result
= XNEW (struct command_line
);
1323 result
->next
= copy_command_lines (cmds
->next
).release ();
1324 result
->line
= xstrdup (cmds
->line
);
1325 result
->control_type
= cmds
->control_type
;
1326 result
->body_count
= cmds
->body_count
;
1327 if (cmds
->body_count
> 0)
1331 result
->body_list
= XNEWVEC (struct command_line
*, cmds
->body_count
);
1333 for (i
= 0; i
< cmds
->body_count
; i
++)
1334 result
->body_list
[i
]
1335 = copy_command_lines (cmds
->body_list
[i
]).release ();
1338 result
->body_list
= NULL
;
1341 return command_line_up (result
);
1344 /* Validate that *COMNAME is a valid name for a command. Return the
1345 containing command list, in case it starts with a prefix command.
1346 The prefix must already exist. *COMNAME is advanced to point after
1347 any prefix, and a NUL character overwrites the space after the
1350 static struct cmd_list_element
**
1351 validate_comname (char **comname
)
1353 struct cmd_list_element
**list
= &cmdlist
;
1354 char *p
, *last_word
;
1357 error_no_arg (_("name of command to define"));
1359 /* Find the last word of the argument. */
1360 p
= *comname
+ strlen (*comname
);
1361 while (p
> *comname
&& isspace (p
[-1]))
1363 while (p
> *comname
&& !isspace (p
[-1]))
1367 /* Find the corresponding command list. */
1368 if (last_word
!= *comname
)
1370 struct cmd_list_element
*c
;
1372 const char *tem
= *comname
;
1374 /* Separate the prefix and the command. */
1375 saved_char
= last_word
[-1];
1376 last_word
[-1] = '\0';
1378 c
= lookup_cmd (&tem
, cmdlist
, "", 0, 1);
1379 if (c
->prefixlist
== NULL
)
1380 error (_("\"%s\" is not a prefix command."), *comname
);
1382 list
= c
->prefixlist
;
1383 last_word
[-1] = saved_char
;
1384 *comname
= last_word
;
1390 if (!isalnum (*p
) && *p
!= '-' && *p
!= '_')
1391 error (_("Junk in argument list: \"%s\""), p
);
1398 /* This is just a placeholder in the command data structures. */
1400 user_defined_command (char *ignore
, int from_tty
)
1405 define_command (char *comname
, int from_tty
)
1407 #define MAX_TMPBUF 128
1414 struct cmd_list_element
*c
, *newc
, *hookc
= 0, **list
;
1415 char *tem
, *comfull
;
1417 char tmpbuf
[MAX_TMPBUF
];
1418 int hook_type
= CMD_NO_HOOK
;
1419 int hook_name_size
= 0;
1421 #define HOOK_STRING "hook-"
1423 #define HOOK_POST_STRING "hookpost-"
1424 #define HOOK_POST_LEN 9
1427 list
= validate_comname (&comname
);
1429 /* Look it up, and verify that we got an exact match. */
1431 c
= lookup_cmd (&tem_c
, *list
, "", -1, 1);
1432 if (c
&& strcmp (comname
, c
->name
) != 0)
1439 if (c
->theclass
== class_user
|| c
->theclass
== class_alias
)
1440 q
= query (_("Redefine command \"%s\"? "), c
->name
);
1442 q
= query (_("Really redefine built-in command \"%s\"? "), c
->name
);
1444 error (_("Command \"%s\" not redefined."), c
->name
);
1447 /* If this new command is a hook, then mark the command which it
1448 is hooking. Note that we allow hooking `help' commands, so that
1449 we can hook the `stop' pseudo-command. */
1451 if (!strncmp (comname
, HOOK_STRING
, HOOK_LEN
))
1453 hook_type
= CMD_PRE_HOOK
;
1454 hook_name_size
= HOOK_LEN
;
1456 else if (!strncmp (comname
, HOOK_POST_STRING
, HOOK_POST_LEN
))
1458 hook_type
= CMD_POST_HOOK
;
1459 hook_name_size
= HOOK_POST_LEN
;
1462 if (hook_type
!= CMD_NO_HOOK
)
1464 /* Look up cmd it hooks, and verify that we got an exact match. */
1465 tem_c
= comname
+ hook_name_size
;
1466 hookc
= lookup_cmd (&tem_c
, *list
, "", -1, 0);
1467 if (hookc
&& strcmp (comname
+ hook_name_size
, hookc
->name
) != 0)
1471 warning (_("Your new `%s' command does not "
1472 "hook any existing command."),
1474 if (!query (_("Proceed? ")))
1475 error (_("Not confirmed."));
1479 comname
= xstrdup (comname
);
1481 /* If the rest of the commands will be case insensitive, this one
1482 should behave in the same manner. */
1483 for (tem
= comname
; *tem
; tem
++)
1485 *tem
= tolower (*tem
);
1487 xsnprintf (tmpbuf
, sizeof (tmpbuf
),
1488 "Type commands for definition of \"%s\".", comfull
);
1489 command_line_up cmds
= read_command_lines (tmpbuf
, from_tty
, 1, 0, 0);
1491 if (c
&& c
->theclass
== class_user
)
1492 free_command_lines (&c
->user_commands
);
1494 newc
= add_cmd (comname
, class_user
, user_defined_command
,
1495 (c
&& c
->theclass
== class_user
)
1496 ? c
->doc
: xstrdup ("User-defined."), list
);
1497 newc
->user_commands
= cmds
.release ();
1499 /* If this new command is a hook, then mark both commands as being
1506 hookc
->hook_pre
= newc
; /* Target gets hooked. */
1507 newc
->hookee_pre
= hookc
; /* We are marked as hooking target cmd. */
1510 hookc
->hook_post
= newc
; /* Target gets hooked. */
1511 newc
->hookee_post
= hookc
; /* We are marked as hooking
1515 /* Should never come here as hookc would be 0. */
1516 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1522 document_command (char *comname
, int from_tty
)
1524 struct cmd_list_element
*c
, **list
;
1530 list
= validate_comname (&comname
);
1533 c
= lookup_cmd (&tem
, *list
, "", 0, 1);
1535 if (c
->theclass
!= class_user
)
1536 error (_("Command \"%s\" is built-in."), comfull
);
1538 xsnprintf (tmpbuf
, sizeof (tmpbuf
), "Type documentation for \"%s\".",
1540 command_line_up doclines
= read_command_lines (tmpbuf
, from_tty
, 0, 0, 0);
1543 xfree ((char *) c
->doc
);
1546 struct command_line
*cl1
;
1550 for (cl1
= doclines
.get (); cl1
; cl1
= cl1
->next
)
1551 len
+= strlen (cl1
->line
) + 1;
1553 doc
= (char *) xmalloc (len
+ 1);
1556 for (cl1
= doclines
.get (); cl1
; cl1
= cl1
->next
)
1558 strcat (doc
, cl1
->line
);
1567 /* Used to implement source_command. */
1570 script_from_file (FILE *stream
, const char *file
)
1573 internal_error (__FILE__
, __LINE__
, _("called with NULL file pointer!"));
1575 scoped_restore restore_line_number
1576 = make_scoped_restore (&source_line_number
, 0);
1577 scoped_restore resotre_file
1578 = make_scoped_restore (&source_file_name
, file
);
1580 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
1584 read_command_file (stream
);
1586 CATCH (e
, RETURN_MASK_ERROR
)
1588 /* Re-throw the error, but with the file name information
1590 throw_error (e
.error
,
1591 _("%s:%d: Error in sourced command file:\n%s"),
1592 source_file_name
, source_line_number
, e
.message
);
1597 /* Print the definition of user command C to STREAM. Or, if C is a
1598 prefix command, show the definitions of all user commands under C
1599 (recursively). PREFIX and NAME combined are the name of the
1602 show_user_1 (struct cmd_list_element
*c
, const char *prefix
, const char *name
,
1603 struct ui_file
*stream
)
1605 struct command_line
*cmdlines
;
1607 if (c
->prefixlist
!= NULL
)
1609 const char *prefixname
= c
->prefixname
;
1611 for (c
= *c
->prefixlist
; c
!= NULL
; c
= c
->next
)
1612 if (c
->theclass
== class_user
|| c
->prefixlist
!= NULL
)
1613 show_user_1 (c
, prefixname
, c
->name
, gdb_stdout
);
1617 cmdlines
= c
->user_commands
;
1618 fprintf_filtered (stream
, "User command \"%s%s\":\n", prefix
, name
);
1622 print_command_lines (current_uiout
, cmdlines
, 1);
1623 fputs_filtered ("\n", stream
);
1628 initialize_file_ftype _initialize_cli_script
;
1631 _initialize_cli_script (void)
1633 add_com ("document", class_support
, document_command
, _("\
1634 Document a user-defined command.\n\
1635 Give command name as argument. Give documentation on following lines.\n\
1636 End with a line of just \"end\"."));
1637 add_com ("define", class_support
, define_command
, _("\
1638 Define a new command name. Command name is argument.\n\
1639 Definition appears on following lines, one command per line.\n\
1640 End with a line of just \"end\".\n\
1641 Use the \"document\" command to give documentation for the new command.\n\
1642 Commands defined in this way may have up to ten arguments."));
1644 add_com ("while", class_support
, while_command
, _("\
1645 Execute nested commands WHILE the conditional expression is non zero.\n\
1646 The conditional expression must follow the word `while' 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 `end'."));
1650 add_com ("if", class_support
, if_command
, _("\
1651 Execute nested commands once IF the conditional expression is non zero.\n\
1652 The conditional expression must follow the word `if' and must in turn be\n\
1653 followed by a new line. The nested commands must be entered one per line,\n\
1654 and should be terminated by the word 'else' or `end'. If an else clause\n\
1655 is used, the same rules apply to its nested commands as to the first ones."));