1 /* Implementation of the GDB variable objects API.
3 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
4 2009 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"
35 #include "gdbthread.h"
39 #include "python/python.h"
40 #include "python/python-internal.h"
45 /* Non-zero if we want to see trace of varobj level stuff. */
49 show_varobjdebug (struct ui_file
*file
, int from_tty
,
50 struct cmd_list_element
*c
, const char *value
)
52 fprintf_filtered (file
, _("Varobj debugging is %s.\n"), value
);
55 /* String representations of gdb's format codes */
56 char *varobj_format_string
[] =
57 { "natural", "binary", "decimal", "hexadecimal", "octal" };
59 /* String representations of gdb's known languages */
60 char *varobj_language_string
[] = { "unknown", "C", "C++", "Java" };
64 /* Every root variable has one of these structures saved in its
65 varobj. Members which must be free'd are noted. */
69 /* Alloc'd expression for this parent. */
70 struct expression
*exp
;
72 /* Block for which this expression is valid */
73 struct block
*valid_block
;
75 /* The frame for this expression. This field is set iff valid_block is
77 struct frame_id frame
;
79 /* The thread ID that this varobj_root belong to. This field
80 is only valid if valid_block is not NULL.
81 When not 0, indicates which thread 'frame' belongs to.
82 When 0, indicates that the thread list was empty when the varobj_root
86 /* If 1, the -var-update always recomputes the value in the
87 current thread and frame. Otherwise, variable object is
88 always updated in the specific scope/thread/frame */
91 /* Flag that indicates validity: set to 0 when this varobj_root refers
92 to symbols that do not exist anymore. */
95 /* Language info for this variable and its children */
96 struct language_specific
*lang
;
98 /* The varobj for this root node. */
99 struct varobj
*rootvar
;
101 /* Next root variable */
102 struct varobj_root
*next
;
105 /* Every variable in the system has a structure of this type defined
106 for it. This structure holds all information necessary to manipulate
107 a particular object variable. Members which must be freed are noted. */
111 /* Alloc'd name of the variable for this object.. If this variable is a
112 child, then this name will be the child's source name.
113 (bar, not foo.bar) */
114 /* NOTE: This is the "expression" */
117 /* Alloc'd expression for this child. Can be used to create a
118 root variable corresponding to this child. */
121 /* The alloc'd name for this variable's object. This is here for
122 convenience when constructing this object's children. */
125 /* Index of this variable in its parent or -1 */
128 /* The type of this variable. This can be NULL
129 for artifial variable objects -- currently, the "accessibility"
130 variable objects in C++. */
133 /* The value of this expression or subexpression. A NULL value
134 indicates there was an error getting this value.
135 Invariant: if varobj_value_is_changeable_p (this) is non-zero,
136 the value is either NULL, or not lazy. */
139 /* The number of (immediate) children this variable has */
142 /* If this object is a child, this points to its immediate parent. */
143 struct varobj
*parent
;
145 /* Children of this object. */
146 VEC (varobj_p
) *children
;
148 /* Whether the children of this varobj were requested. This field is
149 used to decide if dynamic varobj should recompute their children.
150 In the event that the frontend never asked for the children, we
152 int children_requested
;
154 /* Description of the root variable. Points to root variable for children. */
155 struct varobj_root
*root
;
157 /* The format of the output for this object */
158 enum varobj_display_formats format
;
160 /* Was this variable updated via a varobj_set_value operation */
163 /* Last print value. */
166 /* Is this variable frozen. Frozen variables are never implicitly
167 updated by -var-update *
168 or -var-update <direct-or-indirect-parent>. */
171 /* Is the value of this variable intentionally not fetched? It is
172 not fetched if either the variable is frozen, or any parents is
176 /* The pretty-printer that has been constructed. If NULL, then a
177 new printer object is needed, and one will be constructed. */
178 PyObject
*pretty_printer
;
184 struct cpstack
*next
;
187 /* A list of varobjs */
195 /* Private function prototypes */
197 /* Helper functions for the above subcommands. */
199 static int delete_variable (struct cpstack
**, struct varobj
*, int);
201 static void delete_variable_1 (struct cpstack
**, int *,
202 struct varobj
*, int, int);
204 static int install_variable (struct varobj
*);
206 static void uninstall_variable (struct varobj
*);
208 static struct varobj
*create_child (struct varobj
*, int, char *);
210 static struct varobj
*
211 create_child_with_value (struct varobj
*parent
, int index
, const char *name
,
212 struct value
*value
);
214 /* Utility routines */
216 static struct varobj
*new_variable (void);
218 static struct varobj
*new_root_variable (void);
220 static void free_variable (struct varobj
*var
);
222 static struct cleanup
*make_cleanup_free_variable (struct varobj
*var
);
224 static struct type
*get_type (struct varobj
*var
);
226 static struct type
*get_value_type (struct varobj
*var
);
228 static struct type
*get_target_type (struct type
*);
230 static enum varobj_display_formats
variable_default_display (struct varobj
*);
232 static void cppush (struct cpstack
**pstack
, char *name
);
234 static char *cppop (struct cpstack
**pstack
);
236 static int install_new_value (struct varobj
*var
, struct value
*value
,
239 static void install_default_visualizer (struct varobj
*var
);
241 /* Language-specific routines. */
243 static enum varobj_languages
variable_language (struct varobj
*var
);
245 static int number_of_children (struct varobj
*);
247 static char *name_of_variable (struct varobj
*);
249 static char *name_of_child (struct varobj
*, int);
251 static struct value
*value_of_root (struct varobj
**var_handle
, int *);
253 static struct value
*value_of_child (struct varobj
*parent
, int index
);
255 static char *my_value_of_variable (struct varobj
*var
,
256 enum varobj_display_formats format
);
258 static char *value_get_print_value (struct value
*value
,
259 enum varobj_display_formats format
,
260 PyObject
*value_formatter
);
262 static int varobj_value_is_changeable_p (struct varobj
*var
);
264 static int is_root_p (struct varobj
*var
);
266 static struct varobj
*
267 varobj_add_child (struct varobj
*var
, const char *name
, struct value
*value
);
269 /* C implementation */
271 static int c_number_of_children (struct varobj
*var
);
273 static char *c_name_of_variable (struct varobj
*parent
);
275 static char *c_name_of_child (struct varobj
*parent
, int index
);
277 static char *c_path_expr_of_child (struct varobj
*child
);
279 static struct value
*c_value_of_root (struct varobj
**var_handle
);
281 static struct value
*c_value_of_child (struct varobj
*parent
, int index
);
283 static struct type
*c_type_of_child (struct varobj
*parent
, int index
);
285 static char *c_value_of_variable (struct varobj
*var
,
286 enum varobj_display_formats format
);
288 /* C++ implementation */
290 static int cplus_number_of_children (struct varobj
*var
);
292 static void cplus_class_num_children (struct type
*type
, int children
[3]);
294 static char *cplus_name_of_variable (struct varobj
*parent
);
296 static char *cplus_name_of_child (struct varobj
*parent
, int index
);
298 static char *cplus_path_expr_of_child (struct varobj
*child
);
300 static struct value
*cplus_value_of_root (struct varobj
**var_handle
);
302 static struct value
*cplus_value_of_child (struct varobj
*parent
, int index
);
304 static struct type
*cplus_type_of_child (struct varobj
*parent
, int index
);
306 static char *cplus_value_of_variable (struct varobj
*var
,
307 enum varobj_display_formats format
);
309 /* Java implementation */
311 static int java_number_of_children (struct varobj
*var
);
313 static char *java_name_of_variable (struct varobj
*parent
);
315 static char *java_name_of_child (struct varobj
*parent
, int index
);
317 static char *java_path_expr_of_child (struct varobj
*child
);
319 static struct value
*java_value_of_root (struct varobj
**var_handle
);
321 static struct value
*java_value_of_child (struct varobj
*parent
, int index
);
323 static struct type
*java_type_of_child (struct varobj
*parent
, int index
);
325 static char *java_value_of_variable (struct varobj
*var
,
326 enum varobj_display_formats format
);
328 /* The language specific vector */
330 struct language_specific
333 /* The language of this variable */
334 enum varobj_languages language
;
336 /* The number of children of PARENT. */
337 int (*number_of_children
) (struct varobj
* parent
);
339 /* The name (expression) of a root varobj. */
340 char *(*name_of_variable
) (struct varobj
* parent
);
342 /* The name of the INDEX'th child of PARENT. */
343 char *(*name_of_child
) (struct varobj
* parent
, int index
);
345 /* Returns the rooted expression of CHILD, which is a variable
346 obtain that has some parent. */
347 char *(*path_expr_of_child
) (struct varobj
* child
);
349 /* The ``struct value *'' of the root variable ROOT. */
350 struct value
*(*value_of_root
) (struct varobj
** root_handle
);
352 /* The ``struct value *'' of the INDEX'th child of PARENT. */
353 struct value
*(*value_of_child
) (struct varobj
* parent
, int index
);
355 /* The type of the INDEX'th child of PARENT. */
356 struct type
*(*type_of_child
) (struct varobj
* parent
, int index
);
358 /* The current value of VAR. */
359 char *(*value_of_variable
) (struct varobj
* var
,
360 enum varobj_display_formats format
);
363 /* Array of known source language routines. */
364 static struct language_specific languages
[vlang_end
] = {
365 /* Unknown (try treating as C */
368 c_number_of_children
,
371 c_path_expr_of_child
,
380 c_number_of_children
,
383 c_path_expr_of_child
,
392 cplus_number_of_children
,
393 cplus_name_of_variable
,
395 cplus_path_expr_of_child
,
397 cplus_value_of_child
,
399 cplus_value_of_variable
}
404 java_number_of_children
,
405 java_name_of_variable
,
407 java_path_expr_of_child
,
411 java_value_of_variable
}
414 /* A little convenience enum for dealing with C++/Java */
417 v_public
= 0, v_private
, v_protected
422 /* Mappings of varobj_display_formats enums to gdb's format codes */
423 static int format_code
[] = { 0, 't', 'd', 'x', 'o' };
425 /* Header of the list of root variable objects */
426 static struct varobj_root
*rootlist
;
427 static int rootcount
= 0; /* number of root varobjs in the list */
429 /* Prime number indicating the number of buckets in the hash table */
430 /* A prime large enough to avoid too many colisions */
431 #define VAROBJ_TABLE_SIZE 227
433 /* Pointer to the varobj hash table (built at run time) */
434 static struct vlist
**varobj_table
;
436 /* Is the variable X one of our "fake" children? */
437 #define CPLUS_FAKE_CHILD(x) \
438 ((x) != NULL && (x)->type == NULL && (x)->value == NULL)
441 /* API Implementation */
443 is_root_p (struct varobj
*var
)
445 return (var
->root
->rootvar
== var
);
448 /* Creates a varobj (not its children) */
450 /* Return the full FRAME which corresponds to the given CORE_ADDR
451 or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
453 static struct frame_info
*
454 find_frame_addr_in_frame_chain (CORE_ADDR frame_addr
)
456 struct frame_info
*frame
= NULL
;
458 if (frame_addr
== (CORE_ADDR
) 0)
461 for (frame
= get_current_frame ();
463 frame
= get_prev_frame (frame
))
465 if (get_frame_base_address (frame
) == frame_addr
)
473 varobj_create (char *objname
,
474 char *expression
, CORE_ADDR frame
, enum varobj_type type
)
477 struct frame_info
*fi
;
478 struct frame_info
*old_fi
= NULL
;
480 struct cleanup
*old_chain
;
482 /* Fill out a varobj structure for the (root) variable being constructed. */
483 var
= new_root_variable ();
484 old_chain
= make_cleanup_free_variable (var
);
486 if (expression
!= NULL
)
489 enum varobj_languages lang
;
490 struct value
*value
= NULL
;
492 /* Parse and evaluate the expression, filling in as much of the
493 variable's data as possible. */
495 if (has_stack_frames ())
497 /* Allow creator to specify context of variable */
498 if ((type
== USE_CURRENT_FRAME
) || (type
== USE_SELECTED_FRAME
))
499 fi
= get_selected_frame (NULL
);
501 /* FIXME: cagney/2002-11-23: This code should be doing a
502 lookup using the frame ID and not just the frame's
503 ``address''. This, of course, means an interface
504 change. However, with out that interface change ISAs,
505 such as the ia64 with its two stacks, won't work.
506 Similar goes for the case where there is a frameless
508 fi
= find_frame_addr_in_frame_chain (frame
);
513 /* frame = -2 means always use selected frame */
514 if (type
== USE_SELECTED_FRAME
)
515 var
->root
->floating
= 1;
519 block
= get_frame_block (fi
, 0);
522 innermost_block
= NULL
;
523 /* Wrap the call to parse expression, so we can
524 return a sensible error. */
525 if (!gdb_parse_exp_1 (&p
, block
, 0, &var
->root
->exp
))
530 /* Don't allow variables to be created for types. */
531 if (var
->root
->exp
->elts
[0].opcode
== OP_TYPE
)
533 do_cleanups (old_chain
);
534 fprintf_unfiltered (gdb_stderr
, "Attempt to use a type name"
535 " as an expression.\n");
539 var
->format
= variable_default_display (var
);
540 var
->root
->valid_block
= innermost_block
;
541 var
->name
= xstrdup (expression
);
542 /* For a root var, the name and the expr are the same. */
543 var
->path_expr
= xstrdup (expression
);
545 /* When the frame is different from the current frame,
546 we must select the appropriate frame before parsing
547 the expression, otherwise the value will not be current.
548 Since select_frame is so benign, just call it for all cases. */
549 if (innermost_block
&& fi
!= NULL
)
551 var
->root
->frame
= get_frame_id (fi
);
552 var
->root
->thread_id
= pid_to_thread_id (inferior_ptid
);
553 old_fi
= get_selected_frame (NULL
);
557 /* We definitely need to catch errors here.
558 If evaluate_expression succeeds we got the value we wanted.
559 But if it fails, we still go on with a call to evaluate_type() */
560 if (!gdb_evaluate_expression (var
->root
->exp
, &value
))
562 /* Error getting the value. Try to at least get the
564 struct value
*type_only_value
= evaluate_type (var
->root
->exp
);
565 var
->type
= value_type (type_only_value
);
568 var
->type
= value_type (value
);
570 install_new_value (var
, value
, 1 /* Initial assignment */);
572 /* Set language info */
573 lang
= variable_language (var
);
574 var
->root
->lang
= &languages
[lang
];
576 /* Set ourselves as our root */
577 var
->root
->rootvar
= var
;
579 /* Reset the selected frame */
581 select_frame (old_fi
);
584 /* If the variable object name is null, that means this
585 is a temporary variable, so don't install it. */
587 if ((var
!= NULL
) && (objname
!= NULL
))
589 var
->obj_name
= xstrdup (objname
);
591 /* If a varobj name is duplicated, the install will fail so
593 if (!install_variable (var
))
595 do_cleanups (old_chain
);
600 install_default_visualizer (var
);
601 discard_cleanups (old_chain
);
605 /* Generates an unique name that can be used for a varobj */
608 varobj_gen_name (void)
613 /* generate a name for this object */
615 obj_name
= xstrprintf ("var%d", id
);
620 /* Given an OBJNAME, returns the pointer to the corresponding varobj. Call
621 error if OBJNAME cannot be found. */
624 varobj_get_handle (char *objname
)
628 unsigned int index
= 0;
631 for (chp
= objname
; *chp
; chp
++)
633 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
636 cv
= *(varobj_table
+ index
);
637 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, objname
) != 0))
641 error (_("Variable object not found"));
646 /* Given the handle, return the name of the object */
649 varobj_get_objname (struct varobj
*var
)
651 return var
->obj_name
;
654 /* Given the handle, return the expression represented by the object */
657 varobj_get_expression (struct varobj
*var
)
659 return name_of_variable (var
);
662 /* Deletes a varobj and all its children if only_children == 0,
663 otherwise deletes only the children; returns a malloc'ed list of all the
664 (malloc'ed) names of the variables that have been deleted (NULL terminated) */
667 varobj_delete (struct varobj
*var
, char ***dellist
, int only_children
)
671 struct cpstack
*result
= NULL
;
674 /* Initialize a stack for temporary results */
675 cppush (&result
, NULL
);
678 /* Delete only the variable children */
679 delcount
= delete_variable (&result
, var
, 1 /* only the children */ );
681 /* Delete the variable and all its children */
682 delcount
= delete_variable (&result
, var
, 0 /* parent+children */ );
684 /* We may have been asked to return a list of what has been deleted */
687 *dellist
= xmalloc ((delcount
+ 1) * sizeof (char *));
691 *cp
= cppop (&result
);
692 while ((*cp
!= NULL
) && (mycount
> 0))
696 *cp
= cppop (&result
);
699 if (mycount
|| (*cp
!= NULL
))
700 warning (_("varobj_delete: assertion failed - mycount(=%d) <> 0"),
707 /* Convenience function for varobj_set_visualizer. Instantiate a
708 pretty-printer for a given value. */
710 instantiate_pretty_printer (PyObject
*constructor
, struct value
*value
)
713 PyObject
*val_obj
= NULL
;
715 volatile struct gdb_exception except
;
717 TRY_CATCH (except
, RETURN_MASK_ALL
)
719 value
= value_copy (value
);
721 GDB_PY_HANDLE_EXCEPTION (except
);
722 val_obj
= value_to_value_object (value
);
727 printer
= PyObject_CallFunctionObjArgs (constructor
, val_obj
, NULL
);
734 /* Set/Get variable object display format */
736 enum varobj_display_formats
737 varobj_set_display_format (struct varobj
*var
,
738 enum varobj_display_formats format
)
745 case FORMAT_HEXADECIMAL
:
747 var
->format
= format
;
751 var
->format
= variable_default_display (var
);
754 if (varobj_value_is_changeable_p (var
)
755 && var
->value
&& !value_lazy (var
->value
))
757 xfree (var
->print_value
);
758 var
->print_value
= value_get_print_value (var
->value
, var
->format
,
759 var
->pretty_printer
);
765 enum varobj_display_formats
766 varobj_get_display_format (struct varobj
*var
)
772 varobj_get_display_hint (struct varobj
*var
)
777 PyGILState_STATE state
= PyGILState_Ensure ();
778 if (var
->pretty_printer
)
779 result
= gdbpy_get_display_hint (var
->pretty_printer
);
780 PyGILState_Release (state
);
786 /* If the variable object is bound to a specific thread, that
787 is its evaluation can always be done in context of a frame
788 inside that thread, returns GDB id of the thread -- which
789 is always positive. Otherwise, returns -1. */
791 varobj_get_thread_id (struct varobj
*var
)
793 if (var
->root
->valid_block
&& var
->root
->thread_id
> 0)
794 return var
->root
->thread_id
;
800 varobj_set_frozen (struct varobj
*var
, int frozen
)
802 /* When a variable is unfrozen, we don't fetch its value.
803 The 'not_fetched' flag remains set, so next -var-update
806 We don't fetch the value, because for structures the client
807 should do -var-update anyway. It would be bad to have different
808 client-size logic for structure and other types. */
809 var
->frozen
= frozen
;
813 varobj_get_frozen (struct varobj
*var
)
819 update_dynamic_varobj_children (struct varobj
*var
,
820 VEC (varobj_p
) **changed
,
821 VEC (varobj_p
) **new_and_unchanged
,
826 /* FIXME: we *might* want to provide this functionality as
827 a standalone function, so that other interested parties
828 than varobj code can benefit for this. */
829 struct cleanup
*back_to
;
833 int children_changed
= 0;
834 PyObject
*printer
= var
->pretty_printer
;
835 PyGILState_STATE state
;
837 state
= PyGILState_Ensure ();
838 back_to
= make_cleanup_py_restore_gil (&state
);
841 if (!PyObject_HasAttr (printer
, gdbpy_children_cst
))
843 do_cleanups (back_to
);
847 children
= PyObject_CallMethodObjArgs (printer
, gdbpy_children_cst
,
852 gdbpy_print_stack ();
853 error ("Null value returned for children");
856 make_cleanup_py_decref (children
);
858 if (!PyIter_Check (children
))
859 error ("Returned value is not iterable");
861 iterator
= PyObject_GetIter (children
);
864 gdbpy_print_stack ();
865 error ("Could not get children iterator");
867 make_cleanup_py_decref (iterator
);
871 PyObject
*item
= PyIter_Next (iterator
);
875 struct cleanup
*inner
;
879 inner
= make_cleanup_py_decref (item
);
881 if (!PyArg_ParseTuple (item
, "sO", &name
, &py_v
))
882 error ("Invalid item from the child list");
884 if (PyObject_TypeCheck (py_v
, &value_object_type
))
886 /* If we just call convert_value_from_python for this type,
887 we won't know who owns the result. For this one case we
888 need to copy the resulting value. */
889 v
= value_object_to_value (py_v
);
893 v
= convert_value_from_python (py_v
);
895 /* TODO: This assume the name of the i-th child never changes. */
897 /* Now see what to do here. */
898 if (VEC_length (varobj_p
, var
->children
) < i
+ 1)
900 /* There's no child yet. */
901 struct varobj
*child
= varobj_add_child (var
, name
, v
);
902 if (new_and_unchanged
)
903 VEC_safe_push (varobj_p
, *new_and_unchanged
, child
);
904 children_changed
= 1;
908 varobj_p existing
= VEC_index (varobj_p
, var
->children
, i
);
909 if (install_new_value (existing
, v
, 0) && changed
)
912 VEC_safe_push (varobj_p
, *changed
, existing
);
916 if (new_and_unchanged
)
917 VEC_safe_push (varobj_p
, *new_and_unchanged
, existing
);
924 if (i
< VEC_length (varobj_p
, var
->children
))
927 children_changed
= 1;
928 for (i
= 0; i
< VEC_length (varobj_p
, var
->children
); ++i
)
929 varobj_delete (VEC_index (varobj_p
, var
->children
, i
), NULL
, 0);
931 VEC_truncate (varobj_p
, var
->children
, i
);
932 var
->num_children
= VEC_length (varobj_p
, var
->children
);
934 do_cleanups (back_to
);
936 *cchanged
= children_changed
;
939 gdb_assert (0 && "should never be called if Python is not enabled");
944 varobj_get_num_children (struct varobj
*var
)
946 if (var
->num_children
== -1)
949 if (!var
->pretty_printer
950 || !update_dynamic_varobj_children (var
, NULL
, NULL
, &changed
))
951 var
->num_children
= number_of_children (var
);
954 return var
->num_children
;
957 /* Creates a list of the immediate children of a variable object;
958 the return code is the number of such children or -1 on error */
961 varobj_list_children (struct varobj
*var
)
963 struct varobj
*child
;
965 int i
, children_changed
;
967 var
->children_requested
= 1;
969 if (var
->pretty_printer
970 /* This, in theory, can result in the number of children changing without
971 frontend noticing. But well, calling -var-list-children on the same
972 varobj twice is not something a sane frontend would do. */
973 && update_dynamic_varobj_children (var
, NULL
, NULL
, &children_changed
))
974 return var
->children
;
976 if (var
->num_children
== -1)
977 var
->num_children
= number_of_children (var
);
979 /* If that failed, give up. */
980 if (var
->num_children
== -1)
981 return var
->children
;
983 /* If we're called when the list of children is not yet initialized,
984 allocate enough elements in it. */
985 while (VEC_length (varobj_p
, var
->children
) < var
->num_children
)
986 VEC_safe_push (varobj_p
, var
->children
, NULL
);
988 for (i
= 0; i
< var
->num_children
; i
++)
990 varobj_p existing
= VEC_index (varobj_p
, var
->children
, i
);
992 if (existing
== NULL
)
994 /* Either it's the first call to varobj_list_children for
995 this variable object, and the child was never created,
996 or it was explicitly deleted by the client. */
997 name
= name_of_child (var
, i
);
998 existing
= create_child (var
, i
, name
);
999 VEC_replace (varobj_p
, var
->children
, i
, existing
);
1000 install_default_visualizer (existing
);
1004 return var
->children
;
1007 static struct varobj
*
1008 varobj_add_child (struct varobj
*var
, const char *name
, struct value
*value
)
1010 varobj_p v
= create_child_with_value (var
,
1011 VEC_length (varobj_p
, var
->children
),
1013 VEC_safe_push (varobj_p
, var
->children
, v
);
1014 install_default_visualizer (v
);
1018 /* Obtain the type of an object Variable as a string similar to the one gdb
1019 prints on the console */
1022 varobj_get_type (struct varobj
*var
)
1025 struct cleanup
*old_chain
;
1026 struct ui_file
*stb
;
1030 /* For the "fake" variables, do not return a type. (It's type is
1032 Do not return a type for invalid variables as well. */
1033 if (CPLUS_FAKE_CHILD (var
) || !var
->root
->is_valid
)
1036 stb
= mem_fileopen ();
1037 old_chain
= make_cleanup_ui_file_delete (stb
);
1039 /* To print the type, we simply create a zero ``struct value *'' and
1040 cast it to our type. We then typeprint this variable. */
1041 val
= value_zero (var
->type
, not_lval
);
1042 type_print (value_type (val
), "", stb
, -1);
1044 thetype
= ui_file_xstrdup (stb
, &length
);
1045 do_cleanups (old_chain
);
1049 /* Obtain the type of an object variable. */
1052 varobj_get_gdb_type (struct varobj
*var
)
1057 /* Return a pointer to the full rooted expression of varobj VAR.
1058 If it has not been computed yet, compute it. */
1060 varobj_get_path_expr (struct varobj
*var
)
1062 if (var
->path_expr
!= NULL
)
1063 return var
->path_expr
;
1066 /* For root varobjs, we initialize path_expr
1067 when creating varobj, so here it should be
1069 gdb_assert (!is_root_p (var
));
1070 return (*var
->root
->lang
->path_expr_of_child
) (var
);
1074 enum varobj_languages
1075 varobj_get_language (struct varobj
*var
)
1077 return variable_language (var
);
1081 varobj_get_attributes (struct varobj
*var
)
1085 if (varobj_editable_p (var
))
1086 /* FIXME: define masks for attributes */
1087 attributes
|= 0x00000001; /* Editable */
1093 varobj_get_formatted_value (struct varobj
*var
,
1094 enum varobj_display_formats format
)
1096 return my_value_of_variable (var
, format
);
1100 varobj_get_value (struct varobj
*var
)
1102 return my_value_of_variable (var
, var
->format
);
1105 /* Set the value of an object variable (if it is editable) to the
1106 value of the given expression */
1107 /* Note: Invokes functions that can call error() */
1110 varobj_set_value (struct varobj
*var
, char *expression
)
1116 /* The argument "expression" contains the variable's new value.
1117 We need to first construct a legal expression for this -- ugh! */
1118 /* Does this cover all the bases? */
1119 struct expression
*exp
;
1120 struct value
*value
;
1121 int saved_input_radix
= input_radix
;
1122 char *s
= expression
;
1125 gdb_assert (varobj_editable_p (var
));
1127 input_radix
= 10; /* ALWAYS reset to decimal temporarily */
1128 exp
= parse_exp_1 (&s
, 0, 0);
1129 if (!gdb_evaluate_expression (exp
, &value
))
1131 /* We cannot proceed without a valid expression. */
1136 /* All types that are editable must also be changeable. */
1137 gdb_assert (varobj_value_is_changeable_p (var
));
1139 /* The value of a changeable variable object must not be lazy. */
1140 gdb_assert (!value_lazy (var
->value
));
1142 /* Need to coerce the input. We want to check if the
1143 value of the variable object will be different
1144 after assignment, and the first thing value_assign
1145 does is coerce the input.
1146 For example, if we are assigning an array to a pointer variable we
1147 should compare the pointer with the the array's address, not with the
1149 value
= coerce_array (value
);
1151 /* The new value may be lazy. gdb_value_assign, or
1152 rather value_contents, will take care of this.
1153 If fetching of the new value will fail, gdb_value_assign
1154 with catch the exception. */
1155 if (!gdb_value_assign (var
->value
, value
, &val
))
1158 /* If the value has changed, record it, so that next -var-update can
1159 report this change. If a variable had a value of '1', we've set it
1160 to '333' and then set again to '1', when -var-update will report this
1161 variable as changed -- because the first assignment has set the
1162 'updated' flag. There's no need to optimize that, because return value
1163 of -var-update should be considered an approximation. */
1164 var
->updated
= install_new_value (var
, val
, 0 /* Compare values. */);
1165 input_radix
= saved_input_radix
;
1169 /* Returns a malloc'ed list with all root variable objects */
1171 varobj_list (struct varobj
***varlist
)
1174 struct varobj_root
*croot
;
1175 int mycount
= rootcount
;
1177 /* Alloc (rootcount + 1) entries for the result */
1178 *varlist
= xmalloc ((rootcount
+ 1) * sizeof (struct varobj
*));
1182 while ((croot
!= NULL
) && (mycount
> 0))
1184 *cv
= croot
->rootvar
;
1187 croot
= croot
->next
;
1189 /* Mark the end of the list */
1192 if (mycount
|| (croot
!= NULL
))
1194 ("varobj_list: assertion failed - wrong tally of root vars (%d:%d)",
1195 rootcount
, mycount
);
1200 /* Assign a new value to a variable object. If INITIAL is non-zero,
1201 this is the first assignement after the variable object was just
1202 created, or changed type. In that case, just assign the value
1204 Otherwise, assign the new value, and return 1 if the value is different
1205 from the current one, 0 otherwise. The comparison is done on textual
1206 representation of value. Therefore, some types need not be compared. E.g.
1207 for structures the reported value is always "{...}", so no comparison is
1208 necessary here. If the old value was NULL and new one is not, or vice versa,
1211 The VALUE parameter should not be released -- the function will
1212 take care of releasing it when needed. */
1214 install_new_value (struct varobj
*var
, struct value
*value
, int initial
)
1219 int intentionally_not_fetched
= 0;
1220 char *print_value
= NULL
;
1222 /* We need to know the varobj's type to decide if the value should
1223 be fetched or not. C++ fake children (public/protected/private) don't have
1225 gdb_assert (var
->type
|| CPLUS_FAKE_CHILD (var
));
1226 changeable
= varobj_value_is_changeable_p (var
);
1228 /* If the type has custom visualizer, we consider it to be always
1229 changeable. FIXME: need to make sure this behaviour will not
1230 mess up read-sensitive values. */
1231 if (var
->pretty_printer
)
1234 need_to_fetch
= changeable
;
1236 /* We are not interested in the address of references, and given
1237 that in C++ a reference is not rebindable, it cannot
1238 meaningfully change. So, get hold of the real value. */
1241 value
= coerce_ref (value
);
1242 release_value (value
);
1245 if (var
->type
&& TYPE_CODE (var
->type
) == TYPE_CODE_UNION
)
1246 /* For unions, we need to fetch the value implicitly because
1247 of implementation of union member fetch. When gdb
1248 creates a value for a field and the value of the enclosing
1249 structure is not lazy, it immediately copies the necessary
1250 bytes from the enclosing values. If the enclosing value is
1251 lazy, the call to value_fetch_lazy on the field will read
1252 the data from memory. For unions, that means we'll read the
1253 same memory more than once, which is not desirable. So
1257 /* The new value might be lazy. If the type is changeable,
1258 that is we'll be comparing values of this type, fetch the
1259 value now. Otherwise, on the next update the old value
1260 will be lazy, which means we've lost that old value. */
1261 if (need_to_fetch
&& value
&& value_lazy (value
))
1263 struct varobj
*parent
= var
->parent
;
1264 int frozen
= var
->frozen
;
1265 for (; !frozen
&& parent
; parent
= parent
->parent
)
1266 frozen
|= parent
->frozen
;
1268 if (frozen
&& initial
)
1270 /* For variables that are frozen, or are children of frozen
1271 variables, we don't do fetch on initial assignment.
1272 For non-initial assignemnt we do the fetch, since it means we're
1273 explicitly asked to compare the new value with the old one. */
1274 intentionally_not_fetched
= 1;
1276 else if (!gdb_value_fetch_lazy (value
))
1278 /* Set the value to NULL, so that for the next -var-update,
1279 we don't try to compare the new value with this value,
1280 that we couldn't even read. */
1286 /* Below, we'll be comparing string rendering of old and new
1287 values. Don't get string rendering if the value is
1288 lazy -- if it is, the code above has decided that the value
1289 should not be fetched. */
1290 if (value
&& !value_lazy (value
))
1291 print_value
= value_get_print_value (value
, var
->format
,
1292 var
->pretty_printer
);
1294 /* If the type is changeable, compare the old and the new values.
1295 If this is the initial assignment, we don't have any old value
1297 if (!initial
&& changeable
)
1299 /* If the value of the varobj was changed by -var-set-value, then the
1300 value in the varobj and in the target is the same. However, that value
1301 is different from the value that the varobj had after the previous
1302 -var-update. So need to the varobj as changed. */
1309 /* Try to compare the values. That requires that both
1310 values are non-lazy. */
1311 if (var
->not_fetched
&& value_lazy (var
->value
))
1313 /* This is a frozen varobj and the value was never read.
1314 Presumably, UI shows some "never read" indicator.
1315 Now that we've fetched the real value, we need to report
1316 this varobj as changed so that UI can show the real
1320 else if (var
->value
== NULL
&& value
== NULL
)
1323 else if (var
->value
== NULL
|| value
== NULL
)
1329 gdb_assert (!value_lazy (var
->value
));
1330 gdb_assert (!value_lazy (value
));
1332 gdb_assert (var
->print_value
!= NULL
&& print_value
!= NULL
);
1333 if (strcmp (var
->print_value
, print_value
) != 0)
1339 if (!initial
&& !changeable
)
1341 /* For values that are not changeable, we don't compare the values.
1342 However, we want to notice if a value was not NULL and now is NULL,
1343 or vise versa, so that we report when top-level varobjs come in scope
1344 and leave the scope. */
1345 changed
= (var
->value
!= NULL
) != (value
!= NULL
);
1348 /* We must always keep the new value, since children depend on it. */
1349 if (var
->value
!= NULL
&& var
->value
!= value
)
1350 value_free (var
->value
);
1352 if (var
->print_value
)
1353 xfree (var
->print_value
);
1354 var
->print_value
= print_value
;
1355 if (value
&& value_lazy (value
) && intentionally_not_fetched
)
1356 var
->not_fetched
= 1;
1358 var
->not_fetched
= 0;
1361 gdb_assert (!var
->value
|| value_type (var
->value
));
1367 install_visualizer (struct varobj
*var
, PyObject
*visualizer
)
1370 /* If there are any children now, wipe them. */
1371 varobj_delete (var
, NULL
, 1 /* children only */);
1372 var
->num_children
= -1;
1374 Py_XDECREF (var
->pretty_printer
);
1375 var
->pretty_printer
= visualizer
;
1377 install_new_value (var
, var
->value
, 1);
1379 /* If we removed the visualizer, and the user ever requested the
1380 object's children, then we must compute the list of children.
1381 Note that we needn't do this when installing a visualizer,
1382 because updating will recompute dynamic children. */
1383 if (!visualizer
&& var
->children_requested
)
1384 varobj_list_children (var
);
1386 error ("Python support required");
1391 install_default_visualizer (struct varobj
*var
)
1394 struct cleanup
*cleanup
;
1395 PyGILState_STATE state
;
1396 PyObject
*pretty_printer
= NULL
;
1398 state
= PyGILState_Ensure ();
1399 cleanup
= make_cleanup_py_restore_gil (&state
);
1403 pretty_printer
= gdbpy_get_varobj_pretty_printer (var
->value
);
1404 if (! pretty_printer
)
1406 gdbpy_print_stack ();
1407 error (_("Cannot instantiate printer for default visualizer"));
1411 if (pretty_printer
== Py_None
)
1413 Py_DECREF (pretty_printer
);
1414 pretty_printer
= NULL
;
1417 install_visualizer (var
, pretty_printer
);
1418 do_cleanups (cleanup
);
1420 /* No error is right as this function is inserted just as a hook. */
1425 varobj_set_visualizer (struct varobj
*var
, const char *visualizer
)
1428 PyObject
*mainmod
, *globals
, *pretty_printer
, *constructor
;
1429 struct cleanup
*back_to
, *value
;
1430 PyGILState_STATE state
;
1433 state
= PyGILState_Ensure ();
1434 back_to
= make_cleanup_py_restore_gil (&state
);
1436 mainmod
= PyImport_AddModule ("__main__");
1437 globals
= PyModule_GetDict (mainmod
);
1438 Py_INCREF (globals
);
1439 make_cleanup_py_decref (globals
);
1441 constructor
= PyRun_String (visualizer
, Py_eval_input
, globals
, globals
);
1443 /* Do not instantiate NoneType. */
1444 if (constructor
== Py_None
)
1446 pretty_printer
= Py_None
;
1447 Py_INCREF (pretty_printer
);
1450 pretty_printer
= instantiate_pretty_printer (constructor
, var
->value
);
1452 Py_XDECREF (constructor
);
1454 if (! pretty_printer
)
1456 gdbpy_print_stack ();
1457 error ("Could not evaluate visualizer expression: %s", visualizer
);
1460 if (pretty_printer
== Py_None
)
1462 Py_DECREF (pretty_printer
);
1463 pretty_printer
= NULL
;
1466 install_visualizer (var
, pretty_printer
);
1468 do_cleanups (back_to
);
1470 error ("Python support required");
1474 /* Update the values for a variable and its children. This is a
1475 two-pronged attack. First, re-parse the value for the root's
1476 expression to see if it's changed. Then go all the way
1477 through its children, reconstructing them and noting if they've
1480 The EXPLICIT parameter specifies if this call is result
1481 of MI request to update this specific variable, or
1482 result of implicit -var-update *. For implicit request, we don't
1483 update frozen variables.
1485 NOTE: This function may delete the caller's varobj. If it
1486 returns TYPE_CHANGED, then it has done this and VARP will be modified
1487 to point to the new varobj. */
1489 VEC(varobj_update_result
) *varobj_update (struct varobj
**varp
, int explicit)
1492 int type_changed
= 0;
1497 struct varobj
**templist
= NULL
;
1499 VEC (varobj_update_result
) *stack
= NULL
;
1500 VEC (varobj_update_result
) *result
= NULL
;
1501 struct frame_info
*fi
;
1503 /* Frozen means frozen -- we don't check for any change in
1504 this varobj, including its going out of scope, or
1505 changing type. One use case for frozen varobjs is
1506 retaining previously evaluated expressions, and we don't
1507 want them to be reevaluated at all. */
1508 if (!explicit && (*varp
)->frozen
)
1511 if (!(*varp
)->root
->is_valid
)
1513 varobj_update_result r
= {*varp
};
1514 r
.status
= VAROBJ_INVALID
;
1515 VEC_safe_push (varobj_update_result
, result
, &r
);
1519 if ((*varp
)->root
->rootvar
== *varp
)
1521 varobj_update_result r
= {*varp
};
1522 r
.status
= VAROBJ_IN_SCOPE
;
1524 /* Update the root variable. value_of_root can return NULL
1525 if the variable is no longer around, i.e. we stepped out of
1526 the frame in which a local existed. We are letting the
1527 value_of_root variable dispose of the varobj if the type
1529 new = value_of_root (varp
, &type_changed
);
1532 r
.type_changed
= type_changed
;
1533 if (install_new_value ((*varp
), new, type_changed
))
1537 r
.status
= VAROBJ_NOT_IN_SCOPE
;
1538 r
.value_installed
= 1;
1540 if (r
.status
== VAROBJ_NOT_IN_SCOPE
)
1542 VEC_safe_push (varobj_update_result
, result
, &r
);
1546 VEC_safe_push (varobj_update_result
, stack
, &r
);
1550 varobj_update_result r
= {*varp
};
1551 VEC_safe_push (varobj_update_result
, stack
, &r
);
1554 /* Walk through the children, reconstructing them all. */
1555 while (!VEC_empty (varobj_update_result
, stack
))
1557 varobj_update_result r
= *(VEC_last (varobj_update_result
, stack
));
1558 struct varobj
*v
= r
.varobj
;
1560 VEC_pop (varobj_update_result
, stack
);
1562 /* Update this variable, unless it's a root, which is already
1564 if (!r
.value_installed
)
1566 new = value_of_child (v
->parent
, v
->index
);
1567 if (install_new_value (v
, new, 0 /* type not changed */))
1574 /* We probably should not get children of a varobj that has a
1575 pretty-printer, but for which -var-list-children was never
1576 invoked. Presumably, such varobj is not yet expanded in the
1577 UI, so we need not bother getting it. */
1578 if (v
->pretty_printer
)
1580 VEC (varobj_p
) *changed
= 0, *new_and_unchanged
= 0;
1581 int i
, children_changed
;
1584 if (!v
->children_requested
)
1590 /* If update_dynamic_varobj_children returns 0, then we have
1591 a non-conforming pretty-printer, so we skip it. */
1592 if (update_dynamic_varobj_children (v
, &changed
, &new_and_unchanged
,
1595 if (children_changed
)
1596 r
.children_changed
= 1;
1597 for (i
= 0; VEC_iterate (varobj_p
, changed
, i
, tmp
); ++i
)
1599 varobj_update_result r
= {tmp
};
1601 r
.value_installed
= 1;
1602 VEC_safe_push (varobj_update_result
, stack
, &r
);
1605 VEC_iterate (varobj_p
, new_and_unchanged
, i
, tmp
);
1608 varobj_update_result r
= {tmp
};
1609 r
.value_installed
= 1;
1610 VEC_safe_push (varobj_update_result
, stack
, &r
);
1612 if (r
.changed
|| r
.children_changed
)
1613 VEC_safe_push (varobj_update_result
, result
, &r
);
1618 /* Push any children. Use reverse order so that the first
1619 child is popped from the work stack first, and so
1620 will be added to result first. This does not
1621 affect correctness, just "nicer". */
1622 for (i
= VEC_length (varobj_p
, v
->children
)-1; i
>= 0; --i
)
1624 varobj_p c
= VEC_index (varobj_p
, v
->children
, i
);
1625 /* Child may be NULL if explicitly deleted by -var-delete. */
1626 if (c
!= NULL
&& !c
->frozen
)
1628 varobj_update_result r
= {c
};
1629 VEC_safe_push (varobj_update_result
, stack
, &r
);
1633 if (r
.changed
|| r
.type_changed
)
1634 VEC_safe_push (varobj_update_result
, result
, &r
);
1637 VEC_free (varobj_update_result
, stack
);
1643 /* Helper functions */
1646 * Variable object construction/destruction
1650 delete_variable (struct cpstack
**resultp
, struct varobj
*var
,
1651 int only_children_p
)
1655 delete_variable_1 (resultp
, &delcount
, var
,
1656 only_children_p
, 1 /* remove_from_parent_p */ );
1661 /* Delete the variable object VAR and its children */
1662 /* IMPORTANT NOTE: If we delete a variable which is a child
1663 and the parent is not removed we dump core. It must be always
1664 initially called with remove_from_parent_p set */
1666 delete_variable_1 (struct cpstack
**resultp
, int *delcountp
,
1667 struct varobj
*var
, int only_children_p
,
1668 int remove_from_parent_p
)
1672 /* Delete any children of this variable, too. */
1673 for (i
= 0; i
< VEC_length (varobj_p
, var
->children
); ++i
)
1675 varobj_p child
= VEC_index (varobj_p
, var
->children
, i
);
1678 if (!remove_from_parent_p
)
1679 child
->parent
= NULL
;
1680 delete_variable_1 (resultp
, delcountp
, child
, 0, only_children_p
);
1682 VEC_free (varobj_p
, var
->children
);
1684 /* if we were called to delete only the children we are done here */
1685 if (only_children_p
)
1688 /* Otherwise, add it to the list of deleted ones and proceed to do so */
1689 /* If the name is null, this is a temporary variable, that has not
1690 yet been installed, don't report it, it belongs to the caller... */
1691 if (var
->obj_name
!= NULL
)
1693 cppush (resultp
, xstrdup (var
->obj_name
));
1694 *delcountp
= *delcountp
+ 1;
1697 /* If this variable has a parent, remove it from its parent's list */
1698 /* OPTIMIZATION: if the parent of this variable is also being deleted,
1699 (as indicated by remove_from_parent_p) we don't bother doing an
1700 expensive list search to find the element to remove when we are
1701 discarding the list afterwards */
1702 if ((remove_from_parent_p
) && (var
->parent
!= NULL
))
1704 VEC_replace (varobj_p
, var
->parent
->children
, var
->index
, NULL
);
1707 if (var
->obj_name
!= NULL
)
1708 uninstall_variable (var
);
1710 /* Free memory associated with this variable */
1711 free_variable (var
);
1714 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
1716 install_variable (struct varobj
*var
)
1719 struct vlist
*newvl
;
1721 unsigned int index
= 0;
1724 for (chp
= var
->obj_name
; *chp
; chp
++)
1726 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
1729 cv
= *(varobj_table
+ index
);
1730 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
1734 error (_("Duplicate variable object name"));
1736 /* Add varobj to hash table */
1737 newvl
= xmalloc (sizeof (struct vlist
));
1738 newvl
->next
= *(varobj_table
+ index
);
1740 *(varobj_table
+ index
) = newvl
;
1742 /* If root, add varobj to root list */
1743 if (is_root_p (var
))
1745 /* Add to list of root variables */
1746 if (rootlist
== NULL
)
1747 var
->root
->next
= NULL
;
1749 var
->root
->next
= rootlist
;
1750 rootlist
= var
->root
;
1757 /* Unistall the object VAR. */
1759 uninstall_variable (struct varobj
*var
)
1763 struct varobj_root
*cr
;
1764 struct varobj_root
*prer
;
1766 unsigned int index
= 0;
1769 /* Remove varobj from hash table */
1770 for (chp
= var
->obj_name
; *chp
; chp
++)
1772 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
1775 cv
= *(varobj_table
+ index
);
1777 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
1784 fprintf_unfiltered (gdb_stdlog
, "Deleting %s\n", var
->obj_name
);
1789 ("Assertion failed: Could not find variable object \"%s\" to delete",
1795 *(varobj_table
+ index
) = cv
->next
;
1797 prev
->next
= cv
->next
;
1801 /* If root, remove varobj from root list */
1802 if (is_root_p (var
))
1804 /* Remove from list of root variables */
1805 if (rootlist
== var
->root
)
1806 rootlist
= var
->root
->next
;
1811 while ((cr
!= NULL
) && (cr
->rootvar
!= var
))
1819 ("Assertion failed: Could not find varobj \"%s\" in root list",
1826 prer
->next
= cr
->next
;
1833 /* Create and install a child of the parent of the given name */
1834 static struct varobj
*
1835 create_child (struct varobj
*parent
, int index
, char *name
)
1837 return create_child_with_value (parent
, index
, name
,
1838 value_of_child (parent
, index
));
1841 static struct varobj
*
1842 create_child_with_value (struct varobj
*parent
, int index
, const char *name
,
1843 struct value
*value
)
1845 struct varobj
*child
;
1848 child
= new_variable ();
1850 /* name is allocated by name_of_child */
1851 /* FIXME: xstrdup should not be here. */
1852 child
->name
= xstrdup (name
);
1853 child
->index
= index
;
1854 child
->parent
= parent
;
1855 child
->root
= parent
->root
;
1856 childs_name
= xstrprintf ("%s.%s", parent
->obj_name
, name
);
1857 child
->obj_name
= childs_name
;
1858 install_variable (child
);
1860 /* Compute the type of the child. Must do this before
1861 calling install_new_value. */
1863 /* If the child had no evaluation errors, var->value
1864 will be non-NULL and contain a valid type. */
1865 child
->type
= value_type (value
);
1867 /* Otherwise, we must compute the type. */
1868 child
->type
= (*child
->root
->lang
->type_of_child
) (child
->parent
,
1870 install_new_value (child
, value
, 1);
1877 * Miscellaneous utility functions.
1880 /* Allocate memory and initialize a new variable */
1881 static struct varobj
*
1886 var
= (struct varobj
*) xmalloc (sizeof (struct varobj
));
1888 var
->path_expr
= NULL
;
1889 var
->obj_name
= NULL
;
1893 var
->num_children
= -1;
1895 var
->children
= NULL
;
1899 var
->print_value
= NULL
;
1901 var
->not_fetched
= 0;
1902 var
->children_requested
= 0;
1903 var
->pretty_printer
= 0;
1908 /* Allocate memory and initialize a new root variable */
1909 static struct varobj
*
1910 new_root_variable (void)
1912 struct varobj
*var
= new_variable ();
1913 var
->root
= (struct varobj_root
*) xmalloc (sizeof (struct varobj_root
));;
1914 var
->root
->lang
= NULL
;
1915 var
->root
->exp
= NULL
;
1916 var
->root
->valid_block
= NULL
;
1917 var
->root
->frame
= null_frame_id
;
1918 var
->root
->floating
= 0;
1919 var
->root
->rootvar
= NULL
;
1920 var
->root
->is_valid
= 1;
1925 /* Free any allocated memory associated with VAR. */
1927 free_variable (struct varobj
*var
)
1929 value_free (var
->value
);
1931 /* Free the expression if this is a root variable. */
1932 if (is_root_p (var
))
1934 xfree (var
->root
->exp
);
1940 PyGILState_STATE state
= PyGILState_Ensure ();
1941 Py_XDECREF (var
->pretty_printer
);
1942 PyGILState_Release (state
);
1947 xfree (var
->obj_name
);
1948 xfree (var
->print_value
);
1949 xfree (var
->path_expr
);
1954 do_free_variable_cleanup (void *var
)
1956 free_variable (var
);
1959 static struct cleanup
*
1960 make_cleanup_free_variable (struct varobj
*var
)
1962 return make_cleanup (do_free_variable_cleanup
, var
);
1965 /* This returns the type of the variable. It also skips past typedefs
1966 to return the real type of the variable.
1968 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
1969 except within get_target_type and get_type. */
1970 static struct type
*
1971 get_type (struct varobj
*var
)
1977 type
= check_typedef (type
);
1982 /* Return the type of the value that's stored in VAR,
1983 or that would have being stored there if the
1984 value were accessible.
1986 This differs from VAR->type in that VAR->type is always
1987 the true type of the expession in the source language.
1988 The return value of this function is the type we're
1989 actually storing in varobj, and using for displaying
1990 the values and for comparing previous and new values.
1992 For example, top-level references are always stripped. */
1993 static struct type
*
1994 get_value_type (struct varobj
*var
)
1999 type
= value_type (var
->value
);
2003 type
= check_typedef (type
);
2005 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2006 type
= get_target_type (type
);
2008 type
= check_typedef (type
);
2013 /* This returns the target type (or NULL) of TYPE, also skipping
2014 past typedefs, just like get_type ().
2016 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
2017 except within get_target_type and get_type. */
2018 static struct type
*
2019 get_target_type (struct type
*type
)
2023 type
= TYPE_TARGET_TYPE (type
);
2025 type
= check_typedef (type
);
2031 /* What is the default display for this variable? We assume that
2032 everything is "natural". Any exceptions? */
2033 static enum varobj_display_formats
2034 variable_default_display (struct varobj
*var
)
2036 return FORMAT_NATURAL
;
2039 /* FIXME: The following should be generic for any pointer */
2041 cppush (struct cpstack
**pstack
, char *name
)
2045 s
= (struct cpstack
*) xmalloc (sizeof (struct cpstack
));
2051 /* FIXME: The following should be generic for any pointer */
2053 cppop (struct cpstack
**pstack
)
2058 if ((*pstack
)->name
== NULL
&& (*pstack
)->next
== NULL
)
2063 *pstack
= (*pstack
)->next
;
2070 * Language-dependencies
2073 /* Common entry points */
2075 /* Get the language of variable VAR. */
2076 static enum varobj_languages
2077 variable_language (struct varobj
*var
)
2079 enum varobj_languages lang
;
2081 switch (var
->root
->exp
->language_defn
->la_language
)
2087 case language_cplus
:
2098 /* Return the number of children for a given variable.
2099 The result of this function is defined by the language
2100 implementation. The number of children returned by this function
2101 is the number of children that the user will see in the variable
2104 number_of_children (struct varobj
*var
)
2106 return (*var
->root
->lang
->number_of_children
) (var
);;
2109 /* What is the expression for the root varobj VAR? Returns a malloc'd string. */
2111 name_of_variable (struct varobj
*var
)
2113 return (*var
->root
->lang
->name_of_variable
) (var
);
2116 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd string. */
2118 name_of_child (struct varobj
*var
, int index
)
2120 return (*var
->root
->lang
->name_of_child
) (var
, index
);
2123 /* What is the ``struct value *'' of the root variable VAR?
2124 For floating variable object, evaluation can get us a value
2125 of different type from what is stored in varobj already. In
2127 - *type_changed will be set to 1
2128 - old varobj will be freed, and new one will be
2129 created, with the same name.
2130 - *var_handle will be set to the new varobj
2131 Otherwise, *type_changed will be set to 0. */
2132 static struct value
*
2133 value_of_root (struct varobj
**var_handle
, int *type_changed
)
2137 if (var_handle
== NULL
)
2142 /* This should really be an exception, since this should
2143 only get called with a root variable. */
2145 if (!is_root_p (var
))
2148 if (var
->root
->floating
)
2150 struct varobj
*tmp_var
;
2151 char *old_type
, *new_type
;
2153 tmp_var
= varobj_create (NULL
, var
->name
, (CORE_ADDR
) 0,
2154 USE_SELECTED_FRAME
);
2155 if (tmp_var
== NULL
)
2159 old_type
= varobj_get_type (var
);
2160 new_type
= varobj_get_type (tmp_var
);
2161 if (strcmp (old_type
, new_type
) == 0)
2163 /* The expression presently stored inside var->root->exp
2164 remembers the locations of local variables relatively to
2165 the frame where the expression was created (in DWARF location
2166 button, for example). Naturally, those locations are not
2167 correct in other frames, so update the expression. */
2169 struct expression
*tmp_exp
= var
->root
->exp
;
2170 var
->root
->exp
= tmp_var
->root
->exp
;
2171 tmp_var
->root
->exp
= tmp_exp
;
2173 varobj_delete (tmp_var
, NULL
, 0);
2178 tmp_var
->obj_name
= xstrdup (var
->obj_name
);
2179 varobj_delete (var
, NULL
, 0);
2181 install_variable (tmp_var
);
2182 *var_handle
= tmp_var
;
2194 return (*var
->root
->lang
->value_of_root
) (var_handle
);
2197 /* What is the ``struct value *'' for the INDEX'th child of PARENT? */
2198 static struct value
*
2199 value_of_child (struct varobj
*parent
, int index
)
2201 struct value
*value
;
2203 value
= (*parent
->root
->lang
->value_of_child
) (parent
, index
);
2208 /* GDB already has a command called "value_of_variable". Sigh. */
2210 my_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
2212 if (var
->root
->is_valid
)
2213 return (*var
->root
->lang
->value_of_variable
) (var
, format
);
2219 value_get_print_value (struct value
*value
, enum varobj_display_formats format
,
2220 PyObject
*value_formatter
)
2223 struct ui_file
*stb
;
2224 struct cleanup
*old_chain
;
2225 char *thevalue
= NULL
;
2226 struct value_print_options opts
;
2233 PyGILState_STATE state
= PyGILState_Ensure ();
2234 if (value_formatter
&& PyObject_HasAttr (value_formatter
,
2235 gdbpy_to_string_cst
))
2238 struct value
*replacement
;
2239 int string_print
= 0;
2241 hint
= gdbpy_get_display_hint (value_formatter
);
2244 if (!strcmp (hint
, "string"))
2249 thevalue
= apply_varobj_pretty_printer (value_formatter
,
2251 if (thevalue
&& !string_print
)
2253 PyGILState_Release (state
);
2257 value
= replacement
;
2259 PyGILState_Release (state
);
2263 stb
= mem_fileopen ();
2264 old_chain
= make_cleanup_ui_file_delete (stb
);
2266 get_formatted_print_options (&opts
, format_code
[(int) format
]);
2271 make_cleanup (xfree
, thevalue
);
2272 LA_PRINT_STRING (stb
, builtin_type (current_gdbarch
)->builtin_char
,
2273 (gdb_byte
*) thevalue
, strlen (thevalue
),
2277 common_val_print (value
, stb
, 0, &opts
, current_language
);
2278 thevalue
= ui_file_xstrdup (stb
, &dummy
);
2280 do_cleanups (old_chain
);
2285 varobj_editable_p (struct varobj
*var
)
2288 struct value
*value
;
2290 if (!(var
->root
->is_valid
&& var
->value
&& VALUE_LVAL (var
->value
)))
2293 type
= get_value_type (var
);
2295 switch (TYPE_CODE (type
))
2297 case TYPE_CODE_STRUCT
:
2298 case TYPE_CODE_UNION
:
2299 case TYPE_CODE_ARRAY
:
2300 case TYPE_CODE_FUNC
:
2301 case TYPE_CODE_METHOD
:
2311 /* Return non-zero if changes in value of VAR
2312 must be detected and reported by -var-update.
2313 Return zero is -var-update should never report
2314 changes of such values. This makes sense for structures
2315 (since the changes in children values will be reported separately),
2316 or for artifical objects (like 'public' pseudo-field in C++).
2318 Return value of 0 means that gdb need not call value_fetch_lazy
2319 for the value of this variable object. */
2321 varobj_value_is_changeable_p (struct varobj
*var
)
2326 if (CPLUS_FAKE_CHILD (var
))
2329 type
= get_value_type (var
);
2331 switch (TYPE_CODE (type
))
2333 case TYPE_CODE_STRUCT
:
2334 case TYPE_CODE_UNION
:
2335 case TYPE_CODE_ARRAY
:
2346 /* Return 1 if that varobj is floating, that is is always evaluated in the
2347 selected frame, and not bound to thread/frame. Such variable objects
2348 are created using '@' as frame specifier to -var-create. */
2350 varobj_floating_p (struct varobj
*var
)
2352 return var
->root
->floating
;
2355 /* Given the value and the type of a variable object,
2356 adjust the value and type to those necessary
2357 for getting children of the variable object.
2358 This includes dereferencing top-level references
2359 to all types and dereferencing pointers to
2362 Both TYPE and *TYPE should be non-null. VALUE
2363 can be null if we want to only translate type.
2364 *VALUE can be null as well -- if the parent
2367 If WAS_PTR is not NULL, set *WAS_PTR to 0 or 1
2368 depending on whether pointer was dereferenced
2369 in this function. */
2371 adjust_value_for_child_access (struct value
**value
,
2375 gdb_assert (type
&& *type
);
2380 *type
= check_typedef (*type
);
2382 /* The type of value stored in varobj, that is passed
2383 to us, is already supposed to be
2384 reference-stripped. */
2386 gdb_assert (TYPE_CODE (*type
) != TYPE_CODE_REF
);
2388 /* Pointers to structures are treated just like
2389 structures when accessing children. Don't
2390 dererences pointers to other types. */
2391 if (TYPE_CODE (*type
) == TYPE_CODE_PTR
)
2393 struct type
*target_type
= get_target_type (*type
);
2394 if (TYPE_CODE (target_type
) == TYPE_CODE_STRUCT
2395 || TYPE_CODE (target_type
) == TYPE_CODE_UNION
)
2397 if (value
&& *value
)
2399 int success
= gdb_value_ind (*value
, value
);
2403 *type
= target_type
;
2409 /* The 'get_target_type' function calls check_typedef on
2410 result, so we can immediately check type code. No
2411 need to call check_typedef here. */
2416 c_number_of_children (struct varobj
*var
)
2418 struct type
*type
= get_value_type (var
);
2420 struct type
*target
;
2422 adjust_value_for_child_access (NULL
, &type
, NULL
);
2423 target
= get_target_type (type
);
2425 switch (TYPE_CODE (type
))
2427 case TYPE_CODE_ARRAY
:
2428 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (target
) > 0
2429 && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type
))
2430 children
= TYPE_LENGTH (type
) / TYPE_LENGTH (target
);
2432 /* If we don't know how many elements there are, don't display
2437 case TYPE_CODE_STRUCT
:
2438 case TYPE_CODE_UNION
:
2439 children
= TYPE_NFIELDS (type
);
2443 /* The type here is a pointer to non-struct. Typically, pointers
2444 have one child, except for function ptrs, which have no children,
2445 and except for void*, as we don't know what to show.
2447 We can show char* so we allow it to be dereferenced. If you decide
2448 to test for it, please mind that a little magic is necessary to
2449 properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
2450 TYPE_NAME == "char" */
2451 if (TYPE_CODE (target
) == TYPE_CODE_FUNC
2452 || TYPE_CODE (target
) == TYPE_CODE_VOID
)
2459 /* Other types have no children */
2467 c_name_of_variable (struct varobj
*parent
)
2469 return xstrdup (parent
->name
);
2472 /* Return the value of element TYPE_INDEX of a structure
2473 value VALUE. VALUE's type should be a structure,
2474 or union, or a typedef to struct/union.
2476 Returns NULL if getting the value fails. Never throws. */
2477 static struct value
*
2478 value_struct_element_index (struct value
*value
, int type_index
)
2480 struct value
*result
= NULL
;
2481 volatile struct gdb_exception e
;
2483 struct type
*type
= value_type (value
);
2484 type
= check_typedef (type
);
2486 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
2487 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
2489 TRY_CATCH (e
, RETURN_MASK_ERROR
)
2491 if (field_is_static (&TYPE_FIELD (type
, type_index
)))
2492 result
= value_static_field (type
, type_index
);
2494 result
= value_primitive_field (value
, 0, type_index
, type
);
2506 /* Obtain the information about child INDEX of the variable
2508 If CNAME is not null, sets *CNAME to the name of the child relative
2510 If CVALUE is not null, sets *CVALUE to the value of the child.
2511 If CTYPE is not null, sets *CTYPE to the type of the child.
2513 If any of CNAME, CVALUE, or CTYPE is not null, but the corresponding
2514 information cannot be determined, set *CNAME, *CVALUE, or *CTYPE
2517 c_describe_child (struct varobj
*parent
, int index
,
2518 char **cname
, struct value
**cvalue
, struct type
**ctype
,
2519 char **cfull_expression
)
2521 struct value
*value
= parent
->value
;
2522 struct type
*type
= get_value_type (parent
);
2523 char *parent_expression
= NULL
;
2532 if (cfull_expression
)
2534 *cfull_expression
= NULL
;
2535 parent_expression
= varobj_get_path_expr (parent
);
2537 adjust_value_for_child_access (&value
, &type
, &was_ptr
);
2539 switch (TYPE_CODE (type
))
2541 case TYPE_CODE_ARRAY
:
2543 *cname
= xstrprintf ("%d", index
2544 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
)));
2546 if (cvalue
&& value
)
2548 int real_index
= index
+ TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
2549 struct value
*indval
=
2550 value_from_longest (builtin_type_int32
, (LONGEST
) real_index
);
2551 gdb_value_subscript (value
, indval
, cvalue
);
2555 *ctype
= get_target_type (type
);
2557 if (cfull_expression
)
2558 *cfull_expression
= xstrprintf ("(%s)[%d]", parent_expression
,
2560 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
)));
2565 case TYPE_CODE_STRUCT
:
2566 case TYPE_CODE_UNION
:
2568 *cname
= xstrdup (TYPE_FIELD_NAME (type
, index
));
2570 if (cvalue
&& value
)
2572 /* For C, varobj index is the same as type index. */
2573 *cvalue
= value_struct_element_index (value
, index
);
2577 *ctype
= TYPE_FIELD_TYPE (type
, index
);
2579 if (cfull_expression
)
2581 char *join
= was_ptr
? "->" : ".";
2582 *cfull_expression
= xstrprintf ("(%s)%s%s", parent_expression
, join
,
2583 TYPE_FIELD_NAME (type
, index
));
2590 *cname
= xstrprintf ("*%s", parent
->name
);
2592 if (cvalue
&& value
)
2594 int success
= gdb_value_ind (value
, cvalue
);
2599 /* Don't use get_target_type because it calls
2600 check_typedef and here, we want to show the true
2601 declared type of the variable. */
2603 *ctype
= TYPE_TARGET_TYPE (type
);
2605 if (cfull_expression
)
2606 *cfull_expression
= xstrprintf ("*(%s)", parent_expression
);
2611 /* This should not happen */
2613 *cname
= xstrdup ("???");
2614 if (cfull_expression
)
2615 *cfull_expression
= xstrdup ("???");
2616 /* Don't set value and type, we don't know then. */
2621 c_name_of_child (struct varobj
*parent
, int index
)
2624 c_describe_child (parent
, index
, &name
, NULL
, NULL
, NULL
);
2629 c_path_expr_of_child (struct varobj
*child
)
2631 c_describe_child (child
->parent
, child
->index
, NULL
, NULL
, NULL
,
2633 return child
->path_expr
;
2636 /* If frame associated with VAR can be found, switch
2637 to it and return 1. Otherwise, return 0. */
2639 check_scope (struct varobj
*var
)
2641 struct frame_info
*fi
;
2644 fi
= frame_find_by_id (var
->root
->frame
);
2649 CORE_ADDR pc
= get_frame_pc (fi
);
2650 if (pc
< BLOCK_START (var
->root
->valid_block
) ||
2651 pc
>= BLOCK_END (var
->root
->valid_block
))
2659 static struct value
*
2660 c_value_of_root (struct varobj
**var_handle
)
2662 struct value
*new_val
= NULL
;
2663 struct varobj
*var
= *var_handle
;
2664 struct frame_info
*fi
;
2665 int within_scope
= 0;
2666 struct cleanup
*back_to
;
2668 /* Only root variables can be updated... */
2669 if (!is_root_p (var
))
2670 /* Not a root var */
2673 back_to
= make_cleanup_restore_current_thread ();
2675 /* Determine whether the variable is still around. */
2676 if (var
->root
->valid_block
== NULL
|| var
->root
->floating
)
2678 else if (var
->root
->thread_id
== 0)
2680 /* The program was single-threaded when the variable object was
2681 created. Technically, it's possible that the program became
2682 multi-threaded since then, but we don't support such
2684 within_scope
= check_scope (var
);
2688 ptid_t ptid
= thread_id_to_pid (var
->root
->thread_id
);
2689 if (in_thread_list (ptid
))
2691 switch_to_thread (ptid
);
2692 within_scope
= check_scope (var
);
2698 /* We need to catch errors here, because if evaluate
2699 expression fails we want to just return NULL. */
2700 gdb_evaluate_expression (var
->root
->exp
, &new_val
);
2704 do_cleanups (back_to
);
2709 static struct value
*
2710 c_value_of_child (struct varobj
*parent
, int index
)
2712 struct value
*value
= NULL
;
2713 c_describe_child (parent
, index
, NULL
, &value
, NULL
, NULL
);
2718 static struct type
*
2719 c_type_of_child (struct varobj
*parent
, int index
)
2721 struct type
*type
= NULL
;
2722 c_describe_child (parent
, index
, NULL
, NULL
, &type
, NULL
);
2727 c_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
2729 /* BOGUS: if val_print sees a struct/class, or a reference to one,
2730 it will print out its children instead of "{...}". So we need to
2731 catch that case explicitly. */
2732 struct type
*type
= get_type (var
);
2734 /* If we have a custom formatter, return whatever string it has
2736 if (var
->pretty_printer
&& var
->print_value
)
2737 return xstrdup (var
->print_value
);
2739 /* Strip top-level references. */
2740 while (TYPE_CODE (type
) == TYPE_CODE_REF
)
2741 type
= check_typedef (TYPE_TARGET_TYPE (type
));
2743 switch (TYPE_CODE (type
))
2745 case TYPE_CODE_STRUCT
:
2746 case TYPE_CODE_UNION
:
2747 return xstrdup ("{...}");
2750 case TYPE_CODE_ARRAY
:
2753 number
= xstrprintf ("[%d]", var
->num_children
);
2760 if (var
->value
== NULL
)
2762 /* This can happen if we attempt to get the value of a struct
2763 member when the parent is an invalid pointer. This is an
2764 error condition, so we should tell the caller. */
2769 if (var
->not_fetched
&& value_lazy (var
->value
))
2770 /* Frozen variable and no value yet. We don't
2771 implicitly fetch the value. MI response will
2772 use empty string for the value, which is OK. */
2775 gdb_assert (varobj_value_is_changeable_p (var
));
2776 gdb_assert (!value_lazy (var
->value
));
2778 /* If the specified format is the current one,
2779 we can reuse print_value */
2780 if (format
== var
->format
)
2781 return xstrdup (var
->print_value
);
2783 return value_get_print_value (var
->value
, format
,
2784 var
->pretty_printer
);
2794 cplus_number_of_children (struct varobj
*var
)
2797 int children
, dont_know
;
2802 if (!CPLUS_FAKE_CHILD (var
))
2804 type
= get_value_type (var
);
2805 adjust_value_for_child_access (NULL
, &type
, NULL
);
2807 if (((TYPE_CODE (type
)) == TYPE_CODE_STRUCT
) ||
2808 ((TYPE_CODE (type
)) == TYPE_CODE_UNION
))
2812 cplus_class_num_children (type
, kids
);
2813 if (kids
[v_public
] != 0)
2815 if (kids
[v_private
] != 0)
2817 if (kids
[v_protected
] != 0)
2820 /* Add any baseclasses */
2821 children
+= TYPE_N_BASECLASSES (type
);
2824 /* FIXME: save children in var */
2831 type
= get_value_type (var
->parent
);
2832 adjust_value_for_child_access (NULL
, &type
, NULL
);
2834 cplus_class_num_children (type
, kids
);
2835 if (strcmp (var
->name
, "public") == 0)
2836 children
= kids
[v_public
];
2837 else if (strcmp (var
->name
, "private") == 0)
2838 children
= kids
[v_private
];
2840 children
= kids
[v_protected
];
2845 children
= c_number_of_children (var
);
2850 /* Compute # of public, private, and protected variables in this class.
2851 That means we need to descend into all baseclasses and find out
2852 how many are there, too. */
2854 cplus_class_num_children (struct type
*type
, int children
[3])
2858 children
[v_public
] = 0;
2859 children
[v_private
] = 0;
2860 children
[v_protected
] = 0;
2862 for (i
= TYPE_N_BASECLASSES (type
); i
< TYPE_NFIELDS (type
); i
++)
2864 /* If we have a virtual table pointer, omit it. */
2865 if (TYPE_VPTR_BASETYPE (type
) == type
&& TYPE_VPTR_FIELDNO (type
) == i
)
2868 if (TYPE_FIELD_PROTECTED (type
, i
))
2869 children
[v_protected
]++;
2870 else if (TYPE_FIELD_PRIVATE (type
, i
))
2871 children
[v_private
]++;
2873 children
[v_public
]++;
2878 cplus_name_of_variable (struct varobj
*parent
)
2880 return c_name_of_variable (parent
);
2883 enum accessibility
{ private_field
, protected_field
, public_field
};
2885 /* Check if field INDEX of TYPE has the specified accessibility.
2886 Return 0 if so and 1 otherwise. */
2888 match_accessibility (struct type
*type
, int index
, enum accessibility acc
)
2890 if (acc
== private_field
&& TYPE_FIELD_PRIVATE (type
, index
))
2892 else if (acc
== protected_field
&& TYPE_FIELD_PROTECTED (type
, index
))
2894 else if (acc
== public_field
&& !TYPE_FIELD_PRIVATE (type
, index
)
2895 && !TYPE_FIELD_PROTECTED (type
, index
))
2902 cplus_describe_child (struct varobj
*parent
, int index
,
2903 char **cname
, struct value
**cvalue
, struct type
**ctype
,
2904 char **cfull_expression
)
2907 struct value
*value
;
2910 char *parent_expression
= NULL
;
2918 if (cfull_expression
)
2919 *cfull_expression
= NULL
;
2921 if (CPLUS_FAKE_CHILD (parent
))
2923 value
= parent
->parent
->value
;
2924 type
= get_value_type (parent
->parent
);
2925 if (cfull_expression
)
2926 parent_expression
= varobj_get_path_expr (parent
->parent
);
2930 value
= parent
->value
;
2931 type
= get_value_type (parent
);
2932 if (cfull_expression
)
2933 parent_expression
= varobj_get_path_expr (parent
);
2936 adjust_value_for_child_access (&value
, &type
, &was_ptr
);
2938 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
2939 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
2941 char *join
= was_ptr
? "->" : ".";
2942 if (CPLUS_FAKE_CHILD (parent
))
2944 /* The fields of the class type are ordered as they
2945 appear in the class. We are given an index for a
2946 particular access control type ("public","protected",
2947 or "private"). We must skip over fields that don't
2948 have the access control we are looking for to properly
2949 find the indexed field. */
2950 int type_index
= TYPE_N_BASECLASSES (type
);
2951 enum accessibility acc
= public_field
;
2952 if (strcmp (parent
->name
, "private") == 0)
2953 acc
= private_field
;
2954 else if (strcmp (parent
->name
, "protected") == 0)
2955 acc
= protected_field
;
2959 if (TYPE_VPTR_BASETYPE (type
) == type
2960 && type_index
== TYPE_VPTR_FIELDNO (type
))
2962 else if (match_accessibility (type
, type_index
, acc
))
2969 *cname
= xstrdup (TYPE_FIELD_NAME (type
, type_index
));
2971 if (cvalue
&& value
)
2972 *cvalue
= value_struct_element_index (value
, type_index
);
2975 *ctype
= TYPE_FIELD_TYPE (type
, type_index
);
2977 if (cfull_expression
)
2978 *cfull_expression
= xstrprintf ("((%s)%s%s)", parent_expression
,
2980 TYPE_FIELD_NAME (type
, type_index
));
2982 else if (index
< TYPE_N_BASECLASSES (type
))
2984 /* This is a baseclass. */
2986 *cname
= xstrdup (TYPE_FIELD_NAME (type
, index
));
2988 if (cvalue
&& value
)
2990 *cvalue
= value_cast (TYPE_FIELD_TYPE (type
, index
), value
);
2991 release_value (*cvalue
);
2996 *ctype
= TYPE_FIELD_TYPE (type
, index
);
2999 if (cfull_expression
)
3001 char *ptr
= was_ptr
? "*" : "";
3002 /* Cast the parent to the base' type. Note that in gdb,
3005 will create an lvalue, for all appearences, so we don't
3006 need to use more fancy:
3009 *cfull_expression
= xstrprintf ("(%s(%s%s) %s)",
3011 TYPE_FIELD_NAME (type
, index
),
3018 char *access
= NULL
;
3020 cplus_class_num_children (type
, children
);
3022 /* Everything beyond the baseclasses can
3023 only be "public", "private", or "protected"
3025 The special "fake" children are always output by varobj in
3026 this order. So if INDEX == 2, it MUST be "protected". */
3027 index
-= TYPE_N_BASECLASSES (type
);
3031 if (children
[v_public
] > 0)
3033 else if (children
[v_private
] > 0)
3036 access
= "protected";
3039 if (children
[v_public
] > 0)
3041 if (children
[v_private
] > 0)
3044 access
= "protected";
3046 else if (children
[v_private
] > 0)
3047 access
= "protected";
3050 /* Must be protected */
3051 access
= "protected";
3058 gdb_assert (access
);
3060 *cname
= xstrdup (access
);
3062 /* Value and type and full expression are null here. */
3067 c_describe_child (parent
, index
, cname
, cvalue
, ctype
, cfull_expression
);
3072 cplus_name_of_child (struct varobj
*parent
, int index
)
3075 cplus_describe_child (parent
, index
, &name
, NULL
, NULL
, NULL
);
3080 cplus_path_expr_of_child (struct varobj
*child
)
3082 cplus_describe_child (child
->parent
, child
->index
, NULL
, NULL
, NULL
,
3084 return child
->path_expr
;
3087 static struct value
*
3088 cplus_value_of_root (struct varobj
**var_handle
)
3090 return c_value_of_root (var_handle
);
3093 static struct value
*
3094 cplus_value_of_child (struct varobj
*parent
, int index
)
3096 struct value
*value
= NULL
;
3097 cplus_describe_child (parent
, index
, NULL
, &value
, NULL
, NULL
);
3101 static struct type
*
3102 cplus_type_of_child (struct varobj
*parent
, int index
)
3104 struct type
*type
= NULL
;
3105 cplus_describe_child (parent
, index
, NULL
, NULL
, &type
, NULL
);
3110 cplus_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
3113 /* If we have one of our special types, don't print out
3115 if (CPLUS_FAKE_CHILD (var
))
3116 return xstrdup ("");
3118 return c_value_of_variable (var
, format
);
3124 java_number_of_children (struct varobj
*var
)
3126 return cplus_number_of_children (var
);
3130 java_name_of_variable (struct varobj
*parent
)
3134 name
= cplus_name_of_variable (parent
);
3135 /* If the name has "-" in it, it is because we
3136 needed to escape periods in the name... */
3139 while (*p
!= '\000')
3150 java_name_of_child (struct varobj
*parent
, int index
)
3154 name
= cplus_name_of_child (parent
, index
);
3155 /* Escape any periods in the name... */
3158 while (*p
!= '\000')
3169 java_path_expr_of_child (struct varobj
*child
)
3174 static struct value
*
3175 java_value_of_root (struct varobj
**var_handle
)
3177 return cplus_value_of_root (var_handle
);
3180 static struct value
*
3181 java_value_of_child (struct varobj
*parent
, int index
)
3183 return cplus_value_of_child (parent
, index
);
3186 static struct type
*
3187 java_type_of_child (struct varobj
*parent
, int index
)
3189 return cplus_type_of_child (parent
, index
);
3193 java_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
3195 return cplus_value_of_variable (var
, format
);
3198 extern void _initialize_varobj (void);
3200 _initialize_varobj (void)
3202 int sizeof_table
= sizeof (struct vlist
*) * VAROBJ_TABLE_SIZE
;
3204 varobj_table
= xmalloc (sizeof_table
);
3205 memset (varobj_table
, 0, sizeof_table
);
3207 add_setshow_zinteger_cmd ("debugvarobj", class_maintenance
,
3209 Set varobj debugging."), _("\
3210 Show varobj debugging."), _("\
3211 When non-zero, varobj debugging is enabled."),
3214 &setlist
, &showlist
);
3217 /* Invalidate the varobjs that are tied to locals and re-create the ones that
3218 are defined on globals.
3219 Invalidated varobjs will be always printed in_scope="invalid". */
3222 varobj_invalidate (void)
3224 struct varobj
**all_rootvarobj
;
3225 struct varobj
**varp
;
3227 if (varobj_list (&all_rootvarobj
) > 0)
3229 varp
= all_rootvarobj
;
3230 while (*varp
!= NULL
)
3232 /* Floating varobjs are reparsed on each stop, so we don't care if
3233 the presently parsed expression refers to something that's gone.
3235 if ((*varp
)->root
->floating
)
3238 /* global var must be re-evaluated. */
3239 if ((*varp
)->root
->valid_block
== NULL
)
3241 struct varobj
*tmp_var
;
3243 /* Try to create a varobj with same expression. If we succeed
3244 replace the old varobj, otherwise invalidate it. */
3245 tmp_var
= varobj_create (NULL
, (*varp
)->name
, (CORE_ADDR
) 0,
3247 if (tmp_var
!= NULL
)
3249 tmp_var
->obj_name
= xstrdup ((*varp
)->obj_name
);
3250 varobj_delete (*varp
, NULL
, 0);
3251 install_variable (tmp_var
);
3254 (*varp
)->root
->is_valid
= 0;
3256 else /* locals must be invalidated. */
3257 (*varp
)->root
->is_valid
= 0;
3262 xfree (all_rootvarobj
);