1b725ae77Skettenis /* Implementation of the GDB variable objects API.
2b725ae77Skettenis Copyright 1999, 2000, 2001 Free Software Foundation, Inc.
3b725ae77Skettenis
4b725ae77Skettenis This program is free software; you can redistribute it and/or modify
5b725ae77Skettenis it under the terms of the GNU General Public License as published by
6b725ae77Skettenis the Free Software Foundation; either version 2 of the License, or
7b725ae77Skettenis (at your option) any later version.
8b725ae77Skettenis
9b725ae77Skettenis This program is distributed in the hope that it will be useful,
10b725ae77Skettenis but WITHOUT ANY WARRANTY; without even the implied warranty of
11b725ae77Skettenis MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12b725ae77Skettenis GNU General Public License for more details.
13b725ae77Skettenis
14b725ae77Skettenis You should have received a copy of the GNU General Public License
15b725ae77Skettenis along with this program; if not, write to the Free Software
16b725ae77Skettenis Foundation, Inc., 59 Temple Place - Suite 330,
17b725ae77Skettenis Boston, MA 02111-1307, USA. */
18b725ae77Skettenis
19b725ae77Skettenis #include "defs.h"
20b725ae77Skettenis #include "value.h"
21b725ae77Skettenis #include "expression.h"
22b725ae77Skettenis #include "frame.h"
23b725ae77Skettenis #include "language.h"
24b725ae77Skettenis #include "wrapper.h"
25b725ae77Skettenis #include "gdbcmd.h"
26b725ae77Skettenis #include "gdb_string.h"
27b725ae77Skettenis #include <math.h>
28b725ae77Skettenis
29b725ae77Skettenis #include "varobj.h"
30b725ae77Skettenis
31b725ae77Skettenis /* Non-zero if we want to see trace of varobj level stuff. */
32b725ae77Skettenis
33b725ae77Skettenis int varobjdebug = 0;
34b725ae77Skettenis
35b725ae77Skettenis /* String representations of gdb's format codes */
36b725ae77Skettenis char *varobj_format_string[] =
37b725ae77Skettenis { "natural", "binary", "decimal", "hexadecimal", "octal" };
38b725ae77Skettenis
39b725ae77Skettenis /* String representations of gdb's known languages */
40b725ae77Skettenis char *varobj_language_string[] = { "unknown", "C", "C++", "Java" };
41b725ae77Skettenis
42b725ae77Skettenis /* Data structures */
43b725ae77Skettenis
44b725ae77Skettenis /* Every root variable has one of these structures saved in its
45b725ae77Skettenis varobj. Members which must be free'd are noted. */
46b725ae77Skettenis struct varobj_root
47b725ae77Skettenis {
48b725ae77Skettenis
49b725ae77Skettenis /* Alloc'd expression for this parent. */
50b725ae77Skettenis struct expression *exp;
51b725ae77Skettenis
52b725ae77Skettenis /* Block for which this expression is valid */
53b725ae77Skettenis struct block *valid_block;
54b725ae77Skettenis
55b725ae77Skettenis /* The frame for this expression */
56b725ae77Skettenis struct frame_id frame;
57b725ae77Skettenis
58b725ae77Skettenis /* If 1, "update" always recomputes the frame & valid block
59b725ae77Skettenis using the currently selected frame. */
60b725ae77Skettenis int use_selected_frame;
61b725ae77Skettenis
62b725ae77Skettenis /* Language info for this variable and its children */
63b725ae77Skettenis struct language_specific *lang;
64b725ae77Skettenis
65b725ae77Skettenis /* The varobj for this root node. */
66b725ae77Skettenis struct varobj *rootvar;
67b725ae77Skettenis
68b725ae77Skettenis /* Next root variable */
69b725ae77Skettenis struct varobj_root *next;
70b725ae77Skettenis };
71b725ae77Skettenis
72b725ae77Skettenis /* Every variable in the system has a structure of this type defined
73b725ae77Skettenis for it. This structure holds all information necessary to manipulate
74b725ae77Skettenis a particular object variable. Members which must be freed are noted. */
75b725ae77Skettenis struct varobj
76b725ae77Skettenis {
77b725ae77Skettenis
78b725ae77Skettenis /* Alloc'd name of the variable for this object.. If this variable is a
79b725ae77Skettenis child, then this name will be the child's source name.
80b725ae77Skettenis (bar, not foo.bar) */
81b725ae77Skettenis /* NOTE: This is the "expression" */
82b725ae77Skettenis char *name;
83b725ae77Skettenis
84b725ae77Skettenis /* The alloc'd name for this variable's object. This is here for
85b725ae77Skettenis convenience when constructing this object's children. */
86b725ae77Skettenis char *obj_name;
87b725ae77Skettenis
88b725ae77Skettenis /* Index of this variable in its parent or -1 */
89b725ae77Skettenis int index;
90b725ae77Skettenis
91b725ae77Skettenis /* The type of this variable. This may NEVER be NULL. */
92b725ae77Skettenis struct type *type;
93b725ae77Skettenis
94b725ae77Skettenis /* The value of this expression or subexpression. This may be NULL. */
95b725ae77Skettenis struct value *value;
96b725ae77Skettenis
97b725ae77Skettenis /* Did an error occur evaluating the expression or getting its value? */
98b725ae77Skettenis int error;
99b725ae77Skettenis
100b725ae77Skettenis /* The number of (immediate) children this variable has */
101b725ae77Skettenis int num_children;
102b725ae77Skettenis
103b725ae77Skettenis /* If this object is a child, this points to its immediate parent. */
104b725ae77Skettenis struct varobj *parent;
105b725ae77Skettenis
106b725ae77Skettenis /* A list of this object's children */
107b725ae77Skettenis struct varobj_child *children;
108b725ae77Skettenis
109b725ae77Skettenis /* Description of the root variable. Points to root variable for children. */
110b725ae77Skettenis struct varobj_root *root;
111b725ae77Skettenis
112b725ae77Skettenis /* The format of the output for this object */
113b725ae77Skettenis enum varobj_display_formats format;
114b725ae77Skettenis
115b725ae77Skettenis /* Was this variable updated via a varobj_set_value operation */
116b725ae77Skettenis int updated;
117b725ae77Skettenis };
118b725ae77Skettenis
119b725ae77Skettenis /* Every variable keeps a linked list of its children, described
120b725ae77Skettenis by the following structure. */
121b725ae77Skettenis /* FIXME: Deprecated. All should use vlist instead */
122b725ae77Skettenis
123b725ae77Skettenis struct varobj_child
124b725ae77Skettenis {
125b725ae77Skettenis
126b725ae77Skettenis /* Pointer to the child's data */
127b725ae77Skettenis struct varobj *child;
128b725ae77Skettenis
129b725ae77Skettenis /* Pointer to the next child */
130b725ae77Skettenis struct varobj_child *next;
131b725ae77Skettenis };
132b725ae77Skettenis
133b725ae77Skettenis /* A stack of varobjs */
134b725ae77Skettenis /* FIXME: Deprecated. All should use vlist instead */
135b725ae77Skettenis
136b725ae77Skettenis struct vstack
137b725ae77Skettenis {
138b725ae77Skettenis struct varobj *var;
139b725ae77Skettenis struct vstack *next;
140b725ae77Skettenis };
141b725ae77Skettenis
142b725ae77Skettenis struct cpstack
143b725ae77Skettenis {
144b725ae77Skettenis char *name;
145b725ae77Skettenis struct cpstack *next;
146b725ae77Skettenis };
147b725ae77Skettenis
148b725ae77Skettenis /* A list of varobjs */
149b725ae77Skettenis
150b725ae77Skettenis struct vlist
151b725ae77Skettenis {
152b725ae77Skettenis struct varobj *var;
153b725ae77Skettenis struct vlist *next;
154b725ae77Skettenis };
155b725ae77Skettenis
156b725ae77Skettenis /* Private function prototypes */
157b725ae77Skettenis
158b725ae77Skettenis /* Helper functions for the above subcommands. */
159b725ae77Skettenis
160b725ae77Skettenis static int delete_variable (struct cpstack **, struct varobj *, int);
161b725ae77Skettenis
162b725ae77Skettenis static void delete_variable_1 (struct cpstack **, int *,
163b725ae77Skettenis struct varobj *, int, int);
164b725ae77Skettenis
165b725ae77Skettenis static int install_variable (struct varobj *);
166b725ae77Skettenis
167b725ae77Skettenis static void uninstall_variable (struct varobj *);
168b725ae77Skettenis
169b725ae77Skettenis static struct varobj *child_exists (struct varobj *, char *);
170b725ae77Skettenis
171b725ae77Skettenis static struct varobj *create_child (struct varobj *, int, char *);
172b725ae77Skettenis
173b725ae77Skettenis static void save_child_in_parent (struct varobj *, struct varobj *);
174b725ae77Skettenis
175b725ae77Skettenis static void remove_child_from_parent (struct varobj *, struct varobj *);
176b725ae77Skettenis
177b725ae77Skettenis /* Utility routines */
178b725ae77Skettenis
179b725ae77Skettenis static struct varobj *new_variable (void);
180b725ae77Skettenis
181b725ae77Skettenis static struct varobj *new_root_variable (void);
182b725ae77Skettenis
183b725ae77Skettenis static void free_variable (struct varobj *var);
184b725ae77Skettenis
185b725ae77Skettenis static struct cleanup *make_cleanup_free_variable (struct varobj *var);
186b725ae77Skettenis
187b725ae77Skettenis static struct type *get_type (struct varobj *var);
188b725ae77Skettenis
189b725ae77Skettenis static struct type *get_type_deref (struct varobj *var);
190b725ae77Skettenis
191b725ae77Skettenis static struct type *get_target_type (struct type *);
192b725ae77Skettenis
193b725ae77Skettenis static enum varobj_display_formats variable_default_display (struct varobj *);
194b725ae77Skettenis
195b725ae77Skettenis static int my_value_equal (struct value *, struct value *, int *);
196b725ae77Skettenis
197b725ae77Skettenis static void vpush (struct vstack **pstack, struct varobj *var);
198b725ae77Skettenis
199b725ae77Skettenis static struct varobj *vpop (struct vstack **pstack);
200b725ae77Skettenis
201b725ae77Skettenis static void cppush (struct cpstack **pstack, char *name);
202b725ae77Skettenis
203b725ae77Skettenis static char *cppop (struct cpstack **pstack);
204b725ae77Skettenis
205b725ae77Skettenis /* Language-specific routines. */
206b725ae77Skettenis
207b725ae77Skettenis static enum varobj_languages variable_language (struct varobj *var);
208b725ae77Skettenis
209b725ae77Skettenis static int number_of_children (struct varobj *);
210b725ae77Skettenis
211b725ae77Skettenis static char *name_of_variable (struct varobj *);
212b725ae77Skettenis
213b725ae77Skettenis static char *name_of_child (struct varobj *, int);
214b725ae77Skettenis
215b725ae77Skettenis static struct value *value_of_root (struct varobj **var_handle, int *);
216b725ae77Skettenis
217b725ae77Skettenis static struct value *value_of_child (struct varobj *parent, int index);
218b725ae77Skettenis
219b725ae77Skettenis static struct type *type_of_child (struct varobj *var);
220b725ae77Skettenis
221b725ae77Skettenis static int variable_editable (struct varobj *var);
222b725ae77Skettenis
223b725ae77Skettenis static char *my_value_of_variable (struct varobj *var);
224b725ae77Skettenis
225b725ae77Skettenis static int type_changeable (struct varobj *var);
226b725ae77Skettenis
227b725ae77Skettenis /* C implementation */
228b725ae77Skettenis
229b725ae77Skettenis static int c_number_of_children (struct varobj *var);
230b725ae77Skettenis
231b725ae77Skettenis static char *c_name_of_variable (struct varobj *parent);
232b725ae77Skettenis
233b725ae77Skettenis static char *c_name_of_child (struct varobj *parent, int index);
234b725ae77Skettenis
235b725ae77Skettenis static struct value *c_value_of_root (struct varobj **var_handle);
236b725ae77Skettenis
237b725ae77Skettenis static struct value *c_value_of_child (struct varobj *parent, int index);
238b725ae77Skettenis
239b725ae77Skettenis static struct type *c_type_of_child (struct varobj *parent, int index);
240b725ae77Skettenis
241b725ae77Skettenis static int c_variable_editable (struct varobj *var);
242b725ae77Skettenis
243b725ae77Skettenis static char *c_value_of_variable (struct varobj *var);
244b725ae77Skettenis
245b725ae77Skettenis /* C++ implementation */
246b725ae77Skettenis
247b725ae77Skettenis static int cplus_number_of_children (struct varobj *var);
248b725ae77Skettenis
249b725ae77Skettenis static void cplus_class_num_children (struct type *type, int children[3]);
250b725ae77Skettenis
251b725ae77Skettenis static char *cplus_name_of_variable (struct varobj *parent);
252b725ae77Skettenis
253b725ae77Skettenis static char *cplus_name_of_child (struct varobj *parent, int index);
254b725ae77Skettenis
255b725ae77Skettenis static struct value *cplus_value_of_root (struct varobj **var_handle);
256b725ae77Skettenis
257b725ae77Skettenis static struct value *cplus_value_of_child (struct varobj *parent, int index);
258b725ae77Skettenis
259b725ae77Skettenis static struct type *cplus_type_of_child (struct varobj *parent, int index);
260b725ae77Skettenis
261b725ae77Skettenis static int cplus_variable_editable (struct varobj *var);
262b725ae77Skettenis
263b725ae77Skettenis static char *cplus_value_of_variable (struct varobj *var);
264b725ae77Skettenis
265b725ae77Skettenis /* Java implementation */
266b725ae77Skettenis
267b725ae77Skettenis static int java_number_of_children (struct varobj *var);
268b725ae77Skettenis
269b725ae77Skettenis static char *java_name_of_variable (struct varobj *parent);
270b725ae77Skettenis
271b725ae77Skettenis static char *java_name_of_child (struct varobj *parent, int index);
272b725ae77Skettenis
273b725ae77Skettenis static struct value *java_value_of_root (struct varobj **var_handle);
274b725ae77Skettenis
275b725ae77Skettenis static struct value *java_value_of_child (struct varobj *parent, int index);
276b725ae77Skettenis
277b725ae77Skettenis static struct type *java_type_of_child (struct varobj *parent, int index);
278b725ae77Skettenis
279b725ae77Skettenis static int java_variable_editable (struct varobj *var);
280b725ae77Skettenis
281b725ae77Skettenis static char *java_value_of_variable (struct varobj *var);
282b725ae77Skettenis
283b725ae77Skettenis /* The language specific vector */
284b725ae77Skettenis
285b725ae77Skettenis struct language_specific
286b725ae77Skettenis {
287b725ae77Skettenis
288b725ae77Skettenis /* The language of this variable */
289b725ae77Skettenis enum varobj_languages language;
290b725ae77Skettenis
291b725ae77Skettenis /* The number of children of PARENT. */
292b725ae77Skettenis int (*number_of_children) (struct varobj * parent);
293b725ae77Skettenis
294b725ae77Skettenis /* The name (expression) of a root varobj. */
295b725ae77Skettenis char *(*name_of_variable) (struct varobj * parent);
296b725ae77Skettenis
297b725ae77Skettenis /* The name of the INDEX'th child of PARENT. */
298b725ae77Skettenis char *(*name_of_child) (struct varobj * parent, int index);
299b725ae77Skettenis
300b725ae77Skettenis /* The ``struct value *'' of the root variable ROOT. */
301b725ae77Skettenis struct value *(*value_of_root) (struct varobj ** root_handle);
302b725ae77Skettenis
303b725ae77Skettenis /* The ``struct value *'' of the INDEX'th child of PARENT. */
304b725ae77Skettenis struct value *(*value_of_child) (struct varobj * parent, int index);
305b725ae77Skettenis
306b725ae77Skettenis /* The type of the INDEX'th child of PARENT. */
307b725ae77Skettenis struct type *(*type_of_child) (struct varobj * parent, int index);
308b725ae77Skettenis
309b725ae77Skettenis /* Is VAR editable? */
310b725ae77Skettenis int (*variable_editable) (struct varobj * var);
311b725ae77Skettenis
312b725ae77Skettenis /* The current value of VAR. */
313b725ae77Skettenis char *(*value_of_variable) (struct varobj * var);
314b725ae77Skettenis };
315b725ae77Skettenis
316b725ae77Skettenis /* Array of known source language routines. */
317b725ae77Skettenis static struct language_specific
318b725ae77Skettenis languages[vlang_end][sizeof (struct language_specific)] = {
319b725ae77Skettenis /* Unknown (try treating as C */
320b725ae77Skettenis {
321b725ae77Skettenis vlang_unknown,
322b725ae77Skettenis c_number_of_children,
323b725ae77Skettenis c_name_of_variable,
324b725ae77Skettenis c_name_of_child,
325b725ae77Skettenis c_value_of_root,
326b725ae77Skettenis c_value_of_child,
327b725ae77Skettenis c_type_of_child,
328b725ae77Skettenis c_variable_editable,
329b725ae77Skettenis c_value_of_variable}
330b725ae77Skettenis ,
331b725ae77Skettenis /* C */
332b725ae77Skettenis {
333b725ae77Skettenis vlang_c,
334b725ae77Skettenis c_number_of_children,
335b725ae77Skettenis c_name_of_variable,
336b725ae77Skettenis c_name_of_child,
337b725ae77Skettenis c_value_of_root,
338b725ae77Skettenis c_value_of_child,
339b725ae77Skettenis c_type_of_child,
340b725ae77Skettenis c_variable_editable,
341b725ae77Skettenis c_value_of_variable}
342b725ae77Skettenis ,
343b725ae77Skettenis /* C++ */
344b725ae77Skettenis {
345b725ae77Skettenis vlang_cplus,
346b725ae77Skettenis cplus_number_of_children,
347b725ae77Skettenis cplus_name_of_variable,
348b725ae77Skettenis cplus_name_of_child,
349b725ae77Skettenis cplus_value_of_root,
350b725ae77Skettenis cplus_value_of_child,
351b725ae77Skettenis cplus_type_of_child,
352b725ae77Skettenis cplus_variable_editable,
353b725ae77Skettenis cplus_value_of_variable}
354b725ae77Skettenis ,
355b725ae77Skettenis /* Java */
356b725ae77Skettenis {
357b725ae77Skettenis vlang_java,
358b725ae77Skettenis java_number_of_children,
359b725ae77Skettenis java_name_of_variable,
360b725ae77Skettenis java_name_of_child,
361b725ae77Skettenis java_value_of_root,
362b725ae77Skettenis java_value_of_child,
363b725ae77Skettenis java_type_of_child,
364b725ae77Skettenis java_variable_editable,
365b725ae77Skettenis java_value_of_variable}
366b725ae77Skettenis };
367b725ae77Skettenis
368b725ae77Skettenis /* A little convenience enum for dealing with C++/Java */
369b725ae77Skettenis enum vsections
370b725ae77Skettenis {
371b725ae77Skettenis v_public = 0, v_private, v_protected
372b725ae77Skettenis };
373b725ae77Skettenis
374b725ae77Skettenis /* Private data */
375b725ae77Skettenis
376b725ae77Skettenis /* Mappings of varobj_display_formats enums to gdb's format codes */
377b725ae77Skettenis static int format_code[] = { 0, 't', 'd', 'x', 'o' };
378b725ae77Skettenis
379b725ae77Skettenis /* Header of the list of root variable objects */
380b725ae77Skettenis static struct varobj_root *rootlist;
381b725ae77Skettenis static int rootcount = 0; /* number of root varobjs in the list */
382b725ae77Skettenis
383b725ae77Skettenis /* Prime number indicating the number of buckets in the hash table */
384b725ae77Skettenis /* A prime large enough to avoid too many colisions */
385b725ae77Skettenis #define VAROBJ_TABLE_SIZE 227
386b725ae77Skettenis
387b725ae77Skettenis /* Pointer to the varobj hash table (built at run time) */
388b725ae77Skettenis static struct vlist **varobj_table;
389b725ae77Skettenis
390b725ae77Skettenis /* Is the variable X one of our "fake" children? */
391b725ae77Skettenis #define CPLUS_FAKE_CHILD(x) \
392b725ae77Skettenis ((x) != NULL && (x)->type == NULL && (x)->value == NULL)
393b725ae77Skettenis
394b725ae77Skettenis
395b725ae77Skettenis /* API Implementation */
396b725ae77Skettenis
397b725ae77Skettenis /* Creates a varobj (not its children) */
398b725ae77Skettenis
399b725ae77Skettenis /* Return the full FRAME which corresponds to the given CORE_ADDR
400b725ae77Skettenis or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
401b725ae77Skettenis
402b725ae77Skettenis static struct frame_info *
find_frame_addr_in_frame_chain(CORE_ADDR frame_addr)403b725ae77Skettenis find_frame_addr_in_frame_chain (CORE_ADDR frame_addr)
404b725ae77Skettenis {
405b725ae77Skettenis struct frame_info *frame = NULL;
406b725ae77Skettenis
407b725ae77Skettenis if (frame_addr == (CORE_ADDR) 0)
408b725ae77Skettenis return NULL;
409b725ae77Skettenis
410b725ae77Skettenis while (1)
411b725ae77Skettenis {
412b725ae77Skettenis frame = get_prev_frame (frame);
413b725ae77Skettenis if (frame == NULL)
414b725ae77Skettenis return NULL;
415b725ae77Skettenis if (get_frame_base_address (frame) == frame_addr)
416b725ae77Skettenis return frame;
417b725ae77Skettenis }
418b725ae77Skettenis }
419b725ae77Skettenis
420b725ae77Skettenis struct varobj *
varobj_create(char * objname,char * expression,CORE_ADDR frame,enum varobj_type type)421b725ae77Skettenis varobj_create (char *objname,
422b725ae77Skettenis char *expression, CORE_ADDR frame, enum varobj_type type)
423b725ae77Skettenis {
424b725ae77Skettenis struct varobj *var;
425b725ae77Skettenis struct frame_info *fi;
426b725ae77Skettenis struct frame_info *old_fi = NULL;
427b725ae77Skettenis struct block *block;
428b725ae77Skettenis struct cleanup *old_chain;
429b725ae77Skettenis
430b725ae77Skettenis /* Fill out a varobj structure for the (root) variable being constructed. */
431b725ae77Skettenis var = new_root_variable ();
432b725ae77Skettenis old_chain = make_cleanup_free_variable (var);
433b725ae77Skettenis
434b725ae77Skettenis if (expression != NULL)
435b725ae77Skettenis {
436b725ae77Skettenis char *p;
437b725ae77Skettenis enum varobj_languages lang;
438b725ae77Skettenis
439b725ae77Skettenis /* Parse and evaluate the expression, filling in as much
440b725ae77Skettenis of the variable's data as possible */
441b725ae77Skettenis
442b725ae77Skettenis /* Allow creator to specify context of variable */
443b725ae77Skettenis if ((type == USE_CURRENT_FRAME) || (type == USE_SELECTED_FRAME))
444b725ae77Skettenis fi = deprecated_selected_frame;
445b725ae77Skettenis else
446b725ae77Skettenis /* FIXME: cagney/2002-11-23: This code should be doing a
447b725ae77Skettenis lookup using the frame ID and not just the frame's
448b725ae77Skettenis ``address''. This, of course, means an interface change.
449b725ae77Skettenis However, with out that interface change ISAs, such as the
450b725ae77Skettenis ia64 with its two stacks, won't work. Similar goes for the
451b725ae77Skettenis case where there is a frameless function. */
452b725ae77Skettenis fi = find_frame_addr_in_frame_chain (frame);
453b725ae77Skettenis
454b725ae77Skettenis /* frame = -2 means always use selected frame */
455b725ae77Skettenis if (type == USE_SELECTED_FRAME)
456b725ae77Skettenis var->root->use_selected_frame = 1;
457b725ae77Skettenis
458b725ae77Skettenis block = NULL;
459b725ae77Skettenis if (fi != NULL)
460b725ae77Skettenis block = get_frame_block (fi, 0);
461b725ae77Skettenis
462b725ae77Skettenis p = expression;
463b725ae77Skettenis innermost_block = NULL;
464b725ae77Skettenis /* Wrap the call to parse expression, so we can
465b725ae77Skettenis return a sensible error. */
466b725ae77Skettenis if (!gdb_parse_exp_1 (&p, block, 0, &var->root->exp))
467b725ae77Skettenis {
468b725ae77Skettenis return NULL;
469b725ae77Skettenis }
470b725ae77Skettenis
471b725ae77Skettenis /* Don't allow variables to be created for types. */
472b725ae77Skettenis if (var->root->exp->elts[0].opcode == OP_TYPE)
473b725ae77Skettenis {
474b725ae77Skettenis do_cleanups (old_chain);
475b725ae77Skettenis fprintf_unfiltered (gdb_stderr,
476b725ae77Skettenis "Attempt to use a type name as an expression.");
477b725ae77Skettenis return NULL;
478b725ae77Skettenis }
479b725ae77Skettenis
480b725ae77Skettenis var->format = variable_default_display (var);
481b725ae77Skettenis var->root->valid_block = innermost_block;
482b725ae77Skettenis var->name = savestring (expression, strlen (expression));
483b725ae77Skettenis
484b725ae77Skettenis /* When the frame is different from the current frame,
485b725ae77Skettenis we must select the appropriate frame before parsing
486b725ae77Skettenis the expression, otherwise the value will not be current.
487b725ae77Skettenis Since select_frame is so benign, just call it for all cases. */
488b725ae77Skettenis if (fi != NULL)
489b725ae77Skettenis {
490b725ae77Skettenis var->root->frame = get_frame_id (fi);
491b725ae77Skettenis old_fi = deprecated_selected_frame;
492b725ae77Skettenis select_frame (fi);
493b725ae77Skettenis }
494b725ae77Skettenis
495b725ae77Skettenis /* We definitively need to catch errors here.
496b725ae77Skettenis If evaluate_expression succeeds we got the value we wanted.
497b725ae77Skettenis But if it fails, we still go on with a call to evaluate_type() */
498b725ae77Skettenis if (gdb_evaluate_expression (var->root->exp, &var->value))
499b725ae77Skettenis {
500b725ae77Skettenis /* no error */
501b725ae77Skettenis release_value (var->value);
502b725ae77Skettenis if (VALUE_LAZY (var->value))
503b725ae77Skettenis gdb_value_fetch_lazy (var->value);
504b725ae77Skettenis }
505b725ae77Skettenis else
506b725ae77Skettenis var->value = evaluate_type (var->root->exp);
507b725ae77Skettenis
508b725ae77Skettenis var->type = VALUE_TYPE (var->value);
509b725ae77Skettenis
510b725ae77Skettenis /* Set language info */
511b725ae77Skettenis lang = variable_language (var);
512b725ae77Skettenis var->root->lang = languages[lang];
513b725ae77Skettenis
514b725ae77Skettenis /* Set ourselves as our root */
515b725ae77Skettenis var->root->rootvar = var;
516b725ae77Skettenis
517b725ae77Skettenis /* Reset the selected frame */
518b725ae77Skettenis if (fi != NULL)
519b725ae77Skettenis select_frame (old_fi);
520b725ae77Skettenis }
521b725ae77Skettenis
522b725ae77Skettenis /* If the variable object name is null, that means this
523b725ae77Skettenis is a temporary variable, so don't install it. */
524b725ae77Skettenis
525b725ae77Skettenis if ((var != NULL) && (objname != NULL))
526b725ae77Skettenis {
527b725ae77Skettenis var->obj_name = savestring (objname, strlen (objname));
528b725ae77Skettenis
529b725ae77Skettenis /* If a varobj name is duplicated, the install will fail so
530b725ae77Skettenis we must clenup */
531b725ae77Skettenis if (!install_variable (var))
532b725ae77Skettenis {
533b725ae77Skettenis do_cleanups (old_chain);
534b725ae77Skettenis return NULL;
535b725ae77Skettenis }
536b725ae77Skettenis }
537b725ae77Skettenis
538b725ae77Skettenis discard_cleanups (old_chain);
539b725ae77Skettenis return var;
540b725ae77Skettenis }
541b725ae77Skettenis
542b725ae77Skettenis /* Generates an unique name that can be used for a varobj */
543b725ae77Skettenis
544b725ae77Skettenis char *
varobj_gen_name(void)545b725ae77Skettenis varobj_gen_name (void)
546b725ae77Skettenis {
547b725ae77Skettenis static int id = 0;
548b725ae77Skettenis char *obj_name;
549b725ae77Skettenis
550b725ae77Skettenis /* generate a name for this object */
551b725ae77Skettenis id++;
55211efff7fSkettenis obj_name = xstrprintf ("var%d", id);
553b725ae77Skettenis
554b725ae77Skettenis return obj_name;
555b725ae77Skettenis }
556b725ae77Skettenis
557b725ae77Skettenis /* Given an "objname", returns the pointer to the corresponding varobj
558b725ae77Skettenis or NULL if not found */
559b725ae77Skettenis
560b725ae77Skettenis struct varobj *
varobj_get_handle(char * objname)561b725ae77Skettenis varobj_get_handle (char *objname)
562b725ae77Skettenis {
563b725ae77Skettenis struct vlist *cv;
564b725ae77Skettenis const char *chp;
565b725ae77Skettenis unsigned int index = 0;
566b725ae77Skettenis unsigned int i = 1;
567b725ae77Skettenis
568b725ae77Skettenis for (chp = objname; *chp; chp++)
569b725ae77Skettenis {
570b725ae77Skettenis index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
571b725ae77Skettenis }
572b725ae77Skettenis
573b725ae77Skettenis cv = *(varobj_table + index);
574b725ae77Skettenis while ((cv != NULL) && (strcmp (cv->var->obj_name, objname) != 0))
575b725ae77Skettenis cv = cv->next;
576b725ae77Skettenis
577b725ae77Skettenis if (cv == NULL)
578b725ae77Skettenis error ("Variable object not found");
579b725ae77Skettenis
580b725ae77Skettenis return cv->var;
581b725ae77Skettenis }
582b725ae77Skettenis
583b725ae77Skettenis /* Given the handle, return the name of the object */
584b725ae77Skettenis
585b725ae77Skettenis char *
varobj_get_objname(struct varobj * var)586b725ae77Skettenis varobj_get_objname (struct varobj *var)
587b725ae77Skettenis {
588b725ae77Skettenis return var->obj_name;
589b725ae77Skettenis }
590b725ae77Skettenis
591b725ae77Skettenis /* Given the handle, return the expression represented by the object */
592b725ae77Skettenis
593b725ae77Skettenis char *
varobj_get_expression(struct varobj * var)594b725ae77Skettenis varobj_get_expression (struct varobj *var)
595b725ae77Skettenis {
596b725ae77Skettenis return name_of_variable (var);
597b725ae77Skettenis }
598b725ae77Skettenis
599b725ae77Skettenis /* Deletes a varobj and all its children if only_children == 0,
600b725ae77Skettenis otherwise deletes only the children; returns a malloc'ed list of all the
601b725ae77Skettenis (malloc'ed) names of the variables that have been deleted (NULL terminated) */
602b725ae77Skettenis
603b725ae77Skettenis int
varobj_delete(struct varobj * var,char *** dellist,int only_children)604b725ae77Skettenis varobj_delete (struct varobj *var, char ***dellist, int only_children)
605b725ae77Skettenis {
606b725ae77Skettenis int delcount;
607b725ae77Skettenis int mycount;
608b725ae77Skettenis struct cpstack *result = NULL;
609b725ae77Skettenis char **cp;
610b725ae77Skettenis
611b725ae77Skettenis /* Initialize a stack for temporary results */
612b725ae77Skettenis cppush (&result, NULL);
613b725ae77Skettenis
614b725ae77Skettenis if (only_children)
615b725ae77Skettenis /* Delete only the variable children */
616b725ae77Skettenis delcount = delete_variable (&result, var, 1 /* only the children */ );
617b725ae77Skettenis else
618b725ae77Skettenis /* Delete the variable and all its children */
619b725ae77Skettenis delcount = delete_variable (&result, var, 0 /* parent+children */ );
620b725ae77Skettenis
621b725ae77Skettenis /* We may have been asked to return a list of what has been deleted */
622b725ae77Skettenis if (dellist != NULL)
623b725ae77Skettenis {
624b725ae77Skettenis *dellist = xmalloc ((delcount + 1) * sizeof (char *));
625b725ae77Skettenis
626b725ae77Skettenis cp = *dellist;
627b725ae77Skettenis mycount = delcount;
628b725ae77Skettenis *cp = cppop (&result);
629b725ae77Skettenis while ((*cp != NULL) && (mycount > 0))
630b725ae77Skettenis {
631b725ae77Skettenis mycount--;
632b725ae77Skettenis cp++;
633b725ae77Skettenis *cp = cppop (&result);
634b725ae77Skettenis }
635b725ae77Skettenis
636b725ae77Skettenis if (mycount || (*cp != NULL))
637b725ae77Skettenis warning ("varobj_delete: assertion failed - mycount(=%d) <> 0",
638b725ae77Skettenis mycount);
639b725ae77Skettenis }
640b725ae77Skettenis
641b725ae77Skettenis return delcount;
642b725ae77Skettenis }
643b725ae77Skettenis
644b725ae77Skettenis /* Set/Get variable object display format */
645b725ae77Skettenis
646b725ae77Skettenis enum varobj_display_formats
varobj_set_display_format(struct varobj * var,enum varobj_display_formats format)647b725ae77Skettenis varobj_set_display_format (struct varobj *var,
648b725ae77Skettenis enum varobj_display_formats format)
649b725ae77Skettenis {
650b725ae77Skettenis switch (format)
651b725ae77Skettenis {
652b725ae77Skettenis case FORMAT_NATURAL:
653b725ae77Skettenis case FORMAT_BINARY:
654b725ae77Skettenis case FORMAT_DECIMAL:
655b725ae77Skettenis case FORMAT_HEXADECIMAL:
656b725ae77Skettenis case FORMAT_OCTAL:
657b725ae77Skettenis var->format = format;
658b725ae77Skettenis break;
659b725ae77Skettenis
660b725ae77Skettenis default:
661b725ae77Skettenis var->format = variable_default_display (var);
662b725ae77Skettenis }
663b725ae77Skettenis
664b725ae77Skettenis return var->format;
665b725ae77Skettenis }
666b725ae77Skettenis
667b725ae77Skettenis enum varobj_display_formats
varobj_get_display_format(struct varobj * var)668b725ae77Skettenis varobj_get_display_format (struct varobj *var)
669b725ae77Skettenis {
670b725ae77Skettenis return var->format;
671b725ae77Skettenis }
672b725ae77Skettenis
673b725ae77Skettenis int
varobj_get_num_children(struct varobj * var)674b725ae77Skettenis varobj_get_num_children (struct varobj *var)
675b725ae77Skettenis {
676b725ae77Skettenis if (var->num_children == -1)
677b725ae77Skettenis var->num_children = number_of_children (var);
678b725ae77Skettenis
679b725ae77Skettenis return var->num_children;
680b725ae77Skettenis }
681b725ae77Skettenis
682b725ae77Skettenis /* Creates a list of the immediate children of a variable object;
683b725ae77Skettenis the return code is the number of such children or -1 on error */
684b725ae77Skettenis
685b725ae77Skettenis int
varobj_list_children(struct varobj * var,struct varobj *** childlist)686b725ae77Skettenis varobj_list_children (struct varobj *var, struct varobj ***childlist)
687b725ae77Skettenis {
688b725ae77Skettenis struct varobj *child;
689b725ae77Skettenis char *name;
690b725ae77Skettenis int i;
691b725ae77Skettenis
692b725ae77Skettenis /* sanity check: have we been passed a pointer? */
693b725ae77Skettenis if (childlist == NULL)
694b725ae77Skettenis return -1;
695b725ae77Skettenis
696b725ae77Skettenis *childlist = NULL;
697b725ae77Skettenis
698b725ae77Skettenis if (var->num_children == -1)
699b725ae77Skettenis var->num_children = number_of_children (var);
700b725ae77Skettenis
701b725ae77Skettenis /* List of children */
702b725ae77Skettenis *childlist = xmalloc ((var->num_children + 1) * sizeof (struct varobj *));
703b725ae77Skettenis
704b725ae77Skettenis for (i = 0; i < var->num_children; i++)
705b725ae77Skettenis {
706b725ae77Skettenis /* Mark as the end in case we bail out */
707b725ae77Skettenis *((*childlist) + i) = NULL;
708b725ae77Skettenis
709b725ae77Skettenis /* check if child exists, if not create */
710b725ae77Skettenis name = name_of_child (var, i);
711b725ae77Skettenis child = child_exists (var, name);
712b725ae77Skettenis if (child == NULL)
713b725ae77Skettenis child = create_child (var, i, name);
714b725ae77Skettenis
715b725ae77Skettenis *((*childlist) + i) = child;
716b725ae77Skettenis }
717b725ae77Skettenis
718b725ae77Skettenis /* End of list is marked by a NULL pointer */
719b725ae77Skettenis *((*childlist) + i) = NULL;
720b725ae77Skettenis
721b725ae77Skettenis return var->num_children;
722b725ae77Skettenis }
723b725ae77Skettenis
724b725ae77Skettenis /* Obtain the type of an object Variable as a string similar to the one gdb
725b725ae77Skettenis prints on the console */
726b725ae77Skettenis
727b725ae77Skettenis char *
varobj_get_type(struct varobj * var)728b725ae77Skettenis varobj_get_type (struct varobj *var)
729b725ae77Skettenis {
730b725ae77Skettenis struct value *val;
731b725ae77Skettenis struct cleanup *old_chain;
732b725ae77Skettenis struct ui_file *stb;
733b725ae77Skettenis char *thetype;
734b725ae77Skettenis long length;
735b725ae77Skettenis
736b725ae77Skettenis /* For the "fake" variables, do not return a type. (It's type is
737b725ae77Skettenis NULL, too.) */
738b725ae77Skettenis if (CPLUS_FAKE_CHILD (var))
739b725ae77Skettenis return NULL;
740b725ae77Skettenis
741b725ae77Skettenis stb = mem_fileopen ();
742b725ae77Skettenis old_chain = make_cleanup_ui_file_delete (stb);
743b725ae77Skettenis
744b725ae77Skettenis /* To print the type, we simply create a zero ``struct value *'' and
745b725ae77Skettenis cast it to our type. We then typeprint this variable. */
746b725ae77Skettenis val = value_zero (var->type, not_lval);
747b725ae77Skettenis type_print (VALUE_TYPE (val), "", stb, -1);
748b725ae77Skettenis
749b725ae77Skettenis thetype = ui_file_xstrdup (stb, &length);
750b725ae77Skettenis do_cleanups (old_chain);
751b725ae77Skettenis return thetype;
752b725ae77Skettenis }
753b725ae77Skettenis
754b725ae77Skettenis enum varobj_languages
varobj_get_language(struct varobj * var)755b725ae77Skettenis varobj_get_language (struct varobj *var)
756b725ae77Skettenis {
757b725ae77Skettenis return variable_language (var);
758b725ae77Skettenis }
759b725ae77Skettenis
760b725ae77Skettenis int
varobj_get_attributes(struct varobj * var)761b725ae77Skettenis varobj_get_attributes (struct varobj *var)
762b725ae77Skettenis {
763b725ae77Skettenis int attributes = 0;
764b725ae77Skettenis
765b725ae77Skettenis if (variable_editable (var))
766b725ae77Skettenis /* FIXME: define masks for attributes */
767b725ae77Skettenis attributes |= 0x00000001; /* Editable */
768b725ae77Skettenis
769b725ae77Skettenis return attributes;
770b725ae77Skettenis }
771b725ae77Skettenis
772b725ae77Skettenis char *
varobj_get_value(struct varobj * var)773b725ae77Skettenis varobj_get_value (struct varobj *var)
774b725ae77Skettenis {
775b725ae77Skettenis return my_value_of_variable (var);
776b725ae77Skettenis }
777b725ae77Skettenis
778b725ae77Skettenis /* Set the value of an object variable (if it is editable) to the
779b725ae77Skettenis value of the given expression */
780b725ae77Skettenis /* Note: Invokes functions that can call error() */
781b725ae77Skettenis
782b725ae77Skettenis int
varobj_set_value(struct varobj * var,char * expression)783b725ae77Skettenis varobj_set_value (struct varobj *var, char *expression)
784b725ae77Skettenis {
785b725ae77Skettenis struct value *val;
786b725ae77Skettenis int error;
787b725ae77Skettenis int offset = 0;
788b725ae77Skettenis
789b725ae77Skettenis /* The argument "expression" contains the variable's new value.
790b725ae77Skettenis We need to first construct a legal expression for this -- ugh! */
791b725ae77Skettenis /* Does this cover all the bases? */
792b725ae77Skettenis struct expression *exp;
793b725ae77Skettenis struct value *value;
794b725ae77Skettenis int saved_input_radix = input_radix;
795b725ae77Skettenis
796b725ae77Skettenis if (var->value != NULL && variable_editable (var) && !var->error)
797b725ae77Skettenis {
798b725ae77Skettenis char *s = expression;
799b725ae77Skettenis int i;
800b725ae77Skettenis
801b725ae77Skettenis input_radix = 10; /* ALWAYS reset to decimal temporarily */
802b725ae77Skettenis if (!gdb_parse_exp_1 (&s, 0, 0, &exp))
803b725ae77Skettenis /* We cannot proceed without a well-formed expression. */
804b725ae77Skettenis return 0;
805b725ae77Skettenis if (!gdb_evaluate_expression (exp, &value))
806b725ae77Skettenis {
807b725ae77Skettenis /* We cannot proceed without a valid expression. */
808b725ae77Skettenis xfree (exp);
809b725ae77Skettenis return 0;
810b725ae77Skettenis }
811b725ae77Skettenis
812b725ae77Skettenis if (!my_value_equal (var->value, value, &error))
813b725ae77Skettenis var->updated = 1;
814b725ae77Skettenis if (!gdb_value_assign (var->value, value, &val))
815b725ae77Skettenis return 0;
816b725ae77Skettenis value_free (var->value);
817b725ae77Skettenis release_value (val);
818b725ae77Skettenis var->value = val;
819b725ae77Skettenis input_radix = saved_input_radix;
820b725ae77Skettenis return 1;
821b725ae77Skettenis }
822b725ae77Skettenis
823b725ae77Skettenis return 0;
824b725ae77Skettenis }
825b725ae77Skettenis
826b725ae77Skettenis /* Returns a malloc'ed list with all root variable objects */
827b725ae77Skettenis int
varobj_list(struct varobj *** varlist)828b725ae77Skettenis varobj_list (struct varobj ***varlist)
829b725ae77Skettenis {
830b725ae77Skettenis struct varobj **cv;
831b725ae77Skettenis struct varobj_root *croot;
832b725ae77Skettenis int mycount = rootcount;
833b725ae77Skettenis
834b725ae77Skettenis /* Alloc (rootcount + 1) entries for the result */
835b725ae77Skettenis *varlist = xmalloc ((rootcount + 1) * sizeof (struct varobj *));
836b725ae77Skettenis
837b725ae77Skettenis cv = *varlist;
838b725ae77Skettenis croot = rootlist;
839b725ae77Skettenis while ((croot != NULL) && (mycount > 0))
840b725ae77Skettenis {
841b725ae77Skettenis *cv = croot->rootvar;
842b725ae77Skettenis mycount--;
843b725ae77Skettenis cv++;
844b725ae77Skettenis croot = croot->next;
845b725ae77Skettenis }
846b725ae77Skettenis /* Mark the end of the list */
847b725ae77Skettenis *cv = NULL;
848b725ae77Skettenis
849b725ae77Skettenis if (mycount || (croot != NULL))
850b725ae77Skettenis warning
851b725ae77Skettenis ("varobj_list: assertion failed - wrong tally of root vars (%d:%d)",
852b725ae77Skettenis rootcount, mycount);
853b725ae77Skettenis
854b725ae77Skettenis return rootcount;
855b725ae77Skettenis }
856b725ae77Skettenis
857*15135fadSkurt void
varobj_refresh(void)858*15135fadSkurt varobj_refresh (void)
859*15135fadSkurt {
860*15135fadSkurt struct varobj *var;
861*15135fadSkurt struct varobj_root *croot;
862*15135fadSkurt int mycount = rootcount;
863*15135fadSkurt char * name;
864*15135fadSkurt
865*15135fadSkurt croot = rootlist;
866*15135fadSkurt while ((croot != NULL) && (mycount > 0))
867*15135fadSkurt {
868*15135fadSkurt var = croot->rootvar;
869*15135fadSkurt
870*15135fadSkurt /* Get rid of the memory for the old expression. This also
871*15135fadSkurt leaves var->root->exp == NULL, which is ok for the parsing
872*15135fadSkurt below. */
873*15135fadSkurt free_current_contents ((char **) &var->root->exp);
874*15135fadSkurt
875*15135fadSkurt value_free (var->value);
876*15135fadSkurt var->type = NULL;
877*15135fadSkurt
878*15135fadSkurt name = xstrdup (var->name);
879*15135fadSkurt
880*15135fadSkurt /* Reparse the expression. Wrap the call to parse expression,
881*15135fadSkurt so we can return a sensible error. */
882*15135fadSkurt if (!gdb_parse_exp_1 (&name, var->root->valid_block, 0, &var->root->exp))
883*15135fadSkurt {
884*15135fadSkurt return;
885*15135fadSkurt }
886*15135fadSkurt
887*15135fadSkurt /* We definitively need to catch errors here.
888*15135fadSkurt If evaluate_expression succeeds we got the value we wanted.
889*15135fadSkurt But if it fails, we still go on with a call to evaluate_type() */
890*15135fadSkurt if (gdb_evaluate_expression (var->root->exp, &var->value))
891*15135fadSkurt {
892*15135fadSkurt /* no error */
893*15135fadSkurt release_value (var->value);
894*15135fadSkurt if (VALUE_LAZY (var->value))
895*15135fadSkurt gdb_value_fetch_lazy (var->value);
896*15135fadSkurt }
897*15135fadSkurt else
898*15135fadSkurt var->value = evaluate_type (var->root->exp);
899*15135fadSkurt
900*15135fadSkurt var->type = VALUE_TYPE (var->value);
901*15135fadSkurt
902*15135fadSkurt mycount--;
903*15135fadSkurt croot = croot->next;
904*15135fadSkurt }
905*15135fadSkurt
906*15135fadSkurt if (mycount || (croot != NULL))
907*15135fadSkurt warning
908*15135fadSkurt ("varobj_refresh: assertion failed - wrong tally of root vars (%d:%d)",
909*15135fadSkurt rootcount, mycount);
910*15135fadSkurt }
911*15135fadSkurt
912*15135fadSkurt
913b725ae77Skettenis /* Update the values for a variable and its children. This is a
914b725ae77Skettenis two-pronged attack. First, re-parse the value for the root's
915b725ae77Skettenis expression to see if it's changed. Then go all the way
916b725ae77Skettenis through its children, reconstructing them and noting if they've
917b725ae77Skettenis changed.
918b725ae77Skettenis Return value:
919b725ae77Skettenis -1 if there was an error updating the varobj
920b725ae77Skettenis -2 if the type changed
921b725ae77Skettenis Otherwise it is the number of children + parent changed
922b725ae77Skettenis
923b725ae77Skettenis Only root variables can be updated...
924b725ae77Skettenis
925b725ae77Skettenis NOTE: This function may delete the caller's varobj. If it
926b725ae77Skettenis returns -2, then it has done this and VARP will be modified
927b725ae77Skettenis to point to the new varobj. */
928b725ae77Skettenis
929b725ae77Skettenis int
varobj_update(struct varobj ** varp,struct varobj *** changelist)930b725ae77Skettenis varobj_update (struct varobj **varp, struct varobj ***changelist)
931b725ae77Skettenis {
932b725ae77Skettenis int changed = 0;
933b725ae77Skettenis int type_changed;
934b725ae77Skettenis int i;
935b725ae77Skettenis int vleft;
936b725ae77Skettenis int error2;
937b725ae77Skettenis struct varobj *v;
938b725ae77Skettenis struct varobj **cv;
939b725ae77Skettenis struct varobj **templist = NULL;
940b725ae77Skettenis struct value *new;
941b725ae77Skettenis struct vstack *stack = NULL;
942b725ae77Skettenis struct vstack *result = NULL;
943b725ae77Skettenis struct frame_id old_fid;
944b725ae77Skettenis struct frame_info *fi;
945b725ae77Skettenis
946b725ae77Skettenis /* sanity check: have we been passed a pointer? */
947b725ae77Skettenis if (changelist == NULL)
948b725ae77Skettenis return -1;
949b725ae77Skettenis
950b725ae77Skettenis /* Only root variables can be updated... */
951b725ae77Skettenis if ((*varp)->root->rootvar != *varp)
952b725ae77Skettenis /* Not a root var */
953b725ae77Skettenis return -1;
954b725ae77Skettenis
955b725ae77Skettenis /* Save the selected stack frame, since we will need to change it
956b725ae77Skettenis in order to evaluate expressions. */
957b725ae77Skettenis old_fid = get_frame_id (deprecated_selected_frame);
958b725ae77Skettenis
959b725ae77Skettenis /* Update the root variable. value_of_root can return NULL
960b725ae77Skettenis if the variable is no longer around, i.e. we stepped out of
961b725ae77Skettenis the frame in which a local existed. We are letting the
962b725ae77Skettenis value_of_root variable dispose of the varobj if the type
963b725ae77Skettenis has changed. */
964b725ae77Skettenis type_changed = 1;
965b725ae77Skettenis new = value_of_root (varp, &type_changed);
966b725ae77Skettenis if (new == NULL)
967b725ae77Skettenis {
968b725ae77Skettenis (*varp)->error = 1;
969b725ae77Skettenis return -1;
970b725ae77Skettenis }
971b725ae77Skettenis
972b725ae77Skettenis /* Initialize a stack for temporary results */
973b725ae77Skettenis vpush (&result, NULL);
974b725ae77Skettenis
975b725ae77Skettenis /* If this is a "use_selected_frame" varobj, and its type has changed,
976b725ae77Skettenis them note that it's changed. */
977b725ae77Skettenis if (type_changed)
978b725ae77Skettenis {
979b725ae77Skettenis vpush (&result, *varp);
980b725ae77Skettenis changed++;
981b725ae77Skettenis }
982b725ae77Skettenis /* If values are not equal, note that it's changed.
983b725ae77Skettenis There a couple of exceptions here, though.
984b725ae77Skettenis We don't want some types to be reported as "changed". */
985b725ae77Skettenis else if (type_changeable (*varp) &&
986b725ae77Skettenis ((*varp)->updated || !my_value_equal ((*varp)->value, new, &error2)))
987b725ae77Skettenis {
988b725ae77Skettenis vpush (&result, *varp);
989b725ae77Skettenis (*varp)->updated = 0;
990b725ae77Skettenis changed++;
991b725ae77Skettenis /* error2 replaces var->error since this new value
992b725ae77Skettenis WILL replace the old one. */
993b725ae77Skettenis (*varp)->error = error2;
994b725ae77Skettenis }
995b725ae77Skettenis
996b725ae77Skettenis /* We must always keep around the new value for this root
997b725ae77Skettenis variable expression, or we lose the updated children! */
998b725ae77Skettenis value_free ((*varp)->value);
999b725ae77Skettenis (*varp)->value = new;
1000b725ae77Skettenis
1001b725ae77Skettenis /* Initialize a stack */
1002b725ae77Skettenis vpush (&stack, NULL);
1003b725ae77Skettenis
1004b725ae77Skettenis /* Push the root's children */
1005b725ae77Skettenis if ((*varp)->children != NULL)
1006b725ae77Skettenis {
1007b725ae77Skettenis struct varobj_child *c;
1008b725ae77Skettenis for (c = (*varp)->children; c != NULL; c = c->next)
1009b725ae77Skettenis vpush (&stack, c->child);
1010b725ae77Skettenis }
1011b725ae77Skettenis
1012b725ae77Skettenis /* Walk through the children, reconstructing them all. */
1013b725ae77Skettenis v = vpop (&stack);
1014b725ae77Skettenis while (v != NULL)
1015b725ae77Skettenis {
1016b725ae77Skettenis /* Push any children */
1017b725ae77Skettenis if (v->children != NULL)
1018b725ae77Skettenis {
1019b725ae77Skettenis struct varobj_child *c;
1020b725ae77Skettenis for (c = v->children; c != NULL; c = c->next)
1021b725ae77Skettenis vpush (&stack, c->child);
1022b725ae77Skettenis }
1023b725ae77Skettenis
1024b725ae77Skettenis /* Update this variable */
1025b725ae77Skettenis new = value_of_child (v->parent, v->index);
1026b725ae77Skettenis if (type_changeable (v) &&
1027b725ae77Skettenis (v->updated || !my_value_equal (v->value, new, &error2)))
1028b725ae77Skettenis {
1029b725ae77Skettenis /* Note that it's changed */
1030b725ae77Skettenis vpush (&result, v);
1031b725ae77Skettenis v->updated = 0;
1032b725ae77Skettenis changed++;
1033b725ae77Skettenis }
1034b725ae77Skettenis /* error2 replaces v->error since this new value
1035b725ae77Skettenis WILL replace the old one. */
1036b725ae77Skettenis v->error = error2;
1037b725ae77Skettenis
1038b725ae77Skettenis /* We must always keep new values, since children depend on it. */
1039b725ae77Skettenis if (v->value != NULL)
1040b725ae77Skettenis value_free (v->value);
1041b725ae77Skettenis v->value = new;
1042b725ae77Skettenis
1043b725ae77Skettenis /* Get next child */
1044b725ae77Skettenis v = vpop (&stack);
1045b725ae77Skettenis }
1046b725ae77Skettenis
1047b725ae77Skettenis /* Alloc (changed + 1) list entries */
1048b725ae77Skettenis /* FIXME: add a cleanup for the allocated list(s)
1049b725ae77Skettenis because one day the select_frame called below can longjump */
1050b725ae77Skettenis *changelist = xmalloc ((changed + 1) * sizeof (struct varobj *));
1051b725ae77Skettenis if (changed > 1)
1052b725ae77Skettenis {
1053b725ae77Skettenis templist = xmalloc ((changed + 1) * sizeof (struct varobj *));
1054b725ae77Skettenis cv = templist;
1055b725ae77Skettenis }
1056b725ae77Skettenis else
1057b725ae77Skettenis cv = *changelist;
1058b725ae77Skettenis
1059b725ae77Skettenis /* Copy from result stack to list */
1060b725ae77Skettenis vleft = changed;
1061b725ae77Skettenis *cv = vpop (&result);
1062b725ae77Skettenis while ((*cv != NULL) && (vleft > 0))
1063b725ae77Skettenis {
1064b725ae77Skettenis vleft--;
1065b725ae77Skettenis cv++;
1066b725ae77Skettenis *cv = vpop (&result);
1067b725ae77Skettenis }
1068b725ae77Skettenis if (vleft)
1069b725ae77Skettenis warning ("varobj_update: assertion failed - vleft <> 0");
1070b725ae77Skettenis
1071b725ae77Skettenis if (changed > 1)
1072b725ae77Skettenis {
1073b725ae77Skettenis /* Now we revert the order. */
1074b725ae77Skettenis for (i = 0; i < changed; i++)
1075b725ae77Skettenis *(*changelist + i) = *(templist + changed - 1 - i);
1076b725ae77Skettenis *(*changelist + changed) = NULL;
1077b725ae77Skettenis }
1078b725ae77Skettenis
1079b725ae77Skettenis /* Restore selected frame */
1080b725ae77Skettenis fi = frame_find_by_id (old_fid);
1081b725ae77Skettenis if (fi)
1082b725ae77Skettenis select_frame (fi);
1083b725ae77Skettenis
1084b725ae77Skettenis if (type_changed)
1085b725ae77Skettenis return -2;
1086b725ae77Skettenis else
1087b725ae77Skettenis return changed;
1088b725ae77Skettenis }
1089b725ae77Skettenis
1090b725ae77Skettenis
1091b725ae77Skettenis /* Helper functions */
1092b725ae77Skettenis
1093b725ae77Skettenis /*
1094b725ae77Skettenis * Variable object construction/destruction
1095b725ae77Skettenis */
1096b725ae77Skettenis
1097b725ae77Skettenis static int
delete_variable(struct cpstack ** resultp,struct varobj * var,int only_children_p)1098b725ae77Skettenis delete_variable (struct cpstack **resultp, struct varobj *var,
1099b725ae77Skettenis int only_children_p)
1100b725ae77Skettenis {
1101b725ae77Skettenis int delcount = 0;
1102b725ae77Skettenis
1103b725ae77Skettenis delete_variable_1 (resultp, &delcount, var,
1104b725ae77Skettenis only_children_p, 1 /* remove_from_parent_p */ );
1105b725ae77Skettenis
1106b725ae77Skettenis return delcount;
1107b725ae77Skettenis }
1108b725ae77Skettenis
1109b725ae77Skettenis /* Delete the variable object VAR and its children */
1110b725ae77Skettenis /* IMPORTANT NOTE: If we delete a variable which is a child
1111b725ae77Skettenis and the parent is not removed we dump core. It must be always
1112b725ae77Skettenis initially called with remove_from_parent_p set */
1113b725ae77Skettenis static void
delete_variable_1(struct cpstack ** resultp,int * delcountp,struct varobj * var,int only_children_p,int remove_from_parent_p)1114b725ae77Skettenis delete_variable_1 (struct cpstack **resultp, int *delcountp,
1115b725ae77Skettenis struct varobj *var, int only_children_p,
1116b725ae77Skettenis int remove_from_parent_p)
1117b725ae77Skettenis {
1118b725ae77Skettenis struct varobj_child *vc;
1119b725ae77Skettenis struct varobj_child *next;
1120b725ae77Skettenis
1121b725ae77Skettenis /* Delete any children of this variable, too. */
1122b725ae77Skettenis for (vc = var->children; vc != NULL; vc = next)
1123b725ae77Skettenis {
1124b725ae77Skettenis if (!remove_from_parent_p)
1125b725ae77Skettenis vc->child->parent = NULL;
1126b725ae77Skettenis delete_variable_1 (resultp, delcountp, vc->child, 0, only_children_p);
1127b725ae77Skettenis next = vc->next;
1128b725ae77Skettenis xfree (vc);
1129b725ae77Skettenis }
1130b725ae77Skettenis
1131b725ae77Skettenis /* if we were called to delete only the children we are done here */
1132b725ae77Skettenis if (only_children_p)
1133b725ae77Skettenis return;
1134b725ae77Skettenis
1135b725ae77Skettenis /* Otherwise, add it to the list of deleted ones and proceed to do so */
1136b725ae77Skettenis /* If the name is null, this is a temporary variable, that has not
1137b725ae77Skettenis yet been installed, don't report it, it belongs to the caller... */
1138b725ae77Skettenis if (var->obj_name != NULL)
1139b725ae77Skettenis {
1140b725ae77Skettenis cppush (resultp, xstrdup (var->obj_name));
1141b725ae77Skettenis *delcountp = *delcountp + 1;
1142b725ae77Skettenis }
1143b725ae77Skettenis
1144b725ae77Skettenis /* If this variable has a parent, remove it from its parent's list */
1145b725ae77Skettenis /* OPTIMIZATION: if the parent of this variable is also being deleted,
1146b725ae77Skettenis (as indicated by remove_from_parent_p) we don't bother doing an
1147b725ae77Skettenis expensive list search to find the element to remove when we are
1148b725ae77Skettenis discarding the list afterwards */
1149b725ae77Skettenis if ((remove_from_parent_p) && (var->parent != NULL))
1150b725ae77Skettenis {
1151b725ae77Skettenis remove_child_from_parent (var->parent, var);
1152b725ae77Skettenis }
1153b725ae77Skettenis
1154b725ae77Skettenis if (var->obj_name != NULL)
1155b725ae77Skettenis uninstall_variable (var);
1156b725ae77Skettenis
1157b725ae77Skettenis /* Free memory associated with this variable */
1158b725ae77Skettenis free_variable (var);
1159b725ae77Skettenis }
1160b725ae77Skettenis
1161b725ae77Skettenis /* Install the given variable VAR with the object name VAR->OBJ_NAME. */
1162b725ae77Skettenis static int
install_variable(struct varobj * var)1163b725ae77Skettenis install_variable (struct varobj *var)
1164b725ae77Skettenis {
1165b725ae77Skettenis struct vlist *cv;
1166b725ae77Skettenis struct vlist *newvl;
1167b725ae77Skettenis const char *chp;
1168b725ae77Skettenis unsigned int index = 0;
1169b725ae77Skettenis unsigned int i = 1;
1170b725ae77Skettenis
1171b725ae77Skettenis for (chp = var->obj_name; *chp; chp++)
1172b725ae77Skettenis {
1173b725ae77Skettenis index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
1174b725ae77Skettenis }
1175b725ae77Skettenis
1176b725ae77Skettenis cv = *(varobj_table + index);
1177b725ae77Skettenis while ((cv != NULL) && (strcmp (cv->var->obj_name, var->obj_name) != 0))
1178b725ae77Skettenis cv = cv->next;
1179b725ae77Skettenis
1180b725ae77Skettenis if (cv != NULL)
1181b725ae77Skettenis error ("Duplicate variable object name");
1182b725ae77Skettenis
1183b725ae77Skettenis /* Add varobj to hash table */
1184b725ae77Skettenis newvl = xmalloc (sizeof (struct vlist));
1185b725ae77Skettenis newvl->next = *(varobj_table + index);
1186b725ae77Skettenis newvl->var = var;
1187b725ae77Skettenis *(varobj_table + index) = newvl;
1188b725ae77Skettenis
1189b725ae77Skettenis /* If root, add varobj to root list */
1190b725ae77Skettenis if (var->root->rootvar == var)
1191b725ae77Skettenis {
1192b725ae77Skettenis /* Add to list of root variables */
1193b725ae77Skettenis if (rootlist == NULL)
1194b725ae77Skettenis var->root->next = NULL;
1195b725ae77Skettenis else
1196b725ae77Skettenis var->root->next = rootlist;
1197b725ae77Skettenis rootlist = var->root;
1198b725ae77Skettenis rootcount++;
1199b725ae77Skettenis }
1200b725ae77Skettenis
1201b725ae77Skettenis return 1; /* OK */
1202b725ae77Skettenis }
1203b725ae77Skettenis
1204b725ae77Skettenis /* Unistall the object VAR. */
1205b725ae77Skettenis static void
uninstall_variable(struct varobj * var)1206b725ae77Skettenis uninstall_variable (struct varobj *var)
1207b725ae77Skettenis {
1208b725ae77Skettenis struct vlist *cv;
1209b725ae77Skettenis struct vlist *prev;
1210b725ae77Skettenis struct varobj_root *cr;
1211b725ae77Skettenis struct varobj_root *prer;
1212b725ae77Skettenis const char *chp;
1213b725ae77Skettenis unsigned int index = 0;
1214b725ae77Skettenis unsigned int i = 1;
1215b725ae77Skettenis
1216b725ae77Skettenis /* Remove varobj from hash table */
1217b725ae77Skettenis for (chp = var->obj_name; *chp; chp++)
1218b725ae77Skettenis {
1219b725ae77Skettenis index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE;
1220b725ae77Skettenis }
1221b725ae77Skettenis
1222b725ae77Skettenis cv = *(varobj_table + index);
1223b725ae77Skettenis prev = NULL;
1224b725ae77Skettenis while ((cv != NULL) && (strcmp (cv->var->obj_name, var->obj_name) != 0))
1225b725ae77Skettenis {
1226b725ae77Skettenis prev = cv;
1227b725ae77Skettenis cv = cv->next;
1228b725ae77Skettenis }
1229b725ae77Skettenis
1230b725ae77Skettenis if (varobjdebug)
1231b725ae77Skettenis fprintf_unfiltered (gdb_stdlog, "Deleting %s\n", var->obj_name);
1232b725ae77Skettenis
1233b725ae77Skettenis if (cv == NULL)
1234b725ae77Skettenis {
1235b725ae77Skettenis warning
1236b725ae77Skettenis ("Assertion failed: Could not find variable object \"%s\" to delete",
1237b725ae77Skettenis var->obj_name);
1238b725ae77Skettenis return;
1239b725ae77Skettenis }
1240b725ae77Skettenis
1241b725ae77Skettenis if (prev == NULL)
1242b725ae77Skettenis *(varobj_table + index) = cv->next;
1243b725ae77Skettenis else
1244b725ae77Skettenis prev->next = cv->next;
1245b725ae77Skettenis
1246b725ae77Skettenis xfree (cv);
1247b725ae77Skettenis
1248b725ae77Skettenis /* If root, remove varobj from root list */
1249b725ae77Skettenis if (var->root->rootvar == var)
1250b725ae77Skettenis {
1251b725ae77Skettenis /* Remove from list of root variables */
1252b725ae77Skettenis if (rootlist == var->root)
1253b725ae77Skettenis rootlist = var->root->next;
1254b725ae77Skettenis else
1255b725ae77Skettenis {
1256b725ae77Skettenis prer = NULL;
1257b725ae77Skettenis cr = rootlist;
1258b725ae77Skettenis while ((cr != NULL) && (cr->rootvar != var))
1259b725ae77Skettenis {
1260b725ae77Skettenis prer = cr;
1261b725ae77Skettenis cr = cr->next;
1262b725ae77Skettenis }
1263b725ae77Skettenis if (cr == NULL)
1264b725ae77Skettenis {
1265b725ae77Skettenis warning
1266b725ae77Skettenis ("Assertion failed: Could not find varobj \"%s\" in root list",
1267b725ae77Skettenis var->obj_name);
1268b725ae77Skettenis return;
1269b725ae77Skettenis }
1270b725ae77Skettenis if (prer == NULL)
1271b725ae77Skettenis rootlist = NULL;
1272b725ae77Skettenis else
1273b725ae77Skettenis prer->next = cr->next;
1274b725ae77Skettenis }
1275b725ae77Skettenis rootcount--;
1276b725ae77Skettenis }
1277b725ae77Skettenis
1278b725ae77Skettenis }
1279b725ae77Skettenis
1280b725ae77Skettenis /* Does a child with the name NAME exist in VAR? If so, return its data.
1281b725ae77Skettenis If not, return NULL. */
1282b725ae77Skettenis static struct varobj *
child_exists(struct varobj * var,char * name)1283b725ae77Skettenis child_exists (struct varobj *var, char *name)
1284b725ae77Skettenis {
1285b725ae77Skettenis struct varobj_child *vc;
1286b725ae77Skettenis
1287b725ae77Skettenis for (vc = var->children; vc != NULL; vc = vc->next)
1288b725ae77Skettenis {
1289b725ae77Skettenis if (strcmp (vc->child->name, name) == 0)
1290b725ae77Skettenis return vc->child;
1291b725ae77Skettenis }
1292b725ae77Skettenis
1293b725ae77Skettenis return NULL;
1294b725ae77Skettenis }
1295b725ae77Skettenis
1296b725ae77Skettenis /* Create and install a child of the parent of the given name */
1297b725ae77Skettenis static struct varobj *
create_child(struct varobj * parent,int index,char * name)1298b725ae77Skettenis create_child (struct varobj *parent, int index, char *name)
1299b725ae77Skettenis {
1300b725ae77Skettenis struct varobj *child;
1301b725ae77Skettenis char *childs_name;
1302b725ae77Skettenis
1303b725ae77Skettenis child = new_variable ();
1304b725ae77Skettenis
1305b725ae77Skettenis /* name is allocated by name_of_child */
1306b725ae77Skettenis child->name = name;
1307b725ae77Skettenis child->index = index;
1308b725ae77Skettenis child->value = value_of_child (parent, index);
1309b725ae77Skettenis if ((!CPLUS_FAKE_CHILD (child) && child->value == NULL) || parent->error)
1310b725ae77Skettenis child->error = 1;
1311b725ae77Skettenis child->parent = parent;
1312b725ae77Skettenis child->root = parent->root;
131311efff7fSkettenis childs_name = xstrprintf ("%s.%s", parent->obj_name, name);
1314b725ae77Skettenis child->obj_name = childs_name;
1315b725ae77Skettenis install_variable (child);
1316b725ae77Skettenis
1317b725ae77Skettenis /* Save a pointer to this child in the parent */
1318b725ae77Skettenis save_child_in_parent (parent, child);
1319b725ae77Skettenis
1320b725ae77Skettenis /* Note the type of this child */
1321b725ae77Skettenis child->type = type_of_child (child);
1322b725ae77Skettenis
1323b725ae77Skettenis return child;
1324b725ae77Skettenis }
1325b725ae77Skettenis
1326b725ae77Skettenis /* FIXME: This should be a generic add to list */
1327b725ae77Skettenis /* Save CHILD in the PARENT's data. */
1328b725ae77Skettenis static void
save_child_in_parent(struct varobj * parent,struct varobj * child)1329b725ae77Skettenis save_child_in_parent (struct varobj *parent, struct varobj *child)
1330b725ae77Skettenis {
1331b725ae77Skettenis struct varobj_child *vc;
1332b725ae77Skettenis
1333b725ae77Skettenis /* Insert the child at the top */
1334b725ae77Skettenis vc = parent->children;
1335b725ae77Skettenis parent->children =
1336b725ae77Skettenis (struct varobj_child *) xmalloc (sizeof (struct varobj_child));
1337b725ae77Skettenis
1338b725ae77Skettenis parent->children->next = vc;
1339b725ae77Skettenis parent->children->child = child;
1340b725ae77Skettenis }
1341b725ae77Skettenis
1342b725ae77Skettenis /* FIXME: This should be a generic remove from list */
1343b725ae77Skettenis /* Remove the CHILD from the PARENT's list of children. */
1344b725ae77Skettenis static void
remove_child_from_parent(struct varobj * parent,struct varobj * child)1345b725ae77Skettenis remove_child_from_parent (struct varobj *parent, struct varobj *child)
1346b725ae77Skettenis {
1347b725ae77Skettenis struct varobj_child *vc, *prev;
1348b725ae77Skettenis
1349b725ae77Skettenis /* Find the child in the parent's list */
1350b725ae77Skettenis prev = NULL;
1351b725ae77Skettenis for (vc = parent->children; vc != NULL;)
1352b725ae77Skettenis {
1353b725ae77Skettenis if (vc->child == child)
1354b725ae77Skettenis break;
1355b725ae77Skettenis prev = vc;
1356b725ae77Skettenis vc = vc->next;
1357b725ae77Skettenis }
1358b725ae77Skettenis
1359b725ae77Skettenis if (prev == NULL)
1360b725ae77Skettenis parent->children = vc->next;
1361b725ae77Skettenis else
1362b725ae77Skettenis prev->next = vc->next;
1363b725ae77Skettenis
1364b725ae77Skettenis }
1365b725ae77Skettenis
1366b725ae77Skettenis
1367b725ae77Skettenis /*
1368b725ae77Skettenis * Miscellaneous utility functions.
1369b725ae77Skettenis */
1370b725ae77Skettenis
1371b725ae77Skettenis /* Allocate memory and initialize a new variable */
1372b725ae77Skettenis static struct varobj *
new_variable(void)1373b725ae77Skettenis new_variable (void)
1374b725ae77Skettenis {
1375b725ae77Skettenis struct varobj *var;
1376b725ae77Skettenis
1377b725ae77Skettenis var = (struct varobj *) xmalloc (sizeof (struct varobj));
1378b725ae77Skettenis var->name = NULL;
1379b725ae77Skettenis var->obj_name = NULL;
1380b725ae77Skettenis var->index = -1;
1381b725ae77Skettenis var->type = NULL;
1382b725ae77Skettenis var->value = NULL;
1383b725ae77Skettenis var->error = 0;
1384b725ae77Skettenis var->num_children = -1;
1385b725ae77Skettenis var->parent = NULL;
1386b725ae77Skettenis var->children = NULL;
1387b725ae77Skettenis var->format = 0;
1388b725ae77Skettenis var->root = NULL;
1389b725ae77Skettenis var->updated = 0;
1390b725ae77Skettenis
1391b725ae77Skettenis return var;
1392b725ae77Skettenis }
1393b725ae77Skettenis
1394b725ae77Skettenis /* Allocate memory and initialize a new root variable */
1395b725ae77Skettenis static struct varobj *
new_root_variable(void)1396b725ae77Skettenis new_root_variable (void)
1397b725ae77Skettenis {
1398b725ae77Skettenis struct varobj *var = new_variable ();
1399b725ae77Skettenis var->root = (struct varobj_root *) xmalloc (sizeof (struct varobj_root));;
1400b725ae77Skettenis var->root->lang = NULL;
1401b725ae77Skettenis var->root->exp = NULL;
1402b725ae77Skettenis var->root->valid_block = NULL;
1403b725ae77Skettenis var->root->frame = null_frame_id;
1404b725ae77Skettenis var->root->use_selected_frame = 0;
1405b725ae77Skettenis var->root->rootvar = NULL;
1406b725ae77Skettenis
1407b725ae77Skettenis return var;
1408b725ae77Skettenis }
1409b725ae77Skettenis
1410b725ae77Skettenis /* Free any allocated memory associated with VAR. */
1411b725ae77Skettenis static void
free_variable(struct varobj * var)1412b725ae77Skettenis free_variable (struct varobj *var)
1413b725ae77Skettenis {
1414b725ae77Skettenis /* Free the expression if this is a root variable. */
1415b725ae77Skettenis if (var->root->rootvar == var)
1416b725ae77Skettenis {
1417b725ae77Skettenis free_current_contents ((char **) &var->root->exp);
1418b725ae77Skettenis xfree (var->root);
1419b725ae77Skettenis }
1420b725ae77Skettenis
1421b725ae77Skettenis xfree (var->name);
1422b725ae77Skettenis xfree (var->obj_name);
1423b725ae77Skettenis xfree (var);
1424b725ae77Skettenis }
1425b725ae77Skettenis
1426b725ae77Skettenis static void
do_free_variable_cleanup(void * var)1427b725ae77Skettenis do_free_variable_cleanup (void *var)
1428b725ae77Skettenis {
1429b725ae77Skettenis free_variable (var);
1430b725ae77Skettenis }
1431b725ae77Skettenis
1432b725ae77Skettenis static struct cleanup *
make_cleanup_free_variable(struct varobj * var)1433b725ae77Skettenis make_cleanup_free_variable (struct varobj *var)
1434b725ae77Skettenis {
1435b725ae77Skettenis return make_cleanup (do_free_variable_cleanup, var);
1436b725ae77Skettenis }
1437b725ae77Skettenis
1438b725ae77Skettenis /* This returns the type of the variable. It also skips past typedefs
1439b725ae77Skettenis to return the real type of the variable.
1440b725ae77Skettenis
1441b725ae77Skettenis NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
1442b725ae77Skettenis except within get_target_type and get_type. */
1443b725ae77Skettenis static struct type *
get_type(struct varobj * var)1444b725ae77Skettenis get_type (struct varobj *var)
1445b725ae77Skettenis {
1446b725ae77Skettenis struct type *type;
1447b725ae77Skettenis type = var->type;
1448b725ae77Skettenis
1449b725ae77Skettenis if (type != NULL)
1450b725ae77Skettenis type = check_typedef (type);
1451b725ae77Skettenis
1452b725ae77Skettenis return type;
1453b725ae77Skettenis }
1454b725ae77Skettenis
1455b725ae77Skettenis /* This returns the type of the variable, dereferencing pointers, too. */
1456b725ae77Skettenis static struct type *
get_type_deref(struct varobj * var)1457b725ae77Skettenis get_type_deref (struct varobj *var)
1458b725ae77Skettenis {
1459b725ae77Skettenis struct type *type;
1460b725ae77Skettenis
1461b725ae77Skettenis type = get_type (var);
1462b725ae77Skettenis
1463b725ae77Skettenis if (type != NULL && (TYPE_CODE (type) == TYPE_CODE_PTR
1464b725ae77Skettenis || TYPE_CODE (type) == TYPE_CODE_REF))
1465b725ae77Skettenis type = get_target_type (type);
1466b725ae77Skettenis
1467b725ae77Skettenis return type;
1468b725ae77Skettenis }
1469b725ae77Skettenis
1470b725ae77Skettenis /* This returns the target type (or NULL) of TYPE, also skipping
1471b725ae77Skettenis past typedefs, just like get_type ().
1472b725ae77Skettenis
1473b725ae77Skettenis NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
1474b725ae77Skettenis except within get_target_type and get_type. */
1475b725ae77Skettenis static struct type *
get_target_type(struct type * type)1476b725ae77Skettenis get_target_type (struct type *type)
1477b725ae77Skettenis {
1478b725ae77Skettenis if (type != NULL)
1479b725ae77Skettenis {
1480b725ae77Skettenis type = TYPE_TARGET_TYPE (type);
1481b725ae77Skettenis if (type != NULL)
1482b725ae77Skettenis type = check_typedef (type);
1483b725ae77Skettenis }
1484b725ae77Skettenis
1485b725ae77Skettenis return type;
1486b725ae77Skettenis }
1487b725ae77Skettenis
1488b725ae77Skettenis /* What is the default display for this variable? We assume that
1489b725ae77Skettenis everything is "natural". Any exceptions? */
1490b725ae77Skettenis static enum varobj_display_formats
variable_default_display(struct varobj * var)1491b725ae77Skettenis variable_default_display (struct varobj *var)
1492b725ae77Skettenis {
1493b725ae77Skettenis return FORMAT_NATURAL;
1494b725ae77Skettenis }
1495b725ae77Skettenis
1496b725ae77Skettenis /* This function is similar to gdb's value_equal, except that this
1497b725ae77Skettenis one is "safe" -- it NEVER longjmps. It determines if the VAR's
1498b725ae77Skettenis value is the same as VAL2. */
1499b725ae77Skettenis static int
my_value_equal(struct value * val1,struct value * val2,int * error2)1500b725ae77Skettenis my_value_equal (struct value *val1, struct value *val2, int *error2)
1501b725ae77Skettenis {
1502b725ae77Skettenis int r, err1, err2;
1503b725ae77Skettenis
1504b725ae77Skettenis *error2 = 0;
1505b725ae77Skettenis /* Special case: NULL values. If both are null, say
1506b725ae77Skettenis they're equal. */
1507b725ae77Skettenis if (val1 == NULL && val2 == NULL)
1508b725ae77Skettenis return 1;
1509b725ae77Skettenis else if (val1 == NULL || val2 == NULL)
1510b725ae77Skettenis return 0;
1511b725ae77Skettenis
1512b725ae77Skettenis /* This is bogus, but unfortunately necessary. We must know
1513b725ae77Skettenis exactly what caused an error -- reading val1 or val2 -- so
1514b725ae77Skettenis that we can really determine if we think that something has changed. */
1515b725ae77Skettenis err1 = 0;
1516b725ae77Skettenis err2 = 0;
1517b725ae77Skettenis /* We do need to catch errors here because the whole purpose
1518b725ae77Skettenis is to test if value_equal() has errored */
1519b725ae77Skettenis if (!gdb_value_equal (val1, val1, &r))
1520b725ae77Skettenis err1 = 1;
1521b725ae77Skettenis
1522b725ae77Skettenis if (!gdb_value_equal (val2, val2, &r))
1523b725ae77Skettenis *error2 = err2 = 1;
1524b725ae77Skettenis
1525b725ae77Skettenis if (err1 != err2)
1526b725ae77Skettenis return 0;
1527b725ae77Skettenis
1528b725ae77Skettenis if (!gdb_value_equal (val1, val2, &r))
1529b725ae77Skettenis {
1530b725ae77Skettenis /* An error occurred, this could have happened if
1531b725ae77Skettenis either val1 or val2 errored. ERR1 and ERR2 tell
1532b725ae77Skettenis us which of these it is. If both errored, then
1533b725ae77Skettenis we assume nothing has changed. If one of them is
1534b725ae77Skettenis valid, though, then something has changed. */
1535b725ae77Skettenis if (err1 == err2)
1536b725ae77Skettenis {
1537b725ae77Skettenis /* both the old and new values caused errors, so
1538b725ae77Skettenis we say the value did not change */
1539b725ae77Skettenis /* This is indeterminate, though. Perhaps we should
1540b725ae77Skettenis be safe and say, yes, it changed anyway?? */
1541b725ae77Skettenis return 1;
1542b725ae77Skettenis }
1543b725ae77Skettenis else
1544b725ae77Skettenis {
1545b725ae77Skettenis return 0;
1546b725ae77Skettenis }
1547b725ae77Skettenis }
1548b725ae77Skettenis
1549b725ae77Skettenis return r;
1550b725ae77Skettenis }
1551b725ae77Skettenis
1552b725ae77Skettenis /* FIXME: The following should be generic for any pointer */
1553b725ae77Skettenis static void
vpush(struct vstack ** pstack,struct varobj * var)1554b725ae77Skettenis vpush (struct vstack **pstack, struct varobj *var)
1555b725ae77Skettenis {
1556b725ae77Skettenis struct vstack *s;
1557b725ae77Skettenis
1558b725ae77Skettenis s = (struct vstack *) xmalloc (sizeof (struct vstack));
1559b725ae77Skettenis s->var = var;
1560b725ae77Skettenis s->next = *pstack;
1561b725ae77Skettenis *pstack = s;
1562b725ae77Skettenis }
1563b725ae77Skettenis
1564b725ae77Skettenis /* FIXME: The following should be generic for any pointer */
1565b725ae77Skettenis static struct varobj *
vpop(struct vstack ** pstack)1566b725ae77Skettenis vpop (struct vstack **pstack)
1567b725ae77Skettenis {
1568b725ae77Skettenis struct vstack *s;
1569b725ae77Skettenis struct varobj *v;
1570b725ae77Skettenis
1571b725ae77Skettenis if ((*pstack)->var == NULL && (*pstack)->next == NULL)
1572b725ae77Skettenis return NULL;
1573b725ae77Skettenis
1574b725ae77Skettenis s = *pstack;
1575b725ae77Skettenis v = s->var;
1576b725ae77Skettenis *pstack = (*pstack)->next;
1577b725ae77Skettenis xfree (s);
1578b725ae77Skettenis
1579b725ae77Skettenis return v;
1580b725ae77Skettenis }
1581b725ae77Skettenis
1582b725ae77Skettenis /* FIXME: The following should be generic for any pointer */
1583b725ae77Skettenis static void
cppush(struct cpstack ** pstack,char * name)1584b725ae77Skettenis cppush (struct cpstack **pstack, char *name)
1585b725ae77Skettenis {
1586b725ae77Skettenis struct cpstack *s;
1587b725ae77Skettenis
1588b725ae77Skettenis s = (struct cpstack *) xmalloc (sizeof (struct cpstack));
1589b725ae77Skettenis s->name = name;
1590b725ae77Skettenis s->next = *pstack;
1591b725ae77Skettenis *pstack = s;
1592b725ae77Skettenis }
1593b725ae77Skettenis
1594b725ae77Skettenis /* FIXME: The following should be generic for any pointer */
1595b725ae77Skettenis static char *
cppop(struct cpstack ** pstack)1596b725ae77Skettenis cppop (struct cpstack **pstack)
1597b725ae77Skettenis {
1598b725ae77Skettenis struct cpstack *s;
1599b725ae77Skettenis char *v;
1600b725ae77Skettenis
1601b725ae77Skettenis if ((*pstack)->name == NULL && (*pstack)->next == NULL)
1602b725ae77Skettenis return NULL;
1603b725ae77Skettenis
1604b725ae77Skettenis s = *pstack;
1605b725ae77Skettenis v = s->name;
1606b725ae77Skettenis *pstack = (*pstack)->next;
1607b725ae77Skettenis xfree (s);
1608b725ae77Skettenis
1609b725ae77Skettenis return v;
1610b725ae77Skettenis }
1611b725ae77Skettenis
1612b725ae77Skettenis /*
1613b725ae77Skettenis * Language-dependencies
1614b725ae77Skettenis */
1615b725ae77Skettenis
1616b725ae77Skettenis /* Common entry points */
1617b725ae77Skettenis
1618b725ae77Skettenis /* Get the language of variable VAR. */
1619b725ae77Skettenis static enum varobj_languages
variable_language(struct varobj * var)1620b725ae77Skettenis variable_language (struct varobj *var)
1621b725ae77Skettenis {
1622b725ae77Skettenis enum varobj_languages lang;
1623b725ae77Skettenis
1624b725ae77Skettenis switch (var->root->exp->language_defn->la_language)
1625b725ae77Skettenis {
1626b725ae77Skettenis default:
1627b725ae77Skettenis case language_c:
1628b725ae77Skettenis lang = vlang_c;
1629b725ae77Skettenis break;
1630b725ae77Skettenis case language_cplus:
1631b725ae77Skettenis lang = vlang_cplus;
1632b725ae77Skettenis break;
1633b725ae77Skettenis case language_java:
1634b725ae77Skettenis lang = vlang_java;
1635b725ae77Skettenis break;
1636b725ae77Skettenis }
1637b725ae77Skettenis
1638b725ae77Skettenis return lang;
1639b725ae77Skettenis }
1640b725ae77Skettenis
1641b725ae77Skettenis /* Return the number of children for a given variable.
1642b725ae77Skettenis The result of this function is defined by the language
1643b725ae77Skettenis implementation. The number of children returned by this function
1644b725ae77Skettenis is the number of children that the user will see in the variable
1645b725ae77Skettenis display. */
1646b725ae77Skettenis static int
number_of_children(struct varobj * var)1647b725ae77Skettenis number_of_children (struct varobj *var)
1648b725ae77Skettenis {
1649b725ae77Skettenis return (*var->root->lang->number_of_children) (var);;
1650b725ae77Skettenis }
1651b725ae77Skettenis
1652b725ae77Skettenis /* What is the expression for the root varobj VAR? Returns a malloc'd string. */
1653b725ae77Skettenis static char *
name_of_variable(struct varobj * var)1654b725ae77Skettenis name_of_variable (struct varobj *var)
1655b725ae77Skettenis {
1656b725ae77Skettenis return (*var->root->lang->name_of_variable) (var);
1657b725ae77Skettenis }
1658b725ae77Skettenis
1659b725ae77Skettenis /* What is the name of the INDEX'th child of VAR? Returns a malloc'd string. */
1660b725ae77Skettenis static char *
name_of_child(struct varobj * var,int index)1661b725ae77Skettenis name_of_child (struct varobj *var, int index)
1662b725ae77Skettenis {
1663b725ae77Skettenis return (*var->root->lang->name_of_child) (var, index);
1664b725ae77Skettenis }
1665b725ae77Skettenis
1666b725ae77Skettenis /* What is the ``struct value *'' of the root variable VAR?
1667b725ae77Skettenis TYPE_CHANGED controls what to do if the type of a
1668b725ae77Skettenis use_selected_frame = 1 variable changes. On input,
1669b725ae77Skettenis TYPE_CHANGED = 1 means discard the old varobj, and replace
1670b725ae77Skettenis it with this one. TYPE_CHANGED = 0 means leave it around.
1671b725ae77Skettenis NB: In both cases, var_handle will point to the new varobj,
1672b725ae77Skettenis so if you use TYPE_CHANGED = 0, you will have to stash the
1673b725ae77Skettenis old varobj pointer away somewhere before calling this.
1674b725ae77Skettenis On return, TYPE_CHANGED will be 1 if the type has changed, and
1675b725ae77Skettenis 0 otherwise. */
1676b725ae77Skettenis static struct value *
value_of_root(struct varobj ** var_handle,int * type_changed)1677b725ae77Skettenis value_of_root (struct varobj **var_handle, int *type_changed)
1678b725ae77Skettenis {
1679b725ae77Skettenis struct varobj *var;
1680b725ae77Skettenis
1681b725ae77Skettenis if (var_handle == NULL)
1682b725ae77Skettenis return NULL;
1683b725ae77Skettenis
1684b725ae77Skettenis var = *var_handle;
1685b725ae77Skettenis
1686b725ae77Skettenis /* This should really be an exception, since this should
1687b725ae77Skettenis only get called with a root variable. */
1688b725ae77Skettenis
1689b725ae77Skettenis if (var->root->rootvar != var)
1690b725ae77Skettenis return NULL;
1691b725ae77Skettenis
1692b725ae77Skettenis if (var->root->use_selected_frame)
1693b725ae77Skettenis {
1694b725ae77Skettenis struct varobj *tmp_var;
1695b725ae77Skettenis char *old_type, *new_type;
1696b725ae77Skettenis old_type = varobj_get_type (var);
1697b725ae77Skettenis tmp_var = varobj_create (NULL, var->name, (CORE_ADDR) 0,
1698b725ae77Skettenis USE_SELECTED_FRAME);
1699b725ae77Skettenis if (tmp_var == NULL)
1700b725ae77Skettenis {
1701b725ae77Skettenis return NULL;
1702b725ae77Skettenis }
1703b725ae77Skettenis new_type = varobj_get_type (tmp_var);
1704b725ae77Skettenis if (strcmp (old_type, new_type) == 0)
1705b725ae77Skettenis {
1706b725ae77Skettenis varobj_delete (tmp_var, NULL, 0);
1707b725ae77Skettenis *type_changed = 0;
1708b725ae77Skettenis }
1709b725ae77Skettenis else
1710b725ae77Skettenis {
1711b725ae77Skettenis if (*type_changed)
1712b725ae77Skettenis {
1713b725ae77Skettenis tmp_var->obj_name =
1714b725ae77Skettenis savestring (var->obj_name, strlen (var->obj_name));
1715b725ae77Skettenis varobj_delete (var, NULL, 0);
1716b725ae77Skettenis }
1717b725ae77Skettenis else
1718b725ae77Skettenis {
1719b725ae77Skettenis tmp_var->obj_name = varobj_gen_name ();
1720b725ae77Skettenis }
1721b725ae77Skettenis install_variable (tmp_var);
1722b725ae77Skettenis *var_handle = tmp_var;
1723b725ae77Skettenis var = *var_handle;
1724b725ae77Skettenis *type_changed = 1;
1725b725ae77Skettenis }
1726b725ae77Skettenis }
1727b725ae77Skettenis else
1728b725ae77Skettenis {
1729b725ae77Skettenis *type_changed = 0;
1730b725ae77Skettenis }
1731b725ae77Skettenis
1732b725ae77Skettenis return (*var->root->lang->value_of_root) (var_handle);
1733b725ae77Skettenis }
1734b725ae77Skettenis
1735b725ae77Skettenis /* What is the ``struct value *'' for the INDEX'th child of PARENT? */
1736b725ae77Skettenis static struct value *
value_of_child(struct varobj * parent,int index)1737b725ae77Skettenis value_of_child (struct varobj *parent, int index)
1738b725ae77Skettenis {
1739b725ae77Skettenis struct value *value;
1740b725ae77Skettenis
1741b725ae77Skettenis value = (*parent->root->lang->value_of_child) (parent, index);
1742b725ae77Skettenis
1743b725ae77Skettenis /* If we're being lazy, fetch the real value of the variable. */
1744b725ae77Skettenis if (value != NULL && VALUE_LAZY (value))
1745b725ae77Skettenis {
1746b725ae77Skettenis /* If we fail to fetch the value of the child, return
1747b725ae77Skettenis NULL so that callers notice that we're leaving an
1748b725ae77Skettenis error message. */
1749b725ae77Skettenis if (!gdb_value_fetch_lazy (value))
1750b725ae77Skettenis value = NULL;
1751b725ae77Skettenis }
1752b725ae77Skettenis
1753b725ae77Skettenis return value;
1754b725ae77Skettenis }
1755b725ae77Skettenis
1756b725ae77Skettenis /* What is the type of VAR? */
1757b725ae77Skettenis static struct type *
type_of_child(struct varobj * var)1758b725ae77Skettenis type_of_child (struct varobj *var)
1759b725ae77Skettenis {
1760b725ae77Skettenis
1761b725ae77Skettenis /* If the child had no evaluation errors, var->value
1762b725ae77Skettenis will be non-NULL and contain a valid type. */
1763b725ae77Skettenis if (var->value != NULL)
1764b725ae77Skettenis return VALUE_TYPE (var->value);
1765b725ae77Skettenis
1766b725ae77Skettenis /* Otherwise, we must compute the type. */
1767b725ae77Skettenis return (*var->root->lang->type_of_child) (var->parent, var->index);
1768b725ae77Skettenis }
1769b725ae77Skettenis
1770b725ae77Skettenis /* Is this variable editable? Use the variable's type to make
1771b725ae77Skettenis this determination. */
1772b725ae77Skettenis static int
variable_editable(struct varobj * var)1773b725ae77Skettenis variable_editable (struct varobj *var)
1774b725ae77Skettenis {
1775b725ae77Skettenis return (*var->root->lang->variable_editable) (var);
1776b725ae77Skettenis }
1777b725ae77Skettenis
1778b725ae77Skettenis /* GDB already has a command called "value_of_variable". Sigh. */
1779b725ae77Skettenis static char *
my_value_of_variable(struct varobj * var)1780b725ae77Skettenis my_value_of_variable (struct varobj *var)
1781b725ae77Skettenis {
1782b725ae77Skettenis return (*var->root->lang->value_of_variable) (var);
1783b725ae77Skettenis }
1784b725ae77Skettenis
1785b725ae77Skettenis /* Is VAR something that can change? Depending on language,
1786b725ae77Skettenis some variable's values never change. For example,
1787b725ae77Skettenis struct and unions never change values. */
1788b725ae77Skettenis static int
type_changeable(struct varobj * var)1789b725ae77Skettenis type_changeable (struct varobj *var)
1790b725ae77Skettenis {
1791b725ae77Skettenis int r;
1792b725ae77Skettenis struct type *type;
1793b725ae77Skettenis
1794b725ae77Skettenis if (CPLUS_FAKE_CHILD (var))
1795b725ae77Skettenis return 0;
1796b725ae77Skettenis
1797b725ae77Skettenis type = get_type (var);
1798b725ae77Skettenis
1799b725ae77Skettenis switch (TYPE_CODE (type))
1800b725ae77Skettenis {
1801b725ae77Skettenis case TYPE_CODE_STRUCT:
1802b725ae77Skettenis case TYPE_CODE_UNION:
1803b725ae77Skettenis case TYPE_CODE_ARRAY:
1804b725ae77Skettenis r = 0;
1805b725ae77Skettenis break;
1806b725ae77Skettenis
1807b725ae77Skettenis default:
1808b725ae77Skettenis r = 1;
1809b725ae77Skettenis }
1810b725ae77Skettenis
1811b725ae77Skettenis return r;
1812b725ae77Skettenis }
1813b725ae77Skettenis
1814b725ae77Skettenis /* C */
1815b725ae77Skettenis static int
c_number_of_children(struct varobj * var)1816b725ae77Skettenis c_number_of_children (struct varobj *var)
1817b725ae77Skettenis {
1818b725ae77Skettenis struct type *type;
1819b725ae77Skettenis struct type *target;
1820b725ae77Skettenis int children;
1821b725ae77Skettenis
1822b725ae77Skettenis type = get_type (var);
1823b725ae77Skettenis target = get_target_type (type);
1824b725ae77Skettenis children = 0;
1825b725ae77Skettenis
1826b725ae77Skettenis switch (TYPE_CODE (type))
1827b725ae77Skettenis {
1828b725ae77Skettenis case TYPE_CODE_ARRAY:
1829b725ae77Skettenis if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (target) > 0
1830b725ae77Skettenis && TYPE_ARRAY_UPPER_BOUND_TYPE (type) != BOUND_CANNOT_BE_DETERMINED)
1831b725ae77Skettenis children = TYPE_LENGTH (type) / TYPE_LENGTH (target);
1832b725ae77Skettenis else
1833b725ae77Skettenis children = -1;
1834b725ae77Skettenis break;
1835b725ae77Skettenis
1836b725ae77Skettenis case TYPE_CODE_STRUCT:
1837b725ae77Skettenis case TYPE_CODE_UNION:
1838b725ae77Skettenis children = TYPE_NFIELDS (type);
1839b725ae77Skettenis break;
1840b725ae77Skettenis
1841b725ae77Skettenis case TYPE_CODE_PTR:
1842b725ae77Skettenis /* This is where things get compilcated. All pointers have one child.
1843b725ae77Skettenis Except, of course, for struct and union ptr, which we automagically
1844b725ae77Skettenis dereference for the user and function ptrs, which have no children.
1845b725ae77Skettenis We also don't dereference void* as we don't know what to show.
1846b725ae77Skettenis We can show char* so we allow it to be dereferenced. If you decide
1847b725ae77Skettenis to test for it, please mind that a little magic is necessary to
1848b725ae77Skettenis properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
1849b725ae77Skettenis TYPE_NAME == "char" */
1850b725ae77Skettenis
1851b725ae77Skettenis switch (TYPE_CODE (target))
1852b725ae77Skettenis {
1853b725ae77Skettenis case TYPE_CODE_STRUCT:
1854b725ae77Skettenis case TYPE_CODE_UNION:
1855b725ae77Skettenis children = TYPE_NFIELDS (target);
1856b725ae77Skettenis break;
1857b725ae77Skettenis
1858b725ae77Skettenis case TYPE_CODE_FUNC:
1859b725ae77Skettenis case TYPE_CODE_VOID:
1860b725ae77Skettenis children = 0;
1861b725ae77Skettenis break;
1862b725ae77Skettenis
1863b725ae77Skettenis default:
1864b725ae77Skettenis children = 1;
1865b725ae77Skettenis }
1866b725ae77Skettenis break;
1867b725ae77Skettenis
1868b725ae77Skettenis default:
1869b725ae77Skettenis /* Other types have no children */
1870b725ae77Skettenis break;
1871b725ae77Skettenis }
1872b725ae77Skettenis
1873b725ae77Skettenis return children;
1874b725ae77Skettenis }
1875b725ae77Skettenis
1876b725ae77Skettenis static char *
c_name_of_variable(struct varobj * parent)1877b725ae77Skettenis c_name_of_variable (struct varobj *parent)
1878b725ae77Skettenis {
1879b725ae77Skettenis return savestring (parent->name, strlen (parent->name));
1880b725ae77Skettenis }
1881b725ae77Skettenis
1882b725ae77Skettenis static char *
c_name_of_child(struct varobj * parent,int index)1883b725ae77Skettenis c_name_of_child (struct varobj *parent, int index)
1884b725ae77Skettenis {
1885b725ae77Skettenis struct type *type;
1886b725ae77Skettenis struct type *target;
1887b725ae77Skettenis char *name;
1888b725ae77Skettenis char *string;
1889b725ae77Skettenis
1890b725ae77Skettenis type = get_type (parent);
1891b725ae77Skettenis target = get_target_type (type);
1892b725ae77Skettenis
1893b725ae77Skettenis switch (TYPE_CODE (type))
1894b725ae77Skettenis {
1895b725ae77Skettenis case TYPE_CODE_ARRAY:
189611efff7fSkettenis name = xstrprintf ("%d", index);
1897b725ae77Skettenis break;
1898b725ae77Skettenis
1899b725ae77Skettenis case TYPE_CODE_STRUCT:
1900b725ae77Skettenis case TYPE_CODE_UNION:
1901b725ae77Skettenis string = TYPE_FIELD_NAME (type, index);
1902b725ae77Skettenis name = savestring (string, strlen (string));
1903b725ae77Skettenis break;
1904b725ae77Skettenis
1905b725ae77Skettenis case TYPE_CODE_PTR:
1906b725ae77Skettenis switch (TYPE_CODE (target))
1907b725ae77Skettenis {
1908b725ae77Skettenis case TYPE_CODE_STRUCT:
1909b725ae77Skettenis case TYPE_CODE_UNION:
1910b725ae77Skettenis string = TYPE_FIELD_NAME (target, index);
1911b725ae77Skettenis name = savestring (string, strlen (string));
1912b725ae77Skettenis break;
1913b725ae77Skettenis
1914b725ae77Skettenis default:
191511efff7fSkettenis name = xstrprintf ("*%s", parent->name);
1916b725ae77Skettenis break;
1917b725ae77Skettenis }
1918b725ae77Skettenis break;
1919b725ae77Skettenis
1920b725ae77Skettenis default:
1921b725ae77Skettenis /* This should not happen */
1922b725ae77Skettenis name = xstrdup ("???");
1923b725ae77Skettenis }
1924b725ae77Skettenis
1925b725ae77Skettenis return name;
1926b725ae77Skettenis }
1927b725ae77Skettenis
1928b725ae77Skettenis static struct value *
c_value_of_root(struct varobj ** var_handle)1929b725ae77Skettenis c_value_of_root (struct varobj **var_handle)
1930b725ae77Skettenis {
1931b725ae77Skettenis struct value *new_val;
1932b725ae77Skettenis struct varobj *var = *var_handle;
1933b725ae77Skettenis struct frame_info *fi;
1934b725ae77Skettenis int within_scope;
1935b725ae77Skettenis
1936b725ae77Skettenis /* Only root variables can be updated... */
1937b725ae77Skettenis if (var->root->rootvar != var)
1938b725ae77Skettenis /* Not a root var */
1939b725ae77Skettenis return NULL;
1940b725ae77Skettenis
1941b725ae77Skettenis
1942b725ae77Skettenis /* Determine whether the variable is still around. */
1943b725ae77Skettenis if (var->root->valid_block == NULL)
1944b725ae77Skettenis within_scope = 1;
1945b725ae77Skettenis else
1946b725ae77Skettenis {
1947b725ae77Skettenis reinit_frame_cache ();
1948b725ae77Skettenis fi = frame_find_by_id (var->root->frame);
1949b725ae77Skettenis within_scope = fi != NULL;
1950b725ae77Skettenis /* FIXME: select_frame could fail */
1951b725ae77Skettenis if (within_scope)
1952b725ae77Skettenis select_frame (fi);
1953b725ae77Skettenis }
1954b725ae77Skettenis
1955b725ae77Skettenis if (within_scope)
1956b725ae77Skettenis {
1957b725ae77Skettenis /* We need to catch errors here, because if evaluate
1958b725ae77Skettenis expression fails we just want to make val->error = 1 and
1959b725ae77Skettenis go on */
1960b725ae77Skettenis if (gdb_evaluate_expression (var->root->exp, &new_val))
1961b725ae77Skettenis {
1962b725ae77Skettenis if (VALUE_LAZY (new_val))
1963b725ae77Skettenis {
1964b725ae77Skettenis /* We need to catch errors because if
1965b725ae77Skettenis value_fetch_lazy fails we still want to continue
1966b725ae77Skettenis (after making val->error = 1) */
1967b725ae77Skettenis /* FIXME: Shouldn't be using VALUE_CONTENTS? The
1968b725ae77Skettenis comment on value_fetch_lazy() says it is only
1969b725ae77Skettenis called from the macro... */
1970b725ae77Skettenis if (!gdb_value_fetch_lazy (new_val))
1971b725ae77Skettenis var->error = 1;
1972b725ae77Skettenis else
1973b725ae77Skettenis var->error = 0;
1974b725ae77Skettenis }
1975b725ae77Skettenis }
1976b725ae77Skettenis else
1977b725ae77Skettenis var->error = 1;
1978b725ae77Skettenis
1979b725ae77Skettenis release_value (new_val);
1980b725ae77Skettenis return new_val;
1981b725ae77Skettenis }
1982b725ae77Skettenis
1983b725ae77Skettenis return NULL;
1984b725ae77Skettenis }
1985b725ae77Skettenis
1986b725ae77Skettenis static struct value *
c_value_of_child(struct varobj * parent,int index)1987b725ae77Skettenis c_value_of_child (struct varobj *parent, int index)
1988b725ae77Skettenis {
1989b725ae77Skettenis struct value *value;
1990b725ae77Skettenis struct value *temp;
1991b725ae77Skettenis struct value *indval;
1992b725ae77Skettenis struct type *type, *target;
1993b725ae77Skettenis char *name;
1994b725ae77Skettenis
1995b725ae77Skettenis type = get_type (parent);
1996b725ae77Skettenis target = get_target_type (type);
1997b725ae77Skettenis name = name_of_child (parent, index);
1998b725ae77Skettenis temp = parent->value;
1999b725ae77Skettenis value = NULL;
2000b725ae77Skettenis
2001b725ae77Skettenis if (temp != NULL)
2002b725ae77Skettenis {
2003b725ae77Skettenis switch (TYPE_CODE (type))
2004b725ae77Skettenis {
2005b725ae77Skettenis case TYPE_CODE_ARRAY:
2006b725ae77Skettenis #if 0
2007b725ae77Skettenis /* This breaks if the array lives in a (vector) register. */
2008b725ae77Skettenis value = value_slice (temp, index, 1);
2009b725ae77Skettenis temp = value_coerce_array (value);
2010b725ae77Skettenis gdb_value_ind (temp, &value);
2011b725ae77Skettenis #else
2012b725ae77Skettenis indval = value_from_longest (builtin_type_int, (LONGEST) index);
2013b725ae77Skettenis gdb_value_subscript (temp, indval, &value);
2014b725ae77Skettenis #endif
2015b725ae77Skettenis break;
2016b725ae77Skettenis
2017b725ae77Skettenis case TYPE_CODE_STRUCT:
2018b725ae77Skettenis case TYPE_CODE_UNION:
2019b725ae77Skettenis gdb_value_struct_elt (NULL, &value, &temp, NULL, name, NULL,
2020b725ae77Skettenis "vstructure");
2021b725ae77Skettenis break;
2022b725ae77Skettenis
2023b725ae77Skettenis case TYPE_CODE_PTR:
2024b725ae77Skettenis switch (TYPE_CODE (target))
2025b725ae77Skettenis {
2026b725ae77Skettenis case TYPE_CODE_STRUCT:
2027b725ae77Skettenis case TYPE_CODE_UNION:
2028b725ae77Skettenis gdb_value_struct_elt (NULL, &value, &temp, NULL, name, NULL,
2029b725ae77Skettenis "vstructure");
2030b725ae77Skettenis break;
2031b725ae77Skettenis
2032b725ae77Skettenis default:
2033b725ae77Skettenis gdb_value_ind (temp, &value);
2034b725ae77Skettenis break;
2035b725ae77Skettenis }
2036b725ae77Skettenis break;
2037b725ae77Skettenis
2038b725ae77Skettenis default:
2039b725ae77Skettenis break;
2040b725ae77Skettenis }
2041b725ae77Skettenis }
2042b725ae77Skettenis
2043b725ae77Skettenis if (value != NULL)
2044b725ae77Skettenis release_value (value);
2045b725ae77Skettenis
2046b725ae77Skettenis xfree (name);
2047b725ae77Skettenis return value;
2048b725ae77Skettenis }
2049b725ae77Skettenis
2050b725ae77Skettenis static struct type *
c_type_of_child(struct varobj * parent,int index)2051b725ae77Skettenis c_type_of_child (struct varobj *parent, int index)
2052b725ae77Skettenis {
2053b725ae77Skettenis struct type *type;
2054b725ae77Skettenis char *name = name_of_child (parent, index);
2055b725ae77Skettenis
2056b725ae77Skettenis switch (TYPE_CODE (parent->type))
2057b725ae77Skettenis {
2058b725ae77Skettenis case TYPE_CODE_ARRAY:
2059b725ae77Skettenis type = get_target_type (parent->type);
2060b725ae77Skettenis break;
2061b725ae77Skettenis
2062b725ae77Skettenis case TYPE_CODE_STRUCT:
2063b725ae77Skettenis case TYPE_CODE_UNION:
2064b725ae77Skettenis type = lookup_struct_elt_type (parent->type, name, 0);
2065b725ae77Skettenis break;
2066b725ae77Skettenis
2067b725ae77Skettenis case TYPE_CODE_PTR:
2068b725ae77Skettenis switch (TYPE_CODE (get_target_type (parent->type)))
2069b725ae77Skettenis {
2070b725ae77Skettenis case TYPE_CODE_STRUCT:
2071b725ae77Skettenis case TYPE_CODE_UNION:
2072b725ae77Skettenis type = lookup_struct_elt_type (parent->type, name, 0);
2073b725ae77Skettenis break;
2074b725ae77Skettenis
2075b725ae77Skettenis default:
2076b725ae77Skettenis type = get_target_type (parent->type);
2077b725ae77Skettenis break;
2078b725ae77Skettenis }
2079b725ae77Skettenis break;
2080b725ae77Skettenis
2081b725ae77Skettenis default:
2082b725ae77Skettenis /* This should not happen as only the above types have children */
2083b725ae77Skettenis warning ("Child of parent whose type does not allow children");
2084b725ae77Skettenis /* FIXME: Can we still go on? */
2085b725ae77Skettenis type = NULL;
2086b725ae77Skettenis break;
2087b725ae77Skettenis }
2088b725ae77Skettenis
2089b725ae77Skettenis xfree (name);
2090b725ae77Skettenis return type;
2091b725ae77Skettenis }
2092b725ae77Skettenis
2093b725ae77Skettenis static int
c_variable_editable(struct varobj * var)2094b725ae77Skettenis c_variable_editable (struct varobj *var)
2095b725ae77Skettenis {
2096b725ae77Skettenis switch (TYPE_CODE (get_type (var)))
2097b725ae77Skettenis {
2098b725ae77Skettenis case TYPE_CODE_STRUCT:
2099b725ae77Skettenis case TYPE_CODE_UNION:
2100b725ae77Skettenis case TYPE_CODE_ARRAY:
2101b725ae77Skettenis case TYPE_CODE_FUNC:
2102b725ae77Skettenis case TYPE_CODE_MEMBER:
2103b725ae77Skettenis case TYPE_CODE_METHOD:
2104b725ae77Skettenis return 0;
2105b725ae77Skettenis break;
2106b725ae77Skettenis
2107b725ae77Skettenis default:
2108b725ae77Skettenis return 1;
2109b725ae77Skettenis break;
2110b725ae77Skettenis }
2111b725ae77Skettenis }
2112b725ae77Skettenis
2113b725ae77Skettenis static char *
c_value_of_variable(struct varobj * var)2114b725ae77Skettenis c_value_of_variable (struct varobj *var)
2115b725ae77Skettenis {
2116b725ae77Skettenis /* BOGUS: if val_print sees a struct/class, it will print out its
2117b725ae77Skettenis children instead of "{...}" */
2118b725ae77Skettenis
2119b725ae77Skettenis switch (TYPE_CODE (get_type (var)))
2120b725ae77Skettenis {
2121b725ae77Skettenis case TYPE_CODE_STRUCT:
2122b725ae77Skettenis case TYPE_CODE_UNION:
2123b725ae77Skettenis return xstrdup ("{...}");
2124b725ae77Skettenis /* break; */
2125b725ae77Skettenis
2126b725ae77Skettenis case TYPE_CODE_ARRAY:
2127b725ae77Skettenis {
2128b725ae77Skettenis char *number;
212911efff7fSkettenis number = xstrprintf ("[%d]", var->num_children);
2130b725ae77Skettenis return (number);
2131b725ae77Skettenis }
2132b725ae77Skettenis /* break; */
2133b725ae77Skettenis
2134b725ae77Skettenis default:
2135b725ae77Skettenis {
2136b725ae77Skettenis if (var->value == NULL)
2137b725ae77Skettenis {
2138b725ae77Skettenis /* This can happen if we attempt to get the value of a struct
2139b725ae77Skettenis member when the parent is an invalid pointer. This is an
2140b725ae77Skettenis error condition, so we should tell the caller. */
2141b725ae77Skettenis return NULL;
2142b725ae77Skettenis }
2143b725ae77Skettenis else
2144b725ae77Skettenis {
2145b725ae77Skettenis long dummy;
2146b725ae77Skettenis struct ui_file *stb = mem_fileopen ();
2147b725ae77Skettenis struct cleanup *old_chain = make_cleanup_ui_file_delete (stb);
2148b725ae77Skettenis char *thevalue;
2149b725ae77Skettenis
2150b725ae77Skettenis if (VALUE_LAZY (var->value))
2151b725ae77Skettenis gdb_value_fetch_lazy (var->value);
2152b725ae77Skettenis val_print (VALUE_TYPE (var->value),
2153b725ae77Skettenis VALUE_CONTENTS_RAW (var->value), 0,
2154b725ae77Skettenis VALUE_ADDRESS (var->value), stb,
2155b725ae77Skettenis format_code[(int) var->format], 1, 0, 0);
2156b725ae77Skettenis thevalue = ui_file_xstrdup (stb, &dummy);
2157b725ae77Skettenis do_cleanups (old_chain);
2158b725ae77Skettenis return thevalue;
2159b725ae77Skettenis }
2160b725ae77Skettenis }
2161b725ae77Skettenis }
2162b725ae77Skettenis }
2163b725ae77Skettenis
2164b725ae77Skettenis
2165b725ae77Skettenis /* C++ */
2166b725ae77Skettenis
2167b725ae77Skettenis static int
cplus_number_of_children(struct varobj * var)2168b725ae77Skettenis cplus_number_of_children (struct varobj *var)
2169b725ae77Skettenis {
2170b725ae77Skettenis struct type *type;
2171b725ae77Skettenis int children, dont_know;
2172b725ae77Skettenis
2173b725ae77Skettenis dont_know = 1;
2174b725ae77Skettenis children = 0;
2175b725ae77Skettenis
2176b725ae77Skettenis if (!CPLUS_FAKE_CHILD (var))
2177b725ae77Skettenis {
2178b725ae77Skettenis type = get_type_deref (var);
2179b725ae77Skettenis
2180b725ae77Skettenis if (((TYPE_CODE (type)) == TYPE_CODE_STRUCT) ||
2181b725ae77Skettenis ((TYPE_CODE (type)) == TYPE_CODE_UNION))
2182b725ae77Skettenis {
2183b725ae77Skettenis int kids[3];
2184b725ae77Skettenis
2185b725ae77Skettenis cplus_class_num_children (type, kids);
2186b725ae77Skettenis if (kids[v_public] != 0)
2187b725ae77Skettenis children++;
2188b725ae77Skettenis if (kids[v_private] != 0)
2189b725ae77Skettenis children++;
2190b725ae77Skettenis if (kids[v_protected] != 0)
2191b725ae77Skettenis children++;
2192b725ae77Skettenis
2193b725ae77Skettenis /* Add any baseclasses */
2194b725ae77Skettenis children += TYPE_N_BASECLASSES (type);
2195b725ae77Skettenis dont_know = 0;
2196b725ae77Skettenis
2197b725ae77Skettenis /* FIXME: save children in var */
2198b725ae77Skettenis }
2199b725ae77Skettenis }
2200b725ae77Skettenis else
2201b725ae77Skettenis {
2202b725ae77Skettenis int kids[3];
2203b725ae77Skettenis
2204b725ae77Skettenis type = get_type_deref (var->parent);
2205b725ae77Skettenis
2206b725ae77Skettenis cplus_class_num_children (type, kids);
2207b725ae77Skettenis if (strcmp (var->name, "public") == 0)
2208b725ae77Skettenis children = kids[v_public];
2209b725ae77Skettenis else if (strcmp (var->name, "private") == 0)
2210b725ae77Skettenis children = kids[v_private];
2211b725ae77Skettenis else
2212b725ae77Skettenis children = kids[v_protected];
2213b725ae77Skettenis dont_know = 0;
2214b725ae77Skettenis }
2215b725ae77Skettenis
2216b725ae77Skettenis if (dont_know)
2217b725ae77Skettenis children = c_number_of_children (var);
2218b725ae77Skettenis
2219b725ae77Skettenis return children;
2220b725ae77Skettenis }
2221b725ae77Skettenis
2222b725ae77Skettenis /* Compute # of public, private, and protected variables in this class.
2223b725ae77Skettenis That means we need to descend into all baseclasses and find out
2224b725ae77Skettenis how many are there, too. */
2225b725ae77Skettenis static void
cplus_class_num_children(struct type * type,int children[3])2226b725ae77Skettenis cplus_class_num_children (struct type *type, int children[3])
2227b725ae77Skettenis {
2228b725ae77Skettenis int i;
2229b725ae77Skettenis
2230b725ae77Skettenis children[v_public] = 0;
2231b725ae77Skettenis children[v_private] = 0;
2232b725ae77Skettenis children[v_protected] = 0;
2233b725ae77Skettenis
2234b725ae77Skettenis for (i = TYPE_N_BASECLASSES (type); i < TYPE_NFIELDS (type); i++)
2235b725ae77Skettenis {
2236b725ae77Skettenis /* If we have a virtual table pointer, omit it. */
2237b725ae77Skettenis if (TYPE_VPTR_BASETYPE (type) == type && TYPE_VPTR_FIELDNO (type) == i)
2238b725ae77Skettenis continue;
2239b725ae77Skettenis
2240b725ae77Skettenis if (TYPE_FIELD_PROTECTED (type, i))
2241b725ae77Skettenis children[v_protected]++;
2242b725ae77Skettenis else if (TYPE_FIELD_PRIVATE (type, i))
2243b725ae77Skettenis children[v_private]++;
2244b725ae77Skettenis else
2245b725ae77Skettenis children[v_public]++;
2246b725ae77Skettenis }
2247b725ae77Skettenis }
2248b725ae77Skettenis
2249b725ae77Skettenis static char *
cplus_name_of_variable(struct varobj * parent)2250b725ae77Skettenis cplus_name_of_variable (struct varobj *parent)
2251b725ae77Skettenis {
2252b725ae77Skettenis return c_name_of_variable (parent);
2253b725ae77Skettenis }
2254b725ae77Skettenis
2255b725ae77Skettenis static char *
cplus_name_of_child(struct varobj * parent,int index)2256b725ae77Skettenis cplus_name_of_child (struct varobj *parent, int index)
2257b725ae77Skettenis {
2258b725ae77Skettenis char *name;
2259b725ae77Skettenis struct type *type;
2260b725ae77Skettenis
2261b725ae77Skettenis if (CPLUS_FAKE_CHILD (parent))
2262b725ae77Skettenis {
2263b725ae77Skettenis /* Looking for children of public, private, or protected. */
2264b725ae77Skettenis type = get_type_deref (parent->parent);
2265b725ae77Skettenis }
2266b725ae77Skettenis else
2267b725ae77Skettenis type = get_type_deref (parent);
2268b725ae77Skettenis
2269b725ae77Skettenis name = NULL;
2270b725ae77Skettenis switch (TYPE_CODE (type))
2271b725ae77Skettenis {
2272b725ae77Skettenis case TYPE_CODE_STRUCT:
2273b725ae77Skettenis case TYPE_CODE_UNION:
2274b725ae77Skettenis if (CPLUS_FAKE_CHILD (parent))
2275b725ae77Skettenis {
2276b725ae77Skettenis /* The fields of the class type are ordered as they
2277b725ae77Skettenis appear in the class. We are given an index for a
2278b725ae77Skettenis particular access control type ("public","protected",
2279b725ae77Skettenis or "private"). We must skip over fields that don't
2280b725ae77Skettenis have the access control we are looking for to properly
2281b725ae77Skettenis find the indexed field. */
2282b725ae77Skettenis int type_index = TYPE_N_BASECLASSES (type);
2283b725ae77Skettenis if (strcmp (parent->name, "private") == 0)
2284b725ae77Skettenis {
2285b725ae77Skettenis while (index >= 0)
2286b725ae77Skettenis {
2287b725ae77Skettenis if (TYPE_VPTR_BASETYPE (type) == type
2288b725ae77Skettenis && type_index == TYPE_VPTR_FIELDNO (type))
2289b725ae77Skettenis ; /* ignore vptr */
2290b725ae77Skettenis else if (TYPE_FIELD_PRIVATE (type, type_index))
2291b725ae77Skettenis --index;
2292b725ae77Skettenis ++type_index;
2293b725ae77Skettenis }
2294b725ae77Skettenis --type_index;
2295b725ae77Skettenis }
2296b725ae77Skettenis else if (strcmp (parent->name, "protected") == 0)
2297b725ae77Skettenis {
2298b725ae77Skettenis while (index >= 0)
2299b725ae77Skettenis {
2300b725ae77Skettenis if (TYPE_VPTR_BASETYPE (type) == type
2301b725ae77Skettenis && type_index == TYPE_VPTR_FIELDNO (type))
2302b725ae77Skettenis ; /* ignore vptr */
2303b725ae77Skettenis else if (TYPE_FIELD_PROTECTED (type, type_index))
2304b725ae77Skettenis --index;
2305b725ae77Skettenis ++type_index;
2306b725ae77Skettenis }
2307b725ae77Skettenis --type_index;
2308b725ae77Skettenis }
2309b725ae77Skettenis else
2310b725ae77Skettenis {
2311b725ae77Skettenis while (index >= 0)
2312b725ae77Skettenis {
2313b725ae77Skettenis if (TYPE_VPTR_BASETYPE (type) == type
2314b725ae77Skettenis && type_index == TYPE_VPTR_FIELDNO (type))
2315b725ae77Skettenis ; /* ignore vptr */
2316b725ae77Skettenis else if (!TYPE_FIELD_PRIVATE (type, type_index) &&
2317b725ae77Skettenis !TYPE_FIELD_PROTECTED (type, type_index))
2318b725ae77Skettenis --index;
2319b725ae77Skettenis ++type_index;
2320b725ae77Skettenis }
2321b725ae77Skettenis --type_index;
2322b725ae77Skettenis }
2323b725ae77Skettenis
2324b725ae77Skettenis name = TYPE_FIELD_NAME (type, type_index);
2325b725ae77Skettenis }
2326b725ae77Skettenis else if (index < TYPE_N_BASECLASSES (type))
2327b725ae77Skettenis /* We are looking up the name of a base class */
2328b725ae77Skettenis name = TYPE_FIELD_NAME (type, index);
2329b725ae77Skettenis else
2330b725ae77Skettenis {
2331b725ae77Skettenis int children[3];
2332b725ae77Skettenis cplus_class_num_children(type, children);
2333b725ae77Skettenis
2334b725ae77Skettenis /* Everything beyond the baseclasses can
2335b725ae77Skettenis only be "public", "private", or "protected"
2336b725ae77Skettenis
2337b725ae77Skettenis The special "fake" children are always output by varobj in
2338b725ae77Skettenis this order. So if INDEX == 2, it MUST be "protected". */
2339b725ae77Skettenis index -= TYPE_N_BASECLASSES (type);
2340b725ae77Skettenis switch (index)
2341b725ae77Skettenis {
2342b725ae77Skettenis case 0:
2343b725ae77Skettenis if (children[v_public] > 0)
2344b725ae77Skettenis name = "public";
2345b725ae77Skettenis else if (children[v_private] > 0)
2346b725ae77Skettenis name = "private";
2347b725ae77Skettenis else
2348b725ae77Skettenis name = "protected";
2349b725ae77Skettenis break;
2350b725ae77Skettenis case 1:
2351b725ae77Skettenis if (children[v_public] > 0)
2352b725ae77Skettenis {
2353b725ae77Skettenis if (children[v_private] > 0)
2354b725ae77Skettenis name = "private";
2355b725ae77Skettenis else
2356b725ae77Skettenis name = "protected";
2357b725ae77Skettenis }
2358b725ae77Skettenis else if (children[v_private] > 0)
2359b725ae77Skettenis name = "protected";
2360b725ae77Skettenis break;
2361b725ae77Skettenis case 2:
2362b725ae77Skettenis /* Must be protected */
2363b725ae77Skettenis name = "protected";
2364b725ae77Skettenis break;
2365b725ae77Skettenis default:
2366b725ae77Skettenis /* error! */
2367b725ae77Skettenis break;
2368b725ae77Skettenis }
2369b725ae77Skettenis }
2370b725ae77Skettenis break;
2371b725ae77Skettenis
2372b725ae77Skettenis default:
2373b725ae77Skettenis break;
2374b725ae77Skettenis }
2375b725ae77Skettenis
2376b725ae77Skettenis if (name == NULL)
2377b725ae77Skettenis return c_name_of_child (parent, index);
2378b725ae77Skettenis else
2379b725ae77Skettenis {
2380b725ae77Skettenis if (name != NULL)
2381b725ae77Skettenis name = savestring (name, strlen (name));
2382b725ae77Skettenis }
2383b725ae77Skettenis
2384b725ae77Skettenis return name;
2385b725ae77Skettenis }
2386b725ae77Skettenis
2387b725ae77Skettenis static struct value *
cplus_value_of_root(struct varobj ** var_handle)2388b725ae77Skettenis cplus_value_of_root (struct varobj **var_handle)
2389b725ae77Skettenis {
2390b725ae77Skettenis return c_value_of_root (var_handle);
2391b725ae77Skettenis }
2392b725ae77Skettenis
2393b725ae77Skettenis static struct value *
cplus_value_of_child(struct varobj * parent,int index)2394b725ae77Skettenis cplus_value_of_child (struct varobj *parent, int index)
2395b725ae77Skettenis {
2396b725ae77Skettenis struct type *type;
2397b725ae77Skettenis struct value *value;
2398b725ae77Skettenis
2399b725ae77Skettenis if (CPLUS_FAKE_CHILD (parent))
2400b725ae77Skettenis type = get_type_deref (parent->parent);
2401b725ae77Skettenis else
2402b725ae77Skettenis type = get_type_deref (parent);
2403b725ae77Skettenis
2404b725ae77Skettenis value = NULL;
2405b725ae77Skettenis
2406b725ae77Skettenis if (((TYPE_CODE (type)) == TYPE_CODE_STRUCT) ||
2407b725ae77Skettenis ((TYPE_CODE (type)) == TYPE_CODE_UNION))
2408b725ae77Skettenis {
2409b725ae77Skettenis if (CPLUS_FAKE_CHILD (parent))
2410b725ae77Skettenis {
2411b725ae77Skettenis char *name;
2412b725ae77Skettenis struct value *temp = parent->parent->value;
2413b725ae77Skettenis
2414b725ae77Skettenis if (temp == NULL)
2415b725ae77Skettenis return NULL;
2416b725ae77Skettenis
2417b725ae77Skettenis name = name_of_child (parent, index);
2418b725ae77Skettenis gdb_value_struct_elt (NULL, &value, &temp, NULL, name, NULL,
2419b725ae77Skettenis "cplus_structure");
2420b725ae77Skettenis if (value != NULL)
2421b725ae77Skettenis release_value (value);
2422b725ae77Skettenis
2423b725ae77Skettenis xfree (name);
2424b725ae77Skettenis }
2425b725ae77Skettenis else if (index >= TYPE_N_BASECLASSES (type))
2426b725ae77Skettenis {
2427b725ae77Skettenis /* public, private, or protected */
2428b725ae77Skettenis return NULL;
2429b725ae77Skettenis }
2430b725ae77Skettenis else
2431b725ae77Skettenis {
2432b725ae77Skettenis /* Baseclass */
2433b725ae77Skettenis if (parent->value != NULL)
2434b725ae77Skettenis {
2435b725ae77Skettenis struct value *temp = NULL;
2436b725ae77Skettenis
2437b725ae77Skettenis if (TYPE_CODE (VALUE_TYPE (parent->value)) == TYPE_CODE_PTR
2438b725ae77Skettenis || TYPE_CODE (VALUE_TYPE (parent->value)) == TYPE_CODE_REF)
2439b725ae77Skettenis {
2440b725ae77Skettenis if (!gdb_value_ind (parent->value, &temp))
2441b725ae77Skettenis return NULL;
2442b725ae77Skettenis }
2443b725ae77Skettenis else
2444b725ae77Skettenis temp = parent->value;
2445b725ae77Skettenis
2446b725ae77Skettenis if (temp != NULL)
2447b725ae77Skettenis {
2448b725ae77Skettenis value = value_cast (TYPE_FIELD_TYPE (type, index), temp);
2449b725ae77Skettenis release_value (value);
2450b725ae77Skettenis }
2451b725ae77Skettenis else
2452b725ae77Skettenis {
2453b725ae77Skettenis /* We failed to evaluate the parent's value, so don't even
2454b725ae77Skettenis bother trying to evaluate this child. */
2455b725ae77Skettenis return NULL;
2456b725ae77Skettenis }
2457b725ae77Skettenis }
2458b725ae77Skettenis }
2459b725ae77Skettenis }
2460b725ae77Skettenis
2461b725ae77Skettenis if (value == NULL)
2462b725ae77Skettenis return c_value_of_child (parent, index);
2463b725ae77Skettenis
2464b725ae77Skettenis return value;
2465b725ae77Skettenis }
2466b725ae77Skettenis
2467b725ae77Skettenis static struct type *
cplus_type_of_child(struct varobj * parent,int index)2468b725ae77Skettenis cplus_type_of_child (struct varobj *parent, int index)
2469b725ae77Skettenis {
2470b725ae77Skettenis struct type *type, *t;
2471b725ae77Skettenis
2472b725ae77Skettenis if (CPLUS_FAKE_CHILD (parent))
2473b725ae77Skettenis {
2474b725ae77Skettenis /* Looking for the type of a child of public, private, or protected. */
2475b725ae77Skettenis t = get_type_deref (parent->parent);
2476b725ae77Skettenis }
2477b725ae77Skettenis else
2478b725ae77Skettenis t = get_type_deref (parent);
2479b725ae77Skettenis
2480b725ae77Skettenis type = NULL;
2481b725ae77Skettenis switch (TYPE_CODE (t))
2482b725ae77Skettenis {
2483b725ae77Skettenis case TYPE_CODE_STRUCT:
2484b725ae77Skettenis case TYPE_CODE_UNION:
2485b725ae77Skettenis if (CPLUS_FAKE_CHILD (parent))
2486b725ae77Skettenis {
2487b725ae77Skettenis char *name = cplus_name_of_child (parent, index);
2488b725ae77Skettenis type = lookup_struct_elt_type (t, name, 0);
2489b725ae77Skettenis xfree (name);
2490b725ae77Skettenis }
2491b725ae77Skettenis else if (index < TYPE_N_BASECLASSES (t))
2492b725ae77Skettenis type = TYPE_FIELD_TYPE (t, index);
2493b725ae77Skettenis else
2494b725ae77Skettenis {
2495b725ae77Skettenis /* special */
2496b725ae77Skettenis return NULL;
2497b725ae77Skettenis }
2498b725ae77Skettenis break;
2499b725ae77Skettenis
2500b725ae77Skettenis default:
2501b725ae77Skettenis break;
2502b725ae77Skettenis }
2503b725ae77Skettenis
2504b725ae77Skettenis if (type == NULL)
2505b725ae77Skettenis return c_type_of_child (parent, index);
2506b725ae77Skettenis
2507b725ae77Skettenis return type;
2508b725ae77Skettenis }
2509b725ae77Skettenis
2510b725ae77Skettenis static int
cplus_variable_editable(struct varobj * var)2511b725ae77Skettenis cplus_variable_editable (struct varobj *var)
2512b725ae77Skettenis {
2513b725ae77Skettenis if (CPLUS_FAKE_CHILD (var))
2514b725ae77Skettenis return 0;
2515b725ae77Skettenis
2516b725ae77Skettenis return c_variable_editable (var);
2517b725ae77Skettenis }
2518b725ae77Skettenis
2519b725ae77Skettenis static char *
cplus_value_of_variable(struct varobj * var)2520b725ae77Skettenis cplus_value_of_variable (struct varobj *var)
2521b725ae77Skettenis {
2522b725ae77Skettenis
2523b725ae77Skettenis /* If we have one of our special types, don't print out
2524b725ae77Skettenis any value. */
2525b725ae77Skettenis if (CPLUS_FAKE_CHILD (var))
2526b725ae77Skettenis return xstrdup ("");
2527b725ae77Skettenis
2528b725ae77Skettenis return c_value_of_variable (var);
2529b725ae77Skettenis }
2530b725ae77Skettenis
2531b725ae77Skettenis /* Java */
2532b725ae77Skettenis
2533b725ae77Skettenis static int
java_number_of_children(struct varobj * var)2534b725ae77Skettenis java_number_of_children (struct varobj *var)
2535b725ae77Skettenis {
2536b725ae77Skettenis return cplus_number_of_children (var);
2537b725ae77Skettenis }
2538b725ae77Skettenis
2539b725ae77Skettenis static char *
java_name_of_variable(struct varobj * parent)2540b725ae77Skettenis java_name_of_variable (struct varobj *parent)
2541b725ae77Skettenis {
2542b725ae77Skettenis char *p, *name;
2543b725ae77Skettenis
2544b725ae77Skettenis name = cplus_name_of_variable (parent);
2545b725ae77Skettenis /* If the name has "-" in it, it is because we
2546b725ae77Skettenis needed to escape periods in the name... */
2547b725ae77Skettenis p = name;
2548b725ae77Skettenis
2549b725ae77Skettenis while (*p != '\000')
2550b725ae77Skettenis {
2551b725ae77Skettenis if (*p == '-')
2552b725ae77Skettenis *p = '.';
2553b725ae77Skettenis p++;
2554b725ae77Skettenis }
2555b725ae77Skettenis
2556b725ae77Skettenis return name;
2557b725ae77Skettenis }
2558b725ae77Skettenis
2559b725ae77Skettenis static char *
java_name_of_child(struct varobj * parent,int index)2560b725ae77Skettenis java_name_of_child (struct varobj *parent, int index)
2561b725ae77Skettenis {
2562b725ae77Skettenis char *name, *p;
2563b725ae77Skettenis
2564b725ae77Skettenis name = cplus_name_of_child (parent, index);
2565b725ae77Skettenis /* Escape any periods in the name... */
2566b725ae77Skettenis p = name;
2567b725ae77Skettenis
2568b725ae77Skettenis while (*p != '\000')
2569b725ae77Skettenis {
2570b725ae77Skettenis if (*p == '.')
2571b725ae77Skettenis *p = '-';
2572b725ae77Skettenis p++;
2573b725ae77Skettenis }
2574b725ae77Skettenis
2575b725ae77Skettenis return name;
2576b725ae77Skettenis }
2577b725ae77Skettenis
2578b725ae77Skettenis static struct value *
java_value_of_root(struct varobj ** var_handle)2579b725ae77Skettenis java_value_of_root (struct varobj **var_handle)
2580b725ae77Skettenis {
2581b725ae77Skettenis return cplus_value_of_root (var_handle);
2582b725ae77Skettenis }
2583b725ae77Skettenis
2584b725ae77Skettenis static struct value *
java_value_of_child(struct varobj * parent,int index)2585b725ae77Skettenis java_value_of_child (struct varobj *parent, int index)
2586b725ae77Skettenis {
2587b725ae77Skettenis return cplus_value_of_child (parent, index);
2588b725ae77Skettenis }
2589b725ae77Skettenis
2590b725ae77Skettenis static struct type *
java_type_of_child(struct varobj * parent,int index)2591b725ae77Skettenis java_type_of_child (struct varobj *parent, int index)
2592b725ae77Skettenis {
2593b725ae77Skettenis return cplus_type_of_child (parent, index);
2594b725ae77Skettenis }
2595b725ae77Skettenis
2596b725ae77Skettenis static int
java_variable_editable(struct varobj * var)2597b725ae77Skettenis java_variable_editable (struct varobj *var)
2598b725ae77Skettenis {
2599b725ae77Skettenis return cplus_variable_editable (var);
2600b725ae77Skettenis }
2601b725ae77Skettenis
2602b725ae77Skettenis static char *
java_value_of_variable(struct varobj * var)2603b725ae77Skettenis java_value_of_variable (struct varobj *var)
2604b725ae77Skettenis {
2605b725ae77Skettenis return cplus_value_of_variable (var);
2606b725ae77Skettenis }
2607b725ae77Skettenis
2608b725ae77Skettenis extern void _initialize_varobj (void);
2609b725ae77Skettenis void
_initialize_varobj(void)2610b725ae77Skettenis _initialize_varobj (void)
2611b725ae77Skettenis {
2612b725ae77Skettenis int sizeof_table = sizeof (struct vlist *) * VAROBJ_TABLE_SIZE;
2613b725ae77Skettenis
2614b725ae77Skettenis varobj_table = xmalloc (sizeof_table);
2615b725ae77Skettenis memset (varobj_table, 0, sizeof_table);
2616b725ae77Skettenis
261711efff7fSkettenis deprecated_add_show_from_set (add_set_cmd ("debugvarobj", class_maintenance, var_zinteger, (char *) &varobjdebug, "Set varobj debugging.\n\
2618b725ae77Skettenis When non-zero, varobj debugging is enabled.", &setlist),
2619b725ae77Skettenis &showlist);
2620b725ae77Skettenis }
2621