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