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 var
->type
= value_type (value
);
516 install_new_value (var
, value
, 1 /* Initial assignment */);
518 /* Set language info */
519 lang
= variable_language (var
);
520 var
->root
->lang
= languages
[lang
];
522 /* Set ourselves as our root */
523 var
->root
->rootvar
= var
;
525 /* Reset the selected frame */
527 select_frame (old_fi
);
530 /* If the variable object name is null, that means this
531 is a temporary variable, so don't install it. */
533 if ((var
!= NULL
) && (objname
!= NULL
))
535 var
->obj_name
= savestring (objname
, strlen (objname
));
537 /* If a varobj name is duplicated, the install will fail so
539 if (!install_variable (var
))
541 do_cleanups (old_chain
);
546 discard_cleanups (old_chain
);
550 /* Generates an unique name that can be used for a varobj */
553 varobj_gen_name (void)
558 /* generate a name for this object */
560 obj_name
= xstrprintf ("var%d", id
);
565 /* Given an "objname", returns the pointer to the corresponding varobj
566 or NULL if not found */
569 varobj_get_handle (char *objname
)
573 unsigned int index
= 0;
576 for (chp
= objname
; *chp
; chp
++)
578 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
581 cv
= *(varobj_table
+ index
);
582 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, objname
) != 0))
586 error (_("Variable object not found"));
591 /* Given the handle, return the name of the object */
594 varobj_get_objname (struct varobj
*var
)
596 return var
->obj_name
;
599 /* Given the handle, return the expression represented by the object */
602 varobj_get_expression (struct varobj
*var
)
604 return name_of_variable (var
);
607 /* Deletes a varobj and all its children if only_children == 0,
608 otherwise deletes only the children; returns a malloc'ed list of all the
609 (malloc'ed) names of the variables that have been deleted (NULL terminated) */
612 varobj_delete (struct varobj
*var
, char ***dellist
, int only_children
)
616 struct cpstack
*result
= NULL
;
619 /* Initialize a stack for temporary results */
620 cppush (&result
, NULL
);
623 /* Delete only the variable children */
624 delcount
= delete_variable (&result
, var
, 1 /* only the children */ );
626 /* Delete the variable and all its children */
627 delcount
= delete_variable (&result
, var
, 0 /* parent+children */ );
629 /* We may have been asked to return a list of what has been deleted */
632 *dellist
= xmalloc ((delcount
+ 1) * sizeof (char *));
636 *cp
= cppop (&result
);
637 while ((*cp
!= NULL
) && (mycount
> 0))
641 *cp
= cppop (&result
);
644 if (mycount
|| (*cp
!= NULL
))
645 warning (_("varobj_delete: assertion failed - mycount(=%d) <> 0"),
652 /* Set/Get variable object display format */
654 enum varobj_display_formats
655 varobj_set_display_format (struct varobj
*var
,
656 enum varobj_display_formats format
)
663 case FORMAT_HEXADECIMAL
:
665 var
->format
= format
;
669 var
->format
= variable_default_display (var
);
675 enum varobj_display_formats
676 varobj_get_display_format (struct varobj
*var
)
682 varobj_get_num_children (struct varobj
*var
)
684 if (var
->num_children
== -1)
685 var
->num_children
= number_of_children (var
);
687 return var
->num_children
;
690 /* Creates a list of the immediate children of a variable object;
691 the return code is the number of such children or -1 on error */
694 varobj_list_children (struct varobj
*var
, struct varobj
***childlist
)
696 struct varobj
*child
;
700 /* sanity check: have we been passed a pointer? */
701 if (childlist
== NULL
)
706 if (var
->num_children
== -1)
707 var
->num_children
= number_of_children (var
);
709 /* List of children */
710 *childlist
= xmalloc ((var
->num_children
+ 1) * sizeof (struct varobj
*));
712 for (i
= 0; i
< var
->num_children
; i
++)
714 /* Mark as the end in case we bail out */
715 *((*childlist
) + i
) = NULL
;
717 /* check if child exists, if not create */
718 name
= name_of_child (var
, i
);
719 child
= child_exists (var
, name
);
721 child
= create_child (var
, i
, name
);
723 *((*childlist
) + i
) = child
;
726 /* End of list is marked by a NULL pointer */
727 *((*childlist
) + i
) = NULL
;
729 return var
->num_children
;
732 /* Obtain the type of an object Variable as a string similar to the one gdb
733 prints on the console */
736 varobj_get_type (struct varobj
*var
)
739 struct cleanup
*old_chain
;
744 /* For the "fake" variables, do not return a type. (It's type is
746 if (CPLUS_FAKE_CHILD (var
))
749 stb
= mem_fileopen ();
750 old_chain
= make_cleanup_ui_file_delete (stb
);
752 /* To print the type, we simply create a zero ``struct value *'' and
753 cast it to our type. We then typeprint this variable. */
754 val
= value_zero (var
->type
, not_lval
);
755 type_print (value_type (val
), "", stb
, -1);
757 thetype
= ui_file_xstrdup (stb
, &length
);
758 do_cleanups (old_chain
);
762 /* Obtain the type of an object variable. */
765 varobj_get_gdb_type (struct varobj
*var
)
770 enum varobj_languages
771 varobj_get_language (struct varobj
*var
)
773 return variable_language (var
);
777 varobj_get_attributes (struct varobj
*var
)
781 if (variable_editable (var
))
782 /* FIXME: define masks for attributes */
783 attributes
|= 0x00000001; /* Editable */
789 varobj_get_value (struct varobj
*var
)
791 return my_value_of_variable (var
);
794 /* Set the value of an object variable (if it is editable) to the
795 value of the given expression */
796 /* Note: Invokes functions that can call error() */
799 varobj_set_value (struct varobj
*var
, char *expression
)
805 /* The argument "expression" contains the variable's new value.
806 We need to first construct a legal expression for this -- ugh! */
807 /* Does this cover all the bases? */
808 struct expression
*exp
;
810 int saved_input_radix
= input_radix
;
812 if (var
->value
!= NULL
&& variable_editable (var
) && !var
->error
)
814 char *s
= expression
;
817 input_radix
= 10; /* ALWAYS reset to decimal temporarily */
818 exp
= parse_exp_1 (&s
, 0, 0);
819 if (!gdb_evaluate_expression (exp
, &value
))
821 /* We cannot proceed without a valid expression. */
826 /* All types that are editable must also be changeable. */
827 gdb_assert (type_changeable (var
));
829 /* The value of a changeable variable object must not be lazy. */
830 gdb_assert (!value_lazy (var
->value
));
832 /* Need to coerce the input. We want to check if the
833 value of the variable object will be different
834 after assignment, and the first thing value_assign
835 does is coerce the input.
836 For example, if we are assigning an array to a pointer variable we
837 should compare the pointer with the the array's address, not with the
839 value
= coerce_array (value
);
841 /* The new value may be lazy. gdb_value_assign, or
842 rather value_contents, will take care of this.
843 If fetching of the new value will fail, gdb_value_assign
844 with catch the exception. */
845 if (!gdb_value_assign (var
->value
, value
, &val
))
848 /* If the value has changed, record it, so that next -var-update can
849 report this change. If a variable had a value of '1', we've set it
850 to '333' and then set again to '1', when -var-update will report this
851 variable as changed -- because the first assignment has set the
852 'updated' flag. There's no need to optimize that, because return value
853 of -var-update should be considered an approximation. */
854 var
->updated
= install_new_value (var
, val
, 0 /* Compare values. */);
855 input_radix
= saved_input_radix
;
862 /* Returns a malloc'ed list with all root variable objects */
864 varobj_list (struct varobj
***varlist
)
867 struct varobj_root
*croot
;
868 int mycount
= rootcount
;
870 /* Alloc (rootcount + 1) entries for the result */
871 *varlist
= xmalloc ((rootcount
+ 1) * sizeof (struct varobj
*));
875 while ((croot
!= NULL
) && (mycount
> 0))
877 *cv
= croot
->rootvar
;
882 /* Mark the end of the list */
885 if (mycount
|| (croot
!= NULL
))
887 ("varobj_list: assertion failed - wrong tally of root vars (%d:%d)",
893 /* Assign a new value to a variable object. If INITIAL is non-zero,
894 this is the first assignement after the variable object was just
895 created, or changed type. In that case, just assign the value
897 Otherwise, assign the value and if type_changeable returns non-zero,
898 find if the new value is different from the current value.
899 Return 1 if so, and 0 if the values are equal.
901 The VALUE parameter should not be released -- the function will
902 take care of releasing it when needed. */
904 install_new_value (struct varobj
*var
, struct value
*value
, int initial
)
911 /* We need to know the varobj's type to decide if the value should
912 be fetched or not. C++ fake children (public/protected/private) don't have
914 gdb_assert (var
->type
|| CPLUS_FAKE_CHILD (var
));
915 changeable
= type_changeable (var
);
916 need_to_fetch
= changeable
;
918 /* We are not interested in the address of references, and given
919 that in C++ a reference is not rebindable, it cannot
920 meaningfully change. So, get hold of the real value. */
923 value
= coerce_ref (value
);
924 release_value (value
);
927 if (var
->type
&& TYPE_CODE (var
->type
) == TYPE_CODE_UNION
)
928 /* For unions, we need to fetch the value implicitly because
929 of implementation of union member fetch. When gdb
930 creates a value for a field and the value of the enclosing
931 structure is not lazy, it immediately copies the necessary
932 bytes from the enclosing values. If the enclosing value is
933 lazy, the call to value_fetch_lazy on the field will read
934 the data from memory. For unions, that means we'll read the
935 same memory more than once, which is not desirable. So
939 /* The new value might be lazy. If the type is changeable,
940 that is we'll be comparing values of this type, fetch the
941 value now. Otherwise, on the next update the old value
942 will be lazy, which means we've lost that old value. */
943 if (need_to_fetch
&& value
&& value_lazy (value
))
945 if (!gdb_value_fetch_lazy (value
))
948 /* Set the value to NULL, so that for the next -var-update,
949 we don't try to compare the new value with this value,
950 that we couldn't even read. */
957 /* If the type is changeable, compare the old and the new values.
958 If this is the initial assignment, we don't have any old value
960 if (!initial
&& changeable
)
962 /* If the value of the varobj was changed by -var-set-value, then the
963 value in the varobj and in the target is the same. However, that value
964 is different from the value that the varobj had after the previous
965 -var-update. So need to the varobj as changed. */
970 /* Try to compare the values. That requires that both
971 values are non-lazy. */
973 /* Quick comparison of NULL values. */
974 if (var
->value
== NULL
&& value
== NULL
)
977 else if (var
->value
== NULL
|| value
== NULL
)
981 gdb_assert (!value_lazy (var
->value
));
982 gdb_assert (!value_lazy (value
));
984 if (!value_contents_equal (var
->value
, value
))
990 /* We must always keep the new value, since children depend on it. */
991 if (var
->value
!= NULL
)
992 value_free (var
->value
);
996 gdb_assert (!var
->value
|| value_type (var
->value
));
1002 /* Update the values for a variable and its children. This is a
1003 two-pronged attack. First, re-parse the value for the root's
1004 expression to see if it's changed. Then go all the way
1005 through its children, reconstructing them and noting if they've
1008 -1 if there was an error updating the varobj
1009 -2 if the type changed
1010 Otherwise it is the number of children + parent changed
1012 Only root variables can be updated...
1014 NOTE: This function may delete the caller's varobj. If it
1015 returns -2, then it has done this and VARP will be modified
1016 to point to the new varobj. */
1019 varobj_update (struct varobj
**varp
, struct varobj
***changelist
)
1028 struct varobj
**templist
= NULL
;
1030 struct vstack
*stack
= NULL
;
1031 struct vstack
*result
= NULL
;
1032 struct frame_id old_fid
;
1033 struct frame_info
*fi
;
1035 /* sanity check: have we been passed a pointer? */
1036 if (changelist
== NULL
)
1039 /* Only root variables can be updated... */
1040 if ((*varp
)->root
->rootvar
!= *varp
)
1041 /* Not a root var */
1044 /* Save the selected stack frame, since we will need to change it
1045 in order to evaluate expressions. */
1046 old_fid
= get_frame_id (deprecated_selected_frame
);
1048 /* Update the root variable. value_of_root can return NULL
1049 if the variable is no longer around, i.e. we stepped out of
1050 the frame in which a local existed. We are letting the
1051 value_of_root variable dispose of the varobj if the type
1054 new = value_of_root (varp
, &type_changed
);
1061 /* Initialize a stack for temporary results */
1062 vpush (&result
, NULL
);
1064 /* If this is a "use_selected_frame" varobj, and its type has changed,
1065 them note that it's changed. */
1068 vpush (&result
, *varp
);
1072 if (install_new_value ((*varp
), new, type_changed
))
1074 /* If type_changed is 1, install_new_value will never return
1075 non-zero, so we'll never report the same variable twice. */
1076 gdb_assert (!type_changed
);
1077 vpush (&result
, (*varp
));
1081 /* Initialize a stack */
1082 vpush (&stack
, NULL
);
1084 /* Push the root's children */
1085 if ((*varp
)->children
!= NULL
)
1087 struct varobj_child
*c
;
1088 for (c
= (*varp
)->children
; c
!= NULL
; c
= c
->next
)
1089 vpush (&stack
, c
->child
);
1092 /* Walk through the children, reconstructing them all. */
1096 /* Push any children */
1097 if (v
->children
!= NULL
)
1099 struct varobj_child
*c
;
1100 for (c
= v
->children
; c
!= NULL
; c
= c
->next
)
1101 vpush (&stack
, c
->child
);
1104 /* Update this variable */
1105 new = value_of_child (v
->parent
, v
->index
);
1106 if (install_new_value (v
, new, 0 /* type not changed */))
1108 /* Note that it's changed */
1114 /* Get next child */
1118 /* Alloc (changed + 1) list entries */
1119 /* FIXME: add a cleanup for the allocated list(s)
1120 because one day the select_frame called below can longjump */
1121 *changelist
= xmalloc ((changed
+ 1) * sizeof (struct varobj
*));
1124 templist
= xmalloc ((changed
+ 1) * sizeof (struct varobj
*));
1130 /* Copy from result stack to list */
1132 *cv
= vpop (&result
);
1133 while ((*cv
!= NULL
) && (vleft
> 0))
1137 *cv
= vpop (&result
);
1140 warning (_("varobj_update: assertion failed - vleft <> 0"));
1144 /* Now we revert the order. */
1145 for (i
= 0; i
< changed
; i
++)
1146 *(*changelist
+ i
) = *(templist
+ changed
- 1 - i
);
1147 *(*changelist
+ changed
) = NULL
;
1150 /* Restore selected frame */
1151 fi
= frame_find_by_id (old_fid
);
1162 /* Helper functions */
1165 * Variable object construction/destruction
1169 delete_variable (struct cpstack
**resultp
, struct varobj
*var
,
1170 int only_children_p
)
1174 delete_variable_1 (resultp
, &delcount
, var
,
1175 only_children_p
, 1 /* remove_from_parent_p */ );
1180 /* Delete the variable object VAR and its children */
1181 /* IMPORTANT NOTE: If we delete a variable which is a child
1182 and the parent is not removed we dump core. It must be always
1183 initially called with remove_from_parent_p set */
1185 delete_variable_1 (struct cpstack
**resultp
, int *delcountp
,
1186 struct varobj
*var
, int only_children_p
,
1187 int remove_from_parent_p
)
1189 struct varobj_child
*vc
;
1190 struct varobj_child
*next
;
1192 /* Delete any children of this variable, too. */
1193 for (vc
= var
->children
; vc
!= NULL
; vc
= next
)
1195 if (!remove_from_parent_p
)
1196 vc
->child
->parent
= NULL
;
1197 delete_variable_1 (resultp
, delcountp
, vc
->child
, 0, only_children_p
);
1202 /* if we were called to delete only the children we are done here */
1203 if (only_children_p
)
1206 /* Otherwise, add it to the list of deleted ones and proceed to do so */
1207 /* If the name is null, this is a temporary variable, that has not
1208 yet been installed, don't report it, it belongs to the caller... */
1209 if (var
->obj_name
!= NULL
)
1211 cppush (resultp
, xstrdup (var
->obj_name
));
1212 *delcountp
= *delcountp
+ 1;
1215 /* If this variable has a parent, remove it from its parent's list */
1216 /* OPTIMIZATION: if the parent of this variable is also being deleted,
1217 (as indicated by remove_from_parent_p) we don't bother doing an
1218 expensive list search to find the element to remove when we are
1219 discarding the list afterwards */
1220 if ((remove_from_parent_p
) && (var
->parent
!= NULL
))
1222 remove_child_from_parent (var
->parent
, var
);
1225 if (var
->obj_name
!= NULL
)
1226 uninstall_variable (var
);
1228 /* Free memory associated with this variable */
1229 free_variable (var
);
1232 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
1234 install_variable (struct varobj
*var
)
1237 struct vlist
*newvl
;
1239 unsigned int index
= 0;
1242 for (chp
= var
->obj_name
; *chp
; chp
++)
1244 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
1247 cv
= *(varobj_table
+ index
);
1248 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
1252 error (_("Duplicate variable object name"));
1254 /* Add varobj to hash table */
1255 newvl
= xmalloc (sizeof (struct vlist
));
1256 newvl
->next
= *(varobj_table
+ index
);
1258 *(varobj_table
+ index
) = newvl
;
1260 /* If root, add varobj to root list */
1261 if (var
->root
->rootvar
== var
)
1263 /* Add to list of root variables */
1264 if (rootlist
== NULL
)
1265 var
->root
->next
= NULL
;
1267 var
->root
->next
= rootlist
;
1268 rootlist
= var
->root
;
1275 /* Unistall the object VAR. */
1277 uninstall_variable (struct varobj
*var
)
1281 struct varobj_root
*cr
;
1282 struct varobj_root
*prer
;
1284 unsigned int index
= 0;
1287 /* Remove varobj from hash table */
1288 for (chp
= var
->obj_name
; *chp
; chp
++)
1290 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
1293 cv
= *(varobj_table
+ index
);
1295 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
1302 fprintf_unfiltered (gdb_stdlog
, "Deleting %s\n", var
->obj_name
);
1307 ("Assertion failed: Could not find variable object \"%s\" to delete",
1313 *(varobj_table
+ index
) = cv
->next
;
1315 prev
->next
= cv
->next
;
1319 /* If root, remove varobj from root list */
1320 if (var
->root
->rootvar
== var
)
1322 /* Remove from list of root variables */
1323 if (rootlist
== var
->root
)
1324 rootlist
= var
->root
->next
;
1329 while ((cr
!= NULL
) && (cr
->rootvar
!= var
))
1337 ("Assertion failed: Could not find varobj \"%s\" in root list",
1344 prer
->next
= cr
->next
;
1351 /* Does a child with the name NAME exist in VAR? If so, return its data.
1352 If not, return NULL. */
1353 static struct varobj
*
1354 child_exists (struct varobj
*var
, char *name
)
1356 struct varobj_child
*vc
;
1358 for (vc
= var
->children
; vc
!= NULL
; vc
= vc
->next
)
1360 if (strcmp (vc
->child
->name
, name
) == 0)
1367 /* Create and install a child of the parent of the given name */
1368 static struct varobj
*
1369 create_child (struct varobj
*parent
, int index
, char *name
)
1371 struct varobj
*child
;
1373 struct value
*value
;
1375 child
= new_variable ();
1377 /* name is allocated by name_of_child */
1379 child
->index
= index
;
1380 value
= value_of_child (parent
, index
);
1381 child
->parent
= parent
;
1382 child
->root
= parent
->root
;
1383 childs_name
= xstrprintf ("%s.%s", parent
->obj_name
, name
);
1384 child
->obj_name
= childs_name
;
1385 install_variable (child
);
1387 /* Save a pointer to this child in the parent */
1388 save_child_in_parent (parent
, child
);
1390 /* Compute the type of the child. Must do this before
1391 calling install_new_value. */
1393 /* If the child had no evaluation errors, var->value
1394 will be non-NULL and contain a valid type. */
1395 child
->type
= value_type (value
);
1397 /* Otherwise, we must compute the type. */
1398 child
->type
= (*child
->root
->lang
->type_of_child
) (child
->parent
,
1400 install_new_value (child
, value
, 1);
1402 if ((!CPLUS_FAKE_CHILD (child
) && child
->value
== NULL
) || parent
->error
)
1408 /* FIXME: This should be a generic add to list */
1409 /* Save CHILD in the PARENT's data. */
1411 save_child_in_parent (struct varobj
*parent
, struct varobj
*child
)
1413 struct varobj_child
*vc
;
1415 /* Insert the child at the top */
1416 vc
= parent
->children
;
1418 (struct varobj_child
*) xmalloc (sizeof (struct varobj_child
));
1420 parent
->children
->next
= vc
;
1421 parent
->children
->child
= child
;
1424 /* FIXME: This should be a generic remove from list */
1425 /* Remove the CHILD from the PARENT's list of children. */
1427 remove_child_from_parent (struct varobj
*parent
, struct varobj
*child
)
1429 struct varobj_child
*vc
, *prev
;
1431 /* Find the child in the parent's list */
1433 for (vc
= parent
->children
; vc
!= NULL
;)
1435 if (vc
->child
== child
)
1442 parent
->children
= vc
->next
;
1444 prev
->next
= vc
->next
;
1450 * Miscellaneous utility functions.
1453 /* Allocate memory and initialize a new variable */
1454 static struct varobj
*
1459 var
= (struct varobj
*) xmalloc (sizeof (struct varobj
));
1461 var
->obj_name
= NULL
;
1466 var
->num_children
= -1;
1468 var
->children
= NULL
;
1476 /* Allocate memory and initialize a new root variable */
1477 static struct varobj
*
1478 new_root_variable (void)
1480 struct varobj
*var
= new_variable ();
1481 var
->root
= (struct varobj_root
*) xmalloc (sizeof (struct varobj_root
));;
1482 var
->root
->lang
= NULL
;
1483 var
->root
->exp
= NULL
;
1484 var
->root
->valid_block
= NULL
;
1485 var
->root
->frame
= null_frame_id
;
1486 var
->root
->use_selected_frame
= 0;
1487 var
->root
->rootvar
= NULL
;
1492 /* Free any allocated memory associated with VAR. */
1494 free_variable (struct varobj
*var
)
1496 /* Free the expression if this is a root variable. */
1497 if (var
->root
->rootvar
== var
)
1499 free_current_contents (&var
->root
->exp
);
1504 xfree (var
->obj_name
);
1509 do_free_variable_cleanup (void *var
)
1511 free_variable (var
);
1514 static struct cleanup
*
1515 make_cleanup_free_variable (struct varobj
*var
)
1517 return make_cleanup (do_free_variable_cleanup
, var
);
1520 /* This returns the type of the variable. It also skips past typedefs
1521 to return the real type of the variable.
1523 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
1524 except within get_target_type and get_type. */
1525 static struct type
*
1526 get_type (struct varobj
*var
)
1532 type
= check_typedef (type
);
1537 /* This returns the type of the variable, dereferencing pointers, too. */
1538 static struct type
*
1539 get_type_deref (struct varobj
*var
)
1543 type
= get_type (var
);
1545 if (type
!= NULL
&& (TYPE_CODE (type
) == TYPE_CODE_PTR
1546 || TYPE_CODE (type
) == TYPE_CODE_REF
))
1547 type
= get_target_type (type
);
1552 /* This returns the target type (or NULL) of TYPE, also skipping
1553 past typedefs, just like get_type ().
1555 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
1556 except within get_target_type and get_type. */
1557 static struct type
*
1558 get_target_type (struct type
*type
)
1562 type
= TYPE_TARGET_TYPE (type
);
1564 type
= check_typedef (type
);
1570 /* What is the default display for this variable? We assume that
1571 everything is "natural". Any exceptions? */
1572 static enum varobj_display_formats
1573 variable_default_display (struct varobj
*var
)
1575 return FORMAT_NATURAL
;
1578 /* FIXME: The following should be generic for any pointer */
1580 vpush (struct vstack
**pstack
, struct varobj
*var
)
1584 s
= (struct vstack
*) xmalloc (sizeof (struct vstack
));
1590 /* FIXME: The following should be generic for any pointer */
1591 static struct varobj
*
1592 vpop (struct vstack
**pstack
)
1597 if ((*pstack
)->var
== NULL
&& (*pstack
)->next
== NULL
)
1602 *pstack
= (*pstack
)->next
;
1608 /* FIXME: The following should be generic for any pointer */
1610 cppush (struct cpstack
**pstack
, char *name
)
1614 s
= (struct cpstack
*) xmalloc (sizeof (struct cpstack
));
1620 /* FIXME: The following should be generic for any pointer */
1622 cppop (struct cpstack
**pstack
)
1627 if ((*pstack
)->name
== NULL
&& (*pstack
)->next
== NULL
)
1632 *pstack
= (*pstack
)->next
;
1639 * Language-dependencies
1642 /* Common entry points */
1644 /* Get the language of variable VAR. */
1645 static enum varobj_languages
1646 variable_language (struct varobj
*var
)
1648 enum varobj_languages lang
;
1650 switch (var
->root
->exp
->language_defn
->la_language
)
1656 case language_cplus
:
1667 /* Return the number of children for a given variable.
1668 The result of this function is defined by the language
1669 implementation. The number of children returned by this function
1670 is the number of children that the user will see in the variable
1673 number_of_children (struct varobj
*var
)
1675 return (*var
->root
->lang
->number_of_children
) (var
);;
1678 /* What is the expression for the root varobj VAR? Returns a malloc'd string. */
1680 name_of_variable (struct varobj
*var
)
1682 return (*var
->root
->lang
->name_of_variable
) (var
);
1685 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd string. */
1687 name_of_child (struct varobj
*var
, int index
)
1689 return (*var
->root
->lang
->name_of_child
) (var
, index
);
1692 /* What is the ``struct value *'' of the root variable VAR?
1693 TYPE_CHANGED controls what to do if the type of a
1694 use_selected_frame = 1 variable changes. On input,
1695 TYPE_CHANGED = 1 means discard the old varobj, and replace
1696 it with this one. TYPE_CHANGED = 0 means leave it around.
1697 NB: In both cases, var_handle will point to the new varobj,
1698 so if you use TYPE_CHANGED = 0, you will have to stash the
1699 old varobj pointer away somewhere before calling this.
1700 On return, TYPE_CHANGED will be 1 if the type has changed, and
1702 static struct value
*
1703 value_of_root (struct varobj
**var_handle
, int *type_changed
)
1707 if (var_handle
== NULL
)
1712 /* This should really be an exception, since this should
1713 only get called with a root variable. */
1715 if (var
->root
->rootvar
!= var
)
1718 if (var
->root
->use_selected_frame
)
1720 struct varobj
*tmp_var
;
1721 char *old_type
, *new_type
;
1722 old_type
= varobj_get_type (var
);
1723 tmp_var
= varobj_create (NULL
, var
->name
, (CORE_ADDR
) 0,
1724 USE_SELECTED_FRAME
);
1725 if (tmp_var
== NULL
)
1729 new_type
= varobj_get_type (tmp_var
);
1730 if (strcmp (old_type
, new_type
) == 0)
1732 varobj_delete (tmp_var
, NULL
, 0);
1740 savestring (var
->obj_name
, strlen (var
->obj_name
));
1741 varobj_delete (var
, NULL
, 0);
1745 tmp_var
->obj_name
= varobj_gen_name ();
1747 install_variable (tmp_var
);
1748 *var_handle
= tmp_var
;
1758 return (*var
->root
->lang
->value_of_root
) (var_handle
);
1761 /* What is the ``struct value *'' for the INDEX'th child of PARENT? */
1762 static struct value
*
1763 value_of_child (struct varobj
*parent
, int index
)
1765 struct value
*value
;
1767 value
= (*parent
->root
->lang
->value_of_child
) (parent
, index
);
1772 /* Is this variable editable? Use the variable's type to make
1773 this determination. */
1775 variable_editable (struct varobj
*var
)
1777 return (*var
->root
->lang
->variable_editable
) (var
);
1780 /* GDB already has a command called "value_of_variable". Sigh. */
1782 my_value_of_variable (struct varobj
*var
)
1784 return (*var
->root
->lang
->value_of_variable
) (var
);
1787 /* Return non-zero if changes in value of VAR
1788 must be detected and reported by -var-update.
1789 Return zero is -var-update should never report
1790 changes of such values. This makes sense for structures
1791 (since the changes in children values will be reported separately),
1792 or for artifical objects (like 'public' pseudo-field in C++).
1794 Return value of 0 means that gdb need not call value_fetch_lazy
1795 for the value of this variable object. */
1797 type_changeable (struct varobj
*var
)
1802 if (CPLUS_FAKE_CHILD (var
))
1805 type
= get_type (var
);
1807 switch (TYPE_CODE (type
))
1809 case TYPE_CODE_STRUCT
:
1810 case TYPE_CODE_UNION
:
1811 case TYPE_CODE_ARRAY
:
1824 c_number_of_children (struct varobj
*var
)
1827 struct type
*target
;
1830 type
= get_type (var
);
1831 target
= get_target_type (type
);
1834 switch (TYPE_CODE (type
))
1836 case TYPE_CODE_ARRAY
:
1837 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (target
) > 0
1838 && TYPE_ARRAY_UPPER_BOUND_TYPE (type
) != BOUND_CANNOT_BE_DETERMINED
)
1839 children
= TYPE_LENGTH (type
) / TYPE_LENGTH (target
);
1844 case TYPE_CODE_STRUCT
:
1845 case TYPE_CODE_UNION
:
1846 children
= TYPE_NFIELDS (type
);
1850 /* This is where things get compilcated. All pointers have one child.
1851 Except, of course, for struct and union ptr, which we automagically
1852 dereference for the user and function ptrs, which have no children.
1853 We also don't dereference void* as we don't know what to show.
1854 We can show char* so we allow it to be dereferenced. If you decide
1855 to test for it, please mind that a little magic is necessary to
1856 properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
1857 TYPE_NAME == "char" */
1859 switch (TYPE_CODE (target
))
1861 case TYPE_CODE_STRUCT
:
1862 case TYPE_CODE_UNION
:
1863 children
= TYPE_NFIELDS (target
);
1866 case TYPE_CODE_FUNC
:
1867 case TYPE_CODE_VOID
:
1877 /* Other types have no children */
1885 c_name_of_variable (struct varobj
*parent
)
1887 return savestring (parent
->name
, strlen (parent
->name
));
1891 c_name_of_child (struct varobj
*parent
, int index
)
1894 struct type
*target
;
1898 type
= get_type (parent
);
1899 target
= get_target_type (type
);
1901 switch (TYPE_CODE (type
))
1903 case TYPE_CODE_ARRAY
:
1904 name
= xstrprintf ("%d", index
1905 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
)));
1908 case TYPE_CODE_STRUCT
:
1909 case TYPE_CODE_UNION
:
1910 string
= TYPE_FIELD_NAME (type
, index
);
1911 name
= savestring (string
, strlen (string
));
1915 switch (TYPE_CODE (target
))
1917 case TYPE_CODE_STRUCT
:
1918 case TYPE_CODE_UNION
:
1919 string
= TYPE_FIELD_NAME (target
, index
);
1920 name
= savestring (string
, strlen (string
));
1924 name
= xstrprintf ("*%s", parent
->name
);
1930 /* This should not happen */
1931 name
= xstrdup ("???");
1937 static struct value
*
1938 c_value_of_root (struct varobj
**var_handle
)
1940 struct value
*new_val
;
1941 struct varobj
*var
= *var_handle
;
1942 struct frame_info
*fi
;
1945 /* Only root variables can be updated... */
1946 if (var
->root
->rootvar
!= var
)
1947 /* Not a root var */
1951 /* Determine whether the variable is still around. */
1952 if (var
->root
->valid_block
== NULL
)
1956 reinit_frame_cache ();
1957 fi
= frame_find_by_id (var
->root
->frame
);
1958 within_scope
= fi
!= NULL
;
1959 /* FIXME: select_frame could fail */
1966 /* We need to catch errors here, because if evaluate
1967 expression fails we just want to make val->error = 1 and
1969 if (gdb_evaluate_expression (var
->root
->exp
, &new_val
))
1972 release_value (new_val
);
1983 static struct value
*
1984 c_value_of_child (struct varobj
*parent
, int index
)
1986 struct value
*value
;
1988 struct value
*indval
;
1989 struct type
*type
, *target
;
1993 type
= get_type (parent
);
1994 target
= get_target_type (type
);
1995 name
= name_of_child (parent
, index
);
1996 temp
= parent
->value
;
2001 switch (TYPE_CODE (type
))
2003 case TYPE_CODE_ARRAY
:
2004 real_index
= index
+ TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
2006 /* This breaks if the array lives in a (vector) register. */
2007 value
= value_slice (temp
, real_index
, 1);
2008 temp
= value_coerce_array (value
);
2009 gdb_value_ind (temp
, &value
);
2011 indval
= value_from_longest (builtin_type_int
, (LONGEST
) real_index
);
2012 gdb_value_subscript (temp
, indval
, &value
);
2016 case TYPE_CODE_STRUCT
:
2017 case TYPE_CODE_UNION
:
2018 gdb_value_struct_elt (NULL
, &value
, &temp
, NULL
, name
, NULL
,
2023 switch (TYPE_CODE (target
))
2025 case TYPE_CODE_STRUCT
:
2026 case TYPE_CODE_UNION
:
2027 gdb_value_struct_elt (NULL
, &value
, &temp
, NULL
, name
, NULL
,
2032 gdb_value_ind (temp
, &value
);
2043 release_value (value
);
2049 static struct type
*
2050 c_type_of_child (struct varobj
*parent
, int index
)
2053 char *name
= name_of_child (parent
, index
);
2055 switch (TYPE_CODE (parent
->type
))
2057 case TYPE_CODE_ARRAY
:
2058 type
= get_target_type (parent
->type
);
2061 case TYPE_CODE_STRUCT
:
2062 case TYPE_CODE_UNION
:
2063 type
= lookup_struct_elt_type (parent
->type
, name
, 0);
2067 switch (TYPE_CODE (get_target_type (parent
->type
)))
2069 case TYPE_CODE_STRUCT
:
2070 case TYPE_CODE_UNION
:
2071 type
= lookup_struct_elt_type (parent
->type
, name
, 0);
2075 type
= get_target_type (parent
->type
);
2081 /* This should not happen as only the above types have children */
2082 warning (_("Child of parent whose type does not allow children"));
2083 /* FIXME: Can we still go on? */
2093 c_variable_editable (struct varobj
*var
)
2095 switch (TYPE_CODE (get_type (var
)))
2097 case TYPE_CODE_STRUCT
:
2098 case TYPE_CODE_UNION
:
2099 case TYPE_CODE_ARRAY
:
2100 case TYPE_CODE_FUNC
:
2101 case TYPE_CODE_MEMBER
:
2102 case TYPE_CODE_METHOD
:
2113 c_value_of_variable (struct varobj
*var
)
2115 /* BOGUS: if val_print sees a struct/class, or a reference to one,
2116 it will print out its children instead of "{...}". So we need to
2117 catch that case explicitly. */
2118 struct type
*type
= get_type (var
);
2120 /* Strip top-level references. */
2121 while (TYPE_CODE (type
) == TYPE_CODE_REF
)
2122 type
= check_typedef (TYPE_TARGET_TYPE (type
));
2124 switch (TYPE_CODE (type
))
2126 case TYPE_CODE_STRUCT
:
2127 case TYPE_CODE_UNION
:
2128 return xstrdup ("{...}");
2131 case TYPE_CODE_ARRAY
:
2134 number
= xstrprintf ("[%d]", var
->num_children
);
2141 if (var
->value
== NULL
)
2143 /* This can happen if we attempt to get the value of a struct
2144 member when the parent is an invalid pointer. This is an
2145 error condition, so we should tell the caller. */
2151 struct ui_file
*stb
= mem_fileopen ();
2152 struct cleanup
*old_chain
= make_cleanup_ui_file_delete (stb
);
2155 gdb_assert (type_changeable (var
));
2156 gdb_assert (!value_lazy (var
->value
));
2157 common_val_print (var
->value
, stb
,
2158 format_code
[(int) var
->format
], 1, 0, 0);
2159 thevalue
= ui_file_xstrdup (stb
, &dummy
);
2160 do_cleanups (old_chain
);
2171 cplus_number_of_children (struct varobj
*var
)
2174 int children
, dont_know
;
2179 if (!CPLUS_FAKE_CHILD (var
))
2181 type
= get_type_deref (var
);
2183 if (((TYPE_CODE (type
)) == TYPE_CODE_STRUCT
) ||
2184 ((TYPE_CODE (type
)) == TYPE_CODE_UNION
))
2188 cplus_class_num_children (type
, kids
);
2189 if (kids
[v_public
] != 0)
2191 if (kids
[v_private
] != 0)
2193 if (kids
[v_protected
] != 0)
2196 /* Add any baseclasses */
2197 children
+= TYPE_N_BASECLASSES (type
);
2200 /* FIXME: save children in var */
2207 type
= get_type_deref (var
->parent
);
2209 cplus_class_num_children (type
, kids
);
2210 if (strcmp (var
->name
, "public") == 0)
2211 children
= kids
[v_public
];
2212 else if (strcmp (var
->name
, "private") == 0)
2213 children
= kids
[v_private
];
2215 children
= kids
[v_protected
];
2220 children
= c_number_of_children (var
);
2225 /* Compute # of public, private, and protected variables in this class.
2226 That means we need to descend into all baseclasses and find out
2227 how many are there, too. */
2229 cplus_class_num_children (struct type
*type
, int children
[3])
2233 children
[v_public
] = 0;
2234 children
[v_private
] = 0;
2235 children
[v_protected
] = 0;
2237 for (i
= TYPE_N_BASECLASSES (type
); i
< TYPE_NFIELDS (type
); i
++)
2239 /* If we have a virtual table pointer, omit it. */
2240 if (TYPE_VPTR_BASETYPE (type
) == type
&& TYPE_VPTR_FIELDNO (type
) == i
)
2243 if (TYPE_FIELD_PROTECTED (type
, i
))
2244 children
[v_protected
]++;
2245 else if (TYPE_FIELD_PRIVATE (type
, i
))
2246 children
[v_private
]++;
2248 children
[v_public
]++;
2253 cplus_name_of_variable (struct varobj
*parent
)
2255 return c_name_of_variable (parent
);
2259 cplus_name_of_child (struct varobj
*parent
, int index
)
2264 if (CPLUS_FAKE_CHILD (parent
))
2266 /* Looking for children of public, private, or protected. */
2267 type
= get_type_deref (parent
->parent
);
2270 type
= get_type_deref (parent
);
2273 switch (TYPE_CODE (type
))
2275 case TYPE_CODE_STRUCT
:
2276 case TYPE_CODE_UNION
:
2277 if (CPLUS_FAKE_CHILD (parent
))
2279 /* The fields of the class type are ordered as they
2280 appear in the class. We are given an index for a
2281 particular access control type ("public","protected",
2282 or "private"). We must skip over fields that don't
2283 have the access control we are looking for to properly
2284 find the indexed field. */
2285 int type_index
= TYPE_N_BASECLASSES (type
);
2286 if (strcmp (parent
->name
, "private") == 0)
2290 if (TYPE_VPTR_BASETYPE (type
) == type
2291 && type_index
== TYPE_VPTR_FIELDNO (type
))
2293 else if (TYPE_FIELD_PRIVATE (type
, type_index
))
2299 else if (strcmp (parent
->name
, "protected") == 0)
2303 if (TYPE_VPTR_BASETYPE (type
) == type
2304 && type_index
== TYPE_VPTR_FIELDNO (type
))
2306 else if (TYPE_FIELD_PROTECTED (type
, type_index
))
2316 if (TYPE_VPTR_BASETYPE (type
) == type
2317 && type_index
== TYPE_VPTR_FIELDNO (type
))
2319 else if (!TYPE_FIELD_PRIVATE (type
, type_index
) &&
2320 !TYPE_FIELD_PROTECTED (type
, type_index
))
2327 name
= TYPE_FIELD_NAME (type
, type_index
);
2329 else if (index
< TYPE_N_BASECLASSES (type
))
2330 /* We are looking up the name of a base class */
2331 name
= TYPE_FIELD_NAME (type
, index
);
2335 cplus_class_num_children(type
, children
);
2337 /* Everything beyond the baseclasses can
2338 only be "public", "private", or "protected"
2340 The special "fake" children are always output by varobj in
2341 this order. So if INDEX == 2, it MUST be "protected". */
2342 index
-= TYPE_N_BASECLASSES (type
);
2346 if (children
[v_public
] > 0)
2348 else if (children
[v_private
] > 0)
2354 if (children
[v_public
] > 0)
2356 if (children
[v_private
] > 0)
2361 else if (children
[v_private
] > 0)
2365 /* Must be protected */
2380 return c_name_of_child (parent
, index
);
2384 name
= savestring (name
, strlen (name
));
2390 static struct value
*
2391 cplus_value_of_root (struct varobj
**var_handle
)
2393 return c_value_of_root (var_handle
);
2396 static struct value
*
2397 cplus_value_of_child (struct varobj
*parent
, int index
)
2400 struct value
*value
;
2402 if (CPLUS_FAKE_CHILD (parent
))
2403 type
= get_type_deref (parent
->parent
);
2405 type
= get_type_deref (parent
);
2409 if (((TYPE_CODE (type
)) == TYPE_CODE_STRUCT
) ||
2410 ((TYPE_CODE (type
)) == TYPE_CODE_UNION
))
2412 if (CPLUS_FAKE_CHILD (parent
))
2415 struct value
*temp
= parent
->parent
->value
;
2420 name
= name_of_child (parent
, index
);
2421 gdb_value_struct_elt (NULL
, &value
, &temp
, NULL
, name
, NULL
,
2424 release_value (value
);
2428 else if (index
>= TYPE_N_BASECLASSES (type
))
2430 /* public, private, or protected */
2436 if (parent
->value
!= NULL
)
2438 struct value
*temp
= NULL
;
2440 /* No special processing for references is needed --
2441 value_cast below handles references. */
2442 if (TYPE_CODE (value_type (parent
->value
)) == TYPE_CODE_PTR
)
2444 if (!gdb_value_ind (parent
->value
, &temp
))
2448 temp
= parent
->value
;
2452 value
= value_cast (TYPE_FIELD_TYPE (type
, index
), temp
);
2453 release_value (value
);
2457 /* We failed to evaluate the parent's value, so don't even
2458 bother trying to evaluate this child. */
2466 return c_value_of_child (parent
, index
);
2471 static struct type
*
2472 cplus_type_of_child (struct varobj
*parent
, int index
)
2474 struct type
*type
, *t
;
2476 if (CPLUS_FAKE_CHILD (parent
))
2478 /* Looking for the type of a child of public, private, or protected. */
2479 t
= get_type_deref (parent
->parent
);
2482 t
= get_type_deref (parent
);
2485 switch (TYPE_CODE (t
))
2487 case TYPE_CODE_STRUCT
:
2488 case TYPE_CODE_UNION
:
2489 if (CPLUS_FAKE_CHILD (parent
))
2491 char *name
= cplus_name_of_child (parent
, index
);
2492 type
= lookup_struct_elt_type (t
, name
, 0);
2495 else if (index
< TYPE_N_BASECLASSES (t
))
2496 type
= TYPE_FIELD_TYPE (t
, index
);
2509 return c_type_of_child (parent
, index
);
2515 cplus_variable_editable (struct varobj
*var
)
2517 if (CPLUS_FAKE_CHILD (var
))
2520 return c_variable_editable (var
);
2524 cplus_value_of_variable (struct varobj
*var
)
2527 /* If we have one of our special types, don't print out
2529 if (CPLUS_FAKE_CHILD (var
))
2530 return xstrdup ("");
2532 return c_value_of_variable (var
);
2538 java_number_of_children (struct varobj
*var
)
2540 return cplus_number_of_children (var
);
2544 java_name_of_variable (struct varobj
*parent
)
2548 name
= cplus_name_of_variable (parent
);
2549 /* If the name has "-" in it, it is because we
2550 needed to escape periods in the name... */
2553 while (*p
!= '\000')
2564 java_name_of_child (struct varobj
*parent
, int index
)
2568 name
= cplus_name_of_child (parent
, index
);
2569 /* Escape any periods in the name... */
2572 while (*p
!= '\000')
2582 static struct value
*
2583 java_value_of_root (struct varobj
**var_handle
)
2585 return cplus_value_of_root (var_handle
);
2588 static struct value
*
2589 java_value_of_child (struct varobj
*parent
, int index
)
2591 return cplus_value_of_child (parent
, index
);
2594 static struct type
*
2595 java_type_of_child (struct varobj
*parent
, int index
)
2597 return cplus_type_of_child (parent
, index
);
2601 java_variable_editable (struct varobj
*var
)
2603 return cplus_variable_editable (var
);
2607 java_value_of_variable (struct varobj
*var
)
2609 return cplus_value_of_variable (var
);
2612 extern void _initialize_varobj (void);
2614 _initialize_varobj (void)
2616 int sizeof_table
= sizeof (struct vlist
*) * VAROBJ_TABLE_SIZE
;
2618 varobj_table
= xmalloc (sizeof_table
);
2619 memset (varobj_table
, 0, sizeof_table
);
2621 add_setshow_zinteger_cmd ("debugvarobj", class_maintenance
,
2623 Set varobj debugging."), _("\
2624 Show varobj debugging."), _("\
2625 When non-zero, varobj debugging is enabled."),
2628 &setlist
, &showlist
);