1 /* Implementation of the GDB variable objects API.
3 Copyright (C) 1999-2012 Free Software Foundation, Inc.
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 3 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 #include "exceptions.h"
21 #include "expression.h"
28 #include "gdb_assert.h"
29 #include "gdb_string.h"
30 #include "gdb_regex.h"
34 #include "gdbthread.h"
36 #include "ada-varobj.h"
40 #include "python/python.h"
41 #include "python/python-internal.h"
46 /* The names of varobjs representing anonymous structs or unions. */
47 #define ANONYMOUS_STRUCT_NAME _("<anonymous struct>")
48 #define ANONYMOUS_UNION_NAME _("<anonymous union>")
50 /* Non-zero if we want to see trace of varobj level stuff. */
54 show_varobjdebug (struct ui_file
*file
, int from_tty
,
55 struct cmd_list_element
*c
, const char *value
)
57 fprintf_filtered (file
, _("Varobj debugging is %s.\n"), value
);
60 /* String representations of gdb's format codes. */
61 char *varobj_format_string
[] =
62 { "natural", "binary", "decimal", "hexadecimal", "octal" };
64 /* String representations of gdb's known languages. */
65 char *varobj_language_string
[] = { "unknown", "C", "C++", "Java" };
67 /* True if we want to allow Python-based pretty-printing. */
68 static int pretty_printing
= 0;
71 varobj_enable_pretty_printing (void)
78 /* Every root variable has one of these structures saved in its
79 varobj. Members which must be free'd are noted. */
83 /* Alloc'd expression for this parent. */
84 struct expression
*exp
;
86 /* Block for which this expression is valid. */
87 struct block
*valid_block
;
89 /* The frame for this expression. This field is set iff valid_block is
91 struct frame_id frame
;
93 /* The thread ID that this varobj_root belong to. This field
94 is only valid if valid_block is not NULL.
95 When not 0, indicates which thread 'frame' belongs to.
96 When 0, indicates that the thread list was empty when the varobj_root
100 /* If 1, the -var-update always recomputes the value in the
101 current thread and frame. Otherwise, variable object is
102 always updated in the specific scope/thread/frame. */
105 /* Flag that indicates validity: set to 0 when this varobj_root refers
106 to symbols that do not exist anymore. */
109 /* Language info for this variable and its children. */
110 struct language_specific
*lang
;
112 /* The varobj for this root node. */
113 struct varobj
*rootvar
;
115 /* Next root variable */
116 struct varobj_root
*next
;
119 /* Every variable in the system has a structure of this type defined
120 for it. This structure holds all information necessary to manipulate
121 a particular object variable. Members which must be freed are noted. */
125 /* Alloc'd name of the variable for this object. If this variable is a
126 child, then this name will be the child's source name.
127 (bar, not foo.bar). */
128 /* NOTE: This is the "expression". */
131 /* Alloc'd expression for this child. Can be used to create a
132 root variable corresponding to this child. */
135 /* The alloc'd name for this variable's object. This is here for
136 convenience when constructing this object's children. */
139 /* Index of this variable in its parent or -1. */
142 /* The type of this variable. This can be NULL
143 for artifial variable objects -- currently, the "accessibility"
144 variable objects in C++. */
147 /* The value of this expression or subexpression. A NULL value
148 indicates there was an error getting this value.
149 Invariant: if varobj_value_is_changeable_p (this) is non-zero,
150 the value is either NULL, or not lazy. */
153 /* The number of (immediate) children this variable has. */
156 /* If this object is a child, this points to its immediate parent. */
157 struct varobj
*parent
;
159 /* Children of this object. */
160 VEC (varobj_p
) *children
;
162 /* Whether the children of this varobj were requested. This field is
163 used to decide if dynamic varobj should recompute their children.
164 In the event that the frontend never asked for the children, we
166 int children_requested
;
168 /* Description of the root variable. Points to root variable for
170 struct varobj_root
*root
;
172 /* The format of the output for this object. */
173 enum varobj_display_formats format
;
175 /* Was this variable updated via a varobj_set_value operation. */
178 /* Last print value. */
181 /* Is this variable frozen. Frozen variables are never implicitly
182 updated by -var-update *
183 or -var-update <direct-or-indirect-parent>. */
186 /* Is the value of this variable intentionally not fetched? It is
187 not fetched if either the variable is frozen, or any parents is
191 /* Sub-range of children which the MI consumer has requested. If
192 FROM < 0 or TO < 0, means that all children have been
197 /* The pretty-printer constructor. If NULL, then the default
198 pretty-printer will be looked up. If None, then no
199 pretty-printer will be installed. */
200 PyObject
*constructor
;
202 /* The pretty-printer that has been constructed. If NULL, then a
203 new printer object is needed, and one will be constructed. */
204 PyObject
*pretty_printer
;
206 /* The iterator returned by the printer's 'children' method, or NULL
208 PyObject
*child_iter
;
210 /* We request one extra item from the iterator, so that we can
211 report to the caller whether there are more items than we have
212 already reported. However, we don't want to install this value
213 when we read it, because that will mess up future updates. So,
214 we stash it here instead. */
215 PyObject
*saved_item
;
221 struct cpstack
*next
;
224 /* A list of varobjs */
232 /* Private function prototypes */
234 /* Helper functions for the above subcommands. */
236 static int delete_variable (struct cpstack
**, struct varobj
*, int);
238 static void delete_variable_1 (struct cpstack
**, int *,
239 struct varobj
*, int, int);
241 static int install_variable (struct varobj
*);
243 static void uninstall_variable (struct varobj
*);
245 static struct varobj
*create_child (struct varobj
*, int, char *);
247 static struct varobj
*
248 create_child_with_value (struct varobj
*parent
, int index
, const char *name
,
249 struct value
*value
);
251 /* Utility routines */
253 static struct varobj
*new_variable (void);
255 static struct varobj
*new_root_variable (void);
257 static void free_variable (struct varobj
*var
);
259 static struct cleanup
*make_cleanup_free_variable (struct varobj
*var
);
261 static struct type
*get_type (struct varobj
*var
);
263 static struct type
*get_value_type (struct varobj
*var
);
265 static struct type
*get_target_type (struct type
*);
267 static enum varobj_display_formats
variable_default_display (struct varobj
*);
269 static void cppush (struct cpstack
**pstack
, char *name
);
271 static char *cppop (struct cpstack
**pstack
);
273 static int update_type_if_necessary (struct varobj
*var
,
274 struct value
*new_value
);
276 static int install_new_value (struct varobj
*var
, struct value
*value
,
279 /* Language-specific routines. */
281 static enum varobj_languages
variable_language (struct varobj
*var
);
283 static int number_of_children (struct varobj
*);
285 static char *name_of_variable (struct varobj
*);
287 static char *name_of_child (struct varobj
*, int);
289 static struct value
*value_of_root (struct varobj
**var_handle
, int *);
291 static struct value
*value_of_child (struct varobj
*parent
, int index
);
293 static char *my_value_of_variable (struct varobj
*var
,
294 enum varobj_display_formats format
);
296 static char *value_get_print_value (struct value
*value
,
297 enum varobj_display_formats format
,
300 static int varobj_value_is_changeable_p (struct varobj
*var
);
302 static int is_root_p (struct varobj
*var
);
306 static struct varobj
*varobj_add_child (struct varobj
*var
,
308 struct value
*value
);
310 #endif /* HAVE_PYTHON */
312 static int default_value_is_changeable_p (struct varobj
*var
);
314 /* C implementation */
316 static int c_number_of_children (struct varobj
*var
);
318 static char *c_name_of_variable (struct varobj
*parent
);
320 static char *c_name_of_child (struct varobj
*parent
, int index
);
322 static char *c_path_expr_of_child (struct varobj
*child
);
324 static struct value
*c_value_of_root (struct varobj
**var_handle
);
326 static struct value
*c_value_of_child (struct varobj
*parent
, int index
);
328 static struct type
*c_type_of_child (struct varobj
*parent
, int index
);
330 static char *c_value_of_variable (struct varobj
*var
,
331 enum varobj_display_formats format
);
333 /* C++ implementation */
335 static int cplus_number_of_children (struct varobj
*var
);
337 static void cplus_class_num_children (struct type
*type
, int children
[3]);
339 static char *cplus_name_of_variable (struct varobj
*parent
);
341 static char *cplus_name_of_child (struct varobj
*parent
, int index
);
343 static char *cplus_path_expr_of_child (struct varobj
*child
);
345 static struct value
*cplus_value_of_root (struct varobj
**var_handle
);
347 static struct value
*cplus_value_of_child (struct varobj
*parent
, int index
);
349 static struct type
*cplus_type_of_child (struct varobj
*parent
, int index
);
351 static char *cplus_value_of_variable (struct varobj
*var
,
352 enum varobj_display_formats format
);
354 /* Java implementation */
356 static int java_number_of_children (struct varobj
*var
);
358 static char *java_name_of_variable (struct varobj
*parent
);
360 static char *java_name_of_child (struct varobj
*parent
, int index
);
362 static char *java_path_expr_of_child (struct varobj
*child
);
364 static struct value
*java_value_of_root (struct varobj
**var_handle
);
366 static struct value
*java_value_of_child (struct varobj
*parent
, int index
);
368 static struct type
*java_type_of_child (struct varobj
*parent
, int index
);
370 static char *java_value_of_variable (struct varobj
*var
,
371 enum varobj_display_formats format
);
373 /* Ada implementation */
375 static int ada_number_of_children (struct varobj
*var
);
377 static char *ada_name_of_variable (struct varobj
*parent
);
379 static char *ada_name_of_child (struct varobj
*parent
, int index
);
381 static char *ada_path_expr_of_child (struct varobj
*child
);
383 static struct value
*ada_value_of_root (struct varobj
**var_handle
);
385 static struct value
*ada_value_of_child (struct varobj
*parent
, int index
);
387 static struct type
*ada_type_of_child (struct varobj
*parent
, int index
);
389 static char *ada_value_of_variable (struct varobj
*var
,
390 enum varobj_display_formats format
);
392 static int ada_value_is_changeable_p (struct varobj
*var
);
394 static int ada_value_has_mutated (struct varobj
*var
, struct value
*new_val
,
395 struct type
*new_type
);
397 /* The language specific vector */
399 struct language_specific
402 /* The language of this variable. */
403 enum varobj_languages language
;
405 /* The number of children of PARENT. */
406 int (*number_of_children
) (struct varobj
* parent
);
408 /* The name (expression) of a root varobj. */
409 char *(*name_of_variable
) (struct varobj
* parent
);
411 /* The name of the INDEX'th child of PARENT. */
412 char *(*name_of_child
) (struct varobj
* parent
, int index
);
414 /* Returns the rooted expression of CHILD, which is a variable
415 obtain that has some parent. */
416 char *(*path_expr_of_child
) (struct varobj
* child
);
418 /* The ``struct value *'' of the root variable ROOT. */
419 struct value
*(*value_of_root
) (struct varobj
** root_handle
);
421 /* The ``struct value *'' of the INDEX'th child of PARENT. */
422 struct value
*(*value_of_child
) (struct varobj
* parent
, int index
);
424 /* The type of the INDEX'th child of PARENT. */
425 struct type
*(*type_of_child
) (struct varobj
* parent
, int index
);
427 /* The current value of VAR. */
428 char *(*value_of_variable
) (struct varobj
* var
,
429 enum varobj_display_formats format
);
431 /* Return non-zero if changes in value of VAR must be detected and
432 reported by -var-update. Return zero if -var-update should never
433 report changes of such values. This makes sense for structures
434 (since the changes in children values will be reported separately),
435 or for artifical objects (like 'public' pseudo-field in C++).
437 Return value of 0 means that gdb need not call value_fetch_lazy
438 for the value of this variable object. */
439 int (*value_is_changeable_p
) (struct varobj
*var
);
441 /* Return nonzero if the type of VAR has mutated.
443 VAR's value is still the varobj's previous value, while NEW_VALUE
444 is VAR's new value and NEW_TYPE is the var's new type. NEW_VALUE
445 may be NULL indicating that there is no value available (the varobj
446 may be out of scope, of may be the child of a null pointer, for
447 instance). NEW_TYPE, on the other hand, must never be NULL.
449 This function should also be able to assume that var's number of
450 children is set (not < 0).
452 Languages where types do not mutate can set this to NULL. */
453 int (*value_has_mutated
) (struct varobj
*var
, struct value
*new_value
,
454 struct type
*new_type
);
457 /* Array of known source language routines. */
458 static struct language_specific languages
[vlang_end
] = {
459 /* Unknown (try treating as C). */
462 c_number_of_children
,
465 c_path_expr_of_child
,
470 default_value_is_changeable_p
,
471 NULL
/* value_has_mutated */}
476 c_number_of_children
,
479 c_path_expr_of_child
,
484 default_value_is_changeable_p
,
485 NULL
/* value_has_mutated */}
490 cplus_number_of_children
,
491 cplus_name_of_variable
,
493 cplus_path_expr_of_child
,
495 cplus_value_of_child
,
497 cplus_value_of_variable
,
498 default_value_is_changeable_p
,
499 NULL
/* value_has_mutated */}
504 java_number_of_children
,
505 java_name_of_variable
,
507 java_path_expr_of_child
,
511 java_value_of_variable
,
512 default_value_is_changeable_p
,
513 NULL
/* value_has_mutated */},
517 ada_number_of_children
,
518 ada_name_of_variable
,
520 ada_path_expr_of_child
,
524 ada_value_of_variable
,
525 ada_value_is_changeable_p
,
526 ada_value_has_mutated
}
529 /* A little convenience enum for dealing with C++/Java. */
532 v_public
= 0, v_private
, v_protected
537 /* Mappings of varobj_display_formats enums to gdb's format codes. */
538 static int format_code
[] = { 0, 't', 'd', 'x', 'o' };
540 /* Header of the list of root variable objects. */
541 static struct varobj_root
*rootlist
;
543 /* Prime number indicating the number of buckets in the hash table. */
544 /* A prime large enough to avoid too many colisions. */
545 #define VAROBJ_TABLE_SIZE 227
547 /* Pointer to the varobj hash table (built at run time). */
548 static struct vlist
**varobj_table
;
550 /* Is the variable X one of our "fake" children? */
551 #define CPLUS_FAKE_CHILD(x) \
552 ((x) != NULL && (x)->type == NULL && (x)->value == NULL)
555 /* API Implementation */
557 is_root_p (struct varobj
*var
)
559 return (var
->root
->rootvar
== var
);
563 /* Helper function to install a Python environment suitable for
564 use during operations on VAR. */
565 static struct cleanup
*
566 varobj_ensure_python_env (struct varobj
*var
)
568 return ensure_python_env (var
->root
->exp
->gdbarch
,
569 var
->root
->exp
->language_defn
);
573 /* Creates a varobj (not its children). */
575 /* Return the full FRAME which corresponds to the given CORE_ADDR
576 or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
578 static struct frame_info
*
579 find_frame_addr_in_frame_chain (CORE_ADDR frame_addr
)
581 struct frame_info
*frame
= NULL
;
583 if (frame_addr
== (CORE_ADDR
) 0)
586 for (frame
= get_current_frame ();
588 frame
= get_prev_frame (frame
))
590 /* The CORE_ADDR we get as argument was parsed from a string GDB
591 output as $fp. This output got truncated to gdbarch_addr_bit.
592 Truncate the frame base address in the same manner before
593 comparing it against our argument. */
594 CORE_ADDR frame_base
= get_frame_base_address (frame
);
595 int addr_bit
= gdbarch_addr_bit (get_frame_arch (frame
));
597 if (addr_bit
< (sizeof (CORE_ADDR
) * HOST_CHAR_BIT
))
598 frame_base
&= ((CORE_ADDR
) 1 << addr_bit
) - 1;
600 if (frame_base
== frame_addr
)
608 varobj_create (char *objname
,
609 char *expression
, CORE_ADDR frame
, enum varobj_type type
)
612 struct cleanup
*old_chain
;
614 /* Fill out a varobj structure for the (root) variable being constructed. */
615 var
= new_root_variable ();
616 old_chain
= make_cleanup_free_variable (var
);
618 if (expression
!= NULL
)
620 struct frame_info
*fi
;
621 struct frame_id old_id
= null_frame_id
;
624 enum varobj_languages lang
;
625 struct value
*value
= NULL
;
626 volatile struct gdb_exception except
;
629 /* Parse and evaluate the expression, filling in as much of the
630 variable's data as possible. */
632 if (has_stack_frames ())
634 /* Allow creator to specify context of variable. */
635 if ((type
== USE_CURRENT_FRAME
) || (type
== USE_SELECTED_FRAME
))
636 fi
= get_selected_frame (NULL
);
638 /* FIXME: cagney/2002-11-23: This code should be doing a
639 lookup using the frame ID and not just the frame's
640 ``address''. This, of course, means an interface
641 change. However, with out that interface change ISAs,
642 such as the ia64 with its two stacks, won't work.
643 Similar goes for the case where there is a frameless
645 fi
= find_frame_addr_in_frame_chain (frame
);
650 /* frame = -2 means always use selected frame. */
651 if (type
== USE_SELECTED_FRAME
)
652 var
->root
->floating
= 1;
658 block
= get_frame_block (fi
, 0);
659 pc
= get_frame_pc (fi
);
663 innermost_block
= NULL
;
664 /* Wrap the call to parse expression, so we can
665 return a sensible error. */
666 TRY_CATCH (except
, RETURN_MASK_ERROR
)
668 var
->root
->exp
= parse_exp_1 (&p
, pc
, block
, 0);
671 if (except
.reason
< 0)
673 do_cleanups (old_chain
);
677 /* Don't allow variables to be created for types. */
678 if (var
->root
->exp
->elts
[0].opcode
== OP_TYPE
)
680 do_cleanups (old_chain
);
681 fprintf_unfiltered (gdb_stderr
, "Attempt to use a type name"
682 " as an expression.\n");
686 var
->format
= variable_default_display (var
);
687 var
->root
->valid_block
= innermost_block
;
688 var
->name
= xstrdup (expression
);
689 /* For a root var, the name and the expr are the same. */
690 var
->path_expr
= xstrdup (expression
);
692 /* When the frame is different from the current frame,
693 we must select the appropriate frame before parsing
694 the expression, otherwise the value will not be current.
695 Since select_frame is so benign, just call it for all cases. */
698 /* User could specify explicit FRAME-ADDR which was not found but
699 EXPRESSION is frame specific and we would not be able to evaluate
700 it correctly next time. With VALID_BLOCK set we must also set
701 FRAME and THREAD_ID. */
703 error (_("Failed to find the specified frame"));
705 var
->root
->frame
= get_frame_id (fi
);
706 var
->root
->thread_id
= pid_to_thread_id (inferior_ptid
);
707 old_id
= get_frame_id (get_selected_frame (NULL
));
711 /* We definitely need to catch errors here.
712 If evaluate_expression succeeds we got the value we wanted.
713 But if it fails, we still go on with a call to evaluate_type(). */
714 TRY_CATCH (except
, RETURN_MASK_ERROR
)
716 value
= evaluate_expression (var
->root
->exp
);
719 if (except
.reason
< 0)
721 /* Error getting the value. Try to at least get the
723 struct value
*type_only_value
= evaluate_type (var
->root
->exp
);
725 var
->type
= value_type (type_only_value
);
729 int real_type_found
= 0;
731 var
->type
= value_actual_type (value
, 0, &real_type_found
);
733 value
= value_cast (var
->type
, value
);
736 /* Set language info */
737 lang
= variable_language (var
);
738 var
->root
->lang
= &languages
[lang
];
740 install_new_value (var
, value
, 1 /* Initial assignment */);
742 /* Set ourselves as our root. */
743 var
->root
->rootvar
= var
;
745 /* Reset the selected frame. */
746 if (frame_id_p (old_id
))
747 select_frame (frame_find_by_id (old_id
));
750 /* If the variable object name is null, that means this
751 is a temporary variable, so don't install it. */
753 if ((var
!= NULL
) && (objname
!= NULL
))
755 var
->obj_name
= xstrdup (objname
);
757 /* If a varobj name is duplicated, the install will fail so
759 if (!install_variable (var
))
761 do_cleanups (old_chain
);
766 discard_cleanups (old_chain
);
770 /* Generates an unique name that can be used for a varobj. */
773 varobj_gen_name (void)
778 /* Generate a name for this object. */
780 obj_name
= xstrprintf ("var%d", id
);
785 /* Given an OBJNAME, returns the pointer to the corresponding varobj. Call
786 error if OBJNAME cannot be found. */
789 varobj_get_handle (char *objname
)
793 unsigned int index
= 0;
796 for (chp
= objname
; *chp
; chp
++)
798 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
801 cv
= *(varobj_table
+ index
);
802 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, objname
) != 0))
806 error (_("Variable object not found"));
811 /* Given the handle, return the name of the object. */
814 varobj_get_objname (struct varobj
*var
)
816 return var
->obj_name
;
819 /* Given the handle, return the expression represented by the object. */
822 varobj_get_expression (struct varobj
*var
)
824 return name_of_variable (var
);
827 /* Deletes a varobj and all its children if only_children == 0,
828 otherwise deletes only the children; returns a malloc'ed list of
829 all the (malloc'ed) names of the variables that have been deleted
830 (NULL terminated). */
833 varobj_delete (struct varobj
*var
, char ***dellist
, int only_children
)
837 struct cpstack
*result
= NULL
;
840 /* Initialize a stack for temporary results. */
841 cppush (&result
, NULL
);
844 /* Delete only the variable children. */
845 delcount
= delete_variable (&result
, var
, 1 /* only the children */ );
847 /* Delete the variable and all its children. */
848 delcount
= delete_variable (&result
, var
, 0 /* parent+children */ );
850 /* We may have been asked to return a list of what has been deleted. */
853 *dellist
= xmalloc ((delcount
+ 1) * sizeof (char *));
857 *cp
= cppop (&result
);
858 while ((*cp
!= NULL
) && (mycount
> 0))
862 *cp
= cppop (&result
);
865 if (mycount
|| (*cp
!= NULL
))
866 warning (_("varobj_delete: assertion failed - mycount(=%d) <> 0"),
875 /* Convenience function for varobj_set_visualizer. Instantiate a
876 pretty-printer for a given value. */
878 instantiate_pretty_printer (PyObject
*constructor
, struct value
*value
)
880 PyObject
*val_obj
= NULL
;
883 val_obj
= value_to_value_object (value
);
887 printer
= PyObject_CallFunctionObjArgs (constructor
, val_obj
, NULL
);
894 /* Set/Get variable object display format. */
896 enum varobj_display_formats
897 varobj_set_display_format (struct varobj
*var
,
898 enum varobj_display_formats format
)
905 case FORMAT_HEXADECIMAL
:
907 var
->format
= format
;
911 var
->format
= variable_default_display (var
);
914 if (varobj_value_is_changeable_p (var
)
915 && var
->value
&& !value_lazy (var
->value
))
917 xfree (var
->print_value
);
918 var
->print_value
= value_get_print_value (var
->value
, var
->format
, var
);
924 enum varobj_display_formats
925 varobj_get_display_format (struct varobj
*var
)
931 varobj_get_display_hint (struct varobj
*var
)
936 struct cleanup
*back_to
= varobj_ensure_python_env (var
);
938 if (var
->pretty_printer
)
939 result
= gdbpy_get_display_hint (var
->pretty_printer
);
941 do_cleanups (back_to
);
947 /* Return true if the varobj has items after TO, false otherwise. */
950 varobj_has_more (struct varobj
*var
, int to
)
952 if (VEC_length (varobj_p
, var
->children
) > to
)
954 return ((to
== -1 || VEC_length (varobj_p
, var
->children
) == to
)
955 && var
->saved_item
!= NULL
);
958 /* If the variable object is bound to a specific thread, that
959 is its evaluation can always be done in context of a frame
960 inside that thread, returns GDB id of the thread -- which
961 is always positive. Otherwise, returns -1. */
963 varobj_get_thread_id (struct varobj
*var
)
965 if (var
->root
->valid_block
&& var
->root
->thread_id
> 0)
966 return var
->root
->thread_id
;
972 varobj_set_frozen (struct varobj
*var
, int frozen
)
974 /* When a variable is unfrozen, we don't fetch its value.
975 The 'not_fetched' flag remains set, so next -var-update
978 We don't fetch the value, because for structures the client
979 should do -var-update anyway. It would be bad to have different
980 client-size logic for structure and other types. */
981 var
->frozen
= frozen
;
985 varobj_get_frozen (struct varobj
*var
)
990 /* A helper function that restricts a range to what is actually
991 available in a VEC. This follows the usual rules for the meaning
992 of FROM and TO -- if either is negative, the entire range is
996 restrict_range (VEC (varobj_p
) *children
, int *from
, int *to
)
998 if (*from
< 0 || *to
< 0)
1001 *to
= VEC_length (varobj_p
, children
);
1005 if (*from
> VEC_length (varobj_p
, children
))
1006 *from
= VEC_length (varobj_p
, children
);
1007 if (*to
> VEC_length (varobj_p
, children
))
1008 *to
= VEC_length (varobj_p
, children
);
1016 /* A helper for update_dynamic_varobj_children that installs a new
1017 child when needed. */
1020 install_dynamic_child (struct varobj
*var
,
1021 VEC (varobj_p
) **changed
,
1022 VEC (varobj_p
) **type_changed
,
1023 VEC (varobj_p
) **new,
1024 VEC (varobj_p
) **unchanged
,
1028 struct value
*value
)
1030 if (VEC_length (varobj_p
, var
->children
) < index
+ 1)
1032 /* There's no child yet. */
1033 struct varobj
*child
= varobj_add_child (var
, name
, value
);
1037 VEC_safe_push (varobj_p
, *new, child
);
1043 varobj_p existing
= VEC_index (varobj_p
, var
->children
, index
);
1045 int type_updated
= update_type_if_necessary (existing
, value
);
1049 VEC_safe_push (varobj_p
, *type_changed
, existing
);
1051 if (install_new_value (existing
, value
, 0))
1053 if (!type_updated
&& changed
)
1054 VEC_safe_push (varobj_p
, *changed
, existing
);
1056 else if (!type_updated
&& unchanged
)
1057 VEC_safe_push (varobj_p
, *unchanged
, existing
);
1062 dynamic_varobj_has_child_method (struct varobj
*var
)
1064 struct cleanup
*back_to
;
1065 PyObject
*printer
= var
->pretty_printer
;
1068 back_to
= varobj_ensure_python_env (var
);
1069 result
= PyObject_HasAttr (printer
, gdbpy_children_cst
);
1070 do_cleanups (back_to
);
1077 update_dynamic_varobj_children (struct varobj
*var
,
1078 VEC (varobj_p
) **changed
,
1079 VEC (varobj_p
) **type_changed
,
1080 VEC (varobj_p
) **new,
1081 VEC (varobj_p
) **unchanged
,
1083 int update_children
,
1088 struct cleanup
*back_to
;
1091 PyObject
*printer
= var
->pretty_printer
;
1093 back_to
= varobj_ensure_python_env (var
);
1096 if (!PyObject_HasAttr (printer
, gdbpy_children_cst
))
1098 do_cleanups (back_to
);
1102 if (update_children
|| !var
->child_iter
)
1104 children
= PyObject_CallMethodObjArgs (printer
, gdbpy_children_cst
,
1109 gdbpy_print_stack ();
1110 error (_("Null value returned for children"));
1113 make_cleanup_py_decref (children
);
1115 if (!PyIter_Check (children
))
1116 error (_("Returned value is not iterable"));
1118 Py_XDECREF (var
->child_iter
);
1119 var
->child_iter
= PyObject_GetIter (children
);
1120 if (!var
->child_iter
)
1122 gdbpy_print_stack ();
1123 error (_("Could not get children iterator"));
1126 Py_XDECREF (var
->saved_item
);
1127 var
->saved_item
= NULL
;
1132 i
= VEC_length (varobj_p
, var
->children
);
1134 /* We ask for one extra child, so that MI can report whether there
1135 are more children. */
1136 for (; to
< 0 || i
< to
+ 1; ++i
)
1141 /* See if there was a leftover from last time. */
1142 if (var
->saved_item
)
1144 item
= var
->saved_item
;
1145 var
->saved_item
= NULL
;
1148 item
= PyIter_Next (var
->child_iter
);
1152 /* Normal end of iteration. */
1153 if (!PyErr_Occurred ())
1156 /* If we got a memory error, just use the text as the
1158 if (PyErr_ExceptionMatches (gdbpy_gdb_memory_error
))
1160 PyObject
*type
, *value
, *trace
;
1161 char *name_str
, *value_str
;
1163 PyErr_Fetch (&type
, &value
, &trace
);
1164 value_str
= gdbpy_exception_to_string (type
, value
);
1170 gdbpy_print_stack ();
1174 name_str
= xstrprintf ("<error at %d>", i
);
1175 item
= Py_BuildValue ("(ss)", name_str
, value_str
);
1180 gdbpy_print_stack ();
1188 /* Any other kind of error. */
1189 gdbpy_print_stack ();
1194 /* We don't want to push the extra child on any report list. */
1195 if (to
< 0 || i
< to
)
1200 struct cleanup
*inner
;
1201 int can_mention
= from
< 0 || i
>= from
;
1203 inner
= make_cleanup_py_decref (item
);
1205 if (!PyArg_ParseTuple (item
, "sO", &name
, &py_v
))
1207 gdbpy_print_stack ();
1208 error (_("Invalid item from the child list"));
1211 v
= convert_value_from_python (py_v
);
1213 gdbpy_print_stack ();
1214 install_dynamic_child (var
, can_mention
? changed
: NULL
,
1215 can_mention
? type_changed
: NULL
,
1216 can_mention
? new : NULL
,
1217 can_mention
? unchanged
: NULL
,
1218 can_mention
? cchanged
: NULL
, i
, name
, v
);
1219 do_cleanups (inner
);
1223 Py_XDECREF (var
->saved_item
);
1224 var
->saved_item
= item
;
1226 /* We want to truncate the child list just before this
1235 if (i
< VEC_length (varobj_p
, var
->children
))
1240 for (j
= i
; j
< VEC_length (varobj_p
, var
->children
); ++j
)
1241 varobj_delete (VEC_index (varobj_p
, var
->children
, j
), NULL
, 0);
1242 VEC_truncate (varobj_p
, var
->children
, i
);
1245 /* If there are fewer children than requested, note that the list of
1246 children changed. */
1247 if (to
>= 0 && VEC_length (varobj_p
, var
->children
) < to
)
1250 var
->num_children
= VEC_length (varobj_p
, var
->children
);
1252 do_cleanups (back_to
);
1256 gdb_assert (0 && "should never be called if Python is not enabled");
1261 varobj_get_num_children (struct varobj
*var
)
1263 if (var
->num_children
== -1)
1265 if (var
->pretty_printer
)
1269 /* If we have a dynamic varobj, don't report -1 children.
1270 So, try to fetch some children first. */
1271 update_dynamic_varobj_children (var
, NULL
, NULL
, NULL
, NULL
, &dummy
,
1275 var
->num_children
= number_of_children (var
);
1278 return var
->num_children
>= 0 ? var
->num_children
: 0;
1281 /* Creates a list of the immediate children of a variable object;
1282 the return code is the number of such children or -1 on error. */
1285 varobj_list_children (struct varobj
*var
, int *from
, int *to
)
1288 int i
, children_changed
;
1290 var
->children_requested
= 1;
1292 if (var
->pretty_printer
)
1294 /* This, in theory, can result in the number of children changing without
1295 frontend noticing. But well, calling -var-list-children on the same
1296 varobj twice is not something a sane frontend would do. */
1297 update_dynamic_varobj_children (var
, NULL
, NULL
, NULL
, NULL
,
1298 &children_changed
, 0, 0, *to
);
1299 restrict_range (var
->children
, from
, to
);
1300 return var
->children
;
1303 if (var
->num_children
== -1)
1304 var
->num_children
= number_of_children (var
);
1306 /* If that failed, give up. */
1307 if (var
->num_children
== -1)
1308 return var
->children
;
1310 /* If we're called when the list of children is not yet initialized,
1311 allocate enough elements in it. */
1312 while (VEC_length (varobj_p
, var
->children
) < var
->num_children
)
1313 VEC_safe_push (varobj_p
, var
->children
, NULL
);
1315 for (i
= 0; i
< var
->num_children
; i
++)
1317 varobj_p existing
= VEC_index (varobj_p
, var
->children
, i
);
1319 if (existing
== NULL
)
1321 /* Either it's the first call to varobj_list_children for
1322 this variable object, and the child was never created,
1323 or it was explicitly deleted by the client. */
1324 name
= name_of_child (var
, i
);
1325 existing
= create_child (var
, i
, name
);
1326 VEC_replace (varobj_p
, var
->children
, i
, existing
);
1330 restrict_range (var
->children
, from
, to
);
1331 return var
->children
;
1336 static struct varobj
*
1337 varobj_add_child (struct varobj
*var
, const char *name
, struct value
*value
)
1339 varobj_p v
= create_child_with_value (var
,
1340 VEC_length (varobj_p
, var
->children
),
1343 VEC_safe_push (varobj_p
, var
->children
, v
);
1347 #endif /* HAVE_PYTHON */
1349 /* Obtain the type of an object Variable as a string similar to the one gdb
1350 prints on the console. */
1353 varobj_get_type (struct varobj
*var
)
1355 /* For the "fake" variables, do not return a type. (It's type is
1357 Do not return a type for invalid variables as well. */
1358 if (CPLUS_FAKE_CHILD (var
) || !var
->root
->is_valid
)
1361 return type_to_string (var
->type
);
1364 /* Obtain the type of an object variable. */
1367 varobj_get_gdb_type (struct varobj
*var
)
1372 /* Is VAR a path expression parent, i.e., can it be used to construct
1373 a valid path expression? */
1376 is_path_expr_parent (struct varobj
*var
)
1380 /* "Fake" children are not path_expr parents. */
1381 if (CPLUS_FAKE_CHILD (var
))
1384 type
= get_value_type (var
);
1386 /* Anonymous unions and structs are also not path_expr parents. */
1387 return !((TYPE_CODE (type
) == TYPE_CODE_STRUCT
1388 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
1389 && TYPE_NAME (type
) == NULL
);
1392 /* Return the path expression parent for VAR. */
1394 static struct varobj
*
1395 get_path_expr_parent (struct varobj
*var
)
1397 struct varobj
*parent
= var
;
1399 while (!is_root_p (parent
) && !is_path_expr_parent (parent
))
1400 parent
= parent
->parent
;
1405 /* Return a pointer to the full rooted expression of varobj VAR.
1406 If it has not been computed yet, compute it. */
1408 varobj_get_path_expr (struct varobj
*var
)
1410 if (var
->path_expr
!= NULL
)
1411 return var
->path_expr
;
1414 /* For root varobjs, we initialize path_expr
1415 when creating varobj, so here it should be
1417 gdb_assert (!is_root_p (var
));
1418 return (*var
->root
->lang
->path_expr_of_child
) (var
);
1422 enum varobj_languages
1423 varobj_get_language (struct varobj
*var
)
1425 return variable_language (var
);
1429 varobj_get_attributes (struct varobj
*var
)
1433 if (varobj_editable_p (var
))
1434 /* FIXME: define masks for attributes. */
1435 attributes
|= 0x00000001; /* Editable */
1441 varobj_pretty_printed_p (struct varobj
*var
)
1443 return var
->pretty_printer
!= NULL
;
1447 varobj_get_formatted_value (struct varobj
*var
,
1448 enum varobj_display_formats format
)
1450 return my_value_of_variable (var
, format
);
1454 varobj_get_value (struct varobj
*var
)
1456 return my_value_of_variable (var
, var
->format
);
1459 /* Set the value of an object variable (if it is editable) to the
1460 value of the given expression. */
1461 /* Note: Invokes functions that can call error(). */
1464 varobj_set_value (struct varobj
*var
, char *expression
)
1466 struct value
*val
= NULL
; /* Initialize to keep gcc happy. */
1467 /* The argument "expression" contains the variable's new value.
1468 We need to first construct a legal expression for this -- ugh! */
1469 /* Does this cover all the bases? */
1470 struct expression
*exp
;
1471 struct value
*value
= NULL
; /* Initialize to keep gcc happy. */
1472 int saved_input_radix
= input_radix
;
1473 char *s
= expression
;
1474 volatile struct gdb_exception except
;
1476 gdb_assert (varobj_editable_p (var
));
1478 input_radix
= 10; /* ALWAYS reset to decimal temporarily. */
1479 exp
= parse_exp_1 (&s
, 0, 0, 0);
1480 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1482 value
= evaluate_expression (exp
);
1485 if (except
.reason
< 0)
1487 /* We cannot proceed without a valid expression. */
1492 /* All types that are editable must also be changeable. */
1493 gdb_assert (varobj_value_is_changeable_p (var
));
1495 /* The value of a changeable variable object must not be lazy. */
1496 gdb_assert (!value_lazy (var
->value
));
1498 /* Need to coerce the input. We want to check if the
1499 value of the variable object will be different
1500 after assignment, and the first thing value_assign
1501 does is coerce the input.
1502 For example, if we are assigning an array to a pointer variable we
1503 should compare the pointer with the array's address, not with the
1505 value
= coerce_array (value
);
1507 /* The new value may be lazy. value_assign, or
1508 rather value_contents, will take care of this. */
1509 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1511 val
= value_assign (var
->value
, value
);
1514 if (except
.reason
< 0)
1517 /* If the value has changed, record it, so that next -var-update can
1518 report this change. If a variable had a value of '1', we've set it
1519 to '333' and then set again to '1', when -var-update will report this
1520 variable as changed -- because the first assignment has set the
1521 'updated' flag. There's no need to optimize that, because return value
1522 of -var-update should be considered an approximation. */
1523 var
->updated
= install_new_value (var
, val
, 0 /* Compare values. */);
1524 input_radix
= saved_input_radix
;
1530 /* A helper function to install a constructor function and visualizer
1534 install_visualizer (struct varobj
*var
, PyObject
*constructor
,
1535 PyObject
*visualizer
)
1537 Py_XDECREF (var
->constructor
);
1538 var
->constructor
= constructor
;
1540 Py_XDECREF (var
->pretty_printer
);
1541 var
->pretty_printer
= visualizer
;
1543 Py_XDECREF (var
->child_iter
);
1544 var
->child_iter
= NULL
;
1547 /* Install the default visualizer for VAR. */
1550 install_default_visualizer (struct varobj
*var
)
1552 /* Do not install a visualizer on a CPLUS_FAKE_CHILD. */
1553 if (CPLUS_FAKE_CHILD (var
))
1556 if (pretty_printing
)
1558 PyObject
*pretty_printer
= NULL
;
1562 pretty_printer
= gdbpy_get_varobj_pretty_printer (var
->value
);
1563 if (! pretty_printer
)
1565 gdbpy_print_stack ();
1566 error (_("Cannot instantiate printer for default visualizer"));
1570 if (pretty_printer
== Py_None
)
1572 Py_DECREF (pretty_printer
);
1573 pretty_printer
= NULL
;
1576 install_visualizer (var
, NULL
, pretty_printer
);
1580 /* Instantiate and install a visualizer for VAR using CONSTRUCTOR to
1581 make a new object. */
1584 construct_visualizer (struct varobj
*var
, PyObject
*constructor
)
1586 PyObject
*pretty_printer
;
1588 /* Do not install a visualizer on a CPLUS_FAKE_CHILD. */
1589 if (CPLUS_FAKE_CHILD (var
))
1592 Py_INCREF (constructor
);
1593 if (constructor
== Py_None
)
1594 pretty_printer
= NULL
;
1597 pretty_printer
= instantiate_pretty_printer (constructor
, var
->value
);
1598 if (! pretty_printer
)
1600 gdbpy_print_stack ();
1601 Py_DECREF (constructor
);
1602 constructor
= Py_None
;
1603 Py_INCREF (constructor
);
1606 if (pretty_printer
== Py_None
)
1608 Py_DECREF (pretty_printer
);
1609 pretty_printer
= NULL
;
1613 install_visualizer (var
, constructor
, pretty_printer
);
1616 #endif /* HAVE_PYTHON */
1618 /* A helper function for install_new_value. This creates and installs
1619 a visualizer for VAR, if appropriate. */
1622 install_new_value_visualizer (struct varobj
*var
)
1625 /* If the constructor is None, then we want the raw value. If VAR
1626 does not have a value, just skip this. */
1627 if (var
->constructor
!= Py_None
&& var
->value
)
1629 struct cleanup
*cleanup
;
1631 cleanup
= varobj_ensure_python_env (var
);
1633 if (!var
->constructor
)
1634 install_default_visualizer (var
);
1636 construct_visualizer (var
, var
->constructor
);
1638 do_cleanups (cleanup
);
1645 /* When using RTTI to determine variable type it may be changed in runtime when
1646 the variable value is changed. This function checks whether type of varobj
1647 VAR will change when a new value NEW_VALUE is assigned and if it is so
1648 updates the type of VAR. */
1651 update_type_if_necessary (struct varobj
*var
, struct value
*new_value
)
1655 struct value_print_options opts
;
1657 get_user_print_options (&opts
);
1658 if (opts
.objectprint
)
1660 struct type
*new_type
;
1661 char *curr_type_str
, *new_type_str
;
1663 new_type
= value_actual_type (new_value
, 0, 0);
1664 new_type_str
= type_to_string (new_type
);
1665 curr_type_str
= varobj_get_type (var
);
1666 if (strcmp (curr_type_str
, new_type_str
) != 0)
1668 var
->type
= new_type
;
1670 /* This information may be not valid for a new type. */
1671 varobj_delete (var
, NULL
, 1);
1672 VEC_free (varobj_p
, var
->children
);
1673 var
->num_children
= -1;
1682 /* Assign a new value to a variable object. If INITIAL is non-zero,
1683 this is the first assignement after the variable object was just
1684 created, or changed type. In that case, just assign the value
1686 Otherwise, assign the new value, and return 1 if the value is
1687 different from the current one, 0 otherwise. The comparison is
1688 done on textual representation of value. Therefore, some types
1689 need not be compared. E.g. for structures the reported value is
1690 always "{...}", so no comparison is necessary here. If the old
1691 value was NULL and new one is not, or vice versa, we always return 1.
1693 The VALUE parameter should not be released -- the function will
1694 take care of releasing it when needed. */
1696 install_new_value (struct varobj
*var
, struct value
*value
, int initial
)
1701 int intentionally_not_fetched
= 0;
1702 char *print_value
= NULL
;
1704 /* We need to know the varobj's type to decide if the value should
1705 be fetched or not. C++ fake children (public/protected/private)
1706 don't have a type. */
1707 gdb_assert (var
->type
|| CPLUS_FAKE_CHILD (var
));
1708 changeable
= varobj_value_is_changeable_p (var
);
1710 /* If the type has custom visualizer, we consider it to be always
1711 changeable. FIXME: need to make sure this behaviour will not
1712 mess up read-sensitive values. */
1713 if (var
->pretty_printer
)
1716 need_to_fetch
= changeable
;
1718 /* We are not interested in the address of references, and given
1719 that in C++ a reference is not rebindable, it cannot
1720 meaningfully change. So, get hold of the real value. */
1722 value
= coerce_ref (value
);
1724 if (var
->type
&& TYPE_CODE (var
->type
) == TYPE_CODE_UNION
)
1725 /* For unions, we need to fetch the value implicitly because
1726 of implementation of union member fetch. When gdb
1727 creates a value for a field and the value of the enclosing
1728 structure is not lazy, it immediately copies the necessary
1729 bytes from the enclosing values. If the enclosing value is
1730 lazy, the call to value_fetch_lazy on the field will read
1731 the data from memory. For unions, that means we'll read the
1732 same memory more than once, which is not desirable. So
1736 /* The new value might be lazy. If the type is changeable,
1737 that is we'll be comparing values of this type, fetch the
1738 value now. Otherwise, on the next update the old value
1739 will be lazy, which means we've lost that old value. */
1740 if (need_to_fetch
&& value
&& value_lazy (value
))
1742 struct varobj
*parent
= var
->parent
;
1743 int frozen
= var
->frozen
;
1745 for (; !frozen
&& parent
; parent
= parent
->parent
)
1746 frozen
|= parent
->frozen
;
1748 if (frozen
&& initial
)
1750 /* For variables that are frozen, or are children of frozen
1751 variables, we don't do fetch on initial assignment.
1752 For non-initial assignemnt we do the fetch, since it means we're
1753 explicitly asked to compare the new value with the old one. */
1754 intentionally_not_fetched
= 1;
1758 volatile struct gdb_exception except
;
1760 TRY_CATCH (except
, RETURN_MASK_ERROR
)
1762 value_fetch_lazy (value
);
1765 if (except
.reason
< 0)
1767 /* Set the value to NULL, so that for the next -var-update,
1768 we don't try to compare the new value with this value,
1769 that we couldn't even read. */
1775 /* Get a reference now, before possibly passing it to any Python
1776 code that might release it. */
1778 value_incref (value
);
1780 /* Below, we'll be comparing string rendering of old and new
1781 values. Don't get string rendering if the value is
1782 lazy -- if it is, the code above has decided that the value
1783 should not be fetched. */
1784 if (value
&& !value_lazy (value
) && !var
->pretty_printer
)
1785 print_value
= value_get_print_value (value
, var
->format
, var
);
1787 /* If the type is changeable, compare the old and the new values.
1788 If this is the initial assignment, we don't have any old value
1790 if (!initial
&& changeable
)
1792 /* If the value of the varobj was changed by -var-set-value,
1793 then the value in the varobj and in the target is the same.
1794 However, that value is different from the value that the
1795 varobj had after the previous -var-update. So need to the
1796 varobj as changed. */
1801 else if (! var
->pretty_printer
)
1803 /* Try to compare the values. That requires that both
1804 values are non-lazy. */
1805 if (var
->not_fetched
&& value_lazy (var
->value
))
1807 /* This is a frozen varobj and the value was never read.
1808 Presumably, UI shows some "never read" indicator.
1809 Now that we've fetched the real value, we need to report
1810 this varobj as changed so that UI can show the real
1814 else if (var
->value
== NULL
&& value
== NULL
)
1817 else if (var
->value
== NULL
|| value
== NULL
)
1823 gdb_assert (!value_lazy (var
->value
));
1824 gdb_assert (!value_lazy (value
));
1826 gdb_assert (var
->print_value
!= NULL
&& print_value
!= NULL
);
1827 if (strcmp (var
->print_value
, print_value
) != 0)
1833 if (!initial
&& !changeable
)
1835 /* For values that are not changeable, we don't compare the values.
1836 However, we want to notice if a value was not NULL and now is NULL,
1837 or vise versa, so that we report when top-level varobjs come in scope
1838 and leave the scope. */
1839 changed
= (var
->value
!= NULL
) != (value
!= NULL
);
1842 /* We must always keep the new value, since children depend on it. */
1843 if (var
->value
!= NULL
&& var
->value
!= value
)
1844 value_free (var
->value
);
1846 if (value
&& value_lazy (value
) && intentionally_not_fetched
)
1847 var
->not_fetched
= 1;
1849 var
->not_fetched
= 0;
1852 install_new_value_visualizer (var
);
1854 /* If we installed a pretty-printer, re-compare the printed version
1855 to see if the variable changed. */
1856 if (var
->pretty_printer
)
1858 xfree (print_value
);
1859 print_value
= value_get_print_value (var
->value
, var
->format
, var
);
1860 if ((var
->print_value
== NULL
&& print_value
!= NULL
)
1861 || (var
->print_value
!= NULL
&& print_value
== NULL
)
1862 || (var
->print_value
!= NULL
&& print_value
!= NULL
1863 && strcmp (var
->print_value
, print_value
) != 0))
1866 if (var
->print_value
)
1867 xfree (var
->print_value
);
1868 var
->print_value
= print_value
;
1870 gdb_assert (!var
->value
|| value_type (var
->value
));
1875 /* Return the requested range for a varobj. VAR is the varobj. FROM
1876 and TO are out parameters; *FROM and *TO will be set to the
1877 selected sub-range of VAR. If no range was selected using
1878 -var-set-update-range, then both will be -1. */
1880 varobj_get_child_range (struct varobj
*var
, int *from
, int *to
)
1886 /* Set the selected sub-range of children of VAR to start at index
1887 FROM and end at index TO. If either FROM or TO is less than zero,
1888 this is interpreted as a request for all children. */
1890 varobj_set_child_range (struct varobj
*var
, int from
, int to
)
1897 varobj_set_visualizer (struct varobj
*var
, const char *visualizer
)
1900 PyObject
*mainmod
, *globals
, *constructor
;
1901 struct cleanup
*back_to
;
1903 back_to
= varobj_ensure_python_env (var
);
1905 mainmod
= PyImport_AddModule ("__main__");
1906 globals
= PyModule_GetDict (mainmod
);
1907 Py_INCREF (globals
);
1908 make_cleanup_py_decref (globals
);
1910 constructor
= PyRun_String (visualizer
, Py_eval_input
, globals
, globals
);
1914 gdbpy_print_stack ();
1915 error (_("Could not evaluate visualizer expression: %s"), visualizer
);
1918 construct_visualizer (var
, constructor
);
1919 Py_XDECREF (constructor
);
1921 /* If there are any children now, wipe them. */
1922 varobj_delete (var
, NULL
, 1 /* children only */);
1923 var
->num_children
= -1;
1925 do_cleanups (back_to
);
1927 error (_("Python support required"));
1931 /* If NEW_VALUE is the new value of the given varobj (var), return
1932 non-zero if var has mutated. In other words, if the type of
1933 the new value is different from the type of the varobj's old
1936 NEW_VALUE may be NULL, if the varobj is now out of scope. */
1939 varobj_value_has_mutated (struct varobj
*var
, struct value
*new_value
,
1940 struct type
*new_type
)
1942 /* If we haven't previously computed the number of children in var,
1943 it does not matter from the front-end's perspective whether
1944 the type has mutated or not. For all intents and purposes,
1945 it has not mutated. */
1946 if (var
->num_children
< 0)
1949 if (var
->root
->lang
->value_has_mutated
)
1950 return var
->root
->lang
->value_has_mutated (var
, new_value
, new_type
);
1955 /* Update the values for a variable and its children. This is a
1956 two-pronged attack. First, re-parse the value for the root's
1957 expression to see if it's changed. Then go all the way
1958 through its children, reconstructing them and noting if they've
1961 The EXPLICIT parameter specifies if this call is result
1962 of MI request to update this specific variable, or
1963 result of implicit -var-update *. For implicit request, we don't
1964 update frozen variables.
1966 NOTE: This function may delete the caller's varobj. If it
1967 returns TYPE_CHANGED, then it has done this and VARP will be modified
1968 to point to the new varobj. */
1970 VEC(varobj_update_result
) *
1971 varobj_update (struct varobj
**varp
, int explicit)
1974 int type_changed
= 0;
1977 VEC (varobj_update_result
) *stack
= NULL
;
1978 VEC (varobj_update_result
) *result
= NULL
;
1980 /* Frozen means frozen -- we don't check for any change in
1981 this varobj, including its going out of scope, or
1982 changing type. One use case for frozen varobjs is
1983 retaining previously evaluated expressions, and we don't
1984 want them to be reevaluated at all. */
1985 if (!explicit && (*varp
)->frozen
)
1988 if (!(*varp
)->root
->is_valid
)
1990 varobj_update_result r
= {0};
1993 r
.status
= VAROBJ_INVALID
;
1994 VEC_safe_push (varobj_update_result
, result
, &r
);
1998 if ((*varp
)->root
->rootvar
== *varp
)
2000 varobj_update_result r
= {0};
2003 r
.status
= VAROBJ_IN_SCOPE
;
2005 /* Update the root variable. value_of_root can return NULL
2006 if the variable is no longer around, i.e. we stepped out of
2007 the frame in which a local existed. We are letting the
2008 value_of_root variable dispose of the varobj if the type
2010 new = value_of_root (varp
, &type_changed
);
2011 if (update_type_if_necessary(*varp
, new))
2014 r
.type_changed
= type_changed
;
2015 if (install_new_value ((*varp
), new, type_changed
))
2019 r
.status
= VAROBJ_NOT_IN_SCOPE
;
2020 r
.value_installed
= 1;
2022 if (r
.status
== VAROBJ_NOT_IN_SCOPE
)
2024 if (r
.type_changed
|| r
.changed
)
2025 VEC_safe_push (varobj_update_result
, result
, &r
);
2029 VEC_safe_push (varobj_update_result
, stack
, &r
);
2033 varobj_update_result r
= {0};
2036 VEC_safe_push (varobj_update_result
, stack
, &r
);
2039 /* Walk through the children, reconstructing them all. */
2040 while (!VEC_empty (varobj_update_result
, stack
))
2042 varobj_update_result r
= *(VEC_last (varobj_update_result
, stack
));
2043 struct varobj
*v
= r
.varobj
;
2045 VEC_pop (varobj_update_result
, stack
);
2047 /* Update this variable, unless it's a root, which is already
2049 if (!r
.value_installed
)
2051 struct type
*new_type
;
2053 new = value_of_child (v
->parent
, v
->index
);
2054 if (update_type_if_necessary(v
, new))
2057 new_type
= value_type (new);
2059 new_type
= v
->root
->lang
->type_of_child (v
->parent
, v
->index
);
2061 if (varobj_value_has_mutated (v
, new, new_type
))
2063 /* The children are no longer valid; delete them now.
2064 Report the fact that its type changed as well. */
2065 varobj_delete (v
, NULL
, 1 /* only_children */);
2066 v
->num_children
= -1;
2073 if (install_new_value (v
, new, r
.type_changed
))
2080 /* We probably should not get children of a varobj that has a
2081 pretty-printer, but for which -var-list-children was never
2083 if (v
->pretty_printer
)
2085 VEC (varobj_p
) *changed
= 0, *type_changed
= 0, *unchanged
= 0;
2086 VEC (varobj_p
) *new = 0;
2087 int i
, children_changed
= 0;
2092 if (!v
->children_requested
)
2096 /* If we initially did not have potential children, but
2097 now we do, consider the varobj as changed.
2098 Otherwise, if children were never requested, consider
2099 it as unchanged -- presumably, such varobj is not yet
2100 expanded in the UI, so we need not bother getting
2102 if (!varobj_has_more (v
, 0))
2104 update_dynamic_varobj_children (v
, NULL
, NULL
, NULL
, NULL
,
2106 if (varobj_has_more (v
, 0))
2111 VEC_safe_push (varobj_update_result
, result
, &r
);
2116 /* If update_dynamic_varobj_children returns 0, then we have
2117 a non-conforming pretty-printer, so we skip it. */
2118 if (update_dynamic_varobj_children (v
, &changed
, &type_changed
, &new,
2119 &unchanged
, &children_changed
, 1,
2122 if (children_changed
|| new)
2124 r
.children_changed
= 1;
2127 /* Push in reverse order so that the first child is
2128 popped from the work stack first, and so will be
2129 added to result first. This does not affect
2130 correctness, just "nicer". */
2131 for (i
= VEC_length (varobj_p
, type_changed
) - 1; i
>= 0; --i
)
2133 varobj_p tmp
= VEC_index (varobj_p
, type_changed
, i
);
2134 varobj_update_result r
= {0};
2136 /* Type may change only if value was changed. */
2140 r
.value_installed
= 1;
2141 VEC_safe_push (varobj_update_result
, stack
, &r
);
2143 for (i
= VEC_length (varobj_p
, changed
) - 1; i
>= 0; --i
)
2145 varobj_p tmp
= VEC_index (varobj_p
, changed
, i
);
2146 varobj_update_result r
= {0};
2150 r
.value_installed
= 1;
2151 VEC_safe_push (varobj_update_result
, stack
, &r
);
2153 for (i
= VEC_length (varobj_p
, unchanged
) - 1; i
>= 0; --i
)
2155 varobj_p tmp
= VEC_index (varobj_p
, unchanged
, i
);
2159 varobj_update_result r
= {0};
2162 r
.value_installed
= 1;
2163 VEC_safe_push (varobj_update_result
, stack
, &r
);
2166 if (r
.changed
|| r
.children_changed
)
2167 VEC_safe_push (varobj_update_result
, result
, &r
);
2169 /* Free CHANGED, TYPE_CHANGED and UNCHANGED, but not NEW,
2170 because NEW has been put into the result vector. */
2171 VEC_free (varobj_p
, changed
);
2172 VEC_free (varobj_p
, type_changed
);
2173 VEC_free (varobj_p
, unchanged
);
2179 /* Push any children. Use reverse order so that the first
2180 child is popped from the work stack first, and so
2181 will be added to result first. This does not
2182 affect correctness, just "nicer". */
2183 for (i
= VEC_length (varobj_p
, v
->children
)-1; i
>= 0; --i
)
2185 varobj_p c
= VEC_index (varobj_p
, v
->children
, i
);
2187 /* Child may be NULL if explicitly deleted by -var-delete. */
2188 if (c
!= NULL
&& !c
->frozen
)
2190 varobj_update_result r
= {0};
2193 VEC_safe_push (varobj_update_result
, stack
, &r
);
2197 if (r
.changed
|| r
.type_changed
)
2198 VEC_safe_push (varobj_update_result
, result
, &r
);
2201 VEC_free (varobj_update_result
, stack
);
2207 /* Helper functions */
2210 * Variable object construction/destruction
2214 delete_variable (struct cpstack
**resultp
, struct varobj
*var
,
2215 int only_children_p
)
2219 delete_variable_1 (resultp
, &delcount
, var
,
2220 only_children_p
, 1 /* remove_from_parent_p */ );
2225 /* Delete the variable object VAR and its children. */
2226 /* IMPORTANT NOTE: If we delete a variable which is a child
2227 and the parent is not removed we dump core. It must be always
2228 initially called with remove_from_parent_p set. */
2230 delete_variable_1 (struct cpstack
**resultp
, int *delcountp
,
2231 struct varobj
*var
, int only_children_p
,
2232 int remove_from_parent_p
)
2236 /* Delete any children of this variable, too. */
2237 for (i
= 0; i
< VEC_length (varobj_p
, var
->children
); ++i
)
2239 varobj_p child
= VEC_index (varobj_p
, var
->children
, i
);
2243 if (!remove_from_parent_p
)
2244 child
->parent
= NULL
;
2245 delete_variable_1 (resultp
, delcountp
, child
, 0, only_children_p
);
2247 VEC_free (varobj_p
, var
->children
);
2249 /* if we were called to delete only the children we are done here. */
2250 if (only_children_p
)
2253 /* Otherwise, add it to the list of deleted ones and proceed to do so. */
2254 /* If the name is null, this is a temporary variable, that has not
2255 yet been installed, don't report it, it belongs to the caller... */
2256 if (var
->obj_name
!= NULL
)
2258 cppush (resultp
, xstrdup (var
->obj_name
));
2259 *delcountp
= *delcountp
+ 1;
2262 /* If this variable has a parent, remove it from its parent's list. */
2263 /* OPTIMIZATION: if the parent of this variable is also being deleted,
2264 (as indicated by remove_from_parent_p) we don't bother doing an
2265 expensive list search to find the element to remove when we are
2266 discarding the list afterwards. */
2267 if ((remove_from_parent_p
) && (var
->parent
!= NULL
))
2269 VEC_replace (varobj_p
, var
->parent
->children
, var
->index
, NULL
);
2272 if (var
->obj_name
!= NULL
)
2273 uninstall_variable (var
);
2275 /* Free memory associated with this variable. */
2276 free_variable (var
);
2279 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
2281 install_variable (struct varobj
*var
)
2284 struct vlist
*newvl
;
2286 unsigned int index
= 0;
2289 for (chp
= var
->obj_name
; *chp
; chp
++)
2291 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
2294 cv
= *(varobj_table
+ index
);
2295 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
2299 error (_("Duplicate variable object name"));
2301 /* Add varobj to hash table. */
2302 newvl
= xmalloc (sizeof (struct vlist
));
2303 newvl
->next
= *(varobj_table
+ index
);
2305 *(varobj_table
+ index
) = newvl
;
2307 /* If root, add varobj to root list. */
2308 if (is_root_p (var
))
2310 /* Add to list of root variables. */
2311 if (rootlist
== NULL
)
2312 var
->root
->next
= NULL
;
2314 var
->root
->next
= rootlist
;
2315 rootlist
= var
->root
;
2321 /* Unistall the object VAR. */
2323 uninstall_variable (struct varobj
*var
)
2327 struct varobj_root
*cr
;
2328 struct varobj_root
*prer
;
2330 unsigned int index
= 0;
2333 /* Remove varobj from hash table. */
2334 for (chp
= var
->obj_name
; *chp
; chp
++)
2336 index
= (index
+ (i
++ * (unsigned int) *chp
)) % VAROBJ_TABLE_SIZE
;
2339 cv
= *(varobj_table
+ index
);
2341 while ((cv
!= NULL
) && (strcmp (cv
->var
->obj_name
, var
->obj_name
) != 0))
2348 fprintf_unfiltered (gdb_stdlog
, "Deleting %s\n", var
->obj_name
);
2353 ("Assertion failed: Could not find variable object \"%s\" to delete",
2359 *(varobj_table
+ index
) = cv
->next
;
2361 prev
->next
= cv
->next
;
2365 /* If root, remove varobj from root list. */
2366 if (is_root_p (var
))
2368 /* Remove from list of root variables. */
2369 if (rootlist
== var
->root
)
2370 rootlist
= var
->root
->next
;
2375 while ((cr
!= NULL
) && (cr
->rootvar
!= var
))
2382 warning (_("Assertion failed: Could not find "
2383 "varobj \"%s\" in root list"),
2390 prer
->next
= cr
->next
;
2396 /* Create and install a child of the parent of the given name. */
2397 static struct varobj
*
2398 create_child (struct varobj
*parent
, int index
, char *name
)
2400 return create_child_with_value (parent
, index
, name
,
2401 value_of_child (parent
, index
));
2404 /* Does CHILD represent a child with no name? This happens when
2405 the child is an anonmous struct or union and it has no field name
2406 in its parent variable.
2408 This has already been determined by *_describe_child. The easiest
2409 thing to do is to compare the child's name with ANONYMOUS_*_NAME. */
2412 is_anonymous_child (struct varobj
*child
)
2414 return (strcmp (child
->name
, ANONYMOUS_STRUCT_NAME
) == 0
2415 || strcmp (child
->name
, ANONYMOUS_UNION_NAME
) == 0);
2418 static struct varobj
*
2419 create_child_with_value (struct varobj
*parent
, int index
, const char *name
,
2420 struct value
*value
)
2422 struct varobj
*child
;
2425 child
= new_variable ();
2427 /* Name is allocated by name_of_child. */
2428 /* FIXME: xstrdup should not be here. */
2429 child
->name
= xstrdup (name
);
2430 child
->index
= index
;
2431 child
->parent
= parent
;
2432 child
->root
= parent
->root
;
2434 if (is_anonymous_child (child
))
2435 childs_name
= xstrprintf ("%s.%d_anonymous", parent
->obj_name
, index
);
2437 childs_name
= xstrprintf ("%s.%s", parent
->obj_name
, name
);
2438 child
->obj_name
= childs_name
;
2440 install_variable (child
);
2442 /* Compute the type of the child. Must do this before
2443 calling install_new_value. */
2445 /* If the child had no evaluation errors, var->value
2446 will be non-NULL and contain a valid type. */
2447 child
->type
= value_actual_type (value
, 0, NULL
);
2449 /* Otherwise, we must compute the type. */
2450 child
->type
= (*child
->root
->lang
->type_of_child
) (child
->parent
,
2452 install_new_value (child
, value
, 1);
2459 * Miscellaneous utility functions.
2462 /* Allocate memory and initialize a new variable. */
2463 static struct varobj
*
2468 var
= (struct varobj
*) xmalloc (sizeof (struct varobj
));
2470 var
->path_expr
= NULL
;
2471 var
->obj_name
= NULL
;
2475 var
->num_children
= -1;
2477 var
->children
= NULL
;
2481 var
->print_value
= NULL
;
2483 var
->not_fetched
= 0;
2484 var
->children_requested
= 0;
2487 var
->constructor
= 0;
2488 var
->pretty_printer
= 0;
2489 var
->child_iter
= 0;
2490 var
->saved_item
= 0;
2495 /* Allocate memory and initialize a new root variable. */
2496 static struct varobj
*
2497 new_root_variable (void)
2499 struct varobj
*var
= new_variable ();
2501 var
->root
= (struct varobj_root
*) xmalloc (sizeof (struct varobj_root
));
2502 var
->root
->lang
= NULL
;
2503 var
->root
->exp
= NULL
;
2504 var
->root
->valid_block
= NULL
;
2505 var
->root
->frame
= null_frame_id
;
2506 var
->root
->floating
= 0;
2507 var
->root
->rootvar
= NULL
;
2508 var
->root
->is_valid
= 1;
2513 /* Free any allocated memory associated with VAR. */
2515 free_variable (struct varobj
*var
)
2518 if (var
->pretty_printer
)
2520 struct cleanup
*cleanup
= varobj_ensure_python_env (var
);
2521 Py_XDECREF (var
->constructor
);
2522 Py_XDECREF (var
->pretty_printer
);
2523 Py_XDECREF (var
->child_iter
);
2524 Py_XDECREF (var
->saved_item
);
2525 do_cleanups (cleanup
);
2529 value_free (var
->value
);
2531 /* Free the expression if this is a root variable. */
2532 if (is_root_p (var
))
2534 xfree (var
->root
->exp
);
2539 xfree (var
->obj_name
);
2540 xfree (var
->print_value
);
2541 xfree (var
->path_expr
);
2546 do_free_variable_cleanup (void *var
)
2548 free_variable (var
);
2551 static struct cleanup
*
2552 make_cleanup_free_variable (struct varobj
*var
)
2554 return make_cleanup (do_free_variable_cleanup
, var
);
2557 /* This returns the type of the variable. It also skips past typedefs
2558 to return the real type of the variable.
2560 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
2561 except within get_target_type and get_type. */
2562 static struct type
*
2563 get_type (struct varobj
*var
)
2569 type
= check_typedef (type
);
2574 /* Return the type of the value that's stored in VAR,
2575 or that would have being stored there if the
2576 value were accessible.
2578 This differs from VAR->type in that VAR->type is always
2579 the true type of the expession in the source language.
2580 The return value of this function is the type we're
2581 actually storing in varobj, and using for displaying
2582 the values and for comparing previous and new values.
2584 For example, top-level references are always stripped. */
2585 static struct type
*
2586 get_value_type (struct varobj
*var
)
2591 type
= value_type (var
->value
);
2595 type
= check_typedef (type
);
2597 if (TYPE_CODE (type
) == TYPE_CODE_REF
)
2598 type
= get_target_type (type
);
2600 type
= check_typedef (type
);
2605 /* This returns the target type (or NULL) of TYPE, also skipping
2606 past typedefs, just like get_type ().
2608 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
2609 except within get_target_type and get_type. */
2610 static struct type
*
2611 get_target_type (struct type
*type
)
2615 type
= TYPE_TARGET_TYPE (type
);
2617 type
= check_typedef (type
);
2623 /* What is the default display for this variable? We assume that
2624 everything is "natural". Any exceptions? */
2625 static enum varobj_display_formats
2626 variable_default_display (struct varobj
*var
)
2628 return FORMAT_NATURAL
;
2631 /* FIXME: The following should be generic for any pointer. */
2633 cppush (struct cpstack
**pstack
, char *name
)
2637 s
= (struct cpstack
*) xmalloc (sizeof (struct cpstack
));
2643 /* FIXME: The following should be generic for any pointer. */
2645 cppop (struct cpstack
**pstack
)
2650 if ((*pstack
)->name
== NULL
&& (*pstack
)->next
== NULL
)
2655 *pstack
= (*pstack
)->next
;
2662 * Language-dependencies
2665 /* Common entry points */
2667 /* Get the language of variable VAR. */
2668 static enum varobj_languages
2669 variable_language (struct varobj
*var
)
2671 enum varobj_languages lang
;
2673 switch (var
->root
->exp
->language_defn
->la_language
)
2679 case language_cplus
:
2693 /* Return the number of children for a given variable.
2694 The result of this function is defined by the language
2695 implementation. The number of children returned by this function
2696 is the number of children that the user will see in the variable
2699 number_of_children (struct varobj
*var
)
2701 return (*var
->root
->lang
->number_of_children
) (var
);
2704 /* What is the expression for the root varobj VAR? Returns a malloc'd
2707 name_of_variable (struct varobj
*var
)
2709 return (*var
->root
->lang
->name_of_variable
) (var
);
2712 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd
2715 name_of_child (struct varobj
*var
, int index
)
2717 return (*var
->root
->lang
->name_of_child
) (var
, index
);
2720 /* What is the ``struct value *'' of the root variable VAR?
2721 For floating variable object, evaluation can get us a value
2722 of different type from what is stored in varobj already. In
2724 - *type_changed will be set to 1
2725 - old varobj will be freed, and new one will be
2726 created, with the same name.
2727 - *var_handle will be set to the new varobj
2728 Otherwise, *type_changed will be set to 0. */
2729 static struct value
*
2730 value_of_root (struct varobj
**var_handle
, int *type_changed
)
2734 if (var_handle
== NULL
)
2739 /* This should really be an exception, since this should
2740 only get called with a root variable. */
2742 if (!is_root_p (var
))
2745 if (var
->root
->floating
)
2747 struct varobj
*tmp_var
;
2748 char *old_type
, *new_type
;
2750 tmp_var
= varobj_create (NULL
, var
->name
, (CORE_ADDR
) 0,
2751 USE_SELECTED_FRAME
);
2752 if (tmp_var
== NULL
)
2756 old_type
= varobj_get_type (var
);
2757 new_type
= varobj_get_type (tmp_var
);
2758 if (strcmp (old_type
, new_type
) == 0)
2760 /* The expression presently stored inside var->root->exp
2761 remembers the locations of local variables relatively to
2762 the frame where the expression was created (in DWARF location
2763 button, for example). Naturally, those locations are not
2764 correct in other frames, so update the expression. */
2766 struct expression
*tmp_exp
= var
->root
->exp
;
2768 var
->root
->exp
= tmp_var
->root
->exp
;
2769 tmp_var
->root
->exp
= tmp_exp
;
2771 varobj_delete (tmp_var
, NULL
, 0);
2776 tmp_var
->obj_name
= xstrdup (var
->obj_name
);
2777 tmp_var
->from
= var
->from
;
2778 tmp_var
->to
= var
->to
;
2779 varobj_delete (var
, NULL
, 0);
2781 install_variable (tmp_var
);
2782 *var_handle
= tmp_var
;
2795 struct value
*value
;
2797 value
= (*var
->root
->lang
->value_of_root
) (var_handle
);
2798 if (var
->value
== NULL
|| value
== NULL
)
2800 /* For root varobj-s, a NULL value indicates a scoping issue.
2801 So, nothing to do in terms of checking for mutations. */
2803 else if (varobj_value_has_mutated (var
, value
, value_type (value
)))
2805 /* The type has mutated, so the children are no longer valid.
2806 Just delete them, and tell our caller that the type has
2808 varobj_delete (var
, NULL
, 1 /* only_children */);
2809 var
->num_children
= -1;
2818 /* What is the ``struct value *'' for the INDEX'th child of PARENT? */
2819 static struct value
*
2820 value_of_child (struct varobj
*parent
, int index
)
2822 struct value
*value
;
2824 value
= (*parent
->root
->lang
->value_of_child
) (parent
, index
);
2829 /* GDB already has a command called "value_of_variable". Sigh. */
2831 my_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
2833 if (var
->root
->is_valid
)
2835 if (var
->pretty_printer
)
2836 return value_get_print_value (var
->value
, var
->format
, var
);
2837 return (*var
->root
->lang
->value_of_variable
) (var
, format
);
2844 value_get_print_value (struct value
*value
, enum varobj_display_formats format
,
2847 struct ui_file
*stb
;
2848 struct cleanup
*old_chain
;
2849 gdb_byte
*thevalue
= NULL
;
2850 struct value_print_options opts
;
2851 struct type
*type
= NULL
;
2853 char *encoding
= NULL
;
2854 struct gdbarch
*gdbarch
= NULL
;
2855 /* Initialize it just to avoid a GCC false warning. */
2856 CORE_ADDR str_addr
= 0;
2857 int string_print
= 0;
2862 stb
= mem_fileopen ();
2863 old_chain
= make_cleanup_ui_file_delete (stb
);
2865 gdbarch
= get_type_arch (value_type (value
));
2868 PyObject
*value_formatter
= var
->pretty_printer
;
2870 varobj_ensure_python_env (var
);
2872 if (value_formatter
)
2874 /* First check to see if we have any children at all. If so,
2875 we simply return {...}. */
2876 if (dynamic_varobj_has_child_method (var
))
2878 do_cleanups (old_chain
);
2879 return xstrdup ("{...}");
2882 if (PyObject_HasAttr (value_formatter
, gdbpy_to_string_cst
))
2884 struct value
*replacement
;
2885 PyObject
*output
= NULL
;
2887 output
= apply_varobj_pretty_printer (value_formatter
,
2891 /* If we have string like output ... */
2894 make_cleanup_py_decref (output
);
2896 /* If this is a lazy string, extract it. For lazy
2897 strings we always print as a string, so set
2899 if (gdbpy_is_lazy_string (output
))
2901 gdbpy_extract_lazy_string (output
, &str_addr
, &type
,
2903 make_cleanup (free_current_contents
, &encoding
);
2908 /* If it is a regular (non-lazy) string, extract
2909 it and copy the contents into THEVALUE. If the
2910 hint says to print it as a string, set
2911 string_print. Otherwise just return the extracted
2912 string as a value. */
2915 = python_string_to_target_python_string (output
);
2919 char *s
= PyString_AsString (py_str
);
2922 hint
= gdbpy_get_display_hint (value_formatter
);
2925 if (!strcmp (hint
, "string"))
2930 len
= PyString_Size (py_str
);
2931 thevalue
= xmemdup (s
, len
+ 1, len
+ 1);
2932 type
= builtin_type (gdbarch
)->builtin_char
;
2937 do_cleanups (old_chain
);
2941 make_cleanup (xfree
, thevalue
);
2944 gdbpy_print_stack ();
2947 /* If the printer returned a replacement value, set VALUE
2948 to REPLACEMENT. If there is not a replacement value,
2949 just use the value passed to this function. */
2951 value
= replacement
;
2957 get_formatted_print_options (&opts
, format_code
[(int) format
]);
2961 /* If the THEVALUE has contents, it is a regular string. */
2963 LA_PRINT_STRING (stb
, type
, thevalue
, len
, encoding
, 0, &opts
);
2964 else if (string_print
)
2965 /* Otherwise, if string_print is set, and it is not a regular
2966 string, it is a lazy string. */
2967 val_print_string (type
, encoding
, str_addr
, len
, stb
, &opts
);
2969 /* All other cases. */
2970 common_val_print (value
, stb
, 0, &opts
, current_language
);
2972 thevalue
= ui_file_xstrdup (stb
, NULL
);
2974 do_cleanups (old_chain
);
2979 varobj_editable_p (struct varobj
*var
)
2983 if (!(var
->root
->is_valid
&& var
->value
&& VALUE_LVAL (var
->value
)))
2986 type
= get_value_type (var
);
2988 switch (TYPE_CODE (type
))
2990 case TYPE_CODE_STRUCT
:
2991 case TYPE_CODE_UNION
:
2992 case TYPE_CODE_ARRAY
:
2993 case TYPE_CODE_FUNC
:
2994 case TYPE_CODE_METHOD
:
3004 /* Call VAR's value_is_changeable_p language-specific callback. */
3007 varobj_value_is_changeable_p (struct varobj
*var
)
3009 return var
->root
->lang
->value_is_changeable_p (var
);
3012 /* Return 1 if that varobj is floating, that is is always evaluated in the
3013 selected frame, and not bound to thread/frame. Such variable objects
3014 are created using '@' as frame specifier to -var-create. */
3016 varobj_floating_p (struct varobj
*var
)
3018 return var
->root
->floating
;
3021 /* Given the value and the type of a variable object,
3022 adjust the value and type to those necessary
3023 for getting children of the variable object.
3024 This includes dereferencing top-level references
3025 to all types and dereferencing pointers to
3028 If LOOKUP_ACTUAL_TYPE is set the enclosing type of the
3029 value will be fetched and if it differs from static type
3030 the value will be casted to it.
3032 Both TYPE and *TYPE should be non-null. VALUE
3033 can be null if we want to only translate type.
3034 *VALUE can be null as well -- if the parent
3037 If WAS_PTR is not NULL, set *WAS_PTR to 0 or 1
3038 depending on whether pointer was dereferenced
3039 in this function. */
3041 adjust_value_for_child_access (struct value
**value
,
3044 int lookup_actual_type
)
3046 gdb_assert (type
&& *type
);
3051 *type
= check_typedef (*type
);
3053 /* The type of value stored in varobj, that is passed
3054 to us, is already supposed to be
3055 reference-stripped. */
3057 gdb_assert (TYPE_CODE (*type
) != TYPE_CODE_REF
);
3059 /* Pointers to structures are treated just like
3060 structures when accessing children. Don't
3061 dererences pointers to other types. */
3062 if (TYPE_CODE (*type
) == TYPE_CODE_PTR
)
3064 struct type
*target_type
= get_target_type (*type
);
3065 if (TYPE_CODE (target_type
) == TYPE_CODE_STRUCT
3066 || TYPE_CODE (target_type
) == TYPE_CODE_UNION
)
3068 if (value
&& *value
)
3070 volatile struct gdb_exception except
;
3072 TRY_CATCH (except
, RETURN_MASK_ERROR
)
3074 *value
= value_ind (*value
);
3077 if (except
.reason
< 0)
3080 *type
= target_type
;
3086 /* The 'get_target_type' function calls check_typedef on
3087 result, so we can immediately check type code. No
3088 need to call check_typedef here. */
3090 /* Access a real type of the value (if necessary and possible). */
3091 if (value
&& *value
&& lookup_actual_type
)
3093 struct type
*enclosing_type
;
3094 int real_type_found
= 0;
3096 enclosing_type
= value_actual_type (*value
, 1, &real_type_found
);
3097 if (real_type_found
)
3099 *type
= enclosing_type
;
3100 *value
= value_cast (enclosing_type
, *value
);
3105 /* Implement the "value_is_changeable_p" varobj callback for most
3109 default_value_is_changeable_p (struct varobj
*var
)
3114 if (CPLUS_FAKE_CHILD (var
))
3117 type
= get_value_type (var
);
3119 switch (TYPE_CODE (type
))
3121 case TYPE_CODE_STRUCT
:
3122 case TYPE_CODE_UNION
:
3123 case TYPE_CODE_ARRAY
:
3137 c_number_of_children (struct varobj
*var
)
3139 struct type
*type
= get_value_type (var
);
3141 struct type
*target
;
3143 adjust_value_for_child_access (NULL
, &type
, NULL
, 0);
3144 target
= get_target_type (type
);
3146 switch (TYPE_CODE (type
))
3148 case TYPE_CODE_ARRAY
:
3149 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (target
) > 0
3150 && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type
))
3151 children
= TYPE_LENGTH (type
) / TYPE_LENGTH (target
);
3153 /* If we don't know how many elements there are, don't display
3158 case TYPE_CODE_STRUCT
:
3159 case TYPE_CODE_UNION
:
3160 children
= TYPE_NFIELDS (type
);
3164 /* The type here is a pointer to non-struct. Typically, pointers
3165 have one child, except for function ptrs, which have no children,
3166 and except for void*, as we don't know what to show.
3168 We can show char* so we allow it to be dereferenced. If you decide
3169 to test for it, please mind that a little magic is necessary to
3170 properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
3171 TYPE_NAME == "char". */
3172 if (TYPE_CODE (target
) == TYPE_CODE_FUNC
3173 || TYPE_CODE (target
) == TYPE_CODE_VOID
)
3180 /* Other types have no children. */
3188 c_name_of_variable (struct varobj
*parent
)
3190 return xstrdup (parent
->name
);
3193 /* Return the value of element TYPE_INDEX of a structure
3194 value VALUE. VALUE's type should be a structure,
3195 or union, or a typedef to struct/union.
3197 Returns NULL if getting the value fails. Never throws. */
3198 static struct value
*
3199 value_struct_element_index (struct value
*value
, int type_index
)
3201 struct value
*result
= NULL
;
3202 volatile struct gdb_exception e
;
3203 struct type
*type
= value_type (value
);
3205 type
= check_typedef (type
);
3207 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_STRUCT
3208 || TYPE_CODE (type
) == TYPE_CODE_UNION
);
3210 TRY_CATCH (e
, RETURN_MASK_ERROR
)
3212 if (field_is_static (&TYPE_FIELD (type
, type_index
)))
3213 result
= value_static_field (type
, type_index
);
3215 result
= value_primitive_field (value
, 0, type_index
, type
);
3227 /* Obtain the information about child INDEX of the variable
3229 If CNAME is not null, sets *CNAME to the name of the child relative
3231 If CVALUE is not null, sets *CVALUE to the value of the child.
3232 If CTYPE is not null, sets *CTYPE to the type of the child.
3234 If any of CNAME, CVALUE, or CTYPE is not null, but the corresponding
3235 information cannot be determined, set *CNAME, *CVALUE, or *CTYPE
3238 c_describe_child (struct varobj
*parent
, int index
,
3239 char **cname
, struct value
**cvalue
, struct type
**ctype
,
3240 char **cfull_expression
)
3242 struct value
*value
= parent
->value
;
3243 struct type
*type
= get_value_type (parent
);
3244 char *parent_expression
= NULL
;
3246 volatile struct gdb_exception except
;
3254 if (cfull_expression
)
3256 *cfull_expression
= NULL
;
3257 parent_expression
= varobj_get_path_expr (get_path_expr_parent (parent
));
3259 adjust_value_for_child_access (&value
, &type
, &was_ptr
, 0);
3261 switch (TYPE_CODE (type
))
3263 case TYPE_CODE_ARRAY
:
3266 = xstrdup (int_string (index
3267 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
)),
3270 if (cvalue
&& value
)
3272 int real_index
= index
+ TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
));
3274 TRY_CATCH (except
, RETURN_MASK_ERROR
)
3276 *cvalue
= value_subscript (value
, real_index
);
3281 *ctype
= get_target_type (type
);
3283 if (cfull_expression
)
3285 xstrprintf ("(%s)[%s]", parent_expression
,
3287 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
)),
3293 case TYPE_CODE_STRUCT
:
3294 case TYPE_CODE_UNION
:
3296 const char *field_name
;
3298 /* If the type is anonymous and the field has no name,
3299 set an appropriate name. */
3300 field_name
= TYPE_FIELD_NAME (type
, index
);
3301 if (field_name
== NULL
|| *field_name
== '\0')
3305 if (TYPE_CODE (TYPE_FIELD_TYPE (type
, index
))
3306 == TYPE_CODE_STRUCT
)
3307 *cname
= xstrdup (ANONYMOUS_STRUCT_NAME
);
3309 *cname
= xstrdup (ANONYMOUS_UNION_NAME
);
3312 if (cfull_expression
)
3313 *cfull_expression
= xstrdup ("");
3318 *cname
= xstrdup (field_name
);
3320 if (cfull_expression
)
3322 char *join
= was_ptr
? "->" : ".";
3324 *cfull_expression
= xstrprintf ("(%s)%s%s", parent_expression
,
3329 if (cvalue
&& value
)
3331 /* For C, varobj index is the same as type index. */
3332 *cvalue
= value_struct_element_index (value
, index
);
3336 *ctype
= TYPE_FIELD_TYPE (type
, index
);
3342 *cname
= xstrprintf ("*%s", parent
->name
);
3344 if (cvalue
&& value
)
3346 TRY_CATCH (except
, RETURN_MASK_ERROR
)
3348 *cvalue
= value_ind (value
);
3351 if (except
.reason
< 0)
3355 /* Don't use get_target_type because it calls
3356 check_typedef and here, we want to show the true
3357 declared type of the variable. */
3359 *ctype
= TYPE_TARGET_TYPE (type
);
3361 if (cfull_expression
)
3362 *cfull_expression
= xstrprintf ("*(%s)", parent_expression
);
3367 /* This should not happen. */
3369 *cname
= xstrdup ("???");
3370 if (cfull_expression
)
3371 *cfull_expression
= xstrdup ("???");
3372 /* Don't set value and type, we don't know then. */
3377 c_name_of_child (struct varobj
*parent
, int index
)
3381 c_describe_child (parent
, index
, &name
, NULL
, NULL
, NULL
);
3386 c_path_expr_of_child (struct varobj
*child
)
3388 c_describe_child (child
->parent
, child
->index
, NULL
, NULL
, NULL
,
3390 return child
->path_expr
;
3393 /* If frame associated with VAR can be found, switch
3394 to it and return 1. Otherwise, return 0. */
3396 check_scope (struct varobj
*var
)
3398 struct frame_info
*fi
;
3401 fi
= frame_find_by_id (var
->root
->frame
);
3406 CORE_ADDR pc
= get_frame_pc (fi
);
3408 if (pc
< BLOCK_START (var
->root
->valid_block
) ||
3409 pc
>= BLOCK_END (var
->root
->valid_block
))
3417 static struct value
*
3418 c_value_of_root (struct varobj
**var_handle
)
3420 struct value
*new_val
= NULL
;
3421 struct varobj
*var
= *var_handle
;
3422 int within_scope
= 0;
3423 struct cleanup
*back_to
;
3425 /* Only root variables can be updated... */
3426 if (!is_root_p (var
))
3427 /* Not a root var. */
3430 back_to
= make_cleanup_restore_current_thread ();
3432 /* Determine whether the variable is still around. */
3433 if (var
->root
->valid_block
== NULL
|| var
->root
->floating
)
3435 else if (var
->root
->thread_id
== 0)
3437 /* The program was single-threaded when the variable object was
3438 created. Technically, it's possible that the program became
3439 multi-threaded since then, but we don't support such
3441 within_scope
= check_scope (var
);
3445 ptid_t ptid
= thread_id_to_pid (var
->root
->thread_id
);
3446 if (in_thread_list (ptid
))
3448 switch_to_thread (ptid
);
3449 within_scope
= check_scope (var
);
3455 volatile struct gdb_exception except
;
3457 /* We need to catch errors here, because if evaluate
3458 expression fails we want to just return NULL. */
3459 TRY_CATCH (except
, RETURN_MASK_ERROR
)
3461 new_val
= evaluate_expression (var
->root
->exp
);
3467 do_cleanups (back_to
);
3472 static struct value
*
3473 c_value_of_child (struct varobj
*parent
, int index
)
3475 struct value
*value
= NULL
;
3477 c_describe_child (parent
, index
, NULL
, &value
, NULL
, NULL
);
3481 static struct type
*
3482 c_type_of_child (struct varobj
*parent
, int index
)
3484 struct type
*type
= NULL
;
3486 c_describe_child (parent
, index
, NULL
, NULL
, &type
, NULL
);
3491 c_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
3493 /* BOGUS: if val_print sees a struct/class, or a reference to one,
3494 it will print out its children instead of "{...}". So we need to
3495 catch that case explicitly. */
3496 struct type
*type
= get_type (var
);
3498 /* Strip top-level references. */
3499 while (TYPE_CODE (type
) == TYPE_CODE_REF
)
3500 type
= check_typedef (TYPE_TARGET_TYPE (type
));
3502 switch (TYPE_CODE (type
))
3504 case TYPE_CODE_STRUCT
:
3505 case TYPE_CODE_UNION
:
3506 return xstrdup ("{...}");
3509 case TYPE_CODE_ARRAY
:
3513 number
= xstrprintf ("[%d]", var
->num_children
);
3520 if (var
->value
== NULL
)
3522 /* This can happen if we attempt to get the value of a struct
3523 member when the parent is an invalid pointer. This is an
3524 error condition, so we should tell the caller. */
3529 if (var
->not_fetched
&& value_lazy (var
->value
))
3530 /* Frozen variable and no value yet. We don't
3531 implicitly fetch the value. MI response will
3532 use empty string for the value, which is OK. */
3535 gdb_assert (varobj_value_is_changeable_p (var
));
3536 gdb_assert (!value_lazy (var
->value
));
3538 /* If the specified format is the current one,
3539 we can reuse print_value. */
3540 if (format
== var
->format
)
3541 return xstrdup (var
->print_value
);
3543 return value_get_print_value (var
->value
, format
, var
);
3553 cplus_number_of_children (struct varobj
*var
)
3555 struct value
*value
= NULL
;
3557 int children
, dont_know
;
3558 int lookup_actual_type
= 0;
3559 struct value_print_options opts
;
3564 get_user_print_options (&opts
);
3566 if (!CPLUS_FAKE_CHILD (var
))
3568 type
= get_value_type (var
);
3570 /* It is necessary to access a real type (via RTTI). */
3571 if (opts
.objectprint
)
3574 lookup_actual_type
= (TYPE_CODE (var
->type
) == TYPE_CODE_REF
3575 || TYPE_CODE (var
->type
) == TYPE_CODE_PTR
);
3577 adjust_value_for_child_access (&value
, &type
, NULL
, lookup_actual_type
);
3579 if (((TYPE_CODE (type
)) == TYPE_CODE_STRUCT
) ||
3580 ((TYPE_CODE (type
)) == TYPE_CODE_UNION
))
3584 cplus_class_num_children (type
, kids
);
3585 if (kids
[v_public
] != 0)
3587 if (kids
[v_private
] != 0)
3589 if (kids
[v_protected
] != 0)
3592 /* Add any baseclasses. */
3593 children
+= TYPE_N_BASECLASSES (type
);
3596 /* FIXME: save children in var. */
3603 type
= get_value_type (var
->parent
);
3605 /* It is necessary to access a real type (via RTTI). */
3606 if (opts
.objectprint
)
3608 struct varobj
*parent
= var
->parent
;
3610 value
= parent
->value
;
3611 lookup_actual_type
= (TYPE_CODE (parent
->type
) == TYPE_CODE_REF
3612 || TYPE_CODE (parent
->type
) == TYPE_CODE_PTR
);
3614 adjust_value_for_child_access (&value
, &type
, NULL
, lookup_actual_type
);
3616 cplus_class_num_children (type
, kids
);
3617 if (strcmp (var
->name
, "public") == 0)
3618 children
= kids
[v_public
];
3619 else if (strcmp (var
->name
, "private") == 0)
3620 children
= kids
[v_private
];
3622 children
= kids
[v_protected
];
3627 children
= c_number_of_children (var
);
3632 /* Compute # of public, private, and protected variables in this class.
3633 That means we need to descend into all baseclasses and find out
3634 how many are there, too. */
3636 cplus_class_num_children (struct type
*type
, int children
[3])
3638 int i
, vptr_fieldno
;
3639 struct type
*basetype
= NULL
;
3641 children
[v_public
] = 0;
3642 children
[v_private
] = 0;
3643 children
[v_protected
] = 0;
3645 vptr_fieldno
= get_vptr_fieldno (type
, &basetype
);
3646 for (i
= TYPE_N_BASECLASSES (type
); i
< TYPE_NFIELDS (type
); i
++)
3648 /* If we have a virtual table pointer, omit it. Even if virtual
3649 table pointers are not specifically marked in the debug info,
3650 they should be artificial. */
3651 if ((type
== basetype
&& i
== vptr_fieldno
)
3652 || TYPE_FIELD_ARTIFICIAL (type
, i
))
3655 if (TYPE_FIELD_PROTECTED (type
, i
))
3656 children
[v_protected
]++;
3657 else if (TYPE_FIELD_PRIVATE (type
, i
))
3658 children
[v_private
]++;
3660 children
[v_public
]++;
3665 cplus_name_of_variable (struct varobj
*parent
)
3667 return c_name_of_variable (parent
);
3670 enum accessibility
{ private_field
, protected_field
, public_field
};
3672 /* Check if field INDEX of TYPE has the specified accessibility.
3673 Return 0 if so and 1 otherwise. */
3675 match_accessibility (struct type
*type
, int index
, enum accessibility acc
)
3677 if (acc
== private_field
&& TYPE_FIELD_PRIVATE (type
, index
))
3679 else if (acc
== protected_field
&& TYPE_FIELD_PROTECTED (type
, index
))
3681 else if (acc
== public_field
&& !TYPE_FIELD_PRIVATE (type
, index
)
3682 && !TYPE_FIELD_PROTECTED (type
, index
))
3689 cplus_describe_child (struct varobj
*parent
, int index
,
3690 char **cname
, struct value
**cvalue
, struct type
**ctype
,
3691 char **cfull_expression
)
3693 struct value
*value
;
3696 int lookup_actual_type
= 0;
3697 char *parent_expression
= NULL
;
3699 struct value_print_options opts
;
3707 if (cfull_expression
)
3708 *cfull_expression
= NULL
;
3710 get_user_print_options (&opts
);
3712 var
= (CPLUS_FAKE_CHILD (parent
)) ? parent
->parent
: parent
;
3713 if (opts
.objectprint
)
3714 lookup_actual_type
= (TYPE_CODE (var
->type
) == TYPE_CODE_REF
3715 || TYPE_CODE (var
->type
) == TYPE_CODE_PTR
);
3717 type
= get_value_type (var
);
3718 if (cfull_expression
)
3719 parent_expression
= varobj_get_path_expr (get_path_expr_parent (var
));
3721 adjust_value_for_child_access (&value
, &type
, &was_ptr
, lookup_actual_type
);
3723 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
3724 || TYPE_CODE (type
) == TYPE_CODE_UNION
)
3726 char *join
= was_ptr
? "->" : ".";
3728 if (CPLUS_FAKE_CHILD (parent
))
3730 /* The fields of the class type are ordered as they
3731 appear in the class. We are given an index for a
3732 particular access control type ("public","protected",
3733 or "private"). We must skip over fields that don't
3734 have the access control we are looking for to properly
3735 find the indexed field. */
3736 int type_index
= TYPE_N_BASECLASSES (type
);
3737 enum accessibility acc
= public_field
;
3739 struct type
*basetype
= NULL
;
3740 const char *field_name
;
3742 vptr_fieldno
= get_vptr_fieldno (type
, &basetype
);
3743 if (strcmp (parent
->name
, "private") == 0)
3744 acc
= private_field
;
3745 else if (strcmp (parent
->name
, "protected") == 0)
3746 acc
= protected_field
;
3750 if ((type
== basetype
&& type_index
== vptr_fieldno
)
3751 || TYPE_FIELD_ARTIFICIAL (type
, type_index
))
3753 else if (match_accessibility (type
, type_index
, acc
))
3759 /* If the type is anonymous and the field has no name,
3760 set an appopriate name. */
3761 field_name
= TYPE_FIELD_NAME (type
, type_index
);
3762 if (field_name
== NULL
|| *field_name
== '\0')
3766 if (TYPE_CODE (TYPE_FIELD_TYPE (type
, type_index
))
3767 == TYPE_CODE_STRUCT
)
3768 *cname
= xstrdup (ANONYMOUS_STRUCT_NAME
);
3769 else if (TYPE_CODE (TYPE_FIELD_TYPE (type
, type_index
))
3771 *cname
= xstrdup (ANONYMOUS_UNION_NAME
);
3774 if (cfull_expression
)
3775 *cfull_expression
= xstrdup ("");
3780 *cname
= xstrdup (TYPE_FIELD_NAME (type
, type_index
));
3782 if (cfull_expression
)
3784 = xstrprintf ("((%s)%s%s)", parent_expression
, join
,
3788 if (cvalue
&& value
)
3789 *cvalue
= value_struct_element_index (value
, type_index
);
3792 *ctype
= TYPE_FIELD_TYPE (type
, type_index
);
3794 else if (index
< TYPE_N_BASECLASSES (type
))
3796 /* This is a baseclass. */
3798 *cname
= xstrdup (TYPE_FIELD_NAME (type
, index
));
3800 if (cvalue
&& value
)
3801 *cvalue
= value_cast (TYPE_FIELD_TYPE (type
, index
), value
);
3805 *ctype
= TYPE_FIELD_TYPE (type
, index
);
3808 if (cfull_expression
)
3810 char *ptr
= was_ptr
? "*" : "";
3812 /* Cast the parent to the base' type. Note that in gdb,
3815 will create an lvalue, for all appearences, so we don't
3816 need to use more fancy:
3820 When we are in the scope of the base class or of one
3821 of its children, the type field name will be interpreted
3822 as a constructor, if it exists. Therefore, we must
3823 indicate that the name is a class name by using the
3824 'class' keyword. See PR mi/11912 */
3825 *cfull_expression
= xstrprintf ("(%s(class %s%s) %s)",
3827 TYPE_FIELD_NAME (type
, index
),
3834 char *access
= NULL
;
3837 cplus_class_num_children (type
, children
);
3839 /* Everything beyond the baseclasses can
3840 only be "public", "private", or "protected"
3842 The special "fake" children are always output by varobj in
3843 this order. So if INDEX == 2, it MUST be "protected". */
3844 index
-= TYPE_N_BASECLASSES (type
);
3848 if (children
[v_public
] > 0)
3850 else if (children
[v_private
] > 0)
3853 access
= "protected";
3856 if (children
[v_public
] > 0)
3858 if (children
[v_private
] > 0)
3861 access
= "protected";
3863 else if (children
[v_private
] > 0)
3864 access
= "protected";
3867 /* Must be protected. */
3868 access
= "protected";
3875 gdb_assert (access
);
3877 *cname
= xstrdup (access
);
3879 /* Value and type and full expression are null here. */
3884 c_describe_child (parent
, index
, cname
, cvalue
, ctype
, cfull_expression
);
3889 cplus_name_of_child (struct varobj
*parent
, int index
)
3893 cplus_describe_child (parent
, index
, &name
, NULL
, NULL
, NULL
);
3898 cplus_path_expr_of_child (struct varobj
*child
)
3900 cplus_describe_child (child
->parent
, child
->index
, NULL
, NULL
, NULL
,
3902 return child
->path_expr
;
3905 static struct value
*
3906 cplus_value_of_root (struct varobj
**var_handle
)
3908 return c_value_of_root (var_handle
);
3911 static struct value
*
3912 cplus_value_of_child (struct varobj
*parent
, int index
)
3914 struct value
*value
= NULL
;
3916 cplus_describe_child (parent
, index
, NULL
, &value
, NULL
, NULL
);
3920 static struct type
*
3921 cplus_type_of_child (struct varobj
*parent
, int index
)
3923 struct type
*type
= NULL
;
3925 cplus_describe_child (parent
, index
, NULL
, NULL
, &type
, NULL
);
3930 cplus_value_of_variable (struct varobj
*var
,
3931 enum varobj_display_formats format
)
3934 /* If we have one of our special types, don't print out
3936 if (CPLUS_FAKE_CHILD (var
))
3937 return xstrdup ("");
3939 return c_value_of_variable (var
, format
);
3945 java_number_of_children (struct varobj
*var
)
3947 return cplus_number_of_children (var
);
3951 java_name_of_variable (struct varobj
*parent
)
3955 name
= cplus_name_of_variable (parent
);
3956 /* If the name has "-" in it, it is because we
3957 needed to escape periods in the name... */
3960 while (*p
!= '\000')
3971 java_name_of_child (struct varobj
*parent
, int index
)
3975 name
= cplus_name_of_child (parent
, index
);
3976 /* Escape any periods in the name... */
3979 while (*p
!= '\000')
3990 java_path_expr_of_child (struct varobj
*child
)
3995 static struct value
*
3996 java_value_of_root (struct varobj
**var_handle
)
3998 return cplus_value_of_root (var_handle
);
4001 static struct value
*
4002 java_value_of_child (struct varobj
*parent
, int index
)
4004 return cplus_value_of_child (parent
, index
);
4007 static struct type
*
4008 java_type_of_child (struct varobj
*parent
, int index
)
4010 return cplus_type_of_child (parent
, index
);
4014 java_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
4016 return cplus_value_of_variable (var
, format
);
4019 /* Ada specific callbacks for VAROBJs. */
4022 ada_number_of_children (struct varobj
*var
)
4024 return ada_varobj_get_number_of_children (var
->value
, var
->type
);
4028 ada_name_of_variable (struct varobj
*parent
)
4030 return c_name_of_variable (parent
);
4034 ada_name_of_child (struct varobj
*parent
, int index
)
4036 return ada_varobj_get_name_of_child (parent
->value
, parent
->type
,
4037 parent
->name
, index
);
4041 ada_path_expr_of_child (struct varobj
*child
)
4043 struct varobj
*parent
= child
->parent
;
4044 const char *parent_path_expr
= varobj_get_path_expr (parent
);
4046 return ada_varobj_get_path_expr_of_child (parent
->value
,
4053 static struct value
*
4054 ada_value_of_root (struct varobj
**var_handle
)
4056 return c_value_of_root (var_handle
);
4059 static struct value
*
4060 ada_value_of_child (struct varobj
*parent
, int index
)
4062 return ada_varobj_get_value_of_child (parent
->value
, parent
->type
,
4063 parent
->name
, index
);
4066 static struct type
*
4067 ada_type_of_child (struct varobj
*parent
, int index
)
4069 return ada_varobj_get_type_of_child (parent
->value
, parent
->type
,
4074 ada_value_of_variable (struct varobj
*var
, enum varobj_display_formats format
)
4076 struct value_print_options opts
;
4078 get_formatted_print_options (&opts
, format_code
[(int) format
]);
4082 return ada_varobj_get_value_of_variable (var
->value
, var
->type
, &opts
);
4085 /* Implement the "value_is_changeable_p" routine for Ada. */
4088 ada_value_is_changeable_p (struct varobj
*var
)
4090 struct type
*type
= var
->value
? value_type (var
->value
) : var
->type
;
4092 if (ada_is_array_descriptor_type (type
)
4093 && TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
4095 /* This is in reality a pointer to an unconstrained array.
4096 its value is changeable. */
4100 if (ada_is_string_type (type
))
4102 /* We display the contents of the string in the array's
4103 "value" field. The contents can change, so consider
4104 that the array is changeable. */
4108 return default_value_is_changeable_p (var
);
4111 /* Implement the "value_has_mutated" routine for Ada. */
4114 ada_value_has_mutated (struct varobj
*var
, struct value
*new_val
,
4115 struct type
*new_type
)
4121 /* If the number of fields have changed, then for sure the type
4123 if (ada_varobj_get_number_of_children (new_val
, new_type
)
4124 != var
->num_children
)
4127 /* If the number of fields have remained the same, then we need
4128 to check the name of each field. If they remain the same,
4129 then chances are the type hasn't mutated. This is technically
4130 an incomplete test, as the child's type might have changed
4131 despite the fact that the name remains the same. But we'll
4132 handle this situation by saying that the child has mutated,
4135 If only part (or none!) of the children have been fetched,
4136 then only check the ones we fetched. It does not matter
4137 to the frontend whether a child that it has not fetched yet
4138 has mutated or not. So just assume it hasn't. */
4140 restrict_range (var
->children
, &from
, &to
);
4141 for (i
= from
; i
< to
; i
++)
4142 if (strcmp (ada_varobj_get_name_of_child (new_val
, new_type
,
4144 VEC_index (varobj_p
, var
->children
, i
)->name
) != 0)
4150 /* Iterate all the existing _root_ VAROBJs and call the FUNC callback for them
4151 with an arbitrary caller supplied DATA pointer. */
4154 all_root_varobjs (void (*func
) (struct varobj
*var
, void *data
), void *data
)
4156 struct varobj_root
*var_root
, *var_root_next
;
4158 /* Iterate "safely" - handle if the callee deletes its passed VAROBJ. */
4160 for (var_root
= rootlist
; var_root
!= NULL
; var_root
= var_root_next
)
4162 var_root_next
= var_root
->next
;
4164 (*func
) (var_root
->rootvar
, data
);
4168 extern void _initialize_varobj (void);
4170 _initialize_varobj (void)
4172 int sizeof_table
= sizeof (struct vlist
*) * VAROBJ_TABLE_SIZE
;
4174 varobj_table
= xmalloc (sizeof_table
);
4175 memset (varobj_table
, 0, sizeof_table
);
4177 add_setshow_zinteger_cmd ("debugvarobj", class_maintenance
,
4179 _("Set varobj debugging."),
4180 _("Show varobj debugging."),
4181 _("When non-zero, varobj debugging is enabled."),
4182 NULL
, show_varobjdebug
,
4183 &setlist
, &showlist
);
4186 /* Invalidate varobj VAR if it is tied to locals and re-create it if it is
4187 defined on globals. It is a helper for varobj_invalidate. */
4190 varobj_invalidate_iter (struct varobj
*var
, void *unused
)
4192 /* Floating varobjs are reparsed on each stop, so we don't care if the
4193 presently parsed expression refers to something that's gone. */
4194 if (var
->root
->floating
)
4197 /* global var must be re-evaluated. */
4198 if (var
->root
->valid_block
== NULL
)
4200 struct varobj
*tmp_var
;
4202 /* Try to create a varobj with same expression. If we succeed
4203 replace the old varobj, otherwise invalidate it. */
4204 tmp_var
= varobj_create (NULL
, var
->name
, (CORE_ADDR
) 0,
4206 if (tmp_var
!= NULL
)
4208 tmp_var
->obj_name
= xstrdup (var
->obj_name
);
4209 varobj_delete (var
, NULL
, 0);
4210 install_variable (tmp_var
);
4213 var
->root
->is_valid
= 0;
4215 else /* locals must be invalidated. */
4216 var
->root
->is_valid
= 0;
4219 /* Invalidate the varobjs that are tied to locals and re-create the ones that
4220 are defined on globals.
4221 Invalidated varobjs will be always printed in_scope="invalid". */
4224 varobj_invalidate (void)
4226 all_root_varobjs (varobj_invalidate_iter
, NULL
);