OC - Category 和 Extension

// Clang
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc Person+Test.m

#import "Person.h"
@interface Person (Test)<NSCopying>
@property (nonatomic, copy) NSString *name;
@property (nonatomic, assign) int age;
- (void)eat;
- (void)sleep;
+ (void)run;
+ (void)walk;
@end

#import "Person+Test.h"
@implementation Person (Test)
- (void)eat {
    NSLog(@"eat");
}
- (void)sleep {
    NSLog(@"sleep");
}
+ (void)run {
    NSLog(@"run");
}
+ (void)walk {
    NSLog(@"walk");
}
@end

// Person+Test.cpp
struct _category_t {
    const char *name;
    struct _class_t *cls;
    const struct _method_list_t *instance_methods;
    const struct _method_list_t *class_methods;
    const struct _protocol_list_t *protocols;
    const struct _prop_list_t *properties;
};

// 实例方法列表
static struct /*_method_list_t*/ {
    unsigned int entsize;  // sizeof(struct _objc_method)
    unsigned int method_count;
    struct _objc_method method_list[2];
} _OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_Test __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_objc_method),
    2,
    {{(struct objc_selector *)"eat", "v16@0:8", (void *)_I_Person_Test_eat},
    {(struct objc_selector *)"sleep", "v16@0:8", (void *)_I_Person_Test_sleep}}
};

// 类方法列表
static struct /*_method_list_t*/ {
    unsigned int entsize;  // sizeof(struct _objc_method)
    unsigned int method_count;
    struct _objc_method method_list[2];
} _OBJC_$_CATEGORY_CLASS_METHODS_Person_$_Test __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_objc_method),
    2,
    {{(struct objc_selector *)"run", "v16@0:8", (void *)_C_Person_Test_run},
    {(struct objc_selector *)"walk", "v16@0:8", (void *)_C_Person_Test_walk}}
};

// 协议列表
static struct /*_protocol_list_t*/ {
    long protocol_count;  // Note, this is 32/64 bit
    struct _protocol_t *super_protocols[1];
} _OBJC_CATEGORY_PROTOCOLS_$_Person_$_Test __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    1,
    &_OBJC_PROTOCOL_NSCopying
};

// 属性列表
static struct /*_prop_list_t*/ {
    unsigned int entsize;  // sizeof(struct _prop_t)
    unsigned int count_of_properties;
    struct _prop_t prop_list[2];
} _OBJC_$_PROP_LIST_Person_$_Test __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_prop_t),
    2,
    {{"name","T@\"NSString\",C,N"},
    {"age","Ti,N"}}
};

// Person+Test 分类编译的底层结构
static struct _category_t _OBJC_$_CATEGORY_Person_$_Test __attribute__ ((used, section ("__DATA,__objc_const"))) = 
{
    "Person",
    0, // &OBJC_CLASS_$_Person,
    (const struct _method_list_t *)&_OBJC_$_CATEGORY_INSTANCE_METHODS_Person_$_Test,
    (const struct _method_list_t *)&_OBJC_$_CATEGORY_CLASS_METHODS_Person_$_Test,
    (const struct _protocol_list_t *)&_OBJC_CATEGORY_PROTOCOLS_$_Person_$_Test,
    (const struct _prop_list_t *)&_OBJC_$_PROP_LIST_Person_$_Test,
};

struct category_t {
    const char *name;  //类名
    classref_t cls;    //扩展的类
    struct method_list_t *instanceMethods;       //实例方法列表
    struct method_list_t *classMethods;          //类方法列表
    struct protocol_list_t *protocols;           //协议列表
    struct property_list_t *instanceProperties;  //属性列表
    // Fields below this point are not always present on disk.
    struct property_list_t *_classProperties;

    method_list_t *methodsForMeta(bool isMeta) {
        if (isMeta) return classMethods;
        else return instanceMethods;
    }

    property_list_t *propertiesForMeta(bool isMeta, struct header_info *hi);
};

static void remethodizeClass(Class cls)
{
    category_list *cats;
    bool isMeta;

    runtimeLock.assertLocked();
    /*
     我们只分析分类中实例方法的添加逻辑
     因此这里假设 isMeta = NO
     */
    isMeta = cls->isMetaClass();

    // Re-methodizing: check for more categories
    // 获取 cls 中所有未完成整合的分类
    if ((cats = unattachedCategoriesForClass(cls, false/*not realizing*/))) {
        if (PrintConnecting) {
            _objc_inform("CLASS: attaching categories to class '%s' %s", 
                         cls->nameForLogging(), isMeta ? "(meta)" : "");
        }
        /* 调用 attachCategories
           cls:宿主类
           cats:所有未完成整合的分类
         */
        attachCategories(cls, cats, true /*flush caches*/);        
        free(cats);
    }
}

static void 
attachCategories(Class cls, category_list *cats, bool flush_caches)
{
    if (!cats) return;
    if (PrintReplacedMethods) printReplacements(cls, cats);
    /*
     我们只分析分类中实例方法的添加逻辑
     因此这里假设 isMeta = NO
     */
    bool isMeta = cls->isMetaClass();

    // fixme rearrange to remove these intermediate allocations
    /* 二维数组
       [[method_t,method_t,...], [method_t], [method_t,method_t,method_t,...]]
     */
    method_list_t **mlists = (method_list_t **)
        malloc(cats->count * sizeof(*mlists));
    property_list_t **proplists = (property_list_t **)
        malloc(cats->count * sizeof(*proplists));
    protocol_list_t **protolists = (protocol_list_t **)
        malloc(cats->count * sizeof(*protolists));

    // Count backwards through cats to get newest categories first
    int mcount = 0;
    int propcount = 0;
    int protocount = 0;
    int i = cats->count; //宿主类的分类个数
    bool fromBundle = NO;
    while (i--) { //倒序遍历，最先访问最后编译的分类
        //获取一个分类
        auto& entry = cats->list[i];
        //获取该分类的方法列表
        method_list_t *mlist = entry.cat->methodsForMeta(isMeta);
        if (mlist) {
            //最后编译的分类数据最先加到数组中
            mlists[mcount++] = mlist;
            fromBundle |= entry.hi->isBundle();
        }
        //获取该分类的属性列表，添加规则同上
        property_list_t *proplist = 
            entry.cat->propertiesForMeta(isMeta, entry.hi);
        if (proplist) {
            proplists[propcount++] = proplist;
        }
        //获取该分类的协议列表，添加规则同上
        protocol_list_t *protolist = entry.cat->protocols;
        if (protolist) {
            protolists[protocount++] = protolist;
        }
    }
    //获取宿主类的 class_rw_t 数据
    auto rw = cls->data();
    //主要是针对 分类中有关于内存管理相关方法情况下的 一些特殊处理
    prepareMethodLists(cls, mlists, mcount, NO, fromBundle);
    /*
     rw->methods:宿主类的方法列表
     mcount:含有方法列表的分类个数
     mlists:所有分类的方法列表二维数组
            [[method_t,method_t,...], [method_t], [method_t,method_t,method_t,...]]
             -----------------------  ----------  --------------------------------
                分类A的方法列表(A)           B                      C
     attachLists:将含有 mcount 个元素的 mlists 合并到 rw->methods 中
     */
    rw->methods.attachLists(mlists, mcount);
    free(mlists);
    if (flush_caches  &&  mcount > 0) flushCaches(cls);

    rw->properties.attachLists(proplists, propcount);
    free(proplists);

    rw->protocols.attachLists(protolists, protocount);
    free(protolists);
}

/*
 addedLists:所有分类的方法列表二维数组
   [[method_t,method_t,...], [method_t], [method_t,method_t,method_t,...]]
    -----------------------  ----------  --------------------------------
       分类A的方法列表(A)           B                      C
 addedCount:含有方法列表的分类个数,即 addedLists 的元素个数，假设 
 addedCount = 3
*/
void attachLists(List* const * addedLists, uint32_t addedCount) {
    if (addedCount == 0) return;

    if (hasArray()) {
        // many lists -> many lists
        //宿主类rw->methods方法列表中原有元素总数，假设 oldCount = 2
        uint32_t oldCount = array()->count;
        //合并之后的元素总数 oldCount + addedCount = 5
        uint32_t newCount = oldCount + addedCount;
        //根据新总数分配内存->扩容
        setArray((array_t *)realloc(array(), array_t::byteSize(newCount)));
        //重新设置元素总数
        array()->count = newCount;
        /*
         内存移动:（将宿主类中原来的方法列表挪动到后面去，有几个分类就挪动几格）
         [[], [], [], [原有的第一个元素], [原有的第二个元素]]
         */
        memmove(array()->lists + addedCount, array()->lists, 
                oldCount * sizeof(array()->lists[0]));
        /*
         内存拷贝:（类似于 memmove() ，将 addedLists 拷贝到类中原来的方法列表指向的位置）
         [
            A   --->   [addedLists中的第一个元素],即最后参与编译的分类的方法列表
            B   --->   [addedLists中的第二个元素],即倒二参与编译的分类的方法列表
            C   --->   [addedLists中的第三个元素],
            [原有的第一个元素],
            [原有的第二个元素]
         ]
     
         这也就是分类方法会“覆盖”宿主类方法的原因
         */
        memcpy(array()->lists, addedLists, 
               addedCount * sizeof(array()->lists[0]));
    }
    else if (!list  &&  addedCount == 1) {
        // 0 lists -> 1 list
        list = addedLists[0];
    } 
    else {
        // 1 list -> many lists
        List* oldList = list;
        uint32_t oldCount = oldList ? 1 : 0;
        uint32_t newCount = oldCount + addedCount;
        setArray((array_t *)malloc(array_t::byteSize(newCount)));
        array()->count = newCount;
        if (oldList) array()->lists[addedCount] = oldList;
            memcpy(array()->lists, addedLists, 
           addedCount * sizeof(array()->lists[0]));
    }
}