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 /* The new value may be lazy. gdb_value_assign, or
845 rather value_contents, will take care of this.
846 If fetching of the new value will fail, gdb_value_assign
847 with catch the exception. */
848 if (!gdb_value_assign (var
->value
, value
, &val
))
853 /* If the value has changed, record it, so that next -var-update can
854 report this change. If a variable had a value of '1', we've set it
855 to '333' and then set again to '1', when -var-update will report this
856 variable as changed -- because the first assignment has set the
857 'updated' flag. There's no need to optimize that, because return value
858 of -var-update should be considered an approximation. */
859 var
->updated
= install_new_value (var
, val
, 0 /* Compare values. */);
860 input_radix
= saved_input_radix
;
867 /* Returns a malloc'ed list with all root variable objects */
869 varobj_list (struct varobj
***varlist
)
872 struct varobj_root
*croot
;
873 int mycount
= rootcount
;
875 /* Alloc (rootcount + 1) entries for the result */
876 *varlist
= xmalloc ((rootcount
+ 1) * sizeof (struct varobj
*));
880 while ((croot
!= NULL
) && (mycount
> 0))
882 *cv
= croot
->rootvar
;
887 /* Mark the end of the list */
890 if (mycount
|| (croot
!= NULL
))
892 ("varobj_list: assertion failed - wrong tally of root vars (%d:%d)",
898 /* Assign a new value to a variable object. If INITIAL is non-zero,
899 this is the first assignement after the variable object was just
900 created, or changed type. In that case, just assign the value
902 Otherwise, assign the value and if type_changeable returns non-zero,
903 find if the new value is different from the current value.
904 Return 1 if so, and 0 if the values are equal. */
906 install_new_value (struct varobj
*var
, struct value
*value
, int initial
)
913 /* We need to know the varobj's type to decide if the value should
914 be fetched or not. C++ fake children (public/protected/private) don't have
916 gdb_assert (var
->type
|| CPLUS_FAKE_CHILD (var
));
917 changeable
= type_changeable (var
);
918 need_to_fetch
= changeable
;
920 if (var
->type
&& TYPE_CODE (var
->type
) == TYPE_CODE_UNION
)
921 /* For unions, we need to fetch the value implicitly because
922 of implementation of union member fetch. When gdb
923 creates a value for a field and the value of the enclosing
924 structure is not lazy, it immediately copies the necessary
925 bytes from the enclosing values. If the enclosing value is
926 lazy, the call to value_fetch_lazy on the field will read
927 the data from memory. For unions, that means we'll read the
928 same memory more than once, which is not desirable. So
932 /* The new value might be lazy. If the type is changeable,
933 that is we'll be comparing values of this type, fetch the
934 value now. Otherwise, on the next update the old value
935 will be lazy, which means we've lost that old value. */
936 if (need_to_fetch
&& value
&& value_lazy (value
))
938 if (!gdb_value_fetch_lazy (value
))
941 /* Set the value to NULL, so that for the next -var-update,
942 we don't try to compare the new value with this value,
943 that we couldn't even read. */
950 /* If the type is changeable, compare the old and the new values.
951 If this is the initial assignment, we don't have any old value
953 if (!initial
&& changeable
)
955 /* If the value of the varobj was changed by -var-set-value, then the
956 value in the varobj and in the target is the same. However, that value
957 is different from the value that the varobj had after the previous
958 -var-update. So need to the varobj as changed. */
963 /* Try to compare the values. That requires that both
964 values are non-lazy. */
966 /* Quick comparison of NULL values. */
967 if (var
->value
== NULL
&& value
== NULL
)
970 else if (var
->value
== NULL
|| value
== NULL
)
974 gdb_assert (!value_lazy (var
->value
));
975 gdb_assert (!value_lazy (value
));
977 if (!value_contents_equal (var
->value
, value
))
983 /* We must always keep the new value, since children depend on it. */
984 if (var
->value
!= NULL
)
985 value_free (var
->value
);
993 /* Update the values for a variable and its children. This is a
994 two-pronged attack. First, re-parse the value for the root's
995 expression to see if it's changed. Then go all the way
996 through its children, reconstructing them and noting if they've
999 -1 if there was an error updating the varobj
1000 -2 if the type changed
1001 Otherwise it is the number of children + parent changed
1003 Only root variables can be updated...
1005 NOTE: This function may delete the caller's varobj. If it
1006 returns -2, then it has done this and VARP will be modified
1007 to point to the new varobj. */
1010 varobj_update (struct varobj
**varp
, struct varobj
***changelist
)
1019 struct varobj
**templist
= NULL
;
1021 struct vstack
*stack
= NULL
;
1022 struct vstack
*result
= NULL
;
1023 struct frame_id old_fid
;
1024 struct frame_info
*fi
;
1026 /* sanity check: have we been passed a pointer? */
1027 if (changelist
== NULL
)
1030 /* Only root variables can be updated... */
1031 if ((*varp
)->root
->rootvar
!= *varp
)
1032 /* Not a root var */
1035 /* Save the selected stack frame, since we will need to change it
1036 in order to evaluate expressions. */
1037 old_fid
= get_frame_id (deprecated_selected_frame
);
1039 /* Update the root variable. value_of_root can return NULL
1040 if the variable is no longer around, i.e. we stepped out of
1041 the frame in which a local existed. We are letting the
1042 value_of_root variable dispose of the varobj if the type
1045 new = value_of_root (varp
, &type_changed
);
1052 /* Initialize a stack for temporary results */
1053 vpush (&result
, NULL
);
1055 /* If this is a "use_selected_frame" varobj, and its type has changed,
1056 them note that it's changed. */
1059 vpush (&result
, *varp
);
1063 if (install_new_value ((*varp
), new, type_changed
))
1065 /* If type_changed is 1, install_new_value will never return
1066 non-zero, so we'll never report the same variable twice. */
1067 gdb_assert (!type_changed
);
1068 vpush (&result
, (*varp
));
1072 /* Initialize a stack */
1073 vpush (&stack
, NULL
);
1075 /* Push the root's children */
1076 if ((*varp
)->children
!= NULL
)
1078 struct varobj_child
*c
;
1079 for (c
= (*varp
)->children
; c
!= NULL
; c
= c
->next
)
1080 vpush (&stack
, c
->child
);
1083 /* Walk through the children, reconstructing them all. */
1087 /* Push any children */
1088 if (v
->children
!= NULL
)
1090 struct varobj_child
*c
;
1091 for (c
= v
->children
; c
!= NULL
; c
= c
->next
)
1092 vpush (&stack
, c
->child
);
1095 /* Update this variable */
1096 new = value_of_child (v
->parent
, v
->index
);
1097 if (install_new_value (v
, new, 0 /* type not changed */))
1099 /* Note that it's changed */
1105 /* Get next child */
1109 /* Alloc (changed + 1) list entries */
1110 /* FIXME: add a cleanup for the allocated list(s)
1111 because one day the select_frame called below can longjump */
1112 *changelist
= xmalloc ((changed
+ 1) * sizeof (struct varobj
*));
1115 templist
= xmalloc ((changed
+ 1) * sizeof (struct varobj
*));
1121 /* Copy from result stack to list */
1123 *cv
= vpop (&result
);
1124 while ((*cv
!= NULL
) && (vleft
> 0))
1128 *cv
= vpop (&result
);
1131 warning (_("varobj_update: assertion failed - vleft <> 0"));
1135 /* Now we revert the order. */
1136 for (i
= 0; i
< changed
; i
++)
1137 *(*changelist
+ i
) = *(templist
+ changed
- 1 - i
);
1138 *(*changelist
+ changed
) = NULL
;
1141 /* Restore selected frame */
1142 fi
= frame_find_by_id (old_fid
);
1153 /* Helper functions */
1156 * Variable object construction/destruction
1160 delete_variable (struct cpstack
**resultp
, struct varobj
*var
,
1161 int only_children_p
)
1165 delete_variable_1 (resultp
, &delcount
, var
,
1166 only_children_p
, 1 /* remove_from_parent_p */ );
1171 /* Delete the variable object VAR and its children */
1172 /* IMPORTANT NOTE: If we delete a variable which is a child
1173 and the parent is not removed we dump core. It must be always
1174 initially called with remove_from_parent_p set */
1176 delete_variable_1 (struct cpstack
**resultp
, int *delcountp
,
1177 struct varobj
*var
, int only_children_p
,
1178 int remove_from_parent_p
)
1180 struct varobj_child
*vc
;
1181 struct varobj_child
*next
;
1183 /* Delete any children of this variable, too. */
1184 for (vc
= var
->children
; vc
!= NULL
; vc
= next
)
1186 if (!remove_from_parent_p
)
1187 vc
->child
->parent
= NULL
;
1188 delete_variable_1 (resultp
, delcountp
, vc
->child
, 0, only_children_p
);
1193 /* if we were called to delete only the children we are done here */
1194 if (only_children_p
)
1197 /* Otherwise, add it to the list of deleted ones and proceed to do so */
1198 /* If the name is null, this is a temporary variable, that has not
1199 yet been installed, don't report it, it belongs to the caller... */
1200 if (var
->obj_name
!= NULL
)
1202 cppush (resultp
, xstrdup (var
->obj_name
));
1203 *delcountp
= *delcountp
+ 1;
1206 /* If this variable has a parent, remove it from its parent's list */
1207 /* OPTIMIZATION: if the parent of this variable is also being deleted,
1208 (as indicated by remove_from_parent_p) we don't bother doing an
1209 expensive list search to find the element to remove when we are
1210 discarding the list afterwards */
1211 if ((remove_from_parent_p
) && (var
->parent
!= NULL
))
1213 remove_child_from_parent (var
->parent
, var
);
1216 if (var
->obj_name
!= NULL
)
1217 uninstall_variable (var
);
1219 /* Free memory associated with this variable */
1220 free_variable (var
);
1223 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
1225 install_variable (struct varobj
*var
)
1228 struct vlist
*newvl
;
1230 unsigned int index
= 0;
1233 for (chp
= var
->obj_name
; *chp
; chp
++)
1235 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
1238 cv
= *(varobj_table
+ index
);
1239 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
1243 error (_("Duplicate variable object name"));
1245 /* Add varobj to hash table */
1246 newvl
= xmalloc (sizeof (struct vlist
));
1247 newvl
->next
= *(varobj_table
+ index
);
1249 *(varobj_table
+ index
) = newvl
;
1251 /* If root, add varobj to root list */
1252 if (var
->root
->rootvar
== var
)
1254 /* Add to list of root variables */
1255 if (rootlist
== NULL
)
1256 var
->root
->next
= NULL
;
1258 var
->root
->next
= rootlist
;
1259 rootlist
= var
->root
;
1266 /* Unistall the object VAR. */
1268 uninstall_variable (struct varobj
*var
)
1272 struct varobj_root
*cr
;
1273 struct varobj_root
*prer
;
1275 unsigned int index
= 0;
1278 /* Remove varobj from hash table */
1279 for (chp
= var
->obj_name
; *chp
; chp
++)
1281 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
1284 cv
= *(varobj_table
+ index
);
1286 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
1293 fprintf_unfiltered (gdb_stdlog
, "Deleting %s\n", var
->obj_name
);
1298 ("Assertion failed: Could not find variable object \"%s\" to delete",
1304 *(varobj_table
+ index
) = cv
->next
;
1306 prev
->next
= cv
->next
;
1310 /* If root, remove varobj from root list */
1311 if (var
->root
->rootvar
== var
)
1313 /* Remove from list of root variables */
1314 if (rootlist
== var
->root
)
1315 rootlist
= var
->root
->next
;
1320 while ((cr
!= NULL
) && (cr
->rootvar
!= var
))
1328 ("Assertion failed: Could not find varobj \"%s\" in root list",
1335 prer
->next
= cr
->next
;
1342 /* Does a child with the name NAME exist in VAR? If so, return its data.
1343 If not, return NULL. */
1344 static struct varobj
*
1345 child_exists (struct varobj
*var
, char *name
)
1347 struct varobj_child
*vc
;
1349 for (vc
= var
->children
; vc
!= NULL
; vc
= vc
->next
)
1351 if (strcmp (vc
->child
->name
, name
) == 0)
1358 /* Create and install a child of the parent of the given name */
1359 static struct varobj
*
1360 create_child (struct varobj
*parent
, int index
, char *name
)
1362 struct varobj
*child
;
1364 struct value
*value
;
1366 child
= new_variable ();
1368 /* name is allocated by name_of_child */
1370 child
->index
= index
;
1371 value
= value_of_child (parent
, index
);
1372 child
->parent
= parent
;
1373 child
->root
= parent
->root
;
1374 childs_name
= xstrprintf ("%s.%s", parent
->obj_name
, name
);
1375 child
->obj_name
= childs_name
;
1376 install_variable (child
);
1378 /* Save a pointer to this child in the parent */
1379 save_child_in_parent (parent
, child
);
1381 /* Compute the type of the child. Must do this before
1382 calling install_new_value. */
1384 /* If the child had no evaluation errors, var->value
1385 will be non-NULL and contain a valid type. */
1386 child
->type
= value_type (value
);
1388 /* Otherwise, we must compute the type. */
1389 child
->type
= (*child
->root
->lang
->type_of_child
) (child
->parent
,
1391 install_new_value (child
, value
, 1);
1393 if ((!CPLUS_FAKE_CHILD (child
) && child
->value
== NULL
) || parent
->error
)
1399 /* FIXME: This should be a generic add to list */
1400 /* Save CHILD in the PARENT's data. */
1402 save_child_in_parent (struct varobj
*parent
, struct varobj
*child
)
1404 struct varobj_child
*vc
;
1406 /* Insert the child at the top */
1407 vc
= parent
->children
;
1409 (struct varobj_child
*) xmalloc (sizeof (struct varobj_child
));
1411 parent
->children
->next
= vc
;
1412 parent
->children
->child
= child
;
1415 /* FIXME: This should be a generic remove from list */
1416 /* Remove the CHILD from the PARENT's list of children. */
1418 remove_child_from_parent (struct varobj
*parent
, struct varobj
*child
)
1420 struct varobj_child
*vc
, *prev
;
1422 /* Find the child in the parent's list */
1424 for (vc
= parent
->children
; vc
!= NULL
;)
1426 if (vc
->child
== child
)
1433 parent
->children
= vc
->next
;
1435 prev
->next
= vc
->next
;
1441 * Miscellaneous utility functions.
1444 /* Allocate memory and initialize a new variable */
1445 static struct varobj
*
1450 var
= (struct varobj
*) xmalloc (sizeof (struct varobj
));
1452 var
->obj_name
= NULL
;
1457 var
->num_children
= -1;
1459 var
->children
= NULL
;
1467 /* Allocate memory and initialize a new root variable */
1468 static struct varobj
*
1469 new_root_variable (void)
1471 struct varobj
*var
= new_variable ();
1472 var
->root
= (struct varobj_root
*) xmalloc (sizeof (struct varobj_root
));;
1473 var
->root
->lang
= NULL
;
1474 var
->root
->exp
= NULL
;
1475 var
->root
->valid_block
= NULL
;
1476 var
->root
->frame
= null_frame_id
;
1477 var
->root
->use_selected_frame
= 0;
1478 var
->root
->rootvar
= NULL
;
1483 /* Free any allocated memory associated with VAR. */
1485 free_variable (struct varobj
*var
)
1487 /* Free the expression if this is a root variable. */
1488 if (var
->root
->rootvar
== var
)
1490 free_current_contents (&var
->root
->exp
);
1495 xfree (var
->obj_name
);
1500 do_free_variable_cleanup (void *var
)
1502 free_variable (var
);
1505 static struct cleanup
*
1506 make_cleanup_free_variable (struct varobj
*var
)
1508 return make_cleanup (do_free_variable_cleanup
, var
);
1511 /* This returns the type of the variable. It also skips past typedefs
1512 to return the real type of the variable.
1514 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
1515 except within get_target_type and get_type. */
1516 static struct type
*
1517 get_type (struct varobj
*var
)
1523 type
= check_typedef (type
);
1528 /* This returns the type of the variable, dereferencing pointers, too. */
1529 static struct type
*
1530 get_type_deref (struct varobj
*var
)
1534 type
= get_type (var
);
1536 if (type
!= NULL
&& (TYPE_CODE (type
) == TYPE_CODE_PTR
1537 || TYPE_CODE (type
) == TYPE_CODE_REF
))
1538 type
= get_target_type (type
);
1543 /* This returns the target type (or NULL) of TYPE, also skipping
1544 past typedefs, just like get_type ().
1546 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
1547 except within get_target_type and get_type. */
1548 static struct type
*
1549 get_target_type (struct type
*type
)
1553 type
= TYPE_TARGET_TYPE (type
);
1555 type
= check_typedef (type
);
1561 /* What is the default display for this variable? We assume that
1562 everything is "natural". Any exceptions? */
1563 static enum varobj_display_formats
1564 variable_default_display (struct varobj
*var
)
1566 return FORMAT_NATURAL
;
1569 /* FIXME: The following should be generic for any pointer */
1571 vpush (struct vstack
**pstack
, struct varobj
*var
)
1575 s
= (struct vstack
*) xmalloc (sizeof (struct vstack
));
1581 /* FIXME: The following should be generic for any pointer */
1582 static struct varobj
*
1583 vpop (struct vstack
**pstack
)
1588 if ((*pstack
)->var
== NULL
&& (*pstack
)->next
== NULL
)
1593 *pstack
= (*pstack
)->next
;
1599 /* FIXME: The following should be generic for any pointer */
1601 cppush (struct cpstack
**pstack
, char *name
)
1605 s
= (struct cpstack
*) xmalloc (sizeof (struct cpstack
));
1611 /* FIXME: The following should be generic for any pointer */
1613 cppop (struct cpstack
**pstack
)
1618 if ((*pstack
)->name
== NULL
&& (*pstack
)->next
== NULL
)
1623 *pstack
= (*pstack
)->next
;
1630 * Language-dependencies
1633 /* Common entry points */
1635 /* Get the language of variable VAR. */
1636 static enum varobj_languages
1637 variable_language (struct varobj
*var
)
1639 enum varobj_languages lang
;
1641 switch (var
->root
->exp
->language_defn
->la_language
)
1647 case language_cplus
:
1658 /* Return the number of children for a given variable.
1659 The result of this function is defined by the language
1660 implementation. The number of children returned by this function
1661 is the number of children that the user will see in the variable
1664 number_of_children (struct varobj
*var
)
1666 return (*var
->root
->lang
->number_of_children
) (var
);;
1669 /* What is the expression for the root varobj VAR? Returns a malloc'd string. */
1671 name_of_variable (struct varobj
*var
)
1673 return (*var
->root
->lang
->name_of_variable
) (var
);
1676 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd string. */
1678 name_of_child (struct varobj
*var
, int index
)
1680 return (*var
->root
->lang
->name_of_child
) (var
, index
);
1683 /* What is the ``struct value *'' of the root variable VAR?
1684 TYPE_CHANGED controls what to do if the type of a
1685 use_selected_frame = 1 variable changes. On input,
1686 TYPE_CHANGED = 1 means discard the old varobj, and replace
1687 it with this one. TYPE_CHANGED = 0 means leave it around.
1688 NB: In both cases, var_handle will point to the new varobj,
1689 so if you use TYPE_CHANGED = 0, you will have to stash the
1690 old varobj pointer away somewhere before calling this.
1691 On return, TYPE_CHANGED will be 1 if the type has changed, and
1693 static struct value
*
1694 value_of_root (struct varobj
**var_handle
, int *type_changed
)
1698 if (var_handle
== NULL
)
1703 /* This should really be an exception, since this should
1704 only get called with a root variable. */
1706 if (var
->root
->rootvar
!= var
)
1709 if (var
->root
->use_selected_frame
)
1711 struct varobj
*tmp_var
;
1712 char *old_type
, *new_type
;
1713 old_type
= varobj_get_type (var
);
1714 tmp_var
= varobj_create (NULL
, var
->name
, (CORE_ADDR
) 0,
1715 USE_SELECTED_FRAME
);
1716 if (tmp_var
== NULL
)
1720 new_type
= varobj_get_type (tmp_var
);
1721 if (strcmp (old_type
, new_type
) == 0)
1723 varobj_delete (tmp_var
, NULL
, 0);
1731 savestring (var
->obj_name
, strlen (var
->obj_name
));
1732 varobj_delete (var
, NULL
, 0);
1736 tmp_var
->obj_name
= varobj_gen_name ();
1738 install_variable (tmp_var
);
1739 *var_handle
= tmp_var
;
1749 return (*var
->root
->lang
->value_of_root
) (var_handle
);
1752 /* What is the ``struct value *'' for the INDEX'th child of PARENT? */
1753 static struct value
*
1754 value_of_child (struct varobj
*parent
, int index
)
1756 struct value
*value
;
1758 value
= (*parent
->root
->lang
->value_of_child
) (parent
, index
);
1763 /* Is this variable editable? Use the variable's type to make
1764 this determination. */
1766 variable_editable (struct varobj
*var
)
1768 return (*var
->root
->lang
->variable_editable
) (var
);
1771 /* GDB already has a command called "value_of_variable". Sigh. */
1773 my_value_of_variable (struct varobj
*var
)
1775 return (*var
->root
->lang
->value_of_variable
) (var
);
1778 /* Return non-zero if changes in value of VAR
1779 must be detected and reported by -var-update.
1780 Return zero is -var-update should never report
1781 changes of such values. This makes sense for structures
1782 (since the changes in children values will be reported separately),
1783 or for artifical objects (like 'public' pseudo-field in C++).
1785 Return value of 0 means that gdb need not call value_fetch_lazy
1786 for the value of this variable object. */
1788 type_changeable (struct varobj
*var
)
1793 if (CPLUS_FAKE_CHILD (var
))
1796 type
= get_type (var
);
1798 switch (TYPE_CODE (type
))
1800 case TYPE_CODE_STRUCT
:
1801 case TYPE_CODE_UNION
:
1802 case TYPE_CODE_ARRAY
:
1815 c_number_of_children (struct varobj
*var
)
1818 struct type
*target
;
1821 type
= get_type (var
);
1822 target
= get_target_type (type
);
1825 switch (TYPE_CODE (type
))
1827 case TYPE_CODE_ARRAY
:
1828 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (target
) > 0
1829 && TYPE_ARRAY_UPPER_BOUND_TYPE (type
) != BOUND_CANNOT_BE_DETERMINED
)
1830 children
= TYPE_LENGTH (type
) / TYPE_LENGTH (target
);
1835 case TYPE_CODE_STRUCT
:
1836 case TYPE_CODE_UNION
:
1837 children
= TYPE_NFIELDS (type
);
1841 /* This is where things get compilcated. All pointers have one child.
1842 Except, of course, for struct and union ptr, which we automagically
1843 dereference for the user and function ptrs, which have no children.
1844 We also don't dereference void* as we don't know what to show.
1845 We can show char* so we allow it to be dereferenced. If you decide
1846 to test for it, please mind that a little magic is necessary to
1847 properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
1848 TYPE_NAME == "char" */
1850 switch (TYPE_CODE (target
))
1852 case TYPE_CODE_STRUCT
:
1853 case TYPE_CODE_UNION
:
1854 children
= TYPE_NFIELDS (target
);
1857 case TYPE_CODE_FUNC
:
1858 case TYPE_CODE_VOID
:
1868 /* Other types have no children */
1876 c_name_of_variable (struct varobj
*parent
)
1878 return savestring (parent
->name
, strlen (parent
->name
));
1882 c_name_of_child (struct varobj
*parent
, int index
)
1885 struct type
*target
;
1889 type
= get_type (parent
);
1890 target
= get_target_type (type
);
1892 switch (TYPE_CODE (type
))
1894 case TYPE_CODE_ARRAY
:
1895 name
= xstrprintf ("%d", index
1896 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
)));
1899 case TYPE_CODE_STRUCT
:
1900 case TYPE_CODE_UNION
:
1901 string
= TYPE_FIELD_NAME (type
, index
);
1902 name
= savestring (string
, strlen (string
));
1906 switch (TYPE_CODE (target
))
1908 case TYPE_CODE_STRUCT
:
1909 case TYPE_CODE_UNION
:
1910 string
= TYPE_FIELD_NAME (target
, index
);
1911 name
= savestring (string
, strlen (string
));
1915 name
= xstrprintf ("*%s", parent
->name
);
1921 /* This should not happen */
1922 name
= xstrdup ("???");
1928 static struct value
*
1929 c_value_of_root (struct varobj
**var_handle
)
1931 struct value
*new_val
;
1932 struct varobj
*var
= *var_handle
;
1933 struct frame_info
*fi
;
1936 /* Only root variables can be updated... */
1937 if (var
->root
->rootvar
!= var
)
1938 /* Not a root var */
1942 /* Determine whether the variable is still around. */
1943 if (var
->root
->valid_block
== NULL
)
1947 reinit_frame_cache ();
1948 fi
= frame_find_by_id (var
->root
->frame
);
1949 within_scope
= fi
!= NULL
;
1950 /* FIXME: select_frame could fail */
1957 /* We need to catch errors here, because if evaluate
1958 expression fails we just want to make val->error = 1 and
1960 if (gdb_evaluate_expression (var
->root
->exp
, &new_val
))
1963 release_value (new_val
);
1974 static struct value
*
1975 c_value_of_child (struct varobj
*parent
, int index
)
1977 struct value
*value
;
1979 struct value
*indval
;
1980 struct type
*type
, *target
;
1984 type
= get_type (parent
);
1985 target
= get_target_type (type
);
1986 name
= name_of_child (parent
, index
);
1987 temp
= parent
->value
;
1992 switch (TYPE_CODE (type
))
1994 case TYPE_CODE_ARRAY
:
1995 real_index
= index
+ TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
1997 /* This breaks if the array lives in a (vector) register. */
1998 value
= value_slice (temp
, real_index
, 1);
1999 temp
= value_coerce_array (value
);
2000 gdb_value_ind (temp
, &value
);
2002 indval
= value_from_longest (builtin_type_int
, (LONGEST
) real_index
);
2003 gdb_value_subscript (temp
, indval
, &value
);
2007 case TYPE_CODE_STRUCT
:
2008 case TYPE_CODE_UNION
:
2009 gdb_value_struct_elt (NULL
, &value
, &temp
, NULL
, name
, NULL
,
2014 switch (TYPE_CODE (target
))
2016 case TYPE_CODE_STRUCT
:
2017 case TYPE_CODE_UNION
:
2018 gdb_value_struct_elt (NULL
, &value
, &temp
, NULL
, name
, NULL
,
2023 gdb_value_ind (temp
, &value
);
2034 release_value (value
);
2040 static struct type
*
2041 c_type_of_child (struct varobj
*parent
, int index
)
2044 char *name
= name_of_child (parent
, index
);
2046 switch (TYPE_CODE (parent
->type
))
2048 case TYPE_CODE_ARRAY
:
2049 type
= get_target_type (parent
->type
);
2052 case TYPE_CODE_STRUCT
:
2053 case TYPE_CODE_UNION
:
2054 type
= lookup_struct_elt_type (parent
->type
, name
, 0);
2058 switch (TYPE_CODE (get_target_type (parent
->type
)))
2060 case TYPE_CODE_STRUCT
:
2061 case TYPE_CODE_UNION
:
2062 type
= lookup_struct_elt_type (parent
->type
, name
, 0);
2066 type
= get_target_type (parent
->type
);
2072 /* This should not happen as only the above types have children */
2073 warning (_("Child of parent whose type does not allow children"));
2074 /* FIXME: Can we still go on? */
2084 c_variable_editable (struct varobj
*var
)
2086 switch (TYPE_CODE (get_type (var
)))
2088 case TYPE_CODE_STRUCT
:
2089 case TYPE_CODE_UNION
:
2090 case TYPE_CODE_ARRAY
:
2091 case TYPE_CODE_FUNC
:
2092 case TYPE_CODE_MEMBER
:
2093 case TYPE_CODE_METHOD
:
2104 c_value_of_variable (struct varobj
*var
)
2106 /* BOGUS: if val_print sees a struct/class, or a reference to one,
2107 it will print out its children instead of "{...}". So we need to
2108 catch that case explicitly. */
2109 struct type
*type
= get_type (var
);
2111 /* Strip top-level references. */
2112 while (TYPE_CODE (type
) == TYPE_CODE_REF
)
2113 type
= check_typedef (TYPE_TARGET_TYPE (type
));
2115 switch (TYPE_CODE (type
))
2117 case TYPE_CODE_STRUCT
:
2118 case TYPE_CODE_UNION
:
2119 return xstrdup ("{...}");
2122 case TYPE_CODE_ARRAY
:
2125 number
= xstrprintf ("[%d]", var
->num_children
);
2132 if (var
->value
== NULL
)
2134 /* This can happen if we attempt to get the value of a struct
2135 member when the parent is an invalid pointer. This is an
2136 error condition, so we should tell the caller. */
2142 struct ui_file
*stb
= mem_fileopen ();
2143 struct cleanup
*old_chain
= make_cleanup_ui_file_delete (stb
);
2146 gdb_assert (type_changeable (var
));
2147 gdb_assert (!value_lazy (var
->value
));
2148 common_val_print (var
->value
, stb
,
2149 format_code
[(int) var
->format
], 1, 0, 0);
2150 thevalue
= ui_file_xstrdup (stb
, &dummy
);
2151 do_cleanups (old_chain
);
2162 cplus_number_of_children (struct varobj
*var
)
2165 int children
, dont_know
;
2170 if (!CPLUS_FAKE_CHILD (var
))
2172 type
= get_type_deref (var
);
2174 if (((TYPE_CODE (type
)) == TYPE_CODE_STRUCT
) ||
2175 ((TYPE_CODE (type
)) == TYPE_CODE_UNION
))
2179 cplus_class_num_children (type
, kids
);
2180 if (kids
[v_public
] != 0)
2182 if (kids
[v_private
] != 0)
2184 if (kids
[v_protected
] != 0)
2187 /* Add any baseclasses */
2188 children
+= TYPE_N_BASECLASSES (type
);
2191 /* FIXME: save children in var */
2198 type
= get_type_deref (var
->parent
);
2200 cplus_class_num_children (type
, kids
);
2201 if (strcmp (var
->name
, "public") == 0)
2202 children
= kids
[v_public
];
2203 else if (strcmp (var
->name
, "private") == 0)
2204 children
= kids
[v_private
];
2206 children
= kids
[v_protected
];
2211 children
= c_number_of_children (var
);
2216 /* Compute # of public, private, and protected variables in this class.
2217 That means we need to descend into all baseclasses and find out
2218 how many are there, too. */
2220 cplus_class_num_children (struct type
*type
, int children
[3])
2224 children
[v_public
] = 0;
2225 children
[v_private
] = 0;
2226 children
[v_protected
] = 0;
2228 for (i
= TYPE_N_BASECLASSES (type
); i
< TYPE_NFIELDS (type
); i
++)
2230 /* If we have a virtual table pointer, omit it. */
2231 if (TYPE_VPTR_BASETYPE (type
) == type
&& TYPE_VPTR_FIELDNO (type
) == i
)
2234 if (TYPE_FIELD_PROTECTED (type
, i
))
2235 children
[v_protected
]++;
2236 else if (TYPE_FIELD_PRIVATE (type
, i
))
2237 children
[v_private
]++;
2239 children
[v_public
]++;
2244 cplus_name_of_variable (struct varobj
*parent
)
2246 return c_name_of_variable (parent
);
2250 cplus_name_of_child (struct varobj
*parent
, int index
)
2255 if (CPLUS_FAKE_CHILD (parent
))
2257 /* Looking for children of public, private, or protected. */
2258 type
= get_type_deref (parent
->parent
);
2261 type
= get_type_deref (parent
);
2264 switch (TYPE_CODE (type
))
2266 case TYPE_CODE_STRUCT
:
2267 case TYPE_CODE_UNION
:
2268 if (CPLUS_FAKE_CHILD (parent
))
2270 /* The fields of the class type are ordered as they
2271 appear in the class. We are given an index for a
2272 particular access control type ("public","protected",
2273 or "private"). We must skip over fields that don't
2274 have the access control we are looking for to properly
2275 find the indexed field. */
2276 int type_index
= TYPE_N_BASECLASSES (type
);
2277 if (strcmp (parent
->name
, "private") == 0)
2281 if (TYPE_VPTR_BASETYPE (type
) == type
2282 && type_index
== TYPE_VPTR_FIELDNO (type
))
2284 else if (TYPE_FIELD_PRIVATE (type
, type_index
))
2290 else if (strcmp (parent
->name
, "protected") == 0)
2294 if (TYPE_VPTR_BASETYPE (type
) == type
2295 && type_index
== TYPE_VPTR_FIELDNO (type
))
2297 else if (TYPE_FIELD_PROTECTED (type
, type_index
))
2307 if (TYPE_VPTR_BASETYPE (type
) == type
2308 && type_index
== TYPE_VPTR_FIELDNO (type
))
2310 else if (!TYPE_FIELD_PRIVATE (type
, type_index
) &&
2311 !TYPE_FIELD_PROTECTED (type
, type_index
))
2318 name
= TYPE_FIELD_NAME (type
, type_index
);
2320 else if (index
< TYPE_N_BASECLASSES (type
))
2321 /* We are looking up the name of a base class */
2322 name
= TYPE_FIELD_NAME (type
, index
);
2326 cplus_class_num_children(type
, children
);
2328 /* Everything beyond the baseclasses can
2329 only be "public", "private", or "protected"
2331 The special "fake" children are always output by varobj in
2332 this order. So if INDEX == 2, it MUST be "protected". */
2333 index
-= TYPE_N_BASECLASSES (type
);
2337 if (children
[v_public
] > 0)
2339 else if (children
[v_private
] > 0)
2345 if (children
[v_public
] > 0)
2347 if (children
[v_private
] > 0)
2352 else if (children
[v_private
] > 0)
2356 /* Must be protected */
2371 return c_name_of_child (parent
, index
);
2375 name
= savestring (name
, strlen (name
));
2381 static struct value
*
2382 cplus_value_of_root (struct varobj
**var_handle
)
2384 return c_value_of_root (var_handle
);
2387 static struct value
*
2388 cplus_value_of_child (struct varobj
*parent
, int index
)
2391 struct value
*value
;
2393 if (CPLUS_FAKE_CHILD (parent
))
2394 type
= get_type_deref (parent
->parent
);
2396 type
= get_type_deref (parent
);
2400 if (((TYPE_CODE (type
)) == TYPE_CODE_STRUCT
) ||
2401 ((TYPE_CODE (type
)) == TYPE_CODE_UNION
))
2403 if (CPLUS_FAKE_CHILD (parent
))
2406 struct value
*temp
= parent
->parent
->value
;
2411 name
= name_of_child (parent
, index
);
2412 gdb_value_struct_elt (NULL
, &value
, &temp
, NULL
, name
, NULL
,
2415 release_value (value
);
2419 else if (index
>= TYPE_N_BASECLASSES (type
))
2421 /* public, private, or protected */
2427 if (parent
->value
!= NULL
)
2429 struct value
*temp
= NULL
;
2431 if (TYPE_CODE (value_type (parent
->value
)) == TYPE_CODE_PTR
2432 || TYPE_CODE (value_type (parent
->value
)) == TYPE_CODE_REF
)
2434 if (!gdb_value_ind (parent
->value
, &temp
))
2438 temp
= parent
->value
;
2442 value
= value_cast (TYPE_FIELD_TYPE (type
, index
), temp
);
2443 release_value (value
);
2447 /* We failed to evaluate the parent's value, so don't even
2448 bother trying to evaluate this child. */
2456 return c_value_of_child (parent
, index
);
2461 static struct type
*
2462 cplus_type_of_child (struct varobj
*parent
, int index
)
2464 struct type
*type
, *t
;
2466 if (CPLUS_FAKE_CHILD (parent
))
2468 /* Looking for the type of a child of public, private, or protected. */
2469 t
= get_type_deref (parent
->parent
);
2472 t
= get_type_deref (parent
);
2475 switch (TYPE_CODE (t
))
2477 case TYPE_CODE_STRUCT
:
2478 case TYPE_CODE_UNION
:
2479 if (CPLUS_FAKE_CHILD (parent
))
2481 char *name
= cplus_name_of_child (parent
, index
);
2482 type
= lookup_struct_elt_type (t
, name
, 0);
2485 else if (index
< TYPE_N_BASECLASSES (t
))
2486 type
= TYPE_FIELD_TYPE (t
, index
);
2499 return c_type_of_child (parent
, index
);
2505 cplus_variable_editable (struct varobj
*var
)
2507 if (CPLUS_FAKE_CHILD (var
))
2510 return c_variable_editable (var
);
2514 cplus_value_of_variable (struct varobj
*var
)
2517 /* If we have one of our special types, don't print out
2519 if (CPLUS_FAKE_CHILD (var
))
2520 return xstrdup ("");
2522 return c_value_of_variable (var
);
2528 java_number_of_children (struct varobj
*var
)
2530 return cplus_number_of_children (var
);
2534 java_name_of_variable (struct varobj
*parent
)
2538 name
= cplus_name_of_variable (parent
);
2539 /* If the name has "-" in it, it is because we
2540 needed to escape periods in the name... */
2543 while (*p
!= '\000')
2554 java_name_of_child (struct varobj
*parent
, int index
)
2558 name
= cplus_name_of_child (parent
, index
);
2559 /* Escape any periods in the name... */
2562 while (*p
!= '\000')
2572 static struct value
*
2573 java_value_of_root (struct varobj
**var_handle
)
2575 return cplus_value_of_root (var_handle
);
2578 static struct value
*
2579 java_value_of_child (struct varobj
*parent
, int index
)
2581 return cplus_value_of_child (parent
, index
);
2584 static struct type
*
2585 java_type_of_child (struct varobj
*parent
, int index
)
2587 return cplus_type_of_child (parent
, index
);
2591 java_variable_editable (struct varobj
*var
)
2593 return cplus_variable_editable (var
);
2597 java_value_of_variable (struct varobj
*var
)
2599 return cplus_value_of_variable (var
);
2602 extern void _initialize_varobj (void);
2604 _initialize_varobj (void)
2606 int sizeof_table
= sizeof (struct vlist
*) * VAROBJ_TABLE_SIZE
;
2608 varobj_table
= xmalloc (sizeof_table
);
2609 memset (varobj_table
, 0, sizeof_table
);
2611 add_setshow_zinteger_cmd ("debugvarobj", class_maintenance
,
2613 Set varobj debugging."), _("\
2614 Show varobj debugging."), _("\
2615 When non-zero, varobj debugging is enabled."),
2618 &setlist
, &showlist
);