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"
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
;
394 /* Is the variable X one of our "fake" children? */
395 #define CPLUS_FAKE_CHILD(x) \
396 ((x) != NULL && (x)->type == NULL && (x)->value == NULL)
399 /* API Implementation */
401 /* Creates a varobj (not its children) */
404 varobj_create (char *objname
,
405 char *expression
, CORE_ADDR frame
,
406 enum varobj_type type
)
409 struct frame_info
*fi
;
410 struct frame_info
*old_fi
= NULL
;
412 struct cleanup
*old_chain
;
414 /* Fill out a varobj structure for the (root) variable being constructed. */
415 var
= new_root_variable ();
416 old_chain
= make_cleanup_free_variable (var
);
418 if (expression
!= NULL
)
421 enum varobj_languages lang
;
423 /* Parse and evaluate the expression, filling in as much
424 of the variable's data as possible */
426 /* Allow creator to specify context of variable */
427 if ((type
== USE_CURRENT_FRAME
)
428 || (type
== USE_SELECTED_FRAME
))
431 fi
= find_frame_addr_in_frame_chain (frame
);
433 /* frame = -2 means always use selected frame */
434 if (type
== USE_SELECTED_FRAME
)
435 var
->root
->use_selected_frame
= 1;
439 block
= get_frame_block (fi
);
442 innermost_block
= NULL
;
443 /* Wrap the call to parse expression, so we can
444 return a sensible error. */
445 if (!gdb_parse_exp_1 (&p
, block
, 0, &var
->root
->exp
))
450 /* Don't allow variables to be created for types. */
451 if (var
->root
->exp
->elts
[0].opcode
== OP_TYPE
)
453 do_cleanups (old_chain
);
454 fprintf_unfiltered (gdb_stderr
,
455 "Attempt to use a type name as an expression.");
459 var
->format
= variable_default_display (var
);
460 var
->root
->valid_block
= innermost_block
;
461 var
->name
= savestring (expression
, strlen (expression
));
463 /* When the frame is different from the current frame,
464 we must select the appropriate frame before parsing
465 the expression, otherwise the value will not be current.
466 Since select_frame is so benign, just call it for all cases. */
469 var
->root
->frame
= FRAME_FP (fi
);
470 old_fi
= selected_frame
;
471 select_frame (fi
, -1);
474 /* We definitively need to catch errors here.
475 If evaluate_expression succeeds we got the value we wanted.
476 But if it fails, we still go on with a call to evaluate_type() */
477 if (gdb_evaluate_expression (var
->root
->exp
, &var
->value
))
480 release_value (var
->value
);
481 if (VALUE_LAZY (var
->value
))
482 gdb_value_fetch_lazy (var
->value
);
485 var
->value
= evaluate_type (var
->root
->exp
);
487 var
->type
= VALUE_TYPE (var
->value
);
489 /* Set language info */
490 lang
= variable_language (var
);
491 var
->root
->lang
= languages
[lang
];
493 /* Set ourselves as our root */
494 var
->root
->rootvar
= var
;
496 /* Reset the selected frame */
498 select_frame (old_fi
, -1);
501 /* If the variable object name is null, that means this
502 is a temporary variable, so don't install it. */
504 if ((var
!= NULL
) && (objname
!= NULL
))
506 var
->obj_name
= savestring (objname
, strlen (objname
));
508 /* If a varobj name is duplicated, the install will fail so
510 if (!install_variable (var
))
512 do_cleanups (old_chain
);
517 discard_cleanups (old_chain
);
521 /* Generates an unique name that can be used for a varobj */
524 varobj_gen_name (void)
529 /* generate a name for this object */
531 sprintf (obj_name
, "var%d", id
);
533 return xstrdup (obj_name
);
536 /* Given an "objname", returns the pointer to the corresponding varobj
537 or NULL if not found */
540 varobj_get_handle (char *objname
)
544 unsigned int index
= 0;
547 for (chp
= objname
; *chp
; chp
++)
549 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
552 cv
= *(varobj_table
+ index
);
553 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, objname
) != 0))
557 error ("Variable object not found");
562 /* Given the handle, return the name of the object */
565 varobj_get_objname (struct varobj
*var
)
567 return var
->obj_name
;
570 /* Given the handle, return the expression represented by the object */
573 varobj_get_expression (struct varobj
*var
)
575 return name_of_variable (var
);
578 /* Deletes a varobj and all its children if only_children == 0,
579 otherwise deletes only the children; returns a malloc'ed list of all the
580 (malloc'ed) names of the variables that have been deleted (NULL terminated) */
583 varobj_delete (struct varobj
*var
, char ***dellist
, int only_children
)
587 struct cpstack
*result
= NULL
;
590 /* Initialize a stack for temporary results */
591 cppush (&result
, NULL
);
594 /* Delete only the variable children */
595 delcount
= delete_variable (&result
, var
, 1 /* only the children */ );
597 /* Delete the variable and all its children */
598 delcount
= delete_variable (&result
, var
, 0 /* parent+children */ );
600 /* We may have been asked to return a list of what has been deleted */
603 *dellist
= xmalloc ((delcount
+ 1) * sizeof (char *));
607 *cp
= cppop (&result
);
608 while ((*cp
!= NULL
) && (mycount
> 0))
612 *cp
= cppop (&result
);
615 if (mycount
|| (*cp
!= NULL
))
616 warning ("varobj_delete: assertion failed - mycount(=%d) <> 0", mycount
);
622 /* Set/Get variable object display format */
624 enum varobj_display_formats
625 varobj_set_display_format (struct varobj
*var
,
626 enum varobj_display_formats format
)
633 case FORMAT_HEXADECIMAL
:
635 var
->format
= format
;
639 var
->format
= variable_default_display (var
);
645 enum varobj_display_formats
646 varobj_get_display_format (struct varobj
*var
)
652 varobj_get_num_children (struct varobj
*var
)
654 if (var
->num_children
== -1)
655 var
->num_children
= number_of_children (var
);
657 return var
->num_children
;
660 /* Creates a list of the immediate children of a variable object;
661 the return code is the number of such children or -1 on error */
664 varobj_list_children (struct varobj
*var
, struct varobj
***childlist
)
666 struct varobj
*child
;
670 /* sanity check: have we been passed a pointer? */
671 if (childlist
== NULL
)
676 if (var
->num_children
== -1)
677 var
->num_children
= number_of_children (var
);
679 /* List of children */
680 *childlist
= xmalloc ((var
->num_children
+ 1) * sizeof (struct varobj
*));
682 for (i
= 0; i
< var
->num_children
; i
++)
684 /* Mark as the end in case we bail out */
685 *((*childlist
) + i
) = NULL
;
687 /* check if child exists, if not create */
688 name
= name_of_child (var
, i
);
689 child
= child_exists (var
, name
);
691 child
= create_child (var
, i
, name
);
693 *((*childlist
) + i
) = child
;
696 /* End of list is marked by a NULL pointer */
697 *((*childlist
) + i
) = NULL
;
699 return var
->num_children
;
702 /* Obtain the type of an object Variable as a string similar to the one gdb
703 prints on the console */
706 varobj_get_type (struct varobj
*var
)
709 struct cleanup
*old_chain
;
714 /* For the "fake" variables, do not return a type. (It's type is
716 if (CPLUS_FAKE_CHILD (var
))
719 stb
= mem_fileopen ();
720 old_chain
= make_cleanup_ui_file_delete (stb
);
722 /* To print the type, we simply create a zero value_ptr and
723 cast it to our type. We then typeprint this variable. */
724 val
= value_zero (var
->type
, not_lval
);
725 type_print (VALUE_TYPE (val
), "", stb
, -1);
727 thetype
= ui_file_xstrdup (stb
, &length
);
728 do_cleanups (old_chain
);
732 enum varobj_languages
733 varobj_get_language (struct varobj
*var
)
735 return variable_language (var
);
739 varobj_get_attributes (struct varobj
*var
)
743 if (variable_editable (var
))
744 /* FIXME: define masks for attributes */
745 attributes
|= 0x00000001; /* Editable */
751 varobj_get_value (struct varobj
*var
)
753 return my_value_of_variable (var
);
756 /* Set the value of an object variable (if it is editable) to the
757 value of the given expression */
758 /* Note: Invokes functions that can call error() */
761 varobj_set_value (struct varobj
*var
, char *expression
)
766 /* The argument "expression" contains the variable's new value.
767 We need to first construct a legal expression for this -- ugh! */
768 /* Does this cover all the bases? */
769 struct expression
*exp
;
771 int saved_input_radix
= input_radix
;
773 if (variable_editable (var
) && !var
->error
)
775 char *s
= expression
;
779 input_radix
= 10; /* ALWAYS reset to decimal temporarily */
780 if (!gdb_parse_exp_1 (&s
, 0, 0, &exp
))
781 /* We cannot proceed without a well-formed expression. */
783 if (!gdb_evaluate_expression (exp
, &value
))
785 /* We cannot proceed without a valid expression. */
790 /* If our parent is "public", "private", or "protected", we could
791 be asking to modify the value of a baseclass. If so, we need to
792 adjust our address by the offset of our baseclass in the subclass,
793 since VALUE_ADDRESS (var->value) points at the start of the subclass.
794 For some reason, value_cast doesn't take care of this properly. */
796 if (var
->parent
!= NULL
&& CPLUS_FAKE_CHILD (var
->parent
))
798 struct varobj
*super
, *sub
;
800 super
= var
->parent
->parent
;
804 /* Yes, it is a baseclass */
805 type
= get_type_deref (sub
);
807 if (super
->index
< TYPE_N_BASECLASSES (type
))
809 temp
= value_copy (var
->value
);
810 for (i
= 0; i
< super
->index
; i
++)
811 offset
+= TYPE_LENGTH (TYPE_FIELD_TYPE (type
, i
));
816 VALUE_ADDRESS (temp
) += offset
;
817 if (!gdb_value_assign (temp
, value
, &val
))
819 VALUE_ADDRESS (val
) -= offset
;
820 value_free (var
->value
);
823 input_radix
= saved_input_radix
;
830 /* Returns a malloc'ed list with all root variable objects */
832 varobj_list (struct varobj
***varlist
)
835 struct varobj_root
*croot
;
836 int mycount
= rootcount
;
838 /* Alloc (rootcount + 1) entries for the result */
839 *varlist
= xmalloc ((rootcount
+ 1) * sizeof (struct varobj
*));
843 while ((croot
!= NULL
) && (mycount
> 0))
845 *cv
= croot
->rootvar
;
850 /* Mark the end of the list */
853 if (mycount
|| (croot
!= NULL
))
854 warning ("varobj_list: assertion failed - wrong tally of root vars (%d:%d)",
860 /* Update the values for a variable and its children. This is a
861 two-pronged attack. First, re-parse the value for the root's
862 expression to see if it's changed. Then go all the way
863 through its children, reconstructing them and noting if they've
866 -1 if there was an error updating the varobj
867 -2 if the type changed
868 Otherwise it is the number of children + parent changed
870 Only root variables can be updated... */
873 varobj_update (struct varobj
*var
, struct varobj
***changelist
)
882 struct varobj
**templist
= NULL
;
884 struct vstack
*stack
= NULL
;
885 struct vstack
*result
= NULL
;
886 struct frame_info
*old_fi
;
888 /* sanity check: have we been passed a pointer? */
889 if (changelist
== NULL
)
892 /* Only root variables can be updated... */
893 if (var
->root
->rootvar
!= var
)
897 /* Save the selected stack frame, since we will need to change it
898 in order to evaluate expressions. */
899 old_fi
= selected_frame
;
901 /* Update the root variable. value_of_root can return NULL
902 if the variable is no longer around, i.e. we stepped out of
903 the frame in which a local existed. We are letting the
904 value_of_root variable dispose of the varobj if the type
907 new = value_of_root (&var
, &type_changed
);
914 /* Initialize a stack for temporary results */
915 vpush (&result
, NULL
);
917 /* If this is a "use_selected_frame" varobj, and its type has changed,
918 them note that it's changed. */
921 vpush (&result
, var
);
924 /* If values are not equal, note that it's changed.
925 There a couple of exceptions here, though.
926 We don't want some types to be reported as "changed". */
927 else if (type_changeable (var
) && !my_value_equal (var
->value
, new, &error2
))
929 vpush (&result
, var
);
931 /* error2 replaces var->error since this new value
932 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
, xstrdup (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 (struct varobj
*var
, char *name
)
1217 struct varobj_child
*vc
;
1219 for (vc
= var
->children
; vc
!= NULL
; vc
= vc
->next
)
1221 if (STREQ (vc
->child
->name
, name
))
1228 /* Create and install a child of the parent of the given name */
1229 static struct varobj
*
1230 create_child (struct varobj
*parent
, int index
, char *name
)
1232 struct varobj
*child
;
1235 child
= new_variable ();
1237 /* name is allocated by name_of_child */
1239 child
->index
= index
;
1240 child
->value
= value_of_child (parent
, index
);
1241 if (child
->value
== NULL
|| parent
->error
)
1243 child
->parent
= parent
;
1244 child
->root
= parent
->root
;
1245 childs_name
= (char *) xmalloc ((strlen (parent
->obj_name
) + strlen (name
) + 2)
1247 sprintf (childs_name
, "%s.%s", parent
->obj_name
, name
);
1248 child
->obj_name
= childs_name
;
1249 install_variable (child
);
1251 /* Save a pointer to this child in the parent */
1252 save_child_in_parent (parent
, child
);
1254 /* Note the type of this child */
1255 child
->type
= type_of_child (child
);
1260 /* FIXME: This should be a generic add to list */
1261 /* Save CHILD in the PARENT's data. */
1263 save_child_in_parent (struct varobj
*parent
, struct varobj
*child
)
1265 struct varobj_child
*vc
;
1267 /* Insert the child at the top */
1268 vc
= parent
->children
;
1270 (struct varobj_child
*) xmalloc (sizeof (struct varobj_child
));
1272 parent
->children
->next
= vc
;
1273 parent
->children
->child
= child
;
1276 /* FIXME: This should be a generic remove from list */
1277 /* Remove the CHILD from the PARENT's list of children. */
1279 remove_child_from_parent (struct varobj
*parent
, struct varobj
*child
)
1281 struct varobj_child
*vc
, *prev
;
1283 /* Find the child in the parent's list */
1285 for (vc
= parent
->children
; vc
!= NULL
;)
1287 if (vc
->child
== child
)
1294 parent
->children
= vc
->next
;
1296 prev
->next
= vc
->next
;
1302 * Miscellaneous utility functions.
1305 /* Allocate memory and initialize a new variable */
1306 static struct varobj
*
1311 var
= (struct varobj
*) xmalloc (sizeof (struct varobj
));
1313 var
->obj_name
= NULL
;
1318 var
->num_children
= -1;
1320 var
->children
= NULL
;
1327 /* Allocate memory and initialize a new root variable */
1328 static struct varobj
*
1329 new_root_variable (void)
1331 struct varobj
*var
= new_variable ();
1332 var
->root
= (struct varobj_root
*) xmalloc (sizeof (struct varobj_root
));;
1333 var
->root
->lang
= NULL
;
1334 var
->root
->exp
= NULL
;
1335 var
->root
->valid_block
= NULL
;
1336 var
->root
->frame
= (CORE_ADDR
) -1;
1337 var
->root
->use_selected_frame
= 0;
1338 var
->root
->rootvar
= NULL
;
1343 /* Free any allocated memory associated with VAR. */
1345 free_variable (struct varobj
*var
)
1347 /* Free the expression if this is a root variable. */
1348 if (var
->root
->rootvar
== var
)
1350 free_current_contents ((char **) &var
->root
->exp
);
1355 xfree (var
->obj_name
);
1360 do_free_variable_cleanup (void *var
)
1362 free_variable (var
);
1365 static struct cleanup
*
1366 make_cleanup_free_variable (struct varobj
*var
)
1368 return make_cleanup (do_free_variable_cleanup
, var
);
1371 /* This returns the type of the variable. This skips past typedefs
1372 and returns the real type of the variable. It also dereferences
1373 pointers and references. */
1374 static struct type
*
1375 get_type (struct varobj
*var
)
1380 while (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1381 type
= TYPE_TARGET_TYPE (type
);
1386 /* This returns the type of the variable, dereferencing pointers, too. */
1387 static struct type
*
1388 get_type_deref (struct varobj
*var
)
1392 type
= get_type (var
);
1394 if (type
!= NULL
&& (TYPE_CODE (type
) == TYPE_CODE_PTR
1395 || TYPE_CODE (type
) == TYPE_CODE_REF
))
1396 type
= get_target_type (type
);
1401 /* This returns the target type (or NULL) of TYPE, also skipping
1402 past typedefs, just like get_type (). */
1403 static struct type
*
1404 get_target_type (struct type
*type
)
1408 type
= TYPE_TARGET_TYPE (type
);
1409 while (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
1410 type
= TYPE_TARGET_TYPE (type
);
1416 /* What is the default display for this variable? We assume that
1417 everything is "natural". Any exceptions? */
1418 static enum varobj_display_formats
1419 variable_default_display (struct varobj
*var
)
1421 return FORMAT_NATURAL
;
1424 /* This function is similar to gdb's value_equal, except that this
1425 one is "safe" -- it NEVER longjmps. It determines if the VAR's
1426 value is the same as VAL2. */
1428 my_value_equal (value_ptr val1
, value_ptr val2
, int *error2
)
1433 /* Special case: NULL values. If both are null, say
1435 if (val1
== NULL
&& val2
== NULL
)
1437 else if (val1
== NULL
|| val2
== NULL
)
1440 /* This is bogus, but unfortunately necessary. We must know
1441 exactly what caused an error -- reading val1 or val2 -- so
1442 that we can really determine if we think that something has changed. */
1445 /* We do need to catch errors here because the whole purpose
1446 is to test if value_equal() has errored */
1447 if (!gdb_value_equal (val1
, val1
, &r
))
1450 if (!gdb_value_equal (val2
, val2
, &r
))
1456 if (!gdb_value_equal (val1
, val2
, &r
))
1458 /* An error occurred, this could have happened if
1459 either val1 or val2 errored. ERR1 and ERR2 tell
1460 us which of these it is. If both errored, then
1461 we assume nothing has changed. If one of them is
1462 valid, though, then something has changed. */
1465 /* both the old and new values caused errors, so
1466 we say the value did not change */
1467 /* This is indeterminate, though. Perhaps we should
1468 be safe and say, yes, it changed anyway?? */
1480 /* FIXME: The following should be generic for any pointer */
1482 vpush (struct vstack
**pstack
, struct varobj
*var
)
1486 s
= (struct vstack
*) xmalloc (sizeof (struct vstack
));
1492 /* FIXME: The following should be generic for any pointer */
1493 static struct varobj
*
1494 vpop (struct vstack
**pstack
)
1499 if ((*pstack
)->var
== NULL
&& (*pstack
)->next
== NULL
)
1504 *pstack
= (*pstack
)->next
;
1510 /* FIXME: The following should be generic for any pointer */
1512 cppush (struct cpstack
**pstack
, char *name
)
1516 s
= (struct cpstack
*) xmalloc (sizeof (struct cpstack
));
1522 /* FIXME: The following should be generic for any pointer */
1524 cppop (struct cpstack
**pstack
)
1529 if ((*pstack
)->name
== NULL
&& (*pstack
)->next
== NULL
)
1534 *pstack
= (*pstack
)->next
;
1541 * Language-dependencies
1544 /* Common entry points */
1546 /* Get the language of variable VAR. */
1547 static enum varobj_languages
1548 variable_language (struct varobj
*var
)
1550 enum varobj_languages lang
;
1552 switch (var
->root
->exp
->language_defn
->la_language
)
1558 case language_cplus
:
1569 /* Return the number of children for a given variable.
1570 The result of this function is defined by the language
1571 implementation. The number of children returned by this function
1572 is the number of children that the user will see in the variable
1575 number_of_children (struct varobj
*var
)
1577 return (*var
->root
->lang
->number_of_children
) (var
);;
1580 /* What is the expression for the root varobj VAR? Returns a malloc'd string. */
1582 name_of_variable (struct varobj
*var
)
1584 return (*var
->root
->lang
->name_of_variable
) (var
);
1587 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd string. */
1589 name_of_child (struct varobj
*var
, int index
)
1591 return (*var
->root
->lang
->name_of_child
) (var
, index
);
1594 /* What is the value_ptr of the root variable VAR?
1595 TYPE_CHANGED controls what to do if the type of a
1596 use_selected_frame = 1 variable changes. On input,
1597 TYPE_CHANGED = 1 means discard the old varobj, and replace
1598 it with this one. TYPE_CHANGED = 0 means leave it around.
1599 NB: In both cases, var_handle will point to the new varobj,
1600 so if you use TYPE_CHANGED = 0, you will have to stash the
1601 old varobj pointer away somewhere before calling this.
1602 On return, TYPE_CHANGED will be 1 if the type has changed, and
1605 value_of_root (struct varobj
**var_handle
, int *type_changed
)
1609 if (var_handle
== NULL
)
1614 /* This should really be an exception, since this should
1615 only get called with a root variable. */
1617 if (var
->root
->rootvar
!= var
)
1620 if (var
->root
->use_selected_frame
)
1622 struct varobj
*tmp_var
;
1623 char *old_type
, *new_type
;
1624 old_type
= varobj_get_type (var
);
1625 tmp_var
= varobj_create (NULL
, var
->name
, (CORE_ADDR
) 0,
1626 USE_SELECTED_FRAME
);
1627 if (tmp_var
== NULL
)
1631 new_type
= varobj_get_type (tmp_var
);
1632 if (strcmp(old_type
, new_type
) == 0)
1634 varobj_delete (tmp_var
, NULL
, 0);
1642 savestring (var
->obj_name
, strlen (var
->obj_name
));
1643 uninstall_variable (var
);
1647 tmp_var
->obj_name
= varobj_gen_name ();
1649 install_variable (tmp_var
);
1650 *var_handle
= tmp_var
;
1659 return (*var
->root
->lang
->value_of_root
) (var_handle
);
1662 /* What is the value_ptr for the INDEX'th child of PARENT? */
1664 value_of_child (struct varobj
*parent
, int index
)
1668 value
= (*parent
->root
->lang
->value_of_child
) (parent
, index
);
1670 /* If we're being lazy, fetch the real value of the variable. */
1671 if (value
!= NULL
&& VALUE_LAZY (value
))
1672 gdb_value_fetch_lazy (value
);
1677 /* What is the type of VAR? */
1678 static struct type
*
1679 type_of_child (struct varobj
*var
)
1682 /* If the child had no evaluation errors, var->value
1683 will be non-NULL and contain a valid type. */
1684 if (var
->value
!= NULL
)
1685 return VALUE_TYPE (var
->value
);
1687 /* Otherwise, we must compute the type. */
1688 return (*var
->root
->lang
->type_of_child
) (var
->parent
, var
->index
);
1691 /* Is this variable editable? Use the variable's type to make
1692 this determination. */
1694 variable_editable (struct varobj
*var
)
1696 return (*var
->root
->lang
->variable_editable
) (var
);
1699 /* GDB already has a command called "value_of_variable". Sigh. */
1701 my_value_of_variable (struct varobj
*var
)
1703 return (*var
->root
->lang
->value_of_variable
) (var
);
1706 /* Is VAR something that can change? Depending on language,
1707 some variable's values never change. For example,
1708 struct and unions never change values. */
1710 type_changeable (struct varobj
*var
)
1715 if (CPLUS_FAKE_CHILD (var
))
1718 type
= get_type (var
);
1720 switch (TYPE_CODE (type
))
1722 case TYPE_CODE_STRUCT
:
1723 case TYPE_CODE_UNION
:
1724 case TYPE_CODE_ARRAY
:
1737 c_number_of_children (struct varobj
*var
)
1740 struct type
*target
;
1743 type
= get_type (var
);
1744 target
= get_target_type (type
);
1747 switch (TYPE_CODE (type
))
1749 case TYPE_CODE_ARRAY
:
1750 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (target
) > 0
1751 && TYPE_ARRAY_UPPER_BOUND_TYPE (type
) != BOUND_CANNOT_BE_DETERMINED
)
1752 children
= TYPE_LENGTH (type
) / TYPE_LENGTH (target
);
1757 case TYPE_CODE_STRUCT
:
1758 case TYPE_CODE_UNION
:
1759 children
= TYPE_NFIELDS (type
);
1763 /* This is where things get compilcated. All pointers have one child.
1764 Except, of course, for struct and union ptr, which we automagically
1765 dereference for the user and function ptrs, which have no children. */
1766 switch (TYPE_CODE (target
))
1768 case TYPE_CODE_STRUCT
:
1769 case TYPE_CODE_UNION
:
1770 children
= TYPE_NFIELDS (target
);
1773 case TYPE_CODE_FUNC
:
1778 /* Don't dereference char* or void*. */
1779 if (TYPE_NAME (target
) != NULL
1780 && (STREQ (TYPE_NAME (target
), "char")
1781 || STREQ (TYPE_NAME (target
), "void")))
1789 /* Other types have no children */
1797 c_name_of_variable (struct varobj
*parent
)
1799 return savestring (parent
->name
, strlen (parent
->name
));
1803 c_name_of_child (struct varobj
*parent
, int index
)
1806 struct type
*target
;
1810 type
= get_type (parent
);
1811 target
= get_target_type (type
);
1813 switch (TYPE_CODE (type
))
1815 case TYPE_CODE_ARRAY
:
1817 /* We never get here unless parent->num_children is greater than 0... */
1819 while ((int) pow ((double) 10, (double) len
) < index
)
1821 name
= (char *) xmalloc (1 + len
* sizeof (char));
1822 sprintf (name
, "%d", index
);
1826 case TYPE_CODE_STRUCT
:
1827 case TYPE_CODE_UNION
:
1828 string
= TYPE_FIELD_NAME (type
, index
);
1829 name
= savestring (string
, strlen (string
));
1833 switch (TYPE_CODE (target
))
1835 case TYPE_CODE_STRUCT
:
1836 case TYPE_CODE_UNION
:
1837 string
= TYPE_FIELD_NAME (target
, index
);
1838 name
= savestring (string
, strlen (string
));
1842 name
= (char *) xmalloc ((strlen (parent
->name
) + 2) * sizeof (char));
1843 sprintf (name
, "*%s", parent
->name
);
1849 /* This should not happen */
1850 name
= xstrdup ("???");
1857 c_value_of_root (struct varobj
**var_handle
)
1860 struct varobj
*var
= *var_handle
;
1861 struct frame_info
*fi
;
1864 /* Only root variables can be updated... */
1865 if (var
->root
->rootvar
!= var
)
1866 /* Not a root var */
1870 /* Determine whether the variable is still around. */
1871 if (var
->root
->valid_block
== NULL
)
1875 reinit_frame_cache ();
1878 fi
= find_frame_addr_in_frame_chain (var
->root
->frame
);
1880 within_scope
= fi
!= NULL
;
1881 /* FIXME: select_frame could fail */
1883 select_frame (fi
, -1);
1888 /* We need to catch errors here, because if evaluate
1889 expression fails we just want to make val->error = 1 and
1891 if (gdb_evaluate_expression (var
->root
->exp
, &new_val
))
1893 if (VALUE_LAZY (new_val
))
1895 /* We need to catch errors because if
1896 value_fetch_lazy fails we still want to continue
1897 (after making val->error = 1) */
1898 /* FIXME: Shouldn't be using VALUE_CONTENTS? The
1899 comment on value_fetch_lazy() says it is only
1900 called from the macro... */
1901 if (!gdb_value_fetch_lazy (new_val
))
1910 release_value (new_val
);
1918 c_value_of_child (struct varobj
*parent
, int index
)
1920 value_ptr value
, temp
, indval
;
1921 struct type
*type
, *target
;
1924 type
= get_type (parent
);
1925 target
= get_target_type (type
);
1926 name
= name_of_child (parent
, index
);
1927 temp
= parent
->value
;
1932 switch (TYPE_CODE (type
))
1934 case TYPE_CODE_ARRAY
:
1936 /* This breaks if the array lives in a (vector) register. */
1937 value
= value_slice (temp
, index
, 1);
1938 temp
= value_coerce_array (value
);
1939 gdb_value_ind (temp
, &value
);
1941 indval
= value_from_longest (builtin_type_int
, (LONGEST
) index
);
1942 gdb_value_subscript (temp
, indval
, &value
);
1946 case TYPE_CODE_STRUCT
:
1947 case TYPE_CODE_UNION
:
1948 value
= value_struct_elt (&temp
, NULL
, name
, NULL
, "vstructure");
1952 switch (TYPE_CODE (target
))
1954 case TYPE_CODE_STRUCT
:
1955 case TYPE_CODE_UNION
:
1956 value
= value_struct_elt (&temp
, NULL
, name
, NULL
, "vstructure");
1960 gdb_value_ind (temp
, &value
);
1971 release_value (value
);
1976 static struct type
*
1977 c_type_of_child (struct varobj
*parent
, int index
)
1980 char *name
= name_of_child (parent
, index
);
1982 switch (TYPE_CODE (parent
->type
))
1984 case TYPE_CODE_ARRAY
:
1985 type
= TYPE_TARGET_TYPE (parent
->type
);
1988 case TYPE_CODE_STRUCT
:
1989 case TYPE_CODE_UNION
:
1990 type
= lookup_struct_elt_type (parent
->type
, name
, 0);
1994 switch (TYPE_CODE (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 type
= TYPE_TARGET_TYPE (parent
->type
);
2008 /* This should not happen as only the above types have children */
2009 warning ("Child of parent whose type does not allow children");
2010 /* FIXME: Can we still go on? */
2019 c_variable_editable (struct varobj
*var
)
2021 switch (TYPE_CODE (get_type (var
)))
2023 case TYPE_CODE_STRUCT
:
2024 case TYPE_CODE_UNION
:
2025 case TYPE_CODE_ARRAY
:
2026 case TYPE_CODE_FUNC
:
2027 case TYPE_CODE_MEMBER
:
2028 case TYPE_CODE_METHOD
:
2039 c_value_of_variable (struct varobj
*var
)
2044 if (var
->value
!= NULL
)
2048 /* This can happen if we attempt to get the value of a struct
2049 member when the parent is an invalid pointer. */
2050 return xstrdup ("???");
2053 /* BOGUS: if val_print sees a struct/class, it will print out its
2054 children instead of "{...}" */
2055 type
= get_type (var
);
2056 switch (TYPE_CODE (type
))
2058 case TYPE_CODE_STRUCT
:
2059 case TYPE_CODE_UNION
:
2060 return xstrdup ("{...}");
2063 case TYPE_CODE_ARRAY
:
2066 sprintf (number
, "[%d]", var
->num_children
);
2067 return xstrdup (number
);
2074 struct ui_file
*stb
= mem_fileopen ();
2075 struct cleanup
*old_chain
= make_cleanup_ui_file_delete (stb
);
2078 if (VALUE_LAZY (val
))
2079 gdb_value_fetch_lazy (val
);
2080 val_print (VALUE_TYPE (val
), VALUE_CONTENTS_RAW (val
), 0,
2081 VALUE_ADDRESS (val
),
2082 stb
, format_code
[(int) var
->format
], 1, 0, 0);
2083 thevalue
= ui_file_xstrdup (stb
, &dummy
);
2084 do_cleanups (old_chain
);
2095 cplus_number_of_children (struct varobj
*var
)
2098 int children
, dont_know
;
2103 if (!CPLUS_FAKE_CHILD (var
))
2105 type
= get_type_deref (var
);
2107 if (((TYPE_CODE (type
)) == TYPE_CODE_STRUCT
) ||
2108 ((TYPE_CODE (type
)) == TYPE_CODE_UNION
))
2112 cplus_class_num_children (type
, kids
);
2113 if (kids
[v_public
] != 0)
2115 if (kids
[v_private
] != 0)
2117 if (kids
[v_protected
] != 0)
2120 /* Add any baseclasses */
2121 children
+= TYPE_N_BASECLASSES (type
);
2124 /* FIXME: save children in var */
2131 type
= get_type_deref (var
->parent
);
2133 cplus_class_num_children (type
, kids
);
2134 if (STREQ (var
->name
, "public"))
2135 children
= kids
[v_public
];
2136 else if (STREQ (var
->name
, "private"))
2137 children
= kids
[v_private
];
2139 children
= kids
[v_protected
];
2144 children
= c_number_of_children (var
);
2149 /* Compute # of public, private, and protected variables in this class.
2150 That means we need to descend into all baseclasses and find out
2151 how many are there, too. */
2153 cplus_class_num_children (struct type
*type
, int children
[3])
2157 children
[v_public
] = 0;
2158 children
[v_private
] = 0;
2159 children
[v_protected
] = 0;
2161 for (i
= TYPE_N_BASECLASSES (type
); i
< TYPE_NFIELDS (type
); i
++)
2163 /* If we have a virtual table pointer, omit it. */
2164 if (TYPE_VPTR_BASETYPE (type
) == type
2165 && TYPE_VPTR_FIELDNO (type
) == i
)
2168 if (TYPE_FIELD_PROTECTED (type
, i
))
2169 children
[v_protected
]++;
2170 else if (TYPE_FIELD_PRIVATE (type
, i
))
2171 children
[v_private
]++;
2173 children
[v_public
]++;
2178 cplus_name_of_variable (struct varobj
*parent
)
2180 return c_name_of_variable (parent
);
2184 cplus_name_of_child (struct varobj
*parent
, int index
)
2190 if (CPLUS_FAKE_CHILD (parent
))
2192 /* Looking for children of public, private, or protected. */
2193 type
= get_type_deref (parent
->parent
);
2196 type
= get_type_deref (parent
);
2199 switch (TYPE_CODE (type
))
2201 case TYPE_CODE_STRUCT
:
2202 case TYPE_CODE_UNION
:
2203 cplus_class_num_children (type
, children
);
2205 if (CPLUS_FAKE_CHILD (parent
))
2207 /* FIXME: This assumes that type orders
2208 inherited, public, private, protected */
2209 int i
= index
+ TYPE_N_BASECLASSES (type
);
2210 if (STREQ (parent
->name
, "private") || STREQ (parent
->name
, "protected"))
2211 i
+= children
[v_public
];
2212 if (STREQ (parent
->name
, "protected"))
2213 i
+= children
[v_private
];
2215 name
= TYPE_FIELD_NAME (type
, i
);
2217 else if (index
< TYPE_N_BASECLASSES (type
))
2218 name
= TYPE_FIELD_NAME (type
, index
);
2221 /* Everything beyond the baseclasses can
2222 only be "public", "private", or "protected" */
2223 index
-= TYPE_N_BASECLASSES (type
);
2227 if (children
[v_public
] != 0)
2233 if (children
[v_private
] != 0)
2239 if (children
[v_protected
] != 0)
2256 return c_name_of_child (parent
, index
);
2260 name
= savestring (name
, strlen (name
));
2267 cplus_value_of_root (struct varobj
**var_handle
)
2269 return c_value_of_root (var_handle
);
2273 cplus_value_of_child (struct varobj
*parent
, int index
)
2279 if (CPLUS_FAKE_CHILD (parent
))
2280 type
= get_type_deref (parent
->parent
);
2282 type
= get_type_deref (parent
);
2285 name
= name_of_child (parent
, index
);
2287 if (((TYPE_CODE (type
)) == TYPE_CODE_STRUCT
) ||
2288 ((TYPE_CODE (type
)) == TYPE_CODE_UNION
))
2290 if (CPLUS_FAKE_CHILD (parent
))
2292 value_ptr temp
= parent
->parent
->value
;
2293 value
= value_struct_elt (&temp
, NULL
, name
,
2294 NULL
, "cplus_structure");
2295 release_value (value
);
2297 else if (index
>= TYPE_N_BASECLASSES (type
))
2299 /* public, private, or protected */
2305 if (parent
->value
!= NULL
)
2309 if (TYPE_CODE (VALUE_TYPE (parent
->value
)) == TYPE_CODE_PTR
2310 || TYPE_CODE (VALUE_TYPE (parent
->value
)) == TYPE_CODE_REF
)
2311 gdb_value_ind (parent
->value
, &temp
);
2313 temp
= parent
->value
;
2315 value
= value_cast (TYPE_FIELD_TYPE (type
, index
), temp
);
2316 release_value (value
);
2322 return c_value_of_child (parent
, index
);
2327 static struct type
*
2328 cplus_type_of_child (struct varobj
*parent
, int index
)
2330 struct type
*type
, *t
;
2332 t
= get_type_deref (parent
);
2334 switch (TYPE_CODE (t
))
2336 case TYPE_CODE_STRUCT
:
2337 case TYPE_CODE_UNION
:
2338 if (index
>= TYPE_N_BASECLASSES (t
))
2346 type
= TYPE_FIELD_TYPE (t
, index
);
2355 return c_type_of_child (parent
, index
);
2361 cplus_variable_editable (struct varobj
*var
)
2363 if (CPLUS_FAKE_CHILD (var
))
2366 return c_variable_editable (var
);
2370 cplus_value_of_variable (struct varobj
*var
)
2373 /* If we have one of our special types, don't print out
2375 if (CPLUS_FAKE_CHILD (var
))
2376 return xstrdup ("");
2378 return c_value_of_variable (var
);
2384 java_number_of_children (struct varobj
*var
)
2386 return cplus_number_of_children (var
);
2390 java_name_of_variable (struct varobj
*parent
)
2394 name
= cplus_name_of_variable (parent
);
2395 /* If the name has "-" in it, it is because we
2396 needed to escape periods in the name... */
2399 while (*p
!= '\000')
2410 java_name_of_child (struct varobj
*parent
, int index
)
2414 name
= cplus_name_of_child (parent
, index
);
2415 /* Escape any periods in the name... */
2418 while (*p
!= '\000')
2429 java_value_of_root (struct varobj
**var_handle
)
2431 return cplus_value_of_root (var_handle
);
2435 java_value_of_child (struct varobj
*parent
, int index
)
2437 return cplus_value_of_child (parent
, index
);
2440 static struct type
*
2441 java_type_of_child (struct varobj
*parent
, int index
)
2443 return cplus_type_of_child (parent
, index
);
2447 java_variable_editable (struct varobj
*var
)
2449 return cplus_variable_editable (var
);
2453 java_value_of_variable (struct varobj
*var
)
2455 return cplus_value_of_variable (var
);
2458 extern void _initialize_varobj (void);
2460 _initialize_varobj (void)
2462 int sizeof_table
= sizeof (struct vlist
*) * VAROBJ_TABLE_SIZE
;
2464 varobj_table
= xmalloc (sizeof_table
);
2465 memset (varobj_table
, 0, sizeof_table
);
2468 add_set_cmd ("debugvarobj", class_maintenance
, var_zinteger
,
2469 (char *) &varobjdebug
,
2470 "Set varobj debugging.\n\
2471 When non-zero, varobj debugging is enabled.", &setlist
),