Changeset 1391 for branches/GNU/src/gcc/libobjc

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/ChangeLog (modified) (11 diffs, 1 prop)
• libobjc/Makefile.in (modified) (2 diffs, 1 prop)
• libobjc/Object.m (modified) (5 diffs, 1 prop)
• libobjc/Protocol.m (modified) (3 diffs, 1 prop)
• libobjc/aclocal.m4 (modified) (1 diff, 1 prop)
• libobjc/archive.c (modified) (103 diffs, 1 prop)
• libobjc/class.c (modified) (20 diffs, 1 prop)
• libobjc/configure (modified) (45 diffs, 1 prop)
• libobjc/configure.in (modified) (2 diffs, 1 prop)
• libobjc/encoding.c (modified) (40 diffs, 1 prop)
• libobjc/gc.c (modified) (17 diffs, 1 prop)
• libobjc/hash.c (modified) (4 diffs, 1 prop)
• libobjc/init.c (modified) (55 diffs, 1 prop)
• libobjc/misc.c (modified) (7 diffs, 1 prop)
• libobjc/nil_method.c (modified) (2 diffs, 1 prop)
• libobjc/objc/encoding.h (modified) (2 diffs, 1 prop)
• libobjc/objc/hash.h (modified) (5 diffs, 1 prop)
• libobjc/objc/objc.h (modified) (1 diff, 1 prop)
• libobjc/objc/runtime.h (modified) (3 diffs, 1 prop)
• libobjc/objc/thr.h (modified) (3 diffs, 1 prop)
• libobjc/objects.c (modified) (3 diffs, 1 prop)
• libobjc/sarray.c (modified) (26 diffs, 1 prop)
• libobjc/selector.c (modified) (28 diffs, 1 prop)
• libobjc/sendmsg.c (modified) (33 diffs, 1 prop)
• libobjc/thr-mach.c (modified) (24 diffs, 1 prop)
• libobjc/thr.c (modified) (32 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/ChangeLog

@@ -1 @@
-2003-02-05  Release Manager
-
-        * GCC 3.2.2 Released.
-
-2003-01-28  Christian Cornelssen  <ccorn@cs.tu-berlin.de>
+2004-02-14  Release Manager
+
+        * GCC 3.3.3 Released.
+
+2003-12-01  Zack Weinberg  <zack@codesourcery.com>
+
+        PR 11433
+        * Protocol.m (descriptionForInstanceMethod): Don't dereference
+        instance_methods if it's NULL.
+        (descriptionForClassMethod): Likewise for class_methods.
+
+2003-10-16  Release Manager
+
+        * GCC 3.3.2 Released.
+
+2003-09-09  Alan Modra  <amodra@bigpond.net.au>
+
+        * configure: Regenerate.
+
+2003-08-04  Release Manager
+
+        * GCC 3.3.1 Released.
+
+2003-08-04  Release Manager
+
+        * GCC 3.3.1 Released.
+
+2003-05-13  Release Manager
+
+        * GCC 3.3 Released.
+
+2003-05-13  Release Manager
+
+        * GCC 3.3 Released.
+
+2003-05-13  Release Manager
+
+        * GCC 3.3 Released.
+
+2003-02-20  Alexandre Oliva  <aoliva@redhat.com>
+
+        * configure.in: Propagate ORIGINAL_LD_FOR_MULTILIBS to
+        config.status.
+        * configure: Rebuilt.
+
+2003-01-27  Alexandre Oliva  <aoliva@redhat.com>
+
+        * aclocal.m4 (glibcpp_toolexeclibdir): Instead of
+        $(MULTISUBDIR), use `$CC -print-multi-os-directory`, unless
+        version_specific_libs is enabled.
+        * configure: Rebuilt.
+
+2003-01-26  Christian Cornelssen  <ccorn@cs.tu-berlin.de>
 
         * Makefile.in (FLAGS_TO_PASS): Also pass DESTDIR.
@@ -9 +57 @@
         destination paths in all (un)installation commands.
 
-2003-01-27  Alexandre Oliva  <aoliva@redhat.com>
-
-        * aclocal.m4 (glibcpp_toolexeclibdir): Instead of
-        $(MULTISUBDIR), use `$CC -print-multi-os-directory`, unless
-        version_specific_libs is enabled.
-        * configure: Rebuilt.
-
-2002-11-19  Release Manager
-
-        * GCC 3.2.1 Released.
-
-2002-11-19  Release Manager
-
-        * GCC 3.2.1 Released.
-
-2002-11-18  Release Manager
-
-        * GCC 3.2.1 Released.
-
-2002-10-07  Kaveh R. Ghazi  <ghazi@caip.rutgers.edu>
+2002-09-22  Kaveh R. Ghazi  <ghazi@caip.rutgers.edu>
 
         * Makefile.in (all): Fix multilib parallel build.
 
-2002-08-14  Release Manager
-
-        * GCC 3.2 Released.
-
-2002-07-25  Release Manager
-
-        * GCC 3.1.1 Released.
+Thu Sep 12 12:44:37 2002  Nicola Pero  <n.pero@mi.flashnet.it>
+
+        * sendmsg.c (nil_method): Declare not to take a variable number of
+        args.
+        (objc_msg_lookup): Cast nil_method to IMP before returning it.
+        (objc_msg_lookup_super): The same.
+
+2002-09-10  Jan Hubicka  <jh@suse.cz>
+
+        * nil_method.c (nil_method): No longer defined with variable
+        arguments.
+
+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.
 
 2002-06-25  DJ Delorie  <dj@redhat.com>
@@ -47 +102 @@
         * configure: Regenerate.
 
-2002-05-14  Release Manager
-
-        * GCC 3.1 Released.
-
-2002-05-14  Release Manager
-
-        * GCC 3.1 Released.
+2002-06-21  Kaveh R. Ghazi  <ghazi@caip.rutgers.edu>
+
+        * Object.m (forward, read, write): Fix unused parameter warnings.
+        * encoding.c: Include <stdlib.h>.
+        (target_flags): Mark with attribute unused.
+        (atoi): Delete.
+        * runtime.h (__objc_selector_max_index): Change to unsigned int.
+        (__objc_generate_gc_type_description): Prototype.
+        * selector.c (__objc_selector_max_index): Change to unsigned int.
+
+Mon Jun 17 18:37:42 2002  Nicola Pero  <n.pero@mi.flashnet.it>
+
+        * sendmsg.c (__objc_get_forward_imp): Fix warning by making sure
+        we always have a return value: if __objc_msg_forward does not
+        supply a forwarding implementation, return the default
+        __builtin_apply based one.
+
+2002-06-15  Kaveh R. Ghazi  <ghazi@caip.rutgers.edu>
+
+        * Object.m: Fix signed/unsigned warning.
+        * Protocol.m: Likewise.
+        * archive.c: Always include stdlib.h.
+        (objc_read_short, objc_read_unsigned_short, objc_read_int,
+        objc_read_long, __objc_read_nbyte_uint, __objc_read_nbyte_ulong):
+        Fix signed/unsigned warning.
+        (objc_write_type, objc_read_type, objc_write_types,
+        objc_read_types): Ensure ctype 8-bit safety.
+        (__objc_no_write, __objc_no_read): Mark unused parameters.
+        * class.c (class_table_setup): Specify void arg.
+        * encoding.c (atoi, objc_sizeof_type, objc_alignof_type,
+        objc_skip_typespec, objc_skip_offset,
+        objc_layout_structure_next_member): Ensure ctype 8-bit safety.
+        (objc_layout_structure_next_member): Ensure variables are
+        initialized.
+        * gc.c (__objc_generate_gc_type_description,
+        class_ivar_set_gcinvisible): Mark unused parameters.
+        * init.c (__objc_send_load, __objc_destroy_class_tree_node): Mark
+        unused parameters.
+        (__objc_init_protocols) Fix signed/unsigned warning.
+        * nil_method.c (nil_method): Mark unused parameters.
+        * thr.h (objc_thread_callback): Specify void arg.
+        * sarray.c (sarray_new, sarray_realloc, sarray_free): Fix
+        signed/unsigned warning.
+        (sarray_free): Fix formatting.
+        * selector.c (sel_types_match): Ensure ctype 8-bit safety.
+        * sendmsg.c (__objc_init_install_dtable) Mark unused parameters.
+
+2002-06-09  Andreas Jaeger  <aj@suse.de>
+
+        * encoding.c (objc_layout_structure_next_member): Remove unused
+        variable.
+
+2002-05-20  Kaveh R. Ghazi  <ghazi@caip.rutgers.edu>
+
+        * Makefile.in (SHELL): Set to @SHELL@.
+        (WARN_CFLAGS): New.
+        (ALL_CFLAGS): Add $(WARN_CFLAGS).
+
+2002-05-16  Rainer Orth  <ro@TechFak.Uni-Bielefeld.DE>
+
+        * aclocal.m4: Allow for PWDCMD to override hardcoded pwd.
+        * configure: Regenerate.
 
 2002-05-08  Alexandre Oliva  <aoliva@redhat.com>
@@ -90 +200 @@
 2001-11-14  Aldy Hernandez  <aldyh@redhat.com>
 
-        * encoding.c: Add target_flags.
+        * encoding.c: Add target_flags.
 
 2001-11-07  Aldy Hernandez  <aldyh@redhat.com>
@@ -101 +211 @@
 
         * class.c: Rewritten the class table to use optimized, lock-free
-        lookup.  This more than doubles the speed of class method
-        invocations.  (class_table_setup), (class_table_insert),
-        (class_table_replace), (class_table_get_safe),
-        (class_table_next), (class_table_print),
-        (class_table_print_histogram): New functions.
-        (__objc_init_class_tables): Use class_table_setup.
-        (__objc_add_class_to_hash): Use class_table_get_safe and
-        class_table_insert.  (objc_lookup_class), (objc_get_class): Do not
-        assert the existence of the table; do not lock the runtime; use
-        class_table_get_safe.  (objc_next_class): Use class_table_next.
-        (__objc_resolve_class_links): Use class_table_next.
-        (class_pose_as): Use class_table_replace.
+        lookup.  This more than doubles the speed of class method
+        invocations.  (class_table_setup), (class_table_insert),
+        (class_table_replace), (class_table_get_safe),
+        (class_table_next), (class_table_print),
+        (class_table_print_histogram): New functions.
+        (__objc_init_class_tables): Use class_table_setup.
+        (__objc_add_class_to_hash): Use class_table_get_safe and
+        class_table_insert.  (objc_lookup_class), (objc_get_class): Do not
+        assert the existence of the table; do not lock the runtime; use
+        class_table_get_safe.  (objc_next_class): Use class_table_next.
+        (__objc_resolve_class_links): Use class_table_next.
+        (class_pose_as): Use class_table_replace.
 
 2001-09-10  Ovidiu Predescu  <ovidiu@cup.hp.com>
@@ -227 +337 @@
         friends have on various platforms. (Solution suggested by Helge
         Hess.)
-        
+
         * objc/objc-api.h: Define __objc_msg_forward.
 
@@ -234 +344 @@
 2000-12-06      Ralf Corsepius <corsepiu@faw.uni-ulm.de>
 
-        * thr-rtems.c: New file. Stub to compile. 
+        * thr-rtems.c: New file. Stub to compile.
 
 2000-09-06  Alexandre Oliva  <aoliva@redhat.com>
@@ -276 +386 @@
 Fri Jul 28 08:58:02 2000  Nicola Pero  <nicola@brainstorm.co.uk>
 
-        * configure.in: Added libtool support; build shared libraries 
+        * configure.in: Added libtool support; build shared libraries
         if --enable-shared was passed on command line.
         * Makefile.in: Modified most compilation commands to use libtool.
@@ -337 +447 @@
         * Makefile.in (gc.o, gc_gc.o): Do not pass -fgnu-runtime to
         the compiler when building C code.
-        
+
 Fri Aug  6 23:32:29 1999  Daniel Jacobowitz <drow@drow.them.org>
 
@@ -416 +526 @@
 
         * encoding.c: Redefine get_inner_array_type to get the first entry
-        in the structure.
+        in the structure.
 
 Thu Oct  8 12:21:14 1998  Richard Frith-Macdonald <richard@brainstorm.co.uk>
@@ -481 +591 @@
 
         * New directory.  Moved files from ../gcc/objc.
-

branches/GNU/src/gcc/libobjc/Makefile.in

@@ -23 +23 @@
 #worthless.
 
-SHELL = /bin/sh
+SHELL = @SHELL@
 MAKEOVERRIDES=
 
@@ -68 +68 @@
 CC = @CC@
 CFLAGS = @CFLAGS@
+WARN_CFLAGS = -W -Wall -Wwrite-strings -Wstrict-prototypes
 GTHREAD_FLAGS=@GTHREAD_FLAGS@
-ALL_CFLAGS = -I. -I$(srcdir) $(CPPFLAGS) $(DEFS) $(CFLAGS) \
+ALL_CFLAGS = -I. -I$(srcdir) $(CPPFLAGS) $(DEFS) $(CFLAGS) $(WARN_CFLAGS) \
         $(GTHREAD_FLAGS) -DIN_GCC -DIN_TARGET_LIBS
 

branches/GNU/src/gcc/libobjc/Object.m

@@ -1 +1 @@
 /* The implementation of class Object for Objective-C.
-   Copyright (C) 1993, 1994, 1995, 1997 Free Software Foundation, Inc.
+   Copyright (C) 1993, 1994, 1995, 1997, 2002 Free Software Foundation, Inc.
 
 This file is part of GNU CC.
@@ -200 +200 @@
 + (BOOL) conformsTo: (Protocol*)aProtocol
 {
-  int i;
+  size_t i;
   struct objc_protocol_list* proto_list;
   id parent;
@@ -272 +272 @@
 - (retval_t)forward:(SEL)aSel :(arglist_t)argFrame
 {
+  (void) argFrame; /* UNUSED */
   return (retval_t)[self doesNotRecognize: aSel];
 }
@@ -365 +366 @@
 - read: (TypedStream*)aStream
 {
+  (void) aStream; /* UNUSED */
   // [super read: aStream];  
   return self;
@@ -371 +373 @@
 - write: (TypedStream*)aStream
 {
+  (void) aStream; /* UNUSED */
   // [super write: aStream];
   return self;

branches/GNU/src/gcc/libobjc/Protocol.m

@@ -54 +54 @@
 - (BOOL) conformsTo: (Protocol *)aProtocolObject
 {
-  int i;
+  size_t i;
   struct objc_protocol_list* proto_list;
 
@@ -81 +81 @@
   struct objc_method_description *result;
 
-  for (i = 0; i < instance_methods->count; i++)
-    {
-      if (!strcmp ((char*)instance_methods->list[i].name, name))
-        return &(instance_methods->list[i]);
-    }
+  if (instance_methods)
+    for (i = 0; i < instance_methods->count; i++)
+      {
+        if (!strcmp ((char*)instance_methods->list[i].name, name))
+          return &(instance_methods->list[i]);
+      }
 
   for (proto_list = protocol_list; proto_list; proto_list = proto_list->next)
     {
-      for (i=0; i < proto_list->count; i++)
+      size_t j;
+      for (j=0; j < proto_list->count; j++)
         {
-          if ((result = [proto_list->list[i]
+          if ((result = [proto_list->list[j]
                          descriptionForInstanceMethod: aSel]))
             return result;
@@ -107 +109 @@
   struct objc_method_description *result;
 
-  for (i = 0; i < class_methods->count; i++)
-    {
-      if (!strcmp ((char*)class_methods->list[i].name, name))
-        return &(class_methods->list[i]);
-    }
+  if (class_methods)
+    for (i = 0; i < class_methods->count; i++)
+      {
+        if (!strcmp ((char*)class_methods->list[i].name, name))
+          return &(class_methods->list[i]);
+      }
 
   for (proto_list = protocol_list; proto_list; proto_list = proto_list->next)
     {
-      for (i=0; i < proto_list->count; i++)
+      size_t j;
+      for (j=0; j < proto_list->count; j++)
         {
-          if ((result = [proto_list->list[i]
+          if ((result = [proto_list->list[j]
                          descriptionForClassMethod: aSel]))
             return result;

branches/GNU/src/gcc/libobjc/aclocal.m4

@@ -55 +55 @@
 # canonicalize only relative paths, because then amd will not unmount
 # drives. Thus the use of PWDCMD: set it to 'pawd' or 'amq -w' if using amd.
-glibcpp_builddir=`pwd`
+glibcpp_builddir=`${PWDCMD-pwd}`
 case $srcdir in
 [\\/$]* | ?:[\\/]*) glibcpp_srcdir=${srcdir} ;;

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)

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

@@ -1 +1 @@
 /* GNU Objective C Runtime class related functions
-   Copyright (C) 1993, 1995, 1996, 1997, 2001 Free Software Foundation, Inc.
+   Copyright (C) 1993, 1995, 1996, 1997, 2001, 2002
+     Free Software Foundation, Inc.
    Contributed by Kresten Krab Thorup and Dennis Glatting.
 
@@ -164 +165 @@
 /* Setup the table.  */
 static void
-class_table_setup ()
+class_table_setup (void)
 {
   /* Start - nothing in the table.  */
-  memset (class_table_array, 0, sizeof(class_node_ptr) * CLASS_TABLE_SIZE);
+  memset (class_table_array, 0, sizeof (class_node_ptr) * CLASS_TABLE_SIZE);
 
   /* The table writing mutex.  */
@@ -340 +341 @@
 /* Debugging function - print the class table.  */
 void
-class_table_print ()
+class_table_print (void)
 {
   int i;
@@ -363 +364 @@
    in real cases.  */
 void
-class_table_print_histogram ()
+class_table_print_histogram (void)
 {
   int i, j;
@@ -409 +410 @@
    objc_lookup_class if the runtime is not able to find the class.  
    This may e.g. try to load in the class using dynamic loading.  */
-Class (*_objc_lookup_class)(const char* name) = 0;      /* !T:SAFE */
+Class (*_objc_lookup_class) (const char *name) = 0;      /* !T:SAFE */
 
 
@@ -416 +417 @@
 
 
-void __objc_init_class_tables()
+void
+__objc_init_class_tables (void)
 {
   /* Allocate the class hash table.  */
   
-  if(__class_table_lock)
+  if (__class_table_lock)
     return;
   
-  objc_mutex_lock(__objc_runtime_mutex);
+  objc_mutex_lock (__objc_runtime_mutex);
   
   class_table_setup ();
 
-  objc_mutex_unlock(__objc_runtime_mutex);
+  objc_mutex_unlock (__objc_runtime_mutex);
 }  
 
@@ -433 +435 @@
    class a number, unless it's already known.  */
 void
-__objc_add_class_to_hash(Class class)
+__objc_add_class_to_hash (Class class)
 {
   Class h_class;
 
-  objc_mutex_lock(__objc_runtime_mutex);
+  objc_mutex_lock (__objc_runtime_mutex);
 
   /* Make sure the table is there.  */
-  assert(__class_table_lock);
+  assert (__class_table_lock);
 
   /* Make sure it's not a meta class.  */
-  assert(CLS_ISCLASS(class));
+  assert (CLS_ISCLASS (class));
 
   /* Check to see if the class is already in the hash table.  */
   h_class = class_table_get_safe (class->name);
-  if (!h_class)
+  if (! h_class)
     {
       /* The class isn't in the hash table.  Add the class and assign a class
@@ -453 +455 @@
       static unsigned int class_number = 1;
 
-      CLS_SETNUMBER(class, class_number);
-      CLS_SETNUMBER(class->class_pointer, class_number);
+      CLS_SETNUMBER (class, class_number);
+      CLS_SETNUMBER (class->class_pointer, class_number);
 
       ++class_number;
@@ -460 +462 @@
     }
 
-  objc_mutex_unlock(__objc_runtime_mutex);
+  objc_mutex_unlock (__objc_runtime_mutex);
 }
 
@@ -466 +468 @@
    identify a known class, the hook _objc_lookup_class is called.  If
    this fails, nil is returned.  */
-Class objc_lookup_class (const char* name)
+Class
+objc_lookup_class (const char *name)
 {
   Class class;
@@ -476 +479 @@
 
   if (_objc_lookup_class)
-    return (*_objc_lookup_class)(name);
+    return (*_objc_lookup_class) (name);
   else
     return 0;
@@ -495 +498 @@
 
   if (_objc_lookup_class)
-    class = (*_objc_lookup_class)(name);
-
-  if(class)
+    class = (*_objc_lookup_class) (name);
+
+  if (class)
     return class;
   
-  objc_error(nil, OBJC_ERR_BAD_CLASS, 
-             "objc runtime: cannot find class %s\n", name);
+  objc_error (nil, OBJC_ERR_BAD_CLASS, 
+              "objc runtime: cannot find class %s\n", name);
   return 0;
 }
 
 MetaClass
-objc_get_meta_class(const char *name)
-{
-  return objc_get_class(name)->class_pointer;
+objc_get_meta_class (const char *name)
+{
+  return objc_get_class (name)->class_pointer;
 }
 
@@ -517 +520 @@
        id class; 
        void *es = NULL;
-       while ((class = objc_next_class(&es)))
+       while ((class = objc_next_class (&es)))
          ... do something with class; 
 */
 Class
-objc_next_class(void **enum_state)
+objc_next_class (void **enum_state)
 {
   Class class;
 
-  objc_mutex_lock(__objc_runtime_mutex);
+  objc_mutex_lock (__objc_runtime_mutex);
   
   /* Make sure the table is there.  */
-  assert(__class_table_lock);
-
-  class = class_table_next ((struct class_table_enumerator **)enum_state);
-
-  objc_mutex_unlock(__objc_runtime_mutex);
+  assert (__class_table_lock);
+
+  class = class_table_next ((struct class_table_enumerator **) enum_state);
+
+  objc_mutex_unlock (__objc_runtime_mutex);
   
   return class;
@@ -540 +543 @@
    can be sure of is that the class_pointer for class objects point to
    the right meta class objects.  */
-void __objc_resolve_class_links()
+void
+__objc_resolve_class_links (void)
 {
   struct class_table_enumerator *es = NULL;
@@ -546 +550 @@
   Class class1;
 
-  assert(object_class);
-
-  objc_mutex_lock(__objc_runtime_mutex);
+  assert (object_class);
+
+  objc_mutex_lock (__objc_runtime_mutex);
 
   /* Assign subclass links.  */
@@ -554 +558 @@
     {
       /* Make sure we have what we think we have.  */
-      assert (CLS_ISCLASS(class1));
-      assert (CLS_ISMETA(class1->class_pointer));
+      assert (CLS_ISCLASS (class1));
+      assert (CLS_ISMETA (class1->class_pointer));
 
       /* The class_pointer of all meta classes point to Object's meta
@@ -561 +565 @@
       class1->class_pointer->class_pointer = object_class->class_pointer;
 
-      if (!(CLS_ISRESOLV(class1)))
-        {
-          CLS_SETRESOLV(class1);
-          CLS_SETRESOLV(class1->class_pointer);
+      if (! CLS_ISRESOLV (class1))
+        {
+          CLS_SETRESOLV (class1);
+          CLS_SETRESOLV (class1->class_pointer);
               
-          if(class1->super_class)
+          if (class1->super_class)
             {   
               Class a_super_class 
@@ -608 +612 @@
         {
           sub_class->super_class = class1;
-          if(CLS_ISCLASS(sub_class))
+          if (CLS_ISCLASS (sub_class))
             sub_class->class_pointer->super_class = class1->class_pointer;
         }
     }
 
-  objc_mutex_unlock(__objc_runtime_mutex);
+  objc_mutex_unlock (__objc_runtime_mutex);
 }
 
@@ -623 +627 @@
 class_pose_as (Class impostor, Class super_class)
 {
-  if (!CLS_ISRESOLV (impostor))
+  if (! CLS_ISRESOLV (impostor))
     __objc_resolve_class_links ();
 
@@ -686 +690 @@
      into impostor.  */
 
-  objc_mutex_lock(__objc_runtime_mutex);
+  objc_mutex_lock (__objc_runtime_mutex);
 
   class_table_replace (super_class, impostor);
 
-  objc_mutex_unlock(__objc_runtime_mutex);
+  objc_mutex_unlock (__objc_runtime_mutex);
 
   /* Next, we update the dispatch tables...  */

branches/GNU/src/gcc/libobjc/configure

@@ -773 +773 @@
 # canonicalize only relative paths, because then amd will not unmount
 # drives. Thus the use of PWDCMD: set it to 'pawd' or 'amq -w' if using amd.
-glibcpp_builddir=`pwd`
+glibcpp_builddir=`${PWDCMD-pwd}`
 case $srcdir in
 \\/$* | ?:\\/*) glibcpp_srcdir=${srcdir} ;;
@@ -1605 +1605 @@
 
 hpux10.20*|hpux11*)
-  lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9].[0-9]) shared library'
-  lt_cv_file_magic_cmd=/usr/bin/file
-  lt_cv_file_magic_test_file=/usr/lib/libc.sl
+  case $host_cpu in
+  hppa*)
+    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9].[0-9]) shared library'
+    lt_cv_file_magic_cmd=/usr/bin/file
+    lt_cv_file_magic_test_file=/usr/lib/libc.sl
+    ;;
+  ia64*)
+    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - IA64'
+    lt_cv_file_magic_cmd=/usr/bin/file
+    lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
+    ;;
+  esac
   ;;
 
@@ -1697 +1706 @@
 
 echo $ac_n "checking for object suffix""... $ac_c" 1>&6
-echo "configure:1700: checking for object suffix" >&5
+echo "configure:1709: checking for object suffix" >&5
 if eval "test \"`echo '$''{'ac_cv_objext'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -1703 +1712 @@
   rm -f conftest*
 echo 'int i = 1;' > conftest.$ac_ext
-if { (eval echo configure:1706: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:1715: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
   for ac_file in conftest.*; do
     case $ac_file in
@@ -1727 +1736 @@
   if test "$file_magic_cmd" = '$MAGIC_CMD'; then
     echo $ac_n "checking for ${ac_tool_prefix}file""... $ac_c" 1>&6
-echo "configure:1730: checking for ${ac_tool_prefix}file" >&5
+echo "configure:1739: checking for ${ac_tool_prefix}file" >&5
 if eval "test \"`echo '$''{'lt_cv_path_MAGIC_CMD'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -1789 +1798 @@
   if test -n "$ac_tool_prefix"; then
     echo $ac_n "checking for file""... $ac_c" 1>&6
-echo "configure:1792: checking for file" >&5
+echo "configure:1801: checking for file" >&5
 if eval "test \"`echo '$''{'lt_cv_path_MAGIC_CMD'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -1860 +1869 @@
 set dummy ${ac_tool_prefix}ranlib; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1863: checking for $ac_word" >&5
+echo "configure:1872: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -1892 +1901 @@
 set dummy ranlib; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1895: checking for $ac_word" >&5
+echo "configure:1904: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -1927 +1936 @@
 set dummy ${ac_tool_prefix}strip; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1930: checking for $ac_word" >&5
+echo "configure:1939: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_STRIP'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -1959 +1968 @@
 set dummy strip; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:1962: checking for $ac_word" >&5
+echo "configure:1971: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_STRIP'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -2026 +2035 @@
 *-*-irix6*)
   # Find out which ABI we are using.
-  echo '#line 2029 "configure"' > conftest.$ac_ext
-  if { (eval echo configure:2030: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+  echo '#line 2038 "configure"' > conftest.$ac_ext
+  if { (eval echo configure:2039: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+   if test "$lt_cv_prog_gnu_ld" = yes; then
+    case `/usr/bin/file conftest.$ac_objext` in
+    *32-bit*)
+      LD="${LD-ld} -melf32bsmip"
+      ;;
+    *N32*)
+      LD="${LD-ld} -melf32bmipn32"
+      ;;
+    *64-bit*)
+      LD="${LD-ld} -melf64bmip"
+      ;;
+    esac
+   else
     case `/usr/bin/file conftest.$ac_objext` in
     *32-bit*)
@@ -2039 +2061 @@
       ;;
     esac
+   fi
+  fi
+  rm -rf conftest*
+  ;;
+
+ia64-*-hpux*)
+  # Find out which ABI we are using.
+  echo 'int i;' > conftest.$ac_ext
+  if { (eval echo configure:2072: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+    case "`/usr/bin/file conftest.o`" in
+    *ELF-32*)
+      HPUX_IA64_MODE="32"
+      ;;
+    *ELF-64*)
+      HPUX_IA64_MODE="64"
+      ;;
+    esac
+  fi
+  rm -rf conftest*
+  ;;
+
+x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*|s390*-*linux*|sparc*-*linux*)
+  # Find out which ABI we are using.
+  echo 'int i;' > conftest.$ac_ext
+  if { (eval echo configure:2088: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+    case "`/usr/bin/file conftest.o`" in
+    *32-bit*)
+      case $host in
+        x86_64-*linux*)
+          LD="${LD-ld} -m elf_i386"
+          ;;
+        ppc64-*linux*|powerpc64-*linux*)
+          LD="${LD-ld} -m elf32ppclinux"
+          ;;
+        s390x-*linux*)
+          LD="${LD-ld} -m elf_s390"
+          ;;
+        sparc64-*linux*)
+          LD="${LD-ld} -m elf32_sparc"
+          ;;
+      esac
+      ;;
+    *64-bit*)
+      case $host in
+        x86_64-*linux*)
+          LD="${LD-ld} -m elf_x86_64"
+          ;;
+        ppc*-*linux*|powerpc*-*linux*)
+          LD="${LD-ld} -m elf64ppc"
+          ;;
+        s390*-*linux*)
+          LD="${LD-ld} -m elf64_s390"
+          ;;
+        sparc*-*linux*)
+          LD="${LD-ld} -m elf64_sparc"
+          ;;
+      esac
+      ;;
+    esac
   fi
   rm -rf conftest*
@@ -2048 +2129 @@
   CFLAGS="$CFLAGS -belf"
   echo $ac_n "checking whether the C compiler needs -belf""... $ac_c" 1>&6
-echo "configure:2051: checking whether the C compiler needs -belf" >&5
+echo "configure:2132: checking whether the C compiler needs -belf" >&5
 if eval "test \"`echo '$''{'lt_cv_cc_needs_belf'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -2061 +2142 @@
 
      cat > conftest.$ac_ext <<EOF
-#line 2064 "configure"
+#line 2145 "configure"
 #include "confdefs.h"
 
@@ -2068 +2149 @@
 ; return 0; }
 EOF
-if { (eval echo configure:2071: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2152: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   lt_cv_cc_needs_belf=yes
@@ -2098 +2179 @@
 set dummy ${ac_tool_prefix}dlltool; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2101: checking for $ac_word" >&5
+echo "configure:2182: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_DLLTOOL'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -2130 +2211 @@
 set dummy dlltool; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2133: checking for $ac_word" >&5
+echo "configure:2214: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_DLLTOOL'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -2165 +2246 @@
 set dummy ${ac_tool_prefix}as; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2168: checking for $ac_word" >&5
+echo "configure:2249: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_AS'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -2197 +2278 @@
 set dummy as; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2200: checking for $ac_word" >&5
+echo "configure:2281: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_AS'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -2232 +2313 @@
 set dummy ${ac_tool_prefix}objdump; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2235: checking for $ac_word" >&5
+echo "configure:2316: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_OBJDUMP'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -2264 +2345 @@
 set dummy objdump; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2267: checking for $ac_word" >&5
+echo "configure:2348: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_OBJDUMP'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -2300 +2381 @@
   # can override, but on older systems we have to supply one
   echo $ac_n "checking if libtool should supply DllMain function""... $ac_c" 1>&6
-echo "configure:2303: checking if libtool should supply DllMain function" >&5
+echo "configure:2384: checking if libtool should supply DllMain function" >&5
 if eval "test \"`echo '$''{'lt_cv_need_dllmain'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2308 "configure"
+#line 2389 "configure"
 #include "confdefs.h"
 
@@ -2313 +2394 @@
 ; return 0; }
 EOF
-if { (eval echo configure:2316: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2397: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   lt_cv_need_dllmain=no
@@ -2334 +2415 @@
     CFLAGS="$CFLAGS -mdll"
     echo $ac_n "checking how to link DLLs""... $ac_c" 1>&6
-echo "configure:2337: checking how to link DLLs" >&5
+echo "configure:2418: checking how to link DLLs" >&5
 if eval "test \"`echo '$''{'lt_cv_cc_dll_switch'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2342 "configure"
+#line 2423 "configure"
 #include "confdefs.h"
 
@@ -2346 +2427 @@
 ; return 0; }
 EOF
-if { (eval echo configure:2349: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:2430: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
   rm -rf conftest*
   lt_cv_cc_dll_switch=-mdll
@@ -2464 +2545 @@
 set dummy ranlib; ac_word=$2
 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:2467: checking for $ac_word" >&5
+echo "configure:2548: checking for $ac_word" >&5
 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -2504 +2585 @@
 # ./install, which can be erroneously created by make from ./install.sh.
 echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6
-echo "configure:2507: checking for a BSD compatible install" >&5
+echo "configure:2588: checking for a BSD compatible install" >&5
 if test -z "$INSTALL"; then
 if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then
@@ -2557 +2638 @@
 
 echo $ac_n "checking whether ${MAKE-make} sets \${MAKE}""... $ac_c" 1>&6
-echo "configure:2560: checking whether ${MAKE-make} sets \${MAKE}" >&5
+echo "configure:2641: checking whether ${MAKE-make} sets \${MAKE}" >&5
 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y%./+-%__p_%'`
 if eval "test \"`echo '$''{'ac_cv_prog_make_${ac_make}_set'+set}'`\" = set"; then
@@ -2586 +2667 @@
 # Sanity check for the cross-compilation case:
 echo $ac_n "checking how to run the C preprocessor""... $ac_c" 1>&6
-echo "configure:2589: checking how to run the C preprocessor" >&5
+echo "configure:2670: checking how to run the C preprocessor" >&5
 # On Suns, sometimes $CPP names a directory.
 if test -n "$CPP" && test -d "$CPP"; then
@@ -2601 +2682 @@
   # not just through cpp.
   cat > conftest.$ac_ext <<EOF
-#line 2604 "configure"
+#line 2685 "configure"
 #include "confdefs.h"
 #include <assert.h>
@@ -2607 +2688 @@
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2610: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2691: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
@@ -2618 +2699 @@
   CPP="${CC-cc} -E -traditional-cpp"
   cat > conftest.$ac_ext <<EOF
-#line 2621 "configure"
+#line 2702 "configure"
 #include "confdefs.h"
 #include <assert.h>
@@ -2624 +2705 @@
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2627: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2708: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
@@ -2635 +2716 @@
   CPP="${CC-cc} -nologo -E"
   cat > conftest.$ac_ext <<EOF
-#line 2638 "configure"
+#line 2719 "configure"
 #include "confdefs.h"
 #include <assert.h>
@@ -2641 +2722 @@
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2644: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2725: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
@@ -2667 +2748 @@
 ac_safe=`echo "stdio.h" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for stdio.h""... $ac_c" 1>&6
-echo "configure:2670: checking for stdio.h" >&5
+echo "configure:2751: checking for stdio.h" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2675 "configure"
+#line 2756 "configure"
 #include "confdefs.h"
 #include <stdio.h>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2680: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2761: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
@@ -2705 +2786 @@
 
 echo $ac_n "checking for ANSI C header files""... $ac_c" 1>&6
-echo "configure:2708: checking for ANSI C header files" >&5
+echo "configure:2789: checking for ANSI C header files" >&5
 if eval "test \"`echo '$''{'ac_cv_header_stdc'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2713 "configure"
+#line 2794 "configure"
 #include "confdefs.h"
 #include <stdlib.h>
@@ -2718 +2799 @@
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2721: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2802: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
@@ -2735 +2816 @@
   # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
 cat > conftest.$ac_ext <<EOF
-#line 2738 "configure"
+#line 2819 "configure"
 #include "confdefs.h"
 #include <string.h>
@@ -2753 +2834 @@
   # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
 cat > conftest.$ac_ext <<EOF
-#line 2756 "configure"
+#line 2837 "configure"
 #include "confdefs.h"
 #include <stdlib.h>
@@ -2774 +2855 @@
 else
   cat > conftest.$ac_ext <<EOF
-#line 2777 "configure"
+#line 2858 "configure"
 #include "confdefs.h"
 #include <ctype.h>
@@ -2785 +2866 @@
 
 EOF
-if { (eval echo configure:2788: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:2869: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
 then
   :
@@ -2813 +2894 @@
 ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
 echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:2816: checking for $ac_hdr" >&5
+echo "configure:2897: checking for $ac_hdr" >&5
 if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
 else
   cat > conftest.$ac_ext <<EOF
-#line 2821 "configure"
+#line 2902 "configure"
 #include "confdefs.h"
 #include <$ac_hdr>
 EOF
 ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:2826: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:2907: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
 ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
 if test -z "$ac_err"; then
@@ -2853 +2934 @@
 
 echo $ac_n "checking for gthread cflags""... $ac_c" 1>&6
-echo "configure:2856: checking for gthread cflags" >&5
+echo "configure:2937: checking for gthread cflags" >&5
 if eval "test \"`echo '$''{'objc_cv_gthread_flags'+set}'`\" = set"; then
   echo $ac_n "(cached) $ac_c" 1>&6
@@ -3276 +3357 @@
 toplevel_srcdir=${toplevel_srcdir}
 CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
+ORIGINAL_LD_FOR_MULTILIBS="${ORIGINAL_LD_FOR_MULTILIBS}"
 
 EOF

branches/GNU/src/gcc/libobjc/configure.in

@@ -1 +1 @@
 # Process this file with autoconf to produce a configure script.
-#   Copyright (C) 1995, 1997, 1998, 1999, 2002 Free Software Foundation, Inc.
+#   Copyright (C) 1995, 1997, 1998, 1999, 2002, 2003
+#   Free Software Foundation, Inc.
 #   Contributed by Dave Love (d.love@dl.ac.uk).
 #
@@ -144 +145 @@
 toplevel_srcdir=${toplevel_srcdir}
 CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
+ORIGINAL_LD_FOR_MULTILIBS="${ORIGINAL_LD_FOR_MULTILIBS}"
 )
 

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

@@ -1 +1 @@
 /* Encoding of types for Objective C.
-   Copyright (C) 1993, 1995, 1996, 1997, 1998, 2000 Free Software Foundation, Inc.
+   Copyright (C) 1993, 1995, 1996, 1997, 1998, 2000, 2002
+   Free Software Foundation, Inc.
    Contributed by Kresten Krab Thorup
    Bitfield support by Ovidiu Predescu
@@ -30 +31 @@
 #include "objc-api.h"
 #include "encoding.h"
+#include <stdlib.h>
 
 #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); })
 
 
@@ -79 +81 @@
 /* Some ROUND_TYPE_ALIGN macros use TARGET_foo, and consequently
    target_flags.  Define a dummy entry here to so we don't die.  */
-
-static int target_flags = 0;
-
-static inline int
-atoi (const char* str)
-{
-  int res = 0;
-  
-  while (isdigit (*str))
-    res *= 10, res += (*str++ - '0');
-
-  return res;
-}
-
-/*
-  return the size of an object specified by type 
+/* ??? FIXME: As of 2002-06-21, the attribute `unused' doesn't seem to
+   eliminate the warning.  */
+static int __attribute__ ((__unused__)) target_flags = 0;
+
+/*
+  return the size of an object specified by type
 */
 
 int
-objc_sizeof_type (const char* type)
+objc_sizeof_type (const char *type)
 {
   /* Skip the variable name if any */
@@ -107 +99 @@
     }
 
-  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);
-    break;
-    
+    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);
-    break;
+    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(*++type));
-      return len*objc_aligned_size (type);
-    }
-    break; 
+      int len = atoi (type + 1);
+      while (isdigit ((unsigned char)*++type))
+        ;
+      return len * objc_aligned_size (type);
+    }
+    break;
 
   case _C_BFLD:
@@ -192 +186 @@
 
       position = atoi (type + 1);
-      while (isdigit (*++type));
+      while (isdigit ((unsigned char)*++type))
+        ;
       size = atoi (type + 1);
 
@@ -216 +211 @@
     {
       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)
         {
@@ -230 +226 @@
       return max_size;
     }
-    
+
   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;
     }
@@ -241 +237 @@
 
 /*
-  Return the alignment of an object specified by type 
+  Return the alignment of an object specified by type
 */
 
 int
-objc_alignof_type(const char* type)
+objc_alignof_type (const char *type)
 {
   /* Skip the variable name if any */
@@ -253 +249 @@
         /* do nothing */;
     }
-  switch(*type) {
+  switch (*type) {
   case _C_ID:
-    return __alignof__(id);
+    return __alignof__ (id);
     break;
 
   case _C_CLASS:
-    return __alignof__(Class);
-    break;
-    
+    return __alignof__ (Class);
+    break;
+
   case _C_SEL:
-    return __alignof__(SEL);
+    return __alignof__ (SEL);
     break;
 
   case _C_CHR:
-    return __alignof__(char);
-    break;
-    
+    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;
 
@@ -317 +313 @@
   case _C_ATOM:
   case _C_CHARPTR:
-    return __alignof__(char*);
+    return __alignof__ (char *);
     break;
 
   case _C_ARY_B:
-    while (isdigit(*++type)) /* do nothing */;
+    while (isdigit ((unsigned char)*++type))
+      /* do nothing */;
     return objc_alignof_type (type);
 
@@ -340 +337 @@
     {
       int maxalign = 0;
-      while (*type != _C_UNION_E && *type++ != '=') /* do nothing */;
+      while (*type != _C_UNION_E && *type++ != '=')
+        /* do nothing */;
       while (*type != _C_UNION_E)
         {
@@ -357 +355 @@
   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;
     }
@@ -368 +366 @@
 
 int
-objc_aligned_size (const char* type)
+objc_aligned_size (const char *type)
 {
   int size, align;
@@ -387 +385 @@
 /*
   The size rounded up to the nearest integral of the wordsize, taken
-  to be the size of a void*.
-*/
-
-int 
-objc_promoted_size (const char* type)
+  to be the size of a void *.
+*/
+
+int
+objc_promoted_size (const char *type)
 {
   int size, wordsize;
@@ -403 +401 @@
 
   size = objc_sizeof_type (type);
-  wordsize = sizeof (void*);
+  wordsize = sizeof (void *);
 
   return ROUND (size, wordsize);
@@ -413 +411 @@
 */
 
-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 
+         || *type == _C_IN
          || *type == _C_INOUT
-         || *type == _C_OUT 
+         || *type == _C_OUT
          || *type == _C_BYCOPY
          || *type == _C_BYREF
@@ -430 +428 @@
 }
 
-  
+
 /*
   Skip one typespec element.  If the typespec is prepended by type
@@ -436 +434 @@
 */
 
-const char* 
-objc_skip_typespec (const char* type)
+const char *
+objc_skip_typespec (const char *type)
 {
   /* Skip the variable name if any */
@@ -447 +445 @@
 
   type = objc_skip_type_qualifiers (type);
-  
+
   switch (*type) {
 
@@ -458 +456 @@
     else
       {
-        while (*++type != '"') /* do nothing */;
+        while (*++type != '"')
+          /* do nothing */;
         return type + 1;
       }
@@ -486 +485 @@
   case _C_ARY_B:
     /* skip digits, typespec and closing ']' */
-    
-    while(isdigit(*++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;
       }
@@ -499 +499 @@
   case _C_BFLD:
     /* The new encoding of bitfields is: b 'position' 'type' 'size' */
-    while (isdigit (*++type));  /* skip position */
-    while (isdigit (*++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:
     /* Just skip the following typespec */
-    
+
     return objc_skip_typespec (++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;
     }
@@ -534 +544 @@
   '+' if the argument is passed in registers.
 */
-inline const char* 
-objc_skip_offset (const char* type)
-{
-  if (*type == '+') type++;
-  while(isdigit(*++type));
+inline const char *
+objc_skip_offset (const char *type)
+{
+  if (*type == '+')
+    type++;
+  while (isdigit ((unsigned char) *++type))
+    ;
   return type;
 }
@@ -545 +557 @@
   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);
@@ -556 +568 @@
   Return the number of arguments that the method MTH expects.
   Note that all methods need two implicit arguments `self' and
-  `_cmd'. 
+  `_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)
     {
@@ -578 +590 @@
 
 int
-method_get_sizeof_arguments (struct objc_method* mth)
-{
-  const char* type = objc_skip_typespec (mth->method_types);
+method_get_sizeof_arguments (struct objc_method *mth)
+{
+  const char *type = objc_skip_typespec (mth->method_types);
   return atoi (type);
 }
@@ -589 +601 @@
 
   {
-    char *datum, *type; 
+    char *datum, *type;
     for (datum = method_get_first_argument (method, argframe, &type);
          datum; datum = method_get_next_argument (argframe, &type))
@@ -600 +612 @@
           {
             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);
@@ -625 +636 @@
 
 /*
-  Return a pointer to the value of the first argument of the method 
+  Return a pointer to the value of the first argument of the method
   described in M with the given argumentframe ARGFRAME.  The type
-  is returned in TYPE.  type must be passed to successive calls of 
+  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,
-                           arglist_t argframe, 
-                           const char** type)
+char *
+method_get_first_argument (struct objc_method *m,
+                           arglist_t argframe,
+                           const char **type)
 {
   *type = m->method_types;
@@ -642 +653 @@
    Return a pointer to the ARGth argument of the method
    M from the frame ARGFRAME.  The type of the argument
-   is returned in the value-result argument TYPE 
-*/
-
-char*
-method_get_nth_argument (struct objc_method* m,
-                         arglist_t argframe, int arg, 
+   is returned in the value-result argument TYPE
+*/
+
+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))
@@ -657 +668 @@
   while (arg--)
     t = objc_skip_argspec (t);
-  
+
   *type = t;
   t = objc_skip_typespec (t);
@@ -668 +679 @@
 
 unsigned
-objc_get_type_qualifiers (const char* type)
+objc_get_type_qualifiers (const char *type)
 {
   unsigned res = 0;
@@ -721 +732 @@
   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);
@@ -750 +761 @@
 objc_layout_structure_next_member (struct objc_struct_layout *layout)
 {
-  register int known_align = layout->record_size;
   register int desired_align = 0;
 
   /* The following are used only if the field is a bitfield */
-  register const char *bfld_type;
-  register int bfld_type_size, bfld_type_align, bfld_field_size;
+  register const char *bfld_type = 0;
+  register int bfld_type_size, bfld_type_align = 0, bfld_field_size = 0;
 
   /* The current type without the type qualifiers */
@@ -770 +780 @@
         /* Get the bitfield's type */
         for (bfld_type = type + 1;
-             isdigit(*bfld_type);
+             isdigit ((unsigned char)*bfld_type);
              bfld_type++)
           /* do nothing */;
@@ -794 +804 @@
 
   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(*bfld_type); bfld_type++)
+      for (bfld_type = type + 1;
+           isdigit ((unsigned char) *bfld_type);
+           bfld_type++)
         /* do nothing */;
 
@@ -819 +831 @@
 #ifndef PCC_BITFIELD_TYPE_MATTERS
   layout->record_align = MAX (layout->record_align, desired_align);
-#else
+#else   /* PCC_BITFIELD_TYPE_MATTERS */
   if (*type == _C_BFLD)
     {
@@ -851 +863 @@
   else
     layout->record_align = MAX (layout->record_align, desired_align);
-#endif
+#endif  /* PCC_BITFIELD_TYPE_MATTERS */
 
   /* Does this field automatically have alignment it needs
@@ -865 +877 @@
       layout->record_size = ROUND (layout->record_size, desired_align);
     }
-  
+
   /* Jump to the next field in record. */
 
@@ -885 +897 @@
          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,

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

@@ -1 +1 @@
 /* Basic data types for Objective C.
-   Copyright (C) 1998 Free Software Foundation, Inc.
+   Copyright (C) 1998, 2002 Free Software Foundation, Inc.
    Contributed by Ovidiu Predescu.
 
@@ -59 +59 @@
 
 #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); })
 
 #define SET_BIT_FOR_OFFSET(mask, offset) \
-  GC_set_bit(mask, offset / sizeof (void*))
+  GC_set_bit (mask, offset / sizeof (void *))
 
 /* Some prototypes */
@@ -75 +75 @@
 __objc_gc_setup_array (GC_bitmap mask, const char *type, int offset)
 {
-  int i, len = atoi(type + 1);
-
-  while (isdigit(*++type))
+  int i, len = atoi (type + 1);
+
+  while (isdigit (*++type))
     /* do nothing */;           /* skip the size of the array */
 
@@ -139 +139 @@
       case _C_CHARPTR:
       case _C_ATOM:
-        if (!gc_invisible)
-          SET_BIT_FOR_OFFSET(mask, position);
+        if (! gc_invisible)
+          SET_BIT_FOR_OFFSET (mask, position);
         break;
 
@@ -179 +179 @@
   align = objc_alignof_type (type);
 
-  offset = ROUND(offset, align);
-  for (i = 0; i < size; i += sizeof (void*))
-    {
-      SET_BIT_FOR_OFFSET(mask, offset);
-      offset += sizeof (void*);
+  offset = ROUND (offset, align);
+  for (i = 0; i < size; i += sizeof (void *))
+    {
+      SET_BIT_FOR_OFFSET (mask, offset);
+      offset += sizeof (void *);
     }
 }
@@ -224 +224 @@
       case _C_PTR:
       case _C_CHARPTR:
-        if (!gc_invisible)
-          SET_BIT_FOR_OFFSET(mask, offset);
+        if (! gc_invisible)
+          SET_BIT_FOR_OFFSET (mask, offset);
         break;
 
@@ -255 +255 @@
 {
   int i, ivar_count;
-  struct objc_ivar_list* ivars;
-
-  if (!class)
+  struct objc_ivar_list *ivars;
+
+  if (! class)
     {
       strcat (*type, "{");
@@ -268 +268 @@
 
   ivars = class->ivars;
-  if (!ivars)
+  if (! ivars)
     return;
 
@@ -283 +283 @@
           /* Increase the size of the encoding string so that it
              contains this ivar's type. */
-          *size = ROUND(*current + len + 1, 10);
+          *size = ROUND (*current + len + 1, 10);
           *type = objc_realloc (*type, *size);
         }
@@ -303 +303 @@
   char *class_structure_type;
 
-  if (!CLS_ISCLASS(class))
+  if (! CLS_ISCLASS (class))
     return;
 
@@ -312 +312 @@
   /* The number of bits in the mask is the size of an instance in bytes divided
      by the size of a pointer. */
-  bits_no = (ROUND(class_get_instance_size (class), sizeof(void*))
-             / sizeof (void*));
-  size = ROUND(bits_no, BITS_PER_WORD) / BITS_PER_WORD;
+  bits_no = (ROUND (class_get_instance_size (class), sizeof (void *))
+             / sizeof (void *));
+  size = ROUND (bits_no, BITS_PER_WORD) / BITS_PER_WORD;
   mask = objc_atomic_malloc (size * sizeof (int));
   memset (mask, 0, size * sizeof (int));
@@ -343 +343 @@
 #endif
 
-  class->gc_object_type = (void*)GC_make_descriptor (mask, bits_no);
+  class->gc_object_type = (void *) GC_make_descriptor (mask, bits_no);
 }
 
@@ -371 +371 @@
    pointers.  */
 void
-class_ivar_set_gcinvisible (Class class, const char* ivarname,
+class_ivar_set_gcinvisible (Class class, const char *ivarname,
                             BOOL gc_invisible)
 {
   int i, ivar_count;
-  struct objc_ivar_list* ivars;
-
-  if (!class || !ivarname)
+  struct objc_ivar_list *ivars;
+
+  if (! class || ! ivarname)
     return;
 
   ivars = class->ivars;
-  if (!ivars)
+  if (! ivars)
     return;
 
@@ -391 +391 @@
       const char *type;
 
-      if (!ivar->ivar_name || strcmp (ivar->ivar_name, ivarname))
+      if (! ivar->ivar_name || strcmp (ivar->ivar_name, ivarname))
         continue;
 
@@ -408 +408 @@
           char *new_type;
 
-          if (gc_invisible || !__objc_ivar_pointer (type))
+          if (gc_invisible || ! __objc_ivar_pointer (type))
             return;     /* The type of the variable already matches the
                            requested gc_invisible type */
@@ -423 +423 @@
           char *new_type;
 
-          if (!gc_invisible || !__objc_ivar_pointer (type))
+          if (! gc_invisible || ! __objc_ivar_pointer (type))
             return;     /* The type of the variable already matches the
                            requested gc_invisible type */
@@ -447 +447 @@
 
 void
-__objc_generate_gc_type_description (Class class)
-{
-}
-
-void class_ivar_set_gcinvisible (Class class,
-                                 const char* ivarname,
-                                 BOOL gc_invisible)
+__objc_generate_gc_type_description (Class class __attribute__ ((__unused__)))
+{
+}
+
+void class_ivar_set_gcinvisible (Class class __attribute__ ((__unused__)),
+                                 const char *ivarname __attribute__ ((__unused__)),
+                                 BOOL gc_invisible __attribute__ ((__unused__)))
 {
 }

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

@@ -48 +48 @@
   /* Pass me a value greater than 0 and a power of 2.  */
   assert (size);
-  assert (!(size & (size - 1)));
+  assert (! (size & (size - 1)));
 
   /* Allocate the cache structure.  calloc insures
@@ -197 +197 @@
       } else
         prev = node, node = node->next;
-    } while (!removed && node);
+    } while (! removed && node);
     assert (removed);
   }
@@ -211 +211 @@
   /* If the scan is being started then reset the last node
      visitied pointer and bucket index.  */
-  if (!node)
+  if (! node)
     cache->last_bucket  = 0;
 
@@ -259 +259 @@
       } else
         node = node->next;
-    } while (!retval && node);
+    } while (! retval && node);
 
   return retval;

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

@@ -1 +1 @@
 /* GNU Objective C Runtime initialization 
-   Copyright (C) 1993, 1995, 1996, 1997 Free Software Foundation, Inc.
+   Copyright (C) 1993, 1995, 1996, 1997, 2002 Free Software Foundation, Inc.
    Contributed by Kresten Krab Thorup
    +load support contributed by Ovidiu Predescu <ovidiu@net-community.com>
@@ -28 +28 @@
 
 /* The version number of this runtime.  This must match the number 
-   defined in gcc (objc-act.c) */
+   defined in gcc (objc-act.c).  */
 #define OBJC_VERSION 8
 #define PROTOCOL_VERSION 2
 
-/* This list contains all modules currently loaded into the runtime */
-static struct objc_list* __objc_module_list = 0;        /* !T:MUTEX */
-
-/* This list contains all proto_list's not yet assigned class links */
-static struct objc_list* unclaimed_proto_list = 0;      /* !T:MUTEX */
+/* This list contains all modules currently loaded into the runtime.  */
+static struct objc_list *__objc_module_list = 0;        /* !T:MUTEX */
+
+/* This list contains all proto_list's not yet assigned class links.  */
+static struct objc_list *unclaimed_proto_list = 0;      /* !T:MUTEX */
 
 /* List of unresolved static instances.  */
 static struct objc_list *uninitialized_statics = 0;     /* !T:MUTEX */
 
-/* Global runtime "write" mutex. */
+/* Global runtime "write" mutex.  */
 objc_mutex_t __objc_runtime_mutex = 0;
 
-/* Number of threads that are alive. */
+/* Number of threads that are alive.  */
 int __objc_runtime_threads_alive = 1;                   /* !T:MUTEX */
 
-/* Check compiler vs runtime version */
+/* Check compiler vs runtime version.  */
 static void init_check_module_version (Module_t);
 
-/* Assign isa links to protos */
-static void __objc_init_protocols (struct objc_protocol_list* protos);
-
-/* Add protocol to class */
-static void __objc_class_add_protocols (Class, struct objc_protocol_list*);
-
-/* This is a hook which is called by __objc_exec_class every time a class
-   or a category is loaded into the runtime.  This may e.g. help a
-   dynamic loader determine the classes that have been loaded when
-   an object file is dynamically linked in */
-void (*_objc_load_callback)(Class class, Category* category); /* !T:SAFE */
-
-/* Is all categories/classes resolved? */
+/* Assign isa links to protos.  */
+static void __objc_init_protocols (struct objc_protocol_list *protos);
+
+/* Add protocol to class.  */
+static void __objc_class_add_protocols (Class, struct objc_protocol_list *);
+
+/* This is a hook which is called by __objc_exec_class every time a
+   class or a category is loaded into the runtime.  This may e.g. help
+   a dynamic loader determine the classes that have been loaded when
+   an object file is dynamically linked in.  */
+void (*_objc_load_callback) (Class class, Category *category); /* !T:SAFE */
+
+/* Is all categories/classes resolved?  */
 BOOL __objc_dangling_categories = NO;           /* !T:UNUSED */
 
@@ -69 +69 @@
                            struct objc_selector *orig, BOOL is_const);
 
-/* Sends +load to all classes and categories in certain situations. */
+/* Sends +load to all classes and categories in certain situations.  */
 static void objc_send_load (void);
 
 /* Inserts all the classes defined in module in a tree of classes that
-   resembles the class hierarchy. This tree is traversed in preorder and the
-   classes in its nodes receive the +load message if these methods were not
-   executed before. The algorithm ensures that when the +load method of a class
-   is executed all the superclasses have been already received the +load
-   message. */
+   resembles the class hierarchy. This tree is traversed in preorder
+   and the classes in its nodes receive the +load message if these
+   methods were not executed before. The algorithm ensures that when
+   the +load method of a class is executed all the superclasses have
+   been already received the +load message.  */
 static void __objc_create_classes_tree (Module_t module);
 
@@ -83 +83 @@
 
 /* A special version that works only before the classes are completely
-   installed in the runtime. */
+   installed in the runtime.  */
 static BOOL class_is_subclass_of_class (Class class, Class superclass);
 
@@ -91 +91 @@
 } objc_class_tree;
 
-/* This is a linked list of objc_class_tree trees. The head of these trees
-   are root classes (their super class is Nil). These different trees
-   represent different class hierarchies. */
+/* This is a linked list of objc_class_tree trees. The head of these
+   trees are root classes (their super class is Nil). These different
+   trees represent different class hierarchies.  */
 static struct objc_list *__objc_class_tree_list = NULL;
 
-/* Keeps the +load methods who have been already executed. This hash should
-   not be destroyed during the execution of the program. */
+/* Keeps the +load methods who have been already executed. This hash
+   should not be destroyed during the execution of the program.  */
 static cache_ptr __objc_load_methods = NULL;
 
-/* Creates a tree of classes whose topmost class is directly inherited from
-   `upper' and the bottom class in this tree is `bottom_class'. The classes
-   in this tree are super classes of `bottom_class'. `subclasses' member
-   of each tree node point to the next subclass tree node. */
+/* Creates a tree of classes whose topmost class is directly inherited
+   from `upper' and the bottom class in this tree is
+   `bottom_class'. The classes in this tree are super classes of
+   `bottom_class'. `subclasses' member of each tree node point to the
+   next subclass tree node.  */
+
 static objc_class_tree *
 create_tree_of_subclasses_inherited_from (Class bottom_class, Class upper)
 {
   Class superclass = bottom_class->super_class ?
-                        objc_lookup_class ((char*)bottom_class->super_class)
+                        objc_lookup_class ((char *) bottom_class->super_class)
                       : Nil;
                                         
@@ -127 +129 @@
       tree->subclasses = list_cons (prev, tree->subclasses);
       superclass = (superclass->super_class ?
-                        objc_lookup_class ((char*)superclass->super_class)
+                        objc_lookup_class ((char *) superclass->super_class)
                       : Nil);
       prev = tree;
@@ -135 +137 @@
 }
 
-/* Insert the `class' into the proper place in the `tree' class hierarchy. This
-   function returns a new tree if the class has been successfully inserted into
-   the tree or NULL if the class is not part of the classes hierarchy described
-   by `tree'. This function is private to objc_tree_insert_class(), you should
-   not call it directly. */
+/* Insert the `class' into the proper place in the `tree' class
+   hierarchy. This function returns a new tree if the class has been
+   successfully inserted into the tree or NULL if the class is not
+   part of the classes hierarchy described by `tree'. This function is
+   private to objc_tree_insert_class (), you should not call it
+   directly.  */
+
 static objc_class_tree *
 __objc_tree_insert_class (objc_class_tree *tree, Class class)
@@ -155 +159 @@
     }
   else if ((class->super_class ?
-                    objc_lookup_class ((char*)class->super_class)
+                    objc_lookup_class ((char *) class->super_class)
                   : Nil)
             == tree->class)
@@ -161 +165 @@
       /* If class is a direct subclass of tree->class then add class to the
          list of subclasses. First check to see if it wasn't already
-         inserted. */
+         inserted.  */
       struct objc_list *list = tree->subclasses;
       objc_class_tree *node;
@@ -168 +172 @@
         {
           /* Class has been already inserted; do nothing just return
-             the tree. */
-          if (((objc_class_tree*)list->head)->class == class)
+             the tree.  */
+          if (((objc_class_tree *) list->head)->class == class)
             {
               DEBUG_PRINTF ("2. class %s was previously inserted\n",
@@ -187 +191 @@
   else
     {
-      /* The class is not a direct subclass of tree->class. Search for class's
-         superclasses in the list of subclasses. */
+      /* The class is not a direct subclass of tree->class. Search for
+         class's superclasses in the list of subclasses.  */
       struct objc_list *subclasses = tree->subclasses;
 
-      /* Precondition: the class must be a subclass of tree->class; otherwise
-         return NULL to indicate our caller that it must take the next tree. */
-      if (!class_is_subclass_of_class (class, tree->class))
+      /* Precondition: the class must be a subclass of tree->class;
+         otherwise return NULL to indicate our caller that it must
+         take the next tree.  */
+      if (! class_is_subclass_of_class (class, tree->class))
         return NULL;
 
       for (; subclasses != NULL; subclasses = subclasses->tail)
         {
-          Class aClass = ((objc_class_tree*)(subclasses->head))->class;
+          Class aClass = ((objc_class_tree *) (subclasses->head))->class;
 
           if (class_is_subclass_of_class (class, aClass))
             {
-              /* If we found one of class's superclasses we insert the class
-                 into its subtree and return the original tree since nothing
-                 has been changed. */
+              /* If we found one of class's superclasses we insert the
+                 class into its subtree and return the original tree
+                 since nothing has been changed.  */
               subclasses->head
                   = __objc_tree_insert_class (subclasses->head, class);
@@ -212 +217 @@
         }
 
-      /* We haven't found a subclass of `class' in the `subclasses' list.
-         Create a new tree of classes whose topmost class is a direct subclass
-         of tree->class. */
+      /* We haven't found a subclass of `class' in the `subclasses'
+         list.  Create a new tree of classes whose topmost class is a
+         direct subclass of tree->class.  */
       {
         objc_class_tree *new_tree
-            = create_tree_of_subclasses_inherited_from (class, tree->class);
+          = create_tree_of_subclasses_inherited_from (class, tree->class);
         tree->subclasses = list_cons (new_tree, tree->subclasses);
         DEBUG_PRINTF ("5. class %s inserted\n", class->name);
@@ -225 +230 @@
 }
 
-/* This function inserts `class' in the right tree hierarchy classes. */
+/* This function inserts `class' in the right tree hierarchy classes.  */
+
 static void
 objc_tree_insert_class (Class class)
@@ -245 +251 @@
     }
 
-  /* If the list was finished but the class hasn't been inserted, insert it
-     here. */
-  if (!list_node)
+  /* If the list was finished but the class hasn't been inserted,
+     insert it here.  */
+  if (! list_node)
     {
       __objc_class_tree_list = list_cons (NULL, __objc_class_tree_list);
@@ -254 +260 @@
 }
 
-/* Traverse tree in preorder. Used to send +load. */
+/* Traverse tree in preorder. Used to send +load.  */
+
 static void
 objc_preorder_traverse (objc_class_tree *tree,
                         int level,
-                        void (*function)(objc_class_tree*, int))
+                        void (*function) (objc_class_tree *, int))
 {
   struct objc_list *node;
@@ -267 +274 @@
 }
 
-/* Traverse tree in postorder. Used to destroy a tree. */
+/* Traverse tree in postorder. Used to destroy a tree.  */
+
 static void
 objc_postorder_traverse (objc_class_tree *tree,
-                        int level,
-                        void (*function)(objc_class_tree*, int))
+                         int level,
+                         void (*function) (objc_class_tree *, int))
 {
   struct objc_list *node;
@@ -280 +288 @@
 }
 
-/* Used to print a tree class hierarchy. */
+/* Used to print a tree class hierarchy.  */
+
 #ifdef DEBUG
 static void
@@ -293 +302 @@
 #endif
 
-/* Walks on a linked list of methods in the reverse order and executes all
-   the methods corresponding to `op' selector. Walking in the reverse order
-   assures the +load of class is executed first and then +load of categories
-   because of the way in which categories are added to the class methods. */
+/* Walks on a linked list of methods in the reverse order and executes
+   all the methods corresponding to `op' selector. Walking in the
+   reverse order assures the +load of class is executed first and then
+   +load of categories because of the way in which categories are
+   added to the class methods.  */
+
 static void
 __objc_send_message_in_list (MethodList_t method_list, Class class, SEL op)
@@ -302 +313 @@
   int i;
 
-  if (!method_list)
+  if (! method_list)
     return;
 
@@ -308 +319 @@
   __objc_send_message_in_list (method_list->method_next, class, op);
 
-  /* Search the method list. */
+  /* Search the method list.  */
   for (i = 0; i < method_list->method_count; i++)
     {
@@ -314 +325 @@
 
       if (mth->method_name && sel_eq (mth->method_name, op)
-          && !hash_is_key_in_hash (__objc_load_methods, mth->method_imp))
+          && ! hash_is_key_in_hash (__objc_load_methods, mth->method_imp))
         {
           /* Add this method into the +load hash table */
@@ -321 +332 @@
           DEBUG_PRINTF ("sending +load in class: %s\n", class->name);
 
-          /* The method was found and wasn't previously executed. */
+          /* The method was found and wasn't previously executed.  */
           (*mth->method_imp) ((id)class, mth->method_name);
 
@@ -330 +341 @@
 
 static void
-__objc_send_load (objc_class_tree *tree, int level)
+__objc_send_load (objc_class_tree *tree,
+                  int level __attribute__ ((__unused__)))
 {
   static SEL load_sel = 0;
@@ -336 +348 @@
   MethodList_t method_list = class->class_pointer->methods;
 
-  if (!load_sel)
+  if (! load_sel)
     load_sel = sel_register_name ("load");
 
@@ -343 +355 @@
 
 static void
-__objc_destroy_class_tree_node (objc_class_tree *tree, int level)
+__objc_destroy_class_tree_node (objc_class_tree *tree,
+                                int level __attribute__ ((__unused__)))
 {
   objc_free (tree);
 }
 
-/* This is used to check if the relationship between two classes before the
-   runtime completely installs the classes. */
+/* This is used to check if the relationship between two classes
+   before the runtime completely installs the classes.  */
+
 static BOOL
 class_is_subclass_of_class (Class class, Class superclass)
@@ -358 +372 @@
         return YES;
       class = (class->super_class ?
-                  objc_lookup_class ((char*)class->super_class)
+                  objc_lookup_class ((char *) class->super_class)
                 : Nil);
     }
@@ -365 +379 @@
 }
 
-/* This list contains all the classes in the runtime system for whom their
-   superclasses are not yet know to the runtime. */
-static struct objc_list* unresolved_classes = 0;
-
-/* Extern function used to reference the Object and NXConstantString classes.
- */
+/* This list contains all the classes in the runtime system for whom
+   their superclasses are not yet known to the runtime.  */
+static struct objc_list *unresolved_classes = 0;
+
+/* Extern function used to reference the Object and NXConstantString
+   classes.  */
 
 extern void __objc_force_linking (void);
@@ -381 +395 @@
 }
 
-/* Run through the statics list, removing modules as soon as all its statics
-   have been initialized.  */
+/* Run through the statics list, removing modules as soon as all its
+   statics have been initialized.  */
+
 static void
 objc_init_statics (void)
@@ -389 +404 @@
   struct objc_static_instances **statics_in_module;
 
-  objc_mutex_lock(__objc_runtime_mutex);
+  objc_mutex_lock (__objc_runtime_mutex);
 
   while (*cell)
@@ -401 +416 @@
           Class class = objc_lookup_class (statics->class_name);
 
-          if (!class)
+          if (! class)
             module_initialized = 0;
           /* Actually, the static's class_pointer will be NULL when we
@@ -431 +446 @@
           struct objc_list *this = *cell;
           *cell = this->tail;
-          objc_free(this);
+          objc_free (this);
         }
       else
@@ -437 +452 @@
     }
 
-  objc_mutex_unlock(__objc_runtime_mutex);
+  objc_mutex_unlock (__objc_runtime_mutex);
 } /* objc_init_statics */
 
 /* This function is called by constructor functions generated for each
-   module compiled.  (_GLOBAL_$I$...) The purpose of this function is to
-   gather the module pointers so that they may be processed by the
-   initialization routines as soon as possible */
+   module compiled.  (_GLOBAL_$I$...) The purpose of this function is
+   to gather the module pointers so that they may be processed by the
+   initialization routines as soon as possible.  */
 
 void
@@ -452 +467 @@
   static BOOL previous_constructors = 0;
 
-  static struct objc_list* unclaimed_categories = 0;
+  static struct objc_list *unclaimed_categories = 0;
 
   /* The symbol table (defined in objc-api.h) generated by gcc */
@@ -462 +477 @@
 
   /* Entry used to traverse hash lists */
-  struct objc_list** cell;
+  struct objc_list **cell;
 
   /* The table of selector references for this module */
@@ -473 +488 @@
 
   /* check gcc version */
-  init_check_module_version(module);
+  init_check_module_version (module);
 
   /* On the first call of this routine, initialize some data structures.  */
-  if (!previous_constructors)
+  if (! previous_constructors)
     {
         /* Initialize thread-safe system */
-      __objc_init_thread_system();
+      __objc_init_thread_system ();
       __objc_runtime_threads_alive = 1;
-      __objc_runtime_mutex = objc_mutex_allocate();
-
-      __objc_init_selector_tables();
-      __objc_init_class_tables();
-      __objc_init_dispatch_tables();
+      __objc_runtime_mutex = objc_mutex_allocate ();
+
+      __objc_init_selector_tables ();
+      __objc_init_class_tables ();
+      __objc_init_dispatch_tables ();
       __objc_class_tree_list = list_cons (NULL, __objc_class_tree_list);
       __objc_load_methods
@@ -493 +508 @@
 
   /* Save the module pointer for later processing. (not currently used) */
-  objc_mutex_lock(__objc_runtime_mutex);
-  __objc_module_list = list_cons(module, __objc_module_list);
+  objc_mutex_lock (__objc_runtime_mutex);
+  __objc_module_list = list_cons (module, __objc_module_list);
 
   /* Replace referenced selectors from names to SEL's.  */
@@ -502 +517 @@
         {
           const char *name, *type;
-          name = (char*)selectors[i].sel_id;
-          type = (char*)selectors[i].sel_types;
+          name = (char *) selectors[i].sel_id;
+          type = (char *) selectors[i].sel_types;
           /* Constructors are constant static data so we can safely store
              pointers to them in the runtime structures. is_const == YES */
           __sel_register_typed_name (name, type, 
-                                     (struct objc_selector*)&(selectors[i]),
+                                     (struct objc_selector *) &(selectors[i]),
                                      YES);
         }
@@ -517 +532 @@
     {
       Class class = (Class) symtab->defs[i];
-      const char* superclass = (char*)class->super_class;
+      const char *superclass = (char *) class->super_class;
 
       /* Make sure we have what we think.  */
-      assert (CLS_ISCLASS(class));
-      assert (CLS_ISMETA(class->class_pointer));
+      assert (CLS_ISCLASS (class));
+      assert (CLS_ISMETA (class->class_pointer));
       DEBUG_PRINTF ("phase 1, processing class: %s\n", class->name);
 
       /* Initialize the subclass list to be NULL.
-         In some cases it isn't and this crashes the program. */
+         In some cases it isn't and this crashes the program.  */
       class->subclass_list = NULL;
 
@@ -536 +551 @@
 
       /* Install the fake dispatch tables */
-      __objc_install_premature_dtable(class);
-      __objc_install_premature_dtable(class->class_pointer);
+      __objc_install_premature_dtable (class);
+      __objc_install_premature_dtable (class->class_pointer);
 
       /* Register the instance methods as class methods, this is
-         only done for root classes. */
-      __objc_register_instance_methods_to_class(class);
+         only done for root classes.  */
+      __objc_register_instance_methods_to_class (class);
 
       if (class->protocols)
@@ -547 +562 @@
 
       /* Check to see if the superclass is known in this point. If it's not
-         add the class to the unresolved_classes list. */
-      if (superclass && !objc_lookup_class (superclass))
+         add the class to the unresolved_classes list.  */
+      if (superclass && ! objc_lookup_class (superclass))
         unresolved_classes = list_cons (class, unresolved_classes);
    }
@@ -582 +597 @@
 
           /* Register the instance methods as class methods, this is
-             only done for root classes. */
-          __objc_register_instance_methods_to_class(class);
+             only done for root classes.  */
+          __objc_register_instance_methods_to_class (class);
         }
       else
@@ -589 +604 @@
           /* The object to which the category methods belong can't be found.
              Save the information.  */
-          unclaimed_categories = list_cons(category, unclaimed_categories);
+          unclaimed_categories = list_cons (category, unclaimed_categories);
         }
     }
@@ -626 +641 @@
 
           /* Register the instance methods as class methods, this is
-             only done for root classes. */
-          __objc_register_instance_methods_to_class(class);
+             only done for root classes.  */
+          __objc_register_instance_methods_to_class (class);
         }
       else
@@ -635 +650 @@
   if (unclaimed_proto_list && objc_lookup_class ("Protocol"))
     {
-      list_mapcar (unclaimed_proto_list,(void(*)(void*))__objc_init_protocols);
+      list_mapcar (unclaimed_proto_list,
+                   (void (*) (void *))__objc_init_protocols);
       list_free (unclaimed_proto_list);
       unclaimed_proto_list = 0;
@@ -642 +658 @@
   objc_send_load ();
 
-  objc_mutex_unlock(__objc_runtime_mutex);
-}
-
-static void objc_send_load (void)
-{
-  if (!__objc_module_list)
+  objc_mutex_unlock (__objc_runtime_mutex);
+}
+
+static void
+objc_send_load (void)
+{
+  if (! __objc_module_list)
     return;
  
   /* Try to find out if all the classes loaded so far also have their
-     superclasses known to the runtime. We suppose that the objects that are
-     allocated in the +load method are in general of a class declared in the
-     same module. */
+     superclasses known to the runtime. We suppose that the objects
+     that are allocated in the +load method are in general of a class
+     declared in the same module.  */
   if (unresolved_classes)
     {
       Class class = unresolved_classes->head;
 
-      while (objc_lookup_class ((char*)class->super_class))
+      while (objc_lookup_class ((char *) class->super_class))
         {
           list_remove_head (&unresolved_classes);
@@ -667 +684 @@
         }
 
-      /*
-       * If we still have classes for whom we don't have yet their super
-       * classes known to the runtime we don't send the +load messages.
-       */
+      /* If we still have classes for whom we don't have yet their
+         super classes known to the runtime we don't send the +load
+         messages.  */
       if (unresolved_classes)
         return;
     }
 
-  /* Special check to allow creating and sending messages to constant strings
-     in +load methods. If these classes are not yet known, even if all the
-     other classes are known, delay sending of +load. */
-  if (!objc_lookup_class ("NXConstantString") ||
-      !objc_lookup_class ("Object"))
+  /* Special check to allow creating and sending messages to constant
+     strings in +load methods. If these classes are not yet known,
+     even if all the other classes are known, delay sending of +load.  */
+  if (! objc_lookup_class ("NXConstantString") ||
+      ! objc_lookup_class ("Object"))
     return;
 
-  /* Iterate over all modules in the __objc_module_list and call on them the
-     __objc_create_classes_tree function. This function creates a tree of
-     classes that resembles the class hierarchy. */
-  list_mapcar (__objc_module_list, (void(*)(void*))__objc_create_classes_tree);
+  /* Iterate over all modules in the __objc_module_list and call on
+     them the __objc_create_classes_tree function. This function
+     creates a tree of classes that resembles the class hierarchy.  */
+  list_mapcar (__objc_module_list,
+               (void (*) (void *)) __objc_create_classes_tree);
 
   while (__objc_class_tree_list)
@@ -700 +717 @@
     }
 
-  list_mapcar (__objc_module_list, (void(*)(void*))__objc_call_callback);
+  list_mapcar (__objc_module_list, (void (*) (void *)) __objc_call_callback);
   list_free (__objc_module_list);
   __objc_module_list = NULL;
@@ -713 +730 @@
   int i;
 
-  /* Iterate thru classes defined in this module and insert them in the classes
-     tree hierarchy. */
+  /* Iterate thru classes defined in this module and insert them in
+     the classes tree hierarchy.  */
   for (i = 0; i < symtab->cls_def_cnt; i++)
     {
@@ -726 +743 @@
 __objc_call_callback (Module_t module)
 {
-  /* The runtime mutex is locked in this point */
+  /* The runtime mutex is locked in this point.  */
 
   Symtab_t symtab = module->symtab;
   int i;
 
-  /* Iterate thru classes defined in this module and call the callback for
-     each one. */
+  /* Iterate thru classes defined in this module and call the callback
+     for each one.  */
   for (i = 0; i < symtab->cls_def_cnt; i++)
     {
       Class class = (Class) symtab->defs[i];
 
-      /* Call the _objc_load_callback for this class. */
+      /* Call the _objc_load_callback for this class.  */
       if (_objc_load_callback)
-        _objc_load_callback(class, 0);
-    }
-
-  /* Call the _objc_load_callback for categories. Don't register the instance
-     methods as class methods for categories to root classes since they were
-     already added in the class. */
+        _objc_load_callback (class, 0);
+    }
+
+  /* Call the _objc_load_callback for categories. Don't register the
+     instance methods as class methods for categories to root classes
+     since they were already added in the class.  */
   for (i = 0; i < symtab->cat_def_cnt; i++)
     {
@@ -751 +768 @@
       
       if (_objc_load_callback)
-        _objc_load_callback(class, category);
-    }
-}
-
-/* Sanity check the version of gcc used to compile `module'*/
-static void init_check_module_version(Module_t module)
+        _objc_load_callback (class, category);
+    }
+}
+
+/* Sanity check the version of gcc used to compile `module'.  */
+
+static void
+init_check_module_version (Module_t module)
 {
   if ((module->version != OBJC_VERSION) || (module->size != sizeof (Module)))
@@ -762 +781 @@
       int code;
 
-      if(module->version > OBJC_VERSION)
+      if (module->version > OBJC_VERSION)
         code = OBJC_ERR_OBJC_VERSION;
       else if (module->version < OBJC_VERSION)
@@ -769 +788 @@
         code = OBJC_ERR_MODULE_SIZE;
 
-      objc_error(nil, code, "Module %s version %d doesn't match runtime %d\n",
-               module->name, (int)module->version, OBJC_VERSION);
-    }
-}
-
-static void
-__objc_init_protocols (struct objc_protocol_list* protos)
-{
-  int i;
+      objc_error (nil, code, "Module %s version %d doesn't match runtime %d\n",
+                  module->name, (int)module->version, OBJC_VERSION);
+    }
+}
+
+static void
+__objc_init_protocols (struct objc_protocol_list *protos)
+{
+  size_t i;
   static Class proto_class = 0;
 
@@ -783 +802 @@
     return;
 
-  objc_mutex_lock(__objc_runtime_mutex);
-
-  if (!proto_class)
-    proto_class = objc_lookup_class("Protocol");
-
-  if (!proto_class)
+  objc_mutex_lock (__objc_runtime_mutex);
+
+  if (! proto_class)
+    proto_class = objc_lookup_class ("Protocol");
+
+  if (! proto_class)
     {
       unclaimed_proto_list = list_cons (protos, unclaimed_proto_list);
-      objc_mutex_unlock(__objc_runtime_mutex);
+      objc_mutex_unlock (__objc_runtime_mutex);
       return;
     }
@@ -799 +818 @@
 #endif
 
-  for(i = 0; i < protos->count; i++)
-    {
-      struct objc_protocol* aProto = protos->list[i];
+  for (i = 0; i < protos->count; i++)
+    {
+      struct objc_protocol *aProto = protos->list[i];
       if (((size_t)aProto->class_pointer) == PROTOCOL_VERSION)
         {
@@ -812 +831 @@
       else if (protos->list[i]->class_pointer != proto_class)
         {
-          objc_error(nil, OBJC_ERR_PROTOCOL_VERSION,
+          objc_error (nil, OBJC_ERR_PROTOCOL_VERSION,
                      "Version %d doesn't match runtime protocol version %d\n",
-                     (int)((char*)protos->list[i]->class_pointer-(char*)0),
+                     (int) ((char *) protos->list[i]->class_pointer
+                            - (char *) 0),
                      PROTOCOL_VERSION);
         }
     }
 
-  objc_mutex_unlock(__objc_runtime_mutex);
-}
-
-static void __objc_class_add_protocols (Class class,
-                                        struct objc_protocol_list* protos)
-{
-  /* Well... */
+  objc_mutex_unlock (__objc_runtime_mutex);
+}
+
+static void
+__objc_class_add_protocols (Class class, struct objc_protocol_list *protos)
+{
+  /* Well...  */
   if (! protos)
     return;
 
-  /* Add it... */
+  /* Add it...  */
   protos->next = class->protocols;
   class->protocols = protos;

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

@@ -1 +1 @@
 /* GNU Objective C Runtime Miscellaneous 
-   Copyright (C) 1993, 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
+   Copyright (C) 1993, 1994, 1995, 1996, 1997, 2002
+   Free Software Foundation, Inc.
    Contributed by Kresten Krab Thorup
 
@@ -38 +39 @@
 /* Trigger an objc error */
 void
-objc_error(id object, int code, const char* fmt, ...)
+objc_error (id object, int code, const char *fmt, ...)
 {
   va_list ap;
 
-  va_start(ap, fmt);
-  objc_verror(object, code, fmt, ap);
-  va_end(ap);
+  va_start (ap, fmt);
+  objc_verror (object, code, fmt, ap);
+  va_end (ap);
 }
 
 /* Trigger an objc error */
 void
-objc_verror(id object, int code, const char* fmt, va_list ap)
+objc_verror (id object, int code, const char *fmt, va_list ap)
 {
   BOOL result = NO;
@@ -56 +57 @@
      Otherwise print to stderr */
   if (_objc_error_handler)
-    result = (*_objc_error_handler)(object, code, fmt, ap);
+    result = (*_objc_error_handler) (object, code, fmt, ap);
   else
     vfprintf (stderr, fmt, ap);
@@ -65 +66 @@
     return;
   else
-    abort();
+    abort ();
 }
 
 /* Set the error handler */
 objc_error_handler
-objc_set_error_handler(objc_error_handler func)
+objc_set_error_handler (objc_error_handler func)
 {
   objc_error_handler temp = _objc_error_handler;
@@ -85 +86 @@
 
 void *
-objc_malloc(size_t size)
+objc_malloc (size_t size)
 {
-  void* res = (void*) (*_objc_malloc)(size);
-  if(!res)
-    objc_error(nil, OBJC_ERR_MEMORY, "Virtual memory exhausted\n");
+  void *res = (void *) (*_objc_malloc) (size);
+  if (! res)
+    objc_error (nil, OBJC_ERR_MEMORY, "Virtual memory exhausted\n");
   return res;
 }
 
 void *
-objc_atomic_malloc(size_t size)
+objc_atomic_malloc (size_t size)
 {
-  void* res = (void*) (*_objc_atomic_malloc)(size);
-  if(!res)
-    objc_error(nil, OBJC_ERR_MEMORY, "Virtual memory exhausted\n");
+  void *res = (void *) (*_objc_atomic_malloc) (size);
+  if (! res)
+    objc_error (nil, OBJC_ERR_MEMORY, "Virtual memory exhausted\n");
   return res;
 }
 
 void *
-objc_valloc(size_t size)
+objc_valloc (size_t size)
 {
-  void* res = (void*) (*_objc_valloc)(size);
-  if(!res)
-    objc_error(nil, OBJC_ERR_MEMORY, "Virtual memory exhausted\n");
+  void *res = (void *) (*_objc_valloc) (size);
+  if (! res)
+    objc_error (nil, OBJC_ERR_MEMORY, "Virtual memory exhausted\n");
   return res;
 }
 
 void *
-objc_realloc(void *mem, size_t size)
+objc_realloc (void *mem, size_t size)
 {
-  void* res = (void*) (*_objc_realloc)(mem, size);
-  if(!res)
-    objc_error(nil, OBJC_ERR_MEMORY, "Virtual memory exhausted\n");
+  void *res = (void *) (*_objc_realloc) (mem, size);
+  if (! res)
+    objc_error (nil, OBJC_ERR_MEMORY, "Virtual memory exhausted\n");
   return res;
 }
 
 void *
-objc_calloc(size_t nelem, size_t size)
+objc_calloc (size_t nelem, size_t size)
 {
-  void* res = (void*) (*_objc_calloc)(nelem, size);
-  if(!res)
-    objc_error(nil, OBJC_ERR_MEMORY, "Virtual memory exhausted\n");
+  void *res = (void *) (*_objc_calloc) (nelem, size);
+  if (! res)
+    objc_error (nil, OBJC_ERR_MEMORY, "Virtual memory exhausted\n");
   return res;
 }
 
 void
-objc_free(void *mem)
+objc_free (void *mem)
 {
-  (*_objc_free)(mem);
+  (*_objc_free) (mem);
 }
 
@@ -149 +150 @@
 #include <gc.h>
 
-static void *GC_calloc (size_t nelem, size_t size)
+static void *
+GC_calloc (size_t nelem, size_t size)
 {
-  void* p = GC_malloc (nelem * size);
-  if (!p)
+  void *p = GC_malloc (nelem * size);
+  if (! p)
     objc_error (nil, OBJC_ERR_MEMORY, "Virtual memory exhausted!\n");
 
@@ -159 +161 @@
 }
 
-static void noFree (void* p) {}
+static void
+noFree (void *p)
+{
+}
 
-void *(*_objc_malloc)(size_t) = GC_malloc;
-void *(*_objc_atomic_malloc)(size_t) = GC_malloc_atomic;
-void *(*_objc_valloc)(size_t) = GC_malloc;
-void *(*_objc_realloc)(void *, size_t) = GC_realloc;
-void *(*_objc_calloc)(size_t, size_t) = GC_calloc;
-void (*_objc_free)(void *) = noFree;
+void *(*_objc_malloc) (size_t) = GC_malloc;
+void *(*_objc_atomic_malloc) (size_t) = GC_malloc_atomic;
+void *(*_objc_valloc) (size_t) = GC_malloc;
+void *(*_objc_realloc) (void *, size_t) = GC_realloc;
+void *(*_objc_calloc) (size_t, size_t) = GC_calloc;
+void (*_objc_free) (void *) = noFree;
 
-#else
+#else   /* !OBJC_WITH_GC */
 
-void *(*_objc_malloc)(size_t) = malloc;
-void *(*_objc_atomic_malloc)(size_t) = malloc;
-void *(*_objc_valloc)(size_t) = malloc;
-void *(*_objc_realloc)(void *, size_t) = realloc;
-void *(*_objc_calloc)(size_t, size_t) = calloc;
-void (*_objc_free)(void *) = free;
+void *(*_objc_malloc) (size_t) = malloc;
+void *(*_objc_atomic_malloc) (size_t) = malloc;
+void *(*_objc_valloc) (size_t) = malloc;
+void *(*_objc_realloc) (void *, size_t) = realloc;
+void *(*_objc_calloc) (size_t, size_t) = calloc;
+void (*_objc_free) (void *) = free;
 
 
-#endif
+#endif  /* !OBJC_WITH_GC */

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

@@ -1 +1 @@
 /* GNU Objective C Runtime nil receiver function
-   Copyright (C) 1993, 1995, 1996 Free Software Foundation, Inc.
+   Copyright (C) 1993, 1995, 1996, 2002 Free Software Foundation, Inc.
    Contributed by Kresten Krab Thorup
 
@@ -30 +30 @@
 #include "runtime.h"
 
+/* When the receiver of a method invocation is nil, the runtime
+   returns nil_method() as the method implementation.  This function
+   will be casted to whatever function was supposed to be executed to
+   execute that method (that function will take an id, followed by a
+   SEL, followed by who knows what arguments, depends on the method),
+   and executed.
+   
+   For this reason, nil_method() should be a function which can be
+   called in place of any function taking an 'id' argument followed by
+   a 'SEL' argument, followed by zero, or one, or any number of
+   arguments (both a fixed number, or a variable number !).
+   
+   There is no "proper" implementation of such a nil_method function
+   in C, however in all existing implementations it does not matter
+   when extra arguments are present, so we can simply create a function
+   taking a receiver and a selector, and all other arguments will be
+   ignored. :-)
+*/
+
 id
-nil_method(id receiver, SEL op, ...)
+nil_method (id receiver, SEL op __attribute__ ((__unused__)))
 {
   return receiver;
 }
-
-
-
-

branches/GNU/src/gcc/libobjc/objc/encoding.h

@@ -1 +1 @@
 /* Encoding of types for Objective C.
-   Copyright (C) 1993, 1997 Free Software Foundation, Inc.
+   Copyright (C) 1993, 1997, 2002 Free Software Foundation, Inc.
 
 Author: Kresten Krab Thorup
@@ -51 +51 @@
 #define _F_GCINVISIBLE  0x20
 
-int objc_aligned_size (const char* type);
-int objc_sizeof_type (const char* type);
-int objc_alignof_type (const char* type);
-int objc_aligned_size (const char* type);
-int objc_promoted_size (const char* type);
+int objc_aligned_size (const char *type);
+int objc_sizeof_type (const char *type);
+int objc_alignof_type (const char *type);
+int objc_aligned_size (const char *type);
+int objc_promoted_size (const char *type);
 
-const char* objc_skip_type_qualifiers (const char* type);
-const char* objc_skip_typespec (const char* type);
-const char* objc_skip_offset (const char* type);
-const char* objc_skip_argspec (const char* type);
-int method_get_number_of_arguments (struct objc_method*);
-int method_get_sizeof_arguments (struct objc_method*);
+const char *objc_skip_type_qualifiers (const char *type);
+const char *objc_skip_typespec (const char *type);
+const char *objc_skip_offset (const char *type);
+const char *objc_skip_argspec (const char *type);
+int method_get_number_of_arguments (struct objc_method *);
+int method_get_sizeof_arguments (struct objc_method *);
 
-char* method_get_first_argument (struct objc_method*,
+char *method_get_first_argument (struct objc_method *,
                                  arglist_t argframe, 
-                                 const char** type);
-char* method_get_next_argument (arglist_t argframe, 
+                                 const char **type);
+char *method_get_next_argument (arglist_t argframe, 
                                 const char **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);
 
-unsigned objc_get_type_qualifiers (const char* type);
+unsigned objc_get_type_qualifiers (const char *type);
 
 

branches/GNU/src/gcc/libobjc/objc/hash.h

@@ -61 +61 @@
  * hash_new will have to be casted to this type. 
  */
-typedef unsigned int (*hash_func_type)(void *, const void *);
+typedef unsigned int (*hash_func_type) (void *, const void *);
 
 /*
@@ -70 +70 @@
  */
 
-typedef int (*compare_func_type)(const void *, const void *);
+typedef int (*compare_func_type) (const void *, const void *);
 
 
@@ -175 +175 @@
         
         
-  while (*(char*)key) {
-    ret ^= *(char*)key++ << ctr;
+  while (*(char *) key) {
+    ret ^= *(char *) key++ << ctr;
     ctr = (ctr + 1) % sizeof (void *);
   }
@@ -188 +188 @@
 compare_ptrs (const void *k1, const void *k2)
 {
-  return !(k1 - k2);
+  return ! (k1 - k2);
 }
 
@@ -201 +201 @@
     return 0;
   else
-    return !strcmp (k1, k2);
+    return ! strcmp (k1, k2);
 }
 

branches/GNU/src/gcc/libobjc/objc/objc.h

@@ -74 +74 @@
 /*
 ** Definition of method type.  When retrieving the implementation of a
-** method, this is type of the pointer returned
+** method, this is type of the pointer returned.  The idea of the
+** definition of IMP is to represent a 'pointer to a general function
+** taking an id, a SEL, followed by other unspecified arguments'.  You
+** must always cast an IMP to a pointer to a function taking the
+** appropriate, specific types for that function, before calling it -
+** to make sure the appropriate arguments are passed to it.  The code
+** generated by the compiler to perform method calls automatically
+** does this cast inside method calls.
 */
 typedef id (*IMP)(id, SEL, ...); 

branches/GNU/src/gcc/libobjc/objc/runtime.h

@@ -1 +1 @@
 /* GNU Objective C Runtime internal declarations
-   Copyright (C) 1993, 1995, 1996, 1997 Free Software Foundation, Inc.
+   Copyright (C) 1993, 1995, 1996, 1997, 2002 Free Software Foundation, Inc.
    Contributed by Kresten Krab Thorup
 
@@ -66 +66 @@
 
 /* Number of selectors stored in each of the selector  tables */
-extern int __objc_selector_max_index;
+extern unsigned int __objc_selector_max_index;
 
 /* Mutex locking __objc_selector_max_index and its arrays. */
@@ -83 +83 @@
 SEL  __sel_register_typed_name (const char*, const char*, 
                                 struct objc_selector*, BOOL is_const);
+extern void __objc_generate_gc_type_description (Class);
 
 #endif /* not __objc_runtime_INCLUDE_GNU */

branches/GNU/src/gcc/libobjc/objc/thr.h

@@ -1 +1 @@
 /* Thread and mutex controls for Objective C.
-   Copyright (C) 1996, 1997 Free Software Foundation, Inc.
+   Copyright (C) 1996, 1997, 2002 Free Software Foundation, Inc.
    Contributed by Galen C. Hunt (gchunt@cs.rochester.edu)
 
@@ -75 +75 @@
 
 /* Frontend mutex functions */
-objc_mutex_t objc_mutex_allocate(void);
-int objc_mutex_deallocate(objc_mutex_t mutex);
-int objc_mutex_lock(objc_mutex_t mutex);
-int objc_mutex_unlock(objc_mutex_t mutex);
-int objc_mutex_trylock(objc_mutex_t mutex);
+objc_mutex_t objc_mutex_allocate (void);
+int objc_mutex_deallocate (objc_mutex_t mutex);
+int objc_mutex_lock (objc_mutex_t mutex);
+int objc_mutex_unlock (objc_mutex_t mutex);
+int objc_mutex_trylock (objc_mutex_t mutex);
 
 /* Frontend condition mutex functions */
-objc_condition_t objc_condition_allocate(void);
-int objc_condition_deallocate(objc_condition_t condition);
-int objc_condition_wait(objc_condition_t condition, objc_mutex_t mutex);
-int objc_condition_signal(objc_condition_t condition);
-int objc_condition_broadcast(objc_condition_t condition);
+objc_condition_t objc_condition_allocate (void);
+int objc_condition_deallocate (objc_condition_t condition);
+int objc_condition_wait (objc_condition_t condition, objc_mutex_t mutex);
+int objc_condition_signal (objc_condition_t condition);
+int objc_condition_broadcast (objc_condition_t condition);
 
 /* Frontend thread functions */
-objc_thread_t objc_thread_detach(SEL selector, id object, id argument);
-void objc_thread_yield(void);
-int objc_thread_exit(void);
-int objc_thread_set_priority(int priority);
-int objc_thread_get_priority(void);
-void * objc_thread_get_data(void);
-int objc_thread_set_data(void *value);
-objc_thread_t objc_thread_id(void);
-void objc_thread_add(void);
-void objc_thread_remove(void);
+objc_thread_t objc_thread_detach (SEL selector, id object, id argument);
+void objc_thread_yield (void);
+int objc_thread_exit (void);
+int objc_thread_set_priority (int priority);
+int objc_thread_get_priority (void);
+void * objc_thread_get_data (void);
+int objc_thread_set_data (void *value);
+objc_thread_t objc_thread_id (void);
+void objc_thread_add (void);
+void objc_thread_remove (void);
 
 /*
@@ -112 +112 @@
   so it can implement the NSBecomingMultiThreaded notification.
   */
-typedef void (*objc_thread_callback)();
-objc_thread_callback objc_set_thread_callback(objc_thread_callback func);
+typedef void (*objc_thread_callback) (void);
+objc_thread_callback objc_set_thread_callback (objc_thread_callback func);
 
 /* Backend initialization functions */
-int __objc_init_thread_system(void);
-int __objc_fini_thread_system(void);
+int __objc_init_thread_system (void);
+int __objc_fini_thread_system (void);
 
 /* Backend mutex functions */
-int __objc_mutex_allocate(objc_mutex_t mutex);
-int __objc_mutex_deallocate(objc_mutex_t mutex);
-int __objc_mutex_lock(objc_mutex_t mutex);
-int __objc_mutex_trylock(objc_mutex_t mutex);
-int __objc_mutex_unlock(objc_mutex_t mutex);
+int __objc_mutex_allocate (objc_mutex_t mutex);
+int __objc_mutex_deallocate (objc_mutex_t mutex);
+int __objc_mutex_lock (objc_mutex_t mutex);
+int __objc_mutex_trylock (objc_mutex_t mutex);
+int __objc_mutex_unlock (objc_mutex_t mutex);
 
 /* Backend condition mutex functions */
-int __objc_condition_allocate(objc_condition_t condition);
-int __objc_condition_deallocate(objc_condition_t condition);
-int __objc_condition_wait(objc_condition_t condition, objc_mutex_t mutex);
-int __objc_condition_broadcast(objc_condition_t condition);
-int __objc_condition_signal(objc_condition_t condition);
+int __objc_condition_allocate (objc_condition_t condition);
+int __objc_condition_deallocate (objc_condition_t condition);
+int __objc_condition_wait (objc_condition_t condition, objc_mutex_t mutex);
+int __objc_condition_broadcast (objc_condition_t condition);
+int __objc_condition_signal (objc_condition_t condition);
 
 /* Backend thread functions */
-objc_thread_t __objc_thread_detach(void (*func)(void *arg), void *arg);
-int __objc_thread_set_priority(int priority);
-int __objc_thread_get_priority(void);
-void __objc_thread_yield(void);
-int __objc_thread_exit(void);
-objc_thread_t __objc_thread_id(void);
-int __objc_thread_set_data(void *value);
-void * __objc_thread_get_data(void);
+objc_thread_t __objc_thread_detach (void (*func) (void *arg), void *arg);
+int __objc_thread_set_priority (int priority);
+int __objc_thread_get_priority (void);
+void __objc_thread_yield (void);
+int __objc_thread_exit (void);
+objc_thread_t __objc_thread_id (void);
+int __objc_thread_set_data (void *value);
+void * __objc_thread_get_data (void);
 
 #endif /* not __thread_INCLUDE_GNU */

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

@@ -33 +33 @@
 #endif
 
-id __objc_object_alloc(Class);
-id __objc_object_dispose(id);
-id __objc_object_copy(id);
+id __objc_object_alloc (Class);
+id __objc_object_dispose (id);
+id __objc_object_copy (id);
 
-id (*_objc_object_alloc)(Class)   = __objc_object_alloc;   /* !T:SINGLE */ 
-id (*_objc_object_dispose)(id)    = __objc_object_dispose; /* !T:SINGLE */
-id (*_objc_object_copy)(id)       = __objc_object_copy;    /* !T:SINGLE */
+id (*_objc_object_alloc) (Class)   = __objc_object_alloc;   /* !T:SINGLE */ 
+id (*_objc_object_dispose) (id)    = __objc_object_dispose; /* !T:SINGLE */
+id (*_objc_object_copy) (id)       = __objc_object_copy;    /* !T:SINGLE */
 
 id
-class_create_instance(Class class)
+class_create_instance (Class class)
 {
   id new = nil;
 
 #if OBJC_WITH_GC
-  if (CLS_ISCLASS(class))
-    new = (id)GC_malloc_explicitly_typed (class->instance_size,
-                                          class->gc_object_type);
+  if (CLS_ISCLASS (class))
+    new = (id) GC_malloc_explicitly_typed (class->instance_size,
+                                           class->gc_object_type);
 #else
-  if (CLS_ISCLASS(class))
-    new = (*_objc_object_alloc)(class);
+  if (CLS_ISCLASS (class))
+    new = (*_objc_object_alloc) (class);
 #endif
 
-  if (new!=nil)
+  if (new != nil)
     {
       memset (new, 0, class->instance_size);
@@ -64 +64 @@
 
 id
-object_copy(id object)
+object_copy (id object)
 {
-  if ((object!=nil)&&CLS_ISCLASS(object->class_pointer))
-    return (*_objc_object_copy)(object);
+  if ((object != nil) && CLS_ISCLASS (object->class_pointer))
+    return (*_objc_object_copy) (object);
   else
     return nil;
@@ -73 +73 @@
 
 id
-object_dispose(id object)
+object_dispose (id object)
 {
-  if ((object!=nil)&&CLS_ISCLASS(object->class_pointer))
+  if ((object != nil) && CLS_ISCLASS (object->class_pointer))
     {
       if (_objc_object_dispose)
-        (*_objc_object_dispose)(object);
+        (*_objc_object_dispose) (object);
       else
-        objc_free(object);
+        objc_free (object);
     }
   return nil;
 }
 
-id __objc_object_alloc(Class class)
+id __objc_object_alloc (Class class)
 {
-  return (id)objc_malloc(class->instance_size);
+  return (id) objc_malloc (class->instance_size);
 }
 
-id __objc_object_dispose(id object) 
+id __objc_object_dispose (id object) 
 {
-  objc_free(object);
+  objc_free (object);
   return 0;
 }
 
-id __objc_object_copy(id object)
+id __objc_object_copy (id object)
 {
-  id copy = class_create_instance(object->class_pointer);
-  memcpy(copy, object, object->class_pointer->instance_size);
+  id copy = class_create_instance (object->class_pointer);
+  memcpy (copy, object, object->class_pointer->instance_size);
   return copy;
 }
-
-

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

@@ -1 +1 @@
 /* Sparse Arrays for Objective C dispatch tables
-   Copyright (C) 1993, 1995, 1996 Free Software Foundation, Inc.
+   Copyright (C) 1993, 1995, 1996, 2002 Free Software Foundation, Inc.
 
 This file is part of GNU CC.
@@ -35 +35 @@
 int idxsize = 0;                                        /* !T:MUTEX */
 
-static void *   first_free_data = NULL;                 /* !T:MUTEX */
+static void *first_free_data = NULL;                    /* !T:MUTEX */
 
 #ifdef OBJC_SPARSE2
-const char* __objc_sparse2_id = "2 level sparse indices";
-#endif
-
-#ifdef OBJC_SPARSE3
-const char* __objc_sparse3_id = "3 level sparse indices";
+const char *__objc_sparse2_id = "2 level sparse indices";
+#endif
+
+#ifdef OBJC_SPARSE3
+const char *__objc_sparse3_id = "3 level sparse indices";
 #endif
 
@@ -48 +48 @@
    that were not safe in a multi-threaded environment. */
 void
-sarray_remove_garbage(void)
+sarray_remove_garbage (void)
 {
   void **vp;
   void *np;
   
-  objc_mutex_lock(__objc_runtime_mutex);
+  objc_mutex_lock (__objc_runtime_mutex);
 
   vp = first_free_data;
@@ -60 +60 @@
   while (vp) {
     np = *vp;
-    objc_free(vp);
+    objc_free (vp);
     vp = np;
   }
   
-  objc_mutex_unlock(__objc_runtime_mutex);
+  objc_mutex_unlock (__objc_runtime_mutex);
 }
 
@@ -72 +72 @@
 
 static void
-sarray_free_garbage(void *vp)
-{
-  objc_mutex_lock(__objc_runtime_mutex);
+sarray_free_garbage (void *vp)
+{
+  objc_mutex_lock (__objc_runtime_mutex);
   
   if (__objc_runtime_threads_alive == 1) {
-    objc_free(vp);
+    objc_free (vp);
     if (first_free_data)
-      sarray_remove_garbage();
+      sarray_remove_garbage ();
   }
   else {
@@ -86 +86 @@
   }
       
-  objc_mutex_unlock(__objc_runtime_mutex);
+  objc_mutex_unlock (__objc_runtime_mutex);
 }
 
 /* sarray_at_put : copies data in such a way as to be thread reader safe. */
 void
-sarray_at_put(struct sarray* array, sidx index, void* element)
-{
-#ifdef OBJC_SPARSE3
-  struct sindex** the_index;
-  struct sindex*  new_index;
-#endif
-  struct sbucket** the_bucket;
-  struct sbucket*  new_bucket;
+sarray_at_put (struct sarray *array, sidx index, void *element)
+{
+#ifdef OBJC_SPARSE3
+  struct sindex **the_index;
+  struct sindex *new_index;
+#endif
+  struct sbucket **the_bucket;
+  struct sbucket *new_bucket;
 #ifdef OBJC_SPARSE3
   size_t ioffset;
@@ -123 +123 @@
 #endif /* not PRECOMPUTE_SELECTORS */
 
-  assert(soffset_decode(index) < array->capacity); /* Range check */
+  assert (soffset_decode (index) < array->capacity); /* Range check */
 
 #ifdef OBJC_SPARSE3
@@ -142 +142 @@
 
     /* The index was previously empty, allocate a new */
-    new_index = (struct sindex*)objc_malloc(sizeof(struct sindex));
-    memcpy(new_index, array->empty_index, sizeof(struct sindex));
+    new_index = (struct sindex *) objc_malloc (sizeof (struct sindex));
+    memcpy (new_index, array->empty_index, sizeof (struct sindex));
     new_index->version.version = array->version.version;
     *the_index = new_index;                     /* Prepared for install. */
@@ -152 +152 @@
 
     /* This index must be lazy copied */
-    struct sindex* old_index = *the_index;
-    new_index = (struct sindex*)objc_malloc(sizeof(struct sindex));
-    memcpy( new_index, old_index, sizeof(struct sindex));
+    struct sindex *old_index = *the_index;
+    new_index = (struct sindex *) objc_malloc (sizeof (struct sindex));
+    memcpy (new_index, old_index, sizeof (struct sindex));
     new_index->version.version = array->version.version;
     *the_index = new_index;                     /* Prepared for install. */
@@ -170 +170 @@
     /* The bucket was previously empty (or something like that), */
     /* allocate a new.  This is the effect of `lazy' allocation */  
-    new_bucket = (struct sbucket*)objc_malloc(sizeof(struct sbucket));
-    memcpy((void *) new_bucket, (const void*)array->empty_bucket, 
-           sizeof(struct sbucket));
+    new_bucket = (struct sbucket *) objc_malloc (sizeof (struct sbucket));
+    memcpy ((void *) new_bucket, (const void *) array->empty_bucket, 
+            sizeof (struct sbucket));
     new_bucket->version.version = array->version.version;
     *the_bucket = new_bucket;                   /* Prepared for install. */
@@ -181 +181 @@
 
     /* Perform lazy copy. */
-    struct sbucket* old_bucket = *the_bucket;
-    new_bucket = (struct sbucket*)objc_malloc(sizeof(struct sbucket));
-    memcpy( new_bucket, old_bucket, sizeof(struct sbucket));
+    struct sbucket *old_bucket = *the_bucket;
+    new_bucket = (struct sbucket *) objc_malloc (sizeof (struct sbucket));
+    memcpy (new_bucket, old_bucket, sizeof (struct sbucket));
     new_bucket->version.version = array->version.version;
     *the_bucket = new_bucket;                   /* Prepared for install. */
@@ -194 +194 @@
 
 void
-sarray_at_put_safe(struct sarray* array, sidx index, void* element)
-{
-  if(soffset_decode(index) >= array->capacity)
-    sarray_realloc(array, soffset_decode(index)+1);
-  sarray_at_put(array, index, element);
-}
-
-struct sarray* 
-sarray_new (int size, void* default_element)
-{
-  struct sarray* arr;
-#ifdef OBJC_SPARSE3
-  size_t num_indices = ((size-1)/(INDEX_CAPACITY))+1;
-  struct sindex ** new_indices;
-#else /* OBJC_SPARSE2 */
-  size_t num_indices = ((size-1)/BUCKET_SIZE)+1;
-  struct sbucket ** new_buckets;
-#endif
-  int counter;
-
-  assert(size > 0);
+sarray_at_put_safe (struct sarray *array, sidx index, void *element)
+{
+  if (soffset_decode (index) >= array->capacity)
+    sarray_realloc (array, soffset_decode (index) + 1);
+  sarray_at_put (array, index, element);
+}
+
+struct sarray *
+sarray_new (int size, void *default_element)
+{
+  struct sarray *arr;
+#ifdef OBJC_SPARSE3
+  size_t num_indices = ((size - 1)/(INDEX_CAPACITY)) + 1;
+  struct sindex **new_indices;
+#else /* OBJC_SPARSE2 */
+  size_t num_indices = ((size - 1)/BUCKET_SIZE) + 1;
+  struct sbucket **new_buckets;
+#endif
+  size_t counter;
+
+  assert (size > 0);
 
   /* Allocate core array */
-  arr = (struct sarray*) objc_malloc(sizeof(struct sarray));
+  arr = (struct sarray *) objc_malloc (sizeof (struct sarray));
   arr->version.version = 0;
   
@@ -223 +223 @@
 #ifdef OBJC_SPARSE3
   arr->capacity = num_indices*INDEX_CAPACITY;
-  new_indices = (struct sindex**) 
-    objc_malloc(sizeof(struct sindex*)*num_indices);
-
-  arr->empty_index = (struct sindex*) objc_malloc(sizeof(struct sindex));
+  new_indices = (struct sindex **) 
+    objc_malloc (sizeof (struct sindex *) * num_indices);
+
+  arr->empty_index = (struct sindex *) objc_malloc (sizeof (struct sindex));
   arr->empty_index->version.version = 0;
   
@@ -235 +235 @@
 #else /* OBJC_SPARSE2 */
   arr->capacity = num_indices*BUCKET_SIZE;
-  new_buckets = (struct sbucket**) 
-    objc_malloc(sizeof(struct sbucket*)*num_indices);
+  new_buckets = (struct sbucket **) 
+    objc_malloc (sizeof (struct sbucket *) * num_indices);
   
   narrays  += 1;
@@ -243 +243 @@
 #endif
 
-  arr->empty_bucket = (struct sbucket*) objc_malloc(sizeof(struct sbucket));
+  arr->empty_bucket = (struct sbucket *) objc_malloc (sizeof (struct sbucket));
   arr->empty_bucket->version.version = 0;
   
@@ -249 +249 @@
 
   arr->ref_count = 1;
-  arr->is_copy_of = (struct sarray*)0;
-  
-  for (counter=0; counter<BUCKET_SIZE; counter++)
+  arr->is_copy_of = (struct sarray *) 0;
+  
+  for (counter = 0; counter < BUCKET_SIZE; counter++)
     arr->empty_bucket->elems[counter] = default_element;
 
 #ifdef OBJC_SPARSE3
-  for (counter=0; counter<INDEX_SIZE; counter++)
+  for (counter = 0; counter < INDEX_SIZE; counter++)
     arr->empty_index->buckets[counter] = arr->empty_bucket;
 
-  for (counter=0; counter<num_indices; counter++)
+  for (counter = 0; counter < num_indices; counter++)
     new_indices[counter] = arr->empty_index;
 
 #else /* OBJC_SPARSE2 */
 
-  for (counter=0; counter<num_indices; counter++)
+  for (counter = 0; counter < num_indices; counter++)
     new_buckets[counter] = arr->empty_bucket;
 
@@ -284 +284 @@
 
 void 
-sarray_realloc(struct sarray* array, int newsize)
-{
-#ifdef OBJC_SPARSE3
-  size_t old_max_index = (array->capacity-1)/INDEX_CAPACITY;
-  size_t new_max_index = ((newsize-1)/INDEX_CAPACITY);
-  size_t rounded_size = (new_max_index+1)*INDEX_CAPACITY;
-
-  struct sindex ** new_indices;
-  struct sindex ** old_indices;
-  
-#else /* OBJC_SPARSE2 */
-  size_t old_max_index = (array->capacity-1)/BUCKET_SIZE;
-  size_t new_max_index = ((newsize-1)/BUCKET_SIZE);
-  size_t rounded_size = (new_max_index+1)*BUCKET_SIZE;
-
-  struct sbucket ** new_buckets;
-  struct sbucket ** old_buckets;
-  
-#endif
-
-  int counter;
-
-  assert(newsize > 0);
+sarray_realloc (struct sarray *array, int newsize)
+{
+#ifdef OBJC_SPARSE3
+  size_t old_max_index = (array->capacity - 1)/INDEX_CAPACITY;
+  size_t new_max_index = ((newsize - 1)/INDEX_CAPACITY);
+  size_t rounded_size = (new_max_index + 1) * INDEX_CAPACITY;
+
+  struct sindex **new_indices;
+  struct sindex **old_indices;
+  
+#else /* OBJC_SPARSE2 */
+  size_t old_max_index = (array->capacity - 1)/BUCKET_SIZE;
+  size_t new_max_index = ((newsize - 1)/BUCKET_SIZE);
+  size_t rounded_size = (new_max_index + 1) * BUCKET_SIZE;
+
+  struct sbucket **new_buckets;
+  struct sbucket **old_buckets;
+  
+#endif
+
+  size_t counter;
+
+  assert (newsize > 0);
 
   /* The size is the same, just ignore the request */
-  if(rounded_size <= array->capacity)
+  if (rounded_size <= array->capacity)
     return;
 
-  assert(array->ref_count == 1);        /* stop if lazy copied... */
+  assert (array->ref_count == 1);       /* stop if lazy copied... */
 
   /* We are asked to extend the array -- allocate new bucket table, */
   /* and insert empty_bucket in newly allocated places. */
-  if(rounded_size > array->capacity) 
+  if (rounded_size > array->capacity) 
     {
 
 #ifdef OBJC_SPARSE3
       new_max_index += 4;
-      rounded_size = (new_max_index+1)*INDEX_CAPACITY;
+      rounded_size = (new_max_index + 1) * INDEX_CAPACITY;
       
 #else /* OBJC_SPARSE2 */
       new_max_index += 4;
-      rounded_size = (new_max_index+1)*BUCKET_SIZE;
+      rounded_size = (new_max_index + 1) * BUCKET_SIZE;
 #endif
       
@@ -334 +334 @@
       /* alloc to force re-read by any concurrent readers. */
       old_indices = array->indices;
-      new_indices = (struct sindex**)
-        objc_malloc((new_max_index+1)*sizeof(struct sindex*));
+      new_indices = (struct sindex **)
+        objc_malloc ((new_max_index + 1) * sizeof (struct sindex *));
 #else /* OBJC_SPARSE2 */
       old_buckets = array->buckets;
-      new_buckets = (struct sbucket**)
-        objc_malloc((new_max_index+1)*sizeof(struct sbucket*));
+      new_buckets = (struct sbucket **)
+        objc_malloc ((new_max_index + 1) * sizeof (struct sbucket *));
 #endif
 
       /* copy buckets below old_max_index (they are still valid) */
-      for(counter = 0; counter <= old_max_index; counter++ ) {
+      for (counter = 0; counter <= old_max_index; counter++ ) {
 #ifdef OBJC_SPARSE3
         new_indices[counter] = old_indices[counter];
@@ -353 +353 @@
 #ifdef OBJC_SPARSE3
       /* reset entries above old_max_index to empty_bucket */
-      for(counter = old_max_index+1; counter <= new_max_index; counter++)
+      for (counter = old_max_index + 1; counter <= new_max_index; counter++)
         new_indices[counter] = array->empty_index;
 #else /* OBJC_SPARSE2 */
       /* reset entries above old_max_index to empty_bucket */
-      for(counter = old_max_index+1; counter <= new_max_index; counter++)
+      for (counter = old_max_index + 1; counter <= new_max_index; counter++)
         new_buckets[counter] = array->empty_bucket;
 #endif
@@ -370 +370 @@
 #ifdef OBJC_SPARSE3
       /* free the old indices */
-      sarray_free_garbage(old_indices);
-#else /* OBJC_SPARSE2 */
-      sarray_free_garbage(old_buckets);
+      sarray_free_garbage (old_indices);
+#else /* OBJC_SPARSE2 */
+      sarray_free_garbage (old_buckets);
 #endif
       
@@ -385 +385 @@
 
 void 
-sarray_free(struct sarray* array) {
-
-#ifdef OBJC_SPARSE3
-  size_t old_max_index = (array->capacity-1)/INDEX_CAPACITY;
-  struct sindex ** old_indices;
+sarray_free (struct sarray *array) {
+#ifdef OBJC_SPARSE3
+  size_t old_max_index = (array->capacity - 1)/INDEX_CAPACITY;
+  struct sindex **old_indices;
 #else
-  size_t old_max_index = (array->capacity-1)/BUCKET_SIZE;
-  struct sbucket ** old_buckets;
-#endif
-  int counter = 0;
-
-  assert(array->ref_count != 0);        /* Freed multiple times!!! */
-
-  if(--(array->ref_count) != 0) /* There exists copies of me */
+  size_t old_max_index = (array->capacity - 1)/BUCKET_SIZE;
+  struct sbucket **old_buckets;
+#endif
+  size_t counter = 0;
+
+  assert (array->ref_count != 0);       /* Freed multiple times!!! */
+
+  if (--(array->ref_count) != 0)        /* There exists copies of me */
     return;
 
@@ -407 +406 @@
 #endif
   
-  if((array->is_copy_of) && ((array->is_copy_of->ref_count - 1) == 0))
-    sarray_free(array->is_copy_of);
+  if ((array->is_copy_of) && ((array->is_copy_of->ref_count - 1) == 0))
+    sarray_free (array->is_copy_of);
 
   /* Free all entries that do not point to empty_bucket */
-  for(counter = 0; counter <= old_max_index; counter++ ) {
-#ifdef OBJC_SPARSE3
-    struct sindex* idx = old_indices[counter];
-    if((idx != array->empty_index) &&
+  for (counter = 0; counter <= old_max_index; counter++ ) {
+#ifdef OBJC_SPARSE3
+    struct sindex *idx = old_indices[counter];
+    if ((idx != array->empty_index) &&
        (idx->version.version == array->version.version)) {
       int c2; 
-      for(c2=0; c2<INDEX_SIZE; c2++) {
-        struct sbucket* bkt = idx->buckets[c2];
-        if((bkt != array->empty_bucket) &&
+      for (c2 = 0; c2 < INDEX_SIZE; c2++) {
+        struct sbucket *bkt = idx->buckets[c2];
+        if ((bkt != array->empty_bucket) &&
            (bkt->version.version == array->version.version))
           {
-            sarray_free_garbage(bkt);
+            sarray_free_garbage (bkt);
             nbuckets -= 1;
           }
       }
-      sarray_free_garbage(idx);
+      sarray_free_garbage (idx);
       nindices -= 1;
     }
 #else /* OBJC_SPARSE2 */
-    struct sbucket* bkt = array->buckets[counter];
+    struct sbucket *bkt = array->buckets[counter];
     if ((bkt != array->empty_bucket) &&
         (bkt->version.version == array->version.version))
       {
-        sarray_free_garbage(bkt);
+        sarray_free_garbage (bkt);
         nbuckets -= 1;
       }
@@ -442 +441 @@
 #ifdef OBJC_SPARSE3  
   /* free empty_index */
-  if(array->empty_index->version.version == array->version.version) {
-    sarray_free_garbage(array->empty_index);
+  if (array->empty_index->version.version == array->version.version) {
+    sarray_free_garbage (array->empty_index);
     nindices -= 1;
   }
@@ -449 +448 @@
 
   /* free empty_bucket */
-  if(array->empty_bucket->version.version == array->version.version) {
-    sarray_free_garbage(array->empty_bucket);
+  if (array->empty_bucket->version.version == array->version.version) {
+    sarray_free_garbage (array->empty_bucket);
     nbuckets -= 1;
   }
-  idxsize -= (old_max_index+1);
+  idxsize -= (old_max_index + 1);
   narrays -= 1;
 
 #ifdef OBJC_SPARSE3
   /* free bucket table */
-  sarray_free_garbage(array->indices);
+  sarray_free_garbage (array->indices);
 
 #else
   /* free bucket table */
-  sarray_free_garbage(array->buckets);
+  sarray_free_garbage (array->buckets);
 
 #endif
   
   /* free array */
-  sarray_free_garbage(array);
+  sarray_free_garbage (array);
 }
 
@@ -473 +472 @@
 /* copied.   */
 
-struct sarray* 
-sarray_lazy_copy(struct sarray* oarr)
-{
-  struct sarray* arr;
-
-#ifdef OBJC_SPARSE3
-  size_t num_indices = ((oarr->capacity-1)/INDEX_CAPACITY)+1;
-  struct sindex ** new_indices;
-#else /* OBJC_SPARSE2 */
-  size_t num_indices = ((oarr->capacity-1)/BUCKET_SIZE)+1;
-  struct sbucket ** new_buckets;
+struct sarray *
+sarray_lazy_copy (struct sarray *oarr)
+{
+  struct sarray *arr;
+
+#ifdef OBJC_SPARSE3
+  size_t num_indices = ((oarr->capacity - 1)/INDEX_CAPACITY) + 1;
+  struct sindex **new_indices;
+#else /* OBJC_SPARSE2 */
+  size_t num_indices = ((oarr->capacity - 1)/BUCKET_SIZE) + 1;
+  struct sbucket **new_buckets;
 #endif
 
   /* Allocate core array */
-  arr = (struct sarray*) objc_malloc(sizeof(struct sarray)); /* !!! */
+  arr = (struct sarray *) objc_malloc (sizeof (struct sarray)); /* !!! */
   arr->version.version = oarr->version.version + 1;
 #ifdef OBJC_SPARSE3
@@ -500 +499 @@
 #ifdef OBJC_SPARSE3
   /* Copy bucket table */
-  new_indices = (struct sindex**) 
-    objc_malloc(sizeof(struct sindex*)*num_indices);
-  memcpy( new_indices,oarr->indices, 
-        sizeof(struct sindex*)*num_indices);
+  new_indices = (struct sindex **) 
+    objc_malloc (sizeof (struct sindex *) * num_indices);
+  memcpy (new_indices, oarr->indices, sizeof (struct sindex *) * num_indices);
   arr->indices = new_indices;
 #else 
   /* Copy bucket table */
-  new_buckets = (struct sbucket**) 
-    objc_malloc(sizeof(struct sbucket*)*num_indices);
-  memcpy( new_buckets,oarr->buckets, 
-        sizeof(struct sbucket*)*num_indices);
+  new_buckets = (struct sbucket **) 
+    objc_malloc (sizeof (struct sbucket *) * num_indices);
+  memcpy (new_buckets, oarr->buckets, sizeof (struct sbucket *) * num_indices);
   arr->buckets = new_buckets;
 #endif

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

@@ -1 +1 @@
 /* GNU Objective C Runtime selector related functions
-   Copyright (C) 1993, 1995, 1996, 1997 Free Software Foundation, Inc.
+   Copyright (C) 1993, 1995, 1996, 1997, 2002 Free Software Foundation, Inc.
    Contributed by Kresten Krab Thorup
 
@@ -32 +32 @@
 
 /* Tables mapping selector names to uid and opposite */
-static struct sarray* __objc_selector_array = 0; /* uid -> sel  !T:MUTEX */
-static struct sarray* __objc_selector_names = 0; /* uid -> name !T:MUTEX */
+static struct sarray *__objc_selector_array = 0; /* uid -> sel  !T:MUTEX */
+static struct sarray *__objc_selector_names = 0; /* uid -> name !T:MUTEX */
 static cache_ptr      __objc_selector_hash  = 0; /* name -> uid !T:MUTEX */
 
-static void register_selectors_from_list(MethodList_t);
+static void register_selectors_from_list (MethodList_t);
 
 /* Number of selectors stored in each of the above tables */
-int __objc_selector_max_index = 0;              /* !T:MUTEX */
-
-void __objc_init_selector_tables()
+unsigned int __objc_selector_max_index = 0;     /* !T:MUTEX */
+
+void __objc_init_selector_tables ()
 {
   __objc_selector_array = sarray_new (SELECTOR_HASH_SIZE, 0);
@@ -82 +82 @@
       Method_t method = &method_list->method_list[i];
       method->method_name 
-        = sel_register_typed_name ((const char*)method->method_name, 
-                                     method->method_types);
+        = sel_register_typed_name ((const char *) method->method_name, 
+                                   method->method_types);
       i += 1;
     }
@@ -90 +90 @@
 
 /* Register instance methods as class methods for root classes */
-void __objc_register_instance_methods_to_class(Class class)
+void __objc_register_instance_methods_to_class (Class class)
 {
   MethodList_t method_list;
@@ -99 +99 @@
 
   /* Only if a root class. */
-  if(class->super_class)
+  if (class->super_class)
     return;
 
   /* Allocate a method list to hold the new class methods */
-  new_list = objc_calloc(sizeof(struct objc_method_list)
-                            + sizeof(struct objc_method[max_methods_no]), 1);
+  new_list = objc_calloc (sizeof (struct objc_method_list)
+                            + sizeof (struct objc_method[max_methods_no]), 1);
   method_list = class->methods;
   class_method_list = class->class_pointer->methods;
@@ -119 +119 @@
           Method_t mth = &method_list->method_list[i];
           if (mth->method_name
-              && !search_for_method_in_list (class_method_list,
+              && ! search_for_method_in_list (class_method_list,
                                               mth->method_name))
             {
@@ -127 +127 @@
   
               /* Reallocate the method list if necessary */
-              if(++new_list->method_count == max_methods_no)
+              if (++new_list->method_count == max_methods_no)
                 new_list =
-                  objc_realloc(new_list, sizeof(struct objc_method_list)
-                                + sizeof(struct 
+                  objc_realloc (new_list, sizeof (struct objc_method_list)
+                                + sizeof (struct 
                                         objc_method[max_methods_no += 16]));
               curr_method = &new_list->method_list[new_list->method_count];
@@ -144 +144 @@
     {
       new_list =
-        objc_realloc(new_list, sizeof(struct objc_method_list)
-                     + sizeof(struct objc_method[new_list->method_count]));
+        objc_realloc (new_list, sizeof (struct objc_method_list)
+                     + sizeof (struct objc_method[new_list->method_count]));
       new_list->method_next = class->class_pointer->methods;
       class->class_pointer->methods = new_list;
@@ -157 +157 @@
    the argframe layout */
 BOOL
-sel_types_match (const char* t1, const char* t2)
-{
-  if (!t1 || !t2)
+sel_types_match (const char *t1, const char *t2)
+{
+  if (! t1 || ! t2)
     return NO;
   while (*t1 && *t2)
@@ -165 +165 @@
       if (*t1 == '+') t1++;
       if (*t2 == '+') t2++;
-      while (isdigit(*t1)) t1++;
-      while (isdigit(*t2)) t2++;
+      while (isdigit ((unsigned char) *t1)) t1++;
+      while (isdigit ((unsigned char) *t2)) t2++;
       /* xxx Remove these next two lines when qualifiers are put in
          all selectors, not just Protocol selectors. */
-      t1 = objc_skip_type_qualifiers(t1);
-      t2 = objc_skip_type_qualifiers(t2);
-      if (!*t1 && !*t2)
+      t1 = objc_skip_type_qualifiers (t1);
+      t2 = objc_skip_type_qualifiers (t2);
+      if (! *t1 && ! *t2)
         return YES;
       if (*t1 != *t2)
@@ -188 +188 @@
   sidx i;
 
-  objc_mutex_lock(__objc_runtime_mutex);
+  objc_mutex_lock (__objc_runtime_mutex);
 
   i = (sidx) hash_value_for_key (__objc_selector_hash, name);
   if (i == 0)
     {
-      objc_mutex_unlock(__objc_runtime_mutex);
+      objc_mutex_unlock (__objc_runtime_mutex);
       return 0;
     }
 
-  for (l = (struct objc_list*)sarray_get_safe (__objc_selector_array, i);
+  for (l = (struct objc_list *) sarray_get_safe (__objc_selector_array, i);
        l; l = l->tail)
     {
-      SEL s = (SEL)l->head;
+      SEL s = (SEL) l->head;
       if (types == 0 || s->sel_types == 0)
         {
           if (s->sel_types == types)
             {
-              objc_mutex_unlock(__objc_runtime_mutex);
+              objc_mutex_unlock (__objc_runtime_mutex);
               return s;
             }
@@ -211 +211 @@
       else if (sel_types_match (s->sel_types, types))
         {
-          objc_mutex_unlock(__objc_runtime_mutex);
+          objc_mutex_unlock (__objc_runtime_mutex);
           return s;
         }
     }
 
-  objc_mutex_unlock(__objc_runtime_mutex);
+  objc_mutex_unlock (__objc_runtime_mutex);
   return 0;
 }
@@ -228 +228 @@
   SEL s = NULL;
 
-  objc_mutex_lock(__objc_runtime_mutex);
+  objc_mutex_lock (__objc_runtime_mutex);
 
   i = (sidx) hash_value_for_key (__objc_selector_hash, name);
   if (i == 0)
     {
-      objc_mutex_unlock(__objc_runtime_mutex);
+      objc_mutex_unlock (__objc_runtime_mutex);
       return 0;
     }
 
-  for (l = (struct objc_list*)sarray_get_safe (__objc_selector_array, i);
+  for (l = (struct objc_list *) sarray_get_safe (__objc_selector_array, i);
        l; l = l->tail)
     {
@@ -243 +243 @@
       if (s->sel_types)
         {
-            objc_mutex_unlock(__objc_runtime_mutex);
+            objc_mutex_unlock (__objc_runtime_mutex);
             return s;
         }
     }
 
-  objc_mutex_unlock(__objc_runtime_mutex);
+  objc_mutex_unlock (__objc_runtime_mutex);
   return s;
 }
@@ -259 +259 @@
   sidx i;
 
-  objc_mutex_lock(__objc_runtime_mutex);
+  objc_mutex_lock (__objc_runtime_mutex);
 
   i = (sidx) hash_value_for_key (__objc_selector_hash, name);
   if (soffset_decode (i) == 0)
     {
-      objc_mutex_unlock(__objc_runtime_mutex);
+      objc_mutex_unlock (__objc_runtime_mutex);
       return 0;
     }
 
-  l = (struct objc_list*)sarray_get_safe (__objc_selector_array, i);
-  objc_mutex_unlock(__objc_runtime_mutex);
+  l = (struct objc_list *) sarray_get_safe (__objc_selector_array, i);
+  objc_mutex_unlock (__objc_runtime_mutex);
 
   if (l == 0)
     return 0;
 
-  return (SEL)l->head;
+  return (SEL) l->head;
 }
 
@@ -286 +286 @@
 /* Get name of selector.  If selector is unknown, the empty string "" 
    is returned */ 
-const char*
-sel_get_name (SEL selector)
+const char *sel_get_name (SEL selector)
 {
   const char *ret;
 
-  objc_mutex_lock(__objc_runtime_mutex);
-  if ((soffset_decode((sidx)selector->sel_id) > 0)
-      && (soffset_decode((sidx)selector->sel_id) <= __objc_selector_max_index))
+  objc_mutex_lock (__objc_runtime_mutex);
+  if ((soffset_decode ((sidx)selector->sel_id) > 0)
+      && (soffset_decode ((sidx)selector->sel_id) <= __objc_selector_max_index))
     ret = sarray_get_safe (__objc_selector_names, (sidx) selector->sel_id);
   else
     ret = 0;
-  objc_mutex_unlock(__objc_runtime_mutex);
+  objc_mutex_unlock (__objc_runtime_mutex);
   return ret;
 }
@@ -309 +308 @@
 
 
-const char*
-sel_get_type (SEL selector)
+const char *sel_get_type (SEL selector)
 {
   if (selector)
@@ -319 +317 @@
 
 /* The uninstalled dispatch table */
-extern struct sarray* __objc_uninstalled_dtable;
+extern struct sarray *__objc_uninstalled_dtable;
 
 /* Store the passed selector name in the selector record and return its
@@ -332 +330 @@
                            struct objc_selector *orig, BOOL is_const)
 {
-  struct objc_selector* j;
+  struct objc_selector *j;
   sidx i;
   struct objc_list *l;
@@ -339 +337 @@
   if (soffset_decode (i) != 0)
     {
-      for (l = (struct objc_list*)sarray_get_safe (__objc_selector_array, i);
+      for (l = (struct objc_list *) sarray_get_safe (__objc_selector_array, i);
            l; l = l->tail)
         {
-          SEL s = (SEL)l->head;
+          SEL s = (SEL) l->head;
           if (types == 0 || s->sel_types == 0)
             {
@@ -349 +347 @@
                   if (orig)
                     {
-                      orig->sel_id = (void*)i;
+                      orig->sel_id = (void *) i;
                       return orig;
                     }
@@ -356 +354 @@
                 }
             }
-          else if (!strcmp (s->sel_types, types))
+          else if (! strcmp (s->sel_types, types))
             {
               if (orig)
                 {
-                  orig->sel_id = (void*)i;
+                  orig->sel_id = (void *) i;
                   return orig;
                 }
@@ -372 +370 @@
         j = objc_malloc (sizeof (struct objc_selector));
 
-      j->sel_id = (void*)i;
+      j->sel_id = (void *) i;
       /* Can we use the pointer or must copy types?  Don't copy if NULL */
       if ((is_const) || (types == 0))
-        j->sel_types = (const char*)types;
+        j->sel_types = (const char *) types;
       else {
-        j->sel_types = (char *) objc_malloc(strlen(types)+1);
-        strcpy((char *)j->sel_types, types);
+        j->sel_types = (char *) objc_malloc (strlen (types) + 1);
+        strcpy ((char *) j->sel_types, types);
       }
-      l = (struct objc_list*)sarray_get_safe (__objc_selector_array, i);
+      l = (struct objc_list *) sarray_get_safe (__objc_selector_array, i);
     }
   else
     {
       __objc_selector_max_index += 1;
-      i = soffset_encode(__objc_selector_max_index);
+      i = soffset_encode (__objc_selector_max_index);
       if (orig)
         j = orig;
@@ -391 +389 @@
         j = objc_malloc (sizeof (struct objc_selector));
         
-      j->sel_id = (void*)i;
+      j->sel_id = (void *) i;
       /* Can we use the pointer or must copy types?  Don't copy if NULL */
       if ((is_const) || (types == 0))
-        j->sel_types = (const char*)types;
+        j->sel_types = (const char *) types;
       else {
-        j->sel_types = (char *) objc_malloc(strlen(types)+1);
-        strcpy((char *)j->sel_types, types);
+        j->sel_types = (char *) objc_malloc (strlen (types) + 1);
+        strcpy ((char *) j->sel_types, types);
       }
       l = 0;
@@ -413 +411 @@
       new_name = name;
     else {
-      new_name = (char *) objc_malloc(strlen(name)+1);
-      strcpy((char *)new_name, name);
-    }
-
-    l = list_cons ((void*)j, l);
+      new_name = (char *) objc_malloc (strlen (name) + 1);
+      strcpy ((char *) new_name, name);
+    }
+
+    l = list_cons ((void *) j, l);
     sarray_at_put_safe (__objc_selector_names, i, (void *) new_name);
     sarray_at_put_safe (__objc_selector_array, i, (void *) l);
@@ -424 +422 @@
   }
 
-  sarray_realloc(__objc_uninstalled_dtable, __objc_selector_max_index+1);
+  sarray_realloc (__objc_uninstalled_dtable, __objc_selector_max_index + 1);
 
   return (SEL) j;
@@ -434 +432 @@
   SEL ret;
     
-  objc_mutex_lock(__objc_runtime_mutex);
+  objc_mutex_lock (__objc_runtime_mutex);
   /* Assume that name is not constant static memory and needs to be
      copied before put into a runtime structure.  is_const == NO */
   ret = __sel_register_typed_name (name, 0, 0, NO);
-  objc_mutex_unlock(__objc_runtime_mutex);
+  objc_mutex_unlock (__objc_runtime_mutex);
   
   return ret;
@@ -448 +446 @@
   SEL ret;
     
-  objc_mutex_lock(__objc_runtime_mutex);
+  objc_mutex_lock (__objc_runtime_mutex);
   /* Assume that name and type are not constant static memory and need to
      be copied before put into a runtime structure.  is_const == NO */
   ret = __sel_register_typed_name (name, type, 0, NO);
-  objc_mutex_unlock(__objc_runtime_mutex);
+  objc_mutex_unlock (__objc_runtime_mutex);
   
   return ret;
 }
-

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

@@ -1 +1 @@
 /* GNU Objective C Runtime message lookup 
    Copyright (C) 1993, 1995, 1996, 1997, 1998,
-   2001 Free Software Foundation, Inc.
+   2001, 2002 Free Software Foundation, Inc.
    Contributed by Kresten Krab Thorup
 
@@ -38 +38 @@
 #define rtx int
 
-#if !defined(STRUCT_VALUE) || STRUCT_VALUE == 0
+#if ! defined (STRUCT_VALUE) || STRUCT_VALUE == 0
 #define INVISIBLE_STRUCT_RETURN 1
 #else
@@ -45 +45 @@
 
 /* The uninstalled dispatch table */
-struct sarray* __objc_uninstalled_dtable = 0;   /* !T:MUTEX */
+struct sarray *__objc_uninstalled_dtable = 0;   /* !T:MUTEX */
 
 /* Hook for method forwarding. If it is set, is invoked to return a
    function that performs the real forwarding. Otherwise the libgcc
    based functions (__builtin_apply and friends) are used. */
-IMP (*__objc_msg_forward)(SEL) = NULL;
+IMP (*__objc_msg_forward) (SEL) = NULL;
 
 /* Send +initialize to class */
-static void __objc_send_initialize(Class);
+static void __objc_send_initialize (Class);
 
 static void __objc_install_dispatch_table_for_class (Class);
 
 /* Forward declare some functions */
-static void __objc_init_install_dtable(id, SEL);
+static void __objc_init_install_dtable (id, SEL);
 
 /* Various forwarding functions that are used based upon the
@@ -66 +66 @@
    __objc_word_forward for pointers or types that fit in registers.
    */
-static double __objc_double_forward(id, SEL, ...);
-static id __objc_word_forward(id, SEL, ...);
+static double __objc_double_forward (id, SEL, ...);
+static id __objc_word_forward (id, SEL, ...);
 typedef struct { id many[8]; } __big;
 #if INVISIBLE_STRUCT_RETURN 
@@ -74 +74 @@
 static id
 #endif
-__objc_block_forward(id, SEL, ...);
+__objc_block_forward (id, SEL, ...);
 static Method_t search_for_method_in_hierarchy (Class class, SEL sel);
-Method_t search_for_method_in_list(MethodList_t list, SEL op);
-id nil_method(id, SEL, ...);
+Method_t search_for_method_in_list (MethodList_t list, SEL op);
+id nil_method (id, SEL);
 
 /* Given a selector, return the proper forwarding implementation. */
@@ -84 +84 @@
 __objc_get_forward_imp (SEL sel)
 {
+  /* If a custom forwarding hook was registered, try getting a forwarding
+   * function from it.  */
   if (__objc_msg_forward)
     {
       IMP result;
-      if ((result = __objc_msg_forward (sel)))
+      if ((result = __objc_msg_forward (sel)) != NULL) 
         return result;
     }
-  else
+
+  /* In all other cases, use the default forwarding functions built using
+   * __builtin_apply and friends.  */
     {
       const char *t = sel->sel_types;
@@ -96 +100 @@
       if (t && (*t == '[' || *t == '(' || *t == '{')
 #ifdef OBJC_MAX_STRUCT_BY_VALUE
-          && objc_sizeof_type(t) > OBJC_MAX_STRUCT_BY_VALUE
+          && objc_sizeof_type (t) > OBJC_MAX_STRUCT_BY_VALUE
 #endif
           )
@@ -112 +116 @@
 get_imp (Class class, SEL sel)
 {
-  void* res = sarray_get_safe (class->dtable, (size_t) sel->sel_id);
+  void *res = sarray_get_safe (class->dtable, (size_t) sel->sel_id);
   if (res == 0)
     {
       /* Not a valid method */
-      if(class->dtable == __objc_uninstalled_dtable)
+      if (class->dtable == __objc_uninstalled_dtable)
         {
           /* The dispatch table needs to be installed. */
-          objc_mutex_lock(__objc_runtime_mutex);
+          objc_mutex_lock (__objc_runtime_mutex);
           __objc_install_dispatch_table_for_class (class);
-          objc_mutex_unlock(__objc_runtime_mutex);
+          objc_mutex_unlock (__objc_runtime_mutex);
           /* Call ourselves with the installed dispatch table
              and get the real method */
-          res = get_imp(class, sel);
+          res = get_imp (class, sel);
         }
       else
@@ -131 +135 @@
              method just doesn't exist for the class.
              Return the forwarding implementation. */
-          res = __objc_get_forward_imp(sel);
+          res = __objc_get_forward_imp (sel);
         }
     }
@@ -144 +148 @@
 __objc_responds_to (id object, SEL sel)
 {
-  void* res;
+  void *res;
 
   /* Install dispatch table if need be */
   if (object->class_pointer->dtable == __objc_uninstalled_dtable)
     {
-      objc_mutex_lock(__objc_runtime_mutex);
+      objc_mutex_lock (__objc_runtime_mutex);
       __objc_install_dispatch_table_for_class (object->class_pointer);
-      objc_mutex_unlock(__objc_runtime_mutex);
+      objc_mutex_unlock (__objc_runtime_mutex);
     }
 
@@ -164 +168 @@
 __inline__
 IMP
-objc_msg_lookup(id receiver, SEL op)
+objc_msg_lookup (id receiver, SEL op)
 {
   IMP result;
-  if(receiver)
+  if (receiver)
     {
       result = sarray_get_safe (receiver->class_pointer->dtable, 
@@ -174 +178 @@
         {
           /* Not a valid method */
-          if(receiver->class_pointer->dtable == __objc_uninstalled_dtable)
+          if (receiver->class_pointer->dtable == __objc_uninstalled_dtable)
             {
               /* The dispatch table needs to be installed.
                  This happens on the very first method call to the class. */
-              __objc_init_install_dtable(receiver, op);
+              __objc_init_install_dtable (receiver, op);
 
               /* Get real method for this in newly installed dtable */
-              result = get_imp(receiver->class_pointer, op);
+              result = get_imp (receiver->class_pointer, op);
             }
           else
@@ -188 +192 @@
                  method just doesn't exist for the class.
                  Attempt to forward the method. */
-              result = __objc_get_forward_imp(op);
+              result = __objc_get_forward_imp (op);
             }
         }
@@ -194 +198 @@
     }
   else
-    return nil_method;
+    return (IMP)nil_method;
 }
 
@@ -203 +207 @@
     return get_imp (super->class, sel);
   else
-    return nil_method;
-}
-
-int method_get_sizeof_arguments (Method*);
+    return (IMP)nil_method;
+}
+
+int method_get_sizeof_arguments (Method *);
 
 retval_t
-objc_msg_sendv(id object, SEL op, arglist_t arg_frame)
-{
-  Method* m = class_get_instance_method(object->class_pointer, op);
+objc_msg_sendv (id object, SEL op, arglist_t arg_frame)
+{
+  Method *m = class_get_instance_method (object->class_pointer, op);
   const char *type;
-  *((id*)method_get_first_argument (m, arg_frame, &type)) = object;
-  *((SEL*)method_get_next_argument (arg_frame, &type)) = op;
-  return __builtin_apply((apply_t)m->method_imp, 
-                         arg_frame,
-                         method_get_sizeof_arguments (m));
+  *((id *) method_get_first_argument (m, arg_frame, &type)) = object;
+  *((SEL *) method_get_next_argument (arg_frame, &type)) = op;
+  return __builtin_apply ((apply_t) m->method_imp, 
+                          arg_frame,
+                          method_get_sizeof_arguments (m));
 }
 
 void
-__objc_init_dispatch_tables()
-{
-  __objc_uninstalled_dtable
-    = sarray_new(200, 0);
+__objc_init_dispatch_tables ()
+{
+  __objc_uninstalled_dtable = sarray_new (200, 0);
 }
 
@@ -231 +234 @@
    for each class, namely when the very first message is sent to it. */
 static void
-__objc_init_install_dtable(id receiver, SEL op)
+__objc_init_install_dtable (id receiver, SEL op __attribute__ ((__unused__)))
 {
   /* This may happen, if the programmer has taken the address of a 
      method before the dtable was initialized... too bad for him! */
-  if(receiver->class_pointer->dtable != __objc_uninstalled_dtable)
+  if (receiver->class_pointer->dtable != __objc_uninstalled_dtable)
     return;
 
-  objc_mutex_lock(__objc_runtime_mutex);
-
-  if(CLS_ISCLASS(receiver->class_pointer))
+  objc_mutex_lock (__objc_runtime_mutex);
+
+  if (CLS_ISCLASS (receiver->class_pointer))
     {
       /* receiver is an ordinary object */
-      assert(CLS_ISCLASS(receiver->class_pointer));
+      assert (CLS_ISCLASS (receiver->class_pointer));
 
       /* install instance methods table */
@@ -250 +253 @@
       /* call +initialize -- this will in turn install the factory 
          dispatch table if not already done :-) */
-      __objc_send_initialize(receiver->class_pointer);
+      __objc_send_initialize (receiver->class_pointer);
     }
   else
     {
       /* receiver is a class object */
-      assert(CLS_ISCLASS((Class)receiver));
-      assert(CLS_ISMETA(receiver->class_pointer));
+      assert (CLS_ISCLASS ((Class)receiver));
+      assert (CLS_ISMETA (receiver->class_pointer));
 
       /* Install real dtable for factory methods */
       __objc_install_dispatch_table_for_class (receiver->class_pointer);
 
-      __objc_send_initialize((Class)receiver);
-    }
-  objc_mutex_unlock(__objc_runtime_mutex);
+      __objc_send_initialize ((Class)receiver);
+    }
+  objc_mutex_unlock (__objc_runtime_mutex);
 }
 
@@ -269 +272 @@
    that class (or instances hereof) to be initialized properly */
 void
-__objc_install_premature_dtable(Class class)
-{
-  assert(__objc_uninstalled_dtable);
+__objc_install_premature_dtable (Class class)
+{
+  assert (__objc_uninstalled_dtable);
   class->dtable = __objc_uninstalled_dtable;
 }   
@@ -277 +280 @@
 /* Send +initialize to class if not already done */
 static void
-__objc_send_initialize(Class class)
+__objc_send_initialize (Class class)
 {
   /* This *must* be a class object */
-  assert(CLS_ISCLASS(class));
-  assert(!CLS_ISMETA(class));
-
-  if (!CLS_ISINITIALIZED(class))
-    {
-      CLS_SETINITIALIZED(class);
-      CLS_SETINITIALIZED(class->class_pointer);
+  assert (CLS_ISCLASS (class));
+  assert (! CLS_ISMETA (class));
+
+  if (! CLS_ISINITIALIZED (class))
+    {
+      CLS_SETINITIALIZED (class);
+      CLS_SETINITIALIZED (class->class_pointer);
 
       /* Create the garbage collector type memory description */
       __objc_generate_gc_type_description (class);
 
-      if(class->super_class)
-        __objc_send_initialize(class->super_class);
+      if (class->super_class)
+        __objc_send_initialize (class->super_class);
 
       {
@@ -303 +306 @@
           Method_t method;
 
-          for (i = 0; i< method_list->method_count; i++) {
+          for (i = 0; i < method_list->method_count; i++) {
             method = &(method_list->method_list[i]);
             if (method->method_name
@@ -319 +322 @@
         }
         if (imp)
-            (*imp)((id)class, op);
+            (*imp) ((id) class, op);
                 
       }
@@ -336 +339 @@
   int i;
 
-  if (!method_list)
+  if (! method_list)
     return;
 
@@ -359 +362 @@
   /* If the class has not yet had its class links resolved, we must 
      re-compute all class links */
-  if(!CLS_ISRESOLV(class))
-    __objc_resolve_class_links();
+  if (! CLS_ISRESOLV (class))
+    __objc_resolve_class_links ();
 
   super = class->super_class;
@@ -370 +373 @@
   if (super == 0)
     {
-      objc_mutex_lock(__objc_runtime_mutex);
+      objc_mutex_lock (__objc_runtime_mutex);
       class->dtable = sarray_new (__objc_selector_max_index, 0);
-      objc_mutex_unlock(__objc_runtime_mutex);
+      objc_mutex_unlock (__objc_runtime_mutex);
     }
   else
@@ -390 +393 @@
     return;
 
-  objc_mutex_lock(__objc_runtime_mutex);
+  objc_mutex_lock (__objc_runtime_mutex);
 
   arr = class->dtable;
@@ -403 +406 @@
       __objc_update_dispatch_table_for_class (next);
 
-  objc_mutex_unlock(__objc_runtime_mutex);
+  objc_mutex_unlock (__objc_runtime_mutex);
 }
 
@@ -420 +423 @@
 
   /* Passing of a linked list is not allowed.  Do multiple calls.  */
-  assert (!list->method_next);
+  assert (! list->method_next);
 
   /* Check for duplicates.  */
@@ -431 +434 @@
           /* This is where selector names are transmogrified to SEL's */
           method->method_name = 
-            sel_register_typed_name ((const char*)method->method_name,
+            sel_register_typed_name ((const char *) method->method_name,
                                      method->method_types);
         }
@@ -445 +448 @@
 
 Method_t
-class_get_instance_method(Class class, SEL op)
-{
-  return search_for_method_in_hierarchy(class, op);
+class_get_instance_method (Class class, SEL op)
+{
+  return search_for_method_in_hierarchy (class, op);
 }
 
 Method_t
-class_get_class_method(MetaClass class, SEL op)
-{
-  return search_for_method_in_hierarchy(class, op);
+class_get_class_method (MetaClass class, SEL op)
+{
+  return search_for_method_in_hierarchy (class, op);
 }
 
@@ -577 +580 @@
 
   /* first try if the object understands forward:: */
-  if (!frwd_sel)
-    frwd_sel = sel_get_any_uid("forward::");
+  if (! frwd_sel)
+    frwd_sel = sel_get_any_uid ("forward::");
 
   if (__objc_responds_to (object, frwd_sel))
     {
-      imp = get_imp(object->class_pointer, frwd_sel);
-      return (*imp)(object, frwd_sel, sel, args);
+      imp = get_imp (object->class_pointer, frwd_sel);
+      return (*imp) (object, frwd_sel, sel, args);
     }
 
@@ -598 +601 @@
      error:.  If it does then sent it. */
   {
-    char msg[256 + strlen ((const char*)sel_get_name (sel))
-             + strlen ((const char*)object->class_pointer->name)];
+    char msg[256 + strlen ((const char *) sel_get_name (sel))
+             + strlen ((const char *) object->class_pointer->name)];
 
     sprintf (msg, "(%s) %s does not recognize %s",
-             (CLS_ISMETA(object->class_pointer)
+             (CLS_ISMETA (object->class_pointer)
               ? "class"
               : "instance" ),
@@ -623 +626 @@
 
 void
-__objc_print_dtable_stats()
+__objc_print_dtable_stats ()
 {
   int total = 0;
 
-  objc_mutex_lock(__objc_runtime_mutex);
+  objc_mutex_lock (__objc_runtime_mutex);
 
 #ifdef OBJC_SPARSE2
-  printf("memory usage: (%s)\n", "2-level sparse arrays");
+  printf ("memory usage: (%s)\n", "2-level sparse arrays");
 #else
-  printf("memory usage: (%s)\n", "3-level sparse arrays");
+  printf ("memory usage: (%s)\n", "3-level sparse arrays");
 #endif
 
-  printf("arrays: %d = %ld bytes\n", narrays, 
-         (long)narrays*sizeof(struct sarray));
-  total += narrays*sizeof(struct sarray);
-  printf("buckets: %d = %ld bytes\n", nbuckets, 
-         (long)nbuckets*sizeof(struct sbucket));
-  total += nbuckets*sizeof(struct sbucket);
-
-  printf("idxtables: %d = %ld bytes\n", idxsize, (long)idxsize*sizeof(void*));
-  total += idxsize*sizeof(void*);
-  printf("-----------------------------------\n");
-  printf("total: %d bytes\n", total);
-  printf("===================================\n");
-
-  objc_mutex_unlock(__objc_runtime_mutex);
+  printf ("arrays: %d = %ld bytes\n", narrays, 
+          (long) narrays * sizeof (struct sarray));
+  total += narrays * sizeof (struct sarray);
+  printf ("buckets: %d = %ld bytes\n", nbuckets, 
+          (long) nbuckets * sizeof (struct sbucket));
+  total += nbuckets * sizeof (struct sbucket);
+
+  printf ("idxtables: %d = %ld bytes\n",
+          idxsize, (long) idxsize * sizeof (void *));
+  total += idxsize * sizeof (void *);
+  printf ("-----------------------------------\n");
+  printf ("total: %d bytes\n", total);
+  printf ("===================================\n");
+
+  objc_mutex_unlock (__objc_runtime_mutex);
 }
 
@@ -655 +659 @@
  then that means it needs its dispatch table to be installed. */
 __inline__
-struct sarray* 
-objc_get_uninstalled_dtable()
+struct sarray *
+objc_get_uninstalled_dtable ()
 {
   return __objc_uninstalled_dtable;

branches/GNU/src/gcc/libobjc/thr-mach.c

@@ -1 +1 @@
 /* GNU Objective C Runtime Thread Implementation
-   Copyright (C) 1996, 1997 Free Software Foundation, Inc.
+   Copyright (C) 1996, 1997, 2002 Free Software Foundation, Inc.
    Contributed by Galen C. Hunt (gchunt@cs.rochester.edu)
    Modified for Mach threads by Bill Bumgarner <bbum@friday.com>
@@ -38 +38 @@
   privileges.  Once lowered, it cannot be raised.
   */
-static int __mach_get_max_thread_priority(cthread_t t, int *base)
+static int
+__mach_get_max_thread_priority (cthread_t t, int *base)
 {
   thread_t threadP;
@@ -48 +49 @@
     return -1;
 
-  threadP  = cthread_thread(t);         /* get thread underlying */
-
-  error=thread_info(threadP, THREAD_SCHED_INFO, 
-                    (thread_info_t)&info, &info_count);
+  threadP  = cthread_thread (t);        /* get thread underlying */
+
+  error = thread_info (threadP, THREAD_SCHED_INFO, 
+                       (thread_info_t) &info, &info_count);
 
   if (error != KERN_SUCCESS)
@@ -66 +67 @@
 /* Initialize the threads subsystem. */
 int
-__objc_init_thread_system(void)
+__objc_init_thread_system (void)
 {
   return 0;
@@ -73 +74 @@
 /* Close the threads subsystem. */
 int
-__objc_close_thread_system(void)
+__objc_close_thread_system (void)
 {
   return 0;
@@ -82 +83 @@
 /* Create a new thread of execution. */
 objc_thread_t
-__objc_thread_detach(void (*func)(void *arg), void *arg)
+__objc_thread_detach (void (*func) (void *arg), void *arg)
 {
   objc_thread_t thread_id;
@@ -88 +89 @@
 
   /* create thread */
-  new_thread_handle = cthread_fork((cthread_fn_t)func, arg);
-
-  if(new_thread_handle)
+  new_thread_handle = cthread_fork ((cthread_fn_t) func, arg);
+
+  if (new_thread_handle)
     {
       /* this is not terribly portable */
-      thread_id = *(objc_thread_t *)&new_thread_handle; 
-      cthread_detach(new_thread_handle);
+      thread_id = *(objc_thread_t *) &new_thread_handle; 
+      cthread_detach (new_thread_handle);
     }
   else
@@ -104 +105 @@
 /* Set the current thread's priority. */
 int
-__objc_thread_set_priority(int priority)
-{
-  objc_thread_t *t = objc_thread_id();
+__objc_thread_set_priority (int priority)
+{
+  objc_thread_t *t = objc_thread_id ();
   cthread_t cT = (cthread_t) t; 
-  int maxPriority = __mach_get_max_thread_priority(cT, NULL);
+  int maxPriority = __mach_get_max_thread_priority (cT, NULL);
   int sys_priority = 0;
 
@@ -133 +134 @@
 
   /* Change the priority */
-  if (cthread_priority(cT, sys_priority, 0) == KERN_SUCCESS)
+  if (cthread_priority (cT, sys_priority, 0) == KERN_SUCCESS)
     return 0;
   else
@@ -141 +142 @@
 /* Return the current thread's priority. */
 int
-__objc_thread_get_priority(void)
-{
-  objc_thread_t *t = objc_thread_id();
-  cthread_t cT = (cthread_t) t; /* see objc_thread_id() */
+__objc_thread_get_priority (void)
+{
+  objc_thread_t *t = objc_thread_id ();
+  cthread_t cT = (cthread_t) t; /* see objc_thread_id () */
   int basePriority;
   int maxPriority;
@@ -151 +152 @@
   int interactiveT, backgroundT, lowT; /* thresholds */
 
-  maxPriority = __mach_get_max_thread_priority(cT, &basePriority);
-
-  if(maxPriority == -1)
+  maxPriority = __mach_get_max_thread_priority (cT, &basePriority);
+
+  if (maxPriority == -1)
     return -1;
 
@@ -167 +168 @@
 /* Yield our process time to another thread. */
 void
-__objc_thread_yield(void)
-{
-  cthread_yield();
+__objc_thread_yield (void)
+{
+  cthread_yield ();
 }
 
 /* Terminate the current thread. */
 int
-__objc_thread_exit(void)
+__objc_thread_exit (void)
 {
   /* exit the thread */
-  cthread_exit(&__objc_thread_exit_status);
+  cthread_exit (&__objc_thread_exit_status);
 
   /* Failed if we reached here */
@@ -185 +186 @@
 /* Returns an integer value which uniquely describes a thread. */
 objc_thread_t
-__objc_thread_id(void)
-{
-  cthread_t self = cthread_self();
-
-  return *(objc_thread_t *)&self;
+__objc_thread_id (void)
+{
+  cthread_t self = cthread_self ();
+
+  return *(objc_thread_t *) &self;
 }
 
 /* Sets the thread's local storage pointer. */
 int
-__objc_thread_set_data(void *value)
-{
-  cthread_set_data(cthread_self(), (any_t) value);
+__objc_thread_set_data (void *value)
+{
+  cthread_set_data (cthread_self (), (any_t) value);
   return 0;
 }
@@ -202 +203 @@
 /* Returns the thread's local storage pointer. */
 void *
-__objc_thread_get_data(void)
-{
-  return (void *) cthread_data(cthread_self());
+__objc_thread_get_data (void)
+{
+  return (void *) cthread_data (cthread_self ());
 }
 
@@ -211 +212 @@
 /* Allocate a mutex. */
 int
-__objc_mutex_allocate(objc_mutex_t mutex)
+__objc_mutex_allocate (objc_mutex_t mutex)
 {
   int err = 0;
-  mutex->backend = objc_malloc(sizeof(struct mutex));
-
-  err = mutex_init((mutex_t)(mutex->backend));
+  mutex->backend = objc_malloc (sizeof (struct mutex));
+
+  err = mutex_init ((mutex_t) (mutex->backend));
 
   if (err != 0)
     {
-      objc_free(mutex->backend);
+      objc_free (mutex->backend);
       return -1;
     }
@@ -229 +230 @@
 /* Deallocate a mutex. */
 int
-__objc_mutex_deallocate(objc_mutex_t mutex)
-{
-  mutex_clear((mutex_t)(mutex->backend));
-
-  objc_free(mutex->backend);
+__objc_mutex_deallocate (objc_mutex_t mutex)
+{
+  mutex_clear ((mutex_t) (mutex->backend));
+
+  objc_free (mutex->backend);
   mutex->backend = NULL;
   return 0;
@@ -240 +241 @@
 /* Grab a lock on a mutex. */
 int
-__objc_mutex_lock(objc_mutex_t mutex)
-{
-  mutex_lock((mutex_t)(mutex->backend));
+__objc_mutex_lock (objc_mutex_t mutex)
+{
+  mutex_lock ((mutex_t) (mutex->backend));
   return 0;
 }
@@ -248 +249 @@
 /* Try to grab a lock on a mutex. */
 int
-__objc_mutex_trylock(objc_mutex_t mutex)
-{
-  if (mutex_try_lock((mutex_t)(mutex->backend)) == 0)
+__objc_mutex_trylock (objc_mutex_t mutex)
+{
+  if (mutex_try_lock ((mutex_t) (mutex->backend)) == 0)
     return -1;
   else
@@ -258 +259 @@
 /* Unlock the mutex */
 int
-__objc_mutex_unlock(objc_mutex_t mutex)
-{
-  mutex_unlock((mutex_t)(mutex->backend));
+__objc_mutex_unlock (objc_mutex_t mutex)
+{
+  mutex_unlock ((mutex_t) (mutex->backend));
   return 0;
 }
@@ -268 +269 @@
 /* Allocate a condition. */
 int
-__objc_condition_allocate(objc_condition_t condition)
-{
-  condition->backend = objc_malloc(sizeof(struct condition));
-  condition_init((condition_t)(condition->backend));
+__objc_condition_allocate (objc_condition_t condition)
+{
+  condition->backend = objc_malloc (sizeof (struct condition));
+  condition_init ((condition_t) (condition->backend));
   return 0;
 }
@@ -277 +278 @@
 /* Deallocate a condition. */
 int
-__objc_condition_deallocate(objc_condition_t condition)
-{
-  condition_clear((condition_t)(condition->backend));
-  objc_free(condition->backend);
+__objc_condition_deallocate (objc_condition_t condition)
+{
+  condition_clear ((condition_t) (condition->backend));
+  objc_free (condition->backend);
   condition->backend = NULL;
   return 0;
@@ -287 +288 @@
 /* Wait on the condition */
 int
-__objc_condition_wait(objc_condition_t condition, objc_mutex_t mutex)
-{
-  condition_wait((condition_t)(condition->backend),
-                 (mutex_t)(mutex->backend));
+__objc_condition_wait (objc_condition_t condition, objc_mutex_t mutex)
+{
+  condition_wait ((condition_t) (condition->backend),
+                  (mutex_t) (mutex->backend));
   return 0;
 }
@@ -296 +297 @@
 /* Wake up all threads waiting on this condition. */
 int
-__objc_condition_broadcast(objc_condition_t condition)
-{
-  condition_broadcast((condition_t)(condition->backend));
+__objc_condition_broadcast (objc_condition_t condition)
+{
+  condition_broadcast ((condition_t) (condition->backend));
   return 0;
 }
@@ -304 +305 @@
 /* Wake up one thread waiting on this condition. */
 int
-__objc_condition_signal(objc_condition_t condition)
-{
-  condition_signal((condition_t)(condition->backend));
+__objc_condition_signal (objc_condition_t condition)
+{
+  condition_signal ((condition_t) (condition->backend));
   return 0;
 }

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

@@ -49 +49 @@
   so it can implement the NSBecomingMultiThreaded notification.
   */
-objc_thread_callback objc_set_thread_callback(objc_thread_callback func)
+objc_thread_callback objc_set_thread_callback (objc_thread_callback func)
 {
   objc_thread_callback temp = _objc_became_multi_threaded;
@@ -77 +77 @@
 
 static volatile void
-__objc_thread_detach_function(struct __objc_thread_start_state *istate)
+__objc_thread_detach_function (struct __objc_thread_start_state *istate)
 {
   /* Valid state? */
   if (istate) {
-    id (*imp)(id,SEL,id);
+    id (*imp) (id, SEL, id);
     SEL selector = istate->selector;
     id object   = istate->object;
@@ -87 +87 @@
 
     /* Don't need anymore so free it */
-    objc_free(istate);
+    objc_free (istate);
 
     /* Clear out the thread local storage */
-    objc_thread_set_data(NULL);
+    objc_thread_set_data (NULL);
 
     /* Check to see if we just became multi threaded */
-    if (!__objc_is_multi_threaded)
+    if (! __objc_is_multi_threaded)
       {
         __objc_is_multi_threaded = 1;
@@ -99 +99 @@
         /* Call the hook function */
         if (_objc_became_multi_threaded != NULL)
-          (*_objc_became_multi_threaded)();
+          (*_objc_became_multi_threaded) ();
       }
 
     /* Call the method */
-    if ((imp = (id(*)(id, SEL, id))objc_msg_lookup(object, selector)))
-        (*imp)(object, selector, argument);
+    if ((imp = (id (*) (id, SEL, id))objc_msg_lookup (object, selector)))
+        (*imp) (object, selector, argument);
     else
-      objc_error(object, OBJC_ERR_UNIMPLEMENTED,
-                 "objc_thread_detach called with bad selector.\n");
+      objc_error (object, OBJC_ERR_UNIMPLEMENTED,
+                  "objc_thread_detach called with bad selector.\n");
   }
   else
-    objc_error(nil, OBJC_ERR_BAD_STATE,
-               "objc_thread_detach called with NULL state.\n");
+    objc_error (nil, OBJC_ERR_BAD_STATE,
+                "objc_thread_detach called with NULL state.\n");
 
   /* Exit the thread */
-  objc_thread_exit();
+  objc_thread_exit ();
 }
 
@@ -132 +132 @@
   */
 objc_thread_t
-objc_thread_detach(SEL selector, id object, id argument)
+objc_thread_detach (SEL selector, id object, id argument)
 {
   struct __objc_thread_start_state *istate;
@@ -138 +138 @@
 
   /* Allocate the state structure */
-  if (!(istate = (struct __objc_thread_start_state *)
-        objc_malloc(sizeof(*istate))))
+  if (! (istate = (struct __objc_thread_start_state *)
+         objc_malloc (sizeof (*istate))))
     return NULL;
 
@@ -148 +148 @@
 
   /* lock access */
-  objc_mutex_lock(__objc_runtime_mutex);
+  objc_mutex_lock (__objc_runtime_mutex);
 
   /* Call the backend to spawn the thread */
-  if ((thread_id = __objc_thread_detach((void *)__objc_thread_detach_function,
-                                        istate)) == NULL)
+  if ((thread_id = __objc_thread_detach ((void *)__objc_thread_detach_function,
+                                         istate)) == NULL)
     {
       /* failed! */
-      objc_mutex_unlock(__objc_runtime_mutex);
-      objc_free(istate);
+      objc_mutex_unlock (__objc_runtime_mutex);
+      objc_free (istate);
       return NULL;
     }
@@ -162 +162 @@
   /* Increment our thread counter */
   __objc_runtime_threads_alive++;
-  objc_mutex_unlock(__objc_runtime_mutex);
+  objc_mutex_unlock (__objc_runtime_mutex);
 
   return thread_id;
@@ -169 +169 @@
 /* Set the current thread's priority. */
 int
-objc_thread_set_priority(int priority)
+objc_thread_set_priority (int priority)
 {
   /* Call the backend */
-  return __objc_thread_set_priority(priority);
+  return __objc_thread_set_priority (priority);
 }
 
 /* Return the current thread's priority. */
 int
-objc_thread_get_priority(void)
+objc_thread_get_priority (void)
 {
   /* Call the backend */
-  return __objc_thread_get_priority();
+  return __objc_thread_get_priority ();
 }
 
@@ -189 +189 @@
   */
 void
-objc_thread_yield(void)
+objc_thread_yield (void)
 {
   /* Call the backend */
-  __objc_thread_yield();
+  __objc_thread_yield ();
 }
 
@@ -200 +200 @@
   */
 int
-objc_thread_exit(void)
+objc_thread_exit (void)
 {
   /* Decrement our counter of the number of threads alive */
-  objc_mutex_lock(__objc_runtime_mutex);
+  objc_mutex_lock (__objc_runtime_mutex);
   __objc_runtime_threads_alive--;
-  objc_mutex_unlock(__objc_runtime_mutex);
+  objc_mutex_unlock (__objc_runtime_mutex);
 
   /* Call the backend to terminate the thread */
-  return __objc_thread_exit();
+  return __objc_thread_exit ();
 }
 
@@ -216 +216 @@
   */
 objc_thread_t
-objc_thread_id(void)
+objc_thread_id (void)
 {
   /* Call the backend */
-  return __objc_thread_id();
+  return __objc_thread_id ();
 }
 
@@ -227 +227 @@
   */
 int
-objc_thread_set_data(void *value)
+objc_thread_set_data (void *value)
 {
   /* Call the backend */
-  return __objc_thread_set_data(value);
+  return __objc_thread_set_data (value);
 }
 
@@ -237 +237 @@
   */
 void *
-objc_thread_get_data(void)
+objc_thread_get_data (void)
 {
   /* Call the backend */
-  return __objc_thread_get_data();
+  return __objc_thread_get_data ();
 }
 
@@ -250 +250 @@
   */
 objc_mutex_t
-objc_mutex_allocate(void)
+objc_mutex_allocate (void)
 {
   objc_mutex_t mutex;
 
   /* Allocate the mutex structure */
-  if (!(mutex = (objc_mutex_t)objc_malloc(sizeof(struct objc_mutex))))
+  if (! (mutex = (objc_mutex_t)objc_malloc (sizeof (struct objc_mutex))))
     return NULL;
 
   /* Call backend to create the mutex */
-  if (__objc_mutex_allocate(mutex))
+  if (__objc_mutex_allocate (mutex))
     {
       /* failed! */
-      objc_free(mutex);
+      objc_free (mutex);
       return NULL;
     }
@@ -280 +280 @@
   */
 int
-objc_mutex_deallocate(objc_mutex_t mutex)
+objc_mutex_deallocate (objc_mutex_t mutex)
 {
   int depth;
 
   /* Valid mutex? */
-  if (!mutex)
+  if (! mutex)
     return -1;
 
   /* Acquire lock on mutex */
-  depth = objc_mutex_lock(mutex);
+  depth = objc_mutex_lock (mutex);
 
   /* Call backend to destroy mutex */
-  if (__objc_mutex_deallocate(mutex))
+  if (__objc_mutex_deallocate (mutex))
     return -1;
 
   /* Free the mutex structure */
-  objc_free(mutex);
+  objc_free (mutex);
 
   /* Return last depth */
@@ -309 +309 @@
   */
 int
-objc_mutex_lock(objc_mutex_t mutex)
+objc_mutex_lock (objc_mutex_t mutex)
 {
   objc_thread_t thread_id;
@@ -315 +315 @@
 
   /* Valid mutex? */
-  if (!mutex)
+  if (! mutex)
     return -1;
 
   /* If we already own the lock then increment depth */
-  thread_id = __objc_thread_id();
+  thread_id = __objc_thread_id ();
   if (mutex->owner == thread_id)
     return ++mutex->depth;
 
   /* Call the backend to lock the mutex */
-  status = __objc_mutex_lock(mutex);
+  status = __objc_mutex_lock (mutex);
 
   /* Failed? */
@@ -341 +341 @@
   */
 int
-objc_mutex_trylock(objc_mutex_t mutex)
+objc_mutex_trylock (objc_mutex_t mutex)
 {
   objc_thread_t thread_id;
@@ -347 +347 @@
 
   /* Valid mutex? */
-  if (!mutex)
+  if (! mutex)
     return -1;
 
   /* If we already own the lock then increment depth */ 
-  thread_id = __objc_thread_id();
+  thread_id = __objc_thread_id ();
   if (mutex->owner == thread_id)
     return ++mutex->depth;
     
   /* Call the backend to try to lock the mutex */
-  status = __objc_mutex_trylock(mutex);
+  status = __objc_mutex_trylock (mutex);
 
   /* Failed? */
@@ -376 +376 @@
   */
 int
-objc_mutex_unlock(objc_mutex_t mutex)
+objc_mutex_unlock (objc_mutex_t mutex)
 {
   objc_thread_t thread_id;
@@ -382 +382 @@
 
   /* Valid mutex? */
-  if (!mutex)
+  if (! mutex)
     return -1;
 
   /* If another thread owns the lock then abort */
-  thread_id = __objc_thread_id();
+  thread_id = __objc_thread_id ();
   if (mutex->owner != thread_id)
     return -1;
@@ -399 +399 @@
 
   /* Have the backend unlock the mutex */
-  status = __objc_mutex_unlock(mutex);
+  status = __objc_mutex_unlock (mutex);
 
   /* Failed? */
@@ -415 +415 @@
   */
 objc_condition_t 
-objc_condition_allocate(void)
+objc_condition_allocate (void)
 {
   objc_condition_t condition;
     
   /* Allocate the condition mutex structure */
-  if (!(condition = 
-        (objc_condition_t)objc_malloc(sizeof(struct objc_condition))))
+  if (! (condition = 
+         (objc_condition_t) objc_malloc (sizeof (struct objc_condition))))
     return NULL;
 
   /* Call the backend to create the condition mutex */
-  if (__objc_condition_allocate(condition))
+  if (__objc_condition_allocate (condition))
     {
       /* failed! */
-      objc_free(condition);
+      objc_free (condition);
       return NULL;
     }
@@ -444 +444 @@
   */
 int
-objc_condition_deallocate(objc_condition_t condition)
+objc_condition_deallocate (objc_condition_t condition)
 {
   /* Broadcast the condition */
-  if (objc_condition_broadcast(condition))
+  if (objc_condition_broadcast (condition))
     return -1;
 
   /* Call the backend to destroy */
-  if (__objc_condition_deallocate(condition))
+  if (__objc_condition_deallocate (condition))
     return -1;
 
   /* Free the condition mutex structure */
-  objc_free(condition);
+  objc_free (condition);
 
   return 0;
@@ -461 +461 @@
 
 /*
-  Wait on the condition unlocking the mutex until objc_condition_signal()
-  or objc_condition_broadcast() are called for the same condition. The
+  Wait on the condition unlocking the mutex until objc_condition_signal ()
+  or objc_condition_broadcast () are called for the same condition. The
   given mutex *must* have the depth set to 1 so that it can be unlocked
   here, so that someone else can lock it and signal/broadcast the condition.
@@ -469 +469 @@
   */
 int
-objc_condition_wait(objc_condition_t condition, objc_mutex_t mutex)
+objc_condition_wait (objc_condition_t condition, objc_mutex_t mutex)
 {
   objc_thread_t thread_id;
 
   /* Valid arguments? */
-  if (!mutex || !condition)
+  if (! mutex || ! condition)
     return -1;
 
   /* Make sure we are owner of mutex */
-  thread_id = __objc_thread_id();
+  thread_id = __objc_thread_id ();
   if (mutex->owner != thread_id)
     return -1;
@@ -491 +491 @@
 
   /* Call the backend to wait */
-  __objc_condition_wait(condition, mutex);
+  __objc_condition_wait (condition, mutex);
 
   /* Make ourselves owner of the mutex */
@@ -507 +507 @@
   */
 int
-objc_condition_broadcast(objc_condition_t condition)
+objc_condition_broadcast (objc_condition_t condition)
 {
   /* Valid condition mutex? */
-  if (!condition)
-    return -1;
-
-  return __objc_condition_broadcast(condition);
+  if (! condition)
+    return -1;
+
+  return __objc_condition_broadcast (condition);
 }
 
@@ -523 +523 @@
   */
 int
-objc_condition_signal(objc_condition_t condition)
+objc_condition_signal (objc_condition_t condition)
 {
   /* Valid condition mutex? */
-  if (!condition)
-    return -1;
-
-  return __objc_condition_signal(condition);
+  if (! condition)
+    return -1;
+
+  return __objc_condition_signal (condition);
 }
 
@@ -536 +536 @@
    from now on.  This is used when you are interfacing with some
    external non-objc-based environment/system - you must call
-   objc_thread_add() before an alien thread makes any calls to
+   objc_thread_add () before an alien thread makes any calls to
    Objective-C.  Do not cause the _objc_became_multi_threaded hook to
    be executed. */
 void 
-objc_thread_add(void)
-{
-  objc_mutex_lock(__objc_runtime_mutex);
+objc_thread_add (void)
+{
+  objc_mutex_lock (__objc_runtime_mutex);
   __objc_is_multi_threaded = 1;
   __objc_runtime_threads_alive++;
-  objc_mutex_unlock(__objc_runtime_mutex);  
+  objc_mutex_unlock (__objc_runtime_mutex);  
 }
 
@@ -551 +551 @@
    stopped) by some external code will no longer access objc and thus
    can be forgotten by the objc thread system.  Call
-   objc_thread_remove() when your alien thread is done with making
+   objc_thread_remove () when your alien thread is done with making
    calls to Objective-C. */
 void
-objc_thread_remove(void)
-{
-  objc_mutex_lock(__objc_runtime_mutex);
+objc_thread_remove (void)
+{
+  objc_mutex_lock (__objc_runtime_mutex);
   __objc_runtime_threads_alive--;
-  objc_mutex_unlock(__objc_runtime_mutex);  
+  objc_mutex_unlock (__objc_runtime_mutex);  
 }
 

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