把扩展从php5升级到php7(翻译)

目录：

1. 概述
2. 建议
3. zval
4. reference
5. Boolean
6. string
7. zend_string API
8. smart_str and smart_string
9. strpprintf
10. arrays
11. HashTable API
12. HashTable Iteration API
13. object
14. custom object
15. zend_object_handlers
16. resource
17. parameters Parsing API
18. call frame (zend_execute_data)
19. executor globals
20. opcodes
21. temp variable
22. pcre

概述

很多常用的ZEND API已经发生了变化，例如HashTable API。这篇文章会尽可能多的记录这些变化。强烈建议你先阅读PHP7的实现(我这里有个现成的翻译)。

当然，这肯定不会一篇完整的指南，它不可能涵盖所有的内容，但它收集了那些最常用的案例。

建议

• 在php7下编译你的扩展，编译错误与警告会告诉你绝大部分需要修改的地方。
• 在DEBUG模式下编译与调试你的扩展，在run-time你可以通过断言捕捉一些错误。你还可以看到内存泄露的情况。

zval

• PHP7不再需要指针的指针，绝大部分zval**需要修改成zval*。Z_*_PP()宏也需要修改成 Z_*_P().
• 如果PHP7直接操作zval，那么zval*也需要改成zval，Z_*P()也要改成Z_*(),ZVAL_*(var, …) 需要改成 ZVAL_*(&var, …).一定要谨慎使用&符号，因为PHP7几乎不要求使用zval*,那么很多地方的&也是要去掉的。

• ALLOC_ZVAL, ALLOC_INIT_ZVAL, MAKE_STD_ZVAL 这几个分配内存的宏已经被移除了。大多数情况下，zval*应该修改为zval，而 INIT_PZVAL宏也被移除了。

  //初始化的一些示例代码
  -  zval *zv;
  -  ALLOC_INIT_ZVAL();
  -  ZVAL_LONG(zv, 0);
  +  zval zv;
  +  ZVAL_LONG(&zv, 0);

zval 结构体也发生变化，它如今的定义如下

struct _zval_struct {
    zend_value        value;            /* value */
    union {
        struct {
            ZEND_ENDIAN_LOHI_4(
                zend_uchar    type,         /* active type */
                zend_uchar    type_flags,
                zend_uchar    const_flags,
                zend_uchar    reserved)     /* various IS_VAR flags */
        } v;
        zend_uint type_info;
    } u1;
    union {
        zend_uint     var_flags;
        zend_uint     next;                 /* hash collision chain */
        zend_uint     str_offset;           /* string offset */
        zend_uint     cache_slot;           /* literal cache slot */
    } u2;
};

typedef union _zend_value {
    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;
} zend_value;

主要的区别是，现在处理基本类型和复杂类型有所不同。基本类型是在VM栈上分配的，而不是堆，包括HashTable与Object，并且他们不支持引用计数与垃圾回收。基本类型没有引用计数，也就不再支持Z_ADDREF*(), Z_DELREF*(), Z_REFCOUNT*(),Z_SET_REFCOUNT*()这些宏了。你扩展中的基本类型使用了这些宏，那么程序会得到一个asset或者直接崩溃。

- Z_ADDREF_P(zv)
+ if (Z_REFCOUNTED_P(zv)) {Z_ADDREF_P(zv);}
# or equivalently
+ Z_TRY_ADDREF_P(zv);

一下是几点注意事项：

• 应该使用ZVAL_COPY_VALUE()进行值复制
• 使用ZVAL_COPY()拷贝是增加引用计数
• 可以使用ZVAL_DUP() 替代zval_copy_ctor进行复制
• 原本的NULL被替换成IS_UNDEF类型了，可以使用Z_ISUNDEF(zv)进行读取，ZVAL_UNDEF(&zv)进行初始化

• 可以使用zval_get_long(zv), zval_get_double(zv), zval_get_string(zv)等函数获取zval的值，这样不会改变原始的zval

  //一些示例代码
  - zval tmp;
  - ZVAL_COPY_VALUE(&tmp, zv);
  - zval_copy_ctor(&tmp);
  - convert_to_string(&tmp);
  - // ...
  - zval_dtor(&tmp);
  + zend_string *str = zval_get_string(zv);
  + // ...
  + zend_string_release(str);

更多请查看zend_types.h

reference

PHP7中的zval不再有is_ref字段了，而是使用zend_reference复合类型。如果你仍然使用Z_ISREF*()去检验zval是否是引用，实际上你是在判断zval是否是IS_REFERENCE类型。is_ref相关的宏已经被移除了。Z_SET_ISREF*(), Z_UNSET_ISREF*(), Z_SET_ISREF_TO*()这些宏的用法已经发生了改变，请参照下面。

- Z_SET_ISREF_P(zv);
+ ZVAL_MAKE_REF(zv);

- Z_UNSET_ISREF_P(zv);
+ if (Z_ISREF_P(zv)) {ZVAL_UNREF(zv);}

以前我们直接通过引用类型检测引用，但是现在我们需要使用Z_REFVAL*()间接检测了。

- if (Z_ISREF_P(zv) && Z_TYPE_P(zv) == IS_ARRAY) {
+ if (Z_ISREF_P(zv) && Z_TYPE_P(Z_REFVAL_P(zv)) == IS_ARRAY) {

或者手动使用ZVAL_DEREF()来减少引用计数。

- if (Z_ISREF_P(zv)) {...}
- if (Z_TYPE_P(zv) == IS_ARRAY) {
+ if (Z_ISREF_P(zv)) {...}
+ ZVAL_DEREF(zv);
+ if (Z_TYPE_P(zv) == IS_ARRAY) {

Boolean

IS_BOOL已经被IS_TRUE和IS_FALSE取代了。

- if ((Z_TYPE_PP(item) == IS_BOOL || Z_TYPE_PP(item) == IS_LONG) && Z_LVAL_PP(item)) {
+ if (Z_TYPE_P(item) == IS_TRUE || (Z_TYPE_P(item) == IS_LONG && Z_LVAL_P(item))) {

The Z_BVAL*() macros are removed. Be careful, the return value of Z_LVAL*() on IS_FALSE/IS_TRUE is undefined.

Z_BVAL*()宏已经被移除，注意，对IS_FALSE/IS_TRUE使用Z_LVAL*()得到的结果将是undefined。

string

string的值、长度可以分别使用Z_STRVAL*()、Z_STRLEN*()进行获取。而且现在使用zend_string来表示字符串，可以使用Z_STR*()从zval中获取zend_string的值，也是用使用Z_STRHASH*()获取字符串的HASH值。

如果现在要检测是否是驻留字符串，参数应该是zend_string而不是char*。

- if (IS_INTERNED(Z_STRVAL_P(zv))) {
+ if (IS_INTERNED(Z_STR_P(zv))) {

创建string类型的zval也发生了一些变化。 之前ZVAL_STRING()有个参数是控制字符串是否被复制的。现在这些宏都是用来创建zend_string的，所以这个参数变得没有必要了。 However if its actual value was 0, 你需要释放原始字符串来避免内存泄露。

- ZVAL_STRING(zv, str, 1);
+ ZVAL_STRING(zv, str);

- ZVAL_STRINGL(zv, str, len, 1);
+ ZVAL_STRINGL(zv, str, len);

- ZVAL_STRING(zv, str, 0);
+ ZVAL_STRING(zv, str);
+ efree(str);

- ZVAL_STRINGL(zv, str, len, 0);
+ ZVAL_STRINGL(zv, str, len);
+ efree(str);

RETURN_STRING(), RETVAL_STRNGL()和一些核心API并没有发生变化。

- add_assoc_string(zv, key, str, 1);
+ add_assoc_string(zv, key, str);

- add_assoc_string(zv, key, str, 0);
+ add_assoc_string(zv, key, str);
+ efree(str);

The double reallocation may be avoided using zend_string API directly and creating zval directly from zend_string.

- char * str = estrdup("Hello");
- RETURN_STRING(str);
+ zend_string *str = zend_string_init("Hello", sizeof("Hello")-1, 0);
+ RETURN_STR(str);

Z_STRVAL*()返回的变量应该当作只读的，它不应该被赋值。但是如果一定要修改，那么你应该确定它并没有在其他地方被引用，也就意味着它不能是驻留字符串并且引用计数是1。还有，如果你修改了字符串的值，那么你需要手动计算并保存其HASH值。

+ SEPARATE_ZVAL(zv);
+ Z_STRVAL_P(zv)[0] = Z_STRVAL_P(zv)[0] + ('A' - 'a');
+ zend_string_forget_hash_val((Z_STR_P(zv))

zend_string API

新引擎有新的zend_string API，以前大量使用char*+int的地方，都替换成了zend_string。

zend_string(not IS_STRING zvals)变量可以使用zend_string_init(char *val, int len, int persistent)进行创建。The actual characters may be accessed as str→val and string length as str→len.可以使用zend_string_hash_val获取hash值，它会再必要的时候重新进行计算。

应该使用zend_string_release()来释放string占用的内存，但是不一定会立即释放，因为这个string可能被多次引用。

如果你想保持一个zend_string的指针，那么你需要增加其引用计数，或者你可以直接使用zend_string_copy()来实现。很多时候拷贝只是为了获取其值，那么请尽量使用该函数。

- ptr->str = estrndup(Z_STRVAL_P(zv), Z_STRLEN_P(zv));
+ ptr->str = zend_string_copy(Z_STR_P(zv));
  ...
- efree(str);
+ zend_string_release(str);

复制string现在使用zend_string_dup()替代了。

- char *str = estrndup(Z_STRVAL_P(zv), Z_STRLEN_P(zv));
+ zend_string *str = zend_string_dup(Z_STR_P(zv));
  ...
- efree(str);
+ zend_string_release(str);

原来string的那些宏还是支持的，所以并不是一定要用新的写法。

如果一些string的长度是知道的但是需要一个缓冲区，那么你可以使用zend_string_alloc()或zend_string_realloc()进行内存分配。

- char *ret = emalloc(16+1);
- md5(something, ret); 
- RETURN_STRINGL(ret, 16, 0);
+ zend_string *ret = zend_string_alloc(16, 0);
+ md5(something, ret->val);
+ RETURN_STR(ret);

并不是所有的扩展都要更新到zend_string来替换char*,主要还是看哪一个更合适。

查看zend_string.h可以找到更详细的用法。

smart_str and smart_string

smart_str相关的API已经被重命名为smart_string了，除了新名字，用法基本没变。

- smart_str str = {0};
- smart_str_appendl(str, " ", sizeof(" ") - 1);
- smart_str_0(str);
- RETURN_STRINGL(implstr.c, implstr.len, 0);
+ smart_string str = {0};
+ smart_string_appendl(str, " ", sizeof(" ") - 1);
+ smart_string_0(str);
+ RETVAL_STRINGL(str.c, str.len);
+ smart_string_free(&str);

- smart_str str = {0};
- smart_str_appendl(str, " ", sizeof(" ") - 1);
- smart_str_0(str);
- RETURN_STRINGL(implstr.c, implstr.len, 0);
+ smart_str str = {0};
+ smart_str_appendl(str, " ", sizeof(" ") - 1);
+ smart_str_0(str);
+ if (str.s) {
+   RETURN_STR(str.s);
+ } else {
+   RETURN_EMPTY_STRING();
+ }

typedef struct {
    zend_string *s;
    size_t a;
} smart_str;

事实上smart_str和smart_string非常类似，在PHP5中它们基本算重复的，所以更新代码并不是必要的。

the biggest question what AI to select for each particular case, but it depends the way the final result is used.

但是检测其是否为空发生了一些变化。

- if (smart_str->c) {
+ if (smart_str->s) {

strpprintf

spprintf()和vspprintf()的返回值从char*变成了zend_string,那么你需要改变你的代码了。

+ PHPAPI zend_string *vstrpprintf(size_t max_len, const char *format, va_list ap);
+ PHPAPI zend_string *strpprintf(size_t max_len, const char *format, ...);

arrays

array的实现或多或少是不变的，但是之前是用一个指针指向HashTable，而现在指向的是zend_array。读取HashTable同样使用Z_ARRVAL*()宏，但是现在不可能改变该HashTable的指针了，现在唯一可以读取和改变zend_array的方法是通过Z_ARR*()宏。

使用array_init()同样是创建array的最好方法，但是也可以使用ZVAL_NEW_ARR()创建一个未初始化的array，用ZVAL_ARR()进行初始化。

可不变数组可以使用Z_IMMUTABLE()进行检测，但是如果想改变该数组，请先复制它。使用internal position pointer迭代不可变数组也是不行的。但是可以使用external position pointer结合原来的迭代API可以遍历数组，或者也可以使用新的HashTable迭代API。

HashTable API

HashTable API的变化很显著，移植扩展中要特别注意这点。

• HashTable的元素始终是zval，即使存的是指针，也是被封装成IS_PTR类型的zval。

  - zend_hash_update(ht, Z_STRVAL_P(key), Z_STRLEN_P(key)+1, (void*)&zv, sizeof(zval**), NULL) == SUCCESS) {
  + if (zend_hash_update(EG(function_table), Z_STR_P(key), zv)) != NULL) {

• API基本直接返回zval，而不是返回bool+参数返回zval。

  - if (zend_hash_find(ht, Z_STRVAL_P(key), Z_STRLEN_P(key)+1, (void**)&zv_ptr) == SUCCESS) {
  + if ((zv = zend_hash_find(ht, Z_STR_P(key))) != NULL) {

• 元素的key是用zend_string封装的，但是也同样提供了两类函数：zend_string或者char*+int

• 注意：key不再包含"\0",一些地方+1/-1会发生变化。

  - if (zend_hash_find(ht, "value", sizeof("value"), (void**)&zv_ptr) == SUCCESS) {
  + if ((zv = zend_hash_str_find(ht, "value", sizeof("value")-1)) != NULL) {

上面的规则同样也适用其他一些API。

- add_assoc_bool_ex(&zv, "valid", sizeof("valid"), 0);
+ add_assoc_bool_ex(&zv, "valid", sizeof("valid") - 1, 0);

• 同样提供了一组适用指针类型的参数，它们都有_ptr后缀。

  - if (zend_hash_find(EG(class_table), Z_STRVAL_P(key), Z_STRLEN_P(key)+1, (void**)&ce_ptr) == SUCCESS) {
  + if ((ce_ptr = zend_hash_find_ptr(EG(class_table), Z_STR_P(key))) != NULL) {
  
  - zend_hash_update(EG(class_table), Z_STRVAL_P(key), Z_STRLEN_P(key)+1, (void*)&ce, sizeof(zend_class_entry*), NULL) == SUCCESS) {
  + if (zend_hash_update_ptr(EG(class_table), Z_STR_P(key), ce)) != NULL) {

• API provides a separate group of functions to store memory blocks of arbitrary size. Such functions have the same names with _mem suffix and they implemented as inline wrappers of corresponding _ptr functions. It doesn't mean if something was stored using _mem or _ptr variant. It always may be retrieved back using zend_hash_find_ptr().

  - zend_hash_update(EG(function_table), Z_STRVAL_P(key), Z_STRLEN_P(key)+1, (void*)func, sizeof(zend_function), NULL) == SUCCESS) {
  + if (zend_hash_update_mem(EG(function_table), Z_STR_P(key), func, sizeof(zend_function))) != NULL) {

• 提供了一些新的添加函数，它们被用在添加新的zval并且当前不存在同样的key。它们都有同样的后缀_new。

  zval* zend_hash_add_new(HashTable *ht, zend_string *key, zval *zv);
  zval* zend_hash_str_add_new(HashTable *ht, char *key, int len, zval *zv);
  zval* zend_hash_index_add_new(HashTable *ht, pzval *zv);
  zval* zend_hash_next_index_insert_new(HashTable *ht, pzval *zv);
  void* zend_hash_add_new_ptr(HashTable *ht, zend_string *key, void *pData);
  ...

• HashTable destructors 的参数总是zval*类型。(even if we use zend_hash_add_ptr or zend_hash_add_mem to add elements). Z_PTR_P() macro may be used to reach the actual pointer value in destructors. Also, if elements are added using zend_hash_add_mem, destructor is also responsible for deallocation of the pointers themselves.

  - void my_ht_destructor(void *ptr)
  + void my_ht_destructor(zval *zv)
    {
  -    my_ht_el_t *p = (my_ht_el_t*) ptr;
  +    my_ht_el_t *p = (my_ht_el_t*) Z_PTR_P(zv);
       ...
  +    efree(p); // this efree() is not always necessary
    }
  );

• 像zend_hash_apply_*(),zend_hash_copy(),zend_hash_merge()的参数同样需要用zval*代替void*&&。一些函数可能接收zend_hash_key指针变量作为参数，该结构被定义为下，如果key是字符串，那么h保存hash值，key保存字符串；如果key是数字，那么h就是该数字，而key是NULL。

  typedef struct _zend_hash_key {
      ulong        h;
      zend_string *key;
  } zend_hash_key;

注意：应该使用新的迭代API替换zend_hash_apply*()此类函数，因为效率更高，代码更短。

更多请查看zend_hash.h

HashTable Iteration API

我们提供了一些特别的宏来遍历HashTable，第一个参数是HashTable，剩下的参数变量将在每一步迭代中被复制。

ZEND_HASH_FOREACH_VAL(ht, val)
ZEND_HASH_FOREACH_KEY(ht, h, key)
ZEND_HASH_FOREACH_PTR(ht, ptr)
ZEND_HASH_FOREACH_NUM_KEY(ht, h)
ZEND_HASH_FOREACH_STR_KEY(ht, key)
ZEND_HASH_FOREACH_STR_KEY_VAL(ht, key, val)
ZEND_HASH_FOREACH_KEY_VAL(ht, h, key, val)

最好适用新的宏代替原来的那么操作函数。

- HashPosition pos;
  ulong num_key;
- char *key;
- uint key_len;
+ zend_string *key;
- zval **pzv;
+ zval *zv;
-
- zend_hash_internal_pointer_reset_ex(&ht, &pos);
- while (zend_hash_get_current_data_ex(&ht, (void**)&ppzval, &pos) == SUCCESS) {
-   if (zend_hash_get_current_key_ex(&ht, &key, &key_len, &num_key, 0, &pos) == HASH_KEY_IS_STRING){
-   }
+ ZEND_HASH_FOREACH_KEY_VAL(ht, num_key, key, val) {
+   if (key) { //HASH_KEY_IS_STRING
+   }
    ........
-   zend_hash_move_forward_ex(&ht, &pos);
- }
+ } ZEND_HASH_FOREACH_END();

object

TODO: …

custom object

TODO: …

zend_object被定义为：

struct _zend_object {
    zend_refcounted   gc;
    zend_uint         handle; // TODO: may be removed ???
    zend_class_entry *ce;
    const zend_object_handlers *handlers;
    HashTable        *properties;
    HashTable        *guards; /* protects from __get/__set ... recursion */
    zval              properties_table[1];
};

新的结构中properties_table是内联的，这就带来了问题。以前我们是这样自定义对象的：

struct custom_object {
   zend_object std;
   void  *custom_data;
}

zend_object_value custom_object_new(zend_class_entry *ce TSRMLS_DC) {

   zend_object_value retval;
   struct custom_object *intern;

   intern = emalloc(sizeof(struct custom_object));
   zend_object_std_init(&intern->std, ce TSRMLS_CC);
   object_properties_init(&intern->std, ce);
   retval.handle = zend_objects_store_put(intern,
        (zend_objects_store_dtor_t)zend_objects_destroy_object,
        (zend_objects_free_object_storage_t) custom_free_storage, 
        NULL TSRMLC_CC);
   intern->handle = retval.handle;
   retval.handlers = &custom_object_handlers;
   return retval;
}

struct custom_object* obj = (struct custom_object *)zend_objects_get_address(getThis());

但是现在由于内联属性，zend_object的长度是变化的，所以我们要做出下面的改变了。

struct custom_object {
   void  *custom_data;
   zend_object std;
}

zend_object * custom_object_new(zend_class_entry *ce TSRMLS_DC) {
     # Allocate sizeof(custom) + sizeof(properties table requirements)
     struct custom_object *intern = ecalloc(1, 
         sizeof(struct custom_object) + 
         zend_object_properties_size(ce));
     # Allocating:
     # struct custom_object {
     #    void *custom_data;
     #    zend_object std;
     # }
     # zval[ce->default_properties_count-1]
     zend_object_std_init(&intern->std, ce TSRMLS_CC);
     ...
     custom_object_handlers.offset = XtOffsetof(struct custom_obj, std);
     custom_object_handlers.free_obj = custom_free_storage;

     return &intern->std;
}

# Fetching the custom object:

static inline struct custom_object * php_custom_object_fetch_object(zend_object *obj) {
      return (struct custom_object *)((char *)obj - XtOffsetOf(struct custom_object, std));
}

#define Z_CUSTOM_OBJ_P(zv) php_custom_object_fetch_object(Z_OBJ_P(zv));

struct custom_object* obj = Z_CUSTOM_OBJ_P(getThis());

zend_object_handlers

一个新的字段offset被定义进zend_object_handlers,当你使用自定义对象的时候，一定要对它赋值。

请使用zend_objects_store_*来找到分配的地址。

// An example in spl_array
memcpy(&spl_handler_ArrayObject, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
spl_handler_ArrayObject.offset = XtOffsetOf(spl_array_object, std);

对象的内存会自动被zend_objects_store_*释放，所以你不必通过free_obj句柄来释放。

resource

IS_RESOURCE类型zval不再保持resource handle，也不能使用Z_LVAL*()获取resource handle了,现在应该使用Z_RES*()宏获取。It contains type - resource type, ptr - pointer to actual data, handle - numeric resource index (for compatibility) and service fields for reference counter. Actually this zend_resurce structure is a replacement for indirectly referred zend_rsrc_list_entry. 所有与zend_rsrc_list_entry相关的应该被zend_resource代替.

• zend_list_find()已被移除，因为资源能够被直接获取。

  - long handle = Z_LVAL_P(zv);
  - int  type;
  - void *ptr = zend_list_find(handle, &type);
  + long handle = Z_RES_P(zv)->handle;
  + int  type = Z_RES_P(zv)->type;
  + void *ptr = = Z_RES_P(zv)->ptr;

• Z_RESVAL_*()已被移除，用 Z_RES*()代替。

  - long handle = Z_RESVAL_P(zv);
  + long handle = Z_RES_P(zv)->handle;

• ZEND_REGISTER_RESOURCE/ZEND_FETCH_RESOURCE()都被移除了。

  - ZEND_FETCH_RESOURCE2(ib_link, ibase_db_link *, &link_arg, link_id, LE_LINK, le_link, le_plink);
  
  //if you are sure that link_arg is a IS_RESOURCE type, then use :
  +if ((ib_link = (ibase_db_link *)zend_fetch_resource2(Z_RES_P(link_arg), LE_LINK, le_link, le_plink)) == NULL) {
  +    RETURN_FALSE;
  +}
  
  //otherwise, if you know nothing about link_arg's type, use
  +if ((ib_link = (ibase_db_link *)zend_fetch_resource2_ex(link_arg, LE_LINK, le_link, le_plink)) == NULL) {
  +    RETURN_FALSE;
  +}
  
  - REGISTER_RESOURCE(return_value, result, le_result);
  + RETURN_RES(zend_register_resource(result, le_result);

• zend_list_addref()，zend_list_delref()都被移除。

  - zend_list_addref(Z_LVAL_P(zv));
  + Z_ADDREF_P(zv);
  
  - zend_list_addref(Z_LVAL_P(zv));
  + Z_RES_P(zv)->gc.refcount++;

• zend_list_delete()需传入 zend_resource 指针变量

  - zend_list_delete(Z_LVAL_P(zv));
  + zend_list_delete(Z_RES_P(zv));

• 在多数扩展函数中，像mysql_close()，你应该使用zend_list_close()代替zend_list_delete()，因为close只是关闭实际连接与释放扩展特别的结构，但是不会释放zend_reference structure，所以还可以从其他地方引用该zval，close同样也不会减少引用计数。

  - zend_list_delete(Z_LVAL_P(zv));
  + zend_list_close(Z_RES_P(zv));

parameters Parsing API

• PHP7不再需要zval**，所以请用"z"标识替换"Z"

  - zval **pzv;
  - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &pzv) == FAILURE) {
  + zval *zv;
  + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zv) == FAILURE) {

• PHP7建议适用"S"标识接收zend_string变量。

  - char *str;
  - int len;
  - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &len) == FAILURE) {
  + zend_string *str;
  + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &str) == FAILURE) {

• "+"/"*"只接收zval数组了

  - zval ***argv = NULL;
  + zval *argv = NULL;
    int argn;
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "+", &argv, &argn) == FAILURE) {

• arguments passed by reference should be assigned into the referenced value. It's possible to separte such arguments, to get referenced value at first place.

  - zval **ret;
  - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &ret) == FAILURE) {
  + zval *ret;
  + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z/", &ret) == FAILURE) {
      return;
    }
  - ZVAL_LONG(*ret, 0);
  + ZVAL_LONG(ret, 0);

call frame (zend_execute_data)

每一次的函数调用都记录在zend_execute_data结构链表中，EG(current_execute_data)指向当前执行函数的调用栈，之前只有PHP用户函数才这样。我会尽量解释清楚新旧调用栈之间的区别。

• zend_execute_data.opline - 当前执行的用户函数的指针。内核函数它的值是未定义，之前是NULL。

• zend_execute_data.function_state - 被移除，用 zend_execute_data.call代替。

• zend_execute_data.call - 旧引擎中是call_slot的指针，现在是当前调用函数的指针，它被初始化为NULL, 然后被ZEND_INIT_FCALL (or similar) opcodes改变，最后被ZEND_FO_FCALL回复. 嵌套函数调用，例如foo($a, bar($c)), 将通过zend_execute_data.prev_nested_call构造一个链表。

• zend_execute_data.op_array - 已被zend_execute_data.func替代, 因为现在它不仅代表用户函数也代表内核函数。

• zend_execute_data.func - 当前执行的函数

• zend_execute_data.object - $this of the currently executed function (previously it was a zval*, now it's a zend_object*)

• zend_execute_data.symbol_table - current symbol table or NULL

• zend_execute_data.prev_execute_data - link of backtrace call chain

• original_return_value, current_scope, current_called_scope, current_this - 这些缓存变量值以便在调用后恢复现场的字段已被移除。

• zend_execute_data.scope - scope of the currently executed function (this is a new field).

• zend_execute_data.called_scope - called_scope of the currently executed function (this is a new field).

• zend_execute_data.run_time_cache - run-time-cache of the currently executed function. this is a new field and actually it's a copy of op_array.run_time_cache.

• zend_execute_data.num_args - number of arguments passed to the function (this is a new field)

• zend_execute_data.return_value - pointer to zval* where the currently executed op_array should store the result. 如果不关心返回值它可能就是NULL. (this is a new field).

函数参数都被直接储存在zval插槽中，在内存中紧接着zend_execute_data结构。他们可以通过ZEND_CALL_ARG(execute_data, arg_num)宏获取。如果是用户函数，函数的第一个参数内存位置将会和第一个compiled variable - CV0 重合。In case caller passes more arguments that callee receives, all extra arguments are copied to be after all used by calee CVs and TMP variables.

executor globals

• EG(symbol_table)已经变成了zend_array了，而非HashTable。

  - symbols = zend_hash_num_elements(&EG(symbol_table));
  + symbols = zend_hash_num_elements(&EG(symbol_table).ht);

• EG(uninitialized_zval_ptr) and EG(error_zval_ptr) were removed. Use &EG(uninitialized_zval) and &EG(error_zval) instead.

• EG(current_execute_data) - 此字符发生了一些变化，之前是一个指向最后调用函数的栈帧。现在它指向最后执行的调用栈帧，并不区别是脚本函数还是内核函数。It's possible to get the zend_execute_data structure for the last op_array traversing call chain list.

    zend_execute_data *ex = EG(current_execute_data);
  + while (ex && (!ex->func || !ZEND_USER_CODE(ex->func->type))) {
  +    ex = ex->prev_execute_data;
  + }
    if (ex) {

• EG(opline_ptr) - 被移除，用execute_data->opline替代

• EG(return_value_ptr_ptr) - 被移除，用execute_data->return_value替代

• EG(active_symbol_table) - 被移除，用execute_data->symbol_table替代

• EG(active_op_array) - 被移除，用execute_data->func替代

• EG(called_scope) - 被移除，用execute_data->called_scope替代

• EG(This) - 变成zval, 之前是zval*。不应被修改。

• EG(in_execution) - 被移除. If EG(current_excute_data) is not NULL, we are executing something.

• EG(exception) and EG(prev_exception) - 被改成zend_object*,之前是zval*

opcodes

• ZEND_DO_FCALL_BY_NAME - 已被移除,新增ZEND_INIT_FCALL_BY_NAME.

• ZEND_BIND_GLOBAL - "global $var"的handler

• ZEND_STRLEN - 代替了strlen函数

• ZEND_TYPE_CHECK - 在必要的时候,用来代替is_array/is_int/is_*

• ZEND_DEFINED - 在必要的时候代替zif_defined(if only one parameter and it's constant string and it's not in namespace style)

• ZEND_SEND_VAR_EX - was added to do more check than ZEND_SEND_VAR if the condition can not be settled in compiling time

• ZEND_SEND_VAL_EX - was added to do more check than ZEND_SEND_VAL if the condition can not be settled in compiling time

• ZEND_INIT_USER_CALL - was added to replace call_user_func(_array) if possible if the function can not be found in compiling time, otherwise it can convert to ZEND_INIT_FCALL

• ZEND_SEND_ARRAY - was added to send the second parameter, the array of the call_user_func_array after it is converted to opcode

• ZEND_SEND_USER - was added to send the the parameters of call_user_func after it is converted to opcode

temp variable

TODO: …

pcre

一些正则API使用zend_string作为参数或者返回值了。php_pcre_replace returns a zend_string and takes a zend_string as 1st argument. 仔细检查函数申明与编译错误, 可以发现多数是类型错误。