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
166 struct varobj_root *root;
168 /* The format of the output for this object. */
169 enum varobj_display_formats format;
171 /* Was this variable updated via a varobj_set_value operation. */
174 /* Last print value. */
177 /* Is this variable frozen. Frozen variables are never implicitly
178 updated by -var-update *
179 or -var-update <direct-or-indirect-parent>. */
182 /* Is the value of this variable intentionally not fetched? It is
183 not fetched if either the variable is frozen, or any parents is
187 /* Sub-range of children which the MI consumer has requested. If
188 FROM < 0 or TO < 0, means that all children have been
193 /* The pretty-printer constructor. If NULL, then the default
194 pretty-printer will be looked up. If None, then no
195 pretty-printer will be installed. */
196 PyObject *constructor;
198 /* The pretty-printer that has been constructed. If NULL, then a
199 new printer object is needed, and one will be constructed. */
200 PyObject *pretty_printer;
202 /* The iterator returned by the printer's 'children' method, or NULL
204 PyObject *child_iter;
206 /* We request one extra item from the iterator, so that we can
207 report to the caller whether there are more items than we have
208 already reported. However, we don't want to install this value
209 when we read it, because that will mess up future updates. So,
210 we stash it here instead. */
211 PyObject *saved_item;
217 struct cpstack *next;
220 /* A list of varobjs */
228 /* Private function prototypes */
230 /* Helper functions for the above subcommands. */
232 static int delete_variable (struct cpstack **, struct varobj *, int);
234 static void delete_variable_1 (struct cpstack **, int *,
235 struct varobj *, int, int);
237 static int install_variable (struct varobj *);
239 static void uninstall_variable (struct varobj *);
241 static struct varobj *create_child (struct varobj *, int, char *);
243 static struct varobj *
244 create_child_with_value (struct varobj *parent, int index, const char *name,
245 struct value *value);
247 /* Utility routines */
249 static struct varobj *new_variable (void);
251 static struct varobj *new_root_variable (void);
253 static void free_variable (struct varobj *var);
255 static struct cleanup *make_cleanup_free_variable (struct varobj *var);
257 static struct type *get_type (struct varobj *var);
259 static struct type *get_value_type (struct varobj *var);
261 static struct type *get_target_type (struct type *);
263 static enum varobj_display_formats variable_default_display (struct varobj *);
265 static void cppush (struct cpstack **pstack, char *name);
267 static char *cppop (struct cpstack **pstack);
269 static int install_new_value (struct varobj *var, struct value *value,
272 /* Language-specific routines. */
274 static enum varobj_languages variable_language (struct varobj *var);
276 static int number_of_children (struct varobj *);
278 static char *name_of_variable (struct varobj *);
280 static char *name_of_child (struct varobj *, int);
282 static struct value *value_of_root (struct varobj **var_handle, int *);
284 static struct value *value_of_child (struct varobj *parent, int index);
286 static char *my_value_of_variable (struct varobj *var,
287 enum varobj_display_formats format);
289 static char *value_get_print_value (struct value *value,
290 enum varobj_display_formats format,
293 static int varobj_value_is_changeable_p (struct varobj *var);
295 static int is_root_p (struct varobj *var);
299 static struct varobj *varobj_add_child (struct varobj *var,
301 struct value *value);
303 #endif /* HAVE_PYTHON */
305 /* C implementation */
307 static int c_number_of_children (struct varobj *var);
309 static char *c_name_of_variable (struct varobj *parent);
311 static char *c_name_of_child (struct varobj *parent, int index);
313 static char *c_path_expr_of_child (struct varobj *child);
315 static struct value *c_value_of_root (struct varobj **var_handle);
317 static struct value *c_value_of_child (struct varobj *parent, int index);
319 static struct type *c_type_of_child (struct varobj *parent, int index);
321 static char *c_value_of_variable (struct varobj *var,
322 enum varobj_display_formats format);
324 /* C++ implementation */
326 static int cplus_number_of_children (struct varobj *var);
328 static void cplus_class_num_children (struct type *type, int children[3]);
330 static char *cplus_name_of_variable (struct varobj *parent);
332 static char *cplus_name_of_child (struct varobj *parent, int index);
334 static char *cplus_path_expr_of_child (struct varobj *child);
336 static struct value *cplus_value_of_root (struct varobj **var_handle);
338 static struct value *cplus_value_of_child (struct varobj *parent, int index);
340 static struct type *cplus_type_of_child (struct varobj *parent, int index);
342 static char *cplus_value_of_variable (struct varobj *var,
343 enum varobj_display_formats format);
345 /* Java implementation */
347 static int java_number_of_children (struct varobj *var);
349 static char *java_name_of_variable (struct varobj *parent);
351 static char *java_name_of_child (struct varobj *parent, int index);
353 static char *java_path_expr_of_child (struct varobj *child);
355 static struct value *java_value_of_root (struct varobj **var_handle);
357 static struct value *java_value_of_child (struct varobj *parent, int index);
359 static struct type *java_type_of_child (struct varobj *parent, int index);
361 static char *java_value_of_variable (struct varobj *var,
362 enum varobj_display_formats format);
364 /* The language specific vector */
366 struct language_specific
369 /* The language of this variable. */
370 enum varobj_languages language;
372 /* The number of children of PARENT. */
373 int (*number_of_children) (struct varobj * parent);
375 /* The name (expression) of a root varobj. */
376 char *(*name_of_variable) (struct varobj * parent);
378 /* The name of the INDEX'th child of PARENT. */
379 char *(*name_of_child) (struct varobj * parent, int index);
381 /* Returns the rooted expression of CHILD, which is a variable
382 obtain that has some parent. */
383 char *(*path_expr_of_child) (struct varobj * child);
385 /* The ``struct value *'' of the root variable ROOT. */
386 struct value *(*value_of_root) (struct varobj ** root_handle);
388 /* The ``struct value *'' of the INDEX'th child of PARENT. */
389 struct value *(*value_of_child) (struct varobj * parent, int index);
391 /* The type of the INDEX'th child of PARENT. */
392 struct type *(*type_of_child) (struct varobj * parent, int index);
394 /* The current value of VAR. */
395 char *(*value_of_variable) (struct varobj * var,
396 enum varobj_display_formats format);
399 /* Array of known source language routines. */
400 static struct language_specific languages[vlang_end] = {
401 /* Unknown (try treating as C). */
404 c_number_of_children,
407 c_path_expr_of_child,
416 c_number_of_children,
419 c_path_expr_of_child,
428 cplus_number_of_children,
429 cplus_name_of_variable,
431 cplus_path_expr_of_child,
433 cplus_value_of_child,
435 cplus_value_of_variable}
440 java_number_of_children,
441 java_name_of_variable,
443 java_path_expr_of_child,
447 java_value_of_variable}
450 /* A little convenience enum for dealing with C++/Java. */
453 v_public = 0, v_private, v_protected
458 /* Mappings of varobj_display_formats enums to gdb's format codes. */
459 static int format_code[] = { 0, 't', 'd', 'x', 'o' };
461 /* Header of the list of root variable objects. */
462 static struct varobj_root *rootlist;
464 /* Prime number indicating the number of buckets in the hash table. */
465 /* A prime large enough to avoid too many colisions. */
466 #define VAROBJ_TABLE_SIZE 227
468 /* Pointer to the varobj hash table (built at run time). */
469 static struct vlist **varobj_table;
471 /* Is the variable X one of our "fake" children? */
472 #define CPLUS_FAKE_CHILD(x) \
473 ((x) != NULL && (x)->type == NULL && (x)->value == NULL)
476 /* API Implementation */
478 is_root_p (struct varobj *var)
480 return (var->root->rootvar == var);
484 /* Helper function to install a Python environment suitable for
485 use during operations on VAR. */
487 varobj_ensure_python_env (struct varobj *var)
489 return ensure_python_env (var->root->exp->gdbarch,
490 var->root->exp->language_defn);
494 /* Creates a varobj (not its children). */
496 /* Return the full FRAME which corresponds to the given CORE_ADDR
497 or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
499 static struct frame_info *
500 find_frame_addr_in_frame_chain (CORE_ADDR frame_addr)
502 struct frame_info *frame = NULL;
504 if (frame_addr == (CORE_ADDR) 0)
507 for (frame = get_current_frame ();
509 frame = get_prev_frame (frame))
511 /* The CORE_ADDR we get as argument was parsed from a string GDB
512 output as $fp. This output got truncated to gdbarch_addr_bit.
513 Truncate the frame base address in the same manner before
514 comparing it against our argument. */
515 CORE_ADDR frame_base = get_frame_base_address (frame);
516 int addr_bit = gdbarch_addr_bit (get_frame_arch (frame));
518 if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
519 frame_base &= ((CORE_ADDR) 1 << addr_bit) - 1;
521 if (frame_base == frame_addr)
529 varobj_create (char *objname,
530 char *expression, CORE_ADDR frame, enum varobj_type type)
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)
541 struct frame_info *fi;
542 struct frame_id old_id = null_frame_id;
545 enum varobj_languages lang;
546 struct value *value = NULL;
548 /* Parse and evaluate the expression, filling in as much of the
549 variable's data as possible. */
551 if (has_stack_frames ())
553 /* Allow creator to specify context of variable. */
554 if ((type == USE_CURRENT_FRAME) || (type == USE_SELECTED_FRAME))
555 fi = get_selected_frame (NULL);
557 /* FIXME: cagney/2002-11-23: This code should be doing a
558 lookup using the frame ID and not just the frame's
559 ``address''. This, of course, means an interface
560 change. However, with out that interface change ISAs,
561 such as the ia64 with its two stacks, won't work.
562 Similar goes for the case where there is a frameless
564 fi = find_frame_addr_in_frame_chain (frame);
569 /* frame = -2 means always use selected frame. */
570 if (type == USE_SELECTED_FRAME)
571 var->root->floating = 1;
575 block = get_frame_block (fi, 0);
578 innermost_block = NULL;
579 /* Wrap the call to parse expression, so we can
580 return a sensible error. */
581 if (!gdb_parse_exp_1 (&p, block, 0, &var->root->exp))
586 /* Don't allow variables to be created for types. */
587 if (var->root->exp->elts[0].opcode == OP_TYPE)
589 do_cleanups (old_chain);
590 fprintf_unfiltered (gdb_stderr, "Attempt to use a type name"
591 " as an expression.\n");
595 var->format = variable_default_display (var);
596 var->root->valid_block = innermost_block;
597 var->name = xstrdup (expression);
598 /* For a root var, the name and the expr are the same. */
599 var->path_expr = xstrdup (expression);
601 /* When the frame is different from the current frame,
602 we must select the appropriate frame before parsing
603 the expression, otherwise the value will not be current.
604 Since select_frame is so benign, just call it for all cases. */
607 /* User could specify explicit FRAME-ADDR which was not found but
608 EXPRESSION is frame specific and we would not be able to evaluate
609 it correctly next time. With VALID_BLOCK set we must also set
610 FRAME and THREAD_ID. */
612 error (_("Failed to find the specified frame"));
614 var->root->frame = get_frame_id (fi);
615 var->root->thread_id = pid_to_thread_id (inferior_ptid);
616 old_id = get_frame_id (get_selected_frame (NULL));
620 /* We definitely need to catch errors here.
621 If evaluate_expression succeeds we got the value we wanted.
622 But if it fails, we still go on with a call to evaluate_type(). */
623 if (!gdb_evaluate_expression (var->root->exp, &value))
625 /* Error getting the value. Try to at least get the
627 struct value *type_only_value = evaluate_type (var->root->exp);
629 var->type = value_type (type_only_value);
632 var->type = value_type (value);
634 install_new_value (var, value, 1 /* Initial assignment */);
636 /* Set language info */
637 lang = variable_language (var);
638 var->root->lang = &languages[lang];
640 /* Set ourselves as our root. */
641 var->root->rootvar = var;
643 /* Reset the selected frame. */
644 if (frame_id_p (old_id))
645 select_frame (frame_find_by_id (old_id));
648 /* If the variable object name is null, that means this
649 is a temporary variable, so don't install it. */
651 if ((var != NULL) && (objname != NULL))
653 var->obj_name = xstrdup (objname);
655 /* If a varobj name is duplicated, the install will fail so
657 if (!install_variable (var))
659 do_cleanups (old_chain);
664 discard_cleanups (old_chain);
668 /* Generates an unique name that can be used for a varobj. */
671 varobj_gen_name (void)
676 /* Generate a name for this object. */
678 obj_name = xstrprintf ("var%d", id);
683 /* Given an OBJNAME, returns the pointer to the corresponding varobj. Call
684 error if OBJNAME cannot be found. */
687 varobj_get_handle (char *objname)
691 unsigned int index = 0;
694 for (chp = objname; *chp; chp++)
696 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
699 cv = *(varobj_table + index);
700 while ((cv != NULL) && (strcmp (cv->var->obj_name, objname) != 0))
704 error (_("Variable object not found"));
709 /* Given the handle, return the name of the object. */
712 varobj_get_objname (struct varobj *var)
714 return var->obj_name;
717 /* Given the handle, return the expression represented by the object. */
720 varobj_get_expression (struct varobj *var)
722 return name_of_variable (var);
725 /* Deletes a varobj and all its children if only_children == 0,
726 otherwise deletes only the children; returns a malloc'ed list of
727 all the (malloc'ed) names of the variables that have been deleted
728 (NULL terminated). */
731 varobj_delete (struct varobj *var, char ***dellist, int only_children)
735 struct cpstack *result = NULL;
738 /* Initialize a stack for temporary results. */
739 cppush (&result, NULL);
742 /* Delete only the variable children. */
743 delcount = delete_variable (&result, var, 1 /* only the children */ );
745 /* Delete the variable and all its children. */
746 delcount = delete_variable (&result, var, 0 /* parent+children */ );
748 /* We may have been asked to return a list of what has been deleted. */
751 *dellist = xmalloc ((delcount + 1) * sizeof (char *));
755 *cp = cppop (&result);
756 while ((*cp != NULL) && (mycount > 0))
760 *cp = cppop (&result);
763 if (mycount || (*cp != NULL))
764 warning (_("varobj_delete: assertion failed - mycount(=%d) <> 0"),
773 /* Convenience function for varobj_set_visualizer. Instantiate a
774 pretty-printer for a given value. */
776 instantiate_pretty_printer (PyObject *constructor, struct value *value)
778 PyObject *val_obj = NULL;
781 val_obj = value_to_value_object (value);
785 printer = PyObject_CallFunctionObjArgs (constructor, val_obj, NULL);
793 /* Set/Get variable object display format. */
795 enum varobj_display_formats
796 varobj_set_display_format (struct varobj *var,
797 enum varobj_display_formats format)
804 case FORMAT_HEXADECIMAL:
806 var->format = format;
810 var->format = variable_default_display (var);
813 if (varobj_value_is_changeable_p (var)
814 && var->value && !value_lazy (var->value))
816 xfree (var->print_value);
817 var->print_value = value_get_print_value (var->value, var->format, var);
823 enum varobj_display_formats
824 varobj_get_display_format (struct varobj *var)
830 varobj_get_display_hint (struct varobj *var)
835 struct cleanup *back_to = varobj_ensure_python_env (var);
837 if (var->pretty_printer)
838 result = gdbpy_get_display_hint (var->pretty_printer);
840 do_cleanups (back_to);
846 /* Return true if the varobj has items after TO, false otherwise. */
849 varobj_has_more (struct varobj *var, int to)
851 if (VEC_length (varobj_p, var->children) > to)
853 return ((to == -1 || VEC_length (varobj_p, var->children) == to)
854 && var->saved_item != NULL);
857 /* If the variable object is bound to a specific thread, that
858 is its evaluation can always be done in context of a frame
859 inside that thread, returns GDB id of the thread -- which
860 is always positive. Otherwise, returns -1. */
862 varobj_get_thread_id (struct varobj *var)
864 if (var->root->valid_block && var->root->thread_id > 0)
865 return var->root->thread_id;
871 varobj_set_frozen (struct varobj *var, int frozen)
873 /* When a variable is unfrozen, we don't fetch its value.
874 The 'not_fetched' flag remains set, so next -var-update
877 We don't fetch the value, because for structures the client
878 should do -var-update anyway. It would be bad to have different
879 client-size logic for structure and other types. */
880 var->frozen = frozen;
884 varobj_get_frozen (struct varobj *var)
889 /* A helper function that restricts a range to what is actually
890 available in a VEC. This follows the usual rules for the meaning
891 of FROM and TO -- if either is negative, the entire range is
895 restrict_range (VEC (varobj_p) *children, int *from, int *to)
897 if (*from < 0 || *to < 0)
900 *to = VEC_length (varobj_p, children);
904 if (*from > VEC_length (varobj_p, children))
905 *from = VEC_length (varobj_p, children);
906 if (*to > VEC_length (varobj_p, children))
907 *to = VEC_length (varobj_p, children);
915 /* A helper for update_dynamic_varobj_children that installs a new
916 child when needed. */
919 install_dynamic_child (struct varobj *var,
920 VEC (varobj_p) **changed,
921 VEC (varobj_p) **new,
922 VEC (varobj_p) **unchanged,
928 if (VEC_length (varobj_p, var->children) < index + 1)
930 /* There's no child yet. */
931 struct varobj *child = varobj_add_child (var, name, value);
935 VEC_safe_push (varobj_p, *new, child);
941 varobj_p existing = VEC_index (varobj_p, var->children, index);
943 if (install_new_value (existing, value, 0))
946 VEC_safe_push (varobj_p, *changed, existing);
949 VEC_safe_push (varobj_p, *unchanged, existing);
954 dynamic_varobj_has_child_method (struct varobj *var)
956 struct cleanup *back_to;
957 PyObject *printer = var->pretty_printer;
960 back_to = varobj_ensure_python_env (var);
961 result = PyObject_HasAttr (printer, gdbpy_children_cst);
962 do_cleanups (back_to);
969 update_dynamic_varobj_children (struct varobj *var,
970 VEC (varobj_p) **changed,
971 VEC (varobj_p) **new,
972 VEC (varobj_p) **unchanged,
979 struct cleanup *back_to;
982 PyObject *printer = var->pretty_printer;
984 back_to = varobj_ensure_python_env (var);
987 if (!PyObject_HasAttr (printer, gdbpy_children_cst))
989 do_cleanups (back_to);
993 if (update_children || !var->child_iter)
995 children = PyObject_CallMethodObjArgs (printer, gdbpy_children_cst,
1000 gdbpy_print_stack ();
1001 error (_("Null value returned for children"));
1004 make_cleanup_py_decref (children);
1006 if (!PyIter_Check (children))
1007 error (_("Returned value is not iterable"));
1009 Py_XDECREF (var->child_iter);
1010 var->child_iter = PyObject_GetIter (children);
1011 if (!var->child_iter)
1013 gdbpy_print_stack ();
1014 error (_("Could not get children iterator"));
1017 Py_XDECREF (var->saved_item);
1018 var->saved_item = NULL;
1023 i = VEC_length (varobj_p, var->children);
1025 /* We ask for one extra child, so that MI can report whether there
1026 are more children. */
1027 for (; to < 0 || i < to + 1; ++i)
1031 /* See if there was a leftover from last time. */
1032 if (var->saved_item)
1034 item = var->saved_item;
1035 var->saved_item = NULL;
1038 item = PyIter_Next (var->child_iter);
1043 /* We don't want to push the extra child on any report list. */
1044 if (to < 0 || i < to)
1049 struct cleanup *inner;
1050 int can_mention = from < 0 || i >= from;
1052 inner = make_cleanup_py_decref (item);
1054 if (!PyArg_ParseTuple (item, "sO", &name, &py_v))
1055 error (_("Invalid item from the child list"));
1057 v = convert_value_from_python (py_v);
1059 gdbpy_print_stack ();
1060 install_dynamic_child (var, can_mention ? changed : NULL,
1061 can_mention ? new : NULL,
1062 can_mention ? unchanged : NULL,
1063 can_mention ? cchanged : NULL, i, name, v);
1064 do_cleanups (inner);
1068 Py_XDECREF (var->saved_item);
1069 var->saved_item = item;
1071 /* We want to truncate the child list just before this
1077 if (i < VEC_length (varobj_p, var->children))
1082 for (j = i; j < VEC_length (varobj_p, var->children); ++j)
1083 varobj_delete (VEC_index (varobj_p, var->children, j), NULL, 0);
1084 VEC_truncate (varobj_p, var->children, i);
1087 /* If there are fewer children than requested, note that the list of
1088 children changed. */
1089 if (to >= 0 && VEC_length (varobj_p, var->children) < to)
1092 var->num_children = VEC_length (varobj_p, var->children);
1094 do_cleanups (back_to);
1098 gdb_assert (0 && "should never be called if Python is not enabled");
1103 varobj_get_num_children (struct varobj *var)
1105 if (var->num_children == -1)
1107 if (var->pretty_printer)
1111 /* If we have a dynamic varobj, don't report -1 children.
1112 So, try to fetch some children first. */
1113 update_dynamic_varobj_children (var, NULL, NULL, NULL, &dummy,
1117 var->num_children = number_of_children (var);
1120 return var->num_children >= 0 ? var->num_children : 0;
1123 /* Creates a list of the immediate children of a variable object;
1124 the return code is the number of such children or -1 on error. */
1127 varobj_list_children (struct varobj *var, int *from, int *to)
1130 int i, children_changed;
1132 var->children_requested = 1;
1134 if (var->pretty_printer)
1136 /* This, in theory, can result in the number of children changing without
1137 frontend noticing. But well, calling -var-list-children on the same
1138 varobj twice is not something a sane frontend would do. */
1139 update_dynamic_varobj_children (var, NULL, NULL, NULL, &children_changed,
1141 restrict_range (var->children, from, to);
1142 return var->children;
1145 if (var->num_children == -1)
1146 var->num_children = number_of_children (var);
1148 /* If that failed, give up. */
1149 if (var->num_children == -1)
1150 return var->children;
1152 /* If we're called when the list of children is not yet initialized,
1153 allocate enough elements in it. */
1154 while (VEC_length (varobj_p, var->children) < var->num_children)
1155 VEC_safe_push (varobj_p, var->children, NULL);
1157 for (i = 0; i < var->num_children; i++)
1159 varobj_p existing = VEC_index (varobj_p, var->children, i);
1161 if (existing == NULL)
1163 /* Either it's the first call to varobj_list_children for
1164 this variable object, and the child was never created,
1165 or it was explicitly deleted by the client. */
1166 name = name_of_child (var, i);
1167 existing = create_child (var, i, name);
1168 VEC_replace (varobj_p, var->children, i, existing);
1172 restrict_range (var->children, from, to);
1173 return var->children;
1178 static struct varobj *
1179 varobj_add_child (struct varobj *var, const char *name, struct value *value)
1181 varobj_p v = create_child_with_value (var,
1182 VEC_length (varobj_p, var->children),
1185 VEC_safe_push (varobj_p, var->children, v);
1189 #endif /* HAVE_PYTHON */
1191 /* Obtain the type of an object Variable as a string similar to the one gdb
1192 prints on the console. */
1195 varobj_get_type (struct varobj *var)
1197 /* For the "fake" variables, do not return a type. (It's type is
1199 Do not return a type for invalid variables as well. */
1200 if (CPLUS_FAKE_CHILD (var) || !var->root->is_valid)
1203 return type_to_string (var->type);
1206 /* Obtain the type of an object variable. */
1209 varobj_get_gdb_type (struct varobj *var)
1214 /* Return a pointer to the full rooted expression of varobj VAR.
1215 If it has not been computed yet, compute it. */
1217 varobj_get_path_expr (struct varobj *var)
1219 if (var->path_expr != NULL)
1220 return var->path_expr;
1223 /* For root varobjs, we initialize path_expr
1224 when creating varobj, so here it should be
1226 gdb_assert (!is_root_p (var));
1227 return (*var->root->lang->path_expr_of_child) (var);
1231 enum varobj_languages
1232 varobj_get_language (struct varobj *var)
1234 return variable_language (var);
1238 varobj_get_attributes (struct varobj *var)
1242 if (varobj_editable_p (var))
1243 /* FIXME: define masks for attributes. */
1244 attributes |= 0x00000001; /* Editable */
1250 varobj_pretty_printed_p (struct varobj *var)
1252 return var->pretty_printer != NULL;
1256 varobj_get_formatted_value (struct varobj *var,
1257 enum varobj_display_formats format)
1259 return my_value_of_variable (var, format);
1263 varobj_get_value (struct varobj *var)
1265 return my_value_of_variable (var, var->format);
1268 /* Set the value of an object variable (if it is editable) to the
1269 value of the given expression. */
1270 /* Note: Invokes functions that can call error(). */
1273 varobj_set_value (struct varobj *var, char *expression)
1277 /* The argument "expression" contains the variable's new value.
1278 We need to first construct a legal expression for this -- ugh! */
1279 /* Does this cover all the bases? */
1280 struct expression *exp;
1281 struct value *value;
1282 int saved_input_radix = input_radix;
1283 char *s = expression;
1285 gdb_assert (varobj_editable_p (var));
1287 input_radix = 10; /* ALWAYS reset to decimal temporarily. */
1288 exp = parse_exp_1 (&s, 0, 0);
1289 if (!gdb_evaluate_expression (exp, &value))
1291 /* We cannot proceed without a valid expression. */
1296 /* All types that are editable must also be changeable. */
1297 gdb_assert (varobj_value_is_changeable_p (var));
1299 /* The value of a changeable variable object must not be lazy. */
1300 gdb_assert (!value_lazy (var->value));
1302 /* Need to coerce the input. We want to check if the
1303 value of the variable object will be different
1304 after assignment, and the first thing value_assign
1305 does is coerce the input.
1306 For example, if we are assigning an array to a pointer variable we
1307 should compare the pointer with the array's address, not with the
1309 value = coerce_array (value);
1311 /* The new value may be lazy. gdb_value_assign, or
1312 rather value_contents, will take care of this.
1313 If fetching of the new value will fail, gdb_value_assign
1314 with catch the exception. */
1315 if (!gdb_value_assign (var->value, value, &val))
1318 /* If the value has changed, record it, so that next -var-update can
1319 report this change. If a variable had a value of '1', we've set it
1320 to '333' and then set again to '1', when -var-update will report this
1321 variable as changed -- because the first assignment has set the
1322 'updated' flag. There's no need to optimize that, because return value
1323 of -var-update should be considered an approximation. */
1324 var->updated = install_new_value (var, val, 0 /* Compare values. */);
1325 input_radix = saved_input_radix;
1331 /* A helper function to install a constructor function and visualizer
1335 install_visualizer (struct varobj *var, PyObject *constructor,
1336 PyObject *visualizer)
1338 Py_XDECREF (var->constructor);
1339 var->constructor = constructor;
1341 Py_XDECREF (var->pretty_printer);
1342 var->pretty_printer = visualizer;
1344 Py_XDECREF (var->child_iter);
1345 var->child_iter = NULL;
1348 /* Install the default visualizer for VAR. */
1351 install_default_visualizer (struct varobj *var)
1353 if (pretty_printing)
1355 PyObject *pretty_printer = NULL;
1359 pretty_printer = gdbpy_get_varobj_pretty_printer (var->value);
1360 if (! pretty_printer)
1362 gdbpy_print_stack ();
1363 error (_("Cannot instantiate printer for default visualizer"));
1367 if (pretty_printer == Py_None)
1369 Py_DECREF (pretty_printer);
1370 pretty_printer = NULL;
1373 install_visualizer (var, NULL, pretty_printer);
1377 /* Instantiate and install a visualizer for VAR using CONSTRUCTOR to
1378 make a new object. */
1381 construct_visualizer (struct varobj *var, PyObject *constructor)
1383 PyObject *pretty_printer;
1385 Py_INCREF (constructor);
1386 if (constructor == Py_None)
1387 pretty_printer = NULL;
1390 pretty_printer = instantiate_pretty_printer (constructor, var->value);
1391 if (! pretty_printer)
1393 gdbpy_print_stack ();
1394 Py_DECREF (constructor);
1395 constructor = Py_None;
1396 Py_INCREF (constructor);
1399 if (pretty_printer == Py_None)
1401 Py_DECREF (pretty_printer);
1402 pretty_printer = NULL;
1406 install_visualizer (var, constructor, pretty_printer);
1409 #endif /* HAVE_PYTHON */
1411 /* A helper function for install_new_value. This creates and installs
1412 a visualizer for VAR, if appropriate. */
1415 install_new_value_visualizer (struct varobj *var)
1418 /* If the constructor is None, then we want the raw value. If VAR
1419 does not have a value, just skip this. */
1420 if (var->constructor != Py_None && var->value)
1422 struct cleanup *cleanup;
1424 cleanup = varobj_ensure_python_env (var);
1426 if (!var->constructor)
1427 install_default_visualizer (var);
1429 construct_visualizer (var, var->constructor);
1431 do_cleanups (cleanup);
1438 /* Assign a new value to a variable object. If INITIAL is non-zero,
1439 this is the first assignement after the variable object was just
1440 created, or changed type. In that case, just assign the value
1442 Otherwise, assign the new value, and return 1 if the value is
1443 different from the current one, 0 otherwise. The comparison is
1444 done on textual representation of value. Therefore, some types
1445 need not be compared. E.g. for structures the reported value is
1446 always "{...}", so no comparison is necessary here. If the old
1447 value was NULL and new one is not, or vice versa, we always return 1.
1449 The VALUE parameter should not be released -- the function will
1450 take care of releasing it when needed. */
1452 install_new_value (struct varobj *var, struct value *value, int initial)
1457 int intentionally_not_fetched = 0;
1458 char *print_value = NULL;
1460 /* We need to know the varobj's type to decide if the value should
1461 be fetched or not. C++ fake children (public/protected/private)
1462 don't have a type. */
1463 gdb_assert (var->type || CPLUS_FAKE_CHILD (var));
1464 changeable = varobj_value_is_changeable_p (var);
1466 /* If the type has custom visualizer, we consider it to be always
1467 changeable. FIXME: need to make sure this behaviour will not
1468 mess up read-sensitive values. */
1469 if (var->pretty_printer)
1472 need_to_fetch = changeable;
1474 /* We are not interested in the address of references, and given
1475 that in C++ a reference is not rebindable, it cannot
1476 meaningfully change. So, get hold of the real value. */
1478 value = coerce_ref (value);
1480 if (var->type && TYPE_CODE (var->type) == TYPE_CODE_UNION)
1481 /* For unions, we need to fetch the value implicitly because
1482 of implementation of union member fetch. When gdb
1483 creates a value for a field and the value of the enclosing
1484 structure is not lazy, it immediately copies the necessary
1485 bytes from the enclosing values. If the enclosing value is
1486 lazy, the call to value_fetch_lazy on the field will read
1487 the data from memory. For unions, that means we'll read the
1488 same memory more than once, which is not desirable. So
1492 /* The new value might be lazy. If the type is changeable,
1493 that is we'll be comparing values of this type, fetch the
1494 value now. Otherwise, on the next update the old value
1495 will be lazy, which means we've lost that old value. */
1496 if (need_to_fetch && value && value_lazy (value))
1498 struct varobj *parent = var->parent;
1499 int frozen = var->frozen;
1501 for (; !frozen && parent; parent = parent->parent)
1502 frozen |= parent->frozen;
1504 if (frozen && initial)
1506 /* For variables that are frozen, or are children of frozen
1507 variables, we don't do fetch on initial assignment.
1508 For non-initial assignemnt we do the fetch, since it means we're
1509 explicitly asked to compare the new value with the old one. */
1510 intentionally_not_fetched = 1;
1512 else if (!gdb_value_fetch_lazy (value))
1514 /* Set the value to NULL, so that for the next -var-update,
1515 we don't try to compare the new value with this value,
1516 that we couldn't even read. */
1522 /* Below, we'll be comparing string rendering of old and new
1523 values. Don't get string rendering if the value is
1524 lazy -- if it is, the code above has decided that the value
1525 should not be fetched. */
1526 if (value && !value_lazy (value) && !var->pretty_printer)
1527 print_value = value_get_print_value (value, var->format, var);
1529 /* If the type is changeable, compare the old and the new values.
1530 If this is the initial assignment, we don't have any old value
1532 if (!initial && changeable)
1534 /* If the value of the varobj was changed by -var-set-value,
1535 then the value in the varobj and in the target is the same.
1536 However, that value is different from the value that the
1537 varobj had after the previous -var-update. So need to the
1538 varobj as changed. */
1543 else if (! var->pretty_printer)
1545 /* Try to compare the values. That requires that both
1546 values are non-lazy. */
1547 if (var->not_fetched && value_lazy (var->value))
1549 /* This is a frozen varobj and the value was never read.
1550 Presumably, UI shows some "never read" indicator.
1551 Now that we've fetched the real value, we need to report
1552 this varobj as changed so that UI can show the real
1556 else if (var->value == NULL && value == NULL)
1559 else if (var->value == NULL || value == NULL)
1565 gdb_assert (!value_lazy (var->value));
1566 gdb_assert (!value_lazy (value));
1568 gdb_assert (var->print_value != NULL && print_value != NULL);
1569 if (strcmp (var->print_value, print_value) != 0)
1575 if (!initial && !changeable)
1577 /* For values that are not changeable, we don't compare the values.
1578 However, we want to notice if a value was not NULL and now is NULL,
1579 or vise versa, so that we report when top-level varobjs come in scope
1580 and leave the scope. */
1581 changed = (var->value != NULL) != (value != NULL);
1584 /* We must always keep the new value, since children depend on it. */
1585 if (var->value != NULL && var->value != value)
1586 value_free (var->value);
1589 value_incref (value);
1590 if (value && value_lazy (value) && intentionally_not_fetched)
1591 var->not_fetched = 1;
1593 var->not_fetched = 0;
1596 install_new_value_visualizer (var);
1598 /* If we installed a pretty-printer, re-compare the printed version
1599 to see if the variable changed. */
1600 if (var->pretty_printer)
1602 xfree (print_value);
1603 print_value = value_get_print_value (var->value, var->format, var);
1604 if ((var->print_value == NULL && print_value != NULL)
1605 || (var->print_value != NULL && print_value == NULL)
1606 || (var->print_value != NULL && print_value != NULL
1607 && strcmp (var->print_value, print_value) != 0))
1610 if (var->print_value)
1611 xfree (var->print_value);
1612 var->print_value = print_value;
1614 gdb_assert (!var->value || value_type (var->value));
1619 /* Return the requested range for a varobj. VAR is the varobj. FROM
1620 and TO are out parameters; *FROM and *TO will be set to the
1621 selected sub-range of VAR. If no range was selected using
1622 -var-set-update-range, then both will be -1. */
1624 varobj_get_child_range (struct varobj *var, int *from, int *to)
1630 /* Set the selected sub-range of children of VAR to start at index
1631 FROM and end at index TO. If either FROM or TO is less than zero,
1632 this is interpreted as a request for all children. */
1634 varobj_set_child_range (struct varobj *var, int from, int to)
1641 varobj_set_visualizer (struct varobj *var, const char *visualizer)
1644 PyObject *mainmod, *globals, *constructor;
1645 struct cleanup *back_to;
1647 back_to = varobj_ensure_python_env (var);
1649 mainmod = PyImport_AddModule ("__main__");
1650 globals = PyModule_GetDict (mainmod);
1651 Py_INCREF (globals);
1652 make_cleanup_py_decref (globals);
1654 constructor = PyRun_String (visualizer, Py_eval_input, globals, globals);
1658 gdbpy_print_stack ();
1659 error (_("Could not evaluate visualizer expression: %s"), visualizer);
1662 construct_visualizer (var, constructor);
1663 Py_XDECREF (constructor);
1665 /* If there are any children now, wipe them. */
1666 varobj_delete (var, NULL, 1 /* children only */);
1667 var->num_children = -1;
1669 do_cleanups (back_to);
1671 error (_("Python support required"));
1675 /* Update the values for a variable and its children. This is a
1676 two-pronged attack. First, re-parse the value for the root's
1677 expression to see if it's changed. Then go all the way
1678 through its children, reconstructing them and noting if they've
1681 The EXPLICIT parameter specifies if this call is result
1682 of MI request to update this specific variable, or
1683 result of implicit -var-update *. For implicit request, we don't
1684 update frozen variables.
1686 NOTE: This function may delete the caller's varobj. If it
1687 returns TYPE_CHANGED, then it has done this and VARP will be modified
1688 to point to the new varobj. */
1690 VEC(varobj_update_result) *varobj_update (struct varobj **varp, int explicit)
1693 int type_changed = 0;
1696 VEC (varobj_update_result) *stack = NULL;
1697 VEC (varobj_update_result) *result = NULL;
1699 /* Frozen means frozen -- we don't check for any change in
1700 this varobj, including its going out of scope, or
1701 changing type. One use case for frozen varobjs is
1702 retaining previously evaluated expressions, and we don't
1703 want them to be reevaluated at all. */
1704 if (!explicit && (*varp)->frozen)
1707 if (!(*varp)->root->is_valid)
1709 varobj_update_result r = {0};
1712 r.status = VAROBJ_INVALID;
1713 VEC_safe_push (varobj_update_result, result, &r);
1717 if ((*varp)->root->rootvar == *varp)
1719 varobj_update_result r = {0};
1722 r.status = VAROBJ_IN_SCOPE;
1724 /* Update the root variable. value_of_root can return NULL
1725 if the variable is no longer around, i.e. we stepped out of
1726 the frame in which a local existed. We are letting the
1727 value_of_root variable dispose of the varobj if the type
1729 new = value_of_root (varp, &type_changed);
1732 r.type_changed = type_changed;
1733 if (install_new_value ((*varp), new, type_changed))
1737 r.status = VAROBJ_NOT_IN_SCOPE;
1738 r.value_installed = 1;
1740 if (r.status == VAROBJ_NOT_IN_SCOPE)
1742 if (r.type_changed || r.changed)
1743 VEC_safe_push (varobj_update_result, result, &r);
1747 VEC_safe_push (varobj_update_result, stack, &r);
1751 varobj_update_result r = {0};
1754 VEC_safe_push (varobj_update_result, stack, &r);
1757 /* Walk through the children, reconstructing them all. */
1758 while (!VEC_empty (varobj_update_result, stack))
1760 varobj_update_result r = *(VEC_last (varobj_update_result, stack));
1761 struct varobj *v = r.varobj;
1763 VEC_pop (varobj_update_result, stack);
1765 /* Update this variable, unless it's a root, which is already
1767 if (!r.value_installed)
1769 new = value_of_child (v->parent, v->index);
1770 if (install_new_value (v, new, 0 /* type not changed */))
1777 /* We probably should not get children of a varobj that has a
1778 pretty-printer, but for which -var-list-children was never
1780 if (v->pretty_printer)
1782 VEC (varobj_p) *changed = 0, *new = 0, *unchanged = 0;
1783 int i, children_changed = 0;
1788 if (!v->children_requested)
1792 /* If we initially did not have potential children, but
1793 now we do, consider the varobj as changed.
1794 Otherwise, if children were never requested, consider
1795 it as unchanged -- presumably, such varobj is not yet
1796 expanded in the UI, so we need not bother getting
1798 if (!varobj_has_more (v, 0))
1800 update_dynamic_varobj_children (v, NULL, NULL, NULL,
1802 if (varobj_has_more (v, 0))
1807 VEC_safe_push (varobj_update_result, result, &r);
1812 /* If update_dynamic_varobj_children returns 0, then we have
1813 a non-conforming pretty-printer, so we skip it. */
1814 if (update_dynamic_varobj_children (v, &changed, &new, &unchanged,
1815 &children_changed, 1,
1818 if (children_changed || new)
1820 r.children_changed = 1;
1823 /* Push in reverse order so that the first child is
1824 popped from the work stack first, and so will be
1825 added to result first. This does not affect
1826 correctness, just "nicer". */
1827 for (i = VEC_length (varobj_p, changed) - 1; i >= 0; --i)
1829 varobj_p tmp = VEC_index (varobj_p, changed, i);
1830 varobj_update_result r = {0};
1834 r.value_installed = 1;
1835 VEC_safe_push (varobj_update_result, stack, &r);
1837 for (i = VEC_length (varobj_p, unchanged) - 1; i >= 0; --i)
1839 varobj_p tmp = VEC_index (varobj_p, unchanged, i);
1843 varobj_update_result r = {0};
1846 r.value_installed = 1;
1847 VEC_safe_push (varobj_update_result, stack, &r);
1850 if (r.changed || r.children_changed)
1851 VEC_safe_push (varobj_update_result, result, &r);
1853 /* Free CHANGED and UNCHANGED, but not NEW, because NEW
1854 has been put into the result vector. */
1855 VEC_free (varobj_p, changed);
1856 VEC_free (varobj_p, unchanged);
1862 /* Push any children. Use reverse order so that the first
1863 child is popped from the work stack first, and so
1864 will be added to result first. This does not
1865 affect correctness, just "nicer". */
1866 for (i = VEC_length (varobj_p, v->children)-1; i >= 0; --i)
1868 varobj_p c = VEC_index (varobj_p, v->children, i);
1870 /* Child may be NULL if explicitly deleted by -var-delete. */
1871 if (c != NULL && !c->frozen)
1873 varobj_update_result r = {0};
1876 VEC_safe_push (varobj_update_result, stack, &r);
1880 if (r.changed || r.type_changed)
1881 VEC_safe_push (varobj_update_result, result, &r);
1884 VEC_free (varobj_update_result, stack);
1890 /* Helper functions */
1893 * Variable object construction/destruction
1897 delete_variable (struct cpstack **resultp, struct varobj *var,
1898 int only_children_p)
1902 delete_variable_1 (resultp, &delcount, var,
1903 only_children_p, 1 /* remove_from_parent_p */ );
1908 /* Delete the variable object VAR and its children. */
1909 /* IMPORTANT NOTE: If we delete a variable which is a child
1910 and the parent is not removed we dump core. It must be always
1911 initially called with remove_from_parent_p set. */
1913 delete_variable_1 (struct cpstack **resultp, int *delcountp,
1914 struct varobj *var, int only_children_p,
1915 int remove_from_parent_p)
1919 /* Delete any children of this variable, too. */
1920 for (i = 0; i < VEC_length (varobj_p, var->children); ++i)
1922 varobj_p child = VEC_index (varobj_p, var->children, i);
1926 if (!remove_from_parent_p)
1927 child->parent = NULL;
1928 delete_variable_1 (resultp, delcountp, child, 0, only_children_p);
1930 VEC_free (varobj_p, var->children);
1932 /* if we were called to delete only the children we are done here. */
1933 if (only_children_p)
1936 /* Otherwise, add it to the list of deleted ones and proceed to do so. */
1937 /* If the name is null, this is a temporary variable, that has not
1938 yet been installed, don't report it, it belongs to the caller... */
1939 if (var->obj_name != NULL)
1941 cppush (resultp, xstrdup (var->obj_name));
1942 *delcountp = *delcountp + 1;
1945 /* If this variable has a parent, remove it from its parent's list. */
1946 /* OPTIMIZATION: if the parent of this variable is also being deleted,
1947 (as indicated by remove_from_parent_p) we don't bother doing an
1948 expensive list search to find the element to remove when we are
1949 discarding the list afterwards. */
1950 if ((remove_from_parent_p) && (var->parent != NULL))
1952 VEC_replace (varobj_p, var->parent->children, var->index, NULL);
1955 if (var->obj_name != NULL)
1956 uninstall_variable (var);
1958 /* Free memory associated with this variable. */
1959 free_variable (var);
1962 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
1964 install_variable (struct varobj *var)
1967 struct vlist *newvl;
1969 unsigned int index = 0;
1972 for (chp = var->obj_name; *chp; chp++)
1974 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
1977 cv = *(varobj_table + index);
1978 while ((cv != NULL) && (strcmp (cv->var->obj_name, var->obj_name) != 0))
1982 error (_("Duplicate variable object name"));
1984 /* Add varobj to hash table. */
1985 newvl = xmalloc (sizeof (struct vlist));
1986 newvl->next = *(varobj_table + index);
1988 *(varobj_table + index) = newvl;
1990 /* If root, add varobj to root list. */
1991 if (is_root_p (var))
1993 /* Add to list of root variables. */
1994 if (rootlist == NULL)
1995 var->root->next = NULL;
1997 var->root->next = rootlist;
1998 rootlist = var->root;
2004 /* Unistall the object VAR. */
2006 uninstall_variable (struct varobj *var)
2010 struct varobj_root *cr;
2011 struct varobj_root *prer;
2013 unsigned int index = 0;
2016 /* Remove varobj from hash table. */
2017 for (chp = var->obj_name; *chp; chp++)
2019 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
2022 cv = *(varobj_table + index);
2024 while ((cv != NULL) && (strcmp (cv->var->obj_name, var->obj_name) != 0))
2031 fprintf_unfiltered (gdb_stdlog, "Deleting %s\n", var->obj_name);
2036 ("Assertion failed: Could not find variable object \"%s\" to delete",
2042 *(varobj_table + index) = cv->next;
2044 prev->next = cv->next;
2048 /* If root, remove varobj from root list. */
2049 if (is_root_p (var))
2051 /* Remove from list of root variables. */
2052 if (rootlist == var->root)
2053 rootlist = var->root->next;
2058 while ((cr != NULL) && (cr->rootvar != var))
2065 warning (_("Assertion failed: Could not find "
2066 "varobj \"%s\" in root list"),
2073 prer->next = cr->next;
2079 /* Create and install a child of the parent of the given name. */
2080 static struct varobj *
2081 create_child (struct varobj *parent, int index, char *name)
2083 return create_child_with_value (parent, index, name,
2084 value_of_child (parent, index));
2087 static struct varobj *
2088 create_child_with_value (struct varobj *parent, int index, const char *name,
2089 struct value *value)
2091 struct varobj *child;
2094 child = new_variable ();
2096 /* Name is allocated by name_of_child. */
2097 /* FIXME: xstrdup should not be here. */
2098 child->name = xstrdup (name);
2099 child->index = index;
2100 child->parent = parent;
2101 child->root = parent->root;
2102 childs_name = xstrprintf ("%s.%s", parent->obj_name, name);
2103 child->obj_name = childs_name;
2104 install_variable (child);
2106 /* Compute the type of the child. Must do this before
2107 calling install_new_value. */
2109 /* If the child had no evaluation errors, var->value
2110 will be non-NULL and contain a valid type. */
2111 child->type = value_type (value);
2113 /* Otherwise, we must compute the type. */
2114 child->type = (*child->root->lang->type_of_child) (child->parent,
2116 install_new_value (child, value, 1);
2123 * Miscellaneous utility functions.
2126 /* Allocate memory and initialize a new variable. */
2127 static struct varobj *
2132 var = (struct varobj *) xmalloc (sizeof (struct varobj));
2134 var->path_expr = NULL;
2135 var->obj_name = NULL;
2139 var->num_children = -1;
2141 var->children = NULL;
2145 var->print_value = NULL;
2147 var->not_fetched = 0;
2148 var->children_requested = 0;
2151 var->constructor = 0;
2152 var->pretty_printer = 0;
2153 var->child_iter = 0;
2154 var->saved_item = 0;
2159 /* Allocate memory and initialize a new root variable. */
2160 static struct varobj *
2161 new_root_variable (void)
2163 struct varobj *var = new_variable ();
2165 var->root = (struct varobj_root *) xmalloc (sizeof (struct varobj_root));
2166 var->root->lang = NULL;
2167 var->root->exp = NULL;
2168 var->root->valid_block = NULL;
2169 var->root->frame = null_frame_id;
2170 var->root->floating = 0;
2171 var->root->rootvar = NULL;
2172 var->root->is_valid = 1;
2177 /* Free any allocated memory associated with VAR. */
2179 free_variable (struct varobj *var)
2182 if (var->pretty_printer)
2184 struct cleanup *cleanup = varobj_ensure_python_env (var);
2185 Py_XDECREF (var->constructor);
2186 Py_XDECREF (var->pretty_printer);
2187 Py_XDECREF (var->child_iter);
2188 Py_XDECREF (var->saved_item);
2189 do_cleanups (cleanup);
2193 value_free (var->value);
2195 /* Free the expression if this is a root variable. */
2196 if (is_root_p (var))
2198 xfree (var->root->exp);
2203 xfree (var->obj_name);
2204 xfree (var->print_value);
2205 xfree (var->path_expr);
2210 do_free_variable_cleanup (void *var)
2212 free_variable (var);
2215 static struct cleanup *
2216 make_cleanup_free_variable (struct varobj *var)
2218 return make_cleanup (do_free_variable_cleanup, var);
2221 /* This returns the type of the variable. It also skips past typedefs
2222 to return the real type of the variable.
2224 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
2225 except within get_target_type and get_type. */
2226 static struct type *
2227 get_type (struct varobj *var)
2233 type = check_typedef (type);
2238 /* Return the type of the value that's stored in VAR,
2239 or that would have being stored there if the
2240 value were accessible.
2242 This differs from VAR->type in that VAR->type is always
2243 the true type of the expession in the source language.
2244 The return value of this function is the type we're
2245 actually storing in varobj, and using for displaying
2246 the values and for comparing previous and new values.
2248 For example, top-level references are always stripped. */
2249 static struct type *
2250 get_value_type (struct varobj *var)
2255 type = value_type (var->value);
2259 type = check_typedef (type);
2261 if (TYPE_CODE (type) == TYPE_CODE_REF)
2262 type = get_target_type (type);
2264 type = check_typedef (type);
2269 /* This returns the target type (or NULL) of TYPE, also skipping
2270 past typedefs, just like get_type ().
2272 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
2273 except within get_target_type and get_type. */
2274 static struct type *
2275 get_target_type (struct type *type)
2279 type = TYPE_TARGET_TYPE (type);
2281 type = check_typedef (type);
2287 /* What is the default display for this variable? We assume that
2288 everything is "natural". Any exceptions? */
2289 static enum varobj_display_formats
2290 variable_default_display (struct varobj *var)
2292 return FORMAT_NATURAL;
2295 /* FIXME: The following should be generic for any pointer. */
2297 cppush (struct cpstack **pstack, char *name)
2301 s = (struct cpstack *) xmalloc (sizeof (struct cpstack));
2307 /* FIXME: The following should be generic for any pointer. */
2309 cppop (struct cpstack **pstack)
2314 if ((*pstack)->name == NULL && (*pstack)->next == NULL)
2319 *pstack = (*pstack)->next;
2326 * Language-dependencies
2329 /* Common entry points */
2331 /* Get the language of variable VAR. */
2332 static enum varobj_languages
2333 variable_language (struct varobj *var)
2335 enum varobj_languages lang;
2337 switch (var->root->exp->language_defn->la_language)
2343 case language_cplus:
2354 /* Return the number of children for a given variable.
2355 The result of this function is defined by the language
2356 implementation. The number of children returned by this function
2357 is the number of children that the user will see in the variable
2360 number_of_children (struct varobj *var)
2362 return (*var->root->lang->number_of_children) (var);
2365 /* What is the expression for the root varobj VAR? Returns a malloc'd
2368 name_of_variable (struct varobj *var)
2370 return (*var->root->lang->name_of_variable) (var);
2373 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd
2376 name_of_child (struct varobj *var, int index)
2378 return (*var->root->lang->name_of_child) (var, index);
2381 /* What is the ``struct value *'' of the root variable VAR?
2382 For floating variable object, evaluation can get us a value
2383 of different type from what is stored in varobj already. In
2385 - *type_changed will be set to 1
2386 - old varobj will be freed, and new one will be
2387 created, with the same name.
2388 - *var_handle will be set to the new varobj
2389 Otherwise, *type_changed will be set to 0. */
2390 static struct value *
2391 value_of_root (struct varobj **var_handle, int *type_changed)
2395 if (var_handle == NULL)
2400 /* This should really be an exception, since this should
2401 only get called with a root variable. */
2403 if (!is_root_p (var))
2406 if (var->root->floating)
2408 struct varobj *tmp_var;
2409 char *old_type, *new_type;
2411 tmp_var = varobj_create (NULL, var->name, (CORE_ADDR) 0,
2412 USE_SELECTED_FRAME);
2413 if (tmp_var == NULL)
2417 old_type = varobj_get_type (var);
2418 new_type = varobj_get_type (tmp_var);
2419 if (strcmp (old_type, new_type) == 0)
2421 /* The expression presently stored inside var->root->exp
2422 remembers the locations of local variables relatively to
2423 the frame where the expression was created (in DWARF location
2424 button, for example). Naturally, those locations are not
2425 correct in other frames, so update the expression. */
2427 struct expression *tmp_exp = var->root->exp;
2429 var->root->exp = tmp_var->root->exp;
2430 tmp_var->root->exp = tmp_exp;
2432 varobj_delete (tmp_var, NULL, 0);
2437 tmp_var->obj_name = xstrdup (var->obj_name);
2438 tmp_var->from = var->from;
2439 tmp_var->to = var->to;
2440 varobj_delete (var, NULL, 0);
2442 install_variable (tmp_var);
2443 *var_handle = tmp_var;
2455 return (*var->root->lang->value_of_root) (var_handle);
2458 /* What is the ``struct value *'' for the INDEX'th child of PARENT? */
2459 static struct value *
2460 value_of_child (struct varobj *parent, int index)
2462 struct value *value;
2464 value = (*parent->root->lang->value_of_child) (parent, index);
2469 /* GDB already has a command called "value_of_variable". Sigh. */
2471 my_value_of_variable (struct varobj *var, enum varobj_display_formats format)
2473 if (var->root->is_valid)
2475 if (var->pretty_printer)
2476 return value_get_print_value (var->value, var->format, var);
2477 return (*var->root->lang->value_of_variable) (var, format);
2484 value_get_print_value (struct value *value, enum varobj_display_formats format,
2487 struct ui_file *stb;
2488 struct cleanup *old_chain;
2489 gdb_byte *thevalue = NULL;
2490 struct value_print_options opts;
2491 struct type *type = NULL;
2493 char *encoding = NULL;
2494 struct gdbarch *gdbarch = NULL;
2495 /* Initialize it just to avoid a GCC false warning. */
2496 CORE_ADDR str_addr = 0;
2497 int string_print = 0;
2502 stb = mem_fileopen ();
2503 old_chain = make_cleanup_ui_file_delete (stb);
2505 gdbarch = get_type_arch (value_type (value));
2508 PyObject *value_formatter = var->pretty_printer;
2510 varobj_ensure_python_env (var);
2512 if (value_formatter)
2514 /* First check to see if we have any children at all. If so,
2515 we simply return {...}. */
2516 if (dynamic_varobj_has_child_method (var))
2518 do_cleanups (old_chain);
2519 return xstrdup ("{...}");
2522 if (PyObject_HasAttr (value_formatter, gdbpy_to_string_cst))
2525 struct value *replacement;
2526 PyObject *output = NULL;
2528 hint = gdbpy_get_display_hint (value_formatter);
2531 if (!strcmp (hint, "string"))
2536 output = apply_varobj_pretty_printer (value_formatter,
2541 make_cleanup_py_decref (output);
2543 if (gdbpy_is_lazy_string (output))
2545 gdbpy_extract_lazy_string (output, &str_addr, &type,
2547 make_cleanup (free_current_contents, &encoding);
2553 = python_string_to_target_python_string (output);
2557 char *s = PyString_AsString (py_str);
2559 len = PyString_Size (py_str);
2560 thevalue = xmemdup (s, len + 1, len + 1);
2561 type = builtin_type (gdbarch)->builtin_char;
2566 do_cleanups (old_chain);
2570 make_cleanup (xfree, thevalue);
2573 gdbpy_print_stack ();
2577 value = replacement;
2583 get_formatted_print_options (&opts, format_code[(int) format]);
2587 LA_PRINT_STRING (stb, type, thevalue, len, encoding, 0, &opts);
2588 else if (string_print)
2589 val_print_string (type, encoding, str_addr, len, stb, &opts);
2591 common_val_print (value, stb, 0, &opts, current_language);
2592 thevalue = ui_file_xstrdup (stb, NULL);
2594 do_cleanups (old_chain);
2599 varobj_editable_p (struct varobj *var)
2603 if (!(var->root->is_valid && var->value && VALUE_LVAL (var->value)))
2606 type = get_value_type (var);
2608 switch (TYPE_CODE (type))
2610 case TYPE_CODE_STRUCT:
2611 case TYPE_CODE_UNION:
2612 case TYPE_CODE_ARRAY:
2613 case TYPE_CODE_FUNC:
2614 case TYPE_CODE_METHOD:
2624 /* Return non-zero if changes in value of VAR
2625 must be detected and reported by -var-update.
2626 Return zero is -var-update should never report
2627 changes of such values. This makes sense for structures
2628 (since the changes in children values will be reported separately),
2629 or for artifical objects (like 'public' pseudo-field in C++).
2631 Return value of 0 means that gdb need not call value_fetch_lazy
2632 for the value of this variable object. */
2634 varobj_value_is_changeable_p (struct varobj *var)
2639 if (CPLUS_FAKE_CHILD (var))
2642 type = get_value_type (var);
2644 switch (TYPE_CODE (type))
2646 case TYPE_CODE_STRUCT:
2647 case TYPE_CODE_UNION:
2648 case TYPE_CODE_ARRAY:
2659 /* Return 1 if that varobj is floating, that is is always evaluated in the
2660 selected frame, and not bound to thread/frame. Such variable objects
2661 are created using '@' as frame specifier to -var-create. */
2663 varobj_floating_p (struct varobj *var)
2665 return var->root->floating;
2668 /* Given the value and the type of a variable object,
2669 adjust the value and type to those necessary
2670 for getting children of the variable object.
2671 This includes dereferencing top-level references
2672 to all types and dereferencing pointers to
2675 Both TYPE and *TYPE should be non-null. VALUE
2676 can be null if we want to only translate type.
2677 *VALUE can be null as well -- if the parent
2680 If WAS_PTR is not NULL, set *WAS_PTR to 0 or 1
2681 depending on whether pointer was dereferenced
2682 in this function. */
2684 adjust_value_for_child_access (struct value **value,
2688 gdb_assert (type && *type);
2693 *type = check_typedef (*type);
2695 /* The type of value stored in varobj, that is passed
2696 to us, is already supposed to be
2697 reference-stripped. */
2699 gdb_assert (TYPE_CODE (*type) != TYPE_CODE_REF);
2701 /* Pointers to structures are treated just like
2702 structures when accessing children. Don't
2703 dererences pointers to other types. */
2704 if (TYPE_CODE (*type) == TYPE_CODE_PTR)
2706 struct type *target_type = get_target_type (*type);
2707 if (TYPE_CODE (target_type) == TYPE_CODE_STRUCT
2708 || TYPE_CODE (target_type) == TYPE_CODE_UNION)
2710 if (value && *value)
2712 int success = gdb_value_ind (*value, value);
2717 *type = target_type;
2723 /* The 'get_target_type' function calls check_typedef on
2724 result, so we can immediately check type code. No
2725 need to call check_typedef here. */
2730 c_number_of_children (struct varobj *var)
2732 struct type *type = get_value_type (var);
2734 struct type *target;
2736 adjust_value_for_child_access (NULL, &type, NULL);
2737 target = get_target_type (type);
2739 switch (TYPE_CODE (type))
2741 case TYPE_CODE_ARRAY:
2742 if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (target) > 0
2743 && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))
2744 children = TYPE_LENGTH (type) / TYPE_LENGTH (target);
2746 /* If we don't know how many elements there are, don't display
2751 case TYPE_CODE_STRUCT:
2752 case TYPE_CODE_UNION:
2753 children = TYPE_NFIELDS (type);
2757 /* The type here is a pointer to non-struct. Typically, pointers
2758 have one child, except for function ptrs, which have no children,
2759 and except for void*, as we don't know what to show.
2761 We can show char* so we allow it to be dereferenced. If you decide
2762 to test for it, please mind that a little magic is necessary to
2763 properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
2764 TYPE_NAME == "char". */
2765 if (TYPE_CODE (target) == TYPE_CODE_FUNC
2766 || TYPE_CODE (target) == TYPE_CODE_VOID)
2773 /* Other types have no children. */
2781 c_name_of_variable (struct varobj *parent)
2783 return xstrdup (parent->name);
2786 /* Return the value of element TYPE_INDEX of a structure
2787 value VALUE. VALUE's type should be a structure,
2788 or union, or a typedef to struct/union.
2790 Returns NULL if getting the value fails. Never throws. */
2791 static struct value *
2792 value_struct_element_index (struct value *value, int type_index)
2794 struct value *result = NULL;
2795 volatile struct gdb_exception e;
2796 struct type *type = value_type (value);
2798 type = check_typedef (type);
2800 gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
2801 || TYPE_CODE (type) == TYPE_CODE_UNION);
2803 TRY_CATCH (e, RETURN_MASK_ERROR)
2805 if (field_is_static (&TYPE_FIELD (type, type_index)))
2806 result = value_static_field (type, type_index);
2808 result = value_primitive_field (value, 0, type_index, type);
2820 /* Obtain the information about child INDEX of the variable
2822 If CNAME is not null, sets *CNAME to the name of the child relative
2824 If CVALUE is not null, sets *CVALUE to the value of the child.
2825 If CTYPE is not null, sets *CTYPE to the type of the child.
2827 If any of CNAME, CVALUE, or CTYPE is not null, but the corresponding
2828 information cannot be determined, set *CNAME, *CVALUE, or *CTYPE
2831 c_describe_child (struct varobj *parent, int index,
2832 char **cname, struct value **cvalue, struct type **ctype,
2833 char **cfull_expression)
2835 struct value *value = parent->value;
2836 struct type *type = get_value_type (parent);
2837 char *parent_expression = NULL;
2846 if (cfull_expression)
2848 *cfull_expression = NULL;
2849 parent_expression = varobj_get_path_expr (parent);
2851 adjust_value_for_child_access (&value, &type, &was_ptr);
2853 switch (TYPE_CODE (type))
2855 case TYPE_CODE_ARRAY:
2858 = xstrdup (int_string (index
2859 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)),
2862 if (cvalue && value)
2864 int real_index = index + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type));
2866 gdb_value_subscript (value, real_index, cvalue);
2870 *ctype = get_target_type (type);
2872 if (cfull_expression)
2874 xstrprintf ("(%s)[%s]", parent_expression,
2876 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)),
2882 case TYPE_CODE_STRUCT:
2883 case TYPE_CODE_UNION:
2885 *cname = xstrdup (TYPE_FIELD_NAME (type, index));
2887 if (cvalue && value)
2889 /* For C, varobj index is the same as type index. */
2890 *cvalue = value_struct_element_index (value, index);
2894 *ctype = TYPE_FIELD_TYPE (type, index);
2896 if (cfull_expression)
2898 char *join = was_ptr ? "->" : ".";
2900 *cfull_expression = xstrprintf ("(%s)%s%s", parent_expression, join,
2901 TYPE_FIELD_NAME (type, index));
2908 *cname = xstrprintf ("*%s", parent->name);
2910 if (cvalue && value)
2912 int success = gdb_value_ind (value, cvalue);
2918 /* Don't use get_target_type because it calls
2919 check_typedef and here, we want to show the true
2920 declared type of the variable. */
2922 *ctype = TYPE_TARGET_TYPE (type);
2924 if (cfull_expression)
2925 *cfull_expression = xstrprintf ("*(%s)", parent_expression);
2930 /* This should not happen. */
2932 *cname = xstrdup ("???");
2933 if (cfull_expression)
2934 *cfull_expression = xstrdup ("???");
2935 /* Don't set value and type, we don't know then. */
2940 c_name_of_child (struct varobj *parent, int index)
2944 c_describe_child (parent, index, &name, NULL, NULL, NULL);
2949 c_path_expr_of_child (struct varobj *child)
2951 c_describe_child (child->parent, child->index, NULL, NULL, NULL,
2953 return child->path_expr;
2956 /* If frame associated with VAR can be found, switch
2957 to it and return 1. Otherwise, return 0. */
2959 check_scope (struct varobj *var)
2961 struct frame_info *fi;
2964 fi = frame_find_by_id (var->root->frame);
2969 CORE_ADDR pc = get_frame_pc (fi);
2971 if (pc < BLOCK_START (var->root->valid_block) ||
2972 pc >= BLOCK_END (var->root->valid_block))
2980 static struct value *
2981 c_value_of_root (struct varobj **var_handle)
2983 struct value *new_val = NULL;
2984 struct varobj *var = *var_handle;
2985 int within_scope = 0;
2986 struct cleanup *back_to;
2988 /* Only root variables can be updated... */
2989 if (!is_root_p (var))
2990 /* Not a root var. */
2993 back_to = make_cleanup_restore_current_thread ();
2995 /* Determine whether the variable is still around. */
2996 if (var->root->valid_block == NULL || var->root->floating)
2998 else if (var->root->thread_id == 0)
3000 /* The program was single-threaded when the variable object was
3001 created. Technically, it's possible that the program became
3002 multi-threaded since then, but we don't support such
3004 within_scope = check_scope (var);
3008 ptid_t ptid = thread_id_to_pid (var->root->thread_id);
3009 if (in_thread_list (ptid))
3011 switch_to_thread (ptid);
3012 within_scope = check_scope (var);
3018 /* We need to catch errors here, because if evaluate
3019 expression fails we want to just return NULL. */
3020 gdb_evaluate_expression (var->root->exp, &new_val);
3024 do_cleanups (back_to);
3029 static struct value *
3030 c_value_of_child (struct varobj *parent, int index)
3032 struct value *value = NULL;
3034 c_describe_child (parent, index, NULL, &value, NULL, NULL);
3038 static struct type *
3039 c_type_of_child (struct varobj *parent, int index)
3041 struct type *type = NULL;
3043 c_describe_child (parent, index, NULL, NULL, &type, NULL);
3048 c_value_of_variable (struct varobj *var, enum varobj_display_formats format)
3050 /* BOGUS: if val_print sees a struct/class, or a reference to one,
3051 it will print out its children instead of "{...}". So we need to
3052 catch that case explicitly. */
3053 struct type *type = get_type (var);
3055 /* If we have a custom formatter, return whatever string it has
3057 if (var->pretty_printer && var->print_value)
3058 return xstrdup (var->print_value);
3060 /* Strip top-level references. */
3061 while (TYPE_CODE (type) == TYPE_CODE_REF)
3062 type = check_typedef (TYPE_TARGET_TYPE (type));
3064 switch (TYPE_CODE (type))
3066 case TYPE_CODE_STRUCT:
3067 case TYPE_CODE_UNION:
3068 return xstrdup ("{...}");
3071 case TYPE_CODE_ARRAY:
3075 number = xstrprintf ("[%d]", var->num_children);
3082 if (var->value == NULL)
3084 /* This can happen if we attempt to get the value of a struct
3085 member when the parent is an invalid pointer. This is an
3086 error condition, so we should tell the caller. */
3091 if (var->not_fetched && value_lazy (var->value))
3092 /* Frozen variable and no value yet. We don't
3093 implicitly fetch the value. MI response will
3094 use empty string for the value, which is OK. */
3097 gdb_assert (varobj_value_is_changeable_p (var));
3098 gdb_assert (!value_lazy (var->value));
3100 /* If the specified format is the current one,
3101 we can reuse print_value. */
3102 if (format == var->format)
3103 return xstrdup (var->print_value);
3105 return value_get_print_value (var->value, format, var);
3115 cplus_number_of_children (struct varobj *var)
3118 int children, dont_know;
3123 if (!CPLUS_FAKE_CHILD (var))
3125 type = get_value_type (var);
3126 adjust_value_for_child_access (NULL, &type, NULL);
3128 if (((TYPE_CODE (type)) == TYPE_CODE_STRUCT) ||
3129 ((TYPE_CODE (type)) == TYPE_CODE_UNION))
3133 cplus_class_num_children (type, kids);
3134 if (kids[v_public] != 0)
3136 if (kids[v_private] != 0)
3138 if (kids[v_protected] != 0)
3141 /* Add any baseclasses. */
3142 children += TYPE_N_BASECLASSES (type);
3145 /* FIXME: save children in var. */
3152 type = get_value_type (var->parent);
3153 adjust_value_for_child_access (NULL, &type, NULL);
3155 cplus_class_num_children (type, kids);
3156 if (strcmp (var->name, "public") == 0)
3157 children = kids[v_public];
3158 else if (strcmp (var->name, "private") == 0)
3159 children = kids[v_private];
3161 children = kids[v_protected];
3166 children = c_number_of_children (var);
3171 /* Compute # of public, private, and protected variables in this class.
3172 That means we need to descend into all baseclasses and find out
3173 how many are there, too. */
3175 cplus_class_num_children (struct type *type, int children[3])
3177 int i, vptr_fieldno;
3178 struct type *basetype = NULL;
3180 children[v_public] = 0;
3181 children[v_private] = 0;
3182 children[v_protected] = 0;
3184 vptr_fieldno = get_vptr_fieldno (type, &basetype);
3185 for (i = TYPE_N_BASECLASSES (type); i < TYPE_NFIELDS (type); i++)
3187 /* If we have a virtual table pointer, omit it. Even if virtual
3188 table pointers are not specifically marked in the debug info,
3189 they should be artificial. */
3190 if ((type == basetype && i == vptr_fieldno)
3191 || TYPE_FIELD_ARTIFICIAL (type, i))
3194 if (TYPE_FIELD_PROTECTED (type, i))
3195 children[v_protected]++;
3196 else if (TYPE_FIELD_PRIVATE (type, i))
3197 children[v_private]++;
3199 children[v_public]++;
3204 cplus_name_of_variable (struct varobj *parent)
3206 return c_name_of_variable (parent);
3209 enum accessibility { private_field, protected_field, public_field };
3211 /* Check if field INDEX of TYPE has the specified accessibility.
3212 Return 0 if so and 1 otherwise. */
3214 match_accessibility (struct type *type, int index, enum accessibility acc)
3216 if (acc == private_field && TYPE_FIELD_PRIVATE (type, index))
3218 else if (acc == protected_field && TYPE_FIELD_PROTECTED (type, index))
3220 else if (acc == public_field && !TYPE_FIELD_PRIVATE (type, index)
3221 && !TYPE_FIELD_PROTECTED (type, index))
3228 cplus_describe_child (struct varobj *parent, int index,
3229 char **cname, struct value **cvalue, struct type **ctype,
3230 char **cfull_expression)
3232 struct value *value;
3235 char *parent_expression = NULL;
3243 if (cfull_expression)
3244 *cfull_expression = NULL;
3246 if (CPLUS_FAKE_CHILD (parent))
3248 value = parent->parent->value;
3249 type = get_value_type (parent->parent);
3250 if (cfull_expression)
3251 parent_expression = varobj_get_path_expr (parent->parent);
3255 value = parent->value;
3256 type = get_value_type (parent);
3257 if (cfull_expression)
3258 parent_expression = varobj_get_path_expr (parent);
3261 adjust_value_for_child_access (&value, &type, &was_ptr);
3263 if (TYPE_CODE (type) == TYPE_CODE_STRUCT
3264 || TYPE_CODE (type) == TYPE_CODE_UNION)
3266 char *join = was_ptr ? "->" : ".";
3268 if (CPLUS_FAKE_CHILD (parent))
3270 /* The fields of the class type are ordered as they
3271 appear in the class. We are given an index for a
3272 particular access control type ("public","protected",
3273 or "private"). We must skip over fields that don't
3274 have the access control we are looking for to properly
3275 find the indexed field. */
3276 int type_index = TYPE_N_BASECLASSES (type);
3277 enum accessibility acc = public_field;
3279 struct type *basetype = NULL;
3281 vptr_fieldno = get_vptr_fieldno (type, &basetype);
3282 if (strcmp (parent->name, "private") == 0)
3283 acc = private_field;
3284 else if (strcmp (parent->name, "protected") == 0)
3285 acc = protected_field;
3289 if ((type == basetype && type_index == vptr_fieldno)
3290 || TYPE_FIELD_ARTIFICIAL (type, type_index))
3292 else if (match_accessibility (type, type_index, acc))
3299 *cname = xstrdup (TYPE_FIELD_NAME (type, type_index));
3301 if (cvalue && value)
3302 *cvalue = value_struct_element_index (value, type_index);
3305 *ctype = TYPE_FIELD_TYPE (type, type_index);
3307 if (cfull_expression)
3309 = xstrprintf ("((%s)%s%s)", parent_expression,
3311 TYPE_FIELD_NAME (type, type_index));
3313 else if (index < TYPE_N_BASECLASSES (type))
3315 /* This is a baseclass. */
3317 *cname = xstrdup (TYPE_FIELD_NAME (type, index));
3319 if (cvalue && value)
3320 *cvalue = value_cast (TYPE_FIELD_TYPE (type, index), value);
3324 *ctype = TYPE_FIELD_TYPE (type, index);
3327 if (cfull_expression)
3329 char *ptr = was_ptr ? "*" : "";
3331 /* Cast the parent to the base' type. Note that in gdb,
3334 will create an lvalue, for all appearences, so we don't
3335 need to use more fancy:
3338 *cfull_expression = xstrprintf ("(%s(%s%s) %s)",
3340 TYPE_FIELD_NAME (type, index),
3347 char *access = NULL;
3350 cplus_class_num_children (type, children);
3352 /* Everything beyond the baseclasses can
3353 only be "public", "private", or "protected"
3355 The special "fake" children are always output by varobj in
3356 this order. So if INDEX == 2, it MUST be "protected". */
3357 index -= TYPE_N_BASECLASSES (type);
3361 if (children[v_public] > 0)
3363 else if (children[v_private] > 0)
3366 access = "protected";
3369 if (children[v_public] > 0)
3371 if (children[v_private] > 0)
3374 access = "protected";
3376 else if (children[v_private] > 0)
3377 access = "protected";
3380 /* Must be protected. */
3381 access = "protected";
3388 gdb_assert (access);
3390 *cname = xstrdup (access);
3392 /* Value and type and full expression are null here. */
3397 c_describe_child (parent, index, cname, cvalue, ctype, cfull_expression);
3402 cplus_name_of_child (struct varobj *parent, int index)
3406 cplus_describe_child (parent, index, &name, NULL, NULL, NULL);
3411 cplus_path_expr_of_child (struct varobj *child)
3413 cplus_describe_child (child->parent, child->index, NULL, NULL, NULL,
3415 return child->path_expr;
3418 static struct value *
3419 cplus_value_of_root (struct varobj **var_handle)
3421 return c_value_of_root (var_handle);
3424 static struct value *
3425 cplus_value_of_child (struct varobj *parent, int index)
3427 struct value *value = NULL;
3429 cplus_describe_child (parent, index, NULL, &value, NULL, NULL);
3433 static struct type *
3434 cplus_type_of_child (struct varobj *parent, int index)
3436 struct type *type = NULL;
3438 cplus_describe_child (parent, index, NULL, NULL, &type, NULL);
3443 cplus_value_of_variable (struct varobj *var,
3444 enum varobj_display_formats format)
3447 /* If we have one of our special types, don't print out
3449 if (CPLUS_FAKE_CHILD (var))
3450 return xstrdup ("");
3452 return c_value_of_variable (var, format);
3458 java_number_of_children (struct varobj *var)
3460 return cplus_number_of_children (var);
3464 java_name_of_variable (struct varobj *parent)
3468 name = cplus_name_of_variable (parent);
3469 /* If the name has "-" in it, it is because we
3470 needed to escape periods in the name... */
3473 while (*p != '\000')
3484 java_name_of_child (struct varobj *parent, int index)
3488 name = cplus_name_of_child (parent, index);
3489 /* Escape any periods in the name... */
3492 while (*p != '\000')
3503 java_path_expr_of_child (struct varobj *child)
3508 static struct value *
3509 java_value_of_root (struct varobj **var_handle)
3511 return cplus_value_of_root (var_handle);
3514 static struct value *
3515 java_value_of_child (struct varobj *parent, int index)
3517 return cplus_value_of_child (parent, index);
3520 static struct type *
3521 java_type_of_child (struct varobj *parent, int index)
3523 return cplus_type_of_child (parent, index);
3527 java_value_of_variable (struct varobj *var, enum varobj_display_formats format)
3529 return cplus_value_of_variable (var, format);
3532 /* Iterate all the existing _root_ VAROBJs and call the FUNC callback for them
3533 with an arbitrary caller supplied DATA pointer. */
3536 all_root_varobjs (void (*func) (struct varobj *var, void *data), void *data)
3538 struct varobj_root *var_root, *var_root_next;
3540 /* Iterate "safely" - handle if the callee deletes its passed VAROBJ. */
3542 for (var_root = rootlist; var_root != NULL; var_root = var_root_next)
3544 var_root_next = var_root->next;
3546 (*func) (var_root->rootvar, data);
3550 extern void _initialize_varobj (void);
3552 _initialize_varobj (void)
3554 int sizeof_table = sizeof (struct vlist *) * VAROBJ_TABLE_SIZE;
3556 varobj_table = xmalloc (sizeof_table);
3557 memset (varobj_table, 0, sizeof_table);
3559 add_setshow_zinteger_cmd ("debugvarobj", class_maintenance,
3561 _("Set varobj debugging."),
3562 _("Show varobj debugging."),
3563 _("When non-zero, varobj debugging is enabled."),
3564 NULL, show_varobjdebug,
3565 &setlist, &showlist);
3568 /* Invalidate varobj VAR if it is tied to locals and re-create it if it is
3569 defined on globals. It is a helper for varobj_invalidate. */
3572 varobj_invalidate_iter (struct varobj *var, void *unused)
3574 /* Floating varobjs are reparsed on each stop, so we don't care if the
3575 presently parsed expression refers to something that's gone. */
3576 if (var->root->floating)
3579 /* global var must be re-evaluated. */
3580 if (var->root->valid_block == NULL)
3582 struct varobj *tmp_var;
3584 /* Try to create a varobj with same expression. If we succeed
3585 replace the old varobj, otherwise invalidate it. */
3586 tmp_var = varobj_create (NULL, var->name, (CORE_ADDR) 0,
3588 if (tmp_var != NULL)
3590 tmp_var->obj_name = xstrdup (var->obj_name);
3591 varobj_delete (var, NULL, 0);
3592 install_variable (tmp_var);
3595 var->root->is_valid = 0;
3597 else /* locals must be invalidated. */
3598 var->root->is_valid = 0;
3601 /* Invalidate the varobjs that are tied to locals and re-create the ones that
3602 are defined on globals.
3603 Invalidated varobjs will be always printed in_scope="invalid". */
3606 varobj_invalidate (void)
3608 all_root_varobjs (varobj_invalidate_iter, NULL);