API cleanup.

Removed useless filename and lineno arguments, used in DEBUG build.
The patch doesn't break source compatibility of public API (only binary compatibility).

diff --git a/Zend/zend_API.c b/Zend/zend_API.c
index daa938a3023b17175a0b95159b0d5433e2c1779e..479b388b9607ac923a0f580638bec84ae5489434 100644 (file)
--- a/Zend/zend_API.c
+++ b/Zend/zend_API.c
@@ -1303,7 +1303,7 @@ ZEND_API void object_properties_load(zend_object *object, HashTable *properties)
  * class and all props being public. If only a subset is given or the class
  * has protected members then you need to merge the properties separately by
  * calling zend_merge_properties(). */
-ZEND_API int _object_and_properties_init(zval *arg, zend_class_entry *class_type, HashTable *properties ZEND_FILE_LINE_DC) /* {{{ */
+ZEND_API int object_and_properties_init(zval *arg, zend_class_entry *class_type, HashTable *properties) /* {{{ */
 {
        if (UNEXPECTED(class_type->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_TRAIT|ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS))) {
                if (class_type->ce_flags & ZEND_ACC_INTERFACE) {
@@ -1340,9 +1340,9 @@ ZEND_API int _object_and_properties_init(zval *arg, zend_class_entry *class_type
 }
 /* }}} */
 
-ZEND_API int _object_init_ex(zval *arg, zend_class_entry *class_type ZEND_FILE_LINE_DC) /* {{{ */
+ZEND_API int object_init_ex(zval *arg, zend_class_entry *class_type) /* {{{ */
 {
-       return _object_and_properties_init(arg, class_type, 0 ZEND_FILE_LINE_RELAY_CC);
+       return object_and_properties_init(arg, class_type, 0);
 }
 /* }}} */
 

diff --git a/Zend/zend_API.h b/Zend/zend_API.h
index 3bd2471dda20baf665e02142bd535a825256fca8..98e8ae71dcdf84eacab006e9deac8f65ba9949bc 100644 (file)
--- a/Zend/zend_API.h
+++ b/Zend/zend_API.h
@@ -378,11 +378,9 @@ ZEND_API char *zend_get_type_by_const(int type);
 
 #define array_init(arg)                                ZVAL_ARR((arg), zend_new_array(0))
 #define array_init_size(arg, size)     ZVAL_ARR((arg), zend_new_array(size))
-#define object_init_ex(arg, ce)        _object_init_ex((arg), (ce) ZEND_FILE_LINE_CC)
-#define object_and_properties_init(arg, ce, properties)        _object_and_properties_init((arg), (ce), (properties) ZEND_FILE_LINE_CC)
 ZEND_API int object_init(zval *arg);
-ZEND_API int _object_init_ex(zval *arg, zend_class_entry *ce ZEND_FILE_LINE_DC);
-ZEND_API int _object_and_properties_init(zval *arg, zend_class_entry *ce, HashTable *properties ZEND_FILE_LINE_DC);
+ZEND_API int object_init_ex(zval *arg, zend_class_entry *ce);
+ZEND_API int object_and_properties_init(zval *arg, zend_class_entry *ce, HashTable *properties);
 ZEND_API void object_properties_init(zend_object *object, zend_class_entry *class_type);
 ZEND_API void object_properties_init_ex(zend_object *object, HashTable *properties);
 ZEND_API void object_properties_load(zend_object *object, HashTable *properties);

diff --git a/Zend/zend_hash.c b/Zend/zend_hash.c
index b4a62b1649c637f1886a4648c8df3854659d4dcb..0b516b28e601e27a3a6b2aa05711c69f725f05b4 100644 (file)
--- a/Zend/zend_hash.c
+++ b/Zend/zend_hash.c
@@ -214,14 +214,14 @@ ZEND_API void ZEND_FASTCALL _zend_hash_init(HashTable *ht, uint32_t nSize, dtor_
        _zend_hash_init_int(ht, nSize, pDestructor, persistent);
 }
 
-ZEND_API HashTable* ZEND_FASTCALL _zend_new_array_0(ZEND_FILE_LINE_D)
+ZEND_API HashTable* ZEND_FASTCALL _zend_new_array_0(void)
 {
        HashTable *ht = emalloc(sizeof(HashTable));
        _zend_hash_init_int(ht, HT_MIN_SIZE, ZVAL_PTR_DTOR, 0);
        return ht;
 }
 
-ZEND_API HashTable* ZEND_FASTCALL _zend_new_array(uint32_t nSize ZEND_FILE_LINE_DC)
+ZEND_API HashTable* ZEND_FASTCALL _zend_new_array(uint32_t nSize)
 {
        HashTable *ht = emalloc(sizeof(HashTable));
        _zend_hash_init_int(ht, nSize, ZVAL_PTR_DTOR, 0);
@@ -647,7 +647,7 @@ static zend_always_inline Bucket *zend_hash_index_find_bucket(const HashTable *h
        return NULL;
 }
 
-static zend_always_inline zval *_zend_hash_add_or_update_i(HashTable *ht, zend_string *key, zval *pData, uint32_t flag ZEND_FILE_LINE_DC)
+static zend_always_inline zval *_zend_hash_add_or_update_i(HashTable *ht, zend_string *key, zval *pData, uint32_t flag)
 {
        zend_ulong h;
        uint32_t nIndex;
@@ -732,7 +732,7 @@ add_to_hash:
        return &p->val;
 }
 
-static zend_always_inline zval *_zend_hash_str_add_or_update_i(HashTable *ht, const char *str, size_t len, zend_ulong h, zval *pData, uint32_t flag ZEND_FILE_LINE_DC)
+static zend_always_inline zval *_zend_hash_str_add_or_update_i(HashTable *ht, const char *str, size_t len, zend_ulong h, zval *pData, uint32_t flag)
 {
        zend_string *key;
        uint32_t nIndex;
@@ -799,80 +799,80 @@ add_to_hash:
        return &p->val;
 }
 
-ZEND_API zval* ZEND_FASTCALL _zend_hash_add_or_update(HashTable *ht, zend_string *key, zval *pData, uint32_t flag ZEND_FILE_LINE_DC)
+ZEND_API zval* ZEND_FASTCALL zend_hash_add_or_update(HashTable *ht, zend_string *key, zval *pData, uint32_t flag)
 {
        if (flag == HASH_ADD) {
-               return _zend_hash_add(ht, key, pData ZEND_FILE_LINE_RELAY_CC);
+               return zend_hash_add(ht, key, pData);
        } else if (flag == HASH_ADD_NEW) {
-               return _zend_hash_add_new(ht, key, pData ZEND_FILE_LINE_RELAY_CC);
+               return zend_hash_add_new(ht, key, pData);
        } else if (flag == HASH_UPDATE) {
-               return _zend_hash_update(ht, key, pData ZEND_FILE_LINE_RELAY_CC);
+               return zend_hash_update(ht, key, pData);
        } else {
                ZEND_ASSERT(flag == (HASH_UPDATE|HASH_UPDATE_INDIRECT));
-               return _zend_hash_update_ind(ht, key, pData ZEND_FILE_LINE_RELAY_CC);
+               return zend_hash_update_ind(ht, key, pData);
        }
 }
 
-ZEND_API zval* ZEND_FASTCALL _zend_hash_add(HashTable *ht, zend_string *key, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval* ZEND_FASTCALL zend_hash_add(HashTable *ht, zend_string *key, zval *pData)
 {
-       return _zend_hash_add_or_update_i(ht, key, pData, HASH_ADD ZEND_FILE_LINE_RELAY_CC);
+       return _zend_hash_add_or_update_i(ht, key, pData, HASH_ADD);
 }
 
-ZEND_API zval* ZEND_FASTCALL _zend_hash_update(HashTable *ht, zend_string *key, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval* ZEND_FASTCALL zend_hash_update(HashTable *ht, zend_string *key, zval *pData)
 {
-       return _zend_hash_add_or_update_i(ht, key, pData, HASH_UPDATE ZEND_FILE_LINE_RELAY_CC);
+       return _zend_hash_add_or_update_i(ht, key, pData, HASH_UPDATE);
 }
 
-ZEND_API zval* ZEND_FASTCALL _zend_hash_update_ind(HashTable *ht, zend_string *key, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval* ZEND_FASTCALL zend_hash_update_ind(HashTable *ht, zend_string *key, zval *pData)
 {
-       return _zend_hash_add_or_update_i(ht, key, pData, HASH_UPDATE | HASH_UPDATE_INDIRECT ZEND_FILE_LINE_RELAY_CC);
+       return _zend_hash_add_or_update_i(ht, key, pData, HASH_UPDATE | HASH_UPDATE_INDIRECT);
 }
 
-ZEND_API zval* ZEND_FASTCALL _zend_hash_add_new(HashTable *ht, zend_string *key, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval* ZEND_FASTCALL zend_hash_add_new(HashTable *ht, zend_string *key, zval *pData)
 {
-       return _zend_hash_add_or_update_i(ht, key, pData, HASH_ADD_NEW ZEND_FILE_LINE_RELAY_CC);
+       return _zend_hash_add_or_update_i(ht, key, pData, HASH_ADD_NEW);
 }
 
-ZEND_API zval* ZEND_FASTCALL _zend_hash_str_add_or_update(HashTable *ht, const char *str, size_t len, zval *pData, uint32_t flag ZEND_FILE_LINE_DC)
+ZEND_API zval* ZEND_FASTCALL zend_hash_str_add_or_update(HashTable *ht, const char *str, size_t len, zval *pData, uint32_t flag)
 {
        if (flag == HASH_ADD) {
-               return _zend_hash_str_add(ht, str, len, pData ZEND_FILE_LINE_RELAY_CC);
+               return zend_hash_str_add(ht, str, len, pData);
        } else if (flag == HASH_ADD_NEW) {
-               return _zend_hash_str_add_new(ht, str, len, pData ZEND_FILE_LINE_RELAY_CC);
+               return zend_hash_str_add_new(ht, str, len, pData);
        } else if (flag == HASH_UPDATE) {
-               return _zend_hash_str_update(ht, str, len, pData ZEND_FILE_LINE_RELAY_CC);
+               return zend_hash_str_update(ht, str, len, pData);
        } else {
                ZEND_ASSERT(flag == (HASH_UPDATE|HASH_UPDATE_INDIRECT));
-               return _zend_hash_str_update_ind(ht, str, len, pData ZEND_FILE_LINE_RELAY_CC);
+               return zend_hash_str_update_ind(ht, str, len, pData);
        }
 }
 
-ZEND_API zval* ZEND_FASTCALL _zend_hash_str_update(HashTable *ht, const char *str, size_t len, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval* ZEND_FASTCALL zend_hash_str_update(HashTable *ht, const char *str, size_t len, zval *pData)
 {
        zend_ulong h = zend_hash_func(str, len);
 
-       return _zend_hash_str_add_or_update_i(ht, str, len, h, pData, HASH_UPDATE ZEND_FILE_LINE_RELAY_CC);
+       return _zend_hash_str_add_or_update_i(ht, str, len, h, pData, HASH_UPDATE);
 }
 
-ZEND_API zval* ZEND_FASTCALL _zend_hash_str_update_ind(HashTable *ht, const char *str, size_t len, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval* ZEND_FASTCALL zend_hash_str_update_ind(HashTable *ht, const char *str, size_t len, zval *pData)
 {
        zend_ulong h = zend_hash_func(str, len);
 
-       return _zend_hash_str_add_or_update_i(ht, str, len, h, pData, HASH_UPDATE | HASH_UPDATE_INDIRECT ZEND_FILE_LINE_RELAY_CC);
+       return _zend_hash_str_add_or_update_i(ht, str, len, h, pData, HASH_UPDATE | HASH_UPDATE_INDIRECT);
 }
 
-ZEND_API zval* ZEND_FASTCALL _zend_hash_str_add(HashTable *ht, const char *str, size_t len, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval* ZEND_FASTCALL zend_hash_str_add(HashTable *ht, const char *str, size_t len, zval *pData)
 {
        zend_ulong h = zend_hash_func(str, len);
 
-       return _zend_hash_str_add_or_update_i(ht, str, len, h, pData, HASH_ADD ZEND_FILE_LINE_RELAY_CC);
+       return _zend_hash_str_add_or_update_i(ht, str, len, h, pData, HASH_ADD);
 }
 
-ZEND_API zval* ZEND_FASTCALL _zend_hash_str_add_new(HashTable *ht, const char *str, size_t len, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval* ZEND_FASTCALL zend_hash_str_add_new(HashTable *ht, const char *str, size_t len, zval *pData)
 {
        zend_ulong h = zend_hash_func(str, len);
 
-       return _zend_hash_str_add_or_update_i(ht, str, len, h, pData, HASH_ADD_NEW ZEND_FILE_LINE_RELAY_CC);
+       return _zend_hash_str_add_or_update_i(ht, str, len, h, pData, HASH_ADD_NEW);
 }
 
 ZEND_API zval* ZEND_FASTCALL zend_hash_index_add_empty_element(HashTable *ht, zend_ulong h)
@@ -899,7 +899,7 @@ ZEND_API zval* ZEND_FASTCALL zend_hash_str_add_empty_element(HashTable *ht, cons
        return zend_hash_str_add(ht, str, len, &dummy);
 }
 
-static zend_always_inline zval *_zend_hash_index_add_or_update_i(HashTable *ht, zend_ulong h, zval *pData, uint32_t flag ZEND_FILE_LINE_DC)
+static zend_always_inline zval *_zend_hash_index_add_or_update_i(HashTable *ht, zend_ulong h, zval *pData, uint32_t flag)
 {
        uint32_t nIndex;
        uint32_t idx;
@@ -983,47 +983,47 @@ add:
        return &p->val;
 }
 
-ZEND_API zval* ZEND_FASTCALL _zend_hash_index_add_or_update(HashTable *ht, zend_ulong h, zval *pData, uint32_t flag ZEND_FILE_LINE_DC)
+ZEND_API zval* ZEND_FASTCALL zend_hash_index_add_or_update(HashTable *ht, zend_ulong h, zval *pData, uint32_t flag)
 {
        if (flag == HASH_ADD) {
-               return _zend_hash_index_add(ht, h, pData ZEND_FILE_LINE_RELAY_CC);
+               return zend_hash_index_add(ht, h, pData);
        } else if (flag == (HASH_ADD|HASH_ADD_NEW)) {
-               return _zend_hash_index_add_new(ht, h, pData ZEND_FILE_LINE_RELAY_CC);
+               return zend_hash_index_add_new(ht, h, pData);
        } else if (flag == (HASH_ADD|HASH_ADD_NEXT)) {
                ZEND_ASSERT(h == ht->nNextFreeElement);
-               return _zend_hash_next_index_insert(ht, pData ZEND_FILE_LINE_RELAY_CC);
+               return zend_hash_next_index_insert(ht, pData);
        } else if (flag == (HASH_ADD|HASH_ADD_NEW|HASH_ADD_NEXT)) {
                ZEND_ASSERT(h == ht->nNextFreeElement);
-               return _zend_hash_next_index_insert_new(ht, pData ZEND_FILE_LINE_RELAY_CC);
+               return zend_hash_next_index_insert_new(ht, pData);
        } else {
                ZEND_ASSERT(flag == HASH_UPDATE);
-               return _zend_hash_index_update(ht, h, pData ZEND_FILE_LINE_RELAY_CC);
+               return zend_hash_index_update(ht, h, pData);
        }
 }
 
-ZEND_API zval* ZEND_FASTCALL _zend_hash_index_add(HashTable *ht, zend_ulong h, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval* ZEND_FASTCALL zend_hash_index_add(HashTable *ht, zend_ulong h, zval *pData)
 {
-       return _zend_hash_index_add_or_update_i(ht, h, pData, HASH_ADD ZEND_FILE_LINE_RELAY_CC);
+       return _zend_hash_index_add_or_update_i(ht, h, pData, HASH_ADD);
 }
 
-ZEND_API zval* ZEND_FASTCALL _zend_hash_index_add_new(HashTable *ht, zend_ulong h, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval* ZEND_FASTCALL zend_hash_index_add_new(HashTable *ht, zend_ulong h, zval *pData)
 {
-       return _zend_hash_index_add_or_update_i(ht, h, pData, HASH_ADD | HASH_ADD_NEW ZEND_FILE_LINE_RELAY_CC);
+       return _zend_hash_index_add_or_update_i(ht, h, pData, HASH_ADD | HASH_ADD_NEW);
 }
 
-ZEND_API zval* ZEND_FASTCALL _zend_hash_index_update(HashTable *ht, zend_ulong h, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval* ZEND_FASTCALL zend_hash_index_update(HashTable *ht, zend_ulong h, zval *pData)
 {
-       return _zend_hash_index_add_or_update_i(ht, h, pData, HASH_UPDATE ZEND_FILE_LINE_RELAY_CC);
+       return _zend_hash_index_add_or_update_i(ht, h, pData, HASH_UPDATE);
 }
 
-ZEND_API zval* ZEND_FASTCALL _zend_hash_next_index_insert(HashTable *ht, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval* ZEND_FASTCALL zend_hash_next_index_insert(HashTable *ht, zval *pData)
 {
-       return _zend_hash_index_add_or_update_i(ht, ht->nNextFreeElement, pData, HASH_ADD | HASH_ADD_NEXT ZEND_FILE_LINE_RELAY_CC);
+       return _zend_hash_index_add_or_update_i(ht, ht->nNextFreeElement, pData, HASH_ADD | HASH_ADD_NEXT);
 }
 
-ZEND_API zval* ZEND_FASTCALL _zend_hash_next_index_insert_new(HashTable *ht, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval* ZEND_FASTCALL zend_hash_next_index_insert_new(HashTable *ht, zval *pData)
 {
-       return _zend_hash_index_add_or_update_i(ht, ht->nNextFreeElement, pData, HASH_ADD | HASH_ADD_NEW | HASH_ADD_NEXT ZEND_FILE_LINE_RELAY_CC);
+       return _zend_hash_index_add_or_update_i(ht, ht->nNextFreeElement, pData, HASH_ADD | HASH_ADD_NEW | HASH_ADD_NEXT);
 }
 
 static void ZEND_FASTCALL zend_hash_do_resize(HashTable *ht)
@@ -1991,7 +1991,7 @@ ZEND_API HashTable* ZEND_FASTCALL zend_array_dup(HashTable *source)
 }
 
 
-ZEND_API void ZEND_FASTCALL _zend_hash_merge(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, zend_bool overwrite ZEND_FILE_LINE_DC)
+ZEND_API void ZEND_FASTCALL zend_hash_merge(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, zend_bool overwrite)
 {
     uint32_t idx;
        Bucket *p;
@@ -2010,7 +2010,7 @@ ZEND_API void ZEND_FASTCALL _zend_hash_merge(HashTable *target, HashTable *sourc
                            continue;
                        }
                        if (p->key) {
-                               t = _zend_hash_add_or_update_i(target, p->key, &p->val, HASH_UPDATE | HASH_UPDATE_INDIRECT ZEND_FILE_LINE_RELAY_CC);
+                               t = _zend_hash_add_or_update_i(target, p->key, &p->val, HASH_UPDATE | HASH_UPDATE_INDIRECT);
                                if (pCopyConstructor) {
                                        pCopyConstructor(t);
                                }
@@ -2030,7 +2030,7 @@ ZEND_API void ZEND_FASTCALL _zend_hash_merge(HashTable *target, HashTable *sourc
                            continue;
                        }
                        if (p->key) {
-                               t = _zend_hash_add_or_update_i(target, p->key, &p->val, HASH_ADD | HASH_UPDATE_INDIRECT ZEND_FILE_LINE_RELAY_CC);
+                               t = _zend_hash_add_or_update_i(target, p->key, &p->val, HASH_ADD | HASH_UPDATE_INDIRECT);
                                if (t && pCopyConstructor) {
                                        pCopyConstructor(t);
                                }

diff --git a/Zend/zend_hash.h b/Zend/zend_hash.h
index 984730e5fd3b06698e0b6cdd494abe04684739e4..ac90451e01067c05eeb0014ae0c0bb103c8391c6 100644 (file)
--- a/Zend/zend_hash.h
+++ b/Zend/zend_hash.h
@@ -107,53 +107,24 @@ ZEND_API void ZEND_FASTCALL zend_hash_extend(HashTable *ht, uint32_t nSize, zend
 ZEND_API void ZEND_FASTCALL zend_hash_discard(HashTable *ht, uint32_t nNumUsed);
 
 /* additions/updates/changes */
-ZEND_API zval* ZEND_FASTCALL _zend_hash_add_or_update(HashTable *ht, zend_string *key, zval *pData, uint32_t flag ZEND_FILE_LINE_DC);
-ZEND_API zval* ZEND_FASTCALL _zend_hash_update(HashTable *ht, zend_string *key,zval *pData ZEND_FILE_LINE_DC);
-ZEND_API zval* ZEND_FASTCALL _zend_hash_update_ind(HashTable *ht, zend_string *key,zval *pData ZEND_FILE_LINE_DC);
-ZEND_API zval* ZEND_FASTCALL _zend_hash_add(HashTable *ht, zend_string *key,zval *pData ZEND_FILE_LINE_DC);
-ZEND_API zval* ZEND_FASTCALL _zend_hash_add_new(HashTable *ht, zend_string *key,zval *pData ZEND_FILE_LINE_DC);
-
-#define zend_hash_update(ht, key, pData) \
-               _zend_hash_update(ht, key, pData ZEND_FILE_LINE_CC)
-#define zend_hash_update_ind(ht, key, pData) \
-               _zend_hash_update_ind(ht, key, pData ZEND_FILE_LINE_CC)
-#define zend_hash_add(ht, key, pData) \
-               _zend_hash_add(ht, key, pData ZEND_FILE_LINE_CC)
-#define zend_hash_add_new(ht, key, pData) \
-               _zend_hash_add_new(ht, key, pData ZEND_FILE_LINE_CC)
-
-ZEND_API zval* ZEND_FASTCALL _zend_hash_str_add_or_update(HashTable *ht, const char *key, size_t len, zval *pData, uint32_t flag ZEND_FILE_LINE_DC);
-ZEND_API zval* ZEND_FASTCALL _zend_hash_str_update(HashTable *ht, const char *key, size_t len, zval *pData ZEND_FILE_LINE_DC);
-ZEND_API zval* ZEND_FASTCALL _zend_hash_str_update_ind(HashTable *ht, const char *key, size_t len, zval *pData ZEND_FILE_LINE_DC);
-ZEND_API zval* ZEND_FASTCALL _zend_hash_str_add(HashTable *ht, const char *key, size_t len, zval *pData ZEND_FILE_LINE_DC);
-ZEND_API zval* ZEND_FASTCALL _zend_hash_str_add_new(HashTable *ht, const char *key, size_t len, zval *pData ZEND_FILE_LINE_DC);
-
-#define zend_hash_str_update(ht, key, len, pData) \
-               _zend_hash_str_update(ht, key, len, pData ZEND_FILE_LINE_CC)
-#define zend_hash_str_update_ind(ht, key, len, pData) \
-               _zend_hash_str_update_ind(ht, key, len, pData ZEND_FILE_LINE_CC)
-#define zend_hash_str_add(ht, key, len, pData) \
-               _zend_hash_str_add(ht, key, len, pData ZEND_FILE_LINE_CC)
-#define zend_hash_str_add_new(ht, key, len, pData) \
-               _zend_hash_str_add_new(ht, key, len, pData ZEND_FILE_LINE_CC)
-
-ZEND_API zval* ZEND_FASTCALL _zend_hash_index_add_or_update(HashTable *ht, zend_ulong h, zval *pData, uint32_t flag ZEND_FILE_LINE_DC);
-ZEND_API zval* ZEND_FASTCALL _zend_hash_index_add(HashTable *ht, zend_ulong h, zval *pData ZEND_FILE_LINE_DC);
-ZEND_API zval* ZEND_FASTCALL _zend_hash_index_add_new(HashTable *ht, zend_ulong h, zval *pData ZEND_FILE_LINE_DC);
-ZEND_API zval* ZEND_FASTCALL _zend_hash_index_update(HashTable *ht, zend_ulong h, zval *pData ZEND_FILE_LINE_DC);
-ZEND_API zval* ZEND_FASTCALL _zend_hash_next_index_insert(HashTable *ht, zval *pData ZEND_FILE_LINE_DC);
-ZEND_API zval* ZEND_FASTCALL _zend_hash_next_index_insert_new(HashTable *ht, zval *pData ZEND_FILE_LINE_DC);
-
-#define zend_hash_index_add(ht, h, pData) \
-               _zend_hash_index_add(ht, h, pData ZEND_FILE_LINE_CC)
-#define zend_hash_index_add_new(ht, h, pData) \
-               _zend_hash_index_add_new(ht, h, pData ZEND_FILE_LINE_CC)
-#define zend_hash_index_update(ht, h, pData) \
-               _zend_hash_index_update(ht, h, pData ZEND_FILE_LINE_CC)
-#define zend_hash_next_index_insert(ht, pData) \
-               _zend_hash_next_index_insert(ht, pData ZEND_FILE_LINE_CC)
-#define zend_hash_next_index_insert_new(ht, pData) \
-               _zend_hash_next_index_insert_new(ht, pData ZEND_FILE_LINE_CC)
+ZEND_API zval* ZEND_FASTCALL zend_hash_add_or_update(HashTable *ht, zend_string *key, zval *pData, uint32_t flag);
+ZEND_API zval* ZEND_FASTCALL zend_hash_update(HashTable *ht, zend_string *key,zval *pData);
+ZEND_API zval* ZEND_FASTCALL zend_hash_update_ind(HashTable *ht, zend_string *key,zval *pData);
+ZEND_API zval* ZEND_FASTCALL zend_hash_add(HashTable *ht, zend_string *key,zval *pData);
+ZEND_API zval* ZEND_FASTCALL zend_hash_add_new(HashTable *ht, zend_string *key,zval *pData);
+
+ZEND_API zval* ZEND_FASTCALL zend_hash_str_add_or_update(HashTable *ht, const char *key, size_t len, zval *pData, uint32_t flag);
+ZEND_API zval* ZEND_FASTCALL zend_hash_str_update(HashTable *ht, const char *key, size_t len, zval *pData);
+ZEND_API zval* ZEND_FASTCALL zend_hash_str_update_ind(HashTable *ht, const char *key, size_t len, zval *pData);
+ZEND_API zval* ZEND_FASTCALL zend_hash_str_add(HashTable *ht, const char *key, size_t len, zval *pData);
+ZEND_API zval* ZEND_FASTCALL zend_hash_str_add_new(HashTable *ht, const char *key, size_t len, zval *pData);
+
+ZEND_API zval* ZEND_FASTCALL zend_hash_index_add_or_update(HashTable *ht, zend_ulong h, zval *pData, uint32_t flag);
+ZEND_API zval* ZEND_FASTCALL zend_hash_index_add(HashTable *ht, zend_ulong h, zval *pData);
+ZEND_API zval* ZEND_FASTCALL zend_hash_index_add_new(HashTable *ht, zend_ulong h, zval *pData);
+ZEND_API zval* ZEND_FASTCALL zend_hash_index_update(HashTable *ht, zend_ulong h, zval *pData);
+ZEND_API zval* ZEND_FASTCALL zend_hash_next_index_insert(HashTable *ht, zval *pData);
+ZEND_API zval* ZEND_FASTCALL zend_hash_next_index_insert_new(HashTable *ht, zval *pData);
 
 ZEND_API zval* ZEND_FASTCALL zend_hash_index_add_empty_element(HashTable *ht, zend_ulong h);
 ZEND_API zval* ZEND_FASTCALL zend_hash_add_empty_element(HashTable *ht, zend_string *key);
@@ -267,7 +238,7 @@ ZEND_API void  ZEND_FASTCALL zend_hash_internal_pointer_end_ex(HashTable *ht, Ha
 
 /* Copying, merging and sorting */
 ZEND_API void  ZEND_FASTCALL zend_hash_copy(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor);
-ZEND_API void  ZEND_FASTCALL _zend_hash_merge(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, zend_bool overwrite ZEND_FILE_LINE_DC);
+ZEND_API void  ZEND_FASTCALL zend_hash_merge(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, zend_bool overwrite);
 ZEND_API void  ZEND_FASTCALL zend_hash_merge_ex(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, merge_checker_func_t pMergeSource, void *pParam);
 ZEND_API void  zend_hash_bucket_swap(Bucket *p, Bucket *q);
 ZEND_API void  zend_hash_bucket_renum_swap(Bucket *p, Bucket *q);
@@ -276,9 +247,6 @@ ZEND_API int   zend_hash_compare(HashTable *ht1, HashTable *ht2, compare_func_t
 ZEND_API int   ZEND_FASTCALL zend_hash_sort_ex(HashTable *ht, sort_func_t sort_func, compare_func_t compare_func, zend_bool renumber);
 ZEND_API zval* ZEND_FASTCALL zend_hash_minmax(const HashTable *ht, compare_func_t compar, uint32_t flag);
 
-#define zend_hash_merge(target, source, pCopyConstructor, overwrite)                                   \
-       _zend_hash_merge(target, source, pCopyConstructor, overwrite ZEND_FILE_LINE_CC)
-
 #define zend_hash_sort(ht, compare_func, renumber) \
        zend_hash_sort_ex(ht, zend_sort, compare_func, renumber)
 
@@ -294,20 +262,20 @@ ZEND_API int ZEND_FASTCALL zend_hash_rehash(HashTable *ht);
 # define zend_new_array(size) \
        (__builtin_constant_p(size) ? \
                ((((uint32_t)(size)) <= HT_MIN_SIZE) ? \
-                       _zend_new_array_0(ZEND_FILE_LINE_C) \
+                       _zend_new_array_0() \
                : \
-                       _zend_new_array((size) ZEND_FILE_LINE_CC) \
+                       _zend_new_array((size)) \
                ) \
        : \
-               _zend_new_array((size) ZEND_FILE_LINE_CC) \
+               _zend_new_array((size)) \
        )
 #else
 # define zend_new_array(size) \
-       _zend_new_array(size ZEND_FILE_LINE_CC)
+       _zend_new_array(size)
 #endif
 
-ZEND_API HashTable* ZEND_FASTCALL _zend_new_array_0(ZEND_FILE_LINE_D);
-ZEND_API HashTable* ZEND_FASTCALL _zend_new_array(uint32_t size ZEND_FILE_LINE_DC);
+ZEND_API HashTable* ZEND_FASTCALL _zend_new_array_0(void);
+ZEND_API HashTable* ZEND_FASTCALL _zend_new_array(uint32_t size);
 ZEND_API uint32_t zend_array_count(HashTable *ht);
 ZEND_API HashTable* ZEND_FASTCALL zend_array_dup(HashTable *source);
 ZEND_API void ZEND_FASTCALL zend_array_destroy(HashTable *ht);

diff --git a/Zend/zend_operators.c b/Zend/zend_operators.c
index 10b065bb7992c1098fb03e372ba3506ba82a8bb3..ea3f2e0ba779e5e18283ba173bb757514555b7d7 100644 (file)
--- a/Zend/zend_operators.c
+++ b/Zend/zend_operators.c
@@ -519,7 +519,7 @@ try_again:
 }
 /* }}} */
 
-ZEND_API void ZEND_FASTCALL _convert_to_cstring(zval *op ZEND_FILE_LINE_DC) /* {{{ */
+ZEND_API void ZEND_FASTCALL _convert_to_cstring(zval *op) /* {{{ */
 {
        if (Z_TYPE_P(op) == IS_DOUBLE) {
                zend_string *str;
@@ -528,12 +528,12 @@ ZEND_API void ZEND_FASTCALL _convert_to_cstring(zval *op ZEND_FILE_LINE_DC) /* {
                str = zend_strpprintf_unchecked(0, "%.*H", (int) EG(precision), dval);
                ZVAL_NEW_STR(op, str);
        } else {
-               _convert_to_string(op ZEND_FILE_LINE_CC);
+               _convert_to_string(op);
        }
 }
 /* }}} */
 
-ZEND_API void ZEND_FASTCALL _convert_to_string(zval *op ZEND_FILE_LINE_DC) /* {{{ */
+ZEND_API void ZEND_FASTCALL _convert_to_string(zval *op) /* {{{ */
 {
 try_again:
        switch (Z_TYPE_P(op)) {

diff --git a/Zend/zend_operators.h b/Zend/zend_operators.h
index 46c6f18774b77152ba7de7638d9ece4d555eab64..1de69f6b9adf19430689dc9149af5b188c3a537a 100644 (file)
--- a/Zend/zend_operators.h
+++ b/Zend/zend_operators.h
@@ -247,8 +247,8 @@ ZEND_API int ZEND_FASTCALL increment_function(zval *op1);
 ZEND_API int ZEND_FASTCALL decrement_function(zval *op2);
 
 ZEND_API void ZEND_FASTCALL convert_scalar_to_number(zval *op);
-ZEND_API void ZEND_FASTCALL _convert_to_cstring(zval *op ZEND_FILE_LINE_DC);
-ZEND_API void ZEND_FASTCALL _convert_to_string(zval *op ZEND_FILE_LINE_DC);
+ZEND_API void ZEND_FASTCALL _convert_to_cstring(zval *op);
+ZEND_API void ZEND_FASTCALL _convert_to_string(zval *op);
 ZEND_API void ZEND_FASTCALL convert_to_long(zval *op);
 ZEND_API void ZEND_FASTCALL convert_to_double(zval *op);
 ZEND_API void ZEND_FASTCALL convert_to_long_base(zval *op, int base);
@@ -296,8 +296,8 @@ static zend_always_inline void zend_tmp_string_release(zend_string *tmp) {
 #define _zval_get_double_func(op) zval_get_double_func(op)
 #define _zval_get_string_func(op) zval_get_string_func(op)
 
-#define convert_to_cstring(op) if (Z_TYPE_P(op) != IS_STRING) { _convert_to_cstring((op) ZEND_FILE_LINE_CC); }
-#define convert_to_string(op) if (Z_TYPE_P(op) != IS_STRING) { _convert_to_string((op) ZEND_FILE_LINE_CC); }
+#define convert_to_cstring(op) if (Z_TYPE_P(op) != IS_STRING) { _convert_to_cstring((op)); }
+#define convert_to_string(op) if (Z_TYPE_P(op) != IS_STRING) { _convert_to_string((op)); }
 
 
 ZEND_API int ZEND_FASTCALL zend_is_true(zval *op);

diff --git a/Zend/zend_ts_hash.c b/Zend/zend_ts_hash.c
index f5d210b724b6803d3675ac2ad06ac5c34c747c94..9d48c7425e58b25e4face26877ba3a02328eccb0 100644 (file)
--- a/Zend/zend_ts_hash.c
+++ b/Zend/zend_ts_hash.c
@@ -89,45 +89,45 @@ ZEND_API void zend_ts_hash_clean(TsHashTable *ht)
        end_write(ht);
 }
 
-ZEND_API zval *_zend_ts_hash_add(TsHashTable *ht, zend_string *key, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval *zend_ts_hash_add(TsHashTable *ht, zend_string *key, zval *pData)
 {
        zval *retval;
 
        begin_write(ht);
-       retval = _zend_hash_add(TS_HASH(ht), key, pData ZEND_FILE_LINE_RELAY_CC);
+       retval = zend_hash_add(TS_HASH(ht), key, pData);
        end_write(ht);
 
        return retval;
 }
 
-ZEND_API zval *_zend_ts_hash_update(TsHashTable *ht, zend_string *key, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval *zend_ts_hash_update(TsHashTable *ht, zend_string *key, zval *pData)
 {
        zval *retval;
 
        begin_write(ht);
-       retval = _zend_hash_update(TS_HASH(ht), key, pData ZEND_FILE_LINE_RELAY_CC);
+       retval = zend_hash_update(TS_HASH(ht), key, pData);
        end_write(ht);
 
        return retval;
 }
 
-ZEND_API zval *_zend_ts_hash_next_index_insert(TsHashTable *ht, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval *zend_ts_hash_next_index_insert(TsHashTable *ht, zval *pData)
 {
        zval *retval;
 
        begin_write(ht);
-       retval = _zend_hash_next_index_insert(TS_HASH(ht), pData ZEND_FILE_LINE_RELAY_CC);
+       retval = zend_hash_next_index_insert(TS_HASH(ht), pData);
        end_write(ht);
 
        return retval;
 }
 
-ZEND_API zval *_zend_ts_hash_index_update(TsHashTable *ht, zend_ulong h, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval *zend_ts_hash_index_update(TsHashTable *ht, zend_ulong h, zval *pData)
 {
        zval *retval;
 
        begin_write(ht);
-       retval = _zend_hash_index_update(TS_HASH(ht), h, pData ZEND_FILE_LINE_RELAY_CC);
+       retval = zend_hash_index_update(TS_HASH(ht), h, pData);
        end_write(ht);
 
        return retval;
@@ -356,7 +356,7 @@ ZEND_API zval *zend_ts_hash_str_find(TsHashTable *ht, const char *key, size_t le
        return retval;
 }
 
-ZEND_API zval *_zend_ts_hash_str_update(TsHashTable *ht, const char *key, size_t len, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval *zend_ts_hash_str_update(TsHashTable *ht, const char *key, size_t len, zval *pData)
 {
        zval *retval;
 
@@ -367,7 +367,7 @@ ZEND_API zval *_zend_ts_hash_str_update(TsHashTable *ht, const char *key, size_t
        return retval;
 }
 
-ZEND_API zval *_zend_ts_hash_str_add(TsHashTable *ht, const char *key, size_t len, zval *pData ZEND_FILE_LINE_DC)
+ZEND_API zval *zend_ts_hash_str_add(TsHashTable *ht, const char *key, size_t len, zval *pData)
 {
        zval *retval;
 

diff --git a/Zend/zend_ts_hash.h b/Zend/zend_ts_hash.h
index ef882e08202976e561423f26a6667d1ee24f38eb..35760b92ca42f68971a49a6050d749bda5f98e40 100644 (file)
--- a/Zend/zend_ts_hash.h
+++ b/Zend/zend_ts_hash.h
@@ -48,16 +48,10 @@ ZEND_API void zend_ts_hash_clean(TsHashTable *ht);
 
 
 /* additions/updates/changes */
-#define zend_ts_hash_update(ht, key, pData) \
-               _zend_ts_hash_update(ht, key, pData ZEND_FILE_LINE_CC)
-#define zend_ts_hash_add(ht, key, pData) \
-               _zend_ts_hash_add(ht, key, pData ZEND_FILE_LINE_CC)
-
-#define zend_ts_hash_index_update(ht, h, pData) \
-               _zend_ts_hash_index_update(ht, h, pData ZEND_FILE_LINE_CC)
-#define zend_ts_hash_next_index_insert(ht, pData) \
-               _zend_ts_hash_next_index_insert(ht, ht->nNextFreeElement, pData ZEND_FILE_LINE_CC)
-
+ZEND_API zval *zend_ts_hash_update(TsHashTable *ht, zend_string *key, zval *pData);
+ZEND_API zval *zend_ts_hash_add(TsHashTable *ht, zend_string *key, zval *pData);
+ZEND_API zval *zend_ts_hash_index_update(TsHashTable *ht, zend_ulong h, zval *pData);
+ZEND_API zval *zend_ts_hash_next_index_insert(TsHashTable *ht, zval *pData);
 ZEND_API zval* zend_ts_hash_add_empty_element(TsHashTable *ht, zend_string *key);
 
 ZEND_API void zend_ts_hash_graceful_destroy(TsHashTable *ht);
@@ -100,13 +94,8 @@ void zend_ts_hash_display(TsHashTable *ht);
 #endif
 
 ZEND_API zval *zend_ts_hash_str_find(TsHashTable *ht, const char *key, size_t len);
-ZEND_API zval *_zend_ts_hash_str_update(TsHashTable *ht, const char *key, size_t len, zval *pData ZEND_FILE_LINE_DC);
-ZEND_API zval *_zend_ts_hash_str_add(TsHashTable *ht, const char *key, size_t len, zval *pData ZEND_FILE_LINE_DC);
-
-#define zend_ts_hash_str_update(ht, key, len, pData) \
-               _zend_ts_hash_str_update(ht, key, len, pData ZEND_FILE_LINE_CC)
-#define zend_ts_hash_str_add(ht, key, len, pData) \
-               _zend_ts_hash_str_add(ht, key, len, pData ZEND_FILE_LINE_CC)
+ZEND_API zval *zend_ts_hash_str_update(TsHashTable *ht, const char *key, size_t len, zval *pData);
+ZEND_API zval *zend_ts_hash_str_add(TsHashTable *ht, const char *key, size_t len, zval *pData);
 
 static zend_always_inline void *zend_ts_hash_str_find_ptr(TsHashTable *ht, const char *str, size_t len)
 {

diff --git a/Zend/zend_variables.c b/Zend/zend_variables.c
index bd292450d74940548f4a455b46f1a2b4dbd5a00b..e04926aac05c3e07ef2832011547610ad83a4a81 100644 (file)
--- a/Zend/zend_variables.c
+++ b/Zend/zend_variables.c
@@ -28,15 +28,15 @@
 #include "zend_constants.h"
 #include "zend_list.h"
 
-static void ZEND_FASTCALL zend_string_destroy(zend_string *str ZEND_FILE_LINE_DC);
-static void ZEND_FASTCALL zend_reference_destroy(zend_reference *ref ZEND_FILE_LINE_DC);
-static void ZEND_FASTCALL zend_empty_destroy(zend_reference *ref ZEND_FILE_LINE_DC);
+static void ZEND_FASTCALL zend_string_destroy(zend_string *str);
+static void ZEND_FASTCALL zend_reference_destroy(zend_reference *ref);
+static void ZEND_FASTCALL zend_empty_destroy(zend_reference *ref);
 
 #if ZEND_DEBUG
-static void ZEND_FASTCALL zend_array_destroy_wrapper(zend_array *arr ZEND_FILE_LINE_DC);
-static void ZEND_FASTCALL zend_object_destroy_wrapper(zend_object *obj ZEND_FILE_LINE_DC);
-static void ZEND_FASTCALL zend_resource_destroy_wrapper(zend_resource *res ZEND_FILE_LINE_DC);
-static void ZEND_FASTCALL zend_ast_ref_destroy_wrapper(zend_ast_ref *ast ZEND_FILE_LINE_DC);
+static void ZEND_FASTCALL zend_array_destroy_wrapper(zend_array *arr);
+static void ZEND_FASTCALL zend_object_destroy_wrapper(zend_object *obj);
+static void ZEND_FASTCALL zend_resource_destroy_wrapper(zend_resource *res);
+static void ZEND_FASTCALL zend_ast_ref_destroy_wrapper(zend_ast_ref *ast);
 #else
 # define zend_array_destroy_wrapper    zend_array_destroy
 # define zend_object_destroy_wrapper   zend_objects_store_del
@@ -44,7 +44,7 @@ static void ZEND_FASTCALL zend_ast_ref_destroy_wrapper(zend_ast_ref *ast ZEND_FI
 # define zend_ast_ref_destroy_wrapper  zend_ast_ref_destroy
 #endif
 
-typedef void (ZEND_FASTCALL *zend_rc_dtor_func_t)(zend_refcounted *p ZEND_FILE_LINE_DC);
+typedef void (ZEND_FASTCALL *zend_rc_dtor_func_t)(zend_refcounted *p);
 
 static const zend_rc_dtor_func_t zend_rc_dtor_func[] = {
        /* IS_UNDEF        */ (zend_rc_dtor_func_t)zend_empty_destroy,
@@ -61,60 +61,60 @@ static const zend_rc_dtor_func_t zend_rc_dtor_func[] = {
        /* IS_CONSTANT_AST */ (zend_rc_dtor_func_t)zend_ast_ref_destroy_wrapper
 };
 
-ZEND_API void ZEND_FASTCALL _rc_dtor_func(zend_refcounted *p ZEND_FILE_LINE_DC)
+ZEND_API void ZEND_FASTCALL rc_dtor_func(zend_refcounted *p)
 {
        ZEND_ASSERT(GC_TYPE(p) <= IS_CONSTANT_AST);
-       zend_rc_dtor_func[GC_TYPE(p)](p ZEND_FILE_LINE_RELAY_CC);
+       zend_rc_dtor_func[GC_TYPE(p)](p);
 }
 
-static void ZEND_FASTCALL zend_string_destroy(zend_string *str ZEND_FILE_LINE_DC)
+static void ZEND_FASTCALL zend_string_destroy(zend_string *str)
 {
-       CHECK_ZVAL_STRING_REL(str);
+       CHECK_ZVAL_STRING(str);
        ZEND_ASSERT(!ZSTR_IS_INTERNED(str));
        ZEND_ASSERT(GC_REFCOUNT(str) == 0);
        ZEND_ASSERT(!(GC_FLAGS(str) & IS_STR_PERSISTENT));
        efree(str);
 }
 
-static void ZEND_FASTCALL zend_reference_destroy(zend_reference *ref ZEND_FILE_LINE_DC)
+static void ZEND_FASTCALL zend_reference_destroy(zend_reference *ref)
 {
-       i_zval_ptr_dtor(&ref->val ZEND_FILE_LINE_RELAY_CC);
+       i_zval_ptr_dtor(&ref->val ZEND_FILE_LINE_CC);
        efree_size(ref, sizeof(zend_reference));
 }
 
-static void ZEND_FASTCALL zend_empty_destroy(zend_reference *ref ZEND_FILE_LINE_DC)
+static void ZEND_FASTCALL zend_empty_destroy(zend_reference *ref)
 {
 }
 
 #if ZEND_DEBUG
-static void ZEND_FASTCALL zend_array_destroy_wrapper(zend_array *arr ZEND_FILE_LINE_DC)
+static void ZEND_FASTCALL zend_array_destroy_wrapper(zend_array *arr)
 {
        zend_array_destroy(arr);
 }
 
-static void ZEND_FASTCALL zend_object_destroy_wrapper(zend_object *obj ZEND_FILE_LINE_DC)
+static void ZEND_FASTCALL zend_object_destroy_wrapper(zend_object *obj)
 {
        zend_objects_store_del(obj);
 }
 
-static void ZEND_FASTCALL zend_resource_destroy_wrapper(zend_resource *res ZEND_FILE_LINE_DC)
+static void ZEND_FASTCALL zend_resource_destroy_wrapper(zend_resource *res)
 {
        zend_list_free(res);
 }
 
-static void ZEND_FASTCALL zend_ast_ref_destroy_wrapper(zend_ast_ref *ast ZEND_FILE_LINE_DC)
+static void ZEND_FASTCALL zend_ast_ref_destroy_wrapper(zend_ast_ref *ast)
 {
        zend_ast_ref_destroy(ast);
 }
 #endif
 
-ZEND_API void _zval_ptr_dtor(zval *zval_ptr ZEND_FILE_LINE_DC) /* {{{ */
+ZEND_API void zval_ptr_dtor(zval *zval_ptr) /* {{{ */
 {
-       i_zval_ptr_dtor(zval_ptr ZEND_FILE_LINE_RELAY_CC);
+       i_zval_ptr_dtor(zval_ptr ZEND_FILE_LINE_CC);
 }
 /* }}} */
 
-ZEND_API void _zval_internal_ptr_dtor(zval *zval_ptr ZEND_FILE_LINE_DC) /* {{{ */
+ZEND_API void zval_internal_ptr_dtor(zval *zval_ptr) /* {{{ */
 {
        if (Z_REFCOUNTED_P(zval_ptr)) {
                zend_refcounted *ref = Z_COUNTED_P(zval_ptr);
@@ -123,7 +123,7 @@ ZEND_API void _zval_internal_ptr_dtor(zval *zval_ptr ZEND_FILE_LINE_DC) /* {{{ *
                        if (Z_TYPE_P(zval_ptr) == IS_STRING) {
                                zend_string *str = (zend_string*)ref;
 
-                               CHECK_ZVAL_STRING_REL(str);
+                               CHECK_ZVAL_STRING(str);
                                ZEND_ASSERT(!ZSTR_IS_INTERNED(str));
                                ZEND_ASSERT((GC_FLAGS(str) & IS_STR_PERSISTENT));
                                free(str);
@@ -150,32 +150,17 @@ ZEND_API void zval_add_ref(zval *p)
        }
 }
 
-ZEND_API void ZEND_FASTCALL _zval_copy_ctor_func(zval *zvalue ZEND_FILE_LINE_DC)
+ZEND_API void ZEND_FASTCALL zval_copy_ctor_func(zval *zvalue)
 {
        if (EXPECTED(Z_TYPE_P(zvalue) == IS_ARRAY)) {
                ZVAL_ARR(zvalue, zend_array_dup(Z_ARRVAL_P(zvalue)));
        } else if (EXPECTED(Z_TYPE_P(zvalue) == IS_STRING)) {
                ZEND_ASSERT(!ZSTR_IS_INTERNED(Z_STR_P(zvalue)));
-               CHECK_ZVAL_STRING_REL(Z_STR_P(zvalue));
+               CHECK_ZVAL_STRING(Z_STR_P(zvalue));
                ZVAL_NEW_STR(zvalue, zend_string_dup(Z_STR_P(zvalue), 0));
        }
 }
 
-
-#if ZEND_DEBUG
-ZEND_API void _zval_ptr_dtor_wrapper(zval *zval_ptr)
-{
-
-       i_zval_ptr_dtor(zval_ptr ZEND_FILE_LINE_CC);
-}
-
-
-ZEND_API void _zval_internal_ptr_dtor_wrapper(zval *zval_ptr)
-{
-       zval_internal_ptr_dtor(zval_ptr);
-}
-#endif
-
 /*
  * Local variables:
  * tab-width: 4

diff --git a/Zend/zend_variables.h b/Zend/zend_variables.h
index 2dcd106da69a874b92550530ca900948998a2f09..3d1e390994f898fcdfa175ecfad74e2b5829ec97 100644 (file)
--- a/Zend/zend_variables.h
+++ b/Zend/zend_variables.h
@@ -28,16 +28,13 @@
 
 BEGIN_EXTERN_C()
 
-ZEND_API void ZEND_FASTCALL _rc_dtor_func(zend_refcounted *p ZEND_FILE_LINE_DC);
-ZEND_API void ZEND_FASTCALL _zval_copy_ctor_func(zval *zvalue ZEND_FILE_LINE_DC);
+ZEND_API void ZEND_FASTCALL rc_dtor_func(zend_refcounted *p);
+ZEND_API void ZEND_FASTCALL zval_copy_ctor_func(zval *zvalue);
 
-#define rc_dtor_func(ref)         _rc_dtor_func(ref ZEND_FILE_LINE_CC)
-#define zval_copy_ctor_func(zv)   _zval_copy_ctor_func(zv ZEND_FILE_LINE_CC)
-
-static zend_always_inline void _zval_ptr_dtor_nogc(zval *zval_ptr ZEND_FILE_LINE_DC)
+static zend_always_inline void zval_ptr_dtor_nogc(zval *zval_ptr)
 {
        if (Z_REFCOUNTED_P(zval_ptr) && !Z_DELREF_P(zval_ptr)) {
-               _rc_dtor_func(Z_COUNTED_P(zval_ptr) ZEND_FILE_LINE_RELAY_CC);
+               rc_dtor_func(Z_COUNTED_P(zval_ptr));
        }
 }
 
@@ -46,14 +43,14 @@ static zend_always_inline void i_zval_ptr_dtor(zval *zval_ptr ZEND_FILE_LINE_DC)
        if (Z_REFCOUNTED_P(zval_ptr)) {
                zend_refcounted *ref = Z_COUNTED_P(zval_ptr);
                if (!GC_DELREF(ref)) {
-                       _rc_dtor_func(ref ZEND_FILE_LINE_RELAY_CC);
+                       rc_dtor_func(ref);
                } else {
                        gc_check_possible_root(ref);
                }
        }
 }
 
-static zend_always_inline void _zval_copy_ctor(zval *zvalue ZEND_FILE_LINE_DC)
+static zend_always_inline void zval_copy_ctor(zval *zvalue)
 {
        if (Z_TYPE_P(zvalue) == IS_ARRAY) {
                ZVAL_ARR(zvalue, zend_array_dup(Z_ARR_P(zvalue)));
@@ -62,7 +59,7 @@ static zend_always_inline void _zval_copy_ctor(zval *zvalue ZEND_FILE_LINE_DC)
        }
 }
 
-static zend_always_inline void _zval_opt_copy_ctor(zval *zvalue ZEND_FILE_LINE_DC)
+static zend_always_inline void zval_opt_copy_ctor(zval *zvalue)
 {
        if (Z_OPT_TYPE_P(zvalue) == IS_ARRAY) {
                ZVAL_ARR(zvalue, zend_array_dup(Z_ARR_P(zvalue)));
@@ -81,35 +78,22 @@ static zend_always_inline void zval_ptr_dtor_str(zval *zval_ptr)
        }
 }
 
-ZEND_API void _zval_ptr_dtor(zval *zval_ptr ZEND_FILE_LINE_DC);
-ZEND_API void _zval_internal_ptr_dtor(zval *zvalue ZEND_FILE_LINE_DC);
-#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_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)
-#define zval_internal_ptr_dtor(zvalue) _zval_internal_ptr_dtor((zvalue) ZEND_FILE_LINE_CC)
+ZEND_API void zval_ptr_dtor(zval *zval_ptr);
+ZEND_API void zval_internal_ptr_dtor(zval *zvalue);
 
 /* Kept for compatibility */
 #define zval_dtor(zvalue) zval_ptr_dtor_nogc(zvalue)
-#define zval_internal_dtor(zvalue) _zval_internal_ptr_dtor((zvalue) ZEND_FILE_LINE_CC)
-#define zval_dtor_func _rc_dtor_func
-
-#if ZEND_DEBUG
-ZEND_API void _zval_ptr_dtor_wrapper(zval *zval_ptr);
-ZEND_API void _zval_internal_ptr_dtor_wrapper(zval *zvalue);
-#define zval_ptr_dtor_wrapper _zval_ptr_dtor_wrapper
-#define zval_internal_ptr_dtor_wrapper _zval_internal_ptr_dtor_wrapper
-#else
-#define zval_ptr_dtor_wrapper _zval_ptr_dtor
-#define zval_internal_ptr_dtor_wrapper _zval_internal_ptr_dtor
-#endif
+#define zval_internal_dtor(zvalue) zval_internal_ptr_dtor(zvalue)
+#define zval_dtor_func rc_dtor_func
+#define zval_ptr_dtor_wrapper zval_ptr_dtor
+#define zval_internal_ptr_dtor_wrapper zval_internal_ptr_dtor
 
 ZEND_API void zval_add_ref(zval *p);
 
 END_EXTERN_C()
 
-#define ZVAL_PTR_DTOR zval_ptr_dtor_wrapper
-#define ZVAL_INTERNAL_PTR_DTOR zval_internal_ptr_dtor_wrapper
+#define ZVAL_PTR_DTOR zval_ptr_dtor
+#define ZVAL_INTERNAL_PTR_DTOR zval_internal_ptr_dtor
 
 #endif
 

diff --git a/sapi/phpdbg/phpdbg.h b/sapi/phpdbg/phpdbg.h
index 7560eec7e002bba87df5c557ffe29f9fb998e55b..6d78033b5c0f777ce9d7c4db7e989b9136047449 100644 (file)
--- a/sapi/phpdbg/phpdbg.h
+++ b/sapi/phpdbg/phpdbg.h
@@ -76,10 +76,10 @@
 #undef zend_hash_str_add
 #ifdef PHP_WIN32
 #define zend_hash_str_add(...) \
-       _zend_hash_str_add(__VA_ARGS__ ZEND_FILE_LINE_CC)
+       zend_hash_str_add(__VA_ARGS__)
 #else
 #define zend_hash_str_add_tmp(ht, key, len, pData) \
-       _zend_hash_str_add(ht, key, len, pData ZEND_FILE_LINE_CC)
+       zend_hash_str_add(ht, key, len, pData)
 #define zend_hash_str_add(...) zend_hash_str_add_tmp(__VA_ARGS__)
 #endif