Automatic date update in version.in

[external/binutils.git] / gdb / c-varobj.c

diff --git a/gdb/c-varobj.c b/gdb/c-varobj.c
index 16d5077..2d24774 100644 (file)
--- a/gdb/c-varobj.c
+++ b/gdb/c-varobj.c
@@ -1,6 +1,6 @@
 /* varobj support for C and C++.
 
-   Copyright (C) 1999-2016 Free Software Foundation, Inc.
+   Copyright (C) 1999-2019 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
@@ -34,7 +34,7 @@ static void cplus_class_num_children (struct type *type, int children[3]);
    This has already been determined by *_describe_child. The easiest
    thing to do is to compare the child's name with ANONYMOUS_*_NAME.  */
 
-int
+bool
 varobj_is_anonymous_child (const struct varobj *child)
 {
   return (child->name == ANONYMOUS_STRUCT_NAME
@@ -78,7 +78,7 @@ adjust_value_for_child_access (struct value **value,
      to us, is already supposed to be
      reference-stripped.  */
 
-  gdb_assert (TYPE_CODE (*type) != TYPE_CODE_REF);
+  gdb_assert (!TYPE_IS_REFERENCE (*type));
 
   /* Pointers to structures are treated just like
      structures when accessing children.  Don't
@@ -131,22 +131,21 @@ adjust_value_for_child_access (struct value **value,
 /* Is VAR a path expression parent, i.e., can it be used to construct
    a valid path expression?  */
 
-static int
+static bool
 c_is_path_expr_parent (const struct varobj *var)
 {
   struct type *type;
 
   /* "Fake" children are not path_expr parents.  */
   if (CPLUS_FAKE_CHILD (var))
-    return 0;
+    return false;
 
   type = varobj_get_gdb_type (var);
 
   /* Anonymous unions and structs are also not path_expr parents.  */
   if ((TYPE_CODE (type) == TYPE_CODE_STRUCT
        || TYPE_CODE (type) == TYPE_CODE_UNION)
-      && TYPE_NAME (type) == NULL
-      && TYPE_TAG_NAME (type) == NULL)
+      && TYPE_NAME (type) == NULL)
     {
       const struct varobj *parent = var->parent;
 
@@ -172,10 +171,10 @@ c_is_path_expr_parent (const struct varobj *var)
            }
        }
 
-      return 0;
+      return false;
     }
 
-  return 1;
+  return true;
 }
 
 /* C */
@@ -286,7 +285,7 @@ c_describe_child (const struct varobj *parent, int index,
                  std::string *cname, struct value **cvalue,
                  struct type **ctype, std::string *cfull_expression)
 {
-  struct value *value = parent->value;
+  struct value *value = parent->value.get ();
   struct type *type = varobj_get_value_type (parent);
   std::string parent_expression;
   int was_ptr;
@@ -488,7 +487,7 @@ c_value_of_variable (const struct varobj *var,
   struct type *type = get_type (var);
 
   /* Strip top-level references.  */
-  while (TYPE_CODE (type) == TYPE_CODE_REF)
+  while (TYPE_IS_REFERENCE (type))
     type = check_typedef (TYPE_TARGET_TYPE (type));
 
   switch (TYPE_CODE (type))
@@ -513,21 +512,22 @@ c_value_of_variable (const struct varobj *var,
          }
        else
          {
-           if (var->not_fetched && value_lazy (var->value))
+           if (var->not_fetched && value_lazy (var->value.get ()))
              /* Frozen variable and no value yet.  We don't
                 implicitly fetch the value.  MI response will
                 use empty string for the value, which is OK.  */
              return std::string ();
 
            gdb_assert (varobj_value_is_changeable_p (var));
-           gdb_assert (!value_lazy (var->value));
+           gdb_assert (!value_lazy (var->value.get ()));
            
            /* If the specified format is the current one,
               we can reuse print_value.  */
            if (format == var->format)
              return var->print_value;
            else
-             return varobj_value_get_print_value (var->value, format, var);
+             return varobj_value_get_print_value (var->value.get (), format,
+                                                  var);
          }
       }
     }
@@ -579,8 +579,8 @@ cplus_number_of_children (const struct varobj *var)
       /* It is necessary to access a real type (via RTTI).  */
       if (opts.objectprint)
         {
-          value = var->value;
-          lookup_actual_type = (TYPE_CODE (var->type) == TYPE_CODE_REF
+          value = var->value.get ();
+          lookup_actual_type = (TYPE_IS_REFERENCE (var->type)
                                || TYPE_CODE (var->type) == TYPE_CODE_PTR);
         }
       adjust_value_for_child_access (&value, &type, NULL, lookup_actual_type);
@@ -616,8 +616,8 @@ cplus_number_of_children (const struct varobj *var)
         {
          const struct varobj *parent = var->parent;
 
-         value = parent->value;
-         lookup_actual_type = (TYPE_CODE (parent->type) == TYPE_CODE_REF
+         value = parent->value.get ();
+         lookup_actual_type = (TYPE_IS_REFERENCE (parent->type)
                                || TYPE_CODE (parent->type) == TYPE_CODE_PTR);
         }
       adjust_value_for_child_access (&value, &type, NULL, lookup_actual_type);
@@ -722,9 +722,9 @@ cplus_describe_child (const struct varobj *parent, int index,
 
   var = (CPLUS_FAKE_CHILD (parent)) ? parent->parent : parent;
   if (opts.objectprint)
-    lookup_actual_type = (TYPE_CODE (var->type) == TYPE_CODE_REF
+    lookup_actual_type = (TYPE_IS_REFERENCE (var->type)
                          || TYPE_CODE (var->type) == TYPE_CODE_PTR);
-  value = var->value;
+  value = var->value.get ();
   type = varobj_get_value_type (var);
   if (cfull_expression)
     parent_expression
@@ -843,7 +843,7 @@ cplus_describe_child (const struct varobj *parent, int index,
        }
       else
        {
-         char *access = NULL;
+         const char *access = NULL;
          int children[3];
 
          cplus_class_num_children (type, children);