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