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