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 char *insert_args (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 command_line
*cmdlines
;
356 struct cleanup
*old_chain
;
357 enum command_control_type ret
;
358 static int user_call_depth
= 0;
359 extern unsigned int max_user_call_depth
;
361 cmdlines
= c
->user_commands
;
366 old_chain
= setup_user_args (args
);
368 if (++user_call_depth
> max_user_call_depth
)
369 error (_("Max user call depth exceeded -- command aborted."));
371 make_cleanup (do_restore_user_call_depth
, &user_call_depth
);
373 /* Set the instream to 0, indicating execution of a
374 user-defined function. */
375 make_cleanup (do_restore_instream_cleanup
, instream
);
376 instream
= (FILE *) 0;
378 /* Also set the global in_user_command, so that NULL instream is
379 not confused with Insight. */
382 make_cleanup_restore_integer (&interpreter_async
);
383 interpreter_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
;
452 /* Start by assuming failure, if a problem is detected, the code
453 below will simply "break" out of the switch. */
454 ret
= invalid_control
;
456 switch (cmd
->control_type
)
459 /* A simple command, execute it and return. */
460 new_line
= insert_args (cmd
->line
);
463 make_cleanup (free_current_contents
, &new_line
);
464 execute_command (new_line
, 0);
465 ret
= cmd
->control_type
;
468 case continue_control
:
469 print_command_trace ("loop_continue");
471 /* Return for "continue", and "break" so we can either
472 continue the loop at the top, or break out. */
473 ret
= cmd
->control_type
;
477 print_command_trace ("loop_break");
479 /* Return for "continue", and "break" so we can either
480 continue the loop at the top, or break out. */
481 ret
= cmd
->control_type
;
486 int len
= strlen (cmd
->line
) + 7;
487 char *buffer
= (char *) alloca (len
);
489 xsnprintf (buffer
, len
, "while %s", cmd
->line
);
490 print_command_trace (buffer
);
492 /* Parse the loop control expression for the while statement. */
493 new_line
= insert_args (cmd
->line
);
496 make_cleanup (free_current_contents
, &new_line
);
497 expr
= parse_expression (new_line
);
498 make_cleanup (free_current_contents
, &expr
);
500 ret
= simple_control
;
503 /* Keep iterating so long as the expression is true. */
510 /* Evaluate the expression. */
511 val_mark
= value_mark ();
512 val
= evaluate_expression (expr
);
513 cond_result
= value_true (val
);
514 value_free_to_mark (val_mark
);
516 /* If the value is false, then break out of the loop. */
520 /* Execute the body of the while statement. */
521 current
= *cmd
->body_list
;
524 command_nest_depth
++;
525 ret
= execute_control_command (current
);
526 command_nest_depth
--;
528 /* If we got an error, or a "break" command, then stop
530 if (ret
== invalid_control
|| ret
== break_control
)
536 /* If we got a "continue" command, then restart the loop
538 if (ret
== continue_control
)
541 /* Get the next statement. */
542 current
= current
->next
;
546 /* Reset RET so that we don't recurse the break all the way down. */
547 if (ret
== break_control
)
548 ret
= simple_control
;
555 int len
= strlen (cmd
->line
) + 4;
556 char *buffer
= (char *) alloca (len
);
558 xsnprintf (buffer
, len
, "if %s", cmd
->line
);
559 print_command_trace (buffer
);
561 new_line
= insert_args (cmd
->line
);
564 make_cleanup (free_current_contents
, &new_line
);
565 /* Parse the conditional for the if statement. */
566 expr
= parse_expression (new_line
);
567 make_cleanup (free_current_contents
, &expr
);
570 ret
= simple_control
;
572 /* Evaluate the conditional. */
573 val_mark
= value_mark ();
574 val
= evaluate_expression (expr
);
576 /* Choose which arm to take commands from based on the value
577 of the conditional expression. */
578 if (value_true (val
))
579 current
= *cmd
->body_list
;
580 else if (cmd
->body_count
== 2)
581 current
= *(cmd
->body_list
+ 1);
582 value_free_to_mark (val_mark
);
584 /* Execute commands in the given arm. */
587 command_nest_depth
++;
588 ret
= execute_control_command (current
);
589 command_nest_depth
--;
591 /* If we got an error, get out. */
592 if (ret
!= simple_control
)
595 /* Get the next statement in the body. */
596 current
= current
->next
;
602 case commands_control
:
604 /* Breakpoint commands list, record the commands in the
605 breakpoint's command list and return. */
606 new_line
= insert_args (cmd
->line
);
609 make_cleanup (free_current_contents
, &new_line
);
610 ret
= commands_from_control_command (new_line
, 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."));
633 do_cleanups (old_chain
);
638 /* Like execute_control_command, but first set
639 suppress_next_print_command_trace. */
641 enum command_control_type
642 execute_control_command_untraced (struct command_line
*cmd
)
644 suppress_next_print_command_trace
= 1;
645 return execute_control_command (cmd
);
649 /* "while" command support. Executes a body of statements while the
650 loop condition is nonzero. */
653 while_command (char *arg
, int from_tty
)
655 struct command_line
*command
= NULL
;
656 struct cleanup
*old_chain
;
659 command
= get_command_line (while_control
, arg
);
664 old_chain
= make_cleanup_restore_integer (&interpreter_async
);
665 interpreter_async
= 0;
667 execute_control_command_untraced (command
);
668 free_command_lines (&command
);
670 do_cleanups (old_chain
);
673 /* "if" command support. Execute either the true or false arm depending
674 on the value of the if conditional. */
677 if_command (char *arg
, int from_tty
)
679 struct command_line
*command
= NULL
;
680 struct cleanup
*old_chain
;
683 command
= get_command_line (if_control
, arg
);
688 old_chain
= make_cleanup_restore_integer (&interpreter_async
);
689 interpreter_async
= 0;
691 execute_control_command_untraced (command
);
692 free_command_lines (&command
);
694 do_cleanups (old_chain
);
699 arg_cleanup (void *ignore
)
701 struct user_args
*oargs
= user_args
;
704 internal_error (__FILE__
, __LINE__
,
705 _("arg_cleanup called with no user args.\n"));
707 user_args
= user_args
->next
;
708 xfree (oargs
->command
);
712 /* Bind the incomming arguments for a user defined command to
713 $arg0, $arg1 ... $argMAXUSERARGS. */
715 static struct cleanup
*
716 setup_user_args (char *p
)
718 struct user_args
*args
;
719 struct cleanup
*old_chain
;
720 unsigned int arg_count
= 0;
722 args
= XNEW (struct user_args
);
723 memset (args
, 0, sizeof (struct user_args
));
725 args
->next
= user_args
;
728 old_chain
= make_cleanup (arg_cleanup
, 0/*ignored*/);
733 user_args
->command
= p
= xstrdup (p
);
742 if (arg_count
>= MAXUSERARGS
)
743 error (_("user defined function may only have %d arguments."),
746 /* Strip whitespace. */
747 while (*p
== ' ' || *p
== '\t')
750 /* P now points to an argument. */
752 user_args
->a
[arg_count
].arg
= p
;
754 /* Get to the end of this argument. */
757 if (((*p
== ' ' || *p
== '\t')) && !squote
&& !dquote
&& !bsquote
)
786 user_args
->a
[arg_count
].len
= p
- start_arg
;
793 /* Given character string P, return a point to the first argument
794 ($arg), or NULL if P contains no arguments. */
799 while ((p
= strchr (p
, '$')))
801 if (startswith (p
, "$arg")
802 && (isdigit (p
[4]) || p
[4] == 'c'))
809 /* Insert the user defined arguments stored in user_arg into the $arg
810 arguments found in line, with the updated copy being placed into
814 insert_args (char *line
)
816 char *p
, *save_line
, *new_line
;
819 /* If we are not in a user-defined function, treat $argc, $arg0, et
820 cetera as normal convenience variables. */
821 if (user_args
== NULL
)
822 return xstrdup (line
);
824 /* First we need to know how much memory to allocate for the new
828 while ((p
= locate_arg (line
)))
835 /* $argc. Number will be <=10. */
836 len
+= user_args
->count
== 10 ? 2 : 1;
838 else if (i
>= user_args
->count
)
840 error (_("Missing argument %d in user function."), i
);
845 len
+= user_args
->a
[i
].len
;
850 /* Don't forget the tail. */
851 len
+= strlen (line
);
853 /* Allocate space for the new line and fill it in. */
854 new_line
= (char *) xmalloc (len
+ 1);
855 if (new_line
== NULL
)
858 /* Restore pointer to beginning of old line. */
861 /* Save pointer to beginning of new line. */
862 save_line
= new_line
;
864 while ((p
= locate_arg (line
)))
868 memcpy (new_line
, line
, p
- line
);
869 new_line
+= p
- line
;
873 gdb_assert (user_args
->count
>= 0 && user_args
->count
<= 10);
874 if (user_args
->count
== 10)
880 *(new_line
++) = user_args
->count
+ '0';
885 len
= user_args
->a
[i
].len
;
888 memcpy (new_line
, user_args
->a
[i
].arg
, len
);
894 /* Don't forget the tail. */
895 strcpy (new_line
, line
);
897 /* Return a pointer to the beginning of the new line. */
902 /* Expand the body_list of COMMAND so that it can hold NEW_LENGTH
903 code bodies. This is typically used when we encounter an "else"
904 clause for an "if" command. */
907 realloc_body_list (struct command_line
*command
, int new_length
)
910 struct command_line
**body_list
;
912 n
= command
->body_count
;
918 body_list
= XCNEWVEC (struct command_line
*, new_length
);
920 memcpy (body_list
, command
->body_list
, sizeof (struct command_line
*) * n
);
922 xfree (command
->body_list
);
923 command
->body_list
= body_list
;
924 command
->body_count
= new_length
;
927 /* Read next line from stdin. Passed to read_command_line_1 and
928 recurse_read_control_structure whenever we need to read commands
932 read_next_line (void)
934 char *prompt_ptr
, control_prompt
[256];
937 if (control_level
>= 254)
938 error (_("Control nesting too deep!"));
940 /* Set a prompt based on the nesting of the control commands. */
941 if (instream
== stdin
|| (instream
== 0 && deprecated_readline_hook
!= NULL
))
943 for (i
= 0; i
< control_level
; i
++)
944 control_prompt
[i
] = ' ';
945 control_prompt
[i
] = '>';
946 control_prompt
[i
+ 1] = '\0';
947 prompt_ptr
= (char *) &control_prompt
[0];
952 return command_line_input (prompt_ptr
, instream
== stdin
, "commands");
955 /* Process one input line. If the command is an "end", return such an
956 indication to the caller. If PARSE_COMMANDS is true, strip leading
957 whitespace (trailing whitespace is always stripped) in the line,
958 attempt to recognize GDB control commands, and also return an
959 indication if the command is an "else" or a nop.
961 Otherwise, only "end" is recognized. */
963 static enum misc_command_type
964 process_next_line (char *p
, struct command_line
**command
, int parse_commands
,
965 void (*validator
)(char *, void *), void *closure
)
971 /* Not sure what to do here. */
975 /* Strip trailing whitespace. */
976 p_end
= p
+ strlen (p
);
977 while (p_end
> p
&& (p_end
[-1] == ' ' || p_end
[-1] == '\t'))
981 /* Strip leading whitespace. */
982 while (p_start
< p_end
&& (*p_start
== ' ' || *p_start
== '\t'))
985 /* 'end' is always recognized, regardless of parse_commands value.
986 We also permit whitespace before end and after. */
987 if (p_end
- p_start
== 3 && startswith (p_start
, "end"))
992 /* If commands are parsed, we skip initial spaces. Otherwise,
993 which is the case for Python commands and documentation
994 (see the 'document' command), spaces are preserved. */
997 /* Blanks and comments don't really do anything, but we need to
998 distinguish them from else, end and other commands which can
1000 if (p_end
== p
|| p
[0] == '#')
1003 /* Is the else clause of an if control structure? */
1004 if (p_end
- p
== 4 && startswith (p
, "else"))
1005 return else_command
;
1007 /* Check for while, if, break, continue, etc and build a new
1008 command line structure for them. */
1009 if ((p_end
- p
>= 14 && startswith (p
, "while-stepping"))
1010 || (p_end
- p
>= 8 && startswith (p
, "stepping"))
1011 || (p_end
- p
>= 2 && startswith (p
, "ws")))
1013 /* Because validate_actionline and encode_action lookup
1014 command's line as command, we need the line to
1015 include 'while-stepping'.
1017 For 'ws' alias, the command will have 'ws', not expanded
1018 to 'while-stepping'. This is intentional -- we don't
1019 really want frontend to send a command list with 'ws',
1020 and next break-info returning command line with
1021 'while-stepping'. This should work, but might cause the
1022 breakpoint to be marked as changed while it's actually
1024 *command
= build_command_line (while_stepping_control
, p
);
1026 else if (p_end
- p
> 5 && startswith (p
, "while"))
1031 while (first_arg
< p_end
&& isspace (*first_arg
))
1033 *command
= build_command_line (while_control
, first_arg
);
1035 else if (p_end
- p
> 2 && startswith (p
, "if"))
1040 while (first_arg
< p_end
&& isspace (*first_arg
))
1042 *command
= build_command_line (if_control
, first_arg
);
1044 else if (p_end
- p
>= 8 && startswith (p
, "commands"))
1049 while (first_arg
< p_end
&& isspace (*first_arg
))
1051 *command
= build_command_line (commands_control
, first_arg
);
1053 else if (p_end
- p
== 6 && startswith (p
, "python"))
1055 /* Note that we ignore the inline "python command" form
1057 *command
= build_command_line (python_control
, "");
1059 else if (p_end
- p
== 6 && startswith (p
, "compile"))
1061 /* Note that we ignore the inline "compile command" form
1063 *command
= build_command_line (compile_control
, "");
1064 (*command
)->control_u
.compile
.scope
= COMPILE_I_INVALID_SCOPE
;
1067 else if (p_end
- p
== 5 && startswith (p
, "guile"))
1069 /* Note that we ignore the inline "guile command" form here. */
1070 *command
= build_command_line (guile_control
, "");
1072 else if (p_end
- p
== 10 && startswith (p
, "loop_break"))
1074 *command
= XNEW (struct command_line
);
1075 (*command
)->next
= NULL
;
1076 (*command
)->line
= NULL
;
1077 (*command
)->control_type
= break_control
;
1078 (*command
)->body_count
= 0;
1079 (*command
)->body_list
= NULL
;
1081 else if (p_end
- p
== 13 && startswith (p
, "loop_continue"))
1083 *command
= XNEW (struct command_line
);
1084 (*command
)->next
= NULL
;
1085 (*command
)->line
= NULL
;
1086 (*command
)->control_type
= continue_control
;
1087 (*command
)->body_count
= 0;
1088 (*command
)->body_list
= NULL
;
1094 if (!parse_commands
|| not_handled
)
1096 /* A normal command. */
1097 *command
= XNEW (struct command_line
);
1098 (*command
)->next
= NULL
;
1099 (*command
)->line
= savestring (p
, p_end
- p
);
1100 (*command
)->control_type
= simple_control
;
1101 (*command
)->body_count
= 0;
1102 (*command
)->body_list
= NULL
;
1110 validator ((*command
)->line
, closure
);
1112 CATCH (ex
, RETURN_MASK_ALL
)
1115 throw_exception (ex
);
1120 /* Nothing special. */
1124 /* Recursively read in the control structures and create a
1125 command_line structure from them. Use read_next_line_func to
1126 obtain lines of the command. */
1128 static enum command_control_type
1129 recurse_read_control_structure (char * (*read_next_line_func
) (void),
1130 struct command_line
*current_cmd
,
1131 void (*validator
)(char *, void *),
1134 int current_body
, i
;
1135 enum misc_command_type val
;
1136 enum command_control_type ret
;
1137 struct command_line
**body_ptr
, *child_tail
, *next
;
1142 /* Sanity checks. */
1143 if (current_cmd
->control_type
== simple_control
)
1144 error (_("Recursed on a simple control type."));
1146 if (current_body
> current_cmd
->body_count
)
1147 error (_("Allocated body is smaller than this command type needs."));
1149 /* Read lines from the input stream and build control structures. */
1155 val
= process_next_line (read_next_line_func (), &next
,
1156 current_cmd
->control_type
!= python_control
1157 && current_cmd
->control_type
!= guile_control
1158 && current_cmd
->control_type
!= compile_control
,
1159 validator
, closure
);
1161 /* Just skip blanks and comments. */
1162 if (val
== nop_command
)
1165 if (val
== end_command
)
1167 if (multi_line_command_p (current_cmd
->control_type
))
1169 /* Success reading an entire canned sequence of commands. */
1170 ret
= simple_control
;
1175 ret
= invalid_control
;
1180 /* Not the end of a control structure. */
1181 if (val
== else_command
)
1183 if (current_cmd
->control_type
== if_control
1184 && current_body
== 1)
1186 realloc_body_list (current_cmd
, 2);
1193 ret
= invalid_control
;
1200 child_tail
->next
= next
;
1204 body_ptr
= current_cmd
->body_list
;
1205 for (i
= 1; i
< current_body
; i
++)
1214 /* If the latest line is another control structure, then recurse
1216 if (multi_line_command_p (next
->control_type
))
1219 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1220 validator
, closure
);
1223 if (ret
!= simple_control
)
1234 restore_interp (void *arg
)
1236 interp_set_temp (interp_name ((struct interp
*)arg
));
1239 /* Read lines from the input stream and accumulate them in a chain of
1240 struct command_line's, which is then returned. For input from a
1241 terminal, the special command "end" is used to mark the end of the
1242 input, and is not included in the returned chain of commands.
1244 If PARSE_COMMANDS is true, strip leading whitespace (trailing whitespace
1245 is always stripped) in the line and attempt to recognize GDB control
1246 commands. Otherwise, only "end" is recognized. */
1248 #define END_MESSAGE "End with a line saying just \"end\"."
1250 struct command_line
*
1251 read_command_lines (char *prompt_arg
, int from_tty
, int parse_commands
,
1252 void (*validator
)(char *, void *), void *closure
)
1254 struct command_line
*head
;
1256 if (from_tty
&& input_from_terminal_p ())
1258 if (deprecated_readline_begin_hook
)
1260 /* Note - intentional to merge messages with no newline. */
1261 (*deprecated_readline_begin_hook
) ("%s %s\n", prompt_arg
,
1266 printf_unfiltered ("%s\n%s\n", prompt_arg
, END_MESSAGE
);
1267 gdb_flush (gdb_stdout
);
1272 /* Reading commands assumes the CLI behavior, so temporarily
1273 override the current interpreter with CLI. */
1274 if (current_interp_named_p (INTERP_CONSOLE
))
1275 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1276 validator
, closure
);
1279 struct interp
*old_interp
= interp_set_temp (INTERP_CONSOLE
);
1280 struct cleanup
*old_chain
= make_cleanup (restore_interp
, old_interp
);
1282 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1283 validator
, closure
);
1284 do_cleanups (old_chain
);
1287 if (deprecated_readline_end_hook
&& from_tty
&& input_from_terminal_p ())
1289 (*deprecated_readline_end_hook
) ();
1294 /* Act the same way as read_command_lines, except that each new line is
1295 obtained using READ_NEXT_LINE_FUNC. */
1297 struct command_line
*
1298 read_command_lines_1 (char * (*read_next_line_func
) (void), int parse_commands
,
1299 void (*validator
)(char *, void *), void *closure
)
1301 struct command_line
*head
, *tail
, *next
;
1302 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1303 enum command_control_type ret
;
1304 enum misc_command_type val
;
1312 val
= process_next_line (read_next_line_func (), &next
, parse_commands
,
1313 validator
, closure
);
1315 /* Ignore blank lines or comments. */
1316 if (val
== nop_command
)
1319 if (val
== end_command
)
1321 ret
= simple_control
;
1325 if (val
!= ok_command
)
1327 ret
= invalid_control
;
1331 if (multi_line_command_p (next
->control_type
))
1334 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1335 validator
, closure
);
1338 if (ret
== invalid_control
)
1349 make_cleanup_free_command_lines (&head
);
1356 if (ret
!= invalid_control
)
1357 discard_cleanups (old_chain
);
1359 do_cleanups (old_chain
);
1364 /* Free a chain of struct command_line's. */
1367 free_command_lines (struct command_line
**lptr
)
1369 struct command_line
*l
= *lptr
;
1370 struct command_line
*next
;
1371 struct command_line
**blist
;
1376 if (l
->body_count
> 0)
1378 blist
= l
->body_list
;
1379 for (i
= 0; i
< l
->body_count
; i
++, blist
++)
1380 free_command_lines (blist
);
1391 do_free_command_lines_cleanup (void *arg
)
1393 free_command_lines ((struct command_line
**) arg
);
1397 make_cleanup_free_command_lines (struct command_line
**arg
)
1399 return make_cleanup (do_free_command_lines_cleanup
, arg
);
1402 struct command_line
*
1403 copy_command_lines (struct command_line
*cmds
)
1405 struct command_line
*result
= NULL
;
1409 result
= XNEW (struct command_line
);
1411 result
->next
= copy_command_lines (cmds
->next
);
1412 result
->line
= xstrdup (cmds
->line
);
1413 result
->control_type
= cmds
->control_type
;
1414 result
->body_count
= cmds
->body_count
;
1415 if (cmds
->body_count
> 0)
1419 result
->body_list
= XNEWVEC (struct command_line
*, cmds
->body_count
);
1421 for (i
= 0; i
< cmds
->body_count
; i
++)
1422 result
->body_list
[i
] = copy_command_lines (cmds
->body_list
[i
]);
1425 result
->body_list
= NULL
;
1431 /* Validate that *COMNAME is a valid name for a command. Return the
1432 containing command list, in case it starts with a prefix command.
1433 The prefix must already exist. *COMNAME is advanced to point after
1434 any prefix, and a NUL character overwrites the space after the
1437 static struct cmd_list_element
**
1438 validate_comname (char **comname
)
1440 struct cmd_list_element
**list
= &cmdlist
;
1441 char *p
, *last_word
;
1444 error_no_arg (_("name of command to define"));
1446 /* Find the last word of the argument. */
1447 p
= *comname
+ strlen (*comname
);
1448 while (p
> *comname
&& isspace (p
[-1]))
1450 while (p
> *comname
&& !isspace (p
[-1]))
1454 /* Find the corresponding command list. */
1455 if (last_word
!= *comname
)
1457 struct cmd_list_element
*c
;
1459 const char *tem
= *comname
;
1461 /* Separate the prefix and the command. */
1462 saved_char
= last_word
[-1];
1463 last_word
[-1] = '\0';
1465 c
= lookup_cmd (&tem
, cmdlist
, "", 0, 1);
1466 if (c
->prefixlist
== NULL
)
1467 error (_("\"%s\" is not a prefix command."), *comname
);
1469 list
= c
->prefixlist
;
1470 last_word
[-1] = saved_char
;
1471 *comname
= last_word
;
1477 if (!isalnum (*p
) && *p
!= '-' && *p
!= '_')
1478 error (_("Junk in argument list: \"%s\""), p
);
1485 /* This is just a placeholder in the command data structures. */
1487 user_defined_command (char *ignore
, int from_tty
)
1492 define_command (char *comname
, int from_tty
)
1494 #define MAX_TMPBUF 128
1501 struct command_line
*cmds
;
1502 struct cmd_list_element
*c
, *newc
, *hookc
= 0, **list
;
1503 char *tem
, *comfull
;
1505 char tmpbuf
[MAX_TMPBUF
];
1506 int hook_type
= CMD_NO_HOOK
;
1507 int hook_name_size
= 0;
1509 #define HOOK_STRING "hook-"
1511 #define HOOK_POST_STRING "hookpost-"
1512 #define HOOK_POST_LEN 9
1515 list
= validate_comname (&comname
);
1517 /* Look it up, and verify that we got an exact match. */
1519 c
= lookup_cmd (&tem_c
, *list
, "", -1, 1);
1520 if (c
&& strcmp (comname
, c
->name
) != 0)
1527 if (c
->theclass
== class_user
|| c
->theclass
== class_alias
)
1528 q
= query (_("Redefine command \"%s\"? "), c
->name
);
1530 q
= query (_("Really redefine built-in command \"%s\"? "), c
->name
);
1532 error (_("Command \"%s\" not redefined."), c
->name
);
1535 /* If this new command is a hook, then mark the command which it
1536 is hooking. Note that we allow hooking `help' commands, so that
1537 we can hook the `stop' pseudo-command. */
1539 if (!strncmp (comname
, HOOK_STRING
, HOOK_LEN
))
1541 hook_type
= CMD_PRE_HOOK
;
1542 hook_name_size
= HOOK_LEN
;
1544 else if (!strncmp (comname
, HOOK_POST_STRING
, HOOK_POST_LEN
))
1546 hook_type
= CMD_POST_HOOK
;
1547 hook_name_size
= HOOK_POST_LEN
;
1550 if (hook_type
!= CMD_NO_HOOK
)
1552 /* Look up cmd it hooks, and verify that we got an exact match. */
1553 tem_c
= comname
+ hook_name_size
;
1554 hookc
= lookup_cmd (&tem_c
, *list
, "", -1, 0);
1555 if (hookc
&& strcmp (comname
+ hook_name_size
, hookc
->name
) != 0)
1559 warning (_("Your new `%s' command does not "
1560 "hook any existing command."),
1562 if (!query (_("Proceed? ")))
1563 error (_("Not confirmed."));
1567 comname
= xstrdup (comname
);
1569 /* If the rest of the commands will be case insensitive, this one
1570 should behave in the same manner. */
1571 for (tem
= comname
; *tem
; tem
++)
1573 *tem
= tolower (*tem
);
1575 xsnprintf (tmpbuf
, sizeof (tmpbuf
),
1576 "Type commands for definition of \"%s\".", comfull
);
1577 cmds
= read_command_lines (tmpbuf
, from_tty
, 1, 0, 0);
1579 if (c
&& c
->theclass
== class_user
)
1580 free_command_lines (&c
->user_commands
);
1582 newc
= add_cmd (comname
, class_user
, user_defined_command
,
1583 (c
&& c
->theclass
== class_user
)
1584 ? c
->doc
: xstrdup ("User-defined."), list
);
1585 newc
->user_commands
= cmds
;
1587 /* If this new command is a hook, then mark both commands as being
1594 hookc
->hook_pre
= newc
; /* Target gets hooked. */
1595 newc
->hookee_pre
= hookc
; /* We are marked as hooking target cmd. */
1598 hookc
->hook_post
= newc
; /* Target gets hooked. */
1599 newc
->hookee_post
= hookc
; /* We are marked as hooking
1603 /* Should never come here as hookc would be 0. */
1604 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1610 document_command (char *comname
, int from_tty
)
1612 struct command_line
*doclines
;
1613 struct cmd_list_element
*c
, **list
;
1619 list
= validate_comname (&comname
);
1622 c
= lookup_cmd (&tem
, *list
, "", 0, 1);
1624 if (c
->theclass
!= class_user
)
1625 error (_("Command \"%s\" is built-in."), comfull
);
1627 xsnprintf (tmpbuf
, sizeof (tmpbuf
), "Type documentation for \"%s\".",
1629 doclines
= read_command_lines (tmpbuf
, from_tty
, 0, 0, 0);
1632 xfree ((char *) c
->doc
);
1635 struct command_line
*cl1
;
1639 for (cl1
= doclines
; cl1
; cl1
= cl1
->next
)
1640 len
+= strlen (cl1
->line
) + 1;
1642 doc
= (char *) xmalloc (len
+ 1);
1645 for (cl1
= doclines
; cl1
; cl1
= cl1
->next
)
1647 strcat (doc
, cl1
->line
);
1655 free_command_lines (&doclines
);
1658 struct source_cleanup_lines_args
1661 const char *old_file
;
1665 source_cleanup_lines (void *args
)
1667 struct source_cleanup_lines_args
*p
=
1668 (struct source_cleanup_lines_args
*) args
;
1670 source_line_number
= p
->old_line
;
1671 source_file_name
= p
->old_file
;
1674 /* Used to implement source_command. */
1677 script_from_file (FILE *stream
, const char *file
)
1679 struct cleanup
*old_cleanups
;
1680 struct source_cleanup_lines_args old_lines
;
1683 internal_error (__FILE__
, __LINE__
, _("called with NULL file pointer!"));
1685 old_lines
.old_line
= source_line_number
;
1686 old_lines
.old_file
= source_file_name
;
1687 old_cleanups
= make_cleanup (source_cleanup_lines
, &old_lines
);
1688 source_line_number
= 0;
1689 source_file_name
= file
;
1691 make_cleanup_restore_integer (&interpreter_async
);
1692 interpreter_async
= 0;
1698 read_command_file (stream
);
1700 CATCH (e
, RETURN_MASK_ERROR
)
1702 /* Re-throw the error, but with the file name information
1704 throw_error (e
.error
,
1705 _("%s:%d: Error in sourced command file:\n%s"),
1706 source_file_name
, source_line_number
, e
.message
);
1711 do_cleanups (old_cleanups
);
1714 /* Print the definition of user command C to STREAM. Or, if C is a
1715 prefix command, show the definitions of all user commands under C
1716 (recursively). PREFIX and NAME combined are the name of the
1719 show_user_1 (struct cmd_list_element
*c
, const char *prefix
, const char *name
,
1720 struct ui_file
*stream
)
1722 struct command_line
*cmdlines
;
1724 if (c
->prefixlist
!= NULL
)
1726 const char *prefixname
= c
->prefixname
;
1728 for (c
= *c
->prefixlist
; c
!= NULL
; c
= c
->next
)
1729 if (c
->theclass
== class_user
|| c
->prefixlist
!= NULL
)
1730 show_user_1 (c
, prefixname
, c
->name
, gdb_stdout
);
1734 cmdlines
= c
->user_commands
;
1735 fprintf_filtered (stream
, "User command \"%s%s\":\n", prefix
, name
);
1739 print_command_lines (current_uiout
, cmdlines
, 1);
1740 fputs_filtered ("\n", stream
);
1745 initialize_file_ftype _initialize_cli_script
;
1748 _initialize_cli_script (void)
1750 add_com ("document", class_support
, document_command
, _("\
1751 Document a user-defined command.\n\
1752 Give command name as argument. Give documentation on following lines.\n\
1753 End with a line of just \"end\"."));
1754 add_com ("define", class_support
, define_command
, _("\
1755 Define a new command name. Command name is argument.\n\
1756 Definition appears on following lines, one command per line.\n\
1757 End with a line of just \"end\".\n\
1758 Use the \"document\" command to give documentation for the new command.\n\
1759 Commands defined in this way may have up to ten arguments."));
1761 add_com ("while", class_support
, while_command
, _("\
1762 Execute nested commands WHILE the conditional expression is non zero.\n\
1763 The conditional expression must follow the word `while' and must in turn be\n\
1764 followed by a new line. The nested commands must be entered one per line,\n\
1765 and should be terminated by the word `end'."));
1767 add_com ("if", class_support
, if_command
, _("\
1768 Execute nested commands once IF the conditional expression is non zero.\n\
1769 The conditional expression must follow the word `if' and must in turn be\n\
1770 followed by a new line. The nested commands must be entered one per line,\n\
1771 and should be terminated by the word 'else' or `end'. If an else clause\n\
1772 is used, the same rules apply to its nested commands as to the first ones."));