+2007-01-27 Eli Zaretskii <eliz@gnu.org>
+
+ * cli/cli-script.c: Include breakpoint.h.
+ (build_command_line): Require arguments only for if and while
+ commands.
+ (get_command_line, execute_user_command, execute_control_command):
+ Fix wording of warning messages.
+ (print_command_lines): Print breakpoint commands.
+ (execute_control_command): Call commands_from_control_command to
+ handle the `commands' command inside a body of a flow-control
+ command.
+ (read_next_line): Recognize the `commands' command and build a
+ command line structure for it.
+ (recurse_read_control_structure, read_command_lines): Handle
+ `commands' similarly to `if' and `while'.
+
+ * breakpoint.c (get_number_trailer): Document the special meaning
+ of NULL as the first argument PP.
+ (commands_from_control_command): New function.
+
+ * breakpoint.h (commands_from_control_command): Add prototype.
+
+ * defs.h (commands_control): New enumerated value for enum
+ command_control_type.
+
2007-01-26 Joel Brobecker <brobecker@adacore.com>
* ada-lang.c (ada_exception_breakpoint_ops): Fix typo in function name.
Currently the string can either be a number or "$" followed by the name
of a convenience variable. Making it an expression wouldn't work well
for map_breakpoint_numbers (e.g. "4 + 5 + 6").
+
+ If the string is a NULL pointer, that denotes the last breakpoint.
TRAILER is a character which can be found after the number; most
commonly this is `-'. If you don't want a trailer, use \0. */
}
error (_("No breakpoint number %d."), bnum);
}
+
+/* Like commands_command, but instead of reading the commands from
+ input stream, takes them from an already parsed command structure.
+
+ This is used by cli-script.c to DTRT with breakpoint commands
+ that are part of if and while bodies. */
+enum command_control_type
+commands_from_control_command (char *arg, struct command_line *cmd)
+{
+ struct breakpoint *b;
+ char *p;
+ int bnum;
+
+ /* If we allowed this, we would have problems with when to
+ free the storage, if we change the commands currently
+ being read from. */
+
+ if (executing_breakpoint_commands)
+ error (_("Can't use the \"commands\" command among a breakpoint's commands."));
+
+ /* An empty string for the breakpoint number means the last
+ breakpoint, but get_number expects a NULL pointer. */
+ if (arg && !*arg)
+ p = NULL;
+ else
+ p = arg;
+ bnum = get_number (&p);
+
+ if (p && *p)
+ error (_("Unexpected extra arguments following breakpoint number."));
+
+ ALL_BREAKPOINTS (b)
+ if (b->number == bnum)
+ {
+ free_command_lines (&b->commands);
+ if (cmd->body_count != 1)
+ error (_("Invalid \"commands\" block structure."));
+ /* We need to copy the commands because if/while will free the
+ list after it finishes execution. */
+ b->commands = copy_command_lines (cmd->body_list[0]);
+ breakpoints_changed ();
+ breakpoint_modify_event (b->number);
+ return simple_control;
+ }
+ error (_("No breakpoint number %d."), bnum);
+}
\f
/* Like target_read_memory() but if breakpoints are inserted, return
the shadow contents instead of the breakpoints themselves.
#include "gdb_string.h"
#include "exceptions.h"
#include "top.h"
+#include "breakpoint.h"
#include "cli/cli-cmds.h"
#include "cli/cli-decode.h"
#include "cli/cli-script.h"
{
struct command_line *cmd;
- if (args == NULL)
+ if (args == NULL && (type == if_control || type == while_control))
error (_("if/while commands require arguments."));
cmd = (struct command_line *) xmalloc (sizeof (struct command_line));
/* Read in the body of this command. */
if (recurse_read_control_structure (cmd) == invalid_control)
{
- warning (_("Error reading in control structure."));
+ warning (_("Error reading in canned sequence of commands."));
do_cleanups (old_chain);
return NULL;
}
continue;
}
+ /* A commands command. Print the breakpoint commands and continue. */
+ if (list->control_type == commands_control)
+ {
+ if (*(list->line))
+ ui_out_field_fmt (uiout, NULL, "commands %s", list->line);
+ else
+ ui_out_field_string (uiout, NULL, "commands");
+ ui_out_text (uiout, "\n");
+ print_command_lines (uiout, *list->body_list, depth + 1);
+ if (depth)
+ ui_out_spaces (uiout, 2 * depth);
+ ui_out_field_string (uiout, NULL, "end");
+ ui_out_text (uiout, "\n");
+ list = list->next;
+ continue;
+ }
+
/* ignore illegal command type and try next */
list = list->next;
} /* while (list) */
ret = execute_control_command (cmdlines);
if (ret != simple_control && ret != break_control)
{
- warning (_("Error in control structure."));
+ warning (_("Error executing canned sequence of commands."));
break;
}
cmdlines = cmdlines->next;
break;
}
+ case commands_control:
+ {
+ /* Breakpoint commands list, record the commands in the breakpoint's
+ command list and return. */
+ new_line = insert_args (cmd->line);
+ if (!new_line)
+ break;
+ make_cleanup (free_current_contents, &new_line);
+ ret = commands_from_control_command (new_line, cmd);
+ break;
+ }
default:
- warning (_("Invalid control type in command structure."));
+ warning (_("Invalid control type in canned commands structure."));
break;
}
first_arg++;
*command = build_command_line (if_control, first_arg);
}
+ else if (p1 - p >= 8 && !strncmp (p, "commands", 8))
+ {
+ char *first_arg;
+ first_arg = p + 8;
+ while (first_arg < p1 && isspace (*first_arg))
+ first_arg++;
+ *command = build_command_line (commands_control, first_arg);
+ }
else if (p1 - p == 10 && !strncmp (p, "loop_break", 10))
{
*command = (struct command_line *)
if (val == end_command)
{
if (current_cmd->control_type == while_control
- || current_cmd->control_type == if_control)
+ || current_cmd->control_type == if_control
+ || current_cmd->control_type == commands_control)
{
- /* Success reading an entire control structure. */
+ /* Success reading an entire canned sequence of commands. */
ret = simple_control;
break;
}
/* If the latest line is another control structure, then recurse
on it. */
if (next->control_type == while_control
- || next->control_type == if_control)
+ || next->control_type == if_control
+ || next->control_type == commands_control)
{
control_level++;
ret = recurse_read_control_structure (next);
}
if (next->control_type == while_control
- || next->control_type == if_control)
+ || next->control_type == if_control
+ || next->control_type == commands_control)
{
control_level++;
ret = recurse_read_control_structure (next);
projects / binutils-gdb.git / commitdiff