1 /* Implementation of the GDB variable objects API.
3 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
4 2009 Free Software Foundation, Inc.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 #include "exceptions.h"
22 #include "expression.h"
30 #include "gdb_assert.h"
31 #include "gdb_string.h"
35 #include "gdbthread.h"
39 #include "python/python.h"
40 #include "python/python-internal.h"
45 /* Non-zero if we want to see trace of varobj level stuff. */
49 show_varobjdebug (struct ui_file *file, int from_tty,
50 struct cmd_list_element *c, const char *value)
52 fprintf_filtered (file, _("Varobj debugging is %s.\n"), value);
55 /* String representations of gdb's format codes */
56 char *varobj_format_string[] =
57 { "natural", "binary", "decimal", "hexadecimal", "octal" };
59 /* String representations of gdb's known languages */
60 char *varobj_language_string[] = { "unknown", "C", "C++", "Java" };
64 /* Every root variable has one of these structures saved in its
65 varobj. Members which must be free'd are noted. */
69 /* Alloc'd expression for this parent. */
70 struct expression *exp;
72 /* Block for which this expression is valid */
73 struct block *valid_block;
75 /* The frame for this expression. This field is set iff valid_block is
77 struct frame_id frame;
79 /* The thread ID that this varobj_root belong to. This field
80 is only valid if valid_block is not NULL.
81 When not 0, indicates which thread 'frame' belongs to.
82 When 0, indicates that the thread list was empty when the varobj_root
86 /* If 1, the -var-update always recomputes the value in the
87 current thread and frame. Otherwise, variable object is
88 always updated in the specific scope/thread/frame */
91 /* Flag that indicates validity: set to 0 when this varobj_root refers
92 to symbols that do not exist anymore. */
95 /* Language info for this variable and its children */
96 struct language_specific *lang;
98 /* The varobj for this root node. */
99 struct varobj *rootvar;
101 /* Next root variable */
102 struct varobj_root *next;
105 /* Every variable in the system has a structure of this type defined
106 for it. This structure holds all information necessary to manipulate
107 a particular object variable. Members which must be freed are noted. */
111 /* Alloc'd name of the variable for this object.. If this variable is a
112 child, then this name will be the child's source name.
113 (bar, not foo.bar) */
114 /* NOTE: This is the "expression" */
117 /* Alloc'd expression for this child. Can be used to create a
118 root variable corresponding to this child. */
121 /* The alloc'd name for this variable's object. This is here for
122 convenience when constructing this object's children. */
125 /* Index of this variable in its parent or -1 */
128 /* The type of this variable. This can be NULL
129 for artifial variable objects -- currently, the "accessibility"
130 variable objects in C++. */
133 /* The value of this expression or subexpression. A NULL value
134 indicates there was an error getting this value.
135 Invariant: if varobj_value_is_changeable_p (this) is non-zero,
136 the value is either NULL, or not lazy. */
139 /* The number of (immediate) children this variable has */
142 /* If this object is a child, this points to its immediate parent. */
143 struct varobj *parent;
145 /* Children of this object. */
146 VEC (varobj_p) *children;
148 /* Whether the children of this varobj were requested. This field is
149 used to decide if dynamic varobj should recompute their children.
150 In the event that the frontend never asked for the children, we
152 int children_requested;
154 /* Description of the root variable. Points to root variable for children. */
155 struct varobj_root *root;
157 /* The format of the output for this object */
158 enum varobj_display_formats format;
160 /* Was this variable updated via a varobj_set_value operation */
163 /* Last print value. */
166 /* Is this variable frozen. Frozen variables are never implicitly
167 updated by -var-update *
168 or -var-update <direct-or-indirect-parent>. */
171 /* Is the value of this variable intentionally not fetched? It is
172 not fetched if either the variable is frozen, or any parents is
176 /* The pretty-printer that has been constructed. If NULL, then a
177 new printer object is needed, and one will be constructed. */
178 PyObject *pretty_printer;
184 struct cpstack *next;
187 /* A list of varobjs */
195 /* Private function prototypes */
197 /* Helper functions for the above subcommands. */
199 static int delete_variable (struct cpstack **, struct varobj *, int);
201 static void delete_variable_1 (struct cpstack **, int *,
202 struct varobj *, int, int);
204 static int install_variable (struct varobj *);
206 static void uninstall_variable (struct varobj *);
208 static struct varobj *create_child (struct varobj *, int, char *);
210 static struct varobj *
211 create_child_with_value (struct varobj *parent, int index, const char *name,
212 struct value *value);
214 /* Utility routines */
216 static struct varobj *new_variable (void);
218 static struct varobj *new_root_variable (void);
220 static void free_variable (struct varobj *var);
222 static struct cleanup *make_cleanup_free_variable (struct varobj *var);
224 static struct type *get_type (struct varobj *var);
226 static struct type *get_value_type (struct varobj *var);
228 static struct type *get_target_type (struct type *);
230 static enum varobj_display_formats variable_default_display (struct varobj *);
232 static void cppush (struct cpstack **pstack, char *name);
234 static char *cppop (struct cpstack **pstack);
236 static int install_new_value (struct varobj *var, struct value *value,
239 static void install_default_visualizer (struct varobj *var);
241 /* Language-specific routines. */
243 static enum varobj_languages variable_language (struct varobj *var);
245 static int number_of_children (struct varobj *);
247 static char *name_of_variable (struct varobj *);
249 static char *name_of_child (struct varobj *, int);
251 static struct value *value_of_root (struct varobj **var_handle, int *);
253 static struct value *value_of_child (struct varobj *parent, int index);
255 static char *my_value_of_variable (struct varobj *var,
256 enum varobj_display_formats format);
258 static char *value_get_print_value (struct value *value,
259 enum varobj_display_formats format,
262 static int varobj_value_is_changeable_p (struct varobj *var);
264 static int is_root_p (struct varobj *var);
266 static struct varobj *
267 varobj_add_child (struct varobj *var, const char *name, struct value *value);
269 /* C implementation */
271 static int c_number_of_children (struct varobj *var);
273 static char *c_name_of_variable (struct varobj *parent);
275 static char *c_name_of_child (struct varobj *parent, int index);
277 static char *c_path_expr_of_child (struct varobj *child);
279 static struct value *c_value_of_root (struct varobj **var_handle);
281 static struct value *c_value_of_child (struct varobj *parent, int index);
283 static struct type *c_type_of_child (struct varobj *parent, int index);
285 static char *c_value_of_variable (struct varobj *var,
286 enum varobj_display_formats format);
288 /* C++ implementation */
290 static int cplus_number_of_children (struct varobj *var);
292 static void cplus_class_num_children (struct type *type, int children[3]);
294 static char *cplus_name_of_variable (struct varobj *parent);
296 static char *cplus_name_of_child (struct varobj *parent, int index);
298 static char *cplus_path_expr_of_child (struct varobj *child);
300 static struct value *cplus_value_of_root (struct varobj **var_handle);
302 static struct value *cplus_value_of_child (struct varobj *parent, int index);
304 static struct type *cplus_type_of_child (struct varobj *parent, int index);
306 static char *cplus_value_of_variable (struct varobj *var,
307 enum varobj_display_formats format);
309 /* Java implementation */
311 static int java_number_of_children (struct varobj *var);
313 static char *java_name_of_variable (struct varobj *parent);
315 static char *java_name_of_child (struct varobj *parent, int index);
317 static char *java_path_expr_of_child (struct varobj *child);
319 static struct value *java_value_of_root (struct varobj **var_handle);
321 static struct value *java_value_of_child (struct varobj *parent, int index);
323 static struct type *java_type_of_child (struct varobj *parent, int index);
325 static char *java_value_of_variable (struct varobj *var,
326 enum varobj_display_formats format);
328 /* The language specific vector */
330 struct language_specific
333 /* The language of this variable */
334 enum varobj_languages language;
336 /* The number of children of PARENT. */
337 int (*number_of_children) (struct varobj * parent);
339 /* The name (expression) of a root varobj. */
340 char *(*name_of_variable) (struct varobj * parent);
342 /* The name of the INDEX'th child of PARENT. */
343 char *(*name_of_child) (struct varobj * parent, int index);
345 /* Returns the rooted expression of CHILD, which is a variable
346 obtain that has some parent. */
347 char *(*path_expr_of_child) (struct varobj * child);
349 /* The ``struct value *'' of the root variable ROOT. */
350 struct value *(*value_of_root) (struct varobj ** root_handle);
352 /* The ``struct value *'' of the INDEX'th child of PARENT. */
353 struct value *(*value_of_child) (struct varobj * parent, int index);
355 /* The type of the INDEX'th child of PARENT. */
356 struct type *(*type_of_child) (struct varobj * parent, int index);
358 /* The current value of VAR. */
359 char *(*value_of_variable) (struct varobj * var,
360 enum varobj_display_formats format);
363 /* Array of known source language routines. */
364 static struct language_specific languages[vlang_end] = {
365 /* Unknown (try treating as C */
368 c_number_of_children,
371 c_path_expr_of_child,
380 c_number_of_children,
383 c_path_expr_of_child,
392 cplus_number_of_children,
393 cplus_name_of_variable,
395 cplus_path_expr_of_child,
397 cplus_value_of_child,
399 cplus_value_of_variable}
404 java_number_of_children,
405 java_name_of_variable,
407 java_path_expr_of_child,
411 java_value_of_variable}
414 /* A little convenience enum for dealing with C++/Java */
417 v_public = 0, v_private, v_protected
422 /* Mappings of varobj_display_formats enums to gdb's format codes */
423 static int format_code[] = { 0, 't', 'd', 'x', 'o' };
425 /* Header of the list of root variable objects */
426 static struct varobj_root *rootlist;
428 /* Prime number indicating the number of buckets in the hash table */
429 /* A prime large enough to avoid too many colisions */
430 #define VAROBJ_TABLE_SIZE 227
432 /* Pointer to the varobj hash table (built at run time) */
433 static struct vlist **varobj_table;
435 /* Is the variable X one of our "fake" children? */
436 #define CPLUS_FAKE_CHILD(x) \
437 ((x) != NULL && (x)->type == NULL && (x)->value == NULL)
440 /* API Implementation */
442 is_root_p (struct varobj *var)
444 return (var->root->rootvar == var);
448 /* Helper function to install a Python environment suitable for
449 use during operations on VAR. */
451 varobj_ensure_python_env (struct varobj *var)
453 return ensure_python_env (var->root->exp->gdbarch,
454 var->root->exp->language_defn);
458 /* Creates a varobj (not its children) */
460 /* Return the full FRAME which corresponds to the given CORE_ADDR
461 or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
463 static struct frame_info *
464 find_frame_addr_in_frame_chain (CORE_ADDR frame_addr)
466 struct frame_info *frame = NULL;
468 if (frame_addr == (CORE_ADDR) 0)
471 for (frame = get_current_frame ();
473 frame = get_prev_frame (frame))
475 /* The CORE_ADDR we get as argument was parsed from a string GDB
476 output as $fp. This output got truncated to gdbarch_addr_bit.
477 Truncate the frame base address in the same manner before
478 comparing it against our argument. */
479 CORE_ADDR frame_base = get_frame_base_address (frame);
480 int addr_bit = gdbarch_addr_bit (get_frame_arch (frame));
481 if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
482 frame_base &= ((CORE_ADDR) 1 << addr_bit) - 1;
484 if (frame_base == frame_addr)
492 varobj_create (char *objname,
493 char *expression, CORE_ADDR frame, enum varobj_type type)
496 struct frame_info *fi;
497 struct frame_info *old_fi = NULL;
499 struct cleanup *old_chain;
501 /* Fill out a varobj structure for the (root) variable being constructed. */
502 var = new_root_variable ();
503 old_chain = make_cleanup_free_variable (var);
505 if (expression != NULL)
508 enum varobj_languages lang;
509 struct value *value = NULL;
511 /* Parse and evaluate the expression, filling in as much of the
512 variable's data as possible. */
514 if (has_stack_frames ())
516 /* Allow creator to specify context of variable */
517 if ((type == USE_CURRENT_FRAME) || (type == USE_SELECTED_FRAME))
518 fi = get_selected_frame (NULL);
520 /* FIXME: cagney/2002-11-23: This code should be doing a
521 lookup using the frame ID and not just the frame's
522 ``address''. This, of course, means an interface
523 change. However, with out that interface change ISAs,
524 such as the ia64 with its two stacks, won't work.
525 Similar goes for the case where there is a frameless
527 fi = find_frame_addr_in_frame_chain (frame);
532 /* frame = -2 means always use selected frame */
533 if (type == USE_SELECTED_FRAME)
534 var->root->floating = 1;
538 block = get_frame_block (fi, 0);
541 innermost_block = NULL;
542 /* Wrap the call to parse expression, so we can
543 return a sensible error. */
544 if (!gdb_parse_exp_1 (&p, block, 0, &var->root->exp))
549 /* Don't allow variables to be created for types. */
550 if (var->root->exp->elts[0].opcode == OP_TYPE)
552 do_cleanups (old_chain);
553 fprintf_unfiltered (gdb_stderr, "Attempt to use a type name"
554 " as an expression.\n");
558 var->format = variable_default_display (var);
559 var->root->valid_block = innermost_block;
560 var->name = xstrdup (expression);
561 /* For a root var, the name and the expr are the same. */
562 var->path_expr = xstrdup (expression);
564 /* When the frame is different from the current frame,
565 we must select the appropriate frame before parsing
566 the expression, otherwise the value will not be current.
567 Since select_frame is so benign, just call it for all cases. */
570 /* User could specify explicit FRAME-ADDR which was not found but
571 EXPRESSION is frame specific and we would not be able to evaluate
572 it correctly next time. With VALID_BLOCK set we must also set
573 FRAME and THREAD_ID. */
575 error (_("Failed to find the specified frame"));
577 var->root->frame = get_frame_id (fi);
578 var->root->thread_id = pid_to_thread_id (inferior_ptid);
579 old_fi = get_selected_frame (NULL);
583 /* We definitely need to catch errors here.
584 If evaluate_expression succeeds we got the value we wanted.
585 But if it fails, we still go on with a call to evaluate_type() */
586 if (!gdb_evaluate_expression (var->root->exp, &value))
588 /* Error getting the value. Try to at least get the
590 struct value *type_only_value = evaluate_type (var->root->exp);
591 var->type = value_type (type_only_value);
594 var->type = value_type (value);
596 install_new_value (var, value, 1 /* Initial assignment */);
598 /* Set language info */
599 lang = variable_language (var);
600 var->root->lang = &languages[lang];
602 /* Set ourselves as our root */
603 var->root->rootvar = var;
605 /* Reset the selected frame */
607 select_frame (old_fi);
610 /* If the variable object name is null, that means this
611 is a temporary variable, so don't install it. */
613 if ((var != NULL) && (objname != NULL))
615 var->obj_name = xstrdup (objname);
617 /* If a varobj name is duplicated, the install will fail so
619 if (!install_variable (var))
621 do_cleanups (old_chain);
626 install_default_visualizer (var);
627 discard_cleanups (old_chain);
631 /* Generates an unique name that can be used for a varobj */
634 varobj_gen_name (void)
639 /* generate a name for this object */
641 obj_name = xstrprintf ("var%d", id);
646 /* Given an OBJNAME, returns the pointer to the corresponding varobj. Call
647 error if OBJNAME cannot be found. */
650 varobj_get_handle (char *objname)
654 unsigned int index = 0;
657 for (chp = objname; *chp; chp++)
659 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
662 cv = *(varobj_table + index);
663 while ((cv != NULL) && (strcmp (cv->var->obj_name, objname) != 0))
667 error (_("Variable object not found"));
672 /* Given the handle, return the name of the object */
675 varobj_get_objname (struct varobj *var)
677 return var->obj_name;
680 /* Given the handle, return the expression represented by the object */
683 varobj_get_expression (struct varobj *var)
685 return name_of_variable (var);
688 /* Deletes a varobj and all its children if only_children == 0,
689 otherwise deletes only the children; returns a malloc'ed list of all the
690 (malloc'ed) names of the variables that have been deleted (NULL terminated) */
693 varobj_delete (struct varobj *var, char ***dellist, int only_children)
697 struct cpstack *result = NULL;
700 /* Initialize a stack for temporary results */
701 cppush (&result, NULL);
704 /* Delete only the variable children */
705 delcount = delete_variable (&result, var, 1 /* only the children */ );
707 /* Delete the variable and all its children */
708 delcount = delete_variable (&result, var, 0 /* parent+children */ );
710 /* We may have been asked to return a list of what has been deleted */
713 *dellist = xmalloc ((delcount + 1) * sizeof (char *));
717 *cp = cppop (&result);
718 while ((*cp != NULL) && (mycount > 0))
722 *cp = cppop (&result);
725 if (mycount || (*cp != NULL))
726 warning (_("varobj_delete: assertion failed - mycount(=%d) <> 0"),
733 /* Convenience function for varobj_set_visualizer. Instantiate a
734 pretty-printer for a given value. */
736 instantiate_pretty_printer (PyObject *constructor, struct value *value)
739 PyObject *val_obj = NULL;
741 volatile struct gdb_exception except;
743 TRY_CATCH (except, RETURN_MASK_ALL)
745 value = value_copy (value);
747 GDB_PY_HANDLE_EXCEPTION (except);
748 val_obj = value_to_value_object (value);
753 printer = PyObject_CallFunctionObjArgs (constructor, val_obj, NULL);
760 /* Set/Get variable object display format */
762 enum varobj_display_formats
763 varobj_set_display_format (struct varobj *var,
764 enum varobj_display_formats format)
771 case FORMAT_HEXADECIMAL:
773 var->format = format;
777 var->format = variable_default_display (var);
780 if (varobj_value_is_changeable_p (var)
781 && var->value && !value_lazy (var->value))
783 xfree (var->print_value);
784 var->print_value = value_get_print_value (var->value, var->format, var);
790 enum varobj_display_formats
791 varobj_get_display_format (struct varobj *var)
797 varobj_get_display_hint (struct varobj *var)
802 struct cleanup *back_to = varobj_ensure_python_env (var);
804 if (var->pretty_printer)
805 result = gdbpy_get_display_hint (var->pretty_printer);
807 do_cleanups (back_to);
813 /* If the variable object is bound to a specific thread, that
814 is its evaluation can always be done in context of a frame
815 inside that thread, returns GDB id of the thread -- which
816 is always positive. Otherwise, returns -1. */
818 varobj_get_thread_id (struct varobj *var)
820 if (var->root->valid_block && var->root->thread_id > 0)
821 return var->root->thread_id;
827 varobj_set_frozen (struct varobj *var, int frozen)
829 /* When a variable is unfrozen, we don't fetch its value.
830 The 'not_fetched' flag remains set, so next -var-update
833 We don't fetch the value, because for structures the client
834 should do -var-update anyway. It would be bad to have different
835 client-size logic for structure and other types. */
836 var->frozen = frozen;
840 varobj_get_frozen (struct varobj *var)
846 update_dynamic_varobj_children (struct varobj *var,
847 VEC (varobj_p) **changed,
848 VEC (varobj_p) **new_and_unchanged,
853 /* FIXME: we *might* want to provide this functionality as
854 a standalone function, so that other interested parties
855 than varobj code can benefit for this. */
856 struct cleanup *back_to;
860 int children_changed = 0;
861 PyObject *printer = var->pretty_printer;
863 back_to = varobj_ensure_python_env (var);
866 if (!PyObject_HasAttr (printer, gdbpy_children_cst))
868 do_cleanups (back_to);
872 children = PyObject_CallMethodObjArgs (printer, gdbpy_children_cst,
877 gdbpy_print_stack ();
878 error (_("Null value returned for children"));
881 make_cleanup_py_decref (children);
883 if (!PyIter_Check (children))
884 error (_("Returned value is not iterable"));
886 iterator = PyObject_GetIter (children);
889 gdbpy_print_stack ();
890 error (_("Could not get children iterator"));
892 make_cleanup_py_decref (iterator);
896 PyObject *item = PyIter_Next (iterator);
900 struct cleanup *inner;
904 inner = make_cleanup_py_decref (item);
906 if (!PyArg_ParseTuple (item, "sO", &name, &py_v))
907 error (_("Invalid item from the child list"));
909 v = convert_value_from_python (py_v);
911 /* TODO: This assume the name of the i-th child never changes. */
913 /* Now see what to do here. */
914 if (VEC_length (varobj_p, var->children) < i + 1)
916 /* There's no child yet. */
917 struct varobj *child = varobj_add_child (var, name, v);
918 if (new_and_unchanged)
919 VEC_safe_push (varobj_p, *new_and_unchanged, child);
920 children_changed = 1;
924 varobj_p existing = VEC_index (varobj_p, var->children, i);
925 if (install_new_value (existing, v, 0) && changed)
928 VEC_safe_push (varobj_p, *changed, existing);
932 if (new_and_unchanged)
933 VEC_safe_push (varobj_p, *new_and_unchanged, existing);
940 if (i < VEC_length (varobj_p, var->children))
943 children_changed = 1;
944 for (i = 0; i < VEC_length (varobj_p, var->children); ++i)
945 varobj_delete (VEC_index (varobj_p, var->children, i), NULL, 0);
947 VEC_truncate (varobj_p, var->children, i);
948 var->num_children = VEC_length (varobj_p, var->children);
950 do_cleanups (back_to);
952 *cchanged = children_changed;
955 gdb_assert (0 && "should never be called if Python is not enabled");
960 varobj_get_num_children (struct varobj *var)
962 if (var->num_children == -1)
965 if (!var->pretty_printer
966 || !update_dynamic_varobj_children (var, NULL, NULL, &changed))
967 var->num_children = number_of_children (var);
970 return var->num_children;
973 /* Creates a list of the immediate children of a variable object;
974 the return code is the number of such children or -1 on error */
977 varobj_list_children (struct varobj *var)
979 struct varobj *child;
981 int i, children_changed;
983 var->children_requested = 1;
985 if (var->pretty_printer
986 /* This, in theory, can result in the number of children changing without
987 frontend noticing. But well, calling -var-list-children on the same
988 varobj twice is not something a sane frontend would do. */
989 && update_dynamic_varobj_children (var, NULL, NULL, &children_changed))
990 return var->children;
992 if (var->num_children == -1)
993 var->num_children = number_of_children (var);
995 /* If that failed, give up. */
996 if (var->num_children == -1)
997 return var->children;
999 /* If we're called when the list of children is not yet initialized,
1000 allocate enough elements in it. */
1001 while (VEC_length (varobj_p, var->children) < var->num_children)
1002 VEC_safe_push (varobj_p, var->children, NULL);
1004 for (i = 0; i < var->num_children; i++)
1006 varobj_p existing = VEC_index (varobj_p, var->children, i);
1008 if (existing == NULL)
1010 /* Either it's the first call to varobj_list_children for
1011 this variable object, and the child was never created,
1012 or it was explicitly deleted by the client. */
1013 name = name_of_child (var, i);
1014 existing = create_child (var, i, name);
1015 VEC_replace (varobj_p, var->children, i, existing);
1016 install_default_visualizer (existing);
1020 return var->children;
1023 static struct varobj *
1024 varobj_add_child (struct varobj *var, const char *name, struct value *value)
1026 varobj_p v = create_child_with_value (var,
1027 VEC_length (varobj_p, var->children),
1029 VEC_safe_push (varobj_p, var->children, v);
1030 install_default_visualizer (v);
1034 /* Obtain the type of an object Variable as a string similar to the one gdb
1035 prints on the console */
1038 varobj_get_type (struct varobj *var)
1040 /* For the "fake" variables, do not return a type. (It's type is
1042 Do not return a type for invalid variables as well. */
1043 if (CPLUS_FAKE_CHILD (var) || !var->root->is_valid)
1046 return type_to_string (var->type);
1049 /* Obtain the type of an object variable. */
1052 varobj_get_gdb_type (struct varobj *var)
1057 /* Return a pointer to the full rooted expression of varobj VAR.
1058 If it has not been computed yet, compute it. */
1060 varobj_get_path_expr (struct varobj *var)
1062 if (var->path_expr != NULL)
1063 return var->path_expr;
1066 /* For root varobjs, we initialize path_expr
1067 when creating varobj, so here it should be
1069 gdb_assert (!is_root_p (var));
1070 return (*var->root->lang->path_expr_of_child) (var);
1074 enum varobj_languages
1075 varobj_get_language (struct varobj *var)
1077 return variable_language (var);
1081 varobj_get_attributes (struct varobj *var)
1085 if (varobj_editable_p (var))
1086 /* FIXME: define masks for attributes */
1087 attributes |= 0x00000001; /* Editable */
1093 varobj_get_formatted_value (struct varobj *var,
1094 enum varobj_display_formats format)
1096 return my_value_of_variable (var, format);
1100 varobj_get_value (struct varobj *var)
1102 return my_value_of_variable (var, var->format);
1105 /* Set the value of an object variable (if it is editable) to the
1106 value of the given expression */
1107 /* Note: Invokes functions that can call error() */
1110 varobj_set_value (struct varobj *var, char *expression)
1116 /* The argument "expression" contains the variable's new value.
1117 We need to first construct a legal expression for this -- ugh! */
1118 /* Does this cover all the bases? */
1119 struct expression *exp;
1120 struct value *value;
1121 int saved_input_radix = input_radix;
1122 char *s = expression;
1125 gdb_assert (varobj_editable_p (var));
1127 input_radix = 10; /* ALWAYS reset to decimal temporarily */
1128 exp = parse_exp_1 (&s, 0, 0);
1129 if (!gdb_evaluate_expression (exp, &value))
1131 /* We cannot proceed without a valid expression. */
1136 /* All types that are editable must also be changeable. */
1137 gdb_assert (varobj_value_is_changeable_p (var));
1139 /* The value of a changeable variable object must not be lazy. */
1140 gdb_assert (!value_lazy (var->value));
1142 /* Need to coerce the input. We want to check if the
1143 value of the variable object will be different
1144 after assignment, and the first thing value_assign
1145 does is coerce the input.
1146 For example, if we are assigning an array to a pointer variable we
1147 should compare the pointer with the the array's address, not with the
1149 value = coerce_array (value);
1151 /* The new value may be lazy. gdb_value_assign, or
1152 rather value_contents, will take care of this.
1153 If fetching of the new value will fail, gdb_value_assign
1154 with catch the exception. */
1155 if (!gdb_value_assign (var->value, value, &val))
1158 /* If the value has changed, record it, so that next -var-update can
1159 report this change. If a variable had a value of '1', we've set it
1160 to '333' and then set again to '1', when -var-update will report this
1161 variable as changed -- because the first assignment has set the
1162 'updated' flag. There's no need to optimize that, because return value
1163 of -var-update should be considered an approximation. */
1164 var->updated = install_new_value (var, val, 0 /* Compare values. */);
1165 input_radix = saved_input_radix;
1169 /* Assign a new value to a variable object. If INITIAL is non-zero,
1170 this is the first assignement after the variable object was just
1171 created, or changed type. In that case, just assign the value
1173 Otherwise, assign the new value, and return 1 if the value is different
1174 from the current one, 0 otherwise. The comparison is done on textual
1175 representation of value. Therefore, some types need not be compared. E.g.
1176 for structures the reported value is always "{...}", so no comparison is
1177 necessary here. If the old value was NULL and new one is not, or vice versa,
1180 The VALUE parameter should not be released -- the function will
1181 take care of releasing it when needed. */
1183 install_new_value (struct varobj *var, struct value *value, int initial)
1188 int intentionally_not_fetched = 0;
1189 char *print_value = NULL;
1191 /* We need to know the varobj's type to decide if the value should
1192 be fetched or not. C++ fake children (public/protected/private) don't have
1194 gdb_assert (var->type || CPLUS_FAKE_CHILD (var));
1195 changeable = varobj_value_is_changeable_p (var);
1197 /* If the type has custom visualizer, we consider it to be always
1198 changeable. FIXME: need to make sure this behaviour will not
1199 mess up read-sensitive values. */
1200 if (var->pretty_printer)
1203 need_to_fetch = changeable;
1205 /* We are not interested in the address of references, and given
1206 that in C++ a reference is not rebindable, it cannot
1207 meaningfully change. So, get hold of the real value. */
1210 value = coerce_ref (value);
1211 release_value (value);
1214 if (var->type && TYPE_CODE (var->type) == TYPE_CODE_UNION)
1215 /* For unions, we need to fetch the value implicitly because
1216 of implementation of union member fetch. When gdb
1217 creates a value for a field and the value of the enclosing
1218 structure is not lazy, it immediately copies the necessary
1219 bytes from the enclosing values. If the enclosing value is
1220 lazy, the call to value_fetch_lazy on the field will read
1221 the data from memory. For unions, that means we'll read the
1222 same memory more than once, which is not desirable. So
1226 /* The new value might be lazy. If the type is changeable,
1227 that is we'll be comparing values of this type, fetch the
1228 value now. Otherwise, on the next update the old value
1229 will be lazy, which means we've lost that old value. */
1230 if (need_to_fetch && value && value_lazy (value))
1232 struct varobj *parent = var->parent;
1233 int frozen = var->frozen;
1234 for (; !frozen && parent; parent = parent->parent)
1235 frozen |= parent->frozen;
1237 if (frozen && initial)
1239 /* For variables that are frozen, or are children of frozen
1240 variables, we don't do fetch on initial assignment.
1241 For non-initial assignemnt we do the fetch, since it means we're
1242 explicitly asked to compare the new value with the old one. */
1243 intentionally_not_fetched = 1;
1245 else if (!gdb_value_fetch_lazy (value))
1247 /* Set the value to NULL, so that for the next -var-update,
1248 we don't try to compare the new value with this value,
1249 that we couldn't even read. */
1255 /* Below, we'll be comparing string rendering of old and new
1256 values. Don't get string rendering if the value is
1257 lazy -- if it is, the code above has decided that the value
1258 should not be fetched. */
1259 if (value && !value_lazy (value))
1260 print_value = value_get_print_value (value, var->format, var);
1262 /* If the type is changeable, compare the old and the new values.
1263 If this is the initial assignment, we don't have any old value
1265 if (!initial && changeable)
1267 /* If the value of the varobj was changed by -var-set-value, then the
1268 value in the varobj and in the target is the same. However, that value
1269 is different from the value that the varobj had after the previous
1270 -var-update. So need to the varobj as changed. */
1277 /* Try to compare the values. That requires that both
1278 values are non-lazy. */
1279 if (var->not_fetched && value_lazy (var->value))
1281 /* This is a frozen varobj and the value was never read.
1282 Presumably, UI shows some "never read" indicator.
1283 Now that we've fetched the real value, we need to report
1284 this varobj as changed so that UI can show the real
1288 else if (var->value == NULL && value == NULL)
1291 else if (var->value == NULL || value == NULL)
1297 gdb_assert (!value_lazy (var->value));
1298 gdb_assert (!value_lazy (value));
1300 gdb_assert (var->print_value != NULL && print_value != NULL);
1301 if (strcmp (var->print_value, print_value) != 0)
1307 if (!initial && !changeable)
1309 /* For values that are not changeable, we don't compare the values.
1310 However, we want to notice if a value was not NULL and now is NULL,
1311 or vise versa, so that we report when top-level varobjs come in scope
1312 and leave the scope. */
1313 changed = (var->value != NULL) != (value != NULL);
1316 /* We must always keep the new value, since children depend on it. */
1317 if (var->value != NULL && var->value != value)
1318 value_free (var->value);
1320 if (var->print_value)
1321 xfree (var->print_value);
1322 var->print_value = print_value;
1323 if (value && value_lazy (value) && intentionally_not_fetched)
1324 var->not_fetched = 1;
1326 var->not_fetched = 0;
1329 gdb_assert (!var->value || value_type (var->value));
1335 install_visualizer (struct varobj *var, PyObject *visualizer)
1338 /* If there are any children now, wipe them. */
1339 varobj_delete (var, NULL, 1 /* children only */);
1340 var->num_children = -1;
1342 Py_XDECREF (var->pretty_printer);
1343 var->pretty_printer = visualizer;
1345 install_new_value (var, var->value, 1);
1347 /* If we removed the visualizer, and the user ever requested the
1348 object's children, then we must compute the list of children.
1349 Note that we needn't do this when installing a visualizer,
1350 because updating will recompute dynamic children. */
1351 if (!visualizer && var->children_requested)
1352 varobj_list_children (var);
1354 error (_("Python support required"));
1359 install_default_visualizer (struct varobj *var)
1362 struct cleanup *cleanup;
1363 PyObject *pretty_printer = NULL;
1365 cleanup = varobj_ensure_python_env (var);
1369 pretty_printer = gdbpy_get_varobj_pretty_printer (var->value);
1370 if (! pretty_printer)
1372 gdbpy_print_stack ();
1373 error (_("Cannot instantiate printer for default visualizer"));
1377 if (pretty_printer == Py_None)
1379 Py_DECREF (pretty_printer);
1380 pretty_printer = NULL;
1383 install_visualizer (var, pretty_printer);
1384 do_cleanups (cleanup);
1386 /* No error is right as this function is inserted just as a hook. */
1391 varobj_set_visualizer (struct varobj *var, const char *visualizer)
1394 PyObject *mainmod, *globals, *pretty_printer, *constructor;
1395 struct cleanup *back_to, *value;
1397 back_to = varobj_ensure_python_env (var);
1399 mainmod = PyImport_AddModule ("__main__");
1400 globals = PyModule_GetDict (mainmod);
1401 Py_INCREF (globals);
1402 make_cleanup_py_decref (globals);
1404 constructor = PyRun_String (visualizer, Py_eval_input, globals, globals);
1406 /* Do not instantiate NoneType. */
1407 if (constructor == Py_None)
1409 pretty_printer = Py_None;
1410 Py_INCREF (pretty_printer);
1413 pretty_printer = instantiate_pretty_printer (constructor, var->value);
1415 Py_XDECREF (constructor);
1417 if (! pretty_printer)
1419 gdbpy_print_stack ();
1420 error (_("Could not evaluate visualizer expression: %s"), visualizer);
1423 if (pretty_printer == Py_None)
1425 Py_DECREF (pretty_printer);
1426 pretty_printer = NULL;
1429 install_visualizer (var, pretty_printer);
1431 do_cleanups (back_to);
1433 error (_("Python support required"));
1437 /* Update the values for a variable and its children. This is a
1438 two-pronged attack. First, re-parse the value for the root's
1439 expression to see if it's changed. Then go all the way
1440 through its children, reconstructing them and noting if they've
1443 The EXPLICIT parameter specifies if this call is result
1444 of MI request to update this specific variable, or
1445 result of implicit -var-update *. For implicit request, we don't
1446 update frozen variables.
1448 NOTE: This function may delete the caller's varobj. If it
1449 returns TYPE_CHANGED, then it has done this and VARP will be modified
1450 to point to the new varobj. */
1452 VEC(varobj_update_result) *varobj_update (struct varobj **varp, int explicit)
1455 int type_changed = 0;
1460 struct varobj **templist = NULL;
1462 VEC (varobj_update_result) *stack = NULL;
1463 VEC (varobj_update_result) *result = NULL;
1464 struct frame_info *fi;
1466 /* Frozen means frozen -- we don't check for any change in
1467 this varobj, including its going out of scope, or
1468 changing type. One use case for frozen varobjs is
1469 retaining previously evaluated expressions, and we don't
1470 want them to be reevaluated at all. */
1471 if (!explicit && (*varp)->frozen)
1474 if (!(*varp)->root->is_valid)
1476 varobj_update_result r = {*varp};
1477 r.status = VAROBJ_INVALID;
1478 VEC_safe_push (varobj_update_result, result, &r);
1482 if ((*varp)->root->rootvar == *varp)
1484 varobj_update_result r = {*varp};
1485 r.status = VAROBJ_IN_SCOPE;
1487 /* Update the root variable. value_of_root can return NULL
1488 if the variable is no longer around, i.e. we stepped out of
1489 the frame in which a local existed. We are letting the
1490 value_of_root variable dispose of the varobj if the type
1492 new = value_of_root (varp, &type_changed);
1495 r.type_changed = type_changed;
1496 if (install_new_value ((*varp), new, type_changed))
1500 r.status = VAROBJ_NOT_IN_SCOPE;
1501 r.value_installed = 1;
1503 if (r.status == VAROBJ_NOT_IN_SCOPE)
1505 if (r.type_changed || r.changed)
1506 VEC_safe_push (varobj_update_result, result, &r);
1510 VEC_safe_push (varobj_update_result, stack, &r);
1514 varobj_update_result r = {*varp};
1515 VEC_safe_push (varobj_update_result, stack, &r);
1518 /* Walk through the children, reconstructing them all. */
1519 while (!VEC_empty (varobj_update_result, stack))
1521 varobj_update_result r = *(VEC_last (varobj_update_result, stack));
1522 struct varobj *v = r.varobj;
1524 VEC_pop (varobj_update_result, stack);
1526 /* Update this variable, unless it's a root, which is already
1528 if (!r.value_installed)
1530 new = value_of_child (v->parent, v->index);
1531 if (install_new_value (v, new, 0 /* type not changed */))
1538 /* We probably should not get children of a varobj that has a
1539 pretty-printer, but for which -var-list-children was never
1540 invoked. Presumably, such varobj is not yet expanded in the
1541 UI, so we need not bother getting it. */
1542 if (v->pretty_printer)
1544 VEC (varobj_p) *changed = 0, *new_and_unchanged = 0;
1545 int i, children_changed;
1548 if (!v->children_requested)
1554 /* If update_dynamic_varobj_children returns 0, then we have
1555 a non-conforming pretty-printer, so we skip it. */
1556 if (update_dynamic_varobj_children (v, &changed, &new_and_unchanged,
1559 if (children_changed)
1560 r.children_changed = 1;
1561 for (i = 0; VEC_iterate (varobj_p, changed, i, tmp); ++i)
1563 varobj_update_result r = {tmp};
1565 r.value_installed = 1;
1566 VEC_safe_push (varobj_update_result, stack, &r);
1569 VEC_iterate (varobj_p, new_and_unchanged, i, tmp);
1572 varobj_update_result r = {tmp};
1573 r.value_installed = 1;
1574 VEC_safe_push (varobj_update_result, stack, &r);
1576 if (r.changed || r.children_changed)
1577 VEC_safe_push (varobj_update_result, result, &r);
1582 /* Push any children. Use reverse order so that the first
1583 child is popped from the work stack first, and so
1584 will be added to result first. This does not
1585 affect correctness, just "nicer". */
1586 for (i = VEC_length (varobj_p, v->children)-1; i >= 0; --i)
1588 varobj_p c = VEC_index (varobj_p, v->children, i);
1589 /* Child may be NULL if explicitly deleted by -var-delete. */
1590 if (c != NULL && !c->frozen)
1592 varobj_update_result r = {c};
1593 VEC_safe_push (varobj_update_result, stack, &r);
1597 if (r.changed || r.type_changed)
1598 VEC_safe_push (varobj_update_result, result, &r);
1601 VEC_free (varobj_update_result, stack);
1607 /* Helper functions */
1610 * Variable object construction/destruction
1614 delete_variable (struct cpstack **resultp, struct varobj *var,
1615 int only_children_p)
1619 delete_variable_1 (resultp, &delcount, var,
1620 only_children_p, 1 /* remove_from_parent_p */ );
1625 /* Delete the variable object VAR and its children */
1626 /* IMPORTANT NOTE: If we delete a variable which is a child
1627 and the parent is not removed we dump core. It must be always
1628 initially called with remove_from_parent_p set */
1630 delete_variable_1 (struct cpstack **resultp, int *delcountp,
1631 struct varobj *var, int only_children_p,
1632 int remove_from_parent_p)
1636 /* Delete any children of this variable, too. */
1637 for (i = 0; i < VEC_length (varobj_p, var->children); ++i)
1639 varobj_p child = VEC_index (varobj_p, var->children, i);
1642 if (!remove_from_parent_p)
1643 child->parent = NULL;
1644 delete_variable_1 (resultp, delcountp, child, 0, only_children_p);
1646 VEC_free (varobj_p, var->children);
1648 /* if we were called to delete only the children we are done here */
1649 if (only_children_p)
1652 /* Otherwise, add it to the list of deleted ones and proceed to do so */
1653 /* If the name is null, this is a temporary variable, that has not
1654 yet been installed, don't report it, it belongs to the caller... */
1655 if (var->obj_name != NULL)
1657 cppush (resultp, xstrdup (var->obj_name));
1658 *delcountp = *delcountp + 1;
1661 /* If this variable has a parent, remove it from its parent's list */
1662 /* OPTIMIZATION: if the parent of this variable is also being deleted,
1663 (as indicated by remove_from_parent_p) we don't bother doing an
1664 expensive list search to find the element to remove when we are
1665 discarding the list afterwards */
1666 if ((remove_from_parent_p) && (var->parent != NULL))
1668 VEC_replace (varobj_p, var->parent->children, var->index, NULL);
1671 if (var->obj_name != NULL)
1672 uninstall_variable (var);
1674 /* Free memory associated with this variable */
1675 free_variable (var);
1678 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
1680 install_variable (struct varobj *var)
1683 struct vlist *newvl;
1685 unsigned int index = 0;
1688 for (chp = var->obj_name; *chp; chp++)
1690 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
1693 cv = *(varobj_table + index);
1694 while ((cv != NULL) && (strcmp (cv->var->obj_name, var->obj_name) != 0))
1698 error (_("Duplicate variable object name"));
1700 /* Add varobj to hash table */
1701 newvl = xmalloc (sizeof (struct vlist));
1702 newvl->next = *(varobj_table + index);
1704 *(varobj_table + index) = newvl;
1706 /* If root, add varobj to root list */
1707 if (is_root_p (var))
1709 /* Add to list of root variables */
1710 if (rootlist == NULL)
1711 var->root->next = NULL;
1713 var->root->next = rootlist;
1714 rootlist = var->root;
1720 /* Unistall the object VAR. */
1722 uninstall_variable (struct varobj *var)
1726 struct varobj_root *cr;
1727 struct varobj_root *prer;
1729 unsigned int index = 0;
1732 /* Remove varobj from hash table */
1733 for (chp = var->obj_name; *chp; chp++)
1735 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
1738 cv = *(varobj_table + index);
1740 while ((cv != NULL) && (strcmp (cv->var->obj_name, var->obj_name) != 0))
1747 fprintf_unfiltered (gdb_stdlog, "Deleting %s\n", var->obj_name);
1752 ("Assertion failed: Could not find variable object \"%s\" to delete",
1758 *(varobj_table + index) = cv->next;
1760 prev->next = cv->next;
1764 /* If root, remove varobj from root list */
1765 if (is_root_p (var))
1767 /* Remove from list of root variables */
1768 if (rootlist == var->root)
1769 rootlist = var->root->next;
1774 while ((cr != NULL) && (cr->rootvar != var))
1782 ("Assertion failed: Could not find varobj \"%s\" in root list",
1789 prer->next = cr->next;
1795 /* Create and install a child of the parent of the given name */
1796 static struct varobj *
1797 create_child (struct varobj *parent, int index, char *name)
1799 return create_child_with_value (parent, index, name,
1800 value_of_child (parent, index));
1803 static struct varobj *
1804 create_child_with_value (struct varobj *parent, int index, const char *name,
1805 struct value *value)
1807 struct varobj *child;
1810 child = new_variable ();
1812 /* name is allocated by name_of_child */
1813 /* FIXME: xstrdup should not be here. */
1814 child->name = xstrdup (name);
1815 child->index = index;
1816 child->parent = parent;
1817 child->root = parent->root;
1818 childs_name = xstrprintf ("%s.%s", parent->obj_name, name);
1819 child->obj_name = childs_name;
1820 install_variable (child);
1822 /* Compute the type of the child. Must do this before
1823 calling install_new_value. */
1825 /* If the child had no evaluation errors, var->value
1826 will be non-NULL and contain a valid type. */
1827 child->type = value_type (value);
1829 /* Otherwise, we must compute the type. */
1830 child->type = (*child->root->lang->type_of_child) (child->parent,
1832 install_new_value (child, value, 1);
1839 * Miscellaneous utility functions.
1842 /* Allocate memory and initialize a new variable */
1843 static struct varobj *
1848 var = (struct varobj *) xmalloc (sizeof (struct varobj));
1850 var->path_expr = NULL;
1851 var->obj_name = NULL;
1855 var->num_children = -1;
1857 var->children = NULL;
1861 var->print_value = NULL;
1863 var->not_fetched = 0;
1864 var->children_requested = 0;
1865 var->pretty_printer = 0;
1870 /* Allocate memory and initialize a new root variable */
1871 static struct varobj *
1872 new_root_variable (void)
1874 struct varobj *var = new_variable ();
1875 var->root = (struct varobj_root *) xmalloc (sizeof (struct varobj_root));;
1876 var->root->lang = NULL;
1877 var->root->exp = NULL;
1878 var->root->valid_block = NULL;
1879 var->root->frame = null_frame_id;
1880 var->root->floating = 0;
1881 var->root->rootvar = NULL;
1882 var->root->is_valid = 1;
1887 /* Free any allocated memory associated with VAR. */
1889 free_variable (struct varobj *var)
1892 if (var->pretty_printer)
1894 struct cleanup *cleanup = varobj_ensure_python_env (var);
1895 Py_DECREF (var->pretty_printer);
1896 do_cleanups (cleanup);
1900 value_free (var->value);
1902 /* Free the expression if this is a root variable. */
1903 if (is_root_p (var))
1905 xfree (var->root->exp);
1910 xfree (var->obj_name);
1911 xfree (var->print_value);
1912 xfree (var->path_expr);
1917 do_free_variable_cleanup (void *var)
1919 free_variable (var);
1922 static struct cleanup *
1923 make_cleanup_free_variable (struct varobj *var)
1925 return make_cleanup (do_free_variable_cleanup, var);
1928 /* This returns the type of the variable. It also skips past typedefs
1929 to return the real type of the variable.
1931 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
1932 except within get_target_type and get_type. */
1933 static struct type *
1934 get_type (struct varobj *var)
1940 type = check_typedef (type);
1945 /* Return the type of the value that's stored in VAR,
1946 or that would have being stored there if the
1947 value were accessible.
1949 This differs from VAR->type in that VAR->type is always
1950 the true type of the expession in the source language.
1951 The return value of this function is the type we're
1952 actually storing in varobj, and using for displaying
1953 the values and for comparing previous and new values.
1955 For example, top-level references are always stripped. */
1956 static struct type *
1957 get_value_type (struct varobj *var)
1962 type = value_type (var->value);
1966 type = check_typedef (type);
1968 if (TYPE_CODE (type) == TYPE_CODE_REF)
1969 type = get_target_type (type);
1971 type = check_typedef (type);
1976 /* This returns the target type (or NULL) of TYPE, also skipping
1977 past typedefs, just like get_type ().
1979 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
1980 except within get_target_type and get_type. */
1981 static struct type *
1982 get_target_type (struct type *type)
1986 type = TYPE_TARGET_TYPE (type);
1988 type = check_typedef (type);
1994 /* What is the default display for this variable? We assume that
1995 everything is "natural". Any exceptions? */
1996 static enum varobj_display_formats
1997 variable_default_display (struct varobj *var)
1999 return FORMAT_NATURAL;
2002 /* FIXME: The following should be generic for any pointer */
2004 cppush (struct cpstack **pstack, char *name)
2008 s = (struct cpstack *) xmalloc (sizeof (struct cpstack));
2014 /* FIXME: The following should be generic for any pointer */
2016 cppop (struct cpstack **pstack)
2021 if ((*pstack)->name == NULL && (*pstack)->next == NULL)
2026 *pstack = (*pstack)->next;
2033 * Language-dependencies
2036 /* Common entry points */
2038 /* Get the language of variable VAR. */
2039 static enum varobj_languages
2040 variable_language (struct varobj *var)
2042 enum varobj_languages lang;
2044 switch (var->root->exp->language_defn->la_language)
2050 case language_cplus:
2061 /* Return the number of children for a given variable.
2062 The result of this function is defined by the language
2063 implementation. The number of children returned by this function
2064 is the number of children that the user will see in the variable
2067 number_of_children (struct varobj *var)
2069 return (*var->root->lang->number_of_children) (var);;
2072 /* What is the expression for the root varobj VAR? Returns a malloc'd string. */
2074 name_of_variable (struct varobj *var)
2076 return (*var->root->lang->name_of_variable) (var);
2079 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd string. */
2081 name_of_child (struct varobj *var, int index)
2083 return (*var->root->lang->name_of_child) (var, index);
2086 /* What is the ``struct value *'' of the root variable VAR?
2087 For floating variable object, evaluation can get us a value
2088 of different type from what is stored in varobj already. In
2090 - *type_changed will be set to 1
2091 - old varobj will be freed, and new one will be
2092 created, with the same name.
2093 - *var_handle will be set to the new varobj
2094 Otherwise, *type_changed will be set to 0. */
2095 static struct value *
2096 value_of_root (struct varobj **var_handle, int *type_changed)
2100 if (var_handle == NULL)
2105 /* This should really be an exception, since this should
2106 only get called with a root variable. */
2108 if (!is_root_p (var))
2111 if (var->root->floating)
2113 struct varobj *tmp_var;
2114 char *old_type, *new_type;
2116 tmp_var = varobj_create (NULL, var->name, (CORE_ADDR) 0,
2117 USE_SELECTED_FRAME);
2118 if (tmp_var == NULL)
2122 old_type = varobj_get_type (var);
2123 new_type = varobj_get_type (tmp_var);
2124 if (strcmp (old_type, new_type) == 0)
2126 /* The expression presently stored inside var->root->exp
2127 remembers the locations of local variables relatively to
2128 the frame where the expression was created (in DWARF location
2129 button, for example). Naturally, those locations are not
2130 correct in other frames, so update the expression. */
2132 struct expression *tmp_exp = var->root->exp;
2133 var->root->exp = tmp_var->root->exp;
2134 tmp_var->root->exp = tmp_exp;
2136 varobj_delete (tmp_var, NULL, 0);
2141 tmp_var->obj_name = xstrdup (var->obj_name);
2142 varobj_delete (var, NULL, 0);
2144 install_variable (tmp_var);
2145 *var_handle = tmp_var;
2157 return (*var->root->lang->value_of_root) (var_handle);
2160 /* What is the ``struct value *'' for the INDEX'th child of PARENT? */
2161 static struct value *
2162 value_of_child (struct varobj *parent, int index)
2164 struct value *value;
2166 value = (*parent->root->lang->value_of_child) (parent, index);
2171 /* GDB already has a command called "value_of_variable". Sigh. */
2173 my_value_of_variable (struct varobj *var, enum varobj_display_formats format)
2175 if (var->root->is_valid)
2176 return (*var->root->lang->value_of_variable) (var, format);
2182 value_get_print_value (struct value *value, enum varobj_display_formats format,
2185 struct ui_file *stb;
2186 struct cleanup *old_chain;
2187 gdb_byte *thevalue = NULL;
2188 struct value_print_options opts;
2196 struct cleanup *back_to = varobj_ensure_python_env (var);
2197 PyObject *value_formatter = var->pretty_printer;
2199 if (value_formatter && PyObject_HasAttr (value_formatter,
2200 gdbpy_to_string_cst))
2203 struct value *replacement;
2204 int string_print = 0;
2205 PyObject *output = NULL;
2207 hint = gdbpy_get_display_hint (value_formatter);
2210 if (!strcmp (hint, "string"))
2215 output = apply_varobj_pretty_printer (value_formatter,
2219 PyObject *py_str = python_string_to_target_python_string (output);
2222 char *s = PyString_AsString (py_str);
2223 len = PyString_Size (py_str);
2224 thevalue = xmemdup (s, len + 1, len + 1);
2229 if (thevalue && !string_print)
2231 do_cleanups (back_to);
2235 value = replacement;
2237 do_cleanups (back_to);
2241 stb = mem_fileopen ();
2242 old_chain = make_cleanup_ui_file_delete (stb);
2244 get_formatted_print_options (&opts, format_code[(int) format]);
2249 struct gdbarch *gdbarch = get_type_arch (value_type (value));
2250 make_cleanup (xfree, thevalue);
2251 LA_PRINT_STRING (stb, builtin_type (gdbarch)->builtin_char,
2252 thevalue, len, 0, &opts);
2255 common_val_print (value, stb, 0, &opts, current_language);
2256 thevalue = ui_file_xstrdup (stb, NULL);
2258 do_cleanups (old_chain);
2263 varobj_editable_p (struct varobj *var)
2266 struct value *value;
2268 if (!(var->root->is_valid && var->value && VALUE_LVAL (var->value)))
2271 type = get_value_type (var);
2273 switch (TYPE_CODE (type))
2275 case TYPE_CODE_STRUCT:
2276 case TYPE_CODE_UNION:
2277 case TYPE_CODE_ARRAY:
2278 case TYPE_CODE_FUNC:
2279 case TYPE_CODE_METHOD:
2289 /* Return non-zero if changes in value of VAR
2290 must be detected and reported by -var-update.
2291 Return zero is -var-update should never report
2292 changes of such values. This makes sense for structures
2293 (since the changes in children values will be reported separately),
2294 or for artifical objects (like 'public' pseudo-field in C++).
2296 Return value of 0 means that gdb need not call value_fetch_lazy
2297 for the value of this variable object. */
2299 varobj_value_is_changeable_p (struct varobj *var)
2304 if (CPLUS_FAKE_CHILD (var))
2307 type = get_value_type (var);
2309 switch (TYPE_CODE (type))
2311 case TYPE_CODE_STRUCT:
2312 case TYPE_CODE_UNION:
2313 case TYPE_CODE_ARRAY:
2324 /* Return 1 if that varobj is floating, that is is always evaluated in the
2325 selected frame, and not bound to thread/frame. Such variable objects
2326 are created using '@' as frame specifier to -var-create. */
2328 varobj_floating_p (struct varobj *var)
2330 return var->root->floating;
2333 /* Given the value and the type of a variable object,
2334 adjust the value and type to those necessary
2335 for getting children of the variable object.
2336 This includes dereferencing top-level references
2337 to all types and dereferencing pointers to
2340 Both TYPE and *TYPE should be non-null. VALUE
2341 can be null if we want to only translate type.
2342 *VALUE can be null as well -- if the parent
2345 If WAS_PTR is not NULL, set *WAS_PTR to 0 or 1
2346 depending on whether pointer was dereferenced
2347 in this function. */
2349 adjust_value_for_child_access (struct value **value,
2353 gdb_assert (type && *type);
2358 *type = check_typedef (*type);
2360 /* The type of value stored in varobj, that is passed
2361 to us, is already supposed to be
2362 reference-stripped. */
2364 gdb_assert (TYPE_CODE (*type) != TYPE_CODE_REF);
2366 /* Pointers to structures are treated just like
2367 structures when accessing children. Don't
2368 dererences pointers to other types. */
2369 if (TYPE_CODE (*type) == TYPE_CODE_PTR)
2371 struct type *target_type = get_target_type (*type);
2372 if (TYPE_CODE (target_type) == TYPE_CODE_STRUCT
2373 || TYPE_CODE (target_type) == TYPE_CODE_UNION)
2375 if (value && *value)
2377 int success = gdb_value_ind (*value, value);
2381 *type = target_type;
2387 /* The 'get_target_type' function calls check_typedef on
2388 result, so we can immediately check type code. No
2389 need to call check_typedef here. */
2394 c_number_of_children (struct varobj *var)
2396 struct type *type = get_value_type (var);
2398 struct type *target;
2400 adjust_value_for_child_access (NULL, &type, NULL);
2401 target = get_target_type (type);
2403 switch (TYPE_CODE (type))
2405 case TYPE_CODE_ARRAY:
2406 if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (target) > 0
2407 && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))
2408 children = TYPE_LENGTH (type) / TYPE_LENGTH (target);
2410 /* If we don't know how many elements there are, don't display
2415 case TYPE_CODE_STRUCT:
2416 case TYPE_CODE_UNION:
2417 children = TYPE_NFIELDS (type);
2421 /* The type here is a pointer to non-struct. Typically, pointers
2422 have one child, except for function ptrs, which have no children,
2423 and except for void*, as we don't know what to show.
2425 We can show char* so we allow it to be dereferenced. If you decide
2426 to test for it, please mind that a little magic is necessary to
2427 properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
2428 TYPE_NAME == "char" */
2429 if (TYPE_CODE (target) == TYPE_CODE_FUNC
2430 || TYPE_CODE (target) == TYPE_CODE_VOID)
2437 /* Other types have no children */
2445 c_name_of_variable (struct varobj *parent)
2447 return xstrdup (parent->name);
2450 /* Return the value of element TYPE_INDEX of a structure
2451 value VALUE. VALUE's type should be a structure,
2452 or union, or a typedef to struct/union.
2454 Returns NULL if getting the value fails. Never throws. */
2455 static struct value *
2456 value_struct_element_index (struct value *value, int type_index)
2458 struct value *result = NULL;
2459 volatile struct gdb_exception e;
2461 struct type *type = value_type (value);
2462 type = check_typedef (type);
2464 gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
2465 || TYPE_CODE (type) == TYPE_CODE_UNION);
2467 TRY_CATCH (e, RETURN_MASK_ERROR)
2469 if (field_is_static (&TYPE_FIELD (type, type_index)))
2470 result = value_static_field (type, type_index);
2472 result = value_primitive_field (value, 0, type_index, type);
2484 /* Obtain the information about child INDEX of the variable
2486 If CNAME is not null, sets *CNAME to the name of the child relative
2488 If CVALUE is not null, sets *CVALUE to the value of the child.
2489 If CTYPE is not null, sets *CTYPE to the type of the child.
2491 If any of CNAME, CVALUE, or CTYPE is not null, but the corresponding
2492 information cannot be determined, set *CNAME, *CVALUE, or *CTYPE
2495 c_describe_child (struct varobj *parent, int index,
2496 char **cname, struct value **cvalue, struct type **ctype,
2497 char **cfull_expression)
2499 struct value *value = parent->value;
2500 struct type *type = get_value_type (parent);
2501 char *parent_expression = NULL;
2510 if (cfull_expression)
2512 *cfull_expression = NULL;
2513 parent_expression = varobj_get_path_expr (parent);
2515 adjust_value_for_child_access (&value, &type, &was_ptr);
2517 switch (TYPE_CODE (type))
2519 case TYPE_CODE_ARRAY:
2521 *cname = xstrprintf ("%d", index
2522 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)));
2524 if (cvalue && value)
2526 int real_index = index + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type));
2527 gdb_value_subscript (value, real_index, cvalue);
2531 *ctype = get_target_type (type);
2533 if (cfull_expression)
2534 *cfull_expression = xstrprintf ("(%s)[%d]", parent_expression,
2536 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)));
2541 case TYPE_CODE_STRUCT:
2542 case TYPE_CODE_UNION:
2544 *cname = xstrdup (TYPE_FIELD_NAME (type, index));
2546 if (cvalue && value)
2548 /* For C, varobj index is the same as type index. */
2549 *cvalue = value_struct_element_index (value, index);
2553 *ctype = TYPE_FIELD_TYPE (type, index);
2555 if (cfull_expression)
2557 char *join = was_ptr ? "->" : ".";
2558 *cfull_expression = xstrprintf ("(%s)%s%s", parent_expression, join,
2559 TYPE_FIELD_NAME (type, index));
2566 *cname = xstrprintf ("*%s", parent->name);
2568 if (cvalue && value)
2570 int success = gdb_value_ind (value, cvalue);
2575 /* Don't use get_target_type because it calls
2576 check_typedef and here, we want to show the true
2577 declared type of the variable. */
2579 *ctype = TYPE_TARGET_TYPE (type);
2581 if (cfull_expression)
2582 *cfull_expression = xstrprintf ("*(%s)", parent_expression);
2587 /* This should not happen */
2589 *cname = xstrdup ("???");
2590 if (cfull_expression)
2591 *cfull_expression = xstrdup ("???");
2592 /* Don't set value and type, we don't know then. */
2597 c_name_of_child (struct varobj *parent, int index)
2600 c_describe_child (parent, index, &name, NULL, NULL, NULL);
2605 c_path_expr_of_child (struct varobj *child)
2607 c_describe_child (child->parent, child->index, NULL, NULL, NULL,
2609 return child->path_expr;
2612 /* If frame associated with VAR can be found, switch
2613 to it and return 1. Otherwise, return 0. */
2615 check_scope (struct varobj *var)
2617 struct frame_info *fi;
2620 fi = frame_find_by_id (var->root->frame);
2625 CORE_ADDR pc = get_frame_pc (fi);
2626 if (pc < BLOCK_START (var->root->valid_block) ||
2627 pc >= BLOCK_END (var->root->valid_block))
2635 static struct value *
2636 c_value_of_root (struct varobj **var_handle)
2638 struct value *new_val = NULL;
2639 struct varobj *var = *var_handle;
2640 struct frame_info *fi;
2641 int within_scope = 0;
2642 struct cleanup *back_to;
2644 /* Only root variables can be updated... */
2645 if (!is_root_p (var))
2646 /* Not a root var */
2649 back_to = make_cleanup_restore_current_thread ();
2651 /* Determine whether the variable is still around. */
2652 if (var->root->valid_block == NULL || var->root->floating)
2654 else if (var->root->thread_id == 0)
2656 /* The program was single-threaded when the variable object was
2657 created. Technically, it's possible that the program became
2658 multi-threaded since then, but we don't support such
2660 within_scope = check_scope (var);
2664 ptid_t ptid = thread_id_to_pid (var->root->thread_id);
2665 if (in_thread_list (ptid))
2667 switch_to_thread (ptid);
2668 within_scope = check_scope (var);
2674 /* We need to catch errors here, because if evaluate
2675 expression fails we want to just return NULL. */
2676 gdb_evaluate_expression (var->root->exp, &new_val);
2680 do_cleanups (back_to);
2685 static struct value *
2686 c_value_of_child (struct varobj *parent, int index)
2688 struct value *value = NULL;
2689 c_describe_child (parent, index, NULL, &value, NULL, NULL);
2694 static struct type *
2695 c_type_of_child (struct varobj *parent, int index)
2697 struct type *type = NULL;
2698 c_describe_child (parent, index, NULL, NULL, &type, NULL);
2703 c_value_of_variable (struct varobj *var, enum varobj_display_formats format)
2705 /* BOGUS: if val_print sees a struct/class, or a reference to one,
2706 it will print out its children instead of "{...}". So we need to
2707 catch that case explicitly. */
2708 struct type *type = get_type (var);
2710 /* If we have a custom formatter, return whatever string it has
2712 if (var->pretty_printer && var->print_value)
2713 return xstrdup (var->print_value);
2715 /* Strip top-level references. */
2716 while (TYPE_CODE (type) == TYPE_CODE_REF)
2717 type = check_typedef (TYPE_TARGET_TYPE (type));
2719 switch (TYPE_CODE (type))
2721 case TYPE_CODE_STRUCT:
2722 case TYPE_CODE_UNION:
2723 return xstrdup ("{...}");
2726 case TYPE_CODE_ARRAY:
2729 number = xstrprintf ("[%d]", var->num_children);
2736 if (var->value == NULL)
2738 /* This can happen if we attempt to get the value of a struct
2739 member when the parent is an invalid pointer. This is an
2740 error condition, so we should tell the caller. */
2745 if (var->not_fetched && value_lazy (var->value))
2746 /* Frozen variable and no value yet. We don't
2747 implicitly fetch the value. MI response will
2748 use empty string for the value, which is OK. */
2751 gdb_assert (varobj_value_is_changeable_p (var));
2752 gdb_assert (!value_lazy (var->value));
2754 /* If the specified format is the current one,
2755 we can reuse print_value */
2756 if (format == var->format)
2757 return xstrdup (var->print_value);
2759 return value_get_print_value (var->value, format, var);
2769 cplus_number_of_children (struct varobj *var)
2772 int children, dont_know;
2777 if (!CPLUS_FAKE_CHILD (var))
2779 type = get_value_type (var);
2780 adjust_value_for_child_access (NULL, &type, NULL);
2782 if (((TYPE_CODE (type)) == TYPE_CODE_STRUCT) ||
2783 ((TYPE_CODE (type)) == TYPE_CODE_UNION))
2787 cplus_class_num_children (type, kids);
2788 if (kids[v_public] != 0)
2790 if (kids[v_private] != 0)
2792 if (kids[v_protected] != 0)
2795 /* Add any baseclasses */
2796 children += TYPE_N_BASECLASSES (type);
2799 /* FIXME: save children in var */
2806 type = get_value_type (var->parent);
2807 adjust_value_for_child_access (NULL, &type, NULL);
2809 cplus_class_num_children (type, kids);
2810 if (strcmp (var->name, "public") == 0)
2811 children = kids[v_public];
2812 else if (strcmp (var->name, "private") == 0)
2813 children = kids[v_private];
2815 children = kids[v_protected];
2820 children = c_number_of_children (var);
2825 /* Compute # of public, private, and protected variables in this class.
2826 That means we need to descend into all baseclasses and find out
2827 how many are there, too. */
2829 cplus_class_num_children (struct type *type, int children[3])
2833 children[v_public] = 0;
2834 children[v_private] = 0;
2835 children[v_protected] = 0;
2837 for (i = TYPE_N_BASECLASSES (type); i < TYPE_NFIELDS (type); i++)
2839 /* If we have a virtual table pointer, omit it. */
2840 if (TYPE_VPTR_BASETYPE (type) == type && TYPE_VPTR_FIELDNO (type) == i)
2843 if (TYPE_FIELD_PROTECTED (type, i))
2844 children[v_protected]++;
2845 else if (TYPE_FIELD_PRIVATE (type, i))
2846 children[v_private]++;
2848 children[v_public]++;
2853 cplus_name_of_variable (struct varobj *parent)
2855 return c_name_of_variable (parent);
2858 enum accessibility { private_field, protected_field, public_field };
2860 /* Check if field INDEX of TYPE has the specified accessibility.
2861 Return 0 if so and 1 otherwise. */
2863 match_accessibility (struct type *type, int index, enum accessibility acc)
2865 if (acc == private_field && TYPE_FIELD_PRIVATE (type, index))
2867 else if (acc == protected_field && TYPE_FIELD_PROTECTED (type, index))
2869 else if (acc == public_field && !TYPE_FIELD_PRIVATE (type, index)
2870 && !TYPE_FIELD_PROTECTED (type, index))
2877 cplus_describe_child (struct varobj *parent, int index,
2878 char **cname, struct value **cvalue, struct type **ctype,
2879 char **cfull_expression)
2882 struct value *value;
2885 char *parent_expression = NULL;
2893 if (cfull_expression)
2894 *cfull_expression = NULL;
2896 if (CPLUS_FAKE_CHILD (parent))
2898 value = parent->parent->value;
2899 type = get_value_type (parent->parent);
2900 if (cfull_expression)
2901 parent_expression = varobj_get_path_expr (parent->parent);
2905 value = parent->value;
2906 type = get_value_type (parent);
2907 if (cfull_expression)
2908 parent_expression = varobj_get_path_expr (parent);
2911 adjust_value_for_child_access (&value, &type, &was_ptr);
2913 if (TYPE_CODE (type) == TYPE_CODE_STRUCT
2914 || TYPE_CODE (type) == TYPE_CODE_UNION)
2916 char *join = was_ptr ? "->" : ".";
2917 if (CPLUS_FAKE_CHILD (parent))
2919 /* The fields of the class type are ordered as they
2920 appear in the class. We are given an index for a
2921 particular access control type ("public","protected",
2922 or "private"). We must skip over fields that don't
2923 have the access control we are looking for to properly
2924 find the indexed field. */
2925 int type_index = TYPE_N_BASECLASSES (type);
2926 enum accessibility acc = public_field;
2927 if (strcmp (parent->name, "private") == 0)
2928 acc = private_field;
2929 else if (strcmp (parent->name, "protected") == 0)
2930 acc = protected_field;
2934 if (TYPE_VPTR_BASETYPE (type) == type
2935 && type_index == TYPE_VPTR_FIELDNO (type))
2937 else if (match_accessibility (type, type_index, acc))
2944 *cname = xstrdup (TYPE_FIELD_NAME (type, type_index));
2946 if (cvalue && value)
2947 *cvalue = value_struct_element_index (value, type_index);
2950 *ctype = TYPE_FIELD_TYPE (type, type_index);
2952 if (cfull_expression)
2953 *cfull_expression = xstrprintf ("((%s)%s%s)", parent_expression,
2955 TYPE_FIELD_NAME (type, type_index));
2957 else if (index < TYPE_N_BASECLASSES (type))
2959 /* This is a baseclass. */
2961 *cname = xstrdup (TYPE_FIELD_NAME (type, index));
2963 if (cvalue && value)
2965 *cvalue = value_cast (TYPE_FIELD_TYPE (type, index), value);
2966 release_value (*cvalue);
2971 *ctype = TYPE_FIELD_TYPE (type, index);
2974 if (cfull_expression)
2976 char *ptr = was_ptr ? "*" : "";
2977 /* Cast the parent to the base' type. Note that in gdb,
2980 will create an lvalue, for all appearences, so we don't
2981 need to use more fancy:
2984 *cfull_expression = xstrprintf ("(%s(%s%s) %s)",
2986 TYPE_FIELD_NAME (type, index),
2993 char *access = NULL;
2995 cplus_class_num_children (type, children);
2997 /* Everything beyond the baseclasses can
2998 only be "public", "private", or "protected"
3000 The special "fake" children are always output by varobj in
3001 this order. So if INDEX == 2, it MUST be "protected". */
3002 index -= TYPE_N_BASECLASSES (type);
3006 if (children[v_public] > 0)
3008 else if (children[v_private] > 0)
3011 access = "protected";
3014 if (children[v_public] > 0)
3016 if (children[v_private] > 0)
3019 access = "protected";
3021 else if (children[v_private] > 0)
3022 access = "protected";
3025 /* Must be protected */
3026 access = "protected";
3033 gdb_assert (access);
3035 *cname = xstrdup (access);
3037 /* Value and type and full expression are null here. */
3042 c_describe_child (parent, index, cname, cvalue, ctype, cfull_expression);
3047 cplus_name_of_child (struct varobj *parent, int index)
3050 cplus_describe_child (parent, index, &name, NULL, NULL, NULL);
3055 cplus_path_expr_of_child (struct varobj *child)
3057 cplus_describe_child (child->parent, child->index, NULL, NULL, NULL,
3059 return child->path_expr;
3062 static struct value *
3063 cplus_value_of_root (struct varobj **var_handle)
3065 return c_value_of_root (var_handle);
3068 static struct value *
3069 cplus_value_of_child (struct varobj *parent, int index)
3071 struct value *value = NULL;
3072 cplus_describe_child (parent, index, NULL, &value, NULL, NULL);
3076 static struct type *
3077 cplus_type_of_child (struct varobj *parent, int index)
3079 struct type *type = NULL;
3080 cplus_describe_child (parent, index, NULL, NULL, &type, NULL);
3085 cplus_value_of_variable (struct varobj *var, enum varobj_display_formats format)
3088 /* If we have one of our special types, don't print out
3090 if (CPLUS_FAKE_CHILD (var))
3091 return xstrdup ("");
3093 return c_value_of_variable (var, format);
3099 java_number_of_children (struct varobj *var)
3101 return cplus_number_of_children (var);
3105 java_name_of_variable (struct varobj *parent)
3109 name = cplus_name_of_variable (parent);
3110 /* If the name has "-" in it, it is because we
3111 needed to escape periods in the name... */
3114 while (*p != '\000')
3125 java_name_of_child (struct varobj *parent, int index)
3129 name = cplus_name_of_child (parent, index);
3130 /* Escape any periods in the name... */
3133 while (*p != '\000')
3144 java_path_expr_of_child (struct varobj *child)
3149 static struct value *
3150 java_value_of_root (struct varobj **var_handle)
3152 return cplus_value_of_root (var_handle);
3155 static struct value *
3156 java_value_of_child (struct varobj *parent, int index)
3158 return cplus_value_of_child (parent, index);
3161 static struct type *
3162 java_type_of_child (struct varobj *parent, int index)
3164 return cplus_type_of_child (parent, index);
3168 java_value_of_variable (struct varobj *var, enum varobj_display_formats format)
3170 return cplus_value_of_variable (var, format);
3173 /* Iterate all the existing _root_ VAROBJs and call the FUNC callback for them
3174 with an arbitrary caller supplied DATA pointer. */
3177 all_root_varobjs (void (*func) (struct varobj *var, void *data), void *data)
3179 struct varobj_root *var_root, *var_root_next;
3181 /* Iterate "safely" - handle if the callee deletes its passed VAROBJ. */
3183 for (var_root = rootlist; var_root != NULL; var_root = var_root_next)
3185 var_root_next = var_root->next;
3187 (*func) (var_root->rootvar, data);
3191 extern void _initialize_varobj (void);
3193 _initialize_varobj (void)
3195 int sizeof_table = sizeof (struct vlist *) * VAROBJ_TABLE_SIZE;
3197 varobj_table = xmalloc (sizeof_table);
3198 memset (varobj_table, 0, sizeof_table);
3200 add_setshow_zinteger_cmd ("debugvarobj", class_maintenance,
3202 Set varobj debugging."), _("\
3203 Show varobj debugging."), _("\
3204 When non-zero, varobj debugging is enabled."),
3207 &setlist, &showlist);
3210 /* Invalidate varobj VAR if it is tied to locals and re-create it if it is
3211 defined on globals. It is a helper for varobj_invalidate. */
3214 varobj_invalidate_iter (struct varobj *var, void *unused)
3216 /* Floating varobjs are reparsed on each stop, so we don't care if the
3217 presently parsed expression refers to something that's gone. */
3218 if (var->root->floating)
3221 /* global var must be re-evaluated. */
3222 if (var->root->valid_block == NULL)
3224 struct varobj *tmp_var;
3226 /* Try to create a varobj with same expression. If we succeed
3227 replace the old varobj, otherwise invalidate it. */
3228 tmp_var = varobj_create (NULL, var->name, (CORE_ADDR) 0,
3230 if (tmp_var != NULL)
3232 tmp_var->obj_name = xstrdup (var->obj_name);
3233 varobj_delete (var, NULL, 0);
3234 install_variable (tmp_var);
3237 var->root->is_valid = 0;
3239 else /* locals must be invalidated. */
3240 var->root->is_valid = 0;
3243 /* Invalidate the varobjs that are tied to locals and re-create the ones that
3244 are defined on globals.
3245 Invalidated varobjs will be always printed in_scope="invalid". */
3248 varobj_invalidate (void)
3250 all_root_varobjs (varobj_invalidate_iter, NULL);