#include "target.h"
#include "inferior.h"
#include "gdb_string.h"
+#include "exceptions.h"
#include "top.h"
#include "gdbthread.h"
#include "mi-cmds.h"
static int register_changed_p (int regnum);
static int get_register (int regnum, int format);
-/* A helper function which will set mi_error_message to
- error_last_message. */
-void
-mi_error_last_message (void)
-{
- char *s = error_last_message ();
- xasprintf (&mi_error_message, "%s", s);
- xfree (s);
-}
-
/* Command implementations. FIXME: Is this libgdb? No. This is the MI
layer that calls libgdb. Any operation used in the below should be
formalized. */
/* Because we have called return_command with from_tty = 0, we need
to print the frame here. */
- print_stack_frame (get_selected_frame (), 1, LOC_AND_ADDRESS);
+ print_stack_frame (get_selected_frame (NULL), 1, LOC_AND_ADDRESS);
return MI_CMD_DONE;
}
{
if (!target_executing)
{
- xasprintf (&mi_error_message,
- "mi_cmd_exec_interrupt: Inferior not executing.");
+ mi_error_message = xstrprintf ("mi_cmd_exec_interrupt: Inferior not executing.");
return MI_CMD_ERROR;
}
interrupt_target_command (args, from_tty);
if (argc != 1)
{
- xasprintf (&mi_error_message,
- "mi_cmd_thread_select: USAGE: threadnum.");
+ mi_error_message = xstrprintf ("mi_cmd_thread_select: USAGE: threadnum.");
return MI_CMD_ERROR;
}
else
if (argc != 0)
{
- xasprintf (&mi_error_message,
- "mi_cmd_thread_list_ids: No arguments required.");
+ mi_error_message = xstrprintf ("mi_cmd_thread_list_ids: No arguments required.");
return MI_CMD_ERROR;
}
else
if (regnum < 0 || regnum >= numregs)
{
do_cleanups (cleanup);
- xasprintf (&mi_error_message, "bad register number");
+ mi_error_message = xstrprintf ("bad register number");
return MI_CMD_ERROR;
}
if (REGISTER_NAME (regnum) == NULL
case, some entries of REGISTER_NAME will change depending upon
the particular processor being debugged. */
- numregs = NUM_REGS;
+ numregs = NUM_REGS + NUM_PSEUDO_REGS;
cleanup = make_cleanup_ui_out_list_begin_end (uiout, "changed-registers");
if (changed < 0)
{
do_cleanups (cleanup);
- xasprintf (&mi_error_message,
- "mi_cmd_data_list_changed_registers: Unable to read register contents.");
+ mi_error_message = xstrprintf ("mi_cmd_data_list_changed_registers: Unable to read register contents.");
return MI_CMD_ERROR;
}
else if (changed)
if (changed < 0)
{
do_cleanups (cleanup);
- xasprintf (&mi_error_message,
- "mi_cmd_data_list_register_change: Unable to read register contents.");
+ mi_error_message = xstrprintf ("mi_cmd_data_list_register_change: Unable to read register contents.");
return MI_CMD_ERROR;
}
else if (changed)
else
{
do_cleanups (cleanup);
- xasprintf (&mi_error_message, "bad register number");
+ mi_error_message = xstrprintf ("bad register number");
return MI_CMD_ERROR;
}
}
return -1;
if (memcmp (&old_regs[DEPRECATED_REGISTER_BYTE (regnum)], raw_buffer,
- DEPRECATED_REGISTER_RAW_SIZE (regnum)) == 0)
+ register_size (current_gdbarch, regnum)) == 0)
return 0;
/* Found a changed register. Return 1. */
memcpy (&old_regs[DEPRECATED_REGISTER_BYTE (regnum)], raw_buffer,
- DEPRECATED_REGISTER_RAW_SIZE (regnum));
+ register_size (current_gdbarch, regnum));
return 1;
}
case, some entries of REGISTER_NAME will change depending upon
the particular processor being debugged. */
- numregs = NUM_REGS;
+ numregs = NUM_REGS + NUM_PSEUDO_REGS;
if (argc == 0)
{
- xasprintf (&mi_error_message,
- "mi_cmd_data_list_register_values: Usage: -data-list-register-values <format> [<regnum1>...<regnumN>]");
+ mi_error_message = xstrprintf ("mi_cmd_data_list_register_values: Usage: -data-list-register-values <format> [<regnum1>...<regnumN>]");
return MI_CMD_ERROR;
}
if (!target_has_registers)
{
- xasprintf (&mi_error_message,
- "mi_cmd_data_list_register_values: No registers.");
+ mi_error_message = xstrprintf ("mi_cmd_data_list_register_values: No registers.");
return MI_CMD_ERROR;
}
else
{
do_cleanups (list_cleanup);
- xasprintf (&mi_error_message, "bad register number");
+ mi_error_message = xstrprintf ("bad register number");
return MI_CMD_ERROR;
}
}
static int
get_register (int regnum, int format)
{
- char raw_buffer[MAX_REGISTER_SIZE];
- char virtual_buffer[MAX_REGISTER_SIZE];
+ char buffer[MAX_REGISTER_SIZE];
int optim;
int realnum;
CORE_ADDR addr;
format = 0;
frame_register (deprecated_selected_frame, regnum, &optim, &lval, &addr,
- &realnum, raw_buffer);
+ &realnum, buffer);
if (optim)
{
- xasprintf (&mi_error_message, "Optimized out");
+ mi_error_message = xstrprintf ("Optimized out");
return -1;
}
- /* Convert raw data to virtual format if necessary. */
-
- if (DEPRECATED_REGISTER_CONVERTIBLE_P ()
- && DEPRECATED_REGISTER_CONVERTIBLE (regnum))
- {
- DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (regnum,
- register_type (current_gdbarch, regnum),
- raw_buffer, virtual_buffer);
- }
- else
- memcpy (virtual_buffer, raw_buffer, DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum));
-
if (format == 'r')
{
int j;
strcpy (buf, "0x");
ptr = buf + 2;
- for (j = 0; j < DEPRECATED_REGISTER_RAW_SIZE (regnum); j++)
+ for (j = 0; j < register_size (current_gdbarch, regnum); j++)
{
int idx = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? j
- : DEPRECATED_REGISTER_RAW_SIZE (regnum) - 1 - j;
- sprintf (ptr, "%02x", (unsigned char) raw_buffer[idx]);
+ : register_size (current_gdbarch, regnum) - 1 - j;
+ sprintf (ptr, "%02x", (unsigned char) buffer[idx]);
ptr += 2;
}
ui_out_field_string (uiout, "value", buf);
}
else
{
- val_print (register_type (current_gdbarch, regnum), virtual_buffer, 0, 0,
+ val_print (register_type (current_gdbarch, regnum), buffer, 0, 0,
stb->stream, format, 1, 0, Val_pretty_default);
ui_out_field_stream (uiout, "value", stb);
ui_out_stream_delete (stb);
case, some entries of REGISTER_NAME will change depending upon
the particular processor being debugged. */
- numregs = NUM_REGS;
+ numregs = NUM_REGS + NUM_PSEUDO_REGS;
if (argc == 0)
{
- xasprintf (&mi_error_message,
- "mi_cmd_data_write_register_values: Usage: -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]");
+ mi_error_message = xstrprintf ("mi_cmd_data_write_register_values: Usage: -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]");
return MI_CMD_ERROR;
}
if (!target_has_registers)
{
- xasprintf (&mi_error_message,
- "mi_cmd_data_write_register_values: No registers.");
+ mi_error_message = xstrprintf ("mi_cmd_data_write_register_values: No registers.");
return MI_CMD_ERROR;
}
if (!(argc - 1))
{
- xasprintf (&mi_error_message,
- "mi_cmd_data_write_register_values: No regs and values specified.");
+ mi_error_message = xstrprintf ("mi_cmd_data_write_register_values: No regs and values specified.");
return MI_CMD_ERROR;
}
if ((argc - 1) % 2)
{
- xasprintf (&mi_error_message,
- "mi_cmd_data_write_register_values: Regs and vals are not in pairs.");
+ mi_error_message = xstrprintf ("mi_cmd_data_write_register_values: Regs and vals are not in pairs.");
return MI_CMD_ERROR;
}
old_chain = make_cleanup (xfree, buffer);
store_signed_integer (buffer, DEPRECATED_REGISTER_SIZE, value);
/* Write it down */
- deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (regnum), buffer, DEPRECATED_REGISTER_RAW_SIZE (regnum));
+ deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (regnum), buffer, register_size (current_gdbarch, regnum));
/* Free the buffer. */
do_cleanups (old_chain);
}
else
{
- xasprintf (&mi_error_message, "bad register number");
+ mi_error_message = xstrprintf ("bad register number");
return MI_CMD_ERROR;
}
}
if (argc != 1)
{
- xasprintf (&mi_error_message,
- "mi_cmd_data_assign: Usage: -data-assign expression");
+ mi_error_message = xstrprintf ("mi_cmd_data_assign: Usage: -data-assign expression");
return MI_CMD_ERROR;
}
if (argc != 1)
{
- xasprintf (&mi_error_message,
- "mi_cmd_data_evaluate_expression: Usage: -data-evaluate-expression expression");
+ mi_error_message = xstrprintf ("mi_cmd_data_evaluate_expression: Usage: -data-evaluate-expression expression");
return MI_CMD_ERROR;
}
val = evaluate_expression (expr);
/* Print the result of the expression evaluation. */
- val_print (VALUE_TYPE (val), VALUE_CONTENTS (val),
+ val_print (value_type (val), VALUE_CONTENTS (val),
VALUE_EMBEDDED_OFFSET (val), VALUE_ADDRESS (val),
stb->stream, 0, 0, 0, 0);
char *run;
struct cleanup *old_cleanups = NULL;
- xasprintf (&run, "load %s", args);
+ run = xstrprintf ("load %s", args);
old_cleanups = make_cleanup (xfree, run);
execute_command (run, from_tty);
char *run;
struct cleanup *old_cleanups = NULL;
- xasprintf (&run, "target %s", args);
+ run = xstrprintf ("target %s", args);
old_cleanups = make_cleanup (xfree, run);
/* target-select is always synchronous. once the call has returned
if (argc < 5 || argc > 6)
{
- xasprintf (&mi_error_message,
- "mi_cmd_data_read_memory: Usage: ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR].");
+ mi_error_message = xstrprintf ("mi_cmd_data_read_memory: Usage: ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR].");
return MI_CMD_ERROR;
}
nr_rows = atol (argv[3]);
if (nr_rows <= 0)
{
- xasprintf (&mi_error_message,
- "mi_cmd_data_read_memory: invalid number of rows.");
+ mi_error_message = xstrprintf ("mi_cmd_data_read_memory: invalid number of rows.");
return MI_CMD_ERROR;
}
/* number of bytes per row. */
nr_cols = atol (argv[4]);
if (nr_cols <= 0)
{
- xasprintf (&mi_error_message,
- "mi_cmd_data_read_memory: invalid number of columns.");
+ mi_error_message = xstrprintf ("mi_cmd_data_read_memory: invalid number of columns.");
return MI_CMD_ERROR;
}
/* The un-printable character when printing ascii. */
if (argc != 4)
{
- xasprintf (&mi_error_message,
- "mi_cmd_data_write_memory: Usage: [-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE.");
+ mi_error_message = xstrprintf ("mi_cmd_data_write_memory: Usage: [-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE.");
return MI_CMD_ERROR;
}
to perfrom after the given command has executed (display/supress
prompt, display error). */
-static int
+static void
captured_mi_execute_command (struct ui_out *uiout, void *data)
{
struct captured_mi_execute_command_args *args =
{
mi_out_rewind (uiout);
args->action = EXECUTE_COMMAND_DISPLAY_ERROR;
- return 1;
+ return;
}
else
mi_out_rewind (uiout);
/* Don't print the prompt. We are executing the target in
synchronous mode. */
args->action = EXECUTE_COMMAND_SUPRESS_PROMPT;
- return 1;
+ return;
}
break;
}
- return 1;
+ return;
}
struct mi_parse *command;
struct captured_mi_execute_command_args args;
struct ui_out *saved_uiout = uiout;
- int result;
/* This is to handle EOF (^D). We just quit gdb. */
/* FIXME: we should call some API function here. */
if (command != NULL)
{
+ struct exception result;
/* FIXME: cagney/1999-11-04: Can this use of catch_exceptions either
be pushed even further down or even eliminated? */
args.command = command;
- result = catch_exceptions (uiout, captured_mi_execute_command, &args, "",
- RETURN_MASK_ALL);
+ result = catch_exception (uiout, captured_mi_execute_command, &args,
+ RETURN_MASK_ALL);
if (args.action == EXECUTE_COMMAND_SUPRESS_PROMPT)
{
mi_parse_free (command);
return;
}
- if (args.action == EXECUTE_COMMAND_DISPLAY_ERROR || result < 0)
+ if (args.action == EXECUTE_COMMAND_DISPLAY_ERROR
+ || result.reason < 0)
{
- char *msg = error_last_message ();
+ char *msg = result.message;
struct cleanup *cleanup = make_cleanup (xfree, msg);
/* The command execution failed and error() was called
somewhere */
struct cleanup *old_cleanups;
char *run;
if (args_p)
- xasprintf (&run, "%s %s", cmd, args);
+ run = xstrprintf ("%s %s", cmd, args);
else
run = xstrdup (cmd);
if (mi_debug_p)
make_exec_cleanup (free, async_args);
strcpy (async_args, args);
strcat (async_args, "&");
- xasprintf (&run, "%s %s", mi, async_args);
+ run = xstrprintf ("%s %s", mi, async_args);
make_exec_cleanup (free, run);
add_continuation (mi_exec_async_cli_cmd_continuation, NULL);
old_cleanups = NULL;
}
else
{
- xasprintf (&run, "%s %s", mi, args);
+ run = xstrprintf ("%s %s", mi, args);
old_cleanups = make_cleanup (xfree, run);
}
projects / deliverable / binutils-gdb.git / blobdiff