gcc/testsuite:

[pf3gnuchains/gcc-fork.git] / libobjc / class.c

diff --git a/libobjc/class.c b/libobjc/class.c
index 5df7050..edc56aa 100644 (file)
--- a/libobjc/class.c
+++ b/libobjc/class.c
@@ -781,35 +781,57 @@ __objc_update_classes_with_methods (struct objc_method *method_a, struct objc_me
       
       while (node != NULL)
        {
-         /* Iterate over all methods in the class.  */
-         Class class = node->pointer;
-         struct objc_method_list * method_list = class->methods;
-
-         while (method_list)
+         /* We execute this loop twice: the first time, we iterate
+            over all methods in the class (instance methods), while
+            the second time we iterate over all methods in the meta
+            class (class methods).  */
+         Class class = Nil;
+         BOOL done = NO;
+
+         while (done == NO)
            {
-             int i;
+             struct objc_method_list * method_list;
 
-             for (i = 0; i < method_list->method_count; ++i)
+             if (class == Nil)
+               {
+                 /* The first time, we work on the class.  */
+                 class = node->pointer;
+               }
+             else
                {
-                 struct objc_method *method = &method_list->method_list[i];
+                 /* The second time, we work on the meta class.  */
+                 class = class->class_pointer;
+                 done = YES;
+               }
 
-                 /* If the method is one of the ones we are looking
-                    for, update the implementation.  */
-                 if (method == method_a)
-                   sarray_at_put_safe (class->dtable,
-                                       (sidx) method_a->method_name->sel_id,
-                                       method_a->method_imp);
+             method_list = class->methods;
 
-                 if (method == method_b)
+             while (method_list)
+               {
+                 int i;
+                 
+                 for (i = 0; i < method_list->method_count; ++i)
                    {
-                     if (method_b != NULL)
+                     struct objc_method *method = &method_list->method_list[i];
+                     
+                     /* If the method is one of the ones we are
+                        looking for, update the implementation.  */
+                     if (method == method_a)
                        sarray_at_put_safe (class->dtable,
-                                           (sidx) method_b->method_name->sel_id,
-                                           method_b->method_imp);
+                                           (sidx) method_a->method_name->sel_id,
+                                           method_a->method_imp);
+                     
+                     if (method == method_b)
+                       {
+                         if (method_b != NULL)
+                           sarray_at_put_safe (class->dtable,
+                                               (sidx) method_b->method_name->sel_id,
+                                               method_b->method_imp);
+                       }
                    }
+                 
+                 method_list = method_list->method_next;
                }
-         
-             method_list = method_list->method_next;
            }
          node = node->next;
        }
@@ -925,11 +947,16 @@ class_getSuperclass (Class class_)
 
   /* Classes that are in construction are not resolved, and still have
      the class name (instead of a class pointer) in the
-     class_->superclass field.  In that case we need to lookup the
+     class_->super_class field.  In that case we need to lookup the
      superclass name to return the superclass.  We can not resolve the
      class until it is registered.  */
   if (CLS_IS_IN_CONSTRUCTION (class_))
-    return objc_lookUpClass ((const char *)(class_->super_class));
+    {
+      if (CLS_ISMETA (class_))
+       return object_getClass ((id)objc_lookUpClass ((const char *)(class_->super_class)));
+      else
+       return objc_lookUpClass ((const char *)(class_->super_class));
+    }
 
   /* If the class is not resolved yet, super_class would point to a
      string (the name of the super class) as opposed to the actual