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