Removed IS_TYPE_IMMUTABLE (it's the same as COPYABLE & !REFCOUED)

diff --git a/NEWS b/NEWS
index 7bacef200c357158fa9ee79105125521d3c2fad2..ec4e1e2b134546d29ff84e67a783f43118e988bf 100644 (file)
--- a/NEWS
+++ b/NEWS
@@ -6,6 +6,7 @@ PHP                                                                        NEWS
   . Fix integer overflows (Joshua Rogers)
 
 - Core:
+  . Removed IS_TYPE_IMMUTABLE (it's the same as COPYABLE & !REFCOUED). (Dmitry)
   . Removed the sql.safe_mode directive. (Kalle)
   . Removed support for Netware. (Kalle)
   . Fixed bug #54535 (WSA cleanup executes before MSHUTDOWN). (Kalle)

diff --git a/Zend/zend_ast.c b/Zend/zend_ast.c
index dba945129cf8cd96a0b64cd7cde747a659838687..5072c62891e915ea11d0921fe15152f37d5316a0 100644 (file)
--- a/Zend/zend_ast.c
+++ b/Zend/zend_ast.c
@@ -266,7 +266,7 @@ ZEND_API int zend_ast_evaluate(zval *result, zend_ast *ast, zend_class_entry *sc
                        zval *zv = zend_ast_get_zval(ast);
 
                        if (Z_OPT_CONSTANT_P(zv)) {
-                               if (!(Z_TYPE_FLAGS_P(zv) & IS_TYPE_IMMUTABLE)) {
+                               if (Z_TYPE_FLAGS_P(zv) & IS_TYPE_REFCOUNTED) {
                                        if (UNEXPECTED(zval_update_constant_ex(zv, scope) != SUCCESS)) {
                                                ret = FAILURE;
                                                break;

diff --git a/Zend/zend_builtin_functions.c b/Zend/zend_builtin_functions.c
index 1faf57cf3170cb7082c4456e5e1fd50e47b4d797..41da1f95376faad784c5419a29bb1a78eb9d4ebf 100644 (file)
--- a/Zend/zend_builtin_functions.c
+++ b/Zend/zend_builtin_functions.c
@@ -836,7 +836,7 @@ static int validate_constant_array(HashTable *ht) /* {{{ */
                ZVAL_DEREF(val);
                if (Z_REFCOUNTED_P(val)) {
                        if (Z_TYPE_P(val) == IS_ARRAY) {
-                               if (!Z_IMMUTABLE_P(val)) {
+                               if (Z_REFCOUNTED_P(val)) {
                                        if (Z_ARRVAL_P(val)->u.v.nApplyCount > 0) {
                                                zend_error(E_WARNING, "Constants cannot be recursive arrays");
                                                ret = 0;
@@ -874,7 +874,7 @@ static void copy_constant_array(zval *dst, zval *src) /* {{{ */
                        new_val = zend_hash_index_add_new(Z_ARRVAL_P(dst), idx, val);
                }
                if (Z_TYPE_P(val) == IS_ARRAY) {
-                       if (!Z_IMMUTABLE_P(val)) {
+                       if (Z_REFCOUNTED_P(val)) {
                                copy_constant_array(new_val, val);
                        }
                } else if (Z_REFCOUNTED_P(val)) {
@@ -932,7 +932,7 @@ repeat:
                        val = &val_free;
                        break;
                case IS_ARRAY:
-                       if (!Z_IMMUTABLE_P(val)) {
+                       if (Z_REFCOUNTED_P(val)) {
                                if (!validate_constant_array(Z_ARRVAL_P(val))) {
                                        RETURN_FALSE;
                                } else {

diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c
index cb2e936df046570e3636be6c69cba02fb87dd614..c01a807e55dfc0144a2a9a7a42f8df89ed400c09 100644 (file)
--- a/Zend/zend_execute_API.c
+++ b/Zend/zend_execute_API.c
@@ -573,7 +573,7 @@ ZEND_API int zval_update_constant_ex(zval *p, zend_class_entry *scope) /* {{{ */
                        zend_throw_error(NULL, "Cannot declare self-referencing constant '%s'", Z_STRVAL_P(p));
                        return FAILURE;
                }
-               inline_change = (Z_TYPE_FLAGS_P(p) & IS_TYPE_IMMUTABLE) == 0;
+               inline_change = (Z_TYPE_FLAGS_P(p) & IS_TYPE_REFCOUNTED) != 0;
                SEPARATE_ZVAL_NOREF(p);
                MARK_CONSTANT_VISITED(p);
                if (Z_CONST_FLAGS_P(p) & IS_CONSTANT_CLASS) {
@@ -638,7 +638,7 @@ ZEND_API int zval_update_constant_ex(zval *p, zend_class_entry *scope) /* {{{ */
        } else if (Z_TYPE_P(p) == IS_CONSTANT_AST) {
                zval tmp;
 
-               inline_change = (Z_TYPE_FLAGS_P(p) & IS_TYPE_IMMUTABLE) == 0;
+               inline_change = (Z_TYPE_FLAGS_P(p) & IS_TYPE_REFCOUNTED) != 0;
                if (UNEXPECTED(zend_ast_evaluate(&tmp, Z_ASTVAL_P(p), scope) != SUCCESS)) {
                        return FAILURE;
                }

diff --git a/Zend/zend_object_handlers.c b/Zend/zend_object_handlers.c
index 2273b06fb3c67ce3c70da29a4bce174c436ae686..19165d69f648227777c7f4a710f64f6b9a72efbc 100644 (file)
--- a/Zend/zend_object_handlers.c
+++ b/Zend/zend_object_handlers.c
@@ -163,7 +163,7 @@ ZEND_API HashTable *zend_std_get_debug_info(zval *object, int *is_temp) /* {{{ *
 
        zend_call_method_with_0_params(object, ce, &ce->__debugInfo, ZEND_DEBUGINFO_FUNC_NAME, &retval);
        if (Z_TYPE(retval) == IS_ARRAY) {
-               if (Z_IMMUTABLE(retval)) {
+               if (!Z_REFCOUNTED(retval)) {
                        *is_temp = 1;
                        return zend_array_dup(Z_ARRVAL(retval));
                } else if (Z_REFCOUNT(retval) <= 1) {

diff --git a/Zend/zend_types.h b/Zend/zend_types.h
index 9d4f6a7d4caa7663fe7b48ec0d86dfbff4a2bd2a..16619f04b4b301122392433a7c1da7d0e3352904 100644 (file)
--- a/Zend/zend_types.h
+++ b/Zend/zend_types.h
@@ -386,7 +386,6 @@ static zend_always_inline zend_uchar zval_get_type(const zval* pz) {
 
 #define Z_GC_INFO(zval)                                GC_INFO(Z_COUNTED(zval))
 #define Z_GC_INFO_P(zval_p)                    Z_GC_INFO(*(zval_p))
-
 #define Z_GC_TYPE_INFO(zval)           GC_TYPE_INFO(Z_COUNTED(zval))
 #define Z_GC_TYPE_INFO_P(zval_p)       Z_GC_TYPE_INFO(*(zval_p))
 
@@ -402,7 +401,6 @@ static zend_always_inline zend_uchar zval_get_type(const zval* pz) {
 
 /* zval.u1.v.type_flags */
 #define IS_TYPE_CONSTANT                       (1<<0)
-#define IS_TYPE_IMMUTABLE                      (1<<1)
 #define IS_TYPE_REFCOUNTED                     (1<<2)
 #define IS_TYPE_COPYABLE                       (1<<4)
 
@@ -437,7 +435,7 @@ static zend_always_inline zend_uchar zval_get_type(const zval* pz) {
 #define IS_STR_CONSTANT_UNQUALIFIED (1<<4) /* the same as IS_CONSTANT_UNQUALIFIED */
 
 /* array flags */
-#define IS_ARRAY_IMMUTABLE                     (1<<1) /* the same as IS_TYPE_IMMUTABLE */
+#define IS_ARRAY_IMMUTABLE                     (1<<1)
 
 /* object flags (zval.value->gc.u.flags) */
 #define IS_OBJ_APPLY_COUNT                     0x07
@@ -475,9 +473,6 @@ static zend_always_inline zend_uchar zval_get_type(const zval* pz) {
 #define Z_COPYABLE(zval)                       ((Z_TYPE_FLAGS(zval) & IS_TYPE_COPYABLE) != 0)
 #define Z_COPYABLE_P(zval_p)           Z_COPYABLE(*(zval_p))
 
-#define Z_IMMUTABLE(zval)                      ((Z_TYPE_FLAGS(zval) & IS_TYPE_IMMUTABLE) != 0)
-#define Z_IMMUTABLE_P(zval_p)          Z_IMMUTABLE(*(zval_p))
-
 /* the following Z_OPT_* macros make better code when Z_TYPE_INFO accessed before */
 #define Z_OPT_TYPE(zval)                       (Z_TYPE_INFO(zval) & Z_TYPE_MASK)
 #define Z_OPT_TYPE_P(zval_p)           Z_OPT_TYPE(*(zval_p))
@@ -491,9 +486,6 @@ static zend_always_inline zend_uchar zval_get_type(const zval* pz) {
 #define Z_OPT_COPYABLE(zval)           ((Z_TYPE_INFO(zval) & (IS_TYPE_COPYABLE << Z_TYPE_FLAGS_SHIFT)) != 0)
 #define Z_OPT_COPYABLE_P(zval_p)       Z_OPT_COPYABLE(*(zval_p))
 
-#define Z_OPT_IMMUTABLE(zval)          ((Z_TYPE_INFO(zval) & (IS_TYPE_IMMUTABLE << Z_TYPE_FLAGS_SHIFT)) != 0)
-#define Z_OPT_IMMUTABLE_P(zval_p)      Z_OPT_IMMUTABLE(*(zval_p))
-
 #define Z_OPT_ISREF(zval)                      (Z_OPT_TYPE(zval) == IS_REFERENCE)
 #define Z_OPT_ISREF_P(zval_p)          Z_OPT_ISREF(*(zval_p))
 
@@ -818,7 +810,7 @@ static zend_always_inline zend_uchar zval_get_type(const zval* pz) {
 #define Z_TRY_DELREF(z)                                Z_TRY_DELREF_P(&(z))
 
 static zend_always_inline uint32_t zval_refcount_p(zval* pz) {
-       ZEND_ASSERT(Z_REFCOUNTED_P(pz) || Z_IMMUTABLE_P(pz));
+       ZEND_ASSERT(Z_REFCOUNTED_P(pz) || Z_COPYABLE_P(pz));
        return GC_REFCOUNT(Z_COUNTED_P(pz));
 }
 
@@ -883,8 +875,8 @@ static zend_always_inline uint32_t zval_delref_p(zval* pz) {
                zend_refcounted *_gc = Z_COUNTED_P(_z2);                \
                uint32_t _t = Z_TYPE_INFO_P(_z2);                               \
                ZVAL_COPY_VALUE_EX(_z1, _z2, _gc, _t);                  \
-               if ((_t & ((IS_TYPE_REFCOUNTED|IS_TYPE_IMMUTABLE) << Z_TYPE_FLAGS_SHIFT)) != 0) { \
-                       if ((_t & ((IS_TYPE_COPYABLE|IS_TYPE_IMMUTABLE) << Z_TYPE_FLAGS_SHIFT)) != 0) { \
+               if ((_t & ((IS_TYPE_REFCOUNTED|IS_TYPE_COPYABLE) << Z_TYPE_FLAGS_SHIFT)) != 0) { \
+                       if ((_t & (IS_TYPE_COPYABLE << Z_TYPE_FLAGS_SHIFT)) != 0) { \
                                _zval_copy_ctor_func(_z1 ZEND_FILE_LINE_CC); \
                        } else {                                                                        \
                                GC_REFCOUNT(_gc)++;                                             \
@@ -950,7 +942,7 @@ static zend_always_inline uint32_t zval_delref_p(zval* pz) {
                zval *_zv = (zv);                                                               \
                zend_array *_arr = Z_ARR_P(_zv);                                \
                if (UNEXPECTED(GC_REFCOUNT(_arr) > 1)) {                \
-                       if (!Z_IMMUTABLE_P(_zv)) {                                      \
+                       if (Z_REFCOUNTED_P(_zv)) {                                      \
                                GC_REFCOUNT(_arr)--;                                    \
                        }                                                                                       \
                        ZVAL_ARR(_zv, zend_array_dup(_arr));            \
@@ -960,10 +952,9 @@ static zend_always_inline uint32_t zval_delref_p(zval* pz) {
 #define SEPARATE_ZVAL_NOREF(zv) do {                                   \
                zval *_zv = (zv);                                                               \
                ZEND_ASSERT(Z_TYPE_P(_zv) != IS_REFERENCE);             \
-               if (Z_COPYABLE_P(_zv) ||                                                \
-                   Z_IMMUTABLE_P(_zv)) {                                               \
+               if (Z_COPYABLE_P(_zv)) {                                                \
                        if (Z_REFCOUNT_P(_zv) > 1) {                            \
-                               if (!Z_IMMUTABLE_P(_zv)) {                              \
+                               if (Z_REFCOUNTED_P(_zv)) {                              \
                                        Z_DELREF_P(_zv);                                        \
                                }                                                                               \
                                zval_copy_ctor_func(_zv);                               \
@@ -974,11 +965,10 @@ static zend_always_inline uint32_t zval_delref_p(zval* pz) {
 #define SEPARATE_ZVAL(zv) do {                                                 \
                zval *_zv = (zv);                                                               \
                if (Z_REFCOUNTED_P(_zv) ||                                              \
-                   Z_IMMUTABLE_P(_zv)) {                                               \
+                   Z_COPYABLE_P(_zv)) {                                                \
                        if (Z_REFCOUNT_P(_zv) > 1) {                            \
-                               if (Z_COPYABLE_P(_zv) ||                                \
-                                   Z_IMMUTABLE_P(_zv)) {                               \
-                                       if (!Z_IMMUTABLE_P(_zv)) {                      \
+                               if (Z_COPYABLE_P(_zv)) {                                \
+                                       if (Z_REFCOUNTED_P(_zv)) {                      \
                                                Z_DELREF_P(_zv);                                \
                                        }                                                                       \
                                        zval_copy_ctor_func(_zv);                       \
@@ -992,10 +982,9 @@ static zend_always_inline uint32_t zval_delref_p(zval* pz) {
 
 #define SEPARATE_ZVAL_IF_NOT_REF(zv) do {                              \
                zval *_zv = (zv);                                                               \
-               if (Z_COPYABLE_P(_zv) ||                        \
-                   Z_IMMUTABLE_P(_zv)) {                                               \
+               if (Z_COPYABLE_P(_zv)) {                                                \
                        if (Z_REFCOUNT_P(_zv) > 1) {                            \
-                               if (!Z_IMMUTABLE_P(_zv)) {                              \
+                               if (Z_REFCOUNTED_P(_zv)) {                              \
                                        Z_DELREF_P(_zv);                                        \
                                }                                                                               \
                                zval_copy_ctor_func(_zv);                               \

diff --git a/Zend/zend_variables.h b/Zend/zend_variables.h
index b0054eedd3d4b7d90e156ea2099d36655f793d20..f039986c6e0c0fa605c9aeec820648083a6487e9 100644 (file)
--- a/Zend/zend_variables.h
+++ b/Zend/zend_variables.h
@@ -55,29 +55,7 @@ static zend_always_inline void i_zval_ptr_dtor(zval *zval_ptr ZEND_FILE_LINE_DC)
 
 static zend_always_inline void _zval_copy_ctor(zval *zvalue ZEND_FILE_LINE_DC)
 {
-       if (Z_REFCOUNTED_P(zvalue) || Z_IMMUTABLE_P(zvalue)) {
-               if (Z_COPYABLE_P(zvalue) || Z_IMMUTABLE_P(zvalue)) {
-                       _zval_copy_ctor_func(zvalue ZEND_FILE_LINE_RELAY_CC);
-               } else {
-                       Z_ADDREF_P(zvalue);
-               }
-       }
-}
-
-static zend_always_inline void _zval_opt_copy_ctor(zval *zvalue ZEND_FILE_LINE_DC)
-{
-       if (Z_OPT_REFCOUNTED_P(zvalue) || Z_OPT_IMMUTABLE_P(zvalue)) {
-               if (Z_OPT_COPYABLE_P(zvalue) || Z_OPT_IMMUTABLE_P(zvalue)) {
-                       _zval_copy_ctor_func(zvalue ZEND_FILE_LINE_RELAY_CC);
-               } else {
-                       Z_ADDREF_P(zvalue);
-               }
-       }
-}
-
-static zend_always_inline void _zval_copy_ctor_no_imm(zval *zvalue ZEND_FILE_LINE_DC)
-{
-       if (Z_REFCOUNTED_P(zvalue)) {
+       if (Z_REFCOUNTED_P(zvalue) || Z_COPYABLE_P(zvalue)) {
                if (Z_COPYABLE_P(zvalue)) {
                        _zval_copy_ctor_func(zvalue ZEND_FILE_LINE_RELAY_CC);
                } else {
@@ -86,9 +64,9 @@ static zend_always_inline void _zval_copy_ctor_no_imm(zval *zvalue ZEND_FILE_LIN
        }
 }
 
-static zend_always_inline void _zval_opt_copy_ctor_no_imm(zval *zvalue ZEND_FILE_LINE_DC)
+static zend_always_inline void _zval_opt_copy_ctor(zval *zvalue ZEND_FILE_LINE_DC)
 {
-       if (Z_OPT_REFCOUNTED_P(zvalue)) {
+       if (Z_OPT_REFCOUNTED_P(zvalue) || Z_OPT_COPYABLE_P(zvalue)) {
                if (Z_OPT_COPYABLE_P(zvalue)) {
                        _zval_copy_ctor_func(zvalue ZEND_FILE_LINE_RELAY_CC);
                } else {
@@ -105,8 +83,6 @@ ZEND_API void _zval_internal_ptr_dtor(zval *zvalue ZEND_FILE_LINE_DC);
 ZEND_API void _zval_dtor_wrapper(zval *zvalue);
 #define zval_copy_ctor(zvalue) _zval_copy_ctor((zvalue) ZEND_FILE_LINE_CC)
 #define zval_opt_copy_ctor(zvalue) _zval_opt_copy_ctor((zvalue) ZEND_FILE_LINE_CC)
-#define zval_copy_ctor_no_imm(zvalue) _zval_copy_ctor_no_imm((zvalue) ZEND_FILE_LINE_CC)
-#define zval_opt_copy_ctor_no_imm(zvalue) _zval_opt_copy_ctor_no_imm((zvalue) ZEND_FILE_LINE_CC)
 #define zval_dtor(zvalue) zval_ptr_dtor_nogc(zvalue)
 #define zval_ptr_dtor(zval_ptr) _zval_ptr_dtor((zval_ptr) ZEND_FILE_LINE_CC)
 #define zval_ptr_dtor_nogc(zval_ptr) _zval_ptr_dtor_nogc((zval_ptr) ZEND_FILE_LINE_CC)

diff --git a/ext/mbstring/mbstring.c b/ext/mbstring/mbstring.c
index 8db82aa83a2eb7049b859f446bd345f2acec99c9..a81c6149ee90256f34098152f2d9ca0b8328ee5a 100644 (file)
--- a/ext/mbstring/mbstring.c
+++ b/ext/mbstring/mbstring.c
@@ -3939,7 +3939,7 @@ PHP_FUNCTION(mb_convert_variables)
                                        target_hash = HASH_OF(var);
                                        if (target_hash != NULL) {
                                                while ((hash_entry = zend_hash_get_current_data(target_hash)) != NULL) {
-                                                       if (!Z_IMMUTABLE_P(var)) {
+                                                       if (Z_REFCOUNTED_P(var)) {
                                                                if (++target_hash->u.v.nApplyCount > 1) {
                                                                        --target_hash->u.v.nApplyCount;
                                                                        recursion_error = 1;
@@ -3988,7 +3988,7 @@ detect_end:
                }
                if (recursion_error) {
                        while(stack_level-- && (var = &stack[stack_level])) {
-                               if (!Z_IMMUTABLE_P(var)) {
+                               if (Z_REFCOUNTED_P(var)) {
                                        if (HASH_OF(var)->u.v.nApplyCount > 1) {
                                                HASH_OF(var)->u.v.nApplyCount--;
                                        }
@@ -4055,7 +4055,7 @@ detect_end:
                                                hash_entry = hash_entry_ptr;
                                                ZVAL_DEREF(hash_entry);
                                                if (Z_TYPE_P(hash_entry) == IS_ARRAY || Z_TYPE_P(hash_entry) == IS_OBJECT) {
-                                                       if (!Z_IMMUTABLE_P(hash_entry)) {
+                                                       if (Z_REFCOUNTED_P(hash_entry)) {
                                                                if (++(HASH_OF(hash_entry)->u.v.nApplyCount) > 1) {
                                                                        --(HASH_OF(hash_entry)->u.v.nApplyCount);
                                                                        recursion_error = 1;
@@ -4108,7 +4108,7 @@ conv_end:
 
                if (recursion_error) {
                        while(stack_level-- && (var = &stack[stack_level])) {
-                               if (!Z_IMMUTABLE_P(var)) {
+                               if (Z_REFCOUNTED_P(var)) {
                                        if (HASH_OF(var)->u.v.nApplyCount > 1) {
                                                HASH_OF(var)->u.v.nApplyCount--;
                                        }

diff --git a/ext/opcache/zend_persist.c b/ext/opcache/zend_persist.c
index e022b40950a94e2d1a2b6b67550a3c55982c6f6f..3956a716107b77e035d8751dd1ea726128b602c6 100644 (file)
--- a/ext/opcache/zend_persist.c
+++ b/ext/opcache/zend_persist.c
@@ -276,18 +276,15 @@ static void zend_persist_zval(zval *z)
                        flags = Z_GC_FLAGS_P(z) & ~ (IS_STR_PERSISTENT | IS_STR_INTERNED | IS_STR_PERMANENT);
                        zend_accel_store_interned_string(Z_STR_P(z));
                        Z_GC_FLAGS_P(z) |= flags;
-                       Z_TYPE_FLAGS_P(z) &= ~(IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
-                       if (Z_TYPE_P(z) == IS_CONSTANT) {
-                               Z_TYPE_FLAGS_P(z) |= IS_TYPE_IMMUTABLE;
-                       }
+                       Z_TYPE_FLAGS_P(z) &= ~IS_TYPE_REFCOUNTED;
                        break;
                case IS_ARRAY:
                        new_ptr = zend_shared_alloc_get_xlat_entry(Z_ARR_P(z));
                        if (new_ptr) {
                                Z_ARR_P(z) = new_ptr;
-                               Z_TYPE_FLAGS_P(z) = IS_TYPE_IMMUTABLE;
+                               Z_TYPE_FLAGS_P(z) = IS_TYPE_COPYABLE;
                        } else {
-                               if (Z_IMMUTABLE_P(z)) {
+                               if (!Z_REFCOUNTED_P(z)) {
                                        Z_ARR_P(z) = zend_accel_memdup(Z_ARR_P(z), sizeof(zend_array));
                                        zend_hash_persist_immutable(Z_ARRVAL_P(z));
                                } else {
@@ -295,7 +292,7 @@ static void zend_persist_zval(zval *z)
                                        zend_accel_store(Z_ARR_P(z), sizeof(zend_array));
                                        zend_hash_persist(Z_ARRVAL_P(z), zend_persist_zval);
                                        /* make immutable array */
-                                       Z_TYPE_FLAGS_P(z) = IS_TYPE_IMMUTABLE;
+                                       Z_TYPE_FLAGS_P(z) = IS_TYPE_COPYABLE;
                                        GC_REFCOUNT(Z_COUNTED_P(z)) = 2;
                                        GC_FLAGS(Z_COUNTED_P(z)) |= IS_ARRAY_IMMUTABLE;
                                        Z_ARRVAL_P(z)->u.flags |= HASH_FLAG_STATIC_KEYS;
@@ -316,11 +313,11 @@ static void zend_persist_zval(zval *z)
                        new_ptr = zend_shared_alloc_get_xlat_entry(Z_AST_P(z));
                        if (new_ptr) {
                                Z_AST_P(z) = new_ptr;
-                               Z_TYPE_FLAGS_P(z) = IS_TYPE_CONSTANT | IS_TYPE_IMMUTABLE;
+                               Z_TYPE_FLAGS_P(z) = IS_TYPE_CONSTANT | IS_TYPE_COPYABLE;
                        } else {
                                zend_accel_store(Z_AST_P(z), sizeof(zend_ast_ref));
                                Z_ASTVAL_P(z) = zend_persist_ast(Z_ASTVAL_P(z));
-                               Z_TYPE_FLAGS_P(z) = IS_TYPE_CONSTANT | IS_TYPE_IMMUTABLE;
+                               Z_TYPE_FLAGS_P(z) = IS_TYPE_CONSTANT | IS_TYPE_COPYABLE;
                                GC_REFCOUNT(Z_COUNTED_P(z)) = 2;
                        }
                        break;

diff --git a/ext/wddx/wddx.c b/ext/wddx/wddx.c
index f3d72ddadf65b149cc0b4ca635b306b44cccb2bb..6b8e621ccf13e3c9d3b6c3d572555746b1f9ef92 100644 (file)
--- a/ext/wddx/wddx.c
+++ b/ext/wddx/wddx.c
@@ -693,7 +693,7 @@ static void php_wddx_add_var(wddx_packet *packet, zval *name_var)
                        return;
                }
 
-               if (Z_IMMUTABLE_P(name_var)) {
+               if (!Z_REFCOUNTED_P(name_var)) {
                        ZEND_HASH_FOREACH_VAL(target_hash, val) {
                                php_wddx_add_var(packet, val);
                        } ZEND_HASH_FOREACH_END();