noname

PHP_FUNCTION(makeObject) {
    object_init(return_value);

    // 添加属性
    zend_update_property_string(NULL, return_value, "prop1", strlen("prop1"), "val1");
    zend_update_property_long(NULL, return_value, "prop2", strlen("prop2"), 123);
}

// class定义存储于zend_class_entry
zend_class_entry *test_ce_myclass;

static const zend_function_entry test_methods[] = {
    // 类方法使用宏指令PHP_ME
    // public function hello()
    PHP_ME(MyClass, hello, NULL, ZEND_ACC_PUBLIC)
    // 与函数定义相同
    PHP_FE_END
};

// 主菜，注册并加载类
static void test_init_myclass()
{
    zend_class_entry ce;
    INIT_CLASS_ENTRY(ce, "MyClass", test_methods);
    // 注册MyClass类
    test_ce_myclass = zend_register_internal_class(&ce);
    // 添加属性/常量等
    // public $success = true;
    zend_declare_property_bool(test_ce_myclass, "success", sizeof("success")-1, 1, ZEND_ACC_PUBLIC);
}

// 类方法hello
PHP_METHOD(MyClass, hello)
{
    RETURN_STRING("hello");
}

ZEND_ACC_STATIC
ZEND_ACC_PUBLIC
ZEND_ACC_PROTECTED
ZEND_ACC_PRIVATE
ZEND_ACC_CTOR
ZEND_ACC_DTOR
ZEND_ACC_DEPRECATED

PHP_MINIT_FUNCTION(test)
{
    test_init_myclass();
    return SUCCESS;
}

static const zend_function_entry test_methods[] = {
    PHP_ME(MyClass, hello, NULL, ZEND_ACC_PUBLIC)
    PHP_ME(MyClass, factory, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
    PHP_FE_END
};

PHP_METHOD(MyClass, factory)
{
    object_init_ex(return_value, test_ce_myclass);
}

static const zend_function_entry test_methods[] = {
    // ZEND_ACC_CTOR
    PHP_ME(MyClass, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
    PHP_ME(MyClass, hello, NULL, ZEND_ACC_PUBLIC)
    PHP_ME(MyClass, factory, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
    PHP_FE_END
};

PHP_METHOD(MyClass, __construct)
{

}

#include "zend_interfaces.h"

PHP_METHOD(MyClass, factory)
{
    zval *myzval;

    ZEND_PARSE_PARAMETERS_START(1,1)
        Z_PARAM_ZVAL(myzval)
    ZEND_PARSE_PARAMETERS_END();

    object_init_ex(return_value, test_ce_myclass);

    // zend_call_method，其他的还有
    // zend_call_method_with_0_params
    // zend_call_method_with_1_params
    // zend_call_method_with_2_params
    // ZEND_API zval* zend_call_method(zval *object_pp, zend_class_entry *obj_ce, zend_function **fn_proxy, const char *function_name, size_t function_name_len, zval *retval, int param_count, zval* arg1, zval* arg2);
    zend_call_method(return_value, test_ce_myclass, NULL, "__construct", sizeof("__construct")-1, NULL, 1, myzval, NULL);
}

PHP_METHOD(MyClass, __construct)
{
    char *msg;
    size_t msg_len;

    ZEND_PARSE_PARAMETERS_START(1,1)
        Z_PARAM_STRING(msg, msg_len)
    ZEND_PARSE_PARAMETERS_END();

    zend_update_property_string(test_ce_myclass, getThis(), "msg", sizeof("msg")-1, msg);
}

// 还不是特别了解
typedef struct _test_struct {
    zend_object std;
    int unknown_id;
    char *unknown_str;
} test_struct;

static zend_object *create_test_struct(zend_class_entry *class_type) {
    test_struct *intern;

    intern = ecalloc(1, sizeof(test_struct) + zend_object_properties_size(class_type));

    zend_object_std_init(&intern->std, class_type);
    object_properties_init(&intern->std, class_type);

    intern->std.handlers = zend_get_std_object_handlers();

    return &intern->std;
}

static void free_test_struct(void *object) {
    test_struct *secrets = (test_struct*)object;
    if (secrets->unknown_str) {
        efree(secrets->unknown_str);
    }
    efree(secrets);
}

PHP_METHOD(MyClass, attachStruct) {
    test_struct *secrets;

    // 
    secrets = (test_struct*)getThis();

    RETURN_LONG(secrets->unknown_id);
}

#include <zend_exceptions.h>

zend_class_entry *test_ce_exception;

static void test_init_exception() {
    zend_class_entry ce;
    // 设置第三个参数为NULL，继承Exception所有方法，无自定义行为
    INIT_CLASS_ENTRY(ce, "MyException", NULL);
    //
    test_ce_exception = zend_register_internal_class_ex(&ce, (zend_class_entry*)zend_exception_get_default());
}

PHP_MINIT_FUNCTION(test)
{
    test_init_myclass();
    // 
    test_init_exception();
    return SUCCESS;
}

PHP_METHOD(MyClass, throwExcept) {
    zend_throw_exception(test_ce_exception, "custom exception throw", 1024);
}

typedef struct {
    zend_string *name;
    zend_long age;
} php_test_person;

#define PHP_TEST_PERSON_RES_NAME "Person Data"

int le_test_person;

PHP_MINIT_FUNCTION(test)
{
    le_test_person = zend_register_list_destructors_ex(NULL, NULL, PHP_TEST_PERSON_RES_NAME, module_number);
}

PHP_FUNCTION(test_person_new)
{
    php_test_person * person;
    zend_string * name;
    zend_long age;

    ZEND_PARSE_PARAMETERS_START(2,2)
        Z_PARAM_STR(name);
        Z_PARAM_LONG(age);
    ZEND_PARSE_PARAMETERS_END();

    if (age < 0 || age > 255) {
        php_error_docref(NULL, E_WARNING, "Nonsense age (%ld) given, person resource not created.", age);
        RETURN_FALSE;
    }

    person = emalloc(sizeof(php_test_person));
    person->name = zend_string_copy(name); // estrndup + zend_string => zend_string_copy
    person->age = age;

    RETURN_RES(zend_register_resource(person, le_test_person));
}

PHP_FUNCTION(test_person_greet)
{
    php_test_person *person;
    zval *zperson;

    ZEND_PARSE_PARAMETERS_START(1,1)
        Z_PARAM_RESOURCE(zperson);
    ZEND_PARSE_PARAMETERS_END();

    person = (php_test_person *) zend_fetch_resource_ex(zperson, PHP_TEST_PERSON_RES_NAME, le_test_person);

    php_printf("Hello ");
    PHPWRITE(ZSTR_VAL(person->name), ZSTR_LEN(person->name));
    php_printf("!\nAccording to my records, you are %ld years old.\n", person->age);

    RETURN_TRUE;
}

le_test_person = zend_register_list_destructors_ex(php_test_person_dtor, NULL, PHP_TEST_PERSON_RES_NAME, module_number);

static void php_test_person_dtor(zend_resource *res)
{
    php_test_person *person = (php_test_person *) res->ptr;

    if (person) {
        if (person->name) {
            zend_string_release(person->name); // efree zend_string => zend_string_release
        }
        efree(person);
    }
}

PHP_FUNCTION(test_person_delete)
{
    zval * zperson;

    ZEND_PARSE_PARAMETERS_START(1,1)
        Z_PARAM_RESOURCE(zperson);
    ZEND_PARSE_PARAMETERS_END();

    zend_list_delete(Z_RES_P(zperson));

    RETURN_TRUE;
}

int le_test_person_persist;

PHP_MINIT_FUNCTION(test)
{
    le_test_person = zend_register_list_destructors_ex(php_test_person_dtor, NULL, PHP_TEST_PERSON_RES_NAME, module_number);
    le_test_person_persist = zend_register_list_destructors_ex(NULL, php_test_person_persist_dtor, PHP_TEST_PERSON_RES_NAME, module_number);
}

static void php_test_person_persist_dtor(zend_resource *res)
{
    php_test_person *person = (php_test_person *) res->ptr;

    if (person) {
        if (person->name) {
            zend_string_release(person->name);
        }
        pefree(person, 1);
    }
}

PHP_FUNCTION(test_person_pnew)
{
    php_test_person * person;
    zend_string * name;
    zend_long age;

    ZEND_PARSE_PARAMETERS_START(2,2)
        Z_PARAM_STR(name);
        Z_PARAM_LONG(age);
    ZEND_PARSE_PARAMETERS_END();

    if (age < 0 || age > 255) {
        php_error_docref(NULL, E_WARNING, "Nonsense age (%ld) given, person resource not created.", age);
        RETURN_FALSE;
    }

    person = pemalloc(sizeof(php_test_person), 1);
    person->name = zend_string_dup(name, 1);
    person->age = age;

    RETURN_RES(zend_register_resource(person, le_test_person_persist));
}

PHP_FUNCTION(test_person_pnew2)
{
    php_test_person * person;
    char * key_raw;
    size_t key_len;
    zend_string * name, * key;
    zend_long age;
    zval * zperson = NULL;

    ZEND_PARSE_PARAMETERS_START(2,2)
        Z_PARAM_STR(name);
        Z_PARAM_LONG(age);
    ZEND_PARSE_PARAMETERS_END();

    if (age < 0 || age > 255) {
        php_error_docref(NULL, E_WARNING, "Nonsense age (%ld) given, person resource not created.", age);
        RETURN_FALSE;
    }

    key_len = spprintf(&key_raw, 0, "test_person_%s_%ld\n", ZSTR_VAL(name), age);
    key = zend_string_init(key_raw, key_len, 1);
    efree(key_raw);

    if ((zperson = zend_hash_find(&EG(persistent_list), key)) != NULL) {
        person = (php_test_person *) zend_fetch_resource_ex(zperson, PHP_TEST_PERSON_RES_NAME, le_test_person_persist);

        ZVAL_RES(return_value, zend_register_persistent_resource_ex(key, person, le_test_person_persist));
        zend_string_release(key);
        return ;
    }

    person = pemalloc(sizeof(php_test_person), 1);
    person->name = zend_string_copy(name);
    person->age = age;

    ZVAL_RES(return_value, zend_register_persistent_resource_ex(key, person, le_test_person_persist));
    zend_string_release(key);
}

PHP_FUNCTION(test)
{
    // 参数1
    zend_string *name;
    // 参数2
    zend_long t_param = 0;
    int times = 1;

    // 最低可接收1个参数，最多2个
    ZEND_PARSE_PARAMETERS_START(1, 2)
        Z_PARAM_STR(name)
        Z_PARAM_OPTIONAL
        Z_PARAM_LONG(t_param)
    ZEND_PARSE_PARAMETERS_END();

    // 判断是否有传递默认值
    if (ZEND_NUM_ARGS() == 2) {
        times = (int) (t_param < 1 ? 1 : t_param);
    }

    // 打印
    for (int i = 0; i < times; i++) {
        php_printf("Hello %s", ZSTR_VAL(name));
    }
    RETURN_TRUE;
}

// php7 zval变量结构
typedef union _zend_value {
    zend_long         lval;                /* long value */
    double            dval;                /* double value */
    zend_refcounted  *counted;
    zend_string      *str;
    zend_array       *arr;
    zend_object      *obj;
    zend_resource    *res;
    zend_reference   *ref;
    zend_ast_ref     *ast;
    zval             *zv;
    void             *ptr;
    zend_class_entry *ce;
    zend_function    *func;
    struct {
        uint32_t w1;
        uint32_t w2;
    } ww;
} zend_value;

struct _zval_struct {
    zend_value        value;            /* value */
    union {
        struct {
            ZEND_ENDIAN_LOHI_3(
                zend_uchar    type,            /* active type */
                zend_uchar    type_flags,
                union {
                    uint16_t  extra;        /* not further specified */
                } u)
        } v;
        uint32_t type_info;
    } u1;
    union {
        uint32_t     next;                 /* hash collision chain */
        uint32_t     cache_slot;           /* cache slot (for RECV_INIT) */
        uint32_t     opline_num;           /* opline number (for FAST_CALL) */
        uint32_t     lineno;               /* line number (for ast nodes) */
        uint32_t     num_args;             /* arguments number for EX(This) */
        uint32_t     fe_pos;               /* foreach position */
        uint32_t     fe_iter_idx;          /* foreach iterator index */
        uint32_t     access_flags;         /* class constant access flags */
        uint32_t     property_guard;       /* single property guard */
        uint32_t     constant_flags;       /* constant flags */
        uint32_t     extra;                /* not further specified */
    } u2;
};

// 接收任意类型参数，最后输出其类型
PHP_FUNCTION(test_type)
{
    zval *uservar;

    ZEND_PARSE_PARAMETERS_START(1, 1)
        Z_PARAM_ZVAL(uservar);
    ZEND_PARSE_PARAMETERS_END();

    switch (Z_TYPE_P(uservar)) {
        case IS_NULL:
            php_printf("NULL");
            break;
        case IS_TRUE:
            php_printf("Boolean: TRUE");
            break;
        case IS_FALSE:
            php_printf("Boolean: FALSE");
            break;
        case IS_LONG:
            php_printf("Long: %ld", Z_LVAL_P(uservar));
            break;
        case IS_DOUBLE:
            php_printf("Double: %f", Z_DVAL_P(uservar));
            break;
        case IS_STRING:
            php_printf("String: ");
            PHPWRITE(Z_STRVAL_P(uservar), Z_STRLEN_P (uservar));
            break;
        case IS_RESOURCE:
            php_printf("Resource");
            break;
        case IS_ARRAY:
            php_printf("Array");
            break;
        case IS_OBJECT:
            php_printf("Object");
            break;
        default:
            php_printf("Unknown");
    }
}

PHP_FUNCTION(test_again)
{
    zval *zname;
    
    ZEND_PARSE_PARAMETERS_START(1, 1)
        Z_PARAM_ZVAL(zname);
    ZEND_PARSE_PARAMETERS_END();

    // 将改变原有参数类型
    convert_to_string(zname);
    php_printf("Hello ");
    PHPWRITE(Z_STRVAL_P(zname), Z_STRLEN_P(zname));
    RETURN_TRUE;
}

PHP_FUNCTION(test_array)
{
    // $arr = [];
    array_init(return_value);
    // $arr[3] = 123;
    add_index_long(return_value, 3, 123);
    // $arr[] = "example";
    add_next_index_string(return_value, "example");

    char *mystr = estrdup("five");
    add_next_index_string(return_value, mystr);
    efree(mystr);

    // $arr["pi"] = 3.1415926;
    add_assoc_double(return_value, "pi", 3.1415926);
    
    zval subarr;
    array_init(&subarr);
    add_next_index_string(&subarr, "hello");
    add_assoc_zval(return_value, "subarr", &subarr);
}

// 遍历并打印数组字符串值
PHP_FUNCTION(test_array_strings)
{
    zval *arr, *data;
    HashTable *arr_hash;
    HashPosition pointer;
    int array_count;

    ZEND_PARSE_PARAMETERS_START(1,1)
        Z_PARAM_ARRAY(arr);
    ZEND_PARSE_PARAMETERS_END();

    // 
    arr_hash = Z_ARRVAL_P(arr);
    array_count = zend_hash_num_elements(arr_hash);

    php_printf("The array passed contains %d elements\n", array_count);

    /*
     * 可使用宏ZEND_HASH_FOREACH_VAL、ZEND_HASH_FOREACH_END
     */
    for (
        zend_hash_internal_pointer_reset_ex(arr_hash, &pointer);
        data = zend_hash_get_current_data_ex(arr_hash, &pointer);
        zend_hash_move_forward_ex(arr_hash, &pointer)
    ) {
        // example 1
        // 如果是字符串就打印
        // if (Z_TYPE_P(data) == IS_STRING) {
        //     PHPWRITE(Z_STRVAL_P(data), Z_STRLEN_P(data));
        //     php_printf("\n");
        // }

        // example 2
        // 将参数转为字符串打印
        // zval tmp;
        // tmp = *data;
        // zval_copy_ctor(&tmp);
        // convert_to_string(&tmp);
        // PHPWRITE(Z_STRVAL(tmp), Z_STRLEN(tmp));
        // php_printf("\n");
        // zval_dtor(&tmp);

        // example 3
        // 打印数组key以及value
        int keytype;
        zend_string * str_index;
        zend_ulong num_index;

        keytype = zend_hash_get_current_key_ex(arr_hash, &str_index, &num_index, &pointer);
        if (HASH_KEY_IS_STRING == keytype) {
            // 字符串类型key
            PHPWRITE(ZSTR_VAL(str_index), ZSTR_LEN(str_index));
        } else if (HASH_KEY_IS_LONG == keytype) {
            // 数字key
            php_printf("%ld", num_index);
        }

        php_printf(" => ");

        zval tmp;
        tmp = *data;
        zval_copy_ctor(&tmp);
        convert_to_string(&tmp);
        PHPWRITE(Z_STRVAL(tmp), Z_STRLEN(tmp));
        php_printf("\n");
        zval_dtor(&tmp);
    }

    RETURN_TRUE;
}

// 打印数组val
static int test_array_walk(zval *pDest)
{
    zval tmp;

    tmp = *pDest;
    zval_copy_ctor(&tmp);
    convert_to_string(&tmp);
    PHPWRITE(Z_STRVAL(tmp), Z_STRLEN(tmp));
    php_printf("\n");
    zval_dtor(&tmp);

    return ZEND_HASH_APPLY_KEEP;
}

// 打印prefix以及数组val
static int test_array_walk_arg(zval *pDest, void *argument)
{
    php_printf("%s", (char *)argument);
    test_array_walk(pDest);

    return ZEND_HASH_APPLY_KEEP;
}

// 打印prefix、数组val以及suffix
static int test_array_walk_args(zval *pDest, int num_args, va_list args, zend_hash_key *hash_key)
{
    php_printf("%s", va_arg(args, char *));
    test_array_walk(pDest);
    php_printf("%s\n", va_arg(args, char *));

    return ZEND_HASH_APPLY_KEEP;
}

// 遍历数组
PHP_FUNCTION(test_array_walk)
{
    zval *arr;

    ZEND_PARSE_PARAMETERS_START(1,1)
        Z_PARAM_ARRAY(arr);
    ZEND_PARSE_PARAMETERS_END();

    // 简单的遍历数组处理
    zend_hash_apply(Z_ARRVAL_P(arr), (apply_func_t) test_array_walk);
    // 遍历数组，带一个参数
    zend_hash_apply_with_argument(Z_ARRVAL_P(arr), (apply_func_arg_t) test_array_walk_arg, "Hello");
    // 遍历数组，带多个参数
    zend_hash_apply_with_arguments(Z_ARRVAL_P(arr), (apply_func_args_t) test_array_walk_args, 2, "Hello ", "Welcome to my extension!");
}

// 返回数组指定key的value
PHP_FUNCTION(test_array_value)
{
    zval *arr, *offset, *val;
    char * tmp;
    zend_string *str_index = NULL;
    zend_ulong num_index;

    ZEND_PARSE_PARAMETERS_START(2,2)
        Z_PARAM_ARRAY(arr);
        Z_PARAM_ZVAL(offset);
    ZEND_PARSE_PARAMETERS_END();

    // 对非integer/string的key进行转换
    switch (Z_TYPE_P(offset)) {
        case IS_NULL:
        case IS_FALSE:
            num_index = 0;
            break;
        case IS_TRUE:
            num_index = 1;
            break;
        case IS_DOUBLE:
            num_index = (long) Z_DVAL_P(offset);
            break;
        case IS_LONG:
        case IS_RESOURCE:
            num_index = Z_LVAL_P(offset);
            break;
        case IS_STRING:
            str_index = zval_get_string(offset);
            break;
        case IS_ARRAY:
            tmp = "Array";
            str_index = zend_string_init(tmp, sizeof(tmp) - 1, 0);
            break;
        case IS_OBJECT:
            tmp = "Object";
            str_index = zend_string_init(tmp, sizeof(tmp) - 1, 0);
            break;
        default:
            tmp = "Unknown";
            str_index = zend_string_init(tmp, sizeof(tmp) - 1, 0);
    }

    if (str_index && (val = zend_hash_find(Z_ARRVAL_P(arr), str_index)) == NULL) {
        RETURN_NULL();
    } else if (!str_index && (val = zend_hash_index_find(Z_ARRVAL_P(arr), num_index)) == NULL) {
        RETURN_NULL();
    }

    *return_value = *val;
    zval_copy_ctor(return_value);
}

// 访问全局变量$GLOBALS
PHP_FUNCTION(test_get_global_var)
{
    zval *val;
    zend_string *varname;

    ZEND_PARSE_PARAMETERS_START(1,1)
        Z_PARAM_STR(varname);
    ZEND_PARSE_PARAMETERS_END();

    // 全局变量符号表：EG(symbol_table)
    if ((val = zend_hash_find(&EG(symbol_table), varname)) == NULL) {
        php_error_docref(NULL, E_NOTICE, "Undefined variable: %s", ZSTR_VAL(varname));
        RETURN_NULL();
    }

    *return_value = *val;
    zval_copy_ctor(return_value);
}

#ifndef PHP_TEST_H
# define PHP_TEST_H

/* PHP扩展结构zend_module_entry */
extern zend_module_entry test_module_entry;
# define phpext_test_ptr &test_module_entry

/* version扩展版本号 */
# define PHP_TEST_VERSION "0.1.0"

/* 自定义函数声明PHP_FUNCTION(your_function_name) */
PHP_FUNCTION(test);

#if defined(ZTS) && defined(COMPILE_DL_TEST)
ZEND_TSRMLS_CACHE_EXTERN()
#endif

#endif

#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

#include "php.h"
#include "php_test.h"

/* 自定义函数注册，最终*test_functions注册到模块声明test_module_entry */
static const zend_function_entry test_functions[] = {
    /* 
     * 注册`test`函数，格式为PHP_FE(func_name, arg_info)，arg_info声明参数信息，如是否是引用等，这里先忽略
     */
    PHP_FE(test, NULL)
    PHP_FE_END
};

/* 模块注册 */
zend_module_entry test_module_entry = {
    STANDARD_MODULE_HEADER,
    "test",                    /* 扩展名称 */
    test_functions,            /* 自定义函数注册 */
    NULL,                      /* PHP_MINIT */
    NULL,                      /* PHP_MSHUTDOWN */
    NULL,                      /* PHP_RINIT */
    NULL,                      /* PHP_RSHUTDOWN */
    NULL,                      /* PHP_MINFO */
    PHP_TEST_VERSION,          /* version */
    STANDARD_MODULE_PROPERTIES
};

/* 函数test */
PHP_FUNCTION(test)
{
    RETURN_STRING("Hello World");
}

#ifdef COMPILE_DL_TEST
# ifdef ZTS
ZEND_TSRMLS_CACHE_DEFINE()
# endif
ZEND_GET_MODULE(test)
#endif

// test模块初始化
PHP_MINIT_FUNCTION(test);
// test模块关闭清理函数
PHP_MSHUTDOWN_FUNCTION(test);

#include "php_ini.h"

zend_module_entry test_module_entry = {
    STANDARD_MODULE_HEADER,
    "test",
    test_functions,
    PHP_MINIT(test),      /* 注册MINIT */
    PHP_MSHUTDOWN(test),  /* 注册MSHUTDOWN */
    NULL,
    NULL,
    NULL,
    PHP_TEST_VERSION,
    STANDARD_MODULE_PROPERTIES
};

// ini参数获取代码块
PHP_INI_BEGIN()
    // ini参数test.foo声明
    PHP_INI_ENTRY("test.foo", "bar", PHP_INI_ALL, NULL)
PHP_INI_END();
// 以上宏等同于声明zend_ini_entry_def[]变量

PHP_MINIT_FUNCTION(test)
{
    REGISTER_INI_ENTRIES();

    return SUCCESS;
}

PHP_MSHUTDOWN_FUNCTION(test)
{
    UNREGISTER_INI_ENTRIES();

    return SUCCESS;
}

PHP_FUNCTION(test)
{
    RETURN_STRING(INI_STR("test.foo"));
}

#ifdef ZTS
# include "TSRM.h"
#endif

/* 全局变量声明 */
ZEND_BEGIN_MODULE_GLOBALS(test)
    long counter;
ZEND_END_MODULE_GLOBALS(test)
/* 
 * 上面代码等同
 * typedef struct _zend_pib_globals {
 *     long counter;
 * } zend_test_globals;
 */

/* 宏定义 TEST_G - 全局变量访问 */
#ifdef ZTS
# define TEST_G(v) TSRMG(test_globals_id, zend_test_globals *, v)
#else
# define TEST_G(v) (test_globals.v)
#endif

/* 请求初始化 */
PHP_MINIT_FUNCTION(test);

/* 初始化zend_test_globals */
ZEND_DECLARE_MODULE_GLOBALS(test)
/* 等同于 zend_test_globals test_globals; */

zend_module_entry test_module_entry = {
    STANDARD_MODULE_HEADER,
    "test",
    test_functions,
    PHP_MINIT(test),
    PHP_MSHUTDOWN(test),
    PHP_RINIT(test),     /* 注册请求初始化函数 */
    NULL,
    NULL,
    PHP_TEST_VERSION,
    STANDARD_MODULE_PROPERTIES
};

/* 全局变量初始化，仅在进程/线程创建时初始化 */
static void php_test_init_globals(zend_test_globals *test_globals) {}

// 请求初始化
PHP_RINIT_FUNCTION(test)
{
    /* 因一个进程可服务多个请求，我们需要每个请求都有独立的counter */
    TEST_G(counter) = 0;

    return SUCCESS;
}

// 模块初始化
PHP_MINIT_FUNCTION(test)
{
    /* 全局变量表注册 */
    ZEND_INIT_MODULE_GLOBALS(test, php_test_init_globals, NULL);

    REGISTER_INI_ENTRIES();

    return SUCCESS;
}

ZEND_BEGIN_MODULE_GLOBALS(test)
    long counter;
    zend_bool direction;
ZEND_END_MODULE_GLOBALS(test)

PHP_INI_BEGIN()
    PHP_INI_ENTRY("test.foo", "bar", PHP_INI_ALL, NULL)
    // STD_PHP_INI_ENTRY(name, default_value, modifiable, on_modify, property_name, struct_type, struct_ptr)
    STD_PHP_INI_ENTRY("test.direction", "1", PHP_INI_ALL, OnUpdateBool, direction, zend_test_globals, test_globals)
PHP_INI_END();

static void php_test_init_globals(zend_test_globals *test_globals) {
    /* direction初始化，0|1 */
    test_globals->direction = 1;
}

PHP_FUNCTION(test)
{
    if (TEST_G(direction)) {
        TEST_G(counter)++;
    } else {
        TEST_G(counter)--;
    }

    RETURN_LONG(TEST_G(counter));
}