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 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 make_cleanup_restore_integer (¤t_ui
->async
);
384 current_ui
->async
= 0;
386 command_nest_depth
++;
389 ret
= execute_control_command (cmdlines
);
390 if (ret
!= simple_control
&& ret
!= break_control
)
392 warning (_("Error executing canned sequence of commands."));
395 cmdlines
= cmdlines
->next
;
397 command_nest_depth
--;
398 do_cleanups (old_chain
);
401 /* This function is called every time GDB prints a prompt. It ensures
402 that errors and the like do not confuse the command tracing. */
405 reset_command_nest_depth (void)
407 command_nest_depth
= 1;
410 suppress_next_print_command_trace
= 0;
413 /* Print the command, prefixed with '+' to represent the call depth.
414 This is slightly complicated because this function may be called
415 from execute_command and execute_control_command. Unfortunately
416 execute_command also prints the top level control commands.
417 In these cases execute_command will call execute_control_command
418 via while_command or if_command. Inner levels of 'if' and 'while'
419 are dealt with directly. Therefore we can use these functions
420 to determine whether the command has been printed already or not. */
422 print_command_trace (const char *cmd
)
426 if (suppress_next_print_command_trace
)
428 suppress_next_print_command_trace
= 0;
432 if (!source_verbose
&& !trace_commands
)
435 for (i
=0; i
< command_nest_depth
; i
++)
436 printf_filtered ("+");
438 printf_filtered ("%s\n", cmd
);
441 enum command_control_type
442 execute_control_command (struct command_line
*cmd
)
444 struct expression
*expr
;
445 struct command_line
*current
;
446 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, 0);
448 struct value
*val_mark
;
450 enum command_control_type ret
;
453 /* Start by assuming failure, if a problem is detected, the code
454 below will simply "break" out of the switch. */
455 ret
= invalid_control
;
457 switch (cmd
->control_type
)
460 /* A simple command, execute it and return. */
461 new_line
= insert_args (cmd
->line
);
464 make_cleanup (free_current_contents
, &new_line
);
465 execute_command (new_line
, 0);
466 ret
= cmd
->control_type
;
469 case continue_control
:
470 print_command_trace ("loop_continue");
472 /* Return for "continue", and "break" so we can either
473 continue the loop at the top, or break out. */
474 ret
= cmd
->control_type
;
478 print_command_trace ("loop_break");
480 /* Return for "continue", and "break" so we can either
481 continue the loop at the top, or break out. */
482 ret
= cmd
->control_type
;
487 int len
= strlen (cmd
->line
) + 7;
488 char *buffer
= (char *) alloca (len
);
490 xsnprintf (buffer
, len
, "while %s", cmd
->line
);
491 print_command_trace (buffer
);
493 /* Parse the loop control expression for the while statement. */
494 new_line
= insert_args (cmd
->line
);
497 make_cleanup (free_current_contents
, &new_line
);
498 expr
= parse_expression (new_line
);
499 make_cleanup (free_current_contents
, &expr
);
501 ret
= simple_control
;
504 /* Keep iterating so long as the expression is true. */
511 /* Evaluate the expression. */
512 val_mark
= value_mark ();
513 val
= evaluate_expression (expr
);
514 cond_result
= value_true (val
);
515 value_free_to_mark (val_mark
);
517 /* If the value is false, then break out of the loop. */
521 /* Execute the body of the while statement. */
522 current
= *cmd
->body_list
;
525 command_nest_depth
++;
526 ret
= execute_control_command (current
);
527 command_nest_depth
--;
529 /* If we got an error, or a "break" command, then stop
531 if (ret
== invalid_control
|| ret
== break_control
)
537 /* If we got a "continue" command, then restart the loop
539 if (ret
== continue_control
)
542 /* Get the next statement. */
543 current
= current
->next
;
547 /* Reset RET so that we don't recurse the break all the way down. */
548 if (ret
== break_control
)
549 ret
= simple_control
;
556 int len
= strlen (cmd
->line
) + 4;
557 char *buffer
= (char *) alloca (len
);
559 xsnprintf (buffer
, len
, "if %s", cmd
->line
);
560 print_command_trace (buffer
);
562 new_line
= insert_args (cmd
->line
);
565 make_cleanup (free_current_contents
, &new_line
);
566 /* Parse the conditional for the if statement. */
567 expr
= parse_expression (new_line
);
568 make_cleanup (free_current_contents
, &expr
);
571 ret
= simple_control
;
573 /* Evaluate the conditional. */
574 val_mark
= value_mark ();
575 val
= evaluate_expression (expr
);
577 /* Choose which arm to take commands from based on the value
578 of the conditional expression. */
579 if (value_true (val
))
580 current
= *cmd
->body_list
;
581 else if (cmd
->body_count
== 2)
582 current
= *(cmd
->body_list
+ 1);
583 value_free_to_mark (val_mark
);
585 /* Execute commands in the given arm. */
588 command_nest_depth
++;
589 ret
= execute_control_command (current
);
590 command_nest_depth
--;
592 /* If we got an error, get out. */
593 if (ret
!= simple_control
)
596 /* Get the next statement in the body. */
597 current
= current
->next
;
603 case commands_control
:
605 /* Breakpoint commands list, record the commands in the
606 breakpoint's command list and return. */
607 new_line
= insert_args (cmd
->line
);
610 make_cleanup (free_current_contents
, &new_line
);
611 ret
= commands_from_control_command (new_line
, cmd
);
615 case compile_control
:
616 eval_compile_command (cmd
, NULL
, cmd
->control_u
.compile
.scope
,
617 cmd
->control_u
.compile
.scope_data
);
618 ret
= simple_control
;
624 eval_ext_lang_from_control_command (cmd
);
625 ret
= simple_control
;
630 warning (_("Invalid control type in canned commands structure."));
634 do_cleanups (old_chain
);
639 /* Like execute_control_command, but first set
640 suppress_next_print_command_trace. */
642 enum command_control_type
643 execute_control_command_untraced (struct command_line
*cmd
)
645 suppress_next_print_command_trace
= 1;
646 return execute_control_command (cmd
);
650 /* "while" command support. Executes a body of statements while the
651 loop condition is nonzero. */
654 while_command (char *arg
, int from_tty
)
656 struct command_line
*command
= NULL
;
657 struct cleanup
*old_chain
;
660 command
= get_command_line (while_control
, arg
);
665 old_chain
= make_cleanup_restore_integer (¤t_ui
->async
);
666 current_ui
->async
= 0;
668 execute_control_command_untraced (command
);
669 free_command_lines (&command
);
671 do_cleanups (old_chain
);
674 /* "if" command support. Execute either the true or false arm depending
675 on the value of the if conditional. */
678 if_command (char *arg
, int from_tty
)
680 struct command_line
*command
= NULL
;
681 struct cleanup
*old_chain
;
684 command
= get_command_line (if_control
, arg
);
689 old_chain
= make_cleanup_restore_integer (¤t_ui
->async
);
690 current_ui
->async
= 0;
692 execute_control_command_untraced (command
);
693 free_command_lines (&command
);
695 do_cleanups (old_chain
);
700 arg_cleanup (void *ignore
)
702 struct user_args
*oargs
= user_args
;
705 internal_error (__FILE__
, __LINE__
,
706 _("arg_cleanup called with no user args.\n"));
708 user_args
= user_args
->next
;
709 xfree (oargs
->command
);
713 /* Bind the incomming arguments for a user defined command to
714 $arg0, $arg1 ... $argMAXUSERARGS. */
716 static struct cleanup
*
717 setup_user_args (char *p
)
719 struct user_args
*args
;
720 struct cleanup
*old_chain
;
721 unsigned int arg_count
= 0;
723 args
= XNEW (struct user_args
);
724 memset (args
, 0, sizeof (struct user_args
));
726 args
->next
= user_args
;
729 old_chain
= make_cleanup (arg_cleanup
, 0/*ignored*/);
734 user_args
->command
= p
= xstrdup (p
);
743 if (arg_count
>= MAXUSERARGS
)
744 error (_("user defined function may only have %d arguments."),
747 /* Strip whitespace. */
748 while (*p
== ' ' || *p
== '\t')
751 /* P now points to an argument. */
753 user_args
->a
[arg_count
].arg
= p
;
755 /* Get to the end of this argument. */
758 if (((*p
== ' ' || *p
== '\t')) && !squote
&& !dquote
&& !bsquote
)
787 user_args
->a
[arg_count
].len
= p
- start_arg
;
794 /* Given character string P, return a point to the first argument
795 ($arg), or NULL if P contains no arguments. */
800 while ((p
= strchr (p
, '$')))
802 if (startswith (p
, "$arg")
803 && (isdigit (p
[4]) || p
[4] == 'c'))
810 /* Insert the user defined arguments stored in user_arg into the $arg
811 arguments found in line, with the updated copy being placed into
815 insert_args (char *line
)
817 char *p
, *save_line
, *new_line
;
820 /* If we are not in a user-defined function, treat $argc, $arg0, et
821 cetera as normal convenience variables. */
822 if (user_args
== NULL
)
823 return xstrdup (line
);
825 /* First we need to know how much memory to allocate for the new
829 while ((p
= locate_arg (line
)))
836 /* $argc. Number will be <=10. */
837 len
+= user_args
->count
== 10 ? 2 : 1;
839 else if (i
>= user_args
->count
)
841 error (_("Missing argument %d in user function."), i
);
846 len
+= user_args
->a
[i
].len
;
851 /* Don't forget the tail. */
852 len
+= strlen (line
);
854 /* Allocate space for the new line and fill it in. */
855 new_line
= (char *) xmalloc (len
+ 1);
856 if (new_line
== NULL
)
859 /* Restore pointer to beginning of old line. */
862 /* Save pointer to beginning of new line. */
863 save_line
= new_line
;
865 while ((p
= locate_arg (line
)))
869 memcpy (new_line
, line
, p
- line
);
870 new_line
+= p
- line
;
874 gdb_assert (user_args
->count
>= 0 && user_args
->count
<= 10);
875 if (user_args
->count
== 10)
881 *(new_line
++) = user_args
->count
+ '0';
886 len
= user_args
->a
[i
].len
;
889 memcpy (new_line
, user_args
->a
[i
].arg
, len
);
895 /* Don't forget the tail. */
896 strcpy (new_line
, line
);
898 /* Return a pointer to the beginning of the new line. */
903 /* Expand the body_list of COMMAND so that it can hold NEW_LENGTH
904 code bodies. This is typically used when we encounter an "else"
905 clause for an "if" command. */
908 realloc_body_list (struct command_line
*command
, int new_length
)
911 struct command_line
**body_list
;
913 n
= command
->body_count
;
919 body_list
= XCNEWVEC (struct command_line
*, new_length
);
921 memcpy (body_list
, command
->body_list
, sizeof (struct command_line
*) * n
);
923 xfree (command
->body_list
);
924 command
->body_list
= body_list
;
925 command
->body_count
= new_length
;
928 /* Read next line from stdin. Passed to read_command_line_1 and
929 recurse_read_control_structure whenever we need to read commands
933 read_next_line (void)
935 struct ui
*ui
= current_ui
;
936 char *prompt_ptr
, control_prompt
[256];
938 int from_tty
= ui
->instream
== ui
->stdin_stream
;
940 if (control_level
>= 254)
941 error (_("Control nesting too deep!"));
943 /* Set a prompt based on the nesting of the control commands. */
945 || (ui
->instream
== 0 && deprecated_readline_hook
!= NULL
))
947 for (i
= 0; i
< control_level
; i
++)
948 control_prompt
[i
] = ' ';
949 control_prompt
[i
] = '>';
950 control_prompt
[i
+ 1] = '\0';
951 prompt_ptr
= (char *) &control_prompt
[0];
956 return command_line_input (prompt_ptr
, from_tty
, "commands");
959 /* Process one input line. If the command is an "end", return such an
960 indication to the caller. If PARSE_COMMANDS is true, strip leading
961 whitespace (trailing whitespace is always stripped) in the line,
962 attempt to recognize GDB control commands, and also return an
963 indication if the command is an "else" or a nop.
965 Otherwise, only "end" is recognized. */
967 static enum misc_command_type
968 process_next_line (char *p
, struct command_line
**command
, int parse_commands
,
969 void (*validator
)(char *, void *), void *closure
)
975 /* Not sure what to do here. */
979 /* Strip trailing whitespace. */
980 p_end
= p
+ strlen (p
);
981 while (p_end
> p
&& (p_end
[-1] == ' ' || p_end
[-1] == '\t'))
985 /* Strip leading whitespace. */
986 while (p_start
< p_end
&& (*p_start
== ' ' || *p_start
== '\t'))
989 /* 'end' is always recognized, regardless of parse_commands value.
990 We also permit whitespace before end and after. */
991 if (p_end
- p_start
== 3 && startswith (p_start
, "end"))
996 /* If commands are parsed, we skip initial spaces. Otherwise,
997 which is the case for Python commands and documentation
998 (see the 'document' command), spaces are preserved. */
1001 /* Blanks and comments don't really do anything, but we need to
1002 distinguish them from else, end and other commands which can
1004 if (p_end
== p
|| p
[0] == '#')
1007 /* Is the else clause of an if control structure? */
1008 if (p_end
- p
== 4 && startswith (p
, "else"))
1009 return else_command
;
1011 /* Check for while, if, break, continue, etc and build a new
1012 command line structure for them. */
1013 if ((p_end
- p
>= 14 && startswith (p
, "while-stepping"))
1014 || (p_end
- p
>= 8 && startswith (p
, "stepping"))
1015 || (p_end
- p
>= 2 && startswith (p
, "ws")))
1017 /* Because validate_actionline and encode_action lookup
1018 command's line as command, we need the line to
1019 include 'while-stepping'.
1021 For 'ws' alias, the command will have 'ws', not expanded
1022 to 'while-stepping'. This is intentional -- we don't
1023 really want frontend to send a command list with 'ws',
1024 and next break-info returning command line with
1025 'while-stepping'. This should work, but might cause the
1026 breakpoint to be marked as changed while it's actually
1028 *command
= build_command_line (while_stepping_control
, p
);
1030 else if (p_end
- p
> 5 && startswith (p
, "while"))
1035 while (first_arg
< p_end
&& isspace (*first_arg
))
1037 *command
= build_command_line (while_control
, first_arg
);
1039 else if (p_end
- p
> 2 && startswith (p
, "if"))
1044 while (first_arg
< p_end
&& isspace (*first_arg
))
1046 *command
= build_command_line (if_control
, first_arg
);
1048 else if (p_end
- p
>= 8 && startswith (p
, "commands"))
1053 while (first_arg
< p_end
&& isspace (*first_arg
))
1055 *command
= build_command_line (commands_control
, first_arg
);
1057 else if (p_end
- p
== 6 && startswith (p
, "python"))
1059 /* Note that we ignore the inline "python command" form
1061 *command
= build_command_line (python_control
, "");
1063 else if (p_end
- p
== 6 && startswith (p
, "compile"))
1065 /* Note that we ignore the inline "compile command" form
1067 *command
= build_command_line (compile_control
, "");
1068 (*command
)->control_u
.compile
.scope
= COMPILE_I_INVALID_SCOPE
;
1071 else if (p_end
- p
== 5 && startswith (p
, "guile"))
1073 /* Note that we ignore the inline "guile command" form here. */
1074 *command
= build_command_line (guile_control
, "");
1076 else if (p_end
- p
== 10 && startswith (p
, "loop_break"))
1078 *command
= XNEW (struct command_line
);
1079 (*command
)->next
= NULL
;
1080 (*command
)->line
= NULL
;
1081 (*command
)->control_type
= break_control
;
1082 (*command
)->body_count
= 0;
1083 (*command
)->body_list
= NULL
;
1085 else if (p_end
- p
== 13 && startswith (p
, "loop_continue"))
1087 *command
= XNEW (struct command_line
);
1088 (*command
)->next
= NULL
;
1089 (*command
)->line
= NULL
;
1090 (*command
)->control_type
= continue_control
;
1091 (*command
)->body_count
= 0;
1092 (*command
)->body_list
= NULL
;
1098 if (!parse_commands
|| not_handled
)
1100 /* A normal command. */
1101 *command
= XNEW (struct command_line
);
1102 (*command
)->next
= NULL
;
1103 (*command
)->line
= savestring (p
, p_end
- p
);
1104 (*command
)->control_type
= simple_control
;
1105 (*command
)->body_count
= 0;
1106 (*command
)->body_list
= NULL
;
1114 validator ((*command
)->line
, closure
);
1116 CATCH (ex
, RETURN_MASK_ALL
)
1119 throw_exception (ex
);
1124 /* Nothing special. */
1128 /* Recursively read in the control structures and create a
1129 command_line structure from them. Use read_next_line_func to
1130 obtain lines of the command. */
1132 static enum command_control_type
1133 recurse_read_control_structure (char * (*read_next_line_func
) (void),
1134 struct command_line
*current_cmd
,
1135 void (*validator
)(char *, void *),
1138 int current_body
, i
;
1139 enum misc_command_type val
;
1140 enum command_control_type ret
;
1141 struct command_line
**body_ptr
, *child_tail
, *next
;
1146 /* Sanity checks. */
1147 if (current_cmd
->control_type
== simple_control
)
1148 error (_("Recursed on a simple control type."));
1150 if (current_body
> current_cmd
->body_count
)
1151 error (_("Allocated body is smaller than this command type needs."));
1153 /* Read lines from the input stream and build control structures. */
1159 val
= process_next_line (read_next_line_func (), &next
,
1160 current_cmd
->control_type
!= python_control
1161 && current_cmd
->control_type
!= guile_control
1162 && current_cmd
->control_type
!= compile_control
,
1163 validator
, closure
);
1165 /* Just skip blanks and comments. */
1166 if (val
== nop_command
)
1169 if (val
== end_command
)
1171 if (multi_line_command_p (current_cmd
->control_type
))
1173 /* Success reading an entire canned sequence of commands. */
1174 ret
= simple_control
;
1179 ret
= invalid_control
;
1184 /* Not the end of a control structure. */
1185 if (val
== else_command
)
1187 if (current_cmd
->control_type
== if_control
1188 && current_body
== 1)
1190 realloc_body_list (current_cmd
, 2);
1197 ret
= invalid_control
;
1204 child_tail
->next
= next
;
1208 body_ptr
= current_cmd
->body_list
;
1209 for (i
= 1; i
< current_body
; i
++)
1218 /* If the latest line is another control structure, then recurse
1220 if (multi_line_command_p (next
->control_type
))
1223 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1224 validator
, closure
);
1227 if (ret
!= simple_control
)
1238 restore_interp (void *arg
)
1240 interp_set_temp (interp_name ((struct interp
*)arg
));
1243 /* Read lines from the input stream and accumulate them in a chain of
1244 struct command_line's, which is then returned. For input from a
1245 terminal, the special command "end" is used to mark the end of the
1246 input, and is not included in the returned chain of commands.
1248 If PARSE_COMMANDS is true, strip leading whitespace (trailing whitespace
1249 is always stripped) in the line and attempt to recognize GDB control
1250 commands. Otherwise, only "end" is recognized. */
1252 #define END_MESSAGE "End with a line saying just \"end\"."
1254 struct command_line
*
1255 read_command_lines (char *prompt_arg
, int from_tty
, int parse_commands
,
1256 void (*validator
)(char *, void *), void *closure
)
1258 struct command_line
*head
;
1260 if (from_tty
&& input_interactive_p (current_ui
))
1262 if (deprecated_readline_begin_hook
)
1264 /* Note - intentional to merge messages with no newline. */
1265 (*deprecated_readline_begin_hook
) ("%s %s\n", prompt_arg
,
1270 printf_unfiltered ("%s\n%s\n", prompt_arg
, END_MESSAGE
);
1271 gdb_flush (gdb_stdout
);
1276 /* Reading commands assumes the CLI behavior, so temporarily
1277 override the current interpreter with CLI. */
1278 if (current_interp_named_p (INTERP_CONSOLE
))
1279 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1280 validator
, closure
);
1283 struct interp
*old_interp
= interp_set_temp (INTERP_CONSOLE
);
1284 struct cleanup
*old_chain
= make_cleanup (restore_interp
, old_interp
);
1286 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1287 validator
, closure
);
1288 do_cleanups (old_chain
);
1291 if (from_tty
&& input_interactive_p (current_ui
)
1292 && deprecated_readline_end_hook
)
1294 (*deprecated_readline_end_hook
) ();
1299 /* Act the same way as read_command_lines, except that each new line is
1300 obtained using READ_NEXT_LINE_FUNC. */
1302 struct command_line
*
1303 read_command_lines_1 (char * (*read_next_line_func
) (void), int parse_commands
,
1304 void (*validator
)(char *, void *), void *closure
)
1306 struct command_line
*head
, *tail
, *next
;
1307 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1308 enum command_control_type ret
;
1309 enum misc_command_type val
;
1317 val
= process_next_line (read_next_line_func (), &next
, parse_commands
,
1318 validator
, closure
);
1320 /* Ignore blank lines or comments. */
1321 if (val
== nop_command
)
1324 if (val
== end_command
)
1326 ret
= simple_control
;
1330 if (val
!= ok_command
)
1332 ret
= invalid_control
;
1336 if (multi_line_command_p (next
->control_type
))
1339 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1340 validator
, closure
);
1343 if (ret
== invalid_control
)
1354 make_cleanup_free_command_lines (&head
);
1361 if (ret
!= invalid_control
)
1362 discard_cleanups (old_chain
);
1364 do_cleanups (old_chain
);
1369 /* Free a chain of struct command_line's. */
1372 free_command_lines (struct command_line
**lptr
)
1374 struct command_line
*l
= *lptr
;
1375 struct command_line
*next
;
1376 struct command_line
**blist
;
1381 if (l
->body_count
> 0)
1383 blist
= l
->body_list
;
1384 for (i
= 0; i
< l
->body_count
; i
++, blist
++)
1385 free_command_lines (blist
);
1396 do_free_command_lines_cleanup (void *arg
)
1398 free_command_lines ((struct command_line
**) arg
);
1402 make_cleanup_free_command_lines (struct command_line
**arg
)
1404 return make_cleanup (do_free_command_lines_cleanup
, arg
);
1407 struct command_line
*
1408 copy_command_lines (struct command_line
*cmds
)
1410 struct command_line
*result
= NULL
;
1414 result
= XNEW (struct command_line
);
1416 result
->next
= copy_command_lines (cmds
->next
);
1417 result
->line
= xstrdup (cmds
->line
);
1418 result
->control_type
= cmds
->control_type
;
1419 result
->body_count
= cmds
->body_count
;
1420 if (cmds
->body_count
> 0)
1424 result
->body_list
= XNEWVEC (struct command_line
*, cmds
->body_count
);
1426 for (i
= 0; i
< cmds
->body_count
; i
++)
1427 result
->body_list
[i
] = copy_command_lines (cmds
->body_list
[i
]);
1430 result
->body_list
= NULL
;
1436 /* Validate that *COMNAME is a valid name for a command. Return the
1437 containing command list, in case it starts with a prefix command.
1438 The prefix must already exist. *COMNAME is advanced to point after
1439 any prefix, and a NUL character overwrites the space after the
1442 static struct cmd_list_element
**
1443 validate_comname (char **comname
)
1445 struct cmd_list_element
**list
= &cmdlist
;
1446 char *p
, *last_word
;
1449 error_no_arg (_("name of command to define"));
1451 /* Find the last word of the argument. */
1452 p
= *comname
+ strlen (*comname
);
1453 while (p
> *comname
&& isspace (p
[-1]))
1455 while (p
> *comname
&& !isspace (p
[-1]))
1459 /* Find the corresponding command list. */
1460 if (last_word
!= *comname
)
1462 struct cmd_list_element
*c
;
1464 const char *tem
= *comname
;
1466 /* Separate the prefix and the command. */
1467 saved_char
= last_word
[-1];
1468 last_word
[-1] = '\0';
1470 c
= lookup_cmd (&tem
, cmdlist
, "", 0, 1);
1471 if (c
->prefixlist
== NULL
)
1472 error (_("\"%s\" is not a prefix command."), *comname
);
1474 list
= c
->prefixlist
;
1475 last_word
[-1] = saved_char
;
1476 *comname
= last_word
;
1482 if (!isalnum (*p
) && *p
!= '-' && *p
!= '_')
1483 error (_("Junk in argument list: \"%s\""), p
);
1490 /* This is just a placeholder in the command data structures. */
1492 user_defined_command (char *ignore
, int from_tty
)
1497 define_command (char *comname
, int from_tty
)
1499 #define MAX_TMPBUF 128
1506 struct command_line
*cmds
;
1507 struct cmd_list_element
*c
, *newc
, *hookc
= 0, **list
;
1508 char *tem
, *comfull
;
1510 char tmpbuf
[MAX_TMPBUF
];
1511 int hook_type
= CMD_NO_HOOK
;
1512 int hook_name_size
= 0;
1514 #define HOOK_STRING "hook-"
1516 #define HOOK_POST_STRING "hookpost-"
1517 #define HOOK_POST_LEN 9
1520 list
= validate_comname (&comname
);
1522 /* Look it up, and verify that we got an exact match. */
1524 c
= lookup_cmd (&tem_c
, *list
, "", -1, 1);
1525 if (c
&& strcmp (comname
, c
->name
) != 0)
1532 if (c
->theclass
== class_user
|| c
->theclass
== class_alias
)
1533 q
= query (_("Redefine command \"%s\"? "), c
->name
);
1535 q
= query (_("Really redefine built-in command \"%s\"? "), c
->name
);
1537 error (_("Command \"%s\" not redefined."), c
->name
);
1540 /* If this new command is a hook, then mark the command which it
1541 is hooking. Note that we allow hooking `help' commands, so that
1542 we can hook the `stop' pseudo-command. */
1544 if (!strncmp (comname
, HOOK_STRING
, HOOK_LEN
))
1546 hook_type
= CMD_PRE_HOOK
;
1547 hook_name_size
= HOOK_LEN
;
1549 else if (!strncmp (comname
, HOOK_POST_STRING
, HOOK_POST_LEN
))
1551 hook_type
= CMD_POST_HOOK
;
1552 hook_name_size
= HOOK_POST_LEN
;
1555 if (hook_type
!= CMD_NO_HOOK
)
1557 /* Look up cmd it hooks, and verify that we got an exact match. */
1558 tem_c
= comname
+ hook_name_size
;
1559 hookc
= lookup_cmd (&tem_c
, *list
, "", -1, 0);
1560 if (hookc
&& strcmp (comname
+ hook_name_size
, hookc
->name
) != 0)
1564 warning (_("Your new `%s' command does not "
1565 "hook any existing command."),
1567 if (!query (_("Proceed? ")))
1568 error (_("Not confirmed."));
1572 comname
= xstrdup (comname
);
1574 /* If the rest of the commands will be case insensitive, this one
1575 should behave in the same manner. */
1576 for (tem
= comname
; *tem
; tem
++)
1578 *tem
= tolower (*tem
);
1580 xsnprintf (tmpbuf
, sizeof (tmpbuf
),
1581 "Type commands for definition of \"%s\".", comfull
);
1582 cmds
= read_command_lines (tmpbuf
, from_tty
, 1, 0, 0);
1584 if (c
&& c
->theclass
== class_user
)
1585 free_command_lines (&c
->user_commands
);
1587 newc
= add_cmd (comname
, class_user
, user_defined_command
,
1588 (c
&& c
->theclass
== class_user
)
1589 ? c
->doc
: xstrdup ("User-defined."), list
);
1590 newc
->user_commands
= cmds
;
1592 /* If this new command is a hook, then mark both commands as being
1599 hookc
->hook_pre
= newc
; /* Target gets hooked. */
1600 newc
->hookee_pre
= hookc
; /* We are marked as hooking target cmd. */
1603 hookc
->hook_post
= newc
; /* Target gets hooked. */
1604 newc
->hookee_post
= hookc
; /* We are marked as hooking
1608 /* Should never come here as hookc would be 0. */
1609 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1615 document_command (char *comname
, int from_tty
)
1617 struct command_line
*doclines
;
1618 struct cmd_list_element
*c
, **list
;
1624 list
= validate_comname (&comname
);
1627 c
= lookup_cmd (&tem
, *list
, "", 0, 1);
1629 if (c
->theclass
!= class_user
)
1630 error (_("Command \"%s\" is built-in."), comfull
);
1632 xsnprintf (tmpbuf
, sizeof (tmpbuf
), "Type documentation for \"%s\".",
1634 doclines
= read_command_lines (tmpbuf
, from_tty
, 0, 0, 0);
1637 xfree ((char *) c
->doc
);
1640 struct command_line
*cl1
;
1644 for (cl1
= doclines
; cl1
; cl1
= cl1
->next
)
1645 len
+= strlen (cl1
->line
) + 1;
1647 doc
= (char *) xmalloc (len
+ 1);
1650 for (cl1
= doclines
; cl1
; cl1
= cl1
->next
)
1652 strcat (doc
, cl1
->line
);
1660 free_command_lines (&doclines
);
1663 struct source_cleanup_lines_args
1666 const char *old_file
;
1670 source_cleanup_lines (void *args
)
1672 struct source_cleanup_lines_args
*p
=
1673 (struct source_cleanup_lines_args
*) args
;
1675 source_line_number
= p
->old_line
;
1676 source_file_name
= p
->old_file
;
1679 /* Used to implement source_command. */
1682 script_from_file (FILE *stream
, const char *file
)
1684 struct cleanup
*old_cleanups
;
1685 struct source_cleanup_lines_args old_lines
;
1688 internal_error (__FILE__
, __LINE__
, _("called with NULL file pointer!"));
1690 old_lines
.old_line
= source_line_number
;
1691 old_lines
.old_file
= source_file_name
;
1692 old_cleanups
= make_cleanup (source_cleanup_lines
, &old_lines
);
1693 source_line_number
= 0;
1694 source_file_name
= file
;
1696 make_cleanup_restore_integer (¤t_ui
->async
);
1697 current_ui
->async
= 0;
1703 read_command_file (stream
);
1705 CATCH (e
, RETURN_MASK_ERROR
)
1707 /* Re-throw the error, but with the file name information
1709 throw_error (e
.error
,
1710 _("%s:%d: Error in sourced command file:\n%s"),
1711 source_file_name
, source_line_number
, e
.message
);
1716 do_cleanups (old_cleanups
);
1719 /* Print the definition of user command C to STREAM. Or, if C is a
1720 prefix command, show the definitions of all user commands under C
1721 (recursively). PREFIX and NAME combined are the name of the
1724 show_user_1 (struct cmd_list_element
*c
, const char *prefix
, const char *name
,
1725 struct ui_file
*stream
)
1727 struct command_line
*cmdlines
;
1729 if (c
->prefixlist
!= NULL
)
1731 const char *prefixname
= c
->prefixname
;
1733 for (c
= *c
->prefixlist
; c
!= NULL
; c
= c
->next
)
1734 if (c
->theclass
== class_user
|| c
->prefixlist
!= NULL
)
1735 show_user_1 (c
, prefixname
, c
->name
, gdb_stdout
);
1739 cmdlines
= c
->user_commands
;
1740 fprintf_filtered (stream
, "User command \"%s%s\":\n", prefix
, name
);
1744 print_command_lines (current_uiout
, cmdlines
, 1);
1745 fputs_filtered ("\n", stream
);
1750 initialize_file_ftype _initialize_cli_script
;
1753 _initialize_cli_script (void)
1755 add_com ("document", class_support
, document_command
, _("\
1756 Document a user-defined command.\n\
1757 Give command name as argument. Give documentation on following lines.\n\
1758 End with a line of just \"end\"."));
1759 add_com ("define", class_support
, define_command
, _("\
1760 Define a new command name. Command name is argument.\n\
1761 Definition appears on following lines, one command per line.\n\
1762 End with a line of just \"end\".\n\
1763 Use the \"document\" command to give documentation for the new command.\n\
1764 Commands defined in this way may have up to ten arguments."));
1766 add_com ("while", class_support
, while_command
, _("\
1767 Execute nested commands WHILE the conditional expression is non zero.\n\
1768 The conditional expression must follow the word `while' and must in turn be\n\
1769 followed by a new line. The nested commands must be entered one per line,\n\
1770 and should be terminated by the word `end'."));
1772 add_com ("if", class_support
, if_command
, _("\
1773 Execute nested commands once IF the conditional expression is non zero.\n\
1774 The conditional expression must follow the word `if' and must in turn be\n\
1775 followed by a new line. The nested commands must be entered one per line,\n\
1776 and should be terminated by the word 'else' or `end'. If an else clause\n\
1777 is used, the same rules apply to its nested commands as to the first ones."));