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 /* Ada implementation */
366 static int ada_number_of_children (struct varobj *var);
368 static char *ada_name_of_variable (struct varobj *parent);
370 static char *ada_name_of_child (struct varobj *parent, int index);
372 static char *ada_path_expr_of_child (struct varobj *child);
374 static struct value *ada_value_of_root (struct varobj **var_handle);
376 static struct value *ada_value_of_child (struct varobj *parent, int index);
378 static struct type *ada_type_of_child (struct varobj *parent, int index);
380 static char *ada_value_of_variable (struct varobj *var,
381 enum varobj_display_formats format);
383 /* The language specific vector */
385 struct language_specific
388 /* The language of this variable. */
389 enum varobj_languages language;
391 /* The number of children of PARENT. */
392 int (*number_of_children) (struct varobj * parent);
394 /* The name (expression) of a root varobj. */
395 char *(*name_of_variable) (struct varobj * parent);
397 /* The name of the INDEX'th child of PARENT. */
398 char *(*name_of_child) (struct varobj * parent, int index);
400 /* Returns the rooted expression of CHILD, which is a variable
401 obtain that has some parent. */
402 char *(*path_expr_of_child) (struct varobj * child);
404 /* The ``struct value *'' of the root variable ROOT. */
405 struct value *(*value_of_root) (struct varobj ** root_handle);
407 /* The ``struct value *'' of the INDEX'th child of PARENT. */
408 struct value *(*value_of_child) (struct varobj * parent, int index);
410 /* The type of the INDEX'th child of PARENT. */
411 struct type *(*type_of_child) (struct varobj * parent, int index);
413 /* The current value of VAR. */
414 char *(*value_of_variable) (struct varobj * var,
415 enum varobj_display_formats format);
418 /* Array of known source language routines. */
419 static struct language_specific languages[vlang_end] = {
420 /* Unknown (try treating as C). */
423 c_number_of_children,
426 c_path_expr_of_child,
435 c_number_of_children,
438 c_path_expr_of_child,
447 cplus_number_of_children,
448 cplus_name_of_variable,
450 cplus_path_expr_of_child,
452 cplus_value_of_child,
454 cplus_value_of_variable}
459 java_number_of_children,
460 java_name_of_variable,
462 java_path_expr_of_child,
466 java_value_of_variable},
470 ada_number_of_children,
471 ada_name_of_variable,
473 ada_path_expr_of_child,
477 ada_value_of_variable}
480 /* A little convenience enum for dealing with C++/Java. */
483 v_public = 0, v_private, v_protected
488 /* Mappings of varobj_display_formats enums to gdb's format codes. */
489 static int format_code[] = { 0, 't', 'd', 'x', 'o' };
491 /* Header of the list of root variable objects. */
492 static struct varobj_root *rootlist;
494 /* Prime number indicating the number of buckets in the hash table. */
495 /* A prime large enough to avoid too many colisions. */
496 #define VAROBJ_TABLE_SIZE 227
498 /* Pointer to the varobj hash table (built at run time). */
499 static struct vlist **varobj_table;
501 /* Is the variable X one of our "fake" children? */
502 #define CPLUS_FAKE_CHILD(x) \
503 ((x) != NULL && (x)->type == NULL && (x)->value == NULL)
506 /* API Implementation */
508 is_root_p (struct varobj *var)
510 return (var->root->rootvar == var);
514 /* Helper function to install a Python environment suitable for
515 use during operations on VAR. */
517 varobj_ensure_python_env (struct varobj *var)
519 return ensure_python_env (var->root->exp->gdbarch,
520 var->root->exp->language_defn);
524 /* Creates a varobj (not its children). */
526 /* Return the full FRAME which corresponds to the given CORE_ADDR
527 or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
529 static struct frame_info *
530 find_frame_addr_in_frame_chain (CORE_ADDR frame_addr)
532 struct frame_info *frame = NULL;
534 if (frame_addr == (CORE_ADDR) 0)
537 for (frame = get_current_frame ();
539 frame = get_prev_frame (frame))
541 /* The CORE_ADDR we get as argument was parsed from a string GDB
542 output as $fp. This output got truncated to gdbarch_addr_bit.
543 Truncate the frame base address in the same manner before
544 comparing it against our argument. */
545 CORE_ADDR frame_base = get_frame_base_address (frame);
546 int addr_bit = gdbarch_addr_bit (get_frame_arch (frame));
548 if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
549 frame_base &= ((CORE_ADDR) 1 << addr_bit) - 1;
551 if (frame_base == frame_addr)
559 varobj_create (char *objname,
560 char *expression, CORE_ADDR frame, enum varobj_type type)
563 struct cleanup *old_chain;
565 /* Fill out a varobj structure for the (root) variable being constructed. */
566 var = new_root_variable ();
567 old_chain = make_cleanup_free_variable (var);
569 if (expression != NULL)
571 struct frame_info *fi;
572 struct frame_id old_id = null_frame_id;
575 enum varobj_languages lang;
576 struct value *value = NULL;
578 /* Parse and evaluate the expression, filling in as much of the
579 variable's data as possible. */
581 if (has_stack_frames ())
583 /* Allow creator to specify context of variable. */
584 if ((type == USE_CURRENT_FRAME) || (type == USE_SELECTED_FRAME))
585 fi = get_selected_frame (NULL);
587 /* FIXME: cagney/2002-11-23: This code should be doing a
588 lookup using the frame ID and not just the frame's
589 ``address''. This, of course, means an interface
590 change. However, with out that interface change ISAs,
591 such as the ia64 with its two stacks, won't work.
592 Similar goes for the case where there is a frameless
594 fi = find_frame_addr_in_frame_chain (frame);
599 /* frame = -2 means always use selected frame. */
600 if (type == USE_SELECTED_FRAME)
601 var->root->floating = 1;
605 block = get_frame_block (fi, 0);
608 innermost_block = NULL;
609 /* Wrap the call to parse expression, so we can
610 return a sensible error. */
611 if (!gdb_parse_exp_1 (&p, block, 0, &var->root->exp))
613 do_cleanups (old_chain);
617 /* Don't allow variables to be created for types. */
618 if (var->root->exp->elts[0].opcode == OP_TYPE)
620 do_cleanups (old_chain);
621 fprintf_unfiltered (gdb_stderr, "Attempt to use a type name"
622 " as an expression.\n");
626 var->format = variable_default_display (var);
627 var->root->valid_block = innermost_block;
628 var->name = xstrdup (expression);
629 /* For a root var, the name and the expr are the same. */
630 var->path_expr = xstrdup (expression);
632 /* When the frame is different from the current frame,
633 we must select the appropriate frame before parsing
634 the expression, otherwise the value will not be current.
635 Since select_frame is so benign, just call it for all cases. */
638 /* User could specify explicit FRAME-ADDR which was not found but
639 EXPRESSION is frame specific and we would not be able to evaluate
640 it correctly next time. With VALID_BLOCK set we must also set
641 FRAME and THREAD_ID. */
643 error (_("Failed to find the specified frame"));
645 var->root->frame = get_frame_id (fi);
646 var->root->thread_id = pid_to_thread_id (inferior_ptid);
647 old_id = get_frame_id (get_selected_frame (NULL));
651 /* We definitely need to catch errors here.
652 If evaluate_expression succeeds we got the value we wanted.
653 But if it fails, we still go on with a call to evaluate_type(). */
654 if (!gdb_evaluate_expression (var->root->exp, &value))
656 /* Error getting the value. Try to at least get the
658 struct value *type_only_value = evaluate_type (var->root->exp);
660 var->type = value_type (type_only_value);
663 var->type = value_type (value);
665 install_new_value (var, value, 1 /* Initial assignment */);
667 /* Set language info */
668 lang = variable_language (var);
669 var->root->lang = &languages[lang];
671 /* Set ourselves as our root. */
672 var->root->rootvar = var;
674 /* Reset the selected frame. */
675 if (frame_id_p (old_id))
676 select_frame (frame_find_by_id (old_id));
679 /* If the variable object name is null, that means this
680 is a temporary variable, so don't install it. */
682 if ((var != NULL) && (objname != NULL))
684 var->obj_name = xstrdup (objname);
686 /* If a varobj name is duplicated, the install will fail so
688 if (!install_variable (var))
690 do_cleanups (old_chain);
695 discard_cleanups (old_chain);
699 /* Generates an unique name that can be used for a varobj. */
702 varobj_gen_name (void)
707 /* Generate a name for this object. */
709 obj_name = xstrprintf ("var%d", id);
714 /* Given an OBJNAME, returns the pointer to the corresponding varobj. Call
715 error if OBJNAME cannot be found. */
718 varobj_get_handle (char *objname)
722 unsigned int index = 0;
725 for (chp = objname; *chp; chp++)
727 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
730 cv = *(varobj_table + index);
731 while ((cv != NULL) && (strcmp (cv->var->obj_name, objname) != 0))
735 error (_("Variable object not found"));
740 /* Given the handle, return the name of the object. */
743 varobj_get_objname (struct varobj *var)
745 return var->obj_name;
748 /* Given the handle, return the expression represented by the object. */
751 varobj_get_expression (struct varobj *var)
753 return name_of_variable (var);
756 /* Deletes a varobj and all its children if only_children == 0,
757 otherwise deletes only the children; returns a malloc'ed list of
758 all the (malloc'ed) names of the variables that have been deleted
759 (NULL terminated). */
762 varobj_delete (struct varobj *var, char ***dellist, int only_children)
766 struct cpstack *result = NULL;
769 /* Initialize a stack for temporary results. */
770 cppush (&result, NULL);
773 /* Delete only the variable children. */
774 delcount = delete_variable (&result, var, 1 /* only the children */ );
776 /* Delete the variable and all its children. */
777 delcount = delete_variable (&result, var, 0 /* parent+children */ );
779 /* We may have been asked to return a list of what has been deleted. */
782 *dellist = xmalloc ((delcount + 1) * sizeof (char *));
786 *cp = cppop (&result);
787 while ((*cp != NULL) && (mycount > 0))
791 *cp = cppop (&result);
794 if (mycount || (*cp != NULL))
795 warning (_("varobj_delete: assertion failed - mycount(=%d) <> 0"),
804 /* Convenience function for varobj_set_visualizer. Instantiate a
805 pretty-printer for a given value. */
807 instantiate_pretty_printer (PyObject *constructor, struct value *value)
809 PyObject *val_obj = NULL;
812 val_obj = value_to_value_object (value);
816 printer = PyObject_CallFunctionObjArgs (constructor, val_obj, NULL);
823 /* Set/Get variable object display format. */
825 enum varobj_display_formats
826 varobj_set_display_format (struct varobj *var,
827 enum varobj_display_formats format)
834 case FORMAT_HEXADECIMAL:
836 var->format = format;
840 var->format = variable_default_display (var);
843 if (varobj_value_is_changeable_p (var)
844 && var->value && !value_lazy (var->value))
846 xfree (var->print_value);
847 var->print_value = value_get_print_value (var->value, var->format, var);
853 enum varobj_display_formats
854 varobj_get_display_format (struct varobj *var)
860 varobj_get_display_hint (struct varobj *var)
865 struct cleanup *back_to = varobj_ensure_python_env (var);
867 if (var->pretty_printer)
868 result = gdbpy_get_display_hint (var->pretty_printer);
870 do_cleanups (back_to);
876 /* Return true if the varobj has items after TO, false otherwise. */
879 varobj_has_more (struct varobj *var, int to)
881 if (VEC_length (varobj_p, var->children) > to)
883 return ((to == -1 || VEC_length (varobj_p, var->children) == to)
884 && var->saved_item != NULL);
887 /* If the variable object is bound to a specific thread, that
888 is its evaluation can always be done in context of a frame
889 inside that thread, returns GDB id of the thread -- which
890 is always positive. Otherwise, returns -1. */
892 varobj_get_thread_id (struct varobj *var)
894 if (var->root->valid_block && var->root->thread_id > 0)
895 return var->root->thread_id;
901 varobj_set_frozen (struct varobj *var, int frozen)
903 /* When a variable is unfrozen, we don't fetch its value.
904 The 'not_fetched' flag remains set, so next -var-update
907 We don't fetch the value, because for structures the client
908 should do -var-update anyway. It would be bad to have different
909 client-size logic for structure and other types. */
910 var->frozen = frozen;
914 varobj_get_frozen (struct varobj *var)
919 /* A helper function that restricts a range to what is actually
920 available in a VEC. This follows the usual rules for the meaning
921 of FROM and TO -- if either is negative, the entire range is
925 restrict_range (VEC (varobj_p) *children, int *from, int *to)
927 if (*from < 0 || *to < 0)
930 *to = VEC_length (varobj_p, children);
934 if (*from > VEC_length (varobj_p, children))
935 *from = VEC_length (varobj_p, children);
936 if (*to > VEC_length (varobj_p, children))
937 *to = VEC_length (varobj_p, children);
945 /* A helper for update_dynamic_varobj_children that installs a new
946 child when needed. */
949 install_dynamic_child (struct varobj *var,
950 VEC (varobj_p) **changed,
951 VEC (varobj_p) **new,
952 VEC (varobj_p) **unchanged,
958 if (VEC_length (varobj_p, var->children) < index + 1)
960 /* There's no child yet. */
961 struct varobj *child = varobj_add_child (var, name, value);
965 VEC_safe_push (varobj_p, *new, child);
971 varobj_p existing = VEC_index (varobj_p, var->children, index);
973 if (install_new_value (existing, value, 0))
976 VEC_safe_push (varobj_p, *changed, existing);
979 VEC_safe_push (varobj_p, *unchanged, existing);
984 dynamic_varobj_has_child_method (struct varobj *var)
986 struct cleanup *back_to;
987 PyObject *printer = var->pretty_printer;
990 back_to = varobj_ensure_python_env (var);
991 result = PyObject_HasAttr (printer, gdbpy_children_cst);
992 do_cleanups (back_to);
999 update_dynamic_varobj_children (struct varobj *var,
1000 VEC (varobj_p) **changed,
1001 VEC (varobj_p) **new,
1002 VEC (varobj_p) **unchanged,
1004 int update_children,
1009 struct cleanup *back_to;
1012 PyObject *printer = var->pretty_printer;
1014 back_to = varobj_ensure_python_env (var);
1017 if (!PyObject_HasAttr (printer, gdbpy_children_cst))
1019 do_cleanups (back_to);
1023 if (update_children || !var->child_iter)
1025 children = PyObject_CallMethodObjArgs (printer, gdbpy_children_cst,
1030 gdbpy_print_stack ();
1031 error (_("Null value returned for children"));
1034 make_cleanup_py_decref (children);
1036 if (!PyIter_Check (children))
1037 error (_("Returned value is not iterable"));
1039 Py_XDECREF (var->child_iter);
1040 var->child_iter = PyObject_GetIter (children);
1041 if (!var->child_iter)
1043 gdbpy_print_stack ();
1044 error (_("Could not get children iterator"));
1047 Py_XDECREF (var->saved_item);
1048 var->saved_item = NULL;
1053 i = VEC_length (varobj_p, var->children);
1055 /* We ask for one extra child, so that MI can report whether there
1056 are more children. */
1057 for (; to < 0 || i < to + 1; ++i)
1062 /* See if there was a leftover from last time. */
1063 if (var->saved_item)
1065 item = var->saved_item;
1066 var->saved_item = NULL;
1069 item = PyIter_Next (var->child_iter);
1073 /* Normal end of iteration. */
1074 if (!PyErr_Occurred ())
1077 /* If we got a memory error, just use the text as the
1079 if (PyErr_ExceptionMatches (gdbpy_gdb_memory_error))
1081 PyObject *type, *value, *trace;
1082 char *name_str, *value_str;
1084 PyErr_Fetch (&type, &value, &trace);
1085 value_str = gdbpy_exception_to_string (type, value);
1091 gdbpy_print_stack ();
1095 name_str = xstrprintf ("<error at %d>", i);
1096 item = Py_BuildValue ("(ss)", name_str, value_str);
1101 gdbpy_print_stack ();
1109 /* Any other kind of error. */
1110 gdbpy_print_stack ();
1115 /* We don't want to push the extra child on any report list. */
1116 if (to < 0 || i < to)
1121 struct cleanup *inner;
1122 int can_mention = from < 0 || i >= from;
1124 inner = make_cleanup_py_decref (item);
1126 if (!PyArg_ParseTuple (item, "sO", &name, &py_v))
1128 gdbpy_print_stack ();
1129 error (_("Invalid item from the child list"));
1132 v = convert_value_from_python (py_v);
1134 gdbpy_print_stack ();
1135 install_dynamic_child (var, can_mention ? changed : NULL,
1136 can_mention ? new : NULL,
1137 can_mention ? unchanged : NULL,
1138 can_mention ? cchanged : NULL, i, name, v);
1139 do_cleanups (inner);
1143 Py_XDECREF (var->saved_item);
1144 var->saved_item = item;
1146 /* We want to truncate the child list just before this
1155 if (i < VEC_length (varobj_p, var->children))
1160 for (j = i; j < VEC_length (varobj_p, var->children); ++j)
1161 varobj_delete (VEC_index (varobj_p, var->children, j), NULL, 0);
1162 VEC_truncate (varobj_p, var->children, i);
1165 /* If there are fewer children than requested, note that the list of
1166 children changed. */
1167 if (to >= 0 && VEC_length (varobj_p, var->children) < to)
1170 var->num_children = VEC_length (varobj_p, var->children);
1172 do_cleanups (back_to);
1176 gdb_assert (0 && "should never be called if Python is not enabled");
1181 varobj_get_num_children (struct varobj *var)
1183 if (var->num_children == -1)
1185 if (var->pretty_printer)
1189 /* If we have a dynamic varobj, don't report -1 children.
1190 So, try to fetch some children first. */
1191 update_dynamic_varobj_children (var, NULL, NULL, NULL, &dummy,
1195 var->num_children = number_of_children (var);
1198 return var->num_children >= 0 ? var->num_children : 0;
1201 /* Creates a list of the immediate children of a variable object;
1202 the return code is the number of such children or -1 on error. */
1205 varobj_list_children (struct varobj *var, int *from, int *to)
1208 int i, children_changed;
1210 var->children_requested = 1;
1212 if (var->pretty_printer)
1214 /* This, in theory, can result in the number of children changing without
1215 frontend noticing. But well, calling -var-list-children on the same
1216 varobj twice is not something a sane frontend would do. */
1217 update_dynamic_varobj_children (var, NULL, NULL, NULL, &children_changed,
1219 restrict_range (var->children, from, to);
1220 return var->children;
1223 if (var->num_children == -1)
1224 var->num_children = number_of_children (var);
1226 /* If that failed, give up. */
1227 if (var->num_children == -1)
1228 return var->children;
1230 /* If we're called when the list of children is not yet initialized,
1231 allocate enough elements in it. */
1232 while (VEC_length (varobj_p, var->children) < var->num_children)
1233 VEC_safe_push (varobj_p, var->children, NULL);
1235 for (i = 0; i < var->num_children; i++)
1237 varobj_p existing = VEC_index (varobj_p, var->children, i);
1239 if (existing == NULL)
1241 /* Either it's the first call to varobj_list_children for
1242 this variable object, and the child was never created,
1243 or it was explicitly deleted by the client. */
1244 name = name_of_child (var, i);
1245 existing = create_child (var, i, name);
1246 VEC_replace (varobj_p, var->children, i, existing);
1250 restrict_range (var->children, from, to);
1251 return var->children;
1256 static struct varobj *
1257 varobj_add_child (struct varobj *var, const char *name, struct value *value)
1259 varobj_p v = create_child_with_value (var,
1260 VEC_length (varobj_p, var->children),
1263 VEC_safe_push (varobj_p, var->children, v);
1267 #endif /* HAVE_PYTHON */
1269 /* Obtain the type of an object Variable as a string similar to the one gdb
1270 prints on the console. */
1273 varobj_get_type (struct varobj *var)
1275 /* For the "fake" variables, do not return a type. (It's type is
1277 Do not return a type for invalid variables as well. */
1278 if (CPLUS_FAKE_CHILD (var) || !var->root->is_valid)
1281 return type_to_string (var->type);
1284 /* Obtain the type of an object variable. */
1287 varobj_get_gdb_type (struct varobj *var)
1292 /* Return a pointer to the full rooted expression of varobj VAR.
1293 If it has not been computed yet, compute it. */
1295 varobj_get_path_expr (struct varobj *var)
1297 if (var->path_expr != NULL)
1298 return var->path_expr;
1301 /* For root varobjs, we initialize path_expr
1302 when creating varobj, so here it should be
1304 gdb_assert (!is_root_p (var));
1305 return (*var->root->lang->path_expr_of_child) (var);
1309 enum varobj_languages
1310 varobj_get_language (struct varobj *var)
1312 return variable_language (var);
1316 varobj_get_attributes (struct varobj *var)
1320 if (varobj_editable_p (var))
1321 /* FIXME: define masks for attributes. */
1322 attributes |= 0x00000001; /* Editable */
1328 varobj_pretty_printed_p (struct varobj *var)
1330 return var->pretty_printer != NULL;
1334 varobj_get_formatted_value (struct varobj *var,
1335 enum varobj_display_formats format)
1337 return my_value_of_variable (var, format);
1341 varobj_get_value (struct varobj *var)
1343 return my_value_of_variable (var, var->format);
1346 /* Set the value of an object variable (if it is editable) to the
1347 value of the given expression. */
1348 /* Note: Invokes functions that can call error(). */
1351 varobj_set_value (struct varobj *var, char *expression)
1355 /* The argument "expression" contains the variable's new value.
1356 We need to first construct a legal expression for this -- ugh! */
1357 /* Does this cover all the bases? */
1358 struct expression *exp;
1359 struct value *value;
1360 int saved_input_radix = input_radix;
1361 char *s = expression;
1363 gdb_assert (varobj_editable_p (var));
1365 input_radix = 10; /* ALWAYS reset to decimal temporarily. */
1366 exp = parse_exp_1 (&s, 0, 0);
1367 if (!gdb_evaluate_expression (exp, &value))
1369 /* We cannot proceed without a valid expression. */
1374 /* All types that are editable must also be changeable. */
1375 gdb_assert (varobj_value_is_changeable_p (var));
1377 /* The value of a changeable variable object must not be lazy. */
1378 gdb_assert (!value_lazy (var->value));
1380 /* Need to coerce the input. We want to check if the
1381 value of the variable object will be different
1382 after assignment, and the first thing value_assign
1383 does is coerce the input.
1384 For example, if we are assigning an array to a pointer variable we
1385 should compare the pointer with the array's address, not with the
1387 value = coerce_array (value);
1389 /* The new value may be lazy. gdb_value_assign, or
1390 rather value_contents, will take care of this.
1391 If fetching of the new value will fail, gdb_value_assign
1392 with catch the exception. */
1393 if (!gdb_value_assign (var->value, value, &val))
1396 /* If the value has changed, record it, so that next -var-update can
1397 report this change. If a variable had a value of '1', we've set it
1398 to '333' and then set again to '1', when -var-update will report this
1399 variable as changed -- because the first assignment has set the
1400 'updated' flag. There's no need to optimize that, because return value
1401 of -var-update should be considered an approximation. */
1402 var->updated = install_new_value (var, val, 0 /* Compare values. */);
1403 input_radix = saved_input_radix;
1409 /* A helper function to install a constructor function and visualizer
1413 install_visualizer (struct varobj *var, PyObject *constructor,
1414 PyObject *visualizer)
1416 Py_XDECREF (var->constructor);
1417 var->constructor = constructor;
1419 Py_XDECREF (var->pretty_printer);
1420 var->pretty_printer = visualizer;
1422 Py_XDECREF (var->child_iter);
1423 var->child_iter = NULL;
1426 /* Install the default visualizer for VAR. */
1429 install_default_visualizer (struct varobj *var)
1431 /* Do not install a visualizer on a CPLUS_FAKE_CHILD. */
1432 if (CPLUS_FAKE_CHILD (var))
1435 if (pretty_printing)
1437 PyObject *pretty_printer = NULL;
1441 pretty_printer = gdbpy_get_varobj_pretty_printer (var->value);
1442 if (! pretty_printer)
1444 gdbpy_print_stack ();
1445 error (_("Cannot instantiate printer for default visualizer"));
1449 if (pretty_printer == Py_None)
1451 Py_DECREF (pretty_printer);
1452 pretty_printer = NULL;
1455 install_visualizer (var, NULL, pretty_printer);
1459 /* Instantiate and install a visualizer for VAR using CONSTRUCTOR to
1460 make a new object. */
1463 construct_visualizer (struct varobj *var, PyObject *constructor)
1465 PyObject *pretty_printer;
1467 /* Do not install a visualizer on a CPLUS_FAKE_CHILD. */
1468 if (CPLUS_FAKE_CHILD (var))
1471 Py_INCREF (constructor);
1472 if (constructor == Py_None)
1473 pretty_printer = NULL;
1476 pretty_printer = instantiate_pretty_printer (constructor, var->value);
1477 if (! pretty_printer)
1479 gdbpy_print_stack ();
1480 Py_DECREF (constructor);
1481 constructor = Py_None;
1482 Py_INCREF (constructor);
1485 if (pretty_printer == Py_None)
1487 Py_DECREF (pretty_printer);
1488 pretty_printer = NULL;
1492 install_visualizer (var, constructor, pretty_printer);
1495 #endif /* HAVE_PYTHON */
1497 /* A helper function for install_new_value. This creates and installs
1498 a visualizer for VAR, if appropriate. */
1501 install_new_value_visualizer (struct varobj *var)
1504 /* If the constructor is None, then we want the raw value. If VAR
1505 does not have a value, just skip this. */
1506 if (var->constructor != Py_None && var->value)
1508 struct cleanup *cleanup;
1510 cleanup = varobj_ensure_python_env (var);
1512 if (!var->constructor)
1513 install_default_visualizer (var);
1515 construct_visualizer (var, var->constructor);
1517 do_cleanups (cleanup);
1524 /* Assign a new value to a variable object. If INITIAL is non-zero,
1525 this is the first assignement after the variable object was just
1526 created, or changed type. In that case, just assign the value
1528 Otherwise, assign the new value, and return 1 if the value is
1529 different from the current one, 0 otherwise. The comparison is
1530 done on textual representation of value. Therefore, some types
1531 need not be compared. E.g. for structures the reported value is
1532 always "{...}", so no comparison is necessary here. If the old
1533 value was NULL and new one is not, or vice versa, we always return 1.
1535 The VALUE parameter should not be released -- the function will
1536 take care of releasing it when needed. */
1538 install_new_value (struct varobj *var, struct value *value, int initial)
1543 int intentionally_not_fetched = 0;
1544 char *print_value = NULL;
1546 /* We need to know the varobj's type to decide if the value should
1547 be fetched or not. C++ fake children (public/protected/private)
1548 don't have a type. */
1549 gdb_assert (var->type || CPLUS_FAKE_CHILD (var));
1550 changeable = varobj_value_is_changeable_p (var);
1552 /* If the type has custom visualizer, we consider it to be always
1553 changeable. FIXME: need to make sure this behaviour will not
1554 mess up read-sensitive values. */
1555 if (var->pretty_printer)
1558 need_to_fetch = changeable;
1560 /* We are not interested in the address of references, and given
1561 that in C++ a reference is not rebindable, it cannot
1562 meaningfully change. So, get hold of the real value. */
1564 value = coerce_ref (value);
1566 if (var->type && TYPE_CODE (var->type) == TYPE_CODE_UNION)
1567 /* For unions, we need to fetch the value implicitly because
1568 of implementation of union member fetch. When gdb
1569 creates a value for a field and the value of the enclosing
1570 structure is not lazy, it immediately copies the necessary
1571 bytes from the enclosing values. If the enclosing value is
1572 lazy, the call to value_fetch_lazy on the field will read
1573 the data from memory. For unions, that means we'll read the
1574 same memory more than once, which is not desirable. So
1578 /* The new value might be lazy. If the type is changeable,
1579 that is we'll be comparing values of this type, fetch the
1580 value now. Otherwise, on the next update the old value
1581 will be lazy, which means we've lost that old value. */
1582 if (need_to_fetch && value && value_lazy (value))
1584 struct varobj *parent = var->parent;
1585 int frozen = var->frozen;
1587 for (; !frozen && parent; parent = parent->parent)
1588 frozen |= parent->frozen;
1590 if (frozen && initial)
1592 /* For variables that are frozen, or are children of frozen
1593 variables, we don't do fetch on initial assignment.
1594 For non-initial assignemnt we do the fetch, since it means we're
1595 explicitly asked to compare the new value with the old one. */
1596 intentionally_not_fetched = 1;
1598 else if (!gdb_value_fetch_lazy (value))
1600 /* Set the value to NULL, so that for the next -var-update,
1601 we don't try to compare the new value with this value,
1602 that we couldn't even read. */
1607 /* Get a reference now, before possibly passing it to any Python
1608 code that might release it. */
1610 value_incref (value);
1612 /* Below, we'll be comparing string rendering of old and new
1613 values. Don't get string rendering if the value is
1614 lazy -- if it is, the code above has decided that the value
1615 should not be fetched. */
1616 if (value && !value_lazy (value) && !var->pretty_printer)
1617 print_value = value_get_print_value (value, var->format, var);
1619 /* If the type is changeable, compare the old and the new values.
1620 If this is the initial assignment, we don't have any old value
1622 if (!initial && changeable)
1624 /* If the value of the varobj was changed by -var-set-value,
1625 then the value in the varobj and in the target is the same.
1626 However, that value is different from the value that the
1627 varobj had after the previous -var-update. So need to the
1628 varobj as changed. */
1633 else if (! var->pretty_printer)
1635 /* Try to compare the values. That requires that both
1636 values are non-lazy. */
1637 if (var->not_fetched && value_lazy (var->value))
1639 /* This is a frozen varobj and the value was never read.
1640 Presumably, UI shows some "never read" indicator.
1641 Now that we've fetched the real value, we need to report
1642 this varobj as changed so that UI can show the real
1646 else if (var->value == NULL && value == NULL)
1649 else if (var->value == NULL || value == NULL)
1655 gdb_assert (!value_lazy (var->value));
1656 gdb_assert (!value_lazy (value));
1658 gdb_assert (var->print_value != NULL && print_value != NULL);
1659 if (strcmp (var->print_value, print_value) != 0)
1665 if (!initial && !changeable)
1667 /* For values that are not changeable, we don't compare the values.
1668 However, we want to notice if a value was not NULL and now is NULL,
1669 or vise versa, so that we report when top-level varobjs come in scope
1670 and leave the scope. */
1671 changed = (var->value != NULL) != (value != NULL);
1674 /* We must always keep the new value, since children depend on it. */
1675 if (var->value != NULL && var->value != value)
1676 value_free (var->value);
1678 if (value && value_lazy (value) && intentionally_not_fetched)
1679 var->not_fetched = 1;
1681 var->not_fetched = 0;
1684 install_new_value_visualizer (var);
1686 /* If we installed a pretty-printer, re-compare the printed version
1687 to see if the variable changed. */
1688 if (var->pretty_printer)
1690 xfree (print_value);
1691 print_value = value_get_print_value (var->value, var->format, var);
1692 if ((var->print_value == NULL && print_value != NULL)
1693 || (var->print_value != NULL && print_value == NULL)
1694 || (var->print_value != NULL && print_value != NULL
1695 && strcmp (var->print_value, print_value) != 0))
1698 if (var->print_value)
1699 xfree (var->print_value);
1700 var->print_value = print_value;
1702 gdb_assert (!var->value || value_type (var->value));
1707 /* Return the requested range for a varobj. VAR is the varobj. FROM
1708 and TO are out parameters; *FROM and *TO will be set to the
1709 selected sub-range of VAR. If no range was selected using
1710 -var-set-update-range, then both will be -1. */
1712 varobj_get_child_range (struct varobj *var, int *from, int *to)
1718 /* Set the selected sub-range of children of VAR to start at index
1719 FROM and end at index TO. If either FROM or TO is less than zero,
1720 this is interpreted as a request for all children. */
1722 varobj_set_child_range (struct varobj *var, int from, int to)
1729 varobj_set_visualizer (struct varobj *var, const char *visualizer)
1732 PyObject *mainmod, *globals, *constructor;
1733 struct cleanup *back_to;
1735 back_to = varobj_ensure_python_env (var);
1737 mainmod = PyImport_AddModule ("__main__");
1738 globals = PyModule_GetDict (mainmod);
1739 Py_INCREF (globals);
1740 make_cleanup_py_decref (globals);
1742 constructor = PyRun_String (visualizer, Py_eval_input, globals, globals);
1746 gdbpy_print_stack ();
1747 error (_("Could not evaluate visualizer expression: %s"), visualizer);
1750 construct_visualizer (var, constructor);
1751 Py_XDECREF (constructor);
1753 /* If there are any children now, wipe them. */
1754 varobj_delete (var, NULL, 1 /* children only */);
1755 var->num_children = -1;
1757 do_cleanups (back_to);
1759 error (_("Python support required"));
1763 /* Update the values for a variable and its children. This is a
1764 two-pronged attack. First, re-parse the value for the root's
1765 expression to see if it's changed. Then go all the way
1766 through its children, reconstructing them and noting if they've
1769 The EXPLICIT parameter specifies if this call is result
1770 of MI request to update this specific variable, or
1771 result of implicit -var-update *. For implicit request, we don't
1772 update frozen variables.
1774 NOTE: This function may delete the caller's varobj. If it
1775 returns TYPE_CHANGED, then it has done this and VARP will be modified
1776 to point to the new varobj. */
1778 VEC(varobj_update_result) *
1779 varobj_update (struct varobj **varp, int explicit)
1782 int type_changed = 0;
1785 VEC (varobj_update_result) *stack = NULL;
1786 VEC (varobj_update_result) *result = NULL;
1788 /* Frozen means frozen -- we don't check for any change in
1789 this varobj, including its going out of scope, or
1790 changing type. One use case for frozen varobjs is
1791 retaining previously evaluated expressions, and we don't
1792 want them to be reevaluated at all. */
1793 if (!explicit && (*varp)->frozen)
1796 if (!(*varp)->root->is_valid)
1798 varobj_update_result r = {0};
1801 r.status = VAROBJ_INVALID;
1802 VEC_safe_push (varobj_update_result, result, &r);
1806 if ((*varp)->root->rootvar == *varp)
1808 varobj_update_result r = {0};
1811 r.status = VAROBJ_IN_SCOPE;
1813 /* Update the root variable. value_of_root can return NULL
1814 if the variable is no longer around, i.e. we stepped out of
1815 the frame in which a local existed. We are letting the
1816 value_of_root variable dispose of the varobj if the type
1818 new = value_of_root (varp, &type_changed);
1821 r.type_changed = type_changed;
1822 if (install_new_value ((*varp), new, type_changed))
1826 r.status = VAROBJ_NOT_IN_SCOPE;
1827 r.value_installed = 1;
1829 if (r.status == VAROBJ_NOT_IN_SCOPE)
1831 if (r.type_changed || r.changed)
1832 VEC_safe_push (varobj_update_result, result, &r);
1836 VEC_safe_push (varobj_update_result, stack, &r);
1840 varobj_update_result r = {0};
1843 VEC_safe_push (varobj_update_result, stack, &r);
1846 /* Walk through the children, reconstructing them all. */
1847 while (!VEC_empty (varobj_update_result, stack))
1849 varobj_update_result r = *(VEC_last (varobj_update_result, stack));
1850 struct varobj *v = r.varobj;
1852 VEC_pop (varobj_update_result, stack);
1854 /* Update this variable, unless it's a root, which is already
1856 if (!r.value_installed)
1858 new = value_of_child (v->parent, v->index);
1859 if (install_new_value (v, new, 0 /* type not changed */))
1866 /* We probably should not get children of a varobj that has a
1867 pretty-printer, but for which -var-list-children was never
1869 if (v->pretty_printer)
1871 VEC (varobj_p) *changed = 0, *new = 0, *unchanged = 0;
1872 int i, children_changed = 0;
1877 if (!v->children_requested)
1881 /* If we initially did not have potential children, but
1882 now we do, consider the varobj as changed.
1883 Otherwise, if children were never requested, consider
1884 it as unchanged -- presumably, such varobj is not yet
1885 expanded in the UI, so we need not bother getting
1887 if (!varobj_has_more (v, 0))
1889 update_dynamic_varobj_children (v, NULL, NULL, NULL,
1891 if (varobj_has_more (v, 0))
1896 VEC_safe_push (varobj_update_result, result, &r);
1901 /* If update_dynamic_varobj_children returns 0, then we have
1902 a non-conforming pretty-printer, so we skip it. */
1903 if (update_dynamic_varobj_children (v, &changed, &new, &unchanged,
1904 &children_changed, 1,
1907 if (children_changed || new)
1909 r.children_changed = 1;
1912 /* Push in reverse order so that the first child is
1913 popped from the work stack first, and so will be
1914 added to result first. This does not affect
1915 correctness, just "nicer". */
1916 for (i = VEC_length (varobj_p, changed) - 1; i >= 0; --i)
1918 varobj_p tmp = VEC_index (varobj_p, changed, i);
1919 varobj_update_result r = {0};
1923 r.value_installed = 1;
1924 VEC_safe_push (varobj_update_result, stack, &r);
1926 for (i = VEC_length (varobj_p, unchanged) - 1; i >= 0; --i)
1928 varobj_p tmp = VEC_index (varobj_p, unchanged, i);
1932 varobj_update_result r = {0};
1935 r.value_installed = 1;
1936 VEC_safe_push (varobj_update_result, stack, &r);
1939 if (r.changed || r.children_changed)
1940 VEC_safe_push (varobj_update_result, result, &r);
1942 /* Free CHANGED and UNCHANGED, but not NEW, because NEW
1943 has been put into the result vector. */
1944 VEC_free (varobj_p, changed);
1945 VEC_free (varobj_p, unchanged);
1951 /* Push any children. Use reverse order so that the first
1952 child is popped from the work stack first, and so
1953 will be added to result first. This does not
1954 affect correctness, just "nicer". */
1955 for (i = VEC_length (varobj_p, v->children)-1; i >= 0; --i)
1957 varobj_p c = VEC_index (varobj_p, v->children, i);
1959 /* Child may be NULL if explicitly deleted by -var-delete. */
1960 if (c != NULL && !c->frozen)
1962 varobj_update_result r = {0};
1965 VEC_safe_push (varobj_update_result, stack, &r);
1969 if (r.changed || r.type_changed)
1970 VEC_safe_push (varobj_update_result, result, &r);
1973 VEC_free (varobj_update_result, stack);
1979 /* Helper functions */
1982 * Variable object construction/destruction
1986 delete_variable (struct cpstack **resultp, struct varobj *var,
1987 int only_children_p)
1991 delete_variable_1 (resultp, &delcount, var,
1992 only_children_p, 1 /* remove_from_parent_p */ );
1997 /* Delete the variable object VAR and its children. */
1998 /* IMPORTANT NOTE: If we delete a variable which is a child
1999 and the parent is not removed we dump core. It must be always
2000 initially called with remove_from_parent_p set. */
2002 delete_variable_1 (struct cpstack **resultp, int *delcountp,
2003 struct varobj *var, int only_children_p,
2004 int remove_from_parent_p)
2008 /* Delete any children of this variable, too. */
2009 for (i = 0; i < VEC_length (varobj_p, var->children); ++i)
2011 varobj_p child = VEC_index (varobj_p, var->children, i);
2015 if (!remove_from_parent_p)
2016 child->parent = NULL;
2017 delete_variable_1 (resultp, delcountp, child, 0, only_children_p);
2019 VEC_free (varobj_p, var->children);
2021 /* if we were called to delete only the children we are done here. */
2022 if (only_children_p)
2025 /* Otherwise, add it to the list of deleted ones and proceed to do so. */
2026 /* If the name is null, this is a temporary variable, that has not
2027 yet been installed, don't report it, it belongs to the caller... */
2028 if (var->obj_name != NULL)
2030 cppush (resultp, xstrdup (var->obj_name));
2031 *delcountp = *delcountp + 1;
2034 /* If this variable has a parent, remove it from its parent's list. */
2035 /* OPTIMIZATION: if the parent of this variable is also being deleted,
2036 (as indicated by remove_from_parent_p) we don't bother doing an
2037 expensive list search to find the element to remove when we are
2038 discarding the list afterwards. */
2039 if ((remove_from_parent_p) && (var->parent != NULL))
2041 VEC_replace (varobj_p, var->parent->children, var->index, NULL);
2044 if (var->obj_name != NULL)
2045 uninstall_variable (var);
2047 /* Free memory associated with this variable. */
2048 free_variable (var);
2051 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
2053 install_variable (struct varobj *var)
2056 struct vlist *newvl;
2058 unsigned int index = 0;
2061 for (chp = var->obj_name; *chp; chp++)
2063 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
2066 cv = *(varobj_table + index);
2067 while ((cv != NULL) && (strcmp (cv->var->obj_name, var->obj_name) != 0))
2071 error (_("Duplicate variable object name"));
2073 /* Add varobj to hash table. */
2074 newvl = xmalloc (sizeof (struct vlist));
2075 newvl->next = *(varobj_table + index);
2077 *(varobj_table + index) = newvl;
2079 /* If root, add varobj to root list. */
2080 if (is_root_p (var))
2082 /* Add to list of root variables. */
2083 if (rootlist == NULL)
2084 var->root->next = NULL;
2086 var->root->next = rootlist;
2087 rootlist = var->root;
2093 /* Unistall the object VAR. */
2095 uninstall_variable (struct varobj *var)
2099 struct varobj_root *cr;
2100 struct varobj_root *prer;
2102 unsigned int index = 0;
2105 /* Remove varobj from hash table. */
2106 for (chp = var->obj_name; *chp; chp++)
2108 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
2111 cv = *(varobj_table + index);
2113 while ((cv != NULL) && (strcmp (cv->var->obj_name, var->obj_name) != 0))
2120 fprintf_unfiltered (gdb_stdlog, "Deleting %s\n", var->obj_name);
2125 ("Assertion failed: Could not find variable object \"%s\" to delete",
2131 *(varobj_table + index) = cv->next;
2133 prev->next = cv->next;
2137 /* If root, remove varobj from root list. */
2138 if (is_root_p (var))
2140 /* Remove from list of root variables. */
2141 if (rootlist == var->root)
2142 rootlist = var->root->next;
2147 while ((cr != NULL) && (cr->rootvar != var))
2154 warning (_("Assertion failed: Could not find "
2155 "varobj \"%s\" in root list"),
2162 prer->next = cr->next;
2168 /* Create and install a child of the parent of the given name. */
2169 static struct varobj *
2170 create_child (struct varobj *parent, int index, char *name)
2172 return create_child_with_value (parent, index, name,
2173 value_of_child (parent, index));
2176 static struct varobj *
2177 create_child_with_value (struct varobj *parent, int index, const char *name,
2178 struct value *value)
2180 struct varobj *child;
2183 child = new_variable ();
2185 /* Name is allocated by name_of_child. */
2186 /* FIXME: xstrdup should not be here. */
2187 child->name = xstrdup (name);
2188 child->index = index;
2189 child->parent = parent;
2190 child->root = parent->root;
2191 childs_name = xstrprintf ("%s.%s", parent->obj_name, name);
2192 child->obj_name = childs_name;
2193 install_variable (child);
2195 /* Compute the type of the child. Must do this before
2196 calling install_new_value. */
2198 /* If the child had no evaluation errors, var->value
2199 will be non-NULL and contain a valid type. */
2200 child->type = value_type (value);
2202 /* Otherwise, we must compute the type. */
2203 child->type = (*child->root->lang->type_of_child) (child->parent,
2205 install_new_value (child, value, 1);
2212 * Miscellaneous utility functions.
2215 /* Allocate memory and initialize a new variable. */
2216 static struct varobj *
2221 var = (struct varobj *) xmalloc (sizeof (struct varobj));
2223 var->path_expr = NULL;
2224 var->obj_name = NULL;
2228 var->num_children = -1;
2230 var->children = NULL;
2234 var->print_value = NULL;
2236 var->not_fetched = 0;
2237 var->children_requested = 0;
2240 var->constructor = 0;
2241 var->pretty_printer = 0;
2242 var->child_iter = 0;
2243 var->saved_item = 0;
2248 /* Allocate memory and initialize a new root variable. */
2249 static struct varobj *
2250 new_root_variable (void)
2252 struct varobj *var = new_variable ();
2254 var->root = (struct varobj_root *) xmalloc (sizeof (struct varobj_root));
2255 var->root->lang = NULL;
2256 var->root->exp = NULL;
2257 var->root->valid_block = NULL;
2258 var->root->frame = null_frame_id;
2259 var->root->floating = 0;
2260 var->root->rootvar = NULL;
2261 var->root->is_valid = 1;
2266 /* Free any allocated memory associated with VAR. */
2268 free_variable (struct varobj *var)
2271 if (var->pretty_printer)
2273 struct cleanup *cleanup = varobj_ensure_python_env (var);
2274 Py_XDECREF (var->constructor);
2275 Py_XDECREF (var->pretty_printer);
2276 Py_XDECREF (var->child_iter);
2277 Py_XDECREF (var->saved_item);
2278 do_cleanups (cleanup);
2282 value_free (var->value);
2284 /* Free the expression if this is a root variable. */
2285 if (is_root_p (var))
2287 xfree (var->root->exp);
2292 xfree (var->obj_name);
2293 xfree (var->print_value);
2294 xfree (var->path_expr);
2299 do_free_variable_cleanup (void *var)
2301 free_variable (var);
2304 static struct cleanup *
2305 make_cleanup_free_variable (struct varobj *var)
2307 return make_cleanup (do_free_variable_cleanup, var);
2310 /* This returns the type of the variable. It also skips past typedefs
2311 to return the real type of the variable.
2313 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
2314 except within get_target_type and get_type. */
2315 static struct type *
2316 get_type (struct varobj *var)
2322 type = check_typedef (type);
2327 /* Return the type of the value that's stored in VAR,
2328 or that would have being stored there if the
2329 value were accessible.
2331 This differs from VAR->type in that VAR->type is always
2332 the true type of the expession in the source language.
2333 The return value of this function is the type we're
2334 actually storing in varobj, and using for displaying
2335 the values and for comparing previous and new values.
2337 For example, top-level references are always stripped. */
2338 static struct type *
2339 get_value_type (struct varobj *var)
2344 type = value_type (var->value);
2348 type = check_typedef (type);
2350 if (TYPE_CODE (type) == TYPE_CODE_REF)
2351 type = get_target_type (type);
2353 type = check_typedef (type);
2358 /* This returns the target type (or NULL) of TYPE, also skipping
2359 past typedefs, just like get_type ().
2361 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
2362 except within get_target_type and get_type. */
2363 static struct type *
2364 get_target_type (struct type *type)
2368 type = TYPE_TARGET_TYPE (type);
2370 type = check_typedef (type);
2376 /* What is the default display for this variable? We assume that
2377 everything is "natural". Any exceptions? */
2378 static enum varobj_display_formats
2379 variable_default_display (struct varobj *var)
2381 return FORMAT_NATURAL;
2384 /* FIXME: The following should be generic for any pointer. */
2386 cppush (struct cpstack **pstack, char *name)
2390 s = (struct cpstack *) xmalloc (sizeof (struct cpstack));
2396 /* FIXME: The following should be generic for any pointer. */
2398 cppop (struct cpstack **pstack)
2403 if ((*pstack)->name == NULL && (*pstack)->next == NULL)
2408 *pstack = (*pstack)->next;
2415 * Language-dependencies
2418 /* Common entry points */
2420 /* Get the language of variable VAR. */
2421 static enum varobj_languages
2422 variable_language (struct varobj *var)
2424 enum varobj_languages lang;
2426 switch (var->root->exp->language_defn->la_language)
2432 case language_cplus:
2446 /* Return the number of children for a given variable.
2447 The result of this function is defined by the language
2448 implementation. The number of children returned by this function
2449 is the number of children that the user will see in the variable
2452 number_of_children (struct varobj *var)
2454 return (*var->root->lang->number_of_children) (var);
2457 /* What is the expression for the root varobj VAR? Returns a malloc'd
2460 name_of_variable (struct varobj *var)
2462 return (*var->root->lang->name_of_variable) (var);
2465 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd
2468 name_of_child (struct varobj *var, int index)
2470 return (*var->root->lang->name_of_child) (var, index);
2473 /* What is the ``struct value *'' of the root variable VAR?
2474 For floating variable object, evaluation can get us a value
2475 of different type from what is stored in varobj already. In
2477 - *type_changed will be set to 1
2478 - old varobj will be freed, and new one will be
2479 created, with the same name.
2480 - *var_handle will be set to the new varobj
2481 Otherwise, *type_changed will be set to 0. */
2482 static struct value *
2483 value_of_root (struct varobj **var_handle, int *type_changed)
2487 if (var_handle == NULL)
2492 /* This should really be an exception, since this should
2493 only get called with a root variable. */
2495 if (!is_root_p (var))
2498 if (var->root->floating)
2500 struct varobj *tmp_var;
2501 char *old_type, *new_type;
2503 tmp_var = varobj_create (NULL, var->name, (CORE_ADDR) 0,
2504 USE_SELECTED_FRAME);
2505 if (tmp_var == NULL)
2509 old_type = varobj_get_type (var);
2510 new_type = varobj_get_type (tmp_var);
2511 if (strcmp (old_type, new_type) == 0)
2513 /* The expression presently stored inside var->root->exp
2514 remembers the locations of local variables relatively to
2515 the frame where the expression was created (in DWARF location
2516 button, for example). Naturally, those locations are not
2517 correct in other frames, so update the expression. */
2519 struct expression *tmp_exp = var->root->exp;
2521 var->root->exp = tmp_var->root->exp;
2522 tmp_var->root->exp = tmp_exp;
2524 varobj_delete (tmp_var, NULL, 0);
2529 tmp_var->obj_name = xstrdup (var->obj_name);
2530 tmp_var->from = var->from;
2531 tmp_var->to = var->to;
2532 varobj_delete (var, NULL, 0);
2534 install_variable (tmp_var);
2535 *var_handle = tmp_var;
2547 return (*var->root->lang->value_of_root) (var_handle);
2550 /* What is the ``struct value *'' for the INDEX'th child of PARENT? */
2551 static struct value *
2552 value_of_child (struct varobj *parent, int index)
2554 struct value *value;
2556 value = (*parent->root->lang->value_of_child) (parent, index);
2561 /* GDB already has a command called "value_of_variable". Sigh. */
2563 my_value_of_variable (struct varobj *var, enum varobj_display_formats format)
2565 if (var->root->is_valid)
2567 if (var->pretty_printer)
2568 return value_get_print_value (var->value, var->format, var);
2569 return (*var->root->lang->value_of_variable) (var, format);
2576 value_get_print_value (struct value *value, enum varobj_display_formats format,
2579 struct ui_file *stb;
2580 struct cleanup *old_chain;
2581 gdb_byte *thevalue = NULL;
2582 struct value_print_options opts;
2583 struct type *type = NULL;
2585 char *encoding = NULL;
2586 struct gdbarch *gdbarch = NULL;
2587 /* Initialize it just to avoid a GCC false warning. */
2588 CORE_ADDR str_addr = 0;
2589 int string_print = 0;
2594 stb = mem_fileopen ();
2595 old_chain = make_cleanup_ui_file_delete (stb);
2597 gdbarch = get_type_arch (value_type (value));
2600 PyObject *value_formatter = var->pretty_printer;
2602 varobj_ensure_python_env (var);
2604 if (value_formatter)
2606 /* First check to see if we have any children at all. If so,
2607 we simply return {...}. */
2608 if (dynamic_varobj_has_child_method (var))
2610 do_cleanups (old_chain);
2611 return xstrdup ("{...}");
2614 if (PyObject_HasAttr (value_formatter, gdbpy_to_string_cst))
2616 struct value *replacement;
2617 PyObject *output = NULL;
2619 output = apply_varobj_pretty_printer (value_formatter,
2623 /* If we have string like output ... */
2626 make_cleanup_py_decref (output);
2628 /* If this is a lazy string, extract it. For lazy
2629 strings we always print as a string, so set
2631 if (gdbpy_is_lazy_string (output))
2633 gdbpy_extract_lazy_string (output, &str_addr, &type,
2635 make_cleanup (free_current_contents, &encoding);
2640 /* If it is a regular (non-lazy) string, extract
2641 it and copy the contents into THEVALUE. If the
2642 hint says to print it as a string, set
2643 string_print. Otherwise just return the extracted
2644 string as a value. */
2647 = python_string_to_target_python_string (output);
2651 char *s = PyString_AsString (py_str);
2654 hint = gdbpy_get_display_hint (value_formatter);
2657 if (!strcmp (hint, "string"))
2662 len = PyString_Size (py_str);
2663 thevalue = xmemdup (s, len + 1, len + 1);
2664 type = builtin_type (gdbarch)->builtin_char;
2669 do_cleanups (old_chain);
2673 make_cleanup (xfree, thevalue);
2676 gdbpy_print_stack ();
2679 /* If the printer returned a replacement value, set VALUE
2680 to REPLACEMENT. If there is not a replacement value,
2681 just use the value passed to this function. */
2683 value = replacement;
2689 get_formatted_print_options (&opts, format_code[(int) format]);
2693 /* If the THEVALUE has contents, it is a regular string. */
2695 LA_PRINT_STRING (stb, type, thevalue, len, encoding, 0, &opts);
2696 else if (string_print)
2697 /* Otherwise, if string_print is set, and it is not a regular
2698 string, it is a lazy string. */
2699 val_print_string (type, encoding, str_addr, len, stb, &opts);
2701 /* All other cases. */
2702 common_val_print (value, stb, 0, &opts, current_language);
2704 thevalue = ui_file_xstrdup (stb, NULL);
2706 do_cleanups (old_chain);
2711 varobj_editable_p (struct varobj *var)
2715 if (!(var->root->is_valid && var->value && VALUE_LVAL (var->value)))
2718 type = get_value_type (var);
2720 switch (TYPE_CODE (type))
2722 case TYPE_CODE_STRUCT:
2723 case TYPE_CODE_UNION:
2724 case TYPE_CODE_ARRAY:
2725 case TYPE_CODE_FUNC:
2726 case TYPE_CODE_METHOD:
2736 /* Return non-zero if changes in value of VAR
2737 must be detected and reported by -var-update.
2738 Return zero is -var-update should never report
2739 changes of such values. This makes sense for structures
2740 (since the changes in children values will be reported separately),
2741 or for artifical objects (like 'public' pseudo-field in C++).
2743 Return value of 0 means that gdb need not call value_fetch_lazy
2744 for the value of this variable object. */
2746 varobj_value_is_changeable_p (struct varobj *var)
2751 if (CPLUS_FAKE_CHILD (var))
2754 type = get_value_type (var);
2756 switch (TYPE_CODE (type))
2758 case TYPE_CODE_STRUCT:
2759 case TYPE_CODE_UNION:
2760 case TYPE_CODE_ARRAY:
2771 /* Return 1 if that varobj is floating, that is is always evaluated in the
2772 selected frame, and not bound to thread/frame. Such variable objects
2773 are created using '@' as frame specifier to -var-create. */
2775 varobj_floating_p (struct varobj *var)
2777 return var->root->floating;
2780 /* Given the value and the type of a variable object,
2781 adjust the value and type to those necessary
2782 for getting children of the variable object.
2783 This includes dereferencing top-level references
2784 to all types and dereferencing pointers to
2787 Both TYPE and *TYPE should be non-null. VALUE
2788 can be null if we want to only translate type.
2789 *VALUE can be null as well -- if the parent
2792 If WAS_PTR is not NULL, set *WAS_PTR to 0 or 1
2793 depending on whether pointer was dereferenced
2794 in this function. */
2796 adjust_value_for_child_access (struct value **value,
2800 gdb_assert (type && *type);
2805 *type = check_typedef (*type);
2807 /* The type of value stored in varobj, that is passed
2808 to us, is already supposed to be
2809 reference-stripped. */
2811 gdb_assert (TYPE_CODE (*type) != TYPE_CODE_REF);
2813 /* Pointers to structures are treated just like
2814 structures when accessing children. Don't
2815 dererences pointers to other types. */
2816 if (TYPE_CODE (*type) == TYPE_CODE_PTR)
2818 struct type *target_type = get_target_type (*type);
2819 if (TYPE_CODE (target_type) == TYPE_CODE_STRUCT
2820 || TYPE_CODE (target_type) == TYPE_CODE_UNION)
2822 if (value && *value)
2824 int success = gdb_value_ind (*value, value);
2829 *type = target_type;
2835 /* The 'get_target_type' function calls check_typedef on
2836 result, so we can immediately check type code. No
2837 need to call check_typedef here. */
2842 c_number_of_children (struct varobj *var)
2844 struct type *type = get_value_type (var);
2846 struct type *target;
2848 adjust_value_for_child_access (NULL, &type, NULL);
2849 target = get_target_type (type);
2851 switch (TYPE_CODE (type))
2853 case TYPE_CODE_ARRAY:
2854 if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (target) > 0
2855 && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))
2856 children = TYPE_LENGTH (type) / TYPE_LENGTH (target);
2858 /* If we don't know how many elements there are, don't display
2863 case TYPE_CODE_STRUCT:
2864 case TYPE_CODE_UNION:
2865 children = TYPE_NFIELDS (type);
2869 /* The type here is a pointer to non-struct. Typically, pointers
2870 have one child, except for function ptrs, which have no children,
2871 and except for void*, as we don't know what to show.
2873 We can show char* so we allow it to be dereferenced. If you decide
2874 to test for it, please mind that a little magic is necessary to
2875 properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
2876 TYPE_NAME == "char". */
2877 if (TYPE_CODE (target) == TYPE_CODE_FUNC
2878 || TYPE_CODE (target) == TYPE_CODE_VOID)
2885 /* Other types have no children. */
2893 c_name_of_variable (struct varobj *parent)
2895 return xstrdup (parent->name);
2898 /* Return the value of element TYPE_INDEX of a structure
2899 value VALUE. VALUE's type should be a structure,
2900 or union, or a typedef to struct/union.
2902 Returns NULL if getting the value fails. Never throws. */
2903 static struct value *
2904 value_struct_element_index (struct value *value, int type_index)
2906 struct value *result = NULL;
2907 volatile struct gdb_exception e;
2908 struct type *type = value_type (value);
2910 type = check_typedef (type);
2912 gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
2913 || TYPE_CODE (type) == TYPE_CODE_UNION);
2915 TRY_CATCH (e, RETURN_MASK_ERROR)
2917 if (field_is_static (&TYPE_FIELD (type, type_index)))
2918 result = value_static_field (type, type_index);
2920 result = value_primitive_field (value, 0, type_index, type);
2932 /* Obtain the information about child INDEX of the variable
2934 If CNAME is not null, sets *CNAME to the name of the child relative
2936 If CVALUE is not null, sets *CVALUE to the value of the child.
2937 If CTYPE is not null, sets *CTYPE to the type of the child.
2939 If any of CNAME, CVALUE, or CTYPE is not null, but the corresponding
2940 information cannot be determined, set *CNAME, *CVALUE, or *CTYPE
2943 c_describe_child (struct varobj *parent, int index,
2944 char **cname, struct value **cvalue, struct type **ctype,
2945 char **cfull_expression)
2947 struct value *value = parent->value;
2948 struct type *type = get_value_type (parent);
2949 char *parent_expression = NULL;
2958 if (cfull_expression)
2960 *cfull_expression = NULL;
2961 parent_expression = varobj_get_path_expr (parent);
2963 adjust_value_for_child_access (&value, &type, &was_ptr);
2965 switch (TYPE_CODE (type))
2967 case TYPE_CODE_ARRAY:
2970 = xstrdup (int_string (index
2971 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)),
2974 if (cvalue && value)
2976 int real_index = index + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type));
2978 gdb_value_subscript (value, real_index, cvalue);
2982 *ctype = get_target_type (type);
2984 if (cfull_expression)
2986 xstrprintf ("(%s)[%s]", parent_expression,
2988 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)),
2994 case TYPE_CODE_STRUCT:
2995 case TYPE_CODE_UNION:
2997 *cname = xstrdup (TYPE_FIELD_NAME (type, index));
2999 if (cvalue && value)
3001 /* For C, varobj index is the same as type index. */
3002 *cvalue = value_struct_element_index (value, index);
3006 *ctype = TYPE_FIELD_TYPE (type, index);
3008 if (cfull_expression)
3010 char *join = was_ptr ? "->" : ".";
3012 *cfull_expression = xstrprintf ("(%s)%s%s", parent_expression, join,
3013 TYPE_FIELD_NAME (type, index));
3020 *cname = xstrprintf ("*%s", parent->name);
3022 if (cvalue && value)
3024 int success = gdb_value_ind (value, cvalue);
3030 /* Don't use get_target_type because it calls
3031 check_typedef and here, we want to show the true
3032 declared type of the variable. */
3034 *ctype = TYPE_TARGET_TYPE (type);
3036 if (cfull_expression)
3037 *cfull_expression = xstrprintf ("*(%s)", parent_expression);
3042 /* This should not happen. */
3044 *cname = xstrdup ("???");
3045 if (cfull_expression)
3046 *cfull_expression = xstrdup ("???");
3047 /* Don't set value and type, we don't know then. */
3052 c_name_of_child (struct varobj *parent, int index)
3056 c_describe_child (parent, index, &name, NULL, NULL, NULL);
3061 c_path_expr_of_child (struct varobj *child)
3063 c_describe_child (child->parent, child->index, NULL, NULL, NULL,
3065 return child->path_expr;
3068 /* If frame associated with VAR can be found, switch
3069 to it and return 1. Otherwise, return 0. */
3071 check_scope (struct varobj *var)
3073 struct frame_info *fi;
3076 fi = frame_find_by_id (var->root->frame);
3081 CORE_ADDR pc = get_frame_pc (fi);
3083 if (pc < BLOCK_START (var->root->valid_block) ||
3084 pc >= BLOCK_END (var->root->valid_block))
3092 static struct value *
3093 c_value_of_root (struct varobj **var_handle)
3095 struct value *new_val = NULL;
3096 struct varobj *var = *var_handle;
3097 int within_scope = 0;
3098 struct cleanup *back_to;
3100 /* Only root variables can be updated... */
3101 if (!is_root_p (var))
3102 /* Not a root var. */
3105 back_to = make_cleanup_restore_current_thread ();
3107 /* Determine whether the variable is still around. */
3108 if (var->root->valid_block == NULL || var->root->floating)
3110 else if (var->root->thread_id == 0)
3112 /* The program was single-threaded when the variable object was
3113 created. Technically, it's possible that the program became
3114 multi-threaded since then, but we don't support such
3116 within_scope = check_scope (var);
3120 ptid_t ptid = thread_id_to_pid (var->root->thread_id);
3121 if (in_thread_list (ptid))
3123 switch_to_thread (ptid);
3124 within_scope = check_scope (var);
3130 /* We need to catch errors here, because if evaluate
3131 expression fails we want to just return NULL. */
3132 gdb_evaluate_expression (var->root->exp, &new_val);
3136 do_cleanups (back_to);
3141 static struct value *
3142 c_value_of_child (struct varobj *parent, int index)
3144 struct value *value = NULL;
3146 c_describe_child (parent, index, NULL, &value, NULL, NULL);
3150 static struct type *
3151 c_type_of_child (struct varobj *parent, int index)
3153 struct type *type = NULL;
3155 c_describe_child (parent, index, NULL, NULL, &type, NULL);
3160 c_value_of_variable (struct varobj *var, enum varobj_display_formats format)
3162 /* BOGUS: if val_print sees a struct/class, or a reference to one,
3163 it will print out its children instead of "{...}". So we need to
3164 catch that case explicitly. */
3165 struct type *type = get_type (var);
3167 /* If we have a custom formatter, return whatever string it has
3169 if (var->pretty_printer && var->print_value)
3170 return xstrdup (var->print_value);
3172 /* Strip top-level references. */
3173 while (TYPE_CODE (type) == TYPE_CODE_REF)
3174 type = check_typedef (TYPE_TARGET_TYPE (type));
3176 switch (TYPE_CODE (type))
3178 case TYPE_CODE_STRUCT:
3179 case TYPE_CODE_UNION:
3180 return xstrdup ("{...}");
3183 case TYPE_CODE_ARRAY:
3187 number = xstrprintf ("[%d]", var->num_children);
3194 if (var->value == NULL)
3196 /* This can happen if we attempt to get the value of a struct
3197 member when the parent is an invalid pointer. This is an
3198 error condition, so we should tell the caller. */
3203 if (var->not_fetched && value_lazy (var->value))
3204 /* Frozen variable and no value yet. We don't
3205 implicitly fetch the value. MI response will
3206 use empty string for the value, which is OK. */
3209 gdb_assert (varobj_value_is_changeable_p (var));
3210 gdb_assert (!value_lazy (var->value));
3212 /* If the specified format is the current one,
3213 we can reuse print_value. */
3214 if (format == var->format)
3215 return xstrdup (var->print_value);
3217 return value_get_print_value (var->value, format, var);
3227 cplus_number_of_children (struct varobj *var)
3230 int children, dont_know;
3235 if (!CPLUS_FAKE_CHILD (var))
3237 type = get_value_type (var);
3238 adjust_value_for_child_access (NULL, &type, NULL);
3240 if (((TYPE_CODE (type)) == TYPE_CODE_STRUCT) ||
3241 ((TYPE_CODE (type)) == TYPE_CODE_UNION))
3245 cplus_class_num_children (type, kids);
3246 if (kids[v_public] != 0)
3248 if (kids[v_private] != 0)
3250 if (kids[v_protected] != 0)
3253 /* Add any baseclasses. */
3254 children += TYPE_N_BASECLASSES (type);
3257 /* FIXME: save children in var. */
3264 type = get_value_type (var->parent);
3265 adjust_value_for_child_access (NULL, &type, NULL);
3267 cplus_class_num_children (type, kids);
3268 if (strcmp (var->name, "public") == 0)
3269 children = kids[v_public];
3270 else if (strcmp (var->name, "private") == 0)
3271 children = kids[v_private];
3273 children = kids[v_protected];
3278 children = c_number_of_children (var);
3283 /* Compute # of public, private, and protected variables in this class.
3284 That means we need to descend into all baseclasses and find out
3285 how many are there, too. */
3287 cplus_class_num_children (struct type *type, int children[3])
3289 int i, vptr_fieldno;
3290 struct type *basetype = NULL;
3292 children[v_public] = 0;
3293 children[v_private] = 0;
3294 children[v_protected] = 0;
3296 vptr_fieldno = get_vptr_fieldno (type, &basetype);
3297 for (i = TYPE_N_BASECLASSES (type); i < TYPE_NFIELDS (type); i++)
3299 /* If we have a virtual table pointer, omit it. Even if virtual
3300 table pointers are not specifically marked in the debug info,
3301 they should be artificial. */
3302 if ((type == basetype && i == vptr_fieldno)
3303 || TYPE_FIELD_ARTIFICIAL (type, i))
3306 if (TYPE_FIELD_PROTECTED (type, i))
3307 children[v_protected]++;
3308 else if (TYPE_FIELD_PRIVATE (type, i))
3309 children[v_private]++;
3311 children[v_public]++;
3316 cplus_name_of_variable (struct varobj *parent)
3318 return c_name_of_variable (parent);
3321 enum accessibility { private_field, protected_field, public_field };
3323 /* Check if field INDEX of TYPE has the specified accessibility.
3324 Return 0 if so and 1 otherwise. */
3326 match_accessibility (struct type *type, int index, enum accessibility acc)
3328 if (acc == private_field && TYPE_FIELD_PRIVATE (type, index))
3330 else if (acc == protected_field && TYPE_FIELD_PROTECTED (type, index))
3332 else if (acc == public_field && !TYPE_FIELD_PRIVATE (type, index)
3333 && !TYPE_FIELD_PROTECTED (type, index))
3340 cplus_describe_child (struct varobj *parent, int index,
3341 char **cname, struct value **cvalue, struct type **ctype,
3342 char **cfull_expression)
3344 struct value *value;
3347 char *parent_expression = NULL;
3355 if (cfull_expression)
3356 *cfull_expression = NULL;
3358 if (CPLUS_FAKE_CHILD (parent))
3360 value = parent->parent->value;
3361 type = get_value_type (parent->parent);
3362 if (cfull_expression)
3363 parent_expression = varobj_get_path_expr (parent->parent);
3367 value = parent->value;
3368 type = get_value_type (parent);
3369 if (cfull_expression)
3370 parent_expression = varobj_get_path_expr (parent);
3373 adjust_value_for_child_access (&value, &type, &was_ptr);
3375 if (TYPE_CODE (type) == TYPE_CODE_STRUCT
3376 || TYPE_CODE (type) == TYPE_CODE_UNION)
3378 char *join = was_ptr ? "->" : ".";
3380 if (CPLUS_FAKE_CHILD (parent))
3382 /* The fields of the class type are ordered as they
3383 appear in the class. We are given an index for a
3384 particular access control type ("public","protected",
3385 or "private"). We must skip over fields that don't
3386 have the access control we are looking for to properly
3387 find the indexed field. */
3388 int type_index = TYPE_N_BASECLASSES (type);
3389 enum accessibility acc = public_field;
3391 struct type *basetype = NULL;
3393 vptr_fieldno = get_vptr_fieldno (type, &basetype);
3394 if (strcmp (parent->name, "private") == 0)
3395 acc = private_field;
3396 else if (strcmp (parent->name, "protected") == 0)
3397 acc = protected_field;
3401 if ((type == basetype && type_index == vptr_fieldno)
3402 || TYPE_FIELD_ARTIFICIAL (type, type_index))
3404 else if (match_accessibility (type, type_index, acc))
3411 *cname = xstrdup (TYPE_FIELD_NAME (type, type_index));
3413 if (cvalue && value)
3414 *cvalue = value_struct_element_index (value, type_index);
3417 *ctype = TYPE_FIELD_TYPE (type, type_index);
3419 if (cfull_expression)
3421 = xstrprintf ("((%s)%s%s)", parent_expression,
3423 TYPE_FIELD_NAME (type, type_index));
3425 else if (index < TYPE_N_BASECLASSES (type))
3427 /* This is a baseclass. */
3429 *cname = xstrdup (TYPE_FIELD_NAME (type, index));
3431 if (cvalue && value)
3432 *cvalue = value_cast (TYPE_FIELD_TYPE (type, index), value);
3436 *ctype = TYPE_FIELD_TYPE (type, index);
3439 if (cfull_expression)
3441 char *ptr = was_ptr ? "*" : "";
3443 /* Cast the parent to the base' type. Note that in gdb,
3446 will create an lvalue, for all appearences, so we don't
3447 need to use more fancy:
3451 When we are in the scope of the base class or of one
3452 of its children, the type field name will be interpreted
3453 as a constructor, if it exists. Therefore, we must
3454 indicate that the name is a class name by using the
3455 'class' keyword. See PR mi/11912 */
3456 *cfull_expression = xstrprintf ("(%s(class %s%s) %s)",
3458 TYPE_FIELD_NAME (type, index),
3465 char *access = NULL;
3468 cplus_class_num_children (type, children);
3470 /* Everything beyond the baseclasses can
3471 only be "public", "private", or "protected"
3473 The special "fake" children are always output by varobj in
3474 this order. So if INDEX == 2, it MUST be "protected". */
3475 index -= TYPE_N_BASECLASSES (type);
3479 if (children[v_public] > 0)
3481 else if (children[v_private] > 0)
3484 access = "protected";
3487 if (children[v_public] > 0)
3489 if (children[v_private] > 0)
3492 access = "protected";
3494 else if (children[v_private] > 0)
3495 access = "protected";
3498 /* Must be protected. */
3499 access = "protected";
3506 gdb_assert (access);
3508 *cname = xstrdup (access);
3510 /* Value and type and full expression are null here. */
3515 c_describe_child (parent, index, cname, cvalue, ctype, cfull_expression);
3520 cplus_name_of_child (struct varobj *parent, int index)
3524 cplus_describe_child (parent, index, &name, NULL, NULL, NULL);
3529 cplus_path_expr_of_child (struct varobj *child)
3531 cplus_describe_child (child->parent, child->index, NULL, NULL, NULL,
3533 return child->path_expr;
3536 static struct value *
3537 cplus_value_of_root (struct varobj **var_handle)
3539 return c_value_of_root (var_handle);
3542 static struct value *
3543 cplus_value_of_child (struct varobj *parent, int index)
3545 struct value *value = NULL;
3547 cplus_describe_child (parent, index, NULL, &value, NULL, NULL);
3551 static struct type *
3552 cplus_type_of_child (struct varobj *parent, int index)
3554 struct type *type = NULL;
3556 cplus_describe_child (parent, index, NULL, NULL, &type, NULL);
3561 cplus_value_of_variable (struct varobj *var,
3562 enum varobj_display_formats format)
3565 /* If we have one of our special types, don't print out
3567 if (CPLUS_FAKE_CHILD (var))
3568 return xstrdup ("");
3570 return c_value_of_variable (var, format);
3576 java_number_of_children (struct varobj *var)
3578 return cplus_number_of_children (var);
3582 java_name_of_variable (struct varobj *parent)
3586 name = cplus_name_of_variable (parent);
3587 /* If the name has "-" in it, it is because we
3588 needed to escape periods in the name... */
3591 while (*p != '\000')
3602 java_name_of_child (struct varobj *parent, int index)
3606 name = cplus_name_of_child (parent, index);
3607 /* Escape any periods in the name... */
3610 while (*p != '\000')
3621 java_path_expr_of_child (struct varobj *child)
3626 static struct value *
3627 java_value_of_root (struct varobj **var_handle)
3629 return cplus_value_of_root (var_handle);
3632 static struct value *
3633 java_value_of_child (struct varobj *parent, int index)
3635 return cplus_value_of_child (parent, index);
3638 static struct type *
3639 java_type_of_child (struct varobj *parent, int index)
3641 return cplus_type_of_child (parent, index);
3645 java_value_of_variable (struct varobj *var, enum varobj_display_formats format)
3647 return cplus_value_of_variable (var, format);
3650 /* Ada specific callbacks for VAROBJs. */
3653 ada_number_of_children (struct varobj *var)
3655 return c_number_of_children (var);
3659 ada_name_of_variable (struct varobj *parent)
3661 return c_name_of_variable (parent);
3665 ada_name_of_child (struct varobj *parent, int index)
3667 return c_name_of_child (parent, index);
3671 ada_path_expr_of_child (struct varobj *child)
3673 return c_path_expr_of_child (child);
3676 static struct value *
3677 ada_value_of_root (struct varobj **var_handle)
3679 return c_value_of_root (var_handle);
3682 static struct value *
3683 ada_value_of_child (struct varobj *parent, int index)
3685 return c_value_of_child (parent, index);
3688 static struct type *
3689 ada_type_of_child (struct varobj *parent, int index)
3691 return c_type_of_child (parent, index);
3695 ada_value_of_variable (struct varobj *var, enum varobj_display_formats format)
3697 return c_value_of_variable (var, format);
3700 /* Iterate all the existing _root_ VAROBJs and call the FUNC callback for them
3701 with an arbitrary caller supplied DATA pointer. */
3704 all_root_varobjs (void (*func) (struct varobj *var, void *data), void *data)
3706 struct varobj_root *var_root, *var_root_next;
3708 /* Iterate "safely" - handle if the callee deletes its passed VAROBJ. */
3710 for (var_root = rootlist; var_root != NULL; var_root = var_root_next)
3712 var_root_next = var_root->next;
3714 (*func) (var_root->rootvar, data);
3718 extern void _initialize_varobj (void);
3720 _initialize_varobj (void)
3722 int sizeof_table = sizeof (struct vlist *) * VAROBJ_TABLE_SIZE;
3724 varobj_table = xmalloc (sizeof_table);
3725 memset (varobj_table, 0, sizeof_table);
3727 add_setshow_zinteger_cmd ("debugvarobj", class_maintenance,
3729 _("Set varobj debugging."),
3730 _("Show varobj debugging."),
3731 _("When non-zero, varobj debugging is enabled."),
3732 NULL, show_varobjdebug,
3733 &setlist, &showlist);
3736 /* Invalidate varobj VAR if it is tied to locals and re-create it if it is
3737 defined on globals. It is a helper for varobj_invalidate. */
3740 varobj_invalidate_iter (struct varobj *var, void *unused)
3742 /* Floating varobjs are reparsed on each stop, so we don't care if the
3743 presently parsed expression refers to something that's gone. */
3744 if (var->root->floating)
3747 /* global var must be re-evaluated. */
3748 if (var->root->valid_block == NULL)
3750 struct varobj *tmp_var;
3752 /* Try to create a varobj with same expression. If we succeed
3753 replace the old varobj, otherwise invalidate it. */
3754 tmp_var = varobj_create (NULL, var->name, (CORE_ADDR) 0,
3756 if (tmp_var != NULL)
3758 tmp_var->obj_name = xstrdup (var->obj_name);
3759 varobj_delete (var, NULL, 0);
3760 install_variable (tmp_var);
3763 var->root->is_valid = 0;
3765 else /* locals must be invalidated. */
3766 var->root->is_valid = 0;
3769 /* Invalidate the varobjs that are tied to locals and re-create the ones that
3770 are defined on globals.
3771 Invalidated varobjs will be always printed in_scope="invalid". */
3774 varobj_invalidate (void)
3776 all_root_varobjs (varobj_invalidate_iter, NULL);