1 files changed, 92 insertions, 92 deletions

diff --git a/gdb/valops.c b/gdb/valops.c
index 2e7abf5..5e29482 100644
--- a/gdb/valops.c
+++ b/gdb/valops.c
@@ -215,11 +215,11 @@ value_cast_structs (struct type *type, struct value *v2)
   t2 = check_typedef (value_type (v2));
 
   /* Check preconditions.  */
-  gdb_assert ((TYPE_CODE (t1) == TYPE_CODE_STRUCT
-	       || TYPE_CODE (t1) == TYPE_CODE_UNION)
+  gdb_assert ((t1->code () == TYPE_CODE_STRUCT
+	       || t1->code () == TYPE_CODE_UNION)
 	      && !!"Precondition is that type is of STRUCT or UNION kind.");
-  gdb_assert ((TYPE_CODE (t2) == TYPE_CODE_STRUCT
-	       || TYPE_CODE (t2) == TYPE_CODE_UNION)
+  gdb_assert ((t2->code () == TYPE_CODE_STRUCT
+	       || t2->code () == TYPE_CODE_UNION)
 	      && !!"Precondition is that value is of STRUCT or UNION kind");
 
   if (TYPE_NAME (t1) != NULL
@@ -300,8 +300,8 @@ value_cast_pointers (struct type *type, struct value *arg2,
   struct type *t1 = check_typedef (TYPE_TARGET_TYPE (type1));
   struct type *t2 = check_typedef (TYPE_TARGET_TYPE (type2));
 
-  if (TYPE_CODE (t1) == TYPE_CODE_STRUCT
-      && TYPE_CODE (t2) == TYPE_CODE_STRUCT
+  if (t1->code () == TYPE_CODE_STRUCT
+      && t2->code () == TYPE_CODE_STRUCT
       && (subclass_check || !value_logical_not (arg2)))
     {
       struct value *v2;
@@ -310,7 +310,7 @@ value_cast_pointers (struct type *type, struct value *arg2,
 	v2 = coerce_ref (arg2);
       else
 	v2 = value_ind (arg2);
-      gdb_assert (TYPE_CODE (check_typedef (value_type (v2)))
+      gdb_assert (check_typedef (value_type (v2))->code ()
 		  == TYPE_CODE_STRUCT && !!"Why did coercion fail?");
       v2 = value_cast_structs (t1, v2);
       /* At this point we have what we can have, un-dereference if needed.  */
@@ -359,7 +359,7 @@ value_cast (struct type *type, struct value *arg2)
       struct type *dereftype = check_typedef (TYPE_TARGET_TYPE (t1));
       struct value *val = value_cast (dereftype, arg2);
 
-      return value_ref (val, TYPE_CODE (t1));
+      return value_ref (val, t1->code ());
     }
 
   if (TYPE_IS_REFERENCE (check_typedef (value_type (arg2))))
@@ -372,7 +372,7 @@ value_cast (struct type *type, struct value *arg2)
   struct type *to_type = type;
 
   type = check_typedef (type);
-  code1 = TYPE_CODE (type);
+  code1 = type->code ();
   arg2 = coerce_ref (arg2);
   type2 = check_typedef (value_type (arg2));
 
@@ -415,15 +415,15 @@ value_cast (struct type *type, struct value *arg2)
     }
 
   if (current_language->c_style_arrays
-      && TYPE_CODE (type2) == TYPE_CODE_ARRAY
+      && type2->code () == TYPE_CODE_ARRAY
       && !TYPE_VECTOR (type2))
     arg2 = value_coerce_array (arg2);
 
-  if (TYPE_CODE (type2) == TYPE_CODE_FUNC)
+  if (type2->code () == TYPE_CODE_FUNC)
     arg2 = value_coerce_function (arg2);
 
   type2 = check_typedef (value_type (arg2));
-  code2 = TYPE_CODE (type2);
+  code2 = type2->code ();
 
   if (code1 == TYPE_CODE_COMPLEX)
     return cast_into_complex (to_type, arg2);
@@ -590,8 +590,8 @@ value_reinterpret_cast (struct type *type, struct value *arg)
 
   arg_type = value_type (arg);
 
-  dest_code = TYPE_CODE (real_type);
-  arg_code = TYPE_CODE (arg_type);
+  dest_code = real_type->code ();
+  arg_code = arg_type->code ();
 
   /* We can convert pointer types, or any pointer type to int, or int
      type to pointer.  */
@@ -611,7 +611,7 @@ value_reinterpret_cast (struct type *type, struct value *arg)
 
   if (is_ref)
     result = value_cast (type, value_ref (value_ind (result),
-                                          TYPE_CODE (type)));
+                                          type->code ()));
 
   return result;
 }
@@ -722,24 +722,24 @@ value_dynamic_cast (struct type *type, struct value *arg)
   CORE_ADDR addr;
   int is_ref = TYPE_IS_REFERENCE (resolved_type);
 
-  if (TYPE_CODE (resolved_type) != TYPE_CODE_PTR
+  if (resolved_type->code () != TYPE_CODE_PTR
       && !TYPE_IS_REFERENCE (resolved_type))
     error (_("Argument to dynamic_cast must be a pointer or reference type"));
-  if (TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) != TYPE_CODE_VOID
-      && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) != TYPE_CODE_STRUCT)
+  if (TYPE_TARGET_TYPE (resolved_type)->code () != TYPE_CODE_VOID
+      && TYPE_TARGET_TYPE (resolved_type)->code () != TYPE_CODE_STRUCT)
     error (_("Argument to dynamic_cast must be pointer to class or `void *'"));
 
   class_type = check_typedef (TYPE_TARGET_TYPE (resolved_type));
-  if (TYPE_CODE (resolved_type) == TYPE_CODE_PTR)
+  if (resolved_type->code () == TYPE_CODE_PTR)
     {
-      if (TYPE_CODE (arg_type) != TYPE_CODE_PTR
-	  && ! (TYPE_CODE (arg_type) == TYPE_CODE_INT
+      if (arg_type->code () != TYPE_CODE_PTR
+	  && ! (arg_type->code () == TYPE_CODE_INT
 		&& value_as_long (arg) == 0))
 	error (_("Argument to dynamic_cast does not have pointer type"));
-      if (TYPE_CODE (arg_type) == TYPE_CODE_PTR)
+      if (arg_type->code () == TYPE_CODE_PTR)
 	{
 	  arg_type = check_typedef (TYPE_TARGET_TYPE (arg_type));
-	  if (TYPE_CODE (arg_type) != TYPE_CODE_STRUCT)
+	  if (arg_type->code () != TYPE_CODE_STRUCT)
 	    error (_("Argument to dynamic_cast does "
 		     "not have pointer to class type"));
 	}
@@ -752,7 +752,7 @@ value_dynamic_cast (struct type *type, struct value *arg)
     }
   else
     {
-      if (TYPE_CODE (arg_type) != TYPE_CODE_STRUCT)
+      if (arg_type->code () != TYPE_CODE_STRUCT)
 	error (_("Argument to dynamic_cast does not have class type"));
     }
 
@@ -786,8 +786,8 @@ value_dynamic_cast (struct type *type, struct value *arg)
 
   /* dynamic_cast<void *> means to return a pointer to the
      most-derived object.  */
-  if (TYPE_CODE (resolved_type) == TYPE_CODE_PTR
-      && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) == TYPE_CODE_VOID)
+  if (resolved_type->code () == TYPE_CODE_PTR
+      && TYPE_TARGET_TYPE (resolved_type)->code () == TYPE_CODE_VOID)
     return value_at_lazy (type, addr);
 
   tem = value_at (type, addr);
@@ -808,7 +808,7 @@ value_dynamic_cast (struct type *type, struct value *arg)
 				&result) == 1)
 	return value_cast (type,
 			   is_ref
-			   ? value_ref (result, TYPE_CODE (resolved_type))
+			   ? value_ref (result, resolved_type->code ())
 			   : value_addr (result));
     }
 
@@ -822,10 +822,10 @@ value_dynamic_cast (struct type *type, struct value *arg)
 			       rtti_type, &result) == 1)
     return value_cast (type,
 		       is_ref
-		       ? value_ref (result, TYPE_CODE (resolved_type))
+		       ? value_ref (result, resolved_type->code ())
 		       : value_addr (result));
 
-  if (TYPE_CODE (resolved_type) == TYPE_CODE_PTR)
+  if (resolved_type->code () == TYPE_CODE_PTR)
     return value_zero (type, not_lval);
 
   error (_("dynamic_cast failed"));
@@ -854,7 +854,7 @@ value_one (struct type *type)
     {
       val = value_from_longest (type, (LONGEST) 1);
     }
-  else if (TYPE_CODE (type1) == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
+  else if (type1->code () == TYPE_CODE_ARRAY && TYPE_VECTOR (type1))
     {
       struct type *eltype = check_typedef (TYPE_TARGET_TYPE (type1));
       int i;
@@ -893,7 +893,7 @@ get_value_at (struct type *type, CORE_ADDR addr, int lazy)
 {
   struct value *val;
 
-  if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
+  if (check_typedef (type)->code () == TYPE_CODE_VOID)
     error (_("Attempt to dereference a generic pointer."));
 
   val = value_from_contents_and_address (type, NULL, addr);
@@ -1249,7 +1249,7 @@ value_assign (struct value *toval, struct value *fromval)
      in the case of pointer types.  For object types, the enclosing type
      and embedded offset must *not* be copied: the target object refered
      to by TOVAL retains its original dynamic type after assignment.  */
-  if (TYPE_CODE (type) == TYPE_CODE_PTR)
+  if (type->code () == TYPE_CODE_PTR)
     {
       set_value_enclosing_type (val, value_enclosing_type (fromval));
       set_value_pointed_to_offset (val, value_pointed_to_offset (fromval));
@@ -1306,7 +1306,7 @@ address_of_variable (struct symbol *var, const struct block *b)
   type = value_type (val);
 
   if ((VALUE_LVAL (val) == lval_memory && value_lazy (val))
-      || TYPE_CODE (type) == TYPE_CODE_FUNC)
+      || type->code () == TYPE_CODE_FUNC)
     {
       CORE_ADDR addr = value_address (val);
 
@@ -1358,7 +1358,7 @@ value_must_coerce_to_target (struct value *val)
 
   valtype = check_typedef (value_type (val));
 
-  switch (TYPE_CODE (valtype))
+  switch (valtype->code ())
     {
     case TYPE_CODE_ARRAY:
       return TYPE_VECTOR (valtype) ? 0 : 1;
@@ -1478,7 +1478,7 @@ value_addr (struct value *arg1)
 	  return arg2;
 	}
     }
-  if (TYPE_CODE (type) == TYPE_CODE_FUNC)
+  if (type->code () == TYPE_CODE_FUNC)
     return value_coerce_function (arg1);
 
   /* If this is an array that has not yet been pushed to the target,
@@ -1514,9 +1514,9 @@ value_ref (struct value *arg1, enum type_code refcode)
 
   gdb_assert (refcode == TYPE_CODE_REF || refcode == TYPE_CODE_RVALUE_REF);
 
-  if ((TYPE_CODE (type) == TYPE_CODE_REF
-       || TYPE_CODE (type) == TYPE_CODE_RVALUE_REF)
-      && TYPE_CODE (type) == refcode)
+  if ((type->code () == TYPE_CODE_REF
+       || type->code () == TYPE_CODE_RVALUE_REF)
+      && type->code () == refcode)
     return arg1;
 
   arg2 = value_addr (arg1);
@@ -1550,7 +1550,7 @@ value_ind (struct value *arg1)
 	}
     }
 
-  if (TYPE_CODE (base_type) == TYPE_CODE_PTR)
+  if (base_type->code () == TYPE_CODE_PTR)
     {
       struct type *enc_type;
 
@@ -1559,8 +1559,8 @@ value_ind (struct value *arg1)
       enc_type = check_typedef (value_enclosing_type (arg1));
       enc_type = TYPE_TARGET_TYPE (enc_type);
 
-      if (TYPE_CODE (check_typedef (enc_type)) == TYPE_CODE_FUNC
-	  || TYPE_CODE (check_typedef (enc_type)) == TYPE_CODE_METHOD)
+      if (check_typedef (enc_type)->code () == TYPE_CODE_FUNC
+	  || check_typedef (enc_type)->code () == TYPE_CODE_METHOD)
 	/* For functions, go through find_function_addr, which knows
 	   how to handle function descriptors.  */
 	arg2 = value_at_lazy (enc_type, 
@@ -1707,7 +1707,7 @@ typecmp (int staticp, int varargs, int nargs,
     t2 ++;
 
   for (i = 0;
-       (i < nargs) && TYPE_CODE (t1[i].type) != TYPE_CODE_VOID;
+       (i < nargs) && t1[i].type->code () != TYPE_CODE_VOID;
        i++)
     {
       struct type *tt1, *tt2;
@@ -1720,13 +1720,13 @@ typecmp (int staticp, int varargs, int nargs,
 
       if (TYPE_IS_REFERENCE (tt1)
 	  /* We should be doing hairy argument matching, as below.  */
-	  && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1)))
-	      == TYPE_CODE (tt2)))
+	  && (check_typedef (TYPE_TARGET_TYPE (tt1))->code ()
+	      == tt2->code ()))
 	{
-	  if (TYPE_CODE (tt2) == TYPE_CODE_ARRAY)
+	  if (tt2->code () == TYPE_CODE_ARRAY)
 	    t2[i] = value_coerce_array (t2[i]);
 	  else
-	    t2[i] = value_ref (t2[i], TYPE_CODE (tt1));
+	    t2[i] = value_ref (t2[i], tt1->code ());
 	  continue;
 	}
 
@@ -1736,17 +1736,17 @@ typecmp (int staticp, int varargs, int nargs,
 	 char *>, and properly access map["hello"], because the
 	 argument to [] will be a reference to a pointer to a char,
 	 and the argument will be a pointer to a char.  */
-      while (TYPE_IS_REFERENCE (tt1) || TYPE_CODE (tt1) == TYPE_CODE_PTR)
+      while (TYPE_IS_REFERENCE (tt1) || tt1->code () == TYPE_CODE_PTR)
 	{
-	  tt1 = check_typedef( TYPE_TARGET_TYPE(tt1) );
+	  tt1 = check_typedef ( TYPE_TARGET_TYPE (tt1) );
 	}
-      while (TYPE_CODE(tt2) == TYPE_CODE_ARRAY
-	     || TYPE_CODE(tt2) == TYPE_CODE_PTR
+      while (tt2->code () == TYPE_CODE_ARRAY
+	     || tt2->code () == TYPE_CODE_PTR
 	     || TYPE_IS_REFERENCE (tt2))
 	{
-	  tt2 = check_typedef (TYPE_TARGET_TYPE(tt2));
+	  tt2 = check_typedef (TYPE_TARGET_TYPE (tt2));
 	}
-      if (TYPE_CODE (tt1) == TYPE_CODE (tt2))
+      if (tt1->code () == tt2->code ())
 	continue;
       /* Array to pointer is a `trivial conversion' according to the
 	 ARM.  */
@@ -1754,7 +1754,7 @@ typecmp (int staticp, int varargs, int nargs,
       /* We should be doing much hairier argument matching (see
          section 13.2 of the ARM), but as a quick kludge, just check
          for the same type code.  */
-      if (TYPE_CODE (t1[i].type) != TYPE_CODE (value_type (t2[i])))
+      if (t1[i].type->code () != value_type (t2[i])->code ())
 	return i + 1;
     }
   if (varargs || t2[i] == NULL)
@@ -1826,8 +1826,8 @@ do_search_struct_field (const char *name, struct value *arg1, LONGEST offset,
 	  {
 	    struct type *field_type = TYPE_FIELD_TYPE (type, i);
 
-	    if (TYPE_CODE (field_type) == TYPE_CODE_UNION
-		|| TYPE_CODE (field_type) == TYPE_CODE_STRUCT)
+	    if (field_type->code () == TYPE_CODE_UNION
+		|| field_type->code () == TYPE_CODE_STRUCT)
 	      {
 		/* Look for a match through the fields of an anonymous
 		   union, or anonymous struct.  C++ provides anonymous
@@ -1850,7 +1850,7 @@ do_search_struct_field (const char *name, struct value *arg1, LONGEST offset,
 		   from GDB) implementation of variant records, the
 		   bitpos is zero in an anonymous union field, so we
 		   have to add the offset of the union here.  */
-		if (TYPE_CODE (field_type) == TYPE_CODE_STRUCT
+		if (field_type->code () == TYPE_CODE_STRUCT
 		    || (TYPE_NFIELDS (field_type) > 0
 			&& TYPE_FIELD_BITPOS (field_type, 0) == 0))
 		  new_offset += TYPE_FIELD_BITPOS (type, i) / 8;
@@ -2119,17 +2119,17 @@ value_struct_elt (struct value **argp, struct value **args,
 
   /* Follow pointers until we get to a non-pointer.  */
 
-  while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t))
+  while (t->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t))
     {
       *argp = value_ind (*argp);
       /* Don't coerce fn pointer to fn and then back again!  */
-      if (TYPE_CODE (check_typedef (value_type (*argp))) != TYPE_CODE_FUNC)
+      if (check_typedef (value_type (*argp))->code () != TYPE_CODE_FUNC)
 	*argp = coerce_array (*argp);
       t = check_typedef (value_type (*argp));
     }
 
-  if (TYPE_CODE (t) != TYPE_CODE_STRUCT
-      && TYPE_CODE (t) != TYPE_CODE_UNION)
+  if (t->code () != TYPE_CODE_STRUCT
+      && t->code () != TYPE_CODE_UNION)
     error (_("Attempt to extract a component of a value that is not a %s."),
 	   err);
 
@@ -2206,16 +2206,16 @@ value_struct_elt_bitpos (struct value **argp, int bitpos, struct type *ftype,
 
   t = check_typedef (value_type (*argp));
 
-  while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t))
+  while (t->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t))
     {
       *argp = value_ind (*argp);
-      if (TYPE_CODE (check_typedef (value_type (*argp))) != TYPE_CODE_FUNC)
+      if (check_typedef (value_type (*argp))->code () != TYPE_CODE_FUNC)
 	*argp = coerce_array (*argp);
       t = check_typedef (value_type (*argp));
     }
 
-  if (TYPE_CODE (t) != TYPE_CODE_STRUCT
-      && TYPE_CODE (t) != TYPE_CODE_UNION)
+  if (t->code () != TYPE_CODE_STRUCT
+      && t->code () != TYPE_CODE_UNION)
     error (_("Attempt to extract a component of a value that is not a %s."),
 	   err);
 
@@ -2359,17 +2359,17 @@ value_find_oload_method_list (struct value **argp, const char *method,
   t = check_typedef (value_type (*argp));
 
   /* Code snarfed from value_struct_elt.  */
-  while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t))
+  while (t->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (t))
     {
       *argp = value_ind (*argp);
       /* Don't coerce fn pointer to fn and then back again!  */
-      if (TYPE_CODE (check_typedef (value_type (*argp))) != TYPE_CODE_FUNC)
+      if (check_typedef (value_type (*argp))->code () != TYPE_CODE_FUNC)
 	*argp = coerce_array (*argp);
       t = check_typedef (value_type (*argp));
     }
 
-  if (TYPE_CODE (t) != TYPE_CODE_STRUCT
-      && TYPE_CODE (t) != TYPE_CODE_UNION)
+  if (t->code () != TYPE_CODE_STRUCT
+      && t->code () != TYPE_CODE_UNION)
     error (_("Attempt to extract a component of a "
 	     "value that is not a struct or union"));
 
@@ -2477,13 +2477,13 @@ find_overload_match (gdb::array_view<value *> args,
 
       /* OBJ may be a pointer value rather than the object itself.  */
       obj = coerce_ref (obj);
-      while (TYPE_CODE (check_typedef (value_type (obj))) == TYPE_CODE_PTR)
+      while (check_typedef (value_type (obj))->code () == TYPE_CODE_PTR)
 	obj = coerce_ref (value_ind (obj));
       obj_type_name = TYPE_NAME (value_type (obj));
 
       /* First check whether this is a data member, e.g. a pointer to
 	 a function.  */
-      if (TYPE_CODE (check_typedef (value_type (obj))) == TYPE_CODE_STRUCT)
+      if (check_typedef (value_type (obj))->code () == TYPE_CODE_STRUCT)
 	{
 	  *valp = search_struct_field (name, obj,
 				       check_typedef (value_type (obj)), 0);
@@ -2606,8 +2606,8 @@ find_overload_match (gdb::array_view<value *> args,
 	     the function part.  Do not try this for non-functions (e.g.
 	     function pointers).  */
           if (qualified_name
-              && TYPE_CODE (check_typedef (SYMBOL_TYPE (fsym)))
-	      == TYPE_CODE_FUNC)
+              && (check_typedef (SYMBOL_TYPE (fsym))->code ()
+		  == TYPE_CODE_FUNC))
             {
 	      temp_func = cp_func_name (qualified_name);
 
@@ -2752,8 +2752,8 @@ find_overload_match (gdb::array_view<value *> args,
       struct type *temp_type = check_typedef (value_type (temp));
       struct type *objtype = check_typedef (obj_type);
 
-      if (TYPE_CODE (temp_type) != TYPE_CODE_PTR
-	  && (TYPE_CODE (objtype) == TYPE_CODE_PTR
+      if (temp_type->code () != TYPE_CODE_PTR
+	  && (objtype->code () == TYPE_CODE_PTR
 	      || TYPE_IS_REFERENCE (objtype)))
 	{
 	  temp = value_addr (temp);
@@ -3118,7 +3118,7 @@ enum_constant_from_type (struct type *type, const char *name)
   int i;
   int name_len = strlen (name);
 
-  gdb_assert (TYPE_CODE (type) == TYPE_CODE_ENUM
+  gdb_assert (type->code () == TYPE_CODE_ENUM
 	      && TYPE_DECLARED_CLASS (type));
 
   for (i = TYPE_N_BASECLASSES (type); i < TYPE_NFIELDS (type); ++i)
@@ -3155,7 +3155,7 @@ value_aggregate_elt (struct type *curtype, const char *name,
 		     struct type *expect_type, int want_address,
 		     enum noside noside)
 {
-  switch (TYPE_CODE (curtype))
+  switch (curtype->code ())
     {
     case TYPE_CODE_STRUCT:
     case TYPE_CODE_UNION:
@@ -3206,7 +3206,7 @@ compare_parameters (struct type *t1, struct type *t2, int skip_artificial)
   /* Special case: a method taking void.  T1 will contain no
      non-artificial fields, and T2 will contain TYPE_CODE_VOID.  */
   if ((TYPE_NFIELDS (t1) - start) == 0 && TYPE_NFIELDS (t2) == 1
-      && TYPE_CODE (TYPE_FIELD_TYPE (t2, 0)) == TYPE_CODE_VOID)
+      && TYPE_FIELD_TYPE (t2, 0)->code () == TYPE_CODE_VOID)
     return 1;
 
   if ((TYPE_NFIELDS (t1) - start) == TYPE_NFIELDS (t2))
@@ -3288,8 +3288,8 @@ value_struct_elt_for_reference (struct type *domain, int offset,
   int i;
   struct value *result;
 
-  if (TYPE_CODE (t) != TYPE_CODE_STRUCT
-      && TYPE_CODE (t) != TYPE_CODE_UNION)
+  if (t->code () != TYPE_CODE_STRUCT
+      && t->code () != TYPE_CODE_UNION)
     error (_("Internal error: non-aggregate type "
 	     "to value_struct_elt_for_reference"));
 
@@ -3330,7 +3330,7 @@ value_struct_elt_for_reference (struct type *domain, int offset,
 		  ptr = value_aggregate_elt (domain, name, NULL, 1, noside);
 		  type = check_typedef (value_type (ptr));
 		  gdb_assert (type != NULL
-			      && TYPE_CODE (type) == TYPE_CODE_MEMBERPTR);
+			      && type->code () == TYPE_CODE_MEMBERPTR);
 		  tmp = lookup_pointer_type (TYPE_SELF_TYPE (type));
 		  v = value_cast_pointers (tmp, v, 1);
 		  mem_offset = value_as_long (ptr);
@@ -3367,7 +3367,7 @@ value_struct_elt_for_reference (struct type *domain, int offset,
      as a pointer to a method.  */
 
   /* Perform all necessary dereferencing.  */
-  while (intype && TYPE_CODE (intype) == TYPE_CODE_PTR)
+  while (intype && intype->code () == TYPE_CODE_PTR)
     intype = TYPE_TARGET_TYPE (intype);
 
   for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i)
@@ -3581,7 +3581,7 @@ value_rtti_indirect_type (struct value *v, int *full,
   type = check_typedef (type);
   if (TYPE_IS_REFERENCE (type))
     target = coerce_ref (v);
-  else if (TYPE_CODE (type) == TYPE_CODE_PTR)
+  else if (type->code () == TYPE_CODE_PTR)
     {
 
       try
@@ -3612,8 +3612,8 @@ value_rtti_indirect_type (struct value *v, int *full,
       real_type = make_cv_type (TYPE_CONST (target_type),
 				TYPE_VOLATILE (target_type), real_type, NULL);
       if (TYPE_IS_REFERENCE (type))
-        real_type = lookup_reference_type (real_type, TYPE_CODE (type));
-      else if (TYPE_CODE (type) == TYPE_CODE_PTR)
+        real_type = lookup_reference_type (real_type, type->code ());
+      else if (type->code () == TYPE_CODE_PTR)
         real_type = lookup_pointer_type (real_type);
       else
         internal_error (__FILE__, __LINE__, _("Unexpected value type."));
@@ -3760,8 +3760,8 @@ value_slice (struct value *array, int lowbound, int length)
   struct type *array_type;
 
   array_type = check_typedef (value_type (array));
-  if (TYPE_CODE (array_type) != TYPE_CODE_ARRAY
-      && TYPE_CODE (array_type) != TYPE_CODE_STRING)
+  if (array_type->code () != TYPE_CODE_ARRAY
+      && array_type->code () != TYPE_CODE_STRING)
     error (_("cannot take slice of non-array"));
 
   if (type_not_allocated (array_type))
@@ -3792,7 +3792,7 @@ value_slice (struct value *array, int lowbound, int length)
     slice_type = create_array_type (NULL,
 				    element_type,
 				    slice_range_type);
-    slice_type->set_code (TYPE_CODE (array_type));
+    slice_type->set_code (array_type->code ());
 
     if (VALUE_LVAL (array) == lval_memory && value_lazy (array))
       slice = allocate_value_lazy (slice_type);
@@ -3839,7 +3839,7 @@ value_real_part (struct value *value)
   struct type *type = check_typedef (value_type (value));
   struct type *ttype = TYPE_TARGET_TYPE (type);
 
-  gdb_assert (TYPE_CODE (type) == TYPE_CODE_COMPLEX);
+  gdb_assert (type->code () == TYPE_CODE_COMPLEX);
   return value_from_component (value, ttype, 0);
 }
 
@@ -3851,7 +3851,7 @@ value_imaginary_part (struct value *value)
   struct type *type = check_typedef (value_type (value));
   struct type *ttype = TYPE_TARGET_TYPE (type);
 
-  gdb_assert (TYPE_CODE (type) == TYPE_CODE_COMPLEX);
+  gdb_assert (type->code () == TYPE_CODE_COMPLEX);
   return value_from_component (value, ttype,
 			       TYPE_LENGTH (check_typedef (ttype)));
 }
@@ -3863,7 +3863,7 @@ cast_into_complex (struct type *type, struct value *val)
 {
   struct type *real_type = TYPE_TARGET_TYPE (type);
 
-  if (TYPE_CODE (value_type (val)) == TYPE_CODE_COMPLEX)
+  if (value_type (val)->code () == TYPE_CODE_COMPLEX)
     {
       struct type *val_real_type = TYPE_TARGET_TYPE (value_type (val));
       struct value *re_val = allocate_value (val_real_type);
@@ -3877,8 +3877,8 @@ cast_into_complex (struct type *type, struct value *val)
 
       return value_literal_complex (re_val, im_val, type);
     }
-  else if (TYPE_CODE (value_type (val)) == TYPE_CODE_FLT
-	   || TYPE_CODE (value_type (val)) == TYPE_CODE_INT)
+  else if (value_type (val)->code () == TYPE_CODE_FLT
+	   || value_type (val)->code () == TYPE_CODE_INT)
     return value_literal_complex (val, 
 				  value_zero (real_type, not_lval), 
 				  type);