Fix a few code typos in the Block ABI spec

[dusek]

Respectful ping after 2 months :-)

[dusek]

Hi rjmccall, ping? :-)

docs/Block-ABI-Apple.rst

.. code-block:: c
     
     void __block_invoke_1(struct __block_literal_1 *_block) {
         printf("hello world\n");
     }
     
     static struct __block_descriptor_1 {
         unsigned long int reserved;
         unsigned long int Block_size;
-    } __block_descriptor_1 = { 0, sizeof(struct __block_literal_1), __block_invoke_1 };
+    } __block_descriptor_1 = { 0, sizeof(struct __block_literal_1) };
 
 and where the ``Block`` literal itself appears:
 
 .. code-block:: c
 
     struct __block_literal_1 _block_literal = {
          &_NSConcreteStackBlock,
          (1<<29), <uninitialized>,
.. code-block:: c
     struct __block_literal_4 {
         void *isa;
         int flags;
         int reserved; 
         void (*invoke)(struct __block_literal_4 *);
         struct __block_literal_3 *const existingBlock;
     };
     
-    void __block_invoke_4(struct __block_literal_2 *_block) {
-       __block->existingBlock->invoke(__block->existingBlock);
+    void __block_invoke_4(struct __block_literal_4 *_block) {
+       _block->existingBlock->invoke(_block->existingBlock);
     }
     
     void __block_copy_4(struct __block_literal_4 *dst, struct __block_literal_4 *src) {
          //_Block_copy_assign(&dst->existingBlock, src->existingBlock, 0);
          _Block_object_assign(&dst->existingBlock, src->existingBlock, BLOCK_FIELD_IS_BLOCK);
     }
     
     void __block_dispose_4(struct __block_literal_4 *src) {
.. code-block:: c
     functioncall(^{ i = 10; });
 
 would translate to:
 
 .. code-block:: c
 
     struct _block_byref_i {
         void *isa;  // set to NULL
-        struct _block_byref_voidBlock *forwarding;
+        struct _block_byref_i *forwarding;
         int flags;   //refcount;
         int size;
         void (*byref_keep)(struct _block_byref_i *dst, struct _block_byref_i *src);
         void (*byref_dispose)(struct _block_byref_i *);
         int captured_i;
     };
     
     
     struct __block_literal_5 {
         void *isa;
         int flags;
         int reserved; 
         void (*invoke)(struct __block_literal_5 *);
         struct __block_descriptor_5 *descriptor;
         struct _block_byref_i *i_holder;
     };
     
     void __block_invoke_5(struct __block_literal_5 *_block) {
-       _block->forwarding->captured_i = 10;
+       _block->i_holder->forwarding->captured_i = 10;
     }
     
     void __block_copy_5(struct __block_literal_5 *dst, struct __block_literal_5 *src) {
          //_Block_byref_assign_copy(&dst->captured_i, src->captured_i);
-         _Block_object_assign(&dst->captured_i, src->captured_i, BLOCK_FIELD_IS_BYREF | BLOCK_BYREF_CALLER);
+         _Block_object_assign(&dst->i_holder, src->i_holder, BLOCK_FIELD_IS_BYREF | BLOCK_BYREF_CALLER);
     }
     
     void __block_dispose_5(struct __block_literal_5 *src) {
          //_Block_byref_release(src->captured_i);
-         _Block_object_dispose(src->captured_i, BLOCK_FIELD_IS_BYREF | BLOCK_BYREF_CALLER);
+         _Block_object_dispose(src->i_holder, BLOCK_FIELD_IS_BYREF | BLOCK_BYREF_CALLER);
     }
     
     static struct __block_descriptor_5 {
         unsigned long int reserved;
         unsigned long int Block_size;
         void (*copy_helper)(struct __block_literal_5 *dst, struct __block_literal_5 *src);
         void (*dispose_helper)(struct __block_literal_5 *);
-    } __block_descriptor_5 = { 0, sizeof(struct __block_literal_5) __block_copy_5, __block_dispose_5 };
+    } __block_descriptor_5 = { 0, sizeof(struct __block_literal_5), __block_copy_5, __block_dispose_5 };
 
 and:
 
 .. code-block:: c
 
-    struct _block_byref_i i = {( .forwarding=&i, .flags=0, .size=sizeof(struct _block_byref_i) )};
+    struct _block_byref_i i = {( .forwarding=&i, .flags=0, .size=sizeof(struct _block_byref_i), .captured_i=2 )};
     struct __block_literal_5 _block_literal = {
           &_NSConcreteStackBlock,
           (1<<25)|(1<<29), <uninitialized>,
           __block_invoke_5,
           &__block_descriptor_5,
-          2,
+          &i,
     };
 
 Importing ``__attribute__((NSObject))`` ``__block`` variables
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 A ``__block`` variable that is also marked ``__attribute__((NSObject))`` should
 have ``byref_keep`` and ``byref_dispose`` helper functions that use
 ``_Block_object_assign`` and ``_Block_object_dispose``.
struct __block_literal_10 {
         struct __block_descriptor_10 *descriptor;
         const FOO foo;
     };
     
     void __block_invoke_10(struct __block_literal_10 *_block) {
        printf("%d\n", _block->foo.value());
     }
     
-    void __block_literal_10(struct __block_literal_10 *dst, struct __block_literal_10 *src) {
+    void __block_copy_10(struct __block_literal_10 *dst, struct __block_literal_10 *src) {
          FOO_ctor(&dst->foo, &src->foo);
     }
     
     void __block_dispose_10(struct __block_literal_10 *src) {
          FOO_dtor(&src->foo);
     }
     
     static struct __block_descriptor_10 {
.. code-block:: c++
       comp_ctor(&foo); // default constructor
       struct __block_literal_10 _block_literal = {
         &_NSConcreteStackBlock,
         (1<<25)|(1<<26)|(1<<29), <uninitialized>,
         __block_invoke_10,
         &__block_descriptor_10,
        };
        comp_ctor(&_block_literal->foo, &foo);  // const copy into stack version
-       struct __block_literal_10 &block = &_block_literal;  // assign literal to block variable
+       struct __block_literal_10 *block = &_block_literal;  // assign literal to block variable
        block->invoke(block);    // invoke block
        comp_dtor(&_block_literal->foo); // destroy stack version of const block copy
        comp_dtor(&foo); // destroy original version
     }
 
 
 C++ objects stored in ``__block`` storage start out on the stack in a
 ``block_byref`` data structure as do other variables.  Such objects (if not

 .. code-block:: c
 
      _Block_object_assign(&dst->target, src->target, BLOCK_FIELD_<appropo>);
 
 in the copy helper and:
 
 .. code-block:: c
 
-    _Block_object_dispose(->target, BLOCK_FIELD_<appropo>);
+    _Block_object_dispose(src->target, BLOCK_FIELD_<appropo>);
 
 in the dispose helper where ``<appropo>`` is:
 
 .. code-block:: c
 
     enum {
         BLOCK_FIELD_IS_OBJECT   =  3,  // id, NSObject, __attribute__((NSObject)), block, ...
         BLOCK_FIELD_IS_BLOCK    =  7,  // a block variable