struct category_t {
    const char *name; // 分類名
    classref_t cls; // 主類
    WrappedPtr<method_list_t, PtrauthStrip> instanceMethods; // 實例方法
    WrappedPtr<method_list_t, PtrauthStrip> classMethods; // 類方法
    struct protocol_list_t *protocols; // 協(xié)議
    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);
    protocol_list_t *protocolsForMeta(bool isMeta) {
        if (isMeta) return nullptr;
        else return protocols;
    }
};

void 
map_images_nolock(unsigned mhCount, const char * const mhPaths[],
                  const struct mach_header * const mhdrs[])
{
    ...
    {
        uint32_t i = mhCount;
        while (i--) { // 讀取 header_info 的順序，決定了后編譯的分類方法會放在先編譯的前面
            const headerType *mhdr = (const headerType *)mhdrs[i];
            auto hi = addHeader(mhdr, mhPaths[i], totalClasses, unoptimizedTotalClasses);
    ...

static void loadAllCategories() {
    mutex_locker_t lock(runtimeLock);
    for (auto *hi = FirstHeader; hi != NULL; hi = hi->getNext()) {
        load_categories_nolock(hi);
    }
}

static void load_categories_nolock(header_info *hi) {
    // 是否具有類屬性
    bool hasClassProperties = hi->info()->hasCategoryClassProperties();
    size_t count;
    auto processCatlist = [&](category_t * const *catlist) { // 獲取需要處理的分類列表
        for (unsigned i = 0; i < count; i++) {
            category_t *cat = catlist[i];
            Class cls = remapClass(cat->cls); // 獲取分類對應(yīng)的主類
            locstamped_category_t lc{cat, hi};
            if (!cls) { // 獲取不到主類（可能因為弱鏈接），跳過本次循環(huán)
                // Category's target class is missing (probably weak-linked).
                // Ignore the category.
                if (PrintConnecting) {
                    _objc_inform("CLASS: IGNORING category \?\?\?(%s) %p with "
                                 "missing weak-linked target class",
                                 cat->name, cat);
                }
                continue;
            }
            // Process this category.
            if (cls->isStubClass()) { // 如果時 stubClass，當時無法確定元類對象是哪個，所以先附著在 stubClass 本身上
                // Stub classes are never realized. Stub classes
                // don't know their metaclass until they're
                // initialized, so we have to add categories with
                // class methods or properties to the stub itself.
                // methodizeClass() will find them and add them to
                // the metaclass as appropriate.
                if (cat->instanceMethods ||
                    cat->protocols ||
                    cat->instanceProperties ||
                    cat->classMethods ||
                    cat->protocols ||
                    (hasClassProperties && cat->_classProperties))
                {
                    objc::unattachedCategories.addForClass(lc, cls);
                }
            } else {
                // First, register the category with its target class.
                // Then, rebuild the class's method lists (etc) if
                // the class is realized.
                if (cat->instanceMethods ||  cat->protocols
                    ||  cat->instanceProperties)
                {
                    if (cls->isRealized()) { // 表示類對象已經(jīng)初始化完畢，會進入合并方法。
                        attachCategories(cls, &lc, 1, ATTACH_EXISTING);
                    } else {
                        objc::unattachedCategories.addForClass(lc, cls);
                    }
                }
                if (cat->classMethods  ||  cat->protocols
                    ||  (hasClassProperties && cat->_classProperties))
                {
                    if (cls->ISA()->isRealized()) { // 表示元類對象已經(jīng)初始化完畢，會進入合并方法。
                        attachCategories(cls->ISA(), &lc, 1, ATTACH_EXISTING | ATTACH_METACLASS);
                    } else {
                        objc::unattachedCategories.addForClass(lc, cls->ISA());
                    }
                }
            }
        }
    };
    processCatlist(hi->catlist(&count));
    processCatlist(hi->catlist2(&count));
}

// Attach method lists and properties and protocols from categories to a class.
// Assumes the categories in cats are all loaded and sorted by load order, 
// oldest categories first.
static void
attachCategories(Class cls, const locstamped_category_t *cats_list, uint32_t cats_count,
                 int flags)
{
    if (slowpath(PrintReplacedMethods)) {
        printReplacements(cls, cats_list, cats_count);
    }
    if (slowpath(PrintConnecting)) {
        _objc_inform("CLASS: attaching %d categories to%s class '%s'%s",
                     cats_count, (flags & ATTACH_EXISTING) ? " existing" : "",
                     cls->nameForLogging(), (flags & ATTACH_METACLASS) ? " (meta)" : "");
    }
    /*
     * Only a few classes have more than 64 categories during launch.
     * This uses a little stack, and avoids malloc.
     *
     * Categories must be added in the proper order, which is back
     * to front. To do that with the chunking, we iterate cats_list
     * from front to back, build up the local buffers backwards,
     * and call attachLists on the chunks. attachLists prepends the
     * lists, so the final result is in the expected order.
     */
    constexpr uint32_t ATTACH_BUFSIZ = 64;
    method_list_t   *mlists[ATTACH_BUFSIZ];
    property_list_t *proplists[ATTACH_BUFSIZ];
    protocol_list_t *protolists[ATTACH_BUFSIZ];
    uint32_t mcount = 0;
    uint32_t propcount = 0;
    uint32_t protocount = 0;
    bool fromBundle = NO;
    bool isMeta = (flags & ATTACH_METACLASS); // 是否是元類對象
    auto rwe = cls->data()->extAllocIfNeeded(); // 為 rwe 生成分配存儲空間
    for (uint32_t i = 0; i < cats_count; i++) { // 遍歷分類列表
        auto& entry = cats_list[i];
        method_list_t *mlist = entry.cat->methodsForMeta(isMeta); // 獲取實例方法或類方法列表
        if (mlist) {
            if (mcount == ATTACH_BUFSIZ) { // 達到容器的容量上限時
                prepareMethodLists(cls, mlists, mcount, NO, fromBundle, __func__); // 準備方法列表
                rwe->methods.attachLists(mlists, mcount); // 附著方法到主類中
                mcount = 0;
            }
            mlists[ATTACH_BUFSIZ - ++mcount] = mlist; // 將分類的方法列表放入準備好的容器中
            fromBundle |= entry.hi->isBundle();
        }
        property_list_t *proplist =
            entry.cat->propertiesForMeta(isMeta, entry.hi); // 獲取對象屬性或類屬性列表
        if (proplist) {
            if (propcount == ATTACH_BUFSIZ) { // 達到容器的容量上限時進行附著
                rwe->properties.attachLists(proplists, propcount); // 附著屬性到類或元類中
                propcount = 0;
            }
            proplists[ATTACH_BUFSIZ - ++propcount] = proplist;
        }
        protocol_list_t *protolist = entry.cat->protocolsForMeta(isMeta); // 獲取協(xié)議列表
        if (protolist) {
            if (protocount == ATTACH_BUFSIZ) { // 達到容器的容量上限時進行附著
                rwe->protocols.attachLists(protolists, protocount); // 附著遵守的協(xié)議到類或元類中
                protocount = 0;
            }
            protolists[ATTACH_BUFSIZ - ++protocount] = protolist;
        }
    }
    // 將剩余的方法、屬性和協(xié)議進行附著
    if (mcount > 0) {
        prepareMethodLists(cls, mlists + ATTACH_BUFSIZ - mcount, mcount,
                           NO, fromBundle, __func__);
        rwe->methods.attachLists(mlists + ATTACH_BUFSIZ - mcount, mcount);
        if (flags & ATTACH_EXISTING) {
            flushCaches(cls, __func__, [](Class c){
                // constant caches have been dealt with in prepareMethodLists
                // if the class still is constant here, it's fine to keep
                return !c->cache.isConstantOptimizedCache();
            });
        }
    }
    rwe->properties.attachLists(proplists + ATTACH_BUFSIZ - propcount, propcount);
    rwe->protocols.attachLists(protolists + ATTACH_BUFSIZ - protocount, protocount);
}

void attachLists(List* const * addedLists, uint32_t addedCount) {
        if (addedCount == 0) return; // 數(shù)量為 0 直接返回
        if (hasArray()) {
            // many lists -> many lists
            uint32_t oldCount = array()->count; // 原有的方法列表的個數(shù)
            uint32_t newCount = oldCount + addedCount; // 合并后的方法列表的個數(shù)
            array_t *newArray = (array_t *)malloc(array_t::byteSize(newCount)); // 創(chuàng)建新的數(shù)組
            newArray->count = newCount;
            array()->count = newCount;
            for (int i = oldCount - 1; i >= 0; i--)
                newArray->lists[i + addedCount] = array()->lists[i]; // 將原有的方法，放到新創(chuàng)建的數(shù)組的最后面
            for (unsigned i = 0; i < addedCount; i++)
                newArray->lists[i] = addedLists[i]; // 將分類中的方法，放到數(shù)組的前面
            free(array()); // 釋放原有數(shù)組的內(nèi)存空間
            setArray(newArray); // 將合并后的數(shù)組作為新的方法數(shù)組
            validate();
        }
        else if (!list  &&  addedCount == 1) { // 如果原本不存在方法列表，直接替換
            // 0 lists -> 1 list
            list = addedLists[0];
            validate();
        } 
        else { // 如果原來只有一個列表，變?yōu)槎鄠€，走這個邏輯
            // 1 list -> many lists
            Ptr<List> oldList = list;
            uint32_t oldCount = oldList ? 1 : 0;
            uint32_t newCount = oldCount + addedCount; // 計算所有方法列表的個數(shù)
            setArray((array_t *)malloc(array_t::byteSize(newCount))); // 分配新的內(nèi)存空間并賦值
            array()->count = newCount;
            if (oldList) array()->lists[addedCount] = oldList; // 將原有的方法，放到新創(chuàng)建的數(shù)組的最后面
            for (unsigned i = 0; i < addedCount; i++) // 將分類中的方法，放到數(shù)組的前面
                array()->lists[i] = addedLists[i]; 
            validate();
        }
    }