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 expression
*expr
;
444 struct command_line
*current
;
445 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, 0);
447 struct value
*val_mark
;
449 enum command_control_type ret
;
451 /* Start by assuming failure, if a problem is detected, the code
452 below will simply "break" out of the switch. */
453 ret
= invalid_control
;
455 switch (cmd
->control_type
)
459 /* A simple command, execute it and return. */
460 std::string new_line
= insert_args (cmd
->line
);
461 execute_command (&new_line
[0], 0);
462 ret
= cmd
->control_type
;
466 case continue_control
:
467 print_command_trace ("loop_continue");
469 /* Return for "continue", and "break" so we can either
470 continue the loop at the top, or break out. */
471 ret
= cmd
->control_type
;
475 print_command_trace ("loop_break");
477 /* Return for "continue", and "break" so we can either
478 continue the loop at the top, or break out. */
479 ret
= cmd
->control_type
;
484 int len
= strlen (cmd
->line
) + 7;
485 char *buffer
= (char *) alloca (len
);
487 xsnprintf (buffer
, len
, "while %s", cmd
->line
);
488 print_command_trace (buffer
);
490 /* Parse the loop control expression for the while statement. */
491 std::string new_line
= insert_args (cmd
->line
);
492 expr
= parse_expression (new_line
.c_str ());
493 make_cleanup (free_current_contents
, &expr
);
495 ret
= simple_control
;
498 /* Keep iterating so long as the expression is true. */
505 /* Evaluate the expression. */
506 val_mark
= value_mark ();
507 val
= evaluate_expression (expr
);
508 cond_result
= value_true (val
);
509 value_free_to_mark (val_mark
);
511 /* If the value is false, then break out of the loop. */
515 /* Execute the body of the while statement. */
516 current
= *cmd
->body_list
;
519 command_nest_depth
++;
520 ret
= execute_control_command (current
);
521 command_nest_depth
--;
523 /* If we got an error, or a "break" command, then stop
525 if (ret
== invalid_control
|| ret
== break_control
)
531 /* If we got a "continue" command, then restart the loop
533 if (ret
== continue_control
)
536 /* Get the next statement. */
537 current
= current
->next
;
541 /* Reset RET so that we don't recurse the break all the way down. */
542 if (ret
== break_control
)
543 ret
= simple_control
;
550 int len
= strlen (cmd
->line
) + 4;
551 char *buffer
= (char *) alloca (len
);
553 xsnprintf (buffer
, len
, "if %s", cmd
->line
);
554 print_command_trace (buffer
);
556 /* Parse the conditional for the if statement. */
557 std::string new_line
= insert_args (cmd
->line
);
558 expr
= parse_expression (new_line
.c_str ());
559 make_cleanup (free_current_contents
, &expr
);
562 ret
= simple_control
;
564 /* Evaluate the conditional. */
565 val_mark
= value_mark ();
566 val
= evaluate_expression (expr
);
568 /* Choose which arm to take commands from based on the value
569 of the conditional expression. */
570 if (value_true (val
))
571 current
= *cmd
->body_list
;
572 else if (cmd
->body_count
== 2)
573 current
= *(cmd
->body_list
+ 1);
574 value_free_to_mark (val_mark
);
576 /* Execute commands in the given arm. */
579 command_nest_depth
++;
580 ret
= execute_control_command (current
);
581 command_nest_depth
--;
583 /* If we got an error, get out. */
584 if (ret
!= simple_control
)
587 /* Get the next statement in the body. */
588 current
= current
->next
;
594 case commands_control
:
596 /* Breakpoint commands list, record the commands in the
597 breakpoint's command list and return. */
598 std::string new_line
= insert_args (cmd
->line
);
599 ret
= commands_from_control_command (new_line
.c_str (), cmd
);
603 case compile_control
:
604 eval_compile_command (cmd
, NULL
, cmd
->control_u
.compile
.scope
,
605 cmd
->control_u
.compile
.scope_data
);
606 ret
= simple_control
;
612 eval_ext_lang_from_control_command (cmd
);
613 ret
= simple_control
;
618 warning (_("Invalid control type in canned commands structure."));
622 do_cleanups (old_chain
);
627 /* Like execute_control_command, but first set
628 suppress_next_print_command_trace. */
630 enum command_control_type
631 execute_control_command_untraced (struct command_line
*cmd
)
633 suppress_next_print_command_trace
= 1;
634 return execute_control_command (cmd
);
638 /* "while" command support. Executes a body of statements while the
639 loop condition is nonzero. */
642 while_command (char *arg
, int from_tty
)
644 struct command_line
*command
= NULL
;
647 command
= get_command_line (while_control
, arg
);
652 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
654 execute_control_command_untraced (command
);
655 free_command_lines (&command
);
658 /* "if" command support. Execute either the true or false arm depending
659 on the value of the if conditional. */
662 if_command (char *arg
, int from_tty
)
664 struct command_line
*command
= NULL
;
665 struct cleanup
*old_chain
;
668 command
= get_command_line (if_control
, arg
);
673 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
675 execute_control_command_untraced (command
);
676 free_command_lines (&command
);
681 arg_cleanup (void *ignore
)
683 struct user_args
*oargs
= user_args
;
686 internal_error (__FILE__
, __LINE__
,
687 _("arg_cleanup called with no user args.\n"));
689 user_args
= user_args
->next
;
690 xfree (oargs
->command
);
694 /* Bind the incomming arguments for a user defined command to
695 $arg0, $arg1 ... $argMAXUSERARGS. */
697 static struct cleanup
*
698 setup_user_args (char *p
)
700 struct user_args
*args
;
701 struct cleanup
*old_chain
;
702 unsigned int arg_count
= 0;
704 args
= XNEW (struct user_args
);
705 memset (args
, 0, sizeof (struct user_args
));
707 args
->next
= user_args
;
710 old_chain
= make_cleanup (arg_cleanup
, 0/*ignored*/);
715 user_args
->command
= p
= xstrdup (p
);
724 if (arg_count
>= MAXUSERARGS
)
725 error (_("user defined function may only have %d arguments."),
728 /* Strip whitespace. */
729 while (*p
== ' ' || *p
== '\t')
732 /* P now points to an argument. */
734 user_args
->a
[arg_count
].arg
= p
;
736 /* Get to the end of this argument. */
739 if (((*p
== ' ' || *p
== '\t')) && !squote
&& !dquote
&& !bsquote
)
768 user_args
->a
[arg_count
].len
= p
- start_arg
;
775 /* Given character string P, return a point to the first argument
776 ($arg), or NULL if P contains no arguments. */
779 locate_arg (const char *p
)
781 while ((p
= strchr (p
, '$')))
783 if (startswith (p
, "$arg")
784 && (isdigit (p
[4]) || p
[4] == 'c'))
791 /* Insert the user defined arguments stored in user_arg into the $arg
792 arguments found in line. */
795 insert_args (const char *line
)
797 /* If we are not in a user-defined function, treat $argc, $arg0, et
798 cetera as normal convenience variables. */
799 if (user_args
== NULL
)
802 std::string new_line
;
805 while ((p
= locate_arg (line
)))
809 new_line
.append (line
, p
- line
);
813 gdb_assert (user_args
->count
>= 0 && user_args
->count
<= 10);
814 if (user_args
->count
== 10)
820 new_line
+= user_args
->count
+ '0';
825 if (i
>= user_args
->count
)
826 error (_("Missing argument %d in user function."), i
);
828 len
= user_args
->a
[i
].len
;
830 new_line
.append (user_args
->a
[i
].arg
, len
);
834 /* Don't forget the tail. */
835 new_line
.append (line
);
841 /* Expand the body_list of COMMAND so that it can hold NEW_LENGTH
842 code bodies. This is typically used when we encounter an "else"
843 clause for an "if" command. */
846 realloc_body_list (struct command_line
*command
, int new_length
)
849 struct command_line
**body_list
;
851 n
= command
->body_count
;
857 body_list
= XCNEWVEC (struct command_line
*, new_length
);
859 memcpy (body_list
, command
->body_list
, sizeof (struct command_line
*) * n
);
861 xfree (command
->body_list
);
862 command
->body_list
= body_list
;
863 command
->body_count
= new_length
;
866 /* Read next line from stdin. Passed to read_command_line_1 and
867 recurse_read_control_structure whenever we need to read commands
871 read_next_line (void)
873 struct ui
*ui
= current_ui
;
874 char *prompt_ptr
, control_prompt
[256];
876 int from_tty
= ui
->instream
== ui
->stdin_stream
;
878 if (control_level
>= 254)
879 error (_("Control nesting too deep!"));
881 /* Set a prompt based on the nesting of the control commands. */
883 || (ui
->instream
== 0 && deprecated_readline_hook
!= NULL
))
885 for (i
= 0; i
< control_level
; i
++)
886 control_prompt
[i
] = ' ';
887 control_prompt
[i
] = '>';
888 control_prompt
[i
+ 1] = '\0';
889 prompt_ptr
= (char *) &control_prompt
[0];
894 return command_line_input (prompt_ptr
, from_tty
, "commands");
897 /* Process one input line. If the command is an "end", return such an
898 indication to the caller. If PARSE_COMMANDS is true, strip leading
899 whitespace (trailing whitespace is always stripped) in the line,
900 attempt to recognize GDB control commands, and also return an
901 indication if the command is an "else" or a nop.
903 Otherwise, only "end" is recognized. */
905 static enum misc_command_type
906 process_next_line (char *p
, struct command_line
**command
, int parse_commands
,
907 void (*validator
)(char *, void *), void *closure
)
913 /* Not sure what to do here. */
917 /* Strip trailing whitespace. */
918 p_end
= p
+ strlen (p
);
919 while (p_end
> p
&& (p_end
[-1] == ' ' || p_end
[-1] == '\t'))
923 /* Strip leading whitespace. */
924 while (p_start
< p_end
&& (*p_start
== ' ' || *p_start
== '\t'))
927 /* 'end' is always recognized, regardless of parse_commands value.
928 We also permit whitespace before end and after. */
929 if (p_end
- p_start
== 3 && startswith (p_start
, "end"))
934 /* If commands are parsed, we skip initial spaces. Otherwise,
935 which is the case for Python commands and documentation
936 (see the 'document' command), spaces are preserved. */
939 /* Blanks and comments don't really do anything, but we need to
940 distinguish them from else, end and other commands which can
942 if (p_end
== p
|| p
[0] == '#')
945 /* Is the else clause of an if control structure? */
946 if (p_end
- p
== 4 && startswith (p
, "else"))
949 /* Check for while, if, break, continue, etc and build a new
950 command line structure for them. */
951 if ((p_end
- p
>= 14 && startswith (p
, "while-stepping"))
952 || (p_end
- p
>= 8 && startswith (p
, "stepping"))
953 || (p_end
- p
>= 2 && startswith (p
, "ws")))
955 /* Because validate_actionline and encode_action lookup
956 command's line as command, we need the line to
957 include 'while-stepping'.
959 For 'ws' alias, the command will have 'ws', not expanded
960 to 'while-stepping'. This is intentional -- we don't
961 really want frontend to send a command list with 'ws',
962 and next break-info returning command line with
963 'while-stepping'. This should work, but might cause the
964 breakpoint to be marked as changed while it's actually
966 *command
= build_command_line (while_stepping_control
, p
);
968 else if (p_end
- p
> 5 && startswith (p
, "while"))
973 while (first_arg
< p_end
&& isspace (*first_arg
))
975 *command
= build_command_line (while_control
, first_arg
);
977 else if (p_end
- p
> 2 && startswith (p
, "if"))
982 while (first_arg
< p_end
&& isspace (*first_arg
))
984 *command
= build_command_line (if_control
, first_arg
);
986 else if (p_end
- p
>= 8 && startswith (p
, "commands"))
991 while (first_arg
< p_end
&& isspace (*first_arg
))
993 *command
= build_command_line (commands_control
, first_arg
);
995 else if (p_end
- p
== 6 && startswith (p
, "python"))
997 /* Note that we ignore the inline "python command" form
999 *command
= build_command_line (python_control
, "");
1001 else if (p_end
- p
== 6 && startswith (p
, "compile"))
1003 /* Note that we ignore the inline "compile command" form
1005 *command
= build_command_line (compile_control
, "");
1006 (*command
)->control_u
.compile
.scope
= COMPILE_I_INVALID_SCOPE
;
1009 else if (p_end
- p
== 5 && startswith (p
, "guile"))
1011 /* Note that we ignore the inline "guile command" form here. */
1012 *command
= build_command_line (guile_control
, "");
1014 else if (p_end
- p
== 10 && startswith (p
, "loop_break"))
1016 *command
= XNEW (struct command_line
);
1017 (*command
)->next
= NULL
;
1018 (*command
)->line
= NULL
;
1019 (*command
)->control_type
= break_control
;
1020 (*command
)->body_count
= 0;
1021 (*command
)->body_list
= NULL
;
1023 else if (p_end
- p
== 13 && startswith (p
, "loop_continue"))
1025 *command
= XNEW (struct command_line
);
1026 (*command
)->next
= NULL
;
1027 (*command
)->line
= NULL
;
1028 (*command
)->control_type
= continue_control
;
1029 (*command
)->body_count
= 0;
1030 (*command
)->body_list
= NULL
;
1036 if (!parse_commands
|| not_handled
)
1038 /* A normal command. */
1039 *command
= XNEW (struct command_line
);
1040 (*command
)->next
= NULL
;
1041 (*command
)->line
= savestring (p
, p_end
- p
);
1042 (*command
)->control_type
= simple_control
;
1043 (*command
)->body_count
= 0;
1044 (*command
)->body_list
= NULL
;
1052 validator ((*command
)->line
, closure
);
1054 CATCH (ex
, RETURN_MASK_ALL
)
1057 throw_exception (ex
);
1062 /* Nothing special. */
1066 /* Recursively read in the control structures and create a
1067 command_line structure from them. Use read_next_line_func to
1068 obtain lines of the command. */
1070 static enum command_control_type
1071 recurse_read_control_structure (char * (*read_next_line_func
) (void),
1072 struct command_line
*current_cmd
,
1073 void (*validator
)(char *, void *),
1076 int current_body
, i
;
1077 enum misc_command_type val
;
1078 enum command_control_type ret
;
1079 struct command_line
**body_ptr
, *child_tail
, *next
;
1084 /* Sanity checks. */
1085 if (current_cmd
->control_type
== simple_control
)
1086 error (_("Recursed on a simple control type."));
1088 if (current_body
> current_cmd
->body_count
)
1089 error (_("Allocated body is smaller than this command type needs."));
1091 /* Read lines from the input stream and build control structures. */
1097 val
= process_next_line (read_next_line_func (), &next
,
1098 current_cmd
->control_type
!= python_control
1099 && current_cmd
->control_type
!= guile_control
1100 && current_cmd
->control_type
!= compile_control
,
1101 validator
, closure
);
1103 /* Just skip blanks and comments. */
1104 if (val
== nop_command
)
1107 if (val
== end_command
)
1109 if (multi_line_command_p (current_cmd
->control_type
))
1111 /* Success reading an entire canned sequence of commands. */
1112 ret
= simple_control
;
1117 ret
= invalid_control
;
1122 /* Not the end of a control structure. */
1123 if (val
== else_command
)
1125 if (current_cmd
->control_type
== if_control
1126 && current_body
== 1)
1128 realloc_body_list (current_cmd
, 2);
1135 ret
= invalid_control
;
1142 child_tail
->next
= next
;
1146 body_ptr
= current_cmd
->body_list
;
1147 for (i
= 1; i
< current_body
; i
++)
1156 /* If the latest line is another control structure, then recurse
1158 if (multi_line_command_p (next
->control_type
))
1161 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1162 validator
, closure
);
1165 if (ret
!= simple_control
)
1176 restore_interp (void *arg
)
1178 interp_set_temp (interp_name ((struct interp
*)arg
));
1181 /* Read lines from the input stream and accumulate them in a chain of
1182 struct command_line's, which is then returned. For input from a
1183 terminal, the special command "end" is used to mark the end of the
1184 input, and is not included in the returned chain of commands.
1186 If PARSE_COMMANDS is true, strip leading whitespace (trailing whitespace
1187 is always stripped) in the line and attempt to recognize GDB control
1188 commands. Otherwise, only "end" is recognized. */
1190 #define END_MESSAGE "End with a line saying just \"end\"."
1192 struct command_line
*
1193 read_command_lines (char *prompt_arg
, int from_tty
, int parse_commands
,
1194 void (*validator
)(char *, void *), void *closure
)
1196 struct command_line
*head
;
1198 if (from_tty
&& input_interactive_p (current_ui
))
1200 if (deprecated_readline_begin_hook
)
1202 /* Note - intentional to merge messages with no newline. */
1203 (*deprecated_readline_begin_hook
) ("%s %s\n", prompt_arg
,
1208 printf_unfiltered ("%s\n%s\n", prompt_arg
, END_MESSAGE
);
1209 gdb_flush (gdb_stdout
);
1214 /* Reading commands assumes the CLI behavior, so temporarily
1215 override the current interpreter with CLI. */
1216 if (current_interp_named_p (INTERP_CONSOLE
))
1217 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1218 validator
, closure
);
1221 struct interp
*old_interp
= interp_set_temp (INTERP_CONSOLE
);
1222 struct cleanup
*old_chain
= make_cleanup (restore_interp
, old_interp
);
1224 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1225 validator
, closure
);
1226 do_cleanups (old_chain
);
1229 if (from_tty
&& input_interactive_p (current_ui
)
1230 && deprecated_readline_end_hook
)
1232 (*deprecated_readline_end_hook
) ();
1237 /* Act the same way as read_command_lines, except that each new line is
1238 obtained using READ_NEXT_LINE_FUNC. */
1240 struct command_line
*
1241 read_command_lines_1 (char * (*read_next_line_func
) (void), int parse_commands
,
1242 void (*validator
)(char *, void *), void *closure
)
1244 struct command_line
*head
, *tail
, *next
;
1245 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1246 enum command_control_type ret
;
1247 enum misc_command_type val
;
1255 val
= process_next_line (read_next_line_func (), &next
, parse_commands
,
1256 validator
, closure
);
1258 /* Ignore blank lines or comments. */
1259 if (val
== nop_command
)
1262 if (val
== end_command
)
1264 ret
= simple_control
;
1268 if (val
!= ok_command
)
1270 ret
= invalid_control
;
1274 if (multi_line_command_p (next
->control_type
))
1277 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1278 validator
, closure
);
1281 if (ret
== invalid_control
)
1292 make_cleanup_free_command_lines (&head
);
1299 if (ret
!= invalid_control
)
1300 discard_cleanups (old_chain
);
1302 do_cleanups (old_chain
);
1307 /* Free a chain of struct command_line's. */
1310 free_command_lines (struct command_line
**lptr
)
1312 struct command_line
*l
= *lptr
;
1313 struct command_line
*next
;
1314 struct command_line
**blist
;
1319 if (l
->body_count
> 0)
1321 blist
= l
->body_list
;
1322 for (i
= 0; i
< l
->body_count
; i
++, blist
++)
1323 free_command_lines (blist
);
1334 do_free_command_lines_cleanup (void *arg
)
1336 free_command_lines ((struct command_line
**) arg
);
1340 make_cleanup_free_command_lines (struct command_line
**arg
)
1342 return make_cleanup (do_free_command_lines_cleanup
, arg
);
1345 struct command_line
*
1346 copy_command_lines (struct command_line
*cmds
)
1348 struct command_line
*result
= NULL
;
1352 result
= XNEW (struct command_line
);
1354 result
->next
= copy_command_lines (cmds
->next
);
1355 result
->line
= xstrdup (cmds
->line
);
1356 result
->control_type
= cmds
->control_type
;
1357 result
->body_count
= cmds
->body_count
;
1358 if (cmds
->body_count
> 0)
1362 result
->body_list
= XNEWVEC (struct command_line
*, cmds
->body_count
);
1364 for (i
= 0; i
< cmds
->body_count
; i
++)
1365 result
->body_list
[i
] = copy_command_lines (cmds
->body_list
[i
]);
1368 result
->body_list
= NULL
;
1374 /* Validate that *COMNAME is a valid name for a command. Return the
1375 containing command list, in case it starts with a prefix command.
1376 The prefix must already exist. *COMNAME is advanced to point after
1377 any prefix, and a NUL character overwrites the space after the
1380 static struct cmd_list_element
**
1381 validate_comname (char **comname
)
1383 struct cmd_list_element
**list
= &cmdlist
;
1384 char *p
, *last_word
;
1387 error_no_arg (_("name of command to define"));
1389 /* Find the last word of the argument. */
1390 p
= *comname
+ strlen (*comname
);
1391 while (p
> *comname
&& isspace (p
[-1]))
1393 while (p
> *comname
&& !isspace (p
[-1]))
1397 /* Find the corresponding command list. */
1398 if (last_word
!= *comname
)
1400 struct cmd_list_element
*c
;
1402 const char *tem
= *comname
;
1404 /* Separate the prefix and the command. */
1405 saved_char
= last_word
[-1];
1406 last_word
[-1] = '\0';
1408 c
= lookup_cmd (&tem
, cmdlist
, "", 0, 1);
1409 if (c
->prefixlist
== NULL
)
1410 error (_("\"%s\" is not a prefix command."), *comname
);
1412 list
= c
->prefixlist
;
1413 last_word
[-1] = saved_char
;
1414 *comname
= last_word
;
1420 if (!isalnum (*p
) && *p
!= '-' && *p
!= '_')
1421 error (_("Junk in argument list: \"%s\""), p
);
1428 /* This is just a placeholder in the command data structures. */
1430 user_defined_command (char *ignore
, int from_tty
)
1435 define_command (char *comname
, int from_tty
)
1437 #define MAX_TMPBUF 128
1444 struct command_line
*cmds
;
1445 struct cmd_list_element
*c
, *newc
, *hookc
= 0, **list
;
1446 char *tem
, *comfull
;
1448 char tmpbuf
[MAX_TMPBUF
];
1449 int hook_type
= CMD_NO_HOOK
;
1450 int hook_name_size
= 0;
1452 #define HOOK_STRING "hook-"
1454 #define HOOK_POST_STRING "hookpost-"
1455 #define HOOK_POST_LEN 9
1458 list
= validate_comname (&comname
);
1460 /* Look it up, and verify that we got an exact match. */
1462 c
= lookup_cmd (&tem_c
, *list
, "", -1, 1);
1463 if (c
&& strcmp (comname
, c
->name
) != 0)
1470 if (c
->theclass
== class_user
|| c
->theclass
== class_alias
)
1471 q
= query (_("Redefine command \"%s\"? "), c
->name
);
1473 q
= query (_("Really redefine built-in command \"%s\"? "), c
->name
);
1475 error (_("Command \"%s\" not redefined."), c
->name
);
1478 /* If this new command is a hook, then mark the command which it
1479 is hooking. Note that we allow hooking `help' commands, so that
1480 we can hook the `stop' pseudo-command. */
1482 if (!strncmp (comname
, HOOK_STRING
, HOOK_LEN
))
1484 hook_type
= CMD_PRE_HOOK
;
1485 hook_name_size
= HOOK_LEN
;
1487 else if (!strncmp (comname
, HOOK_POST_STRING
, HOOK_POST_LEN
))
1489 hook_type
= CMD_POST_HOOK
;
1490 hook_name_size
= HOOK_POST_LEN
;
1493 if (hook_type
!= CMD_NO_HOOK
)
1495 /* Look up cmd it hooks, and verify that we got an exact match. */
1496 tem_c
= comname
+ hook_name_size
;
1497 hookc
= lookup_cmd (&tem_c
, *list
, "", -1, 0);
1498 if (hookc
&& strcmp (comname
+ hook_name_size
, hookc
->name
) != 0)
1502 warning (_("Your new `%s' command does not "
1503 "hook any existing command."),
1505 if (!query (_("Proceed? ")))
1506 error (_("Not confirmed."));
1510 comname
= xstrdup (comname
);
1512 /* If the rest of the commands will be case insensitive, this one
1513 should behave in the same manner. */
1514 for (tem
= comname
; *tem
; tem
++)
1516 *tem
= tolower (*tem
);
1518 xsnprintf (tmpbuf
, sizeof (tmpbuf
),
1519 "Type commands for definition of \"%s\".", comfull
);
1520 cmds
= read_command_lines (tmpbuf
, from_tty
, 1, 0, 0);
1522 if (c
&& c
->theclass
== class_user
)
1523 free_command_lines (&c
->user_commands
);
1525 newc
= add_cmd (comname
, class_user
, user_defined_command
,
1526 (c
&& c
->theclass
== class_user
)
1527 ? c
->doc
: xstrdup ("User-defined."), list
);
1528 newc
->user_commands
= cmds
;
1530 /* If this new command is a hook, then mark both commands as being
1537 hookc
->hook_pre
= newc
; /* Target gets hooked. */
1538 newc
->hookee_pre
= hookc
; /* We are marked as hooking target cmd. */
1541 hookc
->hook_post
= newc
; /* Target gets hooked. */
1542 newc
->hookee_post
= hookc
; /* We are marked as hooking
1546 /* Should never come here as hookc would be 0. */
1547 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1553 document_command (char *comname
, int from_tty
)
1555 struct command_line
*doclines
;
1556 struct cmd_list_element
*c
, **list
;
1562 list
= validate_comname (&comname
);
1565 c
= lookup_cmd (&tem
, *list
, "", 0, 1);
1567 if (c
->theclass
!= class_user
)
1568 error (_("Command \"%s\" is built-in."), comfull
);
1570 xsnprintf (tmpbuf
, sizeof (tmpbuf
), "Type documentation for \"%s\".",
1572 doclines
= read_command_lines (tmpbuf
, from_tty
, 0, 0, 0);
1575 xfree ((char *) c
->doc
);
1578 struct command_line
*cl1
;
1582 for (cl1
= doclines
; cl1
; cl1
= cl1
->next
)
1583 len
+= strlen (cl1
->line
) + 1;
1585 doc
= (char *) xmalloc (len
+ 1);
1588 for (cl1
= doclines
; cl1
; cl1
= cl1
->next
)
1590 strcat (doc
, cl1
->line
);
1598 free_command_lines (&doclines
);
1601 struct source_cleanup_lines_args
1604 const char *old_file
;
1608 source_cleanup_lines (void *args
)
1610 struct source_cleanup_lines_args
*p
=
1611 (struct source_cleanup_lines_args
*) args
;
1613 source_line_number
= p
->old_line
;
1614 source_file_name
= p
->old_file
;
1617 /* Used to implement source_command. */
1620 script_from_file (FILE *stream
, const char *file
)
1622 struct cleanup
*old_cleanups
;
1623 struct source_cleanup_lines_args old_lines
;
1626 internal_error (__FILE__
, __LINE__
, _("called with NULL file pointer!"));
1628 old_lines
.old_line
= source_line_number
;
1629 old_lines
.old_file
= source_file_name
;
1630 old_cleanups
= make_cleanup (source_cleanup_lines
, &old_lines
);
1631 source_line_number
= 0;
1632 source_file_name
= file
;
1635 scoped_restore save_async
= make_scoped_restore (¤t_ui
->async
, 0);
1639 read_command_file (stream
);
1641 CATCH (e
, RETURN_MASK_ERROR
)
1643 /* Re-throw the error, but with the file name information
1645 throw_error (e
.error
,
1646 _("%s:%d: Error in sourced command file:\n%s"),
1647 source_file_name
, source_line_number
, e
.message
);
1652 do_cleanups (old_cleanups
);
1655 /* Print the definition of user command C to STREAM. Or, if C is a
1656 prefix command, show the definitions of all user commands under C
1657 (recursively). PREFIX and NAME combined are the name of the
1660 show_user_1 (struct cmd_list_element
*c
, const char *prefix
, const char *name
,
1661 struct ui_file
*stream
)
1663 struct command_line
*cmdlines
;
1665 if (c
->prefixlist
!= NULL
)
1667 const char *prefixname
= c
->prefixname
;
1669 for (c
= *c
->prefixlist
; c
!= NULL
; c
= c
->next
)
1670 if (c
->theclass
== class_user
|| c
->prefixlist
!= NULL
)
1671 show_user_1 (c
, prefixname
, c
->name
, gdb_stdout
);
1675 cmdlines
= c
->user_commands
;
1676 fprintf_filtered (stream
, "User command \"%s%s\":\n", prefix
, name
);
1680 print_command_lines (current_uiout
, cmdlines
, 1);
1681 fputs_filtered ("\n", stream
);
1686 initialize_file_ftype _initialize_cli_script
;
1689 _initialize_cli_script (void)
1691 add_com ("document", class_support
, document_command
, _("\
1692 Document a user-defined command.\n\
1693 Give command name as argument. Give documentation on following lines.\n\
1694 End with a line of just \"end\"."));
1695 add_com ("define", class_support
, define_command
, _("\
1696 Define a new command name. Command name is argument.\n\
1697 Definition appears on following lines, one command per line.\n\
1698 End with a line of just \"end\".\n\
1699 Use the \"document\" command to give documentation for the new command.\n\
1700 Commands defined in this way may have up to ten arguments."));
1702 add_com ("while", class_support
, while_command
, _("\
1703 Execute nested commands WHILE the conditional expression is non zero.\n\
1704 The conditional expression must follow the word `while' 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 `end'."));
1708 add_com ("if", class_support
, if_command
, _("\
1709 Execute nested commands once IF the conditional expression is non zero.\n\
1710 The conditional expression must follow the word `if' and must in turn be\n\
1711 followed by a new line. The nested commands must be entered one per line,\n\
1712 and should be terminated by the word 'else' or `end'. If an else clause\n\
1713 is used, the same rules apply to its nested commands as to the first ones."));