1 /* Implementation of the GDB variable objects API.
3 Copyright (C) 1999-2012 Free Software Foundation, Inc.
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 3 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 #include "exceptions.h"
21 #include "expression.h"
28 #include "gdb_assert.h"
29 #include "gdb_string.h"
30 #include "gdb_regex.h"
34 #include "gdbthread.h"
38 #include "python/python.h"
39 #include "python/python-internal.h"
44 /* Non-zero if we want to see trace of varobj level stuff. */
48 show_varobjdebug (struct ui_file *file, int from_tty,
49 struct cmd_list_element *c, const char *value)
51 fprintf_filtered (file, _("Varobj debugging is %s.\n"), value);
54 /* String representations of gdb's format codes. */
55 char *varobj_format_string[] =
56 { "natural", "binary", "decimal", "hexadecimal", "octal" };
58 /* String representations of gdb's known languages. */
59 char *varobj_language_string[] = { "unknown", "C", "C++", "Java" };
61 /* True if we want to allow Python-based pretty-printing. */
62 static int pretty_printing = 0;
65 varobj_enable_pretty_printing (void)
72 /* Every root variable has one of these structures saved in its
73 varobj. Members which must be free'd are noted. */
77 /* Alloc'd expression for this parent. */
78 struct expression *exp;
80 /* Block for which this expression is valid. */
81 struct block *valid_block;
83 /* The frame for this expression. This field is set iff valid_block is
85 struct frame_id frame;
87 /* The thread ID that this varobj_root belong to. This field
88 is only valid if valid_block is not NULL.
89 When not 0, indicates which thread 'frame' belongs to.
90 When 0, indicates that the thread list was empty when the varobj_root
94 /* If 1, the -var-update always recomputes the value in the
95 current thread and frame. Otherwise, variable object is
96 always updated in the specific scope/thread/frame. */
99 /* Flag that indicates validity: set to 0 when this varobj_root refers
100 to symbols that do not exist anymore. */
103 /* Language info for this variable and its children. */
104 struct language_specific *lang;
106 /* The varobj for this root node. */
107 struct varobj *rootvar;
109 /* Next root variable */
110 struct varobj_root *next;
113 /* Every variable in the system has a structure of this type defined
114 for it. This structure holds all information necessary to manipulate
115 a particular object variable. Members which must be freed are noted. */
119 /* Alloc'd name of the variable for this object. If this variable is a
120 child, then this name will be the child's source name.
121 (bar, not foo.bar). */
122 /* NOTE: This is the "expression". */
125 /* Alloc'd expression for this child. Can be used to create a
126 root variable corresponding to this child. */
129 /* The alloc'd name for this variable's object. This is here for
130 convenience when constructing this object's children. */
133 /* Index of this variable in its parent or -1. */
136 /* The type of this variable. This can be NULL
137 for artifial variable objects -- currently, the "accessibility"
138 variable objects in C++. */
141 /* The value of this expression or subexpression. A NULL value
142 indicates there was an error getting this value.
143 Invariant: if varobj_value_is_changeable_p (this) is non-zero,
144 the value is either NULL, or not lazy. */
147 /* The number of (immediate) children this variable has. */
150 /* If this object is a child, this points to its immediate parent. */
151 struct varobj *parent;
153 /* Children of this object. */
154 VEC (varobj_p) *children;
156 /* Whether the children of this varobj were requested. This field is
157 used to decide if dynamic varobj should recompute their children.
158 In the event that the frontend never asked for the children, we
160 int children_requested;
162 /* Description of the root variable. Points to root variable for
164 struct varobj_root *root;
166 /* The format of the output for this object. */
167 enum varobj_display_formats format;
169 /* Was this variable updated via a varobj_set_value operation. */
172 /* Last print value. */
175 /* Is this variable frozen. Frozen variables are never implicitly
176 updated by -var-update *
177 or -var-update <direct-or-indirect-parent>. */
180 /* Is the value of this variable intentionally not fetched? It is
181 not fetched if either the variable is frozen, or any parents is
185 /* Sub-range of children which the MI consumer has requested. If
186 FROM < 0 or TO < 0, means that all children have been
191 /* The pretty-printer constructor. If NULL, then the default
192 pretty-printer will be looked up. If None, then no
193 pretty-printer will be installed. */
194 PyObject *constructor;
196 /* The pretty-printer that has been constructed. If NULL, then a
197 new printer object is needed, and one will be constructed. */
198 PyObject *pretty_printer;
200 /* The iterator returned by the printer's 'children' method, or NULL
202 PyObject *child_iter;
204 /* We request one extra item from the iterator, so that we can
205 report to the caller whether there are more items than we have
206 already reported. However, we don't want to install this value
207 when we read it, because that will mess up future updates. So,
208 we stash it here instead. */
209 PyObject *saved_item;
215 struct cpstack *next;
218 /* A list of varobjs */
226 /* Private function prototypes */
228 /* Helper functions for the above subcommands. */
230 static int delete_variable (struct cpstack **, struct varobj *, int);
232 static void delete_variable_1 (struct cpstack **, int *,
233 struct varobj *, int, int);
235 static int install_variable (struct varobj *);
237 static void uninstall_variable (struct varobj *);
239 static struct varobj *create_child (struct varobj *, int, char *);
241 static struct varobj *
242 create_child_with_value (struct varobj *parent, int index, const char *name,
243 struct value *value);
245 /* Utility routines */
247 static struct varobj *new_variable (void);
249 static struct varobj *new_root_variable (void);
251 static void free_variable (struct varobj *var);
253 static struct cleanup *make_cleanup_free_variable (struct varobj *var);
255 static struct type *get_type (struct varobj *var);
257 static struct type *get_value_type (struct varobj *var);
259 static struct type *get_target_type (struct type *);
261 static enum varobj_display_formats variable_default_display (struct varobj *);
263 static void cppush (struct cpstack **pstack, char *name);
265 static char *cppop (struct cpstack **pstack);
267 static int install_new_value (struct varobj *var, struct value *value,
270 /* Language-specific routines. */
272 static enum varobj_languages variable_language (struct varobj *var);
274 static int number_of_children (struct varobj *);
276 static char *name_of_variable (struct varobj *);
278 static char *name_of_child (struct varobj *, int);
280 static struct value *value_of_root (struct varobj **var_handle, int *);
282 static struct value *value_of_child (struct varobj *parent, int index);
284 static char *my_value_of_variable (struct varobj *var,
285 enum varobj_display_formats format);
287 static char *value_get_print_value (struct value *value,
288 enum varobj_display_formats format,
291 static int varobj_value_is_changeable_p (struct varobj *var);
293 static int is_root_p (struct varobj *var);
297 static struct varobj *varobj_add_child (struct varobj *var,
299 struct value *value);
301 #endif /* HAVE_PYTHON */
303 /* C implementation */
305 static int c_number_of_children (struct varobj *var);
307 static char *c_name_of_variable (struct varobj *parent);
309 static char *c_name_of_child (struct varobj *parent, int index);
311 static char *c_path_expr_of_child (struct varobj *child);
313 static struct value *c_value_of_root (struct varobj **var_handle);
315 static struct value *c_value_of_child (struct varobj *parent, int index);
317 static struct type *c_type_of_child (struct varobj *parent, int index);
319 static char *c_value_of_variable (struct varobj *var,
320 enum varobj_display_formats format);
322 /* C++ implementation */
324 static int cplus_number_of_children (struct varobj *var);
326 static void cplus_class_num_children (struct type *type, int children[3]);
328 static char *cplus_name_of_variable (struct varobj *parent);
330 static char *cplus_name_of_child (struct varobj *parent, int index);
332 static char *cplus_path_expr_of_child (struct varobj *child);
334 static struct value *cplus_value_of_root (struct varobj **var_handle);
336 static struct value *cplus_value_of_child (struct varobj *parent, int index);
338 static struct type *cplus_type_of_child (struct varobj *parent, int index);
340 static char *cplus_value_of_variable (struct varobj *var,
341 enum varobj_display_formats format);
343 /* Java implementation */
345 static int java_number_of_children (struct varobj *var);
347 static char *java_name_of_variable (struct varobj *parent);
349 static char *java_name_of_child (struct varobj *parent, int index);
351 static char *java_path_expr_of_child (struct varobj *child);
353 static struct value *java_value_of_root (struct varobj **var_handle);
355 static struct value *java_value_of_child (struct varobj *parent, int index);
357 static struct type *java_type_of_child (struct varobj *parent, int index);
359 static char *java_value_of_variable (struct varobj *var,
360 enum varobj_display_formats format);
362 /* Ada implementation */
364 static int ada_number_of_children (struct varobj *var);
366 static char *ada_name_of_variable (struct varobj *parent);
368 static char *ada_name_of_child (struct varobj *parent, int index);
370 static char *ada_path_expr_of_child (struct varobj *child);
372 static struct value *ada_value_of_root (struct varobj **var_handle);
374 static struct value *ada_value_of_child (struct varobj *parent, int index);
376 static struct type *ada_type_of_child (struct varobj *parent, int index);
378 static char *ada_value_of_variable (struct varobj *var,
379 enum varobj_display_formats format);
381 /* The language specific vector */
383 struct language_specific
386 /* The language of this variable. */
387 enum varobj_languages language;
389 /* The number of children of PARENT. */
390 int (*number_of_children) (struct varobj * parent);
392 /* The name (expression) of a root varobj. */
393 char *(*name_of_variable) (struct varobj * parent);
395 /* The name of the INDEX'th child of PARENT. */
396 char *(*name_of_child) (struct varobj * parent, int index);
398 /* Returns the rooted expression of CHILD, which is a variable
399 obtain that has some parent. */
400 char *(*path_expr_of_child) (struct varobj * child);
402 /* The ``struct value *'' of the root variable ROOT. */
403 struct value *(*value_of_root) (struct varobj ** root_handle);
405 /* The ``struct value *'' of the INDEX'th child of PARENT. */
406 struct value *(*value_of_child) (struct varobj * parent, int index);
408 /* The type of the INDEX'th child of PARENT. */
409 struct type *(*type_of_child) (struct varobj * parent, int index);
411 /* The current value of VAR. */
412 char *(*value_of_variable) (struct varobj * var,
413 enum varobj_display_formats format);
416 /* Array of known source language routines. */
417 static struct language_specific languages[vlang_end] = {
418 /* Unknown (try treating as C). */
421 c_number_of_children,
424 c_path_expr_of_child,
433 c_number_of_children,
436 c_path_expr_of_child,
445 cplus_number_of_children,
446 cplus_name_of_variable,
448 cplus_path_expr_of_child,
450 cplus_value_of_child,
452 cplus_value_of_variable}
457 java_number_of_children,
458 java_name_of_variable,
460 java_path_expr_of_child,
464 java_value_of_variable},
468 ada_number_of_children,
469 ada_name_of_variable,
471 ada_path_expr_of_child,
475 ada_value_of_variable}
478 /* A little convenience enum for dealing with C++/Java. */
481 v_public = 0, v_private, v_protected
486 /* Mappings of varobj_display_formats enums to gdb's format codes. */
487 static int format_code[] = { 0, 't', 'd', 'x', 'o' };
489 /* Header of the list of root variable objects. */
490 static struct varobj_root *rootlist;
492 /* Prime number indicating the number of buckets in the hash table. */
493 /* A prime large enough to avoid too many colisions. */
494 #define VAROBJ_TABLE_SIZE 227
496 /* Pointer to the varobj hash table (built at run time). */
497 static struct vlist **varobj_table;
499 /* Is the variable X one of our "fake" children? */
500 #define CPLUS_FAKE_CHILD(x) \
501 ((x) != NULL && (x)->type == NULL && (x)->value == NULL)
504 /* API Implementation */
506 is_root_p (struct varobj *var)
508 return (var->root->rootvar == var);
512 /* Helper function to install a Python environment suitable for
513 use during operations on VAR. */
515 varobj_ensure_python_env (struct varobj *var)
517 return ensure_python_env (var->root->exp->gdbarch,
518 var->root->exp->language_defn);
522 /* Creates a varobj (not its children). */
524 /* Return the full FRAME which corresponds to the given CORE_ADDR
525 or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
527 static struct frame_info *
528 find_frame_addr_in_frame_chain (CORE_ADDR frame_addr)
530 struct frame_info *frame = NULL;
532 if (frame_addr == (CORE_ADDR) 0)
535 for (frame = get_current_frame ();
537 frame = get_prev_frame (frame))
539 /* The CORE_ADDR we get as argument was parsed from a string GDB
540 output as $fp. This output got truncated to gdbarch_addr_bit.
541 Truncate the frame base address in the same manner before
542 comparing it against our argument. */
543 CORE_ADDR frame_base = get_frame_base_address (frame);
544 int addr_bit = gdbarch_addr_bit (get_frame_arch (frame));
546 if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
547 frame_base &= ((CORE_ADDR) 1 << addr_bit) - 1;
549 if (frame_base == frame_addr)
557 varobj_create (char *objname,
558 char *expression, CORE_ADDR frame, enum varobj_type type)
561 struct cleanup *old_chain;
563 /* Fill out a varobj structure for the (root) variable being constructed. */
564 var = new_root_variable ();
565 old_chain = make_cleanup_free_variable (var);
567 if (expression != NULL)
569 struct frame_info *fi;
570 struct frame_id old_id = null_frame_id;
573 enum varobj_languages lang;
574 struct value *value = NULL;
575 volatile struct gdb_exception except;
577 /* Parse and evaluate the expression, filling in as much of the
578 variable's data as possible. */
580 if (has_stack_frames ())
582 /* Allow creator to specify context of variable. */
583 if ((type == USE_CURRENT_FRAME) || (type == USE_SELECTED_FRAME))
584 fi = get_selected_frame (NULL);
586 /* FIXME: cagney/2002-11-23: This code should be doing a
587 lookup using the frame ID and not just the frame's
588 ``address''. This, of course, means an interface
589 change. However, with out that interface change ISAs,
590 such as the ia64 with its two stacks, won't work.
591 Similar goes for the case where there is a frameless
593 fi = find_frame_addr_in_frame_chain (frame);
598 /* frame = -2 means always use selected frame. */
599 if (type == USE_SELECTED_FRAME)
600 var->root->floating = 1;
604 block = get_frame_block (fi, 0);
607 innermost_block = NULL;
608 /* Wrap the call to parse expression, so we can
609 return a sensible error. */
610 TRY_CATCH (except, RETURN_MASK_ERROR)
612 var->root->exp = parse_exp_1 (&p, block, 0);
615 if (except.reason < 0)
617 do_cleanups (old_chain);
621 /* Don't allow variables to be created for types. */
622 if (var->root->exp->elts[0].opcode == OP_TYPE)
624 do_cleanups (old_chain);
625 fprintf_unfiltered (gdb_stderr, "Attempt to use a type name"
626 " as an expression.\n");
630 var->format = variable_default_display (var);
631 var->root->valid_block = innermost_block;
632 var->name = xstrdup (expression);
633 /* For a root var, the name and the expr are the same. */
634 var->path_expr = xstrdup (expression);
636 /* When the frame is different from the current frame,
637 we must select the appropriate frame before parsing
638 the expression, otherwise the value will not be current.
639 Since select_frame is so benign, just call it for all cases. */
642 /* User could specify explicit FRAME-ADDR which was not found but
643 EXPRESSION is frame specific and we would not be able to evaluate
644 it correctly next time. With VALID_BLOCK set we must also set
645 FRAME and THREAD_ID. */
647 error (_("Failed to find the specified frame"));
649 var->root->frame = get_frame_id (fi);
650 var->root->thread_id = pid_to_thread_id (inferior_ptid);
651 old_id = get_frame_id (get_selected_frame (NULL));
655 /* We definitely need to catch errors here.
656 If evaluate_expression succeeds we got the value we wanted.
657 But if it fails, we still go on with a call to evaluate_type(). */
658 TRY_CATCH (except, RETURN_MASK_ERROR)
660 value = evaluate_expression (var->root->exp);
663 if (except.reason < 0)
665 /* Error getting the value. Try to at least get the
667 struct value *type_only_value = evaluate_type (var->root->exp);
669 var->type = value_type (type_only_value);
672 var->type = value_type (value);
674 install_new_value (var, value, 1 /* Initial assignment */);
676 /* Set language info */
677 lang = variable_language (var);
678 var->root->lang = &languages[lang];
680 /* Set ourselves as our root. */
681 var->root->rootvar = var;
683 /* Reset the selected frame. */
684 if (frame_id_p (old_id))
685 select_frame (frame_find_by_id (old_id));
688 /* If the variable object name is null, that means this
689 is a temporary variable, so don't install it. */
691 if ((var != NULL) && (objname != NULL))
693 var->obj_name = xstrdup (objname);
695 /* If a varobj name is duplicated, the install will fail so
697 if (!install_variable (var))
699 do_cleanups (old_chain);
704 discard_cleanups (old_chain);
708 /* Generates an unique name that can be used for a varobj. */
711 varobj_gen_name (void)
716 /* Generate a name for this object. */
718 obj_name = xstrprintf ("var%d", id);
723 /* Given an OBJNAME, returns the pointer to the corresponding varobj. Call
724 error if OBJNAME cannot be found. */
727 varobj_get_handle (char *objname)
731 unsigned int index = 0;
734 for (chp = objname; *chp; chp++)
736 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
739 cv = *(varobj_table + index);
740 while ((cv != NULL) && (strcmp (cv->var->obj_name, objname) != 0))
744 error (_("Variable object not found"));
749 /* Given the handle, return the name of the object. */
752 varobj_get_objname (struct varobj *var)
754 return var->obj_name;
757 /* Given the handle, return the expression represented by the object. */
760 varobj_get_expression (struct varobj *var)
762 return name_of_variable (var);
765 /* Deletes a varobj and all its children if only_children == 0,
766 otherwise deletes only the children; returns a malloc'ed list of
767 all the (malloc'ed) names of the variables that have been deleted
768 (NULL terminated). */
771 varobj_delete (struct varobj *var, char ***dellist, int only_children)
775 struct cpstack *result = NULL;
778 /* Initialize a stack for temporary results. */
779 cppush (&result, NULL);
782 /* Delete only the variable children. */
783 delcount = delete_variable (&result, var, 1 /* only the children */ );
785 /* Delete the variable and all its children. */
786 delcount = delete_variable (&result, var, 0 /* parent+children */ );
788 /* We may have been asked to return a list of what has been deleted. */
791 *dellist = xmalloc ((delcount + 1) * sizeof (char *));
795 *cp = cppop (&result);
796 while ((*cp != NULL) && (mycount > 0))
800 *cp = cppop (&result);
803 if (mycount || (*cp != NULL))
804 warning (_("varobj_delete: assertion failed - mycount(=%d) <> 0"),
813 /* Convenience function for varobj_set_visualizer. Instantiate a
814 pretty-printer for a given value. */
816 instantiate_pretty_printer (PyObject *constructor, struct value *value)
818 PyObject *val_obj = NULL;
821 val_obj = value_to_value_object (value);
825 printer = PyObject_CallFunctionObjArgs (constructor, val_obj, NULL);
832 /* Set/Get variable object display format. */
834 enum varobj_display_formats
835 varobj_set_display_format (struct varobj *var,
836 enum varobj_display_formats format)
843 case FORMAT_HEXADECIMAL:
845 var->format = format;
849 var->format = variable_default_display (var);
852 if (varobj_value_is_changeable_p (var)
853 && var->value && !value_lazy (var->value))
855 xfree (var->print_value);
856 var->print_value = value_get_print_value (var->value, var->format, var);
862 enum varobj_display_formats
863 varobj_get_display_format (struct varobj *var)
869 varobj_get_display_hint (struct varobj *var)
874 struct cleanup *back_to = varobj_ensure_python_env (var);
876 if (var->pretty_printer)
877 result = gdbpy_get_display_hint (var->pretty_printer);
879 do_cleanups (back_to);
885 /* Return true if the varobj has items after TO, false otherwise. */
888 varobj_has_more (struct varobj *var, int to)
890 if (VEC_length (varobj_p, var->children) > to)
892 return ((to == -1 || VEC_length (varobj_p, var->children) == to)
893 && var->saved_item != NULL);
896 /* If the variable object is bound to a specific thread, that
897 is its evaluation can always be done in context of a frame
898 inside that thread, returns GDB id of the thread -- which
899 is always positive. Otherwise, returns -1. */
901 varobj_get_thread_id (struct varobj *var)
903 if (var->root->valid_block && var->root->thread_id > 0)
904 return var->root->thread_id;
910 varobj_set_frozen (struct varobj *var, int frozen)
912 /* When a variable is unfrozen, we don't fetch its value.
913 The 'not_fetched' flag remains set, so next -var-update
916 We don't fetch the value, because for structures the client
917 should do -var-update anyway. It would be bad to have different
918 client-size logic for structure and other types. */
919 var->frozen = frozen;
923 varobj_get_frozen (struct varobj *var)
928 /* A helper function that restricts a range to what is actually
929 available in a VEC. This follows the usual rules for the meaning
930 of FROM and TO -- if either is negative, the entire range is
934 restrict_range (VEC (varobj_p) *children, int *from, int *to)
936 if (*from < 0 || *to < 0)
939 *to = VEC_length (varobj_p, children);
943 if (*from > VEC_length (varobj_p, children))
944 *from = VEC_length (varobj_p, children);
945 if (*to > VEC_length (varobj_p, children))
946 *to = VEC_length (varobj_p, children);
954 /* A helper for update_dynamic_varobj_children that installs a new
955 child when needed. */
958 install_dynamic_child (struct varobj *var,
959 VEC (varobj_p) **changed,
960 VEC (varobj_p) **new,
961 VEC (varobj_p) **unchanged,
967 if (VEC_length (varobj_p, var->children) < index + 1)
969 /* There's no child yet. */
970 struct varobj *child = varobj_add_child (var, name, value);
974 VEC_safe_push (varobj_p, *new, child);
980 varobj_p existing = VEC_index (varobj_p, var->children, index);
982 if (install_new_value (existing, value, 0))
985 VEC_safe_push (varobj_p, *changed, existing);
988 VEC_safe_push (varobj_p, *unchanged, existing);
993 dynamic_varobj_has_child_method (struct varobj *var)
995 struct cleanup *back_to;
996 PyObject *printer = var->pretty_printer;
999 back_to = varobj_ensure_python_env (var);
1000 result = PyObject_HasAttr (printer, gdbpy_children_cst);
1001 do_cleanups (back_to);
1008 update_dynamic_varobj_children (struct varobj *var,
1009 VEC (varobj_p) **changed,
1010 VEC (varobj_p) **new,
1011 VEC (varobj_p) **unchanged,
1013 int update_children,
1018 struct cleanup *back_to;
1021 PyObject *printer = var->pretty_printer;
1023 back_to = varobj_ensure_python_env (var);
1026 if (!PyObject_HasAttr (printer, gdbpy_children_cst))
1028 do_cleanups (back_to);
1032 if (update_children || !var->child_iter)
1034 children = PyObject_CallMethodObjArgs (printer, gdbpy_children_cst,
1039 gdbpy_print_stack ();
1040 error (_("Null value returned for children"));
1043 make_cleanup_py_decref (children);
1045 if (!PyIter_Check (children))
1046 error (_("Returned value is not iterable"));
1048 Py_XDECREF (var->child_iter);
1049 var->child_iter = PyObject_GetIter (children);
1050 if (!var->child_iter)
1052 gdbpy_print_stack ();
1053 error (_("Could not get children iterator"));
1056 Py_XDECREF (var->saved_item);
1057 var->saved_item = NULL;
1062 i = VEC_length (varobj_p, var->children);
1064 /* We ask for one extra child, so that MI can report whether there
1065 are more children. */
1066 for (; to < 0 || i < to + 1; ++i)
1071 /* See if there was a leftover from last time. */
1072 if (var->saved_item)
1074 item = var->saved_item;
1075 var->saved_item = NULL;
1078 item = PyIter_Next (var->child_iter);
1082 /* Normal end of iteration. */
1083 if (!PyErr_Occurred ())
1086 /* If we got a memory error, just use the text as the
1088 if (PyErr_ExceptionMatches (gdbpy_gdb_memory_error))
1090 PyObject *type, *value, *trace;
1091 char *name_str, *value_str;
1093 PyErr_Fetch (&type, &value, &trace);
1094 value_str = gdbpy_exception_to_string (type, value);
1100 gdbpy_print_stack ();
1104 name_str = xstrprintf ("<error at %d>", i);
1105 item = Py_BuildValue ("(ss)", name_str, value_str);
1110 gdbpy_print_stack ();
1118 /* Any other kind of error. */
1119 gdbpy_print_stack ();
1124 /* We don't want to push the extra child on any report list. */
1125 if (to < 0 || i < to)
1130 struct cleanup *inner;
1131 int can_mention = from < 0 || i >= from;
1133 inner = make_cleanup_py_decref (item);
1135 if (!PyArg_ParseTuple (item, "sO", &name, &py_v))
1137 gdbpy_print_stack ();
1138 error (_("Invalid item from the child list"));
1141 v = convert_value_from_python (py_v);
1143 gdbpy_print_stack ();
1144 install_dynamic_child (var, can_mention ? changed : NULL,
1145 can_mention ? new : NULL,
1146 can_mention ? unchanged : NULL,
1147 can_mention ? cchanged : NULL, i, name, v);
1148 do_cleanups (inner);
1152 Py_XDECREF (var->saved_item);
1153 var->saved_item = item;
1155 /* We want to truncate the child list just before this
1164 if (i < VEC_length (varobj_p, var->children))
1169 for (j = i; j < VEC_length (varobj_p, var->children); ++j)
1170 varobj_delete (VEC_index (varobj_p, var->children, j), NULL, 0);
1171 VEC_truncate (varobj_p, var->children, i);
1174 /* If there are fewer children than requested, note that the list of
1175 children changed. */
1176 if (to >= 0 && VEC_length (varobj_p, var->children) < to)
1179 var->num_children = VEC_length (varobj_p, var->children);
1181 do_cleanups (back_to);
1185 gdb_assert (0 && "should never be called if Python is not enabled");
1190 varobj_get_num_children (struct varobj *var)
1192 if (var->num_children == -1)
1194 if (var->pretty_printer)
1198 /* If we have a dynamic varobj, don't report -1 children.
1199 So, try to fetch some children first. */
1200 update_dynamic_varobj_children (var, NULL, NULL, NULL, &dummy,
1204 var->num_children = number_of_children (var);
1207 return var->num_children >= 0 ? var->num_children : 0;
1210 /* Creates a list of the immediate children of a variable object;
1211 the return code is the number of such children or -1 on error. */
1214 varobj_list_children (struct varobj *var, int *from, int *to)
1217 int i, children_changed;
1219 var->children_requested = 1;
1221 if (var->pretty_printer)
1223 /* This, in theory, can result in the number of children changing without
1224 frontend noticing. But well, calling -var-list-children on the same
1225 varobj twice is not something a sane frontend would do. */
1226 update_dynamic_varobj_children (var, NULL, NULL, NULL, &children_changed,
1228 restrict_range (var->children, from, to);
1229 return var->children;
1232 if (var->num_children == -1)
1233 var->num_children = number_of_children (var);
1235 /* If that failed, give up. */
1236 if (var->num_children == -1)
1237 return var->children;
1239 /* If we're called when the list of children is not yet initialized,
1240 allocate enough elements in it. */
1241 while (VEC_length (varobj_p, var->children) < var->num_children)
1242 VEC_safe_push (varobj_p, var->children, NULL);
1244 for (i = 0; i < var->num_children; i++)
1246 varobj_p existing = VEC_index (varobj_p, var->children, i);
1248 if (existing == NULL)
1250 /* Either it's the first call to varobj_list_children for
1251 this variable object, and the child was never created,
1252 or it was explicitly deleted by the client. */
1253 name = name_of_child (var, i);
1254 existing = create_child (var, i, name);
1255 VEC_replace (varobj_p, var->children, i, existing);
1259 restrict_range (var->children, from, to);
1260 return var->children;
1265 static struct varobj *
1266 varobj_add_child (struct varobj *var, const char *name, struct value *value)
1268 varobj_p v = create_child_with_value (var,
1269 VEC_length (varobj_p, var->children),
1272 VEC_safe_push (varobj_p, var->children, v);
1276 #endif /* HAVE_PYTHON */
1278 /* Obtain the type of an object Variable as a string similar to the one gdb
1279 prints on the console. */
1282 varobj_get_type (struct varobj *var)
1284 /* For the "fake" variables, do not return a type. (It's type is
1286 Do not return a type for invalid variables as well. */
1287 if (CPLUS_FAKE_CHILD (var) || !var->root->is_valid)
1290 return type_to_string (var->type);
1293 /* Obtain the type of an object variable. */
1296 varobj_get_gdb_type (struct varobj *var)
1301 /* Return a pointer to the full rooted expression of varobj VAR.
1302 If it has not been computed yet, compute it. */
1304 varobj_get_path_expr (struct varobj *var)
1306 if (var->path_expr != NULL)
1307 return var->path_expr;
1310 /* For root varobjs, we initialize path_expr
1311 when creating varobj, so here it should be
1313 gdb_assert (!is_root_p (var));
1314 return (*var->root->lang->path_expr_of_child) (var);
1318 enum varobj_languages
1319 varobj_get_language (struct varobj *var)
1321 return variable_language (var);
1325 varobj_get_attributes (struct varobj *var)
1329 if (varobj_editable_p (var))
1330 /* FIXME: define masks for attributes. */
1331 attributes |= 0x00000001; /* Editable */
1337 varobj_pretty_printed_p (struct varobj *var)
1339 return var->pretty_printer != NULL;
1343 varobj_get_formatted_value (struct varobj *var,
1344 enum varobj_display_formats format)
1346 return my_value_of_variable (var, format);
1350 varobj_get_value (struct varobj *var)
1352 return my_value_of_variable (var, var->format);
1355 /* Set the value of an object variable (if it is editable) to the
1356 value of the given expression. */
1357 /* Note: Invokes functions that can call error(). */
1360 varobj_set_value (struct varobj *var, char *expression)
1364 /* The argument "expression" contains the variable's new value.
1365 We need to first construct a legal expression for this -- ugh! */
1366 /* Does this cover all the bases? */
1367 struct expression *exp;
1368 struct value *value;
1369 int saved_input_radix = input_radix;
1370 char *s = expression;
1371 volatile struct gdb_exception except;
1373 gdb_assert (varobj_editable_p (var));
1375 input_radix = 10; /* ALWAYS reset to decimal temporarily. */
1376 exp = parse_exp_1 (&s, 0, 0);
1377 TRY_CATCH (except, RETURN_MASK_ERROR)
1379 value = evaluate_expression (exp);
1382 if (except.reason < 0)
1384 /* We cannot proceed without a valid expression. */
1389 /* All types that are editable must also be changeable. */
1390 gdb_assert (varobj_value_is_changeable_p (var));
1392 /* The value of a changeable variable object must not be lazy. */
1393 gdb_assert (!value_lazy (var->value));
1395 /* Need to coerce the input. We want to check if the
1396 value of the variable object will be different
1397 after assignment, and the first thing value_assign
1398 does is coerce the input.
1399 For example, if we are assigning an array to a pointer variable we
1400 should compare the pointer with the array's address, not with the
1402 value = coerce_array (value);
1404 /* The new value may be lazy. value_assign, or
1405 rather value_contents, will take care of this. */
1406 TRY_CATCH (except, RETURN_MASK_ERROR)
1408 val = value_assign (var->value, value);
1411 if (except.reason < 0)
1414 /* If the value has changed, record it, so that next -var-update can
1415 report this change. If a variable had a value of '1', we've set it
1416 to '333' and then set again to '1', when -var-update will report this
1417 variable as changed -- because the first assignment has set the
1418 'updated' flag. There's no need to optimize that, because return value
1419 of -var-update should be considered an approximation. */
1420 var->updated = install_new_value (var, val, 0 /* Compare values. */);
1421 input_radix = saved_input_radix;
1427 /* A helper function to install a constructor function and visualizer
1431 install_visualizer (struct varobj *var, PyObject *constructor,
1432 PyObject *visualizer)
1434 Py_XDECREF (var->constructor);
1435 var->constructor = constructor;
1437 Py_XDECREF (var->pretty_printer);
1438 var->pretty_printer = visualizer;
1440 Py_XDECREF (var->child_iter);
1441 var->child_iter = NULL;
1444 /* Install the default visualizer for VAR. */
1447 install_default_visualizer (struct varobj *var)
1449 /* Do not install a visualizer on a CPLUS_FAKE_CHILD. */
1450 if (CPLUS_FAKE_CHILD (var))
1453 if (pretty_printing)
1455 PyObject *pretty_printer = NULL;
1459 pretty_printer = gdbpy_get_varobj_pretty_printer (var->value);
1460 if (! pretty_printer)
1462 gdbpy_print_stack ();
1463 error (_("Cannot instantiate printer for default visualizer"));
1467 if (pretty_printer == Py_None)
1469 Py_DECREF (pretty_printer);
1470 pretty_printer = NULL;
1473 install_visualizer (var, NULL, pretty_printer);
1477 /* Instantiate and install a visualizer for VAR using CONSTRUCTOR to
1478 make a new object. */
1481 construct_visualizer (struct varobj *var, PyObject *constructor)
1483 PyObject *pretty_printer;
1485 /* Do not install a visualizer on a CPLUS_FAKE_CHILD. */
1486 if (CPLUS_FAKE_CHILD (var))
1489 Py_INCREF (constructor);
1490 if (constructor == Py_None)
1491 pretty_printer = NULL;
1494 pretty_printer = instantiate_pretty_printer (constructor, var->value);
1495 if (! pretty_printer)
1497 gdbpy_print_stack ();
1498 Py_DECREF (constructor);
1499 constructor = Py_None;
1500 Py_INCREF (constructor);
1503 if (pretty_printer == Py_None)
1505 Py_DECREF (pretty_printer);
1506 pretty_printer = NULL;
1510 install_visualizer (var, constructor, pretty_printer);
1513 #endif /* HAVE_PYTHON */
1515 /* A helper function for install_new_value. This creates and installs
1516 a visualizer for VAR, if appropriate. */
1519 install_new_value_visualizer (struct varobj *var)
1522 /* If the constructor is None, then we want the raw value. If VAR
1523 does not have a value, just skip this. */
1524 if (var->constructor != Py_None && var->value)
1526 struct cleanup *cleanup;
1528 cleanup = varobj_ensure_python_env (var);
1530 if (!var->constructor)
1531 install_default_visualizer (var);
1533 construct_visualizer (var, var->constructor);
1535 do_cleanups (cleanup);
1542 /* Assign a new value to a variable object. If INITIAL is non-zero,
1543 this is the first assignement after the variable object was just
1544 created, or changed type. In that case, just assign the value
1546 Otherwise, assign the new value, and return 1 if the value is
1547 different from the current one, 0 otherwise. The comparison is
1548 done on textual representation of value. Therefore, some types
1549 need not be compared. E.g. for structures the reported value is
1550 always "{...}", so no comparison is necessary here. If the old
1551 value was NULL and new one is not, or vice versa, we always return 1.
1553 The VALUE parameter should not be released -- the function will
1554 take care of releasing it when needed. */
1556 install_new_value (struct varobj *var, struct value *value, int initial)
1561 int intentionally_not_fetched = 0;
1562 char *print_value = NULL;
1564 /* We need to know the varobj's type to decide if the value should
1565 be fetched or not. C++ fake children (public/protected/private)
1566 don't have a type. */
1567 gdb_assert (var->type || CPLUS_FAKE_CHILD (var));
1568 changeable = varobj_value_is_changeable_p (var);
1570 /* If the type has custom visualizer, we consider it to be always
1571 changeable. FIXME: need to make sure this behaviour will not
1572 mess up read-sensitive values. */
1573 if (var->pretty_printer)
1576 need_to_fetch = changeable;
1578 /* We are not interested in the address of references, and given
1579 that in C++ a reference is not rebindable, it cannot
1580 meaningfully change. So, get hold of the real value. */
1582 value = coerce_ref (value);
1584 if (var->type && TYPE_CODE (var->type) == TYPE_CODE_UNION)
1585 /* For unions, we need to fetch the value implicitly because
1586 of implementation of union member fetch. When gdb
1587 creates a value for a field and the value of the enclosing
1588 structure is not lazy, it immediately copies the necessary
1589 bytes from the enclosing values. If the enclosing value is
1590 lazy, the call to value_fetch_lazy on the field will read
1591 the data from memory. For unions, that means we'll read the
1592 same memory more than once, which is not desirable. So
1596 /* The new value might be lazy. If the type is changeable,
1597 that is we'll be comparing values of this type, fetch the
1598 value now. Otherwise, on the next update the old value
1599 will be lazy, which means we've lost that old value. */
1600 if (need_to_fetch && value && value_lazy (value))
1602 struct varobj *parent = var->parent;
1603 int frozen = var->frozen;
1605 for (; !frozen && parent; parent = parent->parent)
1606 frozen |= parent->frozen;
1608 if (frozen && initial)
1610 /* For variables that are frozen, or are children of frozen
1611 variables, we don't do fetch on initial assignment.
1612 For non-initial assignemnt we do the fetch, since it means we're
1613 explicitly asked to compare the new value with the old one. */
1614 intentionally_not_fetched = 1;
1618 volatile struct gdb_exception except;
1620 TRY_CATCH (except, RETURN_MASK_ERROR)
1622 value_fetch_lazy (value);
1625 if (except.reason < 0)
1627 /* Set the value to NULL, so that for the next -var-update,
1628 we don't try to compare the new value with this value,
1629 that we couldn't even read. */
1635 /* Get a reference now, before possibly passing it to any Python
1636 code that might release it. */
1638 value_incref (value);
1640 /* Below, we'll be comparing string rendering of old and new
1641 values. Don't get string rendering if the value is
1642 lazy -- if it is, the code above has decided that the value
1643 should not be fetched. */
1644 if (value && !value_lazy (value) && !var->pretty_printer)
1645 print_value = value_get_print_value (value, var->format, var);
1647 /* If the type is changeable, compare the old and the new values.
1648 If this is the initial assignment, we don't have any old value
1650 if (!initial && changeable)
1652 /* If the value of the varobj was changed by -var-set-value,
1653 then the value in the varobj and in the target is the same.
1654 However, that value is different from the value that the
1655 varobj had after the previous -var-update. So need to the
1656 varobj as changed. */
1661 else if (! var->pretty_printer)
1663 /* Try to compare the values. That requires that both
1664 values are non-lazy. */
1665 if (var->not_fetched && value_lazy (var->value))
1667 /* This is a frozen varobj and the value was never read.
1668 Presumably, UI shows some "never read" indicator.
1669 Now that we've fetched the real value, we need to report
1670 this varobj as changed so that UI can show the real
1674 else if (var->value == NULL && value == NULL)
1677 else if (var->value == NULL || value == NULL)
1683 gdb_assert (!value_lazy (var->value));
1684 gdb_assert (!value_lazy (value));
1686 gdb_assert (var->print_value != NULL && print_value != NULL);
1687 if (strcmp (var->print_value, print_value) != 0)
1693 if (!initial && !changeable)
1695 /* For values that are not changeable, we don't compare the values.
1696 However, we want to notice if a value was not NULL and now is NULL,
1697 or vise versa, so that we report when top-level varobjs come in scope
1698 and leave the scope. */
1699 changed = (var->value != NULL) != (value != NULL);
1702 /* We must always keep the new value, since children depend on it. */
1703 if (var->value != NULL && var->value != value)
1704 value_free (var->value);
1706 if (value && value_lazy (value) && intentionally_not_fetched)
1707 var->not_fetched = 1;
1709 var->not_fetched = 0;
1712 install_new_value_visualizer (var);
1714 /* If we installed a pretty-printer, re-compare the printed version
1715 to see if the variable changed. */
1716 if (var->pretty_printer)
1718 xfree (print_value);
1719 print_value = value_get_print_value (var->value, var->format, var);
1720 if ((var->print_value == NULL && print_value != NULL)
1721 || (var->print_value != NULL && print_value == NULL)
1722 || (var->print_value != NULL && print_value != NULL
1723 && strcmp (var->print_value, print_value) != 0))
1726 if (var->print_value)
1727 xfree (var->print_value);
1728 var->print_value = print_value;
1730 gdb_assert (!var->value || value_type (var->value));
1735 /* Return the requested range for a varobj. VAR is the varobj. FROM
1736 and TO are out parameters; *FROM and *TO will be set to the
1737 selected sub-range of VAR. If no range was selected using
1738 -var-set-update-range, then both will be -1. */
1740 varobj_get_child_range (struct varobj *var, int *from, int *to)
1746 /* Set the selected sub-range of children of VAR to start at index
1747 FROM and end at index TO. If either FROM or TO is less than zero,
1748 this is interpreted as a request for all children. */
1750 varobj_set_child_range (struct varobj *var, int from, int to)
1757 varobj_set_visualizer (struct varobj *var, const char *visualizer)
1760 PyObject *mainmod, *globals, *constructor;
1761 struct cleanup *back_to;
1763 back_to = varobj_ensure_python_env (var);
1765 mainmod = PyImport_AddModule ("__main__");
1766 globals = PyModule_GetDict (mainmod);
1767 Py_INCREF (globals);
1768 make_cleanup_py_decref (globals);
1770 constructor = PyRun_String (visualizer, Py_eval_input, globals, globals);
1774 gdbpy_print_stack ();
1775 error (_("Could not evaluate visualizer expression: %s"), visualizer);
1778 construct_visualizer (var, constructor);
1779 Py_XDECREF (constructor);
1781 /* If there are any children now, wipe them. */
1782 varobj_delete (var, NULL, 1 /* children only */);
1783 var->num_children = -1;
1785 do_cleanups (back_to);
1787 error (_("Python support required"));
1791 /* Update the values for a variable and its children. This is a
1792 two-pronged attack. First, re-parse the value for the root's
1793 expression to see if it's changed. Then go all the way
1794 through its children, reconstructing them and noting if they've
1797 The EXPLICIT parameter specifies if this call is result
1798 of MI request to update this specific variable, or
1799 result of implicit -var-update *. For implicit request, we don't
1800 update frozen variables.
1802 NOTE: This function may delete the caller's varobj. If it
1803 returns TYPE_CHANGED, then it has done this and VARP will be modified
1804 to point to the new varobj. */
1806 VEC(varobj_update_result) *
1807 varobj_update (struct varobj **varp, int explicit)
1810 int type_changed = 0;
1813 VEC (varobj_update_result) *stack = NULL;
1814 VEC (varobj_update_result) *result = NULL;
1816 /* Frozen means frozen -- we don't check for any change in
1817 this varobj, including its going out of scope, or
1818 changing type. One use case for frozen varobjs is
1819 retaining previously evaluated expressions, and we don't
1820 want them to be reevaluated at all. */
1821 if (!explicit && (*varp)->frozen)
1824 if (!(*varp)->root->is_valid)
1826 varobj_update_result r = {0};
1829 r.status = VAROBJ_INVALID;
1830 VEC_safe_push (varobj_update_result, result, &r);
1834 if ((*varp)->root->rootvar == *varp)
1836 varobj_update_result r = {0};
1839 r.status = VAROBJ_IN_SCOPE;
1841 /* Update the root variable. value_of_root can return NULL
1842 if the variable is no longer around, i.e. we stepped out of
1843 the frame in which a local existed. We are letting the
1844 value_of_root variable dispose of the varobj if the type
1846 new = value_of_root (varp, &type_changed);
1849 r.type_changed = type_changed;
1850 if (install_new_value ((*varp), new, type_changed))
1854 r.status = VAROBJ_NOT_IN_SCOPE;
1855 r.value_installed = 1;
1857 if (r.status == VAROBJ_NOT_IN_SCOPE)
1859 if (r.type_changed || r.changed)
1860 VEC_safe_push (varobj_update_result, result, &r);
1864 VEC_safe_push (varobj_update_result, stack, &r);
1868 varobj_update_result r = {0};
1871 VEC_safe_push (varobj_update_result, stack, &r);
1874 /* Walk through the children, reconstructing them all. */
1875 while (!VEC_empty (varobj_update_result, stack))
1877 varobj_update_result r = *(VEC_last (varobj_update_result, stack));
1878 struct varobj *v = r.varobj;
1880 VEC_pop (varobj_update_result, stack);
1882 /* Update this variable, unless it's a root, which is already
1884 if (!r.value_installed)
1886 new = value_of_child (v->parent, v->index);
1887 if (install_new_value (v, new, 0 /* type not changed */))
1894 /* We probably should not get children of a varobj that has a
1895 pretty-printer, but for which -var-list-children was never
1897 if (v->pretty_printer)
1899 VEC (varobj_p) *changed = 0, *new = 0, *unchanged = 0;
1900 int i, children_changed = 0;
1905 if (!v->children_requested)
1909 /* If we initially did not have potential children, but
1910 now we do, consider the varobj as changed.
1911 Otherwise, if children were never requested, consider
1912 it as unchanged -- presumably, such varobj is not yet
1913 expanded in the UI, so we need not bother getting
1915 if (!varobj_has_more (v, 0))
1917 update_dynamic_varobj_children (v, NULL, NULL, NULL,
1919 if (varobj_has_more (v, 0))
1924 VEC_safe_push (varobj_update_result, result, &r);
1929 /* If update_dynamic_varobj_children returns 0, then we have
1930 a non-conforming pretty-printer, so we skip it. */
1931 if (update_dynamic_varobj_children (v, &changed, &new, &unchanged,
1932 &children_changed, 1,
1935 if (children_changed || new)
1937 r.children_changed = 1;
1940 /* Push in reverse order so that the first child is
1941 popped from the work stack first, and so will be
1942 added to result first. This does not affect
1943 correctness, just "nicer". */
1944 for (i = VEC_length (varobj_p, changed) - 1; i >= 0; --i)
1946 varobj_p tmp = VEC_index (varobj_p, changed, i);
1947 varobj_update_result r = {0};
1951 r.value_installed = 1;
1952 VEC_safe_push (varobj_update_result, stack, &r);
1954 for (i = VEC_length (varobj_p, unchanged) - 1; i >= 0; --i)
1956 varobj_p tmp = VEC_index (varobj_p, unchanged, i);
1960 varobj_update_result r = {0};
1963 r.value_installed = 1;
1964 VEC_safe_push (varobj_update_result, stack, &r);
1967 if (r.changed || r.children_changed)
1968 VEC_safe_push (varobj_update_result, result, &r);
1970 /* Free CHANGED and UNCHANGED, but not NEW, because NEW
1971 has been put into the result vector. */
1972 VEC_free (varobj_p, changed);
1973 VEC_free (varobj_p, unchanged);
1979 /* Push any children. Use reverse order so that the first
1980 child is popped from the work stack first, and so
1981 will be added to result first. This does not
1982 affect correctness, just "nicer". */
1983 for (i = VEC_length (varobj_p, v->children)-1; i >= 0; --i)
1985 varobj_p c = VEC_index (varobj_p, v->children, i);
1987 /* Child may be NULL if explicitly deleted by -var-delete. */
1988 if (c != NULL && !c->frozen)
1990 varobj_update_result r = {0};
1993 VEC_safe_push (varobj_update_result, stack, &r);
1997 if (r.changed || r.type_changed)
1998 VEC_safe_push (varobj_update_result, result, &r);
2001 VEC_free (varobj_update_result, stack);
2007 /* Helper functions */
2010 * Variable object construction/destruction
2014 delete_variable (struct cpstack **resultp, struct varobj *var,
2015 int only_children_p)
2019 delete_variable_1 (resultp, &delcount, var,
2020 only_children_p, 1 /* remove_from_parent_p */ );
2025 /* Delete the variable object VAR and its children. */
2026 /* IMPORTANT NOTE: If we delete a variable which is a child
2027 and the parent is not removed we dump core. It must be always
2028 initially called with remove_from_parent_p set. */
2030 delete_variable_1 (struct cpstack **resultp, int *delcountp,
2031 struct varobj *var, int only_children_p,
2032 int remove_from_parent_p)
2036 /* Delete any children of this variable, too. */
2037 for (i = 0; i < VEC_length (varobj_p, var->children); ++i)
2039 varobj_p child = VEC_index (varobj_p, var->children, i);
2043 if (!remove_from_parent_p)
2044 child->parent = NULL;
2045 delete_variable_1 (resultp, delcountp, child, 0, only_children_p);
2047 VEC_free (varobj_p, var->children);
2049 /* if we were called to delete only the children we are done here. */
2050 if (only_children_p)
2053 /* Otherwise, add it to the list of deleted ones and proceed to do so. */
2054 /* If the name is null, this is a temporary variable, that has not
2055 yet been installed, don't report it, it belongs to the caller... */
2056 if (var->obj_name != NULL)
2058 cppush (resultp, xstrdup (var->obj_name));
2059 *delcountp = *delcountp + 1;
2062 /* If this variable has a parent, remove it from its parent's list. */
2063 /* OPTIMIZATION: if the parent of this variable is also being deleted,
2064 (as indicated by remove_from_parent_p) we don't bother doing an
2065 expensive list search to find the element to remove when we are
2066 discarding the list afterwards. */
2067 if ((remove_from_parent_p) && (var->parent != NULL))
2069 VEC_replace (varobj_p, var->parent->children, var->index, NULL);
2072 if (var->obj_name != NULL)
2073 uninstall_variable (var);
2075 /* Free memory associated with this variable. */
2076 free_variable (var);
2079 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
2081 install_variable (struct varobj *var)
2084 struct vlist *newvl;
2086 unsigned int index = 0;
2089 for (chp = var->obj_name; *chp; chp++)
2091 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
2094 cv = *(varobj_table + index);
2095 while ((cv != NULL) && (strcmp (cv->var->obj_name, var->obj_name) != 0))
2099 error (_("Duplicate variable object name"));
2101 /* Add varobj to hash table. */
2102 newvl = xmalloc (sizeof (struct vlist));
2103 newvl->next = *(varobj_table + index);
2105 *(varobj_table + index) = newvl;
2107 /* If root, add varobj to root list. */
2108 if (is_root_p (var))
2110 /* Add to list of root variables. */
2111 if (rootlist == NULL)
2112 var->root->next = NULL;
2114 var->root->next = rootlist;
2115 rootlist = var->root;
2121 /* Unistall the object VAR. */
2123 uninstall_variable (struct varobj *var)
2127 struct varobj_root *cr;
2128 struct varobj_root *prer;
2130 unsigned int index = 0;
2133 /* Remove varobj from hash table. */
2134 for (chp = var->obj_name; *chp; chp++)
2136 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
2139 cv = *(varobj_table + index);
2141 while ((cv != NULL) && (strcmp (cv->var->obj_name, var->obj_name) != 0))
2148 fprintf_unfiltered (gdb_stdlog, "Deleting %s\n", var->obj_name);
2153 ("Assertion failed: Could not find variable object \"%s\" to delete",
2159 *(varobj_table + index) = cv->next;
2161 prev->next = cv->next;
2165 /* If root, remove varobj from root list. */
2166 if (is_root_p (var))
2168 /* Remove from list of root variables. */
2169 if (rootlist == var->root)
2170 rootlist = var->root->next;
2175 while ((cr != NULL) && (cr->rootvar != var))
2182 warning (_("Assertion failed: Could not find "
2183 "varobj \"%s\" in root list"),
2190 prer->next = cr->next;
2196 /* Create and install a child of the parent of the given name. */
2197 static struct varobj *
2198 create_child (struct varobj *parent, int index, char *name)
2200 return create_child_with_value (parent, index, name,
2201 value_of_child (parent, index));
2204 static struct varobj *
2205 create_child_with_value (struct varobj *parent, int index, const char *name,
2206 struct value *value)
2208 struct varobj *child;
2211 child = new_variable ();
2213 /* Name is allocated by name_of_child. */
2214 /* FIXME: xstrdup should not be here. */
2215 child->name = xstrdup (name);
2216 child->index = index;
2217 child->parent = parent;
2218 child->root = parent->root;
2219 childs_name = xstrprintf ("%s.%s", parent->obj_name, name);
2220 child->obj_name = childs_name;
2221 install_variable (child);
2223 /* Compute the type of the child. Must do this before
2224 calling install_new_value. */
2226 /* If the child had no evaluation errors, var->value
2227 will be non-NULL and contain a valid type. */
2228 child->type = value_type (value);
2230 /* Otherwise, we must compute the type. */
2231 child->type = (*child->root->lang->type_of_child) (child->parent,
2233 install_new_value (child, value, 1);
2240 * Miscellaneous utility functions.
2243 /* Allocate memory and initialize a new variable. */
2244 static struct varobj *
2249 var = (struct varobj *) xmalloc (sizeof (struct varobj));
2251 var->path_expr = NULL;
2252 var->obj_name = NULL;
2256 var->num_children = -1;
2258 var->children = NULL;
2262 var->print_value = NULL;
2264 var->not_fetched = 0;
2265 var->children_requested = 0;
2268 var->constructor = 0;
2269 var->pretty_printer = 0;
2270 var->child_iter = 0;
2271 var->saved_item = 0;
2276 /* Allocate memory and initialize a new root variable. */
2277 static struct varobj *
2278 new_root_variable (void)
2280 struct varobj *var = new_variable ();
2282 var->root = (struct varobj_root *) xmalloc (sizeof (struct varobj_root));
2283 var->root->lang = NULL;
2284 var->root->exp = NULL;
2285 var->root->valid_block = NULL;
2286 var->root->frame = null_frame_id;
2287 var->root->floating = 0;
2288 var->root->rootvar = NULL;
2289 var->root->is_valid = 1;
2294 /* Free any allocated memory associated with VAR. */
2296 free_variable (struct varobj *var)
2299 if (var->pretty_printer)
2301 struct cleanup *cleanup = varobj_ensure_python_env (var);
2302 Py_XDECREF (var->constructor);
2303 Py_XDECREF (var->pretty_printer);
2304 Py_XDECREF (var->child_iter);
2305 Py_XDECREF (var->saved_item);
2306 do_cleanups (cleanup);
2310 value_free (var->value);
2312 /* Free the expression if this is a root variable. */
2313 if (is_root_p (var))
2315 xfree (var->root->exp);
2320 xfree (var->obj_name);
2321 xfree (var->print_value);
2322 xfree (var->path_expr);
2327 do_free_variable_cleanup (void *var)
2329 free_variable (var);
2332 static struct cleanup *
2333 make_cleanup_free_variable (struct varobj *var)
2335 return make_cleanup (do_free_variable_cleanup, var);
2338 /* This returns the type of the variable. It also skips past typedefs
2339 to return the real type of the variable.
2341 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
2342 except within get_target_type and get_type. */
2343 static struct type *
2344 get_type (struct varobj *var)
2350 type = check_typedef (type);
2355 /* Return the type of the value that's stored in VAR,
2356 or that would have being stored there if the
2357 value were accessible.
2359 This differs from VAR->type in that VAR->type is always
2360 the true type of the expession in the source language.
2361 The return value of this function is the type we're
2362 actually storing in varobj, and using for displaying
2363 the values and for comparing previous and new values.
2365 For example, top-level references are always stripped. */
2366 static struct type *
2367 get_value_type (struct varobj *var)
2372 type = value_type (var->value);
2376 type = check_typedef (type);
2378 if (TYPE_CODE (type) == TYPE_CODE_REF)
2379 type = get_target_type (type);
2381 type = check_typedef (type);
2386 /* This returns the target type (or NULL) of TYPE, also skipping
2387 past typedefs, just like get_type ().
2389 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
2390 except within get_target_type and get_type. */
2391 static struct type *
2392 get_target_type (struct type *type)
2396 type = TYPE_TARGET_TYPE (type);
2398 type = check_typedef (type);
2404 /* What is the default display for this variable? We assume that
2405 everything is "natural". Any exceptions? */
2406 static enum varobj_display_formats
2407 variable_default_display (struct varobj *var)
2409 return FORMAT_NATURAL;
2412 /* FIXME: The following should be generic for any pointer. */
2414 cppush (struct cpstack **pstack, char *name)
2418 s = (struct cpstack *) xmalloc (sizeof (struct cpstack));
2424 /* FIXME: The following should be generic for any pointer. */
2426 cppop (struct cpstack **pstack)
2431 if ((*pstack)->name == NULL && (*pstack)->next == NULL)
2436 *pstack = (*pstack)->next;
2443 * Language-dependencies
2446 /* Common entry points */
2448 /* Get the language of variable VAR. */
2449 static enum varobj_languages
2450 variable_language (struct varobj *var)
2452 enum varobj_languages lang;
2454 switch (var->root->exp->language_defn->la_language)
2460 case language_cplus:
2474 /* Return the number of children for a given variable.
2475 The result of this function is defined by the language
2476 implementation. The number of children returned by this function
2477 is the number of children that the user will see in the variable
2480 number_of_children (struct varobj *var)
2482 return (*var->root->lang->number_of_children) (var);
2485 /* What is the expression for the root varobj VAR? Returns a malloc'd
2488 name_of_variable (struct varobj *var)
2490 return (*var->root->lang->name_of_variable) (var);
2493 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd
2496 name_of_child (struct varobj *var, int index)
2498 return (*var->root->lang->name_of_child) (var, index);
2501 /* What is the ``struct value *'' of the root variable VAR?
2502 For floating variable object, evaluation can get us a value
2503 of different type from what is stored in varobj already. In
2505 - *type_changed will be set to 1
2506 - old varobj will be freed, and new one will be
2507 created, with the same name.
2508 - *var_handle will be set to the new varobj
2509 Otherwise, *type_changed will be set to 0. */
2510 static struct value *
2511 value_of_root (struct varobj **var_handle, int *type_changed)
2515 if (var_handle == NULL)
2520 /* This should really be an exception, since this should
2521 only get called with a root variable. */
2523 if (!is_root_p (var))
2526 if (var->root->floating)
2528 struct varobj *tmp_var;
2529 char *old_type, *new_type;
2531 tmp_var = varobj_create (NULL, var->name, (CORE_ADDR) 0,
2532 USE_SELECTED_FRAME);
2533 if (tmp_var == NULL)
2537 old_type = varobj_get_type (var);
2538 new_type = varobj_get_type (tmp_var);
2539 if (strcmp (old_type, new_type) == 0)
2541 /* The expression presently stored inside var->root->exp
2542 remembers the locations of local variables relatively to
2543 the frame where the expression was created (in DWARF location
2544 button, for example). Naturally, those locations are not
2545 correct in other frames, so update the expression. */
2547 struct expression *tmp_exp = var->root->exp;
2549 var->root->exp = tmp_var->root->exp;
2550 tmp_var->root->exp = tmp_exp;
2552 varobj_delete (tmp_var, NULL, 0);
2557 tmp_var->obj_name = xstrdup (var->obj_name);
2558 tmp_var->from = var->from;
2559 tmp_var->to = var->to;
2560 varobj_delete (var, NULL, 0);
2562 install_variable (tmp_var);
2563 *var_handle = tmp_var;
2575 return (*var->root->lang->value_of_root) (var_handle);
2578 /* What is the ``struct value *'' for the INDEX'th child of PARENT? */
2579 static struct value *
2580 value_of_child (struct varobj *parent, int index)
2582 struct value *value;
2584 value = (*parent->root->lang->value_of_child) (parent, index);
2589 /* GDB already has a command called "value_of_variable". Sigh. */
2591 my_value_of_variable (struct varobj *var, enum varobj_display_formats format)
2593 if (var->root->is_valid)
2595 if (var->pretty_printer)
2596 return value_get_print_value (var->value, var->format, var);
2597 return (*var->root->lang->value_of_variable) (var, format);
2604 value_get_print_value (struct value *value, enum varobj_display_formats format,
2607 struct ui_file *stb;
2608 struct cleanup *old_chain;
2609 gdb_byte *thevalue = NULL;
2610 struct value_print_options opts;
2611 struct type *type = NULL;
2613 char *encoding = NULL;
2614 struct gdbarch *gdbarch = NULL;
2615 /* Initialize it just to avoid a GCC false warning. */
2616 CORE_ADDR str_addr = 0;
2617 int string_print = 0;
2622 stb = mem_fileopen ();
2623 old_chain = make_cleanup_ui_file_delete (stb);
2625 gdbarch = get_type_arch (value_type (value));
2628 PyObject *value_formatter = var->pretty_printer;
2630 varobj_ensure_python_env (var);
2632 if (value_formatter)
2634 /* First check to see if we have any children at all. If so,
2635 we simply return {...}. */
2636 if (dynamic_varobj_has_child_method (var))
2638 do_cleanups (old_chain);
2639 return xstrdup ("{...}");
2642 if (PyObject_HasAttr (value_formatter, gdbpy_to_string_cst))
2644 struct value *replacement;
2645 PyObject *output = NULL;
2647 output = apply_varobj_pretty_printer (value_formatter,
2651 /* If we have string like output ... */
2654 make_cleanup_py_decref (output);
2656 /* If this is a lazy string, extract it. For lazy
2657 strings we always print as a string, so set
2659 if (gdbpy_is_lazy_string (output))
2661 gdbpy_extract_lazy_string (output, &str_addr, &type,
2663 make_cleanup (free_current_contents, &encoding);
2668 /* If it is a regular (non-lazy) string, extract
2669 it and copy the contents into THEVALUE. If the
2670 hint says to print it as a string, set
2671 string_print. Otherwise just return the extracted
2672 string as a value. */
2675 = python_string_to_target_python_string (output);
2679 char *s = PyString_AsString (py_str);
2682 hint = gdbpy_get_display_hint (value_formatter);
2685 if (!strcmp (hint, "string"))
2690 len = PyString_Size (py_str);
2691 thevalue = xmemdup (s, len + 1, len + 1);
2692 type = builtin_type (gdbarch)->builtin_char;
2697 do_cleanups (old_chain);
2701 make_cleanup (xfree, thevalue);
2704 gdbpy_print_stack ();
2707 /* If the printer returned a replacement value, set VALUE
2708 to REPLACEMENT. If there is not a replacement value,
2709 just use the value passed to this function. */
2711 value = replacement;
2717 get_formatted_print_options (&opts, format_code[(int) format]);
2721 /* If the THEVALUE has contents, it is a regular string. */
2723 LA_PRINT_STRING (stb, type, thevalue, len, encoding, 0, &opts);
2724 else if (string_print)
2725 /* Otherwise, if string_print is set, and it is not a regular
2726 string, it is a lazy string. */
2727 val_print_string (type, encoding, str_addr, len, stb, &opts);
2729 /* All other cases. */
2730 common_val_print (value, stb, 0, &opts, current_language);
2732 thevalue = ui_file_xstrdup (stb, NULL);
2734 do_cleanups (old_chain);
2739 varobj_editable_p (struct varobj *var)
2743 if (!(var->root->is_valid && var->value && VALUE_LVAL (var->value)))
2746 type = get_value_type (var);
2748 switch (TYPE_CODE (type))
2750 case TYPE_CODE_STRUCT:
2751 case TYPE_CODE_UNION:
2752 case TYPE_CODE_ARRAY:
2753 case TYPE_CODE_FUNC:
2754 case TYPE_CODE_METHOD:
2764 /* Return non-zero if changes in value of VAR
2765 must be detected and reported by -var-update.
2766 Return zero is -var-update should never report
2767 changes of such values. This makes sense for structures
2768 (since the changes in children values will be reported separately),
2769 or for artifical objects (like 'public' pseudo-field in C++).
2771 Return value of 0 means that gdb need not call value_fetch_lazy
2772 for the value of this variable object. */
2774 varobj_value_is_changeable_p (struct varobj *var)
2779 if (CPLUS_FAKE_CHILD (var))
2782 type = get_value_type (var);
2784 switch (TYPE_CODE (type))
2786 case TYPE_CODE_STRUCT:
2787 case TYPE_CODE_UNION:
2788 case TYPE_CODE_ARRAY:
2799 /* Return 1 if that varobj is floating, that is is always evaluated in the
2800 selected frame, and not bound to thread/frame. Such variable objects
2801 are created using '@' as frame specifier to -var-create. */
2803 varobj_floating_p (struct varobj *var)
2805 return var->root->floating;
2808 /* Given the value and the type of a variable object,
2809 adjust the value and type to those necessary
2810 for getting children of the variable object.
2811 This includes dereferencing top-level references
2812 to all types and dereferencing pointers to
2815 Both TYPE and *TYPE should be non-null. VALUE
2816 can be null if we want to only translate type.
2817 *VALUE can be null as well -- if the parent
2820 If WAS_PTR is not NULL, set *WAS_PTR to 0 or 1
2821 depending on whether pointer was dereferenced
2822 in this function. */
2824 adjust_value_for_child_access (struct value **value,
2828 gdb_assert (type && *type);
2833 *type = check_typedef (*type);
2835 /* The type of value stored in varobj, that is passed
2836 to us, is already supposed to be
2837 reference-stripped. */
2839 gdb_assert (TYPE_CODE (*type) != TYPE_CODE_REF);
2841 /* Pointers to structures are treated just like
2842 structures when accessing children. Don't
2843 dererences pointers to other types. */
2844 if (TYPE_CODE (*type) == TYPE_CODE_PTR)
2846 struct type *target_type = get_target_type (*type);
2847 if (TYPE_CODE (target_type) == TYPE_CODE_STRUCT
2848 || TYPE_CODE (target_type) == TYPE_CODE_UNION)
2850 if (value && *value)
2852 volatile struct gdb_exception except;
2854 TRY_CATCH (except, RETURN_MASK_ERROR)
2856 *value = value_ind (*value);
2859 if (except.reason < 0)
2862 *type = target_type;
2868 /* The 'get_target_type' function calls check_typedef on
2869 result, so we can immediately check type code. No
2870 need to call check_typedef here. */
2875 c_number_of_children (struct varobj *var)
2877 struct type *type = get_value_type (var);
2879 struct type *target;
2881 adjust_value_for_child_access (NULL, &type, NULL);
2882 target = get_target_type (type);
2884 switch (TYPE_CODE (type))
2886 case TYPE_CODE_ARRAY:
2887 if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (target) > 0
2888 && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))
2889 children = TYPE_LENGTH (type) / TYPE_LENGTH (target);
2891 /* If we don't know how many elements there are, don't display
2896 case TYPE_CODE_STRUCT:
2897 case TYPE_CODE_UNION:
2898 children = TYPE_NFIELDS (type);
2902 /* The type here is a pointer to non-struct. Typically, pointers
2903 have one child, except for function ptrs, which have no children,
2904 and except for void*, as we don't know what to show.
2906 We can show char* so we allow it to be dereferenced. If you decide
2907 to test for it, please mind that a little magic is necessary to
2908 properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
2909 TYPE_NAME == "char". */
2910 if (TYPE_CODE (target) == TYPE_CODE_FUNC
2911 || TYPE_CODE (target) == TYPE_CODE_VOID)
2918 /* Other types have no children. */
2926 c_name_of_variable (struct varobj *parent)
2928 return xstrdup (parent->name);
2931 /* Return the value of element TYPE_INDEX of a structure
2932 value VALUE. VALUE's type should be a structure,
2933 or union, or a typedef to struct/union.
2935 Returns NULL if getting the value fails. Never throws. */
2936 static struct value *
2937 value_struct_element_index (struct value *value, int type_index)
2939 struct value *result = NULL;
2940 volatile struct gdb_exception e;
2941 struct type *type = value_type (value);
2943 type = check_typedef (type);
2945 gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
2946 || TYPE_CODE (type) == TYPE_CODE_UNION);
2948 TRY_CATCH (e, RETURN_MASK_ERROR)
2950 if (field_is_static (&TYPE_FIELD (type, type_index)))
2951 result = value_static_field (type, type_index);
2953 result = value_primitive_field (value, 0, type_index, type);
2965 /* Obtain the information about child INDEX of the variable
2967 If CNAME is not null, sets *CNAME to the name of the child relative
2969 If CVALUE is not null, sets *CVALUE to the value of the child.
2970 If CTYPE is not null, sets *CTYPE to the type of the child.
2972 If any of CNAME, CVALUE, or CTYPE is not null, but the corresponding
2973 information cannot be determined, set *CNAME, *CVALUE, or *CTYPE
2976 c_describe_child (struct varobj *parent, int index,
2977 char **cname, struct value **cvalue, struct type **ctype,
2978 char **cfull_expression)
2980 struct value *value = parent->value;
2981 struct type *type = get_value_type (parent);
2982 char *parent_expression = NULL;
2984 volatile struct gdb_exception except;
2992 if (cfull_expression)
2994 *cfull_expression = NULL;
2995 parent_expression = varobj_get_path_expr (parent);
2997 adjust_value_for_child_access (&value, &type, &was_ptr);
2999 switch (TYPE_CODE (type))
3001 case TYPE_CODE_ARRAY:
3004 = xstrdup (int_string (index
3005 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)),
3008 if (cvalue && value)
3010 int real_index = index + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type));
3012 TRY_CATCH (except, RETURN_MASK_ERROR)
3014 *cvalue = value_subscript (value, real_index);
3019 *ctype = get_target_type (type);
3021 if (cfull_expression)
3023 xstrprintf ("(%s)[%s]", parent_expression,
3025 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)),
3031 case TYPE_CODE_STRUCT:
3032 case TYPE_CODE_UNION:
3034 *cname = xstrdup (TYPE_FIELD_NAME (type, index));
3036 if (cvalue && value)
3038 /* For C, varobj index is the same as type index. */
3039 *cvalue = value_struct_element_index (value, index);
3043 *ctype = TYPE_FIELD_TYPE (type, index);
3045 if (cfull_expression)
3047 char *join = was_ptr ? "->" : ".";
3049 *cfull_expression = xstrprintf ("(%s)%s%s", parent_expression, join,
3050 TYPE_FIELD_NAME (type, index));
3057 *cname = xstrprintf ("*%s", parent->name);
3059 if (cvalue && value)
3061 TRY_CATCH (except, RETURN_MASK_ERROR)
3063 *cvalue = value_ind (value);
3066 if (except.reason < 0)
3070 /* Don't use get_target_type because it calls
3071 check_typedef and here, we want to show the true
3072 declared type of the variable. */
3074 *ctype = TYPE_TARGET_TYPE (type);
3076 if (cfull_expression)
3077 *cfull_expression = xstrprintf ("*(%s)", parent_expression);
3082 /* This should not happen. */
3084 *cname = xstrdup ("???");
3085 if (cfull_expression)
3086 *cfull_expression = xstrdup ("???");
3087 /* Don't set value and type, we don't know then. */
3092 c_name_of_child (struct varobj *parent, int index)
3096 c_describe_child (parent, index, &name, NULL, NULL, NULL);
3101 c_path_expr_of_child (struct varobj *child)
3103 c_describe_child (child->parent, child->index, NULL, NULL, NULL,
3105 return child->path_expr;
3108 /* If frame associated with VAR can be found, switch
3109 to it and return 1. Otherwise, return 0. */
3111 check_scope (struct varobj *var)
3113 struct frame_info *fi;
3116 fi = frame_find_by_id (var->root->frame);
3121 CORE_ADDR pc = get_frame_pc (fi);
3123 if (pc < BLOCK_START (var->root->valid_block) ||
3124 pc >= BLOCK_END (var->root->valid_block))
3132 static struct value *
3133 c_value_of_root (struct varobj **var_handle)
3135 struct value *new_val = NULL;
3136 struct varobj *var = *var_handle;
3137 int within_scope = 0;
3138 struct cleanup *back_to;
3140 /* Only root variables can be updated... */
3141 if (!is_root_p (var))
3142 /* Not a root var. */
3145 back_to = make_cleanup_restore_current_thread ();
3147 /* Determine whether the variable is still around. */
3148 if (var->root->valid_block == NULL || var->root->floating)
3150 else if (var->root->thread_id == 0)
3152 /* The program was single-threaded when the variable object was
3153 created. Technically, it's possible that the program became
3154 multi-threaded since then, but we don't support such
3156 within_scope = check_scope (var);
3160 ptid_t ptid = thread_id_to_pid (var->root->thread_id);
3161 if (in_thread_list (ptid))
3163 switch_to_thread (ptid);
3164 within_scope = check_scope (var);
3170 volatile struct gdb_exception except;
3172 /* We need to catch errors here, because if evaluate
3173 expression fails we want to just return NULL. */
3174 TRY_CATCH (except, RETURN_MASK_ERROR)
3176 new_val = evaluate_expression (var->root->exp);
3182 do_cleanups (back_to);
3187 static struct value *
3188 c_value_of_child (struct varobj *parent, int index)
3190 struct value *value = NULL;
3192 c_describe_child (parent, index, NULL, &value, NULL, NULL);
3196 static struct type *
3197 c_type_of_child (struct varobj *parent, int index)
3199 struct type *type = NULL;
3201 c_describe_child (parent, index, NULL, NULL, &type, NULL);
3206 c_value_of_variable (struct varobj *var, enum varobj_display_formats format)
3208 /* BOGUS: if val_print sees a struct/class, or a reference to one,
3209 it will print out its children instead of "{...}". So we need to
3210 catch that case explicitly. */
3211 struct type *type = get_type (var);
3213 /* If we have a custom formatter, return whatever string it has
3215 if (var->pretty_printer && var->print_value)
3216 return xstrdup (var->print_value);
3218 /* Strip top-level references. */
3219 while (TYPE_CODE (type) == TYPE_CODE_REF)
3220 type = check_typedef (TYPE_TARGET_TYPE (type));
3222 switch (TYPE_CODE (type))
3224 case TYPE_CODE_STRUCT:
3225 case TYPE_CODE_UNION:
3226 return xstrdup ("{...}");
3229 case TYPE_CODE_ARRAY:
3233 number = xstrprintf ("[%d]", var->num_children);
3240 if (var->value == NULL)
3242 /* This can happen if we attempt to get the value of a struct
3243 member when the parent is an invalid pointer. This is an
3244 error condition, so we should tell the caller. */
3249 if (var->not_fetched && value_lazy (var->value))
3250 /* Frozen variable and no value yet. We don't
3251 implicitly fetch the value. MI response will
3252 use empty string for the value, which is OK. */
3255 gdb_assert (varobj_value_is_changeable_p (var));
3256 gdb_assert (!value_lazy (var->value));
3258 /* If the specified format is the current one,
3259 we can reuse print_value. */
3260 if (format == var->format)
3261 return xstrdup (var->print_value);
3263 return value_get_print_value (var->value, format, var);
3273 cplus_number_of_children (struct varobj *var)
3276 int children, dont_know;
3281 if (!CPLUS_FAKE_CHILD (var))
3283 type = get_value_type (var);
3284 adjust_value_for_child_access (NULL, &type, NULL);
3286 if (((TYPE_CODE (type)) == TYPE_CODE_STRUCT) ||
3287 ((TYPE_CODE (type)) == TYPE_CODE_UNION))
3291 cplus_class_num_children (type, kids);
3292 if (kids[v_public] != 0)
3294 if (kids[v_private] != 0)
3296 if (kids[v_protected] != 0)
3299 /* Add any baseclasses. */
3300 children += TYPE_N_BASECLASSES (type);
3303 /* FIXME: save children in var. */
3310 type = get_value_type (var->parent);
3311 adjust_value_for_child_access (NULL, &type, NULL);
3313 cplus_class_num_children (type, kids);
3314 if (strcmp (var->name, "public") == 0)
3315 children = kids[v_public];
3316 else if (strcmp (var->name, "private") == 0)
3317 children = kids[v_private];
3319 children = kids[v_protected];
3324 children = c_number_of_children (var);
3329 /* Compute # of public, private, and protected variables in this class.
3330 That means we need to descend into all baseclasses and find out
3331 how many are there, too. */
3333 cplus_class_num_children (struct type *type, int children[3])
3335 int i, vptr_fieldno;
3336 struct type *basetype = NULL;
3338 children[v_public] = 0;
3339 children[v_private] = 0;
3340 children[v_protected] = 0;
3342 vptr_fieldno = get_vptr_fieldno (type, &basetype);
3343 for (i = TYPE_N_BASECLASSES (type); i < TYPE_NFIELDS (type); i++)
3345 /* If we have a virtual table pointer, omit it. Even if virtual
3346 table pointers are not specifically marked in the debug info,
3347 they should be artificial. */
3348 if ((type == basetype && i == vptr_fieldno)
3349 || TYPE_FIELD_ARTIFICIAL (type, i))
3352 if (TYPE_FIELD_PROTECTED (type, i))
3353 children[v_protected]++;
3354 else if (TYPE_FIELD_PRIVATE (type, i))
3355 children[v_private]++;
3357 children[v_public]++;
3362 cplus_name_of_variable (struct varobj *parent)
3364 return c_name_of_variable (parent);
3367 enum accessibility { private_field, protected_field, public_field };
3369 /* Check if field INDEX of TYPE has the specified accessibility.
3370 Return 0 if so and 1 otherwise. */
3372 match_accessibility (struct type *type, int index, enum accessibility acc)
3374 if (acc == private_field && TYPE_FIELD_PRIVATE (type, index))
3376 else if (acc == protected_field && TYPE_FIELD_PROTECTED (type, index))
3378 else if (acc == public_field && !TYPE_FIELD_PRIVATE (type, index)
3379 && !TYPE_FIELD_PROTECTED (type, index))
3386 cplus_describe_child (struct varobj *parent, int index,
3387 char **cname, struct value **cvalue, struct type **ctype,
3388 char **cfull_expression)
3390 struct value *value;
3393 char *parent_expression = NULL;
3401 if (cfull_expression)
3402 *cfull_expression = NULL;
3404 if (CPLUS_FAKE_CHILD (parent))
3406 value = parent->parent->value;
3407 type = get_value_type (parent->parent);
3408 if (cfull_expression)
3409 parent_expression = varobj_get_path_expr (parent->parent);
3413 value = parent->value;
3414 type = get_value_type (parent);
3415 if (cfull_expression)
3416 parent_expression = varobj_get_path_expr (parent);
3419 adjust_value_for_child_access (&value, &type, &was_ptr);
3421 if (TYPE_CODE (type) == TYPE_CODE_STRUCT
3422 || TYPE_CODE (type) == TYPE_CODE_UNION)
3424 char *join = was_ptr ? "->" : ".";
3426 if (CPLUS_FAKE_CHILD (parent))
3428 /* The fields of the class type are ordered as they
3429 appear in the class. We are given an index for a
3430 particular access control type ("public","protected",
3431 or "private"). We must skip over fields that don't
3432 have the access control we are looking for to properly
3433 find the indexed field. */
3434 int type_index = TYPE_N_BASECLASSES (type);
3435 enum accessibility acc = public_field;
3437 struct type *basetype = NULL;
3439 vptr_fieldno = get_vptr_fieldno (type, &basetype);
3440 if (strcmp (parent->name, "private") == 0)
3441 acc = private_field;
3442 else if (strcmp (parent->name, "protected") == 0)
3443 acc = protected_field;
3447 if ((type == basetype && type_index == vptr_fieldno)
3448 || TYPE_FIELD_ARTIFICIAL (type, type_index))
3450 else if (match_accessibility (type, type_index, acc))
3457 *cname = xstrdup (TYPE_FIELD_NAME (type, type_index));
3459 if (cvalue && value)
3460 *cvalue = value_struct_element_index (value, type_index);
3463 *ctype = TYPE_FIELD_TYPE (type, type_index);
3465 if (cfull_expression)
3467 = xstrprintf ("((%s)%s%s)", parent_expression,
3469 TYPE_FIELD_NAME (type, type_index));
3471 else if (index < TYPE_N_BASECLASSES (type))
3473 /* This is a baseclass. */
3475 *cname = xstrdup (TYPE_FIELD_NAME (type, index));
3477 if (cvalue && value)
3478 *cvalue = value_cast (TYPE_FIELD_TYPE (type, index), value);
3482 *ctype = TYPE_FIELD_TYPE (type, index);
3485 if (cfull_expression)
3487 char *ptr = was_ptr ? "*" : "";
3489 /* Cast the parent to the base' type. Note that in gdb,
3492 will create an lvalue, for all appearences, so we don't
3493 need to use more fancy:
3497 When we are in the scope of the base class or of one
3498 of its children, the type field name will be interpreted
3499 as a constructor, if it exists. Therefore, we must
3500 indicate that the name is a class name by using the
3501 'class' keyword. See PR mi/11912 */
3502 *cfull_expression = xstrprintf ("(%s(class %s%s) %s)",
3504 TYPE_FIELD_NAME (type, index),
3511 char *access = NULL;
3514 cplus_class_num_children (type, children);
3516 /* Everything beyond the baseclasses can
3517 only be "public", "private", or "protected"
3519 The special "fake" children are always output by varobj in
3520 this order. So if INDEX == 2, it MUST be "protected". */
3521 index -= TYPE_N_BASECLASSES (type);
3525 if (children[v_public] > 0)
3527 else if (children[v_private] > 0)
3530 access = "protected";
3533 if (children[v_public] > 0)
3535 if (children[v_private] > 0)
3538 access = "protected";
3540 else if (children[v_private] > 0)
3541 access = "protected";
3544 /* Must be protected. */
3545 access = "protected";
3552 gdb_assert (access);
3554 *cname = xstrdup (access);
3556 /* Value and type and full expression are null here. */
3561 c_describe_child (parent, index, cname, cvalue, ctype, cfull_expression);
3566 cplus_name_of_child (struct varobj *parent, int index)
3570 cplus_describe_child (parent, index, &name, NULL, NULL, NULL);
3575 cplus_path_expr_of_child (struct varobj *child)
3577 cplus_describe_child (child->parent, child->index, NULL, NULL, NULL,
3579 return child->path_expr;
3582 static struct value *
3583 cplus_value_of_root (struct varobj **var_handle)
3585 return c_value_of_root (var_handle);
3588 static struct value *
3589 cplus_value_of_child (struct varobj *parent, int index)
3591 struct value *value = NULL;
3593 cplus_describe_child (parent, index, NULL, &value, NULL, NULL);
3597 static struct type *
3598 cplus_type_of_child (struct varobj *parent, int index)
3600 struct type *type = NULL;
3602 cplus_describe_child (parent, index, NULL, NULL, &type, NULL);
3607 cplus_value_of_variable (struct varobj *var,
3608 enum varobj_display_formats format)
3611 /* If we have one of our special types, don't print out
3613 if (CPLUS_FAKE_CHILD (var))
3614 return xstrdup ("");
3616 return c_value_of_variable (var, format);
3622 java_number_of_children (struct varobj *var)
3624 return cplus_number_of_children (var);
3628 java_name_of_variable (struct varobj *parent)
3632 name = cplus_name_of_variable (parent);
3633 /* If the name has "-" in it, it is because we
3634 needed to escape periods in the name... */
3637 while (*p != '\000')
3648 java_name_of_child (struct varobj *parent, int index)
3652 name = cplus_name_of_child (parent, index);
3653 /* Escape any periods in the name... */
3656 while (*p != '\000')
3667 java_path_expr_of_child (struct varobj *child)
3672 static struct value *
3673 java_value_of_root (struct varobj **var_handle)
3675 return cplus_value_of_root (var_handle);
3678 static struct value *
3679 java_value_of_child (struct varobj *parent, int index)
3681 return cplus_value_of_child (parent, index);
3684 static struct type *
3685 java_type_of_child (struct varobj *parent, int index)
3687 return cplus_type_of_child (parent, index);
3691 java_value_of_variable (struct varobj *var, enum varobj_display_formats format)
3693 return cplus_value_of_variable (var, format);
3696 /* Ada specific callbacks for VAROBJs. */
3699 ada_number_of_children (struct varobj *var)
3701 return c_number_of_children (var);
3705 ada_name_of_variable (struct varobj *parent)
3707 return c_name_of_variable (parent);
3711 ada_name_of_child (struct varobj *parent, int index)
3713 return c_name_of_child (parent, index);
3717 ada_path_expr_of_child (struct varobj *child)
3719 return c_path_expr_of_child (child);
3722 static struct value *
3723 ada_value_of_root (struct varobj **var_handle)
3725 return c_value_of_root (var_handle);
3728 static struct value *
3729 ada_value_of_child (struct varobj *parent, int index)
3731 return c_value_of_child (parent, index);
3734 static struct type *
3735 ada_type_of_child (struct varobj *parent, int index)
3737 return c_type_of_child (parent, index);
3741 ada_value_of_variable (struct varobj *var, enum varobj_display_formats format)
3743 return c_value_of_variable (var, format);
3746 /* Iterate all the existing _root_ VAROBJs and call the FUNC callback for them
3747 with an arbitrary caller supplied DATA pointer. */
3750 all_root_varobjs (void (*func) (struct varobj *var, void *data), void *data)
3752 struct varobj_root *var_root, *var_root_next;
3754 /* Iterate "safely" - handle if the callee deletes its passed VAROBJ. */
3756 for (var_root = rootlist; var_root != NULL; var_root = var_root_next)
3758 var_root_next = var_root->next;
3760 (*func) (var_root->rootvar, data);
3764 extern void _initialize_varobj (void);
3766 _initialize_varobj (void)
3768 int sizeof_table = sizeof (struct vlist *) * VAROBJ_TABLE_SIZE;
3770 varobj_table = xmalloc (sizeof_table);
3771 memset (varobj_table, 0, sizeof_table);
3773 add_setshow_zinteger_cmd ("debugvarobj", class_maintenance,
3775 _("Set varobj debugging."),
3776 _("Show varobj debugging."),
3777 _("When non-zero, varobj debugging is enabled."),
3778 NULL, show_varobjdebug,
3779 &setlist, &showlist);
3782 /* Invalidate varobj VAR if it is tied to locals and re-create it if it is
3783 defined on globals. It is a helper for varobj_invalidate. */
3786 varobj_invalidate_iter (struct varobj *var, void *unused)
3788 /* Floating varobjs are reparsed on each stop, so we don't care if the
3789 presently parsed expression refers to something that's gone. */
3790 if (var->root->floating)
3793 /* global var must be re-evaluated. */
3794 if (var->root->valid_block == NULL)
3796 struct varobj *tmp_var;
3798 /* Try to create a varobj with same expression. If we succeed
3799 replace the old varobj, otherwise invalidate it. */
3800 tmp_var = varobj_create (NULL, var->name, (CORE_ADDR) 0,
3802 if (tmp_var != NULL)
3804 tmp_var->obj_name = xstrdup (var->obj_name);
3805 varobj_delete (var, NULL, 0);
3806 install_variable (tmp_var);
3809 var->root->is_valid = 0;
3811 else /* locals must be invalidated. */
3812 var->root->is_valid = 0;
3815 /* Invalidate the varobjs that are tied to locals and re-create the ones that
3816 are defined on globals.
3817 Invalidated varobjs will be always printed in_scope="invalid". */
3820 varobj_invalidate (void)
3822 all_root_varobjs (varobj_invalidate_iter, NULL);