1 /* GDB CLI command scripting.
3 Copyright (C) 1986-2014 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 "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 "extension.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 /* Return non-zero if TYPE is a multi-line command (i.e., is terminated
85 multi_line_command_p (enum command_control_type type)
91 case while_stepping_control:
92 case commands_control:
101 /* Allocate, initialize a new command line structure for one of the
102 control commands (if/while). */
104 static struct command_line *
105 build_command_line (enum command_control_type type, char *args)
107 struct command_line *cmd;
109 if (args == NULL && (type == if_control || type == while_control))
110 error (_("if/while commands require arguments."));
111 gdb_assert (args != NULL);
113 cmd = (struct command_line *) xmalloc (sizeof (struct command_line));
115 cmd->control_type = type;
119 = (struct command_line **) xmalloc (sizeof (struct command_line *)
121 memset (cmd->body_list, 0, sizeof (struct command_line *) * cmd->body_count);
122 cmd->line = xstrdup (args);
127 /* Build and return a new command structure for the control commands
128 such as "if" and "while". */
130 struct command_line *
131 get_command_line (enum command_control_type type, char *arg)
133 struct command_line *cmd;
134 struct cleanup *old_chain = NULL;
136 /* Allocate and build a new command line structure. */
137 cmd = build_command_line (type, arg);
139 old_chain = make_cleanup_free_command_lines (&cmd);
141 /* Read in the body of this command. */
142 if (recurse_read_control_structure (read_next_line, cmd, 0, 0)
145 warning (_("Error reading in canned sequence of commands."));
146 do_cleanups (old_chain);
150 discard_cleanups (old_chain);
154 /* Recursively print a command (including full control structures). */
157 print_command_lines (struct ui_out *uiout, struct command_line *cmd,
160 struct command_line *list;
166 ui_out_spaces (uiout, 2 * depth);
168 /* A simple command, print it and continue. */
169 if (list->control_type == simple_control)
171 ui_out_field_string (uiout, NULL, list->line);
172 ui_out_text (uiout, "\n");
177 /* loop_continue to jump to the start of a while loop, print it
179 if (list->control_type == continue_control)
181 ui_out_field_string (uiout, NULL, "loop_continue");
182 ui_out_text (uiout, "\n");
187 /* loop_break to break out of a while loop, print it and
189 if (list->control_type == break_control)
191 ui_out_field_string (uiout, NULL, "loop_break");
192 ui_out_text (uiout, "\n");
197 /* A while command. Recursively print its subcommands and
199 if (list->control_type == while_control
200 || list->control_type == while_stepping_control)
202 /* For while-stepping, the line includes the 'while-stepping'
203 token. See comment in process_next_line for explanation.
204 Here, take care not print 'while-stepping' twice. */
205 if (list->control_type == while_control)
206 ui_out_field_fmt (uiout, NULL, "while %s", list->line);
208 ui_out_field_string (uiout, NULL, list->line);
209 ui_out_text (uiout, "\n");
210 print_command_lines (uiout, *list->body_list, depth + 1);
212 ui_out_spaces (uiout, 2 * depth);
213 ui_out_field_string (uiout, NULL, "end");
214 ui_out_text (uiout, "\n");
219 /* An if command. Recursively print both arms before
221 if (list->control_type == if_control)
223 ui_out_field_fmt (uiout, NULL, "if %s", list->line);
224 ui_out_text (uiout, "\n");
226 print_command_lines (uiout, list->body_list[0], depth + 1);
228 /* Show the false arm if it exists. */
229 if (list->body_count == 2)
232 ui_out_spaces (uiout, 2 * depth);
233 ui_out_field_string (uiout, NULL, "else");
234 ui_out_text (uiout, "\n");
235 print_command_lines (uiout, list->body_list[1], depth + 1);
239 ui_out_spaces (uiout, 2 * depth);
240 ui_out_field_string (uiout, NULL, "end");
241 ui_out_text (uiout, "\n");
246 /* A commands command. Print the breakpoint commands and
248 if (list->control_type == commands_control)
251 ui_out_field_fmt (uiout, NULL, "commands %s", list->line);
253 ui_out_field_string (uiout, NULL, "commands");
254 ui_out_text (uiout, "\n");
255 print_command_lines (uiout, *list->body_list, depth + 1);
257 ui_out_spaces (uiout, 2 * depth);
258 ui_out_field_string (uiout, NULL, "end");
259 ui_out_text (uiout, "\n");
264 if (list->control_type == python_control)
266 ui_out_field_string (uiout, NULL, "python");
267 ui_out_text (uiout, "\n");
268 /* Don't indent python code at all. */
269 print_command_lines (uiout, *list->body_list, 0);
271 ui_out_spaces (uiout, 2 * depth);
272 ui_out_field_string (uiout, NULL, "end");
273 ui_out_text (uiout, "\n");
278 if (list->control_type == guile_control)
280 ui_out_field_string (uiout, NULL, "guile");
281 ui_out_text (uiout, "\n");
282 print_command_lines (uiout, *list->body_list, depth + 1);
284 ui_out_spaces (uiout, 2 * depth);
285 ui_out_field_string (uiout, NULL, "end");
286 ui_out_text (uiout, "\n");
291 /* Ignore illegal command type and try next. */
296 /* Handle pre-post hooks. */
299 clear_hook_in_cleanup (void *data)
301 struct cmd_list_element *c = data;
303 c->hook_in = 0; /* Allow hook to work again once it is complete. */
307 execute_cmd_pre_hook (struct cmd_list_element *c)
309 if ((c->hook_pre) && (!c->hook_in))
311 struct cleanup *cleanups = make_cleanup (clear_hook_in_cleanup, c);
312 c->hook_in = 1; /* Prevent recursive hooking. */
313 execute_user_command (c->hook_pre, (char *) 0);
314 do_cleanups (cleanups);
319 execute_cmd_post_hook (struct cmd_list_element *c)
321 if ((c->hook_post) && (!c->hook_in))
323 struct cleanup *cleanups = make_cleanup (clear_hook_in_cleanup, c);
325 c->hook_in = 1; /* Prevent recursive hooking. */
326 execute_user_command (c->hook_post, (char *) 0);
327 do_cleanups (cleanups);
331 /* Execute the command in CMD. */
333 do_restore_user_call_depth (void * call_depth)
335 int *depth = call_depth;
344 execute_user_command (struct cmd_list_element *c, char *args)
346 struct command_line *cmdlines;
347 struct cleanup *old_chain;
348 enum command_control_type ret;
349 static int user_call_depth = 0;
350 extern unsigned int max_user_call_depth;
352 cmdlines = c->user_commands;
357 old_chain = setup_user_args (args);
359 if (++user_call_depth > max_user_call_depth)
360 error (_("Max user call depth exceeded -- command aborted."));
362 make_cleanup (do_restore_user_call_depth, &user_call_depth);
364 /* Set the instream to 0, indicating execution of a
365 user-defined function. */
366 make_cleanup (do_restore_instream_cleanup, instream);
367 instream = (FILE *) 0;
369 /* Also set the global in_user_command, so that NULL instream is
370 not confused with Insight. */
373 make_cleanup_restore_integer (&interpreter_async);
374 interpreter_async = 0;
376 command_nest_depth++;
379 ret = execute_control_command (cmdlines);
380 if (ret != simple_control && ret != break_control)
382 warning (_("Error executing canned sequence of commands."));
385 cmdlines = cmdlines->next;
387 command_nest_depth--;
388 do_cleanups (old_chain);
391 /* This function is called every time GDB prints a prompt. It ensures
392 that errors and the like do not confuse the command tracing. */
395 reset_command_nest_depth (void)
397 command_nest_depth = 1;
400 suppress_next_print_command_trace = 0;
403 /* Print the command, prefixed with '+' to represent the call depth.
404 This is slightly complicated because this function may be called
405 from execute_command and execute_control_command. Unfortunately
406 execute_command also prints the top level control commands.
407 In these cases execute_command will call execute_control_command
408 via while_command or if_command. Inner levels of 'if' and 'while'
409 are dealt with directly. Therefore we can use these functions
410 to determine whether the command has been printed already or not. */
412 print_command_trace (const char *cmd)
416 if (suppress_next_print_command_trace)
418 suppress_next_print_command_trace = 0;
422 if (!source_verbose && !trace_commands)
425 for (i=0; i < command_nest_depth; i++)
426 printf_filtered ("+");
428 printf_filtered ("%s\n", cmd);
431 enum command_control_type
432 execute_control_command (struct command_line *cmd)
434 struct expression *expr;
435 struct command_line *current;
436 struct cleanup *old_chain = make_cleanup (null_cleanup, 0);
438 struct value *val_mark;
440 enum command_control_type ret;
443 /* Start by assuming failure, if a problem is detected, the code
444 below will simply "break" out of the switch. */
445 ret = invalid_control;
447 switch (cmd->control_type)
450 /* A simple command, execute it and return. */
451 new_line = insert_args (cmd->line);
454 make_cleanup (free_current_contents, &new_line);
455 execute_command (new_line, 0);
456 ret = cmd->control_type;
459 case continue_control:
460 print_command_trace ("loop_continue");
462 /* Return for "continue", and "break" so we can either
463 continue the loop at the top, or break out. */
464 ret = cmd->control_type;
468 print_command_trace ("loop_break");
470 /* Return for "continue", and "break" so we can either
471 continue the loop at the top, or break out. */
472 ret = cmd->control_type;
477 int len = strlen (cmd->line) + 7;
478 char *buffer = alloca (len);
480 xsnprintf (buffer, len, "while %s", cmd->line);
481 print_command_trace (buffer);
483 /* Parse the loop control expression for the while statement. */
484 new_line = insert_args (cmd->line);
487 make_cleanup (free_current_contents, &new_line);
488 expr = parse_expression (new_line);
489 make_cleanup (free_current_contents, &expr);
491 ret = simple_control;
494 /* Keep iterating so long as the expression is true. */
501 /* Evaluate the expression. */
502 val_mark = value_mark ();
503 val = evaluate_expression (expr);
504 cond_result = value_true (val);
505 value_free_to_mark (val_mark);
507 /* If the value is false, then break out of the loop. */
511 /* Execute the body of the while statement. */
512 current = *cmd->body_list;
515 command_nest_depth++;
516 ret = execute_control_command (current);
517 command_nest_depth--;
519 /* If we got an error, or a "break" command, then stop
521 if (ret == invalid_control || ret == break_control)
527 /* If we got a "continue" command, then restart the loop
529 if (ret == continue_control)
532 /* Get the next statement. */
533 current = current->next;
537 /* Reset RET so that we don't recurse the break all the way down. */
538 if (ret == break_control)
539 ret = simple_control;
546 int len = strlen (cmd->line) + 4;
547 char *buffer = alloca (len);
549 xsnprintf (buffer, len, "if %s", cmd->line);
550 print_command_trace (buffer);
552 new_line = insert_args (cmd->line);
555 make_cleanup (free_current_contents, &new_line);
556 /* Parse the conditional for the if statement. */
557 expr = parse_expression (new_line);
558 make_cleanup (free_current_contents, &expr);
561 ret = simple_control;
563 /* Evaluate the conditional. */
564 val_mark = value_mark ();
565 val = evaluate_expression (expr);
567 /* Choose which arm to take commands from based on the value
568 of the conditional expression. */
569 if (value_true (val))
570 current = *cmd->body_list;
571 else if (cmd->body_count == 2)
572 current = *(cmd->body_list + 1);
573 value_free_to_mark (val_mark);
575 /* Execute commands in the given arm. */
578 command_nest_depth++;
579 ret = execute_control_command (current);
580 command_nest_depth--;
582 /* If we got an error, get out. */
583 if (ret != simple_control)
586 /* Get the next statement in the body. */
587 current = current->next;
593 case commands_control:
595 /* Breakpoint commands list, record the commands in the
596 breakpoint's command list and return. */
597 new_line = insert_args (cmd->line);
600 make_cleanup (free_current_contents, &new_line);
601 ret = commands_from_control_command (new_line, cmd);
608 eval_ext_lang_from_control_command (cmd);
609 ret = simple_control;
614 warning (_("Invalid control type in canned commands structure."));
618 do_cleanups (old_chain);
623 /* Like execute_control_command, but first set
624 suppress_next_print_command_trace. */
626 enum command_control_type
627 execute_control_command_untraced (struct command_line *cmd)
629 suppress_next_print_command_trace = 1;
630 return execute_control_command (cmd);
634 /* "while" command support. Executes a body of statements while the
635 loop condition is nonzero. */
638 while_command (char *arg, int from_tty)
640 struct command_line *command = NULL;
641 struct cleanup *old_chain;
644 command = get_command_line (while_control, arg);
649 old_chain = make_cleanup_restore_integer (&interpreter_async);
650 interpreter_async = 0;
652 execute_control_command_untraced (command);
653 free_command_lines (&command);
655 do_cleanups (old_chain);
658 /* "if" command support. Execute either the true or false arm depending
659 on the value of the if conditional. */
662 if_command (char *arg, int from_tty)
664 struct command_line *command = NULL;
665 struct cleanup *old_chain;
668 command = get_command_line (if_control, arg);
673 old_chain = make_cleanup_restore_integer (&interpreter_async);
674 interpreter_async = 0;
676 execute_control_command_untraced (command);
677 free_command_lines (&command);
679 do_cleanups (old_chain);
684 arg_cleanup (void *ignore)
686 struct user_args *oargs = user_args;
689 internal_error (__FILE__, __LINE__,
690 _("arg_cleanup called with no user args.\n"));
692 user_args = user_args->next;
693 xfree (oargs->command);
697 /* Bind the incomming arguments for a user defined command to
698 $arg0, $arg1 ... $argMAXUSERARGS. */
700 static struct cleanup *
701 setup_user_args (char *p)
703 struct user_args *args;
704 struct cleanup *old_chain;
705 unsigned int arg_count = 0;
707 args = (struct user_args *) xmalloc (sizeof (struct user_args));
708 memset (args, 0, sizeof (struct user_args));
710 args->next = user_args;
713 old_chain = make_cleanup (arg_cleanup, 0/*ignored*/);
718 user_args->command = p = xstrdup (p);
727 if (arg_count >= MAXUSERARGS)
728 error (_("user defined function may only have %d arguments."),
731 /* Strip whitespace. */
732 while (*p == ' ' || *p == '\t')
735 /* P now points to an argument. */
737 user_args->a[arg_count].arg = p;
739 /* Get to the end of this argument. */
742 if (((*p == ' ' || *p == '\t')) && !squote && !dquote && !bsquote)
771 user_args->a[arg_count].len = p - start_arg;
778 /* Given character string P, return a point to the first argument
779 ($arg), or NULL if P contains no arguments. */
784 while ((p = strchr (p, '$')))
786 if (strncmp (p, "$arg", 4) == 0
787 && (isdigit (p[4]) || p[4] == 'c'))
794 /* Insert the user defined arguments stored in user_arg into the $arg
795 arguments found in line, with the updated copy being placed into
799 insert_args (char *line)
801 char *p, *save_line, *new_line;
804 /* If we are not in a user-defined function, treat $argc, $arg0, et
805 cetera as normal convenience variables. */
806 if (user_args == NULL)
807 return xstrdup (line);
809 /* First we need to know how much memory to allocate for the new
813 while ((p = locate_arg (line)))
820 /* $argc. Number will be <=10. */
821 len += user_args->count == 10 ? 2 : 1;
823 else if (i >= user_args->count)
825 error (_("Missing argument %d in user function."), i);
830 len += user_args->a[i].len;
835 /* Don't forget the tail. */
836 len += strlen (line);
838 /* Allocate space for the new line and fill it in. */
839 new_line = (char *) xmalloc (len + 1);
840 if (new_line == NULL)
843 /* Restore pointer to beginning of old line. */
846 /* Save pointer to beginning of new line. */
847 save_line = new_line;
849 while ((p = locate_arg (line)))
853 memcpy (new_line, line, p - line);
854 new_line += p - line;
858 gdb_assert (user_args->count >= 0 && user_args->count <= 10);
859 if (user_args->count == 10)
865 *(new_line++) = user_args->count + '0';
870 len = user_args->a[i].len;
873 memcpy (new_line, user_args->a[i].arg, len);
879 /* Don't forget the tail. */
880 strcpy (new_line, line);
882 /* Return a pointer to the beginning of the new line. */
887 /* Expand the body_list of COMMAND so that it can hold NEW_LENGTH
888 code bodies. This is typically used when we encounter an "else"
889 clause for an "if" command. */
892 realloc_body_list (struct command_line *command, int new_length)
895 struct command_line **body_list;
897 n = command->body_count;
903 body_list = (struct command_line **)
904 xmalloc (sizeof (struct command_line *) * new_length);
906 memcpy (body_list, command->body_list, sizeof (struct command_line *) * n);
907 memset (body_list + n, 0, sizeof (struct command_line *) * (new_length - n));
909 xfree (command->body_list);
910 command->body_list = body_list;
911 command->body_count = new_length;
914 /* Read next line from stdout. Passed to read_command_line_1 and
915 recurse_read_control_structure whenever we need to read commands
919 read_next_line (void)
921 char *prompt_ptr, control_prompt[256];
924 if (control_level >= 254)
925 error (_("Control nesting too deep!"));
927 /* Set a prompt based on the nesting of the control commands. */
928 if (instream == stdin || (instream == 0 && deprecated_readline_hook != NULL))
930 for (i = 0; i < control_level; i++)
931 control_prompt[i] = ' ';
932 control_prompt[i] = '>';
933 control_prompt[i + 1] = '\0';
934 prompt_ptr = (char *) &control_prompt[0];
939 return command_line_input (prompt_ptr, instream == stdin, "commands");
942 /* Process one input line. If the command is an "end", return such an
943 indication to the caller. If PARSE_COMMANDS is true, strip leading
944 whitespace (trailing whitespace is always stripped) in the line,
945 attempt to recognize GDB control commands, and also return an
946 indication if the command is an "else" or a nop.
948 Otherwise, only "end" is recognized. */
950 static enum misc_command_type
951 process_next_line (char *p, struct command_line **command, int parse_commands,
952 void (*validator)(char *, void *), void *closure)
958 /* Not sure what to do here. */
962 /* Strip trailing whitespace. */
963 p_end = p + strlen (p);
964 while (p_end > p && (p_end[-1] == ' ' || p_end[-1] == '\t'))
968 /* Strip leading whitespace. */
969 while (p_start < p_end && (*p_start == ' ' || *p_start == '\t'))
972 /* 'end' is always recognized, regardless of parse_commands value.
973 We also permit whitespace before end and after. */
974 if (p_end - p_start == 3 && !strncmp (p_start, "end", 3))
979 /* If commands are parsed, we skip initial spaces. Otherwise,
980 which is the case for Python commands and documentation
981 (see the 'document' command), spaces are preserved. */
984 /* Blanks and comments don't really do anything, but we need to
985 distinguish them from else, end and other commands which can
987 if (p_end == p || p[0] == '#')
990 /* Is the else clause of an if control structure? */
991 if (p_end - p == 4 && !strncmp (p, "else", 4))
994 /* Check for while, if, break, continue, etc and build a new
995 command line structure for them. */
996 if ((p_end - p >= 14 && !strncmp (p, "while-stepping", 14))
997 || (p_end - p >= 8 && !strncmp (p, "stepping", 8))
998 || (p_end - p >= 2 && !strncmp (p, "ws", 2)))
1000 /* Because validate_actionline and encode_action lookup
1001 command's line as command, we need the line to
1002 include 'while-stepping'.
1004 For 'ws' alias, the command will have 'ws', not expanded
1005 to 'while-stepping'. This is intentional -- we don't
1006 really want frontend to send a command list with 'ws',
1007 and next break-info returning command line with
1008 'while-stepping'. This should work, but might cause the
1009 breakpoint to be marked as changed while it's actually
1011 *command = build_command_line (while_stepping_control, p);
1013 else if (p_end - p > 5 && !strncmp (p, "while", 5))
1018 while (first_arg < p_end && isspace (*first_arg))
1020 *command = build_command_line (while_control, first_arg);
1022 else if (p_end - p > 2 && !strncmp (p, "if", 2))
1027 while (first_arg < p_end && isspace (*first_arg))
1029 *command = build_command_line (if_control, first_arg);
1031 else if (p_end - p >= 8 && !strncmp (p, "commands", 8))
1036 while (first_arg < p_end && isspace (*first_arg))
1038 *command = build_command_line (commands_control, first_arg);
1040 else if (p_end - p == 6 && !strncmp (p, "python", 6))
1042 /* Note that we ignore the inline "python command" form
1044 *command = build_command_line (python_control, "");
1046 else if (p_end - p == 5 && !strncmp (p, "guile", 5))
1048 /* Note that we ignore the inline "guile command" form here. */
1049 *command = build_command_line (guile_control, "");
1051 else if (p_end - p == 10 && !strncmp (p, "loop_break", 10))
1053 *command = (struct command_line *)
1054 xmalloc (sizeof (struct command_line));
1055 (*command)->next = NULL;
1056 (*command)->line = NULL;
1057 (*command)->control_type = break_control;
1058 (*command)->body_count = 0;
1059 (*command)->body_list = NULL;
1061 else if (p_end - p == 13 && !strncmp (p, "loop_continue", 13))
1063 *command = (struct command_line *)
1064 xmalloc (sizeof (struct command_line));
1065 (*command)->next = NULL;
1066 (*command)->line = NULL;
1067 (*command)->control_type = continue_control;
1068 (*command)->body_count = 0;
1069 (*command)->body_list = NULL;
1075 if (!parse_commands || not_handled)
1077 /* A normal command. */
1078 *command = (struct command_line *)
1079 xmalloc (sizeof (struct command_line));
1080 (*command)->next = NULL;
1081 (*command)->line = savestring (p, p_end - p);
1082 (*command)->control_type = simple_control;
1083 (*command)->body_count = 0;
1084 (*command)->body_list = NULL;
1089 volatile struct gdb_exception ex;
1091 TRY_CATCH (ex, RETURN_MASK_ALL)
1093 validator ((*command)->line, closure);
1098 throw_exception (ex);
1102 /* Nothing special. */
1106 /* Recursively read in the control structures and create a
1107 command_line structure from them. Use read_next_line_func to
1108 obtain lines of the command. */
1110 static enum command_control_type
1111 recurse_read_control_structure (char * (*read_next_line_func) (void),
1112 struct command_line *current_cmd,
1113 void (*validator)(char *, void *),
1116 int current_body, i;
1117 enum misc_command_type val;
1118 enum command_control_type ret;
1119 struct command_line **body_ptr, *child_tail, *next;
1124 /* Sanity checks. */
1125 if (current_cmd->control_type == simple_control)
1126 error (_("Recursed on a simple control type."));
1128 if (current_body > current_cmd->body_count)
1129 error (_("Allocated body is smaller than this command type needs."));
1131 /* Read lines from the input stream and build control structures. */
1137 val = process_next_line (read_next_line_func (), &next,
1138 current_cmd->control_type != python_control
1139 && current_cmd->control_type != guile_control,
1140 validator, closure);
1142 /* Just skip blanks and comments. */
1143 if (val == nop_command)
1146 if (val == end_command)
1148 if (multi_line_command_p (current_cmd->control_type))
1150 /* Success reading an entire canned sequence of commands. */
1151 ret = simple_control;
1156 ret = invalid_control;
1161 /* Not the end of a control structure. */
1162 if (val == else_command)
1164 if (current_cmd->control_type == if_control
1165 && current_body == 1)
1167 realloc_body_list (current_cmd, 2);
1174 ret = invalid_control;
1181 child_tail->next = next;
1185 body_ptr = current_cmd->body_list;
1186 for (i = 1; i < current_body; i++)
1195 /* If the latest line is another control structure, then recurse
1197 if (multi_line_command_p (next->control_type))
1200 ret = recurse_read_control_structure (read_next_line_func, next,
1201 validator, closure);
1204 if (ret != simple_control)
1215 restore_interp (void *arg)
1217 interp_set_temp (interp_name ((struct interp *)arg));
1220 /* Read lines from the input stream and accumulate them in a chain of
1221 struct command_line's, which is then returned. For input from a
1222 terminal, the special command "end" is used to mark the end of the
1223 input, and is not included in the returned chain of commands.
1225 If PARSE_COMMANDS is true, strip leading whitespace (trailing whitespace
1226 is always stripped) in the line and attempt to recognize GDB control
1227 commands. Otherwise, only "end" is recognized. */
1229 #define END_MESSAGE "End with a line saying just \"end\"."
1231 struct command_line *
1232 read_command_lines (char *prompt_arg, int from_tty, int parse_commands,
1233 void (*validator)(char *, void *), void *closure)
1235 struct command_line *head;
1237 if (from_tty && input_from_terminal_p ())
1239 if (deprecated_readline_begin_hook)
1241 /* Note - intentional to merge messages with no newline. */
1242 (*deprecated_readline_begin_hook) ("%s %s\n", prompt_arg,
1247 printf_unfiltered ("%s\n%s\n", prompt_arg, END_MESSAGE);
1248 gdb_flush (gdb_stdout);
1253 /* Reading commands assumes the CLI behavior, so temporarily
1254 override the current interpreter with CLI. */
1255 if (current_interp_named_p (INTERP_CONSOLE))
1256 head = read_command_lines_1 (read_next_line, parse_commands,
1257 validator, closure);
1260 struct interp *old_interp = interp_set_temp (INTERP_CONSOLE);
1261 struct cleanup *old_chain = make_cleanup (restore_interp, old_interp);
1263 head = read_command_lines_1 (read_next_line, parse_commands,
1264 validator, closure);
1265 do_cleanups (old_chain);
1268 if (deprecated_readline_end_hook && from_tty && input_from_terminal_p ())
1270 (*deprecated_readline_end_hook) ();
1275 /* Act the same way as read_command_lines, except that each new line is
1276 obtained using READ_NEXT_LINE_FUNC. */
1278 struct command_line *
1279 read_command_lines_1 (char * (*read_next_line_func) (void), int parse_commands,
1280 void (*validator)(char *, void *), void *closure)
1282 struct command_line *head, *tail, *next;
1283 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
1284 enum command_control_type ret;
1285 enum misc_command_type val;
1293 val = process_next_line (read_next_line_func (), &next, parse_commands,
1294 validator, closure);
1296 /* Ignore blank lines or comments. */
1297 if (val == nop_command)
1300 if (val == end_command)
1302 ret = simple_control;
1306 if (val != ok_command)
1308 ret = invalid_control;
1312 if (multi_line_command_p (next->control_type))
1315 ret = recurse_read_control_structure (read_next_line_func, next,
1316 validator, closure);
1319 if (ret == invalid_control)
1330 make_cleanup_free_command_lines (&head);
1337 if (ret != invalid_control)
1338 discard_cleanups (old_chain);
1340 do_cleanups (old_chain);
1345 /* Free a chain of struct command_line's. */
1348 free_command_lines (struct command_line **lptr)
1350 struct command_line *l = *lptr;
1351 struct command_line *next;
1352 struct command_line **blist;
1357 if (l->body_count > 0)
1359 blist = l->body_list;
1360 for (i = 0; i < l->body_count; i++, blist++)
1361 free_command_lines (blist);
1372 do_free_command_lines_cleanup (void *arg)
1374 free_command_lines (arg);
1378 make_cleanup_free_command_lines (struct command_line **arg)
1380 return make_cleanup (do_free_command_lines_cleanup, arg);
1383 struct command_line *
1384 copy_command_lines (struct command_line *cmds)
1386 struct command_line *result = NULL;
1390 result = (struct command_line *) xmalloc (sizeof (struct command_line));
1392 result->next = copy_command_lines (cmds->next);
1393 result->line = xstrdup (cmds->line);
1394 result->control_type = cmds->control_type;
1395 result->body_count = cmds->body_count;
1396 if (cmds->body_count > 0)
1400 result->body_list = (struct command_line **)
1401 xmalloc (sizeof (struct command_line *) * cmds->body_count);
1403 for (i = 0; i < cmds->body_count; i++)
1404 result->body_list[i] = copy_command_lines (cmds->body_list[i]);
1407 result->body_list = NULL;
1413 /* Validate that *COMNAME is a valid name for a command. Return the
1414 containing command list, in case it starts with a prefix command.
1415 The prefix must already exist. *COMNAME is advanced to point after
1416 any prefix, and a NUL character overwrites the space after the
1419 static struct cmd_list_element **
1420 validate_comname (char **comname)
1422 struct cmd_list_element **list = &cmdlist;
1423 char *p, *last_word;
1426 error_no_arg (_("name of command to define"));
1428 /* Find the last word of the argument. */
1429 p = *comname + strlen (*comname);
1430 while (p > *comname && isspace (p[-1]))
1432 while (p > *comname && !isspace (p[-1]))
1436 /* Find the corresponding command list. */
1437 if (last_word != *comname)
1439 struct cmd_list_element *c;
1441 const char *tem = *comname;
1443 /* Separate the prefix and the command. */
1444 saved_char = last_word[-1];
1445 last_word[-1] = '\0';
1447 c = lookup_cmd (&tem, cmdlist, "", 0, 1);
1448 if (c->prefixlist == NULL)
1449 error (_("\"%s\" is not a prefix command."), *comname);
1451 list = c->prefixlist;
1452 last_word[-1] = saved_char;
1453 *comname = last_word;
1459 if (!isalnum (*p) && *p != '-' && *p != '_')
1460 error (_("Junk in argument list: \"%s\""), p);
1467 /* This is just a placeholder in the command data structures. */
1469 user_defined_command (char *ignore, int from_tty)
1474 define_command (char *comname, int from_tty)
1476 #define MAX_TMPBUF 128
1483 struct command_line *cmds;
1484 struct cmd_list_element *c, *newc, *hookc = 0, **list;
1485 char *tem, *comfull;
1487 char tmpbuf[MAX_TMPBUF];
1488 int hook_type = CMD_NO_HOOK;
1489 int hook_name_size = 0;
1491 #define HOOK_STRING "hook-"
1493 #define HOOK_POST_STRING "hookpost-"
1494 #define HOOK_POST_LEN 9
1497 list = validate_comname (&comname);
1499 /* Look it up, and verify that we got an exact match. */
1501 c = lookup_cmd (&tem_c, *list, "", -1, 1);
1502 if (c && strcmp (comname, c->name) != 0)
1509 if (c->class == class_user || c->class == class_alias)
1510 q = query (_("Redefine command \"%s\"? "), c->name);
1512 q = query (_("Really redefine built-in command \"%s\"? "), c->name);
1514 error (_("Command \"%s\" not redefined."), c->name);
1517 /* If this new command is a hook, then mark the command which it
1518 is hooking. Note that we allow hooking `help' commands, so that
1519 we can hook the `stop' pseudo-command. */
1521 if (!strncmp (comname, HOOK_STRING, HOOK_LEN))
1523 hook_type = CMD_PRE_HOOK;
1524 hook_name_size = HOOK_LEN;
1526 else if (!strncmp (comname, HOOK_POST_STRING, HOOK_POST_LEN))
1528 hook_type = CMD_POST_HOOK;
1529 hook_name_size = HOOK_POST_LEN;
1532 if (hook_type != CMD_NO_HOOK)
1534 /* Look up cmd it hooks, and verify that we got an exact match. */
1535 tem_c = comname + hook_name_size;
1536 hookc = lookup_cmd (&tem_c, *list, "", -1, 0);
1537 if (hookc && strcmp (comname + hook_name_size, hookc->name) != 0)
1541 warning (_("Your new `%s' command does not "
1542 "hook any existing command."),
1544 if (!query (_("Proceed? ")))
1545 error (_("Not confirmed."));
1549 comname = xstrdup (comname);
1551 /* If the rest of the commands will be case insensitive, this one
1552 should behave in the same manner. */
1553 for (tem = comname; *tem; tem++)
1555 *tem = tolower (*tem);
1557 xsnprintf (tmpbuf, sizeof (tmpbuf),
1558 "Type commands for definition of \"%s\".", comfull);
1559 cmds = read_command_lines (tmpbuf, from_tty, 1, 0, 0);
1561 if (c && c->class == class_user)
1562 free_command_lines (&c->user_commands);
1564 newc = add_cmd (comname, class_user, user_defined_command,
1565 (c && c->class == class_user)
1566 ? c->doc : xstrdup ("User-defined."), list);
1567 newc->user_commands = cmds;
1569 /* If this new command is a hook, then mark both commands as being
1576 hookc->hook_pre = newc; /* Target gets hooked. */
1577 newc->hookee_pre = hookc; /* We are marked as hooking target cmd. */
1580 hookc->hook_post = newc; /* Target gets hooked. */
1581 newc->hookee_post = hookc; /* We are marked as hooking
1585 /* Should never come here as hookc would be 0. */
1586 internal_error (__FILE__, __LINE__, _("bad switch"));
1592 document_command (char *comname, int from_tty)
1594 struct command_line *doclines;
1595 struct cmd_list_element *c, **list;
1601 list = validate_comname (&comname);
1604 c = lookup_cmd (&tem, *list, "", 0, 1);
1606 if (c->class != class_user)
1607 error (_("Command \"%s\" is built-in."), comfull);
1609 xsnprintf (tmpbuf, sizeof (tmpbuf), "Type documentation for \"%s\".",
1611 doclines = read_command_lines (tmpbuf, from_tty, 0, 0, 0);
1617 struct command_line *cl1;
1620 for (cl1 = doclines; cl1; cl1 = cl1->next)
1621 len += strlen (cl1->line) + 1;
1623 c->doc = (char *) xmalloc (len + 1);
1626 for (cl1 = doclines; cl1; cl1 = cl1->next)
1628 strcat (c->doc, cl1->line);
1630 strcat (c->doc, "\n");
1634 free_command_lines (&doclines);
1637 struct source_cleanup_lines_args
1640 const char *old_file;
1644 source_cleanup_lines (void *args)
1646 struct source_cleanup_lines_args *p =
1647 (struct source_cleanup_lines_args *) args;
1649 source_line_number = p->old_line;
1650 source_file_name = p->old_file;
1653 /* Used to implement source_command. */
1656 script_from_file (FILE *stream, const char *file)
1658 struct cleanup *old_cleanups;
1659 struct source_cleanup_lines_args old_lines;
1662 internal_error (__FILE__, __LINE__, _("called with NULL file pointer!"));
1664 old_lines.old_line = source_line_number;
1665 old_lines.old_file = source_file_name;
1666 old_cleanups = make_cleanup (source_cleanup_lines, &old_lines);
1667 source_line_number = 0;
1668 source_file_name = file;
1671 volatile struct gdb_exception e;
1673 TRY_CATCH (e, RETURN_MASK_ERROR)
1675 read_command_file (stream);
1682 /* Re-throw the error, but with the file name information
1684 throw_error (e.error,
1685 _("%s:%d: Error in sourced command file:\n%s"),
1686 source_file_name, source_line_number, e.message);
1688 internal_error (__FILE__, __LINE__, _("bad reason"));
1692 do_cleanups (old_cleanups);
1695 /* Print the definition of user command C to STREAM. Or, if C is a
1696 prefix command, show the definitions of all user commands under C
1697 (recursively). PREFIX and NAME combined are the name of the
1700 show_user_1 (struct cmd_list_element *c, const char *prefix, const char *name,
1701 struct ui_file *stream)
1703 struct command_line *cmdlines;
1705 if (c->prefixlist != NULL)
1707 char *prefixname = c->prefixname;
1709 for (c = *c->prefixlist; c != NULL; c = c->next)
1710 if (c->class == class_user || c->prefixlist != NULL)
1711 show_user_1 (c, prefixname, c->name, gdb_stdout);
1715 cmdlines = c->user_commands;
1718 fprintf_filtered (stream, "User command \"%s%s\":\n", prefix, name);
1720 print_command_lines (current_uiout, cmdlines, 1);
1721 fputs_filtered ("\n", stream);
1726 initialize_file_ftype _initialize_cli_script;
1729 _initialize_cli_script (void)
1731 add_com ("document", class_support, document_command, _("\
1732 Document a user-defined command.\n\
1733 Give command name as argument. Give documentation on following lines.\n\
1734 End with a line of just \"end\"."));
1735 add_com ("define", class_support, define_command, _("\
1736 Define a new command name. Command name is argument.\n\
1737 Definition appears on following lines, one command per line.\n\
1738 End with a line of just \"end\".\n\
1739 Use the \"document\" command to give documentation for the new command.\n\
1740 Commands defined in this way may have up to ten arguments."));
1742 add_com ("while", class_support, while_command, _("\
1743 Execute nested commands WHILE the conditional expression is non zero.\n\
1744 The conditional expression must follow the word `while' and must in turn be\n\
1745 followed by a new line. The nested commands must be entered one per line,\n\
1746 and should be terminated by the word `end'."));
1748 add_com ("if", class_support, if_command, _("\
1749 Execute nested commands once IF the conditional expression is non zero.\n\
1750 The conditional expression must follow the word `if' and must in turn be\n\
1751 followed by a new line. The nested commands must be entered one per line,\n\
1752 and should be terminated by the word 'else' or `end'. If an else clause\n\
1753 is used, the same rules apply to its nested commands as to the first ones."));