Changeset 1391 for branches/GNU/src/gcc/libobjc/archive.c

Timestamp:

Apr 27, 2004, 8:39:34 PM (21 years ago)

Author:

bird

Message:

GCC v3.3.3 sources.

Location:

branches/GNU/src/gcc

Files:

• . (modified) (1 prop)
• libobjc/archive.c (modified) (103 diffs, 1 prop)

branches/GNU/src/gcc

@@ -26 +26 @@
 configure.vr
 configure.vrs
+dir.info
 Makefile
-dir.info
 lost+found
 update.out

@@ -26 +26 @@
 configure.vr
 configure.vrs
+dir.info
 Makefile
-dir.info
 lost+found
 update.out

branches/GNU/src/gcc/libobjc/archive.c

@@ -1 @@
-/* GNU Objective C Runtime archiving
-   Copyright (C) 1993, 1995, 1996, 1997 Free Software Foundation, Inc.
+ /* GNU Objective C Runtime archiving
+   Copyright (C) 1993, 1995, 1996, 1997, 2002 Free Software Foundation, Inc.
    Contributed by Kresten Krab Thorup
 
@@ -29 +29 @@
 #include "typedstream.h"
 #include "encoding.h"
-
-#ifdef HAVE_STDLIB_H
 #include <stdlib.h>
-#endif
-
-extern int fflush(FILE*);
+
+extern int fflush (FILE *);
 
 #define ROUND(V, A) \
-  ({ typeof(V) __v=(V); typeof(A) __a=(A);  \
-     __a*((__v+__a-1)/__a); })
-
-#define PTR2LONG(P) (((char*)(P))-(char*)0)
-#define LONG2PTR(L) (((char*)0)+(L))
+  ({ typeof (V) __v = (V); typeof (A) __a = (A);  \
+     __a * ((__v + __a - 1)/__a); })
+
+#define PTR2LONG(P) (((char *) (P))-(char *) 0)
+#define LONG2PTR(L) (((char *) 0) + (L))
 
 /* Declare some functions... */
 
 static int
-objc_read_class (struct objc_typed_stream* stream, Class* class);
-
-int objc_sizeof_type(const char* type);
+objc_read_class (struct objc_typed_stream *stream, Class *class);
+
+int objc_sizeof_type (const char *type);
 
 static int
-objc_write_use_common (struct objc_typed_stream* stream, unsigned long key);
+objc_write_use_common (struct objc_typed_stream *stream, unsigned long key);
 
 static int
-objc_write_register_common (struct objc_typed_stream* stream,
+objc_write_register_common (struct objc_typed_stream *stream,
                             unsigned long key);
 
 static int 
-objc_write_class (struct objc_typed_stream* stream,
-                         struct objc_class* class);
-
-const char* objc_skip_type (const char* type);
-
-static void __objc_finish_write_root_object(struct objc_typed_stream*);
-static void __objc_finish_read_root_object(struct objc_typed_stream*);
+objc_write_class (struct objc_typed_stream *stream,
+                         struct objc_class *class);
+
+const char *objc_skip_type (const char *type);
+
+static void __objc_finish_write_root_object (struct objc_typed_stream *);
+static void __objc_finish_read_root_object (struct objc_typed_stream *);
 
 static __inline__ int
-__objc_code_unsigned_char (unsigned char* buf, unsigned char val)
+__objc_code_unsigned_char (unsigned char *buf, unsigned char val)
 {
   if ((val&_B_VALUE) == val)
@@ -83 +80 @@
 
 int
-objc_write_unsigned_char (struct objc_typed_stream* stream,
+objc_write_unsigned_char (struct objc_typed_stream *stream,
                           unsigned char value)
 {
-  unsigned char buf[sizeof (unsigned char)+1];
+  unsigned char buf[sizeof (unsigned char) + 1];
   int len = __objc_code_unsigned_char (buf, value);
-  return (*stream->write)(stream->physical, buf, len);
+  return (*stream->write) (stream->physical, buf, len);
 }
 
 static __inline__ int
-__objc_code_char (unsigned char* buf, signed char val)
+__objc_code_char (unsigned char *buf, signed char val)
 {
   if (val >= 0)
@@ -105 +102 @@
 
 int
-objc_write_char (struct objc_typed_stream* stream, signed char value)
-{
-  unsigned char buf[sizeof (char)+1];
+objc_write_char (struct objc_typed_stream *stream, signed char value)
+{
+  unsigned char buf[sizeof (char) + 1];
   int len = __objc_code_char (buf, value);
-  return (*stream->write)(stream->physical, buf, len);
+  return (*stream->write) (stream->physical, buf, len);
 }
 
 static __inline__ int
-__objc_code_unsigned_short (unsigned char* buf, unsigned short val)
+__objc_code_unsigned_short (unsigned char *buf, unsigned short val)
 {
   if ((val&_B_VALUE) == val)
@@ -126 +123 @@
       buf[0] = _B_NINT;
 
-      for (c= sizeof(short); c != 0; c -= 1)
-        if (((val>>(8*(c-1)))%0x100) != 0)
+      for (c = sizeof (short); c != 0; c -= 1)
+        if (((val >> (8*(c - 1)))%0x100) != 0)
           break;
 
@@ -134 +131 @@
       for (b = 1; c != 0; c--, b++)
         {
-          buf[b] = (val >> (8*(c-1)))%0x100;
+          buf[b] = (val >> (8*(c - 1)))%0x100;
         }
 
@@ -142 +139 @@
 
 int
-objc_write_unsigned_short (struct objc_typed_stream* stream, 
+objc_write_unsigned_short (struct objc_typed_stream *stream, 
                            unsigned short value)
 {
-  unsigned char buf[sizeof (unsigned short)+1];
+  unsigned char buf[sizeof (unsigned short) + 1];
   int len = __objc_code_unsigned_short (buf, value);
-  return (*stream->write)(stream->physical, buf, len);
+  return (*stream->write) (stream->physical, buf, len);
 }
       
 static __inline__ int
-__objc_code_short (unsigned char* buf, short val)
+__objc_code_short (unsigned char *buf, short val)
 {
   int sign = (val < 0);
@@ -161 +158 @@
 
 int
-objc_write_short (struct objc_typed_stream* stream, short value)
-{
-  unsigned char buf[sizeof (short)+1];
+objc_write_short (struct objc_typed_stream *stream, short value)
+{
+  unsigned char buf[sizeof (short) + 1];
   int len = __objc_code_short (buf, value);
-  return (*stream->write)(stream->physical, buf, len);
+  return (*stream->write) (stream->physical, buf, len);
 }
       
 
 static __inline__ int
-__objc_code_unsigned_int (unsigned char* buf, unsigned int val)
+__objc_code_unsigned_int (unsigned char *buf, unsigned int val)
 {
   if ((val&_B_VALUE) == val)
@@ -183 +180 @@
       buf[0] = _B_NINT;
 
-      for (c= sizeof(int); c != 0; c -= 1)
-        if (((val>>(8*(c-1)))%0x100) != 0)
+      for (c = sizeof (int); c != 0; c -= 1)
+        if (((val >> (8*(c - 1)))%0x100) != 0)
           break;
 
@@ -199 +196 @@
 
 int
-objc_write_unsigned_int (struct objc_typed_stream* stream, unsigned int value)
-{
-  unsigned char buf[sizeof(unsigned int)+1];
+objc_write_unsigned_int (struct objc_typed_stream *stream, unsigned int value)
+{
+  unsigned char buf[sizeof (unsigned int) + 1];
   int len = __objc_code_unsigned_int (buf, value);
-  return (*stream->write)(stream->physical, buf, len);
+  return (*stream->write) (stream->physical, buf, len);
 }
 
 static __inline__ int
-__objc_code_int (unsigned char* buf, int val)
+__objc_code_int (unsigned char *buf, int val)
 {
   int sign = (val < 0);
@@ -217 +214 @@
 
 int
-objc_write_int (struct objc_typed_stream* stream, int value)
-{
-  unsigned char buf[sizeof(int)+1];
+objc_write_int (struct objc_typed_stream *stream, int value)
+{
+  unsigned char buf[sizeof (int) + 1];
   int len = __objc_code_int (buf, value);
-  return (*stream->write)(stream->physical, buf, len);
+  return (*stream->write) (stream->physical, buf, len);
 }
 
 static __inline__ int
-__objc_code_unsigned_long (unsigned char* buf, unsigned long val)
+__objc_code_unsigned_long (unsigned char *buf, unsigned long val)
 {
   if ((val&_B_VALUE) == val)
@@ -238 +235 @@
       buf[0] = _B_NINT;
 
-      for (c= sizeof(long); c != 0; c -= 1)
-        if (((val>>(8*(c-1)))%0x100) != 0)
+      for (c = sizeof (long); c != 0; c -= 1)
+        if (((val >> (8*(c - 1)))%0x100) != 0)
           break;
 
@@ -246 +243 @@
       for (b = 1; c != 0; c--, b++)
         {
-          buf[b] = (val >> (8*(c-1)))%0x100;
+          buf[b] = (val >> (8*(c - 1)))%0x100;
         }
 
@@ -254 +251 @@
 
 int
-objc_write_unsigned_long (struct objc_typed_stream* stream, 
+objc_write_unsigned_long (struct objc_typed_stream *stream, 
                           unsigned long value)
 {
-  unsigned char buf[sizeof(unsigned long)+1];
+  unsigned char buf[sizeof (unsigned long) + 1];
   int len = __objc_code_unsigned_long (buf, value);
-  return (*stream->write)(stream->physical, buf, len);
+  return (*stream->write) (stream->physical, buf, len);
 }
 
 static __inline__ int
-__objc_code_long (unsigned char* buf, long val)
+__objc_code_long (unsigned char *buf, long val)
 {
   int sign = (val < 0);
@@ -273 +270 @@
 
 int
-objc_write_long (struct objc_typed_stream* stream, long value)
-{
-  unsigned char buf[sizeof(long)+1];
+objc_write_long (struct objc_typed_stream *stream, long value)
+{
+  unsigned char buf[sizeof (long) + 1];
   int len = __objc_code_long (buf, value);
-  return (*stream->write)(stream->physical, buf, len);
+  return (*stream->write) (stream->physical, buf, len);
 }
 
 
 int
-objc_write_string (struct objc_typed_stream* stream,
-                   const unsigned char* string, unsigned int nbytes)
-{
-  unsigned char buf[sizeof(unsigned int)+1];
+objc_write_string (struct objc_typed_stream *stream,
+                   const unsigned char *string, unsigned int nbytes)
+{
+  unsigned char buf[sizeof (unsigned int) + 1];
   int len = __objc_code_unsigned_int (buf, nbytes);
   
@@ -294 +291 @@
     buf[0] = (buf[0]&_B_VALUE)|_B_NSTR;
 
-  if ((*stream->write)(stream->physical, buf, len) != 0)
-    return (*stream->write)(stream->physical, string, nbytes);
+  if ((*stream->write) (stream->physical, buf, len) != 0)
+    return (*stream->write) (stream->physical, string, nbytes);
   else
     return 0;
@@ -301 +298 @@
 
 int
-objc_write_string_atomic (struct objc_typed_stream* stream,
-                          unsigned char* string, unsigned int nbytes)
+objc_write_string_atomic (struct objc_typed_stream *stream,
+                          unsigned char *string, unsigned int nbytes)
 {
   unsigned long key;
@@ -318 +315 @@
 
 static int
-objc_write_register_common (struct objc_typed_stream* stream, 
+objc_write_register_common (struct objc_typed_stream *stream, 
                             unsigned long key)
 {
   unsigned char buf[sizeof (unsigned long)+2];
-  int len = __objc_code_unsigned_long (buf+1, key);
+  int len = __objc_code_unsigned_long (buf + 1, key);
   if (len == 1)
     {
       buf[0] = _B_RCOMM|0x01;
       buf[1] &= _B_VALUE;
-      return (*stream->write)(stream->physical, buf, len+1);
+      return (*stream->write) (stream->physical, buf, len + 1);
     }
   else
     {
       buf[1] = (buf[1]&_B_VALUE)|_B_RCOMM;
-      return (*stream->write)(stream->physical, buf+1, len);
+      return (*stream->write) (stream->physical, buf + 1, len);
     }
 }
 
 static int
-objc_write_use_common (struct objc_typed_stream* stream, unsigned long key)
+objc_write_use_common (struct objc_typed_stream *stream, unsigned long key)
 {
   unsigned char buf[sizeof (unsigned long)+2];
-  int len = __objc_code_unsigned_long (buf+1, key);
+  int len = __objc_code_unsigned_long (buf + 1, key);
   if (len == 1)
     {
       buf[0] = _B_UCOMM|0x01;
       buf[1] &= _B_VALUE;
-      return (*stream->write)(stream->physical, buf, 2);
+      return (*stream->write) (stream->physical, buf, 2);
     }
   else
     {
       buf[1] = (buf[1]&_B_VALUE)|_B_UCOMM;
-      return (*stream->write)(stream->physical, buf+1, len);
+      return (*stream->write) (stream->physical, buf + 1, len);
     }
 }
 
 static __inline__ int
-__objc_write_extension (struct objc_typed_stream* stream, unsigned char code)
+__objc_write_extension (struct objc_typed_stream *stream, unsigned char code)
 {
   if (code <= _B_VALUE)
     {
       unsigned char buf = code|_B_EXT;
-      return (*stream->write)(stream->physical, &buf, 1);
+      return (*stream->write) (stream->physical, &buf, 1);
     }
   else 
     {
-      objc_error(nil, OBJC_ERR_BAD_OPCODE,
-                 "__objc_write_extension: bad opcode %c\n", code);
+      objc_error (nil, OBJC_ERR_BAD_OPCODE,
+                  "__objc_write_extension: bad opcode %c\n", code);
       return -1;
     }
@@ -371 +368 @@
 
 __inline__ int
-__objc_write_object (struct objc_typed_stream* stream, id object)
+__objc_write_object (struct objc_typed_stream *stream, id object)
 {
   unsigned char buf = '\0';
@@ -379 +376 @@
       __objc_write_extension (stream, _BX_OBJECT);
       objc_write_class (stream, object->class_pointer);
-      (*objc_msg_lookup(object, write_sel))(object, write_sel, stream);
-      return (*stream->write)(stream->physical, &buf, 1);
+      (*objc_msg_lookup (object, write_sel)) (object, write_sel, stream);
+      return (*stream->write) (stream->physical, &buf, 1);
     }
   else
-    return objc_write_use_common(stream, 0);
+    return objc_write_use_common (stream, 0);
 }
 
 int 
-objc_write_object_reference (struct objc_typed_stream* stream, id object)
+objc_write_object_reference (struct objc_typed_stream *stream, id object)
 {
   unsigned long key;
@@ -398 +395 @@
 
 int 
-objc_write_root_object (struct objc_typed_stream* stream, id object)
+objc_write_root_object (struct objc_typed_stream *stream, id object)
 {
   int len = 0;
@@ -408 +405 @@
       stream->writing_root_p = 1;
       __objc_write_extension (stream, _BX_OBJROOT);
-      if((len = objc_write_object (stream, object)))
-        __objc_finish_write_root_object(stream);
+      if ((len = objc_write_object (stream, object)))
+        __objc_finish_write_root_object (stream);
       stream->writing_root_p = 0;
     }
@@ -416 +413 @@
 
 int 
-objc_write_object (struct objc_typed_stream* stream, id object)
+objc_write_object (struct objc_typed_stream *stream, id object)
 {
   unsigned long key;
@@ -423 +420 @@
 
   else if (object == nil)
-    return objc_write_use_common(stream, 0);
+    return objc_write_use_common (stream, 0);
 
   else
@@ -436 +433 @@
 
 __inline__ int
-__objc_write_class (struct objc_typed_stream* stream, struct objc_class* class)
+__objc_write_class (struct objc_typed_stream *stream, struct objc_class *class)
 {
   __objc_write_extension (stream, _BX_CLASS);
-  objc_write_string_atomic(stream, (char*)class->name,
-                           strlen((char*)class->name));
+  objc_write_string_atomic (stream, (char *) class->name,
+                           strlen ((char *) class->name));
   return objc_write_unsigned_long (stream, class->version);
 }
@@ -446 +443 @@
 
 static int 
-objc_write_class (struct objc_typed_stream* stream,
-                         struct objc_class* class)
+objc_write_class (struct objc_typed_stream *stream,
+                         struct objc_class *class)
 {
   unsigned long key;
@@ -455 +452 @@
     {
       int length;
-      hash_add (&stream->stream_table, LONG2PTR(key=PTR2LONG(class)), class);
+      hash_add (&stream->stream_table, LONG2PTR(key = PTR2LONG(class)), class);
       if ((length = objc_write_register_common (stream, key)))
         return __objc_write_class (stream, class);
@@ -464 +461 @@
 
 __inline__ int 
-__objc_write_selector (struct objc_typed_stream* stream, SEL selector)
-{
-  const char* sel_name;
+__objc_write_selector (struct objc_typed_stream *stream, SEL selector)
+{
+  const char *sel_name;
   __objc_write_extension (stream, _BX_SEL);
   /* to handle NULL selectors */
@@ -476 +473 @@
 
 int 
-objc_write_selector (struct objc_typed_stream* stream, SEL selector)
-{
-  const char* sel_name;
+objc_write_selector (struct objc_typed_stream *stream, SEL selector)
+{
+  const char *sel_name;
   unsigned long key;
 
@@ -492 +489 @@
       int length;
       hash_add (&stream->stream_table, 
-                LONG2PTR(key=PTR2LONG(sel_name)), (char*)sel_name);
+                LONG2PTR(key = PTR2LONG(sel_name)), (char *) sel_name);
       if ((length = objc_write_register_common (stream, key)))
         return __objc_write_selector (stream, selector);
@@ -506 +503 @@
 
 __inline__ int
-objc_read_char (struct objc_typed_stream* stream, char* val)
+objc_read_char (struct objc_typed_stream *stream, char *val)
 {
   unsigned char buf;
   int len;
-  len = (*stream->read)(stream->physical, &buf, 1);
+  len = (*stream->read) (stream->physical, &buf, 1);
   if (len != 0)
     {
@@ -518 +515 @@
       else if ((buf & _B_NUMBER) == 1)
         {
-          len = (*stream->read)(stream->physical, val, 1);
+          len = (*stream->read) (stream->physical, val, 1);
           if (buf&_B_SIGN)
-            (*val) = -1*(*val);
+            (*val) = -1 * (*val);
         }
 
       else
-        objc_error(nil, OBJC_ERR_BAD_DATA,
-                   "expected 8bit signed int, got %dbit int",
-                   (int)(buf&_B_NUMBER)*8);
+        objc_error (nil, OBJC_ERR_BAD_DATA,
+                    "expected 8bit signed int, got %dbit int",
+                    (int) (buf&_B_NUMBER)*8);
     }
   return len;
@@ -533 +530 @@
 
 __inline__ int
-objc_read_unsigned_char (struct objc_typed_stream* stream, unsigned char* val)
+objc_read_unsigned_char (struct objc_typed_stream *stream, unsigned char *val)
 {
   unsigned char buf;
   int len;
-  if ((len = (*stream->read)(stream->physical, &buf, 1)))
+  if ((len = (*stream->read) (stream->physical, &buf, 1)))
     {
       if ((buf & _B_CODE) == _B_SINT)
@@ -543 +540 @@
 
       else if ((buf & _B_NUMBER) == 1)
-        len = (*stream->read)(stream->physical, val, 1);
+        len = (*stream->read) (stream->physical, val, 1);
 
       else
-        objc_error(nil, OBJC_ERR_BAD_DATA,
-                   "expected 8bit unsigned int, got %dbit int",
-                   (int)(buf&_B_NUMBER)*8);
+        objc_error (nil, OBJC_ERR_BAD_DATA,
+                    "expected 8bit unsigned int, got %dbit int",
+                    (int) (buf&_B_NUMBER)*8);
     }
   return len;
@@ -554 +551 @@
 
 __inline__ int
-objc_read_short (struct objc_typed_stream* stream, short* value)
-{
-  unsigned char buf[sizeof(short)+1];
+objc_read_short (struct objc_typed_stream *stream, short *value)
+{
+  unsigned char buf[sizeof (short) + 1];
   int len;
-  if ((len = (*stream->read)(stream->physical, buf, 1)))
+  if ((len = (*stream->read) (stream->physical, buf, 1)))
     {
       if ((buf[0] & _B_CODE) == _B_SINT)
@@ -567 +564 @@
           int pos = 1;
           int nbytes = buf[0] & _B_NUMBER;
-          if (nbytes > sizeof (short))
-            objc_error(nil, OBJC_ERR_BAD_DATA,
-                       "expected short, got bigger (%dbits)", nbytes*8);
-          len = (*stream->read)(stream->physical, buf+1, nbytes);
+          if (nbytes > (int) sizeof (short))
+            objc_error (nil, OBJC_ERR_BAD_DATA,
+                        "expected short, got bigger (%dbits)", nbytes*8);
+          len = (*stream->read) (stream->physical, buf + 1, nbytes);
           (*value) = 0;
           while (pos <= nbytes)
@@ -582 +579 @@
 
 __inline__ int
-objc_read_unsigned_short (struct objc_typed_stream* stream,
-                          unsigned short* value)
-{
-  unsigned char buf[sizeof(unsigned short)+1];
+objc_read_unsigned_short (struct objc_typed_stream *stream,
+                          unsigned short *value)
+{
+  unsigned char buf[sizeof (unsigned short) + 1];
   int len;
-  if ((len = (*stream->read)(stream->physical, buf, 1)))
+  if ((len = (*stream->read) (stream->physical, buf, 1)))
     {
       if ((buf[0] & _B_CODE) == _B_SINT)
@@ -596 +593 @@
           int pos = 1;
           int nbytes = buf[0] & _B_NUMBER;
-          if (nbytes > sizeof (short))
-            objc_error(nil, OBJC_ERR_BAD_DATA,
-                       "expected short, got int or bigger");
-          len = (*stream->read)(stream->physical, buf+1, nbytes);
+          if (nbytes > (int) sizeof (short))
+            objc_error (nil, OBJC_ERR_BAD_DATA,
+                        "expected short, got int or bigger");
+          len = (*stream->read) (stream->physical, buf + 1, nbytes);
           (*value) = 0;
           while (pos <= nbytes)
@@ -610 +607 @@
 
 __inline__ int
-objc_read_int (struct objc_typed_stream* stream, int* value)
-{
-  unsigned char buf[sizeof(int)+1];
+objc_read_int (struct objc_typed_stream *stream, int *value)
+{
+  unsigned char buf[sizeof (int) + 1];
   int len;
-  if ((len = (*stream->read)(stream->physical, buf, 1)))
+  if ((len = (*stream->read) (stream->physical, buf, 1)))
     {
       if ((buf[0] & _B_CODE) == _B_SINT)
@@ -623 +620 @@
           int pos = 1;
           int nbytes = buf[0] & _B_NUMBER;
-          if (nbytes > sizeof (int))
-            objc_error(nil, OBJC_ERR_BAD_DATA, "expected int, got bigger");
-          len = (*stream->read)(stream->physical, buf+1, nbytes);
+          if (nbytes > (int) sizeof (int))
+            objc_error (nil, OBJC_ERR_BAD_DATA, "expected int, got bigger");
+          len = (*stream->read) (stream->physical, buf + 1, nbytes);
           (*value) = 0;
           while (pos <= nbytes)
@@ -637 +634 @@
 
 __inline__ int
-objc_read_long (struct objc_typed_stream* stream, long* value)
-{
-  unsigned char buf[sizeof(long)+1];
+objc_read_long (struct objc_typed_stream *stream, long *value)
+{
+  unsigned char buf[sizeof (long) + 1];
   int len;
-  if ((len = (*stream->read)(stream->physical, buf, 1)))
+  if ((len = (*stream->read) (stream->physical, buf, 1)))
     {
       if ((buf[0] & _B_CODE) == _B_SINT)
@@ -650 +647 @@
           int pos = 1;
           int nbytes = buf[0] & _B_NUMBER;
-          if (nbytes > sizeof (long))
-            objc_error(nil, OBJC_ERR_BAD_DATA, "expected long, got bigger");
-          len = (*stream->read)(stream->physical, buf+1, nbytes);
+          if (nbytes > (int) sizeof (long))
+            objc_error (nil, OBJC_ERR_BAD_DATA, "expected long, got bigger");
+          len = (*stream->read) (stream->physical, buf + 1, nbytes);
           (*value) = 0;
           while (pos <= nbytes)
@@ -664 +661 @@
 
 __inline__ int
-__objc_read_nbyte_uint (struct objc_typed_stream* stream,
-                       unsigned int nbytes, unsigned int* val)
-{
-  int len, pos = 0;
-  unsigned char buf[sizeof(unsigned int)+1];
+__objc_read_nbyte_uint (struct objc_typed_stream *stream,
+                        unsigned int nbytes, unsigned int *val)
+{
+  int len;
+  unsigned int pos = 0;
+  unsigned char buf[sizeof (unsigned int) + 1];
 
   if (nbytes > sizeof (int))
-    objc_error(nil, OBJC_ERR_BAD_DATA, "expected int, got bigger");
-
-  len = (*stream->read)(stream->physical, buf, nbytes);
+    objc_error (nil, OBJC_ERR_BAD_DATA, "expected int, got bigger");
+
+  len = (*stream->read) (stream->physical, buf, nbytes);
   (*val) = 0;
   while (pos < nbytes)
@@ -682 +680 @@
 
 __inline__ int
-objc_read_unsigned_int (struct objc_typed_stream* stream,
-                        unsigned int* value)
-{
-  unsigned char buf[sizeof(unsigned int)+1];
+objc_read_unsigned_int (struct objc_typed_stream *stream,
+                        unsigned int *value)
+{
+  unsigned char buf[sizeof (unsigned int) + 1];
   int len;
-  if ((len = (*stream->read)(stream->physical, buf, 1)))
+  if ((len = (*stream->read) (stream->physical, buf, 1)))
     {
       if ((buf[0] & _B_CODE) == _B_SINT)
@@ -700 +698 @@
 
 int
-__objc_read_nbyte_ulong (struct objc_typed_stream* stream,
-                       unsigned int nbytes, unsigned long* val)
-{
-  int len, pos = 0;
-  unsigned char buf[sizeof(unsigned long)+1];
+__objc_read_nbyte_ulong (struct objc_typed_stream *stream,
+                       unsigned int nbytes, unsigned long *val)
+{
+  int len;
+  unsigned int pos = 0;
+  unsigned char buf[sizeof (unsigned long) + 1];
 
   if (nbytes > sizeof (long))
-    objc_error(nil, OBJC_ERR_BAD_DATA, "expected long, got bigger");
-
-  len = (*stream->read)(stream->physical, buf, nbytes);
+    objc_error (nil, OBJC_ERR_BAD_DATA, "expected long, got bigger");
+
+  len = (*stream->read) (stream->physical, buf, nbytes);
   (*val) = 0;
   while (pos < nbytes)
@@ -718 +717 @@
 
 __inline__ int
-objc_read_unsigned_long (struct objc_typed_stream* stream,
-                        unsigned long* value)
-{
-  unsigned char buf[sizeof(unsigned long)+1];
+objc_read_unsigned_long (struct objc_typed_stream *stream,
+                         unsigned long *value)
+{
+  unsigned char buf[sizeof (unsigned long) + 1];
   int len;
-  if ((len = (*stream->read)(stream->physical, buf, 1)))
+  if ((len = (*stream->read) (stream->physical, buf, 1)))
     {
       if ((buf[0] & _B_CODE) == _B_SINT)
@@ -736 +735 @@
 
 __inline__ int
-objc_read_string (struct objc_typed_stream* stream,
-                  char** string)
-{
-  unsigned char buf[sizeof(unsigned int)+1];
+objc_read_string (struct objc_typed_stream *stream,
+                  char **string)
+{
+  unsigned char buf[sizeof (unsigned int) + 1];
   int len;
-  if ((len = (*stream->read)(stream->physical, buf, 1)))
+  if ((len = (*stream->read) (stream->physical, buf, 1)))
     {
       unsigned long key = 0;
@@ -747 +746 @@
       if ((buf[0]&_B_CODE) == _B_RCOMM) /* register following */
         {
-          len = __objc_read_nbyte_ulong(stream, (buf[0] & _B_VALUE), &key);
-          len = (*stream->read)(stream->physical, buf, 1);
+          len = __objc_read_nbyte_ulong (stream, (buf[0] & _B_VALUE), &key);
+          len = (*stream->read) (stream->physical, buf, 1);
         }
 
@@ -755 +754 @@
         {
           int length = buf[0]&_B_VALUE;
-          (*string) = (char*)objc_malloc(length+1);
+          (*string) = (char*)objc_malloc (length + 1);
           if (key)
             hash_add (&stream->stream_table, LONG2PTR(key), *string);
-          len = (*stream->read)(stream->physical, *string, length);
+          len = (*stream->read) (stream->physical, *string, length);
           (*string)[length] = '\0';
         }
@@ -766 +765 @@
         {
           char *tmp;
-          len = __objc_read_nbyte_ulong(stream, (buf[0] & _B_VALUE), &key);
+          len = __objc_read_nbyte_ulong (stream, (buf[0] & _B_VALUE), &key);
           tmp = hash_value_for_key (stream->stream_table, LONG2PTR (key));
-          *string = objc_malloc (strlen(tmp) + 1);
+          *string = objc_malloc (strlen (tmp) + 1);
           strcpy (*string, tmp);
         }
@@ -776 +775 @@
         {
           unsigned int nbytes = buf[0]&_B_VALUE;
-          len = __objc_read_nbyte_uint(stream, nbytes, &nbytes);
+          len = __objc_read_nbyte_uint (stream, nbytes, &nbytes);
           if (len) {
-            (*string) = (char*)objc_malloc(nbytes+1);
+            (*string) = (char*)objc_malloc (nbytes + 1);
             if (key)
               hash_add (&stream->stream_table, LONG2PTR(key), *string);
-            len = (*stream->read)(stream->physical, *string, nbytes);
+            len = (*stream->read) (stream->physical, *string, nbytes);
             (*string)[nbytes] = '\0';
           }
@@ -788 +787 @@
         
       default:
-        objc_error(nil, OBJC_ERR_BAD_DATA,
-                   "expected string, got opcode %c\n", (buf[0]&_B_CODE));
+        objc_error (nil, OBJC_ERR_BAD_DATA,
+                    "expected string, got opcode %c\n", (buf[0]&_B_CODE));
       }
     }
@@ -798 +797 @@
 
 int
-objc_read_object (struct objc_typed_stream* stream, id* object)
+objc_read_object (struct objc_typed_stream *stream, id *object)
 {
   unsigned char buf[sizeof (unsigned int)];
   int len;
-  if ((len = (*stream->read)(stream->physical, buf, 1)))
+  if ((len = (*stream->read) (stream->physical, buf, 1)))
     {
       SEL read_sel = sel_get_any_uid ("read:");
@@ -809 +808 @@
       if ((buf[0]&_B_CODE) == _B_RCOMM) /* register common */
         {
-          len = __objc_read_nbyte_ulong(stream, (buf[0] & _B_VALUE), &key);
-          len = (*stream->read)(stream->physical, buf, 1);
+          len = __objc_read_nbyte_ulong (stream, (buf[0] & _B_VALUE), &key);
+          len = (*stream->read) (stream->physical, buf, 1);
         }
 
@@ -821 +820 @@
 
           /* create instance */
-          (*object) = class_create_instance(class);
+          (*object) = class_create_instance (class);
 
           /* register? */
@@ -829 +828 @@
           /* send -read: */
           if (__objc_responds_to (*object, read_sel))
-            (*get_imp(class, read_sel))(*object, read_sel, stream);
+            (*get_imp (class, read_sel)) (*object, read_sel, stream);
 
           /* check null-byte */
-          len = (*stream->read)(stream->physical, buf, 1);
+          len = (*stream->read) (stream->physical, buf, 1);
           if (buf[0] != '\0')
-            objc_error(nil, OBJC_ERR_BAD_DATA,
-                       "expected null-byte, got opcode %c", buf[0]);
+            objc_error (nil, OBJC_ERR_BAD_DATA,
+                        "expected null-byte, got opcode %c", buf[0]);
         }
 
@@ -841 +840 @@
         {
           if (key)
-            objc_error(nil, OBJC_ERR_BAD_KEY, "cannot register use upcode...");
-          len = __objc_read_nbyte_ulong(stream, (buf[0] & _B_VALUE), &key);
+            objc_error (nil, OBJC_ERR_BAD_KEY, "cannot register use upcode...");
+          len = __objc_read_nbyte_ulong (stream, (buf[0] & _B_VALUE), &key);
           (*object) = hash_value_for_key (stream->object_table, LONG2PTR(key));
         }
@@ -848 +847 @@
       else if (buf[0] == (_B_EXT | _BX_OBJREF)) /* a forward reference */
         {
-          struct objc_list* other;
+          struct objc_list *other;
           len = objc_read_unsigned_long (stream, &key);
-          other = (struct objc_list*)hash_value_for_key (stream->object_refs, 
-                                                         LONG2PTR(key));
+          other = (struct objc_list *) hash_value_for_key (stream->object_refs, 
+                                                           LONG2PTR(key));
           hash_add (&stream->object_refs, LONG2PTR(key), 
-                    (void*)list_cons(object, other));
+                    (void *)list_cons (object, other));
         }
 
@@ -859 +858 @@
         {
           if (key)
-            objc_error(nil, OBJC_ERR_BAD_KEY,
-                       "cannot register root object...");
+            objc_error (nil, OBJC_ERR_BAD_KEY,
+                        "cannot register root object...");
           len = objc_read_object (stream, object);
           __objc_finish_read_root_object (stream);
@@ -866 +865 @@
 
       else
-        objc_error(nil, OBJC_ERR_BAD_DATA,
-                   "expected object, got opcode %c", buf[0]);
+        objc_error (nil, OBJC_ERR_BAD_DATA,
+                    "expected object, got opcode %c", buf[0]);
     }
   return len;
@@ -873 +872 @@
 
 static int
-objc_read_class (struct objc_typed_stream* stream, Class* class)
+objc_read_class (struct objc_typed_stream *stream, Class *class)
 {
   unsigned char buf[sizeof (unsigned int)];
   int len;
-  if ((len = (*stream->read)(stream->physical, buf, 1)))
+  if ((len = (*stream->read) (stream->physical, buf, 1)))
     {
       unsigned long key = 0;
@@ -883 +882 @@
       if ((buf[0]&_B_CODE) == _B_RCOMM) /* register following */
         {
-          len = __objc_read_nbyte_ulong(stream, (buf[0] & _B_VALUE), &key);
-          len = (*stream->read)(stream->physical, buf, 1);
+          len = __objc_read_nbyte_ulong (stream, (buf[0] & _B_VALUE), &key);
+          len = (*stream->read) (stream->physical, buf, 1);
         }
 
       if (buf[0] == (_B_EXT | _BX_CLASS))
         {
-          char* class_name;
+          char *class_name;
           unsigned long version;
 
           /* get class */
           len = objc_read_string (stream, &class_name);
-          (*class) = objc_get_class(class_name);
-          objc_free(class_name);
+          (*class) = objc_get_class (class_name);
+          objc_free (class_name);
 
           /* register */
@@ -901 +900 @@
             hash_add (&stream->stream_table, LONG2PTR(key), *class);
 
-          objc_read_unsigned_long(stream, &version);
-          hash_add (&stream->class_table, (*class)->name, (void*)version);
+          objc_read_unsigned_long (stream, &version);
+          hash_add (&stream->class_table, (*class)->name, (void *)version);
         }
 
@@ -908 +907 @@
         {
           if (key)
-            objc_error(nil, OBJC_ERR_BAD_KEY, "cannot register use upcode...");
-          len = __objc_read_nbyte_ulong(stream, (buf[0] & _B_VALUE), &key);
-          (*class) = hash_value_for_key (stream->stream_table, LONG2PTR(key));
-          if (!*class)
-            objc_error(nil, OBJC_ERR_BAD_CLASS,
-                       "cannot find class for key %lu", key);
+            objc_error (nil, OBJC_ERR_BAD_KEY, "cannot register use upcode...");
+          len = __objc_read_nbyte_ulong (stream, (buf[0] & _B_VALUE), &key);
+          *class = hash_value_for_key (stream->stream_table, LONG2PTR(key));
+          if (! *class)
+            objc_error (nil, OBJC_ERR_BAD_CLASS,
+                        "cannot find class for key %lu", key);
         }
 
       else
-        objc_error(nil, OBJC_ERR_BAD_DATA,
-                   "expected class, got opcode %c", buf[0]);
+        objc_error (nil, OBJC_ERR_BAD_DATA,
+                    "expected class, got opcode %c", buf[0]);
     }
   return len;
@@ -924 +923 @@
 
 int
-objc_read_selector (struct objc_typed_stream* stream, SEL* selector)
+objc_read_selector (struct objc_typed_stream *stream, SEL* selector)
 {
   unsigned char buf[sizeof (unsigned int)];
   int len;
-  if ((len = (*stream->read)(stream->physical, buf, 1)))
+  if ((len = (*stream->read) (stream->physical, buf, 1)))
     {
       unsigned long key = 0;
@@ -934 +933 @@
       if ((buf[0]&_B_CODE) == _B_RCOMM) /* register following */
         {
-          len = __objc_read_nbyte_ulong(stream, (buf[0] & _B_VALUE), &key);
-          len = (*stream->read)(stream->physical, buf, 1);
+          len = __objc_read_nbyte_ulong (stream, (buf[0] & _B_VALUE), &key);
+          len = (*stream->read) (stream->physical, buf, 1);
         }
 
       if (buf[0] == (_B_EXT|_BX_SEL)) /* selector! */
         {
-          char* selector_name;
+          char *selector_name;
 
           /* get selector */
           len = objc_read_string (stream, &selector_name);
           /* To handle NULL selectors */
-          if (0 == strlen(selector_name))
+          if (0 == strlen (selector_name))
             {
               (*selector) = (SEL)0;
@@ -951 +950 @@
             }
           else 
-            (*selector) = sel_get_any_uid(selector_name);
-          objc_free(selector_name);
+            (*selector) = sel_get_any_uid (selector_name);
+          objc_free (selector_name);
 
           /* register */
           if (key)
-            hash_add (&stream->stream_table, LONG2PTR(key), (void*)*selector);
+            hash_add (&stream->stream_table, LONG2PTR(key), (void *) *selector);
         }
 
@@ -962 +961 @@
         {
           if (key)
-            objc_error(nil, OBJC_ERR_BAD_KEY, "cannot register use upcode...");
-          len = __objc_read_nbyte_ulong(stream, (buf[0] & _B_VALUE), &key);
+            objc_error (nil, OBJC_ERR_BAD_KEY, "cannot register use upcode...");
+          len = __objc_read_nbyte_ulong (stream, (buf[0] & _B_VALUE), &key);
           (*selector) = hash_value_for_key (stream->stream_table, 
                                             LONG2PTR(key));
@@ -969 +968 @@
 
       else
-        objc_error(nil, OBJC_ERR_BAD_DATA,
-                   "expected selector, got opcode %c", buf[0]);
+        objc_error (nil, OBJC_ERR_BAD_DATA,
+                    "expected selector, got opcode %c", buf[0]);
     }
   return len;
@@ -985 +984 @@
 
 int
-objc_write_type(TypedStream* stream, const char* type, const void* data)
-{
-  switch(*type) {
+objc_write_type (TypedStream *stream, const char *type, const void *data)
+{
+  switch (*type) {
   case _C_ID:
-    return objc_write_object (stream, *(id*)data);
+    return objc_write_object (stream, *(id *) data);
     break;
 
   case _C_CLASS:
-    return objc_write_class (stream, *(Class*)data);
+    return objc_write_class (stream, *(Class *) data);
     break;
 
   case _C_SEL:
-    return objc_write_selector (stream, *(SEL*)data);
+    return objc_write_selector (stream, *(SEL *) data);
     break;
 
   case _C_CHR:
-    return objc_write_char(stream, *(signed char*)data);
+    return objc_write_char (stream, *(signed char *) data);
     break;
     
   case _C_UCHR:
-    return objc_write_unsigned_char(stream, *(unsigned char*)data);
+    return objc_write_unsigned_char (stream, *(unsigned char *) data);
     break;
 
   case _C_SHT:
-    return objc_write_short(stream, *(short*)data);
+    return objc_write_short (stream, *(short *) data);
     break;
 
   case _C_USHT:
-    return objc_write_unsigned_short(stream, *(unsigned short*)data);
+    return objc_write_unsigned_short (stream, *(unsigned short *) data);
     break;
 
   case _C_INT:
-    return objc_write_int(stream, *(int*)data);
+    return objc_write_int (stream, *(int *) data);
     break;
 
   case _C_UINT:
-    return objc_write_unsigned_int(stream, *(unsigned int*)data);
+    return objc_write_unsigned_int (stream, *(unsigned int *) data);
     break;
 
   case _C_LNG:
-    return objc_write_long(stream, *(long*)data);
+    return objc_write_long (stream, *(long *) data);
     break;
 
   case _C_ULNG:
-    return objc_write_unsigned_long(stream, *(unsigned long*)data);
+    return objc_write_unsigned_long (stream, *(unsigned long *) data);
     break;
 
   case _C_CHARPTR:
-    return objc_write_string (stream, *(char**)data, strlen(*(char**)data));
+    return objc_write_string (stream,
+                              *(char **) data, strlen (*(char **) data));
     break;
 
   case _C_ATOM:
-    return objc_write_string_atomic (stream, *(char**)data, 
-                                     strlen(*(char**)data));
+    return objc_write_string_atomic (stream, *(char **) data, 
+                                     strlen (*(char **) data));
     break;
 
   case _C_ARY_B:
     {
-      int len = atoi(type+1);
-      while (isdigit(*++type))
+      int len = atoi (type + 1);
+      while (isdigit ((unsigned char) *++type))
         ;
       return objc_write_array (stream, type, len, data);
@@ -1060 +1060 @@
           align = objc_alignof_type (type);       /* padd to alignment */
           acc_size += ROUND (acc_size, align);
-          objc_write_type (stream, type, ((char*)data)+acc_size);
+          objc_write_type (stream, type, ((char *) data) + acc_size);
           acc_size += objc_sizeof_type (type);   /* add component size */
           type = objc_skip_typespec (type);      /* skip component */
@@ -1069 +1069 @@
   default:
     {
-      objc_error(nil, OBJC_ERR_BAD_TYPE,
-                 "objc_write_type: cannot parse typespec: %s\n", type);
+      objc_error (nil, OBJC_ERR_BAD_TYPE,
+                  "objc_write_type: cannot parse typespec: %s\n", type);
       return 0;
     }
@@ -1084 +1084 @@
 
 int
-objc_read_type(TypedStream* stream, const char* type, void* data)
+objc_read_type(TypedStream *stream, const char *type, void *data)
 {
   char c;
-  switch(c = *type) {
+  switch (c = *type) {
   case _C_ID:
     return objc_read_object (stream, (id*)data);
@@ -1139 +1139 @@
   case _C_ARY_B:
     {
-      int len = atoi(type+1);
-      while (isdigit(*++type))
+      int len = atoi (type + 1);
+      while (isdigit ((unsigned char) *++type))
         ;
       return objc_read_array (stream, type, len, data);
@@ -1165 +1165 @@
   default:
     {
-      objc_error(nil, OBJC_ERR_BAD_TYPE,
-                 "objc_read_type: cannot parse typespec: %s\n", type);
+      objc_error (nil, OBJC_ERR_BAD_TYPE,
+                  "objc_read_type: cannot parse typespec: %s\n", type);
       return 0;
     }
@@ -1183 +1183 @@
 
 int 
-objc_write_types (TypedStream* stream, const char* type, ...)
+objc_write_types (TypedStream *stream, const char *type, ...)
 {
   va_list args;
@@ -1193 +1193 @@
   for (c = type; *c; c = objc_skip_typespec (c))
     {
-      switch(*c) {
+      switch (*c) {
       case _C_ID:
         res = objc_write_object (stream, *va_arg (args, id*));
@@ -1199 +1199 @@
 
       case _C_CLASS:
-        res = objc_write_class (stream, *va_arg(args, Class*));
+        res = objc_write_class (stream, *va_arg (args, Class*));
         break;
 
       case _C_SEL:
-        res = objc_write_selector (stream, *va_arg(args, SEL*));
+        res = objc_write_selector (stream, *va_arg (args, SEL*));
         break;
         
@@ -1216 +1216 @@
         
       case _C_SHT:
-        res = objc_write_short (stream, *va_arg(args, short*));
+        res = objc_write_short (stream, *va_arg (args, short*));
         break;
 
       case _C_USHT:
         res = objc_write_unsigned_short (stream,
-                                         *va_arg(args, unsigned short*));
+                                         *va_arg (args, unsigned short*));
         break;
 
       case _C_INT:
-        res = objc_write_int(stream, *va_arg(args, int*));
+        res = objc_write_int(stream, *va_arg (args, int*));
         break;
         
       case _C_UINT:
-        res = objc_write_unsigned_int(stream, *va_arg(args, unsigned int*));
+        res = objc_write_unsigned_int(stream, *va_arg (args, unsigned int*));
         break;
 
       case _C_LNG:
-        res = objc_write_long(stream, *va_arg(args, long*));
+        res = objc_write_long(stream, *va_arg (args, long*));
         break;
         
       case _C_ULNG:
-        res = objc_write_unsigned_long(stream, *va_arg(args, unsigned long*));
+        res = objc_write_unsigned_long(stream, *va_arg (args, unsigned long*));
         break;
 
       case _C_CHARPTR:
         {
-          char** str = va_arg(args, char**);
-          res = objc_write_string (stream, *str, strlen(*str));
+          char **str = va_arg (args, char **);
+          res = objc_write_string (stream, *str, strlen (*str));
         }
         break;
@@ -1249 +1249 @@
       case _C_ATOM:
         {
-          char** str = va_arg(args, char**);
-          res = objc_write_string_atomic (stream, *str, strlen(*str));
+          char **str = va_arg (args, char **);
+          res = objc_write_string_atomic (stream, *str, strlen (*str));
         }
         break;
@@ -1256 +1256 @@
       case _C_ARY_B:
         {
-          int len = atoi(c+1);
-          const char* t = c;
-          while (isdigit(*++t))
+          int len = atoi (c + 1);
+          const char *t = c;
+          while (isdigit ((unsigned char) *++t))
             ;
-          res = objc_write_array (stream, t, len, va_arg(args, void*));
+          res = objc_write_array (stream, t, len, va_arg (args, void *));
           t = objc_skip_typespec (t);
           if (*t != _C_ARY_E)
-            objc_error(nil, OBJC_ERR_BAD_TYPE, "expected `]', got: %s", t);
+            objc_error (nil, OBJC_ERR_BAD_TYPE, "expected `]', got: %s", t);
         }
         break; 
         
       default:
-        objc_error(nil, OBJC_ERR_BAD_TYPE, 
-                   "objc_write_types: cannot parse typespec: %s\n", type);
+        objc_error (nil, OBJC_ERR_BAD_TYPE, 
+                    "objc_write_types: cannot parse typespec: %s\n", type);
       }
     }
@@ -1283 +1283 @@
 
 int 
-objc_read_types(TypedStream* stream, const char* type, ...)
+objc_read_types(TypedStream *stream, const char *type, ...)
 {
   va_list args;
@@ -1289 +1289 @@
   int res = 0;
 
-  va_start(args, type);
+  va_start (args, type);
 
   for (c = type; *c; c = objc_skip_typespec(c))
     {
-      switch(*c) {
+      switch (*c) {
       case _C_ID:
-        res = objc_read_object(stream, va_arg(args, id*));
+        res = objc_read_object(stream, va_arg (args, id*));
         break;
 
       case _C_CLASS:
-        res = objc_read_class(stream, va_arg(args, Class*));
+        res = objc_read_class(stream, va_arg (args, Class*));
         break;
 
       case _C_SEL:
-        res = objc_read_selector(stream, va_arg(args, SEL*));
+        res = objc_read_selector(stream, va_arg (args, SEL*));
         break;
         
       case _C_CHR:
-        res = objc_read_char(stream, va_arg(args, char*));
+        res = objc_read_char(stream, va_arg (args, char*));
         break;
         
       case _C_UCHR:
-        res = objc_read_unsigned_char(stream, va_arg(args, unsigned char*));
+        res = objc_read_unsigned_char(stream, va_arg (args, unsigned char*));
         break;
         
       case _C_SHT:
-        res = objc_read_short(stream, va_arg(args, short*));
+        res = objc_read_short(stream, va_arg (args, short*));
         break;
 
       case _C_USHT:
-        res = objc_read_unsigned_short(stream, va_arg(args, unsigned short*));
+        res = objc_read_unsigned_short(stream, va_arg (args, unsigned short*));
         break;
 
       case _C_INT:
-        res = objc_read_int(stream, va_arg(args, int*));
+        res = objc_read_int(stream, va_arg (args, int*));
         break;
         
       case _C_UINT:
-        res = objc_read_unsigned_int(stream, va_arg(args, unsigned int*));
+        res = objc_read_unsigned_int(stream, va_arg (args, unsigned int*));
         break;
 
       case _C_LNG:
-        res = objc_read_long(stream, va_arg(args, long*));
+        res = objc_read_long(stream, va_arg (args, long*));
         break;
         
       case _C_ULNG:
-        res = objc_read_unsigned_long(stream, va_arg(args, unsigned long*));
+        res = objc_read_unsigned_long(stream, va_arg (args, unsigned long*));
         break;
 
@@ -1341 +1341 @@
       case _C_ATOM:
         {
-          char** str = va_arg(args, char**);
+          char **str = va_arg (args, char **);
           res = objc_read_string (stream, str);
         }
@@ -1348 +1348 @@
       case _C_ARY_B:
         {
-          int len = atoi(c+1);
-          const char* t = c;
-          while (isdigit(*++t))
+          int len = atoi (c + 1);
+          const char *t = c;
+          while (isdigit ((unsigned char) *++t))
             ;
-          res = objc_read_array (stream, t, len, va_arg(args, void*));
+          res = objc_read_array (stream, t, len, va_arg (args, void *));
           t = objc_skip_typespec (t);
           if (*t != _C_ARY_E)
-            objc_error(nil, OBJC_ERR_BAD_TYPE, "expected `]', got: %s", t);
+            objc_error (nil, OBJC_ERR_BAD_TYPE, "expected `]', got: %s", t);
         }
         break; 
         
       default:
-        objc_error(nil, OBJC_ERR_BAD_TYPE, 
-                   "objc_read_types: cannot parse typespec: %s\n", type);
+        objc_error (nil, OBJC_ERR_BAD_TYPE, 
+                    "objc_read_types: cannot parse typespec: %s\n", type);
       }
     }
-  va_end(args);
+  va_end (args);
   return res;
 }
@@ -1374 +1374 @@
 
 int
-objc_write_array (TypedStream* stream, const char* type,
-                  int count, const void* data)
+objc_write_array (TypedStream *stream, const char *type,
+                  int count, const void *data)
 {
   int off = objc_sizeof_type(type);
-  const char* where = data;
+  const char *where = data;
 
   while (count-- > 0)
@@ -1396 +1396 @@
 
 int
-objc_read_array (TypedStream* stream, const char* type,
-                 int count, void* data)
+objc_read_array (TypedStream *stream, const char *type,
+                 int count, void *data)
 {
   int off = objc_sizeof_type(type);
-  char* where = (char*)data;
+  char *where = (char*)data;
 
   while (count-- > 0)
@@ -1411 +1411 @@
 
 static int 
-__objc_fread(FILE* file, char* data, int len)
+__objc_fread (FILE *file, char *data, int len)
 {
   return fread(data, len, 1, file);
@@ -1417 +1417 @@
 
 static int 
-__objc_fwrite(FILE* file, char* data, int len)
+__objc_fwrite (FILE *file, char *data, int len)
 {
   return fwrite(data, len, 1, file);
@@ -1423 +1423 @@
 
 static int
-__objc_feof(FILE* file)
+__objc_feof (FILE *file)
 {
   return feof(file);
@@ -1429 +1429 @@
 
 static int 
-__objc_no_write(FILE* file, char* data, int len)
+__objc_no_write (FILE *file __attribute__ ((__unused__)),
+                 const char *data __attribute__ ((__unused__)),
+                 int len __attribute__ ((__unused__)))
 {
   objc_error (nil, OBJC_ERR_NO_WRITE, "TypedStream not open for writing");
@@ -1436 +1438 @@
 
 static int 
-__objc_no_read(FILE* file, char* data, int len)
+__objc_no_read (FILE *file __attribute__ ((__unused__)),
+                const char *data __attribute__ ((__unused__)),
+                int len __attribute__ ((__unused__)))
 {
   objc_error (nil, OBJC_ERR_NO_READ, "TypedStream not open for reading");
@@ -1443 +1447 @@
 
 static int
-__objc_read_typed_stream_signature (TypedStream* stream)
+__objc_read_typed_stream_signature (TypedStream *stream)
 {
   char buffer[80];
   int pos = 0;
   do
-    (*stream->read)(stream->physical, buffer+pos, 1);
+    (*stream->read) (stream->physical, buffer+pos, 1);
   while (buffer[pos++] != '\0')
     ;
@@ -1459 +1463 @@
 
 static int
-__objc_write_typed_stream_signature (TypedStream* stream)
+__objc_write_typed_stream_signature (TypedStream *stream)
 {
   char buffer[80];
   sprintf(buffer, "GNU TypedStream %d", OBJC_TYPED_STREAM_VERSION);
   stream->version = OBJC_TYPED_STREAM_VERSION;
-  (*stream->write)(stream->physical, buffer, strlen(buffer)+1);
+  (*stream->write) (stream->physical, buffer, strlen (buffer) + 1);
   return 1;
 }
 
-static void __objc_finish_write_root_object(struct objc_typed_stream* stream)
+static void __objc_finish_write_root_object(struct objc_typed_stream *stream)
 {
   hash_delete (stream->object_table);
@@ -1476 +1480 @@
 }
 
-static void __objc_finish_read_root_object(struct objc_typed_stream* stream)
+static void __objc_finish_read_root_object(struct objc_typed_stream *stream)
 {
   node_ptr node;
@@ -1488 +1492 @@
        node = hash_next (stream->object_refs, node))
     {
-      struct objc_list* reflist = node->value;
-      const void* key = node->key;
+      struct objc_list *reflist = node->value;
+      const void *key = node->key;
       id object = hash_value_for_key (stream->object_table, key);
-      while(reflist)
-        {
-          *((id*)reflist->head) = object;
+      while (reflist)
+        {
+          *((id*) reflist->head) = object;
           if (hash_value_for_key (free_list,reflist) == NULL)
             hash_add (&free_list,reflist,reflist);
@@ -1521 +1525 @@
           id object = node->value;
           if (__objc_responds_to (object, awake_sel))
-            (*objc_msg_lookup(object, awake_sel))(object, awake_sel);
+            (*objc_msg_lookup (object, awake_sel)) (object, awake_sel);
         }
     }
@@ -1536 +1540 @@
 */
 
-TypedStream* 
-objc_open_typed_stream (FILE* physical, int mode)
-{
-  TypedStream* s = (TypedStream*)objc_malloc(sizeof(TypedStream));
+TypedStream *
+objc_open_typed_stream (FILE *physical, int mode)
+{
+  TypedStream *s = (TypedStream *) objc_malloc (sizeof (TypedStream));
 
   s->mode = mode;
   s->physical = physical;
-  s->stream_table = hash_new(64,
-                             (hash_func_type)hash_ptr,
-                             (compare_func_type)compare_ptrs);
-  s->object_table = hash_new(64,
-                             (hash_func_type)hash_ptr,
-                             (compare_func_type)compare_ptrs);
-  s->eof = (objc_typed_eof_func)__objc_feof;
-  s->flush = (objc_typed_flush_func)fflush;
+  s->stream_table = hash_new (64,
+                              (hash_func_type) hash_ptr,
+                              (compare_func_type) compare_ptrs);
+  s->object_table = hash_new (64,
+                              (hash_func_type) hash_ptr,
+                              (compare_func_type) compare_ptrs);
+  s->eof = (objc_typed_eof_func) __objc_feof;
+  s->flush = (objc_typed_flush_func) fflush;
   s->writing_root_p = 0;
   if (mode == OBJC_READONLY)
     {
-      s->class_table = hash_new(8, (hash_func_type)hash_string,
-                                (compare_func_type)compare_strings);
-      s->object_refs = hash_new(8, (hash_func_type)hash_ptr,
-                                (compare_func_type)compare_ptrs);
-      s->read = (objc_typed_read_func)__objc_fread;
-      s->write = (objc_typed_write_func)__objc_no_write;
+      s->class_table = hash_new (8, (hash_func_type) hash_string,
+                                 (compare_func_type) compare_strings);
+      s->object_refs = hash_new (8, (hash_func_type) hash_ptr,
+                                 (compare_func_type) compare_ptrs);
+      s->read = (objc_typed_read_func) __objc_fread;
+      s->write = (objc_typed_write_func) __objc_no_write;
       __objc_read_typed_stream_signature (s);
     }
@@ -1566 +1570 @@
       s->class_table = 0;
       s->object_refs = 0;
-      s->read = (objc_typed_read_func)__objc_no_read;
-      s->write = (objc_typed_write_func)__objc_fwrite;
+      s->read = (objc_typed_read_func) __objc_no_read;
+      s->write = (objc_typed_write_func) __objc_fwrite;
       __objc_write_typed_stream_signature (s);
     }      
@@ -1584 +1588 @@
 
 TypedStream*
-objc_open_typed_stream_for_file (const char* file_name, int mode)
-{
-  FILE* file = NULL;
-  TypedStream* s;
+objc_open_typed_stream_for_file (const char *file_name, int mode)
+{
+  FILE *file = NULL;
+  TypedStream *s;
 
   if (mode == OBJC_READONLY)
@@ -1611 +1615 @@
 
 void
-objc_close_typed_stream (TypedStream* stream)
+objc_close_typed_stream (TypedStream *stream)
 {
   if (stream->mode == OBJC_READONLY)
@@ -1624 +1628 @@
 
   if (stream->type == (OBJC_MANAGED_STREAM | OBJC_FILE_STREAM))
-    fclose ((FILE*)stream->physical);
+    fclose ((FILE *)stream->physical);
 
   objc_free(stream);
@@ -1630 +1634 @@
 
 BOOL
-objc_end_of_typed_stream (TypedStream* stream)
-{
-  return (*stream->eof)(stream->physical);
+objc_end_of_typed_stream (TypedStream *stream)
+{
+  return (*stream->eof) (stream->physical);
 }
 
 void
-objc_flush_typed_stream (TypedStream* stream)
-{
-  (*stream->flush)(stream->physical);
+objc_flush_typed_stream (TypedStream *stream)
+{
+  (*stream->flush) (stream->physical);
 }
 
 long
-objc_get_stream_class_version (TypedStream* stream, Class class)
+objc_get_stream_class_version (TypedStream *stream, Class class)
 {
   if (stream->class_table)

@@ -26 +26 @@
 configure.vr
 configure.vrs
+dir.info
 Makefile
-dir.info
 lost+found
 update.out