1 /* GDB CLI command scripting.
3 Copyright (C) 1986-2015 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
= (struct command_line
*) xmalloc (sizeof (struct command_line
));
114 cmd
->control_type
= type
;
118 = (struct command_line
**) xmalloc (sizeof (struct command_line
*)
120 memset (cmd
->body_list
, 0, sizeof (struct command_line
*) * cmd
->body_count
);
121 cmd
->line
= xstrdup (args
);
126 /* Build and return a new command structure for the control commands
127 such as "if" and "while". */
129 struct command_line
*
130 get_command_line (enum command_control_type type
, char *arg
)
132 struct command_line
*cmd
;
133 struct cleanup
*old_chain
= NULL
;
135 /* Allocate and build a new command line structure. */
136 cmd
= build_command_line (type
, arg
);
138 old_chain
= make_cleanup_free_command_lines (&cmd
);
140 /* Read in the body of this command. */
141 if (recurse_read_control_structure (read_next_line
, cmd
, 0, 0)
144 warning (_("Error reading in canned sequence of commands."));
145 do_cleanups (old_chain
);
149 discard_cleanups (old_chain
);
153 /* Recursively print a command (including full control structures). */
156 print_command_lines (struct ui_out
*uiout
, struct command_line
*cmd
,
159 struct command_line
*list
;
165 ui_out_spaces (uiout
, 2 * depth
);
167 /* A simple command, print it and continue. */
168 if (list
->control_type
== simple_control
)
170 ui_out_field_string (uiout
, NULL
, list
->line
);
171 ui_out_text (uiout
, "\n");
176 /* loop_continue to jump to the start of a while loop, print it
178 if (list
->control_type
== continue_control
)
180 ui_out_field_string (uiout
, NULL
, "loop_continue");
181 ui_out_text (uiout
, "\n");
186 /* loop_break to break out of a while loop, print it and
188 if (list
->control_type
== break_control
)
190 ui_out_field_string (uiout
, NULL
, "loop_break");
191 ui_out_text (uiout
, "\n");
196 /* A while command. Recursively print its subcommands and
198 if (list
->control_type
== while_control
199 || list
->control_type
== while_stepping_control
)
201 /* For while-stepping, the line includes the 'while-stepping'
202 token. See comment in process_next_line for explanation.
203 Here, take care not print 'while-stepping' twice. */
204 if (list
->control_type
== while_control
)
205 ui_out_field_fmt (uiout
, NULL
, "while %s", list
->line
);
207 ui_out_field_string (uiout
, NULL
, list
->line
);
208 ui_out_text (uiout
, "\n");
209 print_command_lines (uiout
, *list
->body_list
, depth
+ 1);
211 ui_out_spaces (uiout
, 2 * depth
);
212 ui_out_field_string (uiout
, NULL
, "end");
213 ui_out_text (uiout
, "\n");
218 /* An if command. Recursively print both arms before
220 if (list
->control_type
== if_control
)
222 ui_out_field_fmt (uiout
, NULL
, "if %s", list
->line
);
223 ui_out_text (uiout
, "\n");
225 print_command_lines (uiout
, list
->body_list
[0], depth
+ 1);
227 /* Show the false arm if it exists. */
228 if (list
->body_count
== 2)
231 ui_out_spaces (uiout
, 2 * depth
);
232 ui_out_field_string (uiout
, NULL
, "else");
233 ui_out_text (uiout
, "\n");
234 print_command_lines (uiout
, list
->body_list
[1], depth
+ 1);
238 ui_out_spaces (uiout
, 2 * depth
);
239 ui_out_field_string (uiout
, NULL
, "end");
240 ui_out_text (uiout
, "\n");
245 /* A commands command. Print the breakpoint commands and
247 if (list
->control_type
== commands_control
)
250 ui_out_field_fmt (uiout
, NULL
, "commands %s", list
->line
);
252 ui_out_field_string (uiout
, NULL
, "commands");
253 ui_out_text (uiout
, "\n");
254 print_command_lines (uiout
, *list
->body_list
, depth
+ 1);
256 ui_out_spaces (uiout
, 2 * depth
);
257 ui_out_field_string (uiout
, NULL
, "end");
258 ui_out_text (uiout
, "\n");
263 if (list
->control_type
== python_control
)
265 ui_out_field_string (uiout
, NULL
, "python");
266 ui_out_text (uiout
, "\n");
267 /* Don't indent python code at all. */
268 print_command_lines (uiout
, *list
->body_list
, 0);
270 ui_out_spaces (uiout
, 2 * depth
);
271 ui_out_field_string (uiout
, NULL
, "end");
272 ui_out_text (uiout
, "\n");
277 if (list
->control_type
== compile_control
)
279 ui_out_field_string (uiout
, NULL
, "compile expression");
280 ui_out_text (uiout
, "\n");
281 print_command_lines (uiout
, *list
->body_list
, 0);
283 ui_out_spaces (uiout
, 2 * depth
);
284 ui_out_field_string (uiout
, NULL
, "end");
285 ui_out_text (uiout
, "\n");
290 if (list
->control_type
== guile_control
)
292 ui_out_field_string (uiout
, NULL
, "guile");
293 ui_out_text (uiout
, "\n");
294 print_command_lines (uiout
, *list
->body_list
, depth
+ 1);
296 ui_out_spaces (uiout
, 2 * depth
);
297 ui_out_field_string (uiout
, NULL
, "end");
298 ui_out_text (uiout
, "\n");
303 /* Ignore illegal command type and try next. */
308 /* Handle pre-post hooks. */
311 clear_hook_in_cleanup (void *data
)
313 struct cmd_list_element
*c
= data
;
315 c
->hook_in
= 0; /* Allow hook to work again once it is complete. */
319 execute_cmd_pre_hook (struct cmd_list_element
*c
)
321 if ((c
->hook_pre
) && (!c
->hook_in
))
323 struct cleanup
*cleanups
= make_cleanup (clear_hook_in_cleanup
, c
);
324 c
->hook_in
= 1; /* Prevent recursive hooking. */
325 execute_user_command (c
->hook_pre
, (char *) 0);
326 do_cleanups (cleanups
);
331 execute_cmd_post_hook (struct cmd_list_element
*c
)
333 if ((c
->hook_post
) && (!c
->hook_in
))
335 struct cleanup
*cleanups
= make_cleanup (clear_hook_in_cleanup
, c
);
337 c
->hook_in
= 1; /* Prevent recursive hooking. */
338 execute_user_command (c
->hook_post
, (char *) 0);
339 do_cleanups (cleanups
);
343 /* Execute the command in CMD. */
345 do_restore_user_call_depth (void * call_depth
)
347 int *depth
= call_depth
;
356 execute_user_command (struct cmd_list_element
*c
, char *args
)
358 struct command_line
*cmdlines
;
359 struct cleanup
*old_chain
;
360 enum command_control_type ret
;
361 static int user_call_depth
= 0;
362 extern unsigned int max_user_call_depth
;
364 cmdlines
= c
->user_commands
;
369 old_chain
= setup_user_args (args
);
371 if (++user_call_depth
> max_user_call_depth
)
372 error (_("Max user call depth exceeded -- command aborted."));
374 make_cleanup (do_restore_user_call_depth
, &user_call_depth
);
376 /* Set the instream to 0, indicating execution of a
377 user-defined function. */
378 make_cleanup (do_restore_instream_cleanup
, instream
);
379 instream
= (FILE *) 0;
381 /* Also set the global in_user_command, so that NULL instream is
382 not confused with Insight. */
385 make_cleanup_restore_integer (&interpreter_async
);
386 interpreter_async
= 0;
388 command_nest_depth
++;
391 ret
= execute_control_command (cmdlines
);
392 if (ret
!= simple_control
&& ret
!= break_control
)
394 warning (_("Error executing canned sequence of commands."));
397 cmdlines
= cmdlines
->next
;
399 command_nest_depth
--;
400 do_cleanups (old_chain
);
403 /* This function is called every time GDB prints a prompt. It ensures
404 that errors and the like do not confuse the command tracing. */
407 reset_command_nest_depth (void)
409 command_nest_depth
= 1;
412 suppress_next_print_command_trace
= 0;
415 /* Print the command, prefixed with '+' to represent the call depth.
416 This is slightly complicated because this function may be called
417 from execute_command and execute_control_command. Unfortunately
418 execute_command also prints the top level control commands.
419 In these cases execute_command will call execute_control_command
420 via while_command or if_command. Inner levels of 'if' and 'while'
421 are dealt with directly. Therefore we can use these functions
422 to determine whether the command has been printed already or not. */
424 print_command_trace (const char *cmd
)
428 if (suppress_next_print_command_trace
)
430 suppress_next_print_command_trace
= 0;
434 if (!source_verbose
&& !trace_commands
)
437 for (i
=0; i
< command_nest_depth
; i
++)
438 printf_filtered ("+");
440 printf_filtered ("%s\n", cmd
);
443 enum command_control_type
444 execute_control_command (struct command_line
*cmd
)
446 struct expression
*expr
;
447 struct command_line
*current
;
448 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, 0);
450 struct value
*val_mark
;
452 enum command_control_type ret
;
455 /* Start by assuming failure, if a problem is detected, the code
456 below will simply "break" out of the switch. */
457 ret
= invalid_control
;
459 switch (cmd
->control_type
)
462 /* A simple command, execute it and return. */
463 new_line
= insert_args (cmd
->line
);
466 make_cleanup (free_current_contents
, &new_line
);
467 execute_command (new_line
, 0);
468 ret
= cmd
->control_type
;
471 case continue_control
:
472 print_command_trace ("loop_continue");
474 /* Return for "continue", and "break" so we can either
475 continue the loop at the top, or break out. */
476 ret
= cmd
->control_type
;
480 print_command_trace ("loop_break");
482 /* Return for "continue", and "break" so we can either
483 continue the loop at the top, or break out. */
484 ret
= cmd
->control_type
;
489 int len
= strlen (cmd
->line
) + 7;
490 char *buffer
= alloca (len
);
492 xsnprintf (buffer
, len
, "while %s", cmd
->line
);
493 print_command_trace (buffer
);
495 /* Parse the loop control expression for the while statement. */
496 new_line
= insert_args (cmd
->line
);
499 make_cleanup (free_current_contents
, &new_line
);
500 expr
= parse_expression (new_line
);
501 make_cleanup (free_current_contents
, &expr
);
503 ret
= simple_control
;
506 /* Keep iterating so long as the expression is true. */
513 /* Evaluate the expression. */
514 val_mark
= value_mark ();
515 val
= evaluate_expression (expr
);
516 cond_result
= value_true (val
);
517 value_free_to_mark (val_mark
);
519 /* If the value is false, then break out of the loop. */
523 /* Execute the body of the while statement. */
524 current
= *cmd
->body_list
;
527 command_nest_depth
++;
528 ret
= execute_control_command (current
);
529 command_nest_depth
--;
531 /* If we got an error, or a "break" command, then stop
533 if (ret
== invalid_control
|| ret
== break_control
)
539 /* If we got a "continue" command, then restart the loop
541 if (ret
== continue_control
)
544 /* Get the next statement. */
545 current
= current
->next
;
549 /* Reset RET so that we don't recurse the break all the way down. */
550 if (ret
== break_control
)
551 ret
= simple_control
;
558 int len
= strlen (cmd
->line
) + 4;
559 char *buffer
= alloca (len
);
561 xsnprintf (buffer
, len
, "if %s", cmd
->line
);
562 print_command_trace (buffer
);
564 new_line
= insert_args (cmd
->line
);
567 make_cleanup (free_current_contents
, &new_line
);
568 /* Parse the conditional for the if statement. */
569 expr
= parse_expression (new_line
);
570 make_cleanup (free_current_contents
, &expr
);
573 ret
= simple_control
;
575 /* Evaluate the conditional. */
576 val_mark
= value_mark ();
577 val
= evaluate_expression (expr
);
579 /* Choose which arm to take commands from based on the value
580 of the conditional expression. */
581 if (value_true (val
))
582 current
= *cmd
->body_list
;
583 else if (cmd
->body_count
== 2)
584 current
= *(cmd
->body_list
+ 1);
585 value_free_to_mark (val_mark
);
587 /* Execute commands in the given arm. */
590 command_nest_depth
++;
591 ret
= execute_control_command (current
);
592 command_nest_depth
--;
594 /* If we got an error, get out. */
595 if (ret
!= simple_control
)
598 /* Get the next statement in the body. */
599 current
= current
->next
;
605 case commands_control
:
607 /* Breakpoint commands list, record the commands in the
608 breakpoint's command list and return. */
609 new_line
= insert_args (cmd
->line
);
612 make_cleanup (free_current_contents
, &new_line
);
613 ret
= commands_from_control_command (new_line
, cmd
);
617 case compile_control
:
618 eval_compile_command (cmd
, NULL
, cmd
->control_u
.compile
.scope
,
619 cmd
->control_u
.compile
.scope_data
);
620 ret
= simple_control
;
626 eval_ext_lang_from_control_command (cmd
);
627 ret
= simple_control
;
632 warning (_("Invalid control type in canned commands structure."));
636 do_cleanups (old_chain
);
641 /* Like execute_control_command, but first set
642 suppress_next_print_command_trace. */
644 enum command_control_type
645 execute_control_command_untraced (struct command_line
*cmd
)
647 suppress_next_print_command_trace
= 1;
648 return execute_control_command (cmd
);
652 /* "while" command support. Executes a body of statements while the
653 loop condition is nonzero. */
656 while_command (char *arg
, int from_tty
)
658 struct command_line
*command
= NULL
;
659 struct cleanup
*old_chain
;
662 command
= get_command_line (while_control
, arg
);
667 old_chain
= make_cleanup_restore_integer (&interpreter_async
);
668 interpreter_async
= 0;
670 execute_control_command_untraced (command
);
671 free_command_lines (&command
);
673 do_cleanups (old_chain
);
676 /* "if" command support. Execute either the true or false arm depending
677 on the value of the if conditional. */
680 if_command (char *arg
, int from_tty
)
682 struct command_line
*command
= NULL
;
683 struct cleanup
*old_chain
;
686 command
= get_command_line (if_control
, arg
);
691 old_chain
= make_cleanup_restore_integer (&interpreter_async
);
692 interpreter_async
= 0;
694 execute_control_command_untraced (command
);
695 free_command_lines (&command
);
697 do_cleanups (old_chain
);
702 arg_cleanup (void *ignore
)
704 struct user_args
*oargs
= user_args
;
707 internal_error (__FILE__
, __LINE__
,
708 _("arg_cleanup called with no user args.\n"));
710 user_args
= user_args
->next
;
711 xfree (oargs
->command
);
715 /* Bind the incomming arguments for a user defined command to
716 $arg0, $arg1 ... $argMAXUSERARGS. */
718 static struct cleanup
*
719 setup_user_args (char *p
)
721 struct user_args
*args
;
722 struct cleanup
*old_chain
;
723 unsigned int arg_count
= 0;
725 args
= (struct user_args
*) xmalloc (sizeof (struct user_args
));
726 memset (args
, 0, sizeof (struct user_args
));
728 args
->next
= user_args
;
731 old_chain
= make_cleanup (arg_cleanup
, 0/*ignored*/);
736 user_args
->command
= p
= xstrdup (p
);
745 if (arg_count
>= MAXUSERARGS
)
746 error (_("user defined function may only have %d arguments."),
749 /* Strip whitespace. */
750 while (*p
== ' ' || *p
== '\t')
753 /* P now points to an argument. */
755 user_args
->a
[arg_count
].arg
= p
;
757 /* Get to the end of this argument. */
760 if (((*p
== ' ' || *p
== '\t')) && !squote
&& !dquote
&& !bsquote
)
789 user_args
->a
[arg_count
].len
= p
- start_arg
;
796 /* Given character string P, return a point to the first argument
797 ($arg), or NULL if P contains no arguments. */
802 while ((p
= strchr (p
, '$')))
804 if (startswith (p
, "$arg")
805 && (isdigit (p
[4]) || p
[4] == 'c'))
812 /* Insert the user defined arguments stored in user_arg into the $arg
813 arguments found in line, with the updated copy being placed into
817 insert_args (char *line
)
819 char *p
, *save_line
, *new_line
;
822 /* If we are not in a user-defined function, treat $argc, $arg0, et
823 cetera as normal convenience variables. */
824 if (user_args
== NULL
)
825 return xstrdup (line
);
827 /* First we need to know how much memory to allocate for the new
831 while ((p
= locate_arg (line
)))
838 /* $argc. Number will be <=10. */
839 len
+= user_args
->count
== 10 ? 2 : 1;
841 else if (i
>= user_args
->count
)
843 error (_("Missing argument %d in user function."), i
);
848 len
+= user_args
->a
[i
].len
;
853 /* Don't forget the tail. */
854 len
+= strlen (line
);
856 /* Allocate space for the new line and fill it in. */
857 new_line
= (char *) xmalloc (len
+ 1);
858 if (new_line
== NULL
)
861 /* Restore pointer to beginning of old line. */
864 /* Save pointer to beginning of new line. */
865 save_line
= new_line
;
867 while ((p
= locate_arg (line
)))
871 memcpy (new_line
, line
, p
- line
);
872 new_line
+= p
- line
;
876 gdb_assert (user_args
->count
>= 0 && user_args
->count
<= 10);
877 if (user_args
->count
== 10)
883 *(new_line
++) = user_args
->count
+ '0';
888 len
= user_args
->a
[i
].len
;
891 memcpy (new_line
, user_args
->a
[i
].arg
, len
);
897 /* Don't forget the tail. */
898 strcpy (new_line
, line
);
900 /* Return a pointer to the beginning of the new line. */
905 /* Expand the body_list of COMMAND so that it can hold NEW_LENGTH
906 code bodies. This is typically used when we encounter an "else"
907 clause for an "if" command. */
910 realloc_body_list (struct command_line
*command
, int new_length
)
913 struct command_line
**body_list
;
915 n
= command
->body_count
;
921 body_list
= (struct command_line
**)
922 xmalloc (sizeof (struct command_line
*) * new_length
);
924 memcpy (body_list
, command
->body_list
, sizeof (struct command_line
*) * n
);
925 memset (body_list
+ n
, 0, sizeof (struct command_line
*) * (new_length
- n
));
927 xfree (command
->body_list
);
928 command
->body_list
= body_list
;
929 command
->body_count
= new_length
;
932 /* Read next line from stdout. Passed to read_command_line_1 and
933 recurse_read_control_structure whenever we need to read commands
937 read_next_line (void)
939 char *prompt_ptr
, control_prompt
[256];
942 if (control_level
>= 254)
943 error (_("Control nesting too deep!"));
945 /* Set a prompt based on the nesting of the control commands. */
946 if (instream
== stdin
|| (instream
== 0 && deprecated_readline_hook
!= NULL
))
948 for (i
= 0; i
< control_level
; i
++)
949 control_prompt
[i
] = ' ';
950 control_prompt
[i
] = '>';
951 control_prompt
[i
+ 1] = '\0';
952 prompt_ptr
= (char *) &control_prompt
[0];
957 return command_line_input (prompt_ptr
, instream
== stdin
, "commands");
960 /* Process one input line. If the command is an "end", return such an
961 indication to the caller. If PARSE_COMMANDS is true, strip leading
962 whitespace (trailing whitespace is always stripped) in the line,
963 attempt to recognize GDB control commands, and also return an
964 indication if the command is an "else" or a nop.
966 Otherwise, only "end" is recognized. */
968 static enum misc_command_type
969 process_next_line (char *p
, struct command_line
**command
, int parse_commands
,
970 void (*validator
)(char *, void *), void *closure
)
976 /* Not sure what to do here. */
980 /* Strip trailing whitespace. */
981 p_end
= p
+ strlen (p
);
982 while (p_end
> p
&& (p_end
[-1] == ' ' || p_end
[-1] == '\t'))
986 /* Strip leading whitespace. */
987 while (p_start
< p_end
&& (*p_start
== ' ' || *p_start
== '\t'))
990 /* 'end' is always recognized, regardless of parse_commands value.
991 We also permit whitespace before end and after. */
992 if (p_end
- p_start
== 3 && startswith (p_start
, "end"))
997 /* If commands are parsed, we skip initial spaces. Otherwise,
998 which is the case for Python commands and documentation
999 (see the 'document' command), spaces are preserved. */
1002 /* Blanks and comments don't really do anything, but we need to
1003 distinguish them from else, end and other commands which can
1005 if (p_end
== p
|| p
[0] == '#')
1008 /* Is the else clause of an if control structure? */
1009 if (p_end
- p
== 4 && startswith (p
, "else"))
1010 return else_command
;
1012 /* Check for while, if, break, continue, etc and build a new
1013 command line structure for them. */
1014 if ((p_end
- p
>= 14 && startswith (p
, "while-stepping"))
1015 || (p_end
- p
>= 8 && startswith (p
, "stepping"))
1016 || (p_end
- p
>= 2 && startswith (p
, "ws")))
1018 /* Because validate_actionline and encode_action lookup
1019 command's line as command, we need the line to
1020 include 'while-stepping'.
1022 For 'ws' alias, the command will have 'ws', not expanded
1023 to 'while-stepping'. This is intentional -- we don't
1024 really want frontend to send a command list with 'ws',
1025 and next break-info returning command line with
1026 'while-stepping'. This should work, but might cause the
1027 breakpoint to be marked as changed while it's actually
1029 *command
= build_command_line (while_stepping_control
, p
);
1031 else if (p_end
- p
> 5 && startswith (p
, "while"))
1036 while (first_arg
< p_end
&& isspace (*first_arg
))
1038 *command
= build_command_line (while_control
, first_arg
);
1040 else if (p_end
- p
> 2 && startswith (p
, "if"))
1045 while (first_arg
< p_end
&& isspace (*first_arg
))
1047 *command
= build_command_line (if_control
, first_arg
);
1049 else if (p_end
- p
>= 8 && startswith (p
, "commands"))
1054 while (first_arg
< p_end
&& isspace (*first_arg
))
1056 *command
= build_command_line (commands_control
, first_arg
);
1058 else if (p_end
- p
== 6 && startswith (p
, "python"))
1060 /* Note that we ignore the inline "python command" form
1062 *command
= build_command_line (python_control
, "");
1064 else if (p_end
- p
== 6 && startswith (p
, "compile"))
1066 /* Note that we ignore the inline "compile command" form
1068 *command
= build_command_line (compile_control
, "");
1069 (*command
)->control_u
.compile
.scope
= COMPILE_I_INVALID_SCOPE
;
1072 else if (p_end
- p
== 5 && startswith (p
, "guile"))
1074 /* Note that we ignore the inline "guile command" form here. */
1075 *command
= build_command_line (guile_control
, "");
1077 else if (p_end
- p
== 10 && startswith (p
, "loop_break"))
1079 *command
= (struct command_line
*)
1080 xmalloc (sizeof (struct command_line
));
1081 (*command
)->next
= NULL
;
1082 (*command
)->line
= NULL
;
1083 (*command
)->control_type
= break_control
;
1084 (*command
)->body_count
= 0;
1085 (*command
)->body_list
= NULL
;
1087 else if (p_end
- p
== 13 && startswith (p
, "loop_continue"))
1089 *command
= (struct command_line
*)
1090 xmalloc (sizeof (struct command_line
));
1091 (*command
)->next
= NULL
;
1092 (*command
)->line
= NULL
;
1093 (*command
)->control_type
= continue_control
;
1094 (*command
)->body_count
= 0;
1095 (*command
)->body_list
= NULL
;
1101 if (!parse_commands
|| not_handled
)
1103 /* A normal command. */
1104 *command
= (struct command_line
*)
1105 xmalloc (sizeof (struct command_line
));
1106 (*command
)->next
= NULL
;
1107 (*command
)->line
= savestring (p
, p_end
- p
);
1108 (*command
)->control_type
= simple_control
;
1109 (*command
)->body_count
= 0;
1110 (*command
)->body_list
= NULL
;
1118 validator ((*command
)->line
, closure
);
1120 CATCH (ex
, RETURN_MASK_ALL
)
1123 throw_exception (ex
);
1128 /* Nothing special. */
1132 /* Recursively read in the control structures and create a
1133 command_line structure from them. Use read_next_line_func to
1134 obtain lines of the command. */
1136 static enum command_control_type
1137 recurse_read_control_structure (char * (*read_next_line_func
) (void),
1138 struct command_line
*current_cmd
,
1139 void (*validator
)(char *, void *),
1142 int current_body
, i
;
1143 enum misc_command_type val
;
1144 enum command_control_type ret
;
1145 struct command_line
**body_ptr
, *child_tail
, *next
;
1150 /* Sanity checks. */
1151 if (current_cmd
->control_type
== simple_control
)
1152 error (_("Recursed on a simple control type."));
1154 if (current_body
> current_cmd
->body_count
)
1155 error (_("Allocated body is smaller than this command type needs."));
1157 /* Read lines from the input stream and build control structures. */
1163 val
= process_next_line (read_next_line_func (), &next
,
1164 current_cmd
->control_type
!= python_control
1165 && current_cmd
->control_type
!= guile_control
1166 && current_cmd
->control_type
!= compile_control
,
1167 validator
, closure
);
1169 /* Just skip blanks and comments. */
1170 if (val
== nop_command
)
1173 if (val
== end_command
)
1175 if (multi_line_command_p (current_cmd
->control_type
))
1177 /* Success reading an entire canned sequence of commands. */
1178 ret
= simple_control
;
1183 ret
= invalid_control
;
1188 /* Not the end of a control structure. */
1189 if (val
== else_command
)
1191 if (current_cmd
->control_type
== if_control
1192 && current_body
== 1)
1194 realloc_body_list (current_cmd
, 2);
1201 ret
= invalid_control
;
1208 child_tail
->next
= next
;
1212 body_ptr
= current_cmd
->body_list
;
1213 for (i
= 1; i
< current_body
; i
++)
1222 /* If the latest line is another control structure, then recurse
1224 if (multi_line_command_p (next
->control_type
))
1227 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1228 validator
, closure
);
1231 if (ret
!= simple_control
)
1242 restore_interp (void *arg
)
1244 interp_set_temp (interp_name ((struct interp
*)arg
));
1247 /* Read lines from the input stream and accumulate them in a chain of
1248 struct command_line's, which is then returned. For input from a
1249 terminal, the special command "end" is used to mark the end of the
1250 input, and is not included in the returned chain of commands.
1252 If PARSE_COMMANDS is true, strip leading whitespace (trailing whitespace
1253 is always stripped) in the line and attempt to recognize GDB control
1254 commands. Otherwise, only "end" is recognized. */
1256 #define END_MESSAGE "End with a line saying just \"end\"."
1258 struct command_line
*
1259 read_command_lines (char *prompt_arg
, int from_tty
, int parse_commands
,
1260 void (*validator
)(char *, void *), void *closure
)
1262 struct command_line
*head
;
1264 if (from_tty
&& input_from_terminal_p ())
1266 if (deprecated_readline_begin_hook
)
1268 /* Note - intentional to merge messages with no newline. */
1269 (*deprecated_readline_begin_hook
) ("%s %s\n", prompt_arg
,
1274 printf_unfiltered ("%s\n%s\n", prompt_arg
, END_MESSAGE
);
1275 gdb_flush (gdb_stdout
);
1280 /* Reading commands assumes the CLI behavior, so temporarily
1281 override the current interpreter with CLI. */
1282 if (current_interp_named_p (INTERP_CONSOLE
))
1283 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1284 validator
, closure
);
1287 struct interp
*old_interp
= interp_set_temp (INTERP_CONSOLE
);
1288 struct cleanup
*old_chain
= make_cleanup (restore_interp
, old_interp
);
1290 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1291 validator
, closure
);
1292 do_cleanups (old_chain
);
1295 if (deprecated_readline_end_hook
&& from_tty
&& input_from_terminal_p ())
1297 (*deprecated_readline_end_hook
) ();
1302 /* Act the same way as read_command_lines, except that each new line is
1303 obtained using READ_NEXT_LINE_FUNC. */
1305 struct command_line
*
1306 read_command_lines_1 (char * (*read_next_line_func
) (void), int parse_commands
,
1307 void (*validator
)(char *, void *), void *closure
)
1309 struct command_line
*head
, *tail
, *next
;
1310 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1311 enum command_control_type ret
;
1312 enum misc_command_type val
;
1320 val
= process_next_line (read_next_line_func (), &next
, parse_commands
,
1321 validator
, closure
);
1323 /* Ignore blank lines or comments. */
1324 if (val
== nop_command
)
1327 if (val
== end_command
)
1329 ret
= simple_control
;
1333 if (val
!= ok_command
)
1335 ret
= invalid_control
;
1339 if (multi_line_command_p (next
->control_type
))
1342 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1343 validator
, closure
);
1346 if (ret
== invalid_control
)
1357 make_cleanup_free_command_lines (&head
);
1364 if (ret
!= invalid_control
)
1365 discard_cleanups (old_chain
);
1367 do_cleanups (old_chain
);
1372 /* Free a chain of struct command_line's. */
1375 free_command_lines (struct command_line
**lptr
)
1377 struct command_line
*l
= *lptr
;
1378 struct command_line
*next
;
1379 struct command_line
**blist
;
1384 if (l
->body_count
> 0)
1386 blist
= l
->body_list
;
1387 for (i
= 0; i
< l
->body_count
; i
++, blist
++)
1388 free_command_lines (blist
);
1399 do_free_command_lines_cleanup (void *arg
)
1401 free_command_lines (arg
);
1405 make_cleanup_free_command_lines (struct command_line
**arg
)
1407 return make_cleanup (do_free_command_lines_cleanup
, arg
);
1410 struct command_line
*
1411 copy_command_lines (struct command_line
*cmds
)
1413 struct command_line
*result
= NULL
;
1417 result
= (struct command_line
*) xmalloc (sizeof (struct command_line
));
1419 result
->next
= copy_command_lines (cmds
->next
);
1420 result
->line
= xstrdup (cmds
->line
);
1421 result
->control_type
= cmds
->control_type
;
1422 result
->body_count
= cmds
->body_count
;
1423 if (cmds
->body_count
> 0)
1427 result
->body_list
= (struct command_line
**)
1428 xmalloc (sizeof (struct command_line
*) * cmds
->body_count
);
1430 for (i
= 0; i
< cmds
->body_count
; i
++)
1431 result
->body_list
[i
] = copy_command_lines (cmds
->body_list
[i
]);
1434 result
->body_list
= NULL
;
1440 /* Validate that *COMNAME is a valid name for a command. Return the
1441 containing command list, in case it starts with a prefix command.
1442 The prefix must already exist. *COMNAME is advanced to point after
1443 any prefix, and a NUL character overwrites the space after the
1446 static struct cmd_list_element
**
1447 validate_comname (char **comname
)
1449 struct cmd_list_element
**list
= &cmdlist
;
1450 char *p
, *last_word
;
1453 error_no_arg (_("name of command to define"));
1455 /* Find the last word of the argument. */
1456 p
= *comname
+ strlen (*comname
);
1457 while (p
> *comname
&& isspace (p
[-1]))
1459 while (p
> *comname
&& !isspace (p
[-1]))
1463 /* Find the corresponding command list. */
1464 if (last_word
!= *comname
)
1466 struct cmd_list_element
*c
;
1468 const char *tem
= *comname
;
1470 /* Separate the prefix and the command. */
1471 saved_char
= last_word
[-1];
1472 last_word
[-1] = '\0';
1474 c
= lookup_cmd (&tem
, cmdlist
, "", 0, 1);
1475 if (c
->prefixlist
== NULL
)
1476 error (_("\"%s\" is not a prefix command."), *comname
);
1478 list
= c
->prefixlist
;
1479 last_word
[-1] = saved_char
;
1480 *comname
= last_word
;
1486 if (!isalnum (*p
) && *p
!= '-' && *p
!= '_')
1487 error (_("Junk in argument list: \"%s\""), p
);
1494 /* This is just a placeholder in the command data structures. */
1496 user_defined_command (char *ignore
, int from_tty
)
1501 define_command (char *comname
, int from_tty
)
1503 #define MAX_TMPBUF 128
1510 struct command_line
*cmds
;
1511 struct cmd_list_element
*c
, *newc
, *hookc
= 0, **list
;
1512 char *tem
, *comfull
;
1514 char tmpbuf
[MAX_TMPBUF
];
1515 int hook_type
= CMD_NO_HOOK
;
1516 int hook_name_size
= 0;
1518 #define HOOK_STRING "hook-"
1520 #define HOOK_POST_STRING "hookpost-"
1521 #define HOOK_POST_LEN 9
1524 list
= validate_comname (&comname
);
1526 /* Look it up, and verify that we got an exact match. */
1528 c
= lookup_cmd (&tem_c
, *list
, "", -1, 1);
1529 if (c
&& strcmp (comname
, c
->name
) != 0)
1536 if (c
->theclass
== class_user
|| c
->theclass
== class_alias
)
1537 q
= query (_("Redefine command \"%s\"? "), c
->name
);
1539 q
= query (_("Really redefine built-in command \"%s\"? "), c
->name
);
1541 error (_("Command \"%s\" not redefined."), c
->name
);
1544 /* If this new command is a hook, then mark the command which it
1545 is hooking. Note that we allow hooking `help' commands, so that
1546 we can hook the `stop' pseudo-command. */
1548 if (!strncmp (comname
, HOOK_STRING
, HOOK_LEN
))
1550 hook_type
= CMD_PRE_HOOK
;
1551 hook_name_size
= HOOK_LEN
;
1553 else if (!strncmp (comname
, HOOK_POST_STRING
, HOOK_POST_LEN
))
1555 hook_type
= CMD_POST_HOOK
;
1556 hook_name_size
= HOOK_POST_LEN
;
1559 if (hook_type
!= CMD_NO_HOOK
)
1561 /* Look up cmd it hooks, and verify that we got an exact match. */
1562 tem_c
= comname
+ hook_name_size
;
1563 hookc
= lookup_cmd (&tem_c
, *list
, "", -1, 0);
1564 if (hookc
&& strcmp (comname
+ hook_name_size
, hookc
->name
) != 0)
1568 warning (_("Your new `%s' command does not "
1569 "hook any existing command."),
1571 if (!query (_("Proceed? ")))
1572 error (_("Not confirmed."));
1576 comname
= xstrdup (comname
);
1578 /* If the rest of the commands will be case insensitive, this one
1579 should behave in the same manner. */
1580 for (tem
= comname
; *tem
; tem
++)
1582 *tem
= tolower (*tem
);
1584 xsnprintf (tmpbuf
, sizeof (tmpbuf
),
1585 "Type commands for definition of \"%s\".", comfull
);
1586 cmds
= read_command_lines (tmpbuf
, from_tty
, 1, 0, 0);
1588 if (c
&& c
->theclass
== class_user
)
1589 free_command_lines (&c
->user_commands
);
1591 newc
= add_cmd (comname
, class_user
, user_defined_command
,
1592 (c
&& c
->theclass
== class_user
)
1593 ? c
->doc
: xstrdup ("User-defined."), list
);
1594 newc
->user_commands
= cmds
;
1596 /* If this new command is a hook, then mark both commands as being
1603 hookc
->hook_pre
= newc
; /* Target gets hooked. */
1604 newc
->hookee_pre
= hookc
; /* We are marked as hooking target cmd. */
1607 hookc
->hook_post
= newc
; /* Target gets hooked. */
1608 newc
->hookee_post
= hookc
; /* We are marked as hooking
1612 /* Should never come here as hookc would be 0. */
1613 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1619 document_command (char *comname
, int from_tty
)
1621 struct command_line
*doclines
;
1622 struct cmd_list_element
*c
, **list
;
1628 list
= validate_comname (&comname
);
1631 c
= lookup_cmd (&tem
, *list
, "", 0, 1);
1633 if (c
->theclass
!= class_user
)
1634 error (_("Command \"%s\" is built-in."), comfull
);
1636 xsnprintf (tmpbuf
, sizeof (tmpbuf
), "Type documentation for \"%s\".",
1638 doclines
= read_command_lines (tmpbuf
, from_tty
, 0, 0, 0);
1641 xfree ((char *) c
->doc
);
1644 struct command_line
*cl1
;
1648 for (cl1
= doclines
; cl1
; cl1
= cl1
->next
)
1649 len
+= strlen (cl1
->line
) + 1;
1651 doc
= (char *) xmalloc (len
+ 1);
1654 for (cl1
= doclines
; cl1
; cl1
= cl1
->next
)
1656 strcat (doc
, cl1
->line
);
1664 free_command_lines (&doclines
);
1667 struct source_cleanup_lines_args
1670 const char *old_file
;
1674 source_cleanup_lines (void *args
)
1676 struct source_cleanup_lines_args
*p
=
1677 (struct source_cleanup_lines_args
*) args
;
1679 source_line_number
= p
->old_line
;
1680 source_file_name
= p
->old_file
;
1683 /* Used to implement source_command. */
1686 script_from_file (FILE *stream
, const char *file
)
1688 struct cleanup
*old_cleanups
;
1689 struct source_cleanup_lines_args old_lines
;
1692 internal_error (__FILE__
, __LINE__
, _("called with NULL file pointer!"));
1694 old_lines
.old_line
= source_line_number
;
1695 old_lines
.old_file
= source_file_name
;
1696 old_cleanups
= make_cleanup (source_cleanup_lines
, &old_lines
);
1697 source_line_number
= 0;
1698 source_file_name
= file
;
1700 make_cleanup_restore_integer (&interpreter_async
);
1701 interpreter_async
= 0;
1707 read_command_file (stream
);
1709 CATCH (e
, RETURN_MASK_ERROR
)
1711 /* Re-throw the error, but with the file name information
1713 throw_error (e
.error
,
1714 _("%s:%d: Error in sourced command file:\n%s"),
1715 source_file_name
, source_line_number
, e
.message
);
1720 do_cleanups (old_cleanups
);
1723 /* Print the definition of user command C to STREAM. Or, if C is a
1724 prefix command, show the definitions of all user commands under C
1725 (recursively). PREFIX and NAME combined are the name of the
1728 show_user_1 (struct cmd_list_element
*c
, const char *prefix
, const char *name
,
1729 struct ui_file
*stream
)
1731 struct command_line
*cmdlines
;
1733 if (c
->prefixlist
!= NULL
)
1735 const char *prefixname
= c
->prefixname
;
1737 for (c
= *c
->prefixlist
; c
!= NULL
; c
= c
->next
)
1738 if (c
->theclass
== class_user
|| c
->prefixlist
!= NULL
)
1739 show_user_1 (c
, prefixname
, c
->name
, gdb_stdout
);
1743 cmdlines
= c
->user_commands
;
1744 fprintf_filtered (stream
, "User command \"%s%s\":\n", prefix
, name
);
1748 print_command_lines (current_uiout
, cmdlines
, 1);
1749 fputs_filtered ("\n", stream
);
1754 initialize_file_ftype _initialize_cli_script
;
1757 _initialize_cli_script (void)
1759 add_com ("document", class_support
, document_command
, _("\
1760 Document a user-defined command.\n\
1761 Give command name as argument. Give documentation on following lines.\n\
1762 End with a line of just \"end\"."));
1763 add_com ("define", class_support
, define_command
, _("\
1764 Define a new command name. Command name is argument.\n\
1765 Definition appears on following lines, one command per line.\n\
1766 End with a line of just \"end\".\n\
1767 Use the \"document\" command to give documentation for the new command.\n\
1768 Commands defined in this way may have up to ten arguments."));
1770 add_com ("while", class_support
, while_command
, _("\
1771 Execute nested commands WHILE the conditional expression is non zero.\n\
1772 The conditional expression must follow the word `while' and must in turn be\n\
1773 followed by a new line. The nested commands must be entered one per line,\n\
1774 and should be terminated by the word `end'."));
1776 add_com ("if", class_support
, if_command
, _("\
1777 Execute nested commands once IF the conditional expression is non zero.\n\
1778 The conditional expression must follow the word `if' and must in turn be\n\
1779 followed by a new line. The nested commands must be entered one per line,\n\
1780 and should be terminated by the word 'else' or `end'. If an else clause\n\
1781 is used, the same rules apply to its nested commands as to the first ones."));