Context Navigation

-              r1390
+              r1391
 /* 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>
 …
 /* 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 */
 …
                            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);
 …
 /* 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);
 …
 } 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;
 …
       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;
 …
+}
+/* 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)
 …
+    }
   else if ((class->super_class ?
                     objc_lookup_class ((char*)class->super_class)
+                    objc_lookup_class ((char *) class->super_class)
                   : Nil)
             == tree->class)
 …
       /* 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;
 …
+        {
           /* 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",
 …
   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);
 …
+        }
       /* 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);
 …
+}
+/* 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)
 …
+    }
   /* 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);
 …
+}
+/* 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;
 …
+}
+/* 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;
 …
+}
+/* Used to print a tree class hierarchy. */
+/* Used to print a tree class hierarchy.  */
 #ifdef DEBUG
 static void
 …
 #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)
 …
   int i;
   if (!method_list)
+  if (! method_list)
     return;
 …
   __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++)
+    {
 …
       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 */
 …
           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);
 …
 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;
 …
   MethodList_t method_list = class->class_pointer->methods;
   if (!load_sel)
+  if (! load_sel)
     load_sel = sel_register_name ("load");
 …
 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)
 …
         return YES;
       class = (class->super_class ?
                   objc_lookup_class ((char*)class->super_class)
+                  objc_lookup_class ((char *) class->super_class)
                 : Nil);
+    }
 …
+}
 /* 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);
 …
+}
+/* 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)
 …
   struct objc_static_instances **statics_in_module;
   objc_mutex_lock(__objc_runtime_mutex);
+  objc_mutex_lock (__objc_runtime_mutex);
   while (*cell)
 …
           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
 …
           struct objc_list *this = *cell;
           *cell = this->tail;
           objc_free(this);
+          objc_free (this);
+        }
       else
 …
+    }
   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
 …
   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 */
 …
   /* Entry used to traverse hash lists */
   struct objc_list** cell;
+  struct objc_list **cell;
   /* The table of selector references for this module */
 …
   /* 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
 …
   /* 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.  */
 …
+        {
           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);
+        }
 …
+    {
       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;
 …
       /* 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)
 …
       /* 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);
+   }
 …
           /* 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
 …
           /* 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);
+        }
+    }
 …
           /* 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
 …
   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;
 …
   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);
 …
+        }
+      /*
+       * 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)
 …
+    }
   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;
 …
   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++)
+    {
 …
 __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++)
+    {
 …
       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)))
 …
       int code;
       if(module->version > OBJC_VERSION)
+      if (module->version > OBJC_VERSION)
         code = OBJC_ERR_OBJC_VERSION;
       else if (module->version < OBJC_VERSION)
 …
         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;
 …
     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;
+    }
 …
 #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)
+        {
 …
       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;

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

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

Legend:

branches/GNU/src/gcc

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

Download in other formats: