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; }
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_show_attributes (char *command, char **argv, int argc) { int attr; char *attstr; struct varobj *var; if (argc != 1) error ("mi_cmd_var_show_attributes: 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_show_attributes: Variable object not found"); attr = varobj_get_attributes (var); /* FIXME: define masks for attributes */ if (attr & 0x00000001) attstr = "editable"; else attstr = "noneditable"; ui_out_field_string (uiout, "attr", attstr); 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); }
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; }
enum mi_cmd_result mi_cmd_var_delete (char *command, char **argv, int argc) { char *name; char *expr; struct varobj *var; int numdel; int children_only_p = 0; struct cleanup *old_cleanups; if (argc < 1 || argc > 2) error ("mi_cmd_var_delete: Usage: [-c] EXPRESSION."); name = xstrdup (argv[0]); /* Add cleanup for name. Must be free_current_contents as name can be reallocated */ old_cleanups = make_cleanup (free_current_contents, &name); /* If we have one single argument it cannot be '-c' or any string starting with '-'. */ if (argc == 1) { if (strcmp (name, "-c") == 0) error ("mi_cmd_var_delete: Missing required argument after '-c': variable object name"); if (*name == '-') error ("mi_cmd_var_delete: Illegal variable object name"); } /* If we have 2 arguments they must be '-c' followed by a string which would be the variable name. */ if (argc == 2) { expr = xstrdup (argv[1]); if (strcmp (name, "-c") != 0) error ("mi_cmd_var_delete: Invalid option."); children_only_p = 1; xfree (name); name = xstrdup (expr); xfree (expr); } /* If we didn't error out, now NAME contains the name of the variable. */ var = varobj_get_handle (name); if (var == NULL) error ("mi_cmd_var_delete: Variable object not found."); numdel = varobj_delete (var, NULL, children_only_p); ui_out_field_int (uiout, "ndeleted", numdel); do_cleanups (old_cleanups); return MI_CMD_DONE; }
enum mi_cmd_result mi_cmd_var_update (char *command, char **argv, int argc) { struct varobj *var; struct varobj **rootlist; struct varobj **cr; struct cleanup *cleanup; char *name; int nv; if (argc != 1) error ("mi_cmd_var_update: Usage: NAME."); name = argv[0]; /* Check if the parameter is a "*" which means that we want to update all variables */ if ((*name == '*') && (*(name + 1) == '\0')) { nv = varobj_list (&rootlist); if (mi_version (uiout) <= 1) cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, "changelist"); else cleanup = make_cleanup_ui_out_list_begin_end (uiout, "changelist"); if (nv <= 0) { do_cleanups (cleanup); return MI_CMD_DONE; } cr = rootlist; while (*cr != NULL) { varobj_update_one (*cr); cr++; } xfree (rootlist); do_cleanups (cleanup); } else { /* Get varobj handle, if a valid var obj name was specified */ var = varobj_get_handle (name); if (var == NULL) error ("mi_cmd_var_update: Variable object not found"); if (mi_version (uiout) <= 1) cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, "changelist"); else cleanup = make_cleanup_ui_out_list_begin_end (uiout, "changelist"); varobj_update_one (var); do_cleanups (cleanup); } return MI_CMD_DONE; }
void mi_cmd_var_update (char *command, char **argv, int argc) { struct ui_out *uiout = current_uiout; struct cleanup *cleanup; char *name; enum print_values print_values; if (argc != 1 && argc != 2) error (_("-var-update: Usage: [PRINT_VALUES] NAME.")); if (argc == 1) name = argv[0]; else name = argv[1]; if (argc == 2) print_values = mi_parse_print_values (argv[0]); else print_values = PRINT_NO_VALUES; if (mi_version (uiout) <= 1) cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, "changelist"); else cleanup = make_cleanup_ui_out_list_begin_end (uiout, "changelist"); /* Check if the parameter is a "*", which means that we want to update all variables. */ if ((*name == '*' || *name == '@') && (*(name + 1) == '\0')) { struct mi_cmd_var_update data; data.only_floating = (*name == '@'); data.print_values = print_values; /* varobj_update_one automatically updates all the children of VAROBJ. Therefore update each VAROBJ only once by iterating only the root VAROBJs. */ all_root_varobjs (mi_cmd_var_update_iter, &data); } else { /* Get varobj handle, if a valid var obj name was specified. */ struct varobj *var = varobj_get_handle (name); varobj_update_one (var, print_values, 1 /* explicit */); } do_cleanups (cleanup); }
void mi_cmd_var_info_num_children (char *command, char **argv, int argc) { struct ui_out *uiout = current_uiout; struct varobj *var; if (argc != 1) error (_("-var-info-num-children: Usage: NAME.")); /* Get varobj handle, if a valid var obj name was specified. */ var = varobj_get_handle (argv[0]); ui_out_field_int (uiout, "numchild", varobj_get_num_children (var)); }
void mi_cmd_var_set_visualizer (char *command, char **argv, int argc) { struct varobj *var; if (argc != 2) error (_("Usage: NAME VISUALIZER_FUNCTION.")); var = varobj_get_handle (argv[0]); if (var == NULL) error (_("Variable object not found")); varobj_set_visualizer (var, argv[1]); }
void mi_cmd_var_set_update_range (char *command, char **argv, int argc) { struct varobj *var; int from, to; if (argc != 3) error (_("-var-set-update-range: Usage: VAROBJ FROM TO")); var = varobj_get_handle (argv[0]); from = atoi (argv[1]); to = atoi (argv[2]); varobj_set_child_range (var, from, to); }
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; }
enum mi_cmd_result mi_cmd_var_info_num_children (char *command, char **argv, int argc) { struct varobj *var; if (argc != 1) error ("mi_cmd_var_info_num_children: 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_info_num_children: Variable object not found"); ui_out_field_int (uiout, "numchild", varobj_get_num_children (var)); return MI_CMD_DONE; }
void mi_cmd_var_info_path_expression (char *command, char **argv, int argc) { struct ui_out *uiout = current_uiout; struct varobj *var; char *path_expr; if (argc != 1) error (_("Usage: NAME.")); /* Get varobj handle, if a valid var obj name was specified. */ var = varobj_get_handle (argv[0]); path_expr = varobj_get_path_expr (var); ui_out_field_string (uiout, "path_expr", path_expr); }
void mi_cmd_var_show_format (char *command, char **argv, int argc) { struct ui_out *uiout = current_uiout; enum varobj_display_formats format; struct varobj *var; if (argc != 1) error (_("-var-show-format: Usage: NAME.")); /* Get varobj handle, if a valid var obj name was specified. */ var = varobj_get_handle (argv[0]); format = varobj_get_display_format (var); /* Report the current format. */ ui_out_field_string (uiout, "format", varobj_format_string[(int) format]); }
void mi_cmd_var_info_type (char *command, char **argv, int argc) { struct ui_out *uiout = current_uiout; struct varobj *var; char *type_name; if (argc != 1) error (_("-var-info-type: Usage: NAME.")); /* Get varobj handle, if a valid var obj name was specified. */ var = varobj_get_handle (argv[0]); type_name = varobj_get_type (var); ui_out_field_string (uiout, "type", type_name); xfree (type_name); }
enum mi_cmd_result mi_cmd_var_set_format (char *command, char **argv, int argc) { enum varobj_display_formats format; int len; struct varobj *var; char *formspec; if (argc != 2) error ("mi_cmd_var_set_format: Usage: NAME FORMAT."); /* Get varobj handle, if a valid var obj name was specified */ var = varobj_get_handle (argv[0]); if (var == NULL) error ("mi_cmd_var_set_format: Variable object not found"); formspec = xstrdup (argv[1]); if (formspec == NULL) error ("mi_cmd_var_set_format: Must specify the format as: \"natural\", \"binary\", \"decimal\", \"hexadecimal\", or \"octal\""); len = strlen (formspec); if (strncmp (formspec, "natural", len) == 0) format = FORMAT_NATURAL; else if (strncmp (formspec, "binary", len) == 0) format = FORMAT_BINARY; else if (strncmp (formspec, "decimal", len) == 0) format = FORMAT_DECIMAL; else if (strncmp (formspec, "hexadecimal", len) == 0) format = FORMAT_HEXADECIMAL; else if (strncmp (formspec, "octal", len) == 0) format = FORMAT_OCTAL; else error ("mi_cmd_var_set_format: Unknown display format: must be: \"natural\", \"binary\", \"decimal\", \"hexadecimal\", or \"octal\""); /* Set the format of VAR to given format */ varobj_set_display_format (var, format); /* Report the new current format */ ui_out_field_string (uiout, "format", varobj_format_string[(int) format]); return MI_CMD_DONE; }
enum mi_cmd_result mi_cmd_var_info_expression (char *command, char **argv, int argc) { enum varobj_languages lang; struct varobj *var; if (argc != 1) error ("mi_cmd_var_info_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_info_expression: Variable object not found"); lang = varobj_get_language (var); ui_out_field_string (uiout, "lang", varobj_language_string[(int) lang]); ui_out_field_string (uiout, "exp", varobj_get_expression (var)); return MI_CMD_DONE; }
enum mi_cmd_result mi_cmd_var_show_format (char *command, char **argv, int argc) { enum varobj_display_formats format; struct varobj *var; if (argc != 1) error ("mi_cmd_var_show_format: 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_show_format: Variable object not found"); format = varobj_get_display_format (var); /* Report the current format */ ui_out_field_string (uiout, "format", varobj_format_string[(int) format]); return MI_CMD_DONE; }
void mi_cmd_var_info_expression (char *command, char **argv, int argc) { struct ui_out *uiout = current_uiout; const struct language_defn *lang; struct varobj *var; char *exp; if (argc != 1) error (_("-var-info-expression: Usage: NAME.")); /* Get varobj handle, if a valid var obj name was specified. */ var = varobj_get_handle (argv[0]); lang = varobj_get_language (var); ui_out_field_string (uiout, "lang", lang->la_natural_name); exp = varobj_get_expression (var); ui_out_field_string (uiout, "exp", exp); xfree (exp); }
void mi_cmd_var_show_attributes (char *command, char **argv, int argc) { struct ui_out *uiout = current_uiout; int attr; char *attstr; struct varobj *var; if (argc != 1) error (_("-var-show-attributes: Usage: NAME.")); /* Get varobj handle, if a valid var obj name was specified */ var = varobj_get_handle (argv[0]); attr = varobj_get_attributes (var); /* FIXME: define masks for attributes */ if (attr & 0x00000001) attstr = "editable"; else attstr = "noneditable"; ui_out_field_string (uiout, "attr", attstr); }
void mi_cmd_var_set_frozen (char *command, char **argv, int argc) { struct varobj *var; int frozen; if (argc != 2) error (_("-var-set-format: Usage: NAME FROZEN_FLAG.")); var = varobj_get_handle (argv[0]); if (strcmp (argv[1], "0") == 0) frozen = 0; else if (strcmp (argv[1], "1") == 0) frozen = 1; else error (_("Invalid flag value")); varobj_set_frozen (var, frozen); /* We don't automatically return the new value, or what varobjs got new values during unfreezing. If this information is required, client should call -var-update explicitly. */ }
void mi_cmd_var_list_children (char *command, char **argv, int argc) { struct ui_out *uiout = current_uiout; struct varobj *var; VEC(varobj_p) *children; struct varobj *child; enum print_values print_values; int ix; int from, to; char *display_hint; if (argc < 1 || argc > 4) error (_("-var-list-children: Usage: " "[PRINT_VALUES] NAME [FROM TO]")); /* Get varobj handle, if a valid var obj name was specified. */ if (argc == 1 || argc == 3) var = varobj_get_handle (argv[0]); else var = varobj_get_handle (argv[1]); if (argc > 2) { from = atoi (argv[argc - 2]); to = atoi (argv[argc - 1]); } else { from = -1; to = -1; } children = varobj_list_children (var, &from, &to); ui_out_field_int (uiout, "numchild", to - from); if (argc == 2 || argc == 4) print_values = mi_parse_print_values (argv[0]); else print_values = PRINT_NO_VALUES; display_hint = varobj_get_display_hint (var); if (display_hint) { ui_out_field_string (uiout, "displayhint", display_hint); xfree (display_hint); } if (from < to) { struct cleanup *cleanup_children; 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"); for (ix = from; ix < to && VEC_iterate (varobj_p, children, ix, child); ++ix) { struct cleanup *cleanup_child; cleanup_child = make_cleanup_ui_out_tuple_begin_end (uiout, "child"); print_varobj (child, print_values, 1 /* print expression */); do_cleanups (cleanup_child); } do_cleanups (cleanup_children); } ui_out_field_int (uiout, "has_more", varobj_has_more (var, to)); }
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); } }