1 /* Implementation of the GDB variable objects API.
3 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
4 2009, 2010 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"
32 #include "gdb_regex.h"
36 #include "gdbthread.h"
40 #include "python/python.h"
41 #include "python/python-internal.h"
46 /* Non-zero if we want to see trace of varobj level stuff. */
50 show_varobjdebug (struct ui_file *file, int from_tty,
51 struct cmd_list_element *c, const char *value)
53 fprintf_filtered (file, _("Varobj debugging is %s.\n"), value);
56 /* String representations of gdb's format codes */
57 char *varobj_format_string[] =
58 { "natural", "binary", "decimal", "hexadecimal", "octal" };
60 /* String representations of gdb's known languages */
61 char *varobj_language_string[] = { "unknown", "C", "C++", "Java" };
63 /* True if we want to allow Python-based pretty-printing. */
64 static int pretty_printing = 0;
67 varobj_enable_pretty_printing (void)
74 /* Every root variable has one of these structures saved in its
75 varobj. Members which must be free'd are noted. */
79 /* Alloc'd expression for this parent. */
80 struct expression *exp;
82 /* Block for which this expression is valid */
83 struct block *valid_block;
85 /* The frame for this expression. This field is set iff valid_block is
87 struct frame_id frame;
89 /* The thread ID that this varobj_root belong to. This field
90 is only valid if valid_block is not NULL.
91 When not 0, indicates which thread 'frame' belongs to.
92 When 0, indicates that the thread list was empty when the varobj_root
96 /* If 1, the -var-update always recomputes the value in the
97 current thread and frame. Otherwise, variable object is
98 always updated in the specific scope/thread/frame */
101 /* Flag that indicates validity: set to 0 when this varobj_root refers
102 to symbols that do not exist anymore. */
105 /* Language info for this variable and its children */
106 struct language_specific *lang;
108 /* The varobj for this root node. */
109 struct varobj *rootvar;
111 /* Next root variable */
112 struct varobj_root *next;
115 /* Every variable in the system has a structure of this type defined
116 for it. This structure holds all information necessary to manipulate
117 a particular object variable. Members which must be freed are noted. */
121 /* Alloc'd name of the variable for this object.. If this variable is a
122 child, then this name will be the child's source name.
123 (bar, not foo.bar) */
124 /* NOTE: This is the "expression" */
127 /* Alloc'd expression for this child. Can be used to create a
128 root variable corresponding to this child. */
131 /* The alloc'd name for this variable's object. This is here for
132 convenience when constructing this object's children. */
135 /* Index of this variable in its parent or -1 */
138 /* The type of this variable. This can be NULL
139 for artifial variable objects -- currently, the "accessibility"
140 variable objects in C++. */
143 /* The value of this expression or subexpression. A NULL value
144 indicates there was an error getting this value.
145 Invariant: if varobj_value_is_changeable_p (this) is non-zero,
146 the value is either NULL, or not lazy. */
149 /* The number of (immediate) children this variable has */
152 /* If this object is a child, this points to its immediate parent. */
153 struct varobj *parent;
155 /* Children of this object. */
156 VEC (varobj_p) *children;
158 /* Whether the children of this varobj were requested. This field is
159 used to decide if dynamic varobj should recompute their children.
160 In the event that the frontend never asked for the children, we
162 int children_requested;
164 /* Description of the root variable. Points to root variable for children. */
165 struct varobj_root *root;
167 /* The format of the output for this object */
168 enum varobj_display_formats format;
170 /* Was this variable updated via a varobj_set_value operation */
173 /* Last print value. */
176 /* Is this variable frozen. Frozen variables are never implicitly
177 updated by -var-update *
178 or -var-update <direct-or-indirect-parent>. */
181 /* Is the value of this variable intentionally not fetched? It is
182 not fetched if either the variable is frozen, or any parents is
186 /* Sub-range of children which the MI consumer has requested. If
187 FROM < 0 or TO < 0, means that all children have been
192 /* The pretty-printer constructor. If NULL, then the default
193 pretty-printer will be looked up. If None, then no
194 pretty-printer will be installed. */
195 PyObject *constructor;
197 /* The pretty-printer that has been constructed. If NULL, then a
198 new printer object is needed, and one will be constructed. */
199 PyObject *pretty_printer;
201 /* The iterator returned by the printer's 'children' method, or NULL
203 PyObject *child_iter;
205 /* We request one extra item from the iterator, so that we can
206 report to the caller whether there are more items than we have
207 already reported. However, we don't want to install this value
208 when we read it, because that will mess up future updates. So,
209 we stash it here instead. */
210 PyObject *saved_item;
216 struct cpstack *next;
219 /* A list of varobjs */
227 /* Private function prototypes */
229 /* Helper functions for the above subcommands. */
231 static int delete_variable (struct cpstack **, struct varobj *, int);
233 static void delete_variable_1 (struct cpstack **, int *,
234 struct varobj *, int, int);
236 static int install_variable (struct varobj *);
238 static void uninstall_variable (struct varobj *);
240 static struct varobj *create_child (struct varobj *, int, char *);
242 static struct varobj *
243 create_child_with_value (struct varobj *parent, int index, const char *name,
244 struct value *value);
246 /* Utility routines */
248 static struct varobj *new_variable (void);
250 static struct varobj *new_root_variable (void);
252 static void free_variable (struct varobj *var);
254 static struct cleanup *make_cleanup_free_variable (struct varobj *var);
256 static struct type *get_type (struct varobj *var);
258 static struct type *get_value_type (struct varobj *var);
260 static struct type *get_target_type (struct type *);
262 static enum varobj_display_formats variable_default_display (struct varobj *);
264 static void cppush (struct cpstack **pstack, char *name);
266 static char *cppop (struct cpstack **pstack);
268 static int install_new_value (struct varobj *var, struct value *value,
271 /* Language-specific routines. */
273 static enum varobj_languages variable_language (struct varobj *var);
275 static int number_of_children (struct varobj *);
277 static char *name_of_variable (struct varobj *);
279 static char *name_of_child (struct varobj *, int);
281 static struct value *value_of_root (struct varobj **var_handle, int *);
283 static struct value *value_of_child (struct varobj *parent, int index);
285 static char *my_value_of_variable (struct varobj *var,
286 enum varobj_display_formats format);
288 static char *value_get_print_value (struct value *value,
289 enum varobj_display_formats format,
292 static int varobj_value_is_changeable_p (struct varobj *var);
294 static int is_root_p (struct varobj *var);
298 static struct varobj *
299 varobj_add_child (struct varobj *var, const char *name, struct value *value);
301 #endif /* HAVE_PYTHON */
303 /* C implementation */
305 static int c_number_of_children (struct varobj *var);
307 static char *c_name_of_variable (struct varobj *parent);
309 static char *c_name_of_child (struct varobj *parent, int index);
311 static char *c_path_expr_of_child (struct varobj *child);
313 static struct value *c_value_of_root (struct varobj **var_handle);
315 static struct value *c_value_of_child (struct varobj *parent, int index);
317 static struct type *c_type_of_child (struct varobj *parent, int index);
319 static char *c_value_of_variable (struct varobj *var,
320 enum varobj_display_formats format);
322 /* C++ implementation */
324 static int cplus_number_of_children (struct varobj *var);
326 static void cplus_class_num_children (struct type *type, int children[3]);
328 static char *cplus_name_of_variable (struct varobj *parent);
330 static char *cplus_name_of_child (struct varobj *parent, int index);
332 static char *cplus_path_expr_of_child (struct varobj *child);
334 static struct value *cplus_value_of_root (struct varobj **var_handle);
336 static struct value *cplus_value_of_child (struct varobj *parent, int index);
338 static struct type *cplus_type_of_child (struct varobj *parent, int index);
340 static char *cplus_value_of_variable (struct varobj *var,
341 enum varobj_display_formats format);
343 /* Java implementation */
345 static int java_number_of_children (struct varobj *var);
347 static char *java_name_of_variable (struct varobj *parent);
349 static char *java_name_of_child (struct varobj *parent, int index);
351 static char *java_path_expr_of_child (struct varobj *child);
353 static struct value *java_value_of_root (struct varobj **var_handle);
355 static struct value *java_value_of_child (struct varobj *parent, int index);
357 static struct type *java_type_of_child (struct varobj *parent, int index);
359 static char *java_value_of_variable (struct varobj *var,
360 enum varobj_display_formats format);
362 /* The language specific vector */
364 struct language_specific
367 /* The language of this variable */
368 enum varobj_languages language;
370 /* The number of children of PARENT. */
371 int (*number_of_children) (struct varobj * parent);
373 /* The name (expression) of a root varobj. */
374 char *(*name_of_variable) (struct varobj * parent);
376 /* The name of the INDEX'th child of PARENT. */
377 char *(*name_of_child) (struct varobj * parent, int index);
379 /* Returns the rooted expression of CHILD, which is a variable
380 obtain that has some parent. */
381 char *(*path_expr_of_child) (struct varobj * child);
383 /* The ``struct value *'' of the root variable ROOT. */
384 struct value *(*value_of_root) (struct varobj ** root_handle);
386 /* The ``struct value *'' of the INDEX'th child of PARENT. */
387 struct value *(*value_of_child) (struct varobj * parent, int index);
389 /* The type of the INDEX'th child of PARENT. */
390 struct type *(*type_of_child) (struct varobj * parent, int index);
392 /* The current value of VAR. */
393 char *(*value_of_variable) (struct varobj * var,
394 enum varobj_display_formats format);
397 /* Array of known source language routines. */
398 static struct language_specific languages[vlang_end] = {
399 /* Unknown (try treating as C */
402 c_number_of_children,
405 c_path_expr_of_child,
414 c_number_of_children,
417 c_path_expr_of_child,
426 cplus_number_of_children,
427 cplus_name_of_variable,
429 cplus_path_expr_of_child,
431 cplus_value_of_child,
433 cplus_value_of_variable}
438 java_number_of_children,
439 java_name_of_variable,
441 java_path_expr_of_child,
445 java_value_of_variable}
448 /* A little convenience enum for dealing with C++/Java */
451 v_public = 0, v_private, v_protected
456 /* Mappings of varobj_display_formats enums to gdb's format codes */
457 static int format_code[] = { 0, 't', 'd', 'x', 'o' };
459 /* Header of the list of root variable objects */
460 static struct varobj_root *rootlist;
462 /* Prime number indicating the number of buckets in the hash table */
463 /* A prime large enough to avoid too many colisions */
464 #define VAROBJ_TABLE_SIZE 227
466 /* Pointer to the varobj hash table (built at run time) */
467 static struct vlist **varobj_table;
469 /* Is the variable X one of our "fake" children? */
470 #define CPLUS_FAKE_CHILD(x) \
471 ((x) != NULL && (x)->type == NULL && (x)->value == NULL)
474 /* API Implementation */
476 is_root_p (struct varobj *var)
478 return (var->root->rootvar == var);
482 /* Helper function to install a Python environment suitable for
483 use during operations on VAR. */
485 varobj_ensure_python_env (struct varobj *var)
487 return ensure_python_env (var->root->exp->gdbarch,
488 var->root->exp->language_defn);
492 /* Creates a varobj (not its children) */
494 /* Return the full FRAME which corresponds to the given CORE_ADDR
495 or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
497 static struct frame_info *
498 find_frame_addr_in_frame_chain (CORE_ADDR frame_addr)
500 struct frame_info *frame = NULL;
502 if (frame_addr == (CORE_ADDR) 0)
505 for (frame = get_current_frame ();
507 frame = get_prev_frame (frame))
509 /* The CORE_ADDR we get as argument was parsed from a string GDB
510 output as $fp. This output got truncated to gdbarch_addr_bit.
511 Truncate the frame base address in the same manner before
512 comparing it against our argument. */
513 CORE_ADDR frame_base = get_frame_base_address (frame);
514 int addr_bit = gdbarch_addr_bit (get_frame_arch (frame));
515 if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
516 frame_base &= ((CORE_ADDR) 1 << addr_bit) - 1;
518 if (frame_base == frame_addr)
526 varobj_create (char *objname,
527 char *expression, CORE_ADDR frame, enum varobj_type type)
530 struct frame_info *fi;
531 struct frame_info *old_fi = NULL;
533 struct cleanup *old_chain;
535 /* Fill out a varobj structure for the (root) variable being constructed. */
536 var = new_root_variable ();
537 old_chain = make_cleanup_free_variable (var);
539 if (expression != NULL)
542 enum varobj_languages lang;
543 struct value *value = NULL;
545 /* Parse and evaluate the expression, filling in as much of the
546 variable's data as possible. */
548 if (has_stack_frames ())
550 /* Allow creator to specify context of variable */
551 if ((type == USE_CURRENT_FRAME) || (type == USE_SELECTED_FRAME))
552 fi = get_selected_frame (NULL);
554 /* FIXME: cagney/2002-11-23: This code should be doing a
555 lookup using the frame ID and not just the frame's
556 ``address''. This, of course, means an interface
557 change. However, with out that interface change ISAs,
558 such as the ia64 with its two stacks, won't work.
559 Similar goes for the case where there is a frameless
561 fi = find_frame_addr_in_frame_chain (frame);
566 /* frame = -2 means always use selected frame */
567 if (type == USE_SELECTED_FRAME)
568 var->root->floating = 1;
572 block = get_frame_block (fi, 0);
575 innermost_block = NULL;
576 /* Wrap the call to parse expression, so we can
577 return a sensible error. */
578 if (!gdb_parse_exp_1 (&p, block, 0, &var->root->exp))
583 /* Don't allow variables to be created for types. */
584 if (var->root->exp->elts[0].opcode == OP_TYPE)
586 do_cleanups (old_chain);
587 fprintf_unfiltered (gdb_stderr, "Attempt to use a type name"
588 " as an expression.\n");
592 var->format = variable_default_display (var);
593 var->root->valid_block = innermost_block;
594 var->name = xstrdup (expression);
595 /* For a root var, the name and the expr are the same. */
596 var->path_expr = xstrdup (expression);
598 /* When the frame is different from the current frame,
599 we must select the appropriate frame before parsing
600 the expression, otherwise the value will not be current.
601 Since select_frame is so benign, just call it for all cases. */
604 /* User could specify explicit FRAME-ADDR which was not found but
605 EXPRESSION is frame specific and we would not be able to evaluate
606 it correctly next time. With VALID_BLOCK set we must also set
607 FRAME and THREAD_ID. */
609 error (_("Failed to find the specified frame"));
611 var->root->frame = get_frame_id (fi);
612 var->root->thread_id = pid_to_thread_id (inferior_ptid);
613 old_fi = get_selected_frame (NULL);
617 /* We definitely need to catch errors here.
618 If evaluate_expression succeeds we got the value we wanted.
619 But if it fails, we still go on with a call to evaluate_type() */
620 if (!gdb_evaluate_expression (var->root->exp, &value))
622 /* Error getting the value. Try to at least get the
624 struct value *type_only_value = evaluate_type (var->root->exp);
625 var->type = value_type (type_only_value);
628 var->type = value_type (value);
630 install_new_value (var, value, 1 /* Initial assignment */);
632 /* Set language info */
633 lang = variable_language (var);
634 var->root->lang = &languages[lang];
636 /* Set ourselves as our root */
637 var->root->rootvar = var;
639 /* Reset the selected frame */
641 select_frame (old_fi);
644 /* If the variable object name is null, that means this
645 is a temporary variable, so don't install it. */
647 if ((var != NULL) && (objname != NULL))
649 var->obj_name = xstrdup (objname);
651 /* If a varobj name is duplicated, the install will fail so
653 if (!install_variable (var))
655 do_cleanups (old_chain);
660 discard_cleanups (old_chain);
664 /* Generates an unique name that can be used for a varobj */
667 varobj_gen_name (void)
672 /* generate a name for this object */
674 obj_name = xstrprintf ("var%d", id);
679 /* Given an OBJNAME, returns the pointer to the corresponding varobj. Call
680 error if OBJNAME cannot be found. */
683 varobj_get_handle (char *objname)
687 unsigned int index = 0;
690 for (chp = objname; *chp; chp++)
692 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
695 cv = *(varobj_table + index);
696 while ((cv != NULL) && (strcmp (cv->var->obj_name, objname) != 0))
700 error (_("Variable object not found"));
705 /* Given the handle, return the name of the object */
708 varobj_get_objname (struct varobj *var)
710 return var->obj_name;
713 /* Given the handle, return the expression represented by the object */
716 varobj_get_expression (struct varobj *var)
718 return name_of_variable (var);
721 /* Deletes a varobj and all its children if only_children == 0,
722 otherwise deletes only the children; returns a malloc'ed list of all the
723 (malloc'ed) names of the variables that have been deleted (NULL terminated) */
726 varobj_delete (struct varobj *var, char ***dellist, int only_children)
730 struct cpstack *result = NULL;
733 /* Initialize a stack for temporary results */
734 cppush (&result, NULL);
737 /* Delete only the variable children */
738 delcount = delete_variable (&result, var, 1 /* only the children */ );
740 /* Delete the variable and all its children */
741 delcount = delete_variable (&result, var, 0 /* parent+children */ );
743 /* We may have been asked to return a list of what has been deleted */
746 *dellist = xmalloc ((delcount + 1) * sizeof (char *));
750 *cp = cppop (&result);
751 while ((*cp != NULL) && (mycount > 0))
755 *cp = cppop (&result);
758 if (mycount || (*cp != NULL))
759 warning (_("varobj_delete: assertion failed - mycount(=%d) <> 0"),
768 /* Convenience function for varobj_set_visualizer. Instantiate a
769 pretty-printer for a given value. */
771 instantiate_pretty_printer (PyObject *constructor, struct value *value)
773 PyObject *val_obj = NULL;
776 val_obj = value_to_value_object (value);
780 printer = PyObject_CallFunctionObjArgs (constructor, val_obj, NULL);
788 /* Set/Get variable object display format */
790 enum varobj_display_formats
791 varobj_set_display_format (struct varobj *var,
792 enum varobj_display_formats format)
799 case FORMAT_HEXADECIMAL:
801 var->format = format;
805 var->format = variable_default_display (var);
808 if (varobj_value_is_changeable_p (var)
809 && var->value && !value_lazy (var->value))
811 xfree (var->print_value);
812 var->print_value = value_get_print_value (var->value, var->format, var);
818 enum varobj_display_formats
819 varobj_get_display_format (struct varobj *var)
825 varobj_get_display_hint (struct varobj *var)
830 struct cleanup *back_to = varobj_ensure_python_env (var);
832 if (var->pretty_printer)
833 result = gdbpy_get_display_hint (var->pretty_printer);
835 do_cleanups (back_to);
841 /* Return true if the varobj has items after TO, false otherwise. */
844 varobj_has_more (struct varobj *var, int to)
846 if (VEC_length (varobj_p, var->children) > to)
848 return ((to == -1 || VEC_length (varobj_p, var->children) == to)
849 && var->saved_item != NULL);
852 /* If the variable object is bound to a specific thread, that
853 is its evaluation can always be done in context of a frame
854 inside that thread, returns GDB id of the thread -- which
855 is always positive. Otherwise, returns -1. */
857 varobj_get_thread_id (struct varobj *var)
859 if (var->root->valid_block && var->root->thread_id > 0)
860 return var->root->thread_id;
866 varobj_set_frozen (struct varobj *var, int frozen)
868 /* When a variable is unfrozen, we don't fetch its value.
869 The 'not_fetched' flag remains set, so next -var-update
872 We don't fetch the value, because for structures the client
873 should do -var-update anyway. It would be bad to have different
874 client-size logic for structure and other types. */
875 var->frozen = frozen;
879 varobj_get_frozen (struct varobj *var)
884 /* A helper function that restricts a range to what is actually
885 available in a VEC. This follows the usual rules for the meaning
886 of FROM and TO -- if either is negative, the entire range is
890 restrict_range (VEC (varobj_p) *children, int *from, int *to)
892 if (*from < 0 || *to < 0)
895 *to = VEC_length (varobj_p, children);
899 if (*from > VEC_length (varobj_p, children))
900 *from = VEC_length (varobj_p, children);
901 if (*to > VEC_length (varobj_p, children))
902 *to = VEC_length (varobj_p, children);
910 /* A helper for update_dynamic_varobj_children that installs a new
911 child when needed. */
914 install_dynamic_child (struct varobj *var,
915 VEC (varobj_p) **changed,
916 VEC (varobj_p) **new,
917 VEC (varobj_p) **unchanged,
923 if (VEC_length (varobj_p, var->children) < index + 1)
925 /* There's no child yet. */
926 struct varobj *child = varobj_add_child (var, name, value);
929 VEC_safe_push (varobj_p, *new, child);
935 varobj_p existing = VEC_index (varobj_p, var->children, index);
936 if (install_new_value (existing, value, 0))
939 VEC_safe_push (varobj_p, *changed, existing);
942 VEC_safe_push (varobj_p, *unchanged, existing);
947 dynamic_varobj_has_child_method (struct varobj *var)
949 struct cleanup *back_to;
950 PyObject *printer = var->pretty_printer;
953 back_to = varobj_ensure_python_env (var);
954 result = PyObject_HasAttr (printer, gdbpy_children_cst);
955 do_cleanups (back_to);
962 update_dynamic_varobj_children (struct varobj *var,
963 VEC (varobj_p) **changed,
964 VEC (varobj_p) **new,
965 VEC (varobj_p) **unchanged,
972 struct cleanup *back_to;
975 PyObject *printer = var->pretty_printer;
977 back_to = varobj_ensure_python_env (var);
980 if (!PyObject_HasAttr (printer, gdbpy_children_cst))
982 do_cleanups (back_to);
986 if (update_children || !var->child_iter)
988 children = PyObject_CallMethodObjArgs (printer, gdbpy_children_cst,
993 gdbpy_print_stack ();
994 error (_("Null value returned for children"));
997 make_cleanup_py_decref (children);
999 if (!PyIter_Check (children))
1000 error (_("Returned value is not iterable"));
1002 Py_XDECREF (var->child_iter);
1003 var->child_iter = PyObject_GetIter (children);
1004 if (!var->child_iter)
1006 gdbpy_print_stack ();
1007 error (_("Could not get children iterator"));
1010 Py_XDECREF (var->saved_item);
1011 var->saved_item = NULL;
1016 i = VEC_length (varobj_p, var->children);
1018 /* We ask for one extra child, so that MI can report whether there
1019 are more children. */
1020 for (; to < 0 || i < to + 1; ++i)
1024 /* See if there was a leftover from last time. */
1025 if (var->saved_item)
1027 item = var->saved_item;
1028 var->saved_item = NULL;
1031 item = PyIter_Next (var->child_iter);
1036 /* We don't want to push the extra child on any report list. */
1037 if (to < 0 || i < to)
1042 struct cleanup *inner;
1043 int can_mention = from < 0 || i >= from;
1045 inner = make_cleanup_py_decref (item);
1047 if (!PyArg_ParseTuple (item, "sO", &name, &py_v))
1048 error (_("Invalid item from the child list"));
1050 v = convert_value_from_python (py_v);
1051 install_dynamic_child (var, can_mention ? changed : NULL,
1052 can_mention ? new : NULL,
1053 can_mention ? unchanged : NULL,
1054 can_mention ? cchanged : NULL, i, name, v);
1055 do_cleanups (inner);
1059 Py_XDECREF (var->saved_item);
1060 var->saved_item = item;
1062 /* We want to truncate the child list just before this
1068 if (i < VEC_length (varobj_p, var->children))
1072 for (j = i; j < VEC_length (varobj_p, var->children); ++j)
1073 varobj_delete (VEC_index (varobj_p, var->children, j), NULL, 0);
1074 VEC_truncate (varobj_p, var->children, i);
1077 /* If there are fewer children than requested, note that the list of
1078 children changed. */
1079 if (to >= 0 && VEC_length (varobj_p, var->children) < to)
1082 var->num_children = VEC_length (varobj_p, var->children);
1084 do_cleanups (back_to);
1088 gdb_assert (0 && "should never be called if Python is not enabled");
1093 varobj_get_num_children (struct varobj *var)
1095 if (var->num_children == -1)
1097 if (var->pretty_printer)
1101 /* If we have a dynamic varobj, don't report -1 children.
1102 So, try to fetch some children first. */
1103 update_dynamic_varobj_children (var, NULL, NULL, NULL, &dummy,
1107 var->num_children = number_of_children (var);
1110 return var->num_children >= 0 ? var->num_children : 0;
1113 /* Creates a list of the immediate children of a variable object;
1114 the return code is the number of such children or -1 on error */
1117 varobj_list_children (struct varobj *var, int *from, int *to)
1119 struct varobj *child;
1121 int i, children_changed;
1123 var->children_requested = 1;
1125 if (var->pretty_printer)
1127 /* This, in theory, can result in the number of children changing without
1128 frontend noticing. But well, calling -var-list-children on the same
1129 varobj twice is not something a sane frontend would do. */
1130 update_dynamic_varobj_children (var, NULL, NULL, NULL, &children_changed,
1132 restrict_range (var->children, from, to);
1133 return var->children;
1136 if (var->num_children == -1)
1137 var->num_children = number_of_children (var);
1139 /* If that failed, give up. */
1140 if (var->num_children == -1)
1141 return var->children;
1143 /* If we're called when the list of children is not yet initialized,
1144 allocate enough elements in it. */
1145 while (VEC_length (varobj_p, var->children) < var->num_children)
1146 VEC_safe_push (varobj_p, var->children, NULL);
1148 for (i = 0; i < var->num_children; i++)
1150 varobj_p existing = VEC_index (varobj_p, var->children, i);
1152 if (existing == NULL)
1154 /* Either it's the first call to varobj_list_children for
1155 this variable object, and the child was never created,
1156 or it was explicitly deleted by the client. */
1157 name = name_of_child (var, i);
1158 existing = create_child (var, i, name);
1159 VEC_replace (varobj_p, var->children, i, existing);
1163 restrict_range (var->children, from, to);
1164 return var->children;
1169 static struct varobj *
1170 varobj_add_child (struct varobj *var, const char *name, struct value *value)
1172 varobj_p v = create_child_with_value (var,
1173 VEC_length (varobj_p, var->children),
1175 VEC_safe_push (varobj_p, var->children, v);
1179 #endif /* HAVE_PYTHON */
1181 /* Obtain the type of an object Variable as a string similar to the one gdb
1182 prints on the console */
1185 varobj_get_type (struct varobj *var)
1187 /* For the "fake" variables, do not return a type. (It's type is
1189 Do not return a type for invalid variables as well. */
1190 if (CPLUS_FAKE_CHILD (var) || !var->root->is_valid)
1193 return type_to_string (var->type);
1196 /* Obtain the type of an object variable. */
1199 varobj_get_gdb_type (struct varobj *var)
1204 /* Return a pointer to the full rooted expression of varobj VAR.
1205 If it has not been computed yet, compute it. */
1207 varobj_get_path_expr (struct varobj *var)
1209 if (var->path_expr != NULL)
1210 return var->path_expr;
1213 /* For root varobjs, we initialize path_expr
1214 when creating varobj, so here it should be
1216 gdb_assert (!is_root_p (var));
1217 return (*var->root->lang->path_expr_of_child) (var);
1221 enum varobj_languages
1222 varobj_get_language (struct varobj *var)
1224 return variable_language (var);
1228 varobj_get_attributes (struct varobj *var)
1232 if (varobj_editable_p (var))
1233 /* FIXME: define masks for attributes */
1234 attributes |= 0x00000001; /* Editable */
1240 varobj_pretty_printed_p (struct varobj *var)
1242 return var->pretty_printer != NULL;
1246 varobj_get_formatted_value (struct varobj *var,
1247 enum varobj_display_formats format)
1249 return my_value_of_variable (var, format);
1253 varobj_get_value (struct varobj *var)
1255 return my_value_of_variable (var, var->format);
1258 /* Set the value of an object variable (if it is editable) to the
1259 value of the given expression */
1260 /* Note: Invokes functions that can call error() */
1263 varobj_set_value (struct varobj *var, char *expression)
1269 /* The argument "expression" contains the variable's new value.
1270 We need to first construct a legal expression for this -- ugh! */
1271 /* Does this cover all the bases? */
1272 struct expression *exp;
1273 struct value *value;
1274 int saved_input_radix = input_radix;
1275 char *s = expression;
1278 gdb_assert (varobj_editable_p (var));
1280 input_radix = 10; /* ALWAYS reset to decimal temporarily */
1281 exp = parse_exp_1 (&s, 0, 0);
1282 if (!gdb_evaluate_expression (exp, &value))
1284 /* We cannot proceed without a valid expression. */
1289 /* All types that are editable must also be changeable. */
1290 gdb_assert (varobj_value_is_changeable_p (var));
1292 /* The value of a changeable variable object must not be lazy. */
1293 gdb_assert (!value_lazy (var->value));
1295 /* Need to coerce the input. We want to check if the
1296 value of the variable object will be different
1297 after assignment, and the first thing value_assign
1298 does is coerce the input.
1299 For example, if we are assigning an array to a pointer variable we
1300 should compare the pointer with the the array's address, not with the
1302 value = coerce_array (value);
1304 /* The new value may be lazy. gdb_value_assign, or
1305 rather value_contents, will take care of this.
1306 If fetching of the new value will fail, gdb_value_assign
1307 with catch the exception. */
1308 if (!gdb_value_assign (var->value, value, &val))
1311 /* If the value has changed, record it, so that next -var-update can
1312 report this change. If a variable had a value of '1', we've set it
1313 to '333' and then set again to '1', when -var-update will report this
1314 variable as changed -- because the first assignment has set the
1315 'updated' flag. There's no need to optimize that, because return value
1316 of -var-update should be considered an approximation. */
1317 var->updated = install_new_value (var, val, 0 /* Compare values. */);
1318 input_radix = saved_input_radix;
1324 /* A helper function to install a constructor function and visualizer
1328 install_visualizer (struct varobj *var, PyObject *constructor,
1329 PyObject *visualizer)
1331 Py_XDECREF (var->constructor);
1332 var->constructor = constructor;
1334 Py_XDECREF (var->pretty_printer);
1335 var->pretty_printer = visualizer;
1337 Py_XDECREF (var->child_iter);
1338 var->child_iter = NULL;
1341 /* Install the default visualizer for VAR. */
1344 install_default_visualizer (struct varobj *var)
1346 if (pretty_printing)
1348 PyObject *pretty_printer = NULL;
1352 pretty_printer = gdbpy_get_varobj_pretty_printer (var->value);
1353 if (! pretty_printer)
1355 gdbpy_print_stack ();
1356 error (_("Cannot instantiate printer for default visualizer"));
1360 if (pretty_printer == Py_None)
1362 Py_DECREF (pretty_printer);
1363 pretty_printer = NULL;
1366 install_visualizer (var, NULL, pretty_printer);
1370 /* Instantiate and install a visualizer for VAR using CONSTRUCTOR to
1371 make a new object. */
1374 construct_visualizer (struct varobj *var, PyObject *constructor)
1376 PyObject *pretty_printer;
1378 Py_INCREF (constructor);
1379 if (constructor == Py_None)
1380 pretty_printer = NULL;
1383 pretty_printer = instantiate_pretty_printer (constructor, var->value);
1384 if (! pretty_printer)
1386 gdbpy_print_stack ();
1387 Py_DECREF (constructor);
1388 constructor = Py_None;
1389 Py_INCREF (constructor);
1392 if (pretty_printer == Py_None)
1394 Py_DECREF (pretty_printer);
1395 pretty_printer = NULL;
1399 install_visualizer (var, constructor, pretty_printer);
1402 #endif /* HAVE_PYTHON */
1404 /* A helper function for install_new_value. This creates and installs
1405 a visualizer for VAR, if appropriate. */
1408 install_new_value_visualizer (struct varobj *var)
1411 /* If the constructor is None, then we want the raw value. If VAR
1412 does not have a value, just skip this. */
1413 if (var->constructor != Py_None && var->value)
1415 struct cleanup *cleanup;
1416 PyObject *pretty_printer = NULL;
1418 cleanup = varobj_ensure_python_env (var);
1420 if (!var->constructor)
1421 install_default_visualizer (var);
1423 construct_visualizer (var, var->constructor);
1425 do_cleanups (cleanup);
1432 /* Assign a new value to a variable object. If INITIAL is non-zero,
1433 this is the first assignement after the variable object was just
1434 created, or changed type. In that case, just assign the value
1436 Otherwise, assign the new value, and return 1 if the value is different
1437 from the current one, 0 otherwise. The comparison is done on textual
1438 representation of value. Therefore, some types need not be compared. E.g.
1439 for structures the reported value is always "{...}", so no comparison is
1440 necessary here. If the old value was NULL and new one is not, or vice versa,
1443 The VALUE parameter should not be released -- the function will
1444 take care of releasing it when needed. */
1446 install_new_value (struct varobj *var, struct value *value, int initial)
1451 int intentionally_not_fetched = 0;
1452 char *print_value = NULL;
1454 /* We need to know the varobj's type to decide if the value should
1455 be fetched or not. C++ fake children (public/protected/private) don't have
1457 gdb_assert (var->type || CPLUS_FAKE_CHILD (var));
1458 changeable = varobj_value_is_changeable_p (var);
1460 /* If the type has custom visualizer, we consider it to be always
1461 changeable. FIXME: need to make sure this behaviour will not
1462 mess up read-sensitive values. */
1463 if (var->pretty_printer)
1466 need_to_fetch = changeable;
1468 /* We are not interested in the address of references, and given
1469 that in C++ a reference is not rebindable, it cannot
1470 meaningfully change. So, get hold of the real value. */
1472 value = coerce_ref (value);
1474 if (var->type && TYPE_CODE (var->type) == TYPE_CODE_UNION)
1475 /* For unions, we need to fetch the value implicitly because
1476 of implementation of union member fetch. When gdb
1477 creates a value for a field and the value of the enclosing
1478 structure is not lazy, it immediately copies the necessary
1479 bytes from the enclosing values. If the enclosing value is
1480 lazy, the call to value_fetch_lazy on the field will read
1481 the data from memory. For unions, that means we'll read the
1482 same memory more than once, which is not desirable. So
1486 /* The new value might be lazy. If the type is changeable,
1487 that is we'll be comparing values of this type, fetch the
1488 value now. Otherwise, on the next update the old value
1489 will be lazy, which means we've lost that old value. */
1490 if (need_to_fetch && value && value_lazy (value))
1492 struct varobj *parent = var->parent;
1493 int frozen = var->frozen;
1494 for (; !frozen && parent; parent = parent->parent)
1495 frozen |= parent->frozen;
1497 if (frozen && initial)
1499 /* For variables that are frozen, or are children of frozen
1500 variables, we don't do fetch on initial assignment.
1501 For non-initial assignemnt we do the fetch, since it means we're
1502 explicitly asked to compare the new value with the old one. */
1503 intentionally_not_fetched = 1;
1505 else if (!gdb_value_fetch_lazy (value))
1507 /* Set the value to NULL, so that for the next -var-update,
1508 we don't try to compare the new value with this value,
1509 that we couldn't even read. */
1515 /* Below, we'll be comparing string rendering of old and new
1516 values. Don't get string rendering if the value is
1517 lazy -- if it is, the code above has decided that the value
1518 should not be fetched. */
1519 if (value && !value_lazy (value) && !var->pretty_printer)
1520 print_value = value_get_print_value (value, var->format, var);
1522 /* If the type is changeable, compare the old and the new values.
1523 If this is the initial assignment, we don't have any old value
1525 if (!initial && changeable)
1527 /* If the value of the varobj was changed by -var-set-value, then the
1528 value in the varobj and in the target is the same. However, that value
1529 is different from the value that the varobj had after the previous
1530 -var-update. So need to the varobj as changed. */
1535 else if (! var->pretty_printer)
1537 /* Try to compare the values. That requires that both
1538 values are non-lazy. */
1539 if (var->not_fetched && value_lazy (var->value))
1541 /* This is a frozen varobj and the value was never read.
1542 Presumably, UI shows some "never read" indicator.
1543 Now that we've fetched the real value, we need to report
1544 this varobj as changed so that UI can show the real
1548 else if (var->value == NULL && value == NULL)
1551 else if (var->value == NULL || value == NULL)
1557 gdb_assert (!value_lazy (var->value));
1558 gdb_assert (!value_lazy (value));
1560 gdb_assert (var->print_value != NULL && print_value != NULL);
1561 if (strcmp (var->print_value, print_value) != 0)
1567 if (!initial && !changeable)
1569 /* For values that are not changeable, we don't compare the values.
1570 However, we want to notice if a value was not NULL and now is NULL,
1571 or vise versa, so that we report when top-level varobjs come in scope
1572 and leave the scope. */
1573 changed = (var->value != NULL) != (value != NULL);
1576 /* We must always keep the new value, since children depend on it. */
1577 if (var->value != NULL && var->value != value)
1578 value_free (var->value);
1581 value_incref (value);
1582 if (value && value_lazy (value) && intentionally_not_fetched)
1583 var->not_fetched = 1;
1585 var->not_fetched = 0;
1588 install_new_value_visualizer (var);
1590 /* If we installed a pretty-printer, re-compare the printed version
1591 to see if the variable changed. */
1592 if (var->pretty_printer)
1594 xfree (print_value);
1595 print_value = value_get_print_value (var->value, var->format, var);
1596 if ((var->print_value == NULL && print_value != NULL)
1597 || (var->print_value != NULL && print_value == NULL)
1598 || (var->print_value != NULL && print_value != NULL
1599 && strcmp (var->print_value, print_value) != 0))
1602 if (var->print_value)
1603 xfree (var->print_value);
1604 var->print_value = print_value;
1606 gdb_assert (!var->value || value_type (var->value));
1611 /* Return the requested range for a varobj. VAR is the varobj. FROM
1612 and TO are out parameters; *FROM and *TO will be set to the
1613 selected sub-range of VAR. If no range was selected using
1614 -var-set-update-range, then both will be -1. */
1616 varobj_get_child_range (struct varobj *var, int *from, int *to)
1622 /* Set the selected sub-range of children of VAR to start at index
1623 FROM and end at index TO. If either FROM or TO is less than zero,
1624 this is interpreted as a request for all children. */
1626 varobj_set_child_range (struct varobj *var, int from, int to)
1633 varobj_set_visualizer (struct varobj *var, const char *visualizer)
1636 PyObject *mainmod, *globals, *pretty_printer, *constructor;
1637 struct cleanup *back_to, *value;
1639 back_to = varobj_ensure_python_env (var);
1641 mainmod = PyImport_AddModule ("__main__");
1642 globals = PyModule_GetDict (mainmod);
1643 Py_INCREF (globals);
1644 make_cleanup_py_decref (globals);
1646 constructor = PyRun_String (visualizer, Py_eval_input, globals, globals);
1650 gdbpy_print_stack ();
1651 error (_("Could not evaluate visualizer expression: %s"), visualizer);
1654 construct_visualizer (var, constructor);
1655 Py_XDECREF (constructor);
1657 /* If there are any children now, wipe them. */
1658 varobj_delete (var, NULL, 1 /* children only */);
1659 var->num_children = -1;
1661 do_cleanups (back_to);
1663 error (_("Python support required"));
1667 /* Update the values for a variable and its children. This is a
1668 two-pronged attack. First, re-parse the value for the root's
1669 expression to see if it's changed. Then go all the way
1670 through its children, reconstructing them and noting if they've
1673 The EXPLICIT parameter specifies if this call is result
1674 of MI request to update this specific variable, or
1675 result of implicit -var-update *. For implicit request, we don't
1676 update frozen variables.
1678 NOTE: This function may delete the caller's varobj. If it
1679 returns TYPE_CHANGED, then it has done this and VARP will be modified
1680 to point to the new varobj. */
1682 VEC(varobj_update_result) *varobj_update (struct varobj **varp, int explicit)
1685 int type_changed = 0;
1690 struct varobj **templist = NULL;
1692 VEC (varobj_update_result) *stack = NULL;
1693 VEC (varobj_update_result) *result = NULL;
1694 struct frame_info *fi;
1696 /* Frozen means frozen -- we don't check for any change in
1697 this varobj, including its going out of scope, or
1698 changing type. One use case for frozen varobjs is
1699 retaining previously evaluated expressions, and we don't
1700 want them to be reevaluated at all. */
1701 if (!explicit && (*varp)->frozen)
1704 if (!(*varp)->root->is_valid)
1706 varobj_update_result r = {0};
1708 r.status = VAROBJ_INVALID;
1709 VEC_safe_push (varobj_update_result, result, &r);
1713 if ((*varp)->root->rootvar == *varp)
1715 varobj_update_result r = {0};
1717 r.status = VAROBJ_IN_SCOPE;
1719 /* Update the root variable. value_of_root can return NULL
1720 if the variable is no longer around, i.e. we stepped out of
1721 the frame in which a local existed. We are letting the
1722 value_of_root variable dispose of the varobj if the type
1724 new = value_of_root (varp, &type_changed);
1727 r.type_changed = type_changed;
1728 if (install_new_value ((*varp), new, type_changed))
1732 r.status = VAROBJ_NOT_IN_SCOPE;
1733 r.value_installed = 1;
1735 if (r.status == VAROBJ_NOT_IN_SCOPE)
1737 if (r.type_changed || r.changed)
1738 VEC_safe_push (varobj_update_result, result, &r);
1742 VEC_safe_push (varobj_update_result, stack, &r);
1746 varobj_update_result r = {0};
1748 VEC_safe_push (varobj_update_result, stack, &r);
1751 /* Walk through the children, reconstructing them all. */
1752 while (!VEC_empty (varobj_update_result, stack))
1754 varobj_update_result r = *(VEC_last (varobj_update_result, stack));
1755 struct varobj *v = r.varobj;
1757 VEC_pop (varobj_update_result, stack);
1759 /* Update this variable, unless it's a root, which is already
1761 if (!r.value_installed)
1763 new = value_of_child (v->parent, v->index);
1764 if (install_new_value (v, new, 0 /* type not changed */))
1771 /* We probably should not get children of a varobj that has a
1772 pretty-printer, but for which -var-list-children was never
1774 if (v->pretty_printer)
1776 VEC (varobj_p) *changed = 0, *new = 0, *unchanged = 0;
1777 int i, children_changed = 0;
1782 if (!v->children_requested)
1786 /* If we initially did not have potential children, but
1787 now we do, consider the varobj as changed.
1788 Otherwise, if children were never requested, consider
1789 it as unchanged -- presumably, such varobj is not yet
1790 expanded in the UI, so we need not bother getting
1792 if (!varobj_has_more (v, 0))
1794 update_dynamic_varobj_children (v, NULL, NULL, NULL,
1796 if (varobj_has_more (v, 0))
1801 VEC_safe_push (varobj_update_result, result, &r);
1806 /* If update_dynamic_varobj_children returns 0, then we have
1807 a non-conforming pretty-printer, so we skip it. */
1808 if (update_dynamic_varobj_children (v, &changed, &new, &unchanged,
1809 &children_changed, 1,
1812 if (children_changed || new)
1814 r.children_changed = 1;
1817 /* Push in reverse order so that the first child is
1818 popped from the work stack first, and so will be
1819 added to result first. This does not affect
1820 correctness, just "nicer". */
1821 for (i = VEC_length (varobj_p, changed) - 1; i >= 0; --i)
1823 varobj_p tmp = VEC_index (varobj_p, changed, i);
1824 varobj_update_result r = {0};
1827 r.value_installed = 1;
1828 VEC_safe_push (varobj_update_result, stack, &r);
1830 for (i = VEC_length (varobj_p, unchanged) - 1; i >= 0; --i)
1832 varobj_p tmp = VEC_index (varobj_p, unchanged, i);
1835 varobj_update_result r = {0};
1837 r.value_installed = 1;
1838 VEC_safe_push (varobj_update_result, stack, &r);
1841 if (r.changed || r.children_changed)
1842 VEC_safe_push (varobj_update_result, result, &r);
1844 /* Free CHANGED and UNCHANGED, but not NEW, because NEW
1845 has been put into the result vector. */
1846 VEC_free (varobj_p, changed);
1847 VEC_free (varobj_p, unchanged);
1853 /* Push any children. Use reverse order so that the first
1854 child is popped from the work stack first, and so
1855 will be added to result first. This does not
1856 affect correctness, just "nicer". */
1857 for (i = VEC_length (varobj_p, v->children)-1; i >= 0; --i)
1859 varobj_p c = VEC_index (varobj_p, v->children, i);
1860 /* Child may be NULL if explicitly deleted by -var-delete. */
1861 if (c != NULL && !c->frozen)
1863 varobj_update_result r = {0};
1865 VEC_safe_push (varobj_update_result, stack, &r);
1869 if (r.changed || r.type_changed)
1870 VEC_safe_push (varobj_update_result, result, &r);
1873 VEC_free (varobj_update_result, stack);
1879 /* Helper functions */
1882 * Variable object construction/destruction
1886 delete_variable (struct cpstack **resultp, struct varobj *var,
1887 int only_children_p)
1891 delete_variable_1 (resultp, &delcount, var,
1892 only_children_p, 1 /* remove_from_parent_p */ );
1897 /* Delete the variable object VAR and its children */
1898 /* IMPORTANT NOTE: If we delete a variable which is a child
1899 and the parent is not removed we dump core. It must be always
1900 initially called with remove_from_parent_p set */
1902 delete_variable_1 (struct cpstack **resultp, int *delcountp,
1903 struct varobj *var, int only_children_p,
1904 int remove_from_parent_p)
1908 /* Delete any children of this variable, too. */
1909 for (i = 0; i < VEC_length (varobj_p, var->children); ++i)
1911 varobj_p child = VEC_index (varobj_p, var->children, i);
1914 if (!remove_from_parent_p)
1915 child->parent = NULL;
1916 delete_variable_1 (resultp, delcountp, child, 0, only_children_p);
1918 VEC_free (varobj_p, var->children);
1920 /* if we were called to delete only the children we are done here */
1921 if (only_children_p)
1924 /* Otherwise, add it to the list of deleted ones and proceed to do so */
1925 /* If the name is null, this is a temporary variable, that has not
1926 yet been installed, don't report it, it belongs to the caller... */
1927 if (var->obj_name != NULL)
1929 cppush (resultp, xstrdup (var->obj_name));
1930 *delcountp = *delcountp + 1;
1933 /* If this variable has a parent, remove it from its parent's list */
1934 /* OPTIMIZATION: if the parent of this variable is also being deleted,
1935 (as indicated by remove_from_parent_p) we don't bother doing an
1936 expensive list search to find the element to remove when we are
1937 discarding the list afterwards */
1938 if ((remove_from_parent_p) && (var->parent != NULL))
1940 VEC_replace (varobj_p, var->parent->children, var->index, NULL);
1943 if (var->obj_name != NULL)
1944 uninstall_variable (var);
1946 /* Free memory associated with this variable */
1947 free_variable (var);
1950 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
1952 install_variable (struct varobj *var)
1955 struct vlist *newvl;
1957 unsigned int index = 0;
1960 for (chp = var->obj_name; *chp; chp++)
1962 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
1965 cv = *(varobj_table + index);
1966 while ((cv != NULL) && (strcmp (cv->var->obj_name, var->obj_name) != 0))
1970 error (_("Duplicate variable object name"));
1972 /* Add varobj to hash table */
1973 newvl = xmalloc (sizeof (struct vlist));
1974 newvl->next = *(varobj_table + index);
1976 *(varobj_table + index) = newvl;
1978 /* If root, add varobj to root list */
1979 if (is_root_p (var))
1981 /* Add to list of root variables */
1982 if (rootlist == NULL)
1983 var->root->next = NULL;
1985 var->root->next = rootlist;
1986 rootlist = var->root;
1992 /* Unistall the object VAR. */
1994 uninstall_variable (struct varobj *var)
1998 struct varobj_root *cr;
1999 struct varobj_root *prer;
2001 unsigned int index = 0;
2004 /* Remove varobj from hash table */
2005 for (chp = var->obj_name; *chp; chp++)
2007 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
2010 cv = *(varobj_table + index);
2012 while ((cv != NULL) && (strcmp (cv->var->obj_name, var->obj_name) != 0))
2019 fprintf_unfiltered (gdb_stdlog, "Deleting %s\n", var->obj_name);
2024 ("Assertion failed: Could not find variable object \"%s\" to delete",
2030 *(varobj_table + index) = cv->next;
2032 prev->next = cv->next;
2036 /* If root, remove varobj from root list */
2037 if (is_root_p (var))
2039 /* Remove from list of root variables */
2040 if (rootlist == var->root)
2041 rootlist = var->root->next;
2046 while ((cr != NULL) && (cr->rootvar != var))
2054 ("Assertion failed: Could not find varobj \"%s\" in root list",
2061 prer->next = cr->next;
2067 /* Create and install a child of the parent of the given name */
2068 static struct varobj *
2069 create_child (struct varobj *parent, int index, char *name)
2071 return create_child_with_value (parent, index, name,
2072 value_of_child (parent, index));
2075 static struct varobj *
2076 create_child_with_value (struct varobj *parent, int index, const char *name,
2077 struct value *value)
2079 struct varobj *child;
2082 child = new_variable ();
2084 /* name is allocated by name_of_child */
2085 /* FIXME: xstrdup should not be here. */
2086 child->name = xstrdup (name);
2087 child->index = index;
2088 child->parent = parent;
2089 child->root = parent->root;
2090 childs_name = xstrprintf ("%s.%s", parent->obj_name, name);
2091 child->obj_name = childs_name;
2092 install_variable (child);
2094 /* Compute the type of the child. Must do this before
2095 calling install_new_value. */
2097 /* If the child had no evaluation errors, var->value
2098 will be non-NULL and contain a valid type. */
2099 child->type = value_type (value);
2101 /* Otherwise, we must compute the type. */
2102 child->type = (*child->root->lang->type_of_child) (child->parent,
2104 install_new_value (child, value, 1);
2111 * Miscellaneous utility functions.
2114 /* Allocate memory and initialize a new variable */
2115 static struct varobj *
2120 var = (struct varobj *) xmalloc (sizeof (struct varobj));
2122 var->path_expr = NULL;
2123 var->obj_name = NULL;
2127 var->num_children = -1;
2129 var->children = NULL;
2133 var->print_value = NULL;
2135 var->not_fetched = 0;
2136 var->children_requested = 0;
2139 var->constructor = 0;
2140 var->pretty_printer = 0;
2141 var->child_iter = 0;
2142 var->saved_item = 0;
2147 /* Allocate memory and initialize a new root variable */
2148 static struct varobj *
2149 new_root_variable (void)
2151 struct varobj *var = new_variable ();
2152 var->root = (struct varobj_root *) xmalloc (sizeof (struct varobj_root));;
2153 var->root->lang = NULL;
2154 var->root->exp = NULL;
2155 var->root->valid_block = NULL;
2156 var->root->frame = null_frame_id;
2157 var->root->floating = 0;
2158 var->root->rootvar = NULL;
2159 var->root->is_valid = 1;
2164 /* Free any allocated memory associated with VAR. */
2166 free_variable (struct varobj *var)
2169 if (var->pretty_printer)
2171 struct cleanup *cleanup = varobj_ensure_python_env (var);
2172 Py_XDECREF (var->constructor);
2173 Py_XDECREF (var->pretty_printer);
2174 Py_XDECREF (var->child_iter);
2175 Py_XDECREF (var->saved_item);
2176 do_cleanups (cleanup);
2180 value_free (var->value);
2182 /* Free the expression if this is a root variable. */
2183 if (is_root_p (var))
2185 xfree (var->root->exp);
2190 xfree (var->obj_name);
2191 xfree (var->print_value);
2192 xfree (var->path_expr);
2197 do_free_variable_cleanup (void *var)
2199 free_variable (var);
2202 static struct cleanup *
2203 make_cleanup_free_variable (struct varobj *var)
2205 return make_cleanup (do_free_variable_cleanup, var);
2208 /* This returns the type of the variable. It also skips past typedefs
2209 to return the real type of the variable.
2211 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
2212 except within get_target_type and get_type. */
2213 static struct type *
2214 get_type (struct varobj *var)
2220 type = check_typedef (type);
2225 /* Return the type of the value that's stored in VAR,
2226 or that would have being stored there if the
2227 value were accessible.
2229 This differs from VAR->type in that VAR->type is always
2230 the true type of the expession in the source language.
2231 The return value of this function is the type we're
2232 actually storing in varobj, and using for displaying
2233 the values and for comparing previous and new values.
2235 For example, top-level references are always stripped. */
2236 static struct type *
2237 get_value_type (struct varobj *var)
2242 type = value_type (var->value);
2246 type = check_typedef (type);
2248 if (TYPE_CODE (type) == TYPE_CODE_REF)
2249 type = get_target_type (type);
2251 type = check_typedef (type);
2256 /* This returns the target type (or NULL) of TYPE, also skipping
2257 past typedefs, just like get_type ().
2259 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
2260 except within get_target_type and get_type. */
2261 static struct type *
2262 get_target_type (struct type *type)
2266 type = TYPE_TARGET_TYPE (type);
2268 type = check_typedef (type);
2274 /* What is the default display for this variable? We assume that
2275 everything is "natural". Any exceptions? */
2276 static enum varobj_display_formats
2277 variable_default_display (struct varobj *var)
2279 return FORMAT_NATURAL;
2282 /* FIXME: The following should be generic for any pointer */
2284 cppush (struct cpstack **pstack, char *name)
2288 s = (struct cpstack *) xmalloc (sizeof (struct cpstack));
2294 /* FIXME: The following should be generic for any pointer */
2296 cppop (struct cpstack **pstack)
2301 if ((*pstack)->name == NULL && (*pstack)->next == NULL)
2306 *pstack = (*pstack)->next;
2313 * Language-dependencies
2316 /* Common entry points */
2318 /* Get the language of variable VAR. */
2319 static enum varobj_languages
2320 variable_language (struct varobj *var)
2322 enum varobj_languages lang;
2324 switch (var->root->exp->language_defn->la_language)
2330 case language_cplus:
2341 /* Return the number of children for a given variable.
2342 The result of this function is defined by the language
2343 implementation. The number of children returned by this function
2344 is the number of children that the user will see in the variable
2347 number_of_children (struct varobj *var)
2349 return (*var->root->lang->number_of_children) (var);;
2352 /* What is the expression for the root varobj VAR? Returns a malloc'd string. */
2354 name_of_variable (struct varobj *var)
2356 return (*var->root->lang->name_of_variable) (var);
2359 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd string. */
2361 name_of_child (struct varobj *var, int index)
2363 return (*var->root->lang->name_of_child) (var, index);
2366 /* What is the ``struct value *'' of the root variable VAR?
2367 For floating variable object, evaluation can get us a value
2368 of different type from what is stored in varobj already. In
2370 - *type_changed will be set to 1
2371 - old varobj will be freed, and new one will be
2372 created, with the same name.
2373 - *var_handle will be set to the new varobj
2374 Otherwise, *type_changed will be set to 0. */
2375 static struct value *
2376 value_of_root (struct varobj **var_handle, int *type_changed)
2380 if (var_handle == NULL)
2385 /* This should really be an exception, since this should
2386 only get called with a root variable. */
2388 if (!is_root_p (var))
2391 if (var->root->floating)
2393 struct varobj *tmp_var;
2394 char *old_type, *new_type;
2396 tmp_var = varobj_create (NULL, var->name, (CORE_ADDR) 0,
2397 USE_SELECTED_FRAME);
2398 if (tmp_var == NULL)
2402 old_type = varobj_get_type (var);
2403 new_type = varobj_get_type (tmp_var);
2404 if (strcmp (old_type, new_type) == 0)
2406 /* The expression presently stored inside var->root->exp
2407 remembers the locations of local variables relatively to
2408 the frame where the expression was created (in DWARF location
2409 button, for example). Naturally, those locations are not
2410 correct in other frames, so update the expression. */
2412 struct expression *tmp_exp = var->root->exp;
2413 var->root->exp = tmp_var->root->exp;
2414 tmp_var->root->exp = tmp_exp;
2416 varobj_delete (tmp_var, NULL, 0);
2421 tmp_var->obj_name = xstrdup (var->obj_name);
2422 tmp_var->from = var->from;
2423 tmp_var->to = var->to;
2424 varobj_delete (var, NULL, 0);
2426 install_variable (tmp_var);
2427 *var_handle = tmp_var;
2439 return (*var->root->lang->value_of_root) (var_handle);
2442 /* What is the ``struct value *'' for the INDEX'th child of PARENT? */
2443 static struct value *
2444 value_of_child (struct varobj *parent, int index)
2446 struct value *value;
2448 value = (*parent->root->lang->value_of_child) (parent, index);
2453 /* GDB already has a command called "value_of_variable". Sigh. */
2455 my_value_of_variable (struct varobj *var, enum varobj_display_formats format)
2457 if (var->root->is_valid)
2459 if (var->pretty_printer)
2460 return value_get_print_value (var->value, var->format, var);
2461 return (*var->root->lang->value_of_variable) (var, format);
2468 value_get_print_value (struct value *value, enum varobj_display_formats format,
2471 struct ui_file *stb;
2472 struct cleanup *old_chain;
2473 gdb_byte *thevalue = NULL;
2474 struct value_print_options opts;
2475 struct type *type = NULL;
2477 char *encoding = NULL;
2478 struct gdbarch *gdbarch = NULL;
2483 gdbarch = get_type_arch (value_type (value));
2486 struct cleanup *back_to = varobj_ensure_python_env (var);
2487 PyObject *value_formatter = var->pretty_printer;
2489 if (value_formatter)
2491 /* First check to see if we have any children at all. If so,
2492 we simply return {...}. */
2493 if (dynamic_varobj_has_child_method (var))
2494 return xstrdup ("{...}");
2496 if (PyObject_HasAttr (value_formatter, gdbpy_to_string_cst))
2499 struct value *replacement;
2500 int string_print = 0;
2501 PyObject *output = NULL;
2503 hint = gdbpy_get_display_hint (value_formatter);
2506 if (!strcmp (hint, "string"))
2511 output = apply_varobj_pretty_printer (value_formatter,
2515 if (gdbpy_is_lazy_string (output))
2517 thevalue = gdbpy_extract_lazy_string (output, &type,
2524 = python_string_to_target_python_string (output);
2527 char *s = PyString_AsString (py_str);
2528 len = PyString_Size (py_str);
2529 thevalue = xmemdup (s, len + 1, len + 1);
2530 type = builtin_type (gdbarch)->builtin_char;
2536 if (thevalue && !string_print)
2538 do_cleanups (back_to);
2543 value = replacement;
2546 do_cleanups (back_to);
2550 stb = mem_fileopen ();
2551 old_chain = make_cleanup_ui_file_delete (stb);
2553 get_formatted_print_options (&opts, format_code[(int) format]);
2558 make_cleanup (xfree, thevalue);
2559 make_cleanup (xfree, encoding);
2560 LA_PRINT_STRING (stb, type, thevalue, len, encoding, 0, &opts);
2563 common_val_print (value, stb, 0, &opts, current_language);
2564 thevalue = ui_file_xstrdup (stb, NULL);
2566 do_cleanups (old_chain);
2571 varobj_editable_p (struct varobj *var)
2574 struct value *value;
2576 if (!(var->root->is_valid && var->value && VALUE_LVAL (var->value)))
2579 type = get_value_type (var);
2581 switch (TYPE_CODE (type))
2583 case TYPE_CODE_STRUCT:
2584 case TYPE_CODE_UNION:
2585 case TYPE_CODE_ARRAY:
2586 case TYPE_CODE_FUNC:
2587 case TYPE_CODE_METHOD:
2597 /* Return non-zero if changes in value of VAR
2598 must be detected and reported by -var-update.
2599 Return zero is -var-update should never report
2600 changes of such values. This makes sense for structures
2601 (since the changes in children values will be reported separately),
2602 or for artifical objects (like 'public' pseudo-field in C++).
2604 Return value of 0 means that gdb need not call value_fetch_lazy
2605 for the value of this variable object. */
2607 varobj_value_is_changeable_p (struct varobj *var)
2612 if (CPLUS_FAKE_CHILD (var))
2615 type = get_value_type (var);
2617 switch (TYPE_CODE (type))
2619 case TYPE_CODE_STRUCT:
2620 case TYPE_CODE_UNION:
2621 case TYPE_CODE_ARRAY:
2632 /* Return 1 if that varobj is floating, that is is always evaluated in the
2633 selected frame, and not bound to thread/frame. Such variable objects
2634 are created using '@' as frame specifier to -var-create. */
2636 varobj_floating_p (struct varobj *var)
2638 return var->root->floating;
2641 /* Given the value and the type of a variable object,
2642 adjust the value and type to those necessary
2643 for getting children of the variable object.
2644 This includes dereferencing top-level references
2645 to all types and dereferencing pointers to
2648 Both TYPE and *TYPE should be non-null. VALUE
2649 can be null if we want to only translate type.
2650 *VALUE can be null as well -- if the parent
2653 If WAS_PTR is not NULL, set *WAS_PTR to 0 or 1
2654 depending on whether pointer was dereferenced
2655 in this function. */
2657 adjust_value_for_child_access (struct value **value,
2661 gdb_assert (type && *type);
2666 *type = check_typedef (*type);
2668 /* The type of value stored in varobj, that is passed
2669 to us, is already supposed to be
2670 reference-stripped. */
2672 gdb_assert (TYPE_CODE (*type) != TYPE_CODE_REF);
2674 /* Pointers to structures are treated just like
2675 structures when accessing children. Don't
2676 dererences pointers to other types. */
2677 if (TYPE_CODE (*type) == TYPE_CODE_PTR)
2679 struct type *target_type = get_target_type (*type);
2680 if (TYPE_CODE (target_type) == TYPE_CODE_STRUCT
2681 || TYPE_CODE (target_type) == TYPE_CODE_UNION)
2683 if (value && *value)
2685 int success = gdb_value_ind (*value, value);
2689 *type = target_type;
2695 /* The 'get_target_type' function calls check_typedef on
2696 result, so we can immediately check type code. No
2697 need to call check_typedef here. */
2702 c_number_of_children (struct varobj *var)
2704 struct type *type = get_value_type (var);
2706 struct type *target;
2708 adjust_value_for_child_access (NULL, &type, NULL);
2709 target = get_target_type (type);
2711 switch (TYPE_CODE (type))
2713 case TYPE_CODE_ARRAY:
2714 if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (target) > 0
2715 && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))
2716 children = TYPE_LENGTH (type) / TYPE_LENGTH (target);
2718 /* If we don't know how many elements there are, don't display
2723 case TYPE_CODE_STRUCT:
2724 case TYPE_CODE_UNION:
2725 children = TYPE_NFIELDS (type);
2729 /* The type here is a pointer to non-struct. Typically, pointers
2730 have one child, except for function ptrs, which have no children,
2731 and except for void*, as we don't know what to show.
2733 We can show char* so we allow it to be dereferenced. If you decide
2734 to test for it, please mind that a little magic is necessary to
2735 properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
2736 TYPE_NAME == "char" */
2737 if (TYPE_CODE (target) == TYPE_CODE_FUNC
2738 || TYPE_CODE (target) == TYPE_CODE_VOID)
2745 /* Other types have no children */
2753 c_name_of_variable (struct varobj *parent)
2755 return xstrdup (parent->name);
2758 /* Return the value of element TYPE_INDEX of a structure
2759 value VALUE. VALUE's type should be a structure,
2760 or union, or a typedef to struct/union.
2762 Returns NULL if getting the value fails. Never throws. */
2763 static struct value *
2764 value_struct_element_index (struct value *value, int type_index)
2766 struct value *result = NULL;
2767 volatile struct gdb_exception e;
2769 struct type *type = value_type (value);
2770 type = check_typedef (type);
2772 gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
2773 || TYPE_CODE (type) == TYPE_CODE_UNION);
2775 TRY_CATCH (e, RETURN_MASK_ERROR)
2777 if (field_is_static (&TYPE_FIELD (type, type_index)))
2778 result = value_static_field (type, type_index);
2780 result = value_primitive_field (value, 0, type_index, type);
2792 /* Obtain the information about child INDEX of the variable
2794 If CNAME is not null, sets *CNAME to the name of the child relative
2796 If CVALUE is not null, sets *CVALUE to the value of the child.
2797 If CTYPE is not null, sets *CTYPE to the type of the child.
2799 If any of CNAME, CVALUE, or CTYPE is not null, but the corresponding
2800 information cannot be determined, set *CNAME, *CVALUE, or *CTYPE
2803 c_describe_child (struct varobj *parent, int index,
2804 char **cname, struct value **cvalue, struct type **ctype,
2805 char **cfull_expression)
2807 struct value *value = parent->value;
2808 struct type *type = get_value_type (parent);
2809 char *parent_expression = NULL;
2818 if (cfull_expression)
2820 *cfull_expression = NULL;
2821 parent_expression = varobj_get_path_expr (parent);
2823 adjust_value_for_child_access (&value, &type, &was_ptr);
2825 switch (TYPE_CODE (type))
2827 case TYPE_CODE_ARRAY:
2829 *cname = xstrdup (int_string (index
2830 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)),
2833 if (cvalue && value)
2835 int real_index = index + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type));
2836 gdb_value_subscript (value, real_index, cvalue);
2840 *ctype = get_target_type (type);
2842 if (cfull_expression)
2844 xstrprintf ("(%s)[%s]", parent_expression,
2846 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)),
2852 case TYPE_CODE_STRUCT:
2853 case TYPE_CODE_UNION:
2855 *cname = xstrdup (TYPE_FIELD_NAME (type, index));
2857 if (cvalue && value)
2859 /* For C, varobj index is the same as type index. */
2860 *cvalue = value_struct_element_index (value, index);
2864 *ctype = TYPE_FIELD_TYPE (type, index);
2866 if (cfull_expression)
2868 char *join = was_ptr ? "->" : ".";
2869 *cfull_expression = xstrprintf ("(%s)%s%s", parent_expression, join,
2870 TYPE_FIELD_NAME (type, index));
2877 *cname = xstrprintf ("*%s", parent->name);
2879 if (cvalue && value)
2881 int success = gdb_value_ind (value, cvalue);
2886 /* Don't use get_target_type because it calls
2887 check_typedef and here, we want to show the true
2888 declared type of the variable. */
2890 *ctype = TYPE_TARGET_TYPE (type);
2892 if (cfull_expression)
2893 *cfull_expression = xstrprintf ("*(%s)", parent_expression);
2898 /* This should not happen */
2900 *cname = xstrdup ("???");
2901 if (cfull_expression)
2902 *cfull_expression = xstrdup ("???");
2903 /* Don't set value and type, we don't know then. */
2908 c_name_of_child (struct varobj *parent, int index)
2911 c_describe_child (parent, index, &name, NULL, NULL, NULL);
2916 c_path_expr_of_child (struct varobj *child)
2918 c_describe_child (child->parent, child->index, NULL, NULL, NULL,
2920 return child->path_expr;
2923 /* If frame associated with VAR can be found, switch
2924 to it and return 1. Otherwise, return 0. */
2926 check_scope (struct varobj *var)
2928 struct frame_info *fi;
2931 fi = frame_find_by_id (var->root->frame);
2936 CORE_ADDR pc = get_frame_pc (fi);
2937 if (pc < BLOCK_START (var->root->valid_block) ||
2938 pc >= BLOCK_END (var->root->valid_block))
2946 static struct value *
2947 c_value_of_root (struct varobj **var_handle)
2949 struct value *new_val = NULL;
2950 struct varobj *var = *var_handle;
2951 struct frame_info *fi;
2952 int within_scope = 0;
2953 struct cleanup *back_to;
2955 /* Only root variables can be updated... */
2956 if (!is_root_p (var))
2957 /* Not a root var */
2960 back_to = make_cleanup_restore_current_thread ();
2962 /* Determine whether the variable is still around. */
2963 if (var->root->valid_block == NULL || var->root->floating)
2965 else if (var->root->thread_id == 0)
2967 /* The program was single-threaded when the variable object was
2968 created. Technically, it's possible that the program became
2969 multi-threaded since then, but we don't support such
2971 within_scope = check_scope (var);
2975 ptid_t ptid = thread_id_to_pid (var->root->thread_id);
2976 if (in_thread_list (ptid))
2978 switch_to_thread (ptid);
2979 within_scope = check_scope (var);
2985 /* We need to catch errors here, because if evaluate
2986 expression fails we want to just return NULL. */
2987 gdb_evaluate_expression (var->root->exp, &new_val);
2991 do_cleanups (back_to);
2996 static struct value *
2997 c_value_of_child (struct varobj *parent, int index)
2999 struct value *value = NULL;
3000 c_describe_child (parent, index, NULL, &value, NULL, NULL);
3005 static struct type *
3006 c_type_of_child (struct varobj *parent, int index)
3008 struct type *type = NULL;
3009 c_describe_child (parent, index, NULL, NULL, &type, NULL);
3014 c_value_of_variable (struct varobj *var, enum varobj_display_formats format)
3016 /* BOGUS: if val_print sees a struct/class, or a reference to one,
3017 it will print out its children instead of "{...}". So we need to
3018 catch that case explicitly. */
3019 struct type *type = get_type (var);
3021 /* If we have a custom formatter, return whatever string it has
3023 if (var->pretty_printer && var->print_value)
3024 return xstrdup (var->print_value);
3026 /* Strip top-level references. */
3027 while (TYPE_CODE (type) == TYPE_CODE_REF)
3028 type = check_typedef (TYPE_TARGET_TYPE (type));
3030 switch (TYPE_CODE (type))
3032 case TYPE_CODE_STRUCT:
3033 case TYPE_CODE_UNION:
3034 return xstrdup ("{...}");
3037 case TYPE_CODE_ARRAY:
3040 number = xstrprintf ("[%d]", var->num_children);
3047 if (var->value == NULL)
3049 /* This can happen if we attempt to get the value of a struct
3050 member when the parent is an invalid pointer. This is an
3051 error condition, so we should tell the caller. */
3056 if (var->not_fetched && value_lazy (var->value))
3057 /* Frozen variable and no value yet. We don't
3058 implicitly fetch the value. MI response will
3059 use empty string for the value, which is OK. */
3062 gdb_assert (varobj_value_is_changeable_p (var));
3063 gdb_assert (!value_lazy (var->value));
3065 /* If the specified format is the current one,
3066 we can reuse print_value */
3067 if (format == var->format)
3068 return xstrdup (var->print_value);
3070 return value_get_print_value (var->value, format, var);
3080 cplus_number_of_children (struct varobj *var)
3083 int children, dont_know;
3088 if (!CPLUS_FAKE_CHILD (var))
3090 type = get_value_type (var);
3091 adjust_value_for_child_access (NULL, &type, NULL);
3093 if (((TYPE_CODE (type)) == TYPE_CODE_STRUCT) ||
3094 ((TYPE_CODE (type)) == TYPE_CODE_UNION))
3098 cplus_class_num_children (type, kids);
3099 if (kids[v_public] != 0)
3101 if (kids[v_private] != 0)
3103 if (kids[v_protected] != 0)
3106 /* Add any baseclasses */
3107 children += TYPE_N_BASECLASSES (type);
3110 /* FIXME: save children in var */
3117 type = get_value_type (var->parent);
3118 adjust_value_for_child_access (NULL, &type, NULL);
3120 cplus_class_num_children (type, kids);
3121 if (strcmp (var->name, "public") == 0)
3122 children = kids[v_public];
3123 else if (strcmp (var->name, "private") == 0)
3124 children = kids[v_private];
3126 children = kids[v_protected];
3131 children = c_number_of_children (var);
3136 /* Compute # of public, private, and protected variables in this class.
3137 That means we need to descend into all baseclasses and find out
3138 how many are there, too. */
3140 cplus_class_num_children (struct type *type, int children[3])
3142 int i, vptr_fieldno;
3143 struct type *basetype = NULL;
3145 children[v_public] = 0;
3146 children[v_private] = 0;
3147 children[v_protected] = 0;
3149 vptr_fieldno = get_vptr_fieldno (type, &basetype);
3150 for (i = TYPE_N_BASECLASSES (type); i < TYPE_NFIELDS (type); i++)
3152 /* If we have a virtual table pointer, omit it. Even if virtual
3153 table pointers are not specifically marked in the debug info,
3154 they should be artificial. */
3155 if ((type == basetype && i == vptr_fieldno)
3156 || TYPE_FIELD_ARTIFICIAL (type, i))
3159 if (TYPE_FIELD_PROTECTED (type, i))
3160 children[v_protected]++;
3161 else if (TYPE_FIELD_PRIVATE (type, i))
3162 children[v_private]++;
3164 children[v_public]++;
3169 cplus_name_of_variable (struct varobj *parent)
3171 return c_name_of_variable (parent);
3174 enum accessibility { private_field, protected_field, public_field };
3176 /* Check if field INDEX of TYPE has the specified accessibility.
3177 Return 0 if so and 1 otherwise. */
3179 match_accessibility (struct type *type, int index, enum accessibility acc)
3181 if (acc == private_field && TYPE_FIELD_PRIVATE (type, index))
3183 else if (acc == protected_field && TYPE_FIELD_PROTECTED (type, index))
3185 else if (acc == public_field && !TYPE_FIELD_PRIVATE (type, index)
3186 && !TYPE_FIELD_PROTECTED (type, index))
3193 cplus_describe_child (struct varobj *parent, int index,
3194 char **cname, struct value **cvalue, struct type **ctype,
3195 char **cfull_expression)
3198 struct value *value;
3201 char *parent_expression = NULL;
3209 if (cfull_expression)
3210 *cfull_expression = NULL;
3212 if (CPLUS_FAKE_CHILD (parent))
3214 value = parent->parent->value;
3215 type = get_value_type (parent->parent);
3216 if (cfull_expression)
3217 parent_expression = varobj_get_path_expr (parent->parent);
3221 value = parent->value;
3222 type = get_value_type (parent);
3223 if (cfull_expression)
3224 parent_expression = varobj_get_path_expr (parent);
3227 adjust_value_for_child_access (&value, &type, &was_ptr);
3229 if (TYPE_CODE (type) == TYPE_CODE_STRUCT
3230 || TYPE_CODE (type) == TYPE_CODE_UNION)
3232 char *join = was_ptr ? "->" : ".";
3233 if (CPLUS_FAKE_CHILD (parent))
3235 /* The fields of the class type are ordered as they
3236 appear in the class. We are given an index for a
3237 particular access control type ("public","protected",
3238 or "private"). We must skip over fields that don't
3239 have the access control we are looking for to properly
3240 find the indexed field. */
3241 int type_index = TYPE_N_BASECLASSES (type);
3242 enum accessibility acc = public_field;
3244 struct type *basetype = NULL;
3246 vptr_fieldno = get_vptr_fieldno (type, &basetype);
3247 if (strcmp (parent->name, "private") == 0)
3248 acc = private_field;
3249 else if (strcmp (parent->name, "protected") == 0)
3250 acc = protected_field;
3254 if ((type == basetype && type_index == vptr_fieldno)
3255 || TYPE_FIELD_ARTIFICIAL (type, type_index))
3257 else if (match_accessibility (type, type_index, acc))
3264 *cname = xstrdup (TYPE_FIELD_NAME (type, type_index));
3266 if (cvalue && value)
3267 *cvalue = value_struct_element_index (value, type_index);
3270 *ctype = TYPE_FIELD_TYPE (type, type_index);
3272 if (cfull_expression)
3273 *cfull_expression = xstrprintf ("((%s)%s%s)", parent_expression,
3275 TYPE_FIELD_NAME (type, type_index));
3277 else if (index < TYPE_N_BASECLASSES (type))
3279 /* This is a baseclass. */
3281 *cname = xstrdup (TYPE_FIELD_NAME (type, index));
3283 if (cvalue && value)
3284 *cvalue = value_cast (TYPE_FIELD_TYPE (type, index), value);
3288 *ctype = TYPE_FIELD_TYPE (type, index);
3291 if (cfull_expression)
3293 char *ptr = was_ptr ? "*" : "";
3294 /* Cast the parent to the base' type. Note that in gdb,
3297 will create an lvalue, for all appearences, so we don't
3298 need to use more fancy:
3301 *cfull_expression = xstrprintf ("(%s(%s%s) %s)",
3303 TYPE_FIELD_NAME (type, index),
3310 char *access = NULL;
3312 cplus_class_num_children (type, children);
3314 /* Everything beyond the baseclasses can
3315 only be "public", "private", or "protected"
3317 The special "fake" children are always output by varobj in
3318 this order. So if INDEX == 2, it MUST be "protected". */
3319 index -= TYPE_N_BASECLASSES (type);
3323 if (children[v_public] > 0)
3325 else if (children[v_private] > 0)
3328 access = "protected";
3331 if (children[v_public] > 0)
3333 if (children[v_private] > 0)
3336 access = "protected";
3338 else if (children[v_private] > 0)
3339 access = "protected";
3342 /* Must be protected */
3343 access = "protected";
3350 gdb_assert (access);
3352 *cname = xstrdup (access);
3354 /* Value and type and full expression are null here. */
3359 c_describe_child (parent, index, cname, cvalue, ctype, cfull_expression);
3364 cplus_name_of_child (struct varobj *parent, int index)
3367 cplus_describe_child (parent, index, &name, NULL, NULL, NULL);
3372 cplus_path_expr_of_child (struct varobj *child)
3374 cplus_describe_child (child->parent, child->index, NULL, NULL, NULL,
3376 return child->path_expr;
3379 static struct value *
3380 cplus_value_of_root (struct varobj **var_handle)
3382 return c_value_of_root (var_handle);
3385 static struct value *
3386 cplus_value_of_child (struct varobj *parent, int index)
3388 struct value *value = NULL;
3389 cplus_describe_child (parent, index, NULL, &value, NULL, NULL);
3393 static struct type *
3394 cplus_type_of_child (struct varobj *parent, int index)
3396 struct type *type = NULL;
3397 cplus_describe_child (parent, index, NULL, NULL, &type, NULL);
3402 cplus_value_of_variable (struct varobj *var, enum varobj_display_formats format)
3405 /* If we have one of our special types, don't print out
3407 if (CPLUS_FAKE_CHILD (var))
3408 return xstrdup ("");
3410 return c_value_of_variable (var, format);
3416 java_number_of_children (struct varobj *var)
3418 return cplus_number_of_children (var);
3422 java_name_of_variable (struct varobj *parent)
3426 name = cplus_name_of_variable (parent);
3427 /* If the name has "-" in it, it is because we
3428 needed to escape periods in the name... */
3431 while (*p != '\000')
3442 java_name_of_child (struct varobj *parent, int index)
3446 name = cplus_name_of_child (parent, index);
3447 /* Escape any periods in the name... */
3450 while (*p != '\000')
3461 java_path_expr_of_child (struct varobj *child)
3466 static struct value *
3467 java_value_of_root (struct varobj **var_handle)
3469 return cplus_value_of_root (var_handle);
3472 static struct value *
3473 java_value_of_child (struct varobj *parent, int index)
3475 return cplus_value_of_child (parent, index);
3478 static struct type *
3479 java_type_of_child (struct varobj *parent, int index)
3481 return cplus_type_of_child (parent, index);
3485 java_value_of_variable (struct varobj *var, enum varobj_display_formats format)
3487 return cplus_value_of_variable (var, format);
3490 /* Iterate all the existing _root_ VAROBJs and call the FUNC callback for them
3491 with an arbitrary caller supplied DATA pointer. */
3494 all_root_varobjs (void (*func) (struct varobj *var, void *data), void *data)
3496 struct varobj_root *var_root, *var_root_next;
3498 /* Iterate "safely" - handle if the callee deletes its passed VAROBJ. */
3500 for (var_root = rootlist; var_root != NULL; var_root = var_root_next)
3502 var_root_next = var_root->next;
3504 (*func) (var_root->rootvar, data);
3508 extern void _initialize_varobj (void);
3510 _initialize_varobj (void)
3512 int sizeof_table = sizeof (struct vlist *) * VAROBJ_TABLE_SIZE;
3514 varobj_table = xmalloc (sizeof_table);
3515 memset (varobj_table, 0, sizeof_table);
3517 add_setshow_zinteger_cmd ("debugvarobj", class_maintenance,
3519 Set varobj debugging."), _("\
3520 Show varobj debugging."), _("\
3521 When non-zero, varobj debugging is enabled."),
3524 &setlist, &showlist);
3527 /* Invalidate varobj VAR if it is tied to locals and re-create it if it is
3528 defined on globals. It is a helper for varobj_invalidate. */
3531 varobj_invalidate_iter (struct varobj *var, void *unused)
3533 /* Floating varobjs are reparsed on each stop, so we don't care if the
3534 presently parsed expression refers to something that's gone. */
3535 if (var->root->floating)
3538 /* global var must be re-evaluated. */
3539 if (var->root->valid_block == NULL)
3541 struct varobj *tmp_var;
3543 /* Try to create a varobj with same expression. If we succeed
3544 replace the old varobj, otherwise invalidate it. */
3545 tmp_var = varobj_create (NULL, var->name, (CORE_ADDR) 0,
3547 if (tmp_var != NULL)
3549 tmp_var->obj_name = xstrdup (var->obj_name);
3550 varobj_delete (var, NULL, 0);
3551 install_variable (tmp_var);
3554 var->root->is_valid = 0;
3556 else /* locals must be invalidated. */
3557 var->root->is_valid = 0;
3560 /* Invalidate the varobjs that are tied to locals and re-create the ones that
3561 are defined on globals.
3562 Invalidated varobjs will be always printed in_scope="invalid". */
3565 varobj_invalidate (void)
3567 all_root_varobjs (varobj_invalidate_iter, NULL);