1 /* GDB CLI command scripting.
3 Copyright (c) 1986-2002, 2004-2012 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 */
26 #include "gdb_string.h"
27 #include "exceptions.h"
29 #include "breakpoint.h"
30 #include "cli/cli-cmds.h"
31 #include "cli/cli-decode.h"
32 #include "cli/cli-script.h"
33 #include "gdb_assert.h"
35 #include "python/python.h"
38 /* Prototypes for local functions. */
40 static enum command_control_type
41 recurse_read_control_structure (char * (*read_next_line_func) (void),
42 struct command_line *current_cmd,
43 void (*validator)(char *, void *),
46 static char *insert_args (char *line);
48 static struct cleanup * setup_user_args (char *p);
50 static char *read_next_line (void);
52 /* Level of control structure when reading. */
53 static int control_level;
55 /* Level of control structure when executing. */
56 static int command_nest_depth = 1;
58 /* This is to prevent certain commands being printed twice. */
59 static int suppress_next_print_command_trace = 0;
61 /* Structure for arguments to user defined functions. */
62 #define MAXUSERARGS 10
65 struct user_args *next;
66 /* It is necessary to store a malloced copy of the command line to
67 ensure that the arguments are not overwritten before they are
81 /* Allocate, initialize a new command line structure for one of the
82 control commands (if/while). */
84 static struct command_line *
85 build_command_line (enum command_control_type type, char *args)
87 struct command_line *cmd;
89 if (args == NULL && (type == if_control || type == while_control))
90 error (_("if/while commands require arguments."));
91 gdb_assert (args != NULL);
93 cmd = (struct command_line *) xmalloc (sizeof (struct command_line));
95 cmd->control_type = type;
99 = (struct command_line **) xmalloc (sizeof (struct command_line *)
101 memset (cmd->body_list, 0, sizeof (struct command_line *) * cmd->body_count);
102 cmd->line = xstrdup (args);
107 /* Build and return a new command structure for the control commands
108 such as "if" and "while". */
110 struct command_line *
111 get_command_line (enum command_control_type type, char *arg)
113 struct command_line *cmd;
114 struct cleanup *old_chain = NULL;
116 /* Allocate and build a new command line structure. */
117 cmd = build_command_line (type, arg);
119 old_chain = make_cleanup_free_command_lines (&cmd);
121 /* Read in the body of this command. */
122 if (recurse_read_control_structure (read_next_line, cmd, 0, 0)
125 warning (_("Error reading in canned sequence of commands."));
126 do_cleanups (old_chain);
130 discard_cleanups (old_chain);
134 /* Recursively print a command (including full control structures). */
137 print_command_lines (struct ui_out *uiout, struct command_line *cmd,
140 struct command_line *list;
146 ui_out_spaces (uiout, 2 * depth);
148 /* A simple command, print it and continue. */
149 if (list->control_type == simple_control)
151 ui_out_field_string (uiout, NULL, list->line);
152 ui_out_text (uiout, "\n");
157 /* loop_continue to jump to the start of a while loop, print it
159 if (list->control_type == continue_control)
161 ui_out_field_string (uiout, NULL, "loop_continue");
162 ui_out_text (uiout, "\n");
167 /* loop_break to break out of a while loop, print it and
169 if (list->control_type == break_control)
171 ui_out_field_string (uiout, NULL, "loop_break");
172 ui_out_text (uiout, "\n");
177 /* A while command. Recursively print its subcommands and
179 if (list->control_type == while_control
180 || list->control_type == while_stepping_control)
182 /* For while-stepping, the line includes the 'while-stepping'
183 token. See comment in process_next_line for explanation.
184 Here, take care not print 'while-stepping' twice. */
185 if (list->control_type == while_control)
186 ui_out_field_fmt (uiout, NULL, "while %s", list->line);
188 ui_out_field_string (uiout, NULL, list->line);
189 ui_out_text (uiout, "\n");
190 print_command_lines (uiout, *list->body_list, depth + 1);
192 ui_out_spaces (uiout, 2 * depth);
193 ui_out_field_string (uiout, NULL, "end");
194 ui_out_text (uiout, "\n");
199 /* An if command. Recursively print both arms before
201 if (list->control_type == if_control)
203 ui_out_field_fmt (uiout, NULL, "if %s", list->line);
204 ui_out_text (uiout, "\n");
206 print_command_lines (uiout, list->body_list[0], depth + 1);
208 /* Show the false arm if it exists. */
209 if (list->body_count == 2)
212 ui_out_spaces (uiout, 2 * depth);
213 ui_out_field_string (uiout, NULL, "else");
214 ui_out_text (uiout, "\n");
215 print_command_lines (uiout, list->body_list[1], depth + 1);
219 ui_out_spaces (uiout, 2 * depth);
220 ui_out_field_string (uiout, NULL, "end");
221 ui_out_text (uiout, "\n");
226 /* A commands command. Print the breakpoint commands and
228 if (list->control_type == commands_control)
231 ui_out_field_fmt (uiout, NULL, "commands %s", list->line);
233 ui_out_field_string (uiout, NULL, "commands");
234 ui_out_text (uiout, "\n");
235 print_command_lines (uiout, *list->body_list, depth + 1);
237 ui_out_spaces (uiout, 2 * depth);
238 ui_out_field_string (uiout, NULL, "end");
239 ui_out_text (uiout, "\n");
244 if (list->control_type == python_control)
246 ui_out_field_string (uiout, NULL, "python");
247 ui_out_text (uiout, "\n");
248 /* Don't indent python code at all. */
249 print_command_lines (uiout, *list->body_list, 0);
251 ui_out_spaces (uiout, 2 * depth);
252 ui_out_field_string (uiout, NULL, "end");
253 ui_out_text (uiout, "\n");
258 /* Ignore illegal command type and try next. */
263 /* Handle pre-post hooks. */
266 clear_hook_in_cleanup (void *data)
268 struct cmd_list_element *c = data;
270 c->hook_in = 0; /* Allow hook to work again once it is complete. */
274 execute_cmd_pre_hook (struct cmd_list_element *c)
276 if ((c->hook_pre) && (!c->hook_in))
278 struct cleanup *cleanups = make_cleanup (clear_hook_in_cleanup, c);
279 c->hook_in = 1; /* Prevent recursive hooking. */
280 execute_user_command (c->hook_pre, (char *) 0);
281 do_cleanups (cleanups);
286 execute_cmd_post_hook (struct cmd_list_element *c)
288 if ((c->hook_post) && (!c->hook_in))
290 struct cleanup *cleanups = make_cleanup (clear_hook_in_cleanup, c);
292 c->hook_in = 1; /* Prevent recursive hooking. */
293 execute_user_command (c->hook_post, (char *) 0);
294 do_cleanups (cleanups);
298 /* Execute the command in CMD. */
300 do_restore_user_call_depth (void * call_depth)
302 int *depth = call_depth;
311 execute_user_command (struct cmd_list_element *c, char *args)
313 struct command_line *cmdlines;
314 struct cleanup *old_chain;
315 enum command_control_type ret;
316 static int user_call_depth = 0;
317 extern int max_user_call_depth;
319 cmdlines = c->user_commands;
324 old_chain = setup_user_args (args);
326 if (++user_call_depth > max_user_call_depth)
327 error (_("Max user call depth exceeded -- command aborted."));
329 make_cleanup (do_restore_user_call_depth, &user_call_depth);
331 /* Set the instream to 0, indicating execution of a
332 user-defined function. */
333 make_cleanup (do_restore_instream_cleanup, instream);
334 instream = (FILE *) 0;
336 /* Also set the global in_user_command, so that NULL instream is
337 not confused with Insight. */
340 make_cleanup_restore_integer (&interpreter_async);
341 interpreter_async = 0;
343 command_nest_depth++;
346 ret = execute_control_command (cmdlines);
347 if (ret != simple_control && ret != break_control)
349 warning (_("Error executing canned sequence of commands."));
352 cmdlines = cmdlines->next;
354 command_nest_depth--;
355 do_cleanups (old_chain);
358 /* This function is called every time GDB prints a prompt. It ensures
359 that errors and the like do not confuse the command tracing. */
362 reset_command_nest_depth (void)
364 command_nest_depth = 1;
367 suppress_next_print_command_trace = 0;
370 /* Print the command, prefixed with '+' to represent the call depth.
371 This is slightly complicated because this function may be called
372 from execute_command and execute_control_command. Unfortunately
373 execute_command also prints the top level control commands.
374 In these cases execute_command will call execute_control_command
375 via while_command or if_command. Inner levels of 'if' and 'while'
376 are dealt with directly. Therefore we can use these functions
377 to determine whether the command has been printed already or not. */
379 print_command_trace (const char *cmd)
383 if (suppress_next_print_command_trace)
385 suppress_next_print_command_trace = 0;
389 if (!source_verbose && !trace_commands)
392 for (i=0; i < command_nest_depth; i++)
393 printf_filtered ("+");
395 printf_filtered ("%s\n", cmd);
398 enum command_control_type
399 execute_control_command (struct command_line *cmd)
401 struct expression *expr;
402 struct command_line *current;
403 struct cleanup *old_chain = make_cleanup (null_cleanup, 0);
405 struct value *val_mark;
407 enum command_control_type ret;
410 /* Start by assuming failure, if a problem is detected, the code
411 below will simply "break" out of the switch. */
412 ret = invalid_control;
414 switch (cmd->control_type)
417 /* A simple command, execute it and return. */
418 new_line = insert_args (cmd->line);
421 make_cleanup (free_current_contents, &new_line);
422 execute_command (new_line, 0);
423 ret = cmd->control_type;
426 case continue_control:
427 print_command_trace ("loop_continue");
429 /* Return for "continue", and "break" so we can either
430 continue the loop at the top, or break out. */
431 ret = cmd->control_type;
435 print_command_trace ("loop_break");
437 /* Return for "continue", and "break" so we can either
438 continue the loop at the top, or break out. */
439 ret = cmd->control_type;
444 char *buffer = alloca (strlen (cmd->line) + 7);
446 sprintf (buffer, "while %s", cmd->line);
447 print_command_trace (buffer);
449 /* Parse the loop control expression for the while statement. */
450 new_line = insert_args (cmd->line);
453 make_cleanup (free_current_contents, &new_line);
454 expr = parse_expression (new_line);
455 make_cleanup (free_current_contents, &expr);
457 ret = simple_control;
460 /* Keep iterating so long as the expression is true. */
467 /* Evaluate the expression. */
468 val_mark = value_mark ();
469 val = evaluate_expression (expr);
470 cond_result = value_true (val);
471 value_free_to_mark (val_mark);
473 /* If the value is false, then break out of the loop. */
477 /* Execute the body of the while statement. */
478 current = *cmd->body_list;
481 command_nest_depth++;
482 ret = execute_control_command (current);
483 command_nest_depth--;
485 /* If we got an error, or a "break" command, then stop
487 if (ret == invalid_control || ret == break_control)
493 /* If we got a "continue" command, then restart the loop
495 if (ret == continue_control)
498 /* Get the next statement. */
499 current = current->next;
503 /* Reset RET so that we don't recurse the break all the way down. */
504 if (ret == break_control)
505 ret = simple_control;
512 char *buffer = alloca (strlen (cmd->line) + 4);
514 sprintf (buffer, "if %s", cmd->line);
515 print_command_trace (buffer);
517 new_line = insert_args (cmd->line);
520 make_cleanup (free_current_contents, &new_line);
521 /* Parse the conditional for the if statement. */
522 expr = parse_expression (new_line);
523 make_cleanup (free_current_contents, &expr);
526 ret = simple_control;
528 /* Evaluate the conditional. */
529 val_mark = value_mark ();
530 val = evaluate_expression (expr);
532 /* Choose which arm to take commands from based on the value
533 of the conditional expression. */
534 if (value_true (val))
535 current = *cmd->body_list;
536 else if (cmd->body_count == 2)
537 current = *(cmd->body_list + 1);
538 value_free_to_mark (val_mark);
540 /* Execute commands in the given arm. */
543 command_nest_depth++;
544 ret = execute_control_command (current);
545 command_nest_depth--;
547 /* If we got an error, get out. */
548 if (ret != simple_control)
551 /* Get the next statement in the body. */
552 current = current->next;
557 case commands_control:
559 /* Breakpoint commands list, record the commands in the
560 breakpoint's command list and return. */
561 new_line = insert_args (cmd->line);
564 make_cleanup (free_current_contents, &new_line);
565 ret = commands_from_control_command (new_line, cmd);
570 eval_python_from_control_command (cmd);
571 ret = simple_control;
576 warning (_("Invalid control type in canned commands structure."));
580 do_cleanups (old_chain);
585 /* Like execute_control_command, but first set
586 suppress_next_print_command_trace. */
588 enum command_control_type
589 execute_control_command_untraced (struct command_line *cmd)
591 suppress_next_print_command_trace = 1;
592 return execute_control_command (cmd);
596 /* "while" command support. Executes a body of statements while the
597 loop condition is nonzero. */
600 while_command (char *arg, int from_tty)
602 struct command_line *command = NULL;
603 struct cleanup *old_chain;
606 command = get_command_line (while_control, arg);
611 old_chain = make_cleanup_restore_integer (&interpreter_async);
612 interpreter_async = 0;
614 execute_control_command_untraced (command);
615 free_command_lines (&command);
617 do_cleanups (old_chain);
620 /* "if" command support. Execute either the true or false arm depending
621 on the value of the if conditional. */
624 if_command (char *arg, int from_tty)
626 struct command_line *command = NULL;
627 struct cleanup *old_chain;
630 command = get_command_line (if_control, arg);
635 old_chain = make_cleanup_restore_integer (&interpreter_async);
636 interpreter_async = 0;
638 execute_control_command_untraced (command);
639 free_command_lines (&command);
641 do_cleanups (old_chain);
646 arg_cleanup (void *ignore)
648 struct user_args *oargs = user_args;
651 internal_error (__FILE__, __LINE__,
652 _("arg_cleanup called with no user args.\n"));
654 user_args = user_args->next;
655 xfree (oargs->command);
659 /* Bind the incomming arguments for a user defined command to
660 $arg0, $arg1 ... $argMAXUSERARGS. */
662 static struct cleanup *
663 setup_user_args (char *p)
665 struct user_args *args;
666 struct cleanup *old_chain;
667 unsigned int arg_count = 0;
669 args = (struct user_args *) xmalloc (sizeof (struct user_args));
670 memset (args, 0, sizeof (struct user_args));
672 args->next = user_args;
675 old_chain = make_cleanup (arg_cleanup, 0/*ignored*/);
680 user_args->command = p = xstrdup (p);
689 if (arg_count >= MAXUSERARGS)
691 error (_("user defined function may only have %d arguments."),
696 /* Strip whitespace. */
697 while (*p == ' ' || *p == '\t')
700 /* P now points to an argument. */
702 user_args->a[arg_count].arg = p;
704 /* Get to the end of this argument. */
707 if (((*p == ' ' || *p == '\t')) && !squote && !dquote && !bsquote)
736 user_args->a[arg_count].len = p - start_arg;
743 /* Given character string P, return a point to the first argument
744 ($arg), or NULL if P contains no arguments. */
749 while ((p = strchr (p, '$')))
751 if (strncmp (p, "$arg", 4) == 0
752 && (isdigit (p[4]) || p[4] == 'c'))
759 /* Insert the user defined arguments stored in user_arg into the $arg
760 arguments found in line, with the updated copy being placed into
764 insert_args (char *line)
766 char *p, *save_line, *new_line;
769 /* If we are not in a user-defined function, treat $argc, $arg0, et
770 cetera as normal convenience variables. */
771 if (user_args == NULL)
772 return xstrdup (line);
774 /* First we need to know how much memory to allocate for the new
778 while ((p = locate_arg (line)))
785 /* $argc. Number will be <=10. */
786 len += user_args->count == 10 ? 2 : 1;
788 else if (i >= user_args->count)
790 error (_("Missing argument %d in user function."), i);
795 len += user_args->a[i].len;
800 /* Don't forget the tail. */
801 len += strlen (line);
803 /* Allocate space for the new line and fill it in. */
804 new_line = (char *) xmalloc (len + 1);
805 if (new_line == NULL)
808 /* Restore pointer to beginning of old line. */
811 /* Save pointer to beginning of new line. */
812 save_line = new_line;
814 while ((p = locate_arg (line)))
818 memcpy (new_line, line, p - line);
819 new_line += p - line;
823 gdb_assert (user_args->count >= 0 && user_args->count <= 10);
824 if (user_args->count == 10)
830 *(new_line++) = user_args->count + '0';
835 len = user_args->a[i].len;
838 memcpy (new_line, user_args->a[i].arg, len);
844 /* Don't forget the tail. */
845 strcpy (new_line, line);
847 /* Return a pointer to the beginning of the new line. */
852 /* Expand the body_list of COMMAND so that it can hold NEW_LENGTH
853 code bodies. This is typically used when we encounter an "else"
854 clause for an "if" command. */
857 realloc_body_list (struct command_line *command, int new_length)
860 struct command_line **body_list;
862 n = command->body_count;
868 body_list = (struct command_line **)
869 xmalloc (sizeof (struct command_line *) * new_length);
871 memcpy (body_list, command->body_list, sizeof (struct command_line *) * n);
872 memset (body_list + n, 0, sizeof (struct command_line *) * (new_length - n));
874 xfree (command->body_list);
875 command->body_list = body_list;
876 command->body_count = new_length;
879 /* Read next line from stdout. Passed to read_command_line_1 and
880 recurse_read_control_structure whenever we need to read commands
884 read_next_line (void)
886 char *prompt_ptr, control_prompt[256];
889 if (control_level >= 254)
890 error (_("Control nesting too deep!"));
892 /* Set a prompt based on the nesting of the control commands. */
893 if (instream == stdin || (instream == 0 && deprecated_readline_hook != NULL))
895 for (i = 0; i < control_level; i++)
896 control_prompt[i] = ' ';
897 control_prompt[i] = '>';
898 control_prompt[i + 1] = '\0';
899 prompt_ptr = (char *) &control_prompt[0];
904 return command_line_input (prompt_ptr, instream == stdin, "commands");
907 /* Process one input line. If the command is an "end", return such an
908 indication to the caller. If PARSE_COMMANDS is true, strip leading
909 whitespace (trailing whitespace is always stripped) in the line,
910 attempt to recognize GDB control commands, and also return an
911 indication if the command is an "else" or a nop.
913 Otherwise, only "end" is recognized. */
915 static enum misc_command_type
916 process_next_line (char *p, struct command_line **command, int parse_commands,
917 void (*validator)(char *, void *), void *closure)
923 /* Not sure what to do here. */
927 /* Strip trailing whitespace. */
928 p_end = p + strlen (p);
929 while (p_end > p && (p_end[-1] == ' ' || p_end[-1] == '\t'))
933 /* Strip leading whitespace. */
934 while (p_start < p_end && (*p_start == ' ' || *p_start == '\t'))
937 /* 'end' is always recognized, regardless of parse_commands value.
938 We also permit whitespace before end and after. */
939 if (p_end - p_start == 3 && !strncmp (p_start, "end", 3))
944 /* If commands are parsed, we skip initial spaces. Otherwise,
945 which is the case for Python commands and documentation
946 (see the 'document' command), spaces are preserved. */
949 /* Blanks and comments don't really do anything, but we need to
950 distinguish them from else, end and other commands which can
952 if (p_end == p || p[0] == '#')
955 /* Is the else clause of an if control structure? */
956 if (p_end - p == 4 && !strncmp (p, "else", 4))
959 /* Check for while, if, break, continue, etc and build a new
960 command line structure for them. */
961 if ((p_end - p >= 14 && !strncmp (p, "while-stepping", 14))
962 || (p_end - p >= 8 && !strncmp (p, "stepping", 8))
963 || (p_end - p >= 2 && !strncmp (p, "ws", 2)))
965 /* Because validate_actionline and encode_action lookup
966 command's line as command, we need the line to
967 include 'while-stepping'.
969 For 'ws' alias, the command will have 'ws', not expanded
970 to 'while-stepping'. This is intentional -- we don't
971 really want frontend to send a command list with 'ws',
972 and next break-info returning command line with
973 'while-stepping'. This should work, but might cause the
974 breakpoint to be marked as changed while it's actually
976 *command = build_command_line (while_stepping_control, p);
978 else if (p_end - p > 5 && !strncmp (p, "while", 5))
983 while (first_arg < p_end && isspace (*first_arg))
985 *command = build_command_line (while_control, first_arg);
987 else if (p_end - p > 2 && !strncmp (p, "if", 2))
992 while (first_arg < p_end && isspace (*first_arg))
994 *command = build_command_line (if_control, first_arg);
996 else if (p_end - p >= 8 && !strncmp (p, "commands", 8))
1001 while (first_arg < p_end && isspace (*first_arg))
1003 *command = build_command_line (commands_control, first_arg);
1005 else if (p_end - p == 6 && !strncmp (p, "python", 6))
1007 /* Note that we ignore the inline "python command" form
1009 *command = build_command_line (python_control, "");
1011 else if (p_end - p == 10 && !strncmp (p, "loop_break", 10))
1013 *command = (struct command_line *)
1014 xmalloc (sizeof (struct command_line));
1015 (*command)->next = NULL;
1016 (*command)->line = NULL;
1017 (*command)->control_type = break_control;
1018 (*command)->body_count = 0;
1019 (*command)->body_list = NULL;
1021 else if (p_end - p == 13 && !strncmp (p, "loop_continue", 13))
1023 *command = (struct command_line *)
1024 xmalloc (sizeof (struct command_line));
1025 (*command)->next = NULL;
1026 (*command)->line = NULL;
1027 (*command)->control_type = continue_control;
1028 (*command)->body_count = 0;
1029 (*command)->body_list = NULL;
1035 if (!parse_commands || not_handled)
1037 /* A normal command. */
1038 *command = (struct command_line *)
1039 xmalloc (sizeof (struct command_line));
1040 (*command)->next = NULL;
1041 (*command)->line = savestring (p, p_end - p);
1042 (*command)->control_type = simple_control;
1043 (*command)->body_count = 0;
1044 (*command)->body_list = NULL;
1049 volatile struct gdb_exception ex;
1051 TRY_CATCH (ex, RETURN_MASK_ALL)
1053 validator ((*command)->line, closure);
1058 throw_exception (ex);
1062 /* Nothing special. */
1066 /* Recursively read in the control structures and create a
1067 command_line structure from them. Use read_next_line_func to
1068 obtain lines of the command. */
1070 static enum command_control_type
1071 recurse_read_control_structure (char * (*read_next_line_func) (void),
1072 struct command_line *current_cmd,
1073 void (*validator)(char *, void *),
1076 int current_body, i;
1077 enum misc_command_type val;
1078 enum command_control_type ret;
1079 struct command_line **body_ptr, *child_tail, *next;
1084 /* Sanity checks. */
1085 if (current_cmd->control_type == simple_control)
1086 error (_("Recursed on a simple control type."));
1088 if (current_body > current_cmd->body_count)
1089 error (_("Allocated body is smaller than this command type needs."));
1091 /* Read lines from the input stream and build control structures. */
1097 val = process_next_line (read_next_line_func (), &next,
1098 current_cmd->control_type != python_control,
1099 validator, closure);
1101 /* Just skip blanks and comments. */
1102 if (val == nop_command)
1105 if (val == end_command)
1107 if (current_cmd->control_type == while_control
1108 || current_cmd->control_type == while_stepping_control
1109 || current_cmd->control_type == if_control
1110 || current_cmd->control_type == python_control
1111 || current_cmd->control_type == commands_control)
1113 /* Success reading an entire canned sequence of commands. */
1114 ret = simple_control;
1119 ret = invalid_control;
1124 /* Not the end of a control structure. */
1125 if (val == else_command)
1127 if (current_cmd->control_type == if_control
1128 && current_body == 1)
1130 realloc_body_list (current_cmd, 2);
1137 ret = invalid_control;
1144 child_tail->next = next;
1148 body_ptr = current_cmd->body_list;
1149 for (i = 1; i < current_body; i++)
1158 /* If the latest line is another control structure, then recurse
1160 if (next->control_type == while_control
1161 || next->control_type == while_stepping_control
1162 || next->control_type == if_control
1163 || next->control_type == python_control
1164 || next->control_type == commands_control)
1167 ret = recurse_read_control_structure (read_next_line_func, next,
1168 validator, closure);
1171 if (ret != simple_control)
1182 restore_interp (void *arg)
1184 interp_set_temp (interp_name ((struct interp *)arg));
1187 /* Read lines from the input stream and accumulate them in a chain of
1188 struct command_line's, which is then returned. For input from a
1189 terminal, the special command "end" is used to mark the end of the
1190 input, and is not included in the returned chain of commands.
1192 If PARSE_COMMANDS is true, strip leading whitespace (trailing whitespace
1193 is always stripped) in the line and attempt to recognize GDB control
1194 commands. Otherwise, only "end" is recognized. */
1196 #define END_MESSAGE "End with a line saying just \"end\"."
1198 struct command_line *
1199 read_command_lines (char *prompt_arg, int from_tty, int parse_commands,
1200 void (*validator)(char *, void *), void *closure)
1202 struct command_line *head;
1204 if (from_tty && input_from_terminal_p ())
1206 if (deprecated_readline_begin_hook)
1208 /* Note - intentional to merge messages with no newline. */
1209 (*deprecated_readline_begin_hook) ("%s %s\n", prompt_arg,
1214 printf_unfiltered ("%s\n%s\n", prompt_arg, END_MESSAGE);
1215 gdb_flush (gdb_stdout);
1220 /* Reading commands assumes the CLI behavior, so temporarily
1221 override the current interpreter with CLI. */
1222 if (current_interp_named_p (INTERP_CONSOLE))
1223 head = read_command_lines_1 (read_next_line, parse_commands,
1224 validator, closure);
1227 struct interp *old_interp = interp_set_temp (INTERP_CONSOLE);
1228 struct cleanup *old_chain = make_cleanup (restore_interp, old_interp);
1230 head = read_command_lines_1 (read_next_line, parse_commands,
1231 validator, closure);
1232 do_cleanups (old_chain);
1235 if (deprecated_readline_end_hook && from_tty && input_from_terminal_p ())
1237 (*deprecated_readline_end_hook) ();
1242 /* Act the same way as read_command_lines, except that each new line is
1243 obtained using READ_NEXT_LINE_FUNC. */
1245 struct command_line *
1246 read_command_lines_1 (char * (*read_next_line_func) (void), int parse_commands,
1247 void (*validator)(char *, void *), void *closure)
1249 struct command_line *head, *tail, *next;
1250 struct cleanup *old_chain;
1251 enum command_control_type ret;
1252 enum misc_command_type val;
1261 val = process_next_line (read_next_line_func (), &next, parse_commands,
1262 validator, closure);
1264 /* Ignore blank lines or comments. */
1265 if (val == nop_command)
1268 if (val == end_command)
1270 ret = simple_control;
1274 if (val != ok_command)
1276 ret = invalid_control;
1280 if (next->control_type == while_control
1281 || next->control_type == if_control
1282 || next->control_type == python_control
1283 || next->control_type == commands_control
1284 || next->control_type == while_stepping_control)
1287 ret = recurse_read_control_structure (read_next_line_func, next,
1288 validator, closure);
1291 if (ret == invalid_control)
1302 old_chain = make_cleanup_free_command_lines (&head);
1311 if (ret != invalid_control)
1313 discard_cleanups (old_chain);
1316 do_cleanups (old_chain);
1322 /* Free a chain of struct command_line's. */
1325 free_command_lines (struct command_line **lptr)
1327 struct command_line *l = *lptr;
1328 struct command_line *next;
1329 struct command_line **blist;
1334 if (l->body_count > 0)
1336 blist = l->body_list;
1337 for (i = 0; i < l->body_count; i++, blist++)
1338 free_command_lines (blist);
1349 do_free_command_lines_cleanup (void *arg)
1351 free_command_lines (arg);
1355 make_cleanup_free_command_lines (struct command_line **arg)
1357 return make_cleanup (do_free_command_lines_cleanup, arg);
1360 struct command_line *
1361 copy_command_lines (struct command_line *cmds)
1363 struct command_line *result = NULL;
1367 result = (struct command_line *) xmalloc (sizeof (struct command_line));
1369 result->next = copy_command_lines (cmds->next);
1370 result->line = xstrdup (cmds->line);
1371 result->control_type = cmds->control_type;
1372 result->body_count = cmds->body_count;
1373 if (cmds->body_count > 0)
1377 result->body_list = (struct command_line **)
1378 xmalloc (sizeof (struct command_line *) * cmds->body_count);
1380 for (i = 0; i < cmds->body_count; i++)
1381 result->body_list[i] = copy_command_lines (cmds->body_list[i]);
1384 result->body_list = NULL;
1390 /* Validate that *COMNAME is a valid name for a command. Return the
1391 containing command list, in case it starts with a prefix command.
1392 The prefix must already exist. *COMNAME is advanced to point after
1393 any prefix, and a NUL character overwrites the space after the
1396 static struct cmd_list_element **
1397 validate_comname (char **comname)
1399 struct cmd_list_element **list = &cmdlist;
1400 char *p, *last_word;
1403 error_no_arg (_("name of command to define"));
1405 /* Find the last word of the argument. */
1406 p = *comname + strlen (*comname);
1407 while (p > *comname && isspace (p[-1]))
1409 while (p > *comname && !isspace (p[-1]))
1413 /* Find the corresponding command list. */
1414 if (last_word != *comname)
1416 struct cmd_list_element *c;
1417 char saved_char, *tem = *comname;
1419 /* Separate the prefix and the command. */
1420 saved_char = last_word[-1];
1421 last_word[-1] = '\0';
1423 c = lookup_cmd (&tem, cmdlist, "", 0, 1);
1424 if (c->prefixlist == NULL)
1425 error (_("\"%s\" is not a prefix command."), *comname);
1427 list = c->prefixlist;
1428 last_word[-1] = saved_char;
1429 *comname = last_word;
1435 if (!isalnum (*p) && *p != '-' && *p != '_')
1436 error (_("Junk in argument list: \"%s\""), p);
1443 /* This is just a placeholder in the command data structures. */
1445 user_defined_command (char *ignore, int from_tty)
1450 define_command (char *comname, int from_tty)
1452 #define MAX_TMPBUF 128
1459 struct command_line *cmds;
1460 struct cmd_list_element *c, *newc, *hookc = 0, **list;
1461 char *tem, *comfull;
1462 char tmpbuf[MAX_TMPBUF];
1463 int hook_type = CMD_NO_HOOK;
1464 int hook_name_size = 0;
1466 #define HOOK_STRING "hook-"
1468 #define HOOK_POST_STRING "hookpost-"
1469 #define HOOK_POST_LEN 9
1472 list = validate_comname (&comname);
1474 /* Look it up, and verify that we got an exact match. */
1476 c = lookup_cmd (&tem, *list, "", -1, 1);
1477 if (c && strcmp (comname, c->name) != 0)
1484 if (c->class == class_user || c->class == class_alias)
1485 q = query (_("Redefine command \"%s\"? "), c->name);
1487 q = query (_("Really redefine built-in command \"%s\"? "), c->name);
1489 error (_("Command \"%s\" not redefined."), c->name);
1492 /* If this new command is a hook, then mark the command which it
1493 is hooking. Note that we allow hooking `help' commands, so that
1494 we can hook the `stop' pseudo-command. */
1496 if (!strncmp (comname, HOOK_STRING, HOOK_LEN))
1498 hook_type = CMD_PRE_HOOK;
1499 hook_name_size = HOOK_LEN;
1501 else if (!strncmp (comname, HOOK_POST_STRING, HOOK_POST_LEN))
1503 hook_type = CMD_POST_HOOK;
1504 hook_name_size = HOOK_POST_LEN;
1507 if (hook_type != CMD_NO_HOOK)
1509 /* Look up cmd it hooks, and verify that we got an exact match. */
1510 tem = comname + hook_name_size;
1511 hookc = lookup_cmd (&tem, *list, "", -1, 0);
1512 if (hookc && strcmp (comname + hook_name_size, hookc->name) != 0)
1516 warning (_("Your new `%s' command does not "
1517 "hook any existing command."),
1519 if (!query (_("Proceed? ")))
1520 error (_("Not confirmed."));
1524 comname = xstrdup (comname);
1526 /* If the rest of the commands will be case insensitive, this one
1527 should behave in the same manner. */
1528 for (tem = comname; *tem; tem++)
1530 *tem = tolower (*tem);
1532 sprintf (tmpbuf, "Type commands for definition of \"%s\".", comfull);
1533 cmds = read_command_lines (tmpbuf, from_tty, 1, 0, 0);
1535 if (c && c->class == class_user)
1536 free_command_lines (&c->user_commands);
1538 newc = add_cmd (comname, class_user, user_defined_command,
1539 (c && c->class == class_user)
1540 ? c->doc : xstrdup ("User-defined."), list);
1541 newc->user_commands = cmds;
1543 /* If this new command is a hook, then mark both commands as being
1550 hookc->hook_pre = newc; /* Target gets hooked. */
1551 newc->hookee_pre = hookc; /* We are marked as hooking target cmd. */
1554 hookc->hook_post = newc; /* Target gets hooked. */
1555 newc->hookee_post = hookc; /* We are marked as hooking
1559 /* Should never come here as hookc would be 0. */
1560 internal_error (__FILE__, __LINE__, _("bad switch"));
1566 document_command (char *comname, int from_tty)
1568 struct command_line *doclines;
1569 struct cmd_list_element *c, **list;
1570 char *tem, *comfull;
1574 list = validate_comname (&comname);
1577 c = lookup_cmd (&tem, *list, "", 0, 1);
1579 if (c->class != class_user)
1580 error (_("Command \"%s\" is built-in."), comfull);
1582 sprintf (tmpbuf, "Type documentation for \"%s\".", comfull);
1583 doclines = read_command_lines (tmpbuf, from_tty, 0, 0, 0);
1589 struct command_line *cl1;
1592 for (cl1 = doclines; cl1; cl1 = cl1->next)
1593 len += strlen (cl1->line) + 1;
1595 c->doc = (char *) xmalloc (len + 1);
1598 for (cl1 = doclines; cl1; cl1 = cl1->next)
1600 strcat (c->doc, cl1->line);
1602 strcat (c->doc, "\n");
1606 free_command_lines (&doclines);
1609 struct source_cleanup_lines_args
1612 const char *old_file;
1616 source_cleanup_lines (void *args)
1618 struct source_cleanup_lines_args *p =
1619 (struct source_cleanup_lines_args *) args;
1621 source_line_number = p->old_line;
1622 source_file_name = p->old_file;
1625 /* Used to implement source_command. */
1628 script_from_file (FILE *stream, const char *file)
1630 struct cleanup *old_cleanups;
1631 struct source_cleanup_lines_args old_lines;
1634 internal_error (__FILE__, __LINE__, _("called with NULL file pointer!"));
1636 old_lines.old_line = source_line_number;
1637 old_lines.old_file = source_file_name;
1638 old_cleanups = make_cleanup (source_cleanup_lines, &old_lines);
1639 source_line_number = 0;
1640 source_file_name = file;
1641 /* This will get set every time we read a line. So it won't stay ""
1643 error_pre_print = "";
1646 volatile struct gdb_exception e;
1648 TRY_CATCH (e, RETURN_MASK_ERROR)
1650 read_command_file (stream);
1657 /* Re-throw the error, but with the file name information
1659 throw_error (e.error,
1660 _("%s:%d: Error in sourced command file:\n%s"),
1661 source_file_name, source_line_number, e.message);
1663 internal_error (__FILE__, __LINE__, _("bad reason"));
1667 do_cleanups (old_cleanups);
1670 /* Print the definition of user command C to STREAM. Or, if C is a
1671 prefix command, show the definitions of all user commands under C
1672 (recursively). PREFIX and NAME combined are the name of the
1675 show_user_1 (struct cmd_list_element *c, char *prefix, char *name,
1676 struct ui_file *stream)
1678 struct command_line *cmdlines;
1680 if (c->prefixlist != NULL)
1682 char *prefixname = c->prefixname;
1684 for (c = *c->prefixlist; c != NULL; c = c->next)
1685 if (c->class == class_user || c->prefixlist != NULL)
1686 show_user_1 (c, prefixname, c->name, gdb_stdout);
1690 cmdlines = c->user_commands;
1693 fprintf_filtered (stream, "User command \"%s%s\":\n", prefix, name);
1695 print_command_lines (current_uiout, cmdlines, 1);
1696 fputs_filtered ("\n", stream);