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 val
= value_assign (temp
, value
);
822 VALUE_ADDRESS (val
) -= offset
;
823 value_free (var
->value
);
826 input_radix
= saved_input_radix
;
833 /* Returns a malloc'ed list with all root variable objects */
835 varobj_list (struct varobj
***varlist
)
838 struct varobj_root
*croot
;
839 int mycount
= rootcount
;
841 /* Alloc (rootcount + 1) entries for the result */
842 *varlist
= xmalloc ((rootcount
+ 1) * sizeof (struct varobj
*));
846 while ((croot
!= NULL
) && (mycount
> 0))
848 *cv
= croot
->rootvar
;
853 /* Mark the end of the list */
856 if (mycount
|| (croot
!= NULL
))
857 warning ("varobj_list: assertion failed - wrong tally of root vars (%d:%d)",
863 /* Update the values for a variable and its children. This is a
864 two-pronged attack. First, re-parse the value for the root's
865 expression to see if it's changed. Then go all the way
866 through its children, reconstructing them and noting if they've
869 -1 if there was an error updating the varobj
870 -2 if the type changed
871 Otherwise it is the number of children + parent changed
873 Only root variables can be updated... */
876 varobj_update (struct varobj
*var
, struct varobj
***changelist
)
885 struct varobj
**templist
;
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 (var
->root
->rootvar
!= var
)
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 (&var
, &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
, var
);
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 (var
) && !my_value_equal (var
->value
, new, &error2
))
932 vpush (&result
, var
);
934 /* error2 replaces var->error since this new value
935 WILL replace the old one. */
939 /* We must always keep around the new value for this root
940 variable expression, or we lose the updated children! */
941 value_free (var
->value
);
944 /* Initialize a stack */
945 vpush (&stack
, NULL
);
947 /* Push the root's children */
948 if (var
->children
!= NULL
)
950 struct varobj_child
*c
;
951 for (c
= var
->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
, strdup (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 (var
, name
)
1219 struct varobj
*var
; /* Parent */
1220 char *name
; /* name of child */
1222 struct varobj_child
*vc
;
1224 for (vc
= var
->children
; vc
!= NULL
; vc
= vc
->next
)
1226 if (STREQ (vc
->child
->name
, name
))
1233 /* Create and install a child of the parent of the given name */
1234 static struct varobj
*
1235 create_child (struct varobj
*parent
, int index
, char *name
)
1237 struct varobj
*child
;
1240 child
= new_variable ();
1242 /* name is allocated by name_of_child */
1244 child
->index
= index
;
1245 child
->value
= value_of_child (parent
, index
);
1246 if (child
->value
== NULL
|| parent
->error
)
1248 child
->parent
= parent
;
1249 child
->root
= parent
->root
;
1250 childs_name
= (char *) xmalloc ((strlen (parent
->obj_name
) + strlen (name
) + 2)
1252 sprintf (childs_name
, "%s.%s", parent
->obj_name
, name
);
1253 child
->obj_name
= childs_name
;
1254 install_variable (child
);
1256 /* Save a pointer to this child in the parent */
1257 save_child_in_parent (parent
, child
);
1259 /* Note the type of this child */
1260 child
->type
= type_of_child (child
);
1265 /* FIXME: This should be a generic add to list */
1266 /* Save CHILD in the PARENT's data. */
1268 save_child_in_parent (struct varobj
*parent
, struct varobj
*child
)
1270 struct varobj_child
*vc
;
1272 /* Insert the child at the top */
1273 vc
= parent
->children
;
1275 (struct varobj_child
*) xmalloc (sizeof (struct varobj_child
));
1277 parent
->children
->next
= vc
;
1278 parent
->children
->child
= child
;
1281 /* FIXME: This should be a generic remove from list */
1282 /* Remove the CHILD from the PARENT's list of children. */
1284 remove_child_from_parent (struct varobj
*parent
, struct varobj
*child
)
1286 struct varobj_child
*vc
, *prev
;
1288 /* Find the child in the parent's list */
1290 for (vc
= parent
->children
; vc
!= NULL
;)
1292 if (vc
->child
== child
)
1299 parent
->children
= vc
->next
;
1301 prev
->next
= vc
->next
;
1307 * Miscellaneous utility functions.
1310 /* Allocate memory and initialize a new variable */
1311 static struct varobj
*
1316 var
= (struct varobj
*) xmalloc (sizeof (struct varobj
));
1318 var
->obj_name
= NULL
;
1323 var
->num_children
= -1;
1325 var
->children
= NULL
;
1332 /* Allocate memory and initialize a new root variable */
1333 static struct varobj
*
1334 new_root_variable (void)
1336 struct varobj
*var
= new_variable ();
1337 var
->root
= (struct varobj_root
*) xmalloc (sizeof (struct varobj_root
));;
1338 var
->root
->lang
= NULL
;
1339 var
->root
->exp
= NULL
;
1340 var
->root
->valid_block
= NULL
;
1341 var
->root
->frame
= (CORE_ADDR
) -1;
1342 var
->root
->use_selected_frame
= 0;
1343 var
->root
->rootvar
= NULL
;
1348 /* Free any allocated memory associated with VAR. */
1350 free_variable (struct varobj
*var
)
1352 /* Free the expression if this is a root variable. */
1353 if (var
->root
->rootvar
== var
)
1355 free_current_contents ((char **) &var
->root
->exp
);
1360 FREEIF (var
->obj_name
);
1365 do_free_variable_cleanup (void *var
)
1367 free_variable (var
);
1370 static struct cleanup
*
1371 make_cleanup_free_variable (struct varobj
*var
)
1373 return make_cleanup (do_free_variable_cleanup
, var
);
1376 /* This returns the type of the variable. This skips past typedefs
1377 and returns the real type of the variable. It also dereferences
1378 pointers and references. */
1379 static struct type
*
1380 get_type (struct varobj
*var
)
1385 while (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1386 type
= TYPE_TARGET_TYPE (type
);
1391 /* This returns the type of the variable, dereferencing pointers, too. */
1392 static struct type
*
1393 get_type_deref (struct varobj
*var
)
1397 type
= get_type (var
);
1399 if (type
!= NULL
&& (TYPE_CODE (type
) == TYPE_CODE_PTR
1400 || TYPE_CODE (type
) == TYPE_CODE_REF
))
1401 type
= get_target_type (type
);
1406 /* This returns the target type (or NULL) of TYPE, also skipping
1407 past typedefs, just like get_type (). */
1408 static struct type
*
1409 get_target_type (struct type
*type
)
1413 type
= TYPE_TARGET_TYPE (type
);
1414 while (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1415 type
= TYPE_TARGET_TYPE (type
);
1421 /* What is the default display for this variable? We assume that
1422 everything is "natural". Any exceptions? */
1423 static enum varobj_display_formats
1424 variable_default_display (struct varobj
*var
)
1426 return FORMAT_NATURAL
;
1429 /* This function is similar to gdb's value_equal, except that this
1430 one is "safe" -- it NEVER longjmps. It determines if the VAR's
1431 value is the same as VAL2. */
1433 my_value_equal (value_ptr val1
, value_ptr val2
, int *error2
)
1438 /* Special case: NULL values. If both are null, say
1440 if (val1
== NULL
&& val2
== NULL
)
1442 else if (val1
== NULL
|| val2
== NULL
)
1445 /* This is bogus, but unfortunately necessary. We must know
1446 exactly what caused an error -- reading val1 or val2 -- so
1447 that we can really determine if we think that something has changed. */
1450 /* We do need to catch errors here because the whole purpose
1451 is to test if value_equal() has errored */
1452 if (!gdb_value_equal (val1
, val1
, &r
))
1455 if (!gdb_value_equal (val2
, val2
, &r
))
1461 if (!gdb_value_equal (val1
, val2
, &r
))
1463 /* An error occurred, this could have happened if
1464 either val1 or val2 errored. ERR1 and ERR2 tell
1465 us which of these it is. If both errored, then
1466 we assume nothing has changed. If one of them is
1467 valid, though, then something has changed. */
1470 /* both the old and new values caused errors, so
1471 we say the value did not change */
1472 /* This is indeterminate, though. Perhaps we should
1473 be safe and say, yes, it changed anyway?? */
1485 /* FIXME: The following should be generic for any pointer */
1487 vpush (struct vstack
**pstack
, struct varobj
*var
)
1491 s
= (struct vstack
*) xmalloc (sizeof (struct vstack
));
1497 /* FIXME: The following should be generic for any pointer */
1498 static struct varobj
*
1499 vpop (struct vstack
**pstack
)
1504 if ((*pstack
)->var
== NULL
&& (*pstack
)->next
== NULL
)
1509 *pstack
= (*pstack
)->next
;
1515 /* FIXME: The following should be generic for any pointer */
1517 cppush (struct cpstack
**pstack
, char *name
)
1521 s
= (struct cpstack
*) xmalloc (sizeof (struct cpstack
));
1527 /* FIXME: The following should be generic for any pointer */
1529 cppop (struct cpstack
**pstack
)
1534 if ((*pstack
)->name
== NULL
&& (*pstack
)->next
== NULL
)
1539 *pstack
= (*pstack
)->next
;
1546 * Language-dependencies
1549 /* Common entry points */
1551 /* Get the language of variable VAR. */
1552 static enum varobj_languages
1553 variable_language (struct varobj
*var
)
1555 enum varobj_languages lang
;
1557 switch (var
->root
->exp
->language_defn
->la_language
)
1563 case language_cplus
:
1574 /* Return the number of children for a given variable.
1575 The result of this function is defined by the language
1576 implementation. The number of children returned by this function
1577 is the number of children that the user will see in the variable
1580 number_of_children (struct varobj
*var
)
1582 return (*var
->root
->lang
->number_of_children
) (var
);;
1585 /* What is the expression for the root varobj VAR? Returns a malloc'd string. */
1587 name_of_variable (struct varobj
*var
)
1589 return (*var
->root
->lang
->name_of_variable
) (var
);
1592 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd string. */
1594 name_of_child (struct varobj
*var
, int index
)
1596 return (*var
->root
->lang
->name_of_child
) (var
, index
);
1599 /* What is the value_ptr of the root variable VAR?
1600 TYPE_CHANGED controls what to do if the type of a
1601 use_selected_frame = 1 variable changes. On input,
1602 TYPE_CHANGED = 1 means discard the old varobj, and replace
1603 it with this one. TYPE_CHANGED = 0 means leave it around.
1604 NB: In both cases, var_handle will point to the new varobj,
1605 so if you use TYPE_CHANGED = 0, you will have to stash the
1606 old varobj pointer away somewhere before calling this.
1607 On return, TYPE_CHANGED will be 1 if the type has changed, and
1610 value_of_root (struct varobj
**var_handle
, int *type_changed
)
1614 if (var_handle
== NULL
)
1619 /* This should really be an exception, since this should
1620 only get called with a root variable. */
1622 if (var
->root
->rootvar
!= var
)
1625 if (var
->root
->use_selected_frame
)
1627 struct varobj
*tmp_var
;
1628 char *old_type
, *new_type
;
1629 old_type
= varobj_get_type (var
);
1630 tmp_var
= varobj_create (NULL
, var
->name
, (CORE_ADDR
) 0,
1631 USE_SELECTED_FRAME
);
1632 if (tmp_var
== NULL
)
1636 new_type
= varobj_get_type (tmp_var
);
1637 if (strcmp(old_type
, new_type
) == 0)
1639 varobj_delete (tmp_var
, NULL
, 0);
1647 savestring (var
->obj_name
, strlen (var
->obj_name
));
1648 uninstall_variable (var
);
1652 tmp_var
->obj_name
= varobj_gen_name ();
1654 install_variable (tmp_var
);
1655 *var_handle
= tmp_var
;
1664 return (*var
->root
->lang
->value_of_root
) (var_handle
);
1667 /* What is the value_ptr for the INDEX'th child of PARENT? */
1669 value_of_child (struct varobj
*parent
, int index
)
1673 value
= (*parent
->root
->lang
->value_of_child
) (parent
, index
);
1675 /* If we're being lazy, fetch the real value of the variable. */
1676 if (value
!= NULL
&& VALUE_LAZY (value
))
1677 gdb_value_fetch_lazy (value
);
1682 /* What is the type of VAR? */
1683 static struct type
*
1684 type_of_child (struct varobj
*var
)
1687 /* If the child had no evaluation errors, var->value
1688 will be non-NULL and contain a valid type. */
1689 if (var
->value
!= NULL
)
1690 return VALUE_TYPE (var
->value
);
1692 /* Otherwise, we must compute the type. */
1693 return (*var
->root
->lang
->type_of_child
) (var
->parent
, var
->index
);
1696 /* Is this variable editable? Use the variable's type to make
1697 this determination. */
1699 variable_editable (struct varobj
*var
)
1701 return (*var
->root
->lang
->variable_editable
) (var
);
1704 /* GDB already has a command called "value_of_variable". Sigh. */
1706 my_value_of_variable (struct varobj
*var
)
1708 return (*var
->root
->lang
->value_of_variable
) (var
);
1711 /* Is VAR something that can change? Depending on language,
1712 some variable's values never change. For example,
1713 struct and unions never change values. */
1715 type_changeable (struct varobj
*var
)
1720 if (CPLUS_FAKE_CHILD (var
))
1723 type
= get_type (var
);
1725 switch (TYPE_CODE (type
))
1727 case TYPE_CODE_STRUCT
:
1728 case TYPE_CODE_UNION
:
1729 case TYPE_CODE_ARRAY
:
1742 c_number_of_children (struct varobj
*var
)
1745 struct type
*target
;
1748 type
= get_type (var
);
1749 target
= get_target_type (type
);
1752 switch (TYPE_CODE (type
))
1754 case TYPE_CODE_ARRAY
:
1755 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (target
) > 0
1756 && TYPE_ARRAY_UPPER_BOUND_TYPE (type
) != BOUND_CANNOT_BE_DETERMINED
)
1757 children
= TYPE_LENGTH (type
) / TYPE_LENGTH (target
);
1762 case TYPE_CODE_STRUCT
:
1763 case TYPE_CODE_UNION
:
1764 children
= TYPE_NFIELDS (type
);
1768 /* This is where things get compilcated. All pointers have one child.
1769 Except, of course, for struct and union ptr, which we automagically
1770 dereference for the user and function ptrs, which have no children. */
1771 switch (TYPE_CODE (target
))
1773 case TYPE_CODE_STRUCT
:
1774 case TYPE_CODE_UNION
:
1775 children
= TYPE_NFIELDS (target
);
1778 case TYPE_CODE_FUNC
:
1783 /* Don't dereference char* or void*. */
1784 if (TYPE_NAME (target
) != NULL
1785 && (STREQ (TYPE_NAME (target
), "char")
1786 || STREQ (TYPE_NAME (target
), "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 (type
, children
)
2164 children
[v_public
] = 0;
2165 children
[v_private
] = 0;
2166 children
[v_protected
] = 0;
2168 for (i
= TYPE_N_BASECLASSES (type
); i
< TYPE_NFIELDS (type
); i
++)
2170 /* If we have a virtual table pointer, omit it. */
2171 if (TYPE_VPTR_BASETYPE (type
) == type
2172 && TYPE_VPTR_FIELDNO (type
) == i
)
2175 if (TYPE_FIELD_PROTECTED (type
, i
))
2176 children
[v_protected
]++;
2177 else if (TYPE_FIELD_PRIVATE (type
, i
))
2178 children
[v_private
]++;
2180 children
[v_public
]++;
2185 cplus_name_of_variable (struct varobj
*parent
)
2187 return c_name_of_variable (parent
);
2191 cplus_name_of_child (struct varobj
*parent
, int index
)
2197 if (CPLUS_FAKE_CHILD (parent
))
2199 /* Looking for children of public, private, or protected. */
2200 type
= get_type_deref (parent
->parent
);
2203 type
= get_type_deref (parent
);
2206 switch (TYPE_CODE (type
))
2208 case TYPE_CODE_STRUCT
:
2209 case TYPE_CODE_UNION
:
2210 cplus_class_num_children (type
, children
);
2212 if (CPLUS_FAKE_CHILD (parent
))
2214 /* FIXME: This assumes that type orders
2215 inherited, public, private, protected */
2216 int i
= index
+ TYPE_N_BASECLASSES (type
);
2217 if (STREQ (parent
->name
, "private") || STREQ (parent
->name
, "protected"))
2218 i
+= children
[v_public
];
2219 if (STREQ (parent
->name
, "protected"))
2220 i
+= children
[v_private
];
2222 name
= TYPE_FIELD_NAME (type
, i
);
2224 else if (index
< TYPE_N_BASECLASSES (type
))
2225 name
= TYPE_FIELD_NAME (type
, index
);
2228 /* Everything beyond the baseclasses can
2229 only be "public", "private", or "protected" */
2230 index
-= TYPE_N_BASECLASSES (type
);
2234 if (children
[v_public
] != 0)
2240 if (children
[v_private
] != 0)
2246 if (children
[v_protected
] != 0)
2263 return c_name_of_child (parent
, index
);
2267 name
= savestring (name
, strlen (name
));
2274 cplus_value_of_root (struct varobj
**var_handle
)
2276 return c_value_of_root (var_handle
);
2280 cplus_value_of_child (struct varobj
*parent
, int index
)
2286 if (CPLUS_FAKE_CHILD (parent
))
2287 type
= get_type_deref (parent
->parent
);
2289 type
= get_type_deref (parent
);
2292 name
= name_of_child (parent
, index
);
2294 if (((TYPE_CODE (type
)) == TYPE_CODE_STRUCT
) ||
2295 ((TYPE_CODE (type
)) == TYPE_CODE_UNION
))
2297 if (CPLUS_FAKE_CHILD (parent
))
2299 value_ptr temp
= parent
->parent
->value
;
2300 value
= value_struct_elt (&temp
, NULL
, name
,
2301 NULL
, "cplus_structure");
2302 release_value (value
);
2304 else if (index
>= TYPE_N_BASECLASSES (type
))
2306 /* public, private, or protected */
2312 if (parent
->value
!= NULL
)
2316 if (TYPE_CODE (VALUE_TYPE (parent
->value
)) == TYPE_CODE_PTR
2317 || TYPE_CODE (VALUE_TYPE (parent
->value
)) == TYPE_CODE_REF
)
2318 gdb_value_ind (parent
->value
, &temp
);
2320 temp
= parent
->value
;
2322 value
= value_cast (TYPE_FIELD_TYPE (type
, index
), temp
);
2323 release_value (value
);
2329 return c_value_of_child (parent
, index
);
2334 static struct type
*
2335 cplus_type_of_child (struct varobj
*parent
, int index
)
2337 struct type
*type
, *t
;
2339 t
= get_type_deref (parent
);
2341 switch (TYPE_CODE (t
))
2343 case TYPE_CODE_STRUCT
:
2344 case TYPE_CODE_UNION
:
2345 if (index
>= TYPE_N_BASECLASSES (t
))
2353 type
= TYPE_FIELD_TYPE (t
, index
);
2362 return c_type_of_child (parent
, index
);
2368 cplus_variable_editable (struct varobj
*var
)
2370 if (CPLUS_FAKE_CHILD (var
))
2373 return c_variable_editable (var
);
2377 cplus_value_of_variable (struct varobj
*var
)
2380 /* If we have one of our special types, don't print out
2382 if (CPLUS_FAKE_CHILD (var
))
2383 return xstrdup ("");
2385 return c_value_of_variable (var
);
2391 java_number_of_children (struct varobj
*var
)
2393 return cplus_number_of_children (var
);
2397 java_name_of_variable (struct varobj
*parent
)
2401 name
= cplus_name_of_variable (parent
);
2402 /* If the name has "-" in it, it is because we
2403 needed to escape periods in the name... */
2406 while (*p
!= '\000')
2417 java_name_of_child (struct varobj
*parent
, int index
)
2421 name
= cplus_name_of_child (parent
, index
);
2422 /* Escape any periods in the name... */
2425 while (*p
!= '\000')
2436 java_value_of_root (struct varobj
**var_handle
)
2438 return cplus_value_of_root (var_handle
);
2442 java_value_of_child (struct varobj
*parent
, int index
)
2444 return cplus_value_of_child (parent
, index
);
2447 static struct type
*
2448 java_type_of_child (struct varobj
*parent
, int index
)
2450 return cplus_type_of_child (parent
, index
);
2454 java_variable_editable (struct varobj
*var
)
2456 return cplus_variable_editable (var
);
2460 java_value_of_variable (struct varobj
*var
)
2462 return cplus_value_of_variable (var
);
2465 extern void _initialize_varobj (void);
2467 _initialize_varobj (void)
2469 int sizeof_table
= sizeof (struct vlist
*) * VAROBJ_TABLE_SIZE
;
2471 varobj_table
= xmalloc (sizeof_table
);
2472 memset (varobj_table
, 0, sizeof_table
);
2475 add_set_cmd ("debugvarobj", class_maintenance
, var_zinteger
,
2476 (char *) &varobjdebug
,
2477 "Set varobj debugging.\n\
2478 When non-zero, varobj debugging is enabled.", &setlist
),