Access HashTable.u.flags through HT_FLAGS() macro.

diff --git a/Zend/zend_hash.c b/Zend/zend_hash.c
index fe385dd9c8b6eedaa0f2f3f4bf7ee88a5a01571c..85e7004966702ad711038dbc661ba55ad5fb8ba0 100644 (file)
--- a/Zend/zend_hash.c
+++ b/Zend/zend_hash.c
@@ -26,7 +26,7 @@
 
 #if ZEND_DEBUG
 # define HT_ASSERT(ht, expr) \
-       ZEND_ASSERT((expr) || ((ht)->u.flags & HASH_FLAG_ALLOW_COW_VIOLATION))
+       ZEND_ASSERT((expr) || (HT_FLAGS(ht) & HASH_FLAG_ALLOW_COW_VIOLATION))
 #else
 # define HT_ASSERT(ht, expr)
 #endif
@@ -117,15 +117,15 @@ static zend_always_inline uint32_t zend_hash_check_size(uint32_t nSize)
 static zend_always_inline void zend_hash_real_init_ex(HashTable *ht, int packed)
 {
        HT_ASSERT_RC1(ht);
-       ZEND_ASSERT(!((ht)->u.flags & HASH_FLAG_INITIALIZED));
+       ZEND_ASSERT(!(HT_FLAGS(ht) & HASH_FLAG_INITIALIZED));
        if (packed) {
                HT_SET_DATA_ADDR(ht, pemalloc(HT_SIZE(ht), GC_FLAGS(ht) & IS_ARRAY_PERSISTENT));
-               (ht)->u.flags |= HASH_FLAG_INITIALIZED | HASH_FLAG_PACKED;
+               HT_FLAGS(ht) |= HASH_FLAG_INITIALIZED | HASH_FLAG_PACKED;
                HT_HASH_RESET_PACKED(ht);
        } else {
                (ht)->nTableMask = -(ht)->nTableSize;
                HT_SET_DATA_ADDR(ht, pemalloc(HT_SIZE(ht), GC_FLAGS(ht) & IS_ARRAY_PERSISTENT));
-               (ht)->u.flags |= HASH_FLAG_INITIALIZED;
+               HT_FLAGS(ht) |= HASH_FLAG_INITIALIZED;
                if (EXPECTED(ht->nTableMask == (uint32_t)-8)) {
                        Bucket *arData = ht->arData;
 
@@ -146,7 +146,7 @@ static zend_always_inline void zend_hash_real_init_ex(HashTable *ht, int packed)
 static zend_always_inline void zend_hash_check_init(HashTable *ht, int packed)
 {
        HT_ASSERT_RC1(ht);
-       if (UNEXPECTED(!((ht)->u.flags & HASH_FLAG_INITIALIZED))) {
+       if (UNEXPECTED(!(HT_FLAGS(ht) & HASH_FLAG_INITIALIZED))) {
                zend_hash_real_init_ex(ht, packed);
        }
 }
@@ -175,7 +175,7 @@ static zend_always_inline void _zend_hash_init_int(HashTable *ht, uint32_t nSize
 {
        GC_SET_REFCOUNT(ht, 1);
        GC_TYPE_INFO(ht) = IS_ARRAY | (persistent ? (GC_PERSISTENT << GC_FLAGS_SHIFT) : (GC_COLLECTABLE << GC_FLAGS_SHIFT));
-       ht->u.flags = HASH_FLAG_STATIC_KEYS;
+       HT_FLAGS(ht) = HASH_FLAG_STATIC_KEYS;
        ht->nTableMask = HT_MIN_MASK;
        HT_SET_DATA_ADDR(ht, &uninitialized_bucket);
        ht->nNumUsed = 0;
@@ -222,7 +222,7 @@ ZEND_API void ZEND_FASTCALL zend_hash_packed_to_hash(HashTable *ht)
        Bucket *old_buckets = ht->arData;
 
        HT_ASSERT_RC1(ht);
-       ht->u.flags &= ~HASH_FLAG_PACKED;
+       HT_FLAGS(ht) &= ~HASH_FLAG_PACKED;
        new_data = pemalloc(HT_SIZE_EX(ht->nTableSize, -ht->nTableSize), GC_FLAGS(ht) & IS_ARRAY_PERSISTENT);
        ht->nTableMask = -ht->nTableSize;
        HT_SET_DATA_ADDR(ht, new_data);
@@ -238,7 +238,7 @@ ZEND_API void ZEND_FASTCALL zend_hash_to_packed(HashTable *ht)
 
        HT_ASSERT_RC1(ht);
        new_data = pemalloc(HT_SIZE_EX(ht->nTableSize, HT_MIN_MASK), GC_FLAGS(ht) & IS_ARRAY_PERSISTENT);
-       ht->u.flags |= HASH_FLAG_PACKED | HASH_FLAG_STATIC_KEYS;
+       HT_FLAGS(ht) |= HASH_FLAG_PACKED | HASH_FLAG_STATIC_KEYS;
        ht->nTableMask = HT_MIN_MASK;
        HT_SET_DATA_ADDR(ht, new_data);
        HT_HASH_RESET_PACKED(ht);
@@ -250,20 +250,20 @@ ZEND_API void ZEND_FASTCALL zend_hash_extend(HashTable *ht, uint32_t nSize, zend
 {
        HT_ASSERT_RC1(ht);
        if (nSize == 0) return;
-       if (UNEXPECTED(!((ht)->u.flags & HASH_FLAG_INITIALIZED))) {
+       if (UNEXPECTED(!(HT_FLAGS(ht) & HASH_FLAG_INITIALIZED))) {
                if (nSize > ht->nTableSize) {
                        ht->nTableSize = zend_hash_check_size(nSize);
                }
                zend_hash_check_init(ht, packed);
        } else {
                if (packed) {
-                       ZEND_ASSERT(ht->u.flags & HASH_FLAG_PACKED);
+                       ZEND_ASSERT(HT_FLAGS(ht) & HASH_FLAG_PACKED);
                        if (nSize > ht->nTableSize) {
                                ht->nTableSize = zend_hash_check_size(nSize);
                                HT_SET_DATA_ADDR(ht, perealloc2(HT_GET_DATA_ADDR(ht), HT_SIZE(ht), HT_USED_SIZE(ht), GC_FLAGS(ht) & IS_ARRAY_PERSISTENT));
                        }
                } else {
-                       ZEND_ASSERT(!(ht->u.flags & HASH_FLAG_PACKED));
+                       ZEND_ASSERT(!(HT_FLAGS(ht) & HASH_FLAG_PACKED));
                        if (nSize > ht->nTableSize) {
                                void *new_data, *old_data = HT_GET_DATA_ADDR(ht);
                                Bucket *old_buckets = ht->arData;
@@ -547,19 +547,19 @@ static zend_always_inline zval *_zend_hash_add_or_update_i(HashTable *ht, zend_s
        IS_CONSISTENT(ht);
        HT_ASSERT_RC1(ht);
 
-       if (UNEXPECTED(!(ht->u.flags & HASH_FLAG_INITIALIZED))) {
+       if (UNEXPECTED(!(HT_FLAGS(ht) & HASH_FLAG_INITIALIZED))) {
                CHECK_INIT(ht, 0);
                if (!ZSTR_IS_INTERNED(key)) {
                        zend_string_addref(key);
-                       ht->u.flags &= ~HASH_FLAG_STATIC_KEYS;
+                       HT_FLAGS(ht) &= ~HASH_FLAG_STATIC_KEYS;
                        zend_string_hash_val(key);
                }
                goto add_to_hash;
-       } else if (ht->u.flags & HASH_FLAG_PACKED) {
+       } else if (HT_FLAGS(ht) & HASH_FLAG_PACKED) {
                zend_hash_packed_to_hash(ht);
                if (!ZSTR_IS_INTERNED(key)) {
                        zend_string_addref(key);
-                       ht->u.flags &= ~HASH_FLAG_STATIC_KEYS;
+                       HT_FLAGS(ht) &= ~HASH_FLAG_STATIC_KEYS;
                        zend_string_hash_val(key);
                }
        } else if ((flag & HASH_ADD_NEW) == 0) {
@@ -597,11 +597,11 @@ static zend_always_inline zval *_zend_hash_add_or_update_i(HashTable *ht, zend_s
                }
                if (!ZSTR_IS_INTERNED(key)) {
                        zend_string_addref(key);
-                       ht->u.flags &= ~HASH_FLAG_STATIC_KEYS;
+                       HT_FLAGS(ht) &= ~HASH_FLAG_STATIC_KEYS;
                }
        } else if (!ZSTR_IS_INTERNED(key)) {
                zend_string_addref(key);
-               ht->u.flags &= ~HASH_FLAG_STATIC_KEYS;
+               HT_FLAGS(ht) &= ~HASH_FLAG_STATIC_KEYS;
                zend_string_hash_val(key);
        }
 
@@ -635,10 +635,10 @@ static zend_always_inline zval *_zend_hash_str_add_or_update_i(HashTable *ht, co
        IS_CONSISTENT(ht);
        HT_ASSERT_RC1(ht);
 
-       if (UNEXPECTED(!(ht->u.flags & HASH_FLAG_INITIALIZED))) {
+       if (UNEXPECTED(!(HT_FLAGS(ht) & HASH_FLAG_INITIALIZED))) {
                CHECK_INIT(ht, 0);
                goto add_to_hash;
-       } else if (ht->u.flags & HASH_FLAG_PACKED) {
+       } else if (HT_FLAGS(ht) & HASH_FLAG_PACKED) {
                zend_hash_packed_to_hash(ht);
        } else if ((flag & HASH_ADD_NEW) == 0) {
                p = zend_hash_str_find_bucket(ht, str, len, h);
@@ -687,7 +687,7 @@ add_to_hash:
        p = ht->arData + idx;
        p->key = key = zend_string_init(str, len, GC_FLAGS(ht) & IS_ARRAY_PERSISTENT);
        p->h = ZSTR_H(key) = h;
-       ht->u.flags &= ~HASH_FLAG_STATIC_KEYS;
+       HT_FLAGS(ht) &= ~HASH_FLAG_STATIC_KEYS;
        ZVAL_COPY_VALUE(&p->val, pData);
        nIndex = h | ht->nTableMask;
        Z_NEXT(p->val) = HT_HASH(ht, nIndex);
@@ -789,14 +789,14 @@ static zend_always_inline zval *_zend_hash_index_add_or_update_i(HashTable *ht,
        IS_CONSISTENT(ht);
        HT_ASSERT_RC1(ht);
 
-       if (UNEXPECTED(!(ht->u.flags & HASH_FLAG_INITIALIZED))) {
+       if (UNEXPECTED(!(HT_FLAGS(ht) & HASH_FLAG_INITIALIZED))) {
                CHECK_INIT(ht, h < ht->nTableSize);
                if (h < ht->nTableSize) {
                        p = ht->arData + h;
                        goto add_to_packed;
                }
                goto add_to_hash;
-       } else if (ht->u.flags & HASH_FLAG_PACKED) {
+       } else if (HT_FLAGS(ht) & HASH_FLAG_PACKED) {
                if (h < ht->nNumUsed) {
                        p = ht->arData + h;
                        if (Z_TYPE(p->val) != IS_UNDEF) {
@@ -955,7 +955,7 @@ ZEND_API int ZEND_FASTCALL zend_hash_rehash(HashTable *ht)
        IS_CONSISTENT(ht);
 
        if (UNEXPECTED(ht->nNumOfElements == 0)) {
-               if (ht->u.flags & HASH_FLAG_INITIALIZED) {
+               if (HT_FLAGS(ht) & HASH_FLAG_INITIALIZED) {
                        ht->nNumUsed = 0;
                        HT_HASH_RESET(ht);
                }
@@ -1033,7 +1033,7 @@ ZEND_API int ZEND_FASTCALL zend_hash_rehash(HashTable *ht)
 
 static zend_always_inline void _zend_hash_del_el_ex(HashTable *ht, uint32_t idx, Bucket *p, Bucket *prev)
 {
-       if (!(ht->u.flags & HASH_FLAG_PACKED)) {
+       if (!(HT_FLAGS(ht) & HASH_FLAG_PACKED)) {
                if (prev) {
                        Z_NEXT(prev->val) = Z_NEXT(p->val);
                } else {
@@ -1081,7 +1081,7 @@ static zend_always_inline void _zend_hash_del_el(HashTable *ht, uint32_t idx, Bu
 {
        Bucket *prev = NULL;
 
-       if (!(ht->u.flags & HASH_FLAG_PACKED)) {
+       if (!(HT_FLAGS(ht) & HASH_FLAG_PACKED)) {
                uint32_t nIndex = p->h | ht->nTableMask;
                uint32_t i = HT_HASH(ht, nIndex);
 
@@ -1266,7 +1266,7 @@ ZEND_API int ZEND_FASTCALL zend_hash_index_del(HashTable *ht, zend_ulong h)
        IS_CONSISTENT(ht);
        HT_ASSERT_RC1(ht);
 
-       if (ht->u.flags & HASH_FLAG_PACKED) {
+       if (HT_FLAGS(ht) & HASH_FLAG_PACKED) {
                if (h < ht->nNumUsed) {
                        p = ht->arData + h;
                        if (Z_TYPE(p->val) != IS_UNDEF) {
@@ -1347,7 +1347,7 @@ ZEND_API void ZEND_FASTCALL zend_hash_destroy(HashTable *ht)
                        }
                }
                zend_hash_iterators_remove(ht);
-       } else if (EXPECTED(!(ht->u.flags & HASH_FLAG_INITIALIZED))) {
+       } else if (EXPECTED(!(HT_FLAGS(ht) & HASH_FLAG_INITIALIZED))) {
                return;
        }
        pefree(HT_GET_DATA_ADDR(ht), GC_FLAGS(ht) & IS_ARRAY_PERSISTENT);
@@ -1398,7 +1398,7 @@ ZEND_API void ZEND_FASTCALL zend_array_destroy(HashTable *ht)
                }
                zend_hash_iterators_remove(ht);
                SET_INCONSISTENT(HT_DESTROYED);
-       } else if (EXPECTED(!(ht->u.flags & HASH_FLAG_INITIALIZED))) {
+       } else if (EXPECTED(!(HT_FLAGS(ht) & HASH_FLAG_INITIALIZED))) {
                goto free_ht;
        }
        efree(HT_GET_DATA_ADDR(ht));
@@ -1465,7 +1465,7 @@ ZEND_API void ZEND_FASTCALL zend_hash_clean(HashTable *ht)
                                }
                        }
                }
-               if (!(ht->u.flags & HASH_FLAG_PACKED)) {
+               if (!(HT_FLAGS(ht) & HASH_FLAG_PACKED)) {
                        HT_HASH_RESET(ht);
                }
        }
@@ -1527,7 +1527,7 @@ ZEND_API void ZEND_FASTCALL zend_hash_graceful_destroy(HashTable *ht)
                if (UNEXPECTED(Z_TYPE(p->val) == IS_UNDEF)) continue;
                _zend_hash_del_el(ht, HT_IDX_TO_HASH(idx), p);
        }
-       if (ht->u.flags & HASH_FLAG_INITIALIZED) {
+       if (HT_FLAGS(ht) & HASH_FLAG_INITIALIZED) {
                pefree(HT_GET_DATA_ADDR(ht), GC_FLAGS(ht) & IS_ARRAY_PERSISTENT);
        }
 
@@ -1551,7 +1551,7 @@ ZEND_API void ZEND_FASTCALL zend_hash_graceful_reverse_destroy(HashTable *ht)
                _zend_hash_del_el(ht, HT_IDX_TO_HASH(idx), p);
        }
 
-       if (ht->u.flags & HASH_FLAG_INITIALIZED) {
+       if (HT_FLAGS(ht) & HASH_FLAG_INITIALIZED) {
                pefree(HT_GET_DATA_ADDR(ht), GC_FLAGS(ht) & IS_ARRAY_PERSISTENT);
        }
 
@@ -1833,7 +1833,7 @@ ZEND_API HashTable* ZEND_FASTCALL zend_array_dup(HashTable *source)
        target->pDestructor = source->pDestructor;
 
        if (source->nNumUsed == 0) {
-               target->u.flags = (source->u.flags & ~(HASH_FLAG_INITIALIZED|HASH_FLAG_PACKED)) | HASH_FLAG_STATIC_KEYS;
+               HT_FLAGS(target) = (HT_FLAGS(source) & ~(HASH_FLAG_INITIALIZED|HASH_FLAG_PACKED)) | HASH_FLAG_STATIC_KEYS;
                target->nTableMask = HT_MIN_MASK;
                target->nNumUsed = 0;
                target->nNumOfElements = 0;
@@ -1841,7 +1841,7 @@ ZEND_API HashTable* ZEND_FASTCALL zend_array_dup(HashTable *source)
                target->nInternalPointer = HT_INVALID_IDX;
                HT_SET_DATA_ADDR(target, &uninitialized_bucket);
        } else if (GC_FLAGS(source) & IS_ARRAY_IMMUTABLE) {
-               target->u.flags = source->u.flags;
+               HT_FLAGS(target) = HT_FLAGS(source);
                target->nTableMask = source->nTableMask;
                target->nNumUsed = source->nNumUsed;
                target->nNumOfElements = source->nNumOfElements;
@@ -1857,8 +1857,8 @@ ZEND_API HashTable* ZEND_FASTCALL zend_array_dup(HashTable *source)
                        }
                        target->nInternalPointer = idx;
                }
-       } else if (source->u.flags & HASH_FLAG_PACKED) {
-               target->u.flags = source->u.flags;
+       } else if (HT_FLAGS(source) & HASH_FLAG_PACKED) {
+               HT_FLAGS(target) = HT_FLAGS(source);
                target->nTableMask = source->nTableMask;
                target->nNumUsed = source->nNumUsed;
                target->nNumOfElements = source->nNumOfElements;
@@ -1881,7 +1881,7 @@ ZEND_API HashTable* ZEND_FASTCALL zend_array_dup(HashTable *source)
                        target->nInternalPointer = idx;
                }
        } else {
-               target->u.flags = source->u.flags;
+               HT_FLAGS(target) = HT_FLAGS(source);
                target->nTableMask = source->nTableMask;
                target->nNextFreeElement = source->nNextFreeElement;
                target->nInternalPointer = source->nInternalPointer;
@@ -2074,7 +2074,7 @@ ZEND_API zval* ZEND_FASTCALL zend_hash_index_find(const HashTable *ht, zend_ulon
 
        IS_CONSISTENT(ht);
 
-       if (ht->u.flags & HASH_FLAG_PACKED) {
+       if (HT_FLAGS(ht) & HASH_FLAG_PACKED) {
                if (h < ht->nNumUsed) {
                        p = ht->arData + h;
                        if (Z_TYPE(p->val) != IS_UNDEF) {
@@ -2104,7 +2104,7 @@ ZEND_API zend_bool ZEND_FASTCALL zend_hash_index_exists(const HashTable *ht, zen
 
        IS_CONSISTENT(ht);
 
-       if (ht->u.flags & HASH_FLAG_PACKED) {
+       if (HT_FLAGS(ht) & HASH_FLAG_PACKED) {
                if (h < ht->nNumUsed) {
                        if (Z_TYPE(ht->arData[h].val) != IS_UNDEF) {
                                return 1;
@@ -2344,7 +2344,7 @@ ZEND_API int ZEND_FASTCALL zend_hash_sort_ex(HashTable *ht, sort_func_t sort, co
 
        sort((void *)ht->arData, i, sizeof(Bucket), compar,
                        (swap_func_t)(renumber? zend_hash_bucket_renum_swap :
-                               ((ht->u.flags & HASH_FLAG_PACKED) ? zend_hash_bucket_packed_swap : zend_hash_bucket_swap)));
+                               ((HT_FLAGS(ht) & HASH_FLAG_PACKED) ? zend_hash_bucket_packed_swap : zend_hash_bucket_swap)));
 
        ht->nNumUsed = i;
        ht->nInternalPointer = 0;
@@ -2361,7 +2361,7 @@ ZEND_API int ZEND_FASTCALL zend_hash_sort_ex(HashTable *ht, sort_func_t sort, co
 
                ht->nNextFreeElement = i;
        }
-       if (ht->u.flags & HASH_FLAG_PACKED) {
+       if (HT_FLAGS(ht) & HASH_FLAG_PACKED) {
                if (!renumber) {
                        zend_hash_packed_to_hash(ht);
                }
@@ -2371,7 +2371,7 @@ ZEND_API int ZEND_FASTCALL zend_hash_sort_ex(HashTable *ht, sort_func_t sort, co
                        Bucket *old_buckets = ht->arData;
 
                        new_data = pemalloc(HT_SIZE_EX(ht->nTableSize, HT_MIN_MASK), (GC_FLAGS(ht) & IS_ARRAY_PERSISTENT));
-                       ht->u.flags |= HASH_FLAG_PACKED | HASH_FLAG_STATIC_KEYS;
+                       HT_FLAGS(ht) |= HASH_FLAG_PACKED | HASH_FLAG_STATIC_KEYS;
                        ht->nTableMask = HT_MIN_MASK;
                        HT_SET_DATA_ADDR(ht, new_data);
                        memcpy(ht->arData, old_buckets, sizeof(Bucket) * ht->nNumUsed);

diff --git a/Zend/zend_hash.h b/Zend/zend_hash.h
index 3c9e22cb85ef5bc2db7dbe90e0ba7707b16b5a3f..7e0fb61ae6bbd55dd835b5d7ea0f166142af92ad 100644 (file)
--- a/Zend/zend_hash.h
+++ b/Zend/zend_hash.h
@@ -41,17 +41,19 @@
 #define HASH_FLAG_HAS_EMPTY_IND    (1<<5)
 #define HASH_FLAG_ALLOW_COW_VIOLATION (1<<6)
 
+#define HT_FLAGS(ht) (ht)->u.flags
+
 #define HT_IS_PACKED(ht) \
-       (((ht)->u.flags & HASH_FLAG_PACKED) != 0)
+       ((HT_FLAGS(ht) & HASH_FLAG_PACKED) != 0)
 
 #define HT_IS_WITHOUT_HOLES(ht) \
        ((ht)->nNumUsed == (ht)->nNumOfElements)
 
 #define HT_HAS_STATIC_KEYS_ONLY(ht) \
-       (((ht)->u.flags & (HASH_FLAG_PACKED|HASH_FLAG_STATIC_KEYS)) != 0)
+       ((HT_FLAGS(ht) & (HASH_FLAG_PACKED|HASH_FLAG_STATIC_KEYS)) != 0)
 
 #if ZEND_DEBUG
-# define HT_ALLOW_COW_VIOLATION(ht) (ht)->u.flags |= HASH_FLAG_ALLOW_COW_VIOLATION
+# define HT_ALLOW_COW_VIOLATION(ht) HT_FLAGS(ht) |= HASH_FLAG_ALLOW_COW_VIOLATION
 #else
 # define HT_ALLOW_COW_VIOLATION(ht)
 #endif
@@ -192,7 +194,7 @@ static zend_always_inline zval *zend_hash_find_ex(const HashTable *ht, zend_stri
 }
 
 #define ZEND_HASH_INDEX_FIND(_ht, _h, _ret, _not_found) do { \
-               if (EXPECTED((_ht)->u.flags & HASH_FLAG_PACKED)) { \
+               if (EXPECTED(HT_FLAGS(_ht) & HASH_FLAG_PACKED)) { \
                        if (EXPECTED((zend_ulong)(_h) < (zend_ulong)(_ht)->nNumUsed)) { \
                                _ret = &_ht->arData[_h].val; \
                                if (UNEXPECTED(Z_TYPE_P(_ret) == IS_UNDEF)) { \
@@ -1063,7 +1065,7 @@ static zend_always_inline void *zend_hash_get_current_data_ptr_ex(HashTable *ht,
                HashTable *__fill_ht = (ht); \
                Bucket *__fill_bkt = __fill_ht->arData + __fill_ht->nNumUsed; \
                uint32_t __fill_idx = __fill_ht->nNumUsed; \
-               ZEND_ASSERT(__fill_ht->u.flags & HASH_FLAG_PACKED);
+               ZEND_ASSERT(HT_FLAGS(__fill_ht) & HASH_FLAG_PACKED);
 
 #define ZEND_HASH_FILL_ADD(_val) do { \
                ZVAL_COPY_VALUE(&__fill_bkt->val, _val); \
@@ -1088,7 +1090,7 @@ static zend_always_inline zval *_zend_hash_append(HashTable *ht, zend_string *ke
 
        ZVAL_COPY_VALUE(&p->val, zv);
        if (!ZSTR_IS_INTERNED(key)) {
-               ht->u.flags &= ~HASH_FLAG_STATIC_KEYS;
+               HT_FLAGS(ht) &= ~HASH_FLAG_STATIC_KEYS;
                zend_string_addref(key);
                zend_string_hash_val(key);
        }
@@ -1110,7 +1112,7 @@ static zend_always_inline zval *_zend_hash_append_ptr(HashTable *ht, zend_string
 
        ZVAL_PTR(&p->val, ptr);
        if (!ZSTR_IS_INTERNED(key)) {
-               ht->u.flags &= ~HASH_FLAG_STATIC_KEYS;
+               HT_FLAGS(ht) &= ~HASH_FLAG_STATIC_KEYS;
                zend_string_addref(key);
                zend_string_hash_val(key);
        }
@@ -1132,7 +1134,7 @@ static zend_always_inline void _zend_hash_append_ind(HashTable *ht, zend_string
 
        ZVAL_INDIRECT(&p->val, ptr);
        if (!ZSTR_IS_INTERNED(key)) {
-               ht->u.flags &= ~HASH_FLAG_STATIC_KEYS;
+               HT_FLAGS(ht) &= ~HASH_FLAG_STATIC_KEYS;
                zend_string_addref(key);
                zend_string_hash_val(key);
        }

diff --git a/ext/opcache/zend_accelerator_util_funcs.c b/ext/opcache/zend_accelerator_util_funcs.c
index 1e9b5e9868cd2abeb4e54f52116ebe706f173a49..5901b838204b11bc98d5a1615a924814e325c360 100644 (file)
--- a/ext/opcache/zend_accelerator_util_funcs.c
+++ b/ext/opcache/zend_accelerator_util_funcs.c
@@ -180,15 +180,15 @@ static void zend_hash_clone_constants(HashTable *ht, HashTable *source)
        ht->nNumOfElements = source->nNumOfElements;
        ht->nNextFreeElement = source->nNextFreeElement;
        ht->pDestructor = ZVAL_PTR_DTOR;
-       ht->u.flags = (source->u.flags & HASH_FLAG_INITIALIZED);
+       HT_FLAGS(ht) = (HT_FLAGS(source) & HASH_FLAG_INITIALIZED);
        ht->nInternalPointer = source->nNumOfElements ? 0 : HT_INVALID_IDX;
 
-       if (!(ht->u.flags & HASH_FLAG_INITIALIZED)) {
+       if (!(HT_FLAGS(ht) & HASH_FLAG_INITIALIZED)) {
                ht->arData = source->arData;
                return;
        }
 
-       ZEND_ASSERT((source->u.flags & HASH_FLAG_PACKED) == 0);
+       ZEND_ASSERT((HT_FLAGS(source) & HASH_FLAG_PACKED) == 0);
        HT_SET_DATA_ADDR(ht, emalloc(HT_SIZE(ht)));
        HT_HASH_RESET(ht);
 
@@ -231,15 +231,15 @@ static void zend_hash_clone_methods(HashTable *ht, HashTable *source, zend_class
        ht->nNumOfElements = source->nNumOfElements;
        ht->nNextFreeElement = source->nNextFreeElement;
        ht->pDestructor = ZEND_FUNCTION_DTOR;
-       ht->u.flags = (source->u.flags & HASH_FLAG_INITIALIZED);
+       HT_FLAGS(ht) = (HT_FLAGS(source) & HASH_FLAG_INITIALIZED);
        ht->nInternalPointer = source->nNumOfElements ? 0 : HT_INVALID_IDX;
 
-       if (!(ht->u.flags & HASH_FLAG_INITIALIZED)) {
+       if (!(HT_FLAGS(ht) & HASH_FLAG_INITIALIZED)) {
                ht->arData = source->arData;
                return;
        }
 
-       ZEND_ASSERT(!(source->u.flags & HASH_FLAG_PACKED));
+       ZEND_ASSERT(!(HT_FLAGS(source) & HASH_FLAG_PACKED));
        HT_SET_DATA_ADDR(ht, emalloc(HT_SIZE(ht)));
        HT_HASH_RESET(ht);
 
@@ -289,15 +289,15 @@ static void zend_hash_clone_prop_info(HashTable *ht, HashTable *source, zend_cla
        ht->nNumOfElements = source->nNumOfElements;
        ht->nNextFreeElement = source->nNextFreeElement;
        ht->pDestructor = NULL;
-       ht->u.flags = (source->u.flags & HASH_FLAG_INITIALIZED);
+       HT_FLAGS(ht) = (HT_FLAGS(source) & HASH_FLAG_INITIALIZED);
        ht->nInternalPointer = source->nNumOfElements ? 0 : HT_INVALID_IDX;
 
-       if (!(ht->u.flags & HASH_FLAG_INITIALIZED)) {
+       if (!(HT_FLAGS(ht) & HASH_FLAG_INITIALIZED)) {
                ht->arData = source->arData;
                return;
        }
 
-       ZEND_ASSERT(!(source->u.flags & HASH_FLAG_PACKED));
+       ZEND_ASSERT(!(HT_FLAGS(source) & HASH_FLAG_PACKED));
        HT_SET_DATA_ADDR(ht, emalloc(HT_SIZE(ht)));
        HT_HASH_RESET(ht);
 

diff --git a/ext/opcache/zend_file_cache.c b/ext/opcache/zend_file_cache.c
index 047abcb91c0a0c7831bf62c6747f308070dd16c4..c11bff3868c3f15346c86ff3e69294edf3cf1801 100644 (file)
--- a/ext/opcache/zend_file_cache.c
+++ b/ext/opcache/zend_file_cache.c
@@ -255,7 +255,7 @@ static void zend_file_cache_serialize_hash(HashTable                *ht,
 {
        Bucket *p, *end;
 
-       if (!(ht->u.flags & HASH_FLAG_INITIALIZED)) {
+       if (!(HT_FLAGS(ht) & HASH_FLAG_INITIALIZED)) {
                ht->arData = NULL;
                return;
        }
@@ -880,7 +880,7 @@ static void zend_file_cache_unserialize_hash(HashTable               *ht,
        Bucket *p, *end;
 
        ht->pDestructor = dtor;
-       if (!(ht->u.flags & HASH_FLAG_INITIALIZED)) {
+       if (!(HT_FLAGS(ht) & HASH_FLAG_INITIALIZED)) {
                HT_SET_DATA_ADDR(ht, &uninitialized_bucket);
                return;
        }

diff --git a/ext/opcache/zend_persist.c b/ext/opcache/zend_persist.c
index 010cc9b533c362481c9e6991629b4e18cf574d7f..f292ce09b05911ddc1881bb473102f46b595958d 100644 (file)
--- a/ext/opcache/zend_persist.c
+++ b/ext/opcache/zend_persist.c
@@ -86,7 +86,7 @@ static void zend_hash_persist(HashTable *ht, zend_persist_func_t pPersistElement
        uint32_t idx, nIndex;
        Bucket *p;
 
-       if (!(ht->u.flags & HASH_FLAG_INITIALIZED)) {
+       if (!(HT_FLAGS(ht) & HASH_FLAG_INITIALIZED)) {
                HT_SET_DATA_ADDR(ht, &uninitialized_bucket);
                return;
        }
@@ -94,10 +94,10 @@ static void zend_hash_persist(HashTable *ht, zend_persist_func_t pPersistElement
                efree(HT_GET_DATA_ADDR(ht));
                ht->nTableMask = HT_MIN_MASK;
                HT_SET_DATA_ADDR(ht, &uninitialized_bucket);
-               ht->u.flags &= ~HASH_FLAG_INITIALIZED;
+               HT_FLAGS(ht) &= ~HASH_FLAG_INITIALIZED;
                return;
        }
-       if (ht->u.flags & HASH_FLAG_PACKED) {
+       if (HT_FLAGS(ht) & HASH_FLAG_PACKED) {
                void *data = HT_GET_DATA_ADDR(ht);
                zend_accel_store(data, HT_USED_SIZE(ht));
                HT_SET_DATA_ADDR(ht, data);
@@ -170,7 +170,7 @@ static void zend_hash_persist_immutable(HashTable *ht)
        uint32_t idx, nIndex;
        Bucket *p;
 
-       if (!(ht->u.flags & HASH_FLAG_INITIALIZED)) {
+       if (!(HT_FLAGS(ht) & HASH_FLAG_INITIALIZED)) {
                HT_SET_DATA_ADDR(ht, &uninitialized_bucket);
                return;
        }
@@ -178,10 +178,10 @@ static void zend_hash_persist_immutable(HashTable *ht)
                efree(HT_GET_DATA_ADDR(ht));
                ht->nTableMask = HT_MIN_MASK;
                HT_SET_DATA_ADDR(ht, &uninitialized_bucket);
-               ht->u.flags &= ~HASH_FLAG_INITIALIZED;
+               HT_FLAGS(ht) &= ~HASH_FLAG_INITIALIZED;
                return;
        }
-       if (ht->u.flags & HASH_FLAG_PACKED) {
+       if (HT_FLAGS(ht) & HASH_FLAG_PACKED) {
                HT_SET_DATA_ADDR(ht, zend_accel_memdup(HT_GET_DATA_ADDR(ht), HT_USED_SIZE(ht)));
        } else if (ht->nNumUsed < (uint32_t)(-(int32_t)ht->nTableMask) / 2) {
                /* compact table */
@@ -302,7 +302,7 @@ static void zend_persist_zval(zval *z)
                                        Z_TYPE_FLAGS_P(z) = 0;
                                        GC_SET_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;
+                                       HT_FLAGS(Z_ARRVAL_P(z)) |= HASH_FLAG_STATIC_KEYS;
                                }
                        }
                        break;
@@ -368,7 +368,7 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc
                        /* make immutable array */
                        GC_SET_REFCOUNT(op_array->static_variables, 2);
                        GC_TYPE_INFO(op_array->static_variables) = IS_ARRAY | (IS_ARRAY_IMMUTABLE << GC_FLAGS_SHIFT);
-                       op_array->static_variables->u.flags |= HASH_FLAG_STATIC_KEYS;
+                       HT_FLAGS(op_array->static_variables) |= HASH_FLAG_STATIC_KEYS;
                }
        }
 

diff --git a/ext/opcache/zend_persist_calc.c b/ext/opcache/zend_persist_calc.c
index 87ce9375eb923f5cebc5e2d5d47dfcbe75b20636..eb802325b0c96c8095c13dfa34289652686d3ecc 100644 (file)
--- a/ext/opcache/zend_persist_calc.c
+++ b/ext/opcache/zend_persist_calc.c
@@ -56,11 +56,11 @@ static void zend_hash_persist_calc(HashTable *ht, void (*pPersistElement)(zval *
        uint32_t idx;
        Bucket *p;
 
-       if (!(ht->u.flags & HASH_FLAG_INITIALIZED) || ht->nNumUsed == 0) {
+       if (!(HT_FLAGS(ht) & HASH_FLAG_INITIALIZED) || ht->nNumUsed == 0) {
                return;
        }
 
-       if (!(ht->u.flags & HASH_FLAG_PACKED) && ht->nNumUsed < (uint32_t)(-(int32_t)ht->nTableMask) / 2) {
+       if (!(HT_FLAGS(ht) & HASH_FLAG_PACKED) && ht->nNumUsed < (uint32_t)(-(int32_t)ht->nTableMask) / 2) {
                /* compact table */
                uint32_t hash_size;
 

diff --git a/ext/phar/dirstream.c b/ext/phar/dirstream.c
index 532d9100101222dc38cd2a8075a89e8365069b38..7cdf698d7731e9aaad2d4bfed381cc7e4e23f694 100644 (file)
--- a/ext/phar/dirstream.c
+++ b/ext/phar/dirstream.c
@@ -44,9 +44,9 @@ static int phar_dir_close(php_stream *stream, int close_handle)  /* {{{ */
 {
        HashTable *data = (HashTable *)stream->abstract;
 
-       if (data && data->u.flags) {
+       if (data && HT_FLAGS(data)) {
                zend_hash_destroy(data);
-               data->u.flags = 0;
+               HT_FLAGS(data) = 0;
                FREE_HASHTABLE(data);
                stream->abstract = NULL;
        }
@@ -361,7 +361,7 @@ php_stream *phar_wrapper_open_dir(php_stream_wrapper *wrapper, const char *path,
                return ret;
        }
 
-       if (!phar->manifest.u.flags) {
+       if (!HT_FLAGS(&phar->manifest)) {
                php_url_free(resource);
                return NULL;
        }

diff --git a/ext/phar/func_interceptors.c b/ext/phar/func_interceptors.c
index c0ec38e13e4f634207950236b4c191c67e4a1f9e..a592ca4f45cea34d49271b6b9a4e02ff2f5bfb6a 100644 (file)
--- a/ext/phar/func_interceptors.c
+++ b/ext/phar/func_interceptors.c
@@ -33,8 +33,8 @@ PHAR_FUNC(phar_opendir) /* {{{ */
                goto skip_phar;
        }
 
-       if ((PHAR_G(phar_fname_map.u.flags) && !zend_hash_num_elements(&(PHAR_G(phar_fname_map))))
-               && !cached_phars.u.flags) {
+       if ((HT_FLAGS(&PHAR_G(phar_fname_map)) && !zend_hash_num_elements(&(PHAR_G(phar_fname_map))))
+               && !HT_FLAGS(&cached_phars)) {
                goto skip_phar;
        }
 
@@ -106,8 +106,8 @@ PHAR_FUNC(phar_file_get_contents) /* {{{ */
                goto skip_phar;
        }
 
-       if ((PHAR_G(phar_fname_map.u.flags) && !zend_hash_num_elements(&(PHAR_G(phar_fname_map))))
-               && !cached_phars.u.flags) {
+       if ((HT_FLAGS(&PHAR_G(phar_fname_map)) && !zend_hash_num_elements(&(PHAR_G(phar_fname_map))))
+               && !HT_FLAGS(&cached_phars)) {
                goto skip_phar;
        }
 
@@ -239,8 +239,8 @@ PHAR_FUNC(phar_readfile) /* {{{ */
                goto skip_phar;
        }
 
-       if ((PHAR_G(phar_fname_map.u.flags) && !zend_hash_num_elements(&(PHAR_G(phar_fname_map))))
-               && !cached_phars.u.flags) {
+       if ((HT_FLAGS(&PHAR_G(phar_fname_map)) && !zend_hash_num_elements(&(PHAR_G(phar_fname_map))))
+               && !HT_FLAGS(&cached_phars)) {
                goto skip_phar;
        }
        if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS(), "p|br!", &filename, &filename_len, &use_include_path, &zcontext) == FAILURE) {
@@ -339,8 +339,8 @@ PHAR_FUNC(phar_fopen) /* {{{ */
                goto skip_phar;
        }
 
-       if ((PHAR_G(phar_fname_map.u.flags) && !zend_hash_num_elements(&(PHAR_G(phar_fname_map))))
-               && !cached_phars.u.flags) {
+       if ((HT_FLAGS(&PHAR_G(phar_fname_map)) && !zend_hash_num_elements(&(PHAR_G(phar_fname_map))))
+               && !HT_FLAGS(&cached_phars)) {
                /* no need to check, include_path not even specified in fopen/ no active phars */
                goto skip_phar;
        }
@@ -854,8 +854,8 @@ PHAR_FUNC(phar_is_file) /* {{{ */
                goto skip_phar;
        }
 
-       if ((PHAR_G(phar_fname_map.u.flags) && !zend_hash_num_elements(&(PHAR_G(phar_fname_map))))
-               && !cached_phars.u.flags) {
+       if ((HT_FLAGS(&PHAR_G(phar_fname_map)) && !zend_hash_num_elements(&(PHAR_G(phar_fname_map))))
+               && !HT_FLAGS(&cached_phars)) {
                goto skip_phar;
        }
        if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS(), "p", &filename, &filename_len) == FAILURE) {
@@ -921,8 +921,8 @@ PHAR_FUNC(phar_is_link) /* {{{ */
                goto skip_phar;
        }
 
-       if ((PHAR_G(phar_fname_map.u.flags) && !zend_hash_num_elements(&(PHAR_G(phar_fname_map))))
-               && !cached_phars.u.flags) {
+       if ((HT_FLAGS(&PHAR_G(phar_fname_map)) && !zend_hash_num_elements(&(PHAR_G(phar_fname_map))))
+               && !HT_FLAGS(&cached_phars)) {
                goto skip_phar;
        }
        if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS(), "p", &filename, &filename_len) == FAILURE) {

diff --git a/ext/phar/phar.c b/ext/phar/phar.c
index bc9db24bf870d9c205caa1ebdf582661d204b618..853f24f89ba24e30c3ec4620713608e92611378a 100644 (file)
--- a/ext/phar/phar.c
+++ b/ext/phar/phar.c
@@ -82,7 +82,7 @@ ZEND_INI_MH(phar_ini_modify_handler) /* {{{ */
 
        if (ZSTR_LEN(entry->name) == sizeof("phar.readonly")-1) {
                PHAR_G(readonly) = ini;
-               if (PHAR_G(request_init) && PHAR_G(phar_fname_map.u.flags)) {
+               if (PHAR_G(request_init) && HT_FLAGS(&PHAR_G(phar_fname_map))) {
                        zend_hash_apply_with_argument(&(PHAR_G(phar_fname_map)), phar_set_writeable_bit, (void *)&ini);
                }
        } else {
@@ -146,9 +146,9 @@ finish_error:
                                PHAR_G(manifest_cached) = 0;
                                efree(tmp);
                                zend_hash_destroy(&(PHAR_G(phar_fname_map)));
-                               PHAR_G(phar_fname_map.u.flags) = 0;
+                               HT_FLAGS(&PHAR_G(phar_fname_map)) = 0;
                                zend_hash_destroy(&(PHAR_G(phar_alias_map)));
-                               PHAR_G(phar_alias_map.u.flags) = 0;
+                               HT_FLAGS(&PHAR_G(phar_alias_map)) = 0;
                                zend_hash_destroy(&cached_phars);
                                zend_hash_destroy(&cached_alias);
                                zend_hash_graceful_reverse_destroy(&EG(regular_list));
@@ -173,8 +173,8 @@ finish_error:
        zend_hash_destroy(&cached_alias);
        cached_phars = PHAR_G(phar_fname_map);
        cached_alias = PHAR_G(phar_alias_map);
-       PHAR_G(phar_fname_map.u.flags) = 0;
-       PHAR_G(phar_alias_map.u.flags) = 0;
+       HT_FLAGS(&PHAR_G(phar_fname_map)) = 0;
+       HT_FLAGS(&PHAR_G(phar_alias_map)) = 0;
        zend_hash_graceful_reverse_destroy(&EG(regular_list));
        memset(&EG(regular_list), 0, sizeof(HashTable));
        efree(tmp);
@@ -220,19 +220,19 @@ void phar_destroy_phar_data(phar_archive_data *phar) /* {{{ */
                phar->signature = NULL;
        }
 
-       if (phar->manifest.u.flags) {
+       if (HT_FLAGS(&phar->manifest)) {
                zend_hash_destroy(&phar->manifest);
-               phar->manifest.u.flags = 0;
+               HT_FLAGS(&phar->manifest) = 0;
        }
 
-       if (phar->mounted_dirs.u.flags) {
+       if (HT_FLAGS(&phar->mounted_dirs)) {
                zend_hash_destroy(&phar->mounted_dirs);
-               phar->mounted_dirs.u.flags = 0;
+               HT_FLAGS(&phar->mounted_dirs) = 0;
        }
 
-       if (phar->virtual_dirs.u.flags) {
+       if (HT_FLAGS(&phar->virtual_dirs)) {
                zend_hash_destroy(&phar->virtual_dirs);
-               phar->virtual_dirs.u.flags = 0;
+               HT_FLAGS(&phar->virtual_dirs) = 0;
        }
 
        if (Z_TYPE(phar->metadata) != IS_UNDEF) {
@@ -3515,11 +3515,11 @@ PHP_RSHUTDOWN_FUNCTION(phar) /* {{{ */
        {
                phar_release_functions();
                zend_hash_destroy(&(PHAR_G(phar_alias_map)));
-               PHAR_G(phar_alias_map.u.flags) = 0;
+               HT_FLAGS(&PHAR_G(phar_alias_map)) = 0;
                zend_hash_destroy(&(PHAR_G(phar_fname_map)));
-               PHAR_G(phar_fname_map.u.flags) = 0;
+               HT_FLAGS(&PHAR_G(phar_fname_map)) = 0;
                zend_hash_destroy(&(PHAR_G(phar_persist_map)));
-               PHAR_G(phar_persist_map.u.flags) = 0;
+               HT_FLAGS(&PHAR_G(phar_persist_map)) = 0;
                PHAR_G(phar_SERVER_mung_list) = 0;
 
                if (PHAR_G(cached_fp)) {

diff --git a/ext/phar/phar_object.c b/ext/phar/phar_object.c
index 0e114875c2cdb30f10e2ef08703c0c2acea6ac2f..47f57372433bd552343a528a6a7649a13dc9e44c 100644 (file)
--- a/ext/phar/phar_object.c
+++ b/ext/phar/phar_object.c
@@ -512,7 +512,7 @@ carry_on:
                }
 
                return;
-       } else if (PHAR_G(phar_fname_map.u.flags) && NULL != (pphar = zend_hash_str_find_ptr(&(PHAR_G(phar_fname_map)), fname, fname_len))) {
+       } else if (HT_FLAGS(&PHAR_G(phar_fname_map)) && NULL != (pphar = zend_hash_str_find_ptr(&(PHAR_G(phar_fname_map)), fname, fname_len))) {
                goto carry_on;
        } else if (PHAR_G(manifest_cached) && NULL != (pphar = zend_hash_str_find_ptr(&cached_phars, fname, fname_len))) {
                if (SUCCESS == phar_copy_on_write(&pphar)) {

diff --git a/ext/phar/stream.c b/ext/phar/stream.c
index 0100bc74d984df0566f97e09d04a70332a66740f..4dcd4fd7e3d211934c4d095d00d3fc3838e6e8c1 100644 (file)
--- a/ext/phar/stream.c
+++ b/ext/phar/stream.c
@@ -106,7 +106,7 @@ php_url* phar_parse_url(php_stream_wrapper *wrapper, const char *filename, const
        if (mode[0] == 'w' || (mode[0] == 'r' && mode[1] == '+')) {
                phar_archive_data *pphar = NULL, *phar;
 
-               if (PHAR_G(request_init) && PHAR_G(phar_fname_map.u.flags) && NULL == (pphar = zend_hash_find_ptr(&(PHAR_G(phar_fname_map)), resource->host))) {
+               if (PHAR_G(request_init) && HT_FLAGS(&PHAR_G(phar_fname_map)) && NULL == (pphar = zend_hash_find_ptr(&(PHAR_G(phar_fname_map)), resource->host))) {
                        pphar = NULL;
                }
                if (PHAR_G(readonly) && (!pphar || !pphar->is_data)) {
@@ -597,7 +597,7 @@ static int phar_wrapper_stat(php_stream_wrapper *wrapper, const char *url, int f
                php_url_free(resource);
                return SUCCESS;
        }
-       if (!phar->manifest.u.flags) {
+       if (!HT_FLAGS(&phar->manifest)) {
                php_url_free(resource);
                return FAILURE;
        }
@@ -614,7 +614,7 @@ static int phar_wrapper_stat(php_stream_wrapper *wrapper, const char *url, int f
                return SUCCESS;
        }
        /* check for mounted directories */
-       if (phar->mounted_dirs.u.flags && zend_hash_num_elements(&phar->mounted_dirs)) {
+       if (HT_FLAGS(&phar->mounted_dirs) && zend_hash_num_elements(&phar->mounted_dirs)) {
                zend_string *str_key;
 
                ZEND_HASH_FOREACH_STR_KEY(&phar->mounted_dirs, str_key) {

diff --git a/ext/phar/util.c b/ext/phar/util.c
index f47b908e00374d61642641180ea2f0fa6e626cf4..a2cd6e08c9eee396c022bdf307ca1f1696aedfc6 100644 (file)
--- a/ext/phar/util.c
+++ b/ext/phar/util.c
@@ -922,7 +922,7 @@ phar_entry_info * phar_open_jit(phar_archive_data *phar, phar_entry_info *entry,
 
 PHP_PHAR_API int phar_resolve_alias(char *alias, int alias_len, char **filename, int *filename_len) /* {{{ */ {
        phar_archive_data *fd_ptr;
-       if (PHAR_G(phar_alias_map.u.flags)
+       if (HT_FLAGS(&PHAR_G(phar_alias_map))
                        && NULL != (fd_ptr = zend_hash_str_find_ptr(&(PHAR_G(phar_alias_map)), alias, alias_len))) {
                *filename = fd_ptr->fname;
                *filename_len = fd_ptr->fname_len;
@@ -1246,7 +1246,7 @@ phar_entry_info *phar_get_entry_info_dir(phar_archive_data *phar, char *path, in
                return NULL;
        }
 
-       if (!phar->manifest.u.flags) {
+       if (!HT_FLAGS(&phar->manifest)) {
                return NULL;
        }
 
@@ -1291,7 +1291,7 @@ phar_entry_info *phar_get_entry_info_dir(phar_archive_data *phar, char *path, in
                }
        }
 
-       if (phar->mounted_dirs.u.flags && zend_hash_num_elements(&phar->mounted_dirs)) {
+       if (HT_FLAGS(&phar->mounted_dirs) && zend_hash_num_elements(&phar->mounted_dirs)) {
                zend_string *str_key;
 
                ZEND_HASH_FOREACH_STR_KEY(&phar->mounted_dirs, str_key) {

diff --git a/ext/phar/zip.c b/ext/phar/zip.c
index 6011fd4c0fdf5a80f05027fa7af544c2401ece4b..2bc605bd804812f15b87f7c0df90b5e2daee6280 100644 (file)
--- a/ext/phar/zip.c
+++ b/ext/phar/zip.c
@@ -293,11 +293,11 @@ foundit:
        entry.is_persistent = mydata->is_persistent;
 #define PHAR_ZIP_FAIL_FREE(errmsg, save) \
                        zend_hash_destroy(&mydata->manifest); \
-                       mydata->manifest.u.flags = 0; \
+                       HT_FLAGS(&mydata->manifest) = 0; \
                        zend_hash_destroy(&mydata->mounted_dirs); \
-                       mydata->mounted_dirs.u.flags = 0; \
+                       HT_FLAGS(&mydata->mounted_dirs) = 0; \
                        zend_hash_destroy(&mydata->virtual_dirs); \
-                       mydata->virtual_dirs.u.flags = 0; \
+                       HT_FLAGS(&mydata->virtual_dirs) = 0; \
                        php_stream_close(fp); \
                        zval_dtor(&mydata->metadata); \
                        if (mydata->signature) { \
@@ -315,11 +315,11 @@ foundit:
                        return FAILURE;
 #define PHAR_ZIP_FAIL(errmsg) \
                        zend_hash_destroy(&mydata->manifest); \
-                       mydata->manifest.u.flags = 0; \
+                       HT_FLAGS(&mydata->manifest) = 0; \
                        zend_hash_destroy(&mydata->mounted_dirs); \
-                       mydata->mounted_dirs.u.flags = 0; \
+                       HT_FLAGS(&mydata->mounted_dirs) = 0; \
                        zend_hash_destroy(&mydata->virtual_dirs); \
-                       mydata->virtual_dirs.u.flags = 0; \
+                       HT_FLAGS(&mydata->virtual_dirs) = 0; \
                        php_stream_close(fp); \
                        zval_dtor(&mydata->metadata); \
                        if (mydata->signature) { \

diff --git a/ext/standard/array.c b/ext/standard/array.c
index 0d6a2c1eea06a314c8ea17395934f874f3170853..d6832856b831aac281be92948801cbd7f9e2ae81 100644 (file)
--- a/ext/standard/array.c
+++ b/ext/standard/array.c
@@ -3047,7 +3047,7 @@ static void php_array_data_shuffle(zval *array) /* {{{ */
                p->key = NULL;
        }
        hash->nNextFreeElement = n_elems;
-       if (!(hash->u.flags & HASH_FLAG_PACKED)) {
+       if (!(HT_FLAGS(hash) & HASH_FLAG_PACKED)) {
                zend_hash_to_packed(hash);
        }
 }
@@ -3342,7 +3342,7 @@ PHP_FUNCTION(array_shift)
        }
 
        /* re-index like it did before */
-       if (Z_ARRVAL_P(stack)->u.flags & HASH_FLAG_PACKED) {
+       if (HT_FLAGS(Z_ARRVAL_P(stack)) & HASH_FLAG_PACKED) {
                uint32_t k = 0;
 
                if (EXPECTED(Z_ARRVAL_P(stack)->u.v.nIteratorsCount == 0)) {
@@ -3716,7 +3716,7 @@ PHPAPI int php_array_merge(HashTable *dest, HashTable *src) /* {{{ */
        zval *src_entry;
        zend_string *string_key;
 
-       if ((dest->u.flags & HASH_FLAG_PACKED) && (src->u.flags & HASH_FLAG_PACKED)) {
+       if ((HT_FLAGS(dest) & HASH_FLAG_PACKED) && (HT_FLAGS(src) & HASH_FLAG_PACKED)) {
                zend_hash_extend(dest, zend_hash_num_elements(dest) + zend_hash_num_elements(src), 1);
                ZEND_HASH_FILL_PACKED(dest) {
                        ZEND_HASH_FOREACH_VAL(src, src_entry) {
@@ -3874,7 +3874,7 @@ static inline void php_array_merge_or_replace_wrapper(INTERNAL_FUNCTION_PARAMETE
                /* copy first array */
                array_init_size(return_value, count);
                dest = Z_ARRVAL_P(return_value);
-               if (src->u.flags & HASH_FLAG_PACKED) {
+               if (HT_FLAGS(src) & HASH_FLAG_PACKED) {
                        zend_hash_real_init(dest, 1);
                        ZEND_HASH_FILL_PACKED(dest) {
                                ZEND_HASH_FOREACH_VAL(src, src_entry) {
@@ -4276,7 +4276,7 @@ PHP_FUNCTION(array_reverse)
 
        /* Initialize return array */
        array_init_size(return_value, zend_hash_num_elements(Z_ARRVAL_P(input)));
-       if ((Z_ARRVAL_P(input)->u.flags & HASH_FLAG_PACKED) && !preserve_keys) {
+       if ((HT_FLAGS(Z_ARRVAL_P(input)) & HASH_FLAG_PACKED) && !preserve_keys) {
                zend_hash_real_init(Z_ARRVAL_P(return_value), 1);
                ZEND_HASH_FILL_PACKED(Z_ARRVAL_P(return_value)) {
                        ZEND_HASH_REVERSE_FOREACH_VAL(Z_ARRVAL_P(input), entry) {
@@ -4345,7 +4345,7 @@ PHP_FUNCTION(array_pad)
        }
 
        array_init_size(return_value, pad_size_abs);
-       if (Z_ARRVAL_P(input)->u.flags & HASH_FLAG_PACKED) {
+       if (HT_FLAGS(Z_ARRVAL_P(input)) & HASH_FLAG_PACKED) {
                zend_hash_real_init(Z_ARRVAL_P(return_value), 1);
 
                if (pad_size < 0) {
@@ -5756,7 +5756,7 @@ PHP_FUNCTION(array_multisort)
                hash = Z_ARRVAL_P(arrays[i]);
                hash->nNumUsed = array_size;
                hash->nInternalPointer = 0;
-               repack = !(hash->u.flags & HASH_FLAG_PACKED);
+               repack = !(HT_FLAGS(hash) & HASH_FLAG_PACKED);
 
                for (n = 0, k = 0; k < array_size; k++) {
                        hash->arData[k] = indirect[k][i];
@@ -6154,7 +6154,7 @@ PHP_FUNCTION(array_map)
                }
 
                array_init_size(return_value, maxlen);
-               zend_hash_real_init(Z_ARRVAL_P(return_value), Z_ARRVAL(arrays[0])->u.flags & HASH_FLAG_PACKED);
+               zend_hash_real_init(Z_ARRVAL_P(return_value), HT_FLAGS(Z_ARRVAL(arrays[0])) & HASH_FLAG_PACKED);
 
                ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL(arrays[0]), num_key, str_key, zv) {
                        fci.retval = &result;

diff --git a/ext/standard/var_unserializer.c b/ext/standard/var_unserializer.c
index 83b209b63e18bff7c59bdbcd3899dd726c9669d1..2af099524ce8597caaa43ae5194da5ab31a8d507 100644 (file)
--- a/ext/standard/var_unserializer.c
+++ b/ext/standard/var_unserializer.c
@@ -440,7 +440,7 @@ string_key:
                                                && zend_hash_num_elements(&Z_OBJCE_P(rval)->properties_info) > 0) {
                                        zend_property_info *existing_propinfo;
                                        zend_string *new_key;
-                                       const char *unmangled_class = NULL;
+                                       const char *unmangled_class = NULL; 
                                        const char *unmangled_prop;
                                        size_t unmangled_prop_len;
                                        zend_string *unmangled;
@@ -453,7 +453,7 @@ string_key:
                                        unmangled = zend_string_init(unmangled_prop, unmangled_prop_len, 0);
 
                                        existing_propinfo = zend_hash_find_ptr(&Z_OBJCE_P(rval)->properties_info, unmangled);
-                                       if ((existing_propinfo != NULL)
+                                       if ((existing_propinfo != NULL) 
                                                        && (existing_propinfo->flags & ZEND_ACC_PPP_MASK)) {
                                                if (existing_propinfo->flags & ZEND_ACC_PROTECTED) {
                                                        new_key = zend_mangle_property_name(
@@ -599,7 +599,7 @@ static inline int object_common2(UNSERIALIZE_PARAMETER, zend_long elements)
                return 0;
        }
 
-       zend_hash_extend(ht, zend_hash_num_elements(ht) + elements, (ht->u.flags & HASH_FLAG_PACKED));
+       zend_hash_extend(ht, zend_hash_num_elements(ht) + elements, HT_FLAGS(ht) & HASH_FLAG_PACKED);
        if (!process_nested_data(UNSERIALIZE_PASSTHRU, ht, elements, 1)) {
                if (has_wakeup) {
                        ZVAL_DEREF(rval);
@@ -672,38 +672,38 @@ static int php_var_unserialize_internal(UNSERIALIZE_PARAMETER, int as_key)
 {
        YYCTYPE yych;
        static const unsigned char yybm[] = {
-                 0,   0,   0,   0,   0,   0,   0,   0,
-                 0,   0,   0,   0,   0,   0,   0,   0,
-                 0,   0,   0,   0,   0,   0,   0,   0,
-                 0,   0,   0,   0,   0,   0,   0,   0,
-                 0,   0,   0,   0,   0,   0,   0,   0,
-                 0,   0,   0,   0,   0,   0,   0,   0,
-               128, 128, 128, 128, 128, 128, 128, 128,
-               128, 128,   0,   0,   0,   0,   0,   0,
-                 0,   0,   0,   0,   0,   0,   0,   0,
-                 0,   0,   0,   0,   0,   0,   0,   0,
-                 0,   0,   0,   0,   0,   0,   0,   0,
-                 0,   0,   0,   0,   0,   0,   0,   0,
-                 0,   0,   0,   0,   0,   0,   0,   0,
-                 0,   0,   0,   0,   0,   0,   0,   0,
-                 0,   0,   0,   0,   0,   0,   0,   0,
-                 0,   0,   0,   0,   0,   0,   0,   0,
-                 0,   0,   0,   0,   0,   0,   0,   0,
-                 0,   0,   0,   0,   0,   0,   0,   0,
-                 0,   0,   0,   0,   0,   0,   0,   0,
-                 0,   0,   0,   0,   0,   0,   0,   0,
-                 0,   0,   0,   0,   0,   0,   0,   0,
-                 0,   0,   0,   0,   0,   0,   0,   0,
-                 0,   0,   0,   0,   0,   0,   0,   0,
-                 0,   0,   0,   0,   0,   0,   0,   0,
-                 0,   0,   0,   0,   0,   0,   0,   0,
-                 0,   0,   0,   0,   0,   0,   0,   0,
-                 0,   0,   0,   0,   0,   0,   0,   0,
-                 0,   0,   0,   0,   0,   0,   0,   0,
-                 0,   0,   0,   0,   0,   0,   0,   0,
-                 0,   0,   0,   0,   0,   0,   0,   0,
-                 0,   0,   0,   0,   0,   0,   0,   0,
-                 0,   0,   0,   0,   0,   0,   0,   0,
+                 0,   0,   0,   0,   0,   0,   0,   0, 
+                 0,   0,   0,   0,   0,   0,   0,   0, 
+                 0,   0,   0,   0,   0,   0,   0,   0, 
+                 0,   0,   0,   0,   0,   0,   0,   0, 
+                 0,   0,   0,   0,   0,   0,   0,   0, 
+                 0,   0,   0,   0,   0,   0,   0,   0, 
+               128, 128, 128, 128, 128, 128, 128, 128, 
+               128, 128,   0,   0,   0,   0,   0,   0, 
+                 0,   0,   0,   0,   0,   0,   0,   0, 
+                 0,   0,   0,   0,   0,   0,   0,   0, 
+                 0,   0,   0,   0,   0,   0,   0,   0, 
+                 0,   0,   0,   0,   0,   0,   0,   0, 
+                 0,   0,   0,   0,   0,   0,   0,   0, 
+                 0,   0,   0,   0,   0,   0,   0,   0, 
+                 0,   0,   0,   0,   0,   0,   0,   0, 
+                 0,   0,   0,   0,   0,   0,   0,   0, 
+                 0,   0,   0,   0,   0,   0,   0,   0, 
+                 0,   0,   0,   0,   0,   0,   0,   0, 
+                 0,   0,   0,   0,   0,   0,   0,   0, 
+                 0,   0,   0,   0,   0,   0,   0,   0, 
+                 0,   0,   0,   0,   0,   0,   0,   0, 
+                 0,   0,   0,   0,   0,   0,   0,   0, 
+                 0,   0,   0,   0,   0,   0,   0,   0, 
+                 0,   0,   0,   0,   0,   0,   0,   0, 
+                 0,   0,   0,   0,   0,   0,   0,   0, 
+                 0,   0,   0,   0,   0,   0,   0,   0, 
+                 0,   0,   0,   0,   0,   0,   0,   0, 
+                 0,   0,   0,   0,   0,   0,   0,   0, 
+                 0,   0,   0,   0,   0,   0,   0,   0, 
+                 0,   0,   0,   0,   0,   0,   0,   0, 
+                 0,   0,   0,   0,   0,   0,   0,   0, 
+                 0,   0,   0,   0,   0,   0,   0,   0, 
        };
        if ((YYLIMIT - YYCURSOR) < 7) YYFILL(7);
        yych = *YYCURSOR;

diff --git a/ext/standard/var_unserializer.re b/ext/standard/var_unserializer.re
index 0a2446b2aa27c13d31ff0ecd8f3dee2f196574f1..41b0c80bf22f4a339d99fb3b0ab28c8b3381eced 100644 (file)
--- a/ext/standard/var_unserializer.re
+++ b/ext/standard/var_unserializer.re
@@ -603,7 +603,7 @@ static inline int object_common2(UNSERIALIZE_PARAMETER, zend_long elements)
                return 0;
        }
 
-       zend_hash_extend(ht, zend_hash_num_elements(ht) + elements, (ht->u.flags & HASH_FLAG_PACKED));
+       zend_hash_extend(ht, zend_hash_num_elements(ht) + elements, HT_FLAGS(ht) & HASH_FLAG_PACKED);
        if (!process_nested_data(UNSERIALIZE_PASSTHRU, ht, elements, 1)) {
                if (has_wakeup) {
                        ZVAL_DEREF(rval);