// EDdeviceProtocol 协议
@protocol EDdeviceProtocol
- (void)powerOn;
@end

// Computer 类，继承自 NSObject，遵守 EDdeviceProtocol
@interface Computer : NSObject <EDdeviceProtocol> {
// 成员变量
@public
    int _memorySize;
    int _diskSize;
}

// 属性
@property (copy) NSString *model;

// 实例方法
- (void)print:(NSString *)content;

// 类方法
+ (NSString *)arch;
@end

@implementation Computer
- (void)print:(NSString *)content {
    NSLog(@"Print content: %@.", content);
}

// 协议方法
- (void)powerOn {
    NSLog(@"%s", __func__);
}

+ (NSString *)arch {
    return @"ARM 64";
}
@end

// cpt 为指向 Computer 类型实例对象的指针
Computer *cpt = [[Computer alloc] init];

// ERROR: Direct access to Objective-C's isa is deprecated in favor of object_getClass()
// cpt->isa;

cpt->_memorySize = 16;
cpt->_diskSize = 512;

cpt.model = @"MacBook Pro 13'";

// NSObject.h

@interface NSObject <NSObject> {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wobjc-interface-ivars"
    Class isa  OBJC_ISA_AVAILABILITY;
#pragma clang diagnostic pop
}

// 获取类对象的方法：
Class cptClass1 = [cpt class];
Class cptClass2 = [Computer class];
Class cptClass3 = object_getClass(cpt);

// LLDB:
// (lldb) p/x cptClass1
// (Class) $0 = 0x00000001000013d0 Computer
// (lldb) p/x cptClass2
// (Class) $1 = 0x00000001000013d0 Computer
// (lldb) p/x cptClass3
// (Class) $2 = 0x00000001000013d0 Computer

// Object.mm

typedef struct objc_class *Class;

// objc-runtime-new.h
struct objc_class : objc_object {
    // Class ISA;
    // 父类指针
    Class superclass;
    // 方法缓存，详见 Reference
    cache_t cache;             // formerly cache pointer and vtable
    // 可读可写表（class_rw_t）等
    class_data_bits_t bits;    // class_rw_t * plus custom rr/alloc flags

    // ...
};

// objc-private.h
struct objc_object {
private:
    // isa 指针
    isa_t isa;

// ...
}

// objc-runtime-new.h

struct objc_class : objc_object {
    // objc_class 中的 data 方法，返回指向 class_rw_t 的指针
    class_rw_t *data() {
        // bits 即 objc_class 中 class_data_bits_t 结构体类型的成员变量
        return bits.data();
    }

    // ...
}

#if !__LP64__
// 非 64 位，跳过
#elif 1
// class is a Swift class from the pre-stable Swift ABI
#define FAST_IS_SWIFT_LEGACY    (1UL<<0)
// class is a Swift class from the stable Swift ABI
#define FAST_IS_SWIFT_STABLE    (1UL<<1)
// class or superclass has default retain/release/autorelease/retainCount/
//   _tryRetain/_isDeallocating/retainWeakReference/allowsWeakReference
#define FAST_HAS_DEFAULT_RR     (1UL<<2)
// data pointer
#define FAST_DATA_MASK          0x00007ffffffffff8UL
#else
// 不会落到该 case 下，跳过
#endif

struct class_data_bits_t {
    // Values are the FAST_ flags above.
    uintptr_t bits;

    class_rw_t* data() {
        return (class_rw_t *)(bits & FAST_DATA_MASK);
    }

    // ...
}

// sys/_types/_uintptr_t.h
typedef unsigned long           uintptr_t;

// objc-runtime-new.h

// 可读可写表
struct class_rw_t {
    // Be warned that Symbolication knows the layout of this structure.
    uint32_t flags;
    uint32_t version;

    // 只读表的指针（const：不可修改指针指向内存空间中的数据）
    const class_ro_t *ro;

    // 方法、属性、协议信息
    method_array_t methods;
    property_array_t properties;
    protocol_array_t protocols;

    // ...
};

// objc-runtime-new.h

// method_array_t 继承自 list_array_tt，其中 List 类型为 method_list_t，Element 类型为 method_t
class method_array_t :
    public list_array_tt<method_t, method_list_t>
{
    // ...
};

// list_array_tt 中定义了元素类型为 Element，列表为 List
template <typename Element, typename List>
class list_array_tt {
    // ...
};

// method_t 即是 Obj-C 中方法的结构（详见下文）
struct method_t {
    SEL name;
    const char *types;
    MethodListIMP imp;

    // ...
};

// method_list_t 继承自 entsize_list_tt，其中 List 类型为 method_list_t，Element 类型为 method_t
struct method_list_t : entsize_list_tt<method_t, method_list_t, 0x3> {
    // ...
};

// entsize_list_tt 是非脆弱（Non-fragile）结构体数组的一般实现
template <typename Element, typename List, uint32_t FlagMask>
struct entsize_list_tt {
    // ...
};

// main.mm

V_Class cptClassObject = (__bridge V_Class)[Computer class];
v_class_rw_t *cptRWTable = cptClassObject->data();

// objc-runtime-new.h

// 只读表
struct class_ro_t {
    // 标志位
    uint32_t flags;
    uint32_t instanceStart;
    // 实例大小
    uint32_t instanceSize;
#ifdef __LP64__
    uint32_t reserved;
#endif

    const uint8_t * ivarLayout;

    // 类名
    const char * name;
    method_list_t * baseMethodList;
    protocol_list_t * baseProtocols;
    // 成员变量
    const ivar_list_t * ivars;

    const uint8_t * weakIvarLayout;
    property_list_t *baseProperties;

    method_list_t *baseMethods() const {
        return baseMethodList;
    }
};

// objc-runtime-new.h

// 类是未实现的 Future 类（关于 Future 类目前网上资料较少，Runtime 中有 objc_getFutureClass API，官方文档意为用作与 CoreFoundation 中类型无缝桥接（Toll-Free Bridging），比如 __NSCFArray 等，但该方法并未暴露在外界，即不允许开发者去调用）
// class is unrealized future class - must never be set by compiler
#define RO_FUTURE             (1<<30)
// 类已实化
// class is realized - must never be set by compiler
#define RO_REALIZED           (1<<31)

// class_t->data is class_rw_t, not class_ro_t
#define RW_REALIZED           (1<<31)
// class is unresolved future class
#define RW_FUTURE             (1<<30)

// objc-runtime-new.mm

/***********************************************************************
* realizeClass
* Performs first-time initialization on class cls,
* 在类上执行首次初始化，
* including allocating its read-write data.
* 包括分配读写数据。
* Returns the real class structure for the class.
* 返回类的真实类结构。
* Locking: runtimeLock must be write-locked by the caller
**********************************************************************/
static Class realizeClass(Class cls)
{
    runtimeLock.assertLocked();

    // 只读表指针
    const class_ro_t *ro;
    // 可读可写表指针
    class_rw_t *rw;
    Class supercls;
    Class metacls;
    bool isMeta;

    // 若为空，则返回
    if (!cls) return nil;
    // 若已经实化，则返回
    if (cls->isRealized()) return cls;
    assert(cls == remapClass(cls));

    // fixme verify class is not in an un-dlopened part of the shared cache?

    // 实化前，cls->data() 返回指向只读表的指针，因此可以强转
    ro = (const class_ro_t *)cls->data();
    // 判断是否为未来的类（即 RO_FUTURE 标志着读写数据是否已经被分配）
    // 可读可写表和只读表的首个成员均为 flags 且 RO_FUTURE 与 RW_FUTURE 实际值相同
    if (ro->flags & RO_FUTURE) {
        // This was a future class. rw data is already allocated.
        // 将数据赋值给可读可写表
        rw = cls->data();
        // 将可读可写表中的只读表赋值给只读表
        ro = cls->data()->ro;
        // 更新标记位
        cls->changeInfo(RW_REALIZED|RW_REALIZING, RW_FUTURE);
    } else {
        // 通常为该逻辑

        // Normal class. Allocate writeable class data.
        // 普通类，分配可写入类数据
        // 分配空间
        rw = (class_rw_t *)calloc(sizeof(class_rw_t), 1);
        // 将可读可写表中的只读表指针指向只读表指针
        rw->ro = ro;
        // 更新标记位，实化且正在实化
        rw->flags = RW_REALIZED|RW_REALIZING;
        // 将可读可写表写回类中
        cls->setData(rw);
    }

    // ---
    // 以下内容与 class_rw_t 相关性不大，仅供参考

    // 是否为元类
    isMeta = ro->flags & RO_META;

    rw->version = isMeta ? 7 : 0;  // old runtime went up to 6

    // Choose an index for this class.
    // 设置类的索引
    // Sets cls->instancesRequireRawIsa if indexes no more indexes are available
    cls->chooseClassArrayIndex();

    // 打印 Debug 信息
    if (PrintConnecting) {
        _objc_inform("CLASS: realizing class '%s'%s %p %p #%u",
                     cls->nameForLogging(), isMeta ? " (meta)" : "",
                     (void*)cls, ro, cls->classArrayIndex());
    }

    // 先实化父类，再实化类 / 元类，最后实化类本身
    // Realize superclass and metaclass, if they aren't already.
    // This needs to be done after RW_REALIZED is set above, for root classes.
    // This needs to be done after class index is chosen, for root metaclasses.
    supercls = realizeClass(remapClass(cls->superclass));
    metacls = realizeClass(remapClass(cls->ISA()));

#if SUPPORT_NONPOINTER_ISA
    // 通常为该逻辑

    // Disable non-pointer isa for some classes and/or platforms.
    // Set instancesRequireRawIsa.
    bool instancesRequireRawIsa = cls->instancesRequireRawIsa();
    bool rawIsaIsInherited = false;
    static bool hackedDispatch = false;

    if (DisableNonpointerIsa) {
        // Non-pointer isa disabled by environment or app SDK version
        instancesRequireRawIsa = true;
    }
    else if (!hackedDispatch  &&  !(ro->flags & RO_META)  &&
             0 == strcmp(ro->name, "OS_object"))
    {
        // hack for libdispatch et al - isa also acts as vtable pointer
        hackedDispatch = true;
        instancesRequireRawIsa = true;
    }
    else if (supercls  &&  supercls->superclass  &&
             supercls->instancesRequireRawIsa())
    {
        // This is also propagated by addSubclass()
        // but nonpointer isa setup needs it earlier.
        // Special case: instancesRequireRawIsa does not propagate
        // from root class to root metaclass
        instancesRequireRawIsa = true;
        rawIsaIsInherited = true;
    }

    if (instancesRequireRawIsa) {
        cls->setInstancesRequireRawIsa(rawIsaIsInherited);
    }
// SUPPORT_NONPOINTER_ISA
#endif

    // Update superclass and metaclass in case of remapping
    // 在重新映射的情况下更新超类和元类
    cls->superclass = supercls;
    cls->initClassIsa(metacls);

    // Reconcile instance variable offsets / layout.
    // This may reallocate class_ro_t, updating our ro variable.
    // 如果是父类，且非元类，调整实例变量，可能会重新分配 class_ro_t 并更新 ro 变量
    if (supercls  &&  !isMeta) reconcileInstanceVariables(cls, supercls, ro);

    // Set fastInstanceSize if it wasn't set already.
    // 设置实例大小
    cls->setInstanceSize(ro->instanceSize);

    // Copy some flags from ro to rw
    if (ro->flags & RO_HAS_CXX_STRUCTORS) {
        cls->setHasCxxDtor();
        if (! (ro->flags & RO_HAS_CXX_DTOR_ONLY)) {
            cls->setHasCxxCtor();
        }
    }

    // 设置子类 / 基类
    // Connect this class to its superclass's subclass lists
    if (supercls) {
        addSubclass(supercls, cls);
    } else {
        addRootClass(cls);
    }

    // Attach categories
    // 真正去连接分类
    methodizeClass(cls);

    return cls;
}

struct objc_class : objc_object {
    // 判断类是否实化
    bool isRealized() {
        return data()->flags & RW_REALIZED;
    }
}

// objc.h

/// An opaque type that represents a method selector.
typedef struct objc_selector *SEL;

// objc-ptrauth.h

#if __has_feature(ptrauth_calls)
// Method lists use process-independent signature for compatibility.
using MethodListIMP = IMP __ptrauth_objc_method_list_imp;
#else
using MethodListIMP = IMP;
#endif

struct method_t {
    SEL name;
    const char *types;
    MethodListIMP imp;

    struct SortBySELAddress :
        public std::binary_function<const method_t&,
                                    const method_t&, bool>
    {
        bool operator() (const method_t& lhs,
                         const method_t& rhs)
        { return lhs.name < rhs.name; }
    };
};

VClass cptMetaVClass = (__bridge VClass)object_getClass([Computer class]);
class_rw_t *rwt = cptMetaVClass->data();

// LLDB:
// Printing description of rwt->methods->first:
// (method_t) first = {
//     name = "arch"
//     types = 0x0000000100000f86 "@16@0:8"
//     imp = 0x0000000100000d40 (DemoOC`::+[Computer arch]() at main.mm:52)
// }

@interface Computer : NSObject
- (void)run;
@end

@implementation Computer
@end

@interface Mac : Computer
@end

@implementation Mac
// - (void)run {
//     NSLog(@"RUN");
// }
@end

// '-[Mac run]: unrecognized selector sent to instance 0x10330f6c0'
[[[Mac alloc] init] run];

@interface NSObject (Extension)
@end

@implementation NSObject (Extension)
- (void)run {
    NSLog(@"RUN");
}
@end

@interface Computer : NSObject
+ (void)run;
@end

@implementation Computer
@end

@interface Mac : Computer
@end

@implementation Mac
@end

// OUTPUT:
// RUN