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
);
375 /* Execute the command in CMD. */
377 do_restore_user_call_depth (void * call_depth
)
379 int *depth
= (int *) call_depth
;
388 execute_user_command (struct cmd_list_element
*c
, char *args
)
390 struct ui
*ui
= current_ui
;
391 struct command_line
*cmdlines
;
392 struct cleanup
*old_chain
;
393 enum command_control_type ret
;
394 static int user_call_depth
= 0;
395 extern unsigned int max_user_call_depth
;
397 cmdlines
= c
->user_commands
;
402 scoped_user_args_level
push_user_args (args
);
404 if (++user_call_depth
> max_user_call_depth
)
405 error (_("Max user call depth exceeded -- command aborted."));
407 old_chain
= make_cleanup (do_restore_user_call_depth
, &user_call_depth
);
409 /* Set the instream to 0, indicating execution of a
410 user-defined function. */
411 make_cleanup (do_restore_instream_cleanup
, ui
->instream
);
414 /* Also set the global in_user_command, so that NULL instream is
415 not confused with Insight. */
418 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
420 command_nest_depth
++;
423 ret
= execute_control_command (cmdlines
);
424 if (ret
!= simple_control
&& ret
!= break_control
)
426 warning (_("Error executing canned sequence of commands."));
429 cmdlines
= cmdlines
->next
;
431 command_nest_depth
--;
432 do_cleanups (old_chain
);
435 /* This function is called every time GDB prints a prompt. It ensures
436 that errors and the like do not confuse the command tracing. */
439 reset_command_nest_depth (void)
441 command_nest_depth
= 1;
444 suppress_next_print_command_trace
= 0;
447 /* Print the command, prefixed with '+' to represent the call depth.
448 This is slightly complicated because this function may be called
449 from execute_command and execute_control_command. Unfortunately
450 execute_command also prints the top level control commands.
451 In these cases execute_command will call execute_control_command
452 via while_command or if_command. Inner levels of 'if' and 'while'
453 are dealt with directly. Therefore we can use these functions
454 to determine whether the command has been printed already or not. */
456 print_command_trace (const char *cmd
)
460 if (suppress_next_print_command_trace
)
462 suppress_next_print_command_trace
= 0;
466 if (!source_verbose
&& !trace_commands
)
469 for (i
=0; i
< command_nest_depth
; i
++)
470 printf_filtered ("+");
472 printf_filtered ("%s\n", cmd
);
475 enum command_control_type
476 execute_control_command (struct command_line
*cmd
)
478 struct command_line
*current
;
480 struct value
*val_mark
;
482 enum command_control_type ret
;
484 /* Start by assuming failure, if a problem is detected, the code
485 below will simply "break" out of the switch. */
486 ret
= invalid_control
;
488 switch (cmd
->control_type
)
492 /* A simple command, execute it and return. */
493 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
494 execute_command (&new_line
[0], 0);
495 ret
= cmd
->control_type
;
499 case continue_control
:
500 print_command_trace ("loop_continue");
502 /* Return for "continue", and "break" so we can either
503 continue the loop at the top, or break out. */
504 ret
= cmd
->control_type
;
508 print_command_trace ("loop_break");
510 /* Return for "continue", and "break" so we can either
511 continue the loop at the top, or break out. */
512 ret
= cmd
->control_type
;
517 int len
= strlen (cmd
->line
) + 7;
518 char *buffer
= (char *) alloca (len
);
520 xsnprintf (buffer
, len
, "while %s", cmd
->line
);
521 print_command_trace (buffer
);
523 /* Parse the loop control expression for the while statement. */
524 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
525 expression_up expr
= parse_expression (new_line
.c_str ());
527 ret
= simple_control
;
530 /* Keep iterating so long as the expression is true. */
537 /* Evaluate the expression. */
538 val_mark
= value_mark ();
539 val
= evaluate_expression (expr
.get ());
540 cond_result
= value_true (val
);
541 value_free_to_mark (val_mark
);
543 /* If the value is false, then break out of the loop. */
547 /* Execute the body of the while statement. */
548 current
= *cmd
->body_list
;
551 command_nest_depth
++;
552 ret
= execute_control_command (current
);
553 command_nest_depth
--;
555 /* If we got an error, or a "break" command, then stop
557 if (ret
== invalid_control
|| ret
== break_control
)
563 /* If we got a "continue" command, then restart the loop
565 if (ret
== continue_control
)
568 /* Get the next statement. */
569 current
= current
->next
;
573 /* Reset RET so that we don't recurse the break all the way down. */
574 if (ret
== break_control
)
575 ret
= simple_control
;
582 int len
= strlen (cmd
->line
) + 4;
583 char *buffer
= (char *) alloca (len
);
585 xsnprintf (buffer
, len
, "if %s", cmd
->line
);
586 print_command_trace (buffer
);
588 /* Parse the conditional for the if statement. */
589 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
590 expression_up expr
= parse_expression (new_line
.c_str ());
593 ret
= simple_control
;
595 /* Evaluate the conditional. */
596 val_mark
= value_mark ();
597 val
= evaluate_expression (expr
.get ());
599 /* Choose which arm to take commands from based on the value
600 of the conditional expression. */
601 if (value_true (val
))
602 current
= *cmd
->body_list
;
603 else if (cmd
->body_count
== 2)
604 current
= *(cmd
->body_list
+ 1);
605 value_free_to_mark (val_mark
);
607 /* Execute commands in the given arm. */
610 command_nest_depth
++;
611 ret
= execute_control_command (current
);
612 command_nest_depth
--;
614 /* If we got an error, get out. */
615 if (ret
!= simple_control
)
618 /* Get the next statement in the body. */
619 current
= current
->next
;
625 case commands_control
:
627 /* Breakpoint commands list, record the commands in the
628 breakpoint's command list and return. */
629 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
630 ret
= commands_from_control_command (new_line
.c_str (), cmd
);
634 case compile_control
:
635 eval_compile_command (cmd
, NULL
, cmd
->control_u
.compile
.scope
,
636 cmd
->control_u
.compile
.scope_data
);
637 ret
= simple_control
;
643 eval_ext_lang_from_control_command (cmd
);
644 ret
= simple_control
;
649 warning (_("Invalid control type in canned commands structure."));
656 /* Like execute_control_command, but first set
657 suppress_next_print_command_trace. */
659 enum command_control_type
660 execute_control_command_untraced (struct command_line
*cmd
)
662 suppress_next_print_command_trace
= 1;
663 return execute_control_command (cmd
);
667 /* "while" command support. Executes a body of statements while the
668 loop condition is nonzero. */
671 while_command (char *arg
, int from_tty
)
674 command_line_up command
= get_command_line (while_control
, arg
);
679 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
681 execute_control_command_untraced (command
.get ());
684 /* "if" command support. Execute either the true or false arm depending
685 on the value of the if conditional. */
688 if_command (char *arg
, int from_tty
)
691 command_line_up command
= get_command_line (if_control
, arg
);
696 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
698 execute_control_command_untraced (command
.get ());
701 /* Bind the incoming arguments for a user defined command to $arg0,
704 user_args::user_args (const char *command_line
)
708 if (command_line
== NULL
)
711 m_command_line
= command_line
;
712 p
= m_command_line
.c_str ();
716 const char *start_arg
;
721 /* Strip whitespace. */
722 while (*p
== ' ' || *p
== '\t')
725 /* P now points to an argument. */
728 /* Get to the end of this argument. */
731 if (((*p
== ' ' || *p
== '\t')) && !squote
&& !dquote
&& !bsquote
)
760 m_args
.emplace_back (start_arg
, p
- start_arg
);
764 /* Given character string P, return a point to the first argument
765 ($arg), or NULL if P contains no arguments. */
768 locate_arg (const char *p
)
770 while ((p
= strchr (p
, '$')))
772 if (startswith (p
, "$arg")
773 && (isdigit (p
[4]) || p
[4] == 'c'))
780 /* See cli-script.h. */
783 insert_user_defined_cmd_args (const char *line
)
785 /* If we are not in a user-defined command, treat $argc, $arg0, et
786 cetera as normal convenience variables. */
787 if (user_args_stack
.empty ())
790 const std::unique_ptr
<user_args
> &args
= user_args_stack
.back ();
791 return args
->insert_args (line
);
794 /* Insert the user defined arguments stored in user_args into the $arg
795 arguments found in line. */
798 user_args::insert_args (const char *line
) const
800 std::string new_line
;
803 while ((p
= locate_arg (line
)))
805 new_line
.append (line
, p
- line
);
809 new_line
+= std::to_string (m_args
.size ());
818 i
= strtoul (p
+ 4, &tmp
, 10);
819 if ((i
== 0 && tmp
== p
+ 4) || errno
!= 0)
821 else if (i
>= m_args
.size ())
822 error (_("Missing argument %ld in user function."), i
);
825 new_line
.append (m_args
[i
].str
, m_args
[i
].len
);
830 /* Don't forget the tail. */
831 new_line
.append (line
);
837 /* Expand the body_list of COMMAND so that it can hold NEW_LENGTH
838 code bodies. This is typically used when we encounter an "else"
839 clause for an "if" command. */
842 realloc_body_list (struct command_line
*command
, int new_length
)
845 struct command_line
**body_list
;
847 n
= command
->body_count
;
853 body_list
= XCNEWVEC (struct command_line
*, new_length
);
855 memcpy (body_list
, command
->body_list
, sizeof (struct command_line
*) * n
);
857 xfree (command
->body_list
);
858 command
->body_list
= body_list
;
859 command
->body_count
= new_length
;
862 /* Read next line from stdin. Passed to read_command_line_1 and
863 recurse_read_control_structure whenever we need to read commands
867 read_next_line (void)
869 struct ui
*ui
= current_ui
;
870 char *prompt_ptr
, control_prompt
[256];
872 int from_tty
= ui
->instream
== ui
->stdin_stream
;
874 if (control_level
>= 254)
875 error (_("Control nesting too deep!"));
877 /* Set a prompt based on the nesting of the control commands. */
879 || (ui
->instream
== 0 && deprecated_readline_hook
!= NULL
))
881 for (i
= 0; i
< control_level
; i
++)
882 control_prompt
[i
] = ' ';
883 control_prompt
[i
] = '>';
884 control_prompt
[i
+ 1] = '\0';
885 prompt_ptr
= (char *) &control_prompt
[0];
890 return command_line_input (prompt_ptr
, from_tty
, "commands");
893 /* Return true if CMD's name is NAME. */
896 command_name_equals (struct cmd_list_element
*cmd
, const char *name
)
899 && cmd
!= CMD_LIST_AMBIGUOUS
900 && strcmp (cmd
->name
, name
) == 0);
903 /* Return true if NAME is the only command between COMMAND_START and
904 COMMAND_END. This is useful when we want to know whether the
905 command is inline (i.e., has arguments like 'python command1') or
906 is the start of a multi-line command block. */
909 command_name_equals_not_inline (const char *command_start
,
910 const char *command_end
,
913 return (command_end
- command_start
== strlen (name
)
914 && startswith (command_start
, name
));
917 /* Given an input line P, skip the command and return a pointer to the
921 line_first_arg (const char *p
)
923 const char *first_arg
= p
+ find_command_name_length (p
);
925 return skip_spaces_const (first_arg
);
928 /* Process one input line. If the command is an "end", return such an
929 indication to the caller. If PARSE_COMMANDS is true, strip leading
930 whitespace (trailing whitespace is always stripped) in the line,
931 attempt to recognize GDB control commands, and also return an
932 indication if the command is an "else" or a nop.
934 Otherwise, only "end" is recognized. */
936 static enum misc_command_type
937 process_next_line (char *p
, struct command_line
**command
, int parse_commands
,
938 void (*validator
)(char *, void *), void *closure
)
944 /* Not sure what to do here. */
948 /* Strip trailing whitespace. */
949 p_end
= p
+ strlen (p
);
950 while (p_end
> p
&& (p_end
[-1] == ' ' || p_end
[-1] == '\t'))
954 /* Strip leading whitespace. */
955 while (p_start
< p_end
&& (*p_start
== ' ' || *p_start
== '\t'))
958 /* 'end' is always recognized, regardless of parse_commands value.
959 We also permit whitespace before end and after. */
960 if (p_end
- p_start
== 3 && startswith (p_start
, "end"))
965 /* Resolve command abbreviations (e.g. 'ws' for 'while-stepping'). */
966 const char *cmd_name
= p
;
967 struct cmd_list_element
*cmd
968 = lookup_cmd_1 (&cmd_name
, cmdlist
, NULL
, 1);
970 /* If commands are parsed, we skip initial spaces. Otherwise,
971 which is the case for Python commands and documentation
972 (see the 'document' command), spaces are preserved. */
975 /* Blanks and comments don't really do anything, but we need to
976 distinguish them from else, end and other commands which can
978 if (p_end
== p
|| p
[0] == '#')
981 /* Is the else clause of an if control structure? */
982 if (p_end
- p
== 4 && startswith (p
, "else"))
985 /* Check for while, if, break, continue, etc and build a new
986 command line structure for them. */
987 if (command_name_equals (cmd
, "while-stepping"))
989 /* Because validate_actionline and encode_action lookup
990 command's line as command, we need the line to
991 include 'while-stepping'.
993 For 'ws' alias, the command will have 'ws', not expanded
994 to 'while-stepping'. This is intentional -- we don't
995 really want frontend to send a command list with 'ws',
996 and next break-info returning command line with
997 'while-stepping'. This should work, but might cause the
998 breakpoint to be marked as changed while it's actually
1000 *command
= build_command_line (while_stepping_control
, p
);
1002 else if (command_name_equals (cmd
, "while"))
1004 *command
= build_command_line (while_control
, line_first_arg (p
));
1006 else if (command_name_equals (cmd
, "if"))
1008 *command
= build_command_line (if_control
, line_first_arg (p
));
1010 else if (command_name_equals (cmd
, "commands"))
1012 *command
= build_command_line (commands_control
, line_first_arg (p
));
1014 else if (command_name_equals_not_inline (p_start
, p_end
, "python"))
1016 /* Note that we ignore the inline "python command" form
1018 *command
= build_command_line (python_control
, "");
1020 else if (command_name_equals_not_inline (p_start
, p_end
, "compile"))
1022 /* Note that we ignore the inline "compile command" form
1024 *command
= build_command_line (compile_control
, "");
1025 (*command
)->control_u
.compile
.scope
= COMPILE_I_INVALID_SCOPE
;
1027 else if (command_name_equals_not_inline (p_start
, p_end
, "guile"))
1029 /* Note that we ignore the inline "guile command" form here. */
1030 *command
= build_command_line (guile_control
, "");
1032 else if (p_end
- p
== 10 && startswith (p
, "loop_break"))
1034 *command
= XNEW (struct command_line
);
1035 (*command
)->next
= NULL
;
1036 (*command
)->line
= NULL
;
1037 (*command
)->control_type
= break_control
;
1038 (*command
)->body_count
= 0;
1039 (*command
)->body_list
= NULL
;
1041 else if (p_end
- p
== 13 && startswith (p
, "loop_continue"))
1043 *command
= XNEW (struct command_line
);
1044 (*command
)->next
= NULL
;
1045 (*command
)->line
= NULL
;
1046 (*command
)->control_type
= continue_control
;
1047 (*command
)->body_count
= 0;
1048 (*command
)->body_list
= NULL
;
1054 if (!parse_commands
|| not_handled
)
1056 /* A normal command. */
1057 *command
= XNEW (struct command_line
);
1058 (*command
)->next
= NULL
;
1059 (*command
)->line
= savestring (p
, p_end
- p
);
1060 (*command
)->control_type
= simple_control
;
1061 (*command
)->body_count
= 0;
1062 (*command
)->body_list
= NULL
;
1070 validator ((*command
)->line
, closure
);
1072 CATCH (ex
, RETURN_MASK_ALL
)
1075 throw_exception (ex
);
1080 /* Nothing special. */
1084 /* Recursively read in the control structures and create a
1085 command_line structure from them. Use read_next_line_func to
1086 obtain lines of the command. */
1088 static enum command_control_type
1089 recurse_read_control_structure (char * (*read_next_line_func
) (void),
1090 struct command_line
*current_cmd
,
1091 void (*validator
)(char *, void *),
1094 int current_body
, i
;
1095 enum misc_command_type val
;
1096 enum command_control_type ret
;
1097 struct command_line
**body_ptr
, *child_tail
, *next
;
1102 /* Sanity checks. */
1103 if (current_cmd
->control_type
== simple_control
)
1104 error (_("Recursed on a simple control type."));
1106 if (current_body
> current_cmd
->body_count
)
1107 error (_("Allocated body is smaller than this command type needs."));
1109 /* Read lines from the input stream and build control structures. */
1115 val
= process_next_line (read_next_line_func (), &next
,
1116 current_cmd
->control_type
!= python_control
1117 && current_cmd
->control_type
!= guile_control
1118 && current_cmd
->control_type
!= compile_control
,
1119 validator
, closure
);
1121 /* Just skip blanks and comments. */
1122 if (val
== nop_command
)
1125 if (val
== end_command
)
1127 if (multi_line_command_p (current_cmd
->control_type
))
1129 /* Success reading an entire canned sequence of commands. */
1130 ret
= simple_control
;
1135 ret
= invalid_control
;
1140 /* Not the end of a control structure. */
1141 if (val
== else_command
)
1143 if (current_cmd
->control_type
== if_control
1144 && current_body
== 1)
1146 realloc_body_list (current_cmd
, 2);
1153 ret
= invalid_control
;
1160 child_tail
->next
= next
;
1164 body_ptr
= current_cmd
->body_list
;
1165 for (i
= 1; i
< current_body
; i
++)
1174 /* If the latest line is another control structure, then recurse
1176 if (multi_line_command_p (next
->control_type
))
1179 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1180 validator
, closure
);
1183 if (ret
!= simple_control
)
1194 restore_interp (void *arg
)
1196 interp_set_temp (interp_name ((struct interp
*)arg
));
1199 /* Read lines from the input stream and accumulate them in a chain of
1200 struct command_line's, which is then returned. For input from a
1201 terminal, the special command "end" is used to mark the end of the
1202 input, and is not included in the returned chain of commands.
1204 If PARSE_COMMANDS is true, strip leading whitespace (trailing whitespace
1205 is always stripped) in the line and attempt to recognize GDB control
1206 commands. Otherwise, only "end" is recognized. */
1208 #define END_MESSAGE "End with a line saying just \"end\"."
1211 read_command_lines (char *prompt_arg
, int from_tty
, int parse_commands
,
1212 void (*validator
)(char *, void *), void *closure
)
1214 if (from_tty
&& input_interactive_p (current_ui
))
1216 if (deprecated_readline_begin_hook
)
1218 /* Note - intentional to merge messages with no newline. */
1219 (*deprecated_readline_begin_hook
) ("%s %s\n", prompt_arg
,
1224 printf_unfiltered ("%s\n%s\n", prompt_arg
, END_MESSAGE
);
1225 gdb_flush (gdb_stdout
);
1230 /* Reading commands assumes the CLI behavior, so temporarily
1231 override the current interpreter with CLI. */
1232 command_line_up head
;
1233 if (current_interp_named_p (INTERP_CONSOLE
))
1234 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1235 validator
, closure
);
1238 struct interp
*old_interp
= interp_set_temp (INTERP_CONSOLE
);
1239 struct cleanup
*old_chain
= make_cleanup (restore_interp
, old_interp
);
1241 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1242 validator
, closure
);
1243 do_cleanups (old_chain
);
1246 if (from_tty
&& input_interactive_p (current_ui
)
1247 && deprecated_readline_end_hook
)
1249 (*deprecated_readline_end_hook
) ();
1254 /* Act the same way as read_command_lines, except that each new line is
1255 obtained using READ_NEXT_LINE_FUNC. */
1258 read_command_lines_1 (char * (*read_next_line_func
) (void), int parse_commands
,
1259 void (*validator
)(char *, void *), void *closure
)
1261 struct command_line
*tail
, *next
;
1262 command_line_up head
;
1263 enum command_control_type ret
;
1264 enum misc_command_type val
;
1272 val
= process_next_line (read_next_line_func (), &next
, parse_commands
,
1273 validator
, closure
);
1275 /* Ignore blank lines or comments. */
1276 if (val
== nop_command
)
1279 if (val
== end_command
)
1281 ret
= simple_control
;
1285 if (val
!= ok_command
)
1287 ret
= invalid_control
;
1291 if (multi_line_command_p (next
->control_type
))
1294 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1295 validator
, closure
);
1298 if (ret
== invalid_control
)
1315 if (ret
== invalid_control
)
1321 /* Free a chain of struct command_line's. */
1324 free_command_lines (struct command_line
**lptr
)
1326 struct command_line
*l
= *lptr
;
1327 struct command_line
*next
;
1328 struct command_line
**blist
;
1333 if (l
->body_count
> 0)
1335 blist
= l
->body_list
;
1336 for (i
= 0; i
< l
->body_count
; i
++, blist
++)
1337 free_command_lines (blist
);
1348 copy_command_lines (struct command_line
*cmds
)
1350 struct command_line
*result
= NULL
;
1354 result
= XNEW (struct command_line
);
1356 result
->next
= copy_command_lines (cmds
->next
).release ();
1357 result
->line
= xstrdup (cmds
->line
);
1358 result
->control_type
= cmds
->control_type
;
1359 result
->body_count
= cmds
->body_count
;
1360 if (cmds
->body_count
> 0)
1364 result
->body_list
= XNEWVEC (struct command_line
*, cmds
->body_count
);
1366 for (i
= 0; i
< cmds
->body_count
; i
++)
1367 result
->body_list
[i
]
1368 = copy_command_lines (cmds
->body_list
[i
]).release ();
1371 result
->body_list
= NULL
;
1374 return command_line_up (result
);
1377 /* Validate that *COMNAME is a valid name for a command. Return the
1378 containing command list, in case it starts with a prefix command.
1379 The prefix must already exist. *COMNAME is advanced to point after
1380 any prefix, and a NUL character overwrites the space after the
1383 static struct cmd_list_element
**
1384 validate_comname (char **comname
)
1386 struct cmd_list_element
**list
= &cmdlist
;
1387 char *p
, *last_word
;
1390 error_no_arg (_("name of command to define"));
1392 /* Find the last word of the argument. */
1393 p
= *comname
+ strlen (*comname
);
1394 while (p
> *comname
&& isspace (p
[-1]))
1396 while (p
> *comname
&& !isspace (p
[-1]))
1400 /* Find the corresponding command list. */
1401 if (last_word
!= *comname
)
1403 struct cmd_list_element
*c
;
1405 const char *tem
= *comname
;
1407 /* Separate the prefix and the command. */
1408 saved_char
= last_word
[-1];
1409 last_word
[-1] = '\0';
1411 c
= lookup_cmd (&tem
, cmdlist
, "", 0, 1);
1412 if (c
->prefixlist
== NULL
)
1413 error (_("\"%s\" is not a prefix command."), *comname
);
1415 list
= c
->prefixlist
;
1416 last_word
[-1] = saved_char
;
1417 *comname
= last_word
;
1423 if (!isalnum (*p
) && *p
!= '-' && *p
!= '_')
1424 error (_("Junk in argument list: \"%s\""), p
);
1431 /* This is just a placeholder in the command data structures. */
1433 user_defined_command (char *ignore
, int from_tty
)
1438 define_command (char *comname
, int from_tty
)
1440 #define MAX_TMPBUF 128
1447 struct cmd_list_element
*c
, *newc
, *hookc
= 0, **list
;
1448 char *tem
, *comfull
;
1450 char tmpbuf
[MAX_TMPBUF
];
1451 int hook_type
= CMD_NO_HOOK
;
1452 int hook_name_size
= 0;
1454 #define HOOK_STRING "hook-"
1456 #define HOOK_POST_STRING "hookpost-"
1457 #define HOOK_POST_LEN 9
1460 list
= validate_comname (&comname
);
1462 /* Look it up, and verify that we got an exact match. */
1464 c
= lookup_cmd (&tem_c
, *list
, "", -1, 1);
1465 if (c
&& strcmp (comname
, c
->name
) != 0)
1472 if (c
->theclass
== class_user
|| c
->theclass
== class_alias
)
1473 q
= query (_("Redefine command \"%s\"? "), c
->name
);
1475 q
= query (_("Really redefine built-in command \"%s\"? "), c
->name
);
1477 error (_("Command \"%s\" not redefined."), c
->name
);
1480 /* If this new command is a hook, then mark the command which it
1481 is hooking. Note that we allow hooking `help' commands, so that
1482 we can hook the `stop' pseudo-command. */
1484 if (!strncmp (comname
, HOOK_STRING
, HOOK_LEN
))
1486 hook_type
= CMD_PRE_HOOK
;
1487 hook_name_size
= HOOK_LEN
;
1489 else if (!strncmp (comname
, HOOK_POST_STRING
, HOOK_POST_LEN
))
1491 hook_type
= CMD_POST_HOOK
;
1492 hook_name_size
= HOOK_POST_LEN
;
1495 if (hook_type
!= CMD_NO_HOOK
)
1497 /* Look up cmd it hooks, and verify that we got an exact match. */
1498 tem_c
= comname
+ hook_name_size
;
1499 hookc
= lookup_cmd (&tem_c
, *list
, "", -1, 0);
1500 if (hookc
&& strcmp (comname
+ hook_name_size
, hookc
->name
) != 0)
1504 warning (_("Your new `%s' command does not "
1505 "hook any existing command."),
1507 if (!query (_("Proceed? ")))
1508 error (_("Not confirmed."));
1512 comname
= xstrdup (comname
);
1514 /* If the rest of the commands will be case insensitive, this one
1515 should behave in the same manner. */
1516 for (tem
= comname
; *tem
; tem
++)
1518 *tem
= tolower (*tem
);
1520 xsnprintf (tmpbuf
, sizeof (tmpbuf
),
1521 "Type commands for definition of \"%s\".", comfull
);
1522 command_line_up cmds
= read_command_lines (tmpbuf
, from_tty
, 1, 0, 0);
1524 if (c
&& c
->theclass
== class_user
)
1525 free_command_lines (&c
->user_commands
);
1527 newc
= add_cmd (comname
, class_user
, user_defined_command
,
1528 (c
&& c
->theclass
== class_user
)
1529 ? c
->doc
: xstrdup ("User-defined."), list
);
1530 newc
->user_commands
= cmds
.release ();
1532 /* If this new command is a hook, then mark both commands as being
1539 hookc
->hook_pre
= newc
; /* Target gets hooked. */
1540 newc
->hookee_pre
= hookc
; /* We are marked as hooking target cmd. */
1543 hookc
->hook_post
= newc
; /* Target gets hooked. */
1544 newc
->hookee_post
= hookc
; /* We are marked as hooking
1548 /* Should never come here as hookc would be 0. */
1549 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1555 document_command (char *comname
, int from_tty
)
1557 struct cmd_list_element
*c
, **list
;
1563 list
= validate_comname (&comname
);
1566 c
= lookup_cmd (&tem
, *list
, "", 0, 1);
1568 if (c
->theclass
!= class_user
)
1569 error (_("Command \"%s\" is built-in."), comfull
);
1571 xsnprintf (tmpbuf
, sizeof (tmpbuf
), "Type documentation for \"%s\".",
1573 command_line_up doclines
= read_command_lines (tmpbuf
, from_tty
, 0, 0, 0);
1576 xfree ((char *) c
->doc
);
1579 struct command_line
*cl1
;
1583 for (cl1
= doclines
.get (); cl1
; cl1
= cl1
->next
)
1584 len
+= strlen (cl1
->line
) + 1;
1586 doc
= (char *) xmalloc (len
+ 1);
1589 for (cl1
= doclines
.get (); cl1
; cl1
= cl1
->next
)
1591 strcat (doc
, cl1
->line
);
1600 struct source_cleanup_lines_args
1603 const char *old_file
;
1607 source_cleanup_lines (void *args
)
1609 struct source_cleanup_lines_args
*p
=
1610 (struct source_cleanup_lines_args
*) args
;
1612 source_line_number
= p
->old_line
;
1613 source_file_name
= p
->old_file
;
1616 /* Used to implement source_command. */
1619 script_from_file (FILE *stream
, const char *file
)
1621 struct cleanup
*old_cleanups
;
1622 struct source_cleanup_lines_args old_lines
;
1625 internal_error (__FILE__
, __LINE__
, _("called with NULL file pointer!"));
1627 old_lines
.old_line
= source_line_number
;
1628 old_lines
.old_file
= source_file_name
;
1629 old_cleanups
= make_cleanup (source_cleanup_lines
, &old_lines
);
1630 source_line_number
= 0;
1631 source_file_name
= file
;
1634 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
1638 read_command_file (stream
);
1640 CATCH (e
, RETURN_MASK_ERROR
)
1642 /* Re-throw the error, but with the file name information
1644 throw_error (e
.error
,
1645 _("%s:%d: Error in sourced command file:\n%s"),
1646 source_file_name
, source_line_number
, e
.message
);
1651 do_cleanups (old_cleanups
);
1654 /* Print the definition of user command C to STREAM. Or, if C is a
1655 prefix command, show the definitions of all user commands under C
1656 (recursively). PREFIX and NAME combined are the name of the
1659 show_user_1 (struct cmd_list_element
*c
, const char *prefix
, const char *name
,
1660 struct ui_file
*stream
)
1662 struct command_line
*cmdlines
;
1664 if (c
->prefixlist
!= NULL
)
1666 const char *prefixname
= c
->prefixname
;
1668 for (c
= *c
->prefixlist
; c
!= NULL
; c
= c
->next
)
1669 if (c
->theclass
== class_user
|| c
->prefixlist
!= NULL
)
1670 show_user_1 (c
, prefixname
, c
->name
, gdb_stdout
);
1674 cmdlines
= c
->user_commands
;
1675 fprintf_filtered (stream
, "User command \"%s%s\":\n", prefix
, name
);
1679 print_command_lines (current_uiout
, cmdlines
, 1);
1680 fputs_filtered ("\n", stream
);
1685 initialize_file_ftype _initialize_cli_script
;
1688 _initialize_cli_script (void)
1690 add_com ("document", class_support
, document_command
, _("\
1691 Document a user-defined command.\n\
1692 Give command name as argument. Give documentation on following lines.\n\
1693 End with a line of just \"end\"."));
1694 add_com ("define", class_support
, define_command
, _("\
1695 Define a new command name. Command name is argument.\n\
1696 Definition appears on following lines, one command per line.\n\
1697 End with a line of just \"end\".\n\
1698 Use the \"document\" command to give documentation for the new command.\n\
1699 Commands defined in this way may have up to ten arguments."));
1701 add_com ("while", class_support
, while_command
, _("\
1702 Execute nested commands WHILE the conditional expression is non zero.\n\
1703 The conditional expression must follow the word `while' and must in turn be\n\
1704 followed by a new line. The nested commands must be entered one per line,\n\
1705 and should be terminated by the word `end'."));
1707 add_com ("if", class_support
, if_command
, _("\
1708 Execute nested commands once IF the conditional expression is non zero.\n\
1709 The conditional expression must follow the word `if' and must in turn be\n\
1710 followed by a new line. The nested commands must be entered one per line,\n\
1711 and should be terminated by the word 'else' or `end'. If an else clause\n\
1712 is used, the same rules apply to its nested commands as to the first ones."));