1 /* GDB CLI command scripting.
3 Copyright (c) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2004, 2005, 2006, 2007, 2008,
5 2009, 2010, 2011 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "language.h" /* For value_true */
28 #include "gdb_string.h"
29 #include "exceptions.h"
31 #include "breakpoint.h"
32 #include "cli/cli-cmds.h"
33 #include "cli/cli-decode.h"
34 #include "cli/cli-script.h"
35 #include "gdb_assert.h"
37 #include "python/python.h"
40 /* Prototypes for local functions. */
42 static enum command_control_type
43 recurse_read_control_structure (char * (*read_next_line_func) (void),
44 struct command_line *current_cmd,
45 void (*validator)(char *, void *),
48 static char *insert_args (char *line);
50 static struct cleanup * setup_user_args (char *p);
52 static char *read_next_line (void);
54 /* Level of control structure when reading. */
55 static int control_level;
57 /* Level of control structure when executing. */
58 static int command_nest_depth = 1;
60 /* This is to prevent certain commands being printed twice. */
61 static int suppress_next_print_command_trace = 0;
63 /* Structure for arguments to user defined functions. */
64 #define MAXUSERARGS 10
67 struct user_args *next;
68 /* It is necessary to store a malloced copy of the command line to
69 ensure that the arguments are not overwritten before they are
83 /* Allocate, initialize a new command line structure for one of the
84 control commands (if/while). */
86 static struct command_line *
87 build_command_line (enum command_control_type type, char *args)
89 struct command_line *cmd;
91 if (args == NULL && (type == if_control || type == while_control))
92 error (_("if/while commands require arguments."));
93 gdb_assert (args != NULL);
95 cmd = (struct command_line *) xmalloc (sizeof (struct command_line));
97 cmd->control_type = type;
101 = (struct command_line **) xmalloc (sizeof (struct command_line *)
103 memset (cmd->body_list, 0, sizeof (struct command_line *) * cmd->body_count);
104 cmd->line = xstrdup (args);
109 /* Build and return a new command structure for the control commands
110 such as "if" and "while". */
112 struct command_line *
113 get_command_line (enum command_control_type type, char *arg)
115 struct command_line *cmd;
116 struct cleanup *old_chain = NULL;
118 /* Allocate and build a new command line structure. */
119 cmd = build_command_line (type, arg);
121 old_chain = make_cleanup_free_command_lines (&cmd);
123 /* Read in the body of this command. */
124 if (recurse_read_control_structure (read_next_line, cmd, 0, 0)
127 warning (_("Error reading in canned sequence of commands."));
128 do_cleanups (old_chain);
132 discard_cleanups (old_chain);
136 /* Recursively print a command (including full control structures). */
139 print_command_lines (struct ui_out *uiout, struct command_line *cmd,
142 struct command_line *list;
148 ui_out_spaces (uiout, 2 * depth);
150 /* A simple command, print it and continue. */
151 if (list->control_type == simple_control)
153 ui_out_field_string (uiout, NULL, list->line);
154 ui_out_text (uiout, "\n");
159 /* loop_continue to jump to the start of a while loop, print it
161 if (list->control_type == continue_control)
163 ui_out_field_string (uiout, NULL, "loop_continue");
164 ui_out_text (uiout, "\n");
169 /* loop_break to break out of a while loop, print it and
171 if (list->control_type == break_control)
173 ui_out_field_string (uiout, NULL, "loop_break");
174 ui_out_text (uiout, "\n");
179 /* A while command. Recursively print its subcommands and
181 if (list->control_type == while_control
182 || list->control_type == while_stepping_control)
184 /* For while-stepping, the line includes the 'while-stepping'
185 token. See comment in process_next_line for explanation.
186 Here, take care not print 'while-stepping' twice. */
187 if (list->control_type == while_control)
188 ui_out_field_fmt (uiout, NULL, "while %s", list->line);
190 ui_out_field_string (uiout, NULL, list->line);
191 ui_out_text (uiout, "\n");
192 print_command_lines (uiout, *list->body_list, depth + 1);
194 ui_out_spaces (uiout, 2 * depth);
195 ui_out_field_string (uiout, NULL, "end");
196 ui_out_text (uiout, "\n");
201 /* An if command. Recursively print both arms before
203 if (list->control_type == if_control)
205 ui_out_field_fmt (uiout, NULL, "if %s", list->line);
206 ui_out_text (uiout, "\n");
208 print_command_lines (uiout, list->body_list[0], depth + 1);
210 /* Show the false arm if it exists. */
211 if (list->body_count == 2)
214 ui_out_spaces (uiout, 2 * depth);
215 ui_out_field_string (uiout, NULL, "else");
216 ui_out_text (uiout, "\n");
217 print_command_lines (uiout, list->body_list[1], depth + 1);
221 ui_out_spaces (uiout, 2 * depth);
222 ui_out_field_string (uiout, NULL, "end");
223 ui_out_text (uiout, "\n");
228 /* A commands command. Print the breakpoint commands and
230 if (list->control_type == commands_control)
233 ui_out_field_fmt (uiout, NULL, "commands %s", list->line);
235 ui_out_field_string (uiout, NULL, "commands");
236 ui_out_text (uiout, "\n");
237 print_command_lines (uiout, *list->body_list, depth + 1);
239 ui_out_spaces (uiout, 2 * depth);
240 ui_out_field_string (uiout, NULL, "end");
241 ui_out_text (uiout, "\n");
246 if (list->control_type == python_control)
248 ui_out_field_string (uiout, NULL, "python");
249 ui_out_text (uiout, "\n");
250 /* Don't indent python code at all. */
251 print_command_lines (uiout, *list->body_list, 0);
253 ui_out_spaces (uiout, 2 * depth);
254 ui_out_field_string (uiout, NULL, "end");
255 ui_out_text (uiout, "\n");
260 /* Ignore illegal command type and try next. */
265 /* Handle pre-post hooks. */
268 clear_hook_in_cleanup (void *data)
270 struct cmd_list_element *c = data;
272 c->hook_in = 0; /* Allow hook to work again once it is complete. */
276 execute_cmd_pre_hook (struct cmd_list_element *c)
278 if ((c->hook_pre) && (!c->hook_in))
280 struct cleanup *cleanups = make_cleanup (clear_hook_in_cleanup, c);
281 c->hook_in = 1; /* Prevent recursive hooking. */
282 execute_user_command (c->hook_pre, (char *) 0);
283 do_cleanups (cleanups);
288 execute_cmd_post_hook (struct cmd_list_element *c)
290 if ((c->hook_post) && (!c->hook_in))
292 struct cleanup *cleanups = make_cleanup (clear_hook_in_cleanup, c);
294 c->hook_in = 1; /* Prevent recursive hooking. */
295 execute_user_command (c->hook_post, (char *) 0);
296 do_cleanups (cleanups);
300 /* Execute the command in CMD. */
302 do_restore_user_call_depth (void * call_depth)
304 int *depth = call_depth;
313 execute_user_command (struct cmd_list_element *c, char *args)
315 struct command_line *cmdlines;
316 struct cleanup *old_chain;
317 enum command_control_type ret;
318 static int user_call_depth = 0;
319 extern int max_user_call_depth;
321 cmdlines = c->user_commands;
326 old_chain = setup_user_args (args);
328 if (++user_call_depth > max_user_call_depth)
329 error (_("Max user call depth exceeded -- command aborted."));
331 make_cleanup (do_restore_user_call_depth, &user_call_depth);
333 /* Set the instream to 0, indicating execution of a
334 user-defined function. */
335 make_cleanup (do_restore_instream_cleanup, instream);
336 instream = (FILE *) 0;
338 /* Also set the global in_user_command, so that NULL instream is
339 not confused with Insight. */
342 make_cleanup_restore_integer (&interpreter_async);
343 interpreter_async = 0;
345 command_nest_depth++;
348 ret = execute_control_command (cmdlines);
349 if (ret != simple_control && ret != break_control)
351 warning (_("Error executing canned sequence of commands."));
354 cmdlines = cmdlines->next;
356 command_nest_depth--;
357 do_cleanups (old_chain);
360 /* This function is called every time GDB prints a prompt. It ensures
361 that errors and the like do not confuse the command tracing. */
364 reset_command_nest_depth (void)
366 command_nest_depth = 1;
369 suppress_next_print_command_trace = 0;
372 /* Print the command, prefixed with '+' to represent the call depth.
373 This is slightly complicated because this function may be called
374 from execute_command and execute_control_command. Unfortunately
375 execute_command also prints the top level control commands.
376 In these cases execute_command will call execute_control_command
377 via while_command or if_command. Inner levels of 'if' and 'while'
378 are dealt with directly. Therefore we can use these functions
379 to determine whether the command has been printed already or not. */
381 print_command_trace (const char *cmd)
385 if (suppress_next_print_command_trace)
387 suppress_next_print_command_trace = 0;
391 if (!source_verbose && !trace_commands)
394 for (i=0; i < command_nest_depth; i++)
395 printf_filtered ("+");
397 printf_filtered ("%s\n", cmd);
400 enum command_control_type
401 execute_control_command (struct command_line *cmd)
403 struct expression *expr;
404 struct command_line *current;
405 struct cleanup *old_chain = make_cleanup (null_cleanup, 0);
407 struct value *val_mark;
409 enum command_control_type ret;
412 /* Start by assuming failure, if a problem is detected, the code
413 below will simply "break" out of the switch. */
414 ret = invalid_control;
416 switch (cmd->control_type)
419 /* A simple command, execute it and return. */
420 new_line = insert_args (cmd->line);
423 make_cleanup (free_current_contents, &new_line);
424 execute_command (new_line, 0);
425 ret = cmd->control_type;
428 case continue_control:
429 print_command_trace ("loop_continue");
431 /* Return for "continue", and "break" so we can either
432 continue the loop at the top, or break out. */
433 ret = cmd->control_type;
437 print_command_trace ("loop_break");
439 /* Return for "continue", and "break" so we can either
440 continue the loop at the top, or break out. */
441 ret = cmd->control_type;
446 char *buffer = alloca (strlen (cmd->line) + 7);
448 sprintf (buffer, "while %s", cmd->line);
449 print_command_trace (buffer);
451 /* Parse the loop control expression for the while statement. */
452 new_line = insert_args (cmd->line);
455 make_cleanup (free_current_contents, &new_line);
456 expr = parse_expression (new_line);
457 make_cleanup (free_current_contents, &expr);
459 ret = simple_control;
462 /* Keep iterating so long as the expression is true. */
469 /* Evaluate the expression. */
470 val_mark = value_mark ();
471 val = evaluate_expression (expr);
472 cond_result = value_true (val);
473 value_free_to_mark (val_mark);
475 /* If the value is false, then break out of the loop. */
479 /* Execute the body of the while statement. */
480 current = *cmd->body_list;
483 command_nest_depth++;
484 ret = execute_control_command (current);
485 command_nest_depth--;
487 /* If we got an error, or a "break" command, then stop
489 if (ret == invalid_control || ret == break_control)
495 /* If we got a "continue" command, then restart the loop
497 if (ret == continue_control)
500 /* Get the next statement. */
501 current = current->next;
505 /* Reset RET so that we don't recurse the break all the way down. */
506 if (ret == break_control)
507 ret = simple_control;
514 char *buffer = alloca (strlen (cmd->line) + 4);
516 sprintf (buffer, "if %s", cmd->line);
517 print_command_trace (buffer);
519 new_line = insert_args (cmd->line);
522 make_cleanup (free_current_contents, &new_line);
523 /* Parse the conditional for the if statement. */
524 expr = parse_expression (new_line);
525 make_cleanup (free_current_contents, &expr);
528 ret = simple_control;
530 /* Evaluate the conditional. */
531 val_mark = value_mark ();
532 val = evaluate_expression (expr);
534 /* Choose which arm to take commands from based on the value
535 of the conditional expression. */
536 if (value_true (val))
537 current = *cmd->body_list;
538 else if (cmd->body_count == 2)
539 current = *(cmd->body_list + 1);
540 value_free_to_mark (val_mark);
542 /* Execute commands in the given arm. */
545 command_nest_depth++;
546 ret = execute_control_command (current);
547 command_nest_depth--;
549 /* If we got an error, get out. */
550 if (ret != simple_control)
553 /* Get the next statement in the body. */
554 current = current->next;
559 case commands_control:
561 /* Breakpoint commands list, record the commands in the
562 breakpoint's command list and return. */
563 new_line = insert_args (cmd->line);
566 make_cleanup (free_current_contents, &new_line);
567 ret = commands_from_control_command (new_line, cmd);
572 eval_python_from_control_command (cmd);
573 ret = simple_control;
578 warning (_("Invalid control type in canned commands structure."));
582 do_cleanups (old_chain);
587 /* Like execute_control_command, but first set
588 suppress_next_print_command_trace. */
590 enum command_control_type
591 execute_control_command_untraced (struct command_line *cmd)
593 suppress_next_print_command_trace = 1;
594 return execute_control_command (cmd);
598 /* "while" command support. Executes a body of statements while the
599 loop condition is nonzero. */
602 while_command (char *arg, int from_tty)
604 struct command_line *command = NULL;
605 struct cleanup *old_chain;
608 command = get_command_line (while_control, arg);
613 old_chain = make_cleanup_restore_integer (&interpreter_async);
614 interpreter_async = 0;
616 execute_control_command_untraced (command);
617 free_command_lines (&command);
619 do_cleanups (old_chain);
622 /* "if" command support. Execute either the true or false arm depending
623 on the value of the if conditional. */
626 if_command (char *arg, int from_tty)
628 struct command_line *command = NULL;
629 struct cleanup *old_chain;
632 command = get_command_line (if_control, arg);
637 old_chain = make_cleanup_restore_integer (&interpreter_async);
638 interpreter_async = 0;
640 execute_control_command_untraced (command);
641 free_command_lines (&command);
643 do_cleanups (old_chain);
648 arg_cleanup (void *ignore)
650 struct user_args *oargs = user_args;
653 internal_error (__FILE__, __LINE__,
654 _("arg_cleanup called with no user args.\n"));
656 user_args = user_args->next;
657 xfree (oargs->command);
661 /* Bind the incomming arguments for a user defined command to
662 $arg0, $arg1 ... $argMAXUSERARGS. */
664 static struct cleanup *
665 setup_user_args (char *p)
667 struct user_args *args;
668 struct cleanup *old_chain;
669 unsigned int arg_count = 0;
671 args = (struct user_args *) xmalloc (sizeof (struct user_args));
672 memset (args, 0, sizeof (struct user_args));
674 args->next = user_args;
677 old_chain = make_cleanup (arg_cleanup, 0/*ignored*/);
682 user_args->command = p = xstrdup (p);
691 if (arg_count >= MAXUSERARGS)
693 error (_("user defined function may only have %d arguments."),
698 /* Strip whitespace. */
699 while (*p == ' ' || *p == '\t')
702 /* P now points to an argument. */
704 user_args->a[arg_count].arg = p;
706 /* Get to the end of this argument. */
709 if (((*p == ' ' || *p == '\t')) && !squote && !dquote && !bsquote)
738 user_args->a[arg_count].len = p - start_arg;
745 /* Given character string P, return a point to the first argument
746 ($arg), or NULL if P contains no arguments. */
751 while ((p = strchr (p, '$')))
753 if (strncmp (p, "$arg", 4) == 0
754 && (isdigit (p[4]) || p[4] == 'c'))
761 /* Insert the user defined arguments stored in user_arg into the $arg
762 arguments found in line, with the updated copy being placed into
766 insert_args (char *line)
768 char *p, *save_line, *new_line;
771 /* If we are not in a user-defined function, treat $argc, $arg0, et
772 cetera as normal convenience variables. */
773 if (user_args == NULL)
774 return xstrdup (line);
776 /* First we need to know how much memory to allocate for the new
780 while ((p = locate_arg (line)))
787 /* $argc. Number will be <=10. */
788 len += user_args->count == 10 ? 2 : 1;
790 else if (i >= user_args->count)
792 error (_("Missing argument %d in user function."), i);
797 len += user_args->a[i].len;
802 /* Don't forget the tail. */
803 len += strlen (line);
805 /* Allocate space for the new line and fill it in. */
806 new_line = (char *) xmalloc (len + 1);
807 if (new_line == NULL)
810 /* Restore pointer to beginning of old line. */
813 /* Save pointer to beginning of new line. */
814 save_line = new_line;
816 while ((p = locate_arg (line)))
820 memcpy (new_line, line, p - line);
821 new_line += p - line;
825 gdb_assert (user_args->count >= 0 && user_args->count <= 10);
826 if (user_args->count == 10)
832 *(new_line++) = user_args->count + '0';
837 len = user_args->a[i].len;
840 memcpy (new_line, user_args->a[i].arg, len);
846 /* Don't forget the tail. */
847 strcpy (new_line, line);
849 /* Return a pointer to the beginning of the new line. */
854 /* Expand the body_list of COMMAND so that it can hold NEW_LENGTH
855 code bodies. This is typically used when we encounter an "else"
856 clause for an "if" command. */
859 realloc_body_list (struct command_line *command, int new_length)
862 struct command_line **body_list;
864 n = command->body_count;
870 body_list = (struct command_line **)
871 xmalloc (sizeof (struct command_line *) * new_length);
873 memcpy (body_list, command->body_list, sizeof (struct command_line *) * n);
874 memset (body_list + n, 0, sizeof (struct command_line *) * (new_length - n));
876 xfree (command->body_list);
877 command->body_list = body_list;
878 command->body_count = new_length;
881 /* Read next line from stdout. Passed to read_command_line_1 and
882 recurse_read_control_structure whenever we need to read commands
886 read_next_line (void)
888 char *prompt_ptr, control_prompt[256];
891 if (control_level >= 254)
892 error (_("Control nesting too deep!"));
894 /* Set a prompt based on the nesting of the control commands. */
895 if (instream == stdin || (instream == 0 && deprecated_readline_hook != NULL))
897 for (i = 0; i < control_level; i++)
898 control_prompt[i] = ' ';
899 control_prompt[i] = '>';
900 control_prompt[i + 1] = '\0';
901 prompt_ptr = (char *) &control_prompt[0];
906 return command_line_input (prompt_ptr, instream == stdin, "commands");
909 /* Process one input line. If the command is an "end", return such an
910 indication to the caller. If PARSE_COMMANDS is true, strip leading
911 whitespace (trailing whitespace is always stripped) in the line,
912 attempt to recognize GDB control commands, and also return an
913 indication if the command is an "else" or a nop.
915 Otherwise, only "end" is recognized. */
917 static enum misc_command_type
918 process_next_line (char *p, struct command_line **command, int parse_commands,
919 void (*validator)(char *, void *), void *closure)
925 /* Not sure what to do here. */
929 /* Strip trailing whitespace. */
930 p_end = p + strlen (p);
931 while (p_end > p && (p_end[-1] == ' ' || p_end[-1] == '\t'))
935 /* Strip leading whitespace. */
936 while (p_start < p_end && (*p_start == ' ' || *p_start == '\t'))
939 /* 'end' is always recognized, regardless of parse_commands value.
940 We also permit whitespace before end and after. */
941 if (p_end - p_start == 3 && !strncmp (p_start, "end", 3))
946 /* If commands are parsed, we skip initial spaces. Otherwise,
947 which is the case for Python commands and documentation
948 (see the 'document' command), spaces are preserved. */
951 /* Blanks and comments don't really do anything, but we need to
952 distinguish them from else, end and other commands which can
954 if (p_end == p || p[0] == '#')
957 /* Is the else clause of an if control structure? */
958 if (p_end - p == 4 && !strncmp (p, "else", 4))
961 /* Check for while, if, break, continue, etc and build a new
962 command line structure for them. */
963 if ((p_end - p >= 14 && !strncmp (p, "while-stepping", 14))
964 || (p_end - p >= 8 && !strncmp (p, "stepping", 8))
965 || (p_end - p >= 2 && !strncmp (p, "ws", 2)))
967 /* Because validate_actionline and encode_action lookup
968 command's line as command, we need the line to
969 include 'while-stepping'.
971 For 'ws' alias, the command will have 'ws', not expanded
972 to 'while-stepping'. This is intentional -- we don't
973 really want frontend to send a command list with 'ws',
974 and next break-info returning command line with
975 'while-stepping'. This should work, but might cause the
976 breakpoint to be marked as changed while it's actually
978 *command = build_command_line (while_stepping_control, p);
980 else if (p_end - p > 5 && !strncmp (p, "while", 5))
985 while (first_arg < p_end && isspace (*first_arg))
987 *command = build_command_line (while_control, first_arg);
989 else if (p_end - p > 2 && !strncmp (p, "if", 2))
994 while (first_arg < p_end && isspace (*first_arg))
996 *command = build_command_line (if_control, first_arg);
998 else if (p_end - p >= 8 && !strncmp (p, "commands", 8))
1003 while (first_arg < p_end && isspace (*first_arg))
1005 *command = build_command_line (commands_control, first_arg);
1007 else if (p_end - p == 6 && !strncmp (p, "python", 6))
1009 /* Note that we ignore the inline "python command" form
1011 *command = build_command_line (python_control, "");
1013 else if (p_end - p == 10 && !strncmp (p, "loop_break", 10))
1015 *command = (struct command_line *)
1016 xmalloc (sizeof (struct command_line));
1017 (*command)->next = NULL;
1018 (*command)->line = NULL;
1019 (*command)->control_type = break_control;
1020 (*command)->body_count = 0;
1021 (*command)->body_list = NULL;
1023 else if (p_end - p == 13 && !strncmp (p, "loop_continue", 13))
1025 *command = (struct command_line *)
1026 xmalloc (sizeof (struct command_line));
1027 (*command)->next = NULL;
1028 (*command)->line = NULL;
1029 (*command)->control_type = continue_control;
1030 (*command)->body_count = 0;
1031 (*command)->body_list = NULL;
1037 if (!parse_commands || not_handled)
1039 /* A normal command. */
1040 *command = (struct command_line *)
1041 xmalloc (sizeof (struct command_line));
1042 (*command)->next = NULL;
1043 (*command)->line = savestring (p, p_end - p);
1044 (*command)->control_type = simple_control;
1045 (*command)->body_count = 0;
1046 (*command)->body_list = NULL;
1051 volatile struct gdb_exception ex;
1053 TRY_CATCH (ex, RETURN_MASK_ALL)
1055 validator ((*command)->line, closure);
1060 throw_exception (ex);
1064 /* Nothing special. */
1068 /* Recursively read in the control structures and create a
1069 command_line structure from them. Use read_next_line_func to
1070 obtain lines of the command. */
1072 static enum command_control_type
1073 recurse_read_control_structure (char * (*read_next_line_func) (void),
1074 struct command_line *current_cmd,
1075 void (*validator)(char *, void *),
1078 int current_body, i;
1079 enum misc_command_type val;
1080 enum command_control_type ret;
1081 struct command_line **body_ptr, *child_tail, *next;
1086 /* Sanity checks. */
1087 if (current_cmd->control_type == simple_control)
1088 error (_("Recursed on a simple control type."));
1090 if (current_body > current_cmd->body_count)
1091 error (_("Allocated body is smaller than this command type needs."));
1093 /* Read lines from the input stream and build control structures. */
1099 val = process_next_line (read_next_line_func (), &next,
1100 current_cmd->control_type != python_control,
1101 validator, closure);
1103 /* Just skip blanks and comments. */
1104 if (val == nop_command)
1107 if (val == end_command)
1109 if (current_cmd->control_type == while_control
1110 || current_cmd->control_type == while_stepping_control
1111 || current_cmd->control_type == if_control
1112 || current_cmd->control_type == python_control
1113 || current_cmd->control_type == commands_control)
1115 /* Success reading an entire canned sequence of commands. */
1116 ret = simple_control;
1121 ret = invalid_control;
1126 /* Not the end of a control structure. */
1127 if (val == else_command)
1129 if (current_cmd->control_type == if_control
1130 && current_body == 1)
1132 realloc_body_list (current_cmd, 2);
1139 ret = invalid_control;
1146 child_tail->next = next;
1150 body_ptr = current_cmd->body_list;
1151 for (i = 1; i < current_body; i++)
1160 /* If the latest line is another control structure, then recurse
1162 if (next->control_type == while_control
1163 || next->control_type == while_stepping_control
1164 || next->control_type == if_control
1165 || next->control_type == python_control
1166 || next->control_type == commands_control)
1169 ret = recurse_read_control_structure (read_next_line_func, next,
1170 validator, closure);
1173 if (ret != simple_control)
1183 /* Read lines from the input stream and accumulate them in a chain of
1184 struct command_line's, which is then returned. For input from a
1185 terminal, the special command "end" is used to mark the end of the
1186 input, and is not included in the returned chain of commands.
1188 If PARSE_COMMANDS is true, strip leading whitespace (trailing whitespace
1189 is always stripped) in the line and attempt to recognize GDB control
1190 commands. Otherwise, only "end" is recognized. */
1192 #define END_MESSAGE "End with a line saying just \"end\"."
1194 struct command_line *
1195 read_command_lines (char *prompt_arg, int from_tty, int parse_commands,
1196 void (*validator)(char *, void *), void *closure)
1198 struct command_line *head;
1200 if (from_tty && input_from_terminal_p ())
1202 if (deprecated_readline_begin_hook)
1204 /* Note - intentional to merge messages with no newline. */
1205 (*deprecated_readline_begin_hook) ("%s %s\n", prompt_arg,
1210 printf_unfiltered ("%s\n%s\n", prompt_arg, END_MESSAGE);
1211 gdb_flush (gdb_stdout);
1215 head = read_command_lines_1 (read_next_line, parse_commands,
1216 validator, closure);
1218 if (deprecated_readline_end_hook && from_tty && input_from_terminal_p ())
1220 (*deprecated_readline_end_hook) ();
1225 /* Act the same way as read_command_lines, except that each new line is
1226 obtained using READ_NEXT_LINE_FUNC. */
1228 struct command_line *
1229 read_command_lines_1 (char * (*read_next_line_func) (void), int parse_commands,
1230 void (*validator)(char *, void *), void *closure)
1232 struct command_line *head, *tail, *next;
1233 struct cleanup *old_chain;
1234 enum command_control_type ret;
1235 enum misc_command_type val;
1244 val = process_next_line (read_next_line_func (), &next, parse_commands,
1245 validator, closure);
1247 /* Ignore blank lines or comments. */
1248 if (val == nop_command)
1251 if (val == end_command)
1253 ret = simple_control;
1257 if (val != ok_command)
1259 ret = invalid_control;
1263 if (next->control_type == while_control
1264 || next->control_type == if_control
1265 || next->control_type == python_control
1266 || next->control_type == commands_control
1267 || next->control_type == while_stepping_control)
1270 ret = recurse_read_control_structure (read_next_line_func, next,
1271 validator, closure);
1274 if (ret == invalid_control)
1285 old_chain = make_cleanup_free_command_lines (&head);
1294 if (ret != invalid_control)
1296 discard_cleanups (old_chain);
1299 do_cleanups (old_chain);
1305 /* Free a chain of struct command_line's. */
1308 free_command_lines (struct command_line **lptr)
1310 struct command_line *l = *lptr;
1311 struct command_line *next;
1312 struct command_line **blist;
1317 if (l->body_count > 0)
1319 blist = l->body_list;
1320 for (i = 0; i < l->body_count; i++, blist++)
1321 free_command_lines (blist);
1332 do_free_command_lines_cleanup (void *arg)
1334 free_command_lines (arg);
1338 make_cleanup_free_command_lines (struct command_line **arg)
1340 return make_cleanup (do_free_command_lines_cleanup, arg);
1343 struct command_line *
1344 copy_command_lines (struct command_line *cmds)
1346 struct command_line *result = NULL;
1350 result = (struct command_line *) xmalloc (sizeof (struct command_line));
1352 result->next = copy_command_lines (cmds->next);
1353 result->line = xstrdup (cmds->line);
1354 result->control_type = cmds->control_type;
1355 result->body_count = cmds->body_count;
1356 if (cmds->body_count > 0)
1360 result->body_list = (struct command_line **)
1361 xmalloc (sizeof (struct command_line *) * cmds->body_count);
1363 for (i = 0; i < cmds->body_count; i++)
1364 result->body_list[i] = copy_command_lines (cmds->body_list[i]);
1367 result->body_list = NULL;
1373 /* Validate that *COMNAME is a valid name for a command. Return the
1374 containing command list, in case it starts with a prefix command.
1375 The prefix must already exist. *COMNAME is advanced to point after
1376 any prefix, and a NUL character overwrites the space after the
1379 static struct cmd_list_element **
1380 validate_comname (char **comname)
1382 struct cmd_list_element **list = &cmdlist;
1383 char *p, *last_word;
1386 error_no_arg (_("name of command to define"));
1388 /* Find the last word of the argument. */
1389 p = *comname + strlen (*comname);
1390 while (p > *comname && isspace (p[-1]))
1392 while (p > *comname && !isspace (p[-1]))
1396 /* Find the corresponding command list. */
1397 if (last_word != *comname)
1399 struct cmd_list_element *c;
1400 char saved_char, *tem = *comname;
1402 /* Separate the prefix and the command. */
1403 saved_char = last_word[-1];
1404 last_word[-1] = '\0';
1406 c = lookup_cmd (&tem, cmdlist, "", 0, 1);
1407 if (c->prefixlist == NULL)
1408 error (_("\"%s\" is not a prefix command."), *comname);
1410 list = c->prefixlist;
1411 last_word[-1] = saved_char;
1412 *comname = last_word;
1418 if (!isalnum (*p) && *p != '-' && *p != '_')
1419 error (_("Junk in argument list: \"%s\""), p);
1426 /* This is just a placeholder in the command data structures. */
1428 user_defined_command (char *ignore, int from_tty)
1433 define_command (char *comname, int from_tty)
1435 #define MAX_TMPBUF 128
1442 struct command_line *cmds;
1443 struct cmd_list_element *c, *newc, *hookc = 0, **list;
1444 char *tem, *comfull;
1445 char tmpbuf[MAX_TMPBUF];
1446 int hook_type = CMD_NO_HOOK;
1447 int hook_name_size = 0;
1449 #define HOOK_STRING "hook-"
1451 #define HOOK_POST_STRING "hookpost-"
1452 #define HOOK_POST_LEN 9
1455 list = validate_comname (&comname);
1457 /* Look it up, and verify that we got an exact match. */
1459 c = lookup_cmd (&tem, *list, "", -1, 1);
1460 if (c && strcmp (comname, c->name) != 0)
1467 if (c->class == class_user || c->class == class_alias)
1468 q = query (_("Redefine command \"%s\"? "), c->name);
1470 q = query (_("Really redefine built-in command \"%s\"? "), c->name);
1472 error (_("Command \"%s\" not redefined."), c->name);
1475 /* If this new command is a hook, then mark the command which it
1476 is hooking. Note that we allow hooking `help' commands, so that
1477 we can hook the `stop' pseudo-command. */
1479 if (!strncmp (comname, HOOK_STRING, HOOK_LEN))
1481 hook_type = CMD_PRE_HOOK;
1482 hook_name_size = HOOK_LEN;
1484 else if (!strncmp (comname, HOOK_POST_STRING, HOOK_POST_LEN))
1486 hook_type = CMD_POST_HOOK;
1487 hook_name_size = HOOK_POST_LEN;
1490 if (hook_type != CMD_NO_HOOK)
1492 /* Look up cmd it hooks, and verify that we got an exact match. */
1493 tem = comname + hook_name_size;
1494 hookc = lookup_cmd (&tem, *list, "", -1, 0);
1495 if (hookc && strcmp (comname + hook_name_size, hookc->name) != 0)
1499 warning (_("Your new `%s' command does not "
1500 "hook any existing command."),
1502 if (!query (_("Proceed? ")))
1503 error (_("Not confirmed."));
1507 comname = xstrdup (comname);
1509 /* If the rest of the commands will be case insensitive, this one
1510 should behave in the same manner. */
1511 for (tem = comname; *tem; tem++)
1513 *tem = tolower (*tem);
1515 sprintf (tmpbuf, "Type commands for definition of \"%s\".", comfull);
1516 cmds = read_command_lines (tmpbuf, from_tty, 1, 0, 0);
1518 if (c && c->class == class_user)
1519 free_command_lines (&c->user_commands);
1521 newc = add_cmd (comname, class_user, user_defined_command,
1522 (c && c->class == class_user)
1523 ? c->doc : xstrdup ("User-defined."), list);
1524 newc->user_commands = cmds;
1526 /* If this new command is a hook, then mark both commands as being
1533 hookc->hook_pre = newc; /* Target gets hooked. */
1534 newc->hookee_pre = hookc; /* We are marked as hooking target cmd. */
1537 hookc->hook_post = newc; /* Target gets hooked. */
1538 newc->hookee_post = hookc; /* We are marked as hooking
1542 /* Should never come here as hookc would be 0. */
1543 internal_error (__FILE__, __LINE__, _("bad switch"));
1549 document_command (char *comname, int from_tty)
1551 struct command_line *doclines;
1552 struct cmd_list_element *c, **list;
1553 char *tem, *comfull;
1557 list = validate_comname (&comname);
1560 c = lookup_cmd (&tem, *list, "", 0, 1);
1562 if (c->class != class_user)
1563 error (_("Command \"%s\" is built-in."), comfull);
1565 sprintf (tmpbuf, "Type documentation for \"%s\".", comfull);
1566 doclines = read_command_lines (tmpbuf, from_tty, 0, 0, 0);
1572 struct command_line *cl1;
1575 for (cl1 = doclines; cl1; cl1 = cl1->next)
1576 len += strlen (cl1->line) + 1;
1578 c->doc = (char *) xmalloc (len + 1);
1581 for (cl1 = doclines; cl1; cl1 = cl1->next)
1583 strcat (c->doc, cl1->line);
1585 strcat (c->doc, "\n");
1589 free_command_lines (&doclines);
1592 struct source_cleanup_lines_args
1595 const char *old_file;
1599 source_cleanup_lines (void *args)
1601 struct source_cleanup_lines_args *p =
1602 (struct source_cleanup_lines_args *) args;
1604 source_line_number = p->old_line;
1605 source_file_name = p->old_file;
1608 /* Used to implement source_command. */
1611 script_from_file (FILE *stream, const char *file)
1613 struct cleanup *old_cleanups;
1614 struct source_cleanup_lines_args old_lines;
1617 internal_error (__FILE__, __LINE__, _("called with NULL file pointer!"));
1619 old_cleanups = make_cleanup_fclose (stream);
1621 old_lines.old_line = source_line_number;
1622 old_lines.old_file = source_file_name;
1623 make_cleanup (source_cleanup_lines, &old_lines);
1624 source_line_number = 0;
1625 source_file_name = file;
1626 /* This will get set every time we read a line. So it won't stay ""
1628 error_pre_print = "";
1631 volatile struct gdb_exception e;
1633 TRY_CATCH (e, RETURN_MASK_ERROR)
1635 read_command_file (stream);
1642 /* Re-throw the error, but with the file name information
1644 throw_error (e.error,
1645 _("%s:%d: Error in sourced command file:\n%s"),
1646 source_file_name, source_line_number, e.message);
1648 internal_error (__FILE__, __LINE__, _("bad reason"));
1652 do_cleanups (old_cleanups);
1655 /* Print the definition of user command C to STREAM. Or, if C is a
1656 prefix command, show the definitions of all user commands under C
1657 (recursively). PREFIX and NAME combined are the name of the
1660 show_user_1 (struct cmd_list_element *c, char *prefix, char *name,
1661 struct ui_file *stream)
1663 struct command_line *cmdlines;
1665 if (c->prefixlist != NULL)
1667 char *prefixname = c->prefixname;
1669 for (c = *c->prefixlist; c != NULL; c = c->next)
1670 if (c->class == class_user || c->prefixlist != NULL)
1671 show_user_1 (c, prefixname, c->name, gdb_stdout);
1675 cmdlines = c->user_commands;
1678 fprintf_filtered (stream, "User command \"%s%s\":\n", prefix, name);
1680 print_command_lines (current_uiout, cmdlines, 1);
1681 fputs_filtered ("\n", stream);