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 ret
= simple_control
;
625 eval_ext_lang_from_control_command (cmd
);
626 ret
= simple_control
;
631 warning (_("Invalid control type in canned commands structure."));
635 do_cleanups (old_chain
);
640 /* Like execute_control_command, but first set
641 suppress_next_print_command_trace. */
643 enum command_control_type
644 execute_control_command_untraced (struct command_line
*cmd
)
646 suppress_next_print_command_trace
= 1;
647 return execute_control_command (cmd
);
651 /* "while" command support. Executes a body of statements while the
652 loop condition is nonzero. */
655 while_command (char *arg
, int from_tty
)
657 struct command_line
*command
= NULL
;
658 struct cleanup
*old_chain
;
661 command
= get_command_line (while_control
, arg
);
666 old_chain
= make_cleanup_restore_integer (&interpreter_async
);
667 interpreter_async
= 0;
669 execute_control_command_untraced (command
);
670 free_command_lines (&command
);
672 do_cleanups (old_chain
);
675 /* "if" command support. Execute either the true or false arm depending
676 on the value of the if conditional. */
679 if_command (char *arg
, int from_tty
)
681 struct command_line
*command
= NULL
;
682 struct cleanup
*old_chain
;
685 command
= get_command_line (if_control
, arg
);
690 old_chain
= make_cleanup_restore_integer (&interpreter_async
);
691 interpreter_async
= 0;
693 execute_control_command_untraced (command
);
694 free_command_lines (&command
);
696 do_cleanups (old_chain
);
701 arg_cleanup (void *ignore
)
703 struct user_args
*oargs
= user_args
;
706 internal_error (__FILE__
, __LINE__
,
707 _("arg_cleanup called with no user args.\n"));
709 user_args
= user_args
->next
;
710 xfree (oargs
->command
);
714 /* Bind the incomming arguments for a user defined command to
715 $arg0, $arg1 ... $argMAXUSERARGS. */
717 static struct cleanup
*
718 setup_user_args (char *p
)
720 struct user_args
*args
;
721 struct cleanup
*old_chain
;
722 unsigned int arg_count
= 0;
724 args
= (struct user_args
*) xmalloc (sizeof (struct user_args
));
725 memset (args
, 0, sizeof (struct user_args
));
727 args
->next
= user_args
;
730 old_chain
= make_cleanup (arg_cleanup
, 0/*ignored*/);
735 user_args
->command
= p
= xstrdup (p
);
744 if (arg_count
>= MAXUSERARGS
)
745 error (_("user defined function may only have %d arguments."),
748 /* Strip whitespace. */
749 while (*p
== ' ' || *p
== '\t')
752 /* P now points to an argument. */
754 user_args
->a
[arg_count
].arg
= p
;
756 /* Get to the end of this argument. */
759 if (((*p
== ' ' || *p
== '\t')) && !squote
&& !dquote
&& !bsquote
)
788 user_args
->a
[arg_count
].len
= p
- start_arg
;
795 /* Given character string P, return a point to the first argument
796 ($arg), or NULL if P contains no arguments. */
801 while ((p
= strchr (p
, '$')))
803 if (startswith (p
, "$arg")
804 && (isdigit (p
[4]) || p
[4] == 'c'))
811 /* Insert the user defined arguments stored in user_arg into the $arg
812 arguments found in line, with the updated copy being placed into
816 insert_args (char *line
)
818 char *p
, *save_line
, *new_line
;
821 /* If we are not in a user-defined function, treat $argc, $arg0, et
822 cetera as normal convenience variables. */
823 if (user_args
== NULL
)
824 return xstrdup (line
);
826 /* First we need to know how much memory to allocate for the new
830 while ((p
= locate_arg (line
)))
837 /* $argc. Number will be <=10. */
838 len
+= user_args
->count
== 10 ? 2 : 1;
840 else if (i
>= user_args
->count
)
842 error (_("Missing argument %d in user function."), i
);
847 len
+= user_args
->a
[i
].len
;
852 /* Don't forget the tail. */
853 len
+= strlen (line
);
855 /* Allocate space for the new line and fill it in. */
856 new_line
= (char *) xmalloc (len
+ 1);
857 if (new_line
== NULL
)
860 /* Restore pointer to beginning of old line. */
863 /* Save pointer to beginning of new line. */
864 save_line
= new_line
;
866 while ((p
= locate_arg (line
)))
870 memcpy (new_line
, line
, p
- line
);
871 new_line
+= p
- line
;
875 gdb_assert (user_args
->count
>= 0 && user_args
->count
<= 10);
876 if (user_args
->count
== 10)
882 *(new_line
++) = user_args
->count
+ '0';
887 len
= user_args
->a
[i
].len
;
890 memcpy (new_line
, user_args
->a
[i
].arg
, len
);
896 /* Don't forget the tail. */
897 strcpy (new_line
, line
);
899 /* Return a pointer to the beginning of the new line. */
904 /* Expand the body_list of COMMAND so that it can hold NEW_LENGTH
905 code bodies. This is typically used when we encounter an "else"
906 clause for an "if" command. */
909 realloc_body_list (struct command_line
*command
, int new_length
)
912 struct command_line
**body_list
;
914 n
= command
->body_count
;
920 body_list
= (struct command_line
**)
921 xmalloc (sizeof (struct command_line
*) * new_length
);
923 memcpy (body_list
, command
->body_list
, sizeof (struct command_line
*) * n
);
924 memset (body_list
+ n
, 0, sizeof (struct command_line
*) * (new_length
- n
));
926 xfree (command
->body_list
);
927 command
->body_list
= body_list
;
928 command
->body_count
= new_length
;
931 /* Read next line from stdout. Passed to read_command_line_1 and
932 recurse_read_control_structure whenever we need to read commands
936 read_next_line (void)
938 char *prompt_ptr
, control_prompt
[256];
941 if (control_level
>= 254)
942 error (_("Control nesting too deep!"));
944 /* Set a prompt based on the nesting of the control commands. */
945 if (instream
== stdin
|| (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
, instream
== stdin
, "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
= (struct command_line
*)
1079 xmalloc (sizeof (struct command_line
));
1080 (*command
)->next
= NULL
;
1081 (*command
)->line
= NULL
;
1082 (*command
)->control_type
= break_control
;
1083 (*command
)->body_count
= 0;
1084 (*command
)->body_list
= NULL
;
1086 else if (p_end
- p
== 13 && startswith (p
, "loop_continue"))
1088 *command
= (struct command_line
*)
1089 xmalloc (sizeof (struct command_line
));
1090 (*command
)->next
= NULL
;
1091 (*command
)->line
= NULL
;
1092 (*command
)->control_type
= continue_control
;
1093 (*command
)->body_count
= 0;
1094 (*command
)->body_list
= NULL
;
1100 if (!parse_commands
|| not_handled
)
1102 /* A normal command. */
1103 *command
= (struct command_line
*)
1104 xmalloc (sizeof (struct command_line
));
1105 (*command
)->next
= NULL
;
1106 (*command
)->line
= savestring (p
, p_end
- p
);
1107 (*command
)->control_type
= simple_control
;
1108 (*command
)->body_count
= 0;
1109 (*command
)->body_list
= NULL
;
1114 volatile struct gdb_exception ex
;
1116 TRY_CATCH (ex
, RETURN_MASK_ALL
)
1118 validator ((*command
)->line
, closure
);
1123 throw_exception (ex
);
1127 /* Nothing special. */
1131 /* Recursively read in the control structures and create a
1132 command_line structure from them. Use read_next_line_func to
1133 obtain lines of the command. */
1135 static enum command_control_type
1136 recurse_read_control_structure (char * (*read_next_line_func
) (void),
1137 struct command_line
*current_cmd
,
1138 void (*validator
)(char *, void *),
1141 int current_body
, i
;
1142 enum misc_command_type val
;
1143 enum command_control_type ret
;
1144 struct command_line
**body_ptr
, *child_tail
, *next
;
1149 /* Sanity checks. */
1150 if (current_cmd
->control_type
== simple_control
)
1151 error (_("Recursed on a simple control type."));
1153 if (current_body
> current_cmd
->body_count
)
1154 error (_("Allocated body is smaller than this command type needs."));
1156 /* Read lines from the input stream and build control structures. */
1162 val
= process_next_line (read_next_line_func (), &next
,
1163 current_cmd
->control_type
!= python_control
1164 && current_cmd
->control_type
!= guile_control
1165 && current_cmd
->control_type
!= compile_control
,
1166 validator
, closure
);
1168 /* Just skip blanks and comments. */
1169 if (val
== nop_command
)
1172 if (val
== end_command
)
1174 if (multi_line_command_p (current_cmd
->control_type
))
1176 /* Success reading an entire canned sequence of commands. */
1177 ret
= simple_control
;
1182 ret
= invalid_control
;
1187 /* Not the end of a control structure. */
1188 if (val
== else_command
)
1190 if (current_cmd
->control_type
== if_control
1191 && current_body
== 1)
1193 realloc_body_list (current_cmd
, 2);
1200 ret
= invalid_control
;
1207 child_tail
->next
= next
;
1211 body_ptr
= current_cmd
->body_list
;
1212 for (i
= 1; i
< current_body
; i
++)
1221 /* If the latest line is another control structure, then recurse
1223 if (multi_line_command_p (next
->control_type
))
1226 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1227 validator
, closure
);
1230 if (ret
!= simple_control
)
1241 restore_interp (void *arg
)
1243 interp_set_temp (interp_name ((struct interp
*)arg
));
1246 /* Read lines from the input stream and accumulate them in a chain of
1247 struct command_line's, which is then returned. For input from a
1248 terminal, the special command "end" is used to mark the end of the
1249 input, and is not included in the returned chain of commands.
1251 If PARSE_COMMANDS is true, strip leading whitespace (trailing whitespace
1252 is always stripped) in the line and attempt to recognize GDB control
1253 commands. Otherwise, only "end" is recognized. */
1255 #define END_MESSAGE "End with a line saying just \"end\"."
1257 struct command_line
*
1258 read_command_lines (char *prompt_arg
, int from_tty
, int parse_commands
,
1259 void (*validator
)(char *, void *), void *closure
)
1261 struct command_line
*head
;
1263 if (from_tty
&& input_from_terminal_p ())
1265 if (deprecated_readline_begin_hook
)
1267 /* Note - intentional to merge messages with no newline. */
1268 (*deprecated_readline_begin_hook
) ("%s %s\n", prompt_arg
,
1273 printf_unfiltered ("%s\n%s\n", prompt_arg
, END_MESSAGE
);
1274 gdb_flush (gdb_stdout
);
1279 /* Reading commands assumes the CLI behavior, so temporarily
1280 override the current interpreter with CLI. */
1281 if (current_interp_named_p (INTERP_CONSOLE
))
1282 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1283 validator
, closure
);
1286 struct interp
*old_interp
= interp_set_temp (INTERP_CONSOLE
);
1287 struct cleanup
*old_chain
= make_cleanup (restore_interp
, old_interp
);
1289 head
= read_command_lines_1 (read_next_line
, parse_commands
,
1290 validator
, closure
);
1291 do_cleanups (old_chain
);
1294 if (deprecated_readline_end_hook
&& from_tty
&& input_from_terminal_p ())
1296 (*deprecated_readline_end_hook
) ();
1301 /* Act the same way as read_command_lines, except that each new line is
1302 obtained using READ_NEXT_LINE_FUNC. */
1304 struct command_line
*
1305 read_command_lines_1 (char * (*read_next_line_func
) (void), int parse_commands
,
1306 void (*validator
)(char *, void *), void *closure
)
1308 struct command_line
*head
, *tail
, *next
;
1309 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1310 enum command_control_type ret
;
1311 enum misc_command_type val
;
1319 val
= process_next_line (read_next_line_func (), &next
, parse_commands
,
1320 validator
, closure
);
1322 /* Ignore blank lines or comments. */
1323 if (val
== nop_command
)
1326 if (val
== end_command
)
1328 ret
= simple_control
;
1332 if (val
!= ok_command
)
1334 ret
= invalid_control
;
1338 if (multi_line_command_p (next
->control_type
))
1341 ret
= recurse_read_control_structure (read_next_line_func
, next
,
1342 validator
, closure
);
1345 if (ret
== invalid_control
)
1356 make_cleanup_free_command_lines (&head
);
1363 if (ret
!= invalid_control
)
1364 discard_cleanups (old_chain
);
1366 do_cleanups (old_chain
);
1371 /* Free a chain of struct command_line's. */
1374 free_command_lines (struct command_line
**lptr
)
1376 struct command_line
*l
= *lptr
;
1377 struct command_line
*next
;
1378 struct command_line
**blist
;
1383 if (l
->body_count
> 0)
1385 blist
= l
->body_list
;
1386 for (i
= 0; i
< l
->body_count
; i
++, blist
++)
1387 free_command_lines (blist
);
1398 do_free_command_lines_cleanup (void *arg
)
1400 free_command_lines (arg
);
1404 make_cleanup_free_command_lines (struct command_line
**arg
)
1406 return make_cleanup (do_free_command_lines_cleanup
, arg
);
1409 struct command_line
*
1410 copy_command_lines (struct command_line
*cmds
)
1412 struct command_line
*result
= NULL
;
1416 result
= (struct command_line
*) xmalloc (sizeof (struct command_line
));
1418 result
->next
= copy_command_lines (cmds
->next
);
1419 result
->line
= xstrdup (cmds
->line
);
1420 result
->control_type
= cmds
->control_type
;
1421 result
->body_count
= cmds
->body_count
;
1422 if (cmds
->body_count
> 0)
1426 result
->body_list
= (struct command_line
**)
1427 xmalloc (sizeof (struct command_line
*) * cmds
->body_count
);
1429 for (i
= 0; i
< cmds
->body_count
; i
++)
1430 result
->body_list
[i
] = copy_command_lines (cmds
->body_list
[i
]);
1433 result
->body_list
= NULL
;
1439 /* Validate that *COMNAME is a valid name for a command. Return the
1440 containing command list, in case it starts with a prefix command.
1441 The prefix must already exist. *COMNAME is advanced to point after
1442 any prefix, and a NUL character overwrites the space after the
1445 static struct cmd_list_element
**
1446 validate_comname (char **comname
)
1448 struct cmd_list_element
**list
= &cmdlist
;
1449 char *p
, *last_word
;
1452 error_no_arg (_("name of command to define"));
1454 /* Find the last word of the argument. */
1455 p
= *comname
+ strlen (*comname
);
1456 while (p
> *comname
&& isspace (p
[-1]))
1458 while (p
> *comname
&& !isspace (p
[-1]))
1462 /* Find the corresponding command list. */
1463 if (last_word
!= *comname
)
1465 struct cmd_list_element
*c
;
1467 const char *tem
= *comname
;
1469 /* Separate the prefix and the command. */
1470 saved_char
= last_word
[-1];
1471 last_word
[-1] = '\0';
1473 c
= lookup_cmd (&tem
, cmdlist
, "", 0, 1);
1474 if (c
->prefixlist
== NULL
)
1475 error (_("\"%s\" is not a prefix command."), *comname
);
1477 list
= c
->prefixlist
;
1478 last_word
[-1] = saved_char
;
1479 *comname
= last_word
;
1485 if (!isalnum (*p
) && *p
!= '-' && *p
!= '_')
1486 error (_("Junk in argument list: \"%s\""), p
);
1493 /* This is just a placeholder in the command data structures. */
1495 user_defined_command (char *ignore
, int from_tty
)
1500 define_command (char *comname
, int from_tty
)
1502 #define MAX_TMPBUF 128
1509 struct command_line
*cmds
;
1510 struct cmd_list_element
*c
, *newc
, *hookc
= 0, **list
;
1511 char *tem
, *comfull
;
1513 char tmpbuf
[MAX_TMPBUF
];
1514 int hook_type
= CMD_NO_HOOK
;
1515 int hook_name_size
= 0;
1517 #define HOOK_STRING "hook-"
1519 #define HOOK_POST_STRING "hookpost-"
1520 #define HOOK_POST_LEN 9
1523 list
= validate_comname (&comname
);
1525 /* Look it up, and verify that we got an exact match. */
1527 c
= lookup_cmd (&tem_c
, *list
, "", -1, 1);
1528 if (c
&& strcmp (comname
, c
->name
) != 0)
1535 if (c
->theclass
== class_user
|| c
->theclass
== class_alias
)
1536 q
= query (_("Redefine command \"%s\"? "), c
->name
);
1538 q
= query (_("Really redefine built-in command \"%s\"? "), c
->name
);
1540 error (_("Command \"%s\" not redefined."), c
->name
);
1543 /* If this new command is a hook, then mark the command which it
1544 is hooking. Note that we allow hooking `help' commands, so that
1545 we can hook the `stop' pseudo-command. */
1547 if (!strncmp (comname
, HOOK_STRING
, HOOK_LEN
))
1549 hook_type
= CMD_PRE_HOOK
;
1550 hook_name_size
= HOOK_LEN
;
1552 else if (!strncmp (comname
, HOOK_POST_STRING
, HOOK_POST_LEN
))
1554 hook_type
= CMD_POST_HOOK
;
1555 hook_name_size
= HOOK_POST_LEN
;
1558 if (hook_type
!= CMD_NO_HOOK
)
1560 /* Look up cmd it hooks, and verify that we got an exact match. */
1561 tem_c
= comname
+ hook_name_size
;
1562 hookc
= lookup_cmd (&tem_c
, *list
, "", -1, 0);
1563 if (hookc
&& strcmp (comname
+ hook_name_size
, hookc
->name
) != 0)
1567 warning (_("Your new `%s' command does not "
1568 "hook any existing command."),
1570 if (!query (_("Proceed? ")))
1571 error (_("Not confirmed."));
1575 comname
= xstrdup (comname
);
1577 /* If the rest of the commands will be case insensitive, this one
1578 should behave in the same manner. */
1579 for (tem
= comname
; *tem
; tem
++)
1581 *tem
= tolower (*tem
);
1583 xsnprintf (tmpbuf
, sizeof (tmpbuf
),
1584 "Type commands for definition of \"%s\".", comfull
);
1585 cmds
= read_command_lines (tmpbuf
, from_tty
, 1, 0, 0);
1587 if (c
&& c
->theclass
== class_user
)
1588 free_command_lines (&c
->user_commands
);
1590 newc
= add_cmd (comname
, class_user
, user_defined_command
,
1591 (c
&& c
->theclass
== class_user
)
1592 ? c
->doc
: xstrdup ("User-defined."), list
);
1593 newc
->user_commands
= cmds
;
1595 /* If this new command is a hook, then mark both commands as being
1602 hookc
->hook_pre
= newc
; /* Target gets hooked. */
1603 newc
->hookee_pre
= hookc
; /* We are marked as hooking target cmd. */
1606 hookc
->hook_post
= newc
; /* Target gets hooked. */
1607 newc
->hookee_post
= hookc
; /* We are marked as hooking
1611 /* Should never come here as hookc would be 0. */
1612 internal_error (__FILE__
, __LINE__
, _("bad switch"));
1618 document_command (char *comname
, int from_tty
)
1620 struct command_line
*doclines
;
1621 struct cmd_list_element
*c
, **list
;
1627 list
= validate_comname (&comname
);
1630 c
= lookup_cmd (&tem
, *list
, "", 0, 1);
1632 if (c
->theclass
!= class_user
)
1633 error (_("Command \"%s\" is built-in."), comfull
);
1635 xsnprintf (tmpbuf
, sizeof (tmpbuf
), "Type documentation for \"%s\".",
1637 doclines
= read_command_lines (tmpbuf
, from_tty
, 0, 0, 0);
1640 xfree ((char *) c
->doc
);
1643 struct command_line
*cl1
;
1647 for (cl1
= doclines
; cl1
; cl1
= cl1
->next
)
1648 len
+= strlen (cl1
->line
) + 1;
1650 doc
= (char *) xmalloc (len
+ 1);
1653 for (cl1
= doclines
; cl1
; cl1
= cl1
->next
)
1655 strcat (doc
, cl1
->line
);
1663 free_command_lines (&doclines
);
1666 struct source_cleanup_lines_args
1669 const char *old_file
;
1673 source_cleanup_lines (void *args
)
1675 struct source_cleanup_lines_args
*p
=
1676 (struct source_cleanup_lines_args
*) args
;
1678 source_line_number
= p
->old_line
;
1679 source_file_name
= p
->old_file
;
1682 /* Used to implement source_command. */
1685 script_from_file (FILE *stream
, const char *file
)
1687 struct cleanup
*old_cleanups
;
1688 struct source_cleanup_lines_args old_lines
;
1691 internal_error (__FILE__
, __LINE__
, _("called with NULL file pointer!"));
1693 old_lines
.old_line
= source_line_number
;
1694 old_lines
.old_file
= source_file_name
;
1695 old_cleanups
= make_cleanup (source_cleanup_lines
, &old_lines
);
1696 source_line_number
= 0;
1697 source_file_name
= file
;
1699 make_cleanup_restore_integer (&interpreter_async
);
1700 interpreter_async
= 0;
1703 volatile struct gdb_exception e
;
1705 TRY_CATCH (e
, RETURN_MASK_ERROR
)
1707 read_command_file (stream
);
1714 /* Re-throw the error, but with the file name information
1716 throw_error (e
.error
,
1717 _("%s:%d: Error in sourced command file:\n%s"),
1718 source_file_name
, source_line_number
, e
.message
);
1720 internal_error (__FILE__
, __LINE__
, _("bad reason"));
1724 do_cleanups (old_cleanups
);
1727 /* Print the definition of user command C to STREAM. Or, if C is a
1728 prefix command, show the definitions of all user commands under C
1729 (recursively). PREFIX and NAME combined are the name of the
1732 show_user_1 (struct cmd_list_element
*c
, const char *prefix
, const char *name
,
1733 struct ui_file
*stream
)
1735 struct command_line
*cmdlines
;
1737 if (c
->prefixlist
!= NULL
)
1739 const char *prefixname
= c
->prefixname
;
1741 for (c
= *c
->prefixlist
; c
!= NULL
; c
= c
->next
)
1742 if (c
->theclass
== class_user
|| c
->prefixlist
!= NULL
)
1743 show_user_1 (c
, prefixname
, c
->name
, gdb_stdout
);
1747 cmdlines
= c
->user_commands
;
1748 fprintf_filtered (stream
, "User command \"%s%s\":\n", prefix
, name
);
1752 print_command_lines (current_uiout
, cmdlines
, 1);
1753 fputs_filtered ("\n", stream
);
1758 initialize_file_ftype _initialize_cli_script
;
1761 _initialize_cli_script (void)
1763 add_com ("document", class_support
, document_command
, _("\
1764 Document a user-defined command.\n\
1765 Give command name as argument. Give documentation on following lines.\n\
1766 End with a line of just \"end\"."));
1767 add_com ("define", class_support
, define_command
, _("\
1768 Define a new command name. Command name is argument.\n\
1769 Definition appears on following lines, one command per line.\n\
1770 End with a line of just \"end\".\n\
1771 Use the \"document\" command to give documentation for the new command.\n\
1772 Commands defined in this way may have up to ten arguments."));
1774 add_com ("while", class_support
, while_command
, _("\
1775 Execute nested commands WHILE the conditional expression is non zero.\n\
1776 The conditional expression must follow the word `while' and must in turn be\n\
1777 followed by a new line. The nested commands must be entered one per line,\n\
1778 and should be terminated by the word `end'."));
1780 add_com ("if", class_support
, if_command
, _("\
1781 Execute nested commands once IF the conditional expression is non zero.\n\
1782 The conditional expression must follow the word `if' and must in turn be\n\
1783 followed by a new line. The nested commands must be entered one per line,\n\
1784 and should be terminated by the word 'else' or `end'. If an else clause\n\
1785 is used, the same rules apply to its nested commands as to the first ones."));