void
mi_cmd_var_assign (char *command, char **argv, int argc)
{
struct ui_out *uiout = current_uiout;
struct varobj *var;
char *expression, *val;
struct cleanup *cleanup;
if (argc != 2)
error (_("-var-assign: Usage: NAME EXPRESSION."));
/* Get varobj handle, if a valid var obj name was specified. */
var = varobj_get_handle (argv[0]);
if (!varobj_editable_p (var))
error (_("-var-assign: Variable object is not editable"));
expression = xstrdup (argv[1]);
/* MI command '-var-assign' may write memory, so suppress memory
changed notification if it does. */
cleanup
= make_cleanup_restore_integer (&mi_suppress_notification.memory);
mi_suppress_notification.memory = 1;
if (!varobj_set_value (var, expression))
error (_("-var-assign: Could not assign "
"expression to variable object"));
val = varobj_get_value (var);
ui_out_field_string (uiout, "value", val);
xfree (val);
do_cleanups (cleanup);
}
enum mi_cmd_result
mi_cmd_var_assign (char *command, char **argv, int argc)
{
struct varobj *var;
char *expression;
if (argc != 2)
error ("mi_cmd_var_assign: Usage: NAME EXPRESSION.");
/* Get varobj handle, if a valid var obj name was specified */
var = varobj_get_handle (argv[0]);
if (var == NULL)
error ("mi_cmd_var_assign: Variable object not found");
/* FIXME: define masks for attributes */
if (!(varobj_get_attributes (var) & 0x00000001))
error ("mi_cmd_var_assign: Variable object is not editable");
expression = xstrdup (argv[1]);
if (!varobj_set_value (var, expression))
error ("mi_cmd_var_assign: Could not assign expression to varible object");
ui_out_field_string (uiout, "value", varobj_get_value (var));
return MI_CMD_DONE;
}
void
mi_cmd_var_set_format (char *command, char **argv, int argc)
{
enum varobj_display_formats format;
struct varobj *var;
char *val;
struct ui_out *uiout = current_uiout;
if (argc != 2)
error (_("-var-set-format: Usage: NAME FORMAT."));
/* Get varobj handle, if a valid var obj name was specified. */
var = varobj_get_handle (argv[0]);
format = mi_parse_format (argv[1]);
/* Set the format of VAR to the given format. */
varobj_set_display_format (var, format);
/* Report the new current format. */
ui_out_field_string (uiout, "format", varobj_format_string[(int) format]);
/* Report the value in the new format. */
val = varobj_get_value (var);
ui_out_field_string (uiout, "value", val);
xfree (val);
}
static int
varobj_update_one (struct varobj *var, enum print_values print_values)
{
struct varobj **changelist;
struct varobj **cc;
struct cleanup *cleanup = NULL;
int nc;
nc = varobj_update (&var, &changelist);
/* nc == 0 means that nothing has changed.
nc == -1 means that an error occured in updating the variable.
nc == -2 means the variable has changed type. */
if (nc == 0)
return 1;
else if (nc == -1)
{
if (mi_version (uiout) > 1)
cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
ui_out_field_string (uiout, "name", varobj_get_objname(var));
ui_out_field_string (uiout, "in_scope", "false");
if (mi_version (uiout) > 1)
do_cleanups (cleanup);
return -1;
}
else if (nc == -2)
{
if (mi_version (uiout) > 1)
cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
ui_out_field_string (uiout, "name", varobj_get_objname (var));
ui_out_field_string (uiout, "in_scope", "true");
ui_out_field_string (uiout, "new_type", varobj_get_type(var));
ui_out_field_int (uiout, "new_num_children",
varobj_get_num_children(var));
if (mi_version (uiout) > 1)
do_cleanups (cleanup);
}
else
{
cc = changelist;
while (*cc != NULL)
{
if (mi_version (uiout) > 1)
cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
ui_out_field_string (uiout, "name", varobj_get_objname (*cc));
if (mi_print_value_p (varobj_get_gdb_type (*cc), print_values))
ui_out_field_string (uiout, "value", varobj_get_value (*cc));
ui_out_field_string (uiout, "in_scope", "true");
ui_out_field_string (uiout, "type_changed", "false");
if (mi_version (uiout) > 1)
do_cleanups (cleanup);
cc++;
}
xfree (changelist);
return 1;
}
return 1;
}
enum mi_cmd_result
mi_cmd_var_list_children (char *command, char **argv, int argc)
{
struct varobj *var;
struct varobj **childlist;
struct varobj **cc;
struct cleanup *cleanup_children;
int numchild;
char *type;
enum print_values print_values;
if (argc != 1 && argc != 2)
error (_("mi_cmd_var_list_children: Usage: [PRINT_VALUES] NAME"));
/* Get varobj handle, if a valid var obj name was specified */
if (argc == 1)
var = varobj_get_handle (argv[0]);
else
var = varobj_get_handle (argv[1]);
if (var == NULL)
error (_("Variable object not found"));
numchild = varobj_list_children (var, &childlist);
ui_out_field_int (uiout, "numchild", numchild);
if (argc == 2)
print_values = mi_parse_values_option (argv[0]);
else
print_values = PRINT_NO_VALUES;
if (numchild <= 0)
return MI_CMD_DONE;
if (mi_version (uiout) == 1)
cleanup_children = make_cleanup_ui_out_tuple_begin_end (uiout, "children");
else
cleanup_children = make_cleanup_ui_out_list_begin_end (uiout, "children");
cc = childlist;
while (*cc != NULL)
{
struct cleanup *cleanup_child;
cleanup_child = make_cleanup_ui_out_tuple_begin_end (uiout, "child");
ui_out_field_string (uiout, "name", varobj_get_objname (*cc));
ui_out_field_string (uiout, "exp", varobj_get_expression (*cc));
ui_out_field_int (uiout, "numchild", varobj_get_num_children (*cc));
if (mi_print_value_p (varobj_get_gdb_type (*cc), print_values))
ui_out_field_string (uiout, "value", varobj_get_value (*cc));
type = varobj_get_type (*cc);
/* C++ pseudo-variables (public, private, protected) do not have a type */
if (type)
ui_out_field_string (uiout, "type", type);
do_cleanups (cleanup_child);
cc++;
}
do_cleanups (cleanup_children);
xfree (childlist);
return MI_CMD_DONE;
}
static void
print_varobj (struct varobj *var, enum print_values print_values,
int print_expression)
{
struct ui_out *uiout = current_uiout;
char *type;
int thread_id;
char *display_hint;
ui_out_field_string (uiout, "name", varobj_get_objname (var));
if (print_expression)
{
char *exp = varobj_get_expression (var);
ui_out_field_string (uiout, "exp", exp);
xfree (exp);
}
ui_out_field_int (uiout, "numchild", varobj_get_num_children (var));
if (mi_print_value_p (var, print_values))
{
char *val = varobj_get_value (var);
ui_out_field_string (uiout, "value", val);
xfree (val);
}
type = varobj_get_type (var);
if (type != NULL)
{
ui_out_field_string (uiout, "type", type);
xfree (type);
}
thread_id = varobj_get_thread_id (var);
if (thread_id > 0)
ui_out_field_int (uiout, "thread-id", thread_id);
if (varobj_get_frozen (var))
ui_out_field_int (uiout, "frozen", 1);
display_hint = varobj_get_display_hint (var);
if (display_hint)
{
ui_out_field_string (uiout, "displayhint", display_hint);
xfree (display_hint);
}
if (varobj_is_dynamic_p (var))
ui_out_field_int (uiout, "dynamic", 1);
}
enum mi_cmd_result
mi_cmd_var_evaluate_expression (char *command, char **argv, int argc)
{
struct varobj *var;
if (argc != 1)
error ("mi_cmd_var_evaluate_expression: Usage: NAME.");
/* Get varobj handle, if a valid var obj name was specified */
var = varobj_get_handle (argv[0]);
if (var == NULL)
error ("mi_cmd_var_evaluate_expression: Variable object not found");
ui_out_field_string (uiout, "value", varobj_get_value (var));
return MI_CMD_DONE;
}
static void
varobj_update_one (struct varobj *var, enum print_values print_values,
int is_explicit)
{
struct ui_out *uiout = current_uiout;
VEC (varobj_update_result) *changes;
varobj_update_result *r;
int i;
changes = varobj_update (&var, is_explicit);
for (i = 0; VEC_iterate (varobj_update_result, changes, i, r); ++i)
{
char *display_hint;
int from, to;
struct cleanup *cleanup = make_cleanup (null_cleanup, NULL);
if (mi_version (uiout) > 1)
make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
ui_out_field_string (uiout, "name", varobj_get_objname (r->varobj));
switch (r->status)
{
case VAROBJ_IN_SCOPE:
if (mi_print_value_p (r->varobj, print_values))
{
char *val = varobj_get_value (r->varobj);
ui_out_field_string (uiout, "value", val);
xfree (val);
}
ui_out_field_string (uiout, "in_scope", "true");
break;
case VAROBJ_NOT_IN_SCOPE:
ui_out_field_string (uiout, "in_scope", "false");
break;
case VAROBJ_INVALID:
ui_out_field_string (uiout, "in_scope", "invalid");
break;
}
if (r->status != VAROBJ_INVALID)
{
if (r->type_changed)
ui_out_field_string (uiout, "type_changed", "true");
else
ui_out_field_string (uiout, "type_changed", "false");
}
if (r->type_changed)
{
char *type_name = varobj_get_type (r->varobj);
ui_out_field_string (uiout, "new_type", type_name);
xfree (type_name);
}
if (r->type_changed || r->children_changed)
ui_out_field_int (uiout, "new_num_children",
varobj_get_num_children (r->varobj));
display_hint = varobj_get_display_hint (r->varobj);
if (display_hint)
{
ui_out_field_string (uiout, "displayhint", display_hint);
xfree (display_hint);
}
if (varobj_is_dynamic_p (r->varobj))
ui_out_field_int (uiout, "dynamic", 1);
varobj_get_child_range (r->varobj, &from, &to);
ui_out_field_int (uiout, "has_more",
varobj_has_more (r->varobj, to));
if (r->newobj)
{
int j;
varobj_p child;
struct cleanup *cleanup;
cleanup = make_cleanup_ui_out_list_begin_end (uiout, "new_children");
for (j = 0; VEC_iterate (varobj_p, r->newobj, j, child); ++j)
{
struct cleanup *cleanup_child;
cleanup_child
= make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
print_varobj (child, print_values, 1 /* print_expression */);
do_cleanups (cleanup_child);
}
do_cleanups (cleanup);
VEC_free (varobj_p, r->newobj);
r->newobj = NULL; /* Paranoia. */
}
do_cleanups (cleanup);
}
VEC_free (varobj_update_result, changes);
}
void
mi_cmd_var_evaluate_expression (char *command, char **argv, int argc)
{
struct ui_out *uiout = current_uiout;
struct varobj *var;
enum varobj_display_formats format;
int formatFound;
int oind;
char *oarg;
enum opt
{
OP_FORMAT
};
static const struct mi_opt opts[] =
{
{"f", OP_FORMAT, 1},
{ 0, 0, 0 }
};
/* Parse arguments. */
format = FORMAT_NATURAL;
formatFound = 0;
oind = 0;
while (1)
{
int opt = mi_getopt ("-var-evaluate-expression", argc, argv,
opts, &oind, &oarg);
if (opt < 0)
break;
switch ((enum opt) opt)
{
case OP_FORMAT:
if (formatFound)
error (_("Cannot specify format more than once"));
format = mi_parse_format (oarg);
formatFound = 1;
break;
}
}
if (oind >= argc)
error (_("Usage: [-f FORMAT] NAME"));
if (oind < argc - 1)
error (_("Garbage at end of command"));
/* Get varobj handle, if a valid var obj name was specified. */
var = varobj_get_handle (argv[oind]);
if (formatFound)
{
char *val = varobj_get_formatted_value (var, format);
ui_out_field_string (uiout, "value", val);
xfree (val);
}
else
{
char *val = varobj_get_value (var);
ui_out_field_string (uiout, "value", val);
xfree (val);
}
}