1 /* Implementation of the GDB variable objects API.
3 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
4 2009, 2010, 2011 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));
516 if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
517 frame_base &= ((CORE_ADDR) 1 << addr_bit) - 1;
519 if (frame_base == frame_addr)
527 varobj_create (char *objname,
528 char *expression, CORE_ADDR frame, enum varobj_type type)
531 struct cleanup *old_chain;
533 /* Fill out a varobj structure for the (root) variable being constructed. */
534 var = new_root_variable ();
535 old_chain = make_cleanup_free_variable (var);
537 if (expression != NULL)
539 struct frame_info *fi;
540 struct frame_id old_id = null_frame_id;
543 enum varobj_languages lang;
544 struct value *value = NULL;
546 /* Parse and evaluate the expression, filling in as much of the
547 variable's data as possible. */
549 if (has_stack_frames ())
551 /* Allow creator to specify context of variable */
552 if ((type == USE_CURRENT_FRAME) || (type == USE_SELECTED_FRAME))
553 fi = get_selected_frame (NULL);
555 /* FIXME: cagney/2002-11-23: This code should be doing a
556 lookup using the frame ID and not just the frame's
557 ``address''. This, of course, means an interface
558 change. However, with out that interface change ISAs,
559 such as the ia64 with its two stacks, won't work.
560 Similar goes for the case where there is a frameless
562 fi = find_frame_addr_in_frame_chain (frame);
567 /* frame = -2 means always use selected frame */
568 if (type == USE_SELECTED_FRAME)
569 var->root->floating = 1;
573 block = get_frame_block (fi, 0);
576 innermost_block = NULL;
577 /* Wrap the call to parse expression, so we can
578 return a sensible error. */
579 if (!gdb_parse_exp_1 (&p, block, 0, &var->root->exp))
584 /* Don't allow variables to be created for types. */
585 if (var->root->exp->elts[0].opcode == OP_TYPE)
587 do_cleanups (old_chain);
588 fprintf_unfiltered (gdb_stderr, "Attempt to use a type name"
589 " as an expression.\n");
593 var->format = variable_default_display (var);
594 var->root->valid_block = innermost_block;
595 var->name = xstrdup (expression);
596 /* For a root var, the name and the expr are the same. */
597 var->path_expr = xstrdup (expression);
599 /* When the frame is different from the current frame,
600 we must select the appropriate frame before parsing
601 the expression, otherwise the value will not be current.
602 Since select_frame is so benign, just call it for all cases. */
605 /* User could specify explicit FRAME-ADDR which was not found but
606 EXPRESSION is frame specific and we would not be able to evaluate
607 it correctly next time. With VALID_BLOCK set we must also set
608 FRAME and THREAD_ID. */
610 error (_("Failed to find the specified frame"));
612 var->root->frame = get_frame_id (fi);
613 var->root->thread_id = pid_to_thread_id (inferior_ptid);
614 old_id = get_frame_id (get_selected_frame (NULL));
618 /* We definitely need to catch errors here.
619 If evaluate_expression succeeds we got the value we wanted.
620 But if it fails, we still go on with a call to evaluate_type() */
621 if (!gdb_evaluate_expression (var->root->exp, &value))
623 /* Error getting the value. Try to at least get the
625 struct value *type_only_value = evaluate_type (var->root->exp);
627 var->type = value_type (type_only_value);
630 var->type = value_type (value);
632 install_new_value (var, value, 1 /* Initial assignment */);
634 /* Set language info */
635 lang = variable_language (var);
636 var->root->lang = &languages[lang];
638 /* Set ourselves as our root */
639 var->root->rootvar = var;
641 /* Reset the selected frame */
642 if (frame_id_p (old_id))
643 select_frame (frame_find_by_id (old_id));
646 /* If the variable object name is null, that means this
647 is a temporary variable, so don't install it. */
649 if ((var != NULL) && (objname != NULL))
651 var->obj_name = xstrdup (objname);
653 /* If a varobj name is duplicated, the install will fail so
655 if (!install_variable (var))
657 do_cleanups (old_chain);
662 discard_cleanups (old_chain);
666 /* Generates an unique name that can be used for a varobj */
669 varobj_gen_name (void)
674 /* generate a name for this object */
676 obj_name = xstrprintf ("var%d", id);
681 /* Given an OBJNAME, returns the pointer to the corresponding varobj. Call
682 error if OBJNAME cannot be found. */
685 varobj_get_handle (char *objname)
689 unsigned int index = 0;
692 for (chp = objname; *chp; chp++)
694 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
697 cv = *(varobj_table + index);
698 while ((cv != NULL) && (strcmp (cv->var->obj_name, objname) != 0))
702 error (_("Variable object not found"));
707 /* Given the handle, return the name of the object */
710 varobj_get_objname (struct varobj *var)
712 return var->obj_name;
715 /* Given the handle, return the expression represented by the object */
718 varobj_get_expression (struct varobj *var)
720 return name_of_variable (var);
723 /* Deletes a varobj and all its children if only_children == 0,
724 otherwise deletes only the children; returns a malloc'ed list of
725 all the (malloc'ed) names of the variables that have been deleted
729 varobj_delete (struct varobj *var, char ***dellist, int only_children)
733 struct cpstack *result = NULL;
736 /* Initialize a stack for temporary results */
737 cppush (&result, NULL);
740 /* Delete only the variable children */
741 delcount = delete_variable (&result, var, 1 /* only the children */ );
743 /* Delete the variable and all its children */
744 delcount = delete_variable (&result, var, 0 /* parent+children */ );
746 /* We may have been asked to return a list of what has been deleted */
749 *dellist = xmalloc ((delcount + 1) * sizeof (char *));
753 *cp = cppop (&result);
754 while ((*cp != NULL) && (mycount > 0))
758 *cp = cppop (&result);
761 if (mycount || (*cp != NULL))
762 warning (_("varobj_delete: assertion failed - mycount(=%d) <> 0"),
771 /* Convenience function for varobj_set_visualizer. Instantiate a
772 pretty-printer for a given value. */
774 instantiate_pretty_printer (PyObject *constructor, struct value *value)
776 PyObject *val_obj = NULL;
779 val_obj = value_to_value_object (value);
783 printer = PyObject_CallFunctionObjArgs (constructor, val_obj, NULL);
791 /* Set/Get variable object display format */
793 enum varobj_display_formats
794 varobj_set_display_format (struct varobj *var,
795 enum varobj_display_formats format)
802 case FORMAT_HEXADECIMAL:
804 var->format = format;
808 var->format = variable_default_display (var);
811 if (varobj_value_is_changeable_p (var)
812 && var->value && !value_lazy (var->value))
814 xfree (var->print_value);
815 var->print_value = value_get_print_value (var->value, var->format, var);
821 enum varobj_display_formats
822 varobj_get_display_format (struct varobj *var)
828 varobj_get_display_hint (struct varobj *var)
833 struct cleanup *back_to = varobj_ensure_python_env (var);
835 if (var->pretty_printer)
836 result = gdbpy_get_display_hint (var->pretty_printer);
838 do_cleanups (back_to);
844 /* Return true if the varobj has items after TO, false otherwise. */
847 varobj_has_more (struct varobj *var, int to)
849 if (VEC_length (varobj_p, var->children) > to)
851 return ((to == -1 || VEC_length (varobj_p, var->children) == to)
852 && var->saved_item != NULL);
855 /* If the variable object is bound to a specific thread, that
856 is its evaluation can always be done in context of a frame
857 inside that thread, returns GDB id of the thread -- which
858 is always positive. Otherwise, returns -1. */
860 varobj_get_thread_id (struct varobj *var)
862 if (var->root->valid_block && var->root->thread_id > 0)
863 return var->root->thread_id;
869 varobj_set_frozen (struct varobj *var, int frozen)
871 /* When a variable is unfrozen, we don't fetch its value.
872 The 'not_fetched' flag remains set, so next -var-update
875 We don't fetch the value, because for structures the client
876 should do -var-update anyway. It would be bad to have different
877 client-size logic for structure and other types. */
878 var->frozen = frozen;
882 varobj_get_frozen (struct varobj *var)
887 /* A helper function that restricts a range to what is actually
888 available in a VEC. This follows the usual rules for the meaning
889 of FROM and TO -- if either is negative, the entire range is
893 restrict_range (VEC (varobj_p) *children, int *from, int *to)
895 if (*from < 0 || *to < 0)
898 *to = VEC_length (varobj_p, children);
902 if (*from > VEC_length (varobj_p, children))
903 *from = VEC_length (varobj_p, children);
904 if (*to > VEC_length (varobj_p, children))
905 *to = VEC_length (varobj_p, children);
913 /* A helper for update_dynamic_varobj_children that installs a new
914 child when needed. */
917 install_dynamic_child (struct varobj *var,
918 VEC (varobj_p) **changed,
919 VEC (varobj_p) **new,
920 VEC (varobj_p) **unchanged,
926 if (VEC_length (varobj_p, var->children) < index + 1)
928 /* There's no child yet. */
929 struct varobj *child = varobj_add_child (var, name, value);
933 VEC_safe_push (varobj_p, *new, child);
939 varobj_p existing = VEC_index (varobj_p, var->children, index);
941 if (install_new_value (existing, value, 0))
944 VEC_safe_push (varobj_p, *changed, existing);
947 VEC_safe_push (varobj_p, *unchanged, existing);
952 dynamic_varobj_has_child_method (struct varobj *var)
954 struct cleanup *back_to;
955 PyObject *printer = var->pretty_printer;
958 back_to = varobj_ensure_python_env (var);
959 result = PyObject_HasAttr (printer, gdbpy_children_cst);
960 do_cleanups (back_to);
967 update_dynamic_varobj_children (struct varobj *var,
968 VEC (varobj_p) **changed,
969 VEC (varobj_p) **new,
970 VEC (varobj_p) **unchanged,
977 struct cleanup *back_to;
980 PyObject *printer = var->pretty_printer;
982 back_to = varobj_ensure_python_env (var);
985 if (!PyObject_HasAttr (printer, gdbpy_children_cst))
987 do_cleanups (back_to);
991 if (update_children || !var->child_iter)
993 children = PyObject_CallMethodObjArgs (printer, gdbpy_children_cst,
998 gdbpy_print_stack ();
999 error (_("Null value returned for children"));
1002 make_cleanup_py_decref (children);
1004 if (!PyIter_Check (children))
1005 error (_("Returned value is not iterable"));
1007 Py_XDECREF (var->child_iter);
1008 var->child_iter = PyObject_GetIter (children);
1009 if (!var->child_iter)
1011 gdbpy_print_stack ();
1012 error (_("Could not get children iterator"));
1015 Py_XDECREF (var->saved_item);
1016 var->saved_item = NULL;
1021 i = VEC_length (varobj_p, var->children);
1023 /* We ask for one extra child, so that MI can report whether there
1024 are more children. */
1025 for (; to < 0 || i < to + 1; ++i)
1029 /* See if there was a leftover from last time. */
1030 if (var->saved_item)
1032 item = var->saved_item;
1033 var->saved_item = NULL;
1036 item = PyIter_Next (var->child_iter);
1041 /* We don't want to push the extra child on any report list. */
1042 if (to < 0 || i < to)
1047 struct cleanup *inner;
1048 int can_mention = from < 0 || i >= from;
1050 inner = make_cleanup_py_decref (item);
1052 if (!PyArg_ParseTuple (item, "sO", &name, &py_v))
1053 error (_("Invalid item from the child list"));
1055 v = convert_value_from_python (py_v);
1057 gdbpy_print_stack ();
1058 install_dynamic_child (var, can_mention ? changed : NULL,
1059 can_mention ? new : NULL,
1060 can_mention ? unchanged : NULL,
1061 can_mention ? cchanged : NULL, i, name, v);
1062 do_cleanups (inner);
1066 Py_XDECREF (var->saved_item);
1067 var->saved_item = item;
1069 /* We want to truncate the child list just before this
1075 if (i < VEC_length (varobj_p, var->children))
1080 for (j = i; j < VEC_length (varobj_p, var->children); ++j)
1081 varobj_delete (VEC_index (varobj_p, var->children, j), NULL, 0);
1082 VEC_truncate (varobj_p, var->children, i);
1085 /* If there are fewer children than requested, note that the list of
1086 children changed. */
1087 if (to >= 0 && VEC_length (varobj_p, var->children) < to)
1090 var->num_children = VEC_length (varobj_p, var->children);
1092 do_cleanups (back_to);
1096 gdb_assert (0 && "should never be called if Python is not enabled");
1101 varobj_get_num_children (struct varobj *var)
1103 if (var->num_children == -1)
1105 if (var->pretty_printer)
1109 /* If we have a dynamic varobj, don't report -1 children.
1110 So, try to fetch some children first. */
1111 update_dynamic_varobj_children (var, NULL, NULL, NULL, &dummy,
1115 var->num_children = number_of_children (var);
1118 return var->num_children >= 0 ? var->num_children : 0;
1121 /* Creates a list of the immediate children of a variable object;
1122 the return code is the number of such children or -1 on error */
1125 varobj_list_children (struct varobj *var, int *from, int *to)
1128 int i, children_changed;
1130 var->children_requested = 1;
1132 if (var->pretty_printer)
1134 /* This, in theory, can result in the number of children changing without
1135 frontend noticing. But well, calling -var-list-children on the same
1136 varobj twice is not something a sane frontend would do. */
1137 update_dynamic_varobj_children (var, NULL, NULL, NULL, &children_changed,
1139 restrict_range (var->children, from, to);
1140 return var->children;
1143 if (var->num_children == -1)
1144 var->num_children = number_of_children (var);
1146 /* If that failed, give up. */
1147 if (var->num_children == -1)
1148 return var->children;
1150 /* If we're called when the list of children is not yet initialized,
1151 allocate enough elements in it. */
1152 while (VEC_length (varobj_p, var->children) < var->num_children)
1153 VEC_safe_push (varobj_p, var->children, NULL);
1155 for (i = 0; i < var->num_children; i++)
1157 varobj_p existing = VEC_index (varobj_p, var->children, i);
1159 if (existing == NULL)
1161 /* Either it's the first call to varobj_list_children for
1162 this variable object, and the child was never created,
1163 or it was explicitly deleted by the client. */
1164 name = name_of_child (var, i);
1165 existing = create_child (var, i, name);
1166 VEC_replace (varobj_p, var->children, i, existing);
1170 restrict_range (var->children, from, to);
1171 return var->children;
1176 static struct varobj *
1177 varobj_add_child (struct varobj *var, const char *name, struct value *value)
1179 varobj_p v = create_child_with_value (var,
1180 VEC_length (varobj_p, var->children),
1183 VEC_safe_push (varobj_p, var->children, v);
1187 #endif /* HAVE_PYTHON */
1189 /* Obtain the type of an object Variable as a string similar to the one gdb
1190 prints on the console */
1193 varobj_get_type (struct varobj *var)
1195 /* For the "fake" variables, do not return a type. (It's type is
1197 Do not return a type for invalid variables as well. */
1198 if (CPLUS_FAKE_CHILD (var) || !var->root->is_valid)
1201 return type_to_string (var->type);
1204 /* Obtain the type of an object variable. */
1207 varobj_get_gdb_type (struct varobj *var)
1212 /* Return a pointer to the full rooted expression of varobj VAR.
1213 If it has not been computed yet, compute it. */
1215 varobj_get_path_expr (struct varobj *var)
1217 if (var->path_expr != NULL)
1218 return var->path_expr;
1221 /* For root varobjs, we initialize path_expr
1222 when creating varobj, so here it should be
1224 gdb_assert (!is_root_p (var));
1225 return (*var->root->lang->path_expr_of_child) (var);
1229 enum varobj_languages
1230 varobj_get_language (struct varobj *var)
1232 return variable_language (var);
1236 varobj_get_attributes (struct varobj *var)
1240 if (varobj_editable_p (var))
1241 /* FIXME: define masks for attributes */
1242 attributes |= 0x00000001; /* Editable */
1248 varobj_pretty_printed_p (struct varobj *var)
1250 return var->pretty_printer != NULL;
1254 varobj_get_formatted_value (struct varobj *var,
1255 enum varobj_display_formats format)
1257 return my_value_of_variable (var, format);
1261 varobj_get_value (struct varobj *var)
1263 return my_value_of_variable (var, var->format);
1266 /* Set the value of an object variable (if it is editable) to the
1267 value of the given expression */
1268 /* Note: Invokes functions that can call error() */
1271 varobj_set_value (struct varobj *var, char *expression)
1275 /* The argument "expression" contains the variable's new value.
1276 We need to first construct a legal expression for this -- ugh! */
1277 /* Does this cover all the bases? */
1278 struct expression *exp;
1279 struct value *value;
1280 int saved_input_radix = input_radix;
1281 char *s = expression;
1283 gdb_assert (varobj_editable_p (var));
1285 input_radix = 10; /* ALWAYS reset to decimal temporarily */
1286 exp = parse_exp_1 (&s, 0, 0);
1287 if (!gdb_evaluate_expression (exp, &value))
1289 /* We cannot proceed without a valid expression. */
1294 /* All types that are editable must also be changeable. */
1295 gdb_assert (varobj_value_is_changeable_p (var));
1297 /* The value of a changeable variable object must not be lazy. */
1298 gdb_assert (!value_lazy (var->value));
1300 /* Need to coerce the input. We want to check if the
1301 value of the variable object will be different
1302 after assignment, and the first thing value_assign
1303 does is coerce the input.
1304 For example, if we are assigning an array to a pointer variable we
1305 should compare the pointer with the the array's address, not with the
1307 value = coerce_array (value);
1309 /* The new value may be lazy. gdb_value_assign, or
1310 rather value_contents, will take care of this.
1311 If fetching of the new value will fail, gdb_value_assign
1312 with catch the exception. */
1313 if (!gdb_value_assign (var->value, value, &val))
1316 /* If the value has changed, record it, so that next -var-update can
1317 report this change. If a variable had a value of '1', we've set it
1318 to '333' and then set again to '1', when -var-update will report this
1319 variable as changed -- because the first assignment has set the
1320 'updated' flag. There's no need to optimize that, because return value
1321 of -var-update should be considered an approximation. */
1322 var->updated = install_new_value (var, val, 0 /* Compare values. */);
1323 input_radix = saved_input_radix;
1329 /* A helper function to install a constructor function and visualizer
1333 install_visualizer (struct varobj *var, PyObject *constructor,
1334 PyObject *visualizer)
1336 Py_XDECREF (var->constructor);
1337 var->constructor = constructor;
1339 Py_XDECREF (var->pretty_printer);
1340 var->pretty_printer = visualizer;
1342 Py_XDECREF (var->child_iter);
1343 var->child_iter = NULL;
1346 /* Install the default visualizer for VAR. */
1349 install_default_visualizer (struct varobj *var)
1351 if (pretty_printing)
1353 PyObject *pretty_printer = NULL;
1357 pretty_printer = gdbpy_get_varobj_pretty_printer (var->value);
1358 if (! pretty_printer)
1360 gdbpy_print_stack ();
1361 error (_("Cannot instantiate printer for default visualizer"));
1365 if (pretty_printer == Py_None)
1367 Py_DECREF (pretty_printer);
1368 pretty_printer = NULL;
1371 install_visualizer (var, NULL, pretty_printer);
1375 /* Instantiate and install a visualizer for VAR using CONSTRUCTOR to
1376 make a new object. */
1379 construct_visualizer (struct varobj *var, PyObject *constructor)
1381 PyObject *pretty_printer;
1383 Py_INCREF (constructor);
1384 if (constructor == Py_None)
1385 pretty_printer = NULL;
1388 pretty_printer = instantiate_pretty_printer (constructor, var->value);
1389 if (! pretty_printer)
1391 gdbpy_print_stack ();
1392 Py_DECREF (constructor);
1393 constructor = Py_None;
1394 Py_INCREF (constructor);
1397 if (pretty_printer == Py_None)
1399 Py_DECREF (pretty_printer);
1400 pretty_printer = NULL;
1404 install_visualizer (var, constructor, pretty_printer);
1407 #endif /* HAVE_PYTHON */
1409 /* A helper function for install_new_value. This creates and installs
1410 a visualizer for VAR, if appropriate. */
1413 install_new_value_visualizer (struct varobj *var)
1416 /* If the constructor is None, then we want the raw value. If VAR
1417 does not have a value, just skip this. */
1418 if (var->constructor != Py_None && var->value)
1420 struct cleanup *cleanup;
1422 cleanup = varobj_ensure_python_env (var);
1424 if (!var->constructor)
1425 install_default_visualizer (var);
1427 construct_visualizer (var, var->constructor);
1429 do_cleanups (cleanup);
1436 /* Assign a new value to a variable object. If INITIAL is non-zero,
1437 this is the first assignement after the variable object was just
1438 created, or changed type. In that case, just assign the value
1440 Otherwise, assign the new value, and return 1 if the value is different
1441 from the current one, 0 otherwise. The comparison is done on textual
1442 representation of value. Therefore, some types need not be compared. E.g.
1443 for structures the reported value is always "{...}", so no comparison is
1444 necessary here. If the old value was NULL and new one is not, or vice versa,
1447 The VALUE parameter should not be released -- the function will
1448 take care of releasing it when needed. */
1450 install_new_value (struct varobj *var, struct value *value, int initial)
1455 int intentionally_not_fetched = 0;
1456 char *print_value = NULL;
1458 /* We need to know the varobj's type to decide if the value should
1459 be fetched or not. C++ fake children (public/protected/private)
1460 don't have a type. */
1461 gdb_assert (var->type || CPLUS_FAKE_CHILD (var));
1462 changeable = varobj_value_is_changeable_p (var);
1464 /* If the type has custom visualizer, we consider it to be always
1465 changeable. FIXME: need to make sure this behaviour will not
1466 mess up read-sensitive values. */
1467 if (var->pretty_printer)
1470 need_to_fetch = changeable;
1472 /* We are not interested in the address of references, and given
1473 that in C++ a reference is not rebindable, it cannot
1474 meaningfully change. So, get hold of the real value. */
1476 value = coerce_ref (value);
1478 if (var->type && TYPE_CODE (var->type) == TYPE_CODE_UNION)
1479 /* For unions, we need to fetch the value implicitly because
1480 of implementation of union member fetch. When gdb
1481 creates a value for a field and the value of the enclosing
1482 structure is not lazy, it immediately copies the necessary
1483 bytes from the enclosing values. If the enclosing value is
1484 lazy, the call to value_fetch_lazy on the field will read
1485 the data from memory. For unions, that means we'll read the
1486 same memory more than once, which is not desirable. So
1490 /* The new value might be lazy. If the type is changeable,
1491 that is we'll be comparing values of this type, fetch the
1492 value now. Otherwise, on the next update the old value
1493 will be lazy, which means we've lost that old value. */
1494 if (need_to_fetch && value && value_lazy (value))
1496 struct varobj *parent = var->parent;
1497 int frozen = var->frozen;
1499 for (; !frozen && parent; parent = parent->parent)
1500 frozen |= parent->frozen;
1502 if (frozen && initial)
1504 /* For variables that are frozen, or are children of frozen
1505 variables, we don't do fetch on initial assignment.
1506 For non-initial assignemnt we do the fetch, since it means we're
1507 explicitly asked to compare the new value with the old one. */
1508 intentionally_not_fetched = 1;
1510 else if (!gdb_value_fetch_lazy (value))
1512 /* Set the value to NULL, so that for the next -var-update,
1513 we don't try to compare the new value with this value,
1514 that we couldn't even read. */
1520 /* Below, we'll be comparing string rendering of old and new
1521 values. Don't get string rendering if the value is
1522 lazy -- if it is, the code above has decided that the value
1523 should not be fetched. */
1524 if (value && !value_lazy (value) && !var->pretty_printer)
1525 print_value = value_get_print_value (value, var->format, var);
1527 /* If the type is changeable, compare the old and the new values.
1528 If this is the initial assignment, we don't have any old value
1530 if (!initial && changeable)
1532 /* If the value of the varobj was changed by -var-set-value,
1533 then the value in the varobj and in the target is the same.
1534 However, that value is different from the value that the
1535 varobj had after the previous -var-update. So need to the
1536 varobj as changed. */
1541 else if (! var->pretty_printer)
1543 /* Try to compare the values. That requires that both
1544 values are non-lazy. */
1545 if (var->not_fetched && value_lazy (var->value))
1547 /* This is a frozen varobj and the value was never read.
1548 Presumably, UI shows some "never read" indicator.
1549 Now that we've fetched the real value, we need to report
1550 this varobj as changed so that UI can show the real
1554 else if (var->value == NULL && value == NULL)
1557 else if (var->value == NULL || value == NULL)
1563 gdb_assert (!value_lazy (var->value));
1564 gdb_assert (!value_lazy (value));
1566 gdb_assert (var->print_value != NULL && print_value != NULL);
1567 if (strcmp (var->print_value, print_value) != 0)
1573 if (!initial && !changeable)
1575 /* For values that are not changeable, we don't compare the values.
1576 However, we want to notice if a value was not NULL and now is NULL,
1577 or vise versa, so that we report when top-level varobjs come in scope
1578 and leave the scope. */
1579 changed = (var->value != NULL) != (value != NULL);
1582 /* We must always keep the new value, since children depend on it. */
1583 if (var->value != NULL && var->value != value)
1584 value_free (var->value);
1587 value_incref (value);
1588 if (value && value_lazy (value) && intentionally_not_fetched)
1589 var->not_fetched = 1;
1591 var->not_fetched = 0;
1594 install_new_value_visualizer (var);
1596 /* If we installed a pretty-printer, re-compare the printed version
1597 to see if the variable changed. */
1598 if (var->pretty_printer)
1600 xfree (print_value);
1601 print_value = value_get_print_value (var->value, var->format, var);
1602 if ((var->print_value == NULL && print_value != NULL)
1603 || (var->print_value != NULL && print_value == NULL)
1604 || (var->print_value != NULL && print_value != NULL
1605 && strcmp (var->print_value, print_value) != 0))
1608 if (var->print_value)
1609 xfree (var->print_value);
1610 var->print_value = print_value;
1612 gdb_assert (!var->value || value_type (var->value));
1617 /* Return the requested range for a varobj. VAR is the varobj. FROM
1618 and TO are out parameters; *FROM and *TO will be set to the
1619 selected sub-range of VAR. If no range was selected using
1620 -var-set-update-range, then both will be -1. */
1622 varobj_get_child_range (struct varobj *var, int *from, int *to)
1628 /* Set the selected sub-range of children of VAR to start at index
1629 FROM and end at index TO. If either FROM or TO is less than zero,
1630 this is interpreted as a request for all children. */
1632 varobj_set_child_range (struct varobj *var, int from, int to)
1639 varobj_set_visualizer (struct varobj *var, const char *visualizer)
1642 PyObject *mainmod, *globals, *constructor;
1643 struct cleanup *back_to;
1645 back_to = varobj_ensure_python_env (var);
1647 mainmod = PyImport_AddModule ("__main__");
1648 globals = PyModule_GetDict (mainmod);
1649 Py_INCREF (globals);
1650 make_cleanup_py_decref (globals);
1652 constructor = PyRun_String (visualizer, Py_eval_input, globals, globals);
1656 gdbpy_print_stack ();
1657 error (_("Could not evaluate visualizer expression: %s"), visualizer);
1660 construct_visualizer (var, constructor);
1661 Py_XDECREF (constructor);
1663 /* If there are any children now, wipe them. */
1664 varobj_delete (var, NULL, 1 /* children only */);
1665 var->num_children = -1;
1667 do_cleanups (back_to);
1669 error (_("Python support required"));
1673 /* Update the values for a variable and its children. This is a
1674 two-pronged attack. First, re-parse the value for the root's
1675 expression to see if it's changed. Then go all the way
1676 through its children, reconstructing them and noting if they've
1679 The EXPLICIT parameter specifies if this call is result
1680 of MI request to update this specific variable, or
1681 result of implicit -var-update *. For implicit request, we don't
1682 update frozen variables.
1684 NOTE: This function may delete the caller's varobj. If it
1685 returns TYPE_CHANGED, then it has done this and VARP will be modified
1686 to point to the new varobj. */
1688 VEC(varobj_update_result) *varobj_update (struct varobj **varp, int explicit)
1691 int type_changed = 0;
1694 VEC (varobj_update_result) *stack = NULL;
1695 VEC (varobj_update_result) *result = NULL;
1697 /* Frozen means frozen -- we don't check for any change in
1698 this varobj, including its going out of scope, or
1699 changing type. One use case for frozen varobjs is
1700 retaining previously evaluated expressions, and we don't
1701 want them to be reevaluated at all. */
1702 if (!explicit && (*varp)->frozen)
1705 if (!(*varp)->root->is_valid)
1707 varobj_update_result r = {0};
1710 r.status = VAROBJ_INVALID;
1711 VEC_safe_push (varobj_update_result, result, &r);
1715 if ((*varp)->root->rootvar == *varp)
1717 varobj_update_result r = {0};
1720 r.status = VAROBJ_IN_SCOPE;
1722 /* Update the root variable. value_of_root can return NULL
1723 if the variable is no longer around, i.e. we stepped out of
1724 the frame in which a local existed. We are letting the
1725 value_of_root variable dispose of the varobj if the type
1727 new = value_of_root (varp, &type_changed);
1730 r.type_changed = type_changed;
1731 if (install_new_value ((*varp), new, type_changed))
1735 r.status = VAROBJ_NOT_IN_SCOPE;
1736 r.value_installed = 1;
1738 if (r.status == VAROBJ_NOT_IN_SCOPE)
1740 if (r.type_changed || r.changed)
1741 VEC_safe_push (varobj_update_result, result, &r);
1745 VEC_safe_push (varobj_update_result, stack, &r);
1749 varobj_update_result r = {0};
1752 VEC_safe_push (varobj_update_result, stack, &r);
1755 /* Walk through the children, reconstructing them all. */
1756 while (!VEC_empty (varobj_update_result, stack))
1758 varobj_update_result r = *(VEC_last (varobj_update_result, stack));
1759 struct varobj *v = r.varobj;
1761 VEC_pop (varobj_update_result, stack);
1763 /* Update this variable, unless it's a root, which is already
1765 if (!r.value_installed)
1767 new = value_of_child (v->parent, v->index);
1768 if (install_new_value (v, new, 0 /* type not changed */))
1775 /* We probably should not get children of a varobj that has a
1776 pretty-printer, but for which -var-list-children was never
1778 if (v->pretty_printer)
1780 VEC (varobj_p) *changed = 0, *new = 0, *unchanged = 0;
1781 int i, children_changed = 0;
1786 if (!v->children_requested)
1790 /* If we initially did not have potential children, but
1791 now we do, consider the varobj as changed.
1792 Otherwise, if children were never requested, consider
1793 it as unchanged -- presumably, such varobj is not yet
1794 expanded in the UI, so we need not bother getting
1796 if (!varobj_has_more (v, 0))
1798 update_dynamic_varobj_children (v, NULL, NULL, NULL,
1800 if (varobj_has_more (v, 0))
1805 VEC_safe_push (varobj_update_result, result, &r);
1810 /* If update_dynamic_varobj_children returns 0, then we have
1811 a non-conforming pretty-printer, so we skip it. */
1812 if (update_dynamic_varobj_children (v, &changed, &new, &unchanged,
1813 &children_changed, 1,
1816 if (children_changed || new)
1818 r.children_changed = 1;
1821 /* Push in reverse order so that the first child is
1822 popped from the work stack first, and so will be
1823 added to result first. This does not affect
1824 correctness, just "nicer". */
1825 for (i = VEC_length (varobj_p, changed) - 1; i >= 0; --i)
1827 varobj_p tmp = VEC_index (varobj_p, changed, i);
1828 varobj_update_result r = {0};
1832 r.value_installed = 1;
1833 VEC_safe_push (varobj_update_result, stack, &r);
1835 for (i = VEC_length (varobj_p, unchanged) - 1; i >= 0; --i)
1837 varobj_p tmp = VEC_index (varobj_p, unchanged, i);
1841 varobj_update_result r = {0};
1844 r.value_installed = 1;
1845 VEC_safe_push (varobj_update_result, stack, &r);
1848 if (r.changed || r.children_changed)
1849 VEC_safe_push (varobj_update_result, result, &r);
1851 /* Free CHANGED and UNCHANGED, but not NEW, because NEW
1852 has been put into the result vector. */
1853 VEC_free (varobj_p, changed);
1854 VEC_free (varobj_p, unchanged);
1860 /* Push any children. Use reverse order so that the first
1861 child is popped from the work stack first, and so
1862 will be added to result first. This does not
1863 affect correctness, just "nicer". */
1864 for (i = VEC_length (varobj_p, v->children)-1; i >= 0; --i)
1866 varobj_p c = VEC_index (varobj_p, v->children, i);
1868 /* Child may be NULL if explicitly deleted by -var-delete. */
1869 if (c != NULL && !c->frozen)
1871 varobj_update_result r = {0};
1874 VEC_safe_push (varobj_update_result, stack, &r);
1878 if (r.changed || r.type_changed)
1879 VEC_safe_push (varobj_update_result, result, &r);
1882 VEC_free (varobj_update_result, stack);
1888 /* Helper functions */
1891 * Variable object construction/destruction
1895 delete_variable (struct cpstack **resultp, struct varobj *var,
1896 int only_children_p)
1900 delete_variable_1 (resultp, &delcount, var,
1901 only_children_p, 1 /* remove_from_parent_p */ );
1906 /* Delete the variable object VAR and its children */
1907 /* IMPORTANT NOTE: If we delete a variable which is a child
1908 and the parent is not removed we dump core. It must be always
1909 initially called with remove_from_parent_p set */
1911 delete_variable_1 (struct cpstack **resultp, int *delcountp,
1912 struct varobj *var, int only_children_p,
1913 int remove_from_parent_p)
1917 /* Delete any children of this variable, too. */
1918 for (i = 0; i < VEC_length (varobj_p, var->children); ++i)
1920 varobj_p child = VEC_index (varobj_p, var->children, i);
1924 if (!remove_from_parent_p)
1925 child->parent = NULL;
1926 delete_variable_1 (resultp, delcountp, child, 0, only_children_p);
1928 VEC_free (varobj_p, var->children);
1930 /* if we were called to delete only the children we are done here */
1931 if (only_children_p)
1934 /* Otherwise, add it to the list of deleted ones and proceed to do so */
1935 /* If the name is null, this is a temporary variable, that has not
1936 yet been installed, don't report it, it belongs to the caller... */
1937 if (var->obj_name != NULL)
1939 cppush (resultp, xstrdup (var->obj_name));
1940 *delcountp = *delcountp + 1;
1943 /* If this variable has a parent, remove it from its parent's list */
1944 /* OPTIMIZATION: if the parent of this variable is also being deleted,
1945 (as indicated by remove_from_parent_p) we don't bother doing an
1946 expensive list search to find the element to remove when we are
1947 discarding the list afterwards */
1948 if ((remove_from_parent_p) && (var->parent != NULL))
1950 VEC_replace (varobj_p, var->parent->children, var->index, NULL);
1953 if (var->obj_name != NULL)
1954 uninstall_variable (var);
1956 /* Free memory associated with this variable */
1957 free_variable (var);
1960 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
1962 install_variable (struct varobj *var)
1965 struct vlist *newvl;
1967 unsigned int index = 0;
1970 for (chp = var->obj_name; *chp; chp++)
1972 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
1975 cv = *(varobj_table + index);
1976 while ((cv != NULL) && (strcmp (cv->var->obj_name, var->obj_name) != 0))
1980 error (_("Duplicate variable object name"));
1982 /* Add varobj to hash table */
1983 newvl = xmalloc (sizeof (struct vlist));
1984 newvl->next = *(varobj_table + index);
1986 *(varobj_table + index) = newvl;
1988 /* If root, add varobj to root list */
1989 if (is_root_p (var))
1991 /* Add to list of root variables */
1992 if (rootlist == NULL)
1993 var->root->next = NULL;
1995 var->root->next = rootlist;
1996 rootlist = var->root;
2002 /* Unistall the object VAR. */
2004 uninstall_variable (struct varobj *var)
2008 struct varobj_root *cr;
2009 struct varobj_root *prer;
2011 unsigned int index = 0;
2014 /* Remove varobj from hash table */
2015 for (chp = var->obj_name; *chp; chp++)
2017 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
2020 cv = *(varobj_table + index);
2022 while ((cv != NULL) && (strcmp (cv->var->obj_name, var->obj_name) != 0))
2029 fprintf_unfiltered (gdb_stdlog, "Deleting %s\n", var->obj_name);
2034 ("Assertion failed: Could not find variable object \"%s\" to delete",
2040 *(varobj_table + index) = cv->next;
2042 prev->next = cv->next;
2046 /* If root, remove varobj from root list */
2047 if (is_root_p (var))
2049 /* Remove from list of root variables */
2050 if (rootlist == var->root)
2051 rootlist = var->root->next;
2056 while ((cr != NULL) && (cr->rootvar != var))
2063 warning ("Assertion failed: Could not find "
2064 "varobj \"%s\" in root list",
2071 prer->next = cr->next;
2077 /* Create and install a child of the parent of the given name */
2078 static struct varobj *
2079 create_child (struct varobj *parent, int index, char *name)
2081 return create_child_with_value (parent, index, name,
2082 value_of_child (parent, index));
2085 static struct varobj *
2086 create_child_with_value (struct varobj *parent, int index, const char *name,
2087 struct value *value)
2089 struct varobj *child;
2092 child = new_variable ();
2094 /* name is allocated by name_of_child */
2095 /* FIXME: xstrdup should not be here. */
2096 child->name = xstrdup (name);
2097 child->index = index;
2098 child->parent = parent;
2099 child->root = parent->root;
2100 childs_name = xstrprintf ("%s.%s", parent->obj_name, name);
2101 child->obj_name = childs_name;
2102 install_variable (child);
2104 /* Compute the type of the child. Must do this before
2105 calling install_new_value. */
2107 /* If the child had no evaluation errors, var->value
2108 will be non-NULL and contain a valid type. */
2109 child->type = value_type (value);
2111 /* Otherwise, we must compute the type. */
2112 child->type = (*child->root->lang->type_of_child) (child->parent,
2114 install_new_value (child, value, 1);
2121 * Miscellaneous utility functions.
2124 /* Allocate memory and initialize a new variable */
2125 static struct varobj *
2130 var = (struct varobj *) xmalloc (sizeof (struct varobj));
2132 var->path_expr = NULL;
2133 var->obj_name = NULL;
2137 var->num_children = -1;
2139 var->children = NULL;
2143 var->print_value = NULL;
2145 var->not_fetched = 0;
2146 var->children_requested = 0;
2149 var->constructor = 0;
2150 var->pretty_printer = 0;
2151 var->child_iter = 0;
2152 var->saved_item = 0;
2157 /* Allocate memory and initialize a new root variable */
2158 static struct varobj *
2159 new_root_variable (void)
2161 struct varobj *var = new_variable ();
2163 var->root = (struct varobj_root *) xmalloc (sizeof (struct varobj_root));
2164 var->root->lang = NULL;
2165 var->root->exp = NULL;
2166 var->root->valid_block = NULL;
2167 var->root->frame = null_frame_id;
2168 var->root->floating = 0;
2169 var->root->rootvar = NULL;
2170 var->root->is_valid = 1;
2175 /* Free any allocated memory associated with VAR. */
2177 free_variable (struct varobj *var)
2180 if (var->pretty_printer)
2182 struct cleanup *cleanup = varobj_ensure_python_env (var);
2183 Py_XDECREF (var->constructor);
2184 Py_XDECREF (var->pretty_printer);
2185 Py_XDECREF (var->child_iter);
2186 Py_XDECREF (var->saved_item);
2187 do_cleanups (cleanup);
2191 value_free (var->value);
2193 /* Free the expression if this is a root variable. */
2194 if (is_root_p (var))
2196 xfree (var->root->exp);
2201 xfree (var->obj_name);
2202 xfree (var->print_value);
2203 xfree (var->path_expr);
2208 do_free_variable_cleanup (void *var)
2210 free_variable (var);
2213 static struct cleanup *
2214 make_cleanup_free_variable (struct varobj *var)
2216 return make_cleanup (do_free_variable_cleanup, var);
2219 /* This returns the type of the variable. It also skips past typedefs
2220 to return the real type of the variable.
2222 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
2223 except within get_target_type and get_type. */
2224 static struct type *
2225 get_type (struct varobj *var)
2231 type = check_typedef (type);
2236 /* Return the type of the value that's stored in VAR,
2237 or that would have being stored there if the
2238 value were accessible.
2240 This differs from VAR->type in that VAR->type is always
2241 the true type of the expession in the source language.
2242 The return value of this function is the type we're
2243 actually storing in varobj, and using for displaying
2244 the values and for comparing previous and new values.
2246 For example, top-level references are always stripped. */
2247 static struct type *
2248 get_value_type (struct varobj *var)
2253 type = value_type (var->value);
2257 type = check_typedef (type);
2259 if (TYPE_CODE (type) == TYPE_CODE_REF)
2260 type = get_target_type (type);
2262 type = check_typedef (type);
2267 /* This returns the target type (or NULL) of TYPE, also skipping
2268 past typedefs, just like get_type ().
2270 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
2271 except within get_target_type and get_type. */
2272 static struct type *
2273 get_target_type (struct type *type)
2277 type = TYPE_TARGET_TYPE (type);
2279 type = check_typedef (type);
2285 /* What is the default display for this variable? We assume that
2286 everything is "natural". Any exceptions? */
2287 static enum varobj_display_formats
2288 variable_default_display (struct varobj *var)
2290 return FORMAT_NATURAL;
2293 /* FIXME: The following should be generic for any pointer */
2295 cppush (struct cpstack **pstack, char *name)
2299 s = (struct cpstack *) xmalloc (sizeof (struct cpstack));
2305 /* FIXME: The following should be generic for any pointer */
2307 cppop (struct cpstack **pstack)
2312 if ((*pstack)->name == NULL && (*pstack)->next == NULL)
2317 *pstack = (*pstack)->next;
2324 * Language-dependencies
2327 /* Common entry points */
2329 /* Get the language of variable VAR. */
2330 static enum varobj_languages
2331 variable_language (struct varobj *var)
2333 enum varobj_languages lang;
2335 switch (var->root->exp->language_defn->la_language)
2341 case language_cplus:
2352 /* Return the number of children for a given variable.
2353 The result of this function is defined by the language
2354 implementation. The number of children returned by this function
2355 is the number of children that the user will see in the variable
2358 number_of_children (struct varobj *var)
2360 return (*var->root->lang->number_of_children) (var);;
2363 /* What is the expression for the root varobj VAR? Returns a malloc'd
2366 name_of_variable (struct varobj *var)
2368 return (*var->root->lang->name_of_variable) (var);
2371 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd
2374 name_of_child (struct varobj *var, int index)
2376 return (*var->root->lang->name_of_child) (var, index);
2379 /* What is the ``struct value *'' of the root variable VAR?
2380 For floating variable object, evaluation can get us a value
2381 of different type from what is stored in varobj already. In
2383 - *type_changed will be set to 1
2384 - old varobj will be freed, and new one will be
2385 created, with the same name.
2386 - *var_handle will be set to the new varobj
2387 Otherwise, *type_changed will be set to 0. */
2388 static struct value *
2389 value_of_root (struct varobj **var_handle, int *type_changed)
2393 if (var_handle == NULL)
2398 /* This should really be an exception, since this should
2399 only get called with a root variable. */
2401 if (!is_root_p (var))
2404 if (var->root->floating)
2406 struct varobj *tmp_var;
2407 char *old_type, *new_type;
2409 tmp_var = varobj_create (NULL, var->name, (CORE_ADDR) 0,
2410 USE_SELECTED_FRAME);
2411 if (tmp_var == NULL)
2415 old_type = varobj_get_type (var);
2416 new_type = varobj_get_type (tmp_var);
2417 if (strcmp (old_type, new_type) == 0)
2419 /* The expression presently stored inside var->root->exp
2420 remembers the locations of local variables relatively to
2421 the frame where the expression was created (in DWARF location
2422 button, for example). Naturally, those locations are not
2423 correct in other frames, so update the expression. */
2425 struct expression *tmp_exp = var->root->exp;
2427 var->root->exp = tmp_var->root->exp;
2428 tmp_var->root->exp = tmp_exp;
2430 varobj_delete (tmp_var, NULL, 0);
2435 tmp_var->obj_name = xstrdup (var->obj_name);
2436 tmp_var->from = var->from;
2437 tmp_var->to = var->to;
2438 varobj_delete (var, NULL, 0);
2440 install_variable (tmp_var);
2441 *var_handle = tmp_var;
2453 return (*var->root->lang->value_of_root) (var_handle);
2456 /* What is the ``struct value *'' for the INDEX'th child of PARENT? */
2457 static struct value *
2458 value_of_child (struct varobj *parent, int index)
2460 struct value *value;
2462 value = (*parent->root->lang->value_of_child) (parent, index);
2467 /* GDB already has a command called "value_of_variable". Sigh. */
2469 my_value_of_variable (struct varobj *var, enum varobj_display_formats format)
2471 if (var->root->is_valid)
2473 if (var->pretty_printer)
2474 return value_get_print_value (var->value, var->format, var);
2475 return (*var->root->lang->value_of_variable) (var, format);
2482 value_get_print_value (struct value *value, enum varobj_display_formats format,
2485 struct ui_file *stb;
2486 struct cleanup *old_chain;
2487 gdb_byte *thevalue = NULL;
2488 struct value_print_options opts;
2489 struct type *type = NULL;
2491 char *encoding = NULL;
2492 struct gdbarch *gdbarch = NULL;
2493 /* Initialize it just to avoid a GCC false warning. */
2494 CORE_ADDR str_addr = 0;
2495 int string_print = 0;
2500 stb = mem_fileopen ();
2501 old_chain = make_cleanup_ui_file_delete (stb);
2503 gdbarch = get_type_arch (value_type (value));
2506 PyObject *value_formatter = var->pretty_printer;
2508 varobj_ensure_python_env (var);
2510 if (value_formatter)
2512 /* First check to see if we have any children at all. If so,
2513 we simply return {...}. */
2514 if (dynamic_varobj_has_child_method (var))
2516 do_cleanups (old_chain);
2517 return xstrdup ("{...}");
2520 if (PyObject_HasAttr (value_formatter, gdbpy_to_string_cst))
2523 struct value *replacement;
2524 PyObject *output = NULL;
2526 hint = gdbpy_get_display_hint (value_formatter);
2529 if (!strcmp (hint, "string"))
2534 output = apply_varobj_pretty_printer (value_formatter,
2539 make_cleanup_py_decref (output);
2541 if (gdbpy_is_lazy_string (output))
2543 gdbpy_extract_lazy_string (output, &str_addr, &type,
2545 make_cleanup (free_current_contents, &encoding);
2551 = python_string_to_target_python_string (output);
2555 char *s = PyString_AsString (py_str);
2557 len = PyString_Size (py_str);
2558 thevalue = xmemdup (s, len + 1, len + 1);
2559 type = builtin_type (gdbarch)->builtin_char;
2564 do_cleanups (old_chain);
2568 make_cleanup (xfree, thevalue);
2571 gdbpy_print_stack ();
2575 value = replacement;
2581 get_formatted_print_options (&opts, format_code[(int) format]);
2585 LA_PRINT_STRING (stb, type, thevalue, len, encoding, 0, &opts);
2586 else if (string_print)
2587 val_print_string (type, encoding, str_addr, len, stb, &opts);
2589 common_val_print (value, stb, 0, &opts, current_language);
2590 thevalue = ui_file_xstrdup (stb, NULL);
2592 do_cleanups (old_chain);
2597 varobj_editable_p (struct varobj *var)
2601 if (!(var->root->is_valid && var->value && VALUE_LVAL (var->value)))
2604 type = get_value_type (var);
2606 switch (TYPE_CODE (type))
2608 case TYPE_CODE_STRUCT:
2609 case TYPE_CODE_UNION:
2610 case TYPE_CODE_ARRAY:
2611 case TYPE_CODE_FUNC:
2612 case TYPE_CODE_METHOD:
2622 /* Return non-zero if changes in value of VAR
2623 must be detected and reported by -var-update.
2624 Return zero is -var-update should never report
2625 changes of such values. This makes sense for structures
2626 (since the changes in children values will be reported separately),
2627 or for artifical objects (like 'public' pseudo-field in C++).
2629 Return value of 0 means that gdb need not call value_fetch_lazy
2630 for the value of this variable object. */
2632 varobj_value_is_changeable_p (struct varobj *var)
2637 if (CPLUS_FAKE_CHILD (var))
2640 type = get_value_type (var);
2642 switch (TYPE_CODE (type))
2644 case TYPE_CODE_STRUCT:
2645 case TYPE_CODE_UNION:
2646 case TYPE_CODE_ARRAY:
2657 /* Return 1 if that varobj is floating, that is is always evaluated in the
2658 selected frame, and not bound to thread/frame. Such variable objects
2659 are created using '@' as frame specifier to -var-create. */
2661 varobj_floating_p (struct varobj *var)
2663 return var->root->floating;
2666 /* Given the value and the type of a variable object,
2667 adjust the value and type to those necessary
2668 for getting children of the variable object.
2669 This includes dereferencing top-level references
2670 to all types and dereferencing pointers to
2673 Both TYPE and *TYPE should be non-null. VALUE
2674 can be null if we want to only translate type.
2675 *VALUE can be null as well -- if the parent
2678 If WAS_PTR is not NULL, set *WAS_PTR to 0 or 1
2679 depending on whether pointer was dereferenced
2680 in this function. */
2682 adjust_value_for_child_access (struct value **value,
2686 gdb_assert (type && *type);
2691 *type = check_typedef (*type);
2693 /* The type of value stored in varobj, that is passed
2694 to us, is already supposed to be
2695 reference-stripped. */
2697 gdb_assert (TYPE_CODE (*type) != TYPE_CODE_REF);
2699 /* Pointers to structures are treated just like
2700 structures when accessing children. Don't
2701 dererences pointers to other types. */
2702 if (TYPE_CODE (*type) == TYPE_CODE_PTR)
2704 struct type *target_type = get_target_type (*type);
2705 if (TYPE_CODE (target_type) == TYPE_CODE_STRUCT
2706 || TYPE_CODE (target_type) == TYPE_CODE_UNION)
2708 if (value && *value)
2710 int success = gdb_value_ind (*value, value);
2715 *type = target_type;
2721 /* The 'get_target_type' function calls check_typedef on
2722 result, so we can immediately check type code. No
2723 need to call check_typedef here. */
2728 c_number_of_children (struct varobj *var)
2730 struct type *type = get_value_type (var);
2732 struct type *target;
2734 adjust_value_for_child_access (NULL, &type, NULL);
2735 target = get_target_type (type);
2737 switch (TYPE_CODE (type))
2739 case TYPE_CODE_ARRAY:
2740 if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (target) > 0
2741 && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))
2742 children = TYPE_LENGTH (type) / TYPE_LENGTH (target);
2744 /* If we don't know how many elements there are, don't display
2749 case TYPE_CODE_STRUCT:
2750 case TYPE_CODE_UNION:
2751 children = TYPE_NFIELDS (type);
2755 /* The type here is a pointer to non-struct. Typically, pointers
2756 have one child, except for function ptrs, which have no children,
2757 and except for void*, as we don't know what to show.
2759 We can show char* so we allow it to be dereferenced. If you decide
2760 to test for it, please mind that a little magic is necessary to
2761 properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
2762 TYPE_NAME == "char" */
2763 if (TYPE_CODE (target) == TYPE_CODE_FUNC
2764 || TYPE_CODE (target) == TYPE_CODE_VOID)
2771 /* Other types have no children */
2779 c_name_of_variable (struct varobj *parent)
2781 return xstrdup (parent->name);
2784 /* Return the value of element TYPE_INDEX of a structure
2785 value VALUE. VALUE's type should be a structure,
2786 or union, or a typedef to struct/union.
2788 Returns NULL if getting the value fails. Never throws. */
2789 static struct value *
2790 value_struct_element_index (struct value *value, int type_index)
2792 struct value *result = NULL;
2793 volatile struct gdb_exception e;
2794 struct type *type = value_type (value);
2796 type = check_typedef (type);
2798 gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
2799 || TYPE_CODE (type) == TYPE_CODE_UNION);
2801 TRY_CATCH (e, RETURN_MASK_ERROR)
2803 if (field_is_static (&TYPE_FIELD (type, type_index)))
2804 result = value_static_field (type, type_index);
2806 result = value_primitive_field (value, 0, type_index, type);
2818 /* Obtain the information about child INDEX of the variable
2820 If CNAME is not null, sets *CNAME to the name of the child relative
2822 If CVALUE is not null, sets *CVALUE to the value of the child.
2823 If CTYPE is not null, sets *CTYPE to the type of the child.
2825 If any of CNAME, CVALUE, or CTYPE is not null, but the corresponding
2826 information cannot be determined, set *CNAME, *CVALUE, or *CTYPE
2829 c_describe_child (struct varobj *parent, int index,
2830 char **cname, struct value **cvalue, struct type **ctype,
2831 char **cfull_expression)
2833 struct value *value = parent->value;
2834 struct type *type = get_value_type (parent);
2835 char *parent_expression = NULL;
2844 if (cfull_expression)
2846 *cfull_expression = NULL;
2847 parent_expression = varobj_get_path_expr (parent);
2849 adjust_value_for_child_access (&value, &type, &was_ptr);
2851 switch (TYPE_CODE (type))
2853 case TYPE_CODE_ARRAY:
2856 = xstrdup (int_string (index
2857 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)),
2860 if (cvalue && value)
2862 int real_index = index + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type));
2864 gdb_value_subscript (value, real_index, cvalue);
2868 *ctype = get_target_type (type);
2870 if (cfull_expression)
2872 xstrprintf ("(%s)[%s]", parent_expression,
2874 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)),
2880 case TYPE_CODE_STRUCT:
2881 case TYPE_CODE_UNION:
2883 *cname = xstrdup (TYPE_FIELD_NAME (type, index));
2885 if (cvalue && value)
2887 /* For C, varobj index is the same as type index. */
2888 *cvalue = value_struct_element_index (value, index);
2892 *ctype = TYPE_FIELD_TYPE (type, index);
2894 if (cfull_expression)
2896 char *join = was_ptr ? "->" : ".";
2898 *cfull_expression = xstrprintf ("(%s)%s%s", parent_expression, join,
2899 TYPE_FIELD_NAME (type, index));
2906 *cname = xstrprintf ("*%s", parent->name);
2908 if (cvalue && value)
2910 int success = gdb_value_ind (value, cvalue);
2916 /* Don't use get_target_type because it calls
2917 check_typedef and here, we want to show the true
2918 declared type of the variable. */
2920 *ctype = TYPE_TARGET_TYPE (type);
2922 if (cfull_expression)
2923 *cfull_expression = xstrprintf ("*(%s)", parent_expression);
2928 /* This should not happen */
2930 *cname = xstrdup ("???");
2931 if (cfull_expression)
2932 *cfull_expression = xstrdup ("???");
2933 /* Don't set value and type, we don't know then. */
2938 c_name_of_child (struct varobj *parent, int index)
2942 c_describe_child (parent, index, &name, NULL, NULL, NULL);
2947 c_path_expr_of_child (struct varobj *child)
2949 c_describe_child (child->parent, child->index, NULL, NULL, NULL,
2951 return child->path_expr;
2954 /* If frame associated with VAR can be found, switch
2955 to it and return 1. Otherwise, return 0. */
2957 check_scope (struct varobj *var)
2959 struct frame_info *fi;
2962 fi = frame_find_by_id (var->root->frame);
2967 CORE_ADDR pc = get_frame_pc (fi);
2969 if (pc < BLOCK_START (var->root->valid_block) ||
2970 pc >= BLOCK_END (var->root->valid_block))
2978 static struct value *
2979 c_value_of_root (struct varobj **var_handle)
2981 struct value *new_val = NULL;
2982 struct varobj *var = *var_handle;
2983 int within_scope = 0;
2984 struct cleanup *back_to;
2986 /* Only root variables can be updated... */
2987 if (!is_root_p (var))
2988 /* Not a root var */
2991 back_to = make_cleanup_restore_current_thread ();
2993 /* Determine whether the variable is still around. */
2994 if (var->root->valid_block == NULL || var->root->floating)
2996 else if (var->root->thread_id == 0)
2998 /* The program was single-threaded when the variable object was
2999 created. Technically, it's possible that the program became
3000 multi-threaded since then, but we don't support such
3002 within_scope = check_scope (var);
3006 ptid_t ptid = thread_id_to_pid (var->root->thread_id);
3007 if (in_thread_list (ptid))
3009 switch_to_thread (ptid);
3010 within_scope = check_scope (var);
3016 /* We need to catch errors here, because if evaluate
3017 expression fails we want to just return NULL. */
3018 gdb_evaluate_expression (var->root->exp, &new_val);
3022 do_cleanups (back_to);
3027 static struct value *
3028 c_value_of_child (struct varobj *parent, int index)
3030 struct value *value = NULL;
3032 c_describe_child (parent, index, NULL, &value, NULL, NULL);
3036 static struct type *
3037 c_type_of_child (struct varobj *parent, int index)
3039 struct type *type = NULL;
3041 c_describe_child (parent, index, NULL, NULL, &type, NULL);
3046 c_value_of_variable (struct varobj *var, enum varobj_display_formats format)
3048 /* BOGUS: if val_print sees a struct/class, or a reference to one,
3049 it will print out its children instead of "{...}". So we need to
3050 catch that case explicitly. */
3051 struct type *type = get_type (var);
3053 /* If we have a custom formatter, return whatever string it has
3055 if (var->pretty_printer && var->print_value)
3056 return xstrdup (var->print_value);
3058 /* Strip top-level references. */
3059 while (TYPE_CODE (type) == TYPE_CODE_REF)
3060 type = check_typedef (TYPE_TARGET_TYPE (type));
3062 switch (TYPE_CODE (type))
3064 case TYPE_CODE_STRUCT:
3065 case TYPE_CODE_UNION:
3066 return xstrdup ("{...}");
3069 case TYPE_CODE_ARRAY:
3073 number = xstrprintf ("[%d]", var->num_children);
3080 if (var->value == NULL)
3082 /* This can happen if we attempt to get the value of a struct
3083 member when the parent is an invalid pointer. This is an
3084 error condition, so we should tell the caller. */
3089 if (var->not_fetched && value_lazy (var->value))
3090 /* Frozen variable and no value yet. We don't
3091 implicitly fetch the value. MI response will
3092 use empty string for the value, which is OK. */
3095 gdb_assert (varobj_value_is_changeable_p (var));
3096 gdb_assert (!value_lazy (var->value));
3098 /* If the specified format is the current one,
3099 we can reuse print_value */
3100 if (format == var->format)
3101 return xstrdup (var->print_value);
3103 return value_get_print_value (var->value, format, var);
3113 cplus_number_of_children (struct varobj *var)
3116 int children, dont_know;
3121 if (!CPLUS_FAKE_CHILD (var))
3123 type = get_value_type (var);
3124 adjust_value_for_child_access (NULL, &type, NULL);
3126 if (((TYPE_CODE (type)) == TYPE_CODE_STRUCT) ||
3127 ((TYPE_CODE (type)) == TYPE_CODE_UNION))
3131 cplus_class_num_children (type, kids);
3132 if (kids[v_public] != 0)
3134 if (kids[v_private] != 0)
3136 if (kids[v_protected] != 0)
3139 /* Add any baseclasses */
3140 children += TYPE_N_BASECLASSES (type);
3143 /* FIXME: save children in var */
3150 type = get_value_type (var->parent);
3151 adjust_value_for_child_access (NULL, &type, NULL);
3153 cplus_class_num_children (type, kids);
3154 if (strcmp (var->name, "public") == 0)
3155 children = kids[v_public];
3156 else if (strcmp (var->name, "private") == 0)
3157 children = kids[v_private];
3159 children = kids[v_protected];
3164 children = c_number_of_children (var);
3169 /* Compute # of public, private, and protected variables in this class.
3170 That means we need to descend into all baseclasses and find out
3171 how many are there, too. */
3173 cplus_class_num_children (struct type *type, int children[3])
3175 int i, vptr_fieldno;
3176 struct type *basetype = NULL;
3178 children[v_public] = 0;
3179 children[v_private] = 0;
3180 children[v_protected] = 0;
3182 vptr_fieldno = get_vptr_fieldno (type, &basetype);
3183 for (i = TYPE_N_BASECLASSES (type); i < TYPE_NFIELDS (type); i++)
3185 /* If we have a virtual table pointer, omit it. Even if virtual
3186 table pointers are not specifically marked in the debug info,
3187 they should be artificial. */
3188 if ((type == basetype && i == vptr_fieldno)
3189 || TYPE_FIELD_ARTIFICIAL (type, i))
3192 if (TYPE_FIELD_PROTECTED (type, i))
3193 children[v_protected]++;
3194 else if (TYPE_FIELD_PRIVATE (type, i))
3195 children[v_private]++;
3197 children[v_public]++;
3202 cplus_name_of_variable (struct varobj *parent)
3204 return c_name_of_variable (parent);
3207 enum accessibility { private_field, protected_field, public_field };
3209 /* Check if field INDEX of TYPE has the specified accessibility.
3210 Return 0 if so and 1 otherwise. */
3212 match_accessibility (struct type *type, int index, enum accessibility acc)
3214 if (acc == private_field && TYPE_FIELD_PRIVATE (type, index))
3216 else if (acc == protected_field && TYPE_FIELD_PROTECTED (type, index))
3218 else if (acc == public_field && !TYPE_FIELD_PRIVATE (type, index)
3219 && !TYPE_FIELD_PROTECTED (type, index))
3226 cplus_describe_child (struct varobj *parent, int index,
3227 char **cname, struct value **cvalue, struct type **ctype,
3228 char **cfull_expression)
3230 struct value *value;
3233 char *parent_expression = NULL;
3241 if (cfull_expression)
3242 *cfull_expression = NULL;
3244 if (CPLUS_FAKE_CHILD (parent))
3246 value = parent->parent->value;
3247 type = get_value_type (parent->parent);
3248 if (cfull_expression)
3249 parent_expression = varobj_get_path_expr (parent->parent);
3253 value = parent->value;
3254 type = get_value_type (parent);
3255 if (cfull_expression)
3256 parent_expression = varobj_get_path_expr (parent);
3259 adjust_value_for_child_access (&value, &type, &was_ptr);
3261 if (TYPE_CODE (type) == TYPE_CODE_STRUCT
3262 || TYPE_CODE (type) == TYPE_CODE_UNION)
3264 char *join = was_ptr ? "->" : ".";
3266 if (CPLUS_FAKE_CHILD (parent))
3268 /* The fields of the class type are ordered as they
3269 appear in the class. We are given an index for a
3270 particular access control type ("public","protected",
3271 or "private"). We must skip over fields that don't
3272 have the access control we are looking for to properly
3273 find the indexed field. */
3274 int type_index = TYPE_N_BASECLASSES (type);
3275 enum accessibility acc = public_field;
3277 struct type *basetype = NULL;
3279 vptr_fieldno = get_vptr_fieldno (type, &basetype);
3280 if (strcmp (parent->name, "private") == 0)
3281 acc = private_field;
3282 else if (strcmp (parent->name, "protected") == 0)
3283 acc = protected_field;
3287 if ((type == basetype && type_index == vptr_fieldno)
3288 || TYPE_FIELD_ARTIFICIAL (type, type_index))
3290 else if (match_accessibility (type, type_index, acc))
3297 *cname = xstrdup (TYPE_FIELD_NAME (type, type_index));
3299 if (cvalue && value)
3300 *cvalue = value_struct_element_index (value, type_index);
3303 *ctype = TYPE_FIELD_TYPE (type, type_index);
3305 if (cfull_expression)
3307 = xstrprintf ("((%s)%s%s)", parent_expression,
3309 TYPE_FIELD_NAME (type, type_index));
3311 else if (index < TYPE_N_BASECLASSES (type))
3313 /* This is a baseclass. */
3315 *cname = xstrdup (TYPE_FIELD_NAME (type, index));
3317 if (cvalue && value)
3318 *cvalue = value_cast (TYPE_FIELD_TYPE (type, index), value);
3322 *ctype = TYPE_FIELD_TYPE (type, index);
3325 if (cfull_expression)
3327 char *ptr = was_ptr ? "*" : "";
3329 /* Cast the parent to the base' type. Note that in gdb,
3332 will create an lvalue, for all appearences, so we don't
3333 need to use more fancy:
3336 *cfull_expression = xstrprintf ("(%s(%s%s) %s)",
3338 TYPE_FIELD_NAME (type, index),
3345 char *access = NULL;
3348 cplus_class_num_children (type, children);
3350 /* Everything beyond the baseclasses can
3351 only be "public", "private", or "protected"
3353 The special "fake" children are always output by varobj in
3354 this order. So if INDEX == 2, it MUST be "protected". */
3355 index -= TYPE_N_BASECLASSES (type);
3359 if (children[v_public] > 0)
3361 else if (children[v_private] > 0)
3364 access = "protected";
3367 if (children[v_public] > 0)
3369 if (children[v_private] > 0)
3372 access = "protected";
3374 else if (children[v_private] > 0)
3375 access = "protected";
3378 /* Must be protected */
3379 access = "protected";
3386 gdb_assert (access);
3388 *cname = xstrdup (access);
3390 /* Value and type and full expression are null here. */
3395 c_describe_child (parent, index, cname, cvalue, ctype, cfull_expression);
3400 cplus_name_of_child (struct varobj *parent, int index)
3404 cplus_describe_child (parent, index, &name, NULL, NULL, NULL);
3409 cplus_path_expr_of_child (struct varobj *child)
3411 cplus_describe_child (child->parent, child->index, NULL, NULL, NULL,
3413 return child->path_expr;
3416 static struct value *
3417 cplus_value_of_root (struct varobj **var_handle)
3419 return c_value_of_root (var_handle);
3422 static struct value *
3423 cplus_value_of_child (struct varobj *parent, int index)
3425 struct value *value = NULL;
3427 cplus_describe_child (parent, index, NULL, &value, NULL, NULL);
3431 static struct type *
3432 cplus_type_of_child (struct varobj *parent, int index)
3434 struct type *type = NULL;
3436 cplus_describe_child (parent, index, NULL, NULL, &type, NULL);
3441 cplus_value_of_variable (struct varobj *var,
3442 enum varobj_display_formats format)
3445 /* If we have one of our special types, don't print out
3447 if (CPLUS_FAKE_CHILD (var))
3448 return xstrdup ("");
3450 return c_value_of_variable (var, format);
3456 java_number_of_children (struct varobj *var)
3458 return cplus_number_of_children (var);
3462 java_name_of_variable (struct varobj *parent)
3466 name = cplus_name_of_variable (parent);
3467 /* If the name has "-" in it, it is because we
3468 needed to escape periods in the name... */
3471 while (*p != '\000')
3482 java_name_of_child (struct varobj *parent, int index)
3486 name = cplus_name_of_child (parent, index);
3487 /* Escape any periods in the name... */
3490 while (*p != '\000')
3501 java_path_expr_of_child (struct varobj *child)
3506 static struct value *
3507 java_value_of_root (struct varobj **var_handle)
3509 return cplus_value_of_root (var_handle);
3512 static struct value *
3513 java_value_of_child (struct varobj *parent, int index)
3515 return cplus_value_of_child (parent, index);
3518 static struct type *
3519 java_type_of_child (struct varobj *parent, int index)
3521 return cplus_type_of_child (parent, index);
3525 java_value_of_variable (struct varobj *var, enum varobj_display_formats format)
3527 return cplus_value_of_variable (var, format);
3530 /* Iterate all the existing _root_ VAROBJs and call the FUNC callback for them
3531 with an arbitrary caller supplied DATA pointer. */
3534 all_root_varobjs (void (*func) (struct varobj *var, void *data), void *data)
3536 struct varobj_root *var_root, *var_root_next;
3538 /* Iterate "safely" - handle if the callee deletes its passed VAROBJ. */
3540 for (var_root = rootlist; var_root != NULL; var_root = var_root_next)
3542 var_root_next = var_root->next;
3544 (*func) (var_root->rootvar, data);
3548 extern void _initialize_varobj (void);
3550 _initialize_varobj (void)
3552 int sizeof_table = sizeof (struct vlist *) * VAROBJ_TABLE_SIZE;
3554 varobj_table = xmalloc (sizeof_table);
3555 memset (varobj_table, 0, sizeof_table);
3557 add_setshow_zinteger_cmd ("debugvarobj", class_maintenance,
3559 _("Set varobj debugging."),
3560 _("Show varobj debugging."),
3561 _("When non-zero, varobj debugging is enabled."),
3562 NULL, show_varobjdebug,
3563 &setlist, &showlist);
3566 /* Invalidate varobj VAR if it is tied to locals and re-create it if it is
3567 defined on globals. It is a helper for varobj_invalidate. */
3570 varobj_invalidate_iter (struct varobj *var, void *unused)
3572 /* Floating varobjs are reparsed on each stop, so we don't care if the
3573 presently parsed expression refers to something that's gone. */
3574 if (var->root->floating)
3577 /* global var must be re-evaluated. */
3578 if (var->root->valid_block == NULL)
3580 struct varobj *tmp_var;
3582 /* Try to create a varobj with same expression. If we succeed
3583 replace the old varobj, otherwise invalidate it. */
3584 tmp_var = varobj_create (NULL, var->name, (CORE_ADDR) 0,
3586 if (tmp_var != NULL)
3588 tmp_var->obj_name = xstrdup (var->obj_name);
3589 varobj_delete (var, NULL, 0);
3590 install_variable (tmp_var);
3593 var->root->is_valid = 0;
3595 else /* locals must be invalidated. */
3596 var->root->is_valid = 0;
3599 /* Invalidate the varobjs that are tied to locals and re-create the ones that
3600 are defined on globals.
3601 Invalidated varobjs will be always printed in_scope="invalid". */
3604 varobj_invalidate (void)
3606 all_root_varobjs (varobj_invalidate_iter, NULL);