1 /* Implementation of the GDB variable objects API.
2 Copyright 1999, 2000, 2001 Free Software Foundation, Inc.
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 59 Temple Place - Suite 330,
17 Boston, MA 02111-1307, USA. */
21 #include "expression.h"
30 /* Non-zero if we want to see trace of varobj level stuff. */
34 /* String representations of gdb's format codes */
35 char *varobj_format_string
[] =
36 { "natural", "binary", "decimal", "hexadecimal", "octal" };
38 /* String representations of gdb's known languages */
39 char *varobj_language_string
[] = { "unknown", "C", "C++", "Java" };
43 /* Every root variable has one of these structures saved in its
44 varobj. Members which must be free'd are noted. */
48 /* Alloc'd expression for this parent. */
49 struct expression
*exp
;
51 /* Block for which this expression is valid */
52 struct block
*valid_block
;
54 /* The frame for this expression */
57 /* If 1, "update" always recomputes the frame & valid block
58 using the currently selected frame. */
59 int use_selected_frame
;
61 /* Language info for this variable and its children */
62 struct language_specific
*lang
;
64 /* The varobj for this root node. */
65 struct varobj
*rootvar
;
67 /* Next root variable */
68 struct varobj_root
*next
;
71 /* Every variable in the system has a structure of this type defined
72 for it. This structure holds all information necessary to manipulate
73 a particular object variable. Members which must be freed are noted. */
77 /* Alloc'd name of the variable for this object.. If this variable is a
78 child, then this name will be the child's source name.
80 /* NOTE: This is the "expression" */
83 /* The alloc'd name for this variable's object. This is here for
84 convenience when constructing this object's children. */
87 /* Index of this variable in its parent or -1 */
90 /* The type of this variable. This may NEVER be NULL. */
93 /* The value of this expression or subexpression. This may be NULL. */
96 /* Did an error occur evaluating the expression or getting its value? */
99 /* The number of (immediate) children this variable has */
102 /* If this object is a child, this points to its immediate parent. */
103 struct varobj
*parent
;
105 /* A list of this object's children */
106 struct varobj_child
*children
;
108 /* Description of the root variable. Points to root variable for children. */
109 struct varobj_root
*root
;
111 /* The format of the output for this object */
112 enum varobj_display_formats format
;
115 /* Every variable keeps a linked list of its children, described
116 by the following structure. */
117 /* FIXME: Deprecated. All should use vlist instead */
122 /* Pointer to the child's data */
123 struct varobj
*child
;
125 /* Pointer to the next child */
126 struct varobj_child
*next
;
129 /* A stack of varobjs */
130 /* FIXME: Deprecated. All should use vlist instead */
141 struct cpstack
*next
;
144 /* A list of varobjs */
152 /* Private function prototypes */
154 /* Helper functions for the above subcommands. */
156 static int delete_variable (struct cpstack
**, struct varobj
*, int);
158 static void delete_variable_1 (struct cpstack
**, int *,
159 struct varobj
*, int, int);
161 static int install_variable (struct varobj
*);
163 static void uninstall_variable (struct varobj
*);
165 static struct varobj
*child_exists (struct varobj
*, char *);
167 static struct varobj
*create_child (struct varobj
*, int, char *);
169 static void save_child_in_parent (struct varobj
*, struct varobj
*);
171 static void remove_child_from_parent (struct varobj
*, struct varobj
*);
173 /* Utility routines */
175 static struct varobj
*new_variable (void);
177 static struct varobj
*new_root_variable (void);
179 static void free_variable (struct varobj
*var
);
181 static struct cleanup
*make_cleanup_free_variable (struct varobj
*var
);
183 static struct type
*get_type (struct varobj
*var
);
185 static struct type
*get_type_deref (struct varobj
*var
);
187 static struct type
*get_target_type (struct type
*);
189 static enum varobj_display_formats
variable_default_display (struct varobj
*);
191 static int my_value_equal (struct value
*, struct value
*, int *);
193 static void vpush (struct vstack
**pstack
, struct varobj
*var
);
195 static struct varobj
*vpop (struct vstack
**pstack
);
197 static void cppush (struct cpstack
**pstack
, char *name
);
199 static char *cppop (struct cpstack
**pstack
);
201 /* Language-specific routines. */
203 static enum varobj_languages
variable_language (struct varobj
*var
);
205 static int number_of_children (struct varobj
*);
207 static char *name_of_variable (struct varobj
*);
209 static char *name_of_child (struct varobj
*, int);
211 static struct value
*value_of_root (struct varobj
**var_handle
, int *);
213 static struct value
*value_of_child (struct varobj
*parent
, int index
);
215 static struct type
*type_of_child (struct varobj
*var
);
217 static int variable_editable (struct varobj
*var
);
219 static char *my_value_of_variable (struct varobj
*var
);
221 static int type_changeable (struct varobj
*var
);
223 /* C implementation */
225 static int c_number_of_children (struct varobj
*var
);
227 static char *c_name_of_variable (struct varobj
*parent
);
229 static char *c_name_of_child (struct varobj
*parent
, int index
);
231 static struct value
*c_value_of_root (struct varobj
**var_handle
);
233 static struct value
*c_value_of_child (struct varobj
*parent
, int index
);
235 static struct type
*c_type_of_child (struct varobj
*parent
, int index
);
237 static int c_variable_editable (struct varobj
*var
);
239 static char *c_value_of_variable (struct varobj
*var
);
241 /* C++ implementation */
243 static int cplus_number_of_children (struct varobj
*var
);
245 static void cplus_class_num_children (struct type
*type
, int children
[3]);
247 static char *cplus_name_of_variable (struct varobj
*parent
);
249 static char *cplus_name_of_child (struct varobj
*parent
, int index
);
251 static struct value
*cplus_value_of_root (struct varobj
**var_handle
);
253 static struct value
*cplus_value_of_child (struct varobj
*parent
, int index
);
255 static struct type
*cplus_type_of_child (struct varobj
*parent
, int index
);
257 static int cplus_variable_editable (struct varobj
*var
);
259 static char *cplus_value_of_variable (struct varobj
*var
);
261 /* Java implementation */
263 static int java_number_of_children (struct varobj
*var
);
265 static char *java_name_of_variable (struct varobj
*parent
);
267 static char *java_name_of_child (struct varobj
*parent
, int index
);
269 static struct value
*java_value_of_root (struct varobj
**var_handle
);
271 static struct value
*java_value_of_child (struct varobj
*parent
, int index
);
273 static struct type
*java_type_of_child (struct varobj
*parent
, int index
);
275 static int java_variable_editable (struct varobj
*var
);
277 static char *java_value_of_variable (struct varobj
*var
);
279 /* The language specific vector */
281 struct language_specific
284 /* The language of this variable */
285 enum varobj_languages language
;
287 /* The number of children of PARENT. */
288 int (*number_of_children
) (struct varobj
* parent
);
290 /* The name (expression) of a root varobj. */
291 char *(*name_of_variable
) (struct varobj
* parent
);
293 /* The name of the INDEX'th child of PARENT. */
294 char *(*name_of_child
) (struct varobj
* parent
, int index
);
296 /* The ``struct value *'' of the root variable ROOT. */
297 struct value
*(*value_of_root
) (struct varobj
** root_handle
);
299 /* The ``struct value *'' of the INDEX'th child of PARENT. */
300 struct value
*(*value_of_child
) (struct varobj
* parent
, int index
);
302 /* The type of the INDEX'th child of PARENT. */
303 struct type
*(*type_of_child
) (struct varobj
* parent
, int index
);
305 /* Is VAR editable? */
306 int (*variable_editable
) (struct varobj
* var
);
308 /* The current value of VAR. */
309 char *(*value_of_variable
) (struct varobj
* var
);
312 /* Array of known source language routines. */
313 static struct language_specific
314 languages
[vlang_end
][sizeof (struct language_specific
)] = {
315 /* Unknown (try treating as C */
318 c_number_of_children
,
330 c_number_of_children
,
342 cplus_number_of_children
,
343 cplus_name_of_variable
,
346 cplus_value_of_child
,
348 cplus_variable_editable
,
349 cplus_value_of_variable
}
354 java_number_of_children
,
355 java_name_of_variable
,
360 java_variable_editable
,
361 java_value_of_variable
}
364 /* A little convenience enum for dealing with C++/Java */
367 v_public
= 0, v_private
, v_protected
372 /* Mappings of varobj_display_formats enums to gdb's format codes */
373 static int format_code
[] = { 0, 't', 'd', 'x', 'o' };
375 /* Header of the list of root variable objects */
376 static struct varobj_root
*rootlist
;
377 static int rootcount
= 0; /* number of root varobjs in the list */
379 /* Prime number indicating the number of buckets in the hash table */
380 /* A prime large enough to avoid too many colisions */
381 #define VAROBJ_TABLE_SIZE 227
383 /* Pointer to the varobj hash table (built at run time) */
384 static struct vlist
**varobj_table
;
386 /* Is the variable X one of our "fake" children? */
387 #define CPLUS_FAKE_CHILD(x) \
388 ((x) != NULL && (x)->type == NULL && (x)->value == NULL)
391 /* API Implementation */
393 /* Creates a varobj (not its children) */
396 varobj_create (char *objname
,
397 char *expression
, CORE_ADDR frame
, enum varobj_type type
)
400 struct frame_info
*fi
;
401 struct frame_info
*old_fi
= NULL
;
403 struct cleanup
*old_chain
;
405 /* Fill out a varobj structure for the (root) variable being constructed. */
406 var
= new_root_variable ();
407 old_chain
= make_cleanup_free_variable (var
);
409 if (expression
!= NULL
)
412 enum varobj_languages lang
;
414 /* Parse and evaluate the expression, filling in as much
415 of the variable's data as possible */
417 /* Allow creator to specify context of variable */
418 if ((type
== USE_CURRENT_FRAME
) || (type
== USE_SELECTED_FRAME
))
421 fi
= find_frame_addr_in_frame_chain (frame
);
423 /* frame = -2 means always use selected frame */
424 if (type
== USE_SELECTED_FRAME
)
425 var
->root
->use_selected_frame
= 1;
429 block
= get_frame_block (fi
);
432 innermost_block
= NULL
;
433 /* Wrap the call to parse expression, so we can
434 return a sensible error. */
435 if (!gdb_parse_exp_1 (&p
, block
, 0, &var
->root
->exp
))
440 /* Don't allow variables to be created for types. */
441 if (var
->root
->exp
->elts
[0].opcode
== OP_TYPE
)
443 do_cleanups (old_chain
);
444 fprintf_unfiltered (gdb_stderr
,
445 "Attempt to use a type name as an expression.");
449 var
->format
= variable_default_display (var
);
450 var
->root
->valid_block
= innermost_block
;
451 var
->name
= savestring (expression
, strlen (expression
));
453 /* When the frame is different from the current frame,
454 we must select the appropriate frame before parsing
455 the expression, otherwise the value will not be current.
456 Since select_frame is so benign, just call it for all cases. */
459 var
->root
->frame
= FRAME_FP (fi
);
460 old_fi
= selected_frame
;
461 select_frame (fi
, -1);
464 /* We definitively need to catch errors here.
465 If evaluate_expression succeeds we got the value we wanted.
466 But if it fails, we still go on with a call to evaluate_type() */
467 if (gdb_evaluate_expression (var
->root
->exp
, &var
->value
))
470 release_value (var
->value
);
471 if (VALUE_LAZY (var
->value
))
472 gdb_value_fetch_lazy (var
->value
);
475 var
->value
= evaluate_type (var
->root
->exp
);
477 var
->type
= VALUE_TYPE (var
->value
);
479 /* Set language info */
480 lang
= variable_language (var
);
481 var
->root
->lang
= languages
[lang
];
483 /* Set ourselves as our root */
484 var
->root
->rootvar
= var
;
486 /* Reset the selected frame */
488 select_frame (old_fi
, -1);
491 /* If the variable object name is null, that means this
492 is a temporary variable, so don't install it. */
494 if ((var
!= NULL
) && (objname
!= NULL
))
496 var
->obj_name
= savestring (objname
, strlen (objname
));
498 /* If a varobj name is duplicated, the install will fail so
500 if (!install_variable (var
))
502 do_cleanups (old_chain
);
507 discard_cleanups (old_chain
);
511 /* Generates an unique name that can be used for a varobj */
514 varobj_gen_name (void)
519 /* generate a name for this object */
521 sprintf (obj_name
, "var%d", id
);
523 return xstrdup (obj_name
);
526 /* Given an "objname", returns the pointer to the corresponding varobj
527 or NULL if not found */
530 varobj_get_handle (char *objname
)
534 unsigned int index
= 0;
537 for (chp
= objname
; *chp
; chp
++)
539 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
542 cv
= *(varobj_table
+ index
);
543 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, objname
) != 0))
547 error ("Variable object not found");
552 /* Given the handle, return the name of the object */
555 varobj_get_objname (struct varobj
*var
)
557 return var
->obj_name
;
560 /* Given the handle, return the expression represented by the object */
563 varobj_get_expression (struct varobj
*var
)
565 return name_of_variable (var
);
568 /* Deletes a varobj and all its children if only_children == 0,
569 otherwise deletes only the children; returns a malloc'ed list of all the
570 (malloc'ed) names of the variables that have been deleted (NULL terminated) */
573 varobj_delete (struct varobj
*var
, char ***dellist
, int only_children
)
577 struct cpstack
*result
= NULL
;
580 /* Initialize a stack for temporary results */
581 cppush (&result
, NULL
);
584 /* Delete only the variable children */
585 delcount
= delete_variable (&result
, var
, 1 /* only the children */ );
587 /* Delete the variable and all its children */
588 delcount
= delete_variable (&result
, var
, 0 /* parent+children */ );
590 /* We may have been asked to return a list of what has been deleted */
593 *dellist
= xmalloc ((delcount
+ 1) * sizeof (char *));
597 *cp
= cppop (&result
);
598 while ((*cp
!= NULL
) && (mycount
> 0))
602 *cp
= cppop (&result
);
605 if (mycount
|| (*cp
!= NULL
))
606 warning ("varobj_delete: assertion failed - mycount(=%d) <> 0",
613 /* Set/Get variable object display format */
615 enum varobj_display_formats
616 varobj_set_display_format (struct varobj
*var
,
617 enum varobj_display_formats format
)
624 case FORMAT_HEXADECIMAL
:
626 var
->format
= format
;
630 var
->format
= variable_default_display (var
);
636 enum varobj_display_formats
637 varobj_get_display_format (struct varobj
*var
)
643 varobj_get_num_children (struct varobj
*var
)
645 if (var
->num_children
== -1)
646 var
->num_children
= number_of_children (var
);
648 return var
->num_children
;
651 /* Creates a list of the immediate children of a variable object;
652 the return code is the number of such children or -1 on error */
655 varobj_list_children (struct varobj
*var
, struct varobj
***childlist
)
657 struct varobj
*child
;
661 /* sanity check: have we been passed a pointer? */
662 if (childlist
== NULL
)
667 if (var
->num_children
== -1)
668 var
->num_children
= number_of_children (var
);
670 /* List of children */
671 *childlist
= xmalloc ((var
->num_children
+ 1) * sizeof (struct varobj
*));
673 for (i
= 0; i
< var
->num_children
; i
++)
675 /* Mark as the end in case we bail out */
676 *((*childlist
) + i
) = NULL
;
678 /* check if child exists, if not create */
679 name
= name_of_child (var
, i
);
680 child
= child_exists (var
, name
);
682 child
= create_child (var
, i
, name
);
684 *((*childlist
) + i
) = child
;
687 /* End of list is marked by a NULL pointer */
688 *((*childlist
) + i
) = NULL
;
690 return var
->num_children
;
693 /* Obtain the type of an object Variable as a string similar to the one gdb
694 prints on the console */
697 varobj_get_type (struct varobj
*var
)
700 struct cleanup
*old_chain
;
705 /* For the "fake" variables, do not return a type. (It's type is
707 if (CPLUS_FAKE_CHILD (var
))
710 stb
= mem_fileopen ();
711 old_chain
= make_cleanup_ui_file_delete (stb
);
713 /* To print the type, we simply create a zero ``struct value *'' and
714 cast it to our type. We then typeprint this variable. */
715 val
= value_zero (var
->type
, not_lval
);
716 type_print (VALUE_TYPE (val
), "", stb
, -1);
718 thetype
= ui_file_xstrdup (stb
, &length
);
719 do_cleanups (old_chain
);
723 enum varobj_languages
724 varobj_get_language (struct varobj
*var
)
726 return variable_language (var
);
730 varobj_get_attributes (struct varobj
*var
)
734 if (variable_editable (var
))
735 /* FIXME: define masks for attributes */
736 attributes
|= 0x00000001; /* Editable */
742 varobj_get_value (struct varobj
*var
)
744 return my_value_of_variable (var
);
747 /* Set the value of an object variable (if it is editable) to the
748 value of the given expression */
749 /* Note: Invokes functions that can call error() */
752 varobj_set_value (struct varobj
*var
, char *expression
)
757 /* The argument "expression" contains the variable's new value.
758 We need to first construct a legal expression for this -- ugh! */
759 /* Does this cover all the bases? */
760 struct expression
*exp
;
762 int saved_input_radix
= input_radix
;
764 if (variable_editable (var
) && !var
->error
)
766 char *s
= expression
;
770 input_radix
= 10; /* ALWAYS reset to decimal temporarily */
771 if (!gdb_parse_exp_1 (&s
, 0, 0, &exp
))
772 /* We cannot proceed without a well-formed expression. */
774 if (!gdb_evaluate_expression (exp
, &value
))
776 /* We cannot proceed without a valid expression. */
781 /* If our parent is "public", "private", or "protected", we could
782 be asking to modify the value of a baseclass. If so, we need to
783 adjust our address by the offset of our baseclass in the subclass,
784 since VALUE_ADDRESS (var->value) points at the start of the subclass.
785 For some reason, value_cast doesn't take care of this properly. */
787 if (var
->parent
!= NULL
&& CPLUS_FAKE_CHILD (var
->parent
))
789 struct varobj
*super
, *sub
;
791 super
= var
->parent
->parent
;
795 /* Yes, it is a baseclass */
796 type
= get_type_deref (sub
);
798 if (super
->index
< TYPE_N_BASECLASSES (type
))
800 temp
= value_copy (var
->value
);
801 for (i
= 0; i
< super
->index
; i
++)
802 offset
+= TYPE_LENGTH (TYPE_FIELD_TYPE (type
, i
));
807 VALUE_ADDRESS (temp
) += offset
;
808 if (!gdb_value_assign (temp
, value
, &val
))
810 VALUE_ADDRESS (val
) -= offset
;
811 value_free (var
->value
);
814 input_radix
= saved_input_radix
;
821 /* Returns a malloc'ed list with all root variable objects */
823 varobj_list (struct varobj
***varlist
)
826 struct varobj_root
*croot
;
827 int mycount
= rootcount
;
829 /* Alloc (rootcount + 1) entries for the result */
830 *varlist
= xmalloc ((rootcount
+ 1) * sizeof (struct varobj
*));
834 while ((croot
!= NULL
) && (mycount
> 0))
836 *cv
= croot
->rootvar
;
841 /* Mark the end of the list */
844 if (mycount
|| (croot
!= NULL
))
846 ("varobj_list: assertion failed - wrong tally of root vars (%d:%d)",
852 /* Update the values for a variable and its children. This is a
853 two-pronged attack. First, re-parse the value for the root's
854 expression to see if it's changed. Then go all the way
855 through its children, reconstructing them and noting if they've
858 -1 if there was an error updating the varobj
859 -2 if the type changed
860 Otherwise it is the number of children + parent changed
862 Only root variables can be updated...
864 NOTE: This function may delete the caller's varobj. If it
865 returns -2, then it has done this and VARP will be modified
866 to point to the new varobj. */
869 varobj_update (struct varobj
**varp
, struct varobj
***changelist
)
878 struct varobj
**templist
= NULL
;
880 struct vstack
*stack
= NULL
;
881 struct vstack
*result
= NULL
;
882 struct frame_info
*old_fi
;
884 /* sanity check: have we been passed a pointer? */
885 if (changelist
== NULL
)
888 /* Only root variables can be updated... */
889 if ((*varp
)->root
->rootvar
!= *varp
)
893 /* Save the selected stack frame, since we will need to change it
894 in order to evaluate expressions. */
895 old_fi
= selected_frame
;
897 /* Update the root variable. value_of_root can return NULL
898 if the variable is no longer around, i.e. we stepped out of
899 the frame in which a local existed. We are letting the
900 value_of_root variable dispose of the varobj if the type
903 new = value_of_root (varp
, &type_changed
);
910 /* Initialize a stack for temporary results */
911 vpush (&result
, NULL
);
913 /* If this is a "use_selected_frame" varobj, and its type has changed,
914 them note that it's changed. */
917 vpush (&result
, *varp
);
920 /* If values are not equal, note that it's changed.
921 There a couple of exceptions here, though.
922 We don't want some types to be reported as "changed". */
923 else if (type_changeable (*varp
)
924 && !my_value_equal ((*varp
)->value
, new, &error2
))
926 vpush (&result
, *varp
);
928 /* error2 replaces var->error since this new value
929 WILL replace the old one. */
930 (*varp
)->error
= error2
;
933 /* We must always keep around the new value for this root
934 variable expression, or we lose the updated children! */
935 value_free ((*varp
)->value
);
936 (*varp
)->value
= new;
938 /* Initialize a stack */
939 vpush (&stack
, NULL
);
941 /* Push the root's children */
942 if ((*varp
)->children
!= NULL
)
944 struct varobj_child
*c
;
945 for (c
= (*varp
)->children
; c
!= NULL
; c
= c
->next
)
946 vpush (&stack
, c
->child
);
949 /* Walk through the children, reconstructing them all. */
953 /* Push any children */
954 if (v
->children
!= NULL
)
956 struct varobj_child
*c
;
957 for (c
= v
->children
; c
!= NULL
; c
= c
->next
)
958 vpush (&stack
, c
->child
);
961 /* Update this variable */
962 new = value_of_child (v
->parent
, v
->index
);
963 if (type_changeable (v
) && !my_value_equal (v
->value
, new, &error2
))
965 /* Note that it's changed */
969 /* error2 replaces v->error since this new value
970 WILL replace the old one. */
973 /* We must always keep new values, since children depend on it. */
974 if (v
->value
!= NULL
)
975 value_free (v
->value
);
982 /* Alloc (changed + 1) list entries */
983 /* FIXME: add a cleanup for the allocated list(s)
984 because one day the select_frame called below can longjump */
985 *changelist
= xmalloc ((changed
+ 1) * sizeof (struct varobj
*));
988 templist
= xmalloc ((changed
+ 1) * sizeof (struct varobj
*));
994 /* Copy from result stack to list */
996 *cv
= vpop (&result
);
997 while ((*cv
!= NULL
) && (vleft
> 0))
1001 *cv
= vpop (&result
);
1004 warning ("varobj_update: assertion failed - vleft <> 0");
1008 /* Now we revert the order. */
1009 for (i
= 0; i
< changed
; i
++)
1010 *(*changelist
+ i
) = *(templist
+ changed
- 1 - i
);
1011 *(*changelist
+ changed
) = NULL
;
1014 /* Restore selected frame */
1015 select_frame (old_fi
, -1);
1024 /* Helper functions */
1027 * Variable object construction/destruction
1031 delete_variable (struct cpstack
**resultp
, struct varobj
*var
,
1032 int only_children_p
)
1036 delete_variable_1 (resultp
, &delcount
, var
,
1037 only_children_p
, 1 /* remove_from_parent_p */ );
1042 /* Delete the variable object VAR and its children */
1043 /* IMPORTANT NOTE: If we delete a variable which is a child
1044 and the parent is not removed we dump core. It must be always
1045 initially called with remove_from_parent_p set */
1047 delete_variable_1 (struct cpstack
**resultp
, int *delcountp
,
1048 struct varobj
*var
, int only_children_p
,
1049 int remove_from_parent_p
)
1051 struct varobj_child
*vc
;
1052 struct varobj_child
*next
;
1054 /* Delete any children of this variable, too. */
1055 for (vc
= var
->children
; vc
!= NULL
; vc
= next
)
1057 if (!remove_from_parent_p
)
1058 vc
->child
->parent
= NULL
;
1059 delete_variable_1 (resultp
, delcountp
, vc
->child
, 0, only_children_p
);
1064 /* if we were called to delete only the children we are done here */
1065 if (only_children_p
)
1068 /* Otherwise, add it to the list of deleted ones and proceed to do so */
1069 /* If the name is null, this is a temporary variable, that has not
1070 yet been installed, don't report it, it belongs to the caller... */
1071 if (var
->obj_name
!= NULL
)
1073 cppush (resultp
, xstrdup (var
->obj_name
));
1074 *delcountp
= *delcountp
+ 1;
1077 /* If this variable has a parent, remove it from its parent's list */
1078 /* OPTIMIZATION: if the parent of this variable is also being deleted,
1079 (as indicated by remove_from_parent_p) we don't bother doing an
1080 expensive list search to find the element to remove when we are
1081 discarding the list afterwards */
1082 if ((remove_from_parent_p
) && (var
->parent
!= NULL
))
1084 remove_child_from_parent (var
->parent
, var
);
1087 if (var
->obj_name
!= NULL
)
1088 uninstall_variable (var
);
1090 /* Free memory associated with this variable */
1091 free_variable (var
);
1094 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
1096 install_variable (struct varobj
*var
)
1099 struct vlist
*newvl
;
1101 unsigned int index
= 0;
1104 for (chp
= var
->obj_name
; *chp
; chp
++)
1106 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
1109 cv
= *(varobj_table
+ index
);
1110 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
1114 error ("Duplicate variable object name");
1116 /* Add varobj to hash table */
1117 newvl
= xmalloc (sizeof (struct vlist
));
1118 newvl
->next
= *(varobj_table
+ index
);
1120 *(varobj_table
+ index
) = newvl
;
1122 /* If root, add varobj to root list */
1123 if (var
->root
->rootvar
== var
)
1125 /* Add to list of root variables */
1126 if (rootlist
== NULL
)
1127 var
->root
->next
= NULL
;
1129 var
->root
->next
= rootlist
;
1130 rootlist
= var
->root
;
1137 /* Unistall the object VAR. */
1139 uninstall_variable (struct varobj
*var
)
1143 struct varobj_root
*cr
;
1144 struct varobj_root
*prer
;
1146 unsigned int index
= 0;
1149 /* Remove varobj from hash table */
1150 for (chp
= var
->obj_name
; *chp
; chp
++)
1152 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
1155 cv
= *(varobj_table
+ index
);
1157 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
1164 fprintf_unfiltered (gdb_stdlog
, "Deleting %s\n", var
->obj_name
);
1169 ("Assertion failed: Could not find variable object \"%s\" to delete",
1175 *(varobj_table
+ index
) = cv
->next
;
1177 prev
->next
= cv
->next
;
1181 /* If root, remove varobj from root list */
1182 if (var
->root
->rootvar
== var
)
1184 /* Remove from list of root variables */
1185 if (rootlist
== var
->root
)
1186 rootlist
= var
->root
->next
;
1191 while ((cr
!= NULL
) && (cr
->rootvar
!= var
))
1199 ("Assertion failed: Could not find varobj \"%s\" in root list",
1206 prer
->next
= cr
->next
;
1213 /* Does a child with the name NAME exist in VAR? If so, return its data.
1214 If not, return NULL. */
1215 static struct varobj
*
1216 child_exists (struct varobj
*var
, char *name
)
1218 struct varobj_child
*vc
;
1220 for (vc
= var
->children
; vc
!= NULL
; vc
= vc
->next
)
1222 if (STREQ (vc
->child
->name
, name
))
1229 /* Create and install a child of the parent of the given name */
1230 static struct varobj
*
1231 create_child (struct varobj
*parent
, int index
, char *name
)
1233 struct varobj
*child
;
1236 child
= new_variable ();
1238 /* name is allocated by name_of_child */
1240 child
->index
= index
;
1241 child
->value
= value_of_child (parent
, index
);
1242 if (child
->value
== NULL
|| parent
->error
)
1244 child
->parent
= parent
;
1245 child
->root
= parent
->root
;
1247 (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 xfree (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 (struct value
*val1
, struct value
*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 ``struct value *'' 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
1606 static struct value
*
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 varobj_delete (var
, NULL
, 0);
1649 tmp_var
->obj_name
= varobj_gen_name ();
1651 install_variable (tmp_var
);
1652 *var_handle
= tmp_var
;
1662 return (*var
->root
->lang
->value_of_root
) (var_handle
);
1665 /* What is the ``struct value *'' for the INDEX'th child of PARENT? */
1666 static struct value
*
1667 value_of_child (struct varobj
*parent
, int index
)
1669 struct value
*value
;
1671 value
= (*parent
->root
->lang
->value_of_child
) (parent
, index
);
1673 /* If we're being lazy, fetch the real value of the variable. */
1674 if (value
!= NULL
&& VALUE_LAZY (value
))
1675 gdb_value_fetch_lazy (value
);
1680 /* What is the type of VAR? */
1681 static struct type
*
1682 type_of_child (struct varobj
*var
)
1685 /* If the child had no evaluation errors, var->value
1686 will be non-NULL and contain a valid type. */
1687 if (var
->value
!= NULL
)
1688 return VALUE_TYPE (var
->value
);
1690 /* Otherwise, we must compute the type. */
1691 return (*var
->root
->lang
->type_of_child
) (var
->parent
, var
->index
);
1694 /* Is this variable editable? Use the variable's type to make
1695 this determination. */
1697 variable_editable (struct varobj
*var
)
1699 return (*var
->root
->lang
->variable_editable
) (var
);
1702 /* GDB already has a command called "value_of_variable". Sigh. */
1704 my_value_of_variable (struct varobj
*var
)
1706 return (*var
->root
->lang
->value_of_variable
) (var
);
1709 /* Is VAR something that can change? Depending on language,
1710 some variable's values never change. For example,
1711 struct and unions never change values. */
1713 type_changeable (struct varobj
*var
)
1718 if (CPLUS_FAKE_CHILD (var
))
1721 type
= get_type (var
);
1723 switch (TYPE_CODE (type
))
1725 case TYPE_CODE_STRUCT
:
1726 case TYPE_CODE_UNION
:
1727 case TYPE_CODE_ARRAY
:
1740 c_number_of_children (struct varobj
*var
)
1743 struct type
*target
;
1746 type
= get_type (var
);
1747 target
= get_target_type (type
);
1750 switch (TYPE_CODE (type
))
1752 case TYPE_CODE_ARRAY
:
1753 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (target
) > 0
1754 && TYPE_ARRAY_UPPER_BOUND_TYPE (type
) != BOUND_CANNOT_BE_DETERMINED
)
1755 children
= TYPE_LENGTH (type
) / TYPE_LENGTH (target
);
1760 case TYPE_CODE_STRUCT
:
1761 case TYPE_CODE_UNION
:
1762 children
= TYPE_NFIELDS (type
);
1766 /* This is where things get compilcated. All pointers have one child.
1767 Except, of course, for struct and union ptr, which we automagically
1768 dereference for the user and function ptrs, which have no children.
1769 We also don't dereference void* as we don't know what to show.
1770 We can show char* so we allow it to be dereferenced. If you decide
1771 to test for it, please mind that a little magic is necessary to
1772 properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
1773 TYPE_NAME == "char" */
1775 switch (TYPE_CODE (target
))
1777 case TYPE_CODE_STRUCT
:
1778 case TYPE_CODE_UNION
:
1779 children
= TYPE_NFIELDS (target
);
1782 case TYPE_CODE_FUNC
:
1783 case TYPE_CODE_VOID
:
1793 /* Other types have no children */
1801 c_name_of_variable (struct varobj
*parent
)
1803 return savestring (parent
->name
, strlen (parent
->name
));
1807 c_name_of_child (struct varobj
*parent
, int index
)
1810 struct type
*target
;
1814 type
= get_type (parent
);
1815 target
= get_target_type (type
);
1817 switch (TYPE_CODE (type
))
1819 case TYPE_CODE_ARRAY
:
1821 /* We never get here unless parent->num_children is greater than 0... */
1823 while ((int) pow ((double) 10, (double) len
) < index
)
1825 name
= (char *) xmalloc (1 + len
* sizeof (char));
1826 sprintf (name
, "%d", index
);
1830 case TYPE_CODE_STRUCT
:
1831 case TYPE_CODE_UNION
:
1832 string
= TYPE_FIELD_NAME (type
, index
);
1833 name
= savestring (string
, strlen (string
));
1837 switch (TYPE_CODE (target
))
1839 case TYPE_CODE_STRUCT
:
1840 case TYPE_CODE_UNION
:
1841 string
= TYPE_FIELD_NAME (target
, index
);
1842 name
= savestring (string
, strlen (string
));
1847 (char *) xmalloc ((strlen (parent
->name
) + 2) * sizeof (char));
1848 sprintf (name
, "*%s", parent
->name
);
1854 /* This should not happen */
1855 name
= xstrdup ("???");
1861 static struct value
*
1862 c_value_of_root (struct varobj
**var_handle
)
1864 struct value
*new_val
;
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
);
1922 static struct value
*
1923 c_value_of_child (struct varobj
*parent
, int index
)
1925 struct value
*value
;
1927 struct value
*indval
;
1928 struct type
*type
, *target
;
1931 type
= get_type (parent
);
1932 target
= get_target_type (type
);
1933 name
= name_of_child (parent
, index
);
1934 temp
= parent
->value
;
1939 switch (TYPE_CODE (type
))
1941 case TYPE_CODE_ARRAY
:
1943 /* This breaks if the array lives in a (vector) register. */
1944 value
= value_slice (temp
, index
, 1);
1945 temp
= value_coerce_array (value
);
1946 gdb_value_ind (temp
, &value
);
1948 indval
= value_from_longest (builtin_type_int
, (LONGEST
) index
);
1949 gdb_value_subscript (temp
, indval
, &value
);
1953 case TYPE_CODE_STRUCT
:
1954 case TYPE_CODE_UNION
:
1955 gdb_value_struct_elt (NULL
, &value
, &temp
, NULL
, name
, NULL
, "vstructure");
1959 switch (TYPE_CODE (target
))
1961 case TYPE_CODE_STRUCT
:
1962 case TYPE_CODE_UNION
:
1963 gdb_value_struct_elt (NULL
, &value
, &temp
, NULL
, name
, NULL
, "vstructure");
1967 gdb_value_ind (temp
, &value
);
1978 release_value (value
);
1984 static struct type
*
1985 c_type_of_child (struct varobj
*parent
, int index
)
1988 char *name
= name_of_child (parent
, index
);
1990 switch (TYPE_CODE (parent
->type
))
1992 case TYPE_CODE_ARRAY
:
1993 type
= TYPE_TARGET_TYPE (parent
->type
);
1996 case TYPE_CODE_STRUCT
:
1997 case TYPE_CODE_UNION
:
1998 type
= lookup_struct_elt_type (parent
->type
, name
, 0);
2002 switch (TYPE_CODE (TYPE_TARGET_TYPE (parent
->type
)))
2004 case TYPE_CODE_STRUCT
:
2005 case TYPE_CODE_UNION
:
2006 type
= lookup_struct_elt_type (parent
->type
, name
, 0);
2010 type
= TYPE_TARGET_TYPE (parent
->type
);
2016 /* This should not happen as only the above types have children */
2017 warning ("Child of parent whose type does not allow children");
2018 /* FIXME: Can we still go on? */
2028 c_variable_editable (struct varobj
*var
)
2030 switch (TYPE_CODE (get_type (var
)))
2032 case TYPE_CODE_STRUCT
:
2033 case TYPE_CODE_UNION
:
2034 case TYPE_CODE_ARRAY
:
2035 case TYPE_CODE_FUNC
:
2036 case TYPE_CODE_MEMBER
:
2037 case TYPE_CODE_METHOD
:
2048 c_value_of_variable (struct varobj
*var
)
2053 if (var
->value
!= NULL
)
2057 /* This can happen if we attempt to get the value of a struct
2058 member when the parent is an invalid pointer. */
2059 return xstrdup ("???");
2062 /* BOGUS: if val_print sees a struct/class, it will print out its
2063 children instead of "{...}" */
2064 type
= get_type (var
);
2065 switch (TYPE_CODE (type
))
2067 case TYPE_CODE_STRUCT
:
2068 case TYPE_CODE_UNION
:
2069 return xstrdup ("{...}");
2072 case TYPE_CODE_ARRAY
:
2075 sprintf (number
, "[%d]", var
->num_children
);
2076 return xstrdup (number
);
2083 struct ui_file
*stb
= mem_fileopen ();
2084 struct cleanup
*old_chain
= make_cleanup_ui_file_delete (stb
);
2087 if (VALUE_LAZY (val
))
2088 gdb_value_fetch_lazy (val
);
2089 val_print (VALUE_TYPE (val
), VALUE_CONTENTS_RAW (val
), 0,
2090 VALUE_ADDRESS (val
),
2091 stb
, format_code
[(int) var
->format
], 1, 0, 0);
2092 thevalue
= ui_file_xstrdup (stb
, &dummy
);
2093 do_cleanups (old_chain
);
2104 cplus_number_of_children (struct varobj
*var
)
2107 int children
, dont_know
;
2112 if (!CPLUS_FAKE_CHILD (var
))
2114 type
= get_type_deref (var
);
2116 if (((TYPE_CODE (type
)) == TYPE_CODE_STRUCT
) ||
2117 ((TYPE_CODE (type
)) == TYPE_CODE_UNION
))
2121 cplus_class_num_children (type
, kids
);
2122 if (kids
[v_public
] != 0)
2124 if (kids
[v_private
] != 0)
2126 if (kids
[v_protected
] != 0)
2129 /* Add any baseclasses */
2130 children
+= TYPE_N_BASECLASSES (type
);
2133 /* FIXME: save children in var */
2140 type
= get_type_deref (var
->parent
);
2142 cplus_class_num_children (type
, kids
);
2143 if (STREQ (var
->name
, "public"))
2144 children
= kids
[v_public
];
2145 else if (STREQ (var
->name
, "private"))
2146 children
= kids
[v_private
];
2148 children
= kids
[v_protected
];
2153 children
= c_number_of_children (var
);
2158 /* Compute # of public, private, and protected variables in this class.
2159 That means we need to descend into all baseclasses and find out
2160 how many are there, too. */
2162 cplus_class_num_children (struct type
*type
, int children
[3])
2166 children
[v_public
] = 0;
2167 children
[v_private
] = 0;
2168 children
[v_protected
] = 0;
2170 for (i
= TYPE_N_BASECLASSES (type
); i
< TYPE_NFIELDS (type
); i
++)
2172 /* If we have a virtual table pointer, omit it. */
2173 if (TYPE_VPTR_BASETYPE (type
) == type
&& TYPE_VPTR_FIELDNO (type
) == i
)
2176 if (TYPE_FIELD_PROTECTED (type
, i
))
2177 children
[v_protected
]++;
2178 else if (TYPE_FIELD_PRIVATE (type
, i
))
2179 children
[v_private
]++;
2181 children
[v_public
]++;
2186 cplus_name_of_variable (struct varobj
*parent
)
2188 return c_name_of_variable (parent
);
2192 cplus_name_of_child (struct varobj
*parent
, int index
)
2198 if (CPLUS_FAKE_CHILD (parent
))
2200 /* Looking for children of public, private, or protected. */
2201 type
= get_type_deref (parent
->parent
);
2204 type
= get_type_deref (parent
);
2207 switch (TYPE_CODE (type
))
2209 case TYPE_CODE_STRUCT
:
2210 case TYPE_CODE_UNION
:
2211 cplus_class_num_children (type
, children
);
2213 if (CPLUS_FAKE_CHILD (parent
))
2215 /* FIXME: This assumes that type orders
2216 inherited, public, private, protected */
2217 int i
= index
+ TYPE_N_BASECLASSES (type
);
2218 if (STREQ (parent
->name
, "private")
2219 || STREQ (parent
->name
, "protected"))
2220 i
+= children
[v_public
];
2221 if (STREQ (parent
->name
, "protected"))
2222 i
+= children
[v_private
];
2224 name
= TYPE_FIELD_NAME (type
, i
);
2226 else if (index
< TYPE_N_BASECLASSES (type
))
2227 name
= TYPE_FIELD_NAME (type
, index
);
2230 /* Everything beyond the baseclasses can
2231 only be "public", "private", or "protected" */
2232 index
-= TYPE_N_BASECLASSES (type
);
2236 if (children
[v_public
] != 0)
2242 if (children
[v_private
] != 0)
2248 if (children
[v_protected
] != 0)
2265 return c_name_of_child (parent
, index
);
2269 name
= savestring (name
, strlen (name
));
2275 static struct value
*
2276 cplus_value_of_root (struct varobj
**var_handle
)
2278 return c_value_of_root (var_handle
);
2281 static struct value
*
2282 cplus_value_of_child (struct varobj
*parent
, int index
)
2285 struct value
*value
;
2287 if (CPLUS_FAKE_CHILD (parent
))
2288 type
= get_type_deref (parent
->parent
);
2290 type
= get_type_deref (parent
);
2294 if (((TYPE_CODE (type
)) == TYPE_CODE_STRUCT
) ||
2295 ((TYPE_CODE (type
)) == TYPE_CODE_UNION
))
2297 if (CPLUS_FAKE_CHILD (parent
))
2300 struct value
*temp
= parent
->parent
->value
;
2302 name
= name_of_child (parent
, index
);
2303 gdb_value_struct_elt (NULL
, &value
, &temp
, NULL
, name
, NULL
,
2306 release_value (value
);
2310 else if (index
>= TYPE_N_BASECLASSES (type
))
2312 /* public, private, or protected */
2318 if (parent
->value
!= NULL
)
2322 if (TYPE_CODE (VALUE_TYPE (parent
->value
)) == TYPE_CODE_PTR
2323 || TYPE_CODE (VALUE_TYPE (parent
->value
)) == TYPE_CODE_REF
)
2325 if (!gdb_value_ind (parent
->value
, &temp
))
2329 temp
= parent
->value
;
2331 value
= value_cast (TYPE_FIELD_TYPE (type
, index
), temp
);
2332 release_value (value
);
2338 return c_value_of_child (parent
, index
);
2343 static struct type
*
2344 cplus_type_of_child (struct varobj
*parent
, int index
)
2346 struct type
*type
, *t
;
2348 t
= get_type_deref (parent
);
2350 switch (TYPE_CODE (t
))
2352 case TYPE_CODE_STRUCT
:
2353 case TYPE_CODE_UNION
:
2354 if (index
>= TYPE_N_BASECLASSES (t
))
2362 type
= TYPE_FIELD_TYPE (t
, index
);
2371 return c_type_of_child (parent
, index
);
2377 cplus_variable_editable (struct varobj
*var
)
2379 if (CPLUS_FAKE_CHILD (var
))
2382 return c_variable_editable (var
);
2386 cplus_value_of_variable (struct varobj
*var
)
2389 /* If we have one of our special types, don't print out
2391 if (CPLUS_FAKE_CHILD (var
))
2392 return xstrdup ("");
2394 return c_value_of_variable (var
);
2400 java_number_of_children (struct varobj
*var
)
2402 return cplus_number_of_children (var
);
2406 java_name_of_variable (struct varobj
*parent
)
2410 name
= cplus_name_of_variable (parent
);
2411 /* If the name has "-" in it, it is because we
2412 needed to escape periods in the name... */
2415 while (*p
!= '\000')
2426 java_name_of_child (struct varobj
*parent
, int index
)
2430 name
= cplus_name_of_child (parent
, index
);
2431 /* Escape any periods in the name... */
2434 while (*p
!= '\000')
2444 static struct value
*
2445 java_value_of_root (struct varobj
**var_handle
)
2447 return cplus_value_of_root (var_handle
);
2450 static struct value
*
2451 java_value_of_child (struct varobj
*parent
, int index
)
2453 return cplus_value_of_child (parent
, index
);
2456 static struct type
*
2457 java_type_of_child (struct varobj
*parent
, int index
)
2459 return cplus_type_of_child (parent
, index
);
2463 java_variable_editable (struct varobj
*var
)
2465 return cplus_variable_editable (var
);
2469 java_value_of_variable (struct varobj
*var
)
2471 return cplus_value_of_variable (var
);
2474 extern void _initialize_varobj (void);
2476 _initialize_varobj (void)
2478 int sizeof_table
= sizeof (struct vlist
*) * VAROBJ_TABLE_SIZE
;
2480 varobj_table
= xmalloc (sizeof_table
);
2481 memset (varobj_table
, 0, sizeof_table
);
2483 add_show_from_set (add_set_cmd ("debugvarobj", class_maintenance
, var_zinteger
, (char *) &varobjdebug
, "Set varobj debugging.\n\
2484 When non-zero, varobj debugging is enabled.", &setlist
),