2007-08-10 Michael Snyder <msnyder@access-company.com>

	* gdbtypes.c: Comment/whitespace cleanup.

2 files changed, 476 insertions, 368 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index c4f6ede..0896eda 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,7 @@
 2007-08-10  Michael Snyder  <msnyder@access-company.com>
 
+	* gdbtypes.c: Comment/whitespace cleanup.
+
 	* stabsread.c (read_huge_number): Attempt to compute value before
 	values that it depends on.
 
diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index 887f400..3550543 100644
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -1,7 +1,7 @@
 /* Support routines for manipulating internal types for GDB.
 
-   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002,
-   2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
+   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
+   2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
 
    Contributed by Cygnus Support, using pieces from other GDB modules.
 
@@ -110,7 +110,8 @@ struct type *builtin_type_ia64_quad;
 int opaque_type_resolution = 1;
 static void
 show_opaque_type_resolution (struct ui_file *file, int from_tty,
-			     struct cmd_list_element *c, const char *value)
+			     struct cmd_list_element *c, 
+			     const char *value)
 {
   fprintf_filtered (file, _("\
 Resolution of opaque struct/class/union types (if set before loading symbols) is %s.\n"),
@@ -122,14 +123,15 @@ static void
 show_overload_debug (struct ui_file *file, int from_tty,
 		     struct cmd_list_element *c, const char *value)
 {
-  fprintf_filtered (file, _("Debugging of C++ overloading is %s.\n"), value);
+  fprintf_filtered (file, _("Debugging of C++ overloading is %s.\n"), 
+		    value);
 }
 
 struct extra
   {
     char str[128];
     int len;
-  };				/* maximum extension is 128! FIXME */
+  };				/* Maximum extension is 128!  FIXME  */
 
 static void print_bit_vector (B_TYPE *, int);
 static void print_arg_types (struct field *, int, int);
@@ -140,15 +142,15 @@ static void virtual_base_list_aux (struct type *dclass);
 
 /* Alloc a new type structure and fill it with some defaults.  If
    OBJFILE is non-NULL, then allocate the space for the type structure
-   in that objfile's objfile_obstack.  Otherwise allocate the new type structure
-   by xmalloc () (for permanent types).  */
+   in that objfile's objfile_obstack.  Otherwise allocate the new type
+   structure by xmalloc () (for permanent types).  */
 
 struct type *
 alloc_type (struct objfile *objfile)
 {
   struct type *type;
 
-  /* Alloc the structure and start off with all fields zeroed. */
+  /* Alloc the structure and start off with all fields zeroed.  */
 
   if (objfile == NULL)
     {
@@ -167,7 +169,7 @@ alloc_type (struct objfile *objfile)
     }
   memset (TYPE_MAIN_TYPE (type), 0, sizeof (struct main_type));
 
-  /* Initialize the fields that might not be zero. */
+  /* Initialize the fields that might not be zero.  */
 
   TYPE_CODE (type) = TYPE_CODE_UNDEF;
   TYPE_OBJFILE (type) = objfile;
@@ -236,10 +238,11 @@ make_pointer_type (struct type *type, struct type **typeptr)
   if (ntype)
     {
       if (typeptr == 0)
-	return ntype;		/* Don't care about alloc, and have new type.  */
+	return ntype;		/* Don't care about alloc, 
+				   and have new type.  */
       else if (*typeptr == 0)
 	{
-	  *typeptr = ntype;	/* Tracking alloc, and we have new type.  */
+	  *typeptr = ntype;	/* Tracking alloc, and have new type.  */
 	  return ntype;
 	}
     }
@@ -250,8 +253,7 @@ make_pointer_type (struct type *type, struct type **typeptr)
       if (typeptr)
 	*typeptr = ntype;
     }
-  else
-    /* We have storage, but need to reset it.  */
+  else			/* We have storage, but need to reset it.  */
     {
       ntype = *typeptr;
       objfile = TYPE_OBJFILE (ntype);
@@ -264,14 +266,16 @@ make_pointer_type (struct type *type, struct type **typeptr)
   TYPE_TARGET_TYPE (ntype) = type;
   TYPE_POINTER_TYPE (type) = ntype;
 
-  /* FIXME!  Assume the machine has only one representation for pointers!  */
+  /* FIXME!  Assume the machine has only one representation for
+     pointers!  */
 
-  TYPE_LENGTH (ntype) = gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT;
+  TYPE_LENGTH (ntype) = 
+    gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT;
   TYPE_CODE (ntype) = TYPE_CODE_PTR;
 
   /* Mark pointers as unsigned.  The target converts between pointers
      and addresses (CORE_ADDRs) using gdbarch_pointer_to_address and
-     gdbarch_address_to_pointer. */
+     gdbarch_address_to_pointer.  */
   TYPE_FLAGS (ntype) |= TYPE_FLAG_UNSIGNED;
 
   if (!TYPE_POINTER_TYPE (type))	/* Remember it, if don't have one.  */
@@ -297,10 +301,10 @@ lookup_pointer_type (struct type *type)
   return make_pointer_type (type, (struct type **) 0);
 }
 
-/* Lookup a C++ `reference' to a type TYPE.  TYPEPTR, if nonzero, points
-   to a pointer to memory where the reference type should be stored.
-   If *TYPEPTR is zero, update it to point to the reference type we return.
-   We allocate new memory if needed.  */
+/* Lookup a C++ `reference' to a type TYPE.  TYPEPTR, if nonzero,
+   points to a pointer to memory where the reference type should be
+   stored.  If *TYPEPTR is zero, update it to point to the reference
+   type we return.  We allocate new memory if needed.  */
 
 struct type *
 make_reference_type (struct type *type, struct type **typeptr)
@@ -314,10 +318,11 @@ make_reference_type (struct type *type, struct type **typeptr)
   if (ntype)
     {
       if (typeptr == 0)
-	return ntype;		/* Don't care about alloc, and have new type.  */
+	return ntype;		/* Don't care about alloc, 
+				   and have new type.  */
       else if (*typeptr == 0)
 	{
-	  *typeptr = ntype;	/* Tracking alloc, and we have new type.  */
+	  *typeptr = ntype;	/* Tracking alloc, and have new type.  */
 	  return ntype;
 	}
     }
@@ -328,8 +333,7 @@ make_reference_type (struct type *type, struct type **typeptr)
       if (typeptr)
 	*typeptr = ntype;
     }
-  else
-    /* We have storage, but need to reset it.  */
+  else			/* We have storage, but need to reset it.  */
     {
       ntype = *typeptr;
       objfile = TYPE_OBJFILE (ntype);
@@ -342,8 +346,9 @@ make_reference_type (struct type *type, struct type **typeptr)
   TYPE_TARGET_TYPE (ntype) = type;
   TYPE_REFERENCE_TYPE (type) = ntype;
 
-  /* FIXME!  Assume the machine has only one representation for references,
-     and that it matches the (only) representation for pointers!  */
+  /* FIXME!  Assume the machine has only one representation for
+     references, and that it matches the (only) representation for
+     pointers!  */
 
   TYPE_LENGTH (ntype) = gdbarch_ptr_bit (current_gdbarch) / TARGET_CHAR_BIT;
   TYPE_CODE (ntype) = TYPE_CODE_REF;
@@ -362,7 +367,8 @@ make_reference_type (struct type *type, struct type **typeptr)
   return ntype;
 }
 
-/* Same as above, but caller doesn't care about memory allocation details.  */
+/* Same as above, but caller doesn't care about memory allocation
+   details.  */
 
 struct type *
 lookup_reference_type (struct type *type)
@@ -370,10 +376,10 @@ lookup_reference_type (struct type *type)
   return make_reference_type (type, (struct type **) 0);
 }
 
-/* Lookup a function type that returns type TYPE.  TYPEPTR, if nonzero, points
-   to a pointer to memory where the function type should be stored.
-   If *TYPEPTR is zero, update it to point to the function type we return.
-   We allocate new memory if needed.  */
+/* Lookup a function type that returns type TYPE.  TYPEPTR, if
+   nonzero, points to a pointer to memory where the function type
+   should be stored.  If *TYPEPTR is zero, update it to point to the
+   function type we return.  We allocate new memory if needed.  */
 
 struct type *
 make_function_type (struct type *type, struct type **typeptr)
@@ -387,8 +393,7 @@ make_function_type (struct type *type, struct type **typeptr)
       if (typeptr)
 	*typeptr = ntype;
     }
-  else
-    /* We have storage, but need to reset it.  */
+  else			/* We have storage, but need to reset it.  */
     {
       ntype = *typeptr;
       objfile = TYPE_OBJFILE (ntype);
@@ -421,7 +426,7 @@ address_space_name_to_int (char *space_identifier)
 {
   struct gdbarch *gdbarch = current_gdbarch;
   int type_flags;
-  /* Check for known address space delimiters. */
+  /* Check for known address space delimiters.  */
   if (!strcmp (space_identifier, "code"))
     return TYPE_FLAG_CODE_SPACE;
   else if (!strcmp (space_identifier, "data"))
@@ -436,7 +441,7 @@ address_space_name_to_int (char *space_identifier)
 }
 
 /* Identify address space identifier by integer flag as defined in 
-   gdbtypes.h -- return the string version of the adress space name. */
+   gdbtypes.h -- return the string version of the adress space name.  */
 
 const char *
 address_space_int_to_name (int space_flag)
@@ -476,10 +481,10 @@ make_qualified_type (struct type *type, int new_flags,
     ntype = alloc_type_instance (type);
   else
     {
-      /* If STORAGE was provided, it had better be in the same objfile as
-	 TYPE.  Otherwise, we can't link it into TYPE's cv chain: if one
-	 objfile is freed and the other kept, we'd have dangling
-	 pointers.  */
+      /* If STORAGE was provided, it had better be in the same objfile
+	 as TYPE.  Otherwise, we can't link it into TYPE's cv chain:
+	 if one objfile is freed and the other kept, we'd have
+	 dangling pointers.  */
       gdb_assert (TYPE_OBJFILE (type) == TYPE_OBJFILE (storage));
 
       ntype = storage;
@@ -509,9 +514,10 @@ make_qualified_type (struct type *type, int new_flags,
    is identical to the one supplied except that it has an address
    space attribute attached to it (such as "code" or "data").
 
-   The space attributes "code" and "data" are for Harvard architectures.
-   The address space attributes are for architectures which have
-   alternately sized pointers or pointers with alternate representations.  */
+   The space attributes "code" and "data" are for Harvard
+   architectures.  The address space attributes are for architectures
+   which have alternately sized pointers or pointers with alternate
+   representations.  */
 
 struct type *
 make_type_with_address_space (struct type *type, int space_flag)
@@ -537,7 +543,9 @@ make_type_with_address_space (struct type *type, int space_flag)
    type whereever TYPE lives.  If TYPEPTR is non-zero, set it to the
    new type we construct.  */
 struct type *
-make_cv_type (int cnst, int voltl, struct type *type, struct type **typeptr)
+make_cv_type (int cnst, int voltl, 
+	      struct type *type, 
+	      struct type **typeptr)
 {
   struct type *ntype;	/* New type */
   struct type *tmp_type = type;	/* tmp type */
@@ -569,7 +577,8 @@ make_cv_type (int cnst, int voltl, struct type *type, struct type **typeptr)
       gdb_assert (TYPE_OBJFILE (*typeptr) == TYPE_OBJFILE (type));
     }
   
-  ntype = make_qualified_type (type, new_flags, typeptr ? *typeptr : NULL);
+  ntype = make_qualified_type (type, new_flags, 
+			       typeptr ? *typeptr : NULL);
 
   if (typeptr != NULL)
     *typeptr = ntype;
@@ -599,8 +608,8 @@ replace_type (struct type *ntype, struct type *type)
 
   *TYPE_MAIN_TYPE (ntype) = *TYPE_MAIN_TYPE (type);
 
-  /* The type length is not a part of the main type.  Update it for each
-     type on the variant chain.  */
+  /* The type length is not a part of the main type.  Update it for
+     each type on the variant chain.  */
   chain = ntype;
   do {
     /* Assert that this element of the chain has no address-class bits
@@ -650,11 +659,11 @@ lookup_methodptr_type (struct type *to_type)
   return mtype;
 }
 
-/* Allocate a stub method whose return type is TYPE.  
-   This apparently happens for speed of symbol reading, since parsing
-   out the arguments to the method is cpu-intensive, the way we are doing
-   it.  So, we will fill in arguments later.
-   This always returns a fresh type.   */
+/* Allocate a stub method whose return type is TYPE.  This apparently
+   happens for speed of symbol reading, since parsing out the
+   arguments to the method is cpu-intensive, the way we are doing it.
+   So, we will fill in arguments later.  This always returns a fresh
+   type.  */
 
 struct type *
 allocate_stub_method (struct type *type)
@@ -668,14 +677,15 @@ allocate_stub_method (struct type *type)
   return (mtype);
 }
 
-/* Create a range type using either a blank type supplied in RESULT_TYPE,
-   or creating a new type, inheriting the objfile from INDEX_TYPE.
+/* Create a range type using either a blank type supplied in
+   RESULT_TYPE, or creating a new type, inheriting the objfile from
+   INDEX_TYPE.
 
-   Indices will be of type INDEX_TYPE, and will range from LOW_BOUND to
-   HIGH_BOUND, inclusive.
+   Indices will be of type INDEX_TYPE, and will range from LOW_BOUND
+   to HIGH_BOUND, inclusive.
 
-   FIXME:  Maybe we should check the TYPE_CODE of RESULT_TYPE to make
-   sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
+   FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
+   sure it is TYPE_CODE_UNDEF before we bash it into a range type?  */
 
 struct type *
 create_range_type (struct type *result_type, struct type *index_type,
@@ -706,9 +716,9 @@ create_range_type (struct type *result_type, struct type *index_type,
   return (result_type);
 }
 
-/* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type TYPE.
-   Return 1 if type is a range type, 0 if it is discrete (and bounds
-   will fit in LONGEST), or -1 otherwise. */
+/* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type
+   TYPE.  Return 1 if type is a range type, 0 if it is discrete (and
+   bounds will fit in LONGEST), or -1 otherwise.  */
 
 int
 get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp)
@@ -736,7 +746,7 @@ get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp)
 		*highp = TYPE_FIELD_BITPOS (type, i);
 	    }
 
-	  /* Set unsigned indicator if warranted. */
+	  /* Set unsigned indicator if warranted.  */
 	  if (*lowp >= 0)
 	    {
 	      TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
@@ -761,12 +771,12 @@ get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp)
 	  *highp = -*lowp - 1;
 	  return 0;
 	}
-      /* ... fall through for unsigned ints ... */
+      /* ... fall through for unsigned ints ...  */
     case TYPE_CODE_CHAR:
       *lowp = 0;
       /* This round-about calculation is to avoid shifting by
          TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
-         if TYPE_LENGTH (type) == sizeof (LONGEST). */
+         if TYPE_LENGTH (type) == sizeof (LONGEST).  */
       *highp = 1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1);
       *highp = (*highp - 1) | *highp;
       return 0;
@@ -775,17 +785,20 @@ get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp)
     }
 }
 
-/* Create an array type using either a blank type supplied in RESULT_TYPE,
-   or creating a new type, inheriting the objfile from RANGE_TYPE.
+/* Create an array type using either a blank type supplied in
+   RESULT_TYPE, or creating a new type, inheriting the objfile from
+   RANGE_TYPE.
 
    Elements will be of type ELEMENT_TYPE, the indices will be of type
    RANGE_TYPE.
 
-   FIXME:  Maybe we should check the TYPE_CODE of RESULT_TYPE to make
-   sure it is TYPE_CODE_UNDEF before we bash it into an array type? */
+   FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
+   sure it is TYPE_CODE_UNDEF before we bash it into an array
+   type?  */
 
 struct type *
-create_array_type (struct type *result_type, struct type *element_type,
+create_array_type (struct type *result_type, 
+		   struct type *element_type,
 		   struct type *range_type)
 {
   LONGEST low_bound, high_bound;
@@ -815,19 +828,21 @@ create_array_type (struct type *result_type, struct type *element_type,
   return (result_type);
 }
 
-/* Create a string type using either a blank type supplied in RESULT_TYPE,
-   or creating a new type.  String types are similar enough to array of
-   char types that we can use create_array_type to build the basic type
-   and then bash it into a string type.
+/* Create a string type using either a blank type supplied in
+   RESULT_TYPE, or creating a new type.  String types are similar
+   enough to array of char types that we can use create_array_type to
+   build the basic type and then bash it into a string type.
 
    For fixed length strings, the range type contains 0 as the lower
    bound and the length of the string minus one as the upper bound.
 
-   FIXME:  Maybe we should check the TYPE_CODE of RESULT_TYPE to make
-   sure it is TYPE_CODE_UNDEF before we bash it into a string type? */
+   FIXME: Maybe we should check the TYPE_CODE of RESULT_TYPE to make
+   sure it is TYPE_CODE_UNDEF before we bash it into a string
+   type?  */
 
 struct type *
-create_string_type (struct type *result_type, struct type *range_type)
+create_string_type (struct type *result_type, 
+		    struct type *range_type)
 {
   struct type *string_char_type;
       
@@ -894,9 +909,11 @@ init_flags_type (char *name, int length)
   int nfields = length * TARGET_CHAR_BIT;
   struct type *type;
 
-  type = init_type (TYPE_CODE_FLAGS, length, TYPE_FLAG_UNSIGNED, name, NULL);
+  type = init_type (TYPE_CODE_FLAGS, length, 
+		    TYPE_FLAG_UNSIGNED, name, NULL);
   TYPE_NFIELDS (type) = nfields;
-  TYPE_FIELDS (type) = TYPE_ALLOC (type, nfields * sizeof (struct field));
+  TYPE_FIELDS (type) = TYPE_ALLOC (type, 
+				   nfields * sizeof (struct field));
   memset (TYPE_FIELDS (type), 0, nfields * sizeof (struct field));
 
   return type;
@@ -908,7 +925,8 @@ init_vector_type (struct type *elt_type, int n)
   struct type *array_type;
  
   array_type = create_array_type (0, elt_type,
-				  create_range_type (0, builtin_type_int,
+				  create_range_type (0, 
+						     builtin_type_int,
 						     0, n-1));
   TYPE_FLAGS (array_type) |= TYPE_FLAG_VECTOR;
   return array_type;
@@ -921,8 +939,8 @@ init_vector_type (struct type *elt_type, int n)
    itself), but does include the structure type into which it points
    (for some reason).
 
-   When "smashing" the type, we preserve the objfile that the
-   old type pointed to, since we aren't changing where the type is actually
+   When "smashing" the type, we preserve the objfile that the old type
+   pointed to, since we aren't changing where the type is actually
    allocated.  */
 
 void
@@ -946,8 +964,8 @@ smash_to_memberptr_type (struct type *type, struct type *domain,
 /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
    METHOD just means `function that gets an extra "this" argument'.
 
-   When "smashing" the type, we preserve the objfile that the
-   old type pointed to, since we aren't changing where the type is actually
+   When "smashing" the type, we preserve the objfile that the old type
+   pointed to, since we aren't changing where the type is actually
    allocated.  */
 
 void
@@ -980,15 +998,15 @@ type_name_no_tag (const struct type *type)
   if (TYPE_TAG_NAME (type) != NULL)
     return TYPE_TAG_NAME (type);
 
-  /* Is there code which expects this to return the name if there is no
-     tag name?  My guess is that this is mainly used for C++ in cases where
-     the two will always be the same.  */
+  /* Is there code which expects this to return the name if there is
+     no tag name?  My guess is that this is mainly used for C++ in
+     cases where the two will always be the same.  */
   return TYPE_NAME (type);
 }
 
-/* Lookup a typedef or primitive type named NAME,
-   visible in lexical block BLOCK.
-   If NOERR is nonzero, return zero if NAME is not suitably defined.  */
+/* Lookup a typedef or primitive type named NAME, visible in lexical
+   block BLOCK.  If NOERR is nonzero, return zero if NAME is not
+   suitably defined.  */
 
 struct type *
 lookup_typename (char *name, struct block *block, int noerr)
@@ -996,7 +1014,8 @@ lookup_typename (char *name, struct block *block, int noerr)
   struct symbol *sym;
   struct type *tmp;
 
-  sym = lookup_symbol (name, block, VAR_DOMAIN, 0, (struct symtab **) NULL);
+  sym = lookup_symbol (name, block, VAR_DOMAIN, 0, 
+		       (struct symtab **) NULL);
   if (sym == NULL || SYMBOL_CLASS (sym) != LOC_TYPEDEF)
     {
       tmp = language_lookup_primitive_type_by_name (current_language,
@@ -1037,7 +1056,7 @@ lookup_signed_typename (char *name)
   strcpy (uns, "signed ");
   strcpy (uns + 7, name);
   t = lookup_typename (uns, (struct block *) NULL, 1);
-  /* If we don't find "signed FOO" just try again with plain "FOO". */
+  /* If we don't find "signed FOO" just try again with plain "FOO".  */
   if (t != NULL)
     return t;
   return lookup_typename (name, (struct block *) NULL, 0);
@@ -1060,7 +1079,8 @@ lookup_struct (char *name, struct block *block)
     }
   if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
     {
-      error (_("This context has class, union or enum %s, not a struct."), name);
+      error (_("This context has class, union or enum %s, not a struct."),
+	     name);
     }
   return (SYMBOL_TYPE (sym));
 }
@@ -1092,8 +1112,9 @@ lookup_union (char *name, struct block *block)
     if (TYPE_DECLARED_TYPE (t) == DECLARED_TYPE_UNION)
       return (t);
 
-  /* If we get here, it's not a union */
-  error (_("This context has class, struct or enum %s, not a union."), name);
+  /* If we get here, it's not a union.  */
+  error (_("This context has class, struct or enum %s, not a union."), 
+	 name);
 }
 
 
@@ -1113,7 +1134,8 @@ lookup_enum (char *name, struct block *block)
     }
   if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM)
     {
-      error (_("This context has class, struct or union %s, not an enum."), name);
+      error (_("This context has class, struct or union %s, not an enum."), 
+	     name);
     }
   return (SYMBOL_TYPE (sym));
 }
@@ -1122,16 +1144,19 @@ lookup_enum (char *name, struct block *block)
    visible in lexical block BLOCK.  */
 
 struct type *
-lookup_template_type (char *name, struct type *type, struct block *block)
+lookup_template_type (char *name, struct type *type, 
+		      struct block *block)
 {
   struct symbol *sym;
-  char *nam = (char *) alloca (strlen (name) + strlen (TYPE_NAME (type)) + 4);
+  char *nam = (char *) 
+    alloca (strlen (name) + strlen (TYPE_NAME (type)) + 4);
   strcpy (nam, name);
   strcat (nam, "<");
   strcat (nam, TYPE_NAME (type));
-  strcat (nam, " >");		/* FIXME, extra space still introduced in gcc? */
+  strcat (nam, " >");	/* FIXME, extra space still introduced in gcc? */
 
-  sym = lookup_symbol (nam, block, VAR_DOMAIN, 0, (struct symtab **) NULL);
+  sym = lookup_symbol (nam, block, VAR_DOMAIN, 0, 
+		       (struct symtab **) NULL);
 
   if (sym == NULL)
     {
@@ -1139,17 +1164,20 @@ lookup_template_type (char *name, struct type *type, struct block *block)
     }
   if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
     {
-      error (_("This context has class, union or enum %s, not a struct."), name);
+      error (_("This context has class, union or enum %s, not a struct."),
+	     name);
     }
   return (SYMBOL_TYPE (sym));
 }
 
-/* Given a type TYPE, lookup the type of the component of type named NAME.  
+/* Given a type TYPE, lookup the type of the component of type named
+   NAME.
 
-   TYPE can be either a struct or union, or a pointer or reference to a struct or
-   union.  If it is a pointer or reference, its target type is automatically used.
-   Thus '.' and '->' are interchangable, as specified for the definitions of the
-   expression element types STRUCTOP_STRUCT and STRUCTOP_PTR.
+   TYPE can be either a struct or union, or a pointer or reference to
+   a struct or union.  If it is a pointer or reference, its target
+   type is automatically used.  Thus '.' and '->' are interchangable,
+   as specified for the definitions of the expression element types
+   STRUCTOP_STRUCT and STRUCTOP_PTR.
 
    If NOERR is nonzero, return zero if NAME is not suitably defined.
    If NAME is the name of a baseclass type, return that type.  */
@@ -1179,10 +1207,10 @@ lookup_struct_elt_type (struct type *type, char *name, int noerr)
     }
 
 #if 0
-  /* FIXME:  This change put in by Michael seems incorrect for the case where
-     the structure tag name is the same as the member name.  I.E. when doing
-     "ptype bell->bar" for "struct foo { int bar; int foo; } bell;"
-     Disabled by fnf. */
+  /* FIXME: This change put in by Michael seems incorrect for the case
+     where the structure tag name is the same as the member name.
+     I.E. when doing "ptype bell->bar" for "struct foo { int bar; int
+     foo; } bell;" Disabled by fnf.  */
   {
     char *typename;
 
@@ -1232,9 +1260,9 @@ lookup_struct_elt_type (struct type *type, char *name, int noerr)
 /* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE
    valid.  Callers should be aware that in some cases (for example,
    the type or one of its baseclasses is a stub type and we are
-   debugging a .o file), this function will not be able to find the virtual
-   function table pointer, and vptr_fieldno will remain -1 and vptr_basetype
-   will remain NULL.  */
+   debugging a .o file), this function will not be able to find the
+   virtual function table pointer, and vptr_fieldno will remain -1 and
+   vptr_basetype will remain NULL.  */
 
 void
 fill_in_vptr_fieldno (struct type *type)
@@ -1245,11 +1273,12 @@ fill_in_vptr_fieldno (struct type *type)
     {
       int i;
 
-      /* We must start at zero in case the first (and only) baseclass is
-         virtual (and hence we cannot share the table pointer).  */
+      /* We must start at zero in case the first (and only) baseclass
+         is virtual (and hence we cannot share the table pointer).  */
       for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
 	{
-	  struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
+	  struct type *baseclass = check_typedef (TYPE_BASECLASS (type,
+								  i));
 	  fill_in_vptr_fieldno (baseclass);
 	  if (TYPE_VPTR_FIELDNO (baseclass) >= 0)
 	    {
@@ -1265,7 +1294,9 @@ fill_in_vptr_fieldno (struct type *type)
    Return 1 if the destructor was found, otherwise, return 0.  */
 
 int
-get_destructor_fn_field (struct type *t, int *method_indexp, int *field_indexp)
+get_destructor_fn_field (struct type *t, 
+			 int *method_indexp, 
+			 int *field_indexp)
 {
   int i;
 
@@ -1297,19 +1328,19 @@ stub_noname_complaint (void)
 
    If this is a stubbed struct (i.e. declared as struct foo *), see if
    we can find a full definition in some other file. If so, copy this
-   definition, so we can use it in future.  There used to be a comment (but
-   not any code) that if we don't find a full definition, we'd set a flag
-   so we don't spend time in the future checking the same type.  That would
-   be a mistake, though--we might load in more symbols which contain a
-   full definition for the type.
+   definition, so we can use it in future.  There used to be a comment
+   (but not any code) that if we don't find a full definition, we'd
+   set a flag so we don't spend time in the future checking the same
+   type.  That would be a mistake, though--we might load in more
+   symbols which contain a full definition for the type.
 
    This used to be coded as a macro, but I don't think it is called 
    often enough to merit such treatment.  */
 
-/* Find the real type of TYPE.  This function returns the real type, after
-   removing all layers of typedefs and completing opaque or stub types.
-   Completion changes the TYPE argument, but stripping of typedefs does
-   not.  */
+/* Find the real type of TYPE.  This function returns the real type,
+   after removing all layers of typedefs and completing opaque or stub
+   types.  Completion changes the TYPE argument, but stripping of
+   typedefs does not.  */
 
 struct type *
 check_typedef (struct type *type)
@@ -1327,15 +1358,15 @@ check_typedef (struct type *type)
 	  struct symbol *sym;
 
 	  /* It is dangerous to call lookup_symbol if we are currently
-	     reading a symtab.  Infinite recursion is one danger. */
+	     reading a symtab.  Infinite recursion is one danger.  */
 	  if (currently_reading_symtab)
 	    return type;
 
 	  name = type_name_no_tag (type);
-	  /* FIXME: shouldn't we separately check the TYPE_NAME and the
-	     TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or VAR_DOMAIN
-	     as appropriate?  (this code was written before TYPE_NAME and
-	     TYPE_TAG_NAME were separate).  */
+	  /* FIXME: shouldn't we separately check the TYPE_NAME and
+	     the TYPE_TAG_NAME, and look in STRUCT_DOMAIN and/or
+	     VAR_DOMAIN as appropriate?  (this code was written before
+	     TYPE_NAME and TYPE_TAG_NAME were separate).  */
 	  if (name == NULL)
 	    {
 	      stub_noname_complaint ();
@@ -1345,8 +1376,8 @@ check_typedef (struct type *type)
 			       (struct symtab **) NULL);
 	  if (sym)
 	    TYPE_TARGET_TYPE (type) = SYMBOL_TYPE (sym);
-	  else
-	    TYPE_TARGET_TYPE (type) = alloc_type (NULL);	/* TYPE_CODE_UNDEF */
+	  else					/* TYPE_CODE_UNDEF */
+	    TYPE_TARGET_TYPE (type) = alloc_type (NULL);
 	}
       type = TYPE_TARGET_TYPE (type);
     }
@@ -1354,12 +1385,15 @@ check_typedef (struct type *type)
   is_const = TYPE_CONST (type);
   is_volatile = TYPE_VOLATILE (type);
 
-  /* If this is a struct/class/union with no fields, then check whether a
-     full definition exists somewhere else.  This is for systems where a
-     type definition with no fields is issued for such types, instead of
-     identifying them as stub types in the first place */
+  /* If this is a struct/class/union with no fields, then check
+     whether a full definition exists somewhere else.  This is for
+     systems where a type definition with no fields is issued for such
+     types, instead of identifying them as stub types in the first
+     place.  */
 
-  if (TYPE_IS_OPAQUE (type) && opaque_type_resolution && !currently_reading_symtab)
+  if (TYPE_IS_OPAQUE (type) 
+      && opaque_type_resolution 
+      && !currently_reading_symtab)
     {
       char *name = type_name_no_tag (type);
       struct type *newtype;
@@ -1372,23 +1406,24 @@ check_typedef (struct type *type)
 
       if (newtype)
 	{
-	  /* If the resolved type and the stub are in the same objfile,
-	     then replace the stub type with the real deal.  But if
-	     they're in separate objfiles, leave the stub alone; we'll
-	     just look up the transparent type every time we call
-	     check_typedef.  We can't create pointers between types
-	     allocated to different objfiles, since they may have
-	     different lifetimes.  Trying to copy NEWTYPE over to TYPE's
-	     objfile is pointless, too, since you'll have to move over any
-	     other types NEWTYPE refers to, which could be an unbounded
-	     amount of stuff.  */
+	  /* If the resolved type and the stub are in the same
+	     objfile, then replace the stub type with the real deal.
+	     But if they're in separate objfiles, leave the stub
+	     alone; we'll just look up the transparent type every time
+	     we call check_typedef.  We can't create pointers between
+	     types allocated to different objfiles, since they may
+	     have different lifetimes.  Trying to copy NEWTYPE over to
+	     TYPE's objfile is pointless, too, since you'll have to
+	     move over any other types NEWTYPE refers to, which could
+	     be an unbounded amount of stuff.  */
 	  if (TYPE_OBJFILE (newtype) == TYPE_OBJFILE (type))
 	    make_cv_type (is_const, is_volatile, newtype, &type);
 	  else
 	    type = newtype;
 	}
     }
-  /* Otherwise, rely on the stub flag being set for opaque/stubbed types */
+  /* Otherwise, rely on the stub flag being set for opaque/stubbed
+     types.  */
   else if (TYPE_STUB (type) && !currently_reading_symtab)
     {
       char *name = type_name_no_tag (type);
@@ -1402,14 +1437,16 @@ check_typedef (struct type *type)
 	  stub_noname_complaint ();
 	  return type;
 	}
-      sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 0, (struct symtab **) NULL);
+      sym = lookup_symbol (name, 0, STRUCT_DOMAIN, 
+			   0, (struct symtab **) NULL);
       if (sym)
         {
           /* Same as above for opaque types, we can replace the stub
              with the complete type only if they are int the same
              objfile.  */
 	  if (TYPE_OBJFILE (SYMBOL_TYPE(sym)) == TYPE_OBJFILE (type))
-            make_cv_type (is_const, is_volatile, SYMBOL_TYPE (sym), &type);
+            make_cv_type (is_const, is_volatile, 
+			  SYMBOL_TYPE (sym), &type);
 	  else
 	    type = SYMBOL_TYPE (sym);
         }
@@ -1422,6 +1459,7 @@ check_typedef (struct type *type)
 
       if (TYPE_STUB (target_type) || TYPE_TARGET_STUB (target_type))
 	{
+	  /* Empty.  */
 	}
       else if (TYPE_CODE (type) == TYPE_CODE_ARRAY
 	       && TYPE_NFIELDS (type) == 1
@@ -1432,8 +1470,7 @@ check_typedef (struct type *type)
 	     number of elements and the target type's length.  */
 	  TYPE_LENGTH (type) =
 	    ((TYPE_FIELD_BITPOS (range_type, 1)
-	      - TYPE_FIELD_BITPOS (range_type, 0)
-	      + 1)
+	      - TYPE_FIELD_BITPOS (range_type, 0) + 1)
 	     * TYPE_LENGTH (target_type));
 	  TYPE_FLAGS (type) &= ~TYPE_FLAG_TARGET_STUB;
 	}
@@ -1443,13 +1480,13 @@ check_typedef (struct type *type)
 	  TYPE_FLAGS (type) &= ~TYPE_FLAG_TARGET_STUB;
 	}
     }
-  /* Cache TYPE_LENGTH for future use. */
+  /* Cache TYPE_LENGTH for future use.  */
   TYPE_LENGTH (orig_type) = TYPE_LENGTH (type);
   return type;
 }
 
-/* Parse a type expression in the string [P..P+LENGTH).  If an error occurs,
-   silently return builtin_type_void. */
+/* Parse a type expression in the string [P..P+LENGTH).  If an error
+   occurs, silently return builtin_type_void.  */
 
 static struct type *
 safe_parse_type (char *p, int length)
@@ -1457,15 +1494,15 @@ safe_parse_type (char *p, int length)
   struct ui_file *saved_gdb_stderr;
   struct type *type;
 
-  /* Suppress error messages. */
+  /* Suppress error messages.  */
   saved_gdb_stderr = gdb_stderr;
   gdb_stderr = ui_file_new ();
 
-  /* Call parse_and_eval_type() without fear of longjmp()s. */
+  /* Call parse_and_eval_type() without fear of longjmp()s.  */
   if (!gdb_parse_and_eval_type (p, length, &type))
     type = builtin_type_void;
 
-  /* Stop suppressing error messages. */
+  /* Stop suppressing error messages.  */
   ui_file_delete (gdb_stderr);
   gdb_stderr = saved_gdb_stderr;
 
@@ -1474,13 +1511,13 @@ safe_parse_type (char *p, int length)
 
 /* Ugly hack to convert method stubs into method types.
 
-   He ain't kiddin'.  This demangles the name of the method into a string
-   including argument types, parses out each argument type, generates
-   a string casting a zero to that type, evaluates the string, and stuffs
-   the resulting type into an argtype vector!!!  Then it knows the type
-   of the whole function (including argument types for overloading),
-   which info used to be in the stab's but was removed to hack back
-   the space required for them.  */
+   He ain't kiddin'.  This demangles the name of the method into a
+   string including argument types, parses out each argument type,
+   generates a string casting a zero to that type, evaluates the
+   string, and stuffs the resulting type into an argtype vector!!!
+   Then it knows the type of the whole function (including argument
+   types for overloading), which info used to be in the stab's but was
+   removed to hack back the space required for them.  */
 
 static void
 check_stub_method (struct type *type, int method_id, int signature_id)
@@ -1501,7 +1538,8 @@ check_stub_method (struct type *type, int method_id, int signature_id)
     p = NULL;
 
   if (demangled_name == NULL || p == NULL)
-    error (_("Internal: Cannot demangle mangled name `%s'."), mangled_name);
+    error (_("Internal: Cannot demangle mangled name `%s'."), 
+	   mangled_name);
 
   /* Now, read in the parameters that define this type.  */
   p += 1;
@@ -1591,10 +1629,11 @@ check_stub_method (struct type *type, int method_id, int signature_id)
   xfree (demangled_name);
 }
 
-/* This is the external interface to check_stub_method, above.  This function
-   unstubs all of the signatures for TYPE's METHOD_ID method name.  After
-   calling this function TYPE_FN_FIELD_STUB will be cleared for each signature
-   and TYPE_FN_FIELDLIST_NAME will be correct.
+/* This is the external interface to check_stub_method, above.  This
+   function unstubs all of the signatures for TYPE's METHOD_ID method
+   name.  After calling this function TYPE_FN_FIELD_STUB will be
+   cleared for each signature and TYPE_FN_FIELDLIST_NAME will be
+   correct.
 
    This function unfortunately can not die until stabs do.  */
 
@@ -1612,10 +1651,11 @@ check_stub_method_group (struct type *type, int method_id)
 	check_stub_method (type, method_id, j);
       }
 
-  /* GNU v3 methods with incorrect names were corrected when we read in
-     type information, because it was cheaper to do it then.  The only GNU v2
-     methods with incorrect method names are operators and destructors;
-     destructors were also corrected when we read in type information.
+  /* GNU v3 methods with incorrect names were corrected when we read
+     in type information, because it was cheaper to do it then.  The
+     only GNU v2 methods with incorrect method names are operators and
+     destructors; destructors were also corrected when we read in type
+     information.
 
      Therefore the only thing we need to handle here are v2 operator
      names.  */
@@ -1624,10 +1664,12 @@ check_stub_method_group (struct type *type, int method_id)
       int ret;
       char dem_opname[256];
 
-      ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type, method_id),
+      ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type, 
+							   method_id),
 				   dem_opname, DMGL_ANSI);
       if (!ret)
-	ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type, method_id),
+	ret = cplus_demangle_opname (TYPE_FN_FIELDLIST_NAME (type, 
+							     method_id),
 				     dem_opname, 0);
       if (ret)
 	TYPE_FN_FIELDLIST_NAME (type, method_id) = xstrdup (dem_opname);
@@ -1649,14 +1691,15 @@ allocate_cplus_struct_type (struct type *type)
 
 /* Helper function to initialize the standard scalar types.
 
-   If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
-   of the string pointed to by name in the objfile_obstack for that objfile,
-   and initialize the type name to that copy.  There are places (mipsread.c
-   in particular, where init_type is called with a NULL value for NAME). */
+   If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy of
+   the string pointed to by name in the objfile_obstack for that
+   objfile, and initialize the type name to that copy.  There are
+   places (mipsread.c in particular, where init_type is called with a
+   NULL value for NAME).  */
 
 struct type *
-init_type (enum type_code code, int length, int flags, char *name,
-	   struct objfile *objfile)
+init_type (enum type_code code, int length, int flags,
+	   char *name, struct objfile *objfile)
 {
   struct type *type;
 
@@ -1666,8 +1709,8 @@ init_type (enum type_code code, int length, int flags, char *name,
   TYPE_FLAGS (type) |= flags;
   if ((name != NULL) && (objfile != NULL))
     {
-      TYPE_NAME (type) =
-	obsavestring (name, strlen (name), &objfile->objfile_obstack);
+      TYPE_NAME (type) = obsavestring (name, strlen (name), 
+				       &objfile->objfile_obstack);
     }
   else
     {
@@ -1703,7 +1746,8 @@ init_composite_type (char *name, enum type_code code)
 /* Helper function.  Append a field to a composite type.  */
 
 void
-append_composite_type_field (struct type *t, char *name, struct type *field)
+append_composite_type_field (struct type *t, char *name, 
+			     struct type *field)
 {
   struct field *f;
   TYPE_NFIELDS (t) = TYPE_NFIELDS (t) + 1;
@@ -1736,18 +1780,18 @@ append_composite_type_field (struct type *t, char *name, struct type *field)
    types such as "int" or "double".  Others (stabs for example), do
    define fundamental types.
 
-   For the formats which don't provide fundamental types, gdb can create
-   such types, using defaults reasonable for the current language and
-   the current target machine.
+   For the formats which don't provide fundamental types, gdb can
+   create such types, using defaults reasonable for the current
+   language and the current target machine.
 
-   NOTE:  This routine is obsolescent.  Each debugging format reader
+   NOTE: This routine is obsolescent.  Each debugging format reader
    should manage it's own fundamental types, either creating them from
    suitable defaults or reading them from the debugging information,
-   whichever is appropriate.  The DWARF reader has already been
-   fixed to do this.  Once the other readers are fixed, this routine
-   will go away.  Also note that fundamental types should be managed
-   on a compilation unit basis in a multi-language environment, not
-   on a linkage unit basis as is done here. */
+   whichever is appropriate.  The DWARF reader has already been fixed
+   to do this.  Once the other readers are fixed, this routine will go
+   away.  Also note that fundamental types should be managed on a
+   compilation unit basis in a multi-language environment, not on a
+   linkage unit basis as is done here.  */
 
 
 struct type *
@@ -1758,11 +1802,13 @@ lookup_fundamental_type (struct objfile *objfile, int typeid)
 
   if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
     {
-      error (_("internal error - invalid fundamental type id %d"), typeid);
+      error (_("internal error - invalid fundamental type id %d"), 
+	     typeid);
     }
 
-  /* If this is the first time we need a fundamental type for this objfile
-     then we need to initialize the vector of type pointers. */
+  /* If this is the first time we need a fundamental type for this
+     objfile then we need to initialize the vector of type
+     pointers.  */
 
   if (objfile->fundamental_types == NULL)
     {
@@ -1773,8 +1819,9 @@ lookup_fundamental_type (struct objfile *objfile, int typeid)
       OBJSTAT (objfile, n_types += FT_NUM_MEMBERS);
     }
 
-  /* Look for this particular type in the fundamental type vector.  If one is
-     not found, create and install one appropriate for the current language. */
+  /* Look for this particular type in the fundamental type vector.  If
+     one is not found, create and install one appropriate for the
+     current language.  */
 
   typep = objfile->fundamental_types + typeid;
   if (*typep == NULL)
@@ -1788,7 +1835,8 @@ lookup_fundamental_type (struct objfile *objfile, int typeid)
 int
 can_dereference (struct type *t)
 {
-  /* FIXME: Should we return true for references as well as pointers?  */
+  /* FIXME: Should we return true for references as well as
+     pointers?  */
   CHECK_TYPEDEF (t);
   return
     (t != NULL
@@ -1814,7 +1862,7 @@ is_integral_type (struct type *t)
    Return 1 if so, and 0 if not.
    Note: callers may want to check for identity of the types before
    calling this function -- identical types are considered to satisfy
-   the ancestor relationship even if they're identical */
+   the ancestor relationship even if they're identical.  */
 
 int
 is_ancestor (struct type *base, struct type *dclass)
@@ -1854,26 +1902,27 @@ has_vtable (struct type *dclass)
   if (TYPE_CODE (dclass) != TYPE_CODE_CLASS)
     return 0;
 
-  /* First check for the presence of virtual bases */
+  /* First check for the presence of virtual bases.  */
   if (TYPE_FIELD_VIRTUAL_BITS (dclass))
     for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
       if (B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass), i))
 	return 1;
 
-  /* Next check for virtual functions */
+  /* Next check for virtual functions.  */
   if (TYPE_FN_FIELDLISTS (dclass))
     for (i = 0; i < TYPE_NFN_FIELDS (dclass); i++)
       if (TYPE_FN_FIELD_VIRTUAL_P (TYPE_FN_FIELDLIST1 (dclass, i), 0))
 	return 1;
 
-  /* Recurse on non-virtual bases to see if any of them needs a vtable */
+  /* Recurse on non-virtual bases to see if any of them needs a
+     vtable.  */
   if (TYPE_FIELD_VIRTUAL_BITS (dclass))
     for (i = 0; i < TYPE_N_BASECLASSES (dclass); i++)
       if ((!B_TST (TYPE_FIELD_VIRTUAL_BITS (dclass), i)) &&
 	  (has_vtable (TYPE_FIELD_TYPE (dclass, i))))
 	return 1;
 
-  /* Well, maybe we don't need a virtual table */
+  /* Well, maybe we don't need a virtual table.  */
   return 0;
 }
 
@@ -1890,7 +1939,7 @@ primary_base_class (struct type *dclass)
 {
   /* In HP ANSI C++'s runtime model, a "primary base class" of a class
      is the first directly inherited, non-virtual base class that
-     requires a virtual table */
+     requires a virtual table.  */
 
   int i;
 
@@ -1905,17 +1954,17 @@ primary_base_class (struct type *dclass)
   return NULL;
 }
 
-/* Global manipulated by virtual_base_list[_aux]() */
+/* Global manipulated by virtual_base_list[_aux]().  */
 
 static struct vbase *current_vbase_list = NULL;
 
-/* Return a pointer to a null-terminated list of struct vbase
-   items. The vbasetype pointer of each item in the list points to the
-   type information for a virtual base of the argument DCLASS.
+/* Return a pointer to a null-terminated list of struct vbase items.
+   The vbasetype pointer of each item in the list points to the type
+   information for a virtual base of the argument DCLASS.
 
    Helper function for virtual_base_list(). 
-   Note: the list goes backward, right-to-left. virtual_base_list()
-   copies the items out in reverse order.  */
+   Note: the list goes backward, right-to-left.  
+   virtual_base_list() copies the items out in reverse order.  */
 
 static void
 virtual_base_list_aux (struct type *dclass)
@@ -1987,17 +2036,22 @@ virtual_base_list (struct type *dclass)
   current_vbase_list = NULL;
   virtual_base_list_aux (dclass);
 
-  for (i = 0, tmp_vbase = current_vbase_list; tmp_vbase != NULL; i++, tmp_vbase = tmp_vbase->next)
+  for (i = 0, tmp_vbase = current_vbase_list; 
+       tmp_vbase != NULL; 
+       i++, tmp_vbase = tmp_vbase->next)
     /* no body */ ;
 
   count = i;
 
-  vbase_array = (struct type **) xmalloc ((count + 1) * sizeof (struct type *));
+  vbase_array = (struct type **) 
+    xmalloc ((count + 1) * sizeof (struct type *));
 
-  for (i = count - 1, tmp_vbase = current_vbase_list; i >= 0; i--, tmp_vbase = tmp_vbase->next)
+  for (i = count - 1, tmp_vbase = current_vbase_list; 
+       i >= 0; i--, 
+	 tmp_vbase = tmp_vbase->next)
     vbase_array[i] = tmp_vbase->vbasetype;
 
-  /* Get rid of constructed chain */
+  /* Get rid of constructed chain.  */
   tmp_vbase_2 = tmp_vbase = current_vbase_list;
   while (tmp_vbase)
     {
@@ -2021,7 +2075,9 @@ virtual_base_list_length (struct type *dclass)
   current_vbase_list = NULL;
   virtual_base_list_aux (dclass);
 
-  for (i = 0, tmp_vbase = current_vbase_list; tmp_vbase != NULL; i++, tmp_vbase = tmp_vbase->next)
+  for (i = 0, tmp_vbase = current_vbase_list; 
+       tmp_vbase != NULL; 
+       i++, tmp_vbase = tmp_vbase->next)
     /* no body */ ;
   return i;
 }
@@ -2045,7 +2101,9 @@ virtual_base_list_length_skip_primaries (struct type *dclass)
   current_vbase_list = NULL;
   virtual_base_list_aux (dclass);
 
-  for (i = 0, tmp_vbase = current_vbase_list; tmp_vbase != NULL; tmp_vbase = tmp_vbase->next)
+  for (i = 0, tmp_vbase = current_vbase_list; 
+       tmp_vbase != NULL; 
+       tmp_vbase = tmp_vbase->next)
     {
       if (virtual_base_index (tmp_vbase->vbasetype, primary) >= 0)
 	continue;
@@ -2084,13 +2142,14 @@ virtual_base_index (struct type *base, struct type *dclass)
 
 
 /* Return the index (position) of type BASE, which is a virtual base
-   class of DCLASS, in the latter's virtual base list. Skip over all
+   class of DCLASS, in the latter's virtual base list.  Skip over all
    bases that may appear in the virtual base list of the primary base
    class of DCLASS (recursively).  A return of -1 indicates "not
    found" or a problem.  */
 
 int
-virtual_base_index_skip_primaries (struct type *base, struct type *dclass)
+virtual_base_index_skip_primaries (struct type *base, 
+				   struct type *dclass)
 {
   struct type *vbase;
   int i, j;
@@ -2107,7 +2166,8 @@ virtual_base_index_skip_primaries (struct type *base, struct type *dclass)
   vbase = virtual_base_list (dclass)[0];
   while (vbase)
     {
-      if (!primary || (virtual_base_index_skip_primaries (vbase, primary) < 0))
+      if (!primary 
+	  || (virtual_base_index_skip_primaries (vbase, primary) < 0))
 	j++;
       if (vbase == base)
 	break;
@@ -2117,9 +2177,9 @@ virtual_base_index_skip_primaries (struct type *base, struct type *dclass)
   return vbase ? j : -1;
 }
 
-/* Return position of a derived class DCLASS in the list of
- * primary bases starting with the remotest ancestor.
- * Position returned is 0-based. */
+/* Return position of a derived class DCLASS in the list of primary
+   bases starting with the remotest ancestor.  Position returned is
+   0-based.  */
 
 int
 class_index_in_primary_list (struct type *dclass)
@@ -2134,14 +2194,12 @@ class_index_in_primary_list (struct type *dclass)
     return 0;
 }
 
-/* Return a count of the number of virtual functions a type has.
- * This includes all the virtual functions it inherits from its
- * base classes too.
- */
+/* Return a count of the number of virtual functions a type has.  This
+   includes all the virtual functions it inherits from its base
+   classes too.  */
 
 /* pai: FIXME This doesn't do the right thing: count redefined virtual
- * functions only once (latest redefinition)
- */
+   functions only once (latest redefinition).  */
 
 int
 count_virtual_fns (struct type *dclass)
@@ -2169,10 +2227,10 @@ count_virtual_fns (struct type *dclass)
 /* Functions for overload resolution begin here */
 
 /* Compare two badness vectors A and B and return the result.
- * 0 => A and B are identical
- * 1 => A and B are incomparable
- * 2 => A is better than B
- * 3 => A is worse than B */
+   0 => A and B are identical
+   1 => A and B are incomparable
+   2 => A is better than B
+   3 => A is worse than B  */
 
 int
 compare_badness (struct badness_vector *a, struct badness_vector *b)
@@ -2213,12 +2271,14 @@ compare_badness (struct badness_vector *a, struct badness_vector *b)
     }
 }
 
-/* Rank a function by comparing its parameter types (PARMS, length NPARMS),
- * to the types of an argument list (ARGS, length NARGS).
- * Return a pointer to a badness vector. This has NARGS + 1 entries. */
+/* Rank a function by comparing its parameter types (PARMS, length
+   NPARMS), to the types of an argument list (ARGS, length NARGS).
+   Return a pointer to a badness vector.  This has NARGS + 1
+   entries.  */
 
 struct badness_vector *
-rank_function (struct type **parms, int nparms, struct type **args, int nargs)
+rank_function (struct type **parms, int nparms, 
+	       struct type **args, int nargs)
 {
   int i;
   struct badness_vector *bv;
@@ -2229,11 +2289,11 @@ rank_function (struct type **parms, int nparms, struct type **args, int nargs)
   bv->rank = xmalloc ((nargs + 1) * sizeof (int));
 
   /* First compare the lengths of the supplied lists.
-   * If there is a mismatch, set it to a high value. */
+     If there is a mismatch, set it to a high value.  */
 
   /* pai/1997-06-03 FIXME: when we have debug info about default
-   * arguments and ellipsis parameter lists, we should consider those
-   * and rank the length-match more finely. */
+     arguments and ellipsis parameter lists, we should consider those
+     and rank the length-match more finely.  */
 
   LENGTH_MATCH (bv) = (nargs != nparms) ? LENGTH_MISMATCH_BADNESS : 0;
 
@@ -2257,7 +2317,8 @@ integer_types_same_name_p (const char *first, const char *second)
 {
   int first_p, second_p;
 
-  /* If both are shorts, return 1; if neither is a short, keep checking.  */
+  /* If both are shorts, return 1; if neither is a short, keep
+     checking.  */
   first_p = (strstr (first, "short") != NULL);
   second_p = (strstr (second, "short") != NULL);
   if (first_p && second_p)
@@ -2292,16 +2353,16 @@ integer_types_same_name_p (const char *first, const char *second)
  *
  * Return 0 if they are identical types;
  * Otherwise, return an integer which corresponds to how compatible
- * PARM is to ARG. The higher the return value, the worse the match.
- * Generally the "bad" conversions are all uniformly assigned a 100 */
+ * PARM is to ARG.  The higher the return value, the worse the match.
+ * Generally the "bad" conversions are all uniformly assigned a 100.  */
 
 int
 rank_one_type (struct type *parm, struct type *arg)
 {
-  /* Identical type pointers */
+  /* Identical type pointers.  */
   /* However, this still doesn't catch all cases of same type for arg
-   * and param. The reason is that builtin types are different from
-   * the same ones constructed from the object. */
+     and param.  The reason is that builtin types are different from
+     the same ones constructed from the object.  */
   if (parm == arg)
     return 0;
 
@@ -2312,22 +2373,22 @@ rank_one_type (struct type *parm, struct type *arg)
     arg = check_typedef (arg);
 
   /*
-     Well, damnit, if the names are exactly the same,
-     i'll say they are exactly the same. This happens when we generate
-     method stubs. The types won't point to the same address, but they
+     Well, damnit, if the names are exactly the same, I'll say they
+     are exactly the same.  This happens when we generate method
+     stubs.  The types won't point to the same address, but they
      really are the same.
   */
 
   if (TYPE_NAME (parm) && TYPE_NAME (arg) &&
       !strcmp (TYPE_NAME (parm), TYPE_NAME (arg)))
-      return 0;
+    return 0;
 
-  /* Check if identical after resolving typedefs */
+  /* Check if identical after resolving typedefs.  */
   if (parm == arg)
     return 0;
 
   /* See through references, since we can almost make non-references
-     references. */
+     references.  */
   if (TYPE_CODE (arg) == TYPE_CODE_REF)
     return (rank_one_type (parm, TYPE_TARGET_TYPE (arg))
 	    + REFERENCE_CONVERSION_BADNESS);
@@ -2335,9 +2396,11 @@ rank_one_type (struct type *parm, struct type *arg)
     return (rank_one_type (TYPE_TARGET_TYPE (parm), arg)
 	    + REFERENCE_CONVERSION_BADNESS);
   if (overload_debug)
-  /* Debugging only. */
-    fprintf_filtered (gdb_stderr,"------ Arg is %s [%d], parm is %s [%d]\n",
-        TYPE_NAME (arg), TYPE_CODE (arg), TYPE_NAME (parm), TYPE_CODE (parm));
+  /* Debugging only.  */
+    fprintf_filtered (gdb_stderr, 
+		      "------ Arg is %s [%d], parm is %s [%d]\n",
+		      TYPE_NAME (arg), TYPE_CODE (arg), 
+		      TYPE_NAME (parm), TYPE_CODE (parm));
 
   /* x -> y means arg of type x being supplied for parameter of type y */
 
@@ -2350,9 +2413,11 @@ rank_one_type (struct type *parm, struct type *arg)
 	  if (TYPE_CODE (TYPE_TARGET_TYPE (parm)) == TYPE_CODE_VOID)
 	    return VOID_PTR_CONVERSION_BADNESS;
 	  else
-	    return rank_one_type (TYPE_TARGET_TYPE (parm), TYPE_TARGET_TYPE (arg));
+	    return rank_one_type (TYPE_TARGET_TYPE (parm), 
+				  TYPE_TARGET_TYPE (arg));
 	case TYPE_CODE_ARRAY:
-	  return rank_one_type (TYPE_TARGET_TYPE (parm), TYPE_TARGET_TYPE (arg));
+	  return rank_one_type (TYPE_TARGET_TYPE (parm), 
+				TYPE_TARGET_TYPE (arg));
 	case TYPE_CODE_FUNC:
 	  return rank_one_type (TYPE_TARGET_TYPE (parm), arg);
 	case TYPE_CODE_INT:
@@ -2370,7 +2435,8 @@ rank_one_type (struct type *parm, struct type *arg)
 	{
 	case TYPE_CODE_PTR:
 	case TYPE_CODE_ARRAY:
-	  return rank_one_type (TYPE_TARGET_TYPE (parm), TYPE_TARGET_TYPE (arg));
+	  return rank_one_type (TYPE_TARGET_TYPE (parm), 
+				TYPE_TARGET_TYPE (arg));
 	default:
 	  return INCOMPATIBLE_TYPE_BADNESS;
 	}
@@ -2389,32 +2455,38 @@ rank_one_type (struct type *parm, struct type *arg)
 	  if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
 	    {
 	      /* Deal with signed, unsigned, and plain chars and
-	         signed and unsigned ints */
+	         signed and unsigned ints.  */
 	      if (TYPE_NOSIGN (parm))
 		{
 		  /* This case only for character types */
-		  if (TYPE_NOSIGN (arg))	/* plain char -> plain char */
-		    return 0;
-		  else
-		    return INTEGER_CONVERSION_BADNESS;	/* signed/unsigned char -> plain char */
+		  if (TYPE_NOSIGN (arg))
+		    return 0;	/* plain char -> plain char */
+		  else		/* signed/unsigned char -> plain char */
+		    return INTEGER_CONVERSION_BADNESS;
 		}
 	      else if (TYPE_UNSIGNED (parm))
 		{
 		  if (TYPE_UNSIGNED (arg))
 		    {
-		      /* unsigned int -> unsigned int, or unsigned long -> unsigned long */
-		      if (integer_types_same_name_p (TYPE_NAME (parm), TYPE_NAME (arg)))
+		      /* unsigned int -> unsigned int, or 
+			 unsigned long -> unsigned long */
+		      if (integer_types_same_name_p (TYPE_NAME (parm), 
+						     TYPE_NAME (arg)))
 			return 0;
-		      else if (integer_types_same_name_p (TYPE_NAME (arg), "int")
-			       && integer_types_same_name_p (TYPE_NAME (parm), "long"))
+		      else if (integer_types_same_name_p (TYPE_NAME (arg), 
+							  "int")
+			       && integer_types_same_name_p (TYPE_NAME (parm),
+							     "long"))
 			return INTEGER_PROMOTION_BADNESS;	/* unsigned int -> unsigned long */
 		      else
 			return INTEGER_CONVERSION_BADNESS;	/* unsigned long -> unsigned int */
 		    }
 		  else
 		    {
-		      if (integer_types_same_name_p (TYPE_NAME (arg), "long")
-			  && integer_types_same_name_p (TYPE_NAME (parm), "int"))
+		      if (integer_types_same_name_p (TYPE_NAME (arg), 
+						     "long")
+			  && integer_types_same_name_p (TYPE_NAME (parm), 
+							"int"))
 			return INTEGER_CONVERSION_BADNESS;	/* signed long -> unsigned int */
 		      else
 			return INTEGER_CONVERSION_BADNESS;	/* signed int/long -> unsigned int/long */
@@ -2422,10 +2494,13 @@ rank_one_type (struct type *parm, struct type *arg)
 		}
 	      else if (!TYPE_NOSIGN (arg) && !TYPE_UNSIGNED (arg))
 		{
-		  if (integer_types_same_name_p (TYPE_NAME (parm), TYPE_NAME (arg)))
+		  if (integer_types_same_name_p (TYPE_NAME (parm), 
+						 TYPE_NAME (arg)))
 		    return 0;
-		  else if (integer_types_same_name_p (TYPE_NAME (arg), "int")
-			   && integer_types_same_name_p (TYPE_NAME (parm), "long"))
+		  else if (integer_types_same_name_p (TYPE_NAME (arg), 
+						      "int")
+			   && integer_types_same_name_p (TYPE_NAME (parm), 
+							 "long"))
 		    return INTEGER_PROMOTION_BADNESS;
 		  else
 		    return INTEGER_CONVERSION_BADNESS;
@@ -2482,8 +2557,8 @@ rank_one_type (struct type *parm, struct type *arg)
 	    return INTEGER_PROMOTION_BADNESS;
 	  /* >>> !! else fall through !! <<< */
 	case TYPE_CODE_CHAR:
-	  /* Deal with signed, unsigned, and plain chars for C++
-	     and with int cases falling through from previous case */
+	  /* Deal with signed, unsigned, and plain chars for C++ and
+	     with int cases falling through from previous case.  */
 	  if (TYPE_NOSIGN (parm))
 	    {
 	      if (TYPE_NOSIGN (arg))
@@ -2559,7 +2634,7 @@ rank_one_type (struct type *parm, struct type *arg)
       break;
     case TYPE_CODE_COMPLEX:
       switch (TYPE_CODE (arg))
-	{			/* Strictly not needed for C++, but... */
+	{		/* Strictly not needed for C++, but...  */
 	case TYPE_CODE_FLT:
 	  return FLOAT_PROMOTION_BADNESS;
 	case TYPE_CODE_COMPLEX:
@@ -2618,7 +2693,8 @@ rank_one_type (struct type *parm, struct type *arg)
 	{
 	  /* Not in C++ */
 	case TYPE_CODE_SET:
-	  return rank_one_type (TYPE_FIELD_TYPE (parm, 0), TYPE_FIELD_TYPE (arg, 0));
+	  return rank_one_type (TYPE_FIELD_TYPE (parm, 0), 
+				TYPE_FIELD_TYPE (arg, 0));
 	default:
 	  return INCOMPATIBLE_TYPE_BADNESS;
 	}
@@ -2651,7 +2727,8 @@ print_bit_vector (B_TYPE *bits, int nbits)
 }
 
 /* Note the first arg should be the "this" pointer, we may not want to
-   include it since we may get into a infinitely recursive situation.  */
+   include it since we may get into a infinitely recursive
+   situation.  */
 
 static void
 print_arg_types (struct field *args, int nargs, int spaces)
@@ -2696,18 +2773,21 @@ dump_fn_fieldlists (struct type *type, int spaces)
 				  gdb_stdout);
 	  printf_filtered (")\n");
 	  printfi_filtered (spaces + 8, "type ");
-	  gdb_print_host_address (TYPE_FN_FIELD_TYPE (f, overload_idx), gdb_stdout);
+	  gdb_print_host_address (TYPE_FN_FIELD_TYPE (f, overload_idx), 
+				  gdb_stdout);
 	  printf_filtered ("\n");
 
 	  recursive_dump_type (TYPE_FN_FIELD_TYPE (f, overload_idx),
 			       spaces + 8 + 2);
 
 	  printfi_filtered (spaces + 8, "args ");
-	  gdb_print_host_address (TYPE_FN_FIELD_ARGS (f, overload_idx), gdb_stdout);
+	  gdb_print_host_address (TYPE_FN_FIELD_ARGS (f, overload_idx), 
+				  gdb_stdout);
 	  printf_filtered ("\n");
 
 	  print_arg_types (TYPE_FN_FIELD_ARGS (f, overload_idx),
-			   TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f, overload_idx)),
+			   TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f, 
+							     overload_idx)),
 			   spaces);
 	  printfi_filtered (spaces + 8, "fcontext ");
 	  gdb_print_host_address (TYPE_FN_FIELD_FCONTEXT (f, overload_idx),
@@ -2743,7 +2823,8 @@ print_cplus_stuff (struct type *type, int spaces)
     {
       printfi_filtered (spaces, "virtual_field_bits (%d bits at *",
 			TYPE_N_BASECLASSES (type));
-      gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type), gdb_stdout);
+      gdb_print_host_address (TYPE_FIELD_VIRTUAL_BITS (type), 
+			      gdb_stdout);
       printf_filtered (")");
 
       print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type),
@@ -2754,9 +2835,11 @@ print_cplus_stuff (struct type *type, int spaces)
     {
       if (TYPE_FIELD_PRIVATE_BITS (type) != NULL)
 	{
-	  printfi_filtered (spaces, "private_field_bits (%d bits at *",
+	  printfi_filtered (spaces, 
+			    "private_field_bits (%d bits at *",
 			    TYPE_NFIELDS (type));
-	  gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type), gdb_stdout);
+	  gdb_print_host_address (TYPE_FIELD_PRIVATE_BITS (type), 
+				  gdb_stdout);
 	  printf_filtered (")");
 	  print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type),
 			    TYPE_NFIELDS (type));
@@ -2764,9 +2847,11 @@ print_cplus_stuff (struct type *type, int spaces)
 	}
       if (TYPE_FIELD_PROTECTED_BITS (type) != NULL)
 	{
-	  printfi_filtered (spaces, "protected_field_bits (%d bits at *",
+	  printfi_filtered (spaces, 
+			    "protected_field_bits (%d bits at *",
 			    TYPE_NFIELDS (type));
-	  gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type), gdb_stdout);
+	  gdb_print_host_address (TYPE_FIELD_PROTECTED_BITS (type), 
+				  gdb_stdout);
 	  printf_filtered (")");
 	  print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type),
 			    TYPE_NFIELDS (type));
@@ -2822,10 +2907,10 @@ recursive_dump_type (struct type *type, int spaces)
       || (TYPE_CPLUS_SPECIFIC (type) && TYPE_NFN_FIELDS (type) > 0))
     {
       struct type **first_dont_print
-      = (struct type **) obstack_base (&dont_print_type_obstack);
+	= (struct type **) obstack_base (&dont_print_type_obstack);
 
-      int i = (struct type **) obstack_next_free (&dont_print_type_obstack)
-      - first_dont_print;
+      int i = (struct type **) 
+	obstack_next_free (&dont_print_type_obstack) - first_dont_print;
 
       while (--i >= 0)
 	{
@@ -2969,7 +3054,8 @@ recursive_dump_type (struct type *type, int spaces)
   printfi_filtered (spaces, "type_chain ");
   gdb_print_host_address (TYPE_CHAIN (type), gdb_stdout);
   printf_filtered ("\n");
-  printfi_filtered (spaces, "instance_flags 0x%x", TYPE_INSTANCE_FLAGS (type));
+  printfi_filtered (spaces, "instance_flags 0x%x", 
+		    TYPE_INSTANCE_FLAGS (type));
   if (TYPE_CONST (type))
     {
       puts_filtered (" TYPE_FLAG_CONST");
@@ -3064,12 +3150,14 @@ recursive_dump_type (struct type *type, int spaces)
     {
       recursive_dump_type (TYPE_VPTR_BASETYPE (type), spaces + 2);
     }
-  printfi_filtered (spaces, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type));
+  printfi_filtered (spaces, "vptr_fieldno %d\n", 
+		    TYPE_VPTR_FIELDNO (type));
   switch (TYPE_CODE (type))
     {
     case TYPE_CODE_STRUCT:
       printfi_filtered (spaces, "cplus_stuff ");
-      gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type), gdb_stdout);
+      gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type), 
+			      gdb_stdout);
       puts_filtered ("\n");
       print_cplus_stuff (type, spaces);
       break;
@@ -3100,9 +3188,9 @@ recursive_dump_type (struct type *type, int spaces)
       break;
 
     default:
-      /* We have to pick one of the union types to be able print and test
-         the value.  Pick cplus_struct_type, even though we know it isn't
-         any particular one. */
+      /* We have to pick one of the union types to be able print and
+         test the value.  Pick cplus_struct_type, even though we know
+         it isn't any particular one.  */
       printfi_filtered (spaces, "type_specific ");
       gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type), gdb_stdout);
       if (TYPE_CPLUS_SPECIFIC (type) != NULL)
@@ -3152,13 +3240,14 @@ create_copied_types_hash (struct objfile *objfile)
 			       dummy_obstack_deallocate);
 }
 
-/* Recursively copy (deep copy) TYPE, if it is associated with OBJFILE.
-   Return a new type allocated using malloc, a saved type if we have already
-   visited TYPE (using COPIED_TYPES), or TYPE if it is not associated with
-   OBJFILE.  */
+/* Recursively copy (deep copy) TYPE, if it is associated with
+   OBJFILE.  Return a new type allocated using malloc, a saved type if
+   we have already visited TYPE (using COPIED_TYPES), or TYPE if it is
+   not associated with OBJFILE.  */
 
 struct type *
-copy_type_recursive (struct objfile *objfile, struct type *type,
+copy_type_recursive (struct objfile *objfile, 
+		     struct type *type,
 		     htab_t copied_types)
 {
   struct type_pair *stored, pair;
@@ -3168,8 +3257,8 @@ copy_type_recursive (struct objfile *objfile, struct type *type,
   if (TYPE_OBJFILE (type) == NULL)
     return type;
 
-  /* This type shouldn't be pointing to any types in other objfiles; if
-     it did, the type might disappear unexpectedly.  */
+  /* This type shouldn't be pointing to any types in other objfiles;
+     if it did, the type might disappear unexpectedly.  */
   gdb_assert (TYPE_OBJFILE (type) == objfile);
 
   pair.old = type;
@@ -3188,8 +3277,10 @@ copy_type_recursive (struct objfile *objfile, struct type *type,
 
   /* Copy the common fields of types.  */
   TYPE_CODE (new_type) = TYPE_CODE (type);
-  TYPE_ARRAY_UPPER_BOUND_TYPE (new_type) = TYPE_ARRAY_UPPER_BOUND_TYPE (type);
-  TYPE_ARRAY_LOWER_BOUND_TYPE (new_type) = TYPE_ARRAY_LOWER_BOUND_TYPE (type);
+  TYPE_ARRAY_UPPER_BOUND_TYPE (new_type) = 
+    TYPE_ARRAY_UPPER_BOUND_TYPE (type);
+  TYPE_ARRAY_LOWER_BOUND_TYPE (new_type) = 
+    TYPE_ARRAY_LOWER_BOUND_TYPE (type);
   if (TYPE_NAME (type))
     TYPE_NAME (new_type) = xstrdup (TYPE_NAME (type));
   if (TYPE_TAG_NAME (type))
@@ -3210,23 +3301,27 @@ copy_type_recursive (struct objfile *objfile, struct type *type,
       TYPE_FIELDS (new_type) = xmalloc (sizeof (struct field) * nfields);
       for (i = 0; i < nfields; i++)
 	{
-	  TYPE_FIELD_ARTIFICIAL (new_type, i) = TYPE_FIELD_ARTIFICIAL (type, i);
+	  TYPE_FIELD_ARTIFICIAL (new_type, i) = 
+	    TYPE_FIELD_ARTIFICIAL (type, i);
 	  TYPE_FIELD_BITSIZE (new_type, i) = TYPE_FIELD_BITSIZE (type, i);
 	  if (TYPE_FIELD_TYPE (type, i))
 	    TYPE_FIELD_TYPE (new_type, i)
 	      = copy_type_recursive (objfile, TYPE_FIELD_TYPE (type, i),
 				     copied_types);
 	  if (TYPE_FIELD_NAME (type, i))
-	    TYPE_FIELD_NAME (new_type, i) = xstrdup (TYPE_FIELD_NAME (type, i));
+	    TYPE_FIELD_NAME (new_type, i) = 
+	      xstrdup (TYPE_FIELD_NAME (type, i));
 	  if (TYPE_FIELD_STATIC_HAS_ADDR (type, i))
 	    SET_FIELD_PHYSADDR (TYPE_FIELD (new_type, i),
 				TYPE_FIELD_STATIC_PHYSADDR (type, i));
 	  else if (TYPE_FIELD_STATIC (type, i))
 	    SET_FIELD_PHYSNAME (TYPE_FIELD (new_type, i),
-				xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type, i)));
+				xstrdup (TYPE_FIELD_STATIC_PHYSNAME (type, 
+								     i)));
 	  else
 	    {
-	      TYPE_FIELD_BITPOS (new_type, i) = TYPE_FIELD_BITPOS (type, i);
+	      TYPE_FIELD_BITPOS (new_type, i) = 
+		TYPE_FIELD_BITPOS (type, i);
 	      TYPE_FIELD_STATIC_KIND (new_type, i) = 0;
 	    }
 	}
@@ -3234,13 +3329,15 @@ copy_type_recursive (struct objfile *objfile, struct type *type,
 
   /* Copy pointers to other types.  */
   if (TYPE_TARGET_TYPE (type))
-    TYPE_TARGET_TYPE (new_type) = copy_type_recursive (objfile,
-						       TYPE_TARGET_TYPE (type),
-						       copied_types);
+    TYPE_TARGET_TYPE (new_type) = 
+      copy_type_recursive (objfile, 
+			   TYPE_TARGET_TYPE (type),
+			   copied_types);
   if (TYPE_VPTR_BASETYPE (type))
-    TYPE_VPTR_BASETYPE (new_type) = copy_type_recursive (objfile,
-							 TYPE_VPTR_BASETYPE (type),
-							 copied_types);
+    TYPE_VPTR_BASETYPE (new_type) = 
+      copy_type_recursive (objfile,
+			   TYPE_VPTR_BASETYPE (type),
+			   copied_types);
   /* Maybe copy the type_specific bits.
 
      NOTE drow/2005-12-09: We do not copy the C++-specific bits like
@@ -3329,29 +3426,32 @@ gdbtypes_post_init (struct gdbarch *gdbarch)
 	       TYPE_FLAG_UNSIGNED,
 	       "unsigned char", (struct objfile *) NULL);
   builtin_type->builtin_short =
-    init_type
-	(TYPE_CODE_INT, gdbarch_short_bit (current_gdbarch) / TARGET_CHAR_BIT,
-	 0, "short", (struct objfile *) NULL);
+    init_type (TYPE_CODE_INT, 
+	       gdbarch_short_bit (current_gdbarch) / TARGET_CHAR_BIT,
+	       0, "short", (struct objfile *) NULL);
   builtin_type->builtin_unsigned_short =
-    init_type
-	(TYPE_CODE_INT, gdbarch_short_bit (current_gdbarch) / TARGET_CHAR_BIT,
-	 TYPE_FLAG_UNSIGNED, "unsigned short", (struct objfile *) NULL);
+    init_type (TYPE_CODE_INT, 
+	       gdbarch_short_bit (current_gdbarch) / TARGET_CHAR_BIT,
+	       TYPE_FLAG_UNSIGNED, "unsigned short", 
+	       (struct objfile *) NULL);
   builtin_type->builtin_int =
-    init_type
-	(TYPE_CODE_INT, gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT,
-	 0, "int", (struct objfile *) NULL);
+    init_type (TYPE_CODE_INT, 
+	       gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT,
+	       0, "int", (struct objfile *) NULL);
   builtin_type->builtin_unsigned_int =
-    init_type
-	(TYPE_CODE_INT, gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT,
-	 TYPE_FLAG_UNSIGNED, "unsigned int", (struct objfile *) NULL);
+    init_type (TYPE_CODE_INT, 
+	       gdbarch_int_bit (current_gdbarch) / TARGET_CHAR_BIT,
+	       TYPE_FLAG_UNSIGNED, "unsigned int", 
+	       (struct objfile *) NULL);
   builtin_type->builtin_long =
-    init_type
-	(TYPE_CODE_INT, gdbarch_long_bit (current_gdbarch) / TARGET_CHAR_BIT,
-	 0, "long", (struct objfile *) NULL);
+    init_type (TYPE_CODE_INT, 
+	       gdbarch_long_bit (current_gdbarch) / TARGET_CHAR_BIT,
+	       0, "long", (struct objfile *) NULL);
   builtin_type->builtin_unsigned_long =
-    init_type
-	(TYPE_CODE_INT, gdbarch_long_bit (current_gdbarch) / TARGET_CHAR_BIT,
-	 TYPE_FLAG_UNSIGNED, "unsigned long", (struct objfile *) NULL);
+    init_type (TYPE_CODE_INT, 
+	       gdbarch_long_bit (current_gdbarch) / TARGET_CHAR_BIT,
+	       TYPE_FLAG_UNSIGNED, "unsigned long", 
+	       (struct objfile *) NULL);
   builtin_type->builtin_long_long =
     init_type (TYPE_CODE_INT,
 	       gdbarch_long_long_bit (current_gdbarch) / TARGET_CHAR_BIT,
@@ -3385,7 +3485,7 @@ gdbtypes_post_init (struct gdbarch *gdbarch)
 	       0,
 	       "bool", (struct objfile *) NULL);
 
-  /* Pointer/Address types. */
+  /* Pointer/Address types.  */
 
   /* NOTE: on some targets, addresses and pointers are not necessarily
      the same --- for example, on the D10V, pointers are 16 bits long,
@@ -3413,31 +3513,36 @@ gdbtypes_post_init (struct gdbarch *gdbarch)
      target type for a value the target will never see.  It's only
      used to hold the values of (typeless) linker symbols, which are
      indeed in the unified virtual address space.  */
-  builtin_type->builtin_data_ptr
-    = make_pointer_type (builtin_type->builtin_void, NULL);
-  builtin_type->builtin_func_ptr
-    = lookup_pointer_type (lookup_function_type (builtin_type->builtin_void));
+
+  builtin_type->builtin_data_ptr =
+    make_pointer_type (builtin_type->builtin_void, NULL);
+  builtin_type->builtin_func_ptr =
+    lookup_pointer_type (lookup_function_type (builtin_type->builtin_void));
   builtin_type->builtin_core_addr =
-    init_type (TYPE_CODE_INT, gdbarch_addr_bit (current_gdbarch) / 8,
+    init_type (TYPE_CODE_INT, 
+	       gdbarch_addr_bit (current_gdbarch) / 8,
 	       TYPE_FLAG_UNSIGNED,
 	       "__CORE_ADDR", (struct objfile *) NULL);
 
 
   /* The following set of types is used for symbols with no
      debug information.  */
-  builtin_type->nodebug_text_symbol
-    = init_type (TYPE_CODE_FUNC, 1, 0, "<text variable, no debug info>", NULL);
-  TYPE_TARGET_TYPE (builtin_type->nodebug_text_symbol)
-    = builtin_type->builtin_int;
-  builtin_type->nodebug_data_symbol
-    = init_type (TYPE_CODE_INT, gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
-		 "<data variable, no debug info>", NULL);
-  builtin_type->nodebug_unknown_symbol
-    = init_type (TYPE_CODE_INT, 1, 0,
-		 "<variable (not text or data), no debug info>", NULL);
-  builtin_type->nodebug_tls_symbol
-    = init_type (TYPE_CODE_INT, gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
-		 "<thread local variable, no debug info>", NULL);
+  builtin_type->nodebug_text_symbol =
+    init_type (TYPE_CODE_FUNC, 1, 0, 
+	       "<text variable, no debug info>", NULL);
+  TYPE_TARGET_TYPE (builtin_type->nodebug_text_symbol) =
+    builtin_type->builtin_int;
+  builtin_type->nodebug_data_symbol =
+    init_type (TYPE_CODE_INT, 
+	       gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
+	       "<data variable, no debug info>", NULL);
+  builtin_type->nodebug_unknown_symbol =
+    init_type (TYPE_CODE_INT, 1, 0,
+	       "<variable (not text or data), no debug info>", NULL);
+  builtin_type->nodebug_tls_symbol =
+    init_type (TYPE_CODE_INT, 
+	       gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT, 0,
+	       "<thread local variable, no debug info>", NULL);
 
   return builtin_type;
 }
@@ -3448,9 +3553,10 @@ _initialize_gdbtypes (void)
 {
   gdbtypes_data = gdbarch_data_register_post_init (gdbtypes_post_init);
 
-  /* FIXME: The following types are architecture-neutral.  However, they
-     contain pointer_type and reference_type fields potentially caching
-     pointer or reference types that *are* architecture dependent.  */
+  /* FIXME: The following types are architecture-neutral.  However,
+     they contain pointer_type and reference_type fields potentially
+     caching pointer or reference types that *are* architecture
+     dependent.  */
 
   builtin_type_int0 =
     init_type (TYPE_CODE_INT, 0 / 8,
@@ -3497,20 +3603,20 @@ _initialize_gdbtypes (void)
 	       TYPE_FLAG_UNSIGNED,
 	       "uint128_t", (struct objfile *) NULL);
 
-  builtin_type_ieee_single
-    = build_flt (-1, "builtin_type_ieee_single", floatformats_ieee_single);
-  builtin_type_ieee_double
-    = build_flt (-1, "builtin_type_ieee_double", floatformats_ieee_double);
-  builtin_type_i387_ext
-    = build_flt (-1, "builtin_type_i387_ext", floatformats_i387_ext);
-  builtin_type_m68881_ext
-    = build_flt (-1, "builtin_type_m68881_ext", floatformats_m68881_ext);
-  builtin_type_arm_ext
-    = build_flt (-1, "builtin_type_arm_ext", floatformats_arm_ext);
-  builtin_type_ia64_spill
-    = build_flt (-1, "builtin_type_ia64_spill", floatformats_ia64_spill);
-  builtin_type_ia64_quad
-    = build_flt (-1, "builtin_type_ia64_quad", floatformats_ia64_quad);
+  builtin_type_ieee_single =
+    build_flt (-1, "builtin_type_ieee_single", floatformats_ieee_single);
+  builtin_type_ieee_double =
+    build_flt (-1, "builtin_type_ieee_double", floatformats_ieee_double);
+  builtin_type_i387_ext =
+    build_flt (-1, "builtin_type_i387_ext", floatformats_i387_ext);
+  builtin_type_m68881_ext =
+    build_flt (-1, "builtin_type_m68881_ext", floatformats_m68881_ext);
+  builtin_type_arm_ext =
+    build_flt (-1, "builtin_type_arm_ext", floatformats_arm_ext);
+  builtin_type_ia64_spill =
+    build_flt (-1, "builtin_type_ia64_spill", floatformats_ia64_spill);
+  builtin_type_ia64_quad =
+    build_flt (-1, "builtin_type_ia64_quad", floatformats_ia64_quad);
 
   add_setshow_zinteger_cmd ("overload", no_class, &overload_debug, _("\
 Set debugging of C++ overloading."), _("\
@@ -3520,7 +3626,7 @@ When enabled, ranking of the functions is displayed."),
 			    show_overload_debug,
 			    &setdebuglist, &showdebuglist);
 
-  /* Add user knob for controlling resolution of opaque types */
+  /* Add user knob for controlling resolution of opaque types.  */
   add_setshow_boolean_cmd ("opaque-type-resolution", class_support,
 			   &opaque_type_resolution, _("\
 Set resolution of opaque struct/class/union types (if set before loading symbols)."), _("\