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