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. */
344 clear_hook_in_cleanup (void *data
)
346 struct cmd_list_element
*c
= (struct cmd_list_element
*) data
;
348 c
->hook_in
= 0; /* Allow hook to work again once it is complete. */
352 execute_cmd_pre_hook (struct cmd_list_element
*c
)
354 if ((c
->hook_pre
) && (!c
->hook_in
))
356 struct cleanup
*cleanups
= make_cleanup (clear_hook_in_cleanup
, c
);
357 c
->hook_in
= 1; /* Prevent recursive hooking. */
358 execute_user_command (c
->hook_pre
, (char *) 0);
359 do_cleanups (cleanups
);
364 execute_cmd_post_hook (struct cmd_list_element
*c
)
366 if ((c
->hook_post
) && (!c
->hook_in
))
368 struct cleanup
*cleanups
= make_cleanup (clear_hook_in_cleanup
, c
);
370 c
->hook_in
= 1; /* Prevent recursive hooking. */
371 execute_user_command (c
->hook_post
, (char *) 0);
372 do_cleanups (cleanups
);
377 execute_user_command (struct cmd_list_element
*c
, char *args
)
379 struct ui
*ui
= current_ui
;
380 struct command_line
*cmdlines
;
381 enum command_control_type ret
;
382 extern unsigned int max_user_call_depth
;
384 cmdlines
= c
->user_commands
;
389 scoped_user_args_level
push_user_args (args
);
391 if (user_args_stack
.size () > max_user_call_depth
)
392 error (_("Max user call depth exceeded -- command aborted."));
394 /* Set the instream to 0, indicating execution of a
395 user-defined function. */
396 scoped_restore restore_instream
397 = make_scoped_restore (&ui
->instream
, nullptr);
399 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
401 scoped_restore save_nesting
402 = make_scoped_restore (&command_nest_depth
, command_nest_depth
+ 1);
405 ret
= execute_control_command (cmdlines
);
406 if (ret
!= simple_control
&& ret
!= break_control
)
408 warning (_("Error executing canned sequence of commands."));
411 cmdlines
= cmdlines
->next
;
415 /* This function is called every time GDB prints a prompt. It ensures
416 that errors and the like do not confuse the command tracing. */
419 reset_command_nest_depth (void)
421 command_nest_depth
= 1;
424 suppress_next_print_command_trace
= 0;
427 /* Print the command, prefixed with '+' to represent the call depth.
428 This is slightly complicated because this function may be called
429 from execute_command and execute_control_command. Unfortunately
430 execute_command also prints the top level control commands.
431 In these cases execute_command will call execute_control_command
432 via while_command or if_command. Inner levels of 'if' and 'while'
433 are dealt with directly. Therefore we can use these functions
434 to determine whether the command has been printed already or not. */
436 print_command_trace (const char *cmd
)
440 if (suppress_next_print_command_trace
)
442 suppress_next_print_command_trace
= 0;
446 if (!source_verbose
&& !trace_commands
)
449 for (i
=0; i
< command_nest_depth
; i
++)
450 printf_filtered ("+");
452 printf_filtered ("%s\n", cmd
);
455 enum command_control_type
456 execute_control_command (struct command_line
*cmd
)
458 struct command_line
*current
;
460 struct value
*val_mark
;
462 enum command_control_type ret
;
464 /* Start by assuming failure, if a problem is detected, the code
465 below will simply "break" out of the switch. */
466 ret
= invalid_control
;
468 switch (cmd
->control_type
)
472 /* A simple command, execute it and return. */
473 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
474 execute_command (&new_line
[0], 0);
475 ret
= cmd
->control_type
;
479 case continue_control
:
480 print_command_trace ("loop_continue");
482 /* Return for "continue", and "break" so we can either
483 continue the loop at the top, or break out. */
484 ret
= cmd
->control_type
;
488 print_command_trace ("loop_break");
490 /* Return for "continue", and "break" so we can either
491 continue the loop at the top, or break out. */
492 ret
= cmd
->control_type
;
497 int len
= strlen (cmd
->line
) + 7;
498 char *buffer
= (char *) alloca (len
);
500 xsnprintf (buffer
, len
, "while %s", cmd
->line
);
501 print_command_trace (buffer
);
503 /* Parse the loop control expression for the while statement. */
504 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
505 expression_up expr
= parse_expression (new_line
.c_str ());
507 ret
= simple_control
;
510 /* Keep iterating so long as the expression is true. */
517 /* Evaluate the expression. */
518 val_mark
= value_mark ();
519 val
= evaluate_expression (expr
.get ());
520 cond_result
= value_true (val
);
521 value_free_to_mark (val_mark
);
523 /* If the value is false, then break out of the loop. */
527 /* Execute the body of the while statement. */
528 current
= *cmd
->body_list
;
531 scoped_restore save_nesting
532 = make_scoped_restore (&command_nest_depth
, command_nest_depth
+ 1);
533 ret
= execute_control_command (current
);
535 /* If we got an error, or a "break" command, then stop
537 if (ret
== invalid_control
|| ret
== break_control
)
543 /* If we got a "continue" command, then restart the loop
545 if (ret
== continue_control
)
548 /* Get the next statement. */
549 current
= current
->next
;
553 /* Reset RET so that we don't recurse the break all the way down. */
554 if (ret
== break_control
)
555 ret
= simple_control
;
562 int len
= strlen (cmd
->line
) + 4;
563 char *buffer
= (char *) alloca (len
);
565 xsnprintf (buffer
, len
, "if %s", cmd
->line
);
566 print_command_trace (buffer
);
568 /* Parse the conditional for the if statement. */
569 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
570 expression_up expr
= parse_expression (new_line
.c_str ());
573 ret
= simple_control
;
575 /* Evaluate the conditional. */
576 val_mark
= value_mark ();
577 val
= evaluate_expression (expr
.get ());
579 /* Choose which arm to take commands from based on the value
580 of the conditional expression. */
581 if (value_true (val
))
582 current
= *cmd
->body_list
;
583 else if (cmd
->body_count
== 2)
584 current
= *(cmd
->body_list
+ 1);
585 value_free_to_mark (val_mark
);
587 /* Execute commands in the given arm. */
590 scoped_restore save_nesting
591 = make_scoped_restore (&command_nest_depth
, command_nest_depth
+ 1);
592 ret
= execute_control_command (current
);
594 /* If we got an error, get out. */
595 if (ret
!= simple_control
)
598 /* Get the next statement in the body. */
599 current
= current
->next
;
605 case commands_control
:
607 /* Breakpoint commands list, record the commands in the
608 breakpoint's command list and return. */
609 std::string new_line
= insert_user_defined_cmd_args (cmd
->line
);
610 ret
= commands_from_control_command (new_line
.c_str (), cmd
);
614 case compile_control
:
615 eval_compile_command (cmd
, NULL
, cmd
->control_u
.compile
.scope
,
616 cmd
->control_u
.compile
.scope_data
);
617 ret
= simple_control
;
623 eval_ext_lang_from_control_command (cmd
);
624 ret
= simple_control
;
629 warning (_("Invalid control type in canned commands structure."));
636 /* Like execute_control_command, but first set
637 suppress_next_print_command_trace. */
639 enum command_control_type
640 execute_control_command_untraced (struct command_line
*cmd
)
642 suppress_next_print_command_trace
= 1;
643 return execute_control_command (cmd
);
647 /* "while" command support. Executes a body of statements while the
648 loop condition is nonzero. */
651 while_command (char *arg
, int from_tty
)
654 command_line_up command
= get_command_line (while_control
, arg
);
659 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
661 execute_control_command_untraced (command
.get ());
664 /* "if" command support. Execute either the true or false arm depending
665 on the value of the if conditional. */
668 if_command (char *arg
, int from_tty
)
671 command_line_up command
= get_command_line (if_control
, arg
);
676 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
678 execute_control_command_untraced (command
.get ());
681 /* Bind the incoming arguments for a user defined command to $arg0,
684 user_args::user_args (const char *command_line
)
688 if (command_line
== NULL
)
691 m_command_line
= command_line
;
692 p
= m_command_line
.c_str ();
696 const char *start_arg
;
701 /* Strip whitespace. */
702 while (*p
== ' ' || *p
== '\t')
705 /* P now points to an argument. */
708 /* Get to the end of this argument. */
711 if (((*p
== ' ' || *p
== '\t')) && !squote
&& !dquote
&& !bsquote
)
740 m_args
.emplace_back (start_arg
, p
- start_arg
);
744 /* Given character string P, return a point to the first argument
745 ($arg), or NULL if P contains no arguments. */
748 locate_arg (const char *p
)
750 while ((p
= strchr (p
, '$')))
752 if (startswith (p
, "$arg")
753 && (isdigit (p
[4]) || p
[4] == 'c'))
760 /* See cli-script.h. */
763 insert_user_defined_cmd_args (const char *line
)
765 /* If we are not in a user-defined command, treat $argc, $arg0, et
766 cetera as normal convenience variables. */
767 if (user_args_stack
.empty ())
770 const std::unique_ptr
<user_args
> &args
= user_args_stack
.back ();
771 return args
->insert_args (line
);
774 /* Insert the user defined arguments stored in user_args into the $arg
775 arguments found in line. */
778 user_args::insert_args (const char *line
) const
780 std::string new_line
;
783 while ((p
= locate_arg (line
)))
785 new_line
.append (line
, p
- line
);
789 new_line
+= std::to_string (m_args
.size ());
798 i
= strtoul (p
+ 4, &tmp
, 10);
799 if ((i
== 0 && tmp
== p
+ 4) || errno
!= 0)
801 else if (i
>= m_args
.size ())
802 error (_("Missing argument %ld in user function."), i
);
805 new_line
.append (m_args
[i
].str
, m_args
[i
].len
);
810 /* Don't forget the tail. */
811 new_line
.append (line
);
817 /* Expand the body_list of COMMAND so that it can hold NEW_LENGTH
818 code bodies. This is typically used when we encounter an "else"
819 clause for an "if" command. */
822 realloc_body_list (struct command_line
*command
, int new_length
)
825 struct command_line
**body_list
;
827 n
= command
->body_count
;
833 body_list
= XCNEWVEC (struct command_line
*, new_length
);
835 memcpy (body_list
, command
->body_list
, sizeof (struct command_line
*) * n
);
837 xfree (command
->body_list
);
838 command
->body_list
= body_list
;
839 command
->body_count
= new_length
;
842 /* Read next line from stdin. Passed to read_command_line_1 and
843 recurse_read_control_structure whenever we need to read commands
847 read_next_line (void)
849 struct ui
*ui
= current_ui
;
850 char *prompt_ptr
, control_prompt
[256];
852 int from_tty
= ui
->instream
== ui
->stdin_stream
;
854 if (control_level
>= 254)
855 error (_("Control nesting too deep!"));
857 /* Set a prompt based on the nesting of the control commands. */
859 || (ui
->instream
== 0 && deprecated_readline_hook
!= NULL
))
861 for (i
= 0; i
< control_level
; i
++)
862 control_prompt
[i
] = ' ';
863 control_prompt
[i
] = '>';
864 control_prompt
[i
+ 1] = '\0';
865 prompt_ptr
= (char *) &control_prompt
[0];
870 return command_line_input (prompt_ptr
, from_tty
, "commands");
873 /* Return true if CMD's name is NAME. */
876 command_name_equals (struct cmd_list_element
*cmd
, const char *name
)
879 && cmd
!= CMD_LIST_AMBIGUOUS
880 && strcmp (cmd
->name
, name
) == 0);
883 /* Given an input line P, skip the command and return a pointer to the
887 line_first_arg (const char *p
)
889 const char *first_arg
= p
+ find_command_name_length (p
);
891 return skip_spaces_const (first_arg
);
894 /* Process one input line. If the command is an "end", return such an
895 indication to the caller. If PARSE_COMMANDS is true, strip leading
896 whitespace (trailing whitespace is always stripped) in the line,
897 attempt to recognize GDB control commands, and also return an
898 indication if the command is an "else" or a nop.
900 Otherwise, only "end" is recognized. */
902 static enum misc_command_type
903 process_next_line (char *p
, struct command_line
**command
, int parse_commands
,
904 void (*validator
)(char *, void *), void *closure
)
910 /* Not sure what to do here. */
914 /* Strip trailing whitespace. */
915 p_end
= p
+ strlen (p
);
916 while (p_end
> p
&& (p_end
[-1] == ' ' || p_end
[-1] == '\t'))
920 /* Strip leading whitespace. */
921 while (p_start
< p_end
&& (*p_start
== ' ' || *p_start
== '\t'))
924 /* 'end' is always recognized, regardless of parse_commands value.
925 We also permit whitespace before end and after. */
926 if (p_end
- p_start
== 3 && startswith (p_start
, "end"))
931 /* Resolve command abbreviations (e.g. 'ws' for 'while-stepping'). */
932 const char *cmd_name
= p
;
933 struct cmd_list_element
*cmd
934 = lookup_cmd_1 (&cmd_name
, cmdlist
, NULL
, 1);
935 cmd_name
= skip_spaces_const (cmd_name
);
936 bool inline_cmd
= *cmd_name
!= '\0';
938 /* If commands are parsed, we skip initial spaces. Otherwise,
939 which is the case for Python commands and documentation
940 (see the 'document' command), spaces are preserved. */
943 /* Blanks and comments don't really do anything, but we need to
944 distinguish them from else, end and other commands which can
946 if (p_end
== p
|| p
[0] == '#')
949 /* Is the else clause of an if control structure? */
950 if (p_end
- p
== 4 && startswith (p
, "else"))
953 /* Check for while, if, break, continue, etc and build a new
954 command line structure for them. */
955 if (command_name_equals (cmd
, "while-stepping"))
957 /* Because validate_actionline and encode_action lookup
958 command's line as command, we need the line to
959 include 'while-stepping'.
961 For 'ws' alias, the command will have 'ws', not expanded
962 to 'while-stepping'. This is intentional -- we don't
963 really want frontend to send a command list with 'ws',
964 and next break-info returning command line with
965 'while-stepping'. This should work, but might cause the
966 breakpoint to be marked as changed while it's actually
968 *command
= build_command_line (while_stepping_control
, p
);
970 else if (command_name_equals (cmd
, "while"))
972 *command
= build_command_line (while_control
, line_first_arg (p
));
974 else if (command_name_equals (cmd
, "if"))
976 *command
= build_command_line (if_control
, line_first_arg (p
));
978 else if (command_name_equals (cmd
, "commands"))
980 *command
= build_command_line (commands_control
, line_first_arg (p
));
982 else if (command_name_equals (cmd
, "python") && !inline_cmd
)
984 /* Note that we ignore the inline "python command" form
986 *command
= build_command_line (python_control
, "");
988 else if (command_name_equals (cmd
, "compile") && !inline_cmd
)
990 /* Note that we ignore the inline "compile command" form
992 *command
= build_command_line (compile_control
, "");
993 (*command
)->control_u
.compile
.scope
= COMPILE_I_INVALID_SCOPE
;
995 else if (command_name_equals (cmd
, "guile") && !inline_cmd
)
997 /* Note that we ignore the inline "guile command" form here. */
998 *command
= build_command_line (guile_control
, "");
1000 else if (p_end
- p
== 10 && startswith (p
, "loop_break"))
1002 *command
= XNEW (struct command_line
);
1003 (*command
)->next
= NULL
;
1004 (*command
)->line
= NULL
;
1005 (*command
)->control_type
= break_control
;
1006 (*command
)->body_count
= 0;
1007 (*command
)->body_list
= NULL
;
1009 else if (p_end
- p
== 13 && startswith (p
, "loop_continue"))
1011 *command
= XNEW (struct command_line
);
1012 (*command
)->next
= NULL
;
1013 (*command
)->line
= NULL
;
1014 (*command
)->control_type
= continue_control
;
1015 (*command
)->body_count
= 0;
1016 (*command
)->body_list
= NULL
;
1022 if (!parse_commands
|| not_handled
)
1024 /* A normal command. */
1025 *command
= XNEW (struct command_line
);
1026 (*command
)->next
= NULL
;
1027 (*command
)->line
= savestring (p
, p_end
- p
);
1028 (*command
)->control_type
= simple_control
;
1029 (*command
)->body_count
= 0;
1030 (*command
)->body_list
= NULL
;
1038 validator ((*command
)->line
, closure
);
1040 CATCH (ex
, RETURN_MASK_ALL
)
1043 throw_exception (ex
);
1048 /* Nothing special. */
1052 /* Recursively read in the control structures and create a
1053 command_line structure from them. Use read_next_line_func to
1054 obtain lines of the command. */
1056 static enum command_control_type
1057 recurse_read_control_structure (char * (*read_next_line_func
) (void),
1058 struct command_line
*current_cmd
,
1059 void (*validator
)(char *, void *),
1062 int current_body
, i
;
1063 enum misc_command_type val
;
1064 enum command_control_type ret
;
1065 struct command_line
**body_ptr
, *child_tail
, *next
;
1070 /* Sanity checks. */
1071 if (current_cmd
->control_type
== simple_control
)
1072 error (_("Recursed on a simple control type."));
1074 if (current_body
> current_cmd
->body_count
)
1075 error (_("Allocated body is smaller than this command type needs."));
1077 /* Read lines from the input stream and build control structures. */
1083 val
= process_next_line (read_next_line_func (), &next
,
1084 current_cmd
->control_type
!= python_control
1085 && current_cmd
->control_type
!= guile_control
1086 && current_cmd
->control_type
!= compile_control
,
1087 validator
, closure
);
1089 /* Just skip blanks and comments. */
1090 if (val
== nop_command
)
1093 if (val
== end_command
)
1095 if (multi_line_command_p (current_cmd
->control_type
))
1097 /* Success reading an entire canned sequence of commands. */
1098 ret
= simple_control
;
1103 ret
= invalid_control
;
1108 /* Not the end of a control structure. */
1109 if (val
== else_command
)
1111 if (current_cmd
->control_type
== if_control
1112 && current_body
== 1)
1114 realloc_body_list (current_cmd
, 2);
1121 ret
= invalid_control
;
1128 child_tail
->next
= next
;
1132 body_ptr
= current_cmd
->body_list
;
1133 for (i
= 1; i
< current_body
; i
++)
1142 /* If the latest line is another control structure, then recurse
1144 if (multi_line_command_p (next
->control_type
))
1147 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1148 validator
, closure
);
1151 if (ret
!= simple_control
)
1162 restore_interp (void *arg
)
1164 interp_set_temp (interp_name ((struct interp
*)arg
));
1167 /* Read lines from the input stream and accumulate them in a chain of
1168 struct command_line's, which is then returned. For input from a
1169 terminal, the special command "end" is used to mark the end of the
1170 input, and is not included in the returned chain of commands.
1172 If PARSE_COMMANDS is true, strip leading whitespace (trailing whitespace
1173 is always stripped) in the line and attempt to recognize GDB control
1174 commands. Otherwise, only "end" is recognized. */
1176 #define END_MESSAGE "End with a line saying just \"end\"."
1179 read_command_lines (char *prompt_arg
, int from_tty
, int parse_commands
,
1180 void (*validator
)(char *, void *), void *closure
)
1182 if (from_tty
&& input_interactive_p (current_ui
))
1184 if (deprecated_readline_begin_hook
)
1186 /* Note - intentional to merge messages with no newline. */
1187 (*deprecated_readline_begin_hook
) ("%s %s\n", prompt_arg
,
1192 printf_unfiltered ("%s\n%s\n", prompt_arg
, END_MESSAGE
);
1193 gdb_flush (gdb_stdout
);
1198 /* Reading commands assumes the CLI behavior, so temporarily
1199 override the current interpreter with CLI. */
1200 command_line_up head
;
1201 if (current_interp_named_p (INTERP_CONSOLE
))
1202 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1203 validator
, closure
);
1206 struct interp
*old_interp
= interp_set_temp (INTERP_CONSOLE
);
1207 struct cleanup
*old_chain
= make_cleanup (restore_interp
, old_interp
);
1209 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1210 validator
, closure
);
1211 do_cleanups (old_chain
);
1214 if (from_tty
&& input_interactive_p (current_ui
)
1215 && deprecated_readline_end_hook
)
1217 (*deprecated_readline_end_hook
) ();
1222 /* Act the same way as read_command_lines, except that each new line is
1223 obtained using READ_NEXT_LINE_FUNC. */
1226 read_command_lines_1 (char * (*read_next_line_func
) (void), int parse_commands
,
1227 void (*validator
)(char *, void *), void *closure
)
1229 struct command_line
*tail
, *next
;
1230 command_line_up head
;
1231 enum command_control_type ret
;
1232 enum misc_command_type val
;
1240 val
= process_next_line (read_next_line_func (), &next
, parse_commands
,
1241 validator
, closure
);
1243 /* Ignore blank lines or comments. */
1244 if (val
== nop_command
)
1247 if (val
== end_command
)
1249 ret
= simple_control
;
1253 if (val
!= ok_command
)
1255 ret
= invalid_control
;
1259 if (multi_line_command_p (next
->control_type
))
1262 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1263 validator
, closure
);
1266 if (ret
== invalid_control
)
1283 if (ret
== invalid_control
)
1289 /* Free a chain of struct command_line's. */
1292 free_command_lines (struct command_line
**lptr
)
1294 struct command_line
*l
= *lptr
;
1295 struct command_line
*next
;
1296 struct command_line
**blist
;
1301 if (l
->body_count
> 0)
1303 blist
= l
->body_list
;
1304 for (i
= 0; i
< l
->body_count
; i
++, blist
++)
1305 free_command_lines (blist
);
1316 copy_command_lines (struct command_line
*cmds
)
1318 struct command_line
*result
= NULL
;
1322 result
= XNEW (struct command_line
);
1324 result
->next
= copy_command_lines (cmds
->next
).release ();
1325 result
->line
= xstrdup (cmds
->line
);
1326 result
->control_type
= cmds
->control_type
;
1327 result
->body_count
= cmds
->body_count
;
1328 if (cmds
->body_count
> 0)
1332 result
->body_list
= XNEWVEC (struct command_line
*, cmds
->body_count
);
1334 for (i
= 0; i
< cmds
->body_count
; i
++)
1335 result
->body_list
[i
]
1336 = copy_command_lines (cmds
->body_list
[i
]).release ();
1339 result
->body_list
= NULL
;
1342 return command_line_up (result
);
1345 /* Validate that *COMNAME is a valid name for a command. Return the
1346 containing command list, in case it starts with a prefix command.
1347 The prefix must already exist. *COMNAME is advanced to point after
1348 any prefix, and a NUL character overwrites the space after the
1351 static struct cmd_list_element
**
1352 validate_comname (char **comname
)
1354 struct cmd_list_element
**list
= &cmdlist
;
1355 char *p
, *last_word
;
1358 error_no_arg (_("name of command to define"));
1360 /* Find the last word of the argument. */
1361 p
= *comname
+ strlen (*comname
);
1362 while (p
> *comname
&& isspace (p
[-1]))
1364 while (p
> *comname
&& !isspace (p
[-1]))
1368 /* Find the corresponding command list. */
1369 if (last_word
!= *comname
)
1371 struct cmd_list_element
*c
;
1373 const char *tem
= *comname
;
1375 /* Separate the prefix and the command. */
1376 saved_char
= last_word
[-1];
1377 last_word
[-1] = '\0';
1379 c
= lookup_cmd (&tem
, cmdlist
, "", 0, 1);
1380 if (c
->prefixlist
== NULL
)
1381 error (_("\"%s\" is not a prefix command."), *comname
);
1383 list
= c
->prefixlist
;
1384 last_word
[-1] = saved_char
;
1385 *comname
= last_word
;
1391 if (!isalnum (*p
) && *p
!= '-' && *p
!= '_')
1392 error (_("Junk in argument list: \"%s\""), p
);
1399 /* This is just a placeholder in the command data structures. */
1401 user_defined_command (char *ignore
, int from_tty
)
1406 define_command (char *comname
, int from_tty
)
1408 #define MAX_TMPBUF 128
1415 struct cmd_list_element
*c
, *newc
, *hookc
= 0, **list
;
1416 char *tem
, *comfull
;
1418 char tmpbuf
[MAX_TMPBUF
];
1419 int hook_type
= CMD_NO_HOOK
;
1420 int hook_name_size
= 0;
1422 #define HOOK_STRING "hook-"
1424 #define HOOK_POST_STRING "hookpost-"
1425 #define HOOK_POST_LEN 9
1428 list
= validate_comname (&comname
);
1430 /* Look it up, and verify that we got an exact match. */
1432 c
= lookup_cmd (&tem_c
, *list
, "", -1, 1);
1433 if (c
&& strcmp (comname
, c
->name
) != 0)
1440 if (c
->theclass
== class_user
|| c
->theclass
== class_alias
)
1441 q
= query (_("Redefine command \"%s\"? "), c
->name
);
1443 q
= query (_("Really redefine built-in command \"%s\"? "), c
->name
);
1445 error (_("Command \"%s\" not redefined."), c
->name
);
1448 /* If this new command is a hook, then mark the command which it
1449 is hooking. Note that we allow hooking `help' commands, so that
1450 we can hook the `stop' pseudo-command. */
1452 if (!strncmp (comname
, HOOK_STRING
, HOOK_LEN
))
1454 hook_type
= CMD_PRE_HOOK
;
1455 hook_name_size
= HOOK_LEN
;
1457 else if (!strncmp (comname
, HOOK_POST_STRING
, HOOK_POST_LEN
))
1459 hook_type
= CMD_POST_HOOK
;
1460 hook_name_size
= HOOK_POST_LEN
;
1463 if (hook_type
!= CMD_NO_HOOK
)
1465 /* Look up cmd it hooks, and verify that we got an exact match. */
1466 tem_c
= comname
+ hook_name_size
;
1467 hookc
= lookup_cmd (&tem_c
, *list
, "", -1, 0);
1468 if (hookc
&& strcmp (comname
+ hook_name_size
, hookc
->name
) != 0)
1472 warning (_("Your new `%s' command does not "
1473 "hook any existing command."),
1475 if (!query (_("Proceed? ")))
1476 error (_("Not confirmed."));
1480 comname
= xstrdup (comname
);
1482 xsnprintf (tmpbuf
, sizeof (tmpbuf
),
1483 "Type commands for definition of \"%s\".", comfull
);
1484 command_line_up cmds
= read_command_lines (tmpbuf
, from_tty
, 1, 0, 0);
1486 if (c
&& c
->theclass
== class_user
)
1487 free_command_lines (&c
->user_commands
);
1489 newc
= add_cmd (comname
, class_user
, user_defined_command
,
1490 (c
&& c
->theclass
== class_user
)
1491 ? c
->doc
: xstrdup ("User-defined."), list
);
1492 newc
->user_commands
= cmds
.release ();
1494 /* If this new command is a hook, then mark both commands as being
1501 hookc
->hook_pre
= newc
; /* Target gets hooked. */
1502 newc
->hookee_pre
= hookc
; /* We are marked as hooking target cmd. */
1505 hookc
->hook_post
= newc
; /* Target gets hooked. */
1506 newc
->hookee_post
= hookc
; /* We are marked as hooking
1510 /* Should never come here as hookc would be 0. */
1511 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1517 document_command (char *comname
, int from_tty
)
1519 struct cmd_list_element
*c
, **list
;
1525 list
= validate_comname (&comname
);
1528 c
= lookup_cmd (&tem
, *list
, "", 0, 1);
1530 if (c
->theclass
!= class_user
)
1531 error (_("Command \"%s\" is built-in."), comfull
);
1533 xsnprintf (tmpbuf
, sizeof (tmpbuf
), "Type documentation for \"%s\".",
1535 command_line_up doclines
= read_command_lines (tmpbuf
, from_tty
, 0, 0, 0);
1538 xfree ((char *) c
->doc
);
1541 struct command_line
*cl1
;
1545 for (cl1
= doclines
.get (); cl1
; cl1
= cl1
->next
)
1546 len
+= strlen (cl1
->line
) + 1;
1548 doc
= (char *) xmalloc (len
+ 1);
1551 for (cl1
= doclines
.get (); cl1
; cl1
= cl1
->next
)
1553 strcat (doc
, cl1
->line
);
1562 /* Used to implement source_command. */
1565 script_from_file (FILE *stream
, const char *file
)
1568 internal_error (__FILE__
, __LINE__
, _("called with NULL file pointer!"));
1570 scoped_restore restore_line_number
1571 = make_scoped_restore (&source_line_number
, 0);
1572 scoped_restore resotre_file
1573 = make_scoped_restore (&source_file_name
, file
);
1575 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
1579 read_command_file (stream
);
1581 CATCH (e
, RETURN_MASK_ERROR
)
1583 /* Re-throw the error, but with the file name information
1585 throw_error (e
.error
,
1586 _("%s:%d: Error in sourced command file:\n%s"),
1587 source_file_name
, source_line_number
, e
.message
);
1592 /* Print the definition of user command C to STREAM. Or, if C is a
1593 prefix command, show the definitions of all user commands under C
1594 (recursively). PREFIX and NAME combined are the name of the
1597 show_user_1 (struct cmd_list_element
*c
, const char *prefix
, const char *name
,
1598 struct ui_file
*stream
)
1600 struct command_line
*cmdlines
;
1602 if (c
->prefixlist
!= NULL
)
1604 const char *prefixname
= c
->prefixname
;
1606 for (c
= *c
->prefixlist
; c
!= NULL
; c
= c
->next
)
1607 if (c
->theclass
== class_user
|| c
->prefixlist
!= NULL
)
1608 show_user_1 (c
, prefixname
, c
->name
, gdb_stdout
);
1612 cmdlines
= c
->user_commands
;
1613 fprintf_filtered (stream
, "User command \"%s%s\":\n", prefix
, name
);
1617 print_command_lines (current_uiout
, cmdlines
, 1);
1618 fputs_filtered ("\n", stream
);
1622 _initialize_cli_script (void)
1624 add_com ("document", class_support
, document_command
, _("\
1625 Document a user-defined command.\n\
1626 Give command name as argument. Give documentation on following lines.\n\
1627 End with a line of just \"end\"."));
1628 add_com ("define", class_support
, define_command
, _("\
1629 Define a new command name. Command name is argument.\n\
1630 Definition appears on following lines, one command per line.\n\
1631 End with a line of just \"end\".\n\
1632 Use the \"document\" command to give documentation for the new command.\n\
1633 Commands defined in this way may have up to ten arguments."));
1635 add_com ("while", class_support
, while_command
, _("\
1636 Execute nested commands WHILE the conditional expression is non zero.\n\
1637 The conditional expression must follow the word `while' and must in turn be\n\
1638 followed by a new line. The nested commands must be entered one per line,\n\
1639 and should be terminated by the word `end'."));
1641 add_com ("if", class_support
, if_command
, _("\
1642 Execute nested commands once IF the conditional expression is non zero.\n\
1643 The conditional expression must follow the word `if' and must in turn be\n\
1644 followed by a new line. The nested commands must be entered one per line,\n\
1645 and should be terminated by the word 'else' or `end'. If an else clause\n\
1646 is used, the same rules apply to its nested commands as to the first ones."));