Merge GDB 7.5.1

gdb/varobj.c

 /* Implementation of the GDB variable objects API.
 
    Copyright (C) 1999-2012 Free Software Foundation, Inc.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
 #include "exceptions.h"
 #include "value.h"
 #include "expression.h"
 #include "frame.h"
 #include "language.h"
-#include "wrapper.h"
 #include "gdbcmd.h"
 #include "block.h"
 #include "valprint.h"
 
 #include "gdb_assert.h"
 #include "gdb_string.h"
 #include "gdb_regex.h"
 
 #include "varobj.h"
 #include "vec.h"
 #include "gdbthread.h"
 #include "inferior.h"
+#include "ada-varobj.h"
+#include "ada-lang.h"
 
 #if HAVE_PYTHON
 #include "python/python.h"
 #include "python/python-internal.h"
 #else
 typedef int PyObject;
 #endif
 
+/* The names of varobjs representing anonymous structs or unions.  */
+#define ANONYMOUS_STRUCT_NAME _("<anonymous struct>")
+#define ANONYMOUS_UNION_NAME _("<anonymous union>")
+
 /* Non-zero if we want to see trace of varobj level stuff.  */
 
 int varobjdebug = 0;
 static void
 show_varobjdebug (struct ui_file *file, int from_tty,
                   struct cmd_list_element *c, const char *value)
 {
   fprintf_filtered (file, _("Varobj debugging is %s.\n"), value);
 }
 
@@ skipping 203 matching lines @@
 static struct type *get_value_type (struct varobj *var);
 
 static struct type *get_target_type (struct type *);
 
 static enum varobj_display_formats variable_default_display (struct varobj *);
 
 static void cppush (struct cpstack **pstack, char *name);
 
 static char *cppop (struct cpstack **pstack);
 
+static int update_type_if_necessary (struct varobj *var,
+                                     struct value *new_value);
+
 static int install_new_value (struct varobj *var, struct value *value, 
                               int initial);
 
 /* Language-specific routines.  */
 
 static enum varobj_languages variable_language (struct varobj *var);
 
 static int number_of_children (struct varobj *);
 
 static char *name_of_variable (struct varobj *);
@@ skipping 16 matching lines @@
 static int is_root_p (struct varobj *var);
 
 #if HAVE_PYTHON
 
 static struct varobj *varobj_add_child (struct varobj *var,
                                         const char *name,
                                         struct value *value);
 
 #endif /* HAVE_PYTHON */
 
+static int default_value_is_changeable_p (struct varobj *var);
+
 /* C implementation */
 
 static int c_number_of_children (struct varobj *var);
 
 static char *c_name_of_variable (struct varobj *parent);
 
 static char *c_name_of_child (struct varobj *parent, int index);
 
 static char *c_path_expr_of_child (struct varobj *child);
 
@@ skipping 58 matching lines @@
 
 static struct value *ada_value_of_root (struct varobj **var_handle);
 
 static struct value *ada_value_of_child (struct varobj *parent, int index);
 
 static struct type *ada_type_of_child (struct varobj *parent, int index);
 
 static char *ada_value_of_variable (struct varobj *var,
                                     enum varobj_display_formats format);
 
+static int ada_value_is_changeable_p (struct varobj *var);
+
+static int ada_value_has_mutated (struct varobj *var, struct value *new_val,
+                                  struct type *new_type);
+
 /* The language specific vector */
 
 struct language_specific
 {
 
   /* The language of this variable.  */
   enum varobj_languages language;
 
   /* The number of children of PARENT.  */
   int (*number_of_children) (struct varobj * parent);
@@ skipping 13 matching lines @@
 
   /* The ``struct value *'' of the INDEX'th child of PARENT.  */
   struct value *(*value_of_child) (struct varobj * parent, int index);
 
   /* The type of the INDEX'th child of PARENT.  */
   struct type *(*type_of_child) (struct varobj * parent, int index);
 
   /* The current value of VAR.  */
   char *(*value_of_variable) (struct varobj * var,
                               enum varobj_display_formats format);
+
+  /* Return non-zero if changes in value of VAR must be detected and
+     reported by -var-update.  Return zero if -var-update should never
+     report changes of such values.  This makes sense for structures
+     (since the changes in children values will be reported separately),
+     or for artifical objects (like 'public' pseudo-field in C++).
+
+     Return value of 0 means that gdb need not call value_fetch_lazy
+     for the value of this variable object.  */
+  int (*value_is_changeable_p) (struct varobj *var);
+
+  /* Return nonzero if the type of VAR has mutated.
+
+     VAR's value is still the varobj's previous value, while NEW_VALUE
+     is VAR's new value and NEW_TYPE is the var's new type.  NEW_VALUE
+     may be NULL indicating that there is no value available (the varobj
+     may be out of scope, of may be the child of a null pointer, for
+     instance).  NEW_TYPE, on the other hand, must never be NULL.
+
+     This function should also be able to assume that var's number of
+     children is set (not < 0).
+
+     Languages where types do not mutate can set this to NULL.  */
+  int (*value_has_mutated) (struct varobj *var, struct value *new_value,
+                            struct type *new_type);
 };
 
 /* Array of known source language routines.  */
 static struct language_specific languages[vlang_end] = {
   /* Unknown (try treating as C).  */
   {
    vlang_unknown,
    c_number_of_children,
    c_name_of_variable,
    c_name_of_child,
    c_path_expr_of_child,
    c_value_of_root,
    c_value_of_child,
    c_type_of_child,
-   c_value_of_variable}
+   c_value_of_variable,
+   default_value_is_changeable_p,
+   NULL /* value_has_mutated */}
   ,
   /* C */
   {
    vlang_c,
    c_number_of_children,
    c_name_of_variable,
    c_name_of_child,
    c_path_expr_of_child,
    c_value_of_root,
    c_value_of_child,
    c_type_of_child,
-   c_value_of_variable}
+   c_value_of_variable,
+   default_value_is_changeable_p,
+   NULL /* value_has_mutated */}
   ,
   /* C++ */
   {
    vlang_cplus,
    cplus_number_of_children,
    cplus_name_of_variable,
    cplus_name_of_child,
    cplus_path_expr_of_child,
    cplus_value_of_root,
    cplus_value_of_child,
    cplus_type_of_child,
-   cplus_value_of_variable}
+   cplus_value_of_variable,
+   default_value_is_changeable_p,
+   NULL /* value_has_mutated */}
   ,
   /* Java */
   {
    vlang_java,
    java_number_of_children,
    java_name_of_variable,
    java_name_of_child,
    java_path_expr_of_child,
    java_value_of_root,
    java_value_of_child,
    java_type_of_child,
-   java_value_of_variable},
+   java_value_of_variable,
+   default_value_is_changeable_p,
+   NULL /* value_has_mutated */},
   /* Ada */
   {
    vlang_ada,
    ada_number_of_children,
    ada_name_of_variable,
    ada_name_of_child,
    ada_path_expr_of_child,
    ada_value_of_root,
    ada_value_of_child,
    ada_type_of_child,
-   ada_value_of_variable}
+   ada_value_of_variable,
+   ada_value_is_changeable_p,
+   ada_value_has_mutated}
 };
 
 /* A little convenience enum for dealing with C++/Java.  */
 enum vsections
 {
   v_public = 0, v_private, v_protected
 };
 
 /* Private data */
 
@@ skipping 15 matching lines @@
 ((x) != NULL && (x)->type == NULL && (x)->value == NULL)
 
 
 
 /* API Implementation */
 static int
 is_root_p (struct varobj *var)
 {
   return (var->root->rootvar == var);
 }