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"
30 /* Non-zero if we want to see trace of varobj level stuff. */
34 /* String representations of gdb's format codes */
35 char *varobj_format_string
[] =
36 {"natural", "binary", "decimal", "hexadecimal", "octal"};
38 /* String representations of gdb's known languages */
39 char *varobj_language_string
[] =
40 {"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 */
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
;
116 /* Every variable keeps a linked list of its children, described
117 by the following structure. */
118 /* FIXME: Deprecated. All should use vlist instead */
123 /* Pointer to the child's data */
124 struct varobj
*child
;
126 /* Pointer to the next child */
127 struct varobj_child
*next
;
130 /* A stack of varobjs */
131 /* FIXME: Deprecated. All should use vlist instead */
142 struct cpstack
*next
;
145 /* A list of varobjs */
153 /* Private function prototypes */
155 /* Helper functions for the above subcommands. */
157 static int delete_variable (struct cpstack
**, struct varobj
*, int);
159 static void delete_variable_1 (struct cpstack
**, int *,
160 struct varobj
*, int, int);
162 static int install_variable (struct varobj
*);
164 static void uninstall_variable (struct varobj
*);
166 static struct varobj
*child_exists (struct varobj
*, char *);
168 static struct varobj
*create_child (struct varobj
*, int, char *);
170 static void save_child_in_parent (struct varobj
*, struct varobj
*);
172 static void remove_child_from_parent (struct varobj
*, struct varobj
*);
174 /* Utility routines */
176 static struct varobj
*new_variable (void);
178 static struct varobj
*new_root_variable (void);
180 static void free_variable (struct varobj
*var
);
182 static struct cleanup
*make_cleanup_free_variable (struct varobj
*var
);
184 static struct type
*get_type (struct varobj
*var
);
186 static struct type
*get_type_deref (struct varobj
*var
);
188 static struct type
*get_target_type (struct type
*);
190 static enum varobj_display_formats
variable_default_display (struct varobj
*);
192 static int my_value_equal (value_ptr
, value_ptr
, int *);
194 static void vpush (struct vstack
**pstack
, struct varobj
*var
);
196 static struct varobj
*vpop (struct vstack
**pstack
);
198 static void cppush (struct cpstack
**pstack
, char *name
);
200 static char *cppop (struct cpstack
**pstack
);
202 /* Language-specific routines. */
204 static enum varobj_languages
variable_language (struct varobj
*var
);
206 static int number_of_children (struct varobj
*);
208 static char *name_of_variable (struct varobj
*);
210 static char *name_of_child (struct varobj
*, int);
212 static value_ptr
value_of_root (struct varobj
**var_handle
, int *);
214 static value_ptr
value_of_child (struct varobj
*parent
, int index
);
216 static struct type
*type_of_child (struct varobj
*var
);
218 static int variable_editable (struct varobj
*var
);
220 static char *my_value_of_variable (struct varobj
*var
);
222 static int type_changeable (struct varobj
*var
);
224 /* C implementation */
226 static int c_number_of_children (struct varobj
*var
);
228 static char *c_name_of_variable (struct varobj
*parent
);
230 static char *c_name_of_child (struct varobj
*parent
, int index
);
232 static value_ptr
c_value_of_root (struct varobj
**var_handle
);
234 static value_ptr
c_value_of_child (struct varobj
*parent
, int index
);
236 static struct type
*c_type_of_child (struct varobj
*parent
, int index
);
238 static int c_variable_editable (struct varobj
*var
);
240 static char *c_value_of_variable (struct varobj
*var
);
242 /* C++ implementation */
244 static int cplus_number_of_children (struct varobj
*var
);
246 static void cplus_class_num_children (struct type
*type
, int children
[3]);
248 static char *cplus_name_of_variable (struct varobj
*parent
);
250 static char *cplus_name_of_child (struct varobj
*parent
, int index
);
252 static value_ptr
cplus_value_of_root (struct varobj
**var_handle
);
254 static value_ptr
cplus_value_of_child (struct varobj
*parent
, int index
);
256 static struct type
*cplus_type_of_child (struct varobj
*parent
, int index
);
258 static int cplus_variable_editable (struct varobj
*var
);
260 static char *cplus_value_of_variable (struct varobj
*var
);
262 /* Java implementation */
264 static int java_number_of_children (struct varobj
*var
);
266 static char *java_name_of_variable (struct varobj
*parent
);
268 static char *java_name_of_child (struct varobj
*parent
, int index
);
270 static value_ptr
java_value_of_root (struct varobj
**var_handle
);
272 static value_ptr
java_value_of_child (struct varobj
*parent
, int index
);
274 static struct type
*java_type_of_child (struct varobj
*parent
, int index
);
276 static int java_variable_editable (struct varobj
*var
);
278 static char *java_value_of_variable (struct varobj
*var
);
280 /* The language specific vector */
282 struct language_specific
285 /* The language of this variable */
286 enum varobj_languages language
;
288 /* The number of children of PARENT. */
289 int (*number_of_children
) (struct varobj
* parent
);
291 /* The name (expression) of a root varobj. */
292 char *(*name_of_variable
) (struct varobj
* parent
);
294 /* The name of the INDEX'th child of PARENT. */
295 char *(*name_of_child
) (struct varobj
* parent
, int index
);
297 /* The value_ptr of the root variable ROOT. */
298 value_ptr (*value_of_root
) (struct varobj
** root_handle
);
300 /* The value_ptr of the INDEX'th child of PARENT. */
301 value_ptr (*value_of_child
) (struct varobj
* parent
, int index
);
303 /* The type of the INDEX'th child of PARENT. */
304 struct type
*(*type_of_child
) (struct varobj
* parent
, int index
);
306 /* Is VAR editable? */
307 int (*variable_editable
) (struct varobj
* var
);
309 /* The current value of VAR. */
310 char *(*value_of_variable
) (struct varobj
* var
);
313 /* Array of known source language routines. */
314 static struct language_specific
315 languages
[vlang_end
][sizeof (struct language_specific
)] =
317 /* Unknown (try treating as C */
320 c_number_of_children
,
333 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
359 java_number_of_children
,
360 java_name_of_variable
,
365 java_variable_editable
,
366 java_value_of_variable
370 /* A little convenience enum for dealing with C++/Java */
373 v_public
= 0, v_private
, v_protected
378 /* Mappings of varobj_display_formats enums to gdb's format codes */
379 static int format_code
[] =
380 {0, 't', 'd', 'x', 'o'};
382 /* Header of the list of root variable objects */
383 static struct varobj_root
*rootlist
;
384 static int rootcount
= 0; /* number of root varobjs in the list */
386 /* Prime number indicating the number of buckets in the hash table */
387 /* A prime large enough to avoid too many colisions */
388 #define VAROBJ_TABLE_SIZE 227
390 /* Pointer to the varobj hash table (built at run time) */
391 static struct vlist
**varobj_table
;
393 /* Is the variable X one of our "fake" children? */
394 #define CPLUS_FAKE_CHILD(x) \
395 ((x) != NULL && (x)->type == NULL && (x)->value == NULL)
398 /* API Implementation */
400 /* Creates a varobj (not its children) */
403 varobj_create (char *objname
,
404 char *expression
, CORE_ADDR frame
,
405 enum varobj_type type
)
408 struct frame_info
*fi
;
409 struct frame_info
*old_fi
= NULL
;
411 struct cleanup
*old_chain
;
413 /* Fill out a varobj structure for the (root) variable being constructed. */
414 var
= new_root_variable ();
415 old_chain
= make_cleanup_free_variable (var
);
417 if (expression
!= NULL
)
420 enum varobj_languages lang
;
422 /* Parse and evaluate the expression, filling in as much
423 of the variable's data as possible */
425 /* Allow creator to specify context of variable */
426 if ((type
== USE_CURRENT_FRAME
)
427 || (type
== USE_SELECTED_FRAME
))
430 fi
= find_frame_addr_in_frame_chain (frame
);
432 /* frame = -2 means always use selected frame */
433 if (type
== USE_SELECTED_FRAME
)
434 var
->root
->use_selected_frame
= 1;
438 block
= get_frame_block (fi
);
441 innermost_block
= NULL
;
442 /* Wrap the call to parse expression, so we can
443 return a sensible error. */
444 if (!gdb_parse_exp_1 (&p
, block
, 0, &var
->root
->exp
))
449 /* Don't allow variables to be created for types. */
450 if (var
->root
->exp
->elts
[0].opcode
== OP_TYPE
)
452 do_cleanups (old_chain
);
453 fprintf_unfiltered (gdb_stderr
,
454 "Attempt to use a type name as an expression.");
458 var
->format
= variable_default_display (var
);
459 var
->root
->valid_block
= innermost_block
;
460 var
->name
= savestring (expression
, strlen (expression
));
462 /* When the frame is different from the current frame,
463 we must select the appropriate frame before parsing
464 the expression, otherwise the value will not be current.
465 Since select_frame is so benign, just call it for all cases. */
468 var
->root
->frame
= FRAME_FP (fi
);
469 old_fi
= selected_frame
;
470 select_frame (fi
, -1);
473 /* We definitively need to catch errors here.
474 If evaluate_expression succeeds we got the value we wanted.
475 But if it fails, we still go on with a call to evaluate_type() */
476 if (gdb_evaluate_expression (var
->root
->exp
, &var
->value
))
479 release_value (var
->value
);
480 if (VALUE_LAZY (var
->value
))
481 gdb_value_fetch_lazy (var
->value
);
484 var
->value
= evaluate_type (var
->root
->exp
);
486 var
->type
= VALUE_TYPE (var
->value
);
488 /* Set language info */
489 lang
= variable_language (var
);
490 var
->root
->lang
= languages
[lang
];
492 /* Set ourselves as our root */
493 var
->root
->rootvar
= var
;
495 /* Reset the selected frame */
497 select_frame (old_fi
, -1);
500 /* If the variable object name is null, that means this
501 is a temporary variable, so don't install it. */
503 if ((var
!= NULL
) && (objname
!= NULL
))
505 var
->obj_name
= savestring (objname
, strlen (objname
));
507 /* If a varobj name is duplicated, the install will fail so
509 if (!install_variable (var
))
511 do_cleanups (old_chain
);
516 discard_cleanups (old_chain
);
520 /* Generates an unique name that can be used for a varobj */
523 varobj_gen_name (void)
528 /* generate a name for this object */
530 sprintf (obj_name
, "var%d", id
);
532 return xstrdup (obj_name
);
535 /* Given an "objname", returns the pointer to the corresponding varobj
536 or NULL if not found */
539 varobj_get_handle (char *objname
)
543 unsigned int index
= 0;
546 for (chp
= objname
; *chp
; chp
++)
548 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
551 cv
= *(varobj_table
+ index
);
552 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, objname
) != 0))
556 error ("Variable object not found");
561 /* Given the handle, return the name of the object */
564 varobj_get_objname (struct varobj
*var
)
566 return var
->obj_name
;
569 /* Given the handle, return the expression represented by the object */
572 varobj_get_expression (struct varobj
*var
)
574 return name_of_variable (var
);
577 /* Deletes a varobj and all its children if only_children == 0,
578 otherwise deletes only the children; returns a malloc'ed list of all the
579 (malloc'ed) names of the variables that have been deleted (NULL terminated) */
582 varobj_delete (struct varobj
*var
, char ***dellist
, int only_children
)
586 struct cpstack
*result
= NULL
;
589 /* Initialize a stack for temporary results */
590 cppush (&result
, NULL
);
593 /* Delete only the variable children */
594 delcount
= delete_variable (&result
, var
, 1 /* only the children */ );
596 /* Delete the variable and all its children */
597 delcount
= delete_variable (&result
, var
, 0 /* parent+children */ );
599 /* We may have been asked to return a list of what has been deleted */
602 *dellist
= xmalloc ((delcount
+ 1) * sizeof (char *));
606 *cp
= cppop (&result
);
607 while ((*cp
!= NULL
) && (mycount
> 0))
611 *cp
= cppop (&result
);
614 if (mycount
|| (*cp
!= NULL
))
615 warning ("varobj_delete: assertion failed - mycount(=%d) <> 0", mycount
);
621 /* Set/Get variable object display format */
623 enum varobj_display_formats
624 varobj_set_display_format (struct varobj
*var
,
625 enum varobj_display_formats format
)
632 case FORMAT_HEXADECIMAL
:
634 var
->format
= format
;
638 var
->format
= variable_default_display (var
);
644 enum varobj_display_formats
645 varobj_get_display_format (struct varobj
*var
)
651 varobj_get_num_children (struct varobj
*var
)
653 if (var
->num_children
== -1)
654 var
->num_children
= number_of_children (var
);
656 return var
->num_children
;
659 /* Creates a list of the immediate children of a variable object;
660 the return code is the number of such children or -1 on error */
663 varobj_list_children (struct varobj
*var
, struct varobj
***childlist
)
665 struct varobj
*child
;
669 /* sanity check: have we been passed a pointer? */
670 if (childlist
== NULL
)
675 if (var
->num_children
== -1)
676 var
->num_children
= number_of_children (var
);
678 /* List of children */
679 *childlist
= xmalloc ((var
->num_children
+ 1) * sizeof (struct varobj
*));
681 for (i
= 0; i
< var
->num_children
; i
++)
683 /* Mark as the end in case we bail out */
684 *((*childlist
) + i
) = NULL
;
686 /* check if child exists, if not create */
687 name
= name_of_child (var
, i
);
688 child
= child_exists (var
, name
);
690 child
= create_child (var
, i
, name
);
692 *((*childlist
) + i
) = child
;
695 /* End of list is marked by a NULL pointer */
696 *((*childlist
) + i
) = NULL
;
698 return var
->num_children
;
701 /* Obtain the type of an object Variable as a string similar to the one gdb
702 prints on the console */
705 varobj_get_type (struct varobj
*var
)
708 struct cleanup
*old_chain
;
713 /* For the "fake" variables, do not return a type. (It's type is
715 if (CPLUS_FAKE_CHILD (var
))
718 stb
= mem_fileopen ();
719 old_chain
= make_cleanup_ui_file_delete (stb
);
721 /* To print the type, we simply create a zero value_ptr and
722 cast it to our type. We then typeprint this variable. */
723 val
= value_zero (var
->type
, not_lval
);
724 type_print (VALUE_TYPE (val
), "", stb
, -1);
726 thetype
= ui_file_xstrdup (stb
, &length
);
727 do_cleanups (old_chain
);
731 enum varobj_languages
732 varobj_get_language (struct varobj
*var
)
734 return variable_language (var
);
738 varobj_get_attributes (struct varobj
*var
)
742 if (variable_editable (var
))
743 /* FIXME: define masks for attributes */
744 attributes
|= 0x00000001; /* Editable */
750 varobj_get_value (struct varobj
*var
)
752 return my_value_of_variable (var
);
755 /* Set the value of an object variable (if it is editable) to the
756 value of the given expression */
757 /* Note: Invokes functions that can call error() */
760 varobj_set_value (struct varobj
*var
, char *expression
)
765 /* The argument "expression" contains the variable's new value.
766 We need to first construct a legal expression for this -- ugh! */
767 /* Does this cover all the bases? */
768 struct expression
*exp
;
770 int saved_input_radix
= input_radix
;
772 if (variable_editable (var
) && !var
->error
)
774 char *s
= expression
;
778 input_radix
= 10; /* ALWAYS reset to decimal temporarily */
779 if (!gdb_parse_exp_1 (&s
, 0, 0, &exp
))
780 /* We cannot proceed without a well-formed expression. */
782 if (!gdb_evaluate_expression (exp
, &value
))
784 /* We cannot proceed without a valid expression. */
789 /* If our parent is "public", "private", or "protected", we could
790 be asking to modify the value of a baseclass. If so, we need to
791 adjust our address by the offset of our baseclass in the subclass,
792 since VALUE_ADDRESS (var->value) points at the start of the subclass.
793 For some reason, value_cast doesn't take care of this properly. */
795 if (var
->parent
!= NULL
&& CPLUS_FAKE_CHILD (var
->parent
))
797 struct varobj
*super
, *sub
;
799 super
= var
->parent
->parent
;
803 /* Yes, it is a baseclass */
804 type
= get_type_deref (sub
);
806 if (super
->index
< TYPE_N_BASECLASSES (type
))
808 temp
= value_copy (var
->value
);
809 for (i
= 0; i
< super
->index
; i
++)
810 offset
+= TYPE_LENGTH (TYPE_FIELD_TYPE (type
, i
));
815 VALUE_ADDRESS (temp
) += offset
;
816 if (!gdb_value_assign (temp
, value
, &val
))
818 VALUE_ADDRESS (val
) -= offset
;
819 value_free (var
->value
);
822 input_radix
= saved_input_radix
;
829 /* Returns a malloc'ed list with all root variable objects */
831 varobj_list (struct varobj
***varlist
)
834 struct varobj_root
*croot
;
835 int mycount
= rootcount
;
837 /* Alloc (rootcount + 1) entries for the result */
838 *varlist
= xmalloc ((rootcount
+ 1) * sizeof (struct varobj
*));
842 while ((croot
!= NULL
) && (mycount
> 0))
844 *cv
= croot
->rootvar
;
849 /* Mark the end of the list */
852 if (mycount
|| (croot
!= NULL
))
853 warning ("varobj_list: assertion failed - wrong tally of root vars (%d:%d)",
859 /* Update the values for a variable and its children. This is a
860 two-pronged attack. First, re-parse the value for the root's
861 expression to see if it's changed. Then go all the way
862 through its children, reconstructing them and noting if they've
865 -1 if there was an error updating the varobj
866 -2 if the type changed
867 Otherwise it is the number of children + parent changed
869 Only root variables can be updated...
871 NOTE: This function may delete the caller's varobj. If it
872 returns -2, then it has done this and VARP will be modified
873 to point to the new varobj. */
876 varobj_update (struct varobj
**varp
, struct varobj
***changelist
)
885 struct varobj
**templist
= NULL
;
887 struct vstack
*stack
= NULL
;
888 struct vstack
*result
= NULL
;
889 struct frame_info
*old_fi
;
891 /* sanity check: have we been passed a pointer? */
892 if (changelist
== NULL
)
895 /* Only root variables can be updated... */
896 if ((*varp
)->root
->rootvar
!= *varp
)
900 /* Save the selected stack frame, since we will need to change it
901 in order to evaluate expressions. */
902 old_fi
= selected_frame
;
904 /* Update the root variable. value_of_root can return NULL
905 if the variable is no longer around, i.e. we stepped out of
906 the frame in which a local existed. We are letting the
907 value_of_root variable dispose of the varobj if the type
910 new = value_of_root (varp
, &type_changed
);
917 /* Initialize a stack for temporary results */
918 vpush (&result
, NULL
);
920 /* If this is a "use_selected_frame" varobj, and its type has changed,
921 them note that it's changed. */
924 vpush (&result
, *varp
);
927 /* If values are not equal, note that it's changed.
928 There a couple of exceptions here, though.
929 We don't want some types to be reported as "changed". */
930 else if (type_changeable (*varp
) && !my_value_equal ((*varp
)->value
, new, &error2
))
932 vpush (&result
, *varp
);
934 /* error2 replaces var->error since this new value
935 WILL replace the old one. */
936 (*varp
)->error
= error2
;
939 /* We must always keep around the new value for this root
940 variable expression, or we lose the updated children! */
941 value_free ((*varp
)->value
);
942 (*varp
)->value
= new;
944 /* Initialize a stack */
945 vpush (&stack
, NULL
);
947 /* Push the root's children */
948 if ((*varp
)->children
!= NULL
)
950 struct varobj_child
*c
;
951 for (c
= (*varp
)->children
; c
!= NULL
; c
= c
->next
)
952 vpush (&stack
, c
->child
);
955 /* Walk through the children, reconstructing them all. */
959 /* Push any children */
960 if (v
->children
!= NULL
)
962 struct varobj_child
*c
;
963 for (c
= v
->children
; c
!= NULL
; c
= c
->next
)
964 vpush (&stack
, c
->child
);
967 /* Update this variable */
968 new = value_of_child (v
->parent
, v
->index
);
969 if (type_changeable (v
) && !my_value_equal (v
->value
, new, &error2
))
971 /* Note that it's changed */
975 /* error2 replaces v->error since this new value
976 WILL replace the old one. */
979 /* We must always keep new values, since children depend on it. */
980 if (v
->value
!= NULL
)
981 value_free (v
->value
);
988 /* Alloc (changed + 1) list entries */
989 /* FIXME: add a cleanup for the allocated list(s)
990 because one day the select_frame called below can longjump */
991 *changelist
= xmalloc ((changed
+ 1) * sizeof (struct varobj
*));
994 templist
= xmalloc ((changed
+ 1) * sizeof (struct varobj
*));
1000 /* Copy from result stack to list */
1002 *cv
= vpop (&result
);
1003 while ((*cv
!= NULL
) && (vleft
> 0))
1007 *cv
= vpop (&result
);
1010 warning ("varobj_update: assertion failed - vleft <> 0");
1014 /* Now we revert the order. */
1015 for (i
=0; i
< changed
; i
++)
1016 *(*changelist
+ i
) = *(templist
+ changed
-1 - i
);
1017 *(*changelist
+ changed
) = NULL
;
1020 /* Restore selected frame */
1021 select_frame (old_fi
, -1);
1030 /* Helper functions */
1033 * Variable object construction/destruction
1037 delete_variable (struct cpstack
**resultp
, struct varobj
*var
,
1038 int only_children_p
)
1042 delete_variable_1 (resultp
, &delcount
, var
,
1043 only_children_p
, 1 /* remove_from_parent_p */ );
1048 /* Delete the variable object VAR and its children */
1049 /* IMPORTANT NOTE: If we delete a variable which is a child
1050 and the parent is not removed we dump core. It must be always
1051 initially called with remove_from_parent_p set */
1053 delete_variable_1 (struct cpstack
**resultp
, int *delcountp
, struct varobj
*var
,
1054 int only_children_p
, int remove_from_parent_p
)
1056 struct varobj_child
*vc
;
1057 struct varobj_child
*next
;
1059 /* Delete any children of this variable, too. */
1060 for (vc
= var
->children
; vc
!= NULL
; vc
= next
)
1062 if (!remove_from_parent_p
)
1063 vc
->child
->parent
= NULL
;
1064 delete_variable_1 (resultp
, delcountp
, vc
->child
, 0, only_children_p
);
1069 /* if we were called to delete only the children we are done here */
1070 if (only_children_p
)
1073 /* Otherwise, add it to the list of deleted ones and proceed to do so */
1074 /* If the name is null, this is a temporary variable, that has not
1075 yet been installed, don't report it, it belongs to the caller... */
1076 if (var
->obj_name
!= NULL
)
1078 cppush (resultp
, xstrdup (var
->obj_name
));
1079 *delcountp
= *delcountp
+ 1;
1082 /* If this variable has a parent, remove it from its parent's list */
1083 /* OPTIMIZATION: if the parent of this variable is also being deleted,
1084 (as indicated by remove_from_parent_p) we don't bother doing an
1085 expensive list search to find the element to remove when we are
1086 discarding the list afterwards */
1087 if ((remove_from_parent_p
) &&
1088 (var
->parent
!= NULL
))
1090 remove_child_from_parent (var
->parent
, var
);
1093 if (var
->obj_name
!= NULL
)
1094 uninstall_variable (var
);
1096 /* Free memory associated with this variable */
1097 free_variable (var
);
1100 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
1102 install_variable (struct varobj
*var
)
1105 struct vlist
*newvl
;
1107 unsigned int index
= 0;
1110 for (chp
= var
->obj_name
; *chp
; chp
++)
1112 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
1115 cv
= *(varobj_table
+ index
);
1116 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
1120 error ("Duplicate variable object name");
1122 /* Add varobj to hash table */
1123 newvl
= xmalloc (sizeof (struct vlist
));
1124 newvl
->next
= *(varobj_table
+ index
);
1126 *(varobj_table
+ index
) = newvl
;
1128 /* If root, add varobj to root list */
1129 if (var
->root
->rootvar
== var
)
1131 /* Add to list of root variables */
1132 if (rootlist
== NULL
)
1133 var
->root
->next
= NULL
;
1135 var
->root
->next
= rootlist
;
1136 rootlist
= var
->root
;
1143 /* Unistall the object VAR. */
1145 uninstall_variable (struct varobj
*var
)
1149 struct varobj_root
*cr
;
1150 struct varobj_root
*prer
;
1152 unsigned int index
= 0;
1155 /* Remove varobj from hash table */
1156 for (chp
= var
->obj_name
; *chp
; chp
++)
1158 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
1161 cv
= *(varobj_table
+ index
);
1163 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
1170 fprintf_unfiltered (gdb_stdlog
, "Deleting %s\n", var
->obj_name
);
1174 warning ("Assertion failed: Could not find variable object \"%s\" to delete", var
->obj_name
);
1179 *(varobj_table
+ index
) = cv
->next
;
1181 prev
->next
= cv
->next
;
1185 /* If root, remove varobj from root list */
1186 if (var
->root
->rootvar
== var
)
1188 /* Remove from list of root variables */
1189 if (rootlist
== var
->root
)
1190 rootlist
= var
->root
->next
;
1195 while ((cr
!= NULL
) && (cr
->rootvar
!= var
))
1202 warning ("Assertion failed: Could not find varobj \"%s\" in root list", var
->obj_name
);
1208 prer
->next
= cr
->next
;
1215 /* Does a child with the name NAME exist in VAR? If so, return its data.
1216 If not, return NULL. */
1217 static struct varobj
*
1218 child_exists (struct varobj
*var
, char *name
)
1220 struct varobj_child
*vc
;
1222 for (vc
= var
->children
; vc
!= NULL
; vc
= vc
->next
)
1224 if (STREQ (vc
->child
->name
, name
))
1231 /* Create and install a child of the parent of the given name */
1232 static struct varobj
*
1233 create_child (struct varobj
*parent
, int index
, char *name
)
1235 struct varobj
*child
;
1238 child
= new_variable ();
1240 /* name is allocated by name_of_child */
1242 child
->index
= index
;
1243 child
->value
= value_of_child (parent
, index
);
1244 if (child
->value
== NULL
|| parent
->error
)
1246 child
->parent
= parent
;
1247 child
->root
= parent
->root
;
1248 childs_name
= (char *) xmalloc ((strlen (parent
->obj_name
) + strlen (name
) + 2)
1250 sprintf (childs_name
, "%s.%s", parent
->obj_name
, name
);
1251 child
->obj_name
= childs_name
;
1252 install_variable (child
);
1254 /* Save a pointer to this child in the parent */
1255 save_child_in_parent (parent
, child
);
1257 /* Note the type of this child */
1258 child
->type
= type_of_child (child
);
1263 /* FIXME: This should be a generic add to list */
1264 /* Save CHILD in the PARENT's data. */
1266 save_child_in_parent (struct varobj
*parent
, struct varobj
*child
)
1268 struct varobj_child
*vc
;
1270 /* Insert the child at the top */
1271 vc
= parent
->children
;
1273 (struct varobj_child
*) xmalloc (sizeof (struct varobj_child
));
1275 parent
->children
->next
= vc
;
1276 parent
->children
->child
= child
;
1279 /* FIXME: This should be a generic remove from list */
1280 /* Remove the CHILD from the PARENT's list of children. */
1282 remove_child_from_parent (struct varobj
*parent
, struct varobj
*child
)
1284 struct varobj_child
*vc
, *prev
;
1286 /* Find the child in the parent's list */
1288 for (vc
= parent
->children
; vc
!= NULL
;)
1290 if (vc
->child
== child
)
1297 parent
->children
= vc
->next
;
1299 prev
->next
= vc
->next
;
1305 * Miscellaneous utility functions.
1308 /* Allocate memory and initialize a new variable */
1309 static struct varobj
*
1314 var
= (struct varobj
*) xmalloc (sizeof (struct varobj
));
1316 var
->obj_name
= NULL
;
1321 var
->num_children
= -1;
1323 var
->children
= NULL
;
1330 /* Allocate memory and initialize a new root variable */
1331 static struct varobj
*
1332 new_root_variable (void)
1334 struct varobj
*var
= new_variable ();
1335 var
->root
= (struct varobj_root
*) xmalloc (sizeof (struct varobj_root
));;
1336 var
->root
->lang
= NULL
;
1337 var
->root
->exp
= NULL
;
1338 var
->root
->valid_block
= NULL
;
1339 var
->root
->frame
= (CORE_ADDR
) -1;
1340 var
->root
->use_selected_frame
= 0;
1341 var
->root
->rootvar
= NULL
;
1346 /* Free any allocated memory associated with VAR. */
1348 free_variable (struct varobj
*var
)
1350 /* Free the expression if this is a root variable. */
1351 if (var
->root
->rootvar
== var
)
1353 free_current_contents ((char **) &var
->root
->exp
);
1358 xfree (var
->obj_name
);
1363 do_free_variable_cleanup (void *var
)
1365 free_variable (var
);
1368 static struct cleanup
*
1369 make_cleanup_free_variable (struct varobj
*var
)
1371 return make_cleanup (do_free_variable_cleanup
, var
);
1374 /* This returns the type of the variable. This skips past typedefs
1375 and returns the real type of the variable. It also dereferences
1376 pointers and references. */
1377 static struct type
*
1378 get_type (struct varobj
*var
)
1383 while (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1384 type
= TYPE_TARGET_TYPE (type
);
1389 /* This returns the type of the variable, dereferencing pointers, too. */
1390 static struct type
*
1391 get_type_deref (struct varobj
*var
)
1395 type
= get_type (var
);
1397 if (type
!= NULL
&& (TYPE_CODE (type
) == TYPE_CODE_PTR
1398 || TYPE_CODE (type
) == TYPE_CODE_REF
))
1399 type
= get_target_type (type
);
1404 /* This returns the target type (or NULL) of TYPE, also skipping
1405 past typedefs, just like get_type (). */
1406 static struct type
*
1407 get_target_type (struct type
*type
)
1411 type
= TYPE_TARGET_TYPE (type
);
1412 while (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1413 type
= TYPE_TARGET_TYPE (type
);
1419 /* What is the default display for this variable? We assume that
1420 everything is "natural". Any exceptions? */
1421 static enum varobj_display_formats
1422 variable_default_display (struct varobj
*var
)
1424 return FORMAT_NATURAL
;
1427 /* This function is similar to gdb's value_equal, except that this
1428 one is "safe" -- it NEVER longjmps. It determines if the VAR's
1429 value is the same as VAL2. */
1431 my_value_equal (value_ptr val1
, value_ptr val2
, int *error2
)
1436 /* Special case: NULL values. If both are null, say
1438 if (val1
== NULL
&& val2
== NULL
)
1440 else if (val1
== NULL
|| val2
== NULL
)
1443 /* This is bogus, but unfortunately necessary. We must know
1444 exactly what caused an error -- reading val1 or val2 -- so
1445 that we can really determine if we think that something has changed. */
1448 /* We do need to catch errors here because the whole purpose
1449 is to test if value_equal() has errored */
1450 if (!gdb_value_equal (val1
, val1
, &r
))
1453 if (!gdb_value_equal (val2
, val2
, &r
))
1459 if (!gdb_value_equal (val1
, val2
, &r
))
1461 /* An error occurred, this could have happened if
1462 either val1 or val2 errored. ERR1 and ERR2 tell
1463 us which of these it is. If both errored, then
1464 we assume nothing has changed. If one of them is
1465 valid, though, then something has changed. */
1468 /* both the old and new values caused errors, so
1469 we say the value did not change */
1470 /* This is indeterminate, though. Perhaps we should
1471 be safe and say, yes, it changed anyway?? */
1483 /* FIXME: The following should be generic for any pointer */
1485 vpush (struct vstack
**pstack
, struct varobj
*var
)
1489 s
= (struct vstack
*) xmalloc (sizeof (struct vstack
));
1495 /* FIXME: The following should be generic for any pointer */
1496 static struct varobj
*
1497 vpop (struct vstack
**pstack
)
1502 if ((*pstack
)->var
== NULL
&& (*pstack
)->next
== NULL
)
1507 *pstack
= (*pstack
)->next
;
1513 /* FIXME: The following should be generic for any pointer */
1515 cppush (struct cpstack
**pstack
, char *name
)
1519 s
= (struct cpstack
*) xmalloc (sizeof (struct cpstack
));
1525 /* FIXME: The following should be generic for any pointer */
1527 cppop (struct cpstack
**pstack
)
1532 if ((*pstack
)->name
== NULL
&& (*pstack
)->next
== NULL
)
1537 *pstack
= (*pstack
)->next
;
1544 * Language-dependencies
1547 /* Common entry points */
1549 /* Get the language of variable VAR. */
1550 static enum varobj_languages
1551 variable_language (struct varobj
*var
)
1553 enum varobj_languages lang
;
1555 switch (var
->root
->exp
->language_defn
->la_language
)
1561 case language_cplus
:
1572 /* Return the number of children for a given variable.
1573 The result of this function is defined by the language
1574 implementation. The number of children returned by this function
1575 is the number of children that the user will see in the variable
1578 number_of_children (struct varobj
*var
)
1580 return (*var
->root
->lang
->number_of_children
) (var
);;
1583 /* What is the expression for the root varobj VAR? Returns a malloc'd string. */
1585 name_of_variable (struct varobj
*var
)
1587 return (*var
->root
->lang
->name_of_variable
) (var
);
1590 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd string. */
1592 name_of_child (struct varobj
*var
, int index
)
1594 return (*var
->root
->lang
->name_of_child
) (var
, index
);
1597 /* What is the value_ptr of the root variable VAR?
1598 TYPE_CHANGED controls what to do if the type of a
1599 use_selected_frame = 1 variable changes. On input,
1600 TYPE_CHANGED = 1 means discard the old varobj, and replace
1601 it with this one. TYPE_CHANGED = 0 means leave it around.
1602 NB: In both cases, var_handle will point to the new varobj,
1603 so if you use TYPE_CHANGED = 0, you will have to stash the
1604 old varobj pointer away somewhere before calling this.
1605 On return, TYPE_CHANGED will be 1 if the type has changed, and
1608 value_of_root (struct varobj
**var_handle
, int *type_changed
)
1612 if (var_handle
== NULL
)
1617 /* This should really be an exception, since this should
1618 only get called with a root variable. */
1620 if (var
->root
->rootvar
!= var
)
1623 if (var
->root
->use_selected_frame
)
1625 struct varobj
*tmp_var
;
1626 char *old_type
, *new_type
;
1627 old_type
= varobj_get_type (var
);
1628 tmp_var
= varobj_create (NULL
, var
->name
, (CORE_ADDR
) 0,
1629 USE_SELECTED_FRAME
);
1630 if (tmp_var
== NULL
)
1634 new_type
= varobj_get_type (tmp_var
);
1635 if (strcmp(old_type
, new_type
) == 0)
1637 varobj_delete (tmp_var
, NULL
, 0);
1645 savestring (var
->obj_name
, strlen (var
->obj_name
));
1646 varobj_delete (var
, NULL
, 0);
1650 tmp_var
->obj_name
= varobj_gen_name ();
1652 install_variable (tmp_var
);
1653 *var_handle
= tmp_var
;
1663 return (*var
->root
->lang
->value_of_root
) (var_handle
);
1666 /* What is the value_ptr for the INDEX'th child of PARENT? */
1668 value_of_child (struct varobj
*parent
, int index
)
1672 value
= (*parent
->root
->lang
->value_of_child
) (parent
, index
);
1674 /* If we're being lazy, fetch the real value of the variable. */
1675 if (value
!= NULL
&& VALUE_LAZY (value
))
1676 gdb_value_fetch_lazy (value
);
1681 /* What is the type of VAR? */
1682 static struct type
*
1683 type_of_child (struct varobj
*var
)
1686 /* If the child had no evaluation errors, var->value
1687 will be non-NULL and contain a valid type. */
1688 if (var
->value
!= NULL
)
1689 return VALUE_TYPE (var
->value
);
1691 /* Otherwise, we must compute the type. */
1692 return (*var
->root
->lang
->type_of_child
) (var
->parent
, var
->index
);
1695 /* Is this variable editable? Use the variable's type to make
1696 this determination. */
1698 variable_editable (struct varobj
*var
)
1700 return (*var
->root
->lang
->variable_editable
) (var
);
1703 /* GDB already has a command called "value_of_variable". Sigh. */
1705 my_value_of_variable (struct varobj
*var
)
1707 return (*var
->root
->lang
->value_of_variable
) (var
);
1710 /* Is VAR something that can change? Depending on language,
1711 some variable's values never change. For example,
1712 struct and unions never change values. */
1714 type_changeable (struct varobj
*var
)
1719 if (CPLUS_FAKE_CHILD (var
))
1722 type
= get_type (var
);
1724 switch (TYPE_CODE (type
))
1726 case TYPE_CODE_STRUCT
:
1727 case TYPE_CODE_UNION
:
1728 case TYPE_CODE_ARRAY
:
1741 c_number_of_children (struct varobj
*var
)
1744 struct type
*target
;
1747 type
= get_type (var
);
1748 target
= get_target_type (type
);
1751 switch (TYPE_CODE (type
))
1753 case TYPE_CODE_ARRAY
:
1754 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (target
) > 0
1755 && TYPE_ARRAY_UPPER_BOUND_TYPE (type
) != BOUND_CANNOT_BE_DETERMINED
)
1756 children
= TYPE_LENGTH (type
) / TYPE_LENGTH (target
);
1761 case TYPE_CODE_STRUCT
:
1762 case TYPE_CODE_UNION
:
1763 children
= TYPE_NFIELDS (type
);
1767 /* This is where things get compilcated. All pointers have one child.
1768 Except, of course, for struct and union ptr, which we automagically
1769 dereference for the user and function ptrs, which have no children.
1770 We also don't dereference void* as we don't know what to show.
1771 We can show char* so we allow it to be dereferenced. If you decide
1772 to test for it, please mind that a little magic is necessary to
1773 properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
1774 TYPE_NAME == "char" */
1776 switch (TYPE_CODE (target
))
1778 case TYPE_CODE_STRUCT
:
1779 case TYPE_CODE_UNION
:
1780 children
= TYPE_NFIELDS (target
);
1783 case TYPE_CODE_FUNC
:
1784 case TYPE_CODE_VOID
:
1794 /* Other types have no children */
1802 c_name_of_variable (struct varobj
*parent
)
1804 return savestring (parent
->name
, strlen (parent
->name
));
1808 c_name_of_child (struct varobj
*parent
, int index
)
1811 struct type
*target
;
1815 type
= get_type (parent
);
1816 target
= get_target_type (type
);
1818 switch (TYPE_CODE (type
))
1820 case TYPE_CODE_ARRAY
:
1822 /* We never get here unless parent->num_children is greater than 0... */
1824 while ((int) pow ((double) 10, (double) len
) < index
)
1826 name
= (char *) xmalloc (1 + len
* sizeof (char));
1827 sprintf (name
, "%d", index
);
1831 case TYPE_CODE_STRUCT
:
1832 case TYPE_CODE_UNION
:
1833 string
= TYPE_FIELD_NAME (type
, index
);
1834 name
= savestring (string
, strlen (string
));
1838 switch (TYPE_CODE (target
))
1840 case TYPE_CODE_STRUCT
:
1841 case TYPE_CODE_UNION
:
1842 string
= TYPE_FIELD_NAME (target
, index
);
1843 name
= savestring (string
, strlen (string
));
1847 name
= (char *) xmalloc ((strlen (parent
->name
) + 2) * sizeof (char));
1848 sprintf (name
, "*%s", parent
->name
);
1854 /* This should not happen */
1855 name
= xstrdup ("???");
1862 c_value_of_root (struct varobj
**var_handle
)
1865 struct varobj
*var
= *var_handle
;
1866 struct frame_info
*fi
;
1869 /* Only root variables can be updated... */
1870 if (var
->root
->rootvar
!= var
)
1871 /* Not a root var */
1875 /* Determine whether the variable is still around. */
1876 if (var
->root
->valid_block
== NULL
)
1880 reinit_frame_cache ();
1883 fi
= find_frame_addr_in_frame_chain (var
->root
->frame
);
1885 within_scope
= fi
!= NULL
;
1886 /* FIXME: select_frame could fail */
1888 select_frame (fi
, -1);
1893 /* We need to catch errors here, because if evaluate
1894 expression fails we just want to make val->error = 1 and
1896 if (gdb_evaluate_expression (var
->root
->exp
, &new_val
))
1898 if (VALUE_LAZY (new_val
))
1900 /* We need to catch errors because if
1901 value_fetch_lazy fails we still want to continue
1902 (after making val->error = 1) */
1903 /* FIXME: Shouldn't be using VALUE_CONTENTS? The
1904 comment on value_fetch_lazy() says it is only
1905 called from the macro... */
1906 if (!gdb_value_fetch_lazy (new_val
))
1915 release_value (new_val
);
1923 c_value_of_child (struct varobj
*parent
, int index
)
1925 value_ptr value
, temp
, indval
;
1926 struct type
*type
, *target
;
1929 type
= get_type (parent
);
1930 target
= get_target_type (type
);
1931 name
= name_of_child (parent
, index
);
1932 temp
= parent
->value
;
1937 switch (TYPE_CODE (type
))
1939 case TYPE_CODE_ARRAY
:
1941 /* This breaks if the array lives in a (vector) register. */
1942 value
= value_slice (temp
, index
, 1);
1943 temp
= value_coerce_array (value
);
1944 gdb_value_ind (temp
, &value
);
1946 indval
= value_from_longest (builtin_type_int
, (LONGEST
) index
);
1947 gdb_value_subscript (temp
, indval
, &value
);
1951 case TYPE_CODE_STRUCT
:
1952 case TYPE_CODE_UNION
:
1953 value
= value_struct_elt (&temp
, NULL
, name
, NULL
, "vstructure");
1957 switch (TYPE_CODE (target
))
1959 case TYPE_CODE_STRUCT
:
1960 case TYPE_CODE_UNION
:
1961 value
= value_struct_elt (&temp
, NULL
, name
, NULL
, "vstructure");
1965 gdb_value_ind (temp
, &value
);
1976 release_value (value
);
1981 static struct type
*
1982 c_type_of_child (struct varobj
*parent
, int index
)
1985 char *name
= name_of_child (parent
, index
);
1987 switch (TYPE_CODE (parent
->type
))
1989 case TYPE_CODE_ARRAY
:
1990 type
= TYPE_TARGET_TYPE (parent
->type
);
1993 case TYPE_CODE_STRUCT
:
1994 case TYPE_CODE_UNION
:
1995 type
= lookup_struct_elt_type (parent
->type
, name
, 0);
1999 switch (TYPE_CODE (TYPE_TARGET_TYPE (parent
->type
)))
2001 case TYPE_CODE_STRUCT
:
2002 case TYPE_CODE_UNION
:
2003 type
= lookup_struct_elt_type (parent
->type
, name
, 0);
2007 type
= TYPE_TARGET_TYPE (parent
->type
);
2013 /* This should not happen as only the above types have children */
2014 warning ("Child of parent whose type does not allow children");
2015 /* FIXME: Can we still go on? */
2024 c_variable_editable (struct varobj
*var
)
2026 switch (TYPE_CODE (get_type (var
)))
2028 case TYPE_CODE_STRUCT
:
2029 case TYPE_CODE_UNION
:
2030 case TYPE_CODE_ARRAY
:
2031 case TYPE_CODE_FUNC
:
2032 case TYPE_CODE_MEMBER
:
2033 case TYPE_CODE_METHOD
:
2044 c_value_of_variable (struct varobj
*var
)
2049 if (var
->value
!= NULL
)
2053 /* This can happen if we attempt to get the value of a struct
2054 member when the parent is an invalid pointer. */
2055 return xstrdup ("???");
2058 /* BOGUS: if val_print sees a struct/class, it will print out its
2059 children instead of "{...}" */
2060 type
= get_type (var
);
2061 switch (TYPE_CODE (type
))
2063 case TYPE_CODE_STRUCT
:
2064 case TYPE_CODE_UNION
:
2065 return xstrdup ("{...}");
2068 case TYPE_CODE_ARRAY
:
2071 sprintf (number
, "[%d]", var
->num_children
);
2072 return xstrdup (number
);
2079 struct ui_file
*stb
= mem_fileopen ();
2080 struct cleanup
*old_chain
= make_cleanup_ui_file_delete (stb
);
2083 if (VALUE_LAZY (val
))
2084 gdb_value_fetch_lazy (val
);
2085 val_print (VALUE_TYPE (val
), VALUE_CONTENTS_RAW (val
), 0,
2086 VALUE_ADDRESS (val
),
2087 stb
, format_code
[(int) var
->format
], 1, 0, 0);
2088 thevalue
= ui_file_xstrdup (stb
, &dummy
);
2089 do_cleanups (old_chain
);
2100 cplus_number_of_children (struct varobj
*var
)
2103 int children
, dont_know
;
2108 if (!CPLUS_FAKE_CHILD (var
))
2110 type
= get_type_deref (var
);
2112 if (((TYPE_CODE (type
)) == TYPE_CODE_STRUCT
) ||
2113 ((TYPE_CODE (type
)) == TYPE_CODE_UNION
))
2117 cplus_class_num_children (type
, kids
);
2118 if (kids
[v_public
] != 0)
2120 if (kids
[v_private
] != 0)
2122 if (kids
[v_protected
] != 0)
2125 /* Add any baseclasses */
2126 children
+= TYPE_N_BASECLASSES (type
);
2129 /* FIXME: save children in var */
2136 type
= get_type_deref (var
->parent
);
2138 cplus_class_num_children (type
, kids
);
2139 if (STREQ (var
->name
, "public"))
2140 children
= kids
[v_public
];
2141 else if (STREQ (var
->name
, "private"))
2142 children
= kids
[v_private
];
2144 children
= kids
[v_protected
];
2149 children
= c_number_of_children (var
);
2154 /* Compute # of public, private, and protected variables in this class.
2155 That means we need to descend into all baseclasses and find out
2156 how many are there, too. */
2158 cplus_class_num_children (struct type
*type
, int children
[3])
2162 children
[v_public
] = 0;
2163 children
[v_private
] = 0;
2164 children
[v_protected
] = 0;
2166 for (i
= TYPE_N_BASECLASSES (type
); i
< TYPE_NFIELDS (type
); i
++)
2168 /* If we have a virtual table pointer, omit it. */
2169 if (TYPE_VPTR_BASETYPE (type
) == type
2170 && TYPE_VPTR_FIELDNO (type
) == i
)
2173 if (TYPE_FIELD_PROTECTED (type
, i
))
2174 children
[v_protected
]++;
2175 else if (TYPE_FIELD_PRIVATE (type
, i
))
2176 children
[v_private
]++;
2178 children
[v_public
]++;
2183 cplus_name_of_variable (struct varobj
*parent
)
2185 return c_name_of_variable (parent
);
2189 cplus_name_of_child (struct varobj
*parent
, int index
)
2195 if (CPLUS_FAKE_CHILD (parent
))
2197 /* Looking for children of public, private, or protected. */
2198 type
= get_type_deref (parent
->parent
);
2201 type
= get_type_deref (parent
);
2204 switch (TYPE_CODE (type
))
2206 case TYPE_CODE_STRUCT
:
2207 case TYPE_CODE_UNION
:
2208 cplus_class_num_children (type
, children
);
2210 if (CPLUS_FAKE_CHILD (parent
))
2212 /* FIXME: This assumes that type orders
2213 inherited, public, private, protected */
2214 int i
= index
+ TYPE_N_BASECLASSES (type
);
2215 if (STREQ (parent
->name
, "private") || STREQ (parent
->name
, "protected"))
2216 i
+= children
[v_public
];
2217 if (STREQ (parent
->name
, "protected"))
2218 i
+= children
[v_private
];
2220 name
= TYPE_FIELD_NAME (type
, i
);
2222 else if (index
< TYPE_N_BASECLASSES (type
))
2223 name
= TYPE_FIELD_NAME (type
, index
);
2226 /* Everything beyond the baseclasses can
2227 only be "public", "private", or "protected" */
2228 index
-= TYPE_N_BASECLASSES (type
);
2232 if (children
[v_public
] != 0)
2238 if (children
[v_private
] != 0)
2244 if (children
[v_protected
] != 0)
2261 return c_name_of_child (parent
, index
);
2265 name
= savestring (name
, strlen (name
));
2272 cplus_value_of_root (struct varobj
**var_handle
)
2274 return c_value_of_root (var_handle
);
2278 cplus_value_of_child (struct varobj
*parent
, int index
)
2284 if (CPLUS_FAKE_CHILD (parent
))
2285 type
= get_type_deref (parent
->parent
);
2287 type
= get_type_deref (parent
);
2290 name
= name_of_child (parent
, index
);
2292 if (((TYPE_CODE (type
)) == TYPE_CODE_STRUCT
) ||
2293 ((TYPE_CODE (type
)) == TYPE_CODE_UNION
))
2295 if (CPLUS_FAKE_CHILD (parent
))
2297 value_ptr temp
= parent
->parent
->value
;
2298 value
= value_struct_elt (&temp
, NULL
, name
,
2299 NULL
, "cplus_structure");
2300 release_value (value
);
2302 else if (index
>= TYPE_N_BASECLASSES (type
))
2304 /* public, private, or protected */
2310 if (parent
->value
!= NULL
)
2314 if (TYPE_CODE (VALUE_TYPE (parent
->value
)) == TYPE_CODE_PTR
2315 || TYPE_CODE (VALUE_TYPE (parent
->value
)) == TYPE_CODE_REF
)
2316 gdb_value_ind (parent
->value
, &temp
);
2318 temp
= parent
->value
;
2320 value
= value_cast (TYPE_FIELD_TYPE (type
, index
), temp
);
2321 release_value (value
);
2327 return c_value_of_child (parent
, index
);
2332 static struct type
*
2333 cplus_type_of_child (struct varobj
*parent
, int index
)
2335 struct type
*type
, *t
;
2337 t
= get_type_deref (parent
);
2339 switch (TYPE_CODE (t
))
2341 case TYPE_CODE_STRUCT
:
2342 case TYPE_CODE_UNION
:
2343 if (index
>= TYPE_N_BASECLASSES (t
))
2351 type
= TYPE_FIELD_TYPE (t
, index
);
2360 return c_type_of_child (parent
, index
);
2366 cplus_variable_editable (struct varobj
*var
)
2368 if (CPLUS_FAKE_CHILD (var
))
2371 return c_variable_editable (var
);
2375 cplus_value_of_variable (struct varobj
*var
)
2378 /* If we have one of our special types, don't print out
2380 if (CPLUS_FAKE_CHILD (var
))
2381 return xstrdup ("");
2383 return c_value_of_variable (var
);
2389 java_number_of_children (struct varobj
*var
)
2391 return cplus_number_of_children (var
);
2395 java_name_of_variable (struct varobj
*parent
)
2399 name
= cplus_name_of_variable (parent
);
2400 /* If the name has "-" in it, it is because we
2401 needed to escape periods in the name... */
2404 while (*p
!= '\000')
2415 java_name_of_child (struct varobj
*parent
, int index
)
2419 name
= cplus_name_of_child (parent
, index
);
2420 /* Escape any periods in the name... */
2423 while (*p
!= '\000')
2434 java_value_of_root (struct varobj
**var_handle
)
2436 return cplus_value_of_root (var_handle
);
2440 java_value_of_child (struct varobj
*parent
, int index
)
2442 return cplus_value_of_child (parent
, index
);
2445 static struct type
*
2446 java_type_of_child (struct varobj
*parent
, int index
)
2448 return cplus_type_of_child (parent
, index
);
2452 java_variable_editable (struct varobj
*var
)
2454 return cplus_variable_editable (var
);
2458 java_value_of_variable (struct varobj
*var
)
2460 return cplus_value_of_variable (var
);
2463 extern void _initialize_varobj (void);
2465 _initialize_varobj (void)
2467 int sizeof_table
= sizeof (struct vlist
*) * VAROBJ_TABLE_SIZE
;
2469 varobj_table
= xmalloc (sizeof_table
);
2470 memset (varobj_table
, 0, sizeof_table
);
2473 add_set_cmd ("debugvarobj", class_maintenance
, var_zinteger
,
2474 (char *) &varobjdebug
,
2475 "Set varobj debugging.\n\
2476 When non-zero, varobj debugging is enabled.", &setlist
),