xref: /openbsd-src/gnu/usr.bin/binutils/gdb/varobj.c (revision 15135fad20e50182f0393627abde324de2099a40)
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