1 /* Implementation of the GDB variable objects API.
2 Copyright 1999, 2000, 2001 Free Software Foundation, Inc.
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 59 Temple Place - Suite 330,
17 Boston, MA 02111-1307, USA. */
21 #include "expression.h"
26 #include "gdb_string.h"
31 /* Non-zero if we want to see trace of varobj level stuff. */
35 /* String representations of gdb's format codes */
36 char *varobj_format_string
[] =
37 { "natural", "binary", "decimal", "hexadecimal", "octal" };
39 /* String representations of gdb's known languages */
40 char *varobj_language_string
[] = { "unknown", "C", "C++", "Java" };
44 /* Every root variable has one of these structures saved in its
45 varobj. Members which must be free'd are noted. */
49 /* Alloc'd expression for this parent. */
50 struct expression
*exp
;
52 /* Block for which this expression is valid */
53 struct block
*valid_block
;
55 /* The frame for this expression */
56 struct frame_id frame
;
58 /* If 1, "update" always recomputes the frame & valid block
59 using the currently selected frame. */
60 int use_selected_frame
;
62 /* Language info for this variable and its children */
63 struct language_specific
*lang
;
65 /* The varobj for this root node. */
66 struct varobj
*rootvar
;
68 /* Next root variable */
69 struct varobj_root
*next
;
72 /* Every variable in the system has a structure of this type defined
73 for it. This structure holds all information necessary to manipulate
74 a particular object variable. Members which must be freed are noted. */
78 /* Alloc'd name of the variable for this object.. If this variable is a
79 child, then this name will be the child's source name.
81 /* NOTE: This is the "expression" */
84 /* The alloc'd name for this variable's object. This is here for
85 convenience when constructing this object's children. */
88 /* Index of this variable in its parent or -1 */
91 /* The type of this variable. This may NEVER be NULL. */
94 /* The value of this expression or subexpression. This may be NULL. */
97 /* Did an error occur evaluating the expression or getting its value? */
100 /* The number of (immediate) children this variable has */
103 /* If this object is a child, this points to its immediate parent. */
104 struct varobj
*parent
;
106 /* A list of this object's children */
107 struct varobj_child
*children
;
109 /* Description of the root variable. Points to root variable for children. */
110 struct varobj_root
*root
;
112 /* The format of the output for this object */
113 enum varobj_display_formats format
;
115 /* Was this variable updated via a varobj_set_value operation */
119 /* Every variable keeps a linked list of its children, described
120 by the following structure. */
121 /* FIXME: Deprecated. All should use vlist instead */
126 /* Pointer to the child's data */
127 struct varobj
*child
;
129 /* Pointer to the next child */
130 struct varobj_child
*next
;
133 /* A stack of varobjs */
134 /* FIXME: Deprecated. All should use vlist instead */
145 struct cpstack
*next
;
148 /* A list of varobjs */
156 /* Private function prototypes */
158 /* Helper functions for the above subcommands. */
160 static int delete_variable (struct cpstack
**, struct varobj
*, int);
162 static void delete_variable_1 (struct cpstack
**, int *,
163 struct varobj
*, int, int);
165 static int install_variable (struct varobj
*);
167 static void uninstall_variable (struct varobj
*);
169 static struct varobj
*child_exists (struct varobj
*, char *);
171 static struct varobj
*create_child (struct varobj
*, int, char *);
173 static void save_child_in_parent (struct varobj
*, struct varobj
*);
175 static void remove_child_from_parent (struct varobj
*, struct varobj
*);
177 /* Utility routines */
179 static struct varobj
*new_variable (void);
181 static struct varobj
*new_root_variable (void);
183 static void free_variable (struct varobj
*var
);
185 static struct cleanup
*make_cleanup_free_variable (struct varobj
*var
);
187 static struct type
*get_type (struct varobj
*var
);
189 static struct type
*get_type_deref (struct varobj
*var
);
191 static struct type
*get_target_type (struct type
*);
193 static enum varobj_display_formats
variable_default_display (struct varobj
*);
195 static int my_value_equal (struct value
*, struct value
*, int *);
197 static void vpush (struct vstack
**pstack
, struct varobj
*var
);
199 static struct varobj
*vpop (struct vstack
**pstack
);
201 static void cppush (struct cpstack
**pstack
, char *name
);
203 static char *cppop (struct cpstack
**pstack
);
205 /* Language-specific routines. */
207 static enum varobj_languages
variable_language (struct varobj
*var
);
209 static int number_of_children (struct varobj
*);
211 static char *name_of_variable (struct varobj
*);
213 static char *name_of_child (struct varobj
*, int);
215 static struct value
*value_of_root (struct varobj
**var_handle
, int *);
217 static struct value
*value_of_child (struct varobj
*parent
, int index
);
219 static struct type
*type_of_child (struct varobj
*var
);
221 static int variable_editable (struct varobj
*var
);
223 static char *my_value_of_variable (struct varobj
*var
);
225 static int type_changeable (struct varobj
*var
);
227 /* C implementation */
229 static int c_number_of_children (struct varobj
*var
);
231 static char *c_name_of_variable (struct varobj
*parent
);
233 static char *c_name_of_child (struct varobj
*parent
, int index
);
235 static struct value
*c_value_of_root (struct varobj
**var_handle
);
237 static struct value
*c_value_of_child (struct varobj
*parent
, int index
);
239 static struct type
*c_type_of_child (struct varobj
*parent
, int index
);
241 static int c_variable_editable (struct varobj
*var
);
243 static char *c_value_of_variable (struct varobj
*var
);
245 /* C++ implementation */
247 static int cplus_number_of_children (struct varobj
*var
);
249 static void cplus_class_num_children (struct type
*type
, int children
[3]);
251 static char *cplus_name_of_variable (struct varobj
*parent
);
253 static char *cplus_name_of_child (struct varobj
*parent
, int index
);
255 static struct value
*cplus_value_of_root (struct varobj
**var_handle
);
257 static struct value
*cplus_value_of_child (struct varobj
*parent
, int index
);
259 static struct type
*cplus_type_of_child (struct varobj
*parent
, int index
);
261 static int cplus_variable_editable (struct varobj
*var
);
263 static char *cplus_value_of_variable (struct varobj
*var
);
265 /* Java implementation */
267 static int java_number_of_children (struct varobj
*var
);
269 static char *java_name_of_variable (struct varobj
*parent
);
271 static char *java_name_of_child (struct varobj
*parent
, int index
);
273 static struct value
*java_value_of_root (struct varobj
**var_handle
);
275 static struct value
*java_value_of_child (struct varobj
*parent
, int index
);
277 static struct type
*java_type_of_child (struct varobj
*parent
, int index
);
279 static int java_variable_editable (struct varobj
*var
);
281 static char *java_value_of_variable (struct varobj
*var
);
283 /* The language specific vector */
285 struct language_specific
288 /* The language of this variable */
289 enum varobj_languages language
;
291 /* The number of children of PARENT. */
292 int (*number_of_children
) (struct varobj
* parent
);
294 /* The name (expression) of a root varobj. */
295 char *(*name_of_variable
) (struct varobj
* parent
);
297 /* The name of the INDEX'th child of PARENT. */
298 char *(*name_of_child
) (struct varobj
* parent
, int index
);
300 /* The ``struct value *'' of the root variable ROOT. */
301 struct value
*(*value_of_root
) (struct varobj
** root_handle
);
303 /* The ``struct value *'' of the INDEX'th child of PARENT. */
304 struct value
*(*value_of_child
) (struct varobj
* parent
, int index
);
306 /* The type of the INDEX'th child of PARENT. */
307 struct type
*(*type_of_child
) (struct varobj
* parent
, int index
);
309 /* Is VAR editable? */
310 int (*variable_editable
) (struct varobj
* var
);
312 /* The current value of VAR. */
313 char *(*value_of_variable
) (struct varobj
* var
);
316 /* Array of known source language routines. */
317 static struct language_specific
318 languages
[vlang_end
][sizeof (struct language_specific
)] = {
319 /* Unknown (try treating as C */
322 c_number_of_children
,
334 c_number_of_children
,
346 cplus_number_of_children
,
347 cplus_name_of_variable
,
350 cplus_value_of_child
,
352 cplus_variable_editable
,
353 cplus_value_of_variable
}
358 java_number_of_children
,
359 java_name_of_variable
,
364 java_variable_editable
,
365 java_value_of_variable
}
368 /* A little convenience enum for dealing with C++/Java */
371 v_public
= 0, v_private
, v_protected
376 /* Mappings of varobj_display_formats enums to gdb's format codes */
377 static int format_code
[] = { 0, 't', 'd', 'x', 'o' };
379 /* Header of the list of root variable objects */
380 static struct varobj_root
*rootlist
;
381 static int rootcount
= 0; /* number of root varobjs in the list */
383 /* Prime number indicating the number of buckets in the hash table */
384 /* A prime large enough to avoid too many colisions */
385 #define VAROBJ_TABLE_SIZE 227
387 /* Pointer to the varobj hash table (built at run time) */
388 static struct vlist
**varobj_table
;
390 /* Is the variable X one of our "fake" children? */
391 #define CPLUS_FAKE_CHILD(x) \
392 ((x) != NULL && (x)->type == NULL && (x)->value == NULL)
395 /* API Implementation */
397 /* Creates a varobj (not its children) */
400 varobj_create (char *objname
,
401 char *expression
, CORE_ADDR frame
, enum varobj_type type
)
404 struct frame_info
*fi
;
405 struct frame_info
*old_fi
= NULL
;
407 struct cleanup
*old_chain
;
409 /* Fill out a varobj structure for the (root) variable being constructed. */
410 var
= new_root_variable ();
411 old_chain
= make_cleanup_free_variable (var
);
413 if (expression
!= NULL
)
416 enum varobj_languages lang
;
418 /* Parse and evaluate the expression, filling in as much
419 of the variable's data as possible */
421 /* Allow creator to specify context of variable */
422 if ((type
== USE_CURRENT_FRAME
) || (type
== USE_SELECTED_FRAME
))
425 fi
= find_frame_addr_in_frame_chain (frame
);
427 /* frame = -2 means always use selected frame */
428 if (type
== USE_SELECTED_FRAME
)
429 var
->root
->use_selected_frame
= 1;
433 block
= get_frame_block (fi
, 0);
436 innermost_block
= NULL
;
437 /* Wrap the call to parse expression, so we can
438 return a sensible error. */
439 if (!gdb_parse_exp_1 (&p
, block
, 0, &var
->root
->exp
))
444 /* Don't allow variables to be created for types. */
445 if (var
->root
->exp
->elts
[0].opcode
== OP_TYPE
)
447 do_cleanups (old_chain
);
448 fprintf_unfiltered (gdb_stderr
,
449 "Attempt to use a type name as an expression.");
453 var
->format
= variable_default_display (var
);
454 var
->root
->valid_block
= innermost_block
;
455 var
->name
= savestring (expression
, strlen (expression
));
457 /* When the frame is different from the current frame,
458 we must select the appropriate frame before parsing
459 the expression, otherwise the value will not be current.
460 Since select_frame is so benign, just call it for all cases. */
463 get_frame_id (fi
, &var
->root
->frame
);
464 old_fi
= selected_frame
;
468 /* We definitively need to catch errors here.
469 If evaluate_expression succeeds we got the value we wanted.
470 But if it fails, we still go on with a call to evaluate_type() */
471 if (gdb_evaluate_expression (var
->root
->exp
, &var
->value
))
474 release_value (var
->value
);
475 if (VALUE_LAZY (var
->value
))
476 gdb_value_fetch_lazy (var
->value
);
479 var
->value
= evaluate_type (var
->root
->exp
);
481 var
->type
= VALUE_TYPE (var
->value
);
483 /* Set language info */
484 lang
= variable_language (var
);
485 var
->root
->lang
= languages
[lang
];
487 /* Set ourselves as our root */
488 var
->root
->rootvar
= var
;
490 /* Reset the selected frame */
492 select_frame (old_fi
);
495 /* If the variable object name is null, that means this
496 is a temporary variable, so don't install it. */
498 if ((var
!= NULL
) && (objname
!= NULL
))
500 var
->obj_name
= savestring (objname
, strlen (objname
));
502 /* If a varobj name is duplicated, the install will fail so
504 if (!install_variable (var
))
506 do_cleanups (old_chain
);
511 discard_cleanups (old_chain
);
515 /* Generates an unique name that can be used for a varobj */
518 varobj_gen_name (void)
523 /* generate a name for this object */
525 xasprintf (&obj_name
, "var%d", id
);
530 /* Given an "objname", returns the pointer to the corresponding varobj
531 or NULL if not found */
534 varobj_get_handle (char *objname
)
538 unsigned int index
= 0;
541 for (chp
= objname
; *chp
; chp
++)
543 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
546 cv
= *(varobj_table
+ index
);
547 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, objname
) != 0))
551 error ("Variable object not found");
556 /* Given the handle, return the name of the object */
559 varobj_get_objname (struct varobj
*var
)
561 return var
->obj_name
;
564 /* Given the handle, return the expression represented by the object */
567 varobj_get_expression (struct varobj
*var
)
569 return name_of_variable (var
);
572 /* Deletes a varobj and all its children if only_children == 0,
573 otherwise deletes only the children; returns a malloc'ed list of all the
574 (malloc'ed) names of the variables that have been deleted (NULL terminated) */
577 varobj_delete (struct varobj
*var
, char ***dellist
, int only_children
)
581 struct cpstack
*result
= NULL
;
584 /* Initialize a stack for temporary results */
585 cppush (&result
, NULL
);
588 /* Delete only the variable children */
589 delcount
= delete_variable (&result
, var
, 1 /* only the children */ );
591 /* Delete the variable and all its children */
592 delcount
= delete_variable (&result
, var
, 0 /* parent+children */ );
594 /* We may have been asked to return a list of what has been deleted */
597 *dellist
= xmalloc ((delcount
+ 1) * sizeof (char *));
601 *cp
= cppop (&result
);
602 while ((*cp
!= NULL
) && (mycount
> 0))
606 *cp
= cppop (&result
);
609 if (mycount
|| (*cp
!= NULL
))
610 warning ("varobj_delete: assertion failed - mycount(=%d) <> 0",
617 /* Set/Get variable object display format */
619 enum varobj_display_formats
620 varobj_set_display_format (struct varobj
*var
,
621 enum varobj_display_formats format
)
628 case FORMAT_HEXADECIMAL
:
630 var
->format
= format
;
634 var
->format
= variable_default_display (var
);
640 enum varobj_display_formats
641 varobj_get_display_format (struct varobj
*var
)
647 varobj_get_num_children (struct varobj
*var
)
649 if (var
->num_children
== -1)
650 var
->num_children
= number_of_children (var
);
652 return var
->num_children
;
655 /* Creates a list of the immediate children of a variable object;
656 the return code is the number of such children or -1 on error */
659 varobj_list_children (struct varobj
*var
, struct varobj
***childlist
)
661 struct varobj
*child
;
665 /* sanity check: have we been passed a pointer? */
666 if (childlist
== NULL
)
671 if (var
->num_children
== -1)
672 var
->num_children
= number_of_children (var
);
674 /* List of children */
675 *childlist
= xmalloc ((var
->num_children
+ 1) * sizeof (struct varobj
*));
677 for (i
= 0; i
< var
->num_children
; i
++)
679 /* Mark as the end in case we bail out */
680 *((*childlist
) + i
) = NULL
;
682 /* check if child exists, if not create */
683 name
= name_of_child (var
, i
);
684 child
= child_exists (var
, name
);
686 child
= create_child (var
, i
, name
);
688 *((*childlist
) + i
) = child
;
691 /* End of list is marked by a NULL pointer */
692 *((*childlist
) + i
) = NULL
;
694 return var
->num_children
;
697 /* Obtain the type of an object Variable as a string similar to the one gdb
698 prints on the console */
701 varobj_get_type (struct varobj
*var
)
704 struct cleanup
*old_chain
;
709 /* For the "fake" variables, do not return a type. (It's type is
711 if (CPLUS_FAKE_CHILD (var
))
714 stb
= mem_fileopen ();
715 old_chain
= make_cleanup_ui_file_delete (stb
);
717 /* To print the type, we simply create a zero ``struct value *'' and
718 cast it to our type. We then typeprint this variable. */
719 val
= value_zero (var
->type
, not_lval
);
720 type_print (VALUE_TYPE (val
), "", stb
, -1);
722 thetype
= ui_file_xstrdup (stb
, &length
);
723 do_cleanups (old_chain
);
727 enum varobj_languages
728 varobj_get_language (struct varobj
*var
)
730 return variable_language (var
);
734 varobj_get_attributes (struct varobj
*var
)
738 if (variable_editable (var
))
739 /* FIXME: define masks for attributes */
740 attributes
|= 0x00000001; /* Editable */
746 varobj_get_value (struct varobj
*var
)
748 return my_value_of_variable (var
);
751 /* Set the value of an object variable (if it is editable) to the
752 value of the given expression */
753 /* Note: Invokes functions that can call error() */
756 varobj_set_value (struct varobj
*var
, char *expression
)
762 /* The argument "expression" contains the variable's new value.
763 We need to first construct a legal expression for this -- ugh! */
764 /* Does this cover all the bases? */
765 struct expression
*exp
;
767 int saved_input_radix
= input_radix
;
769 if (var
->value
!= NULL
&& variable_editable (var
) && !var
->error
)
771 char *s
= expression
;
774 input_radix
= 10; /* ALWAYS reset to decimal temporarily */
775 if (!gdb_parse_exp_1 (&s
, 0, 0, &exp
))
776 /* We cannot proceed without a well-formed expression. */
778 if (!gdb_evaluate_expression (exp
, &value
))
780 /* We cannot proceed without a valid expression. */
785 if (!my_value_equal (var
->value
, value
, &error
))
787 if (!gdb_value_assign (var
->value
, value
, &val
))
789 value_free (var
->value
);
792 input_radix
= saved_input_radix
;
799 /* Returns a malloc'ed list with all root variable objects */
801 varobj_list (struct varobj
***varlist
)
804 struct varobj_root
*croot
;
805 int mycount
= rootcount
;
807 /* Alloc (rootcount + 1) entries for the result */
808 *varlist
= xmalloc ((rootcount
+ 1) * sizeof (struct varobj
*));
812 while ((croot
!= NULL
) && (mycount
> 0))
814 *cv
= croot
->rootvar
;
819 /* Mark the end of the list */
822 if (mycount
|| (croot
!= NULL
))
824 ("varobj_list: assertion failed - wrong tally of root vars (%d:%d)",
830 /* Update the values for a variable and its children. This is a
831 two-pronged attack. First, re-parse the value for the root's
832 expression to see if it's changed. Then go all the way
833 through its children, reconstructing them and noting if they've
836 -1 if there was an error updating the varobj
837 -2 if the type changed
838 Otherwise it is the number of children + parent changed
840 Only root variables can be updated...
842 NOTE: This function may delete the caller's varobj. If it
843 returns -2, then it has done this and VARP will be modified
844 to point to the new varobj. */
847 varobj_update (struct varobj
**varp
, struct varobj
***changelist
)
856 struct varobj
**templist
= NULL
;
858 struct vstack
*stack
= NULL
;
859 struct vstack
*result
= NULL
;
860 struct frame_id old_fid
;
861 struct frame_info
*fi
;
863 /* sanity check: have we been passed a pointer? */
864 if (changelist
== NULL
)
867 /* Only root variables can be updated... */
868 if ((*varp
)->root
->rootvar
!= *varp
)
872 /* Save the selected stack frame, since we will need to change it
873 in order to evaluate expressions. */
874 get_frame_id (selected_frame
, &old_fid
);
876 /* Update the root variable. value_of_root can return NULL
877 if the variable is no longer around, i.e. we stepped out of
878 the frame in which a local existed. We are letting the
879 value_of_root variable dispose of the varobj if the type
882 new = value_of_root (varp
, &type_changed
);
889 /* Initialize a stack for temporary results */
890 vpush (&result
, NULL
);
892 /* If this is a "use_selected_frame" varobj, and its type has changed,
893 them note that it's changed. */
896 vpush (&result
, *varp
);
899 /* If values are not equal, note that it's changed.
900 There a couple of exceptions here, though.
901 We don't want some types to be reported as "changed". */
902 else if (type_changeable (*varp
) &&
903 ((*varp
)->updated
|| !my_value_equal ((*varp
)->value
, new, &error2
)))
905 vpush (&result
, *varp
);
906 (*varp
)->updated
= 0;
908 /* error2 replaces var->error since this new value
909 WILL replace the old one. */
910 (*varp
)->error
= error2
;
913 /* We must always keep around the new value for this root
914 variable expression, or we lose the updated children! */
915 value_free ((*varp
)->value
);
916 (*varp
)->value
= new;
918 /* Initialize a stack */
919 vpush (&stack
, NULL
);
921 /* Push the root's children */
922 if ((*varp
)->children
!= NULL
)
924 struct varobj_child
*c
;
925 for (c
= (*varp
)->children
; c
!= NULL
; c
= c
->next
)
926 vpush (&stack
, c
->child
);
929 /* Walk through the children, reconstructing them all. */
933 /* Push any children */
934 if (v
->children
!= NULL
)
936 struct varobj_child
*c
;
937 for (c
= v
->children
; c
!= NULL
; c
= c
->next
)
938 vpush (&stack
, c
->child
);
941 /* Update this variable */
942 new = value_of_child (v
->parent
, v
->index
);
943 if (type_changeable (v
) &&
944 (v
->updated
|| !my_value_equal (v
->value
, new, &error2
)))
946 /* Note that it's changed */
951 /* error2 replaces v->error since this new value
952 WILL replace the old one. */
955 /* We must always keep new values, since children depend on it. */
956 if (v
->value
!= NULL
)
957 value_free (v
->value
);
964 /* Alloc (changed + 1) list entries */
965 /* FIXME: add a cleanup for the allocated list(s)
966 because one day the select_frame called below can longjump */
967 *changelist
= xmalloc ((changed
+ 1) * sizeof (struct varobj
*));
970 templist
= xmalloc ((changed
+ 1) * sizeof (struct varobj
*));
976 /* Copy from result stack to list */
978 *cv
= vpop (&result
);
979 while ((*cv
!= NULL
) && (vleft
> 0))
983 *cv
= vpop (&result
);
986 warning ("varobj_update: assertion failed - vleft <> 0");
990 /* Now we revert the order. */
991 for (i
= 0; i
< changed
; i
++)
992 *(*changelist
+ i
) = *(templist
+ changed
- 1 - i
);
993 *(*changelist
+ changed
) = NULL
;
996 /* Restore selected frame */
997 fi
= frame_find_by_id (old_fid
);
1008 /* Helper functions */
1011 * Variable object construction/destruction
1015 delete_variable (struct cpstack
**resultp
, struct varobj
*var
,
1016 int only_children_p
)
1020 delete_variable_1 (resultp
, &delcount
, var
,
1021 only_children_p
, 1 /* remove_from_parent_p */ );
1026 /* Delete the variable object VAR and its children */
1027 /* IMPORTANT NOTE: If we delete a variable which is a child
1028 and the parent is not removed we dump core. It must be always
1029 initially called with remove_from_parent_p set */
1031 delete_variable_1 (struct cpstack
**resultp
, int *delcountp
,
1032 struct varobj
*var
, int only_children_p
,
1033 int remove_from_parent_p
)
1035 struct varobj_child
*vc
;
1036 struct varobj_child
*next
;
1038 /* Delete any children of this variable, too. */
1039 for (vc
= var
->children
; vc
!= NULL
; vc
= next
)
1041 if (!remove_from_parent_p
)
1042 vc
->child
->parent
= NULL
;
1043 delete_variable_1 (resultp
, delcountp
, vc
->child
, 0, only_children_p
);
1048 /* if we were called to delete only the children we are done here */
1049 if (only_children_p
)
1052 /* Otherwise, add it to the list of deleted ones and proceed to do so */
1053 /* If the name is null, this is a temporary variable, that has not
1054 yet been installed, don't report it, it belongs to the caller... */
1055 if (var
->obj_name
!= NULL
)
1057 cppush (resultp
, xstrdup (var
->obj_name
));
1058 *delcountp
= *delcountp
+ 1;
1061 /* If this variable has a parent, remove it from its parent's list */
1062 /* OPTIMIZATION: if the parent of this variable is also being deleted,
1063 (as indicated by remove_from_parent_p) we don't bother doing an
1064 expensive list search to find the element to remove when we are
1065 discarding the list afterwards */
1066 if ((remove_from_parent_p
) && (var
->parent
!= NULL
))
1068 remove_child_from_parent (var
->parent
, var
);
1071 if (var
->obj_name
!= NULL
)
1072 uninstall_variable (var
);
1074 /* Free memory associated with this variable */
1075 free_variable (var
);
1078 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
1080 install_variable (struct varobj
*var
)
1083 struct vlist
*newvl
;
1085 unsigned int index
= 0;
1088 for (chp
= var
->obj_name
; *chp
; chp
++)
1090 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
1093 cv
= *(varobj_table
+ index
);
1094 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
1098 error ("Duplicate variable object name");
1100 /* Add varobj to hash table */
1101 newvl
= xmalloc (sizeof (struct vlist
));
1102 newvl
->next
= *(varobj_table
+ index
);
1104 *(varobj_table
+ index
) = newvl
;
1106 /* If root, add varobj to root list */
1107 if (var
->root
->rootvar
== var
)
1109 /* Add to list of root variables */
1110 if (rootlist
== NULL
)
1111 var
->root
->next
= NULL
;
1113 var
->root
->next
= rootlist
;
1114 rootlist
= var
->root
;
1121 /* Unistall the object VAR. */
1123 uninstall_variable (struct varobj
*var
)
1127 struct varobj_root
*cr
;
1128 struct varobj_root
*prer
;
1130 unsigned int index
= 0;
1133 /* Remove varobj from hash table */
1134 for (chp
= var
->obj_name
; *chp
; chp
++)
1136 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
1139 cv
= *(varobj_table
+ index
);
1141 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
1148 fprintf_unfiltered (gdb_stdlog
, "Deleting %s\n", var
->obj_name
);
1153 ("Assertion failed: Could not find variable object \"%s\" to delete",
1159 *(varobj_table
+ index
) = cv
->next
;
1161 prev
->next
= cv
->next
;
1165 /* If root, remove varobj from root list */
1166 if (var
->root
->rootvar
== var
)
1168 /* Remove from list of root variables */
1169 if (rootlist
== var
->root
)
1170 rootlist
= var
->root
->next
;
1175 while ((cr
!= NULL
) && (cr
->rootvar
!= var
))
1183 ("Assertion failed: Could not find varobj \"%s\" in root list",
1190 prer
->next
= cr
->next
;
1197 /* Does a child with the name NAME exist in VAR? If so, return its data.
1198 If not, return NULL. */
1199 static struct varobj
*
1200 child_exists (struct varobj
*var
, char *name
)
1202 struct varobj_child
*vc
;
1204 for (vc
= var
->children
; vc
!= NULL
; vc
= vc
->next
)
1206 if (STREQ (vc
->child
->name
, name
))
1213 /* Create and install a child of the parent of the given name */
1214 static struct varobj
*
1215 create_child (struct varobj
*parent
, int index
, char *name
)
1217 struct varobj
*child
;
1220 child
= new_variable ();
1222 /* name is allocated by name_of_child */
1224 child
->index
= index
;
1225 child
->value
= value_of_child (parent
, index
);
1226 if ((!CPLUS_FAKE_CHILD (child
) && child
->value
== NULL
) || parent
->error
)
1228 child
->parent
= parent
;
1229 child
->root
= parent
->root
;
1230 xasprintf (&childs_name
, "%s.%s", parent
->obj_name
, name
);
1231 child
->obj_name
= childs_name
;
1232 install_variable (child
);
1234 /* Save a pointer to this child in the parent */
1235 save_child_in_parent (parent
, child
);
1237 /* Note the type of this child */
1238 child
->type
= type_of_child (child
);
1243 /* FIXME: This should be a generic add to list */
1244 /* Save CHILD in the PARENT's data. */
1246 save_child_in_parent (struct varobj
*parent
, struct varobj
*child
)
1248 struct varobj_child
*vc
;
1250 /* Insert the child at the top */
1251 vc
= parent
->children
;
1253 (struct varobj_child
*) xmalloc (sizeof (struct varobj_child
));
1255 parent
->children
->next
= vc
;
1256 parent
->children
->child
= child
;
1259 /* FIXME: This should be a generic remove from list */
1260 /* Remove the CHILD from the PARENT's list of children. */
1262 remove_child_from_parent (struct varobj
*parent
, struct varobj
*child
)
1264 struct varobj_child
*vc
, *prev
;
1266 /* Find the child in the parent's list */
1268 for (vc
= parent
->children
; vc
!= NULL
;)
1270 if (vc
->child
== child
)
1277 parent
->children
= vc
->next
;
1279 prev
->next
= vc
->next
;
1285 * Miscellaneous utility functions.
1288 /* Allocate memory and initialize a new variable */
1289 static struct varobj
*
1294 var
= (struct varobj
*) xmalloc (sizeof (struct varobj
));
1296 var
->obj_name
= NULL
;
1301 var
->num_children
= -1;
1303 var
->children
= NULL
;
1311 /* Allocate memory and initialize a new root variable */
1312 static struct varobj
*
1313 new_root_variable (void)
1315 struct varobj
*var
= new_variable ();
1316 var
->root
= (struct varobj_root
*) xmalloc (sizeof (struct varobj_root
));;
1317 var
->root
->lang
= NULL
;
1318 var
->root
->exp
= NULL
;
1319 var
->root
->valid_block
= NULL
;
1320 var
->root
->frame
.base
= 0;
1321 var
->root
->frame
.pc
= 0;
1322 var
->root
->use_selected_frame
= 0;
1323 var
->root
->rootvar
= NULL
;
1328 /* Free any allocated memory associated with VAR. */
1330 free_variable (struct varobj
*var
)
1332 /* Free the expression if this is a root variable. */
1333 if (var
->root
->rootvar
== var
)
1335 free_current_contents ((char **) &var
->root
->exp
);
1340 xfree (var
->obj_name
);
1345 do_free_variable_cleanup (void *var
)
1347 free_variable (var
);
1350 static struct cleanup
*
1351 make_cleanup_free_variable (struct varobj
*var
)
1353 return make_cleanup (do_free_variable_cleanup
, var
);
1356 /* This returns the type of the variable. This skips past typedefs
1357 and returns the real type of the variable. It also dereferences
1358 pointers and references.
1360 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
1361 except within get_target_type and get_type. */
1362 static struct type
*
1363 get_type (struct varobj
*var
)
1368 while (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1369 type
= TYPE_TARGET_TYPE (type
);
1374 /* This returns the type of the variable, dereferencing pointers, too. */
1375 static struct type
*
1376 get_type_deref (struct varobj
*var
)
1380 type
= get_type (var
);
1382 if (type
!= NULL
&& (TYPE_CODE (type
) == TYPE_CODE_PTR
1383 || TYPE_CODE (type
) == TYPE_CODE_REF
))
1384 type
= get_target_type (type
);
1389 /* This returns the target type (or NULL) of TYPE, also skipping
1390 past typedefs, just like get_type ().
1392 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
1393 except within get_target_type and get_type. */
1394 static struct type
*
1395 get_target_type (struct type
*type
)
1399 type
= TYPE_TARGET_TYPE (type
);
1400 while (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1401 type
= TYPE_TARGET_TYPE (type
);
1407 /* What is the default display for this variable? We assume that
1408 everything is "natural". Any exceptions? */
1409 static enum varobj_display_formats
1410 variable_default_display (struct varobj
*var
)
1412 return FORMAT_NATURAL
;
1415 /* This function is similar to gdb's value_equal, except that this
1416 one is "safe" -- it NEVER longjmps. It determines if the VAR's
1417 value is the same as VAL2. */
1419 my_value_equal (struct value
*val1
, struct value
*val2
, int *error2
)
1424 /* Special case: NULL values. If both are null, say
1426 if (val1
== NULL
&& val2
== NULL
)
1428 else if (val1
== NULL
|| val2
== NULL
)
1431 /* This is bogus, but unfortunately necessary. We must know
1432 exactly what caused an error -- reading val1 or val2 -- so
1433 that we can really determine if we think that something has changed. */
1436 /* We do need to catch errors here because the whole purpose
1437 is to test if value_equal() has errored */
1438 if (!gdb_value_equal (val1
, val1
, &r
))
1441 if (!gdb_value_equal (val2
, val2
, &r
))
1447 if (!gdb_value_equal (val1
, val2
, &r
))
1449 /* An error occurred, this could have happened if
1450 either val1 or val2 errored. ERR1 and ERR2 tell
1451 us which of these it is. If both errored, then
1452 we assume nothing has changed. If one of them is
1453 valid, though, then something has changed. */
1456 /* both the old and new values caused errors, so
1457 we say the value did not change */
1458 /* This is indeterminate, though. Perhaps we should
1459 be safe and say, yes, it changed anyway?? */
1471 /* FIXME: The following should be generic for any pointer */
1473 vpush (struct vstack
**pstack
, struct varobj
*var
)
1477 s
= (struct vstack
*) xmalloc (sizeof (struct vstack
));
1483 /* FIXME: The following should be generic for any pointer */
1484 static struct varobj
*
1485 vpop (struct vstack
**pstack
)
1490 if ((*pstack
)->var
== NULL
&& (*pstack
)->next
== NULL
)
1495 *pstack
= (*pstack
)->next
;
1501 /* FIXME: The following should be generic for any pointer */
1503 cppush (struct cpstack
**pstack
, char *name
)
1507 s
= (struct cpstack
*) xmalloc (sizeof (struct cpstack
));
1513 /* FIXME: The following should be generic for any pointer */
1515 cppop (struct cpstack
**pstack
)
1520 if ((*pstack
)->name
== NULL
&& (*pstack
)->next
== NULL
)
1525 *pstack
= (*pstack
)->next
;
1532 * Language-dependencies
1535 /* Common entry points */
1537 /* Get the language of variable VAR. */
1538 static enum varobj_languages
1539 variable_language (struct varobj
*var
)
1541 enum varobj_languages lang
;
1543 switch (var
->root
->exp
->language_defn
->la_language
)
1549 case language_cplus
:
1560 /* Return the number of children for a given variable.
1561 The result of this function is defined by the language
1562 implementation. The number of children returned by this function
1563 is the number of children that the user will see in the variable
1566 number_of_children (struct varobj
*var
)
1568 return (*var
->root
->lang
->number_of_children
) (var
);;
1571 /* What is the expression for the root varobj VAR? Returns a malloc'd string. */
1573 name_of_variable (struct varobj
*var
)
1575 return (*var
->root
->lang
->name_of_variable
) (var
);
1578 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd string. */
1580 name_of_child (struct varobj
*var
, int index
)
1582 return (*var
->root
->lang
->name_of_child
) (var
, index
);
1585 /* What is the ``struct value *'' of the root variable VAR?
1586 TYPE_CHANGED controls what to do if the type of a
1587 use_selected_frame = 1 variable changes. On input,
1588 TYPE_CHANGED = 1 means discard the old varobj, and replace
1589 it with this one. TYPE_CHANGED = 0 means leave it around.
1590 NB: In both cases, var_handle will point to the new varobj,
1591 so if you use TYPE_CHANGED = 0, you will have to stash the
1592 old varobj pointer away somewhere before calling this.
1593 On return, TYPE_CHANGED will be 1 if the type has changed, and
1595 static struct value
*
1596 value_of_root (struct varobj
**var_handle
, int *type_changed
)
1600 if (var_handle
== NULL
)
1605 /* This should really be an exception, since this should
1606 only get called with a root variable. */
1608 if (var
->root
->rootvar
!= var
)
1611 if (var
->root
->use_selected_frame
)
1613 struct varobj
*tmp_var
;
1614 char *old_type
, *new_type
;
1615 old_type
= varobj_get_type (var
);
1616 tmp_var
= varobj_create (NULL
, var
->name
, (CORE_ADDR
) 0,
1617 USE_SELECTED_FRAME
);
1618 if (tmp_var
== NULL
)
1622 new_type
= varobj_get_type (tmp_var
);
1623 if (strcmp (old_type
, new_type
) == 0)
1625 varobj_delete (tmp_var
, NULL
, 0);
1633 savestring (var
->obj_name
, strlen (var
->obj_name
));
1634 varobj_delete (var
, NULL
, 0);
1638 tmp_var
->obj_name
= varobj_gen_name ();
1640 install_variable (tmp_var
);
1641 *var_handle
= tmp_var
;
1651 return (*var
->root
->lang
->value_of_root
) (var_handle
);
1654 /* What is the ``struct value *'' for the INDEX'th child of PARENT? */
1655 static struct value
*
1656 value_of_child (struct varobj
*parent
, int index
)
1658 struct value
*value
;
1660 value
= (*parent
->root
->lang
->value_of_child
) (parent
, index
);
1662 /* If we're being lazy, fetch the real value of the variable. */
1663 if (value
!= NULL
&& VALUE_LAZY (value
))
1665 /* If we fail to fetch the value of the child, return
1666 NULL so that callers notice that we're leaving an
1668 if (!gdb_value_fetch_lazy (value
))
1675 /* What is the type of VAR? */
1676 static struct type
*
1677 type_of_child (struct varobj
*var
)
1680 /* If the child had no evaluation errors, var->value
1681 will be non-NULL and contain a valid type. */
1682 if (var
->value
!= NULL
)
1683 return VALUE_TYPE (var
->value
);
1685 /* Otherwise, we must compute the type. */
1686 return (*var
->root
->lang
->type_of_child
) (var
->parent
, var
->index
);
1689 /* Is this variable editable? Use the variable's type to make
1690 this determination. */
1692 variable_editable (struct varobj
*var
)
1694 return (*var
->root
->lang
->variable_editable
) (var
);
1697 /* GDB already has a command called "value_of_variable". Sigh. */
1699 my_value_of_variable (struct varobj
*var
)
1701 return (*var
->root
->lang
->value_of_variable
) (var
);
1704 /* Is VAR something that can change? Depending on language,
1705 some variable's values never change. For example,
1706 struct and unions never change values. */
1708 type_changeable (struct varobj
*var
)
1713 if (CPLUS_FAKE_CHILD (var
))
1716 type
= get_type (var
);
1718 switch (TYPE_CODE (type
))
1720 case TYPE_CODE_STRUCT
:
1721 case TYPE_CODE_UNION
:
1722 case TYPE_CODE_ARRAY
:
1735 c_number_of_children (struct varobj
*var
)
1738 struct type
*target
;
1741 type
= get_type (var
);
1742 target
= get_target_type (type
);
1745 switch (TYPE_CODE (type
))
1747 case TYPE_CODE_ARRAY
:
1748 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (target
) > 0
1749 && TYPE_ARRAY_UPPER_BOUND_TYPE (type
) != BOUND_CANNOT_BE_DETERMINED
)
1750 children
= TYPE_LENGTH (type
) / TYPE_LENGTH (target
);
1755 case TYPE_CODE_STRUCT
:
1756 case TYPE_CODE_UNION
:
1757 children
= TYPE_NFIELDS (type
);
1761 /* This is where things get compilcated. All pointers have one child.
1762 Except, of course, for struct and union ptr, which we automagically
1763 dereference for the user and function ptrs, which have no children.
1764 We also don't dereference void* as we don't know what to show.
1765 We can show char* so we allow it to be dereferenced. If you decide
1766 to test for it, please mind that a little magic is necessary to
1767 properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
1768 TYPE_NAME == "char" */
1770 switch (TYPE_CODE (target
))
1772 case TYPE_CODE_STRUCT
:
1773 case TYPE_CODE_UNION
:
1774 children
= TYPE_NFIELDS (target
);
1777 case TYPE_CODE_FUNC
:
1778 case TYPE_CODE_VOID
:
1788 /* Other types have no children */
1796 c_name_of_variable (struct varobj
*parent
)
1798 return savestring (parent
->name
, strlen (parent
->name
));
1802 c_name_of_child (struct varobj
*parent
, int index
)
1805 struct type
*target
;
1809 type
= get_type (parent
);
1810 target
= get_target_type (type
);
1812 switch (TYPE_CODE (type
))
1814 case TYPE_CODE_ARRAY
:
1815 xasprintf (&name
, "%d", index
);
1818 case TYPE_CODE_STRUCT
:
1819 case TYPE_CODE_UNION
:
1820 string
= TYPE_FIELD_NAME (type
, index
);
1821 name
= savestring (string
, strlen (string
));
1825 switch (TYPE_CODE (target
))
1827 case TYPE_CODE_STRUCT
:
1828 case TYPE_CODE_UNION
:
1829 string
= TYPE_FIELD_NAME (target
, index
);
1830 name
= savestring (string
, strlen (string
));
1834 xasprintf (&name
, "*%s", parent
->name
);
1840 /* This should not happen */
1841 name
= xstrdup ("???");
1847 static struct value
*
1848 c_value_of_root (struct varobj
**var_handle
)
1850 struct value
*new_val
;
1851 struct varobj
*var
= *var_handle
;
1852 struct frame_info
*fi
;
1855 /* Only root variables can be updated... */
1856 if (var
->root
->rootvar
!= var
)
1857 /* Not a root var */
1861 /* Determine whether the variable is still around. */
1862 if (var
->root
->valid_block
== NULL
)
1866 reinit_frame_cache ();
1867 fi
= frame_find_by_id (var
->root
->frame
);
1868 within_scope
= fi
!= NULL
;
1869 /* FIXME: select_frame could fail */
1876 /* We need to catch errors here, because if evaluate
1877 expression fails we just want to make val->error = 1 and
1879 if (gdb_evaluate_expression (var
->root
->exp
, &new_val
))
1881 if (VALUE_LAZY (new_val
))
1883 /* We need to catch errors because if
1884 value_fetch_lazy fails we still want to continue
1885 (after making val->error = 1) */
1886 /* FIXME: Shouldn't be using VALUE_CONTENTS? The
1887 comment on value_fetch_lazy() says it is only
1888 called from the macro... */
1889 if (!gdb_value_fetch_lazy (new_val
))
1898 release_value (new_val
);
1905 static struct value
*
1906 c_value_of_child (struct varobj
*parent
, int index
)
1908 struct value
*value
;
1910 struct value
*indval
;
1911 struct type
*type
, *target
;
1914 type
= get_type (parent
);
1915 target
= get_target_type (type
);
1916 name
= name_of_child (parent
, index
);
1917 temp
= parent
->value
;
1922 switch (TYPE_CODE (type
))
1924 case TYPE_CODE_ARRAY
:
1926 /* This breaks if the array lives in a (vector) register. */
1927 value
= value_slice (temp
, index
, 1);
1928 temp
= value_coerce_array (value
);
1929 gdb_value_ind (temp
, &value
);
1931 indval
= value_from_longest (builtin_type_int
, (LONGEST
) index
);
1932 gdb_value_subscript (temp
, indval
, &value
);
1936 case TYPE_CODE_STRUCT
:
1937 case TYPE_CODE_UNION
:
1938 gdb_value_struct_elt (NULL
, &value
, &temp
, NULL
, name
, NULL
,
1943 switch (TYPE_CODE (target
))
1945 case TYPE_CODE_STRUCT
:
1946 case TYPE_CODE_UNION
:
1947 gdb_value_struct_elt (NULL
, &value
, &temp
, NULL
, name
, NULL
,
1952 gdb_value_ind (temp
, &value
);
1963 release_value (value
);
1969 static struct type
*
1970 c_type_of_child (struct varobj
*parent
, int index
)
1973 char *name
= name_of_child (parent
, index
);
1975 switch (TYPE_CODE (parent
->type
))
1977 case TYPE_CODE_ARRAY
:
1978 type
= get_target_type (parent
->type
);
1981 case TYPE_CODE_STRUCT
:
1982 case TYPE_CODE_UNION
:
1983 type
= lookup_struct_elt_type (parent
->type
, name
, 0);
1987 switch (TYPE_CODE (get_target_type (parent
->type
)))
1989 case TYPE_CODE_STRUCT
:
1990 case TYPE_CODE_UNION
:
1991 type
= lookup_struct_elt_type (parent
->type
, name
, 0);
1995 type
= get_target_type (parent
->type
);
2001 /* This should not happen as only the above types have children */
2002 warning ("Child of parent whose type does not allow children");
2003 /* FIXME: Can we still go on? */
2013 c_variable_editable (struct varobj
*var
)
2015 switch (TYPE_CODE (get_type (var
)))
2017 case TYPE_CODE_STRUCT
:
2018 case TYPE_CODE_UNION
:
2019 case TYPE_CODE_ARRAY
:
2020 case TYPE_CODE_FUNC
:
2021 case TYPE_CODE_MEMBER
:
2022 case TYPE_CODE_METHOD
:
2033 c_value_of_variable (struct varobj
*var
)
2035 /* BOGUS: if val_print sees a struct/class, it will print out its
2036 children instead of "{...}" */
2038 switch (TYPE_CODE (get_type (var
)))
2040 case TYPE_CODE_STRUCT
:
2041 case TYPE_CODE_UNION
:
2042 return xstrdup ("{...}");
2045 case TYPE_CODE_ARRAY
:
2048 xasprintf (&number
, "[%d]", var
->num_children
);
2055 if (var
->value
== NULL
)
2057 /* This can happen if we attempt to get the value of a struct
2058 member when the parent is an invalid pointer. This is an
2059 error condition, so we should tell the caller. */
2065 struct ui_file
*stb
= mem_fileopen ();
2066 struct cleanup
*old_chain
= make_cleanup_ui_file_delete (stb
);
2069 if (VALUE_LAZY (var
->value
))
2070 gdb_value_fetch_lazy (var
->value
);
2071 val_print (VALUE_TYPE (var
->value
),
2072 VALUE_CONTENTS_RAW (var
->value
), 0,
2073 VALUE_ADDRESS (var
->value
), stb
,
2074 format_code
[(int) var
->format
], 1, 0, 0);
2075 thevalue
= ui_file_xstrdup (stb
, &dummy
);
2076 do_cleanups (old_chain
);
2087 cplus_number_of_children (struct varobj
*var
)
2090 int children
, dont_know
;
2095 if (!CPLUS_FAKE_CHILD (var
))
2097 type
= get_type_deref (var
);
2099 if (((TYPE_CODE (type
)) == TYPE_CODE_STRUCT
) ||
2100 ((TYPE_CODE (type
)) == TYPE_CODE_UNION
))
2104 cplus_class_num_children (type
, kids
);
2105 if (kids
[v_public
] != 0)
2107 if (kids
[v_private
] != 0)
2109 if (kids
[v_protected
] != 0)
2112 /* Add any baseclasses */
2113 children
+= TYPE_N_BASECLASSES (type
);
2116 /* FIXME: save children in var */
2123 type
= get_type_deref (var
->parent
);
2125 cplus_class_num_children (type
, kids
);
2126 if (STREQ (var
->name
, "public"))
2127 children
= kids
[v_public
];
2128 else if (STREQ (var
->name
, "private"))
2129 children
= kids
[v_private
];
2131 children
= kids
[v_protected
];
2136 children
= c_number_of_children (var
);
2141 /* Compute # of public, private, and protected variables in this class.
2142 That means we need to descend into all baseclasses and find out
2143 how many are there, too. */
2145 cplus_class_num_children (struct type
*type
, int children
[3])
2149 children
[v_public
] = 0;
2150 children
[v_private
] = 0;
2151 children
[v_protected
] = 0;
2153 for (i
= TYPE_N_BASECLASSES (type
); i
< TYPE_NFIELDS (type
); i
++)
2155 /* If we have a virtual table pointer, omit it. */
2156 if (TYPE_VPTR_BASETYPE (type
) == type
&& TYPE_VPTR_FIELDNO (type
) == i
)
2159 if (TYPE_FIELD_PROTECTED (type
, i
))
2160 children
[v_protected
]++;
2161 else if (TYPE_FIELD_PRIVATE (type
, i
))
2162 children
[v_private
]++;
2164 children
[v_public
]++;
2169 cplus_name_of_variable (struct varobj
*parent
)
2171 return c_name_of_variable (parent
);
2175 cplus_name_of_child (struct varobj
*parent
, int index
)
2181 if (CPLUS_FAKE_CHILD (parent
))
2183 /* Looking for children of public, private, or protected. */
2184 type
= get_type_deref (parent
->parent
);
2187 type
= get_type_deref (parent
);
2190 switch (TYPE_CODE (type
))
2192 case TYPE_CODE_STRUCT
:
2193 case TYPE_CODE_UNION
:
2194 cplus_class_num_children (type
, children
);
2196 if (CPLUS_FAKE_CHILD (parent
))
2200 /* Skip over vptr, if it exists. */
2201 if (TYPE_VPTR_BASETYPE (type
) == type
2202 && index
>= TYPE_VPTR_FIELDNO (type
))
2205 /* FIXME: This assumes that type orders
2206 inherited, public, private, protected */
2207 i
= index
+ TYPE_N_BASECLASSES (type
);
2208 if (STREQ (parent
->name
, "private")
2209 || STREQ (parent
->name
, "protected"))
2210 i
+= children
[v_public
];
2211 if (STREQ (parent
->name
, "protected"))
2212 i
+= children
[v_private
];
2214 name
= TYPE_FIELD_NAME (type
, i
);
2216 else if (index
< TYPE_N_BASECLASSES (type
))
2217 name
= TYPE_FIELD_NAME (type
, index
);
2220 /* Everything beyond the baseclasses can
2221 only be "public", "private", or "protected" */
2222 index
-= TYPE_N_BASECLASSES (type
);
2226 if (children
[v_public
] != 0)
2232 if (children
[v_private
] != 0)
2238 if (children
[v_protected
] != 0)
2255 return c_name_of_child (parent
, index
);
2259 name
= savestring (name
, strlen (name
));
2265 static struct value
*
2266 cplus_value_of_root (struct varobj
**var_handle
)
2268 return c_value_of_root (var_handle
);
2271 static struct value
*
2272 cplus_value_of_child (struct varobj
*parent
, int index
)
2275 struct value
*value
;
2277 if (CPLUS_FAKE_CHILD (parent
))
2278 type
= get_type_deref (parent
->parent
);
2280 type
= get_type_deref (parent
);
2284 if (((TYPE_CODE (type
)) == TYPE_CODE_STRUCT
) ||
2285 ((TYPE_CODE (type
)) == TYPE_CODE_UNION
))
2287 if (CPLUS_FAKE_CHILD (parent
))
2290 struct value
*temp
= parent
->parent
->value
;
2295 name
= name_of_child (parent
, index
);
2296 gdb_value_struct_elt (NULL
, &value
, &temp
, NULL
, name
, NULL
,
2299 release_value (value
);
2303 else if (index
>= TYPE_N_BASECLASSES (type
))
2305 /* public, private, or protected */
2311 if (parent
->value
!= NULL
)
2313 struct value
*temp
= NULL
;
2315 if (TYPE_CODE (VALUE_TYPE (parent
->value
)) == TYPE_CODE_PTR
2316 || TYPE_CODE (VALUE_TYPE (parent
->value
)) == TYPE_CODE_REF
)
2318 if (!gdb_value_ind (parent
->value
, &temp
))
2322 temp
= parent
->value
;
2326 value
= value_cast (TYPE_FIELD_TYPE (type
, index
), temp
);
2327 release_value (value
);
2331 /* We failed to evaluate the parent's value, so don't even
2332 bother trying to evaluate this child. */
2340 return c_value_of_child (parent
, index
);
2345 static struct type
*
2346 cplus_type_of_child (struct varobj
*parent
, int index
)
2348 struct type
*type
, *t
;
2350 if (CPLUS_FAKE_CHILD (parent
))
2352 /* Looking for the type of a child of public, private, or protected. */
2353 t
= get_type_deref (parent
->parent
);
2356 t
= get_type_deref (parent
);
2359 switch (TYPE_CODE (t
))
2361 case TYPE_CODE_STRUCT
:
2362 case TYPE_CODE_UNION
:
2363 if (CPLUS_FAKE_CHILD (parent
))
2365 char *name
= cplus_name_of_child (parent
, index
);
2366 type
= lookup_struct_elt_type (t
, name
, 0);
2369 else if (index
< TYPE_N_BASECLASSES (t
))
2370 type
= TYPE_FIELD_TYPE (t
, index
);
2383 return c_type_of_child (parent
, index
);
2389 cplus_variable_editable (struct varobj
*var
)
2391 if (CPLUS_FAKE_CHILD (var
))
2394 return c_variable_editable (var
);
2398 cplus_value_of_variable (struct varobj
*var
)
2401 /* If we have one of our special types, don't print out
2403 if (CPLUS_FAKE_CHILD (var
))
2404 return xstrdup ("");
2406 return c_value_of_variable (var
);
2412 java_number_of_children (struct varobj
*var
)
2414 return cplus_number_of_children (var
);
2418 java_name_of_variable (struct varobj
*parent
)
2422 name
= cplus_name_of_variable (parent
);
2423 /* If the name has "-" in it, it is because we
2424 needed to escape periods in the name... */
2427 while (*p
!= '\000')
2438 java_name_of_child (struct varobj
*parent
, int index
)
2442 name
= cplus_name_of_child (parent
, index
);
2443 /* Escape any periods in the name... */
2446 while (*p
!= '\000')
2456 static struct value
*
2457 java_value_of_root (struct varobj
**var_handle
)
2459 return cplus_value_of_root (var_handle
);
2462 static struct value
*
2463 java_value_of_child (struct varobj
*parent
, int index
)
2465 return cplus_value_of_child (parent
, index
);
2468 static struct type
*
2469 java_type_of_child (struct varobj
*parent
, int index
)
2471 return cplus_type_of_child (parent
, index
);
2475 java_variable_editable (struct varobj
*var
)
2477 return cplus_variable_editable (var
);
2481 java_value_of_variable (struct varobj
*var
)
2483 return cplus_value_of_variable (var
);
2486 extern void _initialize_varobj (void);
2488 _initialize_varobj (void)
2490 int sizeof_table
= sizeof (struct vlist
*) * VAROBJ_TABLE_SIZE
;
2492 varobj_table
= xmalloc (sizeof_table
);
2493 memset (varobj_table
, 0, sizeof_table
);
2495 add_show_from_set (add_set_cmd ("debugvarobj", class_maintenance
, var_zinteger
, (char *) &varobjdebug
, "Set varobj debugging.\n\
2496 When non-zero, varobj debugging is enabled.", &setlist
),