GDB 7.6.50

gdb/ada-varobj.c

 /* varobj support for Ada.
 
-   Copyright (C) 2012 Free Software Foundation, Inc.
+   Copyright (C) 2012-2013 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
    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 "ada-varobj.h"
 #include "ada-lang.h"
+#include "varobj.h"
 #include "language.h"
 #include "valprint.h"
 
 /* Implementation principle used in this unit:
 
    For our purposes, the meat of the varobj object is made of two
    elements: The varobj's (struct) value, and the varobj's (struct)
    type.  In most situations, the varobj has a non-NULL value, and
    the type becomes redundant, as it can be directly derived from
    the value.  In the initial implementation of this unit, most
    routines would only take a value, and return a value.
 
    But there are many situations where it is possible for a varobj
    to have a NULL value.  For instance, if the varobj becomes out of
    scope.  Or better yet, when the varobj is the child of another
    NULL pointer varobj.  In that situation, we must rely on the type
    instead of the value to create the child varobj.
 
    That's why most functions below work with a (value, type) pair.
    The value may or may not be NULL.  But the type is always expected
    to be set.  When the value is NULL, then we work with the type
    alone, and keep the value NULL.  But when the value is not NULL,
    then we work using the value, because it provides more information.
    But we still always set the type as well, even if that type could
    easily be derived from the value.  The reason behind this is that
    it allows the code to use the type without having to worry about
    it being set or not.  It makes the code clearer.  */
 
+static int ada_varobj_get_number_of_children (struct value *parent_value,
+                                              struct type *parent_type);
+
 /* A convenience function that decodes the VALUE_PTR/TYPE_PTR couple:
    If there is a value (*VALUE_PTR not NULL), then perform the decoding
    using it, and compute the associated type from the resulting value.
    Otherwise, compute a static approximation of *TYPE_PTR, leaving
    *VALUE_PTR unchanged.
 
    The results are written in place.  */
 
 static void
 ada_varobj_decode_var (struct value **value_ptr, struct type **type_ptr)
@@ skipping 255 matching lines @@
       || TYPE_CODE (child_type) == TYPE_CODE_VOID)
     return 0;
 
   /* All other types have 1 child.  */
   return 1;
 }
 
 /* Return the number of children for the (PARENT_VALUE, PARENT_TYPE)
    pair.  */
 
-int
+static int
 ada_varobj_get_number_of_children (struct value *parent_value,
                                    struct type *parent_type)
 {
   ada_varobj_decode_var (&parent_value, &parent_type);
   ada_varobj_adjust_for_child_access (&parent_value, &parent_type);
 
   /* A typedef to an array descriptor in fact represents a pointer
      to an unconstrained array.  These types always have one child
      (the unconstrained array).  */
   if (ada_is_array_descriptor_type (parent_type)
@@ skipping 377 matching lines @@
      and return a NULL child_value.  */
   if (child_name)
     *child_name = xstrdup ("???");
 }
 
 /* Return the name of the child number CHILD_INDEX of the (PARENT_VALUE,
    PARENT_TYPE) pair.  PARENT_NAME is the name of the PARENT.
 
    The result should be deallocated after use with xfree.  */
 
-char *
+static char *
 ada_varobj_get_name_of_child (struct value *parent_value,
                               struct type *parent_type,
                               const char *parent_name, int child_index)
 {
   char *child_name;
 
   ada_varobj_describe_child (parent_value, parent_type, parent_name,
                              NULL, child_index, &child_name, NULL,
                              NULL, NULL);
   return child_name;
 }
 
 /* Return the path expression of the child number CHILD_INDEX of
    the (PARENT_VALUE, PARENT_TYPE) pair.  PARENT_NAME is the name
    of the parent, and PARENT_PATH_EXPR is the parent's path expression.
    Both must be non-NULL.
 
    The result must be deallocated after use with xfree.  */
 
-char *
+static char *
 ada_varobj_get_path_expr_of_child (struct value *parent_value,
                                    struct type *parent_type,
                                    const char *parent_name,
                                    const char *parent_path_expr,
                                    int child_index)
 {
   char *child_path_expr;
 
   ada_varobj_describe_child (parent_value, parent_type, parent_name,
                              parent_path_expr, child_index, NULL,
                              NULL, NULL, &child_path_expr);
 
   return child_path_expr;
 }
 
 /* Return the value of child number CHILD_INDEX of the (PARENT_VALUE,
    PARENT_TYPE) pair.  PARENT_NAME is the name of the parent.  */
 
-struct value *
+static struct value *
 ada_varobj_get_value_of_child (struct value *parent_value,
                                struct type *parent_type,
                                const char *parent_name, int child_index)
 {
   struct value *child_value;
 
   ada_varobj_describe_child (parent_value, parent_type, parent_name,
                              NULL, child_index, NULL, &child_value,
                              NULL, NULL);
 
   return child_value;
 }
 
 /* Return the type of child number CHILD_INDEX of the (PARENT_VALUE,
    PARENT_TYPE) pair.  */
 
-struct type *
+static struct type *
 ada_varobj_get_type_of_child (struct value *parent_value,
                               struct type *parent_type,
                               int child_index)
 {
   struct type *child_type;
 
   ada_varobj_describe_child (parent_value, parent_type, NULL, NULL,
                              child_index, NULL, NULL, &child_type, NULL);
 
   return child_type;
@@ skipping 58 matching lines @@
     }
   else
     result = xstrprintf ("[%d]", numchild);
 
   return result;
 }
 
 /* Return a string representation of the (VALUE, TYPE) pair, using
    the given print options OPTS as our formatting options.  */
 
-char *
+static char *
 ada_varobj_get_value_of_variable (struct value *value,
                                   struct type *type,
                                   struct value_print_options *opts)
 {
   char *result = NULL;
 
   ada_varobj_decode_var (&value, &type);
 
   switch (TYPE_CODE (type))
     {
     case TYPE_CODE_STRUCT:
     case TYPE_CODE_UNION:
       result = xstrdup ("{...}");
       break;
     case TYPE_CODE_ARRAY:
       result = ada_varobj_get_value_of_array_variable (value, type, opts);
       break;
     default:
       if (!value)
         result = xstrdup ("");
       else
         result = ada_varobj_get_value_image (value, opts);
       break;
     }
 
   return result;
 }
 
+/* Ada specific callbacks for VAROBJs.  */
 
+static int
+ada_number_of_children (struct varobj *var)
+{
+  return ada_varobj_get_number_of_children (var->value, var->type);
+}
+
+static char *
+ada_name_of_variable (struct varobj *parent)
+{
+  return c_varobj_ops.name_of_variable (parent);
+}
+
+static char *
+ada_name_of_child (struct varobj *parent, int index)
+{
+  return ada_varobj_get_name_of_child (parent->value, parent->type,
+                                       parent->name, index);
+}
+
+static char*
+ada_path_expr_of_child (struct varobj *child)
+{
+  struct varobj *parent = child->parent;
+  const char *parent_path_expr = varobj_get_path_expr (parent);
+
+  return ada_varobj_get_path_expr_of_child (parent->value,
+                                            parent->type,
+                                            parent->name,
+                                            parent_path_expr,
+                                            child->index);
+}
+
+static struct value *
+ada_value_of_child (struct varobj *parent, int index)
+{
+  return ada_varobj_get_value_of_child (parent->value, parent->type,
+                                        parent->name, index);
+}
+
+static struct type *
+ada_type_of_child (struct varobj *parent, int index)
+{
+  return ada_varobj_get_type_of_child (parent->value, parent->type,
+                                       index);
+}
+
+static char *
+ada_value_of_variable (struct varobj *var, enum varobj_display_formats format)
+{
+  struct value_print_options opts;
+
+  varobj_formatted_print_options (&opts, format);
+
+  return ada_varobj_get_value_of_variable (var->value, var->type, &opts);
+}
+
+/* Implement the "value_is_changeable_p" routine for Ada.  */
+
+static int
+ada_value_is_changeable_p (struct varobj *var)
+{
+  struct type *type = var->value ? value_type (var->value) : var->type;
+
+  if (ada_is_array_descriptor_type (type)
+      && TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
+    {
+      /* This is in reality a pointer to an unconstrained array.
+         its value is changeable.  */
+      return 1;
+    }
+
+  if (ada_is_string_type (type))
+    {
+      /* We display the contents of the string in the array's
+         "value" field.  The contents can change, so consider
+         that the array is changeable.  */
+      return 1;
+    }
+
+  return varobj_default_value_is_changeable_p (var);
+}
+
+/* Implement the "value_has_mutated" routine for Ada.  */
+
+static int
+ada_value_has_mutated (struct varobj *var, struct value *new_val,
+                       struct type *new_type)
+{
+  int i;
+  int from = -1;
+  int to = -1;
+
+  /* If the number of fields have changed, then for sure the type
+     has mutated.  */
+  if (ada_varobj_get_number_of_children (new_val, new_type)
+      != var->num_children)
+    return 1;
+
+  /* If the number of fields have remained the same, then we need
+     to check the name of each field.  If they remain the same,
+     then chances are the type hasn't mutated.  This is technically
+     an incomplete test, as the child's type might have changed
+     despite the fact that the name remains the same.  But we'll
+     handle this situation by saying that the child has mutated,
+     not this value.
+
+     If only part (or none!) of the children have been fetched,
+     then only check the ones we fetched.  It does not matter
+     to the frontend whether a child that it has not fetched yet
+     has mutated or not. So just assume it hasn't.  */
+
+  varobj_restrict_range (var->children, &from, &to);
+  for (i = from; i < to; i++)
+    if (strcmp (ada_varobj_get_name_of_child (new_val, new_type,
+                                              var->name, i),
+                VEC_index (varobj_p, var->children, i)->name) != 0)
+      return 1;
+
+  return 0;
+}
+
+/* varobj operations for ada.  */
+
+const struct lang_varobj_ops ada_varobj_ops =
+{
+  ada_number_of_children,
+  ada_name_of_variable,
+  ada_name_of_child,
+  ada_path_expr_of_child,
+  ada_value_of_child,
+  ada_type_of_child,
+  ada_value_of_variable,
+  ada_value_is_changeable_p,
+  ada_value_has_mutated
+};