1 /* GDB CLI command scripting.
3 Copyright (C) 1986-2016 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"
36 /* Prototypes for local functions. */
38 static enum command_control_type
39 recurse_read_control_structure (char * (*read_next_line_func
) (void),
40 struct command_line
*current_cmd
,
41 void (*validator
)(char *, void *),
44 static std::string
insert_args (const char *line
);
46 static struct cleanup
* setup_user_args (char *p
);
48 static char *read_next_line (void);
50 /* Level of control structure when reading. */
51 static int control_level
;
53 /* Level of control structure when executing. */
54 static int command_nest_depth
= 1;
56 /* This is to prevent certain commands being printed twice. */
57 static int suppress_next_print_command_trace
= 0;
59 /* Structure for arguments to user defined functions. */
60 #define MAXUSERARGS 10
63 struct user_args
*next
;
64 /* It is necessary to store a malloced copy of the command line to
65 ensure that the arguments are not overwritten before they are
79 /* Return non-zero if TYPE is a multi-line command (i.e., is terminated
83 multi_line_command_p (enum command_control_type type
)
89 case while_stepping_control
:
90 case commands_control
:
100 /* Allocate, initialize a new command line structure for one of the
101 control commands (if/while). */
103 static struct command_line
*
104 build_command_line (enum command_control_type type
, char *args
)
106 struct command_line
*cmd
;
108 if (args
== NULL
&& (type
== if_control
|| type
== while_control
))
109 error (_("if/while commands require arguments."));
110 gdb_assert (args
!= NULL
);
112 cmd
= XNEW (struct command_line
);
114 cmd
->control_type
= type
;
117 cmd
->body_list
= XCNEWVEC (struct command_line
*, cmd
->body_count
);
118 cmd
->line
= xstrdup (args
);
123 /* Build and return a new command structure for the control commands
124 such as "if" and "while". */
126 struct command_line
*
127 get_command_line (enum command_control_type type
, char *arg
)
129 struct command_line
*cmd
;
130 struct cleanup
*old_chain
= NULL
;
132 /* Allocate and build a new command line structure. */
133 cmd
= build_command_line (type
, arg
);
135 old_chain
= make_cleanup_free_command_lines (&cmd
);
137 /* Read in the body of this command. */
138 if (recurse_read_control_structure (read_next_line
, cmd
, 0, 0)
141 warning (_("Error reading in canned sequence of commands."));
142 do_cleanups (old_chain
);
146 discard_cleanups (old_chain
);
150 /* Recursively print a command (including full control structures). */
153 print_command_lines (struct ui_out
*uiout
, struct command_line
*cmd
,
156 struct command_line
*list
;
162 ui_out_spaces (uiout
, 2 * depth
);
164 /* A simple command, print it and continue. */
165 if (list
->control_type
== simple_control
)
167 ui_out_field_string (uiout
, NULL
, list
->line
);
168 ui_out_text (uiout
, "\n");
173 /* loop_continue to jump to the start of a while loop, print it
175 if (list
->control_type
== continue_control
)
177 ui_out_field_string (uiout
, NULL
, "loop_continue");
178 ui_out_text (uiout
, "\n");
183 /* loop_break to break out of a while loop, print it and
185 if (list
->control_type
== break_control
)
187 ui_out_field_string (uiout
, NULL
, "loop_break");
188 ui_out_text (uiout
, "\n");
193 /* A while command. Recursively print its subcommands and
195 if (list
->control_type
== while_control
196 || list
->control_type
== while_stepping_control
)
198 /* For while-stepping, the line includes the 'while-stepping'
199 token. See comment in process_next_line for explanation.
200 Here, take care not print 'while-stepping' twice. */
201 if (list
->control_type
== while_control
)
202 ui_out_field_fmt (uiout
, NULL
, "while %s", list
->line
);
204 ui_out_field_string (uiout
, NULL
, list
->line
);
205 ui_out_text (uiout
, "\n");
206 print_command_lines (uiout
, *list
->body_list
, depth
+ 1);
208 ui_out_spaces (uiout
, 2 * depth
);
209 ui_out_field_string (uiout
, NULL
, "end");
210 ui_out_text (uiout
, "\n");
215 /* An if command. Recursively print both arms before
217 if (list
->control_type
== if_control
)
219 ui_out_field_fmt (uiout
, NULL
, "if %s", list
->line
);
220 ui_out_text (uiout
, "\n");
222 print_command_lines (uiout
, list
->body_list
[0], depth
+ 1);
224 /* Show the false arm if it exists. */
225 if (list
->body_count
== 2)
228 ui_out_spaces (uiout
, 2 * depth
);
229 ui_out_field_string (uiout
, NULL
, "else");
230 ui_out_text (uiout
, "\n");
231 print_command_lines (uiout
, list
->body_list
[1], depth
+ 1);
235 ui_out_spaces (uiout
, 2 * depth
);
236 ui_out_field_string (uiout
, NULL
, "end");
237 ui_out_text (uiout
, "\n");
242 /* A commands command. Print the breakpoint commands and
244 if (list
->control_type
== commands_control
)
247 ui_out_field_fmt (uiout
, NULL
, "commands %s", list
->line
);
249 ui_out_field_string (uiout
, NULL
, "commands");
250 ui_out_text (uiout
, "\n");
251 print_command_lines (uiout
, *list
->body_list
, depth
+ 1);
253 ui_out_spaces (uiout
, 2 * depth
);
254 ui_out_field_string (uiout
, NULL
, "end");
255 ui_out_text (uiout
, "\n");
260 if (list
->control_type
== python_control
)
262 ui_out_field_string (uiout
, NULL
, "python");
263 ui_out_text (uiout
, "\n");
264 /* Don't indent python code at all. */
265 print_command_lines (uiout
, *list
->body_list
, 0);
267 ui_out_spaces (uiout
, 2 * depth
);
268 ui_out_field_string (uiout
, NULL
, "end");
269 ui_out_text (uiout
, "\n");
274 if (list
->control_type
== compile_control
)
276 ui_out_field_string (uiout
, NULL
, "compile expression");
277 ui_out_text (uiout
, "\n");
278 print_command_lines (uiout
, *list
->body_list
, 0);
280 ui_out_spaces (uiout
, 2 * depth
);
281 ui_out_field_string (uiout
, NULL
, "end");
282 ui_out_text (uiout
, "\n");
287 if (list
->control_type
== guile_control
)
289 ui_out_field_string (uiout
, NULL
, "guile");
290 ui_out_text (uiout
, "\n");
291 print_command_lines (uiout
, *list
->body_list
, depth
+ 1);
293 ui_out_spaces (uiout
, 2 * depth
);
294 ui_out_field_string (uiout
, NULL
, "end");
295 ui_out_text (uiout
, "\n");
300 /* Ignore illegal command type and try next. */
305 /* Handle pre-post hooks. */
308 clear_hook_in_cleanup (void *data
)
310 struct cmd_list_element
*c
= (struct cmd_list_element
*) data
;
312 c
->hook_in
= 0; /* Allow hook to work again once it is complete. */
316 execute_cmd_pre_hook (struct cmd_list_element
*c
)
318 if ((c
->hook_pre
) && (!c
->hook_in
))
320 struct cleanup
*cleanups
= make_cleanup (clear_hook_in_cleanup
, c
);
321 c
->hook_in
= 1; /* Prevent recursive hooking. */
322 execute_user_command (c
->hook_pre
, (char *) 0);
323 do_cleanups (cleanups
);
328 execute_cmd_post_hook (struct cmd_list_element
*c
)
330 if ((c
->hook_post
) && (!c
->hook_in
))
332 struct cleanup
*cleanups
= make_cleanup (clear_hook_in_cleanup
, c
);
334 c
->hook_in
= 1; /* Prevent recursive hooking. */
335 execute_user_command (c
->hook_post
, (char *) 0);
336 do_cleanups (cleanups
);
340 /* Execute the command in CMD. */
342 do_restore_user_call_depth (void * call_depth
)
344 int *depth
= (int *) call_depth
;
353 execute_user_command (struct cmd_list_element
*c
, char *args
)
355 struct ui
*ui
= current_ui
;
356 struct command_line
*cmdlines
;
357 struct cleanup
*old_chain
;
358 enum command_control_type ret
;
359 static int user_call_depth
= 0;
360 extern unsigned int max_user_call_depth
;
362 cmdlines
= c
->user_commands
;
367 old_chain
= setup_user_args (args
);
369 if (++user_call_depth
> max_user_call_depth
)
370 error (_("Max user call depth exceeded -- command aborted."));
372 make_cleanup (do_restore_user_call_depth
, &user_call_depth
);
374 /* Set the instream to 0, indicating execution of a
375 user-defined function. */
376 make_cleanup (do_restore_instream_cleanup
, ui
->instream
);
379 /* Also set the global in_user_command, so that NULL instream is
380 not confused with Insight. */
383 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
385 command_nest_depth
++;
388 ret
= execute_control_command (cmdlines
);
389 if (ret
!= simple_control
&& ret
!= break_control
)
391 warning (_("Error executing canned sequence of commands."));
394 cmdlines
= cmdlines
->next
;
396 command_nest_depth
--;
397 do_cleanups (old_chain
);
400 /* This function is called every time GDB prints a prompt. It ensures
401 that errors and the like do not confuse the command tracing. */
404 reset_command_nest_depth (void)
406 command_nest_depth
= 1;
409 suppress_next_print_command_trace
= 0;
412 /* Print the command, prefixed with '+' to represent the call depth.
413 This is slightly complicated because this function may be called
414 from execute_command and execute_control_command. Unfortunately
415 execute_command also prints the top level control commands.
416 In these cases execute_command will call execute_control_command
417 via while_command or if_command. Inner levels of 'if' and 'while'
418 are dealt with directly. Therefore we can use these functions
419 to determine whether the command has been printed already or not. */
421 print_command_trace (const char *cmd
)
425 if (suppress_next_print_command_trace
)
427 suppress_next_print_command_trace
= 0;
431 if (!source_verbose
&& !trace_commands
)
434 for (i
=0; i
< command_nest_depth
; i
++)
435 printf_filtered ("+");
437 printf_filtered ("%s\n", cmd
);
440 enum command_control_type
441 execute_control_command (struct command_line
*cmd
)
443 struct command_line
*current
;
445 struct value
*val_mark
;
447 enum command_control_type ret
;
449 /* Start by assuming failure, if a problem is detected, the code
450 below will simply "break" out of the switch. */
451 ret
= invalid_control
;
453 switch (cmd
->control_type
)
457 /* A simple command, execute it and return. */
458 std::string new_line
= insert_args (cmd
->line
);
459 execute_command (&new_line
[0], 0);
460 ret
= cmd
->control_type
;
464 case continue_control
:
465 print_command_trace ("loop_continue");
467 /* Return for "continue", and "break" so we can either
468 continue the loop at the top, or break out. */
469 ret
= cmd
->control_type
;
473 print_command_trace ("loop_break");
475 /* Return for "continue", and "break" so we can either
476 continue the loop at the top, or break out. */
477 ret
= cmd
->control_type
;
482 int len
= strlen (cmd
->line
) + 7;
483 char *buffer
= (char *) alloca (len
);
485 xsnprintf (buffer
, len
, "while %s", cmd
->line
);
486 print_command_trace (buffer
);
488 /* Parse the loop control expression for the while statement. */
489 std::string new_line
= insert_args (cmd
->line
);
490 expression_up expr
= parse_expression (new_line
.c_str ());
492 ret
= simple_control
;
495 /* Keep iterating so long as the expression is true. */
502 /* Evaluate the expression. */
503 val_mark
= value_mark ();
504 val
= evaluate_expression (expr
.get ());
505 cond_result
= value_true (val
);
506 value_free_to_mark (val_mark
);
508 /* If the value is false, then break out of the loop. */
512 /* Execute the body of the while statement. */
513 current
= *cmd
->body_list
;
516 command_nest_depth
++;
517 ret
= execute_control_command (current
);
518 command_nest_depth
--;
520 /* If we got an error, or a "break" command, then stop
522 if (ret
== invalid_control
|| ret
== break_control
)
528 /* If we got a "continue" command, then restart the loop
530 if (ret
== continue_control
)
533 /* Get the next statement. */
534 current
= current
->next
;
538 /* Reset RET so that we don't recurse the break all the way down. */
539 if (ret
== break_control
)
540 ret
= simple_control
;
547 int len
= strlen (cmd
->line
) + 4;
548 char *buffer
= (char *) alloca (len
);
550 xsnprintf (buffer
, len
, "if %s", cmd
->line
);
551 print_command_trace (buffer
);
553 /* Parse the conditional for the if statement. */
554 std::string new_line
= insert_args (cmd
->line
);
555 expression_up expr
= parse_expression (new_line
.c_str ());
558 ret
= simple_control
;
560 /* Evaluate the conditional. */
561 val_mark
= value_mark ();
562 val
= evaluate_expression (expr
.get ());
564 /* Choose which arm to take commands from based on the value
565 of the conditional expression. */
566 if (value_true (val
))
567 current
= *cmd
->body_list
;
568 else if (cmd
->body_count
== 2)
569 current
= *(cmd
->body_list
+ 1);
570 value_free_to_mark (val_mark
);
572 /* Execute commands in the given arm. */
575 command_nest_depth
++;
576 ret
= execute_control_command (current
);
577 command_nest_depth
--;
579 /* If we got an error, get out. */
580 if (ret
!= simple_control
)
583 /* Get the next statement in the body. */
584 current
= current
->next
;
590 case commands_control
:
592 /* Breakpoint commands list, record the commands in the
593 breakpoint's command list and return. */
594 std::string new_line
= insert_args (cmd
->line
);
595 ret
= commands_from_control_command (new_line
.c_str (), cmd
);
599 case compile_control
:
600 eval_compile_command (cmd
, NULL
, cmd
->control_u
.compile
.scope
,
601 cmd
->control_u
.compile
.scope_data
);
602 ret
= simple_control
;
608 eval_ext_lang_from_control_command (cmd
);
609 ret
= simple_control
;
614 warning (_("Invalid control type in canned commands structure."));
621 /* Like execute_control_command, but first set
622 suppress_next_print_command_trace. */
624 enum command_control_type
625 execute_control_command_untraced (struct command_line
*cmd
)
627 suppress_next_print_command_trace
= 1;
628 return execute_control_command (cmd
);
632 /* "while" command support. Executes a body of statements while the
633 loop condition is nonzero. */
636 while_command (char *arg
, int from_tty
)
638 struct command_line
*command
= NULL
;
641 command
= get_command_line (while_control
, arg
);
646 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
648 execute_control_command_untraced (command
);
649 free_command_lines (&command
);
652 /* "if" command support. Execute either the true or false arm depending
653 on the value of the if conditional. */
656 if_command (char *arg
, int from_tty
)
658 struct command_line
*command
= NULL
;
659 struct cleanup
*old_chain
;
662 command
= get_command_line (if_control
, arg
);
667 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
669 execute_control_command_untraced (command
);
670 free_command_lines (&command
);
675 arg_cleanup (void *ignore
)
677 struct user_args
*oargs
= user_args
;
680 internal_error (__FILE__
, __LINE__
,
681 _("arg_cleanup called with no user args.\n"));
683 user_args
= user_args
->next
;
684 xfree (oargs
->command
);
688 /* Bind the incomming arguments for a user defined command to
689 $arg0, $arg1 ... $argMAXUSERARGS. */
691 static struct cleanup
*
692 setup_user_args (char *p
)
694 struct user_args
*args
;
695 struct cleanup
*old_chain
;
696 unsigned int arg_count
= 0;
698 args
= XNEW (struct user_args
);
699 memset (args
, 0, sizeof (struct user_args
));
701 args
->next
= user_args
;
704 old_chain
= make_cleanup (arg_cleanup
, 0/*ignored*/);
709 user_args
->command
= p
= xstrdup (p
);
718 if (arg_count
>= MAXUSERARGS
)
719 error (_("user defined function may only have %d arguments."),
722 /* Strip whitespace. */
723 while (*p
== ' ' || *p
== '\t')
726 /* P now points to an argument. */
728 user_args
->a
[arg_count
].arg
= p
;
730 /* Get to the end of this argument. */
733 if (((*p
== ' ' || *p
== '\t')) && !squote
&& !dquote
&& !bsquote
)
762 user_args
->a
[arg_count
].len
= p
- start_arg
;
769 /* Given character string P, return a point to the first argument
770 ($arg), or NULL if P contains no arguments. */
773 locate_arg (const char *p
)
775 while ((p
= strchr (p
, '$')))
777 if (startswith (p
, "$arg")
778 && (isdigit (p
[4]) || p
[4] == 'c'))
785 /* Insert the user defined arguments stored in user_arg into the $arg
786 arguments found in line. */
789 insert_args (const char *line
)
791 /* If we are not in a user-defined function, treat $argc, $arg0, et
792 cetera as normal convenience variables. */
793 if (user_args
== NULL
)
796 std::string new_line
;
799 while ((p
= locate_arg (line
)))
803 new_line
.append (line
, p
- line
);
807 gdb_assert (user_args
->count
>= 0 && user_args
->count
<= 10);
808 if (user_args
->count
== 10)
814 new_line
+= user_args
->count
+ '0';
819 if (i
>= user_args
->count
)
820 error (_("Missing argument %d in user function."), i
);
822 len
= user_args
->a
[i
].len
;
824 new_line
.append (user_args
->a
[i
].arg
, len
);
828 /* Don't forget the tail. */
829 new_line
.append (line
);
835 /* Expand the body_list of COMMAND so that it can hold NEW_LENGTH
836 code bodies. This is typically used when we encounter an "else"
837 clause for an "if" command. */
840 realloc_body_list (struct command_line
*command
, int new_length
)
843 struct command_line
**body_list
;
845 n
= command
->body_count
;
851 body_list
= XCNEWVEC (struct command_line
*, new_length
);
853 memcpy (body_list
, command
->body_list
, sizeof (struct command_line
*) * n
);
855 xfree (command
->body_list
);
856 command
->body_list
= body_list
;
857 command
->body_count
= new_length
;
860 /* Read next line from stdin. Passed to read_command_line_1 and
861 recurse_read_control_structure whenever we need to read commands
865 read_next_line (void)
867 struct ui
*ui
= current_ui
;
868 char *prompt_ptr
, control_prompt
[256];
870 int from_tty
= ui
->instream
== ui
->stdin_stream
;
872 if (control_level
>= 254)
873 error (_("Control nesting too deep!"));
875 /* Set a prompt based on the nesting of the control commands. */
877 || (ui
->instream
== 0 && deprecated_readline_hook
!= NULL
))
879 for (i
= 0; i
< control_level
; i
++)
880 control_prompt
[i
] = ' ';
881 control_prompt
[i
] = '>';
882 control_prompt
[i
+ 1] = '\0';
883 prompt_ptr
= (char *) &control_prompt
[0];
888 return command_line_input (prompt_ptr
, from_tty
, "commands");
891 /* Process one input line. If the command is an "end", return such an
892 indication to the caller. If PARSE_COMMANDS is true, strip leading
893 whitespace (trailing whitespace is always stripped) in the line,
894 attempt to recognize GDB control commands, and also return an
895 indication if the command is an "else" or a nop.
897 Otherwise, only "end" is recognized. */
899 static enum misc_command_type
900 process_next_line (char *p
, struct command_line
**command
, int parse_commands
,
901 void (*validator
)(char *, void *), void *closure
)
907 /* Not sure what to do here. */
911 /* Strip trailing whitespace. */
912 p_end
= p
+ strlen (p
);
913 while (p_end
> p
&& (p_end
[-1] == ' ' || p_end
[-1] == '\t'))
917 /* Strip leading whitespace. */
918 while (p_start
< p_end
&& (*p_start
== ' ' || *p_start
== '\t'))
921 /* 'end' is always recognized, regardless of parse_commands value.
922 We also permit whitespace before end and after. */
923 if (p_end
- p_start
== 3 && startswith (p_start
, "end"))
928 /* If commands are parsed, we skip initial spaces. Otherwise,
929 which is the case for Python commands and documentation
930 (see the 'document' command), spaces are preserved. */
933 /* Blanks and comments don't really do anything, but we need to
934 distinguish them from else, end and other commands which can
936 if (p_end
== p
|| p
[0] == '#')
939 /* Is the else clause of an if control structure? */
940 if (p_end
- p
== 4 && startswith (p
, "else"))
943 /* Check for while, if, break, continue, etc and build a new
944 command line structure for them. */
945 if ((p_end
- p
>= 14 && startswith (p
, "while-stepping"))
946 || (p_end
- p
>= 8 && startswith (p
, "stepping"))
947 || (p_end
- p
>= 2 && startswith (p
, "ws")))
949 /* Because validate_actionline and encode_action lookup
950 command's line as command, we need the line to
951 include 'while-stepping'.
953 For 'ws' alias, the command will have 'ws', not expanded
954 to 'while-stepping'. This is intentional -- we don't
955 really want frontend to send a command list with 'ws',
956 and next break-info returning command line with
957 'while-stepping'. This should work, but might cause the
958 breakpoint to be marked as changed while it's actually
960 *command
= build_command_line (while_stepping_control
, p
);
962 else if (p_end
- p
> 5 && startswith (p
, "while"))
967 while (first_arg
< p_end
&& isspace (*first_arg
))
969 *command
= build_command_line (while_control
, first_arg
);
971 else if (p_end
- p
> 2 && startswith (p
, "if"))
976 while (first_arg
< p_end
&& isspace (*first_arg
))
978 *command
= build_command_line (if_control
, first_arg
);
980 else if (p_end
- p
>= 8 && startswith (p
, "commands"))
985 while (first_arg
< p_end
&& isspace (*first_arg
))
987 *command
= build_command_line (commands_control
, first_arg
);
989 else if (p_end
- p
== 6 && startswith (p
, "python"))
991 /* Note that we ignore the inline "python command" form
993 *command
= build_command_line (python_control
, "");
995 else if (p_end
- p
== 6 && startswith (p
, "compile"))
997 /* Note that we ignore the inline "compile command" form
999 *command
= build_command_line (compile_control
, "");
1000 (*command
)->control_u
.compile
.scope
= COMPILE_I_INVALID_SCOPE
;
1003 else if (p_end
- p
== 5 && startswith (p
, "guile"))
1005 /* Note that we ignore the inline "guile command" form here. */
1006 *command
= build_command_line (guile_control
, "");
1008 else if (p_end
- p
== 10 && startswith (p
, "loop_break"))
1010 *command
= XNEW (struct command_line
);
1011 (*command
)->next
= NULL
;
1012 (*command
)->line
= NULL
;
1013 (*command
)->control_type
= break_control
;
1014 (*command
)->body_count
= 0;
1015 (*command
)->body_list
= NULL
;
1017 else if (p_end
- p
== 13 && startswith (p
, "loop_continue"))
1019 *command
= XNEW (struct command_line
);
1020 (*command
)->next
= NULL
;
1021 (*command
)->line
= NULL
;
1022 (*command
)->control_type
= continue_control
;
1023 (*command
)->body_count
= 0;
1024 (*command
)->body_list
= NULL
;
1030 if (!parse_commands
|| not_handled
)
1032 /* A normal command. */
1033 *command
= XNEW (struct command_line
);
1034 (*command
)->next
= NULL
;
1035 (*command
)->line
= savestring (p
, p_end
- p
);
1036 (*command
)->control_type
= simple_control
;
1037 (*command
)->body_count
= 0;
1038 (*command
)->body_list
= NULL
;
1046 validator ((*command
)->line
, closure
);
1048 CATCH (ex
, RETURN_MASK_ALL
)
1051 throw_exception (ex
);
1056 /* Nothing special. */
1060 /* Recursively read in the control structures and create a
1061 command_line structure from them. Use read_next_line_func to
1062 obtain lines of the command. */
1064 static enum command_control_type
1065 recurse_read_control_structure (char * (*read_next_line_func
) (void),
1066 struct command_line
*current_cmd
,
1067 void (*validator
)(char *, void *),
1070 int current_body
, i
;
1071 enum misc_command_type val
;
1072 enum command_control_type ret
;
1073 struct command_line
**body_ptr
, *child_tail
, *next
;
1078 /* Sanity checks. */
1079 if (current_cmd
->control_type
== simple_control
)
1080 error (_("Recursed on a simple control type."));
1082 if (current_body
> current_cmd
->body_count
)
1083 error (_("Allocated body is smaller than this command type needs."));
1085 /* Read lines from the input stream and build control structures. */
1091 val
= process_next_line (read_next_line_func (), &next
,
1092 current_cmd
->control_type
!= python_control
1093 && current_cmd
->control_type
!= guile_control
1094 && current_cmd
->control_type
!= compile_control
,
1095 validator
, closure
);
1097 /* Just skip blanks and comments. */
1098 if (val
== nop_command
)
1101 if (val
== end_command
)
1103 if (multi_line_command_p (current_cmd
->control_type
))
1105 /* Success reading an entire canned sequence of commands. */
1106 ret
= simple_control
;
1111 ret
= invalid_control
;
1116 /* Not the end of a control structure. */
1117 if (val
== else_command
)
1119 if (current_cmd
->control_type
== if_control
1120 && current_body
== 1)
1122 realloc_body_list (current_cmd
, 2);
1129 ret
= invalid_control
;
1136 child_tail
->next
= next
;
1140 body_ptr
= current_cmd
->body_list
;
1141 for (i
= 1; i
< current_body
; i
++)
1150 /* If the latest line is another control structure, then recurse
1152 if (multi_line_command_p (next
->control_type
))
1155 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1156 validator
, closure
);
1159 if (ret
!= simple_control
)
1170 restore_interp (void *arg
)
1172 interp_set_temp (interp_name ((struct interp
*)arg
));
1175 /* Read lines from the input stream and accumulate them in a chain of
1176 struct command_line's, which is then returned. For input from a
1177 terminal, the special command "end" is used to mark the end of the
1178 input, and is not included in the returned chain of commands.
1180 If PARSE_COMMANDS is true, strip leading whitespace (trailing whitespace
1181 is always stripped) in the line and attempt to recognize GDB control
1182 commands. Otherwise, only "end" is recognized. */
1184 #define END_MESSAGE "End with a line saying just \"end\"."
1186 struct command_line
*
1187 read_command_lines (char *prompt_arg
, int from_tty
, int parse_commands
,
1188 void (*validator
)(char *, void *), void *closure
)
1190 struct command_line
*head
;
1192 if (from_tty
&& input_interactive_p (current_ui
))
1194 if (deprecated_readline_begin_hook
)
1196 /* Note - intentional to merge messages with no newline. */
1197 (*deprecated_readline_begin_hook
) ("%s %s\n", prompt_arg
,
1202 printf_unfiltered ("%s\n%s\n", prompt_arg
, END_MESSAGE
);
1203 gdb_flush (gdb_stdout
);
1208 /* Reading commands assumes the CLI behavior, so temporarily
1209 override the current interpreter with CLI. */
1210 if (current_interp_named_p (INTERP_CONSOLE
))
1211 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1212 validator
, closure
);
1215 struct interp
*old_interp
= interp_set_temp (INTERP_CONSOLE
);
1216 struct cleanup
*old_chain
= make_cleanup (restore_interp
, old_interp
);
1218 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1219 validator
, closure
);
1220 do_cleanups (old_chain
);
1223 if (from_tty
&& input_interactive_p (current_ui
)
1224 && deprecated_readline_end_hook
)
1226 (*deprecated_readline_end_hook
) ();
1231 /* Act the same way as read_command_lines, except that each new line is
1232 obtained using READ_NEXT_LINE_FUNC. */
1234 struct command_line
*
1235 read_command_lines_1 (char * (*read_next_line_func
) (void), int parse_commands
,
1236 void (*validator
)(char *, void *), void *closure
)
1238 struct command_line
*head
, *tail
, *next
;
1239 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1240 enum command_control_type ret
;
1241 enum misc_command_type val
;
1249 val
= process_next_line (read_next_line_func (), &next
, parse_commands
,
1250 validator
, closure
);
1252 /* Ignore blank lines or comments. */
1253 if (val
== nop_command
)
1256 if (val
== end_command
)
1258 ret
= simple_control
;
1262 if (val
!= ok_command
)
1264 ret
= invalid_control
;
1268 if (multi_line_command_p (next
->control_type
))
1271 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1272 validator
, closure
);
1275 if (ret
== invalid_control
)
1286 make_cleanup_free_command_lines (&head
);
1293 if (ret
!= invalid_control
)
1294 discard_cleanups (old_chain
);
1296 do_cleanups (old_chain
);
1301 /* Free a chain of struct command_line's. */
1304 free_command_lines (struct command_line
**lptr
)
1306 struct command_line
*l
= *lptr
;
1307 struct command_line
*next
;
1308 struct command_line
**blist
;
1313 if (l
->body_count
> 0)
1315 blist
= l
->body_list
;
1316 for (i
= 0; i
< l
->body_count
; i
++, blist
++)
1317 free_command_lines (blist
);
1328 do_free_command_lines_cleanup (void *arg
)
1330 free_command_lines ((struct command_line
**) arg
);
1334 make_cleanup_free_command_lines (struct command_line
**arg
)
1336 return make_cleanup (do_free_command_lines_cleanup
, arg
);
1339 struct command_line
*
1340 copy_command_lines (struct command_line
*cmds
)
1342 struct command_line
*result
= NULL
;
1346 result
= XNEW (struct command_line
);
1348 result
->next
= copy_command_lines (cmds
->next
);
1349 result
->line
= xstrdup (cmds
->line
);
1350 result
->control_type
= cmds
->control_type
;
1351 result
->body_count
= cmds
->body_count
;
1352 if (cmds
->body_count
> 0)
1356 result
->body_list
= XNEWVEC (struct command_line
*, cmds
->body_count
);
1358 for (i
= 0; i
< cmds
->body_count
; i
++)
1359 result
->body_list
[i
] = copy_command_lines (cmds
->body_list
[i
]);
1362 result
->body_list
= NULL
;
1368 /* Validate that *COMNAME is a valid name for a command. Return the
1369 containing command list, in case it starts with a prefix command.
1370 The prefix must already exist. *COMNAME is advanced to point after
1371 any prefix, and a NUL character overwrites the space after the
1374 static struct cmd_list_element
**
1375 validate_comname (char **comname
)
1377 struct cmd_list_element
**list
= &cmdlist
;
1378 char *p
, *last_word
;
1381 error_no_arg (_("name of command to define"));
1383 /* Find the last word of the argument. */
1384 p
= *comname
+ strlen (*comname
);
1385 while (p
> *comname
&& isspace (p
[-1]))
1387 while (p
> *comname
&& !isspace (p
[-1]))
1391 /* Find the corresponding command list. */
1392 if (last_word
!= *comname
)
1394 struct cmd_list_element
*c
;
1396 const char *tem
= *comname
;
1398 /* Separate the prefix and the command. */
1399 saved_char
= last_word
[-1];
1400 last_word
[-1] = '\0';
1402 c
= lookup_cmd (&tem
, cmdlist
, "", 0, 1);
1403 if (c
->prefixlist
== NULL
)
1404 error (_("\"%s\" is not a prefix command."), *comname
);
1406 list
= c
->prefixlist
;
1407 last_word
[-1] = saved_char
;
1408 *comname
= last_word
;
1414 if (!isalnum (*p
) && *p
!= '-' && *p
!= '_')
1415 error (_("Junk in argument list: \"%s\""), p
);
1422 /* This is just a placeholder in the command data structures. */
1424 user_defined_command (char *ignore
, int from_tty
)
1429 define_command (char *comname
, int from_tty
)
1431 #define MAX_TMPBUF 128
1438 struct command_line
*cmds
;
1439 struct cmd_list_element
*c
, *newc
, *hookc
= 0, **list
;
1440 char *tem
, *comfull
;
1442 char tmpbuf
[MAX_TMPBUF
];
1443 int hook_type
= CMD_NO_HOOK
;
1444 int hook_name_size
= 0;
1446 #define HOOK_STRING "hook-"
1448 #define HOOK_POST_STRING "hookpost-"
1449 #define HOOK_POST_LEN 9
1452 list
= validate_comname (&comname
);
1454 /* Look it up, and verify that we got an exact match. */
1456 c
= lookup_cmd (&tem_c
, *list
, "", -1, 1);
1457 if (c
&& strcmp (comname
, c
->name
) != 0)
1464 if (c
->theclass
== class_user
|| c
->theclass
== class_alias
)
1465 q
= query (_("Redefine command \"%s\"? "), c
->name
);
1467 q
= query (_("Really redefine built-in command \"%s\"? "), c
->name
);
1469 error (_("Command \"%s\" not redefined."), c
->name
);
1472 /* If this new command is a hook, then mark the command which it
1473 is hooking. Note that we allow hooking `help' commands, so that
1474 we can hook the `stop' pseudo-command. */
1476 if (!strncmp (comname
, HOOK_STRING
, HOOK_LEN
))
1478 hook_type
= CMD_PRE_HOOK
;
1479 hook_name_size
= HOOK_LEN
;
1481 else if (!strncmp (comname
, HOOK_POST_STRING
, HOOK_POST_LEN
))
1483 hook_type
= CMD_POST_HOOK
;
1484 hook_name_size
= HOOK_POST_LEN
;
1487 if (hook_type
!= CMD_NO_HOOK
)
1489 /* Look up cmd it hooks, and verify that we got an exact match. */
1490 tem_c
= comname
+ hook_name_size
;
1491 hookc
= lookup_cmd (&tem_c
, *list
, "", -1, 0);
1492 if (hookc
&& strcmp (comname
+ hook_name_size
, hookc
->name
) != 0)
1496 warning (_("Your new `%s' command does not "
1497 "hook any existing command."),
1499 if (!query (_("Proceed? ")))
1500 error (_("Not confirmed."));
1504 comname
= xstrdup (comname
);
1506 /* If the rest of the commands will be case insensitive, this one
1507 should behave in the same manner. */
1508 for (tem
= comname
; *tem
; tem
++)
1510 *tem
= tolower (*tem
);
1512 xsnprintf (tmpbuf
, sizeof (tmpbuf
),
1513 "Type commands for definition of \"%s\".", comfull
);
1514 cmds
= read_command_lines (tmpbuf
, from_tty
, 1, 0, 0);
1516 if (c
&& c
->theclass
== class_user
)
1517 free_command_lines (&c
->user_commands
);
1519 newc
= add_cmd (comname
, class_user
, user_defined_command
,
1520 (c
&& c
->theclass
== class_user
)
1521 ? c
->doc
: xstrdup ("User-defined."), list
);
1522 newc
->user_commands
= cmds
;
1524 /* If this new command is a hook, then mark both commands as being
1531 hookc
->hook_pre
= newc
; /* Target gets hooked. */
1532 newc
->hookee_pre
= hookc
; /* We are marked as hooking target cmd. */
1535 hookc
->hook_post
= newc
; /* Target gets hooked. */
1536 newc
->hookee_post
= hookc
; /* We are marked as hooking
1540 /* Should never come here as hookc would be 0. */
1541 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1547 document_command (char *comname
, int from_tty
)
1549 struct command_line
*doclines
;
1550 struct cmd_list_element
*c
, **list
;
1556 list
= validate_comname (&comname
);
1559 c
= lookup_cmd (&tem
, *list
, "", 0, 1);
1561 if (c
->theclass
!= class_user
)
1562 error (_("Command \"%s\" is built-in."), comfull
);
1564 xsnprintf (tmpbuf
, sizeof (tmpbuf
), "Type documentation for \"%s\".",
1566 doclines
= read_command_lines (tmpbuf
, from_tty
, 0, 0, 0);
1569 xfree ((char *) c
->doc
);
1572 struct command_line
*cl1
;
1576 for (cl1
= doclines
; cl1
; cl1
= cl1
->next
)
1577 len
+= strlen (cl1
->line
) + 1;
1579 doc
= (char *) xmalloc (len
+ 1);
1582 for (cl1
= doclines
; cl1
; cl1
= cl1
->next
)
1584 strcat (doc
, cl1
->line
);
1592 free_command_lines (&doclines
);
1595 struct source_cleanup_lines_args
1598 const char *old_file
;
1602 source_cleanup_lines (void *args
)
1604 struct source_cleanup_lines_args
*p
=
1605 (struct source_cleanup_lines_args
*) args
;
1607 source_line_number
= p
->old_line
;
1608 source_file_name
= p
->old_file
;
1611 /* Used to implement source_command. */
1614 script_from_file (FILE *stream
, const char *file
)
1616 struct cleanup
*old_cleanups
;
1617 struct source_cleanup_lines_args old_lines
;
1620 internal_error (__FILE__
, __LINE__
, _("called with NULL file pointer!"));
1622 old_lines
.old_line
= source_line_number
;
1623 old_lines
.old_file
= source_file_name
;
1624 old_cleanups
= make_cleanup (source_cleanup_lines
, &old_lines
);
1625 source_line_number
= 0;
1626 source_file_name
= file
;
1629 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
1633 read_command_file (stream
);
1635 CATCH (e
, RETURN_MASK_ERROR
)
1637 /* Re-throw the error, but with the file name information
1639 throw_error (e
.error
,
1640 _("%s:%d: Error in sourced command file:\n%s"),
1641 source_file_name
, source_line_number
, e
.message
);
1646 do_cleanups (old_cleanups
);
1649 /* Print the definition of user command C to STREAM. Or, if C is a
1650 prefix command, show the definitions of all user commands under C
1651 (recursively). PREFIX and NAME combined are the name of the
1654 show_user_1 (struct cmd_list_element
*c
, const char *prefix
, const char *name
,
1655 struct ui_file
*stream
)
1657 struct command_line
*cmdlines
;
1659 if (c
->prefixlist
!= NULL
)
1661 const char *prefixname
= c
->prefixname
;
1663 for (c
= *c
->prefixlist
; c
!= NULL
; c
= c
->next
)
1664 if (c
->theclass
== class_user
|| c
->prefixlist
!= NULL
)
1665 show_user_1 (c
, prefixname
, c
->name
, gdb_stdout
);
1669 cmdlines
= c
->user_commands
;
1670 fprintf_filtered (stream
, "User command \"%s%s\":\n", prefix
, name
);
1674 print_command_lines (current_uiout
, cmdlines
, 1);
1675 fputs_filtered ("\n", stream
);
1680 initialize_file_ftype _initialize_cli_script
;
1683 _initialize_cli_script (void)
1685 add_com ("document", class_support
, document_command
, _("\
1686 Document a user-defined command.\n\
1687 Give command name as argument. Give documentation on following lines.\n\
1688 End with a line of just \"end\"."));
1689 add_com ("define", class_support
, define_command
, _("\
1690 Define a new command name. Command name is argument.\n\
1691 Definition appears on following lines, one command per line.\n\
1692 End with a line of just \"end\".\n\
1693 Use the \"document\" command to give documentation for the new command.\n\
1694 Commands defined in this way may have up to ten arguments."));
1696 add_com ("while", class_support
, while_command
, _("\
1697 Execute nested commands WHILE the conditional expression is non zero.\n\
1698 The conditional expression must follow the word `while' and must in turn be\n\
1699 followed by a new line. The nested commands must be entered one per line,\n\
1700 and should be terminated by the word `end'."));
1702 add_com ("if", class_support
, if_command
, _("\
1703 Execute nested commands once IF the conditional expression is non zero.\n\
1704 The conditional expression must follow the word `if' and must in turn be\n\
1705 followed by a new line. The nested commands must be entered one per line,\n\
1706 and should be terminated by the word 'else' or `end'. If an else clause\n\
1707 is used, the same rules apply to its nested commands as to the first ones."));