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