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 (type_changed
|| !my_value_equal (var
->value
, new, &error2
))
922 /* Note that it's changed There a couple of exceptions here,
923 though. We don't want some types to be reported as
924 "changed". The exception to this is if this is a
925 "use_selected_frame" varobj, and its type has changed. */
926 if (type_changed
|| type_changeable (var
))
928 vpush (&result
, var
);
932 /* error2 replaces var->error since this new value
933 WILL replace the old one. */
936 /* We must always keep around the new value for this root
937 variable expression, or we lose the updated children! */
938 value_free (var
->value
);
941 /* Initialize a stack */
942 vpush (&stack
, NULL
);
944 /* Push the root's children */
945 if (var
->children
!= NULL
)
947 struct varobj_child
*c
;
948 for (c
= var
->children
; c
!= NULL
; c
= c
->next
)
949 vpush (&stack
, c
->child
);
952 /* Walk through the children, reconstructing them all. */
956 /* Push any children */
957 if (v
->children
!= NULL
)
959 struct varobj_child
*c
;
960 for (c
= v
->children
; c
!= NULL
; c
= c
->next
)
961 vpush (&stack
, c
->child
);
964 /* Update this variable */
965 new = value_of_child (v
->parent
, v
->index
);
966 if (type_changeable (v
) && !my_value_equal (v
->value
, new, &error2
))
968 /* Note that it's changed */
972 /* error2 replaces v->error since this new value
973 WILL replace the old one. */
976 /* We must always keep new values, since children depend on it. */
977 if (v
->value
!= NULL
)
978 value_free (v
->value
);
985 /* Alloc (changed + 1) list entries */
986 /* FIXME: add a cleanup for the allocated list(s)
987 because one day the select_frame called below can longjump */
988 *changelist
= xmalloc ((changed
+ 1) * sizeof (struct varobj
*));
991 templist
= xmalloc ((changed
+ 1) * sizeof (struct varobj
*));
997 /* Copy from result stack to list */
999 *cv
= vpop (&result
);
1000 while ((*cv
!= NULL
) && (vleft
> 0))
1004 *cv
= vpop (&result
);
1007 warning ("varobj_update: assertion failed - vleft <> 0");
1011 /* Now we revert the order. */
1012 for (i
=0; i
< changed
; i
++)
1013 *(*changelist
+ i
) = *(templist
+ changed
-1 - i
);
1014 *(*changelist
+ changed
) = NULL
;
1017 /* Restore selected frame */
1018 select_frame (old_fi
, -1);
1027 /* Helper functions */
1030 * Variable object construction/destruction
1034 delete_variable (struct cpstack
**resultp
, struct varobj
*var
,
1035 int only_children_p
)
1039 delete_variable_1 (resultp
, &delcount
, var
,
1040 only_children_p
, 1 /* remove_from_parent_p */ );
1045 /* Delete the variable object VAR and its children */
1046 /* IMPORTANT NOTE: If we delete a variable which is a child
1047 and the parent is not removed we dump core. It must be always
1048 initially called with remove_from_parent_p set */
1050 delete_variable_1 (struct cpstack
**resultp
, int *delcountp
, struct varobj
*var
,
1051 int only_children_p
, int remove_from_parent_p
)
1053 struct varobj_child
*vc
;
1054 struct varobj_child
*next
;
1056 /* Delete any children of this variable, too. */
1057 for (vc
= var
->children
; vc
!= NULL
; vc
= next
)
1059 if (!remove_from_parent_p
)
1060 vc
->child
->parent
= NULL
;
1061 delete_variable_1 (resultp
, delcountp
, vc
->child
, 0, only_children_p
);
1066 /* if we were called to delete only the children we are done here */
1067 if (only_children_p
)
1070 /* Otherwise, add it to the list of deleted ones and proceed to do so */
1071 /* If the name is null, this is a temporary variable, that has not
1072 yet been installed, don't report it, it belongs to the caller... */
1073 if (var
->obj_name
!= NULL
)
1075 cppush (resultp
, strdup (var
->obj_name
));
1076 *delcountp
= *delcountp
+ 1;
1079 /* If this variable has a parent, remove it from its parent's list */
1080 /* OPTIMIZATION: if the parent of this variable is also being deleted,
1081 (as indicated by remove_from_parent_p) we don't bother doing an
1082 expensive list search to find the element to remove when we are
1083 discarding the list afterwards */
1084 if ((remove_from_parent_p
) &&
1085 (var
->parent
!= NULL
))
1087 remove_child_from_parent (var
->parent
, var
);
1090 if (var
->obj_name
!= NULL
)
1091 uninstall_variable (var
);
1093 /* Free memory associated with this variable */
1094 free_variable (var
);
1097 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
1099 install_variable (struct varobj
*var
)
1102 struct vlist
*newvl
;
1104 unsigned int index
= 0;
1107 for (chp
= var
->obj_name
; *chp
; chp
++)
1109 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
1112 cv
= *(varobj_table
+ index
);
1113 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
1117 error ("Duplicate variable object name");
1119 /* Add varobj to hash table */
1120 newvl
= xmalloc (sizeof (struct vlist
));
1121 newvl
->next
= *(varobj_table
+ index
);
1123 *(varobj_table
+ index
) = newvl
;
1125 /* If root, add varobj to root list */
1126 if (var
->root
->rootvar
== var
)
1128 /* Add to list of root variables */
1129 if (rootlist
== NULL
)
1130 var
->root
->next
= NULL
;
1132 var
->root
->next
= rootlist
;
1133 rootlist
= var
->root
;
1140 /* Unistall the object VAR. */
1142 uninstall_variable (struct varobj
*var
)
1146 struct varobj_root
*cr
;
1147 struct varobj_root
*prer
;
1149 unsigned int index
= 0;
1152 /* Remove varobj from hash table */
1153 for (chp
= var
->obj_name
; *chp
; chp
++)
1155 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
1158 cv
= *(varobj_table
+ index
);
1160 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
1167 fprintf_unfiltered (gdb_stdlog
, "Deleting %s\n", var
->obj_name
);
1171 warning ("Assertion failed: Could not find variable object \"%s\" to delete", var
->obj_name
);
1176 *(varobj_table
+ index
) = cv
->next
;
1178 prev
->next
= cv
->next
;
1182 /* If root, remove varobj from root list */
1183 if (var
->root
->rootvar
== var
)
1185 /* Remove from list of root variables */
1186 if (rootlist
== var
->root
)
1187 rootlist
= var
->root
->next
;
1192 while ((cr
!= NULL
) && (cr
->rootvar
!= var
))
1199 warning ("Assertion failed: Could not find varobj \"%s\" in root list", var
->obj_name
);
1205 prer
->next
= cr
->next
;
1212 /* Does a child with the name NAME exist in VAR? If so, return its data.
1213 If not, return NULL. */
1214 static struct varobj
*
1215 child_exists (var
, name
)
1216 struct varobj
*var
; /* Parent */
1217 char *name
; /* name of child */
1219 struct varobj_child
*vc
;
1221 for (vc
= var
->children
; vc
!= NULL
; vc
= vc
->next
)
1223 if (STREQ (vc
->child
->name
, name
))
1230 /* Create and install a child of the parent of the given name */
1231 static struct varobj
*
1232 create_child (struct varobj
*parent
, int index
, char *name
)
1234 struct varobj
*child
;
1237 child
= new_variable ();
1239 /* name is allocated by name_of_child */
1241 child
->index
= index
;
1242 child
->value
= value_of_child (parent
, index
);
1243 if (child
->value
== NULL
|| parent
->error
)
1245 child
->parent
= parent
;
1246 child
->root
= parent
->root
;
1247 childs_name
= (char *) xmalloc ((strlen (parent
->obj_name
) + strlen (name
) + 2)
1249 sprintf (childs_name
, "%s.%s", parent
->obj_name
, name
);
1250 child
->obj_name
= childs_name
;
1251 install_variable (child
);
1253 /* Save a pointer to this child in the parent */
1254 save_child_in_parent (parent
, child
);
1256 /* Note the type of this child */
1257 child
->type
= type_of_child (child
);
1262 /* FIXME: This should be a generic add to list */
1263 /* Save CHILD in the PARENT's data. */
1265 save_child_in_parent (struct varobj
*parent
, struct varobj
*child
)
1267 struct varobj_child
*vc
;
1269 /* Insert the child at the top */
1270 vc
= parent
->children
;
1272 (struct varobj_child
*) xmalloc (sizeof (struct varobj_child
));
1274 parent
->children
->next
= vc
;
1275 parent
->children
->child
= child
;
1278 /* FIXME: This should be a generic remove from list */
1279 /* Remove the CHILD from the PARENT's list of children. */
1281 remove_child_from_parent (struct varobj
*parent
, struct varobj
*child
)
1283 struct varobj_child
*vc
, *prev
;
1285 /* Find the child in the parent's list */
1287 for (vc
= parent
->children
; vc
!= NULL
;)
1289 if (vc
->child
== child
)
1296 parent
->children
= vc
->next
;
1298 prev
->next
= vc
->next
;
1304 * Miscellaneous utility functions.
1307 /* Allocate memory and initialize a new variable */
1308 static struct varobj
*
1313 var
= (struct varobj
*) xmalloc (sizeof (struct varobj
));
1315 var
->obj_name
= NULL
;
1320 var
->num_children
= -1;
1322 var
->children
= NULL
;
1329 /* Allocate memory and initialize a new root variable */
1330 static struct varobj
*
1331 new_root_variable (void)
1333 struct varobj
*var
= new_variable ();
1334 var
->root
= (struct varobj_root
*) xmalloc (sizeof (struct varobj_root
));;
1335 var
->root
->lang
= NULL
;
1336 var
->root
->exp
= NULL
;
1337 var
->root
->valid_block
= NULL
;
1338 var
->root
->frame
= (CORE_ADDR
) -1;
1339 var
->root
->use_selected_frame
= 0;
1340 var
->root
->rootvar
= NULL
;
1345 /* Free any allocated memory associated with VAR. */
1347 free_variable (struct varobj
*var
)
1349 /* Free the expression if this is a root variable. */
1350 if (var
->root
->rootvar
== var
)
1352 free_current_contents ((char **) &var
->root
->exp
);
1357 FREEIF (var
->obj_name
);
1362 do_free_variable_cleanup (void *var
)
1364 free_variable (var
);
1367 static struct cleanup
*
1368 make_cleanup_free_variable (struct varobj
*var
)
1370 return make_cleanup (do_free_variable_cleanup
, var
);
1373 /* This returns the type of the variable. This skips past typedefs
1374 and returns the real type of the variable. It also dereferences
1375 pointers and references. */
1376 static struct type
*
1377 get_type (struct varobj
*var
)
1382 while (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1383 type
= TYPE_TARGET_TYPE (type
);
1388 /* This returns the type of the variable, dereferencing pointers, too. */
1389 static struct type
*
1390 get_type_deref (struct varobj
*var
)
1394 type
= get_type (var
);
1396 if (type
!= NULL
&& (TYPE_CODE (type
) == TYPE_CODE_PTR
1397 || TYPE_CODE (type
) == TYPE_CODE_REF
))
1398 type
= get_target_type (type
);
1403 /* This returns the target type (or NULL) of TYPE, also skipping
1404 past typedefs, just like get_type (). */
1405 static struct type
*
1406 get_target_type (struct type
*type
)
1410 type
= TYPE_TARGET_TYPE (type
);
1411 while (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1412 type
= TYPE_TARGET_TYPE (type
);
1418 /* What is the default display for this variable? We assume that
1419 everything is "natural". Any exceptions? */
1420 static enum varobj_display_formats
1421 variable_default_display (struct varobj
*var
)
1423 return FORMAT_NATURAL
;
1426 /* This function is similar to gdb's value_equal, except that this
1427 one is "safe" -- it NEVER longjmps. It determines if the VAR's
1428 value is the same as VAL2. */
1430 my_value_equal (value_ptr val1
, value_ptr val2
, int *error2
)
1435 /* Special case: NULL values. If both are null, say
1437 if (val1
== NULL
&& val2
== NULL
)
1439 else if (val1
== NULL
|| val2
== NULL
)
1442 /* This is bogus, but unfortunately necessary. We must know
1443 exactly what caused an error -- reading val1 or val2 -- so
1444 that we can really determine if we think that something has changed. */
1447 /* We do need to catch errors here because the whole purpose
1448 is to test if value_equal() has errored */
1449 if (!gdb_value_equal (val1
, val1
, &r
))
1452 if (!gdb_value_equal (val2
, val2
, &r
))
1458 if (!gdb_value_equal (val1
, val2
, &r
))
1460 /* An error occurred, this could have happened if
1461 either val1 or val2 errored. ERR1 and ERR2 tell
1462 us which of these it is. If both errored, then
1463 we assume nothing has changed. If one of them is
1464 valid, though, then something has changed. */
1467 /* both the old and new values caused errors, so
1468 we say the value did not change */
1469 /* This is indeterminate, though. Perhaps we should
1470 be safe and say, yes, it changed anyway?? */
1482 /* FIXME: The following should be generic for any pointer */
1484 vpush (struct vstack
**pstack
, struct varobj
*var
)
1488 s
= (struct vstack
*) xmalloc (sizeof (struct vstack
));
1494 /* FIXME: The following should be generic for any pointer */
1495 static struct varobj
*
1496 vpop (struct vstack
**pstack
)
1501 if ((*pstack
)->var
== NULL
&& (*pstack
)->next
== NULL
)
1506 *pstack
= (*pstack
)->next
;
1512 /* FIXME: The following should be generic for any pointer */
1514 cppush (struct cpstack
**pstack
, char *name
)
1518 s
= (struct cpstack
*) xmalloc (sizeof (struct cpstack
));
1524 /* FIXME: The following should be generic for any pointer */
1526 cppop (struct cpstack
**pstack
)
1531 if ((*pstack
)->name
== NULL
&& (*pstack
)->next
== NULL
)
1536 *pstack
= (*pstack
)->next
;
1543 * Language-dependencies
1546 /* Common entry points */
1548 /* Get the language of variable VAR. */
1549 static enum varobj_languages
1550 variable_language (struct varobj
*var
)
1552 enum varobj_languages lang
;
1554 switch (var
->root
->exp
->language_defn
->la_language
)
1560 case language_cplus
:
1571 /* Return the number of children for a given variable.
1572 The result of this function is defined by the language
1573 implementation. The number of children returned by this function
1574 is the number of children that the user will see in the variable
1577 number_of_children (struct varobj
*var
)
1579 return (*var
->root
->lang
->number_of_children
) (var
);;
1582 /* What is the expression for the root varobj VAR? Returns a malloc'd string. */
1584 name_of_variable (struct varobj
*var
)
1586 return (*var
->root
->lang
->name_of_variable
) (var
);
1589 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd string. */
1591 name_of_child (struct varobj
*var
, int index
)
1593 return (*var
->root
->lang
->name_of_child
) (var
, index
);
1596 /* What is the value_ptr of the root variable VAR?
1597 TYPE_CHANGED controls what to do if the type of a
1598 use_selected_frame = 1 variable changes. On input,
1599 TYPE_CHANGED = 1 means discard the old varobj, and replace
1600 it with this one. TYPE_CHANGED = 0 means leave it around.
1601 NB: In both cases, var_handle will point to the new varobj,
1602 so if you use TYPE_CHANGED = 0, you will have to stash the
1603 old varobj pointer away somewhere before calling this.
1604 On return, TYPE_CHANGED will be 1 if the type has changed, and
1607 value_of_root (struct varobj
**var_handle
, int *type_changed
)
1611 if (var_handle
== NULL
)
1616 /* This should really be an exception, since this should
1617 only get called with a root variable. */
1619 if (var
->root
->rootvar
!= var
)
1622 if (var
->root
->use_selected_frame
)
1624 struct varobj
*tmp_var
;
1625 char *old_type
, *new_type
;
1626 old_type
= varobj_get_type (var
);
1627 tmp_var
= varobj_create (NULL
, var
->name
, (CORE_ADDR
) 0,
1628 USE_SELECTED_FRAME
);
1629 if (tmp_var
== NULL
)
1633 new_type
= varobj_get_type (tmp_var
);
1634 if (strcmp(old_type
, new_type
) == 0)
1636 varobj_delete (tmp_var
, NULL
, 0);
1644 savestring (var
->obj_name
, strlen (var
->obj_name
));
1645 uninstall_variable (var
);
1649 tmp_var
->obj_name
= varobj_gen_name ();
1651 install_variable (tmp_var
);
1652 *var_handle
= tmp_var
;
1661 return (*var
->root
->lang
->value_of_root
) (var_handle
);
1664 /* What is the value_ptr for the INDEX'th child of PARENT? */
1666 value_of_child (struct varobj
*parent
, int index
)
1670 value
= (*parent
->root
->lang
->value_of_child
) (parent
, index
);
1672 /* If we're being lazy, fetch the real value of the variable. */
1673 if (value
!= NULL
&& VALUE_LAZY (value
))
1674 gdb_value_fetch_lazy (value
);
1679 /* What is the type of VAR? */
1680 static struct type
*
1681 type_of_child (struct varobj
*var
)
1684 /* If the child had no evaluation errors, var->value
1685 will be non-NULL and contain a valid type. */
1686 if (var
->value
!= NULL
)
1687 return VALUE_TYPE (var
->value
);
1689 /* Otherwise, we must compute the type. */
1690 return (*var
->root
->lang
->type_of_child
) (var
->parent
, var
->index
);
1693 /* Is this variable editable? Use the variable's type to make
1694 this determination. */
1696 variable_editable (struct varobj
*var
)
1698 return (*var
->root
->lang
->variable_editable
) (var
);
1701 /* GDB already has a command called "value_of_variable". Sigh. */
1703 my_value_of_variable (struct varobj
*var
)
1705 return (*var
->root
->lang
->value_of_variable
) (var
);
1708 /* Is VAR something that can change? Depending on language,
1709 some variable's values never change. For example,
1710 struct and unions never change values. */
1712 type_changeable (struct varobj
*var
)
1717 if (CPLUS_FAKE_CHILD (var
))
1720 type
= get_type (var
);
1722 switch (TYPE_CODE (type
))
1724 case TYPE_CODE_STRUCT
:
1725 case TYPE_CODE_UNION
:
1738 c_number_of_children (struct varobj
*var
)
1741 struct type
*target
;
1744 type
= get_type (var
);
1745 target
= get_target_type (type
);
1748 switch (TYPE_CODE (type
))
1750 case TYPE_CODE_ARRAY
:
1751 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (target
) > 0
1752 && TYPE_ARRAY_UPPER_BOUND_TYPE (type
) != BOUND_CANNOT_BE_DETERMINED
)
1753 children
= TYPE_LENGTH (type
) / TYPE_LENGTH (target
);
1758 case TYPE_CODE_STRUCT
:
1759 case TYPE_CODE_UNION
:
1760 children
= TYPE_NFIELDS (type
);
1764 /* This is where things get compilcated. All pointers have one child.
1765 Except, of course, for struct and union ptr, which we automagically
1766 dereference for the user and function ptrs, which have no children. */
1767 switch (TYPE_CODE (target
))
1769 case TYPE_CODE_STRUCT
:
1770 case TYPE_CODE_UNION
:
1771 children
= TYPE_NFIELDS (target
);
1774 case TYPE_CODE_FUNC
:
1779 /* Don't dereference char* or void*. */
1780 if (TYPE_NAME (target
) != NULL
1781 && (STREQ (TYPE_NAME (target
), "char")
1782 || STREQ (TYPE_NAME (target
), "void")))
1790 /* Other types have no children */
1798 c_name_of_variable (struct varobj
*parent
)
1800 return savestring (parent
->name
, strlen (parent
->name
));
1804 c_name_of_child (struct varobj
*parent
, int index
)
1807 struct type
*target
;
1811 type
= get_type (parent
);
1812 target
= get_target_type (type
);
1814 switch (TYPE_CODE (type
))
1816 case TYPE_CODE_ARRAY
:
1818 /* We never get here unless parent->num_children is greater than 0... */
1820 while ((int) pow ((double) 10, (double) len
) < index
)
1822 name
= (char *) xmalloc (1 + len
* sizeof (char));
1823 sprintf (name
, "%d", index
);
1827 case TYPE_CODE_STRUCT
:
1828 case TYPE_CODE_UNION
:
1829 string
= TYPE_FIELD_NAME (type
, index
);
1830 name
= savestring (string
, strlen (string
));
1834 switch (TYPE_CODE (target
))
1836 case TYPE_CODE_STRUCT
:
1837 case TYPE_CODE_UNION
:
1838 string
= TYPE_FIELD_NAME (target
, index
);
1839 name
= savestring (string
, strlen (string
));
1843 name
= (char *) xmalloc ((strlen (parent
->name
) + 2) * sizeof (char));
1844 sprintf (name
, "*%s", parent
->name
);
1850 /* This should not happen */
1851 name
= xstrdup ("???");
1858 c_value_of_root (struct varobj
**var_handle
)
1861 struct varobj
*var
= *var_handle
;
1862 struct frame_info
*fi
;
1865 /* Only root variables can be updated... */
1866 if (var
->root
->rootvar
!= var
)
1867 /* Not a root var */
1871 /* Determine whether the variable is still around. */
1872 if (var
->root
->valid_block
== NULL
)
1876 reinit_frame_cache ();
1879 fi
= find_frame_addr_in_frame_chain (var
->root
->frame
);
1881 within_scope
= fi
!= NULL
;
1882 /* FIXME: select_frame could fail */
1884 select_frame (fi
, -1);
1889 /* We need to catch errors here, because if evaluate
1890 expression fails we just want to make val->error = 1 and
1892 if (gdb_evaluate_expression (var
->root
->exp
, &new_val
))
1894 if (VALUE_LAZY (new_val
))
1896 /* We need to catch errors because if
1897 value_fetch_lazy fails we still want to continue
1898 (after making val->error = 1) */
1899 /* FIXME: Shouldn't be using VALUE_CONTENTS? The
1900 comment on value_fetch_lazy() says it is only
1901 called from the macro... */
1902 if (!gdb_value_fetch_lazy (new_val
))
1911 release_value (new_val
);
1919 c_value_of_child (struct varobj
*parent
, int index
)
1921 value_ptr value
, temp
, indval
;
1922 struct type
*type
, *target
;
1925 type
= get_type (parent
);
1926 target
= get_target_type (type
);
1927 name
= name_of_child (parent
, index
);
1928 temp
= parent
->value
;
1933 switch (TYPE_CODE (type
))
1935 case TYPE_CODE_ARRAY
:
1937 /* This breaks if the array lives in a (vector) register. */
1938 value
= value_slice (temp
, index
, 1);
1939 temp
= value_coerce_array (value
);
1940 gdb_value_ind (temp
, &value
);
1942 indval
= value_from_longest (builtin_type_int
, (LONGEST
) index
);
1943 gdb_value_subscript (temp
, indval
, &value
);
1947 case TYPE_CODE_STRUCT
:
1948 case TYPE_CODE_UNION
:
1949 value
= value_struct_elt (&temp
, NULL
, name
, NULL
, "vstructure");
1953 switch (TYPE_CODE (target
))
1955 case TYPE_CODE_STRUCT
:
1956 case TYPE_CODE_UNION
:
1957 value
= value_struct_elt (&temp
, NULL
, name
, NULL
, "vstructure");
1961 gdb_value_ind (temp
, &value
);
1972 release_value (value
);
1977 static struct type
*
1978 c_type_of_child (struct varobj
*parent
, int index
)
1981 char *name
= name_of_child (parent
, index
);
1983 switch (TYPE_CODE (parent
->type
))
1985 case TYPE_CODE_ARRAY
:
1986 type
= TYPE_TARGET_TYPE (parent
->type
);
1989 case TYPE_CODE_STRUCT
:
1990 case TYPE_CODE_UNION
:
1991 type
= lookup_struct_elt_type (parent
->type
, name
, 0);
1995 switch (TYPE_CODE (TYPE_TARGET_TYPE (parent
->type
)))
1997 case TYPE_CODE_STRUCT
:
1998 case TYPE_CODE_UNION
:
1999 type
= lookup_struct_elt_type (parent
->type
, name
, 0);
2003 type
= TYPE_TARGET_TYPE (parent
->type
);
2009 /* This should not happen as only the above types have children */
2010 warning ("Child of parent whose type does not allow children");
2011 /* FIXME: Can we still go on? */
2020 c_variable_editable (struct varobj
*var
)
2022 switch (TYPE_CODE (get_type (var
)))
2024 case TYPE_CODE_STRUCT
:
2025 case TYPE_CODE_UNION
:
2026 case TYPE_CODE_ARRAY
:
2027 case TYPE_CODE_FUNC
:
2028 case TYPE_CODE_MEMBER
:
2029 case TYPE_CODE_METHOD
:
2040 c_value_of_variable (struct varobj
*var
)
2045 if (var
->value
!= NULL
)
2049 /* This can happen if we attempt to get the value of a struct
2050 member when the parent is an invalid pointer. */
2051 return xstrdup ("???");
2054 /* BOGUS: if val_print sees a struct/class, it will print out its
2055 children instead of "{...}" */
2056 type
= get_type (var
);
2057 switch (TYPE_CODE (type
))
2059 case TYPE_CODE_STRUCT
:
2060 case TYPE_CODE_UNION
:
2061 return xstrdup ("{...}");
2064 case TYPE_CODE_ARRAY
:
2067 sprintf (number
, "[%d]", var
->num_children
);
2068 return xstrdup (number
);
2075 struct ui_file
*stb
= mem_fileopen ();
2076 struct cleanup
*old_chain
= make_cleanup_ui_file_delete (stb
);
2079 if (VALUE_LAZY (val
))
2080 gdb_value_fetch_lazy (val
);
2081 val_print (VALUE_TYPE (val
), VALUE_CONTENTS_RAW (val
), 0,
2082 VALUE_ADDRESS (val
),
2083 stb
, format_code
[(int) var
->format
], 1, 0, 0);
2084 thevalue
= ui_file_xstrdup (stb
, &dummy
);
2085 do_cleanups (old_chain
);
2096 cplus_number_of_children (struct varobj
*var
)
2099 int children
, dont_know
;
2104 if (!CPLUS_FAKE_CHILD (var
))
2106 type
= get_type_deref (var
);
2108 if (((TYPE_CODE (type
)) == TYPE_CODE_STRUCT
) ||
2109 ((TYPE_CODE (type
)) == TYPE_CODE_UNION
))
2113 cplus_class_num_children (type
, kids
);
2114 if (kids
[v_public
] != 0)
2116 if (kids
[v_private
] != 0)
2118 if (kids
[v_protected
] != 0)
2121 /* Add any baseclasses */
2122 children
+= TYPE_N_BASECLASSES (type
);
2125 /* FIXME: save children in var */
2132 type
= get_type_deref (var
->parent
);
2134 cplus_class_num_children (type
, kids
);
2135 if (STREQ (var
->name
, "public"))
2136 children
= kids
[v_public
];
2137 else if (STREQ (var
->name
, "private"))
2138 children
= kids
[v_private
];
2140 children
= kids
[v_protected
];
2145 children
= c_number_of_children (var
);
2150 /* Compute # of public, private, and protected variables in this class.
2151 That means we need to descend into all baseclasses and find out
2152 how many are there, too. */
2154 cplus_class_num_children (type
, children
)
2160 children
[v_public
] = 0;
2161 children
[v_private
] = 0;
2162 children
[v_protected
] = 0;
2164 for (i
= TYPE_N_BASECLASSES (type
); i
< TYPE_NFIELDS (type
); i
++)
2166 /* If we have a virtual table pointer, omit it. */
2167 if (TYPE_VPTR_BASETYPE (type
) == type
2168 && TYPE_VPTR_FIELDNO (type
) == i
)
2171 if (TYPE_FIELD_PROTECTED (type
, i
))
2172 children
[v_protected
]++;
2173 else if (TYPE_FIELD_PRIVATE (type
, i
))
2174 children
[v_private
]++;
2176 children
[v_public
]++;
2181 cplus_name_of_variable (struct varobj
*parent
)
2183 return c_name_of_variable (parent
);
2187 cplus_name_of_child (struct varobj
*parent
, int index
)
2193 if (CPLUS_FAKE_CHILD (parent
))
2195 /* Looking for children of public, private, or protected. */
2196 type
= get_type_deref (parent
->parent
);
2199 type
= get_type_deref (parent
);
2202 switch (TYPE_CODE (type
))
2204 case TYPE_CODE_STRUCT
:
2205 case TYPE_CODE_UNION
:
2206 cplus_class_num_children (type
, children
);
2208 if (CPLUS_FAKE_CHILD (parent
))
2210 /* FIXME: This assumes that type orders
2211 inherited, public, private, protected */
2212 int i
= index
+ TYPE_N_BASECLASSES (type
);
2213 if (STREQ (parent
->name
, "private") || STREQ (parent
->name
, "protected"))
2214 i
+= children
[v_public
];
2215 if (STREQ (parent
->name
, "protected"))
2216 i
+= children
[v_private
];
2218 name
= TYPE_FIELD_NAME (type
, i
);
2220 else if (index
< TYPE_N_BASECLASSES (type
))
2221 name
= TYPE_FIELD_NAME (type
, index
);
2224 /* Everything beyond the baseclasses can
2225 only be "public", "private", or "protected" */
2226 index
-= TYPE_N_BASECLASSES (type
);
2230 if (children
[v_public
] != 0)
2236 if (children
[v_private
] != 0)
2242 if (children
[v_protected
] != 0)
2259 return c_name_of_child (parent
, index
);
2263 name
= savestring (name
, strlen (name
));
2270 cplus_value_of_root (struct varobj
**var_handle
)
2272 return c_value_of_root (var_handle
);
2276 cplus_value_of_child (struct varobj
*parent
, int index
)
2282 if (CPLUS_FAKE_CHILD (parent
))
2283 type
= get_type_deref (parent
->parent
);
2285 type
= get_type_deref (parent
);
2288 name
= name_of_child (parent
, index
);
2290 if (((TYPE_CODE (type
)) == TYPE_CODE_STRUCT
) ||
2291 ((TYPE_CODE (type
)) == TYPE_CODE_UNION
))
2293 if (CPLUS_FAKE_CHILD (parent
))
2295 value_ptr temp
= parent
->parent
->value
;
2296 value
= value_struct_elt (&temp
, NULL
, name
,
2297 NULL
, "cplus_structure");
2298 release_value (value
);
2300 else if (index
>= TYPE_N_BASECLASSES (type
))
2302 /* public, private, or protected */
2308 if (parent
->value
!= NULL
)
2312 if (TYPE_CODE (VALUE_TYPE (parent
->value
)) == TYPE_CODE_PTR
2313 || TYPE_CODE (VALUE_TYPE (parent
->value
)) == TYPE_CODE_REF
)
2314 gdb_value_ind (parent
->value
, &temp
);
2316 temp
= parent
->value
;
2318 value
= value_cast (TYPE_FIELD_TYPE (type
, index
), temp
);
2319 release_value (value
);
2325 return c_value_of_child (parent
, index
);
2330 static struct type
*
2331 cplus_type_of_child (struct varobj
*parent
, int index
)
2333 struct type
*type
, *t
;
2335 t
= get_type_deref (parent
);
2337 switch (TYPE_CODE (t
))
2339 case TYPE_CODE_STRUCT
:
2340 case TYPE_CODE_UNION
:
2341 if (index
>= TYPE_N_BASECLASSES (t
))
2349 type
= TYPE_FIELD_TYPE (t
, index
);
2358 return c_type_of_child (parent
, index
);
2364 cplus_variable_editable (struct varobj
*var
)
2366 if (CPLUS_FAKE_CHILD (var
))
2369 return c_variable_editable (var
);
2373 cplus_value_of_variable (struct varobj
*var
)
2376 /* If we have one of our special types, don't print out
2378 if (CPLUS_FAKE_CHILD (var
))
2379 return xstrdup ("");
2381 return c_value_of_variable (var
);
2387 java_number_of_children (struct varobj
*var
)
2389 return cplus_number_of_children (var
);
2393 java_name_of_variable (struct varobj
*parent
)
2397 name
= cplus_name_of_variable (parent
);
2398 /* If the name has "-" in it, it is because we
2399 needed to escape periods in the name... */
2402 while (*p
!= '\000')
2413 java_name_of_child (struct varobj
*parent
, int index
)
2417 name
= cplus_name_of_child (parent
, index
);
2418 /* Escape any periods in the name... */
2421 while (*p
!= '\000')
2432 java_value_of_root (struct varobj
**var_handle
)
2434 return cplus_value_of_root (var_handle
);
2438 java_value_of_child (struct varobj
*parent
, int index
)
2440 return cplus_value_of_child (parent
, index
);
2443 static struct type
*
2444 java_type_of_child (struct varobj
*parent
, int index
)
2446 return cplus_type_of_child (parent
, index
);
2450 java_variable_editable (struct varobj
*var
)
2452 return cplus_variable_editable (var
);
2456 java_value_of_variable (struct varobj
*var
)
2458 return cplus_value_of_variable (var
);
2461 extern void _initialize_varobj (void);
2463 _initialize_varobj (void)
2465 int sizeof_table
= sizeof (struct vlist
*) * VAROBJ_TABLE_SIZE
;
2467 varobj_table
= xmalloc (sizeof_table
);
2468 memset (varobj_table
, 0, sizeof_table
);
2471 add_set_cmd ("debugvarobj", class_maintenance
, var_zinteger
,
2472 (char *) &varobjdebug
,
2473 "Set varobj debugging.\n\
2474 When non-zero, varobj debugging is enabled.", &setlist
),