2002-07-02 Rodney Brown <rbrown64@csc.com.au>

	* objc/encoding.h: Fix formatting.
	* objc/hash.h: Likewise.
	* objc/objc-api.h: Likewise.
	* objc/runtime.h: Likewise.
	* objc/thr.h: Likewise.
	* archive.c: Likewise.
	* class.c: Likewise.
	* encoding.c: Likewise.
	* gc.c: Likewise.
	* hash.c: Likewise.
	* init.c: Likewise.
	* misc.c: Likewise.
	* nil_method.c: Likewise.
	* objects.c: Likewise.
	* sarray.c: Likewise.
	* selector.c: Likewise.
	* sendmsg.c: Likewise.
	* thr-mach.c: Likewise.
	* thr.c: Likewise.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@55190 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 118 insertions, 97 deletions

diff --git a/libobjc/encoding.c b/libobjc/encoding.c
index 8fd6e5b26c2..be4c08b423e 100644
--- a/libobjc/encoding.c
+++ b/libobjc/encoding.c
@@ -34,18 +34,18 @@ Boston, MA 02111-1307, USA.  */
 
 #undef  MAX
 #define MAX(X, Y)                    \
-  ({ typeof(X) __x = (X), __y = (Y); \
+  ({ typeof (X) __x = (X), __y = (Y); \
      (__x > __y ? __x : __y); })
 
 #undef  MIN
 #define MIN(X, Y)                    \
-  ({ typeof(X) __x = (X), __y = (Y); \
+  ({ typeof (X) __x = (X), __y = (Y); \
      (__x < __y ? __x : __y); })
 
 #undef  ROUND
 #define ROUND(V, A) \
-  ({ typeof(V) __v=(V); typeof(A) __a=(A); \
-     __a*((__v+__a-1)/__a); })
+  ({ typeof (V) __v = (V); typeof (A) __a = (A); \
+     __a * ((__v+__a - 1)/__a); })
 
 
 /* Various hacks for objc_layout_record. These are used by the target
@@ -89,7 +89,7 @@ static int __attribute__ ((__unused__)) target_flags = 0;
 */
 
 int
-objc_sizeof_type (const char* type)
+objc_sizeof_type (const char *type)
 {
   /* Skip the variable name if any */
   if (*type == '"')
@@ -98,81 +98,83 @@ objc_sizeof_type (const char* type)
 	/* do nothing */;
     }
 
-  switch(*type) {
+  switch (*type) {
   case _C_ID:
-    return sizeof(id);
+    return sizeof (id);
     break;
 
   case _C_CLASS:
-    return sizeof(Class);
+    return sizeof (Class);
     break;
 
   case _C_SEL:
-    return sizeof(SEL);
+    return sizeof (SEL);
     break;
 
   case _C_CHR:
-    return sizeof(char);
+    return sizeof (char);
     break;
 
   case _C_UCHR:
-    return sizeof(unsigned char);
+    return sizeof (unsigned char);
     break;
 
   case _C_SHT:
-    return sizeof(short);
+    return sizeof (short);
     break;
 
   case _C_USHT:
-    return sizeof(unsigned short);
+    return sizeof (unsigned short);
     break;
 
   case _C_INT:
-    return sizeof(int);
+    return sizeof (int);
     break;
 
   case _C_UINT:
-    return sizeof(unsigned int);
+    return sizeof (unsigned int);
     break;
 
   case _C_LNG:
-    return sizeof(long);
+    return sizeof (long);
     break;
 
   case _C_ULNG:
-    return sizeof(unsigned long);
+    return sizeof (unsigned long);
     break;
 
   case _C_LNG_LNG:
-    return sizeof(long long);
+    return sizeof (long long);
     break;
 
   case _C_ULNG_LNG:
-    return sizeof(unsigned long long);
+    return sizeof (unsigned long long);
     break;
 
   case _C_FLT:
-    return sizeof(float);
+    return sizeof (float);
     break;
 
   case _C_DBL:
-    return sizeof(double);
+    return sizeof (double);
     break;
 
   case _C_VOID:
-    return sizeof(void);
+    return sizeof (void);
     break;
+
   case _C_PTR:
   case _C_ATOM:
   case _C_CHARPTR:
-    return sizeof(char*);
+    return sizeof (char *);
     break;
 
   case _C_ARY_B:
     {
-      int len = atoi(type+1);
-      while (isdigit((unsigned char)*++type));
-      return len*objc_aligned_size (type);
+      int len = atoi (type + 1);
+      while (isdigit ((unsigned char)*++type))
+	;
+      return len * objc_aligned_size (type);
     }
     break;
 
@@ -183,7 +185,8 @@ objc_sizeof_type (const char* type)
       int startByte, endByte;
 
       position = atoi (type + 1);
-      while (isdigit ((unsigned char)*++type));
+      while (isdigit ((unsigned char)*++type))
+	;
       size = atoi (type + 1);
 
       startByte = position / BITS_PER_UNIT;
@@ -207,7 +210,8 @@ objc_sizeof_type (const char* type)
   case _C_UNION_B:
     {
       int max_size = 0;
-      while (*type != _C_UNION_E && *type++ != '=') /* do nothing */;
+      while (*type != _C_UNION_E && *type++ != '=')
+	/* do nothing */;
       while (*type != _C_UNION_E)
 	{
 	  /* Skip the variable name if any */
@@ -224,7 +228,7 @@ objc_sizeof_type (const char* type)
 
   default:
     {
-      objc_error(nil, OBJC_ERR_BAD_TYPE, "unknown type %s\n", type);
+      objc_error (nil, OBJC_ERR_BAD_TYPE, "unknown type %s\n", type);
       return 0;
     }
   }
@@ -236,7 +240,7 @@ objc_sizeof_type (const char* type)
 */
 
 int
-objc_alignof_type(const char* type)
+objc_alignof_type (const char *type)
 {
   /* Skip the variable name if any */
   if (*type == '"')
@@ -244,75 +248,76 @@ objc_alignof_type(const char* type)
       for (type++; *type++ != '"';)
 	/* do nothing */;
     }
-  switch(*type) {
+  switch (*type) {
   case _C_ID:
-    return __alignof__(id);
+    return __alignof__ (id);
     break;
 
   case _C_CLASS:
-    return __alignof__(Class);
+    return __alignof__ (Class);
     break;
 
   case _C_SEL:
-    return __alignof__(SEL);
+    return __alignof__ (SEL);
     break;
 
   case _C_CHR:
-    return __alignof__(char);
+    return __alignof__ (char);
     break;
 
   case _C_UCHR:
-    return __alignof__(unsigned char);
+    return __alignof__ (unsigned char);
     break;
 
   case _C_SHT:
-    return __alignof__(short);
+    return __alignof__ (short);
     break;
 
   case _C_USHT:
-    return __alignof__(unsigned short);
+    return __alignof__ (unsigned short);
     break;
 
   case _C_INT:
-    return __alignof__(int);
+    return __alignof__ (int);
     break;
 
   case _C_UINT:
-    return __alignof__(unsigned int);
+    return __alignof__ (unsigned int);
     break;
 
   case _C_LNG:
-    return __alignof__(long);
+    return __alignof__ (long);
     break;
 
   case _C_ULNG:
-    return __alignof__(unsigned long);
+    return __alignof__ (unsigned long);
     break;
 
   case _C_LNG_LNG:
-    return __alignof__(long long);
+    return __alignof__ (long long);
     break;
 
   case _C_ULNG_LNG:
-    return __alignof__(unsigned long long);
+    return __alignof__ (unsigned long long);
     break;
 
   case _C_FLT:
-    return __alignof__(float);
+    return __alignof__ (float);
     break;
 
   case _C_DBL:
-    return __alignof__(double);
+    return __alignof__ (double);
     break;
 
   case _C_PTR:
   case _C_ATOM:
   case _C_CHARPTR:
-    return __alignof__(char*);
+    return __alignof__ (char *);
     break;
 
   case _C_ARY_B:
-    while (isdigit((unsigned char)*++type)) /* do nothing */;
+    while (isdigit ((unsigned char)*++type))
+      /* do nothing */;
     return objc_alignof_type (type);
 
   case _C_STRUCT_B:
@@ -331,7 +336,8 @@ objc_alignof_type(const char* type)
   case _C_UNION_B:
     {
       int maxalign = 0;
-      while (*type != _C_UNION_E && *type++ != '=') /* do nothing */;
+      while (*type != _C_UNION_E && *type++ != '=')
+	/* do nothing */;
       while (*type != _C_UNION_E)
 	{
 	  /* Skip the variable name if any */
@@ -348,7 +354,7 @@ objc_alignof_type(const char* type)
 
   default:
     {
-      objc_error(nil, OBJC_ERR_BAD_TYPE, "unknown type %s\n", type);
+      objc_error (nil, OBJC_ERR_BAD_TYPE, "unknown type %s\n", type);
       return 0;
     }
   }
@@ -359,7 +365,7 @@ objc_alignof_type(const char* type)
 */
 
 int
-objc_aligned_size (const char* type)
+objc_aligned_size (const char *type)
 {
   int size, align;
 
@@ -378,11 +384,11 @@ objc_aligned_size (const char* type)
 
 /*
   The size rounded up to the nearest integral of the wordsize, taken
-  to be the size of a void*.
+  to be the size of a void *.
 */
 
 int
-objc_promoted_size (const char* type)
+objc_promoted_size (const char *type)
 {
   int size, wordsize;
 
@@ -394,7 +400,7 @@ objc_promoted_size (const char* type)
     }
 
   size = objc_sizeof_type (type);
-  wordsize = sizeof (void*);
+  wordsize = sizeof (void *);
 
   return ROUND (size, wordsize);
 }
@@ -404,8 +410,8 @@ objc_promoted_size (const char* type)
   occurring in method prototype encodings.
 */
 
-inline const char*
-objc_skip_type_qualifiers (const char* type)
+inline const char *
+objc_skip_type_qualifiers (const char *type)
 {
   while (*type == _C_CONST
 	 || *type == _C_IN
@@ -427,8 +433,8 @@ objc_skip_type_qualifiers (const char* type)
   qualifiers, these are skipped as well.
 */
 
-const char*
-objc_skip_typespec (const char* type)
+const char *
+objc_skip_typespec (const char *type)
 {
   /* Skip the variable name if any */
   if (*type == '"')
@@ -449,7 +455,8 @@ objc_skip_typespec (const char* type)
       return type;
     else
       {
-	while (*++type != '"') /* do nothing */;
+	while (*++type != '"')
+	  /* do nothing */;
 	return type + 1;
       }
 
@@ -478,34 +485,45 @@ objc_skip_typespec (const char* type)
   case _C_ARY_B:
     /* skip digits, typespec and closing ']' */
 
-    while(isdigit((unsigned char)*++type));
-    type = objc_skip_typespec(type);
+    while (isdigit ((unsigned char)*++type))
+      ;
+    type = objc_skip_typespec (type);
     if (*type == _C_ARY_E)
       return ++type;
     else
       {
-	objc_error(nil, OBJC_ERR_BAD_TYPE, "bad array type %s\n", type);
+	objc_error (nil, OBJC_ERR_BAD_TYPE, "bad array type %s\n", type);
 	return 0;
       }
 
   case _C_BFLD:
     /* The new encoding of bitfields is: b 'position' 'type' 'size' */
-    while (isdigit ((unsigned char)*++type));	/* skip position */
-    while (isdigit ((unsigned char)*++type));	/* skip type and size */
+    while (isdigit ((unsigned char)*++type))
+      ;	/* skip position */
+    while (isdigit ((unsigned char)*++type))
+      ;	/* skip type and size */
     return type;
 
   case _C_STRUCT_B:
     /* skip name, and elements until closing '}'  */
 
-    while (*type != _C_STRUCT_E && *type++ != '=');
-    while (*type != _C_STRUCT_E) { type = objc_skip_typespec (type); }
+    while (*type != _C_STRUCT_E && *type++ != '=')
+      ;
+    while (*type != _C_STRUCT_E)
+      {
+	type = objc_skip_typespec (type);
+      }
     return ++type;
 
   case _C_UNION_B:
     /* skip name, and elements until closing ')'  */
 
-    while (*type != _C_UNION_E && *type++ != '=');
-    while (*type != _C_UNION_E) { type = objc_skip_typespec (type); }
+    while (*type != _C_UNION_E && *type++ != '=')
+      ;
+    while (*type != _C_UNION_E)
+      {
+	type = objc_skip_typespec (type);
+      }
     return ++type;
 
   case _C_PTR:
@@ -515,7 +533,7 @@ objc_skip_typespec (const char* type)
 
   default:
     {
-      objc_error(nil, OBJC_ERR_BAD_TYPE, "unknown type %s\n", type);
+      objc_error (nil, OBJC_ERR_BAD_TYPE, "unknown type %s\n", type);
       return 0;
     }
   }
@@ -525,19 +543,21 @@ objc_skip_typespec (const char* type)
   Skip an offset as part of a method encoding.  This is prepended by a
   '+' if the argument is passed in registers.
 */
-inline const char*
-objc_skip_offset (const char* type)
+inline const char *
+objc_skip_offset (const char *type)
 {
-  if (*type == '+') type++;
-  while(isdigit((unsigned char)*++type));
+  if (*type == '+')
+    type++;
+  while (isdigit ((unsigned char) *++type))
+    ;
   return type;
 }
 
 /*
   Skip an argument specification of a method encoding.
 */
-const char*
-objc_skip_argspec (const char* type)
+const char *
+objc_skip_argspec (const char *type)
 {
   type = objc_skip_typespec (type);
   type = objc_skip_offset (type);
@@ -550,10 +570,10 @@ objc_skip_argspec (const char* type)
   `_cmd'.
 */
 int
-method_get_number_of_arguments (struct objc_method* mth)
+method_get_number_of_arguments (struct objc_method *mth)
 {
   int i = 0;
-  const char* type = mth->method_types;
+  const char *type = mth->method_types;
   while (*type)
     {
       type = objc_skip_argspec (type);
@@ -569,9 +589,9 @@ method_get_number_of_arguments (struct objc_method* mth)
 */
 
 int
-method_get_sizeof_arguments (struct objc_method* mth)
+method_get_sizeof_arguments (struct objc_method *mth)
 {
-  const char* type = objc_skip_typespec (mth->method_types);
+  const char *type = objc_skip_typespec (mth->method_types);
   return atoi (type);
 }
 
@@ -591,15 +611,14 @@ method_get_sizeof_arguments (struct objc_method* mth)
 	else
 	  {
 	    if ((flags & _F_IN) == _F_IN)
-              [portal encodeData: *(char**)datum ofType: ++type];
+              [portal encodeData: *(char **) datum ofType: ++type];
 	  }
       }
   }
 */
 
-char*
-method_get_next_argument (arglist_t argframe,
-			  const char **type)
+char *
+method_get_next_argument (arglist_t argframe, const char **type)
 {
   const char *t = objc_skip_argspec (*type);
 
@@ -621,10 +640,10 @@ method_get_next_argument (arglist_t argframe,
   is returned in TYPE.  type must be passed to successive calls of
   method_get_next_argument.
 */
-char*
-method_get_first_argument (struct objc_method* m,
+char *
+method_get_first_argument (struct objc_method *m,
 			   arglist_t argframe,
-			   const char** type)
+			   const char **type)
 {
   *type = m->method_types;
   return method_get_next_argument (argframe, type);
@@ -636,12 +655,12 @@ method_get_first_argument (struct objc_method* m,
    is returned in the value-result argument TYPE
 */
 
-char*
-method_get_nth_argument (struct objc_method* m,
+char *
+method_get_nth_argument (struct objc_method *m,
 			 arglist_t argframe, int arg,
 			 const char **type)
 {
-  const char* t = objc_skip_argspec (m->method_types);
+  const char *t = objc_skip_argspec (m->method_types);
 
   if (arg > method_get_number_of_arguments (m))
     return 0;
@@ -659,7 +678,7 @@ method_get_nth_argument (struct objc_method* m,
 }
 
 unsigned
-objc_get_type_qualifiers (const char* type)
+objc_get_type_qualifiers (const char *type)
 {
   unsigned res = 0;
   BOOL flag = YES;
@@ -712,7 +731,7 @@ objc_layout_structure (const char *type,
 
   if (*type++ != _C_STRUCT_B)
     {
-      objc_error(nil, OBJC_ERR_BAD_TYPE,
+      objc_error (nil, OBJC_ERR_BAD_TYPE,
                  "record type expected in objc_layout_structure, got %s\n",
                  type);
     }
@@ -760,7 +779,7 @@ objc_layout_structure_next_member (struct objc_struct_layout *layout)
       else {
         /* Get the bitfield's type */
         for (bfld_type = type + 1;
-             isdigit((unsigned char)*bfld_type);
+             isdigit ((unsigned char)*bfld_type);
              bfld_type++)
           /* do nothing */;
 
@@ -784,12 +803,14 @@ objc_layout_structure_next_member (struct objc_struct_layout *layout)
   type = objc_skip_type_qualifiers (layout->type);
 
   if (*type != _C_BFLD)
-    desired_align = objc_alignof_type(type) * BITS_PER_UNIT;
+    desired_align = objc_alignof_type (type) * BITS_PER_UNIT;
   else
     {
       desired_align = 1;
       /* Skip the bitfield's offset */
-      for (bfld_type = type + 1; isdigit((unsigned char)*bfld_type); bfld_type++)
+      for (bfld_type = type + 1;
+           isdigit ((unsigned char) *bfld_type);
+           bfld_type++)
         /* do nothing */;
 
       bfld_type_size = objc_sizeof_type (bfld_type) * BITS_PER_UNIT;
@@ -809,7 +830,7 @@ objc_layout_structure_next_member (struct objc_struct_layout *layout)
      is meaningless.  */
 #ifndef PCC_BITFIELD_TYPE_MATTERS
   layout->record_align = MAX (layout->record_align, desired_align);
-#else
+#else	/* PCC_BITFIELD_TYPE_MATTERS */
   if (*type == _C_BFLD)
     {
       /* For these machines, a zero-length field does not
@@ -841,7 +862,7 @@ objc_layout_structure_next_member (struct objc_struct_layout *layout)
     }
   else
     layout->record_align = MAX (layout->record_align, desired_align);
-#endif
+#endif	/* PCC_BITFIELD_TYPE_MATTERS */
 
   /* Does this field automatically have alignment it needs
      by virtue of the fields that precede it and the record's
@@ -875,7 +896,7 @@ void objc_layout_finish_structure (struct objc_struct_layout *layout,
          in the record type.  Round it up to a multiple of the record's
          alignment. */
 
-#if defined(ROUND_TYPE_ALIGN) && !defined(__sparc__)
+#if defined (ROUND_TYPE_ALIGN) && ! defined (__sparc__)
       layout->record_align = ROUND_TYPE_ALIGN (layout->original_type,
                                                1,
                                                layout->record_align);