// C 语言函数
int cFunc(int arg) {
    return arg;
}

int main_1(int argc, const char * argv[]) {
    int result1 = cFunc(10);

    // C 语言中的函数指针需要通过函数名来获得其地址
    int (*cFuncPtr)(int) = &cFunc;
    int result2 = (*cFuncPtr)(10);

    printf("result1 = %d, result2 = %d\n", result1, result2);

    return 0;
}

// OUTPUT:
// result1 = 10, result2 = 10

// main_2

// 省略返回值的 void
^(int arg) {
    printf("%d\n", arg);
};

// 完整写法
^void (int arg) {
    printf("%d\n", arg);
};

Block_literal_expression ::= ^ block_decl compound_statement_body
block_decl ::=
block_decl ::= parameter_list
block_decl ::= type_expression

// main_2

// 省略返回值 & 参数
^{ /* compound_statement_body */ };
// 省略返回值
^(int arg){ /* compound_statement_body */ };
// 省略参数
^int{ /* compound_statement_body */ return 0; };

// BlockType_1 是一个参数和返回值均为 int 的 Block 类型
typedef int (^BlockType_1)(int);

@interface Foo_1 : NSObject
@property (nonatomic, strong) BlockType_1 block;
@end

@implementation Foo_1
// 作为对象方法参数
- (void)blockAsArg_1:(int(^)(int))block {
    block(10);
}
// 使用 typedef 作为对象方法参数
- (void)blockAsArg_2:(BlockType_1)block {
    block(10);
}
// 作为对象方法返回值
- (int(^)(int))blockAsReturnValue_1 {
    return ^(int arg) { return arg; };
}
// 使用 typedef 作为对象方法返回值
- (BlockType_1)blockAsReturnValue_2 {
    return ^(int arg) { return arg; };
}
@end

// Block 作为 C 语言函数参数
void blockAsArg_1(int (^block)(int)) {
    block(10);
}
// 使用 typedef 作为 C 语言函数参数
void blockAsArg_2(BlockType_1 block) {
    block(10);
}

// 《Objective-C 高级编程》中提到的，将 Block 以非 typedef 形式作为 C 语言函数的返回值类型；但目前会报错，且尚未找到相应的解决方法：
// ERROR: Block pointer to non-function type is invalid
// ERROR: Returning 'int (^)(int)' from a function with incompatible result type 'int (int)'
// int (^blockAsReturnValue()(int)) {
//     return ^(int arg) { return arg; };
// }

BlockType_1 blockAsReturnValue() {
    return ^(int arg) { return arg; };
}

int main_2(int argc, const char * argv[]) {
    // 声明 Block 类型的变量
    int (^block1)(int);
    // 声明并赋值 Block（省略返回值类型）
    int(^block2)(int) = ^(int arg) { return arg; };
    block2 = ^int(int arg) { return arg; };
    // Block 类型的变量之间赋值
    int (^block3)(int) = block2;

    block1 = block2;

    // 使用 typedef
    BlockType_1 block4;
    BlockType_1 block5 = ^(int arg) { return arg; };
    block5 = ^int(int arg) { return arg; };
    BlockType_1 block6 = block5;
    block4 = block5;

    return 0;
}

int main_3(int argc, const char * argv[]) {
    void(^block)(void) = ^{
        NSLog(@"Hello, World!");
    };

    block();

    return 0;
}

// OUTPUT:
// Hello, World!

// Block 实现的结构体
struct __block_impl {
  void *isa;     // isa 指针，即 Block 也是 id 类型，即 Obj-C 对象
  int Flags;     // 标记，默认会被初始化为 0
  int Reserved;  // 保留域（ABI 兼容），默认 0
  void *FuncPtr; // Block 代码块的函数指针
};

// ➡️ Block 结构体
struct __main_3_block_impl_0 {
  struct __block_impl impl;           // 实现（非指针）
  struct __main_3_block_desc_0* Desc; // 描述信息（指针）
  // 构造函数
  __main_3_block_impl_0(void *fp, struct __main_3_block_desc_0 *desc, int flags=0) {
    impl.isa = &_NSConcreteStackBlock; // Block 作为 Obj-C 对象，那么 isa 将指向其类对象，即 _NSConcreteStackBlock
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

// Block 内代码块封装在该 C 语言静态函数中，函数命名规则：__CALLER_METHOD_NAME_block_func_NUMBER
// 类似 Obj-C 实例方法参数 self 或 C++ 实例方法参数 this，__cself 为指向 Block 结构体的变量
static void __main_3_block_func_0(struct __main_3_block_impl_0 *__cself) {
  NSLog((NSString *)&__NSConstantStringImpl__var_folders_ps_0m9gnvtj0893vpf1cr595djh0000gn_T_main_b9596e_mi_0);
}

// Block 描述信息的结构体静态变量
static struct __main_3_block_desc_0 {
  size_t reserved;   // 保留域，默认 0
  size_t Block_size; // Block 大小，sizeof 整个 Block 结构体 ⬇️
} __main_3_block_desc_0_DATA = { 0, sizeof(struct __main_3_block_impl_0)};

// 主函数
int main_3(int argc, const char * argv[]) {
    // 通过 __main_3_block_impl_0 结构体的构造函数初始化，参数为静态函数和描述信息静态变量的地址，将地址存储在 block 变量中
    // 忽略类型转换：block = &__main_3_block_impl_0(__main_3_block_func_0, &__main_3_block_desc_0_DATA));
    void(*block)(void) = ((void (*)())&__main_3_block_impl_0((void *)__main_3_block_func_0, &__main_3_block_desc_0_DATA));

    // 执行 Block（参数 block 即静态函数中的参数 __cself）
    // 忽略类型转换：block->FuncPtr(block);
    // 在 __main_block_impl_0 结构体中，impl 是第一个变量，因此其与结构体本身的首地址一致，因此可以强转
    ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);

    return 0;
}

int main_4(int argc, const char * argv[]) {
    void (^block)(void);

    {
        auto int autoVar = 1;
        const char *autoConstVar = "kingcos.me";

        block = ^() {
            NSLog(@"autoVar == %d, autoConstVar == %s", autoVar, autoConstVar);
        };

        autoVar = 10;
        // const char * 为常量，不可改变存储的类型
        // autoConstVar = 1.5;
    }

    // ERROR: Use of undeclared identifier 'autoVar'
    // autoVar = 10;

    block();

    return 0;
}

// OUTPUT:
// autoVar == 1, autoConstVar == kingcos.me

struct __main_4_block_impl_0 {
  struct __block_impl impl;
  struct __main_4_block_desc_0* Desc;
  int autoVar;              // 捕获的自动变量 autoVar
  const char *autoConstVar; // 捕获的变量类型与外界声明完全相同

  __main_4_block_impl_0(void *fp, struct __main_4_block_desc_0 *desc, int _autoVar, const char *_autoConstVar, int flags=0) : autoVar(_autoVar), autoConstVar(_autoConstVar) { // 构造函数初始化内结构体内部的自动变量
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

static void __main_4_block_func_0(struct __main_4_block_impl_0 *__cself) {
  // 从 __celf 取初始化时获得的值
  int autoVar = __cself->autoVar; // bound by copy
  const char *autoConstVar = __cself->autoConstVar; // bound by copy

  NSLog((NSString *)&__NSConstantStringImpl__var_folders_ps_0m9gnvtj0893vpf1cr595djh0000gn_T_main_27d308_mi_3, autoVar, autoConstVar);
}

static struct __main_4_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} __main_4_block_desc_0_DATA = { 0, sizeof(struct __main_4_block_impl_0)};

int main_4(int argc, const char * argv[]) {
    // 在代码块外声明的 Block 变量
    void (*block)(void);

    {
        auto int autoVar = 1;
        const char *autoConstV// 构造时将外部自动变量的值直接传入
        // 忽略类型转换：block = &__main_4_block_impl_0(__main_4_block_func_0, &__main_4_block_desc_0_DATA, autoVar, autoConstVar));
        block = ((void (*)())&__main_4_block_impl_0((void *)__main_4_block_func_0, &__main_4_block_desc_0_DATA, autoVar, autoConstVar));

        autoVar = 10;
    }

    // 执行 Block
    // 忽略类型转换：block->FuncPtr(block);
    ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);

    return 0;
}

@interface Foo_2 : NSObject
@property (nonatomic, copy) NSString *prop;

- (void)bar_1;
- (void)bar_2;

+ (void)bar;
@end

@implementation Foo_2
- (void)dealloc
{
    NSLog(@"dealloc");
}

- (void)bar_1 {
    void (^block_1)(void) = ^() {
        NSLog(@"self == %@", self);
    };

    block_1();
}

- (void)bar_2 {
    self.prop = @"kingcos.me";

    void (^block_2)(void) = ^() {
        // WARNING: Block implicitly retains 'self'; explicitly mention 'self' to indicate this is intended behavior
        // NSLog(@"_prop == %@.", _prop);

        NSLog(@"_prop == %@", self->_prop);
    };

    block_2();
}

+ (void)bar {
    void (^block)(void) = ^() {
        NSLog(@"self == %@", self);
    };

    block();
}
@end

int main_4(int argc, const char * argv[]) {
    Foo_2 *foo = [[Foo_2 alloc] init];
    [foo bar_1];
    [foo bar_2];

    [Foo_2 bar];

    return 0;
}

// OUTPUT:
// self == <Foo_2: 0x100532d80>
// _prop == kingcos.me
// self == Foo_2
// dealloc

struct __Foo_2__bar_1_block_impl_0 {
  struct __block_impl impl;
  struct __Foo_2__bar_1_block_desc_0* Desc;
  Foo_2 *const __strong self; // 捕获的 self

  __Foo_2__bar_1_block_impl_0(void *fp, struct __Foo_2__bar_1_block_desc_0 *desc, Foo_2 *const __strong _self, int flags=0) : self(_self) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

static void __Foo_2__bar_1_block_func_0(struct __Foo_2__bar_1_block_impl_0 *__cself) {
  // 执行时取出 self
  Foo_2 *const __strong self = __cself->self; // bound by copy

  NSLog((NSString *)&__NSConstantStringImpl__var_folders_ps_0m9gnvtj0893vpf1cr595djh0000gn_T_main_169b69_mi_1, self);
}

struct __Foo_2__bar_2_block_impl_0 {
  struct __block_impl impl;
  struct __Foo_2__bar_2_block_desc_0* Desc;
  Foo_2 *const __strong self; // 捕获的 self

  __Foo_2__bar_2_block_impl_0(void *fp, struct __Foo_2__bar_2_block_desc_0 *desc, Foo_2 *const __strong _self, int flags=0) : self(_self) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

static void __Foo_2__bar_2_block_func_0(struct __Foo_2__bar_2_block_impl_0 *__cself) {
  Foo_2 *const __strong self = __cself->self; // bound by copy

  // self + OBJC_IVAR_$_Foo_2$_prop：成员变量是根据 self 做的偏移
  NSLog((NSString *)&__NSConstantStringImpl__var_folders_ps_0m9gnvtj0893vpf1cr595djh0000gn_T_main_169b69_mi_3, (*(NSString *__strong *)((char *)self + OBJC_IVAR_$_Foo_2$_prop)));
}

struct __Foo_2__bar_block_impl_0 {
  struct __block_impl impl;
  struct __Foo_2__bar_block_desc_0* Desc;
  const Class self; // 对于类方法，则捕获的是类对象
  __Foo_2__bar_block_impl_0(void *fp, struct __Foo_2__bar_block_desc_0 *desc, const Class _self, int flags=0) : self(_self) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

static void __Foo_2__bar_block_func_0(struct __Foo_2__bar_block_impl_0 *__cself) {
  const Class self = __cself->self; // bound by copy

  NSLog((NSString *)&__NSConstantStringImpl__var_folders_ps_0m9gnvtj0893vpf1cr595djh0000gn_T_main_169b69_mi_4, self);
}

int main_5(int argc, const char * argv[]) {
    void (^block)(void);

    {
        static int a = 1;

        block = ^() {
            NSLog(@"a == %d", a);
        };

        a = 10;
    }

    block();

    return 0;
}

// OUTPUT:
// a == 10

struct __main_5_block_impl_0 {
  struct __block_impl impl;
  struct __main_5_block_desc_0* Desc;
  int *a; // 捕获的变量，类型为指向 int 类型的指针
  __main_5_block_impl_0(void *fp, struct __main_5_block_desc_0 *desc, int *_a, int flags=0) : a(_a) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

static void __main_5_block_func_0(struct __main_5_block_impl_0 *__cself) {
  // int *a = &a;（外界 a 的地址）
  int *a = __cself->a; // bound by copy

  NSLog((NSString *)&__NSConstantStringImpl__var_folders_ps_0m9gnvtj0893vpf1cr595djh0000gn_T_main_0fafd0_mi_4, (*a));
}

static struct __main_5_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} __main_5_block_desc_0_DATA = { 0, sizeof(struct __main_5_block_impl_0)};

int main_5(int argc, const char * argv[]) {
    void (*block)(void);

    {
        static int a = 1;

        // 忽略类型转换：block = &__main_5_block_impl_0(__main_5_block_func_0, &__main_5_block_desc_0_DATA, &a);（&a 即 a 的地址作为参数传入）
        block = ((void (*)())&__main_5_block_impl_0((void *)__main_5_block_func_0, &__main_5_block_desc_0_DATA, &a));

        // a 的值发生改变
        a = 10;
    }

    ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);

    return 0;
}

// 全局变量
int globalVar_1 = 1;
// 全局静态变量
static int staticGlobalVar_1 = 2;

int main_6(int argc, const char * argv[]) {
    void (^block)(void) = ^() {
        NSLog(@"globalVar_1 == %d, staticGlobalVar_1 == %d", globalVar_1, staticGlobalVar_1);
    };

    globalVar_1 = 10;
    staticGlobalVar_1 = 20;

    block();

    return 0;
}

// OUTOUT:
// globalVar_1 == 10, staticGlobalVar_1 == 20

int globalVar_1 = 1;
static int staticGlobalVar_1 = 2;

struct __main_6_block_impl_0 {
  struct __block_impl impl;
  struct __main_6_block_desc_0* Desc;
  // 没有捕获

  __main_6_block_impl_0(void *fp, struct __main_6_block_desc_0 *desc, int flags=0) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

static void __main_6_block_func_0(struct __main_6_block_impl_0 *__cself) {
  // 直接访问
  NSLog((NSString *)&__NSConstantStringImpl__var_folders_ps_0m9gnvtj0893vpf1cr595djh0000gn_T_main_d50b04_mi_8, globalVar_1, staticGlobalVar_1);
}

void cFunc_2(char a[10]) {
    printf("%d\n", a[0]);
}

void cFunc_3(char a[10]) {
    // C 语言不允许数组类型变量赋值给另外的数组类型变量
    // ERROR: Array initializer must be an initializer list or string literal
    // char b[10] = a;
    // printf("%d\n", b[0]);
}

int main_7(int argc, const char * argv[]) {
    const char cLocalArr[] = "kingcos.me";
    const char *cLocalString = "kingcos.me";

    ^{
        // Block 不会对 C 语言数组进行捕获
        // ERROR: Cannot refer to declaration with an array type inside block
        // printf("%c\n", cLocalArr[7]);

        // 使用指针代替
        printf("%c\n", cLocalString[7]);
    }();

    // 猜测 Block 遵循了类似 C 语言的规范
    char a[10] = {2};

    cFunc_2(a);
    cFunc_3(a);

    return 0;
}

// OUTPUT:
// .
// 2

int main_8(int argc, const char * argv[]) {
    void (^block1)(void) = ^() {
        NSLog(@"Hello, world!");
    };

    int a = 1;
    void (^block2)(void) = ^() {
        NSLog(@"%d", a);
    };

    NSLog(@"%@ %@ %@", [block1 class], [block2 class], [^{
        NSLog(@"%d", a);
    } class]);

    NSLog(@"%@ %@ %@", [block1 superclass], [block2 superclass],[^{
        NSLog(@"%d", a);
    } superclass]);

    NSLog(@"%@ %@ %@", [[block1 superclass] superclass], [[block2 superclass] superclass],[[^{
        NSLog(@"%d", a);
    } superclass] superclass]);

    NSLog(@"%@ %@ %@", [[[block1 superclass] superclass] superclass], [[[block2 superclass] superclass] superclass],[[[^{
        NSLog(@"%d", a);
    } superclass] superclass] superclass]);

    return 0;
}

// OUTPUT:
// __NSGlobalBlock__ __NSMallocBlock__ __NSStackBlock__
// __NSGlobalBlock __NSMallocBlock __NSStackBlock
// NSBlock NSBlock NSBlock
// NSObject NSObject NSObject

int globalVar_2 = 1;

int main_9(int argc, const char * argv[]) {
    void (^gloablBlock)(void) = ^{
        // 没有访问任何外界变量
        NSLog(@"This is a __NSGlobalBlock__.");
    };

    NSLog(@"%@", [gloablBlock class]);

    static int staticVar = 1;

    gloablBlock = ^{
        // 访问了全局变量或局部静态变量
        NSLog(@"globalVar2 == %d, staticVar == %d.", globalVar_2, staticVar);
    };

    NSLog(@"%@", [gloablBlock class]);

    // 该 Block 实际初始化时将：
    // impl.isa = &_NSConcreteGlobalBlock;

    return 0;
}

// OUTPUT:
// __NSGlobalBlock__
// __NSGlobalBlock__

int main_10(int argc, const char * argv[]) {
#if !__has_feature(objc_arc)
    int c = 1;

    void (^stackBlock)(void) = ^{
        NSLog(@"c == %d.", c);
    };

    NSLog(@"%@", [stackBlock class]);
#endif

    // stackBlock 初始化时将：
    // impl.isa = &_NSConcreteStackBlock;

    return 0;
}

// OUTPUT:
//  __NSStackBlock__

@interface Foo_3 : NSObject
@end

@implementation Foo_3
- (void)dealloc
{
#if !__has_feature(objc_arc)
    [super dealloc]; // MRC 下需手动调用下父类的 dealloc
#endif
    NSLog(@"dealloc");
}
@end

void (^stackBlock_1)(void);
void (^stackBlock_2)(void);

void initBlockInARC() {
#if __has_feature(objc_arc)
    // 初始化，引用计数 +1
    Foo_3 *strongF = [[Foo_3 alloc] init];

    NSLog(@"%ld", CFGetRetainCount((__bridge CFTypeRef)(strongF)));

    // 弱引用，引用计数不变 +0
    __weak Foo_3 *weakF = strongF;

    NSLog(@"%ld", CFGetRetainCount((__bridge CFTypeRef)(strongF)));

    // Block 捕获，引用计数 +1
    // __NSStackBlock__
    ^{
        NSLog(@"%@", strongF);
        NSLog(@"%@", weakF);
    };

    NSLog(@"%ld", CFGetRetainCount((__bridge CFTypeRef)(strongF)));
#endif
}

void initBlockInMRC() {
#if !__has_feature(objc_arc)
    int c = 10;

    stackBlock_1 = ^{
        NSLog(@"c == %d", c);
    };

    // 初始化，引用计数 +1
    Foo_3 *f = [[Foo_3 alloc] init];

    NSLog(@"%ld", [f retainCount]);

    // MRC 下 stackBlock_2 捕获 f 但不持有，引用计数 +0
    stackBlock_2 = ^{
       NSLog(@"f == %@", f);
    };

    NSLog(@"%ld", [f retainCount]);

    [f release];
#endif
}

int main_11(int argc, const char * argv[]) {
#if __has_feature(objc_arc)
    // 初始化 stackBlock
    initBlockInARC();
#else
    // 初始化 stackBlock
    initBlockInMRC();

    // 执行 stackBlock_1
    stackBlock_1(); // c == -272632744
    // 执行 stackBlock_2
    stackBlock_2(); // CRASH: objc[59614]: Attempt to use unknown class 0x7ffeefbff428.

    NSLog(@"stackBlock_1 is a %@.", [stackBlock_1 class]); // CRASH: EXC_BAD_ACCESS
#endif

    return 0;
}

// MRC OUTPUT:
// 1
// 1
// dealloc

// ARC OUTPUT:
// 1
// 1
// 2
// dealloc

struct __initBlockInARC_block_impl_0 {
  struct __block_impl impl;
  struct __initBlockInARC_block_desc_0* Desc;
  Foo_3 *__strong strongF; // ⚠️ 强引用
  Foo_3 *__weak weakF;     // ⚠️ 弱引用

  __initBlockInARC_block_impl_0(void *fp, struct __initBlockInARC_block_desc_0 *desc, Foo_3 *__strong _strongF, Foo_3 *__weak _weakF, int flags=0) : strongF(_strongF), weakF(_weakF) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

@interface Foo_4 : NSObject
@end

@implementation Foo_4
- (void)dealloc
{
#if !__has_feature(objc_arc)
    [super dealloc];
#endif
    NSLog(@"dealloc");
}
@end

typedef void(^BlockType_2)(void);

void (^mallocBlock_1)(void);
void (^mallocBlock_2)(void);

void initBlock() {
#if !__has_feature(objc_arc)
    int c = 10;

    mallocBlock_1 = [^{
        NSLog(@"c == %d", c);
    } copy];

    Foo_4 *f = [[Foo_4 alloc] init];

    mallocBlock_2 = [^{
        NSLog(@"%@", f);
    } copy];

    [f release];
#else
    int c = 10;

    mallocBlock_1 = ^{
        NSLog(@"c == %d", c);
    };

    Foo_4 *strongF = [[Foo_4 alloc] init];
    __weak Foo_4 *weakF = strongF;

    // 1⃣️ ARC 下强指针 mallocBlock_2 指向的 Block 会被自动拷贝为 __NSMallocBlock__
    mallocBlock_2 = ^{
        NSLog(@"%@", strongF);
        NSLog(@"%@", weakF);
    };

    // 使用弱引用指针指向的 Block，将仍然是 __NSStackBlock__，编译将提示以下警告
    // WARNING: Assigning block literal to a weak variable; object will be released after assignment
    __weak BlockType_2 weakStackBlock = ^{
        NSLog(@"%@", strongF);
        NSLog(@"%@", weakF);
    };

    NSLog(@"weakStackBlock is %@", weakStackBlock);

    // 3⃣️ Block 作为 Cocoa API 中方法名含有 `usingBlock` 的参数时会被自动拷贝为 __NSMallocBlock__
    // 4⃣️ Block 作为 GCD API 参数时会被自动拷贝为 __NSMallocBlock__
#endif
}

BlockType_2 returnMallocBlock() {
    auto int autoVar = 10;

#if !__has_feature(objc_arc)
    // MRC 下如果直接返回 Block，将报错「Returning block that lives on the local stack」
    // 即编译器已经发现返回的 Block 是在栈上，一旦函数体走完，Block 就会被销毁，因此在 MRC 下需要手动 copy：
    return [^{
        NSLog(@"%d", autoVar);
    } copy];
#else
    // 2⃣️ ARC 下 Block 作为函数返回值会被自动拷贝为 __NSMallocBlock__
    return ^{
        NSLog(@"%d", autoVar);
    };
#endif
}

int main_12(int argc, const char * argv[]) {
    initBlock();

    NSLog(@"mallocBlock_1 is %@", [mallocBlock_1 class]);
    NSLog(@"mallocBlock_2 is %@", [mallocBlock_2 class]);
    NSLog(@"returnMallocBlock() is %@", [returnMallocBlock() class]);

    mallocBlock_1();
    mallocBlock_2();

#if !__has_feature(objc_arc)
    [mallocBlock_1 release];
    [mallocBlock_2 release];
#endif

    return 0;
}

// MRC OUTPUT:
// mallocBlock_1 is __NSMallocBlock__
// mallocBlock_2 is __NSMallocBlock__
// returnMallocBlock() is __NSMallocBlock__
// c == 10
// <Foo_4: 0x100559170>
// dealloc

// ARC OUTPUT:
// weakStackBlock is <__NSStackBlock__: 0x7ffeefbff3d0>
// mallocBlock_1 is __NSMallocBlock__
// mallocBlock_2 is __NSMallocBlock__
// returnMallocBlock() is __NSMallocBlock__
// c == 10
// <Foo_4: 0x1022a7e40>
// <Foo_4: 0x1022a7e40>
// ⚠️：此处 mallocBlock_1 & mallocBlock_2 全局变量还没有释放，因而持有的 strongF 也没有被释放

@interface Foo_5 : NSObject
#if !__has_feature(objc_arc)
// MRC
@property (nonatomic, copy) void (^block_1)(void);
#else
// ARC
@property (nonatomic, copy) void (^block_2)(void);
@property (nonatomic, strong) void (^block_3)(void);
#endif
@end

@implementation Foo_5
@end

#if __has_feature(objc_arc)
typedef int(^BlockType_3)(int);

BlockType_3 returnSomeBlock(int arg) {
    return ^(int param){ return arg * param; };
}
#endif

int main_13(int argc, const char * argv[]) {
#if __has_feature(objc_arc)
    NSLog(@"%@", returnSomeBlock(10));
#endif

    return 0;
}

// OUTPUT:
// <__NSMallocBlock__: 0x1006baa60>

BlockType_3 returnSomeBlock(int arg) {
    return ((int (*)(int))&__returnSomeBlock_block_impl_0((void *)__returnSomeBlock_block_func_0, &__returnSomeBlock_block_desc_0_DATA, arg));
}

Block_in_Obj-C`returnSomeBlock:
    0x100003390 <+0>:  pushq  %rbp
    0x100003391 <+1>:  movq   %rsp, %rbp
    0x100003394 <+4>:  subq   $0x30, %rsp
    0x100003398 <+8>:  movl   %edi, -0x4(%rbp)
->  0x10000339b <+11>: movq   0xc5e(%rip), %rax         ; (void *)0x00007fff8dfbbe40: _NSConcreteStackBlock
    0x1000033a2 <+18>: movq   %rax, -0x28(%rbp)
    0x1000033a6 <+22>: movl   $0xc0000000, -0x20(%rbp)  ; imm = 0xC0000000
    0x1000033ad <+29>: movl   $0x0, -0x1c(%rbp)
    0x1000033b4 <+36>: leaq   0x35(%rip), %rax          ; __returnSomeBlock_block_invoke at main.m:551
    0x1000033bb <+43>: movq   %rax, -0x18(%rbp)
    0x1000033bf <+47>: leaq   0x1022(%rip), %rax        ; __block_descriptor_36_e8_i12
?0i8l
    0x1000033c6 <+54>: movq   %rax, -0x10(%rbp)
    0x1000033ca <+58>: movl   -0x4(%rbp), %edi
    0x1000033cd <+61>: movl   %edi, -0x8(%rbp)
    0x1000033d0 <+64>: leaq   -0x28(%rbp), %rdi
    0x1000033d4 <+68>: callq  0x100003ac0               ; symbol stub for: objc_retainBlock
    0x1000033d9 <+73>: movq   %rax, %rdi
    0x1000033dc <+76>: addq   $0x30, %rsp
    0x1000033e0 <+80>: popq   %rbp
    0x1000033e1 <+81>: jmp    0x100003a8a               ; symbol stub for: objc_autoreleaseReturnValue

BlockType_3 returnSomeBlock(int arg) {
    // 构造 Block，赋值给 tmp 变量（默认是强指针引用）
    BlockType_3 __strong tmp = &__returnSomeBlock_block_impl_0(
        __returnSomeBlock_block_func_0,
        &__returnSomeBlock_block_desc_0_DATA,
        arg
    );
    // 根据 objc4 - NSObject.mm，等同 tmp = _Block_copy(tmp);，_Block_copy 的源码 Apple 开源在 libclosure
    // 将栈上的 Block 拷贝到堆上，并将堆上 Block 地址返回给 tmp 保存
    tmp = objc_retainBlock(tmp);
    // 注册到自动释放池并返回
    return objc_autoreleaseReturnValue(tmp);
}

typedef void(^BlockType_4)(void);

NSArray *returnBlocksArray_1() {
    int autoVar = 1;

    return [[NSArray alloc] initWithObjects:
            ^{ NSLog(@"%d", autoVar); },
            ^{ NSLog(@"%d", autoVar); },
            nil];
}

int main_14(int argc, const char * argv[]) {
    NSArray *arr_1 = returnBlocksArray_1();
    BlockType_4 block_1 = (BlockType_4)[arr_1 objectAtIndex:0];
    block_1();
    // CRASH: EXC_BAD_ACCESS
    // block_1 = (BlockType_4)[arr_1 objectAtIndex:1];

    return 0;
}

// OUTPUT:
// 1

NSArray *returnBlocksArray_2() {
    int autoVar = 10;

    // 拷贝到堆上
    return [[NSArray alloc] initWithObjects:
            [^{ NSLog(@"%d", autoVar); } copy],
            [^{ NSLog(@"%d", autoVar); } copy],
            nil];
}

NSArray *returnBlocksArray_3() {
    int autoVar = 100;

    // 使用强指针指向
    BlockType_4 block = ^{ NSLog(@"%d", autoVar); };

    return [[NSArray alloc] initWithObjects:
            block,
            block,
            nil];
}

int main_14(int argc, const char * argv[]) {
    NSArray *arr_2 = returnBlocksArray_2();
    BlockType_4 block_2 = (BlockType_4)[arr_2 objectAtIndex:0];
    block_2();
    block_2 = (BlockType_4)[arr_2 objectAtIndex:1];
    block_2();

    NSArray *arr_3 = returnBlocksArray_3();
    BlockType_4 block_3 = (BlockType_4)[arr_3 objectAtIndex:0];
    block_3();
    block_3 = (BlockType_4)[arr_3 objectAtIndex:1];
    block_3();

    return 0;
}

// OUTPUT:
// 10
// 10
// 100
// 100

int main_14(int argc, const char * argv[]) {
    int autoVar = 0;
    BlockType_4 block_4 = ^{ NSLog(@"%d", autoVar); };
    block_4 = [[[block_4 copy] copy] copy];

    NSLog(@"%ld", CFGetRetainCount((__bridge CFTypeRef)(block_4)));

    return 0;
}

// OUTPUT:
// 1

@interface Foo_6 : NSObject
@end

@implementation Foo_6
- (void)dealloc
{
    NSLog(@"dealloc");
}
@end

int main_15(int argc, const char * argv[]) {
    Foo_6 *strongF = [[Foo_6 alloc] init];

    __weak Foo_6 *weakF = strongF;

    void(^someBlcok)(void) = ^{
        NSLog(@"%@", strongF);
        NSLog(@"%@", weakF);
    };

    someBlcok();

    return 0;
}

// OUTPUT:
// <Foo_6: 0x1007ab750>
// <Foo_6: 0x1007ab750>
// dealloc

struct __main_15_block_impl_0 {
  struct __block_impl impl;
  struct __main_15_block_desc_0* Desc;
  Foo_6 *__strong strongF; // 默认强引用
  Foo_6 *__weak weakF;     // 显式弱引用
  __main_15_block_impl_0(void *fp, struct __main_15_block_desc_0 *desc, Foo_6 *__strong _strongF, Foo_6 *__weak _weakF, int flags=0) : strongF(_strongF), weakF(_weakF) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

static void __main_15_block_func_0(struct __main_15_block_impl_0 *__cself) {
  Foo_6 *__strong strongF = __cself->strongF; // bound by copy
  Foo_6 *__weak weakF = __cself->weakF; // bound by copy

  NSLog((NSString *)&__NSConstantStringImpl__var_folders_ps_0m9gnvtj0893vpf1cr595djh0000gn_T_main_e96639_mi_49, strongF);
  NSLog((NSString *)&__NSConstantStringImpl__var_folders_ps_0m9gnvtj0893vpf1cr595djh0000gn_T_main_e96639_mi_50, weakF);
}

// 栈上的 Block 拷贝到堆时，会调用 __main_block_copy_0 方法
static void __main_15_block_copy_0(struct __main_15_block_impl_0*dst, struct __main_15_block_impl_0*src) {
    // _Block_object_assign 函数会根据自动变量的修饰符（__strong / __weak）作出相应的操作，形成强引用或弱引用（类似 Retain，将对象赋值在对象类型的结构体成员变量中）
    // BLOCK_FIELD_IS_OBJECT 为 flags，函数内部根据此参数决定相应的处理逻辑；该 flag 对应为 _Block_retain_object
    _Block_object_assign((void*)&dst->strongF, (void*)src->strongF, 3/*BLOCK_FIELD_IS_OBJECT*/); // 对外界 strongF 强引用
    _Block_object_assign((void*)&dst->weakF, (void*)src->weakF, 3/*BLOCK_FIELD_IS_OBJECT*/);     // 对外界 weakF 弱引用
    // _Block_object_assign 的源码 Apple 开源在 libclosure，此处暂略
}

// 堆上的 Block 销毁时，会调用 __main_15_block_dispose_0 方法，类似对象的 dealloc 方法
static void __main_15_block_dispose_0(struct __main_15_block_impl_0*src) {
    // _Block_object_dispose 函数使得自动变量的引用计数减一（类似 Release，释放赋值在对象类型的结构体成员变量中的对象）
    // BLOCK_FIELD_IS_OBJECT 对应为 _Block_release_object(object);
    _Block_object_dispose((void*)src->strongF, 3/*BLOCK_FIELD_IS_OBJECT*/);
    _Block_object_dispose((void*)src->weakF, 3/*BLOCK_FIELD_IS_OBJECT*/);
}

static struct __main_15_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  // 当在 Block 中访问对象类型的自动变量时会增加额外的域来协助管理内存
  void (*copy)(struct __main_15_block_impl_0*, struct __main_15_block_impl_0*);
  void (*dispose)(struct __main_15_block_impl_0*);
} __main_15_block_desc_0_DATA = { 0, sizeof(struct __main_15_block_impl_0), __main_15_block_copy_0, __main_15_block_dispose_0};

int main_15(int argc, const char * argv[]) {
    Foo_6 *strongF = ((Foo_6 *(*)(id, SEL))(void *)objc_msgSend)((id)((Foo_6 *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("Foo_6"), sel_registerName("alloc")), sel_registerName("init"));

    __attribute__((objc_ownership(weak))) Foo_6 *weakF = strongF;

    void(*someBlcok)(void) = ((void (*)())&__main_15_block_impl_0((void *)__main_15_block_func_0, &__main_15_block_desc_0_DATA, strongF, weakF, 570425344));

    ((void (*)(__block_impl *))((__block_impl *)someBlcok)->FuncPtr)((__block_impl *)someBlcok);

    return 0;
}

// 静态全局变量
static int staticGlobalVar = 0;
// 全局变量
int globalVar = 0;

int main_16(int argc, const char * argv[]) {
    // 自动变量
    int autoVar = 0;
    // 静态变量
    static int staticVar = 0;

    auto NSMutableArray *autoArray = [[NSMutableArray alloc] init];

    ^{
        // ERROR: Variable is not assignable (missing __block type specifier)
        // autoVar = 10;

        staticVar = 10;
        staticGlobalVar = 10;
        globalVar = 10;

        [autoArray addObject:@"kingcos.me"];

        // ERROR: Variable is not assignable (missing __block type specifier)
        // autoArray = [[NSMutableArray alloc] init];
    }();

    return 0;
}

int main_17(int argc, const char * argv[]) {
    void(^block1)(void);
    void(^block2)(void);

    {
        __block int autoVar = 1;
        __block auto NSMutableArray *autoArray = [[NSMutableArray alloc] init];

        NSLog(@"autoVar = %d", autoVar);

        block1 = ^{
            autoVar = 10;
            autoArray = [[NSMutableArray alloc] init];

            NSLog(@"autoVar = %d", autoVar);
        };

        block2 = ^{
            autoVar = 20;

            NSLog(@"autoVar = %d", autoVar);
        };

        NSLog(@"autoVar = %d", autoVar);
    }

    block1();
    block2();

    return 0;
}

// OUTPUT:
// autoVar = 1
// autoVar = 1
// autoVar = 10
// autoVar = 20

// 将自动变量包装的结构体
struct __Block_byref_autoVar_0 {
  void *__isa; // 标志着这是个 Obj-C 对象
__Block_byref_autoVar_0 *__forwarding; // 结构体本身的地址
 int __flags; // 标志位
 int __size;  // sizeof 结构体的大小
 int autoVar; // 自动变量，初始化时赋值
};

struct __Block_byref_autoArray_1 {
  void *__isa;
__Block_byref_autoArray_1 *__forwarding;
 int __flags;
 int __size;
 // 内存管理方法
 void (*__Block_byref_id_object_copy)(void*, void*);
 void (*__Block_byref_id_object_dispose)(void*);
  NSMutableArray *__strong autoArray; // 对象类型的自动变量
};

// Block 结构体
struct __main_17_block_impl_0 {
  struct __block_impl impl;
  struct __main_5_block_desc_0* Desc;
  // 不使用 __block 时为 int autoVar;，此时为指向 __Block_byref_autoVar_0 的指针
  __Block_byref_autoVar_0 *autoVar; // by ref
  // 不使用 __block 时为 NSMutableArray *autoArray;，此时为指向 __Block_byref_autoArray_1 的指针
  __Block_byref_autoArray_1 *autoArray; // by ref
  __main_17_block_impl_0(void *fp, struct __main_5_block_desc_0 *desc, __Block_byref_autoVar_0 *_autoVar, __Block_byref_autoArray_1 *_autoArray, int flags=0) : autoVar(_autoVar->__forwarding), autoArray(_autoArray->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

static void __main_17_block_func_0(struct __main_17_block_impl_0 *__cself) {
  // 指向结构体的指针
  __Block_byref_autoVar_0 *autoVar = __cself->autoVar; // bound by ref
  __Block_byref_autoArray_1 *autoArray = __cself->autoArray; // bound by ref

  // 通过指向自身的指针改变了值
  (autoVar->__forwarding->autoVar) = 10;
  (autoArray->__forwarding->autoArray) = ((NSMutableArray *(*)(id, SEL))(void *)objc_msgSend)((id)((NSMutableArray *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSMutableArray"), sel_registerName("alloc")), sel_registerName("init"));
}

static void __main_17_block_copy_0(struct __main_17_block_impl_0*dst, struct __main_17_block_impl_0*src) {
    _Block_object_assign((void*)&dst->autoVar, (void*)src->autoVar, 8/*BLOCK_FIELD_IS_BYREF*/);
    _Block_object_assign((void*)&dst->autoArray, (void*)src->autoArray, 8/*BLOCK_FIELD_IS_BYREF*/);
}

static void __main_17_block_dispose_0(struct __main_17_block_impl_0*src) {
    _Block_object_dispose((void*)src->autoVar, 8/*BLOCK_FIELD_IS_BYREF*/);
    _Block_object_dispose((void*)src->autoArray, 8/*BLOCK_FIELD_IS_BYREF*/);
}

static struct __main_17_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __main_17_block_impl_0*, struct __main_17_block_impl_0*);
  void (*dispose)(struct __main_17_block_impl_0*);
} __main_17_block_desc_0_DATA = { 0, sizeof(struct __main_17_block_impl_0), __main_17_block_copy_0, __main_17_block_dispose_0};

// 第二个 Block
struct __main_17_block_impl_1 {
  struct __block_impl impl;
  struct __main_17_block_desc_1* Desc;
  __Block_byref_autoVar_0 *autoVar; // by ref
  __main_17_block_impl_1(void *fp, struct __main_17_block_desc_1 *desc, __Block_byref_autoVar_0 *_autoVar, int flags=0) : autoVar(_autoVar->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

static void __main_17_block_func_1(struct __main_17_block_impl_1 *__cself) {
  __Block_byref_autoVar_0 *autoVar = __cself->autoVar; // bound by ref

  (autoVar->__forwarding->autoVar) = 20;
}

static void __main_17_block_copy_1(struct __main_17_block_impl_1*dst, struct __main_17_block_impl_1*src) {
    _Block_object_assign((void*)&dst->autoVar, (void*)src->autoVar, 8/*BLOCK_FIELD_IS_BYREF*/);
}

static void __main_17_block_dispose_1(struct __main_17_block_impl_1*src) {
    _Block_object_dispose((void*)src->autoVar, 8/*BLOCK_FIELD_IS_BYREF*/);
}

static struct __main_17_block_desc_1 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __main_17_block_impl_1*, struct __main_17_block_impl_1*);
  void (*dispose)(struct __main_17_block_impl_1*);
} __main_17_block_desc_1_DATA = { 0, sizeof(struct __main_17_block_impl_1), __main_17_block_copy_1, __main_17_block_dispose_1};

int main_17(int argc, const char * argv[]) {
    void(*block1)(void);
    void(*block2)(void);

    {
        // 初始化 __Block_byref_autoVar_0 结构体，将 autoVar 的地址赋值给结构体中的 __forwarding 指针
        // __Block_byref_autoVar_0 autoVar = {0, &autoVar, 0, sizeof(__Block_byref_autoVar_0), 0（初始值）}
        __attribute__((__blocks__(byref))) __Block_byref_autoVar_0 autoVar = {(void*)0,(__Block_byref_autoVar_0 *)&autoVar, 0, sizeof(__Block_byref_autoVar_0), 0};

        // 初始化 __Block_byref_autoArray_1 结构体，将 autoArray 的地址赋值给结构体中的 __forwarding 指针
        // __Block_byref_autoArray_1 autoArray = {0, &autoArray, 33554432, sizeof(__Block_byref_autoArray_1), __Block_byref_id_object_copy_131, __Block_byref_id_object_dispose_131, NSMutableArray（初始值）}
        __attribute__((__blocks__(byref))) auto __Block_byref_autoArray_1 autoArray = {(void*)0,(__Block_byref_autoArray_1 *)&autoArray, 33554432, sizeof(__Block_byref_autoArray_1), __Block_byref_id_object_copy_131, __Block_byref_id_object_dispose_131, ((NSMutableArray *(*)(id, SEL))(void *)objc_msgSend)((id)((NSMutableArray *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSMutableArray"), sel_registerName("alloc")), sel_registerName("init"))};

        // 外界通过 __forwarding 访问 __block 变量
        NSLog((NSString *)&__NSConstantStringImpl__var_folders_ps_0m9gnvtj0893vpf1cr595djh0000gn_T_main_8f352d_mi_52, (autoVar.__forwarding->autoVar));

        // 忽略类型转换：block1 = &__main_17_block_impl_0(__main_17_block_func_0, &__main_17_block_desc_0_DATA, &autoVar, &autoArray, 570425344);
        block1 = ((void (*)())&__main_17_block_impl_0((void *)__main_17_block_func_0, &__main_17_block_desc_0_DATA, (__Block_byref_autoVar_0 *)&autoVar, (__Block_byref_autoArray_1 *)&autoArray, 570425344));

        // 忽略类型转换：block2 = &__main_17_block_impl_1(__main_17_block_func_1, &___main_17_block_desc_1_DATA, &autoVar, 570425344);
        block2 = ((void (*)())&__main_17_block_impl_1((void *)__main_17_block_func_1, &__main_17_block_desc_1_DATA, (__Block_byref_autoVar_0 *)&autoVar, 570425344));

        // 外界通过 __forwarding 访问 __block 变量
        NSLog((NSString *)&__NSConstantStringImpl__var_folders_ps_0m9gnvtj0893vpf1cr595djh0000gn_T_main_8f352d_mi_55, (autoVar.__forwarding->autoVar));
    }

    ((void (*)(__block_impl *))((__block_impl *)block1)->FuncPtr)((__block_impl *)block1);
    ((void (*)(__block_impl *))((__block_impl *)block2)->FuncPtr)((__block_impl *)block2);

    return 0;
}