变量的类型和实现

struct _zval_struct { // zval
    /* 变量信息 */
    zvalue_value value; /* value值 */
    zend_uint refcount__gc;
    zend_uchar type; /* 类型 */
    zend_uchar is_ref__gc;
};
typedef union _zvalue_value {
    long lval; /* 长整型 */
    double dval; /* 浮点型 */
    struct {
        char *val;
        int len;
    } str;  /* String value */
    HashTable *ht; /* Array or object (hash table) */
    zend_object_value obj; /* Object value */
    zend_ast *ast; /* zend_ast 结构体用于表示抽象语法树中的节点 */
} zvalue_value;

#undef  ALLOC_ZVAL
#define ALLOC_ZVAL(z)                                     \
    do {                                                  \
        (z) = (zval*)emalloc(sizeof(zval_gc_info));     \
        GC_ZVAL_INIT(z);                                 \
    } while (0)

#define GC_ZVAL_INIT(z) {      \
    (z)->refcount__gc = 1;     \
    (z)->type = IS_NULL;       \
    (z)->is_ref__gc = 0;       \
}

typedef struct _zval_gc_info {
    zval z;
    union {
        gc_root_buffer       *buffered;
        struct _zval_gc_info *next;
    } u;
} zval_gc_info;

typedef struct _zend_mm_block_info {
    size_t _size;
    size_t _prev;
} zend_mm_block_info;

typedef struct _zend_mm_block {
    zend_mm_block_info info;
} zend_mm_block;

struct _zval_struct {
    zend_value        value;  /* 变量的值 */
    union {
        struct {
            ZEND_ENDIAN_LOHI_4(
                zend_uchar    type,      /* 标明zval类型，即变量类型（如 IS_NULL、IS_LONG、IS_DOUBLE、IS_STRING、IS_ARRAY、IS_OBJECT 等） */
                zend_uchar    type_flags, /* 用于存储变量类型的额外标志信息。 */
                zend_uchar    const_flags, /* 用于常量的标志信息。 */
                zend_uchar    reserved) /* 保留字段，用于未来的扩展。 */
        } v;
        uint32_t type_info;
    } u1;
    union {
        uint32_t     next;               /* 用来解决哈希冲突，详见第5章*/
        uint32_t     cache_slot;         /* 运行时缓存 */
        uint32_t     lineno;             /* 对于zend_ast_zval存行号 */
        uint32_t     num_args;           /* EX(This) 参数个数*/
        uint32_t     fe_pos;             /* foreach的位置 */
        uint32_t     fe_iter_idx;        /* foreach游标的标记*/
        uint32_t     access_flags;       /* 类的常量访问标识 */
        uint32_t     property_guard;     /* 单一属性保护 */
    } u2;
};

typedef union _zend_value {
    zend_long         lval;              /* 整型 */
    double             dval;             /* 浮点型 */
    zend_refcounted  *counted;           /*引用计数*/
    zend_string      *str;               /*字符串类型*/
    zend_array       *arr;               /*数组类型*/
    zend_object      *obj;               /*对象类型*/
    zend_resource    *res;               /*资源类型*/
    zend_reference   *ref;               /*引用类型*/
    zend_ast_ref     *ast;               /*抽象语法树*/
    zval              *zv;               /*zval类型*/
    void              *ptr;              /*指针类型*/
    zend_class_entry *ce;                /*class类型*/
    zend_function    *func;              /*function类型*/
    struct {
        uint32_t w1;
        uint32_t w2;
    } ww;
} zend_value;

#define IS_UNDEF                     0 /*标记未使用类型*/
#define IS_NULL                      1 /*NULL*/
#define IS_FALSE                     2 /*布尔false*/
#define IS_TRUE                      3 /*布尔true*/
#define IS_LONG                      4 /*长整型*/
#define IS_DOUBLE                    5 /*浮点型*/
#define IS_STRING                    6 /*字符串*/
#define IS_ARRAY                     7 /*数组*/
#define IS_OBJECT                    8 /*对象*/
#define IS_RESOURCE                  9 /*资源类型*/
#define IS_REFERENCE                10 /*参考类型（内部使用）*/
#define IS_CONSTANT                 11 /*常量类型*/
#define IS_CONSTANT_AST             12 /*常量类型的AST树*/
/*伪类型*/
#define _IS_BOOL                    13 /*表示变量的类型是布尔类型*/
#define IS_CALLABLE                 14 /*是一个类型常量，用于判断一个变量是否可以作为可调用的函数或方法*/
#define IS_ITERABLE                 19 /*是 PHP 7.1 引入的一个类型常量，用于判断一个变量是否可以迭代*/
#define IS_VOID                     18 /*在 PHP 7.1 引入了 void 类型的返回声明，用于函数声明时指定函数没有返回值*/
/*内部类型*/
#define IS_INDIRECT                 15 /*间接类型*/
#define IS_PTR                      17 /*指针类型*/
#define _IS_ERROR                   20 /*错误类型*/

$a = 10;   // $a = zval_1(u1.v.type=IS_LONG, value.lval=10)

$b = $a;   // $a = zval_1(u1.v.type=IS_LONG, value.lval=10)
            // $b = zval_2(u1.v.type=IS_LONG, value.lval=10)

$a = 20;   // $a = zval_1(u1.v.type=IS_LONG, value.lval=20)
            // $b = zval_2(u1.v.type=IS_LONG, value.lval=10)

unset($a); // $a = zval_1(u1.v.type=IS_UNDEF, value.lval=20)
            // $b = zval_2(u1.v.type=IS_LONG, value.lval=10)

struct _zend_string {
    zend_refcounted_h gc;
    zend_ulong        h;                 /* hash value */
    size_t             len;
    char               val[1];
};

IS_STR_PERSISTENT            //是malloc分配内存的字符串
IS_STR_INTERNED              //INTERNED STRING
IS_STR_PERMANENT             //不可变的字符串，起哨兵作用
IS_STR_CONSTANT              //代表常量的字符串
IS_STR_CONSTANT_UNQUALIFIED  //带有可能命名空间的常量字符串

struct _zend_array {
    zend_refcounted_h gc;
    //…代码省略…//

$a = 'hello'; //$a -> zval1(type=IS_STRING, refcount__gc=1, is_ref__gc=0)
$b = $a; //$b, $a -> zval1(type=IS_STRING, refcount__gc=2, is_ref__gc=0)
$c = &$b; //$a -> zval1(type=IS_STRING, refcount__gc=1, is_ref__gc=0)
        //$c, $b -> zval2(type=IS_STRING, refcount__gc=2, is_ref__gc=1)

struct _zend_reference {
    zend_refcounted_h gc;
    zval               val;
};

/* 上面提到的zend_string都是同一个地址 */
$a = 'hello'.time(); //$a -> zend_string(refcount=1, val)
$b = $a ; //$b, $a -> zend_string(refcount=2, val)
$c = &$b; //$a -> zend_string(refcount=2, val)
//$c, $b -> zval(type=IS_REFERENCE, refcount=2) -> zend_string(refcount=2, val)

#define IS_INDIRECT                  15  // 间接zval
#define IS_PTR                       17  // 指针zval
#define _IS_ERROR                    20  // 内部使用的错误类型

<?php
class User
{
    function hello()
    {
        global $a;
        $a = 'hello';
    }
}

$obj = new User();
$obj->hello();
echo $a;

(gdb) p *ex.symbol_table.arData[8].key
$9 = {gc = {refcount = 0, u = {v = {type = 6 '\006', flags = 2 '\002', gc_info = 0}, type_info = 518}}, h = 9223372036854953478, len = 1, val = "a"}
(gdb) p ex.symbol_table.arData[8].val
$10 = {value = {lval = 140737350021264, dval = 6.9533489732241371e-310, counted = 0x7ffff7c13090, str = 0x7ffff7c13090, arr = 0x7ffff7c13090, obj =  0x7ffff7c13090,  res  = 0x7ffff7c13090,  ref  =  0x7ffff7c13090,  ast  = 0x7ffff7c13090, zv = 0x7ffff7c13090, ptr = 0x7ffff7c13090, ce =  0x7ffff7c13090,  func  =  0x7ffff7c13090,  ww  =  {w1  =  4156633232,  w2  = 32767}}, u1 = {v = {type = 15 '\017', type_flags = 0 '\000', const_flags = 0 '\000', reserved = 0 '\000'}, type_info = 15}, u2 = {next = 4294967295, cache_slot = 4294967295, lineno = 4294967295, num_args = 4294967295, fe_pos = 4294967295, fe_iter_idx = 4294967295, access_flags = 4294967295, property_guard = 4294967295}}

<? php
$a = "hello";

struct _zend_ast_ref {
    zend_refcounted_h gc;
    zend_ast         *ast;
};

typedef struct _zend_ast {
    zend_ast_kind kind;  // AST 节点类型
    zend_ast_attr attr;  // 节点属性
    uint32_t lineno;     // 行号
    uint32_t children;   // 子节点数量
    zend_ast *child[1];  // 子节点数组
} zend_ast;

#define ZVAL_NEW_AST(z, a) do {                             \
        zval *__z = (z);                                    \
        zend_ast_ref *_ast =                                \
        (zend_ast_ref *) emalloc(sizeof(zend_ast_ref));     \
        GC_REFCOUNT(_ast) = 1;                              \
        GC_TYPE_INFO(_ast) = IS_CONSTANT_AST;               \
        _ast->ast = (a);                                    \
        Z_AST_P(__z) = _ast;                                \
        Z_TYPE_INFO_P(__z) = IS_CONSTANT_AST_EX;            \
    } while (0)

struct _zend_resource {
    zend_refcounted_h gc; /* 引用计数和垃圾回收信息 */
    int                handle; /* 资源句柄 */
    int                type; /* 资源类型 */
    void              *ptr; /* 指向实际资源的指针 */
};

typedef struct _zend_object_value {
    zend_object_handle handle;
    const zend_object_handlers *handlers;
} zend_object_value;

typedef struct _zend_object_store_bucket {
    zend_bool destructor_called;
    zend_bool valid;
    zend_uchar apply_count;
    union _store_bucket {
        struct _store_object {
            void *object;
            zend_objects_store_dtor_t dtor;
            zend_objects_free_object_storage_t free_storage;
            zend_objects_store_clone_t clone;
            const zend_object_handlers *handlers;
            zend_uint refcount;
            gc_root_buffer *buffered;
        } obj;
        struct {
            int next;
        } free_list;
    } bucket;
} zend_object_store_bucket;

typedef struct _zend_objects_store {
    zend_object_store_bucket *object_buckets; /* 对象存储桶数组 */
    zend_uint top; /* 下一个可用槽的位置 */
    zend_uint size; /* 存储桶数组的大小 */
    int free_list_head; /* 自由列表头，用于重用已释放的槽 */
} zend_objects_store;

EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(z)].bucket.obj

struct _zend_object {
    zend_refcounted_h gc;
    uint32_t          handle; //对象句柄 TODO: may be removed ? ? ?
    zend_class_entry *ce; /* 指向对象所属类的 zend_class_entry 结构体的指针。通过该指针，可以访问对象的类名、属性和方法 */
    const zend_object_handlers *handlers; /* 指向对象处理程序的指针。对象处理程序定义了对象的行为，例如访问属性、调用方法等 */
    HashTable        *properties;
    zval               properties_table[1]; /* 属性数组，这个数组用于动态管理对象的属性，使得 PHP 可以支持灵活的属性添加和删除*/
};