1 /* Implementation of the GDB variable objects API.
3 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
4 Free Software Foundation, Inc.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street, Fifth Floor,
19 Boston, MA 02110-1301, USA. */
22 #include "exceptions.h"
24 #include "expression.h"
30 #include "gdb_assert.h"
31 #include "gdb_string.h"
35 /* Non-zero if we want to see trace of varobj level stuff. */
39 show_varobjdebug (struct ui_file
*file
, int from_tty
,
40 struct cmd_list_element
*c
, const char *value
)
42 fprintf_filtered (file
, _("Varobj debugging is %s.\n"), value
);
45 /* String representations of gdb's format codes */
46 char *varobj_format_string
[] =
47 { "natural", "binary", "decimal", "hexadecimal", "octal" };
49 /* String representations of gdb's known languages */
50 char *varobj_language_string
[] = { "unknown", "C", "C++", "Java" };
54 /* Every root variable has one of these structures saved in its
55 varobj. Members which must be free'd are noted. */
59 /* Alloc'd expression for this parent. */
60 struct expression
*exp
;
62 /* Block for which this expression is valid */
63 struct block
*valid_block
;
65 /* The frame for this expression */
66 struct frame_id frame
;
68 /* If 1, "update" always recomputes the frame & valid block
69 using the currently selected frame. */
70 int use_selected_frame
;
72 /* Language info for this variable and its children */
73 struct language_specific
*lang
;
75 /* The varobj for this root node. */
76 struct varobj
*rootvar
;
78 /* Next root variable */
79 struct varobj_root
*next
;
82 /* Every variable in the system has a structure of this type defined
83 for it. This structure holds all information necessary to manipulate
84 a particular object variable. Members which must be freed are noted. */
88 /* Alloc'd name of the variable for this object.. If this variable is a
89 child, then this name will be the child's source name.
91 /* NOTE: This is the "expression" */
94 /* The alloc'd name for this variable's object. This is here for
95 convenience when constructing this object's children. */
98 /* Index of this variable in its parent or -1 */
101 /* The type of this variable. This may NEVER be NULL. */
104 /* The value of this expression or subexpression. This may be NULL.
105 Invariant: if type_changeable (this) is non-zero, the value is either
106 NULL, or not lazy. */
109 /* Did an error occur evaluating the expression or getting its value? */
112 /* The number of (immediate) children this variable has */
115 /* If this object is a child, this points to its immediate parent. */
116 struct varobj
*parent
;
118 /* A list of this object's children */
119 struct varobj_child
*children
;
121 /* Description of the root variable. Points to root variable for children. */
122 struct varobj_root
*root
;
124 /* The format of the output for this object */
125 enum varobj_display_formats format
;
127 /* Was this variable updated via a varobj_set_value operation */
131 /* Every variable keeps a linked list of its children, described
132 by the following structure. */
133 /* FIXME: Deprecated. All should use vlist instead */
138 /* Pointer to the child's data */
139 struct varobj
*child
;
141 /* Pointer to the next child */
142 struct varobj_child
*next
;
145 /* A stack of varobjs */
146 /* FIXME: Deprecated. All should use vlist instead */
157 struct cpstack
*next
;
160 /* A list of varobjs */
168 /* Private function prototypes */
170 /* Helper functions for the above subcommands. */
172 static int delete_variable (struct cpstack
**, struct varobj
*, int);
174 static void delete_variable_1 (struct cpstack
**, int *,
175 struct varobj
*, int, int);
177 static int install_variable (struct varobj
*);
179 static void uninstall_variable (struct varobj
*);
181 static struct varobj
*child_exists (struct varobj
*, char *);
183 static struct varobj
*create_child (struct varobj
*, int, char *);
185 static void save_child_in_parent (struct varobj
*, struct varobj
*);
187 static void remove_child_from_parent (struct varobj
*, struct varobj
*);
189 /* Utility routines */
191 static struct varobj
*new_variable (void);
193 static struct varobj
*new_root_variable (void);
195 static void free_variable (struct varobj
*var
);
197 static struct cleanup
*make_cleanup_free_variable (struct varobj
*var
);
199 static struct type
*get_type (struct varobj
*var
);
201 static struct type
*get_type_deref (struct varobj
*var
);
203 static struct type
*get_target_type (struct type
*);
205 static enum varobj_display_formats
variable_default_display (struct varobj
*);
207 static void vpush (struct vstack
**pstack
, struct varobj
*var
);
209 static struct varobj
*vpop (struct vstack
**pstack
);
211 static void cppush (struct cpstack
**pstack
, char *name
);
213 static char *cppop (struct cpstack
**pstack
);
215 static int install_new_value (struct varobj
*var
, struct value
*value
,
218 /* Language-specific routines. */
220 static enum varobj_languages
variable_language (struct varobj
*var
);
222 static int number_of_children (struct varobj
*);
224 static char *name_of_variable (struct varobj
*);
226 static char *name_of_child (struct varobj
*, int);
228 static struct value
*value_of_root (struct varobj
**var_handle
, int *);
230 static struct value
*value_of_child (struct varobj
*parent
, int index
);
232 static int variable_editable (struct varobj
*var
);
234 static char *my_value_of_variable (struct varobj
*var
);
236 static int type_changeable (struct varobj
*var
);
238 /* C implementation */
240 static int c_number_of_children (struct varobj
*var
);
242 static char *c_name_of_variable (struct varobj
*parent
);
244 static char *c_name_of_child (struct varobj
*parent
, int index
);
246 static struct value
*c_value_of_root (struct varobj
**var_handle
);
248 static struct value
*c_value_of_child (struct varobj
*parent
, int index
);
250 static struct type
*c_type_of_child (struct varobj
*parent
, int index
);
252 static int c_variable_editable (struct varobj
*var
);
254 static char *c_value_of_variable (struct varobj
*var
);
256 /* C++ implementation */
258 static int cplus_number_of_children (struct varobj
*var
);
260 static void cplus_class_num_children (struct type
*type
, int children
[3]);
262 static char *cplus_name_of_variable (struct varobj
*parent
);
264 static char *cplus_name_of_child (struct varobj
*parent
, int index
);
266 static struct value
*cplus_value_of_root (struct varobj
**var_handle
);
268 static struct value
*cplus_value_of_child (struct varobj
*parent
, int index
);
270 static struct type
*cplus_type_of_child (struct varobj
*parent
, int index
);
272 static int cplus_variable_editable (struct varobj
*var
);
274 static char *cplus_value_of_variable (struct varobj
*var
);
276 /* Java implementation */
278 static int java_number_of_children (struct varobj
*var
);
280 static char *java_name_of_variable (struct varobj
*parent
);
282 static char *java_name_of_child (struct varobj
*parent
, int index
);
284 static struct value
*java_value_of_root (struct varobj
**var_handle
);
286 static struct value
*java_value_of_child (struct varobj
*parent
, int index
);
288 static struct type
*java_type_of_child (struct varobj
*parent
, int index
);
290 static int java_variable_editable (struct varobj
*var
);
292 static char *java_value_of_variable (struct varobj
*var
);
294 /* The language specific vector */
296 struct language_specific
299 /* The language of this variable */
300 enum varobj_languages language
;
302 /* The number of children of PARENT. */
303 int (*number_of_children
) (struct varobj
* parent
);
305 /* The name (expression) of a root varobj. */
306 char *(*name_of_variable
) (struct varobj
* parent
);
308 /* The name of the INDEX'th child of PARENT. */
309 char *(*name_of_child
) (struct varobj
* parent
, int index
);
311 /* The ``struct value *'' of the root variable ROOT. */
312 struct value
*(*value_of_root
) (struct varobj
** root_handle
);
314 /* The ``struct value *'' of the INDEX'th child of PARENT. */
315 struct value
*(*value_of_child
) (struct varobj
* parent
, int index
);
317 /* The type of the INDEX'th child of PARENT. */
318 struct type
*(*type_of_child
) (struct varobj
* parent
, int index
);
320 /* Is VAR editable? */
321 int (*variable_editable
) (struct varobj
* var
);
323 /* The current value of VAR. */
324 char *(*value_of_variable
) (struct varobj
* var
);
327 /* Array of known source language routines. */
328 static struct language_specific
329 languages
[vlang_end
][sizeof (struct language_specific
)] = {
330 /* Unknown (try treating as C */
333 c_number_of_children
,
345 c_number_of_children
,
357 cplus_number_of_children
,
358 cplus_name_of_variable
,
361 cplus_value_of_child
,
363 cplus_variable_editable
,
364 cplus_value_of_variable
}
369 java_number_of_children
,
370 java_name_of_variable
,
375 java_variable_editable
,
376 java_value_of_variable
}
379 /* A little convenience enum for dealing with C++/Java */
382 v_public
= 0, v_private
, v_protected
387 /* Mappings of varobj_display_formats enums to gdb's format codes */
388 static int format_code
[] = { 0, 't', 'd', 'x', 'o' };
390 /* Header of the list of root variable objects */
391 static struct varobj_root
*rootlist
;
392 static int rootcount
= 0; /* number of root varobjs in the list */
394 /* Prime number indicating the number of buckets in the hash table */
395 /* A prime large enough to avoid too many colisions */
396 #define VAROBJ_TABLE_SIZE 227
398 /* Pointer to the varobj hash table (built at run time) */
399 static struct vlist
**varobj_table
;
401 /* Is the variable X one of our "fake" children? */
402 #define CPLUS_FAKE_CHILD(x) \
403 ((x) != NULL && (x)->type == NULL && (x)->value == NULL)
406 /* API Implementation */
408 /* Creates a varobj (not its children) */
410 /* Return the full FRAME which corresponds to the given CORE_ADDR
411 or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
413 static struct frame_info
*
414 find_frame_addr_in_frame_chain (CORE_ADDR frame_addr
)
416 struct frame_info
*frame
= NULL
;
418 if (frame_addr
== (CORE_ADDR
) 0)
423 frame
= get_prev_frame (frame
);
426 if (get_frame_base_address (frame
) == frame_addr
)
432 varobj_create (char *objname
,
433 char *expression
, CORE_ADDR frame
, enum varobj_type type
)
436 struct frame_info
*fi
;
437 struct frame_info
*old_fi
= NULL
;
439 struct cleanup
*old_chain
;
441 /* Fill out a varobj structure for the (root) variable being constructed. */
442 var
= new_root_variable ();
443 old_chain
= make_cleanup_free_variable (var
);
445 if (expression
!= NULL
)
448 enum varobj_languages lang
;
451 /* Parse and evaluate the expression, filling in as much
452 of the variable's data as possible */
454 /* Allow creator to specify context of variable */
455 if ((type
== USE_CURRENT_FRAME
) || (type
== USE_SELECTED_FRAME
))
456 fi
= deprecated_selected_frame
;
458 /* FIXME: cagney/2002-11-23: This code should be doing a
459 lookup using the frame ID and not just the frame's
460 ``address''. This, of course, means an interface change.
461 However, with out that interface change ISAs, such as the
462 ia64 with its two stacks, won't work. Similar goes for the
463 case where there is a frameless function. */
464 fi
= find_frame_addr_in_frame_chain (frame
);
466 /* frame = -2 means always use selected frame */
467 if (type
== USE_SELECTED_FRAME
)
468 var
->root
->use_selected_frame
= 1;
472 block
= get_frame_block (fi
, 0);
475 innermost_block
= NULL
;
476 /* Wrap the call to parse expression, so we can
477 return a sensible error. */
478 if (!gdb_parse_exp_1 (&p
, block
, 0, &var
->root
->exp
))
483 /* Don't allow variables to be created for types. */
484 if (var
->root
->exp
->elts
[0].opcode
== OP_TYPE
)
486 do_cleanups (old_chain
);
487 fprintf_unfiltered (gdb_stderr
, "Attempt to use a type name"
488 " as an expression.\n");
492 var
->format
= variable_default_display (var
);
493 var
->root
->valid_block
= innermost_block
;
494 var
->name
= savestring (expression
, strlen (expression
));
496 /* When the frame is different from the current frame,
497 we must select the appropriate frame before parsing
498 the expression, otherwise the value will not be current.
499 Since select_frame is so benign, just call it for all cases. */
502 var
->root
->frame
= get_frame_id (fi
);
503 old_fi
= deprecated_selected_frame
;
507 /* We definitively need to catch errors here.
508 If evaluate_expression succeeds we got the value we wanted.
509 But if it fails, we still go on with a call to evaluate_type() */
510 if (!gdb_evaluate_expression (var
->root
->exp
, &value
))
511 /* Error getting the value. Try to at least get the
513 value
= evaluate_type (var
->root
->exp
);
515 release_value (value
);
517 var
->type
= value_type (value
);
519 install_new_value (var
, value
, 1 /* Initial assignment */);
521 /* Set language info */
522 lang
= variable_language (var
);
523 var
->root
->lang
= languages
[lang
];
525 /* Set ourselves as our root */
526 var
->root
->rootvar
= var
;
528 /* Reset the selected frame */
530 select_frame (old_fi
);
533 /* If the variable object name is null, that means this
534 is a temporary variable, so don't install it. */
536 if ((var
!= NULL
) && (objname
!= NULL
))
538 var
->obj_name
= savestring (objname
, strlen (objname
));
540 /* If a varobj name is duplicated, the install will fail so
542 if (!install_variable (var
))
544 do_cleanups (old_chain
);
549 discard_cleanups (old_chain
);
553 /* Generates an unique name that can be used for a varobj */
556 varobj_gen_name (void)
561 /* generate a name for this object */
563 obj_name
= xstrprintf ("var%d", id
);
568 /* Given an "objname", returns the pointer to the corresponding varobj
569 or NULL if not found */
572 varobj_get_handle (char *objname
)
576 unsigned int index
= 0;
579 for (chp
= objname
; *chp
; chp
++)
581 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
584 cv
= *(varobj_table
+ index
);
585 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, objname
) != 0))
589 error (_("Variable object not found"));
594 /* Given the handle, return the name of the object */
597 varobj_get_objname (struct varobj
*var
)
599 return var
->obj_name
;
602 /* Given the handle, return the expression represented by the object */
605 varobj_get_expression (struct varobj
*var
)
607 return name_of_variable (var
);
610 /* Deletes a varobj and all its children if only_children == 0,
611 otherwise deletes only the children; returns a malloc'ed list of all the
612 (malloc'ed) names of the variables that have been deleted (NULL terminated) */
615 varobj_delete (struct varobj
*var
, char ***dellist
, int only_children
)
619 struct cpstack
*result
= NULL
;
622 /* Initialize a stack for temporary results */
623 cppush (&result
, NULL
);
626 /* Delete only the variable children */
627 delcount
= delete_variable (&result
, var
, 1 /* only the children */ );
629 /* Delete the variable and all its children */
630 delcount
= delete_variable (&result
, var
, 0 /* parent+children */ );
632 /* We may have been asked to return a list of what has been deleted */
635 *dellist
= xmalloc ((delcount
+ 1) * sizeof (char *));
639 *cp
= cppop (&result
);
640 while ((*cp
!= NULL
) && (mycount
> 0))
644 *cp
= cppop (&result
);
647 if (mycount
|| (*cp
!= NULL
))
648 warning (_("varobj_delete: assertion failed - mycount(=%d) <> 0"),
655 /* Set/Get variable object display format */
657 enum varobj_display_formats
658 varobj_set_display_format (struct varobj
*var
,
659 enum varobj_display_formats format
)
666 case FORMAT_HEXADECIMAL
:
668 var
->format
= format
;
672 var
->format
= variable_default_display (var
);
678 enum varobj_display_formats
679 varobj_get_display_format (struct varobj
*var
)
685 varobj_get_num_children (struct varobj
*var
)
687 if (var
->num_children
== -1)
688 var
->num_children
= number_of_children (var
);
690 return var
->num_children
;
693 /* Creates a list of the immediate children of a variable object;
694 the return code is the number of such children or -1 on error */
697 varobj_list_children (struct varobj
*var
, struct varobj
***childlist
)
699 struct varobj
*child
;
703 /* sanity check: have we been passed a pointer? */
704 if (childlist
== NULL
)
709 if (var
->num_children
== -1)
710 var
->num_children
= number_of_children (var
);
712 /* List of children */
713 *childlist
= xmalloc ((var
->num_children
+ 1) * sizeof (struct varobj
*));
715 for (i
= 0; i
< var
->num_children
; i
++)
717 /* Mark as the end in case we bail out */
718 *((*childlist
) + i
) = NULL
;
720 /* check if child exists, if not create */
721 name
= name_of_child (var
, i
);
722 child
= child_exists (var
, name
);
724 child
= create_child (var
, i
, name
);
726 *((*childlist
) + i
) = child
;
729 /* End of list is marked by a NULL pointer */
730 *((*childlist
) + i
) = NULL
;
732 return var
->num_children
;
735 /* Obtain the type of an object Variable as a string similar to the one gdb
736 prints on the console */
739 varobj_get_type (struct varobj
*var
)
742 struct cleanup
*old_chain
;
747 /* For the "fake" variables, do not return a type. (It's type is
749 if (CPLUS_FAKE_CHILD (var
))
752 stb
= mem_fileopen ();
753 old_chain
= make_cleanup_ui_file_delete (stb
);
755 /* To print the type, we simply create a zero ``struct value *'' and
756 cast it to our type. We then typeprint this variable. */
757 val
= value_zero (var
->type
, not_lval
);
758 type_print (value_type (val
), "", stb
, -1);
760 thetype
= ui_file_xstrdup (stb
, &length
);
761 do_cleanups (old_chain
);
765 /* Obtain the type of an object variable. */
768 varobj_get_gdb_type (struct varobj
*var
)
773 enum varobj_languages
774 varobj_get_language (struct varobj
*var
)
776 return variable_language (var
);
780 varobj_get_attributes (struct varobj
*var
)
784 if (variable_editable (var
))
785 /* FIXME: define masks for attributes */
786 attributes
|= 0x00000001; /* Editable */
792 varobj_get_value (struct varobj
*var
)
794 return my_value_of_variable (var
);
797 /* Set the value of an object variable (if it is editable) to the
798 value of the given expression */
799 /* Note: Invokes functions that can call error() */
802 varobj_set_value (struct varobj
*var
, char *expression
)
808 /* The argument "expression" contains the variable's new value.
809 We need to first construct a legal expression for this -- ugh! */
810 /* Does this cover all the bases? */
811 struct expression
*exp
;
813 int saved_input_radix
= input_radix
;
815 if (var
->value
!= NULL
&& variable_editable (var
) && !var
->error
)
817 char *s
= expression
;
820 input_radix
= 10; /* ALWAYS reset to decimal temporarily */
821 exp
= parse_exp_1 (&s
, 0, 0);
822 if (!gdb_evaluate_expression (exp
, &value
))
824 /* We cannot proceed without a valid expression. */
829 /* All types that are editable must also be changeable. */
830 gdb_assert (type_changeable (var
));
832 /* The value of a changeable variable object must not be lazy. */
833 gdb_assert (!value_lazy (var
->value
));
835 /* Need to coerce the input. We want to check if the
836 value of the variable object will be different
837 after assignment, and the first thing value_assign
838 does is coerce the input.
839 For example, if we are assigning an array to a pointer variable we
840 should compare the pointer with the the array's address, not with the
842 value
= coerce_array (value
);
844 if (!value_contents_equal (var
->value
, value
))
847 /* The new value may be lazy. gdb_value_assign, or
848 rather value_contents, will take care of this.
849 If fetching of the new value will fail, gdb_value_assign
850 with catch the exception. */
851 if (!gdb_value_assign (var
->value
, value
, &val
))
853 value_free (var
->value
);
856 input_radix
= saved_input_radix
;
863 /* Returns a malloc'ed list with all root variable objects */
865 varobj_list (struct varobj
***varlist
)
868 struct varobj_root
*croot
;
869 int mycount
= rootcount
;
871 /* Alloc (rootcount + 1) entries for the result */
872 *varlist
= xmalloc ((rootcount
+ 1) * sizeof (struct varobj
*));
876 while ((croot
!= NULL
) && (mycount
> 0))
878 *cv
= croot
->rootvar
;
883 /* Mark the end of the list */
886 if (mycount
|| (croot
!= NULL
))
888 ("varobj_list: assertion failed - wrong tally of root vars (%d:%d)",
894 /* Assign a new value to a variable object. If INITIAL is non-zero,
895 this is the first assignement after the variable object was just
896 created, or changed type. In that case, just assign the value
898 Otherwise, assign the value and if type_changeable returns non-zero,
899 find if the new value is different from the current value.
900 Return 1 if so, and 0 if the values are equal. */
902 install_new_value (struct varobj
*var
, struct value
*value
, int initial
)
909 /* We need to know the varobj's type to decide if the value should
910 be fetched or not. C++ fake children (public/protected/private) don't have
912 gdb_assert (var
->type
|| CPLUS_FAKE_CHILD (var
));
913 changeable
= type_changeable (var
);
914 need_to_fetch
= changeable
;
916 if (var
->type
&& TYPE_CODE (var
->type
) == TYPE_CODE_UNION
)
917 /* For unions, we need to fetch the value implicitly because
918 of implementation of union member fetch. When gdb
919 creates a value for a field and the value of the enclosing
920 structure is not lazy, it immediately copies the necessary
921 bytes from the enclosing values. If the enclosing value is
922 lazy, the call to value_fetch_lazy on the field will read
923 the data from memory. For unions, that means we'll read the
924 same memory more than once, which is not desirable. So
928 /* The new value might be lazy. If the type is changeable,
929 that is we'll be comparing values of this type, fetch the
930 value now. Otherwise, on the next update the old value
931 will be lazy, which means we've lost that old value. */
932 if (need_to_fetch
&& value
&& value_lazy (value
))
934 if (!gdb_value_fetch_lazy (value
))
937 /* Set the value to NULL, so that for the next -var-update,
938 we don't try to compare the new value with this value,
939 that we couldn't even read. */
946 /* If the type is changeable, compare the old and the new values.
947 If this is the initial assignment, we don't have any old value
949 if (!initial
&& changeable
)
951 /* If the value of the varobj was changed by -var-set-value, then the
952 value in the varobj and in the target is the same. However, that value
953 is different from the value that the varobj had after the previous
954 -var-update. So need to the varobj as changed. */
959 /* Try to compare the values. That requires that both
960 values are non-lazy. */
962 /* Quick comparison of NULL values. */
963 if (var
->value
== NULL
&& value
== NULL
)
966 else if (var
->value
== NULL
|| value
== NULL
)
970 gdb_assert (!value_lazy (var
->value
));
971 gdb_assert (!value_lazy (value
));
973 if (!value_contents_equal (var
->value
, value
))
979 /* We must always keep the new value, since children depend on it. */
980 if (var
->value
!= NULL
)
981 value_free (var
->value
);
989 /* Update the values for a variable and its children. This is a
990 two-pronged attack. First, re-parse the value for the root's
991 expression to see if it's changed. Then go all the way
992 through its children, reconstructing them and noting if they've
995 -1 if there was an error updating the varobj
996 -2 if the type changed
997 Otherwise it is the number of children + parent changed
999 Only root variables can be updated...
1001 NOTE: This function may delete the caller's varobj. If it
1002 returns -2, then it has done this and VARP will be modified
1003 to point to the new varobj. */
1006 varobj_update (struct varobj
**varp
, struct varobj
***changelist
)
1015 struct varobj
**templist
= NULL
;
1017 struct vstack
*stack
= NULL
;
1018 struct vstack
*result
= NULL
;
1019 struct frame_id old_fid
;
1020 struct frame_info
*fi
;
1022 /* sanity check: have we been passed a pointer? */
1023 if (changelist
== NULL
)
1026 /* Only root variables can be updated... */
1027 if ((*varp
)->root
->rootvar
!= *varp
)
1028 /* Not a root var */
1031 /* Save the selected stack frame, since we will need to change it
1032 in order to evaluate expressions. */
1033 old_fid
= get_frame_id (deprecated_selected_frame
);
1035 /* Update the root variable. value_of_root can return NULL
1036 if the variable is no longer around, i.e. we stepped out of
1037 the frame in which a local existed. We are letting the
1038 value_of_root variable dispose of the varobj if the type
1041 new = value_of_root (varp
, &type_changed
);
1048 /* Initialize a stack for temporary results */
1049 vpush (&result
, NULL
);
1051 /* If this is a "use_selected_frame" varobj, and its type has changed,
1052 them note that it's changed. */
1055 vpush (&result
, *varp
);
1059 if (install_new_value ((*varp
), new, type_changed
))
1061 /* If type_changed is 1, install_new_value will never return
1062 non-zero, so we'll never report the same variable twice. */
1063 gdb_assert (!type_changed
);
1064 vpush (&result
, (*varp
));
1068 /* Initialize a stack */
1069 vpush (&stack
, NULL
);
1071 /* Push the root's children */
1072 if ((*varp
)->children
!= NULL
)
1074 struct varobj_child
*c
;
1075 for (c
= (*varp
)->children
; c
!= NULL
; c
= c
->next
)
1076 vpush (&stack
, c
->child
);
1079 /* Walk through the children, reconstructing them all. */
1083 /* Push any children */
1084 if (v
->children
!= NULL
)
1086 struct varobj_child
*c
;
1087 for (c
= v
->children
; c
!= NULL
; c
= c
->next
)
1088 vpush (&stack
, c
->child
);
1091 /* Update this variable */
1092 new = value_of_child (v
->parent
, v
->index
);
1093 if (install_new_value (v
, new, 0 /* type not changed */))
1095 /* Note that it's changed */
1101 /* Get next child */
1105 /* Alloc (changed + 1) list entries */
1106 /* FIXME: add a cleanup for the allocated list(s)
1107 because one day the select_frame called below can longjump */
1108 *changelist
= xmalloc ((changed
+ 1) * sizeof (struct varobj
*));
1111 templist
= xmalloc ((changed
+ 1) * sizeof (struct varobj
*));
1117 /* Copy from result stack to list */
1119 *cv
= vpop (&result
);
1120 while ((*cv
!= NULL
) && (vleft
> 0))
1124 *cv
= vpop (&result
);
1127 warning (_("varobj_update: assertion failed - vleft <> 0"));
1131 /* Now we revert the order. */
1132 for (i
= 0; i
< changed
; i
++)
1133 *(*changelist
+ i
) = *(templist
+ changed
- 1 - i
);
1134 *(*changelist
+ changed
) = NULL
;
1137 /* Restore selected frame */
1138 fi
= frame_find_by_id (old_fid
);
1149 /* Helper functions */
1152 * Variable object construction/destruction
1156 delete_variable (struct cpstack
**resultp
, struct varobj
*var
,
1157 int only_children_p
)
1161 delete_variable_1 (resultp
, &delcount
, var
,
1162 only_children_p
, 1 /* remove_from_parent_p */ );
1167 /* Delete the variable object VAR and its children */
1168 /* IMPORTANT NOTE: If we delete a variable which is a child
1169 and the parent is not removed we dump core. It must be always
1170 initially called with remove_from_parent_p set */
1172 delete_variable_1 (struct cpstack
**resultp
, int *delcountp
,
1173 struct varobj
*var
, int only_children_p
,
1174 int remove_from_parent_p
)
1176 struct varobj_child
*vc
;
1177 struct varobj_child
*next
;
1179 /* Delete any children of this variable, too. */
1180 for (vc
= var
->children
; vc
!= NULL
; vc
= next
)
1182 if (!remove_from_parent_p
)
1183 vc
->child
->parent
= NULL
;
1184 delete_variable_1 (resultp
, delcountp
, vc
->child
, 0, only_children_p
);
1189 /* if we were called to delete only the children we are done here */
1190 if (only_children_p
)
1193 /* Otherwise, add it to the list of deleted ones and proceed to do so */
1194 /* If the name is null, this is a temporary variable, that has not
1195 yet been installed, don't report it, it belongs to the caller... */
1196 if (var
->obj_name
!= NULL
)
1198 cppush (resultp
, xstrdup (var
->obj_name
));
1199 *delcountp
= *delcountp
+ 1;
1202 /* If this variable has a parent, remove it from its parent's list */
1203 /* OPTIMIZATION: if the parent of this variable is also being deleted,
1204 (as indicated by remove_from_parent_p) we don't bother doing an
1205 expensive list search to find the element to remove when we are
1206 discarding the list afterwards */
1207 if ((remove_from_parent_p
) && (var
->parent
!= NULL
))
1209 remove_child_from_parent (var
->parent
, var
);
1212 if (var
->obj_name
!= NULL
)
1213 uninstall_variable (var
);
1215 /* Free memory associated with this variable */
1216 free_variable (var
);
1219 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
1221 install_variable (struct varobj
*var
)
1224 struct vlist
*newvl
;
1226 unsigned int index
= 0;
1229 for (chp
= var
->obj_name
; *chp
; chp
++)
1231 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
1234 cv
= *(varobj_table
+ index
);
1235 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
1239 error (_("Duplicate variable object name"));
1241 /* Add varobj to hash table */
1242 newvl
= xmalloc (sizeof (struct vlist
));
1243 newvl
->next
= *(varobj_table
+ index
);
1245 *(varobj_table
+ index
) = newvl
;
1247 /* If root, add varobj to root list */
1248 if (var
->root
->rootvar
== var
)
1250 /* Add to list of root variables */
1251 if (rootlist
== NULL
)
1252 var
->root
->next
= NULL
;
1254 var
->root
->next
= rootlist
;
1255 rootlist
= var
->root
;
1262 /* Unistall the object VAR. */
1264 uninstall_variable (struct varobj
*var
)
1268 struct varobj_root
*cr
;
1269 struct varobj_root
*prer
;
1271 unsigned int index
= 0;
1274 /* Remove varobj from hash table */
1275 for (chp
= var
->obj_name
; *chp
; chp
++)
1277 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
1280 cv
= *(varobj_table
+ index
);
1282 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
1289 fprintf_unfiltered (gdb_stdlog
, "Deleting %s\n", var
->obj_name
);
1294 ("Assertion failed: Could not find variable object \"%s\" to delete",
1300 *(varobj_table
+ index
) = cv
->next
;
1302 prev
->next
= cv
->next
;
1306 /* If root, remove varobj from root list */
1307 if (var
->root
->rootvar
== var
)
1309 /* Remove from list of root variables */
1310 if (rootlist
== var
->root
)
1311 rootlist
= var
->root
->next
;
1316 while ((cr
!= NULL
) && (cr
->rootvar
!= var
))
1324 ("Assertion failed: Could not find varobj \"%s\" in root list",
1331 prer
->next
= cr
->next
;
1338 /* Does a child with the name NAME exist in VAR? If so, return its data.
1339 If not, return NULL. */
1340 static struct varobj
*
1341 child_exists (struct varobj
*var
, char *name
)
1343 struct varobj_child
*vc
;
1345 for (vc
= var
->children
; vc
!= NULL
; vc
= vc
->next
)
1347 if (strcmp (vc
->child
->name
, name
) == 0)
1354 /* Create and install a child of the parent of the given name */
1355 static struct varobj
*
1356 create_child (struct varobj
*parent
, int index
, char *name
)
1358 struct varobj
*child
;
1360 struct value
*value
;
1362 child
= new_variable ();
1364 /* name is allocated by name_of_child */
1366 child
->index
= index
;
1367 value
= value_of_child (parent
, index
);
1368 child
->parent
= parent
;
1369 child
->root
= parent
->root
;
1370 childs_name
= xstrprintf ("%s.%s", parent
->obj_name
, name
);
1371 child
->obj_name
= childs_name
;
1372 install_variable (child
);
1374 /* Save a pointer to this child in the parent */
1375 save_child_in_parent (parent
, child
);
1377 /* Compute the type of the child. Must do this before
1378 calling install_new_value. */
1380 /* If the child had no evaluation errors, var->value
1381 will be non-NULL and contain a valid type. */
1382 child
->type
= value_type (value
);
1384 /* Otherwise, we must compute the type. */
1385 child
->type
= (*child
->root
->lang
->type_of_child
) (child
->parent
,
1387 install_new_value (child
, value
, 1);
1389 if ((!CPLUS_FAKE_CHILD (child
) && child
->value
== NULL
) || parent
->error
)
1395 /* FIXME: This should be a generic add to list */
1396 /* Save CHILD in the PARENT's data. */
1398 save_child_in_parent (struct varobj
*parent
, struct varobj
*child
)
1400 struct varobj_child
*vc
;
1402 /* Insert the child at the top */
1403 vc
= parent
->children
;
1405 (struct varobj_child
*) xmalloc (sizeof (struct varobj_child
));
1407 parent
->children
->next
= vc
;
1408 parent
->children
->child
= child
;
1411 /* FIXME: This should be a generic remove from list */
1412 /* Remove the CHILD from the PARENT's list of children. */
1414 remove_child_from_parent (struct varobj
*parent
, struct varobj
*child
)
1416 struct varobj_child
*vc
, *prev
;
1418 /* Find the child in the parent's list */
1420 for (vc
= parent
->children
; vc
!= NULL
;)
1422 if (vc
->child
== child
)
1429 parent
->children
= vc
->next
;
1431 prev
->next
= vc
->next
;
1437 * Miscellaneous utility functions.
1440 /* Allocate memory and initialize a new variable */
1441 static struct varobj
*
1446 var
= (struct varobj
*) xmalloc (sizeof (struct varobj
));
1448 var
->obj_name
= NULL
;
1453 var
->num_children
= -1;
1455 var
->children
= NULL
;
1463 /* Allocate memory and initialize a new root variable */
1464 static struct varobj
*
1465 new_root_variable (void)
1467 struct varobj
*var
= new_variable ();
1468 var
->root
= (struct varobj_root
*) xmalloc (sizeof (struct varobj_root
));;
1469 var
->root
->lang
= NULL
;
1470 var
->root
->exp
= NULL
;
1471 var
->root
->valid_block
= NULL
;
1472 var
->root
->frame
= null_frame_id
;
1473 var
->root
->use_selected_frame
= 0;
1474 var
->root
->rootvar
= NULL
;
1479 /* Free any allocated memory associated with VAR. */
1481 free_variable (struct varobj
*var
)
1483 /* Free the expression if this is a root variable. */
1484 if (var
->root
->rootvar
== var
)
1486 free_current_contents (&var
->root
->exp
);
1491 xfree (var
->obj_name
);
1496 do_free_variable_cleanup (void *var
)
1498 free_variable (var
);
1501 static struct cleanup
*
1502 make_cleanup_free_variable (struct varobj
*var
)
1504 return make_cleanup (do_free_variable_cleanup
, var
);
1507 /* This returns the type of the variable. It also skips past typedefs
1508 to return the real type of the variable.
1510 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
1511 except within get_target_type and get_type. */
1512 static struct type
*
1513 get_type (struct varobj
*var
)
1519 type
= check_typedef (type
);
1524 /* This returns the type of the variable, dereferencing pointers, too. */
1525 static struct type
*
1526 get_type_deref (struct varobj
*var
)
1530 type
= get_type (var
);
1532 if (type
!= NULL
&& (TYPE_CODE (type
) == TYPE_CODE_PTR
1533 || TYPE_CODE (type
) == TYPE_CODE_REF
))
1534 type
= get_target_type (type
);
1539 /* This returns the target type (or NULL) of TYPE, also skipping
1540 past typedefs, just like get_type ().
1542 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
1543 except within get_target_type and get_type. */
1544 static struct type
*
1545 get_target_type (struct type
*type
)
1549 type
= TYPE_TARGET_TYPE (type
);
1551 type
= check_typedef (type
);
1557 /* What is the default display for this variable? We assume that
1558 everything is "natural". Any exceptions? */
1559 static enum varobj_display_formats
1560 variable_default_display (struct varobj
*var
)
1562 return FORMAT_NATURAL
;
1565 /* FIXME: The following should be generic for any pointer */
1567 vpush (struct vstack
**pstack
, struct varobj
*var
)
1571 s
= (struct vstack
*) xmalloc (sizeof (struct vstack
));
1577 /* FIXME: The following should be generic for any pointer */
1578 static struct varobj
*
1579 vpop (struct vstack
**pstack
)
1584 if ((*pstack
)->var
== NULL
&& (*pstack
)->next
== NULL
)
1589 *pstack
= (*pstack
)->next
;
1595 /* FIXME: The following should be generic for any pointer */
1597 cppush (struct cpstack
**pstack
, char *name
)
1601 s
= (struct cpstack
*) xmalloc (sizeof (struct cpstack
));
1607 /* FIXME: The following should be generic for any pointer */
1609 cppop (struct cpstack
**pstack
)
1614 if ((*pstack
)->name
== NULL
&& (*pstack
)->next
== NULL
)
1619 *pstack
= (*pstack
)->next
;
1626 * Language-dependencies
1629 /* Common entry points */
1631 /* Get the language of variable VAR. */
1632 static enum varobj_languages
1633 variable_language (struct varobj
*var
)
1635 enum varobj_languages lang
;
1637 switch (var
->root
->exp
->language_defn
->la_language
)
1643 case language_cplus
:
1654 /* Return the number of children for a given variable.
1655 The result of this function is defined by the language
1656 implementation. The number of children returned by this function
1657 is the number of children that the user will see in the variable
1660 number_of_children (struct varobj
*var
)
1662 return (*var
->root
->lang
->number_of_children
) (var
);;
1665 /* What is the expression for the root varobj VAR? Returns a malloc'd string. */
1667 name_of_variable (struct varobj
*var
)
1669 return (*var
->root
->lang
->name_of_variable
) (var
);
1672 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd string. */
1674 name_of_child (struct varobj
*var
, int index
)
1676 return (*var
->root
->lang
->name_of_child
) (var
, index
);
1679 /* What is the ``struct value *'' of the root variable VAR?
1680 TYPE_CHANGED controls what to do if the type of a
1681 use_selected_frame = 1 variable changes. On input,
1682 TYPE_CHANGED = 1 means discard the old varobj, and replace
1683 it with this one. TYPE_CHANGED = 0 means leave it around.
1684 NB: In both cases, var_handle will point to the new varobj,
1685 so if you use TYPE_CHANGED = 0, you will have to stash the
1686 old varobj pointer away somewhere before calling this.
1687 On return, TYPE_CHANGED will be 1 if the type has changed, and
1689 static struct value
*
1690 value_of_root (struct varobj
**var_handle
, int *type_changed
)
1694 if (var_handle
== NULL
)
1699 /* This should really be an exception, since this should
1700 only get called with a root variable. */
1702 if (var
->root
->rootvar
!= var
)
1705 if (var
->root
->use_selected_frame
)
1707 struct varobj
*tmp_var
;
1708 char *old_type
, *new_type
;
1709 old_type
= varobj_get_type (var
);
1710 tmp_var
= varobj_create (NULL
, var
->name
, (CORE_ADDR
) 0,
1711 USE_SELECTED_FRAME
);
1712 if (tmp_var
== NULL
)
1716 new_type
= varobj_get_type (tmp_var
);
1717 if (strcmp (old_type
, new_type
) == 0)
1719 varobj_delete (tmp_var
, NULL
, 0);
1727 savestring (var
->obj_name
, strlen (var
->obj_name
));
1728 varobj_delete (var
, NULL
, 0);
1732 tmp_var
->obj_name
= varobj_gen_name ();
1734 install_variable (tmp_var
);
1735 *var_handle
= tmp_var
;
1745 return (*var
->root
->lang
->value_of_root
) (var_handle
);
1748 /* What is the ``struct value *'' for the INDEX'th child of PARENT? */
1749 static struct value
*
1750 value_of_child (struct varobj
*parent
, int index
)
1752 struct value
*value
;
1754 value
= (*parent
->root
->lang
->value_of_child
) (parent
, index
);
1759 /* Is this variable editable? Use the variable's type to make
1760 this determination. */
1762 variable_editable (struct varobj
*var
)
1764 return (*var
->root
->lang
->variable_editable
) (var
);
1767 /* GDB already has a command called "value_of_variable". Sigh. */
1769 my_value_of_variable (struct varobj
*var
)
1771 return (*var
->root
->lang
->value_of_variable
) (var
);
1774 /* Return non-zero if changes in value of VAR
1775 must be detected and reported by -var-update.
1776 Return zero is -var-update should never report
1777 changes of such values. This makes sense for structures
1778 (since the changes in children values will be reported separately),
1779 or for artifical objects (like 'public' pseudo-field in C++).
1781 Return value of 0 means that gdb need not call value_fetch_lazy
1782 for the value of this variable object. */
1784 type_changeable (struct varobj
*var
)
1789 if (CPLUS_FAKE_CHILD (var
))
1792 type
= get_type (var
);
1794 switch (TYPE_CODE (type
))
1796 case TYPE_CODE_STRUCT
:
1797 case TYPE_CODE_UNION
:
1798 case TYPE_CODE_ARRAY
:
1811 c_number_of_children (struct varobj
*var
)
1814 struct type
*target
;
1817 type
= get_type (var
);
1818 target
= get_target_type (type
);
1821 switch (TYPE_CODE (type
))
1823 case TYPE_CODE_ARRAY
:
1824 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (target
) > 0
1825 && TYPE_ARRAY_UPPER_BOUND_TYPE (type
) != BOUND_CANNOT_BE_DETERMINED
)
1826 children
= TYPE_LENGTH (type
) / TYPE_LENGTH (target
);
1831 case TYPE_CODE_STRUCT
:
1832 case TYPE_CODE_UNION
:
1833 children
= TYPE_NFIELDS (type
);
1837 /* This is where things get compilcated. All pointers have one child.
1838 Except, of course, for struct and union ptr, which we automagically
1839 dereference for the user and function ptrs, which have no children.
1840 We also don't dereference void* as we don't know what to show.
1841 We can show char* so we allow it to be dereferenced. If you decide
1842 to test for it, please mind that a little magic is necessary to
1843 properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
1844 TYPE_NAME == "char" */
1846 switch (TYPE_CODE (target
))
1848 case TYPE_CODE_STRUCT
:
1849 case TYPE_CODE_UNION
:
1850 children
= TYPE_NFIELDS (target
);
1853 case TYPE_CODE_FUNC
:
1854 case TYPE_CODE_VOID
:
1864 /* Other types have no children */
1872 c_name_of_variable (struct varobj
*parent
)
1874 return savestring (parent
->name
, strlen (parent
->name
));
1878 c_name_of_child (struct varobj
*parent
, int index
)
1881 struct type
*target
;
1885 type
= get_type (parent
);
1886 target
= get_target_type (type
);
1888 switch (TYPE_CODE (type
))
1890 case TYPE_CODE_ARRAY
:
1891 name
= xstrprintf ("%d", index
1892 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
)));
1895 case TYPE_CODE_STRUCT
:
1896 case TYPE_CODE_UNION
:
1897 string
= TYPE_FIELD_NAME (type
, index
);
1898 name
= savestring (string
, strlen (string
));
1902 switch (TYPE_CODE (target
))
1904 case TYPE_CODE_STRUCT
:
1905 case TYPE_CODE_UNION
:
1906 string
= TYPE_FIELD_NAME (target
, index
);
1907 name
= savestring (string
, strlen (string
));
1911 name
= xstrprintf ("*%s", parent
->name
);
1917 /* This should not happen */
1918 name
= xstrdup ("???");
1924 static struct value
*
1925 c_value_of_root (struct varobj
**var_handle
)
1927 struct value
*new_val
;
1928 struct varobj
*var
= *var_handle
;
1929 struct frame_info
*fi
;
1932 /* Only root variables can be updated... */
1933 if (var
->root
->rootvar
!= var
)
1934 /* Not a root var */
1938 /* Determine whether the variable is still around. */
1939 if (var
->root
->valid_block
== NULL
)
1943 reinit_frame_cache ();
1944 fi
= frame_find_by_id (var
->root
->frame
);
1945 within_scope
= fi
!= NULL
;
1946 /* FIXME: select_frame could fail */
1953 /* We need to catch errors here, because if evaluate
1954 expression fails we just want to make val->error = 1 and
1956 if (gdb_evaluate_expression (var
->root
->exp
, &new_val
))
1959 release_value (new_val
);
1970 static struct value
*
1971 c_value_of_child (struct varobj
*parent
, int index
)
1973 struct value
*value
;
1975 struct value
*indval
;
1976 struct type
*type
, *target
;
1980 type
= get_type (parent
);
1981 target
= get_target_type (type
);
1982 name
= name_of_child (parent
, index
);
1983 temp
= parent
->value
;
1988 switch (TYPE_CODE (type
))
1990 case TYPE_CODE_ARRAY
:
1991 real_index
= index
+ TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
1993 /* This breaks if the array lives in a (vector) register. */
1994 value
= value_slice (temp
, real_index
, 1);
1995 temp
= value_coerce_array (value
);
1996 gdb_value_ind (temp
, &value
);
1998 indval
= value_from_longest (builtin_type_int
, (LONGEST
) real_index
);
1999 gdb_value_subscript (temp
, indval
, &value
);
2003 case TYPE_CODE_STRUCT
:
2004 case TYPE_CODE_UNION
:
2005 gdb_value_struct_elt (NULL
, &value
, &temp
, NULL
, name
, NULL
,
2010 switch (TYPE_CODE (target
))
2012 case TYPE_CODE_STRUCT
:
2013 case TYPE_CODE_UNION
:
2014 gdb_value_struct_elt (NULL
, &value
, &temp
, NULL
, name
, NULL
,
2019 gdb_value_ind (temp
, &value
);
2030 release_value (value
);
2036 static struct type
*
2037 c_type_of_child (struct varobj
*parent
, int index
)
2040 char *name
= name_of_child (parent
, index
);
2042 switch (TYPE_CODE (parent
->type
))
2044 case TYPE_CODE_ARRAY
:
2045 type
= get_target_type (parent
->type
);
2048 case TYPE_CODE_STRUCT
:
2049 case TYPE_CODE_UNION
:
2050 type
= lookup_struct_elt_type (parent
->type
, name
, 0);
2054 switch (TYPE_CODE (get_target_type (parent
->type
)))
2056 case TYPE_CODE_STRUCT
:
2057 case TYPE_CODE_UNION
:
2058 type
= lookup_struct_elt_type (parent
->type
, name
, 0);
2062 type
= get_target_type (parent
->type
);
2068 /* This should not happen as only the above types have children */
2069 warning (_("Child of parent whose type does not allow children"));
2070 /* FIXME: Can we still go on? */
2080 c_variable_editable (struct varobj
*var
)
2082 switch (TYPE_CODE (get_type (var
)))
2084 case TYPE_CODE_STRUCT
:
2085 case TYPE_CODE_UNION
:
2086 case TYPE_CODE_ARRAY
:
2087 case TYPE_CODE_FUNC
:
2088 case TYPE_CODE_MEMBER
:
2089 case TYPE_CODE_METHOD
:
2100 c_value_of_variable (struct varobj
*var
)
2102 /* BOGUS: if val_print sees a struct/class, or a reference to one,
2103 it will print out its children instead of "{...}". So we need to
2104 catch that case explicitly. */
2105 struct type
*type
= get_type (var
);
2107 /* Strip top-level references. */
2108 while (TYPE_CODE (type
) == TYPE_CODE_REF
)
2109 type
= check_typedef (TYPE_TARGET_TYPE (type
));
2111 switch (TYPE_CODE (type
))
2113 case TYPE_CODE_STRUCT
:
2114 case TYPE_CODE_UNION
:
2115 return xstrdup ("{...}");
2118 case TYPE_CODE_ARRAY
:
2121 number
= xstrprintf ("[%d]", var
->num_children
);
2128 if (var
->value
== NULL
)
2130 /* This can happen if we attempt to get the value of a struct
2131 member when the parent is an invalid pointer. This is an
2132 error condition, so we should tell the caller. */
2138 struct ui_file
*stb
= mem_fileopen ();
2139 struct cleanup
*old_chain
= make_cleanup_ui_file_delete (stb
);
2142 gdb_assert (type_changeable (var
));
2143 gdb_assert (!value_lazy (var
->value
));
2144 common_val_print (var
->value
, stb
,
2145 format_code
[(int) var
->format
], 1, 0, 0);
2146 thevalue
= ui_file_xstrdup (stb
, &dummy
);
2147 do_cleanups (old_chain
);
2158 cplus_number_of_children (struct varobj
*var
)
2161 int children
, dont_know
;
2166 if (!CPLUS_FAKE_CHILD (var
))
2168 type
= get_type_deref (var
);
2170 if (((TYPE_CODE (type
)) == TYPE_CODE_STRUCT
) ||
2171 ((TYPE_CODE (type
)) == TYPE_CODE_UNION
))
2175 cplus_class_num_children (type
, kids
);
2176 if (kids
[v_public
] != 0)
2178 if (kids
[v_private
] != 0)
2180 if (kids
[v_protected
] != 0)
2183 /* Add any baseclasses */
2184 children
+= TYPE_N_BASECLASSES (type
);
2187 /* FIXME: save children in var */
2194 type
= get_type_deref (var
->parent
);
2196 cplus_class_num_children (type
, kids
);
2197 if (strcmp (var
->name
, "public") == 0)
2198 children
= kids
[v_public
];
2199 else if (strcmp (var
->name
, "private") == 0)
2200 children
= kids
[v_private
];
2202 children
= kids
[v_protected
];
2207 children
= c_number_of_children (var
);
2212 /* Compute # of public, private, and protected variables in this class.
2213 That means we need to descend into all baseclasses and find out
2214 how many are there, too. */
2216 cplus_class_num_children (struct type
*type
, int children
[3])
2220 children
[v_public
] = 0;
2221 children
[v_private
] = 0;
2222 children
[v_protected
] = 0;
2224 for (i
= TYPE_N_BASECLASSES (type
); i
< TYPE_NFIELDS (type
); i
++)
2226 /* If we have a virtual table pointer, omit it. */
2227 if (TYPE_VPTR_BASETYPE (type
) == type
&& TYPE_VPTR_FIELDNO (type
) == i
)
2230 if (TYPE_FIELD_PROTECTED (type
, i
))
2231 children
[v_protected
]++;
2232 else if (TYPE_FIELD_PRIVATE (type
, i
))
2233 children
[v_private
]++;
2235 children
[v_public
]++;
2240 cplus_name_of_variable (struct varobj
*parent
)
2242 return c_name_of_variable (parent
);
2246 cplus_name_of_child (struct varobj
*parent
, int index
)
2251 if (CPLUS_FAKE_CHILD (parent
))
2253 /* Looking for children of public, private, or protected. */
2254 type
= get_type_deref (parent
->parent
);
2257 type
= get_type_deref (parent
);
2260 switch (TYPE_CODE (type
))
2262 case TYPE_CODE_STRUCT
:
2263 case TYPE_CODE_UNION
:
2264 if (CPLUS_FAKE_CHILD (parent
))
2266 /* The fields of the class type are ordered as they
2267 appear in the class. We are given an index for a
2268 particular access control type ("public","protected",
2269 or "private"). We must skip over fields that don't
2270 have the access control we are looking for to properly
2271 find the indexed field. */
2272 int type_index
= TYPE_N_BASECLASSES (type
);
2273 if (strcmp (parent
->name
, "private") == 0)
2277 if (TYPE_VPTR_BASETYPE (type
) == type
2278 && type_index
== TYPE_VPTR_FIELDNO (type
))
2280 else if (TYPE_FIELD_PRIVATE (type
, type_index
))
2286 else if (strcmp (parent
->name
, "protected") == 0)
2290 if (TYPE_VPTR_BASETYPE (type
) == type
2291 && type_index
== TYPE_VPTR_FIELDNO (type
))
2293 else if (TYPE_FIELD_PROTECTED (type
, type_index
))
2303 if (TYPE_VPTR_BASETYPE (type
) == type
2304 && type_index
== TYPE_VPTR_FIELDNO (type
))
2306 else if (!TYPE_FIELD_PRIVATE (type
, type_index
) &&
2307 !TYPE_FIELD_PROTECTED (type
, type_index
))
2314 name
= TYPE_FIELD_NAME (type
, type_index
);
2316 else if (index
< TYPE_N_BASECLASSES (type
))
2317 /* We are looking up the name of a base class */
2318 name
= TYPE_FIELD_NAME (type
, index
);
2322 cplus_class_num_children(type
, children
);
2324 /* Everything beyond the baseclasses can
2325 only be "public", "private", or "protected"
2327 The special "fake" children are always output by varobj in
2328 this order. So if INDEX == 2, it MUST be "protected". */
2329 index
-= TYPE_N_BASECLASSES (type
);
2333 if (children
[v_public
] > 0)
2335 else if (children
[v_private
] > 0)
2341 if (children
[v_public
] > 0)
2343 if (children
[v_private
] > 0)
2348 else if (children
[v_private
] > 0)
2352 /* Must be protected */
2367 return c_name_of_child (parent
, index
);
2371 name
= savestring (name
, strlen (name
));
2377 static struct value
*
2378 cplus_value_of_root (struct varobj
**var_handle
)
2380 return c_value_of_root (var_handle
);
2383 static struct value
*
2384 cplus_value_of_child (struct varobj
*parent
, int index
)
2387 struct value
*value
;
2389 if (CPLUS_FAKE_CHILD (parent
))
2390 type
= get_type_deref (parent
->parent
);
2392 type
= get_type_deref (parent
);
2396 if (((TYPE_CODE (type
)) == TYPE_CODE_STRUCT
) ||
2397 ((TYPE_CODE (type
)) == TYPE_CODE_UNION
))
2399 if (CPLUS_FAKE_CHILD (parent
))
2402 struct value
*temp
= parent
->parent
->value
;
2407 name
= name_of_child (parent
, index
);
2408 gdb_value_struct_elt (NULL
, &value
, &temp
, NULL
, name
, NULL
,
2411 release_value (value
);
2415 else if (index
>= TYPE_N_BASECLASSES (type
))
2417 /* public, private, or protected */
2423 if (parent
->value
!= NULL
)
2425 struct value
*temp
= NULL
;
2427 if (TYPE_CODE (value_type (parent
->value
)) == TYPE_CODE_PTR
2428 || TYPE_CODE (value_type (parent
->value
)) == TYPE_CODE_REF
)
2430 if (!gdb_value_ind (parent
->value
, &temp
))
2434 temp
= parent
->value
;
2438 value
= value_cast (TYPE_FIELD_TYPE (type
, index
), temp
);
2439 release_value (value
);
2443 /* We failed to evaluate the parent's value, so don't even
2444 bother trying to evaluate this child. */
2452 return c_value_of_child (parent
, index
);
2457 static struct type
*
2458 cplus_type_of_child (struct varobj
*parent
, int index
)
2460 struct type
*type
, *t
;
2462 if (CPLUS_FAKE_CHILD (parent
))
2464 /* Looking for the type of a child of public, private, or protected. */
2465 t
= get_type_deref (parent
->parent
);
2468 t
= get_type_deref (parent
);
2471 switch (TYPE_CODE (t
))
2473 case TYPE_CODE_STRUCT
:
2474 case TYPE_CODE_UNION
:
2475 if (CPLUS_FAKE_CHILD (parent
))
2477 char *name
= cplus_name_of_child (parent
, index
);
2478 type
= lookup_struct_elt_type (t
, name
, 0);
2481 else if (index
< TYPE_N_BASECLASSES (t
))
2482 type
= TYPE_FIELD_TYPE (t
, index
);
2495 return c_type_of_child (parent
, index
);
2501 cplus_variable_editable (struct varobj
*var
)
2503 if (CPLUS_FAKE_CHILD (var
))
2506 return c_variable_editable (var
);
2510 cplus_value_of_variable (struct varobj
*var
)
2513 /* If we have one of our special types, don't print out
2515 if (CPLUS_FAKE_CHILD (var
))
2516 return xstrdup ("");
2518 return c_value_of_variable (var
);
2524 java_number_of_children (struct varobj
*var
)
2526 return cplus_number_of_children (var
);
2530 java_name_of_variable (struct varobj
*parent
)
2534 name
= cplus_name_of_variable (parent
);
2535 /* If the name has "-" in it, it is because we
2536 needed to escape periods in the name... */
2539 while (*p
!= '\000')
2550 java_name_of_child (struct varobj
*parent
, int index
)
2554 name
= cplus_name_of_child (parent
, index
);
2555 /* Escape any periods in the name... */
2558 while (*p
!= '\000')
2568 static struct value
*
2569 java_value_of_root (struct varobj
**var_handle
)
2571 return cplus_value_of_root (var_handle
);
2574 static struct value
*
2575 java_value_of_child (struct varobj
*parent
, int index
)
2577 return cplus_value_of_child (parent
, index
);
2580 static struct type
*
2581 java_type_of_child (struct varobj
*parent
, int index
)
2583 return cplus_type_of_child (parent
, index
);
2587 java_variable_editable (struct varobj
*var
)
2589 return cplus_variable_editable (var
);
2593 java_value_of_variable (struct varobj
*var
)
2595 return cplus_value_of_variable (var
);
2598 extern void _initialize_varobj (void);
2600 _initialize_varobj (void)
2602 int sizeof_table
= sizeof (struct vlist
*) * VAROBJ_TABLE_SIZE
;
2604 varobj_table
= xmalloc (sizeof_table
);
2605 memset (varobj_table
, 0, sizeof_table
);
2607 add_setshow_zinteger_cmd ("debugvarobj", class_maintenance
,
2609 Set varobj debugging."), _("\
2610 Show varobj debugging."), _("\
2611 When non-zero, varobj debugging is enabled."),
2614 &setlist
, &showlist
);