1 /* Implementation of the GDB variable objects API.
2 Copyright 1999, 2000 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"
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
[] =
41 {"unknown", "C", "C++", "Java"};
45 /* Every root variable has one of these structures saved in its
46 varobj. Members which must be free'd are noted. */
50 /* Alloc'd expression for this parent. */
51 struct expression
*exp
;
53 /* Block for which this expression is valid */
54 struct block
*valid_block
;
56 /* The frame for this expression */
59 /* If 1, "update" always recomputes the frame & valid block
60 using the currently selected frame. */
61 int use_selected_frame
;
63 /* Language info for this variable and its children */
64 struct language_specific
*lang
;
66 /* The varobj for this root node. */
67 struct varobj
*rootvar
;
69 /* Next root variable */
70 struct varobj_root
*next
;
73 /* Every variable in the system has a structure of this type defined
74 for it. This structure holds all information necessary to manipulate
75 a particular object variable. Members which must be freed are noted. */
79 /* Alloc'd name of the variable for this object.. If this variable is a
80 child, then this name will be the child's source name.
82 /* NOTE: This is the "expression" */
85 /* The alloc'd name for this variable's object. This is here for
86 convenience when constructing this object's children. */
89 /* Index of this variable in its parent or -1 */
92 /* The type of this variable. This may NEVER be NULL. */
95 /* The value of this expression or subexpression. This may be NULL. */
98 /* Did an error occur evaluating the expression or getting its value? */
101 /* The number of (immediate) children this variable has */
104 /* If this object is a child, this points to its immediate parent. */
105 struct varobj
*parent
;
107 /* A list of this object's children */
108 struct varobj_child
*children
;
110 /* Description of the root variable. Points to root variable for children. */
111 struct varobj_root
*root
;
113 /* The format of the output for this object */
114 enum varobj_display_formats format
;
117 /* Every variable keeps a linked list of its children, described
118 by the following structure. */
119 /* FIXME: Deprecated. All should use vlist instead */
124 /* Pointer to the child's data */
125 struct varobj
*child
;
127 /* Pointer to the next child */
128 struct varobj_child
*next
;
131 /* A stack of varobjs */
132 /* FIXME: Deprecated. All should use vlist instead */
143 struct cpstack
*next
;
146 /* A list of varobjs */
154 /* Private function prototypes */
156 /* Helper functions for the above subcommands. */
158 static int delete_variable (struct cpstack
**, struct varobj
*, int);
160 static void delete_variable_1 (struct cpstack
**, int *,
161 struct varobj
*, int, int);
163 static int install_variable (struct varobj
*);
165 static void uninstall_variable (struct varobj
*);
167 static struct varobj
*child_exists (struct varobj
*, char *);
169 static struct varobj
*create_child (struct varobj
*, int, char *);
171 static void save_child_in_parent (struct varobj
*, struct varobj
*);
173 static void remove_child_from_parent (struct varobj
*, struct varobj
*);
175 /* Utility routines */
177 static struct varobj
*new_variable (void);
179 static struct varobj
*new_root_variable (void);
181 static void free_variable (struct varobj
*var
);
183 static struct cleanup
*make_cleanup_free_variable (struct varobj
*var
);
185 static struct type
*get_type (struct varobj
*var
);
187 static struct type
*get_type_deref (struct varobj
*var
);
189 static struct type
*get_target_type (struct type
*);
191 static enum varobj_display_formats
variable_default_display (struct varobj
*);
193 static int my_value_equal (value_ptr
, value_ptr
, int *);
195 static void vpush (struct vstack
**pstack
, struct varobj
*var
);
197 static struct varobj
*vpop (struct vstack
**pstack
);
199 static void cppush (struct cpstack
**pstack
, char *name
);
201 static char *cppop (struct cpstack
**pstack
);
203 /* Language-specific routines. */
205 static enum varobj_languages
variable_language (struct varobj
*var
);
207 static int number_of_children (struct varobj
*);
209 static char *name_of_variable (struct varobj
*);
211 static char *name_of_child (struct varobj
*, int);
213 static value_ptr
value_of_root (struct varobj
**var_handle
, int *);
215 static value_ptr
value_of_child (struct varobj
*parent
, int index
);
217 static struct type
*type_of_child (struct varobj
*var
);
219 static int variable_editable (struct varobj
*var
);
221 static char *my_value_of_variable (struct varobj
*var
);
223 static int type_changeable (struct varobj
*var
);
225 /* C implementation */
227 static int c_number_of_children (struct varobj
*var
);
229 static char *c_name_of_variable (struct varobj
*parent
);
231 static char *c_name_of_child (struct varobj
*parent
, int index
);
233 static value_ptr
c_value_of_root (struct varobj
**var_handle
);
235 static value_ptr
c_value_of_child (struct varobj
*parent
, int index
);
237 static struct type
*c_type_of_child (struct varobj
*parent
, int index
);
239 static int c_variable_editable (struct varobj
*var
);
241 static char *c_value_of_variable (struct varobj
*var
);
243 /* C++ implementation */
245 static int cplus_number_of_children (struct varobj
*var
);
247 static void cplus_class_num_children (struct type
*type
, int children
[3]);
249 static char *cplus_name_of_variable (struct varobj
*parent
);
251 static char *cplus_name_of_child (struct varobj
*parent
, int index
);
253 static value_ptr
cplus_value_of_root (struct varobj
**var_handle
);
255 static value_ptr
cplus_value_of_child (struct varobj
*parent
, int index
);
257 static struct type
*cplus_type_of_child (struct varobj
*parent
, int index
);
259 static int cplus_variable_editable (struct varobj
*var
);
261 static char *cplus_value_of_variable (struct varobj
*var
);
263 /* Java implementation */
265 static int java_number_of_children (struct varobj
*var
);
267 static char *java_name_of_variable (struct varobj
*parent
);
269 static char *java_name_of_child (struct varobj
*parent
, int index
);
271 static value_ptr
java_value_of_root (struct varobj
**var_handle
);
273 static value_ptr
java_value_of_child (struct varobj
*parent
, int index
);
275 static struct type
*java_type_of_child (struct varobj
*parent
, int index
);
277 static int java_variable_editable (struct varobj
*var
);
279 static char *java_value_of_variable (struct varobj
*var
);
281 /* The language specific vector */
283 struct language_specific
286 /* The language of this variable */
287 enum varobj_languages language
;
289 /* The number of children of PARENT. */
290 int (*number_of_children
) (struct varobj
* parent
);
292 /* The name (expression) of a root varobj. */
293 char *(*name_of_variable
) (struct varobj
* parent
);
295 /* The name of the INDEX'th child of PARENT. */
296 char *(*name_of_child
) (struct varobj
* parent
, int index
);
298 /* The value_ptr of the root variable ROOT. */
299 value_ptr (*value_of_root
) (struct varobj
** root_handle
);
301 /* The value_ptr of the INDEX'th child of PARENT. */
302 value_ptr (*value_of_child
) (struct varobj
* parent
, int index
);
304 /* The type of the INDEX'th child of PARENT. */
305 struct type
*(*type_of_child
) (struct varobj
* parent
, int index
);
307 /* Is VAR editable? */
308 int (*variable_editable
) (struct varobj
* var
);
310 /* The current value of VAR. */
311 char *(*value_of_variable
) (struct varobj
* var
);
314 /* Array of known source language routines. */
315 static struct language_specific
316 languages
[vlang_end
][sizeof (struct language_specific
)] =
318 /* Unknown (try treating as C */
321 c_number_of_children
,
334 c_number_of_children
,
347 cplus_number_of_children
,
348 cplus_name_of_variable
,
351 cplus_value_of_child
,
353 cplus_variable_editable
,
354 cplus_value_of_variable
360 java_number_of_children
,
361 java_name_of_variable
,
366 java_variable_editable
,
367 java_value_of_variable
371 /* A little convenience enum for dealing with C++/Java */
374 v_public
= 0, v_private
, v_protected
379 /* Mappings of varobj_display_formats enums to gdb's format codes */
380 static int format_code
[] =
381 {0, 't', 'd', 'x', 'o'};
383 /* Header of the list of root variable objects */
384 static struct varobj_root
*rootlist
;
385 static int rootcount
= 0; /* number of root varobjs in the list */
387 /* Prime number indicating the number of buckets in the hash table */
388 /* A prime large enough to avoid too many colisions */
389 #define VAROBJ_TABLE_SIZE 227
391 /* Pointer to the varobj hash table (built at run time) */
392 static struct vlist
**varobj_table
;
397 #define FREEIF(x) if (x != NULL) free((char *) (x))
399 /* Is the variable X one of our "fake" children? */
400 #define CPLUS_FAKE_CHILD(x) \
401 ((x) != NULL && (x)->type == NULL && (x)->value == NULL)
404 /* API Implementation */
406 /* Creates a varobj (not its children) */
409 varobj_create (char *objname
,
410 char *expression
, CORE_ADDR frame
,
411 enum varobj_type type
)
414 struct frame_info
*fi
, *old_fi
;
416 struct cleanup
*old_chain
;
418 /* Fill out a varobj structure for the (root) variable being constructed. */
419 var
= new_root_variable ();
420 old_chain
= make_cleanup_free_variable (var
);
422 if (expression
!= NULL
)
425 enum varobj_languages lang
;
427 /* Parse and evaluate the expression, filling in as much
428 of the variable's data as possible */
430 /* Allow creator to specify context of variable */
431 if ((type
== USE_CURRENT_FRAME
)
432 || (type
== USE_SELECTED_FRAME
))
435 fi
= find_frame_addr_in_frame_chain (frame
);
437 /* frame = -2 means always use selected frame */
438 if (type
== USE_SELECTED_FRAME
)
439 var
->root
->use_selected_frame
= 1;
443 block
= get_frame_block (fi
);
446 innermost_block
= NULL
;
447 /* Wrap the call to parse expression, so we can
448 return a sensible error. */
449 if (!gdb_parse_exp_1 (&p
, block
, 0, &var
->root
->exp
))
454 /* Don't allow variables to be created for types. */
455 if (var
->root
->exp
->elts
[0].opcode
== OP_TYPE
)
457 do_cleanups (old_chain
);
458 fprintf_unfiltered (gdb_stderr
,
459 "Attempt to use a type name as an expression.");
463 var
->format
= variable_default_display (var
);
464 var
->root
->valid_block
= innermost_block
;
465 var
->name
= savestring (expression
, strlen (expression
));
467 /* When the frame is different from the current frame,
468 we must select the appropriate frame before parsing
469 the expression, otherwise the value will not be current.
470 Since select_frame is so benign, just call it for all cases. */
473 var
->root
->frame
= FRAME_FP (fi
);
474 old_fi
= selected_frame
;
475 select_frame (fi
, -1);
478 /* We definitively need to catch errors here.
479 If evaluate_expression succeeds we got the value we wanted.
480 But if it fails, we still go on with a call to evaluate_type() */
481 if (gdb_evaluate_expression (var
->root
->exp
, &var
->value
))
484 release_value (var
->value
);
485 if (VALUE_LAZY (var
->value
))
486 gdb_value_fetch_lazy (var
->value
);
489 var
->value
= evaluate_type (var
->root
->exp
);
491 var
->type
= VALUE_TYPE (var
->value
);
493 /* Set language info */
494 lang
= variable_language (var
);
495 var
->root
->lang
= languages
[lang
];
497 /* Set ourselves as our root */
498 var
->root
->rootvar
= var
;
500 /* Reset the selected frame */
502 select_frame (old_fi
, -1);
505 /* If the variable object name is null, that means this
506 is a temporary variable, so don't install it. */
508 if ((var
!= NULL
) && (objname
!= NULL
))
510 var
->obj_name
= savestring (objname
, strlen (objname
));
512 /* If a varobj name is duplicated, the install will fail so
514 if (!install_variable (var
))
516 do_cleanups (old_chain
);
521 discard_cleanups (old_chain
);
525 /* Generates an unique name that can be used for a varobj */
528 varobj_gen_name (void)
533 /* generate a name for this object */
535 sprintf (obj_name
, "var%d", id
);
537 return xstrdup (obj_name
);
540 /* Given an "objname", returns the pointer to the corresponding varobj
541 or NULL if not found */
544 varobj_get_handle (char *objname
)
548 unsigned int index
= 0;
551 for (chp
= objname
; *chp
; chp
++)
553 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
556 cv
= *(varobj_table
+ index
);
557 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, objname
) != 0))
561 error ("Variable object not found");
566 /* Given the handle, return the name of the object */
569 varobj_get_objname (struct varobj
*var
)
571 return var
->obj_name
;
574 /* Given the handle, return the expression represented by the object */
577 varobj_get_expression (struct varobj
*var
)
579 return name_of_variable (var
);
582 /* Deletes a varobj and all its children if only_children == 0,
583 otherwise deletes only the children; returns a malloc'ed list of all the
584 (malloc'ed) names of the variables that have been deleted (NULL terminated) */
587 varobj_delete (struct varobj
*var
, char ***dellist
, int only_children
)
591 struct cpstack
*result
= NULL
;
594 /* Initialize a stack for temporary results */
595 cppush (&result
, NULL
);
598 /* Delete only the variable children */
599 delcount
= delete_variable (&result
, var
, 1 /* only the children */ );
601 /* Delete the variable and all its children */
602 delcount
= delete_variable (&result
, var
, 0 /* parent+children */ );
604 /* We may have been asked to return a list of what has been deleted */
607 *dellist
= xmalloc ((delcount
+ 1) * sizeof (char *));
611 *cp
= cppop (&result
);
612 while ((*cp
!= NULL
) && (mycount
> 0))
616 *cp
= cppop (&result
);
619 if (mycount
|| (*cp
!= NULL
))
620 warning ("varobj_delete: assertion failed - mycount(=%d) <> 0", mycount
);
626 /* Set/Get variable object display format */
628 enum varobj_display_formats
629 varobj_set_display_format (struct varobj
*var
,
630 enum varobj_display_formats format
)
637 case FORMAT_HEXADECIMAL
:
639 var
->format
= format
;
643 var
->format
= variable_default_display (var
);
649 enum varobj_display_formats
650 varobj_get_display_format (struct varobj
*var
)
656 varobj_get_num_children (struct varobj
*var
)
658 if (var
->num_children
== -1)
659 var
->num_children
= number_of_children (var
);
661 return var
->num_children
;
664 /* Creates a list of the immediate children of a variable object;
665 the return code is the number of such children or -1 on error */
668 varobj_list_children (struct varobj
*var
, struct varobj
***childlist
)
670 struct varobj
*child
;
674 /* sanity check: have we been passed a pointer? */
675 if (childlist
== NULL
)
680 if (var
->num_children
== -1)
681 var
->num_children
= number_of_children (var
);
683 /* List of children */
684 *childlist
= xmalloc ((var
->num_children
+ 1) * sizeof (struct varobj
*));
686 for (i
= 0; i
< var
->num_children
; i
++)
688 /* Mark as the end in case we bail out */
689 *((*childlist
) + i
) = NULL
;
691 /* check if child exists, if not create */
692 name
= name_of_child (var
, i
);
693 child
= child_exists (var
, name
);
695 child
= create_child (var
, i
, name
);
697 *((*childlist
) + i
) = child
;
700 /* End of list is marked by a NULL pointer */
701 *((*childlist
) + i
) = NULL
;
703 return var
->num_children
;
706 /* Obtain the type of an object Variable as a string similar to the one gdb
707 prints on the console */
710 varobj_get_type (struct varobj
*var
)
713 struct cleanup
*old_chain
;
718 /* For the "fake" variables, do not return a type. (It's type is
720 if (CPLUS_FAKE_CHILD (var
))
723 stb
= mem_fileopen ();
724 old_chain
= make_cleanup_ui_file_delete (stb
);
726 /* To print the type, we simply create a zero value_ptr and
727 cast it to our type. We then typeprint this variable. */
728 val
= value_zero (var
->type
, not_lval
);
729 type_print (VALUE_TYPE (val
), "", stb
, -1);
731 thetype
= ui_file_xstrdup (stb
, &length
);
732 do_cleanups (old_chain
);
736 enum varobj_languages
737 varobj_get_language (struct varobj
*var
)
739 return variable_language (var
);
743 varobj_get_attributes (struct varobj
*var
)
747 if (variable_editable (var
))
748 /* FIXME: define masks for attributes */
749 attributes
|= 0x00000001; /* Editable */
755 varobj_get_value (struct varobj
*var
)
757 return my_value_of_variable (var
);
760 /* Set the value of an object variable (if it is editable) to the
761 value of the given expression */
762 /* Note: Invokes functions that can call error() */
765 varobj_set_value (struct varobj
*var
, char *expression
)
770 /* The argument "expression" contains the variable's new value.
771 We need to first construct a legal expression for this -- ugh! */
772 /* Does this cover all the bases? */
773 struct expression
*exp
;
775 int saved_input_radix
= input_radix
;
777 if (variable_editable (var
) && !var
->error
)
779 char *s
= expression
;
783 input_radix
= 10; /* ALWAYS reset to decimal temporarily */
784 if (!gdb_parse_exp_1 (&s
, 0, 0, &exp
))
785 /* We cannot proceed without a well-formed expression. */
787 if (!gdb_evaluate_expression (exp
, &value
))
789 /* We cannot proceed without a valid expression. */
794 /* If our parent is "public", "private", or "protected", we could
795 be asking to modify the value of a baseclass. If so, we need to
796 adjust our address by the offset of our baseclass in the subclass,
797 since VALUE_ADDRESS (var->value) points at the start of the subclass.
798 For some reason, value_cast doesn't take care of this properly. */
800 if (var
->parent
!= NULL
&& CPLUS_FAKE_CHILD (var
->parent
))
802 struct varobj
*super
, *sub
;
804 super
= var
->parent
->parent
;
808 /* Yes, it is a baseclass */
809 type
= get_type_deref (sub
);
811 if (super
->index
< TYPE_N_BASECLASSES (type
))
813 temp
= value_copy (var
->value
);
814 for (i
= 0; i
< super
->index
; i
++)
815 offset
+= TYPE_LENGTH (TYPE_FIELD_TYPE (type
, i
));
820 VALUE_ADDRESS (temp
) += offset
;
821 if (!gdb_value_assign (temp
, value
, &val
))
823 VALUE_ADDRESS (val
) -= offset
;
824 value_free (var
->value
);
827 input_radix
= saved_input_radix
;
834 /* Returns a malloc'ed list with all root variable objects */
836 varobj_list (struct varobj
***varlist
)
839 struct varobj_root
*croot
;
840 int mycount
= rootcount
;
842 /* Alloc (rootcount + 1) entries for the result */
843 *varlist
= xmalloc ((rootcount
+ 1) * sizeof (struct varobj
*));
847 while ((croot
!= NULL
) && (mycount
> 0))
849 *cv
= croot
->rootvar
;
854 /* Mark the end of the list */
857 if (mycount
|| (croot
!= NULL
))
858 warning ("varobj_list: assertion failed - wrong tally of root vars (%d:%d)",
864 /* Update the values for a variable and its children. This is a
865 two-pronged attack. First, re-parse the value for the root's
866 expression to see if it's changed. Then go all the way
867 through its children, reconstructing them and noting if they've
870 -1 if there was an error updating the varobj
871 -2 if the type changed
872 Otherwise it is the number of children + parent changed
874 Only root variables can be updated... */
877 varobj_update (struct varobj
*var
, struct varobj
***changelist
)
886 struct varobj
**templist
;
888 struct vstack
*stack
= NULL
;
889 struct vstack
*result
= NULL
;
890 struct frame_info
*old_fi
;
892 /* sanity check: have we been passed a pointer? */
893 if (changelist
== NULL
)
896 /* Only root variables can be updated... */
897 if (var
->root
->rootvar
!= var
)
901 /* Save the selected stack frame, since we will need to change it
902 in order to evaluate expressions. */
903 old_fi
= selected_frame
;
905 /* Update the root variable. value_of_root can return NULL
906 if the variable is no longer around, i.e. we stepped out of
907 the frame in which a local existed. We are letting the
908 value_of_root variable dispose of the varobj if the type
911 new = value_of_root (&var
, &type_changed
);
918 /* Initialize a stack for temporary results */
919 vpush (&result
, NULL
);
921 /* If this is a "use_selected_frame" varobj, and its type has changed,
922 them note that it's changed. */
925 vpush (&result
, var
);
928 /* If values are not equal, note that it's changed.
929 There a couple of exceptions here, though.
930 We don't want some types to be reported as "changed". */
931 else if (type_changeable (var
) && !my_value_equal (var
->value
, new, &error2
))
933 vpush (&result
, var
);
935 /* error2 replaces var->error since this new value
936 WILL replace the old one. */
940 /* We must always keep around the new value for this root
941 variable expression, or we lose the updated children! */
942 value_free (var
->value
);
945 /* Initialize a stack */
946 vpush (&stack
, NULL
);
948 /* Push the root's children */
949 if (var
->children
!= NULL
)
951 struct varobj_child
*c
;
952 for (c
= var
->children
; c
!= NULL
; c
= c
->next
)
953 vpush (&stack
, c
->child
);
956 /* Walk through the children, reconstructing them all. */
960 /* Push any children */
961 if (v
->children
!= NULL
)
963 struct varobj_child
*c
;
964 for (c
= v
->children
; c
!= NULL
; c
= c
->next
)
965 vpush (&stack
, c
->child
);
968 /* Update this variable */
969 new = value_of_child (v
->parent
, v
->index
);
970 if (type_changeable (v
) && !my_value_equal (v
->value
, new, &error2
))
972 /* Note that it's changed */
976 /* error2 replaces v->error since this new value
977 WILL replace the old one. */
980 /* We must always keep new values, since children depend on it. */
981 if (v
->value
!= NULL
)
982 value_free (v
->value
);
989 /* Alloc (changed + 1) list entries */
990 /* FIXME: add a cleanup for the allocated list(s)
991 because one day the select_frame called below can longjump */
992 *changelist
= xmalloc ((changed
+ 1) * sizeof (struct varobj
*));
995 templist
= xmalloc ((changed
+ 1) * sizeof (struct varobj
*));
1001 /* Copy from result stack to list */
1003 *cv
= vpop (&result
);
1004 while ((*cv
!= NULL
) && (vleft
> 0))
1008 *cv
= vpop (&result
);
1011 warning ("varobj_update: assertion failed - vleft <> 0");
1015 /* Now we revert the order. */
1016 for (i
=0; i
< changed
; i
++)
1017 *(*changelist
+ i
) = *(templist
+ changed
-1 - i
);
1018 *(*changelist
+ changed
) = NULL
;
1021 /* Restore selected frame */
1022 select_frame (old_fi
, -1);
1031 /* Helper functions */
1034 * Variable object construction/destruction
1038 delete_variable (struct cpstack
**resultp
, struct varobj
*var
,
1039 int only_children_p
)
1043 delete_variable_1 (resultp
, &delcount
, var
,
1044 only_children_p
, 1 /* remove_from_parent_p */ );
1049 /* Delete the variable object VAR and its children */
1050 /* IMPORTANT NOTE: If we delete a variable which is a child
1051 and the parent is not removed we dump core. It must be always
1052 initially called with remove_from_parent_p set */
1054 delete_variable_1 (struct cpstack
**resultp
, int *delcountp
, struct varobj
*var
,
1055 int only_children_p
, int remove_from_parent_p
)
1057 struct varobj_child
*vc
;
1058 struct varobj_child
*next
;
1060 /* Delete any children of this variable, too. */
1061 for (vc
= var
->children
; vc
!= NULL
; vc
= next
)
1063 if (!remove_from_parent_p
)
1064 vc
->child
->parent
= NULL
;
1065 delete_variable_1 (resultp
, delcountp
, vc
->child
, 0, only_children_p
);
1070 /* if we were called to delete only the children we are done here */
1071 if (only_children_p
)
1074 /* Otherwise, add it to the list of deleted ones and proceed to do so */
1075 /* If the name is null, this is a temporary variable, that has not
1076 yet been installed, don't report it, it belongs to the caller... */
1077 if (var
->obj_name
!= NULL
)
1079 cppush (resultp
, strdup (var
->obj_name
));
1080 *delcountp
= *delcountp
+ 1;
1083 /* If this variable has a parent, remove it from its parent's list */
1084 /* OPTIMIZATION: if the parent of this variable is also being deleted,
1085 (as indicated by remove_from_parent_p) we don't bother doing an
1086 expensive list search to find the element to remove when we are
1087 discarding the list afterwards */
1088 if ((remove_from_parent_p
) &&
1089 (var
->parent
!= NULL
))
1091 remove_child_from_parent (var
->parent
, var
);
1094 if (var
->obj_name
!= NULL
)
1095 uninstall_variable (var
);
1097 /* Free memory associated with this variable */
1098 free_variable (var
);
1101 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
1103 install_variable (struct varobj
*var
)
1106 struct vlist
*newvl
;
1108 unsigned int index
= 0;
1111 for (chp
= var
->obj_name
; *chp
; chp
++)
1113 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
1116 cv
= *(varobj_table
+ index
);
1117 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
1121 error ("Duplicate variable object name");
1123 /* Add varobj to hash table */
1124 newvl
= xmalloc (sizeof (struct vlist
));
1125 newvl
->next
= *(varobj_table
+ index
);
1127 *(varobj_table
+ index
) = newvl
;
1129 /* If root, add varobj to root list */
1130 if (var
->root
->rootvar
== var
)
1132 /* Add to list of root variables */
1133 if (rootlist
== NULL
)
1134 var
->root
->next
= NULL
;
1136 var
->root
->next
= rootlist
;
1137 rootlist
= var
->root
;
1144 /* Unistall the object VAR. */
1146 uninstall_variable (struct varobj
*var
)
1150 struct varobj_root
*cr
;
1151 struct varobj_root
*prer
;
1153 unsigned int index
= 0;
1156 /* Remove varobj from hash table */
1157 for (chp
= var
->obj_name
; *chp
; chp
++)
1159 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
1162 cv
= *(varobj_table
+ index
);
1164 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
1171 fprintf_unfiltered (gdb_stdlog
, "Deleting %s\n", var
->obj_name
);
1175 warning ("Assertion failed: Could not find variable object \"%s\" to delete", var
->obj_name
);
1180 *(varobj_table
+ index
) = cv
->next
;
1182 prev
->next
= cv
->next
;
1186 /* If root, remove varobj from root list */
1187 if (var
->root
->rootvar
== var
)
1189 /* Remove from list of root variables */
1190 if (rootlist
== var
->root
)
1191 rootlist
= var
->root
->next
;
1196 while ((cr
!= NULL
) && (cr
->rootvar
!= var
))
1203 warning ("Assertion failed: Could not find varobj \"%s\" in root list", var
->obj_name
);
1209 prer
->next
= cr
->next
;
1216 /* Does a child with the name NAME exist in VAR? If so, return its data.
1217 If not, return NULL. */
1218 static struct varobj
*
1219 child_exists (struct varobj
*var
, char *name
)
1221 struct varobj_child
*vc
;
1223 for (vc
= var
->children
; vc
!= NULL
; vc
= vc
->next
)
1225 if (STREQ (vc
->child
->name
, name
))
1232 /* Create and install a child of the parent of the given name */
1233 static struct varobj
*
1234 create_child (struct varobj
*parent
, int index
, char *name
)
1236 struct varobj
*child
;
1239 child
= new_variable ();
1241 /* name is allocated by name_of_child */
1243 child
->index
= index
;
1244 child
->value
= value_of_child (parent
, index
);
1245 if (child
->value
== NULL
|| parent
->error
)
1247 child
->parent
= parent
;
1248 child
->root
= parent
->root
;
1249 childs_name
= (char *) xmalloc ((strlen (parent
->obj_name
) + strlen (name
) + 2)
1251 sprintf (childs_name
, "%s.%s", parent
->obj_name
, name
);
1252 child
->obj_name
= childs_name
;
1253 install_variable (child
);
1255 /* Save a pointer to this child in the parent */
1256 save_child_in_parent (parent
, child
);
1258 /* Note the type of this child */
1259 child
->type
= type_of_child (child
);
1264 /* FIXME: This should be a generic add to list */
1265 /* Save CHILD in the PARENT's data. */
1267 save_child_in_parent (struct varobj
*parent
, struct varobj
*child
)
1269 struct varobj_child
*vc
;
1271 /* Insert the child at the top */
1272 vc
= parent
->children
;
1274 (struct varobj_child
*) xmalloc (sizeof (struct varobj_child
));
1276 parent
->children
->next
= vc
;
1277 parent
->children
->child
= child
;
1280 /* FIXME: This should be a generic remove from list */
1281 /* Remove the CHILD from the PARENT's list of children. */
1283 remove_child_from_parent (struct varobj
*parent
, struct varobj
*child
)
1285 struct varobj_child
*vc
, *prev
;
1287 /* Find the child in the parent's list */
1289 for (vc
= parent
->children
; vc
!= NULL
;)
1291 if (vc
->child
== child
)
1298 parent
->children
= vc
->next
;
1300 prev
->next
= vc
->next
;
1306 * Miscellaneous utility functions.
1309 /* Allocate memory and initialize a new variable */
1310 static struct varobj
*
1315 var
= (struct varobj
*) xmalloc (sizeof (struct varobj
));
1317 var
->obj_name
= NULL
;
1322 var
->num_children
= -1;
1324 var
->children
= NULL
;
1331 /* Allocate memory and initialize a new root variable */
1332 static struct varobj
*
1333 new_root_variable (void)
1335 struct varobj
*var
= new_variable ();
1336 var
->root
= (struct varobj_root
*) xmalloc (sizeof (struct varobj_root
));;
1337 var
->root
->lang
= NULL
;
1338 var
->root
->exp
= NULL
;
1339 var
->root
->valid_block
= NULL
;
1340 var
->root
->frame
= (CORE_ADDR
) -1;
1341 var
->root
->use_selected_frame
= 0;
1342 var
->root
->rootvar
= NULL
;
1347 /* Free any allocated memory associated with VAR. */
1349 free_variable (struct varobj
*var
)
1351 /* Free the expression if this is a root variable. */
1352 if (var
->root
->rootvar
== var
)
1354 free_current_contents ((char **) &var
->root
->exp
);
1359 FREEIF (var
->obj_name
);
1364 do_free_variable_cleanup (void *var
)
1366 free_variable (var
);
1369 static struct cleanup
*
1370 make_cleanup_free_variable (struct varobj
*var
)
1372 return make_cleanup (do_free_variable_cleanup
, var
);
1375 /* This returns the type of the variable. This skips past typedefs
1376 and returns the real type of the variable. It also dereferences
1377 pointers and references. */
1378 static struct type
*
1379 get_type (struct varobj
*var
)
1384 while (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1385 type
= TYPE_TARGET_TYPE (type
);
1390 /* This returns the type of the variable, dereferencing pointers, too. */
1391 static struct type
*
1392 get_type_deref (struct varobj
*var
)
1396 type
= get_type (var
);
1398 if (type
!= NULL
&& (TYPE_CODE (type
) == TYPE_CODE_PTR
1399 || TYPE_CODE (type
) == TYPE_CODE_REF
))
1400 type
= get_target_type (type
);
1405 /* This returns the target type (or NULL) of TYPE, also skipping
1406 past typedefs, just like get_type (). */
1407 static struct type
*
1408 get_target_type (struct type
*type
)
1412 type
= TYPE_TARGET_TYPE (type
);
1413 while (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1414 type
= TYPE_TARGET_TYPE (type
);
1420 /* What is the default display for this variable? We assume that
1421 everything is "natural". Any exceptions? */
1422 static enum varobj_display_formats
1423 variable_default_display (struct varobj
*var
)
1425 return FORMAT_NATURAL
;
1428 /* This function is similar to gdb's value_equal, except that this
1429 one is "safe" -- it NEVER longjmps. It determines if the VAR's
1430 value is the same as VAL2. */
1432 my_value_equal (value_ptr val1
, value_ptr val2
, int *error2
)
1437 /* Special case: NULL values. If both are null, say
1439 if (val1
== NULL
&& val2
== NULL
)
1441 else if (val1
== NULL
|| val2
== NULL
)
1444 /* This is bogus, but unfortunately necessary. We must know
1445 exactly what caused an error -- reading val1 or val2 -- so
1446 that we can really determine if we think that something has changed. */
1449 /* We do need to catch errors here because the whole purpose
1450 is to test if value_equal() has errored */
1451 if (!gdb_value_equal (val1
, val1
, &r
))
1454 if (!gdb_value_equal (val2
, val2
, &r
))
1460 if (!gdb_value_equal (val1
, val2
, &r
))
1462 /* An error occurred, this could have happened if
1463 either val1 or val2 errored. ERR1 and ERR2 tell
1464 us which of these it is. If both errored, then
1465 we assume nothing has changed. If one of them is
1466 valid, though, then something has changed. */
1469 /* both the old and new values caused errors, so
1470 we say the value did not change */
1471 /* This is indeterminate, though. Perhaps we should
1472 be safe and say, yes, it changed anyway?? */
1484 /* FIXME: The following should be generic for any pointer */
1486 vpush (struct vstack
**pstack
, struct varobj
*var
)
1490 s
= (struct vstack
*) xmalloc (sizeof (struct vstack
));
1496 /* FIXME: The following should be generic for any pointer */
1497 static struct varobj
*
1498 vpop (struct vstack
**pstack
)
1503 if ((*pstack
)->var
== NULL
&& (*pstack
)->next
== NULL
)
1508 *pstack
= (*pstack
)->next
;
1514 /* FIXME: The following should be generic for any pointer */
1516 cppush (struct cpstack
**pstack
, char *name
)
1520 s
= (struct cpstack
*) xmalloc (sizeof (struct cpstack
));
1526 /* FIXME: The following should be generic for any pointer */
1528 cppop (struct cpstack
**pstack
)
1533 if ((*pstack
)->name
== NULL
&& (*pstack
)->next
== NULL
)
1538 *pstack
= (*pstack
)->next
;
1545 * Language-dependencies
1548 /* Common entry points */
1550 /* Get the language of variable VAR. */
1551 static enum varobj_languages
1552 variable_language (struct varobj
*var
)
1554 enum varobj_languages lang
;
1556 switch (var
->root
->exp
->language_defn
->la_language
)
1562 case language_cplus
:
1573 /* Return the number of children for a given variable.
1574 The result of this function is defined by the language
1575 implementation. The number of children returned by this function
1576 is the number of children that the user will see in the variable
1579 number_of_children (struct varobj
*var
)
1581 return (*var
->root
->lang
->number_of_children
) (var
);;
1584 /* What is the expression for the root varobj VAR? Returns a malloc'd string. */
1586 name_of_variable (struct varobj
*var
)
1588 return (*var
->root
->lang
->name_of_variable
) (var
);
1591 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd string. */
1593 name_of_child (struct varobj
*var
, int index
)
1595 return (*var
->root
->lang
->name_of_child
) (var
, index
);
1598 /* What is the value_ptr of the root variable VAR?
1599 TYPE_CHANGED controls what to do if the type of a
1600 use_selected_frame = 1 variable changes. On input,
1601 TYPE_CHANGED = 1 means discard the old varobj, and replace
1602 it with this one. TYPE_CHANGED = 0 means leave it around.
1603 NB: In both cases, var_handle will point to the new varobj,
1604 so if you use TYPE_CHANGED = 0, you will have to stash the
1605 old varobj pointer away somewhere before calling this.
1606 On return, TYPE_CHANGED will be 1 if the type has changed, and
1609 value_of_root (struct varobj
**var_handle
, int *type_changed
)
1613 if (var_handle
== NULL
)
1618 /* This should really be an exception, since this should
1619 only get called with a root variable. */
1621 if (var
->root
->rootvar
!= var
)
1624 if (var
->root
->use_selected_frame
)
1626 struct varobj
*tmp_var
;
1627 char *old_type
, *new_type
;
1628 old_type
= varobj_get_type (var
);
1629 tmp_var
= varobj_create (NULL
, var
->name
, (CORE_ADDR
) 0,
1630 USE_SELECTED_FRAME
);
1631 if (tmp_var
== NULL
)
1635 new_type
= varobj_get_type (tmp_var
);
1636 if (strcmp(old_type
, new_type
) == 0)
1638 varobj_delete (tmp_var
, NULL
, 0);
1646 savestring (var
->obj_name
, strlen (var
->obj_name
));
1647 uninstall_variable (var
);
1651 tmp_var
->obj_name
= varobj_gen_name ();
1653 install_variable (tmp_var
);
1654 *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 switch (TYPE_CODE (target
))
1772 case TYPE_CODE_STRUCT
:
1773 case TYPE_CODE_UNION
:
1774 children
= TYPE_NFIELDS (target
);
1777 case TYPE_CODE_FUNC
:
1782 /* Don't dereference char* or void*. */
1783 if (TYPE_NAME (target
) != NULL
1784 && (STREQ (TYPE_NAME (target
), "char")
1785 || STREQ (TYPE_NAME (target
), "void")))
1793 /* Other types have no children */
1801 c_name_of_variable (struct varobj
*parent
)
1803 return savestring (parent
->name
, strlen (parent
->name
));
1807 c_name_of_child (struct varobj
*parent
, int index
)
1810 struct type
*target
;
1814 type
= get_type (parent
);
1815 target
= get_target_type (type
);
1817 switch (TYPE_CODE (type
))
1819 case TYPE_CODE_ARRAY
:
1821 /* We never get here unless parent->num_children is greater than 0... */
1823 while ((int) pow ((double) 10, (double) len
) < index
)
1825 name
= (char *) xmalloc (1 + len
* sizeof (char));
1826 sprintf (name
, "%d", index
);
1830 case TYPE_CODE_STRUCT
:
1831 case TYPE_CODE_UNION
:
1832 string
= TYPE_FIELD_NAME (type
, index
);
1833 name
= savestring (string
, strlen (string
));
1837 switch (TYPE_CODE (target
))
1839 case TYPE_CODE_STRUCT
:
1840 case TYPE_CODE_UNION
:
1841 string
= TYPE_FIELD_NAME (target
, index
);
1842 name
= savestring (string
, strlen (string
));
1846 name
= (char *) xmalloc ((strlen (parent
->name
) + 2) * sizeof (char));
1847 sprintf (name
, "*%s", parent
->name
);
1853 /* This should not happen */
1854 name
= xstrdup ("???");
1861 c_value_of_root (struct varobj
**var_handle
)
1864 struct varobj
*var
= *var_handle
;
1865 struct frame_info
*fi
;
1868 /* Only root variables can be updated... */
1869 if (var
->root
->rootvar
!= var
)
1870 /* Not a root var */
1874 /* Determine whether the variable is still around. */
1875 if (var
->root
->valid_block
== NULL
)
1879 reinit_frame_cache ();
1882 fi
= find_frame_addr_in_frame_chain (var
->root
->frame
);
1884 within_scope
= fi
!= NULL
;
1885 /* FIXME: select_frame could fail */
1887 select_frame (fi
, -1);
1892 /* We need to catch errors here, because if evaluate
1893 expression fails we just want to make val->error = 1 and
1895 if (gdb_evaluate_expression (var
->root
->exp
, &new_val
))
1897 if (VALUE_LAZY (new_val
))
1899 /* We need to catch errors because if
1900 value_fetch_lazy fails we still want to continue
1901 (after making val->error = 1) */
1902 /* FIXME: Shouldn't be using VALUE_CONTENTS? The
1903 comment on value_fetch_lazy() says it is only
1904 called from the macro... */
1905 if (!gdb_value_fetch_lazy (new_val
))
1914 release_value (new_val
);
1922 c_value_of_child (struct varobj
*parent
, int index
)
1924 value_ptr value
, temp
, indval
;
1925 struct type
*type
, *target
;
1928 type
= get_type (parent
);
1929 target
= get_target_type (type
);
1930 name
= name_of_child (parent
, index
);
1931 temp
= parent
->value
;
1936 switch (TYPE_CODE (type
))
1938 case TYPE_CODE_ARRAY
:
1940 /* This breaks if the array lives in a (vector) register. */
1941 value
= value_slice (temp
, index
, 1);
1942 temp
= value_coerce_array (value
);
1943 gdb_value_ind (temp
, &value
);
1945 indval
= value_from_longest (builtin_type_int
, (LONGEST
) index
);
1946 gdb_value_subscript (temp
, indval
, &value
);
1950 case TYPE_CODE_STRUCT
:
1951 case TYPE_CODE_UNION
:
1952 value
= value_struct_elt (&temp
, NULL
, name
, NULL
, "vstructure");
1956 switch (TYPE_CODE (target
))
1958 case TYPE_CODE_STRUCT
:
1959 case TYPE_CODE_UNION
:
1960 value
= value_struct_elt (&temp
, NULL
, name
, NULL
, "vstructure");
1964 gdb_value_ind (temp
, &value
);
1975 release_value (value
);
1980 static struct type
*
1981 c_type_of_child (struct varobj
*parent
, int index
)
1984 char *name
= name_of_child (parent
, index
);
1986 switch (TYPE_CODE (parent
->type
))
1988 case TYPE_CODE_ARRAY
:
1989 type
= TYPE_TARGET_TYPE (parent
->type
);
1992 case TYPE_CODE_STRUCT
:
1993 case TYPE_CODE_UNION
:
1994 type
= lookup_struct_elt_type (parent
->type
, name
, 0);
1998 switch (TYPE_CODE (TYPE_TARGET_TYPE (parent
->type
)))
2000 case TYPE_CODE_STRUCT
:
2001 case TYPE_CODE_UNION
:
2002 type
= lookup_struct_elt_type (parent
->type
, name
, 0);
2006 type
= TYPE_TARGET_TYPE (parent
->type
);
2012 /* This should not happen as only the above types have children */
2013 warning ("Child of parent whose type does not allow children");
2014 /* FIXME: Can we still go on? */
2023 c_variable_editable (struct varobj
*var
)
2025 switch (TYPE_CODE (get_type (var
)))
2027 case TYPE_CODE_STRUCT
:
2028 case TYPE_CODE_UNION
:
2029 case TYPE_CODE_ARRAY
:
2030 case TYPE_CODE_FUNC
:
2031 case TYPE_CODE_MEMBER
:
2032 case TYPE_CODE_METHOD
:
2043 c_value_of_variable (struct varobj
*var
)
2048 if (var
->value
!= NULL
)
2052 /* This can happen if we attempt to get the value of a struct
2053 member when the parent is an invalid pointer. */
2054 return xstrdup ("???");
2057 /* BOGUS: if val_print sees a struct/class, it will print out its
2058 children instead of "{...}" */
2059 type
= get_type (var
);
2060 switch (TYPE_CODE (type
))
2062 case TYPE_CODE_STRUCT
:
2063 case TYPE_CODE_UNION
:
2064 return xstrdup ("{...}");
2067 case TYPE_CODE_ARRAY
:
2070 sprintf (number
, "[%d]", var
->num_children
);
2071 return xstrdup (number
);
2078 struct ui_file
*stb
= mem_fileopen ();
2079 struct cleanup
*old_chain
= make_cleanup_ui_file_delete (stb
);
2082 if (VALUE_LAZY (val
))
2083 gdb_value_fetch_lazy (val
);
2084 val_print (VALUE_TYPE (val
), VALUE_CONTENTS_RAW (val
), 0,
2085 VALUE_ADDRESS (val
),
2086 stb
, format_code
[(int) var
->format
], 1, 0, 0);
2087 thevalue
= ui_file_xstrdup (stb
, &dummy
);
2088 do_cleanups (old_chain
);
2099 cplus_number_of_children (struct varobj
*var
)
2102 int children
, dont_know
;
2107 if (!CPLUS_FAKE_CHILD (var
))
2109 type
= get_type_deref (var
);
2111 if (((TYPE_CODE (type
)) == TYPE_CODE_STRUCT
) ||
2112 ((TYPE_CODE (type
)) == TYPE_CODE_UNION
))
2116 cplus_class_num_children (type
, kids
);
2117 if (kids
[v_public
] != 0)
2119 if (kids
[v_private
] != 0)
2121 if (kids
[v_protected
] != 0)
2124 /* Add any baseclasses */
2125 children
+= TYPE_N_BASECLASSES (type
);
2128 /* FIXME: save children in var */
2135 type
= get_type_deref (var
->parent
);
2137 cplus_class_num_children (type
, kids
);
2138 if (STREQ (var
->name
, "public"))
2139 children
= kids
[v_public
];
2140 else if (STREQ (var
->name
, "private"))
2141 children
= kids
[v_private
];
2143 children
= kids
[v_protected
];
2148 children
= c_number_of_children (var
);
2153 /* Compute # of public, private, and protected variables in this class.
2154 That means we need to descend into all baseclasses and find out
2155 how many are there, too. */
2157 cplus_class_num_children (struct type
*type
, int children
[3])
2161 children
[v_public
] = 0;
2162 children
[v_private
] = 0;
2163 children
[v_protected
] = 0;
2165 for (i
= TYPE_N_BASECLASSES (type
); i
< TYPE_NFIELDS (type
); i
++)
2167 /* If we have a virtual table pointer, omit it. */
2168 if (TYPE_VPTR_BASETYPE (type
) == type
2169 && TYPE_VPTR_FIELDNO (type
) == i
)
2172 if (TYPE_FIELD_PROTECTED (type
, i
))
2173 children
[v_protected
]++;
2174 else if (TYPE_FIELD_PRIVATE (type
, i
))
2175 children
[v_private
]++;
2177 children
[v_public
]++;
2182 cplus_name_of_variable (struct varobj
*parent
)
2184 return c_name_of_variable (parent
);
2188 cplus_name_of_child (struct varobj
*parent
, int index
)
2194 if (CPLUS_FAKE_CHILD (parent
))
2196 /* Looking for children of public, private, or protected. */
2197 type
= get_type_deref (parent
->parent
);
2200 type
= get_type_deref (parent
);
2203 switch (TYPE_CODE (type
))
2205 case TYPE_CODE_STRUCT
:
2206 case TYPE_CODE_UNION
:
2207 cplus_class_num_children (type
, children
);
2209 if (CPLUS_FAKE_CHILD (parent
))
2211 /* FIXME: This assumes that type orders
2212 inherited, public, private, protected */
2213 int i
= index
+ TYPE_N_BASECLASSES (type
);
2214 if (STREQ (parent
->name
, "private") || STREQ (parent
->name
, "protected"))
2215 i
+= children
[v_public
];
2216 if (STREQ (parent
->name
, "protected"))
2217 i
+= children
[v_private
];
2219 name
= TYPE_FIELD_NAME (type
, i
);
2221 else if (index
< TYPE_N_BASECLASSES (type
))
2222 name
= TYPE_FIELD_NAME (type
, index
);
2225 /* Everything beyond the baseclasses can
2226 only be "public", "private", or "protected" */
2227 index
-= TYPE_N_BASECLASSES (type
);
2231 if (children
[v_public
] != 0)
2237 if (children
[v_private
] != 0)
2243 if (children
[v_protected
] != 0)
2260 return c_name_of_child (parent
, index
);
2264 name
= savestring (name
, strlen (name
));
2271 cplus_value_of_root (struct varobj
**var_handle
)
2273 return c_value_of_root (var_handle
);
2277 cplus_value_of_child (struct varobj
*parent
, int index
)
2283 if (CPLUS_FAKE_CHILD (parent
))
2284 type
= get_type_deref (parent
->parent
);
2286 type
= get_type_deref (parent
);
2289 name
= name_of_child (parent
, index
);
2291 if (((TYPE_CODE (type
)) == TYPE_CODE_STRUCT
) ||
2292 ((TYPE_CODE (type
)) == TYPE_CODE_UNION
))
2294 if (CPLUS_FAKE_CHILD (parent
))
2296 value_ptr temp
= parent
->parent
->value
;
2297 value
= value_struct_elt (&temp
, NULL
, name
,
2298 NULL
, "cplus_structure");
2299 release_value (value
);
2301 else if (index
>= TYPE_N_BASECLASSES (type
))
2303 /* public, private, or protected */
2309 if (parent
->value
!= NULL
)
2313 if (TYPE_CODE (VALUE_TYPE (parent
->value
)) == TYPE_CODE_PTR
2314 || TYPE_CODE (VALUE_TYPE (parent
->value
)) == TYPE_CODE_REF
)
2315 gdb_value_ind (parent
->value
, &temp
);
2317 temp
= parent
->value
;
2319 value
= value_cast (TYPE_FIELD_TYPE (type
, index
), temp
);
2320 release_value (value
);
2326 return c_value_of_child (parent
, index
);
2331 static struct type
*
2332 cplus_type_of_child (struct varobj
*parent
, int index
)
2334 struct type
*type
, *t
;
2336 t
= get_type_deref (parent
);
2338 switch (TYPE_CODE (t
))
2340 case TYPE_CODE_STRUCT
:
2341 case TYPE_CODE_UNION
:
2342 if (index
>= TYPE_N_BASECLASSES (t
))
2350 type
= TYPE_FIELD_TYPE (t
, index
);
2359 return c_type_of_child (parent
, index
);
2365 cplus_variable_editable (struct varobj
*var
)
2367 if (CPLUS_FAKE_CHILD (var
))
2370 return c_variable_editable (var
);
2374 cplus_value_of_variable (struct varobj
*var
)
2377 /* If we have one of our special types, don't print out
2379 if (CPLUS_FAKE_CHILD (var
))
2380 return xstrdup ("");
2382 return c_value_of_variable (var
);
2388 java_number_of_children (struct varobj
*var
)
2390 return cplus_number_of_children (var
);
2394 java_name_of_variable (struct varobj
*parent
)
2398 name
= cplus_name_of_variable (parent
);
2399 /* If the name has "-" in it, it is because we
2400 needed to escape periods in the name... */
2403 while (*p
!= '\000')
2414 java_name_of_child (struct varobj
*parent
, int index
)
2418 name
= cplus_name_of_child (parent
, index
);
2419 /* Escape any periods in the name... */
2422 while (*p
!= '\000')
2433 java_value_of_root (struct varobj
**var_handle
)
2435 return cplus_value_of_root (var_handle
);
2439 java_value_of_child (struct varobj
*parent
, int index
)
2441 return cplus_value_of_child (parent
, index
);
2444 static struct type
*
2445 java_type_of_child (struct varobj
*parent
, int index
)
2447 return cplus_type_of_child (parent
, index
);
2451 java_variable_editable (struct varobj
*var
)
2453 return cplus_variable_editable (var
);
2457 java_value_of_variable (struct varobj
*var
)
2459 return cplus_value_of_variable (var
);
2462 extern void _initialize_varobj (void);
2464 _initialize_varobj (void)
2466 int sizeof_table
= sizeof (struct vlist
*) * VAROBJ_TABLE_SIZE
;
2468 varobj_table
= xmalloc (sizeof_table
);
2469 memset (varobj_table
, 0, sizeof_table
);
2472 add_set_cmd ("debugvarobj", class_maintenance
, var_zinteger
,
2473 (char *) &varobjdebug
,
2474 "Set varobj debugging.\n\
2475 When non-zero, varobj debugging is enabled.", &setlist
),