if (Z_OBJ_HANDLER_P(expr, get)) {
zval *z = Z_OBJ_HANDLER_P(expr, get)(expr TSRMLS_CC);
- z->refcount++;
+ Z_ADDREF_P(z);
if(Z_TYPE_P(z) != IS_OBJECT) {
zend_make_string_zval(z, expr_copy, use_copy);
if (*use_copy) {
if (Z_OBJ_HANDLER_P(expr, get)) {
zval *z = Z_OBJ_HANDLER_P(expr, get)(expr TSRMLS_CC);
- z->refcount++;
+ Z_ADDREF_P(z);
if(Z_TYPE_P(z) != IS_OBJECT) {
zend_make_printable_zval(z, expr_copy, use_copy);
if (*use_copy) {
if (Z_OBJ_HANDLER_P(expr, get)) {
zval *z = Z_OBJ_HANDLER_P(expr, get)(expr TSRMLS_CC);
- z->refcount++;
+ Z_ADDREF_P(z);
if(Z_TYPE_P(z) != IS_OBJECT) {
zend_make_unicode_zval(z, expr_copy, use_copy);
if (*use_copy) {
/* This zval can be used to initialize allocate zval's to an uninit'ed value */
- zval_used_for_init.is_ref = 0;
- zval_used_for_init.refcount = 1;
+ zval_used_for_init.is_ref__gc = 0;
+ zval_used_for_init.refcount__gc = 1;
Z_TYPE(zval_used_for_init) = IS_NULL;
#ifdef ZTS
struct _zval_struct {
/* Variable information */
zvalue_value value; /* value */
- zend_uint refcount;
+ zend_uint refcount__gc;
zend_uchar type; /* active type */
- zend_uchar is_ref;
+ zend_uchar is_ref__gc;
zend_uchar idx_type; /* type of element's index in constant array */
};
+#define Z_REFCOUNT_PP(ppz) Z_REFCOUNT_P(*(ppz))
+#define Z_SET_REFCOUNT_PP(ppz, rc) Z_SET_REFCOUNT_P(*(ppz), rc)
+#define Z_ADDREF_PP(ppz) Z_ADDREF_P(*(ppz))
+#define Z_DELREF_PP(ppz) Z_DELREF_P(*(ppz))
+#define Z_ISREF_PP(ppz) Z_ISREF_P(*(ppz))
+#define Z_SET_ISREF_PP(ppz) Z_SET_ISREF_P(*(ppz))
+#define Z_UNSET_ISREF_PP(ppz) Z_UNSET_ISREF_P(*(ppz))
+#define Z_SET_ISREF_TO_PP(ppz, isref) Z_SET_ISREF_TO_P(*(ppz), isref)
+
+#define Z_REFCOUNT_P(pz) zval_refcount_p(pz)
+#define Z_SET_REFCOUNT_P(pz, rc) zval_set_refcount_p(pz, rc)
+#define Z_ADDREF_P(pz) zval_addref_p(pz)
+#define Z_DELREF_P(pz) zval_delref_p(pz)
+#define Z_ISREF_P(pz) zval_isref_p(pz)
+#define Z_SET_ISREF_P(pz) zval_set_isref_p(pz)
+#define Z_UNSET_ISREF_P(pz) zval_unset_isref_p(pz)
+#define Z_SET_ISREF_TO_P(pz, isref) zval_set_isref_to_p(pz, isref)
+
+#define Z_REFCOUNT(z) Z_REFCOUNT_P(&(z))
+#define Z_SET_REFCOUNT(z, rc) Z_SET_REFCOUNT_P(&(z), rc)
+#define Z_ADDREF(z) Z_ADDREF_P(&(z))
+#define Z_DELREF(z) Z_DELREF_P(&(z))
+#define Z_ISREF(z) Z_ISREF_P(&(z))
+#define Z_SET_ISREF(z) Z_SET_ISREF_P(&(z))
+#define Z_UNSET_ISREF(z) Z_UNSET_ISREF_P(&(z))
+#define Z_SET_ISREF_TO(z, isref) Z_SET_ISREF_TO_P(&(z), isref)
+
+#if defined(__GNUC__)
+#define always_inline inline __attribute__((always_inline))
+#elif defined(_MSC_VER)
+#define always_inline __forceinline
+#else
+#define always_inline inline
+#endif
+
+static always_inline zend_uint zval_refcount_p(zval* pz) {
+ return pz->refcount__gc;
+}
+
+static always_inline zend_uint zval_set_refcount_p(zval* pz, zend_uint rc) {
+ return pz->refcount__gc = rc;
+}
+
+static always_inline zend_uint zval_addref_p(zval* pz) {
+ return ++pz->refcount__gc;
+}
+
+static always_inline zend_uint zval_delref_p(zval* pz) {
+ return --pz->refcount__gc;
+}
+
+static always_inline zend_bool zval_isref_p(zval* pz) {
+ return pz->is_ref__gc;
+}
+
+static always_inline zend_bool zval_set_isref_p(zval* pz) {
+ return pz->is_ref__gc = 1;
+}
+
+static always_inline zend_bool zval_unset_isref_p(zval* pz) {
+ return pz->is_ref__gc = 0;
+}
+
+static always_inline zend_bool zval_set_isref_to_p(zval* pz, zend_bool isref) {
+
+ return pz->is_ref__gc = isref;
+}
+
/* excpt.h on Digital Unix 4.0 defines function_table */
#undef function_table
#define ZMSG_MEMORY_LEAKS_GRAND_TOTAL 7L
-#define ZVAL_ADDREF(pz) (++(pz)->refcount)
-#define ZVAL_DELREF(pz) (--(pz)->refcount)
-#define ZVAL_REFCOUNT(pz) ((pz)->refcount)
-
#define INIT_PZVAL(z) \
- (z)->refcount = 1; \
- (z)->is_ref = 0;
+ (z)->refcount__gc = 1; \
+ (z)->is_ref__gc = 0;
#define INIT_ZVAL(z) z = zval_used_for_init;
ALLOC_ZVAL(zv); \
INIT_PZVAL(zv);
-#define PZVAL_IS_REF(z) ((z)->is_ref)
+#define PZVAL_IS_REF(z) Z_ISREF_P(z)
#define SEPARATE_ZVAL(ppzv) \
{ \
zval *orig_ptr = *(ppzv); \
\
- if (orig_ptr->refcount>1) { \
- orig_ptr->refcount--; \
+ if (Z_REFCOUNT_P(orig_ptr) > 1) { \
+ Z_DELREF_P(orig_ptr); \
ALLOC_ZVAL(*(ppzv)); \
**(ppzv) = *orig_ptr; \
zval_copy_ctor(*(ppzv)); \
- (*(ppzv))->refcount=1; \
- (*(ppzv))->is_ref = 0; \
+ Z_SET_REFCOUNT_PP(ppzv, 1); \
+ Z_UNSET_ISREF_PP((ppzv)); \
} \
}
#define SEPARATE_ZVAL_TO_MAKE_IS_REF(ppzv) \
if (!PZVAL_IS_REF(*ppzv)) { \
SEPARATE_ZVAL(ppzv); \
- (*(ppzv))->is_ref = 1; \
+ Z_SET_ISREF_PP((ppzv)); \
}
#define COPY_PZVAL_TO_ZVAL(zv, pzv) \
(zv) = *(pzv); \
- if ((pzv)->refcount>1) { \
+ if (Z_REFCOUNT_P(pzv)>1) { \
zval_copy_ctor(&(zv)); \
- (pzv)->refcount--; \
+ Z_DELREF_P((pzv)); \
} else { \
FREE_ZVAL(pzv); \
} \
int is_ref, refcount; \
\
SEPARATE_ZVAL_IF_NOT_REF(ppzv_dest); \
- is_ref = (*ppzv_dest)->is_ref; \
- refcount = (*ppzv_dest)->refcount; \
+ is_ref = Z_ISREF_PP(ppzv_dest); \
+ refcount = Z_REFCOUNT_PP(ppzv_dest); \
zval_dtor(*ppzv_dest); \
**ppzv_dest = *pzv_src; \
if (copy) { \
zval_copy_ctor(*ppzv_dest); \
} \
- (*ppzv_dest)->is_ref = is_ref; \
- (*ppzv_dest)->refcount = refcount; \
+ Z_SET_ISREF_TO_PP(ppzv_dest, is_ref); \
+ Z_SET_REFCOUNT_PP(ppzv_dest, refcount); \
}
#define SEPARATE_ARG_IF_REF(varptr) \
ALLOC_ZVAL(varptr); \
varptr->value = original_var->value; \
Z_TYPE_P(varptr) = Z_TYPE_P(original_var); \
- varptr->is_ref = 0; \
- varptr->refcount = 1; \
+ Z_UNSET_ISREF_P(varptr); \
+ Z_SET_REFCOUNT_P(varptr, 1); \
zval_copy_ctor(varptr); \
} else { \
- varptr->refcount++; \
+ Z_ADDREF_P(varptr); \
}
#define READY_TO_DESTROY(zv) \
- ((zv)->refcount == 1 && \
+ (Z_REFCOUNT_P(zv) == 1 && \
(Z_TYPE_P(zv) != IS_OBJECT || \
zend_objects_store_get_refcount(zv TSRMLS_CC) == 1))
while (param_count-->0) {
param = va_arg(ptr, zval **);
param_ptr = *(p-arg_count);
- if (!PZVAL_IS_REF(param_ptr) && param_ptr->refcount>1) {
+ if (!PZVAL_IS_REF(param_ptr) && Z_REFCOUNT_P(param_ptr) > 1) {
zval *new_tmp;
ALLOC_ZVAL(new_tmp);
zval_copy_ctor(new_tmp);
INIT_PZVAL(new_tmp);
param_ptr = new_tmp;
- ((zval *) *(p-arg_count))->refcount--;
+ Z_DELREF_P((zval *) *(p-arg_count));
*(p-arg_count) = param_ptr;
}
*param = param_ptr;
while (param_count-->0) {
param_ptr = *(p-arg_count);
- if (!PZVAL_IS_REF(param_ptr) && param_ptr->refcount>1) {
+ if (!PZVAL_IS_REF(param_ptr) && Z_REFCOUNT_P(param_ptr) > 1) {
zval *new_tmp;
ALLOC_ZVAL(new_tmp);
zval_copy_ctor(new_tmp);
INIT_PZVAL(new_tmp);
param_ptr = new_tmp;
- ((zval *) *(p-arg_count))->refcount--;
+ Z_DELREF_P((zval *) *(p-arg_count));
*(p-arg_count) = param_ptr;
}
*(argument_array++) = param_ptr;
if (!Z_OBJ_HANDLER_PP(arg, cast_object) && Z_OBJ_HANDLER_PP(arg, get)) {
int use_copy;
zval *z = Z_OBJ_HANDLER_PP(arg, get)(*arg TSRMLS_CC);
- z->refcount++;
+ Z_ADDREF_P(z);
if(Z_TYPE_P(z) != IS_OBJECT) {
zval_dtor(*arg);
Z_TYPE_P(*arg) = IS_NULL;
utype = IS_STRING;
break;
}
- if ((*p)->is_ref &&
+ if (Z_ISREF_PP(p) &&
class_type->parent &&
zend_u_hash_find(&class_type->parent->default_static_members, utype, str_index, str_length, (void**)&q) == SUCCESS &&
*p == *q &&
zend_u_hash_find(CE_STATIC_MEMBERS(class_type->parent), utype, str_index, str_length, (void**)&q) == SUCCESS) {
- (*q)->refcount++;
- (*q)->is_ref = 1;
+ Z_ADDREF_PP(q);
+ Z_SET_ISREF_PP(q);
zend_u_hash_add(CE_STATIC_MEMBERS(class_type), utype, str_index, str_length, (void**)q, sizeof(zval*), NULL);
} else {
zval *q;
if (num_symbol_tables <= 0) return FAILURE;
- symbol->is_ref = is_ref;
+ Z_SET_ISREF_TO_P(symbol, is_ref);
va_start(symbol_table_list, num_symbol_tables);
while (num_symbol_tables-- > 0) {
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(args), &pos);
while (zend_hash_get_current_data_ex(Z_ARRVAL_P(args), (void *) &arg, &pos) == SUCCESS) {
*params++ = arg;
- ZVAL_ADDREF(*arg);
+ Z_ADDREF_P(*arg);
zend_hash_move_forward_ex(Z_ARRVAL_P(args), &pos);
}
fci->params = (zval ***) erealloc(fci->params, fci->param_count * sizeof(zval **));
for (i = 0; i < argc; ++i) {
- ZVAL_ADDREF(*(argv[i]));
+ Z_ADDREF_P(*(argv[i]));
fci->params[i] = argv[i];
}
}
for (i = 0; i < argc; ++i) {
arg = va_arg(*argv, zval **);
- ZVAL_ADDREF(*arg);
+ Z_ADDREF_P(*arg);
fci->params[i] = arg;
}
}
zval *tmp;
ALLOC_ZVAL(tmp);
- tmp->is_ref = 0;
- tmp->refcount = 0;
+ Z_UNSET_ISREF_P(tmp);
+ Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_NULL(tmp);
zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC);
}
zval *tmp;
ALLOC_ZVAL(tmp);
- tmp->is_ref = 0;
- tmp->refcount = 0;
+ Z_UNSET_ISREF_P(tmp);
+ Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_BOOL(tmp, value);
zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC);
}
zval *tmp;
ALLOC_ZVAL(tmp);
- tmp->is_ref = 0;
- tmp->refcount = 0;
+ Z_UNSET_ISREF_P(tmp);
+ Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_LONG(tmp, value);
zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC);
}
zval *tmp;
ALLOC_ZVAL(tmp);
- tmp->is_ref = 0;
- tmp->refcount = 0;
+ Z_UNSET_ISREF_P(tmp);
+ Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_DOUBLE(tmp, value);
zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC);
}
zval *tmp;
ALLOC_ZVAL(tmp);
- tmp->is_ref = 0;
- tmp->refcount = 0;
+ Z_UNSET_ISREF_P(tmp);
+ Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_STRING(tmp, value, 1);
zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC);
}
zval *tmp;
ALLOC_ZVAL(tmp);
- tmp->is_ref = 0;
- tmp->refcount = 0;
+ Z_UNSET_ISREF_P(tmp);
+ Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_STRINGL(tmp, value, value_len, 1);
zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC);
}
zval *tmp;
ALLOC_ZVAL(tmp);
- tmp->is_ref = 0;
- tmp->refcount = 0;
+ Z_UNSET_ISREF_P(tmp);
+ Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_ASCII_STRING(tmp, value, 1);
zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC);
}
zval *tmp;
ALLOC_ZVAL(tmp);
- tmp->is_ref = 0;
- tmp->refcount = 0;
+ Z_UNSET_ISREF_P(tmp);
+ Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_ASCII_STRINGL(tmp, value, value_len, 1);
zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC);
}
zval *tmp;
ALLOC_ZVAL(tmp);
- tmp->is_ref = 0;
- tmp->refcount = 0;
+ Z_UNSET_ISREF_P(tmp);
+ Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_RT_STRING(tmp, value, 1);
zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC);
}
zval *tmp;
ALLOC_ZVAL(tmp);
- tmp->is_ref = 0;
- tmp->refcount = 0;
+ Z_UNSET_ISREF_P(tmp);
+ Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_RT_STRINGL(tmp, value, value_len, 1);
zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC);
}
zval *tmp;
ALLOC_ZVAL(tmp);
- tmp->is_ref = 0;
- tmp->refcount = 0;
+ Z_UNSET_ISREF_P(tmp);
+ Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_UNICODE(tmp, value, 1);
zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC);
}
zval *tmp;
ALLOC_ZVAL(tmp);
- tmp->is_ref = 0;
- tmp->refcount = 0;
+ Z_UNSET_ISREF_P(tmp);
+ Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_UNICODEL(tmp, value, value_len, 1);
zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC);
}
zval_dtor(*property);
Z_TYPE_PP(property) = Z_TYPE_P(value);
(*property)->value = value->value;
- if (value->refcount > 0) {
+ if (Z_REFCOUNT_P(value) > 0) {
zval_copy_ctor(*property);
}
} else {
zval *garbage = *property;
- value->refcount++;
+ Z_ADDREF_P(value);
if (PZVAL_IS_REF(value)) {
SEPARATE_ZVAL(&value);
}
zval *tmp;
ALLOC_ZVAL(tmp);
- tmp->is_ref = 0;
- tmp->refcount = 0;
+ Z_UNSET_ISREF_P(tmp);
+ Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_NULL(tmp);
return zend_update_static_property(scope, name, name_length, tmp TSRMLS_CC);
}
zval *tmp;
ALLOC_ZVAL(tmp);
- tmp->is_ref = 0;
- tmp->refcount = 0;
+ Z_UNSET_ISREF_P(tmp);
+ Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_BOOL(tmp, value);
return zend_update_static_property(scope, name, name_length, tmp TSRMLS_CC);
}
zval *tmp;
ALLOC_ZVAL(tmp);
- tmp->is_ref = 0;
- tmp->refcount = 0;
+ Z_UNSET_ISREF_P(tmp);
+ Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_LONG(tmp, value);
return zend_update_static_property(scope, name, name_length, tmp TSRMLS_CC);
}
zval *tmp;
ALLOC_ZVAL(tmp);
- tmp->is_ref = 0;
- tmp->refcount = 0;
+ Z_UNSET_ISREF_P(tmp);
+ Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_DOUBLE(tmp, value);
return zend_update_static_property(scope, name, name_length, tmp TSRMLS_CC);
}
zval *tmp;
ALLOC_ZVAL(tmp);
- tmp->is_ref = 0;
- tmp->refcount = 0;
+ Z_UNSET_ISREF_P(tmp);
+ Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_STRING(tmp, value, 1);
return zend_update_static_property(scope, name, name_length, tmp TSRMLS_CC);
}
zval *tmp;
ALLOC_ZVAL(tmp);
- tmp->is_ref = 0;
- tmp->refcount = 0;
+ Z_UNSET_ISREF_P(tmp);
+ Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_STRINGL(tmp, value, value_len, 1);
return zend_update_static_property(scope, name, name_length, tmp TSRMLS_CC);
}
zval *tmp;
ALLOC_ZVAL(tmp);
- tmp->is_ref = 0;
- tmp->refcount = 0;
+ Z_UNSET_ISREF_P(tmp);
+ Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_ASCII_STRING(tmp, value, 1);
return zend_update_static_property(scope, name, name_length, tmp TSRMLS_CC);
}
zval *tmp;
ALLOC_ZVAL(tmp);
- tmp->is_ref = 0;
- tmp->refcount = 0;
+ Z_UNSET_ISREF_P(tmp);
+ Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_ASCII_STRINGL(tmp, value, value_len, 1);
return zend_update_static_property(scope, name, name_length, tmp TSRMLS_CC);
}
zval *tmp;
ALLOC_ZVAL(tmp);
- tmp->is_ref = 0;
- tmp->refcount = 0;
+ Z_UNSET_ISREF_P(tmp);
+ Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_RT_STRING(tmp, value, 1);
return zend_update_static_property(scope, name, name_length, tmp TSRMLS_CC);
}
zval *tmp;
ALLOC_ZVAL(tmp);
- tmp->is_ref = 0;
- tmp->refcount = 0;
+ Z_UNSET_ISREF_P(tmp);
+ Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_RT_STRINGL(tmp, value, value_len, 1);
return zend_update_static_property(scope, name, name_length, tmp TSRMLS_CC);
}
zval *tmp;
ALLOC_ZVAL(tmp);
- tmp->is_ref = 0;
- tmp->refcount = 0;
+ Z_UNSET_ISREF_P(tmp);
+ Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_UNICODE(tmp, value, 1);
return zend_update_static_property(scope, name, name_length, tmp TSRMLS_CC);
}
zval *tmp;
ALLOC_ZVAL(tmp);
- tmp->is_ref = 0;
- tmp->refcount = 0;
+ Z_UNSET_ISREF_P(tmp);
+ Z_SET_REFCOUNT_P(tmp, 0);
ZVAL_UNICODEL(tmp, value, value_len, 1);
return zend_update_static_property(scope, name, name_length, tmp TSRMLS_CC);
}
#define ZVAL_ZVAL(z, zv, copy, dtor) { \
int is_ref, refcount; \
- is_ref = (z)->is_ref; \
- refcount = (z)->refcount; \
+ is_ref = Z_ISREF_P(z); \
+ refcount = Z_REFCOUNT_P(z); \
*(z) = *(zv); \
if (copy) { \
zval_copy_ctor(z); \
} \
zval_ptr_dtor(&zv); \
} \
- (z)->is_ref = is_ref; \
- (z)->refcount = refcount; \
+ Z_SET_ISREF_TO_P(z, is_ref); \
+ Z_SET_REFCOUNT_P(z, refcount); \
}
#define ZVAL_TEXT(z, t, duplicate) \
\
if (zend_u_hash_find(symtable, (type), (name), (name_length), (void **) &orig_var)==SUCCESS \
&& PZVAL_IS_REF(*orig_var)) { \
- (var)->refcount = (*orig_var)->refcount; \
- (var)->is_ref = 1; \
+ Z_SET_REFCOUNT_P(var, Z_REFCOUNT_PP(orig_var)); \
+ Z_SET_ISREF_P(var); \
\
if (_refcount) { \
- (var)->refcount += _refcount-1; \
+ Z_SET_REFCOUNT_P(var, Z_REFCOUNT_P(var) + _refcount - 1); \
} \
zval_dtor(*orig_var); \
**orig_var = *(var); \
FREE_ZVAL(var); \
} else { \
- (var)->is_ref = _is_ref; \
+ Z_SET_ISREF_TO_P(var, _is_ref); \
if (_refcount) { \
- (var)->refcount = _refcount; \
+ Z_SET_REFCOUNT_P(var, _refcount); \
} \
zend_u_hash_update(symtable, (type), (name), (name_length), &(var), sizeof(zval *), NULL); \
} \
\
if (zend_rt_hash_find(symtable, (name), (name_length), (void **) &orig_var)==SUCCESS \
&& PZVAL_IS_REF(*orig_var)) { \
- (var)->refcount = (*orig_var)->refcount; \
- (var)->is_ref = 1; \
+ Z_SET_REFCOUNT_P(var, Z_REFCOUNT_PP(orig_var)); \
+ Z_SET_ISREF_P(var); \
\
if (_refcount) { \
- (var)->refcount += _refcount-1; \
+ Z_SET_REFCOUNT_P(var, Z_REFCOUNT_P(var) + _refcount - 1); \
} \
zval_dtor(*orig_var); \
**orig_var = *(var); \
FREE_ZVAL(var); \
} else { \
- (var)->is_ref = _is_ref; \
+ Z_SET_ISREF_TO_P(var, _is_ref); \
if (_refcount) { \
- (var)->refcount = _refcount; \
+ Z_SET_REFCOUNT_P(var, _refcount); \
} \
zend_rt_hash_update(symtable, (name), (name_length), &(var), sizeof(zval *), NULL); \
} \
entry = *entry_ptr;
/* add value elements */
- if (entry->is_ref) {
+ if (Z_ISREF_P(entry)) {
ALLOC_ZVAL(tmp);
*tmp = *entry;
zval_copy_ctor(tmp);
- tmp->is_ref=0;
- tmp->refcount=0;
+ Z_UNSET_ISREF_P(tmp);
+ Z_SET_REFCOUNT_P(tmp, 0);
entry=tmp;
}
zend_hash_index_update(Z_ARRVAL_P(return_value), 1, &entry, sizeof(zval *), NULL);
- entry->refcount++;
+ Z_ADDREF_P(entry);
zend_ascii_hash_update(Z_ARRVAL_P(return_value), "value", sizeof("value"), &entry, sizeof(zval *), NULL);
- entry->refcount++;
+ Z_ADDREF_P(entry);
/* add the key elements */
switch (zend_hash_get_current_key_ex(target_hash, &string_key, &string_key_len, &num_key, 1, NULL)) {
break;
}
zend_ascii_hash_update(Z_ARRVAL_P(return_value), "key", sizeof("key"), inserted_pointer, sizeof(zval *), NULL);
- (*inserted_pointer)->refcount++;
+ Z_ADDREF_PP(inserted_pointer);
zend_hash_move_forward(target_hash);
}
/* }}} */
if (zend_check_property_access(zobj, ZEND_STR_TYPE, key, key_len-1 TSRMLS_CC) == SUCCESS) {
zend_u_unmangle_property_name(ZEND_STR_TYPE, key, key_len-1, &class_name, &prop_name);
/* Not separating references */
- (*value)->refcount++;
+ Z_ADDREF_PP(value);
add_u_assoc_zval(return_value, ZEND_STR_TYPE, prop_name, *value);
}
}
if (Z_TYPE_PP(arg) != IS_OBJECT) {
SEPARATE_ZVAL_TO_MAKE_IS_REF(arg);
}
- (*arg)->refcount++;
+ Z_ADDREF_PP(arg);
add_next_index_zval(arg_array, *arg);
} else {
add_next_index_null(arg_array);
}
if (provide_object) {
add_ascii_assoc_zval_ex(stack_frame, "object", sizeof("object"), ptr->object);
- ptr->object->refcount++;
+ Z_ADDREF_P(ptr->object);
}
add_ascii_assoc_ascii_string_ex(stack_frame, "type", sizeof("type"), "->", 1);
memcpy(Z_STRVAL_P(result)+1+name_length+filename_length, char_pos_buf, char_pos_len+1);
Z_TYPE_P(result) = IS_STRING;
}
- result->refcount = 1;
+ Z_SET_REFCOUNT_P(result, 1);
}
/* }}} */
Z_TYPE(opline->op2.u.constant) = Z_TYPE(function_name->u.constant);
Z_UNIVAL(opline->op2.u.constant) = lcname;
Z_UNILEN(opline->op2.u.constant) = lcname_len;
- opline->op2.u.constant.refcount = 1;
+ Z_SET_REFCOUNT(opline->op2.u.constant, 1);
opline->extended_value = ZEND_DECLARE_FUNCTION;
zend_u_hash_update(CG(function_table), Z_TYPE(opline->op1.u.constant), Z_UNIVAL(opline->op1.u.constant), Z_UNILEN(opline->op1.u.constant), &op_array, sizeof(zend_op_array), (void **) &CG(active_op_array));
}
zval **pvalue;
if (zend_u_hash_quick_find(&parent_ce->default_properties, utype, parent_info->name, parent_info->name_length+1, parent_info->h, (void **) &pvalue) == SUCCESS) {
- (*pvalue)->refcount++;
+ Z_ADDREF_PP(pvalue);
zend_u_hash_del(&ce->default_properties, utype, child_info->name, child_info->name_length+1);
zend_u_hash_quick_update(&ce->default_properties, utype, parent_info->name, parent_info->name_length+1, parent_info->h, pvalue, sizeof(zval *), NULL);
}
parent_ce->name, prop_name, ce->name);
}
}
- (*prop)->refcount++;
+ Z_ADDREF_PP(prop);
zend_u_hash_update(&ce->default_static_members, utype, child_info->name, child_info->name_length+1, (void**)prop, sizeof(zval*), NULL);
zend_u_hash_del(&ce->default_static_members, utype, prot_name, prot_name_length+1);
}
if (!zend_u_hash_quick_exists(target, key->type, key->arKey, key->nKeyLength, key->h)) {
SEPARATE_ZVAL_TO_MAKE_IS_REF(p);
if (zend_u_hash_quick_add(target, key->type, key->arKey, key->nKeyLength, key->h, p, sizeof(zval*), NULL) == SUCCESS) {
- (*p)->refcount++;
+ Z_ADDREF_PP(p);
}
}
return ZEND_HASH_APPLY_KEEP;
opline->op2.op_type = IS_CONST;
Z_TYPE(opline->op2.u.constant) = Z_TYPE(class_name->u.constant);
- opline->op2.u.constant.refcount = 1;
+ Z_SET_REFCOUNT(opline->op2.u.constant, 1);
if (doing_inheritance) {
opline->extended_value = parent_class_name->u.var;
if (retval) {
*result = c->value;
zval_copy_ctor(result);
- result->refcount = 1;
- result->is_ref = 0;
+ Z_SET_REFCOUNT_P(result, 1);
+ Z_UNSET_ISREF_P(result);
}
return retval;
*result = c->value;
zval_update_constant_ex(&result, (void*)1, NULL TSRMLS_CC);
zval_copy_ctor(result);
- result->refcount = 1;
- result->is_ref = 0;
+ Z_SET_REFCOUNT_P(result, 1);
+ Z_UNSET_ISREF_P(result);
return 1;
}
efree(lcname.v);
zend_hash_copy(object->properties, &class_type->default_properties, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
ALLOC_ZVAL(trace);
- trace->is_ref = 0;
- trace->refcount = 0;
+ Z_UNSET_ISREF_P(trace);
+ Z_SET_REFCOUNT_P(trace, 0);
zend_fetch_debug_backtrace(trace, skip_top_traces, 0 TSRMLS_CC);
zend_update_property_rt_string(default_exception_ce, &obj, "file", sizeof("file")-1, zend_get_executed_filename(TSRMLS_C) TSRMLS_CC);
static inline void zend_pzval_unlock_func(zval *z, zend_free_op *should_free, int unref) /* {{{ */
{
- if (!--z->refcount) {
- z->refcount = 1;
- z->is_ref = 0;
+ if (!Z_DELREF_P(z)) {
+ Z_SET_REFCOUNT_P(z, 1);
+ Z_UNSET_ISREF_P(z);
should_free->var = z;
/* should_free->is_var = 1; */
} else {
should_free->var = 0;
- if (unref && z->is_ref && z->refcount == 1) {
- z->is_ref = 0;
+ if (unref && Z_ISREF_P(z) && Z_REFCOUNT_P(z) == 1) {
+ Z_UNSET_ISREF_P(z);
}
}
}
static inline void zend_pzval_unlock_free_func(zval *z) /* {{{ */
{
- if (!--z->refcount) {
+ if (!Z_DELREF_P(z)) {
zval_dtor(z);
safe_free_zval_ptr(z);
}
#define PZVAL_UNLOCK(z, f) zend_pzval_unlock_func(z, f, 1)
#define PZVAL_UNLOCK_EX(z, f, u) zend_pzval_unlock_func(z, f, u)
#define PZVAL_UNLOCK_FREE(z) zend_pzval_unlock_free_func(z)
-#define PZVAL_LOCK(z) (z)->refcount++
+#define PZVAL_LOCK(z) Z_ADDREF_P((z))
#define RETURN_VALUE_UNUSED(pzn) (((pzn)->u.EA.type & EXT_TYPE_UNUSED))
#define SELECTIVE_PZVAL_LOCK(pzv, pzn) if (!RETURN_VALUE_UNUSED(pzn)) { PZVAL_LOCK(pzv); }
#define INIT_PZVAL_COPY(z,v) \
(z)->value = (v)->value; \
Z_TYPE_P(z) = Z_TYPE_P(v); \
- (z)->refcount = 1; \
- (z)->is_ref = 0;
+ Z_SET_REFCOUNT_P((z), 1); \
+ Z_UNSET_ISREF_P(z);
#define MAKE_REAL_ZVAL_PTR(val) \
do { \
ALLOC_ZVAL(_tmp); \
_tmp->value = (val)->value; \
Z_TYPE_P(_tmp) = Z_TYPE_P(val); \
- _tmp->refcount = 1; \
- _tmp->is_ref = 0; \
+ Z_SET_REFCOUNT_P(_tmp, 1); \
+ Z_UNSET_ISREF_P(_tmp); \
val = _tmp; \
} while (0)
{
zval *new_zval = &EG(uninitialized_zval);
- new_zval->refcount++;
+ Z_ADDREF_P(new_zval);
zend_u_hash_quick_update(EG(active_symbol_table), utype, cv->name, cv->name_len+1, cv->hash_value, &new_zval, sizeof(zval *), (void **)ptr);
}
/* }}} */
Z_TYPE_P(ptr) = IS_UNICODE;
}
PZVAL_UNLOCK_FREE(str);
- ptr->refcount=1;
- ptr->is_ref=1;
+ Z_SET_REFCOUNT_P(ptr, 1);
+ Z_SET_ISREF_P(ptr);
return ptr;
}
}
} else if (variable_ptr != value_ptr) {
if (!PZVAL_IS_REF(value_ptr)) {
/* break it away */
- value_ptr->refcount--;
- if (value_ptr->refcount>0) {
+ Z_DELREF_P(value_ptr);
+ if (Z_REFCOUNT_P(value_ptr) > 0) {
ALLOC_ZVAL(*value_ptr_ptr);
**value_ptr_ptr = *value_ptr;
value_ptr = *value_ptr_ptr;
zendi_zval_copy_ctor(*value_ptr);
}
- value_ptr->refcount = 1;
- value_ptr->is_ref = 1;
+ Z_SET_REFCOUNT_P(value_ptr, 1);
+ Z_SET_ISREF_P(value_ptr);
}
*variable_ptr_ptr = value_ptr;
- value_ptr->refcount++;
+ Z_ADDREF_P(value_ptr);
zval_ptr_dtor(&variable_ptr);
- } else if (!variable_ptr->is_ref) {
+ } else if (!Z_ISREF_P(variable_ptr)) {
if (variable_ptr_ptr == value_ptr_ptr) {
SEPARATE_ZVAL(variable_ptr_ptr);
} else if (variable_ptr==EG(uninitialized_zval_ptr)
- || variable_ptr->refcount>2) {
+ || Z_REFCOUNT_P(variable_ptr) > 2) {
/* we need to separate */
- variable_ptr->refcount -= 2;
+ Z_DELREF_P(variable_ptr);
+ Z_DELREF_P(variable_ptr);
ALLOC_ZVAL(*variable_ptr_ptr);
**variable_ptr_ptr = *variable_ptr;
zval_copy_ctor(*variable_ptr_ptr);
*value_ptr_ptr = *variable_ptr_ptr;
- (*variable_ptr_ptr)->refcount = 2;
+ Z_SET_REFCOUNT_P((*variable_ptr_ptr), 2);
}
- (*variable_ptr_ptr)->is_ref = 1;
+ Z_SET_ISREF_PP(variable_ptr_ptr);
}
}
/* }}} */
ALLOC_ZVAL(value);
*value = *orig_value;
- value->is_ref = 0;
- value->refcount = 0;
+ Z_UNSET_ISREF_P(value);
+ Z_SET_REFCOUNT_P(value, 0);
} else if (value_op->op_type == IS_CONST) {
zval *orig_value = value;
ALLOC_ZVAL(value);
*value = *orig_value;
- value->is_ref = 0;
- value->refcount = 0;
+ Z_UNSET_ISREF_P(value);
+ Z_SET_REFCOUNT_P(value, 0);
zval_copy_ctor(value);
}
- value->refcount++;
+ Z_ADDREF_P(value);
if (opcode == ZEND_ASSIGN_OBJ) {
if (IS_TMP_FREE(free_op2)) {
MAKE_REAL_ZVAL_PTR(property_name);
if (PZVAL_IS_REF(variable_ptr)) {
if (variable_ptr!=value) {
- zend_uint refcount = variable_ptr->refcount;
+ zend_uint refcount = Z_REFCOUNT_P(variable_ptr);
zval garbage;
if (type!=IS_TMP_VAR) {
- value->refcount++;
+ Z_ADDREF_P(value);
}
garbage = *variable_ptr;
*variable_ptr = *value;
- variable_ptr->refcount = refcount;
- variable_ptr->is_ref = 1;
+ Z_SET_REFCOUNT_P(variable_ptr, refcount);
+ Z_SET_ISREF_P(variable_ptr);
if (type!=IS_TMP_VAR) {
zendi_zval_copy_ctor(*variable_ptr);
- value->refcount--;
+ Z_DELREF_P(value);
}
zendi_zval_dtor(garbage);
}
} else {
- variable_ptr->refcount--;
- if (variable_ptr->refcount==0) {
+ Z_DELREF_P(variable_ptr);
+ if (Z_REFCOUNT_P(variable_ptr) == 0) {
switch (type) {
case IS_CV:
case IS_VAR:
/* break missing intentionally */
case IS_CONST:
if (variable_ptr==value) {
- variable_ptr->refcount++;
+ Z_ADDREF_P(variable_ptr);
} else if (PZVAL_IS_REF(value)) {
zval tmp;
tmp = *value;
zval_copy_ctor(&tmp);
- tmp.refcount=1;
+ Z_SET_REFCOUNT(tmp, 1);
zendi_zval_dtor(*variable_ptr);
*variable_ptr = tmp;
} else {
- value->refcount++;
+ Z_ADDREF_P(value);
zendi_zval_dtor(*variable_ptr);
safe_free_zval_ptr(variable_ptr);
*variable_ptr_ptr = value;
break;
case IS_TMP_VAR:
zendi_zval_dtor(*variable_ptr);
- value->refcount=1;
+ Z_SET_REFCOUNT_P(value, 1);
*variable_ptr = *value;
break;
EMPTY_SWITCH_DEFAULT_CASE()
case IS_VAR:
/* break missing intentionally */
case IS_CONST:
- if (PZVAL_IS_REF(value) && value->refcount > 0) {
+ if (PZVAL_IS_REF(value) && Z_REFCOUNT_P(value) > 0) {
ALLOC_ZVAL(variable_ptr);
*variable_ptr_ptr = variable_ptr;
*variable_ptr = *value;
zval_copy_ctor(variable_ptr);
- variable_ptr->refcount=1;
+ Z_SET_REFCOUNT_P(variable_ptr, 1);
break;
}
*variable_ptr_ptr = value;
- value->refcount++;
+ Z_ADDREF_P(value);
break;
case IS_TMP_VAR:
ALLOC_ZVAL(*variable_ptr_ptr);
- value->refcount=1;
+ Z_SET_REFCOUNT_P(value, 1);
**variable_ptr_ptr = *value;
break;
EMPTY_SWITCH_DEFAULT_CASE()
}
}
- (*variable_ptr_ptr)->is_ref=0;
+ Z_UNSET_ISREF_PP(variable_ptr_ptr);
}
done_setting_var:
static inline void zend_receive(zval **variable_ptr_ptr, zval *value TSRMLS_DC) /* {{{ */
{
- (*variable_ptr_ptr)->refcount--;
+ Z_DELREF_PP(variable_ptr_ptr);
*variable_ptr_ptr = value;
- value->refcount++;
+ Z_ADDREF_P(value);
}
/* }}} */
case BP_VAR_W: {
zval *new_zval = &EG(uninitialized_zval);
- new_zval->refcount++;
+ Z_ADDREF_P(new_zval);
zend_u_symtable_update(ht, ztype, offset_key, offset_key_length + 1, &new_zval, sizeof(zval *), (void **) &retval);
}
break;
case BP_VAR_W: {
zval *new_zval = &EG(uninitialized_zval);
- new_zval->refcount++;
+ Z_ADDREF_P(new_zval);
zend_hash_index_update(ht, index, &new_zval, sizeof(zval *), (void **) &retval);
}
break;
zval **retval;
case IS_ARRAY:
- if ((type==BP_VAR_W || type==BP_VAR_RW) && container->refcount>1 && !PZVAL_IS_REF(container)) {
+ if ((type==BP_VAR_W || type==BP_VAR_RW) && Z_REFCOUNT_P(container) > 1 && !PZVAL_IS_REF(container)) {
SEPARATE_ZVAL(container_ptr);
container = *container_ptr;
}
if (dim == NULL) {
zval *new_zval = &EG(uninitialized_zval);
- new_zval->refcount++;
+ Z_ADDREF_P(new_zval);
if (zend_hash_next_index_insert(Z_ARRVAL_P(container), &new_zval, sizeof(zval *), (void **) &retval) == FAILURE) {
zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
retval = &EG(error_zval_ptr);
- new_zval->refcount--;
+ Z_DELREF_P(new_zval);
}
} else {
retval = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, type TSRMLS_CC);
overloaded_result = Z_OBJ_HT_P(container)->read_dimension(container, dim, type TSRMLS_CC);
if (overloaded_result) {
- if (!overloaded_result->is_ref &&
+ if (!Z_ISREF_P(overloaded_result) &&
(type == BP_VAR_W || type == BP_VAR_RW || type == BP_VAR_UNSET)) {
- if (overloaded_result->refcount > 0) {
+ if (Z_REFCOUNT_P(overloaded_result) > 0) {
zval *tmp = overloaded_result;
ALLOC_ZVAL(overloaded_result);
*overloaded_result = *tmp;
zval_copy_ctor(overloaded_result);
- overloaded_result->is_ref = 0;
- overloaded_result->refcount = 0;
+ Z_UNSET_ISREF_P(overloaded_result);
+ Z_SET_REFCOUNT_P(overloaded_result, 0);
}
if (Z_TYPE_P(overloaded_result) != IS_OBJECT) {
zend_class_entry *ce = Z_OBJCE_P(container);
result->var.ptr_ptr = retval;
AI_USE_PTR(result->var);
PZVAL_LOCK(*result->var.ptr_ptr);
- } else if ((*retval)->refcount == 0) {
+ } else if (Z_REFCOUNT_PP(retval) == 0) {
/* Destroy unused result from offsetGet() magic method */
- (*retval)->refcount = 1;
+ Z_SET_REFCOUNT_P((*retval), 1);
zval_ptr_dtor(retval);
}
if (dim_is_tmp_var) {
{
INIT_ZVAL(EG(uninitialized_zval));
/* trick to make uninitialized_zval never be modified, passed by ref, etc. */
- EG(uninitialized_zval).refcount++;
+ Z_ADDREF(EG(uninitialized_zval));
INIT_ZVAL(EG(error_zval));
EG(uninitialized_zval_ptr)=&EG(uninitialized_zval);
EG(error_zval_ptr)=&EG(error_zval);
zval *globals;
ALLOC_ZVAL(globals);
- globals->refcount=1;
- globals->is_ref=1;
+ Z_SET_REFCOUNT_P(globals, 1);
+ Z_SET_ISREF_P(globals);
Z_TYPE_P(globals) = IS_ARRAY;
Z_ARRVAL_P(globals) = &EG(symbol_table);
zend_ascii_hash_update(&EG(symbol_table), "GLOBALS", sizeof("GLOBALS"), &globals, sizeof(zval *), NULL);
static int zval_call_destructor(zval **zv TSRMLS_DC) /* {{{ */
{
- if (Z_TYPE_PP(zv) == IS_OBJECT && (*zv)->refcount == 1) {
+ if (Z_TYPE_PP(zv) == IS_OBJECT && Z_REFCOUNT_PP(zv) == 1) {
return ZEND_HASH_APPLY_REMOVE;
} else {
return ZEND_HASH_APPLY_KEEP;
#if DEBUG_ZEND>=2
printf("Reducing refcount for %x (%x): %d->%d\n", *zval_ptr, zval_ptr, (*zval_ptr)->refcount, (*zval_ptr)->refcount-1);
#endif
- (*zval_ptr)->refcount--;
- if ((*zval_ptr)->refcount==0) {
+ Z_DELREF_PP(zval_ptr);
+ if (Z_REFCOUNT_PP(zval_ptr) == 0) {
zval_dtor(*zval_ptr);
safe_free_zval_ptr_rel(*zval_ptr ZEND_FILE_LINE_RELAY_CC ZEND_FILE_LINE_CC);
- } else if ((*zval_ptr)->refcount == 1) {
- (*zval_ptr)->is_ref = 0;
+ } else if (Z_REFCOUNT_PP(zval_ptr) == 1) {
+ Z_UNSET_ISREF_PP(zval_ptr);
}
}
/* }}} */
#if DEBUG_ZEND>=2
printf("Reducing refcount for %x (%x): %d->%d\n", *zval_ptr, zval_ptr, (*zval_ptr)->refcount, (*zval_ptr)->refcount-1);
#endif
- (*zval_ptr)->refcount--;
- if ((*zval_ptr)->refcount==0) {
+ Z_DELREF_PP(zval_ptr);
+ if (Z_REFCOUNT_PP(zval_ptr) == 0) {
zval_internal_dtor(*zval_ptr);
free(*zval_ptr);
- } else if ((*zval_ptr)->refcount == 1) {
- (*zval_ptr)->is_ref = 0;
+ } else if (Z_REFCOUNT_PP(zval_ptr) == 1) {
+ Z_UNSET_ISREF_PP(zval_ptr);
}
}
/* }}} */
MARK_CONSTANT_VISITED(p);
- refcount = p->refcount;
- is_ref = p->is_ref;
+ refcount = Z_REFCOUNT_P(p);
+ is_ref = Z_ISREF_P(p);
if (!zend_u_get_constant_ex(ZEND_STR_TYPE, Z_UNIVAL_P(p), Z_UNILEN_P(p), &const_value, scope, Z_REAL_TYPE_P(p) TSRMLS_CC)) {
if ((UG(unicode) && (colon.u = u_memrchr(Z_USTRVAL_P(p), ':', Z_USTRLEN_P(p))) && colon.u > Z_USTRVAL_P(p) && *(colon.u-1) == ':') ||
*p = const_value;
}
- p->refcount = refcount;
- p->is_ref = is_ref;
+ Z_SET_REFCOUNT_P(p, refcount);
+ Z_SET_ISREF_TO_P(p, is_ref);
} else if (Z_TYPE_P(p) == IS_CONSTANT_ARRAY) {
zval **element, *new_val;
zstr str_index;
ALLOC_ZVAL(new_val);
*new_val = **element;
zval_copy_ctor(new_val);
- new_val->refcount = 1;
- new_val->is_ref = 0;
+ Z_SET_REFCOUNT_P(new_val, 1);
+ Z_UNSET_ISREF_P(new_val);
/* preserve this bit for inheritance */
Z_TYPE_PP(element) |= IS_CONSTANT_INDEX;
fci->function_name = *tmp_real_function_name;
SEPARATE_ZVAL_IF_NOT_REF(tmp_object_ptr);
fci->object_pp = tmp_object_ptr;
- (*fci->object_pp)->is_ref = 1;
+ Z_SET_ISREF_PP(fci->object_pp);
}
if (fci->object_pp && !*fci->object_pp) {
if (ARG_SHOULD_BE_SENT_BY_REF(EX(function_state).function, i+1)
&& !PZVAL_IS_REF(*fci->params[i])) {
- if ((*fci->params[i])->refcount>1) {
+ if (Z_REFCOUNT_PP(fci->params[i]) > 1) {
zval *new_zval;
if (fci->no_separation) {
ALLOC_ZVAL(new_zval);
*new_zval = **fci->params[i];
zval_copy_ctor(new_zval);
- new_zval->refcount = 1;
- (*fci->params[i])->refcount--;
+ Z_SET_REFCOUNT_P(new_zval, 1);
+ Z_DELREF_PP(fci->params[i]);
*fci->params[i] = new_zval;
}
- (*fci->params[i])->refcount++;
- (*fci->params[i])->is_ref = 1;
+ Z_ADDREF_PP(fci->params[i]);
+ Z_SET_ISREF_PP(fci->params[i]);
param = *fci->params[i];
} else if (*fci->params[i] != &EG(uninitialized_zval)) {
- (*fci->params[i])->refcount++;
+ Z_ADDREF_PP(fci->params[i]);
param = *fci->params[i];
} else {
ALLOC_ZVAL(param);
EG(This) = *fci->object_pp;
if (!PZVAL_IS_REF(EG(This))) {
- EG(This)->refcount++; /* For $this pointer */
+ Z_ADDREF_P(EG(This)); /* For $this pointer */
} else {
zval *this_ptr;
while (opline<end) {
if (opline->op1.op_type==IS_CONST) {
- opline->op1.u.constant.is_ref = 1;
- opline->op1.u.constant.refcount = 2; /* Make sure is_ref won't be reset */
+ Z_SET_ISREF(opline->op1.u.constant);
+ Z_SET_REFCOUNT(opline->op1.u.constant, 2); /* Make sure is_ref won't be reset */
}
if (opline->op2.op_type==IS_CONST) {
- opline->op2.u.constant.is_ref = 1;
- opline->op2.u.constant.refcount = 2;
+ Z_SET_ISREF(opline->op2.u.constant);
+ Z_SET_REFCOUNT(opline->op2.u.constant, 2);
}
switch (opline->opcode) {
case ZEND_GOTO:
iterator = emalloc(sizeof(zend_user_iterator));
- object->refcount++;
+ Z_ADDREF_P(object);
iterator->it.data = (void*)object;
iterator->it.funcs = ce->iterator_funcs.funcs;
iterator->ce = Z_OBJCE_P(object);
retval_znode.op_type = IS_CONST;
Z_TYPE(retval_znode.u.constant) = IS_LONG;
Z_LVAL(retval_znode.u.constant) = 1;
- retval_znode.u.constant.is_ref = 0;
- retval_znode.u.constant.refcount = 1;
+ Z_UNSET_ISREF(retval_znode.u.constant);
+ Z_SET_REFCOUNT(retval_znode.u.constant, 1);
zend_save_lexical_state(&original_lex_state TSRMLS_CC);
zval_ptr_dtor(&member);
if (retval) {
- retval->refcount--;
+ Z_DELREF_P(retval);
}
return retval;
zend_class_entry *ce = Z_OBJCE_P(object);
SEPARATE_ARG_IF_REF(member);
- value->refcount++;
+ Z_ADDREF_P(value);
/* __set handler is called with two arguments:
property name
if (rv) {
retval = &rv;
- if (!rv->is_ref &&
+ if (!Z_ISREF_P(rv) &&
(type == BP_VAR_W || type == BP_VAR_RW || type == BP_VAR_UNSET)) {
- if (rv->refcount > 0) {
+ if (Z_REFCOUNT_P(rv) > 0) {
zval *tmp = rv;
ALLOC_ZVAL(rv);
*rv = *tmp;
zval_copy_ctor(rv);
- rv->is_ref = 0;
- rv->refcount = 0;
+ Z_UNSET_ISREF_P(rv);
+ Z_SET_REFCOUNT_P(rv, 0);
}
if (Z_TYPE_P(rv) != IS_OBJECT) {
zend_error(E_NOTICE, "Indirect modification of overloaded property %v::$%R has no effect", zobj->ce->name, Z_TYPE_P(member), Z_UNIVAL_P(member));
}
}
if (tmp_member) {
- (*retval)->refcount++;
+ Z_ADDREF_PP(retval);
zval_ptr_dtor(&tmp_member);
- (*retval)->refcount--;
+ Z_DELREF_PP(retval);
}
return *retval;
}
/* To check: can't *variable_ptr be some system variable like error_zval here? */
Z_TYPE_PP(variable_ptr) = Z_TYPE_P(value);
(*variable_ptr)->value = value->value;
- if (value->refcount>0) {
+ if (Z_REFCOUNT_P(value) > 0) {
zval_copy_ctor(*variable_ptr);
}
zval_dtor(&garbage);
zval *garbage = *variable_ptr;
/* if we assign referenced variable, we should separate it */
- value->refcount++;
+ Z_ADDREF_P(value);
if (PZVAL_IS_REF(value)) {
SEPARATE_ZVAL(&value);
}
zval **foo;
/* if we assign referenced variable, we should separate it */
- value->refcount++;
+ Z_ADDREF_P(value);
if (PZVAL_IS_REF(value)) {
SEPARATE_ZVAL(&value);
}
}
/* Undo PZVAL_LOCK() */
- retval->refcount--;
+ Z_DELREF_P(retval);
return retval;
} else {
new_zval = &EG(uninitialized_zval);
/* zend_error(E_NOTICE, "Undefined property: %R", Z_TYPE_P(member), Z_STRVAL_P(member)); */
- new_zval->refcount++;
+ Z_ADDREF_P(new_zval);
zend_u_hash_quick_update(zobj->properties, Z_TYPE_P(member), property_info->name, property_info->name_length+1, property_info->h, &new_zval, sizeof(zval *), (void **) &retval);
} else {
/* we do have getter - fail and let it try again with usual get/set */
zend_call_method_with_2_params(&this_ptr, ce, &ce->__call, ZEND_CALL_FUNC_NAME, &method_result_ptr, method_name_ptr, method_args_ptr);
if (method_result_ptr) {
- if (method_result_ptr->is_ref || method_result_ptr->refcount > 1) {
+ if (Z_ISREF_P(method_result_ptr) || Z_REFCOUNT_P(method_result_ptr) > 1) {
RETVAL_ZVAL(method_result_ptr, 1, 1);
} else {
RETVAL_ZVAL(method_result_ptr, 0, 1);
zend_call_method_with_2_params(NULL, ce, &ce->__callstatic, ZEND_CALLSTATIC_FUNC_NAME, &method_result_ptr, method_name_ptr, method_args_ptr);
if (method_result_ptr) {
- if (method_result_ptr->is_ref || method_result_ptr->refcount > 1) {
+ if (Z_ISREF_P(method_result_ptr) || Z_REFCOUNT_P(method_result_ptr) > 1) {
RETVAL_ZVAL(method_result_ptr, 1, 1);
} else {
RETVAL_ZVAL(method_result_ptr, 0, 1);
rv = zend_std_call_getter(object, member TSRMLS_CC);
guard->in_get = 0;
if (rv) {
- rv->refcount++;
+ Z_ADDREF_P(rv);
result = i_zend_is_true(rv);
zval_ptr_dtor(&rv);
}
handle = Z_OBJ_HANDLE_P(zobject);
- zobject->refcount++;
+ Z_ADDREF_P(zobject);
zend_objects_store_del_ref_by_handle(handle TSRMLS_CC);
- zobject->refcount--;
+ Z_DELREF_P(zobject);
}
/* }}} */
obj->refcount--;
#if ZEND_DEBUG_OBJECTS
- if (obj->refcount == 0) {
+ if (Z_REFCOUNT_P(obj) == 0) {
fprintf(stderr, "Deallocated object id #%d\n", handle);
} else {
fprintf(stderr, "Decreased refcount of object id #%d\n", handle);
end = opline + op_array->last;
while (opline < end) {
if (opline->op1.op_type == IS_CONST) {
- opline->op1.u.constant.is_ref = 1;
- opline->op1.u.constant.refcount = 2; /* Make sure is_ref won't be reset */
+ Z_SET_ISREF(opline->op1.u.constant);
+ Z_SET_REFCOUNT(opline->op1.u.constant, 2); /* Make sure is_ref won't be reset */
}
if (opline->op2.op_type == IS_CONST) {
- opline->op2.u.constant.is_ref = 1;
- opline->op2.u.constant.refcount = 2;
+ Z_SET_ISREF(opline->op2.u.constant);
+ Z_SET_REFCOUNT(opline->op2.u.constant, 2);
}
switch (opline->opcode) {
case ZEND_GOTO:
static inline void zend_free_obj_get_result(zval *op) /* {{{ */
{
if (op) {
- if (op->refcount == 0) {
+ if (Z_REFCOUNT_P(op) == 0) {
zval_dtor(op);
FREE_ZVAL(op);
} else {
ZEND_API void zval_add_ref(zval **p) /* {{{ */
{
- (*p)->refcount++;
+ Z_ADDREF_PP(p);
}
/* }}} */
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
z = value;
}
- z->refcount++;
+ Z_ADDREF_P(z);
SEPARATE_ZVAL_IF_NOT_REF(&z);
binary_op(z, z, value TSRMLS_CC);
switch (opline->extended_value) {
zval **object_ptr = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_W);
if (object_ptr && OP1_TYPE != IS_CV && !OP1_FREE) {
- (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
+ Z_ADDREF_PP(object_ptr); /* undo the effect of get_obj_zval_ptr_ptr() */
}
if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
- objval->refcount++;
+ Z_ADDREF_P(objval);
binary_op(objval, objval, value TSRMLS_CC);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
zval_ptr_dtor(&objval);
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
z = value;
}
- z->refcount++;
+ Z_ADDREF_P(z);
SEPARATE_ZVAL_IF_NOT_REF(&z);
incdec_op(z);
*retval = z;
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
zendi_zval_copy_ctor(*z_copy);
INIT_PZVAL(z_copy);
incdec_op(z_copy);
- z->refcount++;
+ Z_ADDREF_P(z);
Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
zval_ptr_dtor(&z_copy);
zval_ptr_dtor(&z);
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */
zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
- val->refcount++;
+ Z_ADDREF_P(val);
increment_function(val);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
zval_ptr_dtor(&val);
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */
zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
- val->refcount++;
+ Z_ADDREF_P(val);
decrement_function(val);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
zval_ptr_dtor(&val);
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */
zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
- val->refcount++;
+ Z_ADDREF_P(val);
increment_function(val);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
zval_ptr_dtor(&val);
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */
zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
- val->refcount++;
+ Z_ADDREF_P(val);
decrement_function(val);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
zval_ptr_dtor(&val);
case BP_VAR_W: {
zval *new_zval = &EG(uninitialized_zval);
- new_zval->refcount++;
+ Z_ADDREF_P(new_zval);
zend_u_hash_update(target_symbol_table, Z_TYPE_P(varname), Z_UNIVAL_P(varname), Z_UNILEN_P(varname)+1, &new_zval, sizeof(zval *), (void **) &retval);
}
break;
/* here we are sure we are dealing with an object */
*retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
- if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
+ if (RETURN_VALUE_UNUSED(&opline->result) && (Z_REFCOUNT_PP(retval) == 0)) {
zval_dtor(*retval);
FREE_ZVAL(*retval);
} else {
if (OP2_TYPE == IS_VAR &&
value_ptr_ptr &&
- !(*value_ptr_ptr)->is_ref &&
+ !Z_ISREF_PP(value_ptr_ptr) &&
opline->extended_value == ZEND_RETURNS_FUNCTION &&
!EX_T(opline->op2.u.var).var.fcall_returned_reference) {
if (free_op2.var == NULL) {
Z_STRLEN_P(tmp) = 0;
Z_TYPE_P(tmp) = IS_STRING;
}
- tmp->refcount = 1;
- tmp->is_ref = 0;
+ Z_SET_REFCOUNT_P(tmp, 1);
+ Z_UNSET_ISREF_P(tmp);
ZEND_VM_NEXT_OPCODE();
}
EX(object) = NULL;
} else {
if (!PZVAL_IS_REF(EX(object))) {
- EX(object)->refcount++; /* For $this pointer */
+ Z_ADDREF_P(EX(object)); /* For $this pointer */
} else {
zval *this_ptr;
ALLOC_ZVAL(this_ptr);
}
if ((EX(object) = EG(This))) {
- EX(object)->refcount++;
+ Z_ADDREF_P(EX(object));
EX(called_scope) = Z_OBJCE_P(EX(object));
}
}
/* We shouldn't fix bad extensions here,
because it can break proper ones (Bug #34045)
if (!EX(function_state).function->common.return_reference) {
- EX_T(opline->result.u.var).var.ptr->is_ref = 0;
- EX_T(opline->result.u.var).var.ptr->refcount = 1;
+ Z_UNSET_ISREF_P(EX_T(opline->result.u.var).var.ptr);
+ Z_SET_REFCOUNT_P(EX_T(opline->result.u.var).var.ptr, 1);
}
*/
if (!return_value_used) {
if (!return_value_used) {
zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
} else {
- EX_T(opline->result.u.var).var.ptr->is_ref = 0;
- EX_T(opline->result.u.var).var.ptr->refcount = 1;
+ Z_UNSET_ISREF_P(EX_T(opline->result.u.var).var.ptr);
+ Z_SET_REFCOUNT_P(EX_T(opline->result.u.var).var.ptr, 1);
EX_T(opline->result.u.var).var.fcall_returned_reference = 0;
}
}
if (EG(This)) {
if (EG(exception) && IS_CTOR_CALL(EX(called_scope))) {
if (IS_CTOR_USED(EX(called_scope))) {
- EG(This)->refcount--;
+ Z_DELREF_P(EG(This));
}
- if (EG(This)->refcount == 1) {
+ if (Z_REFCOUNT_P(EG(This)) == 1) {
zend_object_store_ctor_failed(EG(This) TSRMLS_CC);
}
}
zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
}
- if (OP1_TYPE == IS_VAR && !(*retval_ptr_ptr)->is_ref) {
+ if (OP1_TYPE == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) {
if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
EX_T(opline->op1.u.var).var.fcall_returned_reference) {
} else if (opline->extended_value == ZEND_RETURNS_NEW) {
}
SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
- (*retval_ptr_ptr)->refcount++;
+ Z_ADDREF_PP(retval_ptr_ptr);
(*EG(return_value_ptr_ptr)) = (*retval_ptr_ptr);
} else {
if (!IS_OP1_TMP_FREE()) { /* Not a temp var */
if (EG(active_op_array)->return_reference == ZEND_RETURN_REF ||
- (PZVAL_IS_REF(retval_ptr) && retval_ptr->refcount > 0)) {
+ (PZVAL_IS_REF(retval_ptr) && Z_REFCOUNT_P(retval_ptr) > 0)) {
zval *ret;
ALLOC_ZVAL(ret);
*EG(return_value_ptr_ptr) = ret;
} else {
*EG(return_value_ptr_ptr) = retval_ptr;
- retval_ptr->refcount++;
+ Z_ADDREF_P(retval_ptr);
}
} else {
zval *ret;
if (varptr == &EG(uninitialized_zval)) {
ALLOC_ZVAL(varptr);
INIT_ZVAL(*varptr);
- varptr->refcount = 0;
+ Z_SET_REFCOUNT_P(varptr, 0);
} else if (PZVAL_IS_REF(varptr)) {
zval *original_var = varptr;
ALLOC_ZVAL(varptr);
*varptr = *original_var;
- varptr->is_ref = 0;
- varptr->refcount = 0;
+ Z_UNSET_ISREF_P(varptr);
+ Z_SET_REFCOUNT_P(varptr, 0);
zval_copy_ctor(varptr);
}
- varptr->refcount++;
+ Z_ADDREF_P(varptr);
zend_ptr_stack_push(&EG(argument_stack), varptr);
FREE_OP1(); /* for string offsets */
EX_T(opline->op1.u.var).var.fcall_returned_reference) &&
varptr != &EG(uninitialized_zval) &&
(PZVAL_IS_REF(varptr) ||
- (varptr->refcount == 1 && (OP1_TYPE == IS_CV || free_op1.var)))) {
- varptr->is_ref = 1;
- varptr->refcount++;
+ (Z_REFCOUNT_P(varptr) == 1 && (OP1_TYPE == IS_CV || free_op1.var)))) {
+ Z_SET_ISREF_P(varptr);
+ Z_ADDREF_P(varptr);
zend_ptr_stack_push(&EG(argument_stack), varptr);
} else {
zval *valptr;
SEPARATE_ZVAL_TO_MAKE_IS_REF(varptr_ptr);
varptr = *varptr_ptr;
- varptr->refcount++;
+ Z_ADDREF_P(varptr);
zend_ptr_stack_push(&EG(argument_stack), varptr);
FREE_OP1_VAR_PTR();
if (Z_TYPE(opline->op2.u.constant)==IS_CONSTANT_ARRAY) {
zval_copy_ctor(default_value);
}
- default_value->refcount=1;
+ Z_SET_REFCOUNT_P(default_value, 1);
zval_update_constant(&default_value, 0 TSRMLS_CC);
- default_value->refcount=0;
- default_value->is_ref=0;
+ Z_SET_REFCOUNT_P(default_value, 0);
+ Z_UNSET_ISREF_P(default_value);
param = &default_value;
assignment_value = default_value;
} else {
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
} else {
switch_expr_is_overloaded = 1;
- EX_T(opline->op1.u.var).str_offset.str->refcount++;
+ Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
}
}
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
if (!obj || Z_TYPE_P(obj) != IS_OBJECT) {
zend_error_noreturn(E_ERROR, "__clone method called on non-object");
EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr);
- EX_T(opline->result.u.var).var.ptr->refcount++;
+ Z_ADDREF_P(EX_T(opline->result.u.var).var.ptr);
FREE_OP1_IF_VAR();
ZEND_VM_NEXT_OPCODE();
}
zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
}
EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr);
- EX_T(opline->result.u.var).var.ptr->refcount++;
+ Z_ADDREF_P(EX_T(opline->result.u.var).var.ptr);
}
if (ce && clone) {
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
Z_OBJVAL_P(EX_T(opline->result.u.var).var.ptr) = clone_call(obj TSRMLS_CC);
Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_OBJECT;
- EX_T(opline->result.u.var).var.ptr->refcount=1;
- EX_T(opline->result.u.var).var.ptr->is_ref=1;
+ Z_SET_REFCOUNT_P(EX_T(opline->result.u.var).var.ptr, 1);
+ Z_SET_ISREF_P(EX_T(opline->result.u.var).var.ptr);
if (!RETURN_VALUE_USED(opline) || EG(exception)) {
zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
}
if (opline->extended_value) {
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
expr_ptr = *expr_ptr_ptr;
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
} else
#endif
if (PZVAL_IS_REF(expr_ptr)) {
expr_ptr = new_expr;
zendi_zval_copy_ctor(*expr_ptr);
} else {
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
}
}
if (offset) {
convert_to_text(&tmp);
varname = &tmp;
} else if (OP1_TYPE == IS_CV || OP1_TYPE == IS_VAR) {
- varname->refcount++;
+ Z_ADDREF_P(varname);
}
if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
free_offset = 1;
}
} else if (OP2_TYPE == IS_CV || OP2_TYPE == IS_VAR) {
- offset->refcount++;
+ Z_ADDREF_P(offset);
}
if (zend_u_symtable_del(ht, Z_TYPE_P(offset), offset_key, offset_len+1) == SUCCESS &&
ce = Z_OBJCE_PP(array_ptr_ptr);
if (!ce || ce->get_iterator == NULL) {
SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
- (*array_ptr_ptr)->refcount++;
+ Z_ADDREF_PP(array_ptr_ptr);
}
array_ptr = *array_ptr_ptr;
} else {
if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) {
SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
- (*array_ptr_ptr)->is_ref = 1;
+ Z_SET_ISREF_PP(array_ptr_ptr);
}
}
array_ptr = *array_ptr_ptr;
- array_ptr->refcount++;
+ Z_ADDREF_P(array_ptr);
}
} else {
array_ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
} else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
ce = Z_OBJCE_P(array_ptr);
if (!ce || !ce->get_iterator) {
- array_ptr->refcount++;
+ Z_ADDREF_P(array_ptr);
}
} else {
if ((OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) &&
- !array_ptr->is_ref &&
- array_ptr->refcount > 1) {
+ !Z_ISREF_P(array_ptr) &&
+ Z_REFCOUNT_P(array_ptr) > 1) {
zval *tmp;
ALLOC_ZVAL(tmp);
zval_copy_ctor(tmp);
array_ptr = tmp;
} else {
- array_ptr->refcount++;
+ Z_ADDREF_P(array_ptr);
}
}
}
if (iter->funcs->rewind) {
iter->funcs->rewind(iter TSRMLS_CC);
if (EG(exception)) {
- array_ptr->refcount--;
+ Z_DELREF_P(array_ptr);
zval_ptr_dtor(&array_ptr);
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
FREE_OP1_VAR_PTR();
}
is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS;
if (EG(exception)) {
- array_ptr->refcount--;
+ Z_DELREF_P(array_ptr);
zval_ptr_dtor(&array_ptr);
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
FREE_OP1_VAR_PTR();
* In case that ever happens we need an additional flag. */
iter->funcs->move_forward(iter TSRMLS_CC);
if (EG(exception)) {
- array->refcount--;
+ Z_DELREF_P(array);
zval_ptr_dtor(&array);
ZEND_VM_NEXT_OPCODE();
}
if (!iter || (iter->index > 0 && iter->funcs->valid(iter TSRMLS_CC) == FAILURE)) {
/* reached end of iteration */
if (EG(exception)) {
- array->refcount--;
+ Z_DELREF_P(array);
zval_ptr_dtor(&array);
ZEND_VM_NEXT_OPCODE();
}
}
iter->funcs->get_current_data(iter, &value TSRMLS_CC);
if (EG(exception)) {
- array->refcount--;
+ Z_DELREF_P(array);
zval_ptr_dtor(&array);
ZEND_VM_NEXT_OPCODE();
}
if (iter->funcs->get_current_key) {
key_type = iter->funcs->get_current_key(iter, &str_key, &str_key_len, &int_key TSRMLS_CC);
if (EG(exception)) {
- array->refcount--;
+ Z_DELREF_P(array);
zval_ptr_dtor(&array);
ZEND_VM_NEXT_OPCODE();
}
if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
SEPARATE_ZVAL_IF_NOT_REF(value);
- (*value)->is_ref = 1;
+ Z_SET_ISREF_PP(value);
EX_T(opline->result.u.var).var.ptr_ptr = value;
- (*value)->refcount++;
+ Z_ADDREF_PP(value);
} else {
EX_T(opline->result.u.var).var.ptr_ptr = value;
PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
EX(called_scope) = (zend_class_entry*)zend_ptr_stack_pop(&EG(arg_types_stack));
if (EX(object)) {
if (IS_CTOR_USED(EX(called_scope))) {
- EX(object)->refcount--;
+ Z_DELREF_P(EX(object));
}
zval_ptr_dtor(&EX(object));
}
}
if (op_array->uses_this && EG(This)) {
- EG(This)->refcount++; /* For $this pointer */
+ Z_ADDREF_P(EG(This)); /* For $this pointer */
if (zend_ascii_hash_add(EG(active_symbol_table), "this", sizeof("this"), &EG(This), sizeof(zval *), NULL)==FAILURE) {
- EG(This)->refcount--;
+ Z_DELREF_P(EG(This));
}
}
Z_STRLEN_P(tmp) = 0;
Z_TYPE_P(tmp) = IS_STRING;
}
- tmp->refcount = 1;
- tmp->is_ref = 0;
+ Z_SET_REFCOUNT_P(tmp, 1);
+ Z_UNSET_ISREF_P(tmp);
ZEND_VM_NEXT_OPCODE();
}
/* We shouldn't fix bad extensions here,
because it can break proper ones (Bug #34045)
if (!EX(function_state).function->common.return_reference) {
- EX_T(opline->result.u.var).var.ptr->is_ref = 0;
- EX_T(opline->result.u.var).var.ptr->refcount = 1;
+ Z_UNSET_ISREF_P(EX_T(opline->result.u.var).var.ptr);
+ Z_SET_REFCOUNT_P(EX_T(opline->result.u.var).var.ptr, 1);
}
*/
if (!return_value_used) {
if (!return_value_used) {
zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
} else {
- EX_T(opline->result.u.var).var.ptr->is_ref = 0;
- EX_T(opline->result.u.var).var.ptr->refcount = 1;
+ Z_UNSET_ISREF_P(EX_T(opline->result.u.var).var.ptr);
+ Z_SET_REFCOUNT_P(EX_T(opline->result.u.var).var.ptr, 1);
EX_T(opline->result.u.var).var.fcall_returned_reference = 0;
}
}
if (EG(This)) {
if (EG(exception) && IS_CTOR_CALL(EX(called_scope))) {
if (IS_CTOR_USED(EX(called_scope))) {
- EG(This)->refcount--;
+ Z_DELREF_P(EG(This));
}
- if (EG(This)->refcount == 1) {
+ if (Z_REFCOUNT_P(EG(This)) == 1) {
zend_object_store_ctor_failed(EG(This) TSRMLS_CC);
}
}
EX(called_scope) = (zend_class_entry*)zend_ptr_stack_pop(&EG(arg_types_stack));
if (EX(object)) {
if (IS_CTOR_USED(EX(called_scope))) {
- EX(object)->refcount--;
+ Z_DELREF_P(EX(object));
}
zval_ptr_dtor(&EX(object));
}
if (Z_TYPE(opline->op2.u.constant)==IS_CONSTANT_ARRAY) {
zval_copy_ctor(default_value);
}
- default_value->refcount=1;
+ Z_SET_REFCOUNT_P(default_value, 1);
zval_update_constant(&default_value, 0 TSRMLS_CC);
- default_value->refcount=0;
- default_value->is_ref=0;
+ Z_SET_REFCOUNT_P(default_value, 0);
+ Z_UNSET_ISREF_P(default_value);
param = &default_value;
assignment_value = default_value;
} else {
case BP_VAR_W: {
zval *new_zval = &EG(uninitialized_zval);
- new_zval->refcount++;
+ Z_ADDREF_P(new_zval);
zend_u_hash_update(target_symbol_table, Z_TYPE_P(varname), Z_UNIVAL_P(varname), Z_UNILEN_P(varname)+1, &new_zval, sizeof(zval *), (void **) &retval);
}
break;
zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
}
- if (IS_CONST == IS_VAR && !(*retval_ptr_ptr)->is_ref) {
+ if (IS_CONST == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) {
if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
EX_T(opline->op1.u.var).var.fcall_returned_reference) {
} else if (opline->extended_value == ZEND_RETURNS_NEW) {
}
SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
- (*retval_ptr_ptr)->refcount++;
+ Z_ADDREF_PP(retval_ptr_ptr);
(*EG(return_value_ptr_ptr)) = (*retval_ptr_ptr);
} else {
if (!0) { /* Not a temp var */
if (EG(active_op_array)->return_reference == ZEND_RETURN_REF ||
- (PZVAL_IS_REF(retval_ptr) && retval_ptr->refcount > 0)) {
+ (PZVAL_IS_REF(retval_ptr) && Z_REFCOUNT_P(retval_ptr) > 0)) {
zval *ret;
ALLOC_ZVAL(ret);
*EG(return_value_ptr_ptr) = ret;
} else {
*EG(return_value_ptr_ptr) = retval_ptr;
- retval_ptr->refcount++;
+ Z_ADDREF_P(retval_ptr);
}
} else {
zval *ret;
if (!obj || Z_TYPE_P(obj) != IS_OBJECT) {
zend_error_noreturn(E_ERROR, "__clone method called on non-object");
EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr);
- EX_T(opline->result.u.var).var.ptr->refcount++;
+ Z_ADDREF_P(EX_T(opline->result.u.var).var.ptr);
ZEND_VM_NEXT_OPCODE();
}
zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
}
EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr);
- EX_T(opline->result.u.var).var.ptr->refcount++;
+ Z_ADDREF_P(EX_T(opline->result.u.var).var.ptr);
}
if (ce && clone) {
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
Z_OBJVAL_P(EX_T(opline->result.u.var).var.ptr) = clone_call(obj TSRMLS_CC);
Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_OBJECT;
- EX_T(opline->result.u.var).var.ptr->refcount=1;
- EX_T(opline->result.u.var).var.ptr->is_ref=1;
+ Z_SET_REFCOUNT_P(EX_T(opline->result.u.var).var.ptr, 1);
+ Z_SET_ISREF_P(EX_T(opline->result.u.var).var.ptr);
if (!RETURN_VALUE_USED(opline) || EG(exception)) {
zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
}
convert_to_text(&tmp);
varname = &tmp;
} else if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
- varname->refcount++;
+ Z_ADDREF_P(varname);
}
if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
ce = Z_OBJCE_PP(array_ptr_ptr);
if (!ce || ce->get_iterator == NULL) {
SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
- (*array_ptr_ptr)->refcount++;
+ Z_ADDREF_PP(array_ptr_ptr);
}
array_ptr = *array_ptr_ptr;
} else {
if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) {
SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
- (*array_ptr_ptr)->is_ref = 1;
+ Z_SET_ISREF_PP(array_ptr_ptr);
}
}
array_ptr = *array_ptr_ptr;
- array_ptr->refcount++;
+ Z_ADDREF_P(array_ptr);
}
} else {
array_ptr = &opline->op1.u.constant;
} else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
ce = Z_OBJCE_P(array_ptr);
if (!ce || !ce->get_iterator) {
- array_ptr->refcount++;
+ Z_ADDREF_P(array_ptr);
}
} else {
if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) &&
- !array_ptr->is_ref &&
- array_ptr->refcount > 1) {
+ !Z_ISREF_P(array_ptr) &&
+ Z_REFCOUNT_P(array_ptr) > 1) {
zval *tmp;
ALLOC_ZVAL(tmp);
zval_copy_ctor(tmp);
array_ptr = tmp;
} else {
- array_ptr->refcount++;
+ Z_ADDREF_P(array_ptr);
}
}
}
if (iter->funcs->rewind) {
iter->funcs->rewind(iter TSRMLS_CC);
if (EG(exception)) {
- array_ptr->refcount--;
+ Z_DELREF_P(array_ptr);
zval_ptr_dtor(&array_ptr);
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
}
is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS;
if (EG(exception)) {
- array_ptr->refcount--;
+ Z_DELREF_P(array_ptr);
zval_ptr_dtor(&array_ptr);
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
}
if ((EX(object) = EG(This))) {
- EX(object)->refcount++;
+ Z_ADDREF_P(EX(object));
EX(called_scope) = Z_OBJCE_P(EX(object));
}
}
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
} else {
switch_expr_is_overloaded = 1;
- EX_T(opline->op1.u.var).str_offset.str->refcount++;
+ Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
}
}
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
if (opline->extended_value) {
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
expr_ptr = *expr_ptr_ptr;
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
} else
#endif
if (PZVAL_IS_REF(expr_ptr)) {
expr_ptr = new_expr;
zendi_zval_copy_ctor(*expr_ptr);
} else {
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
}
}
if (offset) {
}
if ((EX(object) = EG(This))) {
- EX(object)->refcount++;
+ Z_ADDREF_P(EX(object));
EX(called_scope) = Z_OBJCE_P(EX(object));
}
}
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
} else {
switch_expr_is_overloaded = 1;
- EX_T(opline->op1.u.var).str_offset.str->refcount++;
+ Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
}
}
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
if (opline->extended_value) {
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
expr_ptr = *expr_ptr_ptr;
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
} else
#endif
if (PZVAL_IS_REF(expr_ptr)) {
expr_ptr = new_expr;
zendi_zval_copy_ctor(*expr_ptr);
} else {
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
}
}
if (offset) {
}
if ((EX(object) = EG(This))) {
- EX(object)->refcount++;
+ Z_ADDREF_P(EX(object));
EX(called_scope) = Z_OBJCE_P(EX(object));
}
}
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
} else {
switch_expr_is_overloaded = 1;
- EX_T(opline->op1.u.var).str_offset.str->refcount++;
+ Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
}
}
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
if (opline->extended_value) {
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
expr_ptr = *expr_ptr_ptr;
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
} else
#endif
if (PZVAL_IS_REF(expr_ptr)) {
expr_ptr = new_expr;
zendi_zval_copy_ctor(*expr_ptr);
} else {
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
}
}
if (offset) {
}
if ((EX(object) = EG(This))) {
- EX(object)->refcount++;
+ Z_ADDREF_P(EX(object));
EX(called_scope) = Z_OBJCE_P(EX(object));
}
}
if (opline->extended_value) {
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
expr_ptr = *expr_ptr_ptr;
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
} else
#endif
if (PZVAL_IS_REF(expr_ptr)) {
expr_ptr = new_expr;
zendi_zval_copy_ctor(*expr_ptr);
} else {
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
}
}
if (offset) {
}
if ((EX(object) = EG(This))) {
- EX(object)->refcount++;
+ Z_ADDREF_P(EX(object));
EX(called_scope) = Z_OBJCE_P(EX(object));
}
}
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
} else {
switch_expr_is_overloaded = 1;
- EX_T(opline->op1.u.var).str_offset.str->refcount++;
+ Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
}
}
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
if (opline->extended_value) {
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
expr_ptr = *expr_ptr_ptr;
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
} else
#endif
if (PZVAL_IS_REF(expr_ptr)) {
expr_ptr = new_expr;
zendi_zval_copy_ctor(*expr_ptr);
} else {
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
}
}
if (offset) {
case BP_VAR_W: {
zval *new_zval = &EG(uninitialized_zval);
- new_zval->refcount++;
+ Z_ADDREF_P(new_zval);
zend_u_hash_update(target_symbol_table, Z_TYPE_P(varname), Z_UNIVAL_P(varname), Z_UNILEN_P(varname)+1, &new_zval, sizeof(zval *), (void **) &retval);
}
break;
zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
}
- if (IS_TMP_VAR == IS_VAR && !(*retval_ptr_ptr)->is_ref) {
+ if (IS_TMP_VAR == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) {
if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
EX_T(opline->op1.u.var).var.fcall_returned_reference) {
} else if (opline->extended_value == ZEND_RETURNS_NEW) {
}
SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
- (*retval_ptr_ptr)->refcount++;
+ Z_ADDREF_PP(retval_ptr_ptr);
(*EG(return_value_ptr_ptr)) = (*retval_ptr_ptr);
} else {
if (!1) { /* Not a temp var */
if (EG(active_op_array)->return_reference == ZEND_RETURN_REF ||
- (PZVAL_IS_REF(retval_ptr) && retval_ptr->refcount > 0)) {
+ (PZVAL_IS_REF(retval_ptr) && Z_REFCOUNT_P(retval_ptr) > 0)) {
zval *ret;
ALLOC_ZVAL(ret);
*EG(return_value_ptr_ptr) = ret;
} else {
*EG(return_value_ptr_ptr) = retval_ptr;
- retval_ptr->refcount++;
+ Z_ADDREF_P(retval_ptr);
}
} else {
zval *ret;
if (!obj || Z_TYPE_P(obj) != IS_OBJECT) {
zend_error_noreturn(E_ERROR, "__clone method called on non-object");
EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr);
- EX_T(opline->result.u.var).var.ptr->refcount++;
+ Z_ADDREF_P(EX_T(opline->result.u.var).var.ptr);
ZEND_VM_NEXT_OPCODE();
}
zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
}
EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr);
- EX_T(opline->result.u.var).var.ptr->refcount++;
+ Z_ADDREF_P(EX_T(opline->result.u.var).var.ptr);
}
if (ce && clone) {
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
Z_OBJVAL_P(EX_T(opline->result.u.var).var.ptr) = clone_call(obj TSRMLS_CC);
Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_OBJECT;
- EX_T(opline->result.u.var).var.ptr->refcount=1;
- EX_T(opline->result.u.var).var.ptr->is_ref=1;
+ Z_SET_REFCOUNT_P(EX_T(opline->result.u.var).var.ptr, 1);
+ Z_SET_ISREF_P(EX_T(opline->result.u.var).var.ptr);
if (!RETURN_VALUE_USED(opline) || EG(exception)) {
zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
}
convert_to_text(&tmp);
varname = &tmp;
} else if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
- varname->refcount++;
+ Z_ADDREF_P(varname);
}
if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
ce = Z_OBJCE_PP(array_ptr_ptr);
if (!ce || ce->get_iterator == NULL) {
SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
- (*array_ptr_ptr)->refcount++;
+ Z_ADDREF_PP(array_ptr_ptr);
}
array_ptr = *array_ptr_ptr;
} else {
if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) {
SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
- (*array_ptr_ptr)->is_ref = 1;
+ Z_SET_ISREF_PP(array_ptr_ptr);
}
}
array_ptr = *array_ptr_ptr;
- array_ptr->refcount++;
+ Z_ADDREF_P(array_ptr);
}
} else {
array_ptr = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
} else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
ce = Z_OBJCE_P(array_ptr);
if (!ce || !ce->get_iterator) {
- array_ptr->refcount++;
+ Z_ADDREF_P(array_ptr);
}
} else {
if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) &&
- !array_ptr->is_ref &&
- array_ptr->refcount > 1) {
+ !Z_ISREF_P(array_ptr) &&
+ Z_REFCOUNT_P(array_ptr) > 1) {
zval *tmp;
ALLOC_ZVAL(tmp);
zval_copy_ctor(tmp);
array_ptr = tmp;
} else {
- array_ptr->refcount++;
+ Z_ADDREF_P(array_ptr);
}
}
}
if (iter->funcs->rewind) {
iter->funcs->rewind(iter TSRMLS_CC);
if (EG(exception)) {
- array_ptr->refcount--;
+ Z_DELREF_P(array_ptr);
zval_ptr_dtor(&array_ptr);
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
}
is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS;
if (EG(exception)) {
- array_ptr->refcount--;
+ Z_DELREF_P(array_ptr);
zval_ptr_dtor(&array_ptr);
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
EX(object) = NULL;
} else {
if (!PZVAL_IS_REF(EX(object))) {
- EX(object)->refcount++; /* For $this pointer */
+ Z_ADDREF_P(EX(object)); /* For $this pointer */
} else {
zval *this_ptr;
ALLOC_ZVAL(this_ptr);
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
} else {
switch_expr_is_overloaded = 1;
- EX_T(opline->op1.u.var).str_offset.str->refcount++;
+ Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
}
}
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
if (opline->extended_value) {
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
expr_ptr = *expr_ptr_ptr;
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
} else
#endif
if (PZVAL_IS_REF(expr_ptr)) {
expr_ptr = new_expr;
zendi_zval_copy_ctor(*expr_ptr);
} else {
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
}
}
if (offset) {
EX(object) = NULL;
} else {
if (!PZVAL_IS_REF(EX(object))) {
- EX(object)->refcount++; /* For $this pointer */
+ Z_ADDREF_P(EX(object)); /* For $this pointer */
} else {
zval *this_ptr;
ALLOC_ZVAL(this_ptr);
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
} else {
switch_expr_is_overloaded = 1;
- EX_T(opline->op1.u.var).str_offset.str->refcount++;
+ Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
}
}
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
if (opline->extended_value) {
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
expr_ptr = *expr_ptr_ptr;
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
} else
#endif
if (PZVAL_IS_REF(expr_ptr)) {
expr_ptr = new_expr;
zendi_zval_copy_ctor(*expr_ptr);
} else {
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
}
}
if (offset) {
EX(object) = NULL;
} else {
if (!PZVAL_IS_REF(EX(object))) {
- EX(object)->refcount++; /* For $this pointer */
+ Z_ADDREF_P(EX(object)); /* For $this pointer */
} else {
zval *this_ptr;
ALLOC_ZVAL(this_ptr);
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
} else {
switch_expr_is_overloaded = 1;
- EX_T(opline->op1.u.var).str_offset.str->refcount++;
+ Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
}
}
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
if (opline->extended_value) {
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
expr_ptr = *expr_ptr_ptr;
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
} else
#endif
if (PZVAL_IS_REF(expr_ptr)) {
expr_ptr = new_expr;
zendi_zval_copy_ctor(*expr_ptr);
} else {
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
}
}
if (offset) {
if (opline->extended_value) {
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
expr_ptr = *expr_ptr_ptr;
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
} else
#endif
if (PZVAL_IS_REF(expr_ptr)) {
expr_ptr = new_expr;
zendi_zval_copy_ctor(*expr_ptr);
} else {
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
}
}
if (offset) {
EX(object) = NULL;
} else {
if (!PZVAL_IS_REF(EX(object))) {
- EX(object)->refcount++; /* For $this pointer */
+ Z_ADDREF_P(EX(object)); /* For $this pointer */
} else {
zval *this_ptr;
ALLOC_ZVAL(this_ptr);
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
} else {
switch_expr_is_overloaded = 1;
- EX_T(opline->op1.u.var).str_offset.str->refcount++;
+ Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
}
}
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
if (opline->extended_value) {
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
expr_ptr = *expr_ptr_ptr;
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
} else
#endif
if (PZVAL_IS_REF(expr_ptr)) {
expr_ptr = new_expr;
zendi_zval_copy_ctor(*expr_ptr);
} else {
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
}
}
if (offset) {
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */
zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
- val->refcount++;
+ Z_ADDREF_P(val);
increment_function(val);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
zval_ptr_dtor(&val);
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */
zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
- val->refcount++;
+ Z_ADDREF_P(val);
decrement_function(val);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
zval_ptr_dtor(&val);
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */
zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
- val->refcount++;
+ Z_ADDREF_P(val);
increment_function(val);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
zval_ptr_dtor(&val);
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */
zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
- val->refcount++;
+ Z_ADDREF_P(val);
decrement_function(val);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
zval_ptr_dtor(&val);
case BP_VAR_W: {
zval *new_zval = &EG(uninitialized_zval);
- new_zval->refcount++;
+ Z_ADDREF_P(new_zval);
zend_u_hash_update(target_symbol_table, Z_TYPE_P(varname), Z_UNIVAL_P(varname), Z_UNILEN_P(varname)+1, &new_zval, sizeof(zval *), (void **) &retval);
}
break;
zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
}
- if (IS_VAR == IS_VAR && !(*retval_ptr_ptr)->is_ref) {
+ if (IS_VAR == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) {
if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
EX_T(opline->op1.u.var).var.fcall_returned_reference) {
} else if (opline->extended_value == ZEND_RETURNS_NEW) {
}
SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
- (*retval_ptr_ptr)->refcount++;
+ Z_ADDREF_PP(retval_ptr_ptr);
(*EG(return_value_ptr_ptr)) = (*retval_ptr_ptr);
} else {
if (!0) { /* Not a temp var */
if (EG(active_op_array)->return_reference == ZEND_RETURN_REF ||
- (PZVAL_IS_REF(retval_ptr) && retval_ptr->refcount > 0)) {
+ (PZVAL_IS_REF(retval_ptr) && Z_REFCOUNT_P(retval_ptr) > 0)) {
zval *ret;
ALLOC_ZVAL(ret);
*EG(return_value_ptr_ptr) = ret;
} else {
*EG(return_value_ptr_ptr) = retval_ptr;
- retval_ptr->refcount++;
+ Z_ADDREF_P(retval_ptr);
}
} else {
zval *ret;
if (varptr == &EG(uninitialized_zval)) {
ALLOC_ZVAL(varptr);
INIT_ZVAL(*varptr);
- varptr->refcount = 0;
+ Z_SET_REFCOUNT_P(varptr, 0);
} else if (PZVAL_IS_REF(varptr)) {
zval *original_var = varptr;
ALLOC_ZVAL(varptr);
*varptr = *original_var;
- varptr->is_ref = 0;
- varptr->refcount = 0;
+ Z_UNSET_ISREF_P(varptr);
+ Z_SET_REFCOUNT_P(varptr, 0);
zval_copy_ctor(varptr);
}
- varptr->refcount++;
+ Z_ADDREF_P(varptr);
zend_ptr_stack_push(&EG(argument_stack), varptr);
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);}; /* for string offsets */
EX_T(opline->op1.u.var).var.fcall_returned_reference) &&
varptr != &EG(uninitialized_zval) &&
(PZVAL_IS_REF(varptr) ||
- (varptr->refcount == 1 && (IS_VAR == IS_CV || free_op1.var)))) {
- varptr->is_ref = 1;
- varptr->refcount++;
+ (Z_REFCOUNT_P(varptr) == 1 && (IS_VAR == IS_CV || free_op1.var)))) {
+ Z_SET_ISREF_P(varptr);
+ Z_ADDREF_P(varptr);
zend_ptr_stack_push(&EG(argument_stack), varptr);
} else {
zval *valptr;
SEPARATE_ZVAL_TO_MAKE_IS_REF(varptr_ptr);
varptr = *varptr_ptr;
- varptr->refcount++;
+ Z_ADDREF_P(varptr);
zend_ptr_stack_push(&EG(argument_stack), varptr);
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
if (!obj || Z_TYPE_P(obj) != IS_OBJECT) {
zend_error_noreturn(E_ERROR, "__clone method called on non-object");
EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr);
- EX_T(opline->result.u.var).var.ptr->refcount++;
+ Z_ADDREF_P(EX_T(opline->result.u.var).var.ptr);
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
}
zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
}
EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr);
- EX_T(opline->result.u.var).var.ptr->refcount++;
+ Z_ADDREF_P(EX_T(opline->result.u.var).var.ptr);
}
if (ce && clone) {
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
Z_OBJVAL_P(EX_T(opline->result.u.var).var.ptr) = clone_call(obj TSRMLS_CC);
Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_OBJECT;
- EX_T(opline->result.u.var).var.ptr->refcount=1;
- EX_T(opline->result.u.var).var.ptr->is_ref=1;
+ Z_SET_REFCOUNT_P(EX_T(opline->result.u.var).var.ptr, 1);
+ Z_SET_ISREF_P(EX_T(opline->result.u.var).var.ptr);
if (!RETURN_VALUE_USED(opline) || EG(exception)) {
zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
}
convert_to_text(&tmp);
varname = &tmp;
} else if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
- varname->refcount++;
+ Z_ADDREF_P(varname);
}
if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
ce = Z_OBJCE_PP(array_ptr_ptr);
if (!ce || ce->get_iterator == NULL) {
SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
- (*array_ptr_ptr)->refcount++;
+ Z_ADDREF_PP(array_ptr_ptr);
}
array_ptr = *array_ptr_ptr;
} else {
if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) {
SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
- (*array_ptr_ptr)->is_ref = 1;
+ Z_SET_ISREF_PP(array_ptr_ptr);
}
}
array_ptr = *array_ptr_ptr;
- array_ptr->refcount++;
+ Z_ADDREF_P(array_ptr);
}
} else {
array_ptr = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
} else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
ce = Z_OBJCE_P(array_ptr);
if (!ce || !ce->get_iterator) {
- array_ptr->refcount++;
+ Z_ADDREF_P(array_ptr);
}
} else {
if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
- !array_ptr->is_ref &&
- array_ptr->refcount > 1) {
+ !Z_ISREF_P(array_ptr) &&
+ Z_REFCOUNT_P(array_ptr) > 1) {
zval *tmp;
ALLOC_ZVAL(tmp);
zval_copy_ctor(tmp);
array_ptr = tmp;
} else {
- array_ptr->refcount++;
+ Z_ADDREF_P(array_ptr);
}
}
}
if (iter->funcs->rewind) {
iter->funcs->rewind(iter TSRMLS_CC);
if (EG(exception)) {
- array_ptr->refcount--;
+ Z_DELREF_P(array_ptr);
zval_ptr_dtor(&array_ptr);
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
}
is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS;
if (EG(exception)) {
- array_ptr->refcount--;
+ Z_DELREF_P(array_ptr);
zval_ptr_dtor(&array_ptr);
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
* In case that ever happens we need an additional flag. */
iter->funcs->move_forward(iter TSRMLS_CC);
if (EG(exception)) {
- array->refcount--;
+ Z_DELREF_P(array);
zval_ptr_dtor(&array);
ZEND_VM_NEXT_OPCODE();
}
if (!iter || (iter->index > 0 && iter->funcs->valid(iter TSRMLS_CC) == FAILURE)) {
/* reached end of iteration */
if (EG(exception)) {
- array->refcount--;
+ Z_DELREF_P(array);
zval_ptr_dtor(&array);
ZEND_VM_NEXT_OPCODE();
}
}
iter->funcs->get_current_data(iter, &value TSRMLS_CC);
if (EG(exception)) {
- array->refcount--;
+ Z_DELREF_P(array);
zval_ptr_dtor(&array);
ZEND_VM_NEXT_OPCODE();
}
if (iter->funcs->get_current_key) {
key_type = iter->funcs->get_current_key(iter, &str_key, &str_key_len, &int_key TSRMLS_CC);
if (EG(exception)) {
- array->refcount--;
+ Z_DELREF_P(array);
zval_ptr_dtor(&array);
ZEND_VM_NEXT_OPCODE();
}
if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
SEPARATE_ZVAL_IF_NOT_REF(value);
- (*value)->is_ref = 1;
+ Z_SET_ISREF_PP(value);
EX_T(opline->result.u.var).var.ptr_ptr = value;
- (*value)->refcount++;
+ Z_ADDREF_PP(value);
} else {
EX_T(opline->result.u.var).var.ptr_ptr = value;
PZVAL_LOCK(*EX_T(opline->result.u.var).var.ptr_ptr);
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
z = value;
}
- z->refcount++;
+ Z_ADDREF_P(z);
SEPARATE_ZVAL_IF_NOT_REF(&z);
binary_op(z, z, value TSRMLS_CC);
switch (opline->extended_value) {
zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
if (object_ptr && IS_VAR != IS_CV && !(free_op1.var != NULL)) {
- (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
+ Z_ADDREF_PP(object_ptr); /* undo the effect of get_obj_zval_ptr_ptr() */
}
if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
- objval->refcount++;
+ Z_ADDREF_P(objval);
binary_op(objval, objval, value TSRMLS_CC);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
zval_ptr_dtor(&objval);
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
z = value;
}
- z->refcount++;
+ Z_ADDREF_P(z);
SEPARATE_ZVAL_IF_NOT_REF(&z);
incdec_op(z);
*retval = z;
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
zendi_zval_copy_ctor(*z_copy);
INIT_PZVAL(z_copy);
incdec_op(z_copy);
- z->refcount++;
+ Z_ADDREF_P(z);
Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
zval_ptr_dtor(&z_copy);
zval_ptr_dtor(&z);
/* here we are sure we are dealing with an object */
*retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
- if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
+ if (RETURN_VALUE_UNUSED(&opline->result) && (Z_REFCOUNT_PP(retval) == 0)) {
zval_dtor(*retval);
FREE_ZVAL(*retval);
} else {
EX(object) = NULL;
} else {
if (!PZVAL_IS_REF(EX(object))) {
- EX(object)->refcount++; /* For $this pointer */
+ Z_ADDREF_P(EX(object)); /* For $this pointer */
} else {
zval *this_ptr;
ALLOC_ZVAL(this_ptr);
}
if ((EX(object) = EG(This))) {
- EX(object)->refcount++;
+ Z_ADDREF_P(EX(object));
EX(called_scope) = Z_OBJCE_P(EX(object));
}
}
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
} else {
switch_expr_is_overloaded = 1;
- EX_T(opline->op1.u.var).str_offset.str->refcount++;
+ Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
}
}
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
if (opline->extended_value) {
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
expr_ptr = *expr_ptr_ptr;
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
} else
#endif
if (PZVAL_IS_REF(expr_ptr)) {
expr_ptr = new_expr;
zendi_zval_copy_ctor(*expr_ptr);
} else {
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
}
}
if (offset) {
free_offset = 1;
}
} else if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
- offset->refcount++;
+ Z_ADDREF_P(offset);
}
if (zend_u_symtable_del(ht, Z_TYPE_P(offset), offset_key, offset_len+1) == SUCCESS &&
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
z = value;
}
- z->refcount++;
+ Z_ADDREF_P(z);
SEPARATE_ZVAL_IF_NOT_REF(&z);
binary_op(z, z, value TSRMLS_CC);
switch (opline->extended_value) {
zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
if (object_ptr && IS_VAR != IS_CV && !(free_op1.var != NULL)) {
- (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
+ Z_ADDREF_PP(object_ptr); /* undo the effect of get_obj_zval_ptr_ptr() */
}
if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
- objval->refcount++;
+ Z_ADDREF_P(objval);
binary_op(objval, objval, value TSRMLS_CC);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
zval_ptr_dtor(&objval);
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
z = value;
}
- z->refcount++;
+ Z_ADDREF_P(z);
SEPARATE_ZVAL_IF_NOT_REF(&z);
incdec_op(z);
*retval = z;
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
zendi_zval_copy_ctor(*z_copy);
INIT_PZVAL(z_copy);
incdec_op(z_copy);
- z->refcount++;
+ Z_ADDREF_P(z);
Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
zval_ptr_dtor(&z_copy);
zval_ptr_dtor(&z);
/* here we are sure we are dealing with an object */
*retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
- if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
+ if (RETURN_VALUE_UNUSED(&opline->result) && (Z_REFCOUNT_PP(retval) == 0)) {
zval_dtor(*retval);
FREE_ZVAL(*retval);
} else {
EX(object) = NULL;
} else {
if (!PZVAL_IS_REF(EX(object))) {
- EX(object)->refcount++; /* For $this pointer */
+ Z_ADDREF_P(EX(object)); /* For $this pointer */
} else {
zval *this_ptr;
ALLOC_ZVAL(this_ptr);
}
if ((EX(object) = EG(This))) {
- EX(object)->refcount++;
+ Z_ADDREF_P(EX(object));
EX(called_scope) = Z_OBJCE_P(EX(object));
}
}
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
} else {
switch_expr_is_overloaded = 1;
- EX_T(opline->op1.u.var).str_offset.str->refcount++;
+ Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
}
}
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
if (opline->extended_value) {
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
expr_ptr = *expr_ptr_ptr;
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
} else
#endif
if (PZVAL_IS_REF(expr_ptr)) {
expr_ptr = new_expr;
zendi_zval_copy_ctor(*expr_ptr);
} else {
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
}
}
if (offset) {
free_offset = 1;
}
} else if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
- offset->refcount++;
+ Z_ADDREF_P(offset);
}
if (zend_u_symtable_del(ht, Z_TYPE_P(offset), offset_key, offset_len+1) == SUCCESS &&
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
z = value;
}
- z->refcount++;
+ Z_ADDREF_P(z);
SEPARATE_ZVAL_IF_NOT_REF(&z);
binary_op(z, z, value TSRMLS_CC);
switch (opline->extended_value) {
zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
if (object_ptr && IS_VAR != IS_CV && !(free_op1.var != NULL)) {
- (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
+ Z_ADDREF_PP(object_ptr); /* undo the effect of get_obj_zval_ptr_ptr() */
}
if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
- objval->refcount++;
+ Z_ADDREF_P(objval);
binary_op(objval, objval, value TSRMLS_CC);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
zval_ptr_dtor(&objval);
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
z = value;
}
- z->refcount++;
+ Z_ADDREF_P(z);
SEPARATE_ZVAL_IF_NOT_REF(&z);
incdec_op(z);
*retval = z;
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
zendi_zval_copy_ctor(*z_copy);
INIT_PZVAL(z_copy);
incdec_op(z_copy);
- z->refcount++;
+ Z_ADDREF_P(z);
Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
zval_ptr_dtor(&z_copy);
zval_ptr_dtor(&z);
/* here we are sure we are dealing with an object */
*retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
- if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
+ if (RETURN_VALUE_UNUSED(&opline->result) && (Z_REFCOUNT_PP(retval) == 0)) {
zval_dtor(*retval);
FREE_ZVAL(*retval);
} else {
if (IS_VAR == IS_VAR &&
value_ptr_ptr &&
- !(*value_ptr_ptr)->is_ref &&
+ !Z_ISREF_PP(value_ptr_ptr) &&
opline->extended_value == ZEND_RETURNS_FUNCTION &&
!EX_T(opline->op2.u.var).var.fcall_returned_reference) {
if (free_op2.var == NULL) {
EX(object) = NULL;
} else {
if (!PZVAL_IS_REF(EX(object))) {
- EX(object)->refcount++; /* For $this pointer */
+ Z_ADDREF_P(EX(object)); /* For $this pointer */
} else {
zval *this_ptr;
ALLOC_ZVAL(this_ptr);
}
if ((EX(object) = EG(This))) {
- EX(object)->refcount++;
+ Z_ADDREF_P(EX(object));
EX(called_scope) = Z_OBJCE_P(EX(object));
}
}
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
} else {
switch_expr_is_overloaded = 1;
- EX_T(opline->op1.u.var).str_offset.str->refcount++;
+ Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
}
}
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
if (opline->extended_value) {
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
expr_ptr = *expr_ptr_ptr;
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
} else
#endif
if (PZVAL_IS_REF(expr_ptr)) {
expr_ptr = new_expr;
zendi_zval_copy_ctor(*expr_ptr);
} else {
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
}
}
if (offset) {
free_offset = 1;
}
} else if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
- offset->refcount++;
+ Z_ADDREF_P(offset);
}
if (zend_u_symtable_del(ht, Z_TYPE_P(offset), offset_key, offset_len+1) == SUCCESS &&
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
z = value;
}
- z->refcount++;
+ Z_ADDREF_P(z);
SEPARATE_ZVAL_IF_NOT_REF(&z);
binary_op(z, z, value TSRMLS_CC);
switch (opline->extended_value) {
zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
if (object_ptr && IS_VAR != IS_CV && !(free_op1.var != NULL)) {
- (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
+ Z_ADDREF_PP(object_ptr); /* undo the effect of get_obj_zval_ptr_ptr() */
}
if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
- objval->refcount++;
+ Z_ADDREF_P(objval);
binary_op(objval, objval, value TSRMLS_CC);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
zval_ptr_dtor(&objval);
}
if ((EX(object) = EG(This))) {
- EX(object)->refcount++;
+ Z_ADDREF_P(EX(object));
EX(called_scope) = Z_OBJCE_P(EX(object));
}
}
if (opline->extended_value) {
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
expr_ptr = *expr_ptr_ptr;
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
} else
#endif
if (PZVAL_IS_REF(expr_ptr)) {
expr_ptr = new_expr;
zendi_zval_copy_ctor(*expr_ptr);
} else {
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
}
}
if (offset) {
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
z = value;
}
- z->refcount++;
+ Z_ADDREF_P(z);
SEPARATE_ZVAL_IF_NOT_REF(&z);
binary_op(z, z, value TSRMLS_CC);
switch (opline->extended_value) {
zval **object_ptr = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
if (object_ptr && IS_VAR != IS_CV && !(free_op1.var != NULL)) {
- (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
+ Z_ADDREF_PP(object_ptr); /* undo the effect of get_obj_zval_ptr_ptr() */
}
if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
- objval->refcount++;
+ Z_ADDREF_P(objval);
binary_op(objval, objval, value TSRMLS_CC);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
zval_ptr_dtor(&objval);
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
z = value;
}
- z->refcount++;
+ Z_ADDREF_P(z);
SEPARATE_ZVAL_IF_NOT_REF(&z);
incdec_op(z);
*retval = z;
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
zendi_zval_copy_ctor(*z_copy);
INIT_PZVAL(z_copy);
incdec_op(z_copy);
- z->refcount++;
+ Z_ADDREF_P(z);
Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
zval_ptr_dtor(&z_copy);
zval_ptr_dtor(&z);
/* here we are sure we are dealing with an object */
*retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
- if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
+ if (RETURN_VALUE_UNUSED(&opline->result) && (Z_REFCOUNT_PP(retval) == 0)) {
zval_dtor(*retval);
FREE_ZVAL(*retval);
} else {
if (IS_CV == IS_VAR &&
value_ptr_ptr &&
- !(*value_ptr_ptr)->is_ref &&
+ !Z_ISREF_PP(value_ptr_ptr) &&
opline->extended_value == ZEND_RETURNS_FUNCTION &&
!EX_T(opline->op2.u.var).var.fcall_returned_reference) {
if (free_op2.var == NULL) {
EX(object) = NULL;
} else {
if (!PZVAL_IS_REF(EX(object))) {
- EX(object)->refcount++; /* For $this pointer */
+ Z_ADDREF_P(EX(object)); /* For $this pointer */
} else {
zval *this_ptr;
ALLOC_ZVAL(this_ptr);
}
if ((EX(object) = EG(This))) {
- EX(object)->refcount++;
+ Z_ADDREF_P(EX(object));
EX(called_scope) = Z_OBJCE_P(EX(object));
}
}
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
} else {
switch_expr_is_overloaded = 1;
- EX_T(opline->op1.u.var).str_offset.str->refcount++;
+ Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
}
}
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
if (opline->extended_value) {
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
expr_ptr = *expr_ptr_ptr;
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
} else
#endif
if (PZVAL_IS_REF(expr_ptr)) {
expr_ptr = new_expr;
zendi_zval_copy_ctor(*expr_ptr);
} else {
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
}
}
if (offset) {
free_offset = 1;
}
} else if (IS_CV == IS_CV || IS_CV == IS_VAR) {
- offset->refcount++;
+ Z_ADDREF_P(offset);
}
if (zend_u_symtable_del(ht, Z_TYPE_P(offset), offset_key, offset_len+1) == SUCCESS &&
if (!obj || Z_TYPE_P(obj) != IS_OBJECT) {
zend_error_noreturn(E_ERROR, "__clone method called on non-object");
EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr);
- EX_T(opline->result.u.var).var.ptr->refcount++;
+ Z_ADDREF_P(EX_T(opline->result.u.var).var.ptr);
ZEND_VM_NEXT_OPCODE();
}
zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
}
EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr);
- EX_T(opline->result.u.var).var.ptr->refcount++;
+ Z_ADDREF_P(EX_T(opline->result.u.var).var.ptr);
}
if (ce && clone) {
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
Z_OBJVAL_P(EX_T(opline->result.u.var).var.ptr) = clone_call(obj TSRMLS_CC);
Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_OBJECT;
- EX_T(opline->result.u.var).var.ptr->refcount=1;
- EX_T(opline->result.u.var).var.ptr->is_ref=1;
+ Z_SET_REFCOUNT_P(EX_T(opline->result.u.var).var.ptr, 1);
+ Z_SET_ISREF_P(EX_T(opline->result.u.var).var.ptr);
if (!RETURN_VALUE_USED(opline) || EG(exception)) {
zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
}
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
z = value;
}
- z->refcount++;
+ Z_ADDREF_P(z);
SEPARATE_ZVAL_IF_NOT_REF(&z);
binary_op(z, z, value TSRMLS_CC);
switch (opline->extended_value) {
zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
if (object_ptr && IS_UNUSED != IS_CV && !0) {
- (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
+ Z_ADDREF_PP(object_ptr); /* undo the effect of get_obj_zval_ptr_ptr() */
}
if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
- objval->refcount++;
+ Z_ADDREF_P(objval);
binary_op(objval, objval, value TSRMLS_CC);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
zval_ptr_dtor(&objval);
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
z = value;
}
- z->refcount++;
+ Z_ADDREF_P(z);
SEPARATE_ZVAL_IF_NOT_REF(&z);
incdec_op(z);
*retval = z;
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
zendi_zval_copy_ctor(*z_copy);
INIT_PZVAL(z_copy);
incdec_op(z_copy);
- z->refcount++;
+ Z_ADDREF_P(z);
Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
zval_ptr_dtor(&z_copy);
zval_ptr_dtor(&z);
/* here we are sure we are dealing with an object */
*retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
- if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
+ if (RETURN_VALUE_UNUSED(&opline->result) && (Z_REFCOUNT_PP(retval) == 0)) {
zval_dtor(*retval);
FREE_ZVAL(*retval);
} else {
EX(object) = NULL;
} else {
if (!PZVAL_IS_REF(EX(object))) {
- EX(object)->refcount++; /* For $this pointer */
+ Z_ADDREF_P(EX(object)); /* For $this pointer */
} else {
zval *this_ptr;
ALLOC_ZVAL(this_ptr);
free_offset = 1;
}
} else if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
- offset->refcount++;
+ Z_ADDREF_P(offset);
}
if (zend_u_symtable_del(ht, Z_TYPE_P(offset), offset_key, offset_len+1) == SUCCESS &&
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
z = value;
}
- z->refcount++;
+ Z_ADDREF_P(z);
SEPARATE_ZVAL_IF_NOT_REF(&z);
binary_op(z, z, value TSRMLS_CC);
switch (opline->extended_value) {
zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
if (object_ptr && IS_UNUSED != IS_CV && !0) {
- (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
+ Z_ADDREF_PP(object_ptr); /* undo the effect of get_obj_zval_ptr_ptr() */
}
if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
- objval->refcount++;
+ Z_ADDREF_P(objval);
binary_op(objval, objval, value TSRMLS_CC);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
zval_ptr_dtor(&objval);
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
z = value;
}
- z->refcount++;
+ Z_ADDREF_P(z);
SEPARATE_ZVAL_IF_NOT_REF(&z);
incdec_op(z);
*retval = z;
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
zendi_zval_copy_ctor(*z_copy);
INIT_PZVAL(z_copy);
incdec_op(z_copy);
- z->refcount++;
+ Z_ADDREF_P(z);
Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
zval_ptr_dtor(&z_copy);
zval_ptr_dtor(&z);
/* here we are sure we are dealing with an object */
*retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
- if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
+ if (RETURN_VALUE_UNUSED(&opline->result) && (Z_REFCOUNT_PP(retval) == 0)) {
zval_dtor(*retval);
FREE_ZVAL(*retval);
} else {
EX(object) = NULL;
} else {
if (!PZVAL_IS_REF(EX(object))) {
- EX(object)->refcount++; /* For $this pointer */
+ Z_ADDREF_P(EX(object)); /* For $this pointer */
} else {
zval *this_ptr;
ALLOC_ZVAL(this_ptr);
free_offset = 1;
}
} else if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
- offset->refcount++;
+ Z_ADDREF_P(offset);
}
if (zend_u_symtable_del(ht, Z_TYPE_P(offset), offset_key, offset_len+1) == SUCCESS &&
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
z = value;
}
- z->refcount++;
+ Z_ADDREF_P(z);
SEPARATE_ZVAL_IF_NOT_REF(&z);
binary_op(z, z, value TSRMLS_CC);
switch (opline->extended_value) {
zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
if (object_ptr && IS_UNUSED != IS_CV && !0) {
- (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
+ Z_ADDREF_PP(object_ptr); /* undo the effect of get_obj_zval_ptr_ptr() */
}
if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
- objval->refcount++;
+ Z_ADDREF_P(objval);
binary_op(objval, objval, value TSRMLS_CC);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
zval_ptr_dtor(&objval);
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
z = value;
}
- z->refcount++;
+ Z_ADDREF_P(z);
SEPARATE_ZVAL_IF_NOT_REF(&z);
incdec_op(z);
*retval = z;
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
zendi_zval_copy_ctor(*z_copy);
INIT_PZVAL(z_copy);
incdec_op(z_copy);
- z->refcount++;
+ Z_ADDREF_P(z);
Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
zval_ptr_dtor(&z_copy);
zval_ptr_dtor(&z);
/* here we are sure we are dealing with an object */
*retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
- if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
+ if (RETURN_VALUE_UNUSED(&opline->result) && (Z_REFCOUNT_PP(retval) == 0)) {
zval_dtor(*retval);
FREE_ZVAL(*retval);
} else {
EX(object) = NULL;
} else {
if (!PZVAL_IS_REF(EX(object))) {
- EX(object)->refcount++; /* For $this pointer */
+ Z_ADDREF_P(EX(object)); /* For $this pointer */
} else {
zval *this_ptr;
ALLOC_ZVAL(this_ptr);
free_offset = 1;
}
} else if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
- offset->refcount++;
+ Z_ADDREF_P(offset);
}
if (zend_u_symtable_del(ht, Z_TYPE_P(offset), offset_key, offset_len+1) == SUCCESS &&
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
z = value;
}
- z->refcount++;
+ Z_ADDREF_P(z);
SEPARATE_ZVAL_IF_NOT_REF(&z);
binary_op(z, z, value TSRMLS_CC);
switch (opline->extended_value) {
zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
if (object_ptr && IS_UNUSED != IS_CV && !0) {
- (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
+ Z_ADDREF_PP(object_ptr); /* undo the effect of get_obj_zval_ptr_ptr() */
}
if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
- objval->refcount++;
+ Z_ADDREF_P(objval);
binary_op(objval, objval, value TSRMLS_CC);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
zval_ptr_dtor(&objval);
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
z = value;
}
- z->refcount++;
+ Z_ADDREF_P(z);
SEPARATE_ZVAL_IF_NOT_REF(&z);
binary_op(z, z, value TSRMLS_CC);
switch (opline->extended_value) {
zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
if (object_ptr && IS_UNUSED != IS_CV && !0) {
- (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
+ Z_ADDREF_PP(object_ptr); /* undo the effect of get_obj_zval_ptr_ptr() */
}
if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
- objval->refcount++;
+ Z_ADDREF_P(objval);
binary_op(objval, objval, value TSRMLS_CC);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
zval_ptr_dtor(&objval);
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
z = value;
}
- z->refcount++;
+ Z_ADDREF_P(z);
SEPARATE_ZVAL_IF_NOT_REF(&z);
incdec_op(z);
*retval = z;
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
zendi_zval_copy_ctor(*z_copy);
INIT_PZVAL(z_copy);
incdec_op(z_copy);
- z->refcount++;
+ Z_ADDREF_P(z);
Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
zval_ptr_dtor(&z_copy);
zval_ptr_dtor(&z);
/* here we are sure we are dealing with an object */
*retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
- if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
+ if (RETURN_VALUE_UNUSED(&opline->result) && (Z_REFCOUNT_PP(retval) == 0)) {
zval_dtor(*retval);
FREE_ZVAL(*retval);
} else {
EX(object) = NULL;
} else {
if (!PZVAL_IS_REF(EX(object))) {
- EX(object)->refcount++; /* For $this pointer */
+ Z_ADDREF_P(EX(object)); /* For $this pointer */
} else {
zval *this_ptr;
ALLOC_ZVAL(this_ptr);
free_offset = 1;
}
} else if (IS_CV == IS_CV || IS_CV == IS_VAR) {
- offset->refcount++;
+ Z_ADDREF_P(offset);
}
if (zend_u_symtable_del(ht, Z_TYPE_P(offset), offset_key, offset_len+1) == SUCCESS &&
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */
zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
- val->refcount++;
+ Z_ADDREF_P(val);
increment_function(val);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
zval_ptr_dtor(&val);
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */
zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
- val->refcount++;
+ Z_ADDREF_P(val);
decrement_function(val);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
zval_ptr_dtor(&val);
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */
zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
- val->refcount++;
+ Z_ADDREF_P(val);
increment_function(val);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
zval_ptr_dtor(&val);
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */
zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
- val->refcount++;
+ Z_ADDREF_P(val);
decrement_function(val);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
zval_ptr_dtor(&val);
case BP_VAR_W: {
zval *new_zval = &EG(uninitialized_zval);
- new_zval->refcount++;
+ Z_ADDREF_P(new_zval);
zend_u_hash_update(target_symbol_table, Z_TYPE_P(varname), Z_UNIVAL_P(varname), Z_UNILEN_P(varname)+1, &new_zval, sizeof(zval *), (void **) &retval);
}
break;
zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
}
- if (IS_CV == IS_VAR && !(*retval_ptr_ptr)->is_ref) {
+ if (IS_CV == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) {
if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
EX_T(opline->op1.u.var).var.fcall_returned_reference) {
} else if (opline->extended_value == ZEND_RETURNS_NEW) {
}
SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
- (*retval_ptr_ptr)->refcount++;
+ Z_ADDREF_PP(retval_ptr_ptr);
(*EG(return_value_ptr_ptr)) = (*retval_ptr_ptr);
} else {
if (!0) { /* Not a temp var */
if (EG(active_op_array)->return_reference == ZEND_RETURN_REF ||
- (PZVAL_IS_REF(retval_ptr) && retval_ptr->refcount > 0)) {
+ (PZVAL_IS_REF(retval_ptr) && Z_REFCOUNT_P(retval_ptr) > 0)) {
zval *ret;
ALLOC_ZVAL(ret);
*EG(return_value_ptr_ptr) = ret;
} else {
*EG(return_value_ptr_ptr) = retval_ptr;
- retval_ptr->refcount++;
+ Z_ADDREF_P(retval_ptr);
}
} else {
zval *ret;
if (varptr == &EG(uninitialized_zval)) {
ALLOC_ZVAL(varptr);
INIT_ZVAL(*varptr);
- varptr->refcount = 0;
+ Z_SET_REFCOUNT_P(varptr, 0);
} else if (PZVAL_IS_REF(varptr)) {
zval *original_var = varptr;
ALLOC_ZVAL(varptr);
*varptr = *original_var;
- varptr->is_ref = 0;
- varptr->refcount = 0;
+ Z_UNSET_ISREF_P(varptr);
+ Z_SET_REFCOUNT_P(varptr, 0);
zval_copy_ctor(varptr);
}
- varptr->refcount++;
+ Z_ADDREF_P(varptr);
zend_ptr_stack_push(&EG(argument_stack), varptr);
; /* for string offsets */
EX_T(opline->op1.u.var).var.fcall_returned_reference) &&
varptr != &EG(uninitialized_zval) &&
(PZVAL_IS_REF(varptr) ||
- (varptr->refcount == 1 && (IS_CV == IS_CV || free_op1.var)))) {
- varptr->is_ref = 1;
- varptr->refcount++;
+ (Z_REFCOUNT_P(varptr) == 1 && (IS_CV == IS_CV || free_op1.var)))) {
+ Z_SET_ISREF_P(varptr);
+ Z_ADDREF_P(varptr);
zend_ptr_stack_push(&EG(argument_stack), varptr);
} else {
zval *valptr;
SEPARATE_ZVAL_TO_MAKE_IS_REF(varptr_ptr);
varptr = *varptr_ptr;
- varptr->refcount++;
+ Z_ADDREF_P(varptr);
zend_ptr_stack_push(&EG(argument_stack), varptr);
ZEND_VM_NEXT_OPCODE();
if (!obj || Z_TYPE_P(obj) != IS_OBJECT) {
zend_error_noreturn(E_ERROR, "__clone method called on non-object");
EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr);
- EX_T(opline->result.u.var).var.ptr->refcount++;
+ Z_ADDREF_P(EX_T(opline->result.u.var).var.ptr);
ZEND_VM_NEXT_OPCODE();
}
zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
}
EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr);
- EX_T(opline->result.u.var).var.ptr->refcount++;
+ Z_ADDREF_P(EX_T(opline->result.u.var).var.ptr);
}
if (ce && clone) {
ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
Z_OBJVAL_P(EX_T(opline->result.u.var).var.ptr) = clone_call(obj TSRMLS_CC);
Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_OBJECT;
- EX_T(opline->result.u.var).var.ptr->refcount=1;
- EX_T(opline->result.u.var).var.ptr->is_ref=1;
+ Z_SET_REFCOUNT_P(EX_T(opline->result.u.var).var.ptr, 1);
+ Z_SET_ISREF_P(EX_T(opline->result.u.var).var.ptr);
if (!RETURN_VALUE_USED(opline) || EG(exception)) {
zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
}
convert_to_text(&tmp);
varname = &tmp;
} else if (IS_CV == IS_CV || IS_CV == IS_VAR) {
- varname->refcount++;
+ Z_ADDREF_P(varname);
}
if (opline->op2.u.EA.type == ZEND_FETCH_STATIC_MEMBER) {
ce = Z_OBJCE_PP(array_ptr_ptr);
if (!ce || ce->get_iterator == NULL) {
SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
- (*array_ptr_ptr)->refcount++;
+ Z_ADDREF_PP(array_ptr_ptr);
}
array_ptr = *array_ptr_ptr;
} else {
if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) {
SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
- (*array_ptr_ptr)->is_ref = 1;
+ Z_SET_ISREF_PP(array_ptr_ptr);
}
}
array_ptr = *array_ptr_ptr;
- array_ptr->refcount++;
+ Z_ADDREF_P(array_ptr);
}
} else {
array_ptr = _get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
} else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
ce = Z_OBJCE_P(array_ptr);
if (!ce || !ce->get_iterator) {
- array_ptr->refcount++;
+ Z_ADDREF_P(array_ptr);
}
} else {
if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
- !array_ptr->is_ref &&
- array_ptr->refcount > 1) {
+ !Z_ISREF_P(array_ptr) &&
+ Z_REFCOUNT_P(array_ptr) > 1) {
zval *tmp;
ALLOC_ZVAL(tmp);
zval_copy_ctor(tmp);
array_ptr = tmp;
} else {
- array_ptr->refcount++;
+ Z_ADDREF_P(array_ptr);
}
}
}
if (iter->funcs->rewind) {
iter->funcs->rewind(iter TSRMLS_CC);
if (EG(exception)) {
- array_ptr->refcount--;
+ Z_DELREF_P(array_ptr);
zval_ptr_dtor(&array_ptr);
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
}
is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS;
if (EG(exception)) {
- array_ptr->refcount--;
+ Z_DELREF_P(array_ptr);
zval_ptr_dtor(&array_ptr);
if (opline->extended_value & ZEND_FE_RESET_VARIABLE) {
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
z = value;
}
- z->refcount++;
+ Z_ADDREF_P(z);
SEPARATE_ZVAL_IF_NOT_REF(&z);
binary_op(z, z, value TSRMLS_CC);
switch (opline->extended_value) {
zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
if (object_ptr && IS_CV != IS_CV && !0) {
- (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
+ Z_ADDREF_PP(object_ptr); /* undo the effect of get_obj_zval_ptr_ptr() */
}
if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
- objval->refcount++;
+ Z_ADDREF_P(objval);
binary_op(objval, objval, value TSRMLS_CC);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
zval_ptr_dtor(&objval);
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
z = value;
}
- z->refcount++;
+ Z_ADDREF_P(z);
SEPARATE_ZVAL_IF_NOT_REF(&z);
incdec_op(z);
*retval = z;
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
zendi_zval_copy_ctor(*z_copy);
INIT_PZVAL(z_copy);
incdec_op(z_copy);
- z->refcount++;
+ Z_ADDREF_P(z);
Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
zval_ptr_dtor(&z_copy);
zval_ptr_dtor(&z);
/* here we are sure we are dealing with an object */
*retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
- if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
+ if (RETURN_VALUE_UNUSED(&opline->result) && (Z_REFCOUNT_PP(retval) == 0)) {
zval_dtor(*retval);
FREE_ZVAL(*retval);
} else {
EX(object) = NULL;
} else {
if (!PZVAL_IS_REF(EX(object))) {
- EX(object)->refcount++; /* For $this pointer */
+ Z_ADDREF_P(EX(object)); /* For $this pointer */
} else {
zval *this_ptr;
ALLOC_ZVAL(this_ptr);
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
} else {
switch_expr_is_overloaded = 1;
- EX_T(opline->op1.u.var).str_offset.str->refcount++;
+ Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
}
}
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
if (opline->extended_value) {
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
expr_ptr = *expr_ptr_ptr;
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
} else
#endif
if (PZVAL_IS_REF(expr_ptr)) {
expr_ptr = new_expr;
zendi_zval_copy_ctor(*expr_ptr);
} else {
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
}
}
if (offset) {
free_offset = 1;
}
} else if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
- offset->refcount++;
+ Z_ADDREF_P(offset);
}
if (zend_u_symtable_del(ht, Z_TYPE_P(offset), offset_key, offset_len+1) == SUCCESS &&
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
z = value;
}
- z->refcount++;
+ Z_ADDREF_P(z);
SEPARATE_ZVAL_IF_NOT_REF(&z);
binary_op(z, z, value TSRMLS_CC);
switch (opline->extended_value) {
zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
if (object_ptr && IS_CV != IS_CV && !0) {
- (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
+ Z_ADDREF_PP(object_ptr); /* undo the effect of get_obj_zval_ptr_ptr() */
}
if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
- objval->refcount++;
+ Z_ADDREF_P(objval);
binary_op(objval, objval, value TSRMLS_CC);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
zval_ptr_dtor(&objval);
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
z = value;
}
- z->refcount++;
+ Z_ADDREF_P(z);
SEPARATE_ZVAL_IF_NOT_REF(&z);
incdec_op(z);
*retval = z;
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
zendi_zval_copy_ctor(*z_copy);
INIT_PZVAL(z_copy);
incdec_op(z_copy);
- z->refcount++;
+ Z_ADDREF_P(z);
Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
zval_ptr_dtor(&z_copy);
zval_ptr_dtor(&z);
/* here we are sure we are dealing with an object */
*retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
- if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
+ if (RETURN_VALUE_UNUSED(&opline->result) && (Z_REFCOUNT_PP(retval) == 0)) {
zval_dtor(*retval);
FREE_ZVAL(*retval);
} else {
EX(object) = NULL;
} else {
if (!PZVAL_IS_REF(EX(object))) {
- EX(object)->refcount++; /* For $this pointer */
+ Z_ADDREF_P(EX(object)); /* For $this pointer */
} else {
zval *this_ptr;
ALLOC_ZVAL(this_ptr);
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
} else {
switch_expr_is_overloaded = 1;
- EX_T(opline->op1.u.var).str_offset.str->refcount++;
+ Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
}
}
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
if (opline->extended_value) {
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
expr_ptr = *expr_ptr_ptr;
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
} else
#endif
if (PZVAL_IS_REF(expr_ptr)) {
expr_ptr = new_expr;
zendi_zval_copy_ctor(*expr_ptr);
} else {
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
}
}
if (offset) {
free_offset = 1;
}
} else if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
- offset->refcount++;
+ Z_ADDREF_P(offset);
}
if (zend_u_symtable_del(ht, Z_TYPE_P(offset), offset_key, offset_len+1) == SUCCESS &&
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
z = value;
}
- z->refcount++;
+ Z_ADDREF_P(z);
SEPARATE_ZVAL_IF_NOT_REF(&z);
binary_op(z, z, value TSRMLS_CC);
switch (opline->extended_value) {
zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
if (object_ptr && IS_CV != IS_CV && !0) {
- (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
+ Z_ADDREF_PP(object_ptr); /* undo the effect of get_obj_zval_ptr_ptr() */
}
if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
- objval->refcount++;
+ Z_ADDREF_P(objval);
binary_op(objval, objval, value TSRMLS_CC);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
zval_ptr_dtor(&objval);
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
z = value;
}
- z->refcount++;
+ Z_ADDREF_P(z);
SEPARATE_ZVAL_IF_NOT_REF(&z);
incdec_op(z);
*retval = z;
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
zendi_zval_copy_ctor(*z_copy);
INIT_PZVAL(z_copy);
incdec_op(z_copy);
- z->refcount++;
+ Z_ADDREF_P(z);
Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
zval_ptr_dtor(&z_copy);
zval_ptr_dtor(&z);
/* here we are sure we are dealing with an object */
*retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
- if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
+ if (RETURN_VALUE_UNUSED(&opline->result) && (Z_REFCOUNT_PP(retval) == 0)) {
zval_dtor(*retval);
FREE_ZVAL(*retval);
} else {
if (IS_VAR == IS_VAR &&
value_ptr_ptr &&
- !(*value_ptr_ptr)->is_ref &&
+ !Z_ISREF_PP(value_ptr_ptr) &&
opline->extended_value == ZEND_RETURNS_FUNCTION &&
!EX_T(opline->op2.u.var).var.fcall_returned_reference) {
if (free_op2.var == NULL) {
EX(object) = NULL;
} else {
if (!PZVAL_IS_REF(EX(object))) {
- EX(object)->refcount++; /* For $this pointer */
+ Z_ADDREF_P(EX(object)); /* For $this pointer */
} else {
zval *this_ptr;
ALLOC_ZVAL(this_ptr);
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
} else {
switch_expr_is_overloaded = 1;
- EX_T(opline->op1.u.var).str_offset.str->refcount++;
+ Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
}
}
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
if (opline->extended_value) {
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
expr_ptr = *expr_ptr_ptr;
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
} else
#endif
if (PZVAL_IS_REF(expr_ptr)) {
expr_ptr = new_expr;
zendi_zval_copy_ctor(*expr_ptr);
} else {
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
}
}
if (offset) {
free_offset = 1;
}
} else if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
- offset->refcount++;
+ Z_ADDREF_P(offset);
}
if (zend_u_symtable_del(ht, Z_TYPE_P(offset), offset_key, offset_len+1) == SUCCESS &&
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
z = value;
}
- z->refcount++;
+ Z_ADDREF_P(z);
SEPARATE_ZVAL_IF_NOT_REF(&z);
binary_op(z, z, value TSRMLS_CC);
switch (opline->extended_value) {
zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
if (object_ptr && IS_CV != IS_CV && !0) {
- (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
+ Z_ADDREF_PP(object_ptr); /* undo the effect of get_obj_zval_ptr_ptr() */
}
if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
- objval->refcount++;
+ Z_ADDREF_P(objval);
binary_op(objval, objval, value TSRMLS_CC);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
zval_ptr_dtor(&objval);
if (opline->extended_value) {
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
expr_ptr = *expr_ptr_ptr;
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
} else
#endif
if (PZVAL_IS_REF(expr_ptr)) {
expr_ptr = new_expr;
zendi_zval_copy_ctor(*expr_ptr);
} else {
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
}
}
if (offset) {
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
z = value;
}
- z->refcount++;
+ Z_ADDREF_P(z);
SEPARATE_ZVAL_IF_NOT_REF(&z);
binary_op(z, z, value TSRMLS_CC);
switch (opline->extended_value) {
zval **object_ptr = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_W TSRMLS_CC);
if (object_ptr && IS_CV != IS_CV && !0) {
- (*object_ptr)->refcount++; /* undo the effect of get_obj_zval_ptr_ptr() */
+ Z_ADDREF_PP(object_ptr); /* undo the effect of get_obj_zval_ptr_ptr() */
}
if (object_ptr && Z_TYPE_PP(object_ptr) == IS_OBJECT) {
&& Z_OBJ_HANDLER_PP(var_ptr, set)) {
/* proxy object */
zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
- objval->refcount++;
+ Z_ADDREF_P(objval);
binary_op(objval, objval, value TSRMLS_CC);
Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
zval_ptr_dtor(&objval);
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
z = value;
}
- z->refcount++;
+ Z_ADDREF_P(z);
SEPARATE_ZVAL_IF_NOT_REF(&z);
incdec_op(z);
*retval = z;
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
- if (z->refcount == 0) {
+ if (Z_REFCOUNT_P(z) == 0) {
zval_dtor(z);
FREE_ZVAL(z);
}
zendi_zval_copy_ctor(*z_copy);
INIT_PZVAL(z_copy);
incdec_op(z_copy);
- z->refcount++;
+ Z_ADDREF_P(z);
Z_OBJ_HT_P(object)->write_property(object, property, z_copy TSRMLS_CC);
zval_ptr_dtor(&z_copy);
zval_ptr_dtor(&z);
/* here we are sure we are dealing with an object */
*retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
- if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
+ if (RETURN_VALUE_UNUSED(&opline->result) && (Z_REFCOUNT_PP(retval) == 0)) {
zval_dtor(*retval);
FREE_ZVAL(*retval);
} else {
if (IS_CV == IS_VAR &&
value_ptr_ptr &&
- !(*value_ptr_ptr)->is_ref &&
+ !Z_ISREF_PP(value_ptr_ptr) &&
opline->extended_value == ZEND_RETURNS_FUNCTION &&
!EX_T(opline->op2.u.var).var.fcall_returned_reference) {
if (free_op2.var == NULL) {
EX(object) = NULL;
} else {
if (!PZVAL_IS_REF(EX(object))) {
- EX(object)->refcount++; /* For $this pointer */
+ Z_ADDREF_P(EX(object)); /* For $this pointer */
} else {
zval *this_ptr;
ALLOC_ZVAL(this_ptr);
PZVAL_LOCK(EX_T(opline->op1.u.var).var.ptr);
} else {
switch_expr_is_overloaded = 1;
- EX_T(opline->op1.u.var).str_offset.str->refcount++;
+ Z_ADDREF_P(EX_T(opline->op1.u.var).str_offset.str);
}
}
is_equal_function(&EX_T(opline->result.u.var).tmp_var,
if (opline->extended_value) {
SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
expr_ptr = *expr_ptr_ptr;
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
} else
#endif
if (PZVAL_IS_REF(expr_ptr)) {
expr_ptr = new_expr;
zendi_zval_copy_ctor(*expr_ptr);
} else {
- expr_ptr->refcount++;
+ Z_ADDREF_P(expr_ptr);
}
}
if (offset) {
free_offset = 1;
}
} else if (IS_CV == IS_CV || IS_CV == IS_VAR) {
- offset->refcount++;
+ Z_ADDREF_P(offset);
}
if (zend_u_symtable_del(ht, Z_TYPE_P(offset), offset_key, offset_len+1) == SUCCESS &&
}
if (op_array->uses_this && EG(This)) {
- EG(This)->refcount++; /* For $this pointer */
+ Z_ADDREF_P(EG(This)); /* For $this pointer */
if (zend_ascii_hash_add(EG(active_symbol_table), "this", sizeof("this"), &EG(This), sizeof(zval *), NULL)==FAILURE) {
- EG(This)->refcount--;
+ Z_DELREF_P(EG(This));
}
}
MAKE_STD_ZVAL(return_value);
ZVAL_NULL(return_value);
- return_value->refcount = 0;
- return_value->is_ref = 0;
+ Z_SET_REFCOUNT_P(return_value, 0);
+ Z_UNSET_ISREF_P(return_value);
obj = CDNO_FETCH(object);
MAKE_STD_ZVAL(return_value);
ZVAL_NULL(return_value);
- return_value->refcount = 0;
- return_value->is_ref = 0;
+ Z_SET_REFCOUNT_P(return_value, 0);
+ Z_UNSET_ISREF_P(return_value);
obj = CDNO_FETCH(object);
return;
}
- if (stm->refcount > 0) {
+ if (Z_REFCOUNT_P(stm) > 0) {
CoDisconnectObject((IUnknown*)stm, 0);
}
memset(stm, 0, sizeof(*stm));
stm->engine_thread = GetCurrentThreadId();
stm->lpVtbl = &php_istream_vtbl;
- stm->refcount = 1;
+ Z_SET_REFCOUNT_P(stm, 1);
stm->stream = stream;
zend_list_addref(stream->rsrc_id);
cloneproxy = emalloc(sizeof(*cloneproxy));
memcpy(cloneproxy, proxy, sizeof(*cloneproxy));
- ZVAL_ADDREF(cloneproxy->zobj);
+ Z_ADDREF_P(cloneproxy->zobj);
cloneproxy->indices = safe_emalloc(cloneproxy->dimensions, sizeof(zval *), 0);
clone_indices(cloneproxy, proxy, proxy->dimensions);
proxy->zobj = com_object;
}
- ZVAL_ADDREF(proxy->zobj);
+ Z_ADDREF_P(proxy->zobj);
proxy->indices = safe_emalloc(proxy->dimensions, sizeof(zval *), 0);
if (rel) {
I->proxy = proxy;
I->proxy_obj = object;
- ZVAL_ADDREF(I->proxy_obj);
+ Z_ADDREF_P(I->proxy_obj);
I->indices = safe_emalloc(proxy->dimensions + 1, sizeof(LONG), 0);
for (i = 0; i < proxy->dimensions; i++) {
disp->engine_thread = GetCurrentThreadId();
disp->lpVtbl = &php_dispatch_vtbl;
- disp->refcount = 1;
+ Z_SET_REFCOUNT_P(disp, 1);
if (object)
- ZVAL_ADDREF(object);
+ Z_ADDREF_P(object);
disp->object = object;
disp->id = zend_list_insert(disp, le_dispatch);
disp->id = 0;
- if (disp->refcount > 0)
+ if (Z_REFCOUNT_P(disp) > 0)
CoDisconnectObject((IUnknown*)disp, 0);
zend_hash_destroy(disp->dispid_to_name);
Z_TYPE_P(object) = IS_OBJECT;
object_init_ex(object, pce);
- object->refcount = 1;
- object->is_ref = 0;
+ Z_SET_REFCOUNT_P(object, 1);
+ Z_UNSET_ISREF_P(object);
return object;
}
}
if (newval->type != IS_STRING) {
- if(newval->refcount > 1) {
+ if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval;
zval_copy_ctor(&value_copy);
newval = &value_copy;
}
if (newval->type != IS_STRING) {
- if(newval->refcount > 1) {
+ if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval;
zval_copy_ctor(&value_copy);
newval = &value_copy;
}
if (newval->type != IS_STRING) {
- if(newval->refcount > 1) {
+ if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval;
zval_copy_ctor(&value_copy);
newval = &value_copy;
return FAILURE;
}
- if(newval->refcount > 1) {
+ if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval;
zval_copy_ctor(&value_copy);
newval = &value_copy;
}
if (newval->type != IS_STRING) {
- if(newval->refcount > 1) {
+ if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval;
zval_copy_ctor(&value_copy);
newval = &value_copy;
zval value_copy;
dom_doc_propsptr doc_prop;
- if(newval->refcount > 1) {
+ if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval;
zval_copy_ctor(&value_copy);
newval = &value_copy;
zval value_copy;
dom_doc_propsptr doc_prop;
- if(newval->refcount > 1) {
+ if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval;
zval_copy_ctor(&value_copy);
newval = &value_copy;
zval value_copy;
dom_doc_propsptr doc_prop;
- if(newval->refcount > 1) {
+ if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval;
zval_copy_ctor(&value_copy);
newval = &value_copy;
zval value_copy;
dom_doc_propsptr doc_prop;
- if(newval->refcount > 1) {
+ if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval;
zval_copy_ctor(&value_copy);
newval = &value_copy;
zval value_copy;
dom_doc_propsptr doc_prop;
- if(newval->refcount > 1) {
+ if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval;
zval_copy_ctor(&value_copy);
newval = &value_copy;
zval value_copy;
dom_doc_propsptr doc_prop;
- if(newval->refcount > 1) {
+ if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval;
zval_copy_ctor(&value_copy);
newval = &value_copy;
zval value_copy;
dom_doc_propsptr doc_prop;
- if(newval->refcount > 1) {
+ if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval;
zval_copy_ctor(&value_copy);
newval = &value_copy;
}
if (newval->type != IS_STRING) {
- if(newval->refcount > 1) {
+ if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval;
zval_copy_ctor(&value_copy);
newval = &value_copy;
zend_hash_move_forward(nodeht);
if (zend_hash_get_current_data(nodeht, (void **) &entry)==SUCCESS) {
curattr = *entry;
- curattr->refcount++;
+ Z_ADDREF_P(curattr);
}
} else {
curnode = (xmlNodePtr)((php_libxml_node_ptr *)intern->ptr)->node;
iterator = emalloc(sizeof(php_dom_iterator));
- object->refcount++;
+ Z_ADDREF_P(object);
iterator->intern.data = (void*)object;
iterator->intern.funcs = &php_dom_iterator_funcs;
zend_hash_internal_pointer_reset(nodeht);
if (zend_hash_get_current_data(nodeht, (void **) &entry)==SUCCESS) {
curattr = *entry;
- curattr->refcount++;
+ Z_ADDREF_P(curattr);
}
} else {
nodep = (xmlNode *)dom_object_get_node(objmap->baseobj);
case XML_CDATA_SECTION_NODE:
case XML_PI_NODE:
if (newval->type != IS_STRING) {
- if(newval->refcount > 1) {
+ if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval;
zval_copy_ctor(&value_copy);
newval = &value_copy;
}
}
if (newval->type != IS_STRING) {
- if(newval->refcount > 1) {
+ if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval;
zval_copy_ctor(&value_copy);
newval = &value_copy;
ret = hnd->read_func(obj, &retval TSRMLS_CC);
if (ret == SUCCESS) {
/* ensure we're creating a temporary variable */
- retval->refcount = 0;
- retval->is_ref = 0;
+ Z_SET_REFCOUNT_P(retval, 0);
+ Z_UNSET_ISREF_P(retval);
} else {
retval = EG(uninitialized_zval_ptr);
}
if (check_empty == 2) {
retval = 1;
} else if (hnd->read_func(obj, &tmp TSRMLS_CC) == SUCCESS) {
- tmp->refcount = 1;
- tmp->is_ref = 0;
+ Z_SET_REFCOUNT_P(tmp, 1);
+ Z_UNSET_ISREF_P(tmp);
if (check_empty == 1) {
retval = zend_is_true(tmp);
} else if (check_empty == 0) {
if (basenode) {
MAKE_STD_ZVAL(baseobj);
baseobj->type = IS_OBJECT;
- baseobj->is_ref = 1;
+ Z_SET_ISREF_P(baseobj);
baseobj->value.obj.handle = basenode->handle;
baseobj->value.obj.handlers = dom_get_obj_handlers(TSRMLS_C);
zval_copy_ctor(baseobj);
if ((intern = (dom_object *) php_dom_object_get_data((void *) obj))) {
return_value->type = IS_OBJECT;
- return_value->is_ref = 1;
+ Z_SET_ISREF_P(return_value);
return_value->value.obj.handle = intern->handle;
return_value->value.obj.handlers = dom_get_obj_handlers(TSRMLS_C);
zval_copy_ctor(return_value);
}
if (newval->type != IS_STRING) {
- if(newval->refcount > 1) {
+ if(Z_REFCOUNT_P(newval) > 1) {
value_copy = *newval;
zval_copy_ctor(&value_copy);
newval = &value_copy;
MAKE_STD_ZVAL(new_elem);
array_init(new_elem);
- ZVAL_ADDREF(*elem);
+ Z_ADDREF_P(*elem);
add_next_index_zval(new_elem, *elem);
zend_hash_update(Z_ARRVAL_P(return_value), header_name, header_name_len, (void *)&new_elem, sizeof(new_elem), NULL);
if (!assoc) {
add_utf8_property_zval_ex(root, (key->len ? key->c : "_empty_"), (key->len ? (key->len + 1) : sizeof("_empty_")), child TSRMLS_CC);
#if PHP_MAJOR_VERSION >= 5
- ZVAL_DELREF(child);
+ Z_DELREF_P(child);
#endif
} else {
add_utf8_assoc_zval_ex(root, (key->len ? key->c : ""), (key->len ? (key->len + 1) : sizeof("")), child);
if (!assoc) {
add_utf8_property_zval_ex(JSON(the_zstack)[JSON(the_top)], (key.len ? key.c : "_empty_"), (key.len ? (key.len + 1) : sizeof("_empty_")), mval TSRMLS_CC);
#if PHP_MAJOR_VERSION >= 5
- ZVAL_DELREF(mval);
+ Z_DELREF_P(mval);
#endif
} else {
add_utf8_assoc_zval_ex(JSON(the_zstack)[JSON(the_top)], (key.len ? key.c : ""), (key.len ? (key.len + 1) : sizeof("")), mval);
if (!assoc) {
add_utf8_property_zval_ex(JSON(the_zstack)[JSON(the_top)], (key.len ? key.c : "_empty_"), (key.len ? (key.len + 1) : sizeof("_empty_")), mval TSRMLS_CC);
#if PHP_MAJOR_VERSION >= 5
- ZVAL_DELREF(mval);
+ Z_DELREF_P(mval);
#endif
} else {
add_utf8_assoc_zval_ex(JSON(the_zstack)[JSON(the_top)], (key.len ? key.c : ""), (key.len ? (key.len + 1) : sizeof("")), mval);
zval_ptr_dtor(&LIBXML(stream_context));
LIBXML(stream_context) = NULL;
}
- ZVAL_ADDREF(arg);
+ Z_ADDREF_P(arg);
LIBXML(stream_context) = arg;
}
/* }}} */
string.len = Z_STRLEN_PP(hash_entry);
ret = mbfl_buffer_converter_feed_result(convd, &string, &result);
if (ret != NULL) {
- if ((*hash_entry)->refcount > 1) {
- ZVAL_DELREF(*hash_entry);
+ if (Z_REFCOUNT_PP(hash_entry) > 1) {
+ Z_DELREF_P(*hash_entry);
MAKE_STD_ZVAL(*hash_entry);
} else {
zval_dtor(*hash_entry);
}
MBSTRG(search_str) = *arg_str;
- ZVAL_ADDREF(MBSTRG(search_str));
+ Z_ADDREF_P(MBSTRG(search_str));
SEPARATE_ZVAL_IF_NOT_REF(&MBSTRG(search_str));
MBSTRG(search_pos) = 0;
}
if (result_type & MYSQL_ASSOC) {
if (result_type & MYSQL_NUM) {
- ZVAL_ADDREF(data);
+ Z_ADDREF_P(data);
}
if (UG(unicode)) {
UChar *ustr;
ret = hnd->read_func(obj, &retval TSRMLS_CC);
if (ret == SUCCESS) {
/* ensure we're creating a temporary variable */
- retval->refcount = 0;
+ Z_SET_REFCOUNT_P(retval, 0);
} else {
retval = EG(uninitialized_zval_ptr);
}
}
if (ret == SUCCESS) {
hnd->write_func(obj, value TSRMLS_CC);
- if (! PZVAL_IS_REF(value) && value->refcount == 0) {
- value->refcount++;
+ if (! PZVAL_IS_REF(value) && Z_REFCOUNT_P(value) == 0) {
+ Z_ADDREF_P(value);
zval_ptr_dtor(&value);
}
} else {
}
if (fetchtype & MYSQLI_ASSOC) {
if (fetchtype & MYSQLI_NUM) {
- ZVAL_ADDREF(res);
+ Z_ADDREF_P(res);
}
if (UG(unicode)) {
UChar *ustr;
stmt->param.vars = (zval **)safe_emalloc(num_vars, sizeof(zval), 0);
for (i = 0; i < num_vars; i++) {
if (bind[i].buffer_type != MYSQL_TYPE_LONG_BLOB) {
- ZVAL_ADDREF(*args[i+start]);
+ Z_ADDREF_P(*args[i+start]);
stmt->param.vars[i] = *args[i+start];
} else {
stmt->param.vars[i] = NULL;
stmt->result.vars = (zval **)safe_emalloc((var_cnt), sizeof(zval), 0);
for (i = start; i < var_cnt+start; i++) {
ofs = i-start;
- ZVAL_ADDREF(*args[i]);
+ Z_ADDREF_P(*args[i]);
stmt->result.vars[ofs] = *args[i];
}
}
INIT_PZVAL(&(ret->block[i].zv));
ZVAL_NULL(&(ret->block[i].zv));
/* Assure it will never be freed before MSHUTDOWN */
- ZVAL_ADDREF(&(ret->block[i].zv));
+ Z_ADDREF_P(&(ret->block[i].zv));
/* 2. Add to the free list */
*(--ret->free_list.last_added) = &(ret->block[i]);
}
} else {
/* This will set the refcount to 1, increase it, to keep the variable */
INIT_PZVAL(&((mysqlnd_zval *) ret)->zv);
- ZVAL_ADDREF(&(((mysqlnd_zval *)ret)->zv));
+ Z_ADDREF_P(&(((mysqlnd_zval *)ret)->zv));
}
DBG_INF_FMT("allocated=%d ret=%p", *allocated, ret);
thd_cache,
thd_cache->parent? thd_cache->parent->block:NULL,
thd_cache->parent? thd_cache->parent->last_in_block:NULL,
- *zv, ZVAL_REFCOUNT(*zv), type);
+ *zv, Z_REFCOUNT_PP(zv), type);
*copy_ctor_called = FALSE;
/* Check whether cache is used and the zval is from the cache */
if (!thd_cache || !(cache = thd_cache->parent) || ((char *)*zv < (char *)thd_cache->parent->block ||
*/
if (type == MYSQLND_RES_PS_BUF || type == MYSQLND_RES_PS_UNBUF) {
; /* do nothing, zval_ptr_dtor will do the job*/
- } else if (ZVAL_REFCOUNT(*zv) > 1) {
+ } else if (Z_REFCOUNT_P(*zv) > 1) {
/*
Not a prepared statement, then we have to
call copy_ctor and then zval_ptr_dtor()
}
/* The zval is from our cache */
- /* refcount is always > 1, because we call ZVAL_ADDREF(). Thus test refcount > 2 */
- if (ZVAL_REFCOUNT(*zv) > 2) {
+ /* refcount is always > 1, because we call Z_ADDREF_P(). Thus test refcount > 2 */
+ if (Z_REFCOUNT_P(*zv) > 2) {
/*
Because the zval is first element in mysqlnd_zval structure, then we can
do upcasting from zval to mysqlnd_zval here. Because we know that this
++cache->put_hits;
++cache->free_items;
((mysqlnd_zval *)*zv)->point_type = MYSQLND_POINTS_FREE;
- ZVAL_DELREF(*zv); /* Make it 1 */
+ Z_DELREF_P(*zv); /* Make it 1 */
ZVAL_NULL(*zv);
#ifdef ZTS
memset(&((mysqlnd_zval *)*zv)->thread_id, 0, sizeof(THREAD_T));
DBG_INF_FMT("%d is of type %d", i, stmt->param_bind[i].type);
if (stmt->param_bind[i].type != MYSQL_TYPE_LONG_BLOB) {
/* Prevent from freeing */
- ZVAL_ADDREF(stmt->param_bind[i].zv);
+ Z_ADDREF_P(stmt->param_bind[i].zv);
/* Don't update is_ref, or we will leak during conversion */
} else {
stmt->param_bind[i].zv = NULL;
stmt->result_bind = result_bind;
for (i = 0; i < stmt->field_count; i++) {
/* Prevent from freeing */
- ZVAL_ADDREF(stmt->result_bind[i].zv);
+ Z_ADDREF_P(stmt->result_bind[i].zv);
/*
Don't update is_ref !!! it's not our job
Otherwise either 009.phpt or mysqli_stmt_bind_result.phpt
We have to separate the actual zval value of the bound
variable from our allocated zvals or we will face double-free
*/
- if (ZVAL_REFCOUNT(stmt->result_bind[i].zv) > 1) {
+ if (Z_REFCOUNT_P(stmt->result_bind[i].zv) > 1) {
#ifdef WE_DONT_COPY_IN_BUFFERED_AND_UNBUFFERED_BECAUSEOF_IS_REF
zval_copy_ctor(stmt->result_bind[i].zv);
#endif
}
/* Forbid ZE to free it, we will clean it */
- ZVAL_ADDREF(data);
+ Z_ADDREF_P(data);
if ((flags & MYSQLND_FETCH_BOTH) == MYSQLND_FETCH_BOTH) {
- ZVAL_ADDREF(data);
+ Z_ADDREF_P(data);
}
if (flags & MYSQLND_FETCH_NUM) {
zend_hash_next_index_insert(row_ht, &data, sizeof(zval *), NULL);
Let us later know what to do with this zval. If ref_count > 1, we will just
decrease it, otherwise free it. zval_ptr_dtor() make this very easy job.
*/
- ZVAL_ADDREF(data);
+ Z_ADDREF_P(data);
if ((flags & MYSQLND_FETCH_BOTH) == MYSQLND_FETCH_BOTH) {
- ZVAL_ADDREF(data);
+ Z_ADDREF_P(data);
}
if (flags & MYSQLND_FETCH_NUM) {
zend_hash_next_index_insert(Z_ARRVAL_P(row), &data, sizeof(zval *), NULL);
*return_value = **entry;
zval_copy_ctor(return_value);
- ZVAL_REFCOUNT(return_value) = 1;
+ Z_REFCOUNT_P(return_value) = 1;
zval_dtor(&row);
DBG_VOID_RETURN;
}
if (fetch_mode & PHP_OCI_ASSOC) {
if (fetch_mode & PHP_OCI_NUM) {
- ZVAL_ADDREF(element);
+ Z_ADDREF_P(element);
}
add_u_assoc_zval(return_value, (UG(unicode) ? IS_UNICODE : IS_STRING), column->name, element);
}
for(i = 0; i < result->numcols; i++) {
ALLOC_ZVAL(tmp);
- tmp->refcount = 1;
+ Z_SET_REFCOUNT_P(tmp, 1);
Z_TYPE_P(tmp) = IS_STRING;
Z_STRLEN_P(tmp) = 0;
sql_c_type = SQL_C_CHAR;
zend_string_to_unicode_ex(UG(utf8_conv), &u, &u_len, subpat_names[i], strlen(subpat_names[i]), &status);
zend_u_hash_update(Z_ARRVAL_P(subpats), IS_UNICODE, ZSTR(u),
u_len+1, &match_sets[i], sizeof(zval *), NULL);
- ZVAL_ADDREF(match_sets[i]);
+ Z_ADDREF_P(match_sets[i]);
efree(u);
status = U_ZERO_ERROR;
} else {
zend_hash_update(Z_ARRVAL_P(subpats), subpat_names[i],
strlen(subpat_names[i])+1, &match_sets[i], sizeof(zval *), NULL);
- ZVAL_ADDREF(match_sets[i]);
+ Z_ADDREF_P(match_sets[i]);
}
}
zend_hash_next_index_insert(Z_ARRVAL_P(subpats), &match_sets[i], sizeof(zval *), NULL);
/* If the entry fits our requirements */
if ((count > 0 && !invert) ||
(count == PCRE_ERROR_NOMATCH && invert)) {
- (*entry)->refcount++;
+ Z_ADDREF_PP(entry);
/* Add to return array */
switch (zend_hash_get_current_key_ex(Z_ARRVAL_P(input), &string_key, &string_key_len, &num_key, 0, NULL))
Z_TYPE_P(object) = IS_OBJECT;
object_init_ex(object, dbstmt_ce);
- object->refcount = 1;
- object->is_ref = 1;
+ Z_SET_REFCOUNT_P(object, 1);
+ Z_SET_ISREF_P(object);
return object;
} /* }}} */
PDO_HANDLE_DBH_ERR();
return FAILURE;
}
- (*item)->refcount++;
+ Z_ADDREF_PP(item);
dbh->def_stmt_ctor_args = *item;
}
return SUCCESS;
array_init(return_value);
add_next_index_text(return_value, dbh->def_stmt_ce->name, 1);
if (dbh->def_stmt_ctor_args) {
- dbh->def_stmt_ctor_args->refcount++;
+ Z_ADDREF_P(dbh->def_stmt_ctor_args);
add_next_index_zval(return_value, dbh->def_stmt_ctor_args);
}
return;
param->is_param = is_param;
if (param->driver_params) {
- ZVAL_ADDREF(param->driver_params);
+ Z_ADDREF_P(param->driver_params);
}
if (!is_param && param->name && stmt->columns) {
case PDO_FETCH_USE_DEFAULT:
case PDO_FETCH_BOTH:
add_assoc_zval(return_value, stmt->columns[i].name, val);
- ZVAL_ADDREF(val);
+ Z_ADDREF_P(val);
add_next_index_zval(return_value, val);
break;
return 0;
}
- ZVAL_ADDREF(param.parameter);
+ Z_ADDREF_P(param.parameter);
if (!really_register_bound_param(¶m, stmt, is_param TSRMLS_CC)) {
if (param.parameter) {
zval_ptr_dtor(&(param.parameter));
RETURN_FALSE;
}
- ZVAL_ADDREF(param.parameter);
+ Z_ADDREF_P(param.parameter);
if (!really_register_bound_param(¶m, stmt, TRUE TSRMLS_CC)) {
if (param.parameter) {
zval_ptr_dtor(&(param.parameter));
switch (stmt->default_fetch_type) {
case PDO_FETCH_INTO:
if (stmt->fetch.into) {
- ZVAL_DELREF(stmt->fetch.into);
+ Z_DELREF_P(stmt->fetch.into);
stmt->fetch.into = NULL;
}
break;
}
}
- return_value->refcount = 0;
- return_value->is_ref = 0;
+ Z_SET_REFCOUNT_P(return_value, 0);
+ Z_UNSET_ISREF_P(return_value);
return return_value;
}
}
Z_TYPE_P(object) = IS_OBJECT;
object_init_ex(object, pce);
- object->refcount = 1;
- object->is_ref = 1;
+ Z_SET_REFCOUNT_P(object, 1);
+ Z_SET_ISREF_P(object);
return object;
}
/* }}} */
"Class %v does not have a property named %R", ce->name, name_type, name);
return;
}
- refcount = (*variable_ptr)->refcount;
- is_ref = (*variable_ptr)->is_ref;
+ refcount = Z_REFCOUNT_PP(variable_ptr);
+ is_ref = Z_ISREF_PP(variable_ptr);
zval_dtor(*variable_ptr);
**variable_ptr = *value;
zval_copy_ctor(*variable_ptr);
- (*variable_ptr)->refcount = refcount;
- (*variable_ptr)->is_ref = is_ref;
+ Z_SET_REFCOUNT_PP(variable_ptr, refcount);
+ Z_SET_ISREF_TO_PP(variable_ptr, is_ref);
}
/* }}} */
zval_dtor(*variable_ptr);
(*variable_ptr)->type = value->type;
(*variable_ptr)->value = value->value;
- if (value->refcount > 0) {
+ if (Z_REFCOUNT_P(value) > 0) {
zval_copy_ctor(*variable_ptr);
}
setter_done = 1;
if (!setter_done) {
zval **foo;
- value->refcount++;
+ Z_ADDREF_P(value);
if (PZVAL_IS_REF(value)) {
SEPARATE_ZVAL(&value);
}
mdata = emalloc(sizeof(*mdata));
for (i = 0; i < 6; i++) {
- ZVAL_ADDREF(*args[i]);
+ Z_ADDREF_P(*args[i]);
mdata->names[i] = *args[i];
}
}
}
- return_value->refcount = 0;
- return_value->is_ref = 0;
+ Z_SET_REFCOUNT_P(return_value, 0);
+ Z_UNSET_ISREF_P(return_value);
if (member == &tmp_zv) {
zval_dtor(&tmp_zv);
case IS_DOUBLE:
case IS_NULL:
case IS_UNICODE:
- if (value->refcount > 1) {
+ if (Z_REFCOUNT_P(value) > 1) {
value_copy = *value;
zval_copy_ctor(&value_copy);
value = &value_copy;
case IS_DOUBLE:
case IS_NULL:
case IS_UNICODE:
- if (value->refcount > 1) {
+ if (Z_REFCOUNT_P(value) > 1) {
value_copy = *value;
zval_copy_ctor(&value_copy);
value = &value_copy;
zval_ptr_dtor(&sxe->tmp);
}
sxe->tmp = return_value;
- return_value->is_ref = 1;
+ Z_SET_ISREF_P(return_value);
return &sxe->tmp;
}
} else {
ZVAL_NULL(object);
}
- object->refcount = 1;
- object->is_ref = 0;
+ Z_SET_REFCOUNT_P(object, 1);
+ Z_UNSET_ISREF_P(object);
switch (type) {
case IS_STRING:
/* FIXME: Should not be fatal */
}
- retval->refcount = 0;
+ Z_SET_REFCOUNT_P(retval, 0);
return retval;
}
}
iterator = emalloc(sizeof(php_sxe_iterator));
- object->refcount++;
+ Z_ADDREF_P(object);
iterator->intern.data = (void*)object;
iterator->intern.funcs = &php_sxe_iterator_funcs;
iterator->sxe = php_sxe_fetch_object(object TSRMLS_CC);
if (*data != *data_ptr) {
zval_ptr_dtor(data);
*data = *data_ptr;
- (*data)->is_ref = 1;
- (*data)->refcount++;
+ Z_SET_ISREF_PP(data);
+ Z_ADDREF_PP(data);
return 1;
}
} else {
old_scope = EG(scope);
EG(scope) = Z_OBJCE_P(object);
- val->refcount--;
+ Z_DELREF_P(val);
add_property_zval(object, name, val);
EG(scope) = old_scope;
}
MAKE_STD_ZVAL(arr);
array_init(arr);
- prop->refcount++;
+ Z_ADDREF_P(prop);
add_next_index_zval(arr, prop);
set_zval_property(ret, (char*)trav->name, arr TSRMLS_CC);
prop = arr;
MAKE_STD_ZVAL(soapvar);
object_init_ex(soapvar, soap_var_class_entry);
add_property_long(soapvar, "enc_type", enc->details.type);
- ret->refcount--;
+ Z_DELREF_P(ret);
add_property_zval(soapvar, "enc_value", ret);
parse_namespace(type_name, &cptype, &ns);
nsptr = xmlSearchNs(data->doc, data, BAD_CAST(ns));
MAKE_STD_ZVAL(tmp);
soap_decode_string(tmp, cptype TSRMLS_CC);
- tmp->refcount--;
+ Z_DELREF_P(tmp);
add_property_zval(soapvar, "enc_stype", tmp);
if (nsptr) {
MAKE_STD_ZVAL(tmp);
soap_decode_string(tmp, (char*)nsptr->href TSRMLS_CC);
- tmp->refcount--;
+ Z_DELREF_P(tmp);
add_property_zval(soapvar, "enc_ns", tmp);
}
efree(cptype);
zend_unicode_to_string_ex(UG(utf8_conv), &Z_STRVAL_P(tmp), &Z_STRLEN_P(tmp), Z_USTRVAL_P(cur_stype), Z_USTRLEN_P(cur_stype), &status);
cur_stype = tmp;
} else {
- cur_stype->refcount++;
+ Z_ADDREF_P(cur_stype);
}
}
if (cur_ns) {
zend_unicode_to_string_ex(UG(utf8_conv), &Z_STRVAL_P(tmp), &Z_STRLEN_P(tmp), Z_USTRVAL_P(cur_ns), Z_USTRLEN_P(cur_ns), &status);
cur_ns = tmp;
} else {
- cur_ns->refcount++;
+ Z_ADDREF_P(cur_ns);
}
}
}
add_soap_fault(this_ptr, faultcode, faultstring, faultactor, details TSRMLS_CC);
if (details) {
- details->refcount--;
+ Z_DELREF_P(details);
}
xmlFreeDoc(response);
return FALSE;
zend_hash_internal_pointer_reset(Z_ARRVAL_P(return_value));
zend_hash_get_current_data(Z_ARRVAL_P(return_value), (void**)&tmp);
tmp = *(zval**)tmp;
- tmp->refcount++;
+ Z_ADDREF_P(tmp);
zval_dtor(return_value);
*return_value = *tmp;
FREE_ZVAL(tmp);
soap_headers = emalloc(sizeof(HashTable));
zend_hash_init(soap_headers, 0, NULL, ZVAL_PTR_DTOR, 0);
zend_hash_next_index_insert(soap_headers, &headers, sizeof(zval*), NULL);
- ZVAL_ADDREF(headers);
+ Z_ADDREF_P(headers);
free_soap_headers = 1;
} else{
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Invalid SOAP header");
}
zend_hash_internal_pointer_reset(default_headers);
while (zend_hash_get_current_data(default_headers, (void**)&tmp) == SUCCESS) {
- ZVAL_ADDREF(*tmp);
+ Z_ADDREF_P(*tmp);
zend_hash_next_index_insert(soap_headers, tmp, sizeof(zval *), NULL);
zend_hash_move_forward(default_headers);
}
instanceof_function(Z_OBJCE_P(headers), soap_header_class_entry TSRMLS_CC)) {
ALLOC_INIT_ZVAL(client->default_headers);
array_init(client->default_headers);
- headers->refcount++;
+ Z_ADDREF_P(headers);
add_next_index_zval(client->default_headers, headers);
} else{
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Invalid SOAP header");
if (fault_string != NULL) {
MAKE_STD_ZVAL(tmp);
soap_decode_string(tmp, fault_string TSRMLS_CC);
- tmp->refcount--;
+ Z_DELREF_P(tmp);
add_property_zval(obj, "faultstring", tmp);
zend_update_property(zend_exception_get_default(TSRMLS_C), obj, "message", sizeof("message")-1, tmp TSRMLS_CC);
}
if (fault_code_ns) {
MAKE_STD_ZVAL(tmp);
soap_decode_string(tmp, fault_code TSRMLS_CC);
- tmp->refcount--;
+ Z_DELREF_P(tmp);
add_property_zval(obj, "faultcode", tmp);
MAKE_STD_ZVAL(tmp);
soap_decode_string(tmp, fault_code_ns TSRMLS_CC);
- tmp->refcount--;
+ Z_DELREF_P(tmp);
add_property_zval(obj, "faultcodens", tmp);
} else {
if (soap_version == SOAP_1_1) {
}
MAKE_STD_ZVAL(tmp);
soap_decode_string(tmp, fault_code TSRMLS_CC);
- tmp->refcount--;
+ Z_DELREF_P(tmp);
add_property_zval(obj, "faultcode", tmp);
}
}
if (fault_actor != NULL) {
MAKE_STD_ZVAL(tmp);
soap_decode_string(tmp, fault_actor TSRMLS_CC);
- tmp->refcount--;
+ Z_DELREF_P(tmp);
add_property_zval(obj, "faultactor", tmp);
}
if (fault_detail != NULL) {
memcpy(lc_name.s + func_name_len, &Z_OBJ_HANDLE_PP(obj_ptr), sizeof(zend_object_handle));
func_name_len += sizeof(zend_object_handle);
alfi.obj = *obj_ptr;
- alfi.obj->refcount++;
+ Z_ADDREF_P(alfi.obj);
if (Z_TYPE(zfunc_name) == IS_UNICODE) {
func_name_len /= sizeof(UChar);
Z_STRLEN(zfunc_name) = func_name_len;
zend_hash_copy(HASH_OF(intern->array), HASH_OF(other->array), (copy_ctor_func_t) zval_add_ref, &tmp, sizeof(zval*));
}
if (Z_OBJ_HT_P(orig) == &spl_handler_ArrayIterator) {
- ZVAL_ADDREF(other->array);
+ Z_ADDREF_P(other->array);
}
} else {
intern->array = orig;
- ZVAL_ADDREF(intern->array);
+ Z_ADDREF_P(intern->array);
intern->ar_flags |= SPL_ARRAY_IS_REF | SPL_ARRAY_USE_OTHER;
}
} else {
/* When in a write context,
* ZE has to be fooled into thinking this is in a reference set
* by separating (if necessary) and returning as an is_ref=1 zval (even if refcount == 1) */
- if ((type == BP_VAR_W || type == BP_VAR_RW) && !(*ret)->is_ref) {
- if ((*ret)->refcount > 1) {
+ if ((type == BP_VAR_W || type == BP_VAR_RW) && !Z_ISREF_PP(ret)) {
+ if (Z_REFCOUNT_PP(ret) > 1) {
zval *newval;
/* Separate */
MAKE_STD_ZVAL(newval);
*newval = **ret;
zval_copy_ctor(newval);
- newval->refcount = 1;
+ Z_SET_REFCOUNT_P(newval, 1);
/* Replace */
- (*ret)->refcount--;
+ Z_DELREF_PP(ret);
*ret = newval;
}
- (*ret)->is_ref = 1;
+ Z_SET_ISREF_PP(ret);
}
return *ret;
}
if (!offset) {
- value->refcount++;
+ Z_ADDREF_P(value);
zend_hash_next_index_insert(spl_array_get_hash_table(intern, 0 TSRMLS_CC), (void**)&value, sizeof(void*), NULL);
return;
}
zend_throw_exception(spl_ce_InvalidArgumentException, "An offset must not begin with \\0 or be empty", 0 TSRMLS_CC);
return;
}
- value->refcount++;
+ Z_ADDREF_P(value);
zend_u_symtable_update(spl_array_get_hash_table(intern, 0 TSRMLS_CC), Z_TYPE_P(offset), Z_UNIVAL_P(offset), Z_UNILEN_P(offset)+1, (void**)&value, sizeof(void*), NULL);
return;
case IS_DOUBLE:
} else {
index = Z_LVAL_P(offset);
}
- value->refcount++;
+ Z_ADDREF_P(value);
zend_hash_index_update(spl_array_get_hash_table(intern, 0 TSRMLS_CC), index, (void**)&value, sizeof(void*), NULL);
return;
case IS_NULL:
- value->refcount++;
+ Z_ADDREF_P(value);
zend_hash_next_index_insert(spl_array_get_hash_table(intern, 0 TSRMLS_CC), (void**)&value, sizeof(void*), NULL);
return;
default:
iterator = emalloc(sizeof(spl_array_it));
- object->refcount++;
+ Z_ADDREF_P(object);
iterator->intern.it.data = (void*)object;
iterator->intern.it.funcs = &spl_array_it_funcs;
iterator->intern.ce = ce;
intern->ar_flags &= ~SPL_ARRAY_IS_SELF;
}
intern->ar_flags |= ar_flags;
- ZVAL_ADDREF(intern->array);
+ Z_ADDREF_P(intern->array);
if (Z_TYPE_PP(array) == IS_OBJECT) {
zend_object_get_properties_t handler = Z_OBJ_HANDLER_PP(array, get_properties);
if ((handler != std_object_handlers.get_properties && handler != spl_array_get_properties)
} else {
intern->ar_flags &= ~SPL_ARRAY_IS_SELF;
}
- ZVAL_ADDREF(intern->array);
+ Z_ADDREF_P(intern->array);
spl_array_rewind(intern TSRMLS_CC);
}
return_value->type = IS_OBJECT;
return_value->value.obj = spl_array_object_new_ex(intern->ce_get_iterator, &iterator, object, 0 TSRMLS_CC);
- return_value->refcount = 1;
- return_value->is_ref = 1;
+ Z_SET_REFCOUNT_P(return_value, 1);
+ Z_SET_ISREF_P(return_value);
}
/* }}} */
/* avoid reference counting in debug mode, thus do it manually */
ZVAL_RESOURCE(&intern->u.file.zresource, php_stream_get_resource_id(intern->u.file.stream));
- intern->u.file.zresource.refcount = 1;
+ Z_SET_REFCOUNT(intern->u.file.zresource, 1);
intern->u.file.delimiter = ',';
intern->u.file.enclosure = '"';
dir_object = (spl_filesystem_object*)zend_object_store_get_object(object TSRMLS_CC);
iterator = spl_filesystem_object_to_iterator(dir_object);
- object->refcount += 2;
+ Z_ADDREF_P(object);
+ Z_ADDREF_P(object);
iterator->intern.data = (void*)object;
iterator->intern.funcs = &spl_filesystem_dir_it_funcs;
iterator->current = object;
dir_object = (spl_filesystem_object*)zend_object_store_get_object(object TSRMLS_CC);
iterator = spl_filesystem_object_to_iterator(dir_object);
- object->refcount++;
+ Z_ADDREF_P(object);
iterator->intern.data = (void*)object;
iterator->intern.funcs = &spl_filesystem_tree_it_funcs;
iterator->current = NULL;
ALLOC_ZVAL(*object);
}
object_init_ex(*object, pce);
- (*object)->refcount = 1;
- (*object)->is_ref = 1; /* check if this can be hold always */
+ Z_SET_REFCOUNT_P((*object), 1);
+ Z_SET_ISREF_PP(object); /* check if this can be hold always */
}
/* }}} */
iterator = emalloc(sizeof(spl_recursive_it_iterator));
object = (spl_recursive_it_object*)zend_object_store_get_object(zobject TSRMLS_CC);
- zobject->refcount++;
+ Z_ADDREF_P(zobject);
iterator->intern.data = (void*)object;
iterator->intern.funcs = ce->iterator_funcs.funcs;
iterator->zobject = zobject;
ce_iterator = Z_OBJCE_P(iterator); /* respect inheritance, don't use spl_ce_RecursiveIterator */
intern->iterators[0].iterator = ce_iterator->get_iterator(ce_iterator, iterator, 0 TSRMLS_CC);
if (inc_refcount) {
- iterator->refcount++;
+ Z_ADDREF_P(iterator);
}
intern->iterators[0].zobject = iterator;
intern->iterators[0].ce = ce_iterator;
php_set_error_handling(EH_THROW, zend_exception_get_default(TSRMLS_C) TSRMLS_CC);
if (inc_refcount) {
- zobject->refcount++;
+ Z_ADDREF_P(zobject);
}
intern->inner.zobject = zobject;
intern->inner.ce = dit_type == DIT_IteratorIterator ? ce : Z_OBJCE_P(zobject);
if (!check_more || spl_dual_it_valid(intern TSRMLS_CC) == SUCCESS) {
intern->inner.iterator->funcs->get_current_data(intern->inner.iterator, &data TSRMLS_CC);
intern->current.data = *data;
- intern->current.data->refcount++;
+ Z_ADDREF_P(intern->current.data);
if (intern->inner.iterator->funcs->get_current_key) {
intern->current.key_type = intern->inner.iterator->funcs->get_current_key(intern->inner.iterator, &intern->current.str_key, &intern->current.str_key_len, &intern->current.int_key TSRMLS_CC);
} else {
return;
}
- value->refcount++;
+ Z_ADDREF_P(value);
zend_u_symtable_update(HASH_OF(intern->u.caching.zcache), type, arKey, nKeyLength+1, &value, sizeof(value), NULL);
}
/* }}} */
zval **it;
intern->u.append.iterator->funcs->get_current_data(intern->u.append.iterator, &it TSRMLS_CC);
- (*it)->refcount++;
+ Z_ADDREF_PP(it);
intern->inner.zobject = *it;
intern->inner.ce = Z_OBJCE_PP(it);
intern->inner.object = zend_object_store_get_object(*it TSRMLS_CC);
if (EG(exception)) {
return ZEND_HASH_APPLY_STOP;
}
- (*data)->refcount++;
+ Z_ADDREF_PP(data);
switch(key_type) {
case HASH_KEY_IS_STRING:
add_assoc_zval_ex(return_value, str_key.s, str_key_len, *data);
break;
}
} else {
- (*data)->refcount++;
+ Z_ADDREF_PP(data);
add_next_index_zval(return_value, *data);
}
return ZEND_HASH_APPLY_KEEP;
if (EG(exception)) {
return ZEND_HASH_APPLY_STOP;
}
- (*data)->refcount++;
+ Z_ADDREF_PP(data);
add_next_index_zval(return_value, *data);
return ZEND_HASH_APPLY_KEEP;
}
}
#endif
- obj->refcount++;
+ Z_ADDREF_P(obj);
} /* }}} */
/* {{{ proto void SplObjectStorage::attach($obj) U
if (*context_p == NULL) {
MAKE_STD_ZVAL(*context_p);
- (*context_p)->is_ref = 1;
+ Z_SET_ISREF_PP(context_p);
Z_TYPE_PP(context_p) = IS_NULL;
}
}
Z_TYPE_P(object) = IS_OBJECT;
object_init_ex(object, pce);
- object->refcount = 1;
- object->is_ref = 0;
+ Z_SET_REFCOUNT_P(object, 1);
+ Z_UNSET_ISREF_P(object);
return object;
}
iterator = emalloc(sizeof(sqlite_object_iterator));
- object->refcount++;
+ Z_ADDREF_P(object);
iterator->it.data = (void*)object;
iterator->it.funcs = ce->iterator_funcs.funcs;
iterator->res = obj->u.res;
MAKE_STD_ZVAL(coltype);
ZVAL_U_STRING(SQLITE2_CONV, coltype, colnames[ncols + i] ? (char *)colnames[ncols + i] : "", ZSTR_DUPLICATE);
- coltype->refcount = 0;
+ Z_SET_REFCOUNT_P(coltype, 0);
if (result_type == PHPSQLITE_NUM) {
- ZVAL_ADDREF(coltype);
+ Z_ADDREF_P(coltype);
add_index_zval(return_value, i, coltype);
}
}
}
- ZVAL_ADDREF(coltype);
+ Z_ADDREF_P(coltype);
add_u_assoc_zval_ex(return_value, colname_type, colname, colname_len + 1, coltype);
efree(colname.v);
}
- if (coltype->refcount <= 0) {
+ if (Z_REFCOUNT_P(coltype) <= 0) {
/* Shouldn't happen (and probably can't) */
- coltype->refcount = 1;
+ Z_SET_REFCOUNT_P(coltype, 1);
zval_ptr_dtor(&coltype);
}
}
rowdata[j] = NULL;
}
}
- decoded->refcount = 0;
+ Z_SET_REFCOUNT_P(decoded, 0);
if (mode & PHPSQLITE_NUM) {
- ZVAL_ADDREF(decoded);
+ Z_ADDREF_P(decoded);
add_index_zval(return_value, j, decoded);
}
if ((mode & PHPSQLITE_ASSOC) || (!(mode & PHPSQLITE_NUM))) {
UChar *colname;
int colname_len;
- ZVAL_ADDREF(decoded);
+ Z_ADDREF_P(decoded);
if (UG(unicode) &&
SUCCESS == zend_string_to_unicode(SQLITE2_CONV, &colname, &colname_len, (char*)colnames[j], strlen((char*)colnames[j]) TSRMLS_CC)) {
*orig_var = *entry;
} else {
- if (var_array->refcount > 1 || *entry == EG(uninitialized_zval_ptr)) {
+ if (Z_REFCOUNT_P(var_array) > 1 || *entry == EG(uninitialized_zval_ptr)) {
SEPARATE_ZVAL_TO_MAKE_IS_REF(entry);
} else {
- (*entry)->is_ref = 1;
+ Z_SET_ISREF_PP(entry);
}
zval_add_ref(entry);
zend_u_hash_update(EG(active_symbol_table), Z_TYPE(final_name), Z_UNIVAL(final_name), Z_UNILEN(final_name)+1, (void **) entry, sizeof(zval *), NULL);
for (pos=0, p=in_hash->pListHead; pos<offset && p ; pos++, p=p->pListNext) {
/* Get entry and increase reference count */
entry = *((zval **)p->pData);
- entry->refcount++;
+ Z_ADDREF_P(entry);
/* Update output hash depending on key type */
if (p->nKeyLength == 0) {
if (removed != NULL) {
for ( ; pos<offset+length && p; pos++, p=p->pListNext) {
entry = *((zval **)p->pData);
- entry->refcount++;
+ Z_ADDREF_P(entry);
if (p->nKeyLength == 0) {
zend_hash_next_index_insert(*removed, &entry, sizeof(zval *), NULL);
} else {
/* ..for each one, create a new zval, copy entry into it and copy it into the output hash */
for (i=0; i<list_count; i++) {
entry = *list[i];
- entry->refcount++;
+ Z_ADDREF_P(entry);
zend_hash_next_index_insert(out_hash, &entry, sizeof(zval *), NULL);
}
}
/* Copy the remaining input hash entries to the output hash */
for ( ; p ; p=p->pListNext) {
entry = *((zval **)p->pData);
- entry->refcount++;
+ Z_ADDREF_P(entry);
if (p->nKeyLength == 0) {
zend_hash_next_index_insert(out_hash, &entry, sizeof(zval *), NULL);
} else {
/* For each subsequent argument, make it a reference, increase refcount, and add it to the end of the array */
for (i=1; i<argc; i++) {
new_var = *args[i];
- new_var->refcount++;
+ Z_ADDREF_P(new_var);
zend_hash_next_index_insert(Z_ARRVAL_P(stack), &new_var, sizeof(zval *), NULL);
}
ukey:
if (recursive &&
zend_u_hash_find(dest, utype, string_key, string_key_len, (void **)&dest_entry) == SUCCESS) {
- if (*src_entry == *dest_entry && ((*dest_entry)->refcount % 2)) {
+ if (*src_entry == *dest_entry && (Z_REFCOUNT_PP(dest_entry) % 2)) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "recursion detected");
return 0;
}
Z_ARRVAL_PP(src_entry), recursive TSRMLS_CC))
return 0;
} else {
- (*src_entry)->refcount++;
+ Z_ADDREF_PP(src_entry);
zend_u_hash_update(dest, utype, string_key, string_key_len,
src_entry, sizeof(zval *), NULL);
break;
case HASH_KEY_IS_LONG:
- (*src_entry)->refcount++;
+ Z_ADDREF_PP(src_entry);
zend_hash_next_index_insert(dest, src_entry, sizeof(zval *), NULL);
break;
}
}
}
if (ok) {
- (*((zval**)p->pData))->refcount++;
+ Z_ADDREF_PP((zval**)p->pData);
zend_hash_index_update(Z_ARRVAL_P(return_value), p->h, p->pData, sizeof(zval*), NULL);
}
} else {
}
}
if (ok) {
- (*((zval**)p->pData))->refcount++;
+ Z_ADDREF_PP((zval**)p->pData);
zend_u_hash_quick_update(Z_ARRVAL_P(return_value), p->key.type, ZSTR(p->key.arKey.s), p->nKeyLength, p->h, p->pData, sizeof(zval*), NULL);
}
}
}
}
if (ok) {
- (*((zval**)p->pData))->refcount++;
+ Z_ADDREF_PP((zval**)p->pData);
zend_hash_index_update(Z_ARRVAL_P(return_value), p->h, p->pData, sizeof(zval*), NULL);
}
} else {
}
}
if (ok) {
- (*((zval**)p->pData))->refcount++;
+ Z_ADDREF_PP((zval**)p->pData);
zend_u_hash_quick_update(Z_ARRVAL_P(return_value), p->key.type, ZSTR(p->key.arKey.s), p->nKeyLength, p->h, p->pData, sizeof(zval*), NULL);
}
}
}
for (i = 0; i < shutdown_function_entry.arg_count; i++) {
- shutdown_function_entry.arguments[i]->refcount++;
+ Z_ADDREF_P(shutdown_function_entry.arguments[i]);
}
zend_hash_next_index_insert(BG(user_shutdown_function_names), &shutdown_function_entry, sizeof(php_shutdown_function_entry), NULL);
}
}
for (i = 0; i < tick_fe.arg_count; i++) {
- tick_fe.arguments[i]->refcount++;
+ Z_ADDREF_P(tick_fe.arguments[i]);
}
zend_llist_add_element(BG(user_tick_functions), &tick_fe);
}
zend_u_delete_global_variable(Z_TYPE(new_key), Z_UNIVAL(new_key), Z_UNILEN(new_key) TSRMLS_CC);
- ZEND_U_SET_SYMBOL_WITH_LENGTH(&EG(symbol_table), Z_TYPE(new_key), Z_UNIVAL(new_key), Z_UNILEN(new_key) + 1, *var, (*var)->refcount+1, 0);
+ ZEND_U_SET_SYMBOL_WITH_LENGTH(&EG(symbol_table), Z_TYPE(new_key), Z_UNIVAL(new_key), Z_UNILEN(new_key) + 1, *var, Z_REFCOUNT_PP(var)+1, 0);
zval_dtor(&new_key);
return 0;
#define MAKE_LONG_ZVAL_INCREF(name, val)\
MAKE_STD_ZVAL(name); \
ZVAL_LONG(name, val); \
- name->refcount++;
+ Z_ADDREF_P(name);
#ifdef PHP_WIN32
#define S_IRUSR S_IREAD
zend_uint refcount;
current = args[objIndex++];
- refcount = (*current)->refcount;
+ refcount = Z_REFCOUNT_PP(current);
zval_dtor( *current );
ZVAL_LONG( *current, (long)(string - baseString) );
- (*current)->refcount = refcount;
- (*current)->is_ref = 1;
+ Z_SET_REFCOUNT_PP(current, refcount);
+ Z_SET_ISREF_PP(current);
} else {
add_index_long(*return_value, objIndex++, string - baseString);
}
zend_uint refcount;
current = args[objIndex++];
- refcount = (*current)->refcount;
+ refcount = Z_REFCOUNT_PP(current);
zval_dtor( *current );
ZVAL_STRINGL( *current, string, end-string, 1);
- (*current)->refcount = refcount;
- (*current)->is_ref = 1;
+ Z_SET_REFCOUNT_PP(current, refcount);
+ Z_SET_ISREF_PP(current);
} else {
add_index_stringl( *return_value, objIndex++, string, end-string, 1);
}
zend_uint refcount;
current = args[objIndex++];
- refcount = (*current)->refcount;
+ refcount = Z_REFCOUNT_PP(current);
zval_dtor( *current );
ZVAL_LONG( *current, (long)(string - baseString) );
- (*current)->refcount = refcount;
- (*current)->is_ref = 1;
+ Z_SET_REFCOUNT_PP(current, refcount);
+ Z_SET_ISREF_PP(current);
} else {
add_index_long(*return_value, objIndex++, string - baseString);
}
zend_uint refcount;
current = args[objIndex++];
- refcount = (*current)->refcount;
+ refcount = Z_REFCOUNT_PP(current);
zval_dtor( *current );
ZVAL_UNICODEL( *current, string, end-string, 1);
- (*current)->refcount = refcount;
- (*current)->is_ref = 1;
+ Z_SET_REFCOUNT_PP(current, refcount);
+ Z_SET_ISREF_PP(current);
} else {
add_index_unicodel( *return_value, objIndex++, string, end-string, 1);
}
context->notifier = php_stream_notification_alloc();
context->notifier->func = user_space_stream_notifier;
context->notifier->ptr = *tmp;
- ZVAL_ADDREF(*tmp);
+ Z_ADDREF_P(*tmp);
context->notifier->dtor = user_space_stream_notifier_dtor;
}
if (SUCCESS == zend_ascii_hash_find(Z_ARRVAL_P(params), "options", sizeof("options"), (void**)&tmp)) {
php_str_replace_in_subject(search, replace, subject_entry, result, case_sensitivity, (argc > 3) ? &count : NULL TSRMLS_CC);
} else {
ALLOC_ZVAL(result);
- ZVAL_ADDREF(*subject_entry);
+ Z_ADDREF_P(*subject_entry);
COPY_PZVAL_TO_ZVAL(*result, *subject_entry);
}
/* Add to return array */
/* create the object */
ALLOC_ZVAL(obj);
object_init_ex(obj, fdat->ce);
- ZVAL_REFCOUNT(obj) = 1;
- PZVAL_IS_REF(obj) = 1;
+ Z_SET_REFCOUNT_P(obj, 1);
+ Z_SET_ISREF_P(obj);
/* filtername */
add_property_rt_string(obj, "filtername", (char*)filtername, 1);
#include "basic_functions.h"
#include "php_incomplete_class.h"
-#define COMMON ((*struc)->is_ref ? "&" : "")
-#define Z_REFCOUNT_PP(a) ((*a)->refcount)
+#define COMMON (Z_ISREF_PP(struc) ? "&" : "")
/* }}} */
}
if (var_old && zend_hash_find(var_hash, p, len, var_old) == SUCCESS) {
- if (!var->is_ref) {
+ if (!Z_ISREF_P(var)) {
/* we still need to bump up the counter, since non-refs will
be counted separately by unserializer */
var_no = -1;
if (var_hash
&& php_add_var_hash(var_hash, struc, (void *) &var_already TSRMLS_CC) == FAILURE) {
- if(struc->is_ref) {
+ if(Z_ISREF_P(struc)) {
smart_str_appendl(buf, "R:", 2);
smart_str_append_long(buf, *var_already);
smart_str_appendc(buf, ';');
prev->next = var_hash;
}
- (*rval)->refcount++;
+ Z_ADDREF_PP(rval);
var_hash->data[var_hash->used_slots++] = *rval;
}
zval_ptr_dtor(rval);
}
*rval = *rval_ref;
- (*rval)->refcount++;
- (*rval)->is_ref = 0;
+ Z_ADDREF_PP(rval);
+ Z_UNSET_ISREF_PP(rval);
return 1;
}
zval_ptr_dtor(rval);
}
*rval = *rval_ref;
- (*rval)->refcount++;
- (*rval)->is_ref = 1;
+ Z_ADDREF_PP(rval);
+ Z_SET_ISREF_PP(rval);
return 1;
}
prev->next = var_hash;
}
- (*rval)->refcount++;
+ Z_ADDREF_PP(rval);
var_hash->data[var_hash->used_slots++] = *rval;
}
zval_ptr_dtor(rval);
}
*rval = *rval_ref;
- (*rval)->refcount++;
- (*rval)->is_ref = 1;
+ Z_ADDREF_PP(rval);
+ Z_SET_ISREF_PP(rval);
return 1;
}
zval_ptr_dtor(rval);
}
*rval = *rval_ref;
- (*rval)->refcount++;
- (*rval)->is_ref = 0;
+ Z_ADDREF_PP(rval);
+ Z_UNSET_ISREF_PP(rval);
return 1;
}
array_init(return_value);
for (i=0; i<result->num_fields; i++) {
- ZVAL_ADDREF(result->data[result->cur_row][i]);
+ Z_ADDREF_P(result->data[result->cur_row][i]);
zend_hash_index_update(Z_ARRVAL_P(return_value), i, (void *) &result->data[result->cur_row][i], sizeof(zval *), NULL);
}
result->cur_row++;
array_init(return_value);
for (i=0; i<result->num_fields; i++) {
- ZVAL_ADDREF(result->data[result->cur_row][i]);
+ Z_ADDREF_P(result->data[result->cur_row][i]);
zend_hash_index_update(Z_ARRVAL_P(return_value), i, (void *) &result->data[result->cur_row][i], sizeof(zval *), NULL);
- ZVAL_ADDREF(result->data[result->cur_row][i]);
+ Z_ADDREF_P(result->data[result->cur_row][i]);
zend_hash_update(Z_ARRVAL_P(return_value), result->fields[i].name, strlen(result->fields[i].name)+1, (void *) &result->data[result->cur_row][i], sizeof(zval *), NULL);
}
result->cur_row++;
zval_copy_ctor(tmp);
if (numerics) {
zend_hash_index_update(Z_ARRVAL_P(return_value), i, (void *) &tmp, sizeof(zval *), NULL);
- tmp->refcount++;
+ Z_ADDREF_P(tmp);
}
if (zend_hash_exists(Z_ARRVAL_P(return_value), result->fields[i].name, strlen(result->fields[i].name)+1)) {
Z_TYPE_P(object) = IS_OBJECT;
object_init_ex(object, pce);
- object->refcount = 1;
- object->is_ref = 1;
+ Z_SET_REFCOUNT_P(object, 1);
+ Z_SET_ISREF_P(object);
return object;
}
}
iter_object = (text_iter_obj *) zend_object_store_get_object(object TSRMLS_CC);
- ZVAL_ADDREF(object);
+ Z_ADDREF_P(object);
iter_object->iter.data = (void *) object;
iter_object->iter.funcs = &text_iter_funcs;
zend_class_entry *old_scope = EG(scope);
EG(scope) = Z_OBJCE_P(ent2->data);
- ent1->data->refcount--;
+ Z_DELREF_P(ent1->data);
add_property_zval(ent2->data, ent1->varname, ent1->data);
EG(scope) = old_scope;
} else {
ret = xmlreader_property_reader(obj, hnd, &retval TSRMLS_CC);
if (ret == SUCCESS) {
/* ensure we're creating a temporary variable */
- retval->refcount = 0;
+ Z_SET_REFCOUNT_P(retval, 0);
} else {
retval = EG(uninitialized_zval_ptr);
}
convert_to_string_with_converter(*entry, UG(utf8_conv));
ALLOC_ZVAL(new_string);
- ZVAL_ADDREF(*entry);
+ Z_ADDREF_P(*entry);
COPY_PZVAL_TO_ZVAL(*new_string, *entry);
zend_hash_update(intern->parameter, string_key.s, tmp_len, &new_string, sizeof(zval*), NULL);
ret = php_zip_property_reader(obj, hnd, &retval, 1 TSRMLS_CC);
if (ret == SUCCESS) {
/* ensure we're creating a temporary variable */
- retval->refcount = 0;
+ Z_SET_REFCOUNT_P(retval, 0);
} else {
retval = EG(uninitialized_zval_ptr);
}
if (type == 2) {
retval = 1;
} else if (php_zip_property_reader(obj, hnd, &tmp, 1 TSRMLS_CC) == SUCCESS) {
- tmp->refcount = 1;
- tmp->is_ref = 0;
+ Z_SET_REFCOUNT_P(tmp, 1);
+ Z_UNSET_ISREF_P(tmp);
if (type == 1) {
retval = zend_is_true(tmp);
} else if (type == 0) {
MAKE_STD_ZVAL(handler_name);
if (SUCCESS == zend_fcall_info_init(output_handler, &user->fci, &user->fcc, handler_name TSRMLS_CC)) {
handler = php_output_handler_init(handler_name, chunk_size, (flags & ~0xf) | PHP_OUTPUT_HANDLER_USER);
- ZVAL_ADDREF(output_handler);
+ Z_ADDREF_P(output_handler);
user->zoh = output_handler;
handler->func.user = user;
} else {
php_output_handler *handler;
handler = ecalloc(1, sizeof(php_output_handler));
- ZVAL_ADDREF(name);
+ Z_ADDREF_P(name);
handler->name = name;
handler->size = chunk_size;
handler->flags = flags;
php_output_handler *handler = *(php_output_handler **) h;
zval *array = (zval *) z;
- ZVAL_ADDREF(handler->name);
+ Z_ADDREF_P(handler->name);
add_next_index_zval(array, handler->name);
return 0;
}
array_init(entry);
}
- ZVAL_ADDREF(handler->name);
+ Z_ADDREF_P(handler->name);
add_ascii_assoc_zval(entry, "name", handler->name);
add_ascii_assoc_long(entry, "type", (long) (handler->flags & 0xf));
add_ascii_assoc_long(entry, "flags", (long) handler->flags);
copy = *arg2;
zval_copy_ctor(©);
- copy.refcount = 0;
+ Z_SET_REFCOUNT(copy, 0);
zend_llist_add_element(&extension_lists.functions, ©);
} else if (!strcasecmp(Z_STRVAL_P(arg1), ZEND_EXTENSION_TOKEN)) { /* load Zend extension */
char *extension_name = estrndup(Z_STRVAL_P(arg2), Z_STRLEN_P(arg2));
Z_STRLEN(tmp) = strlen(fh.filename);
Z_STRVAL(tmp) = zend_strndup(fh.filename, Z_STRLEN(tmp));
Z_TYPE(tmp) = IS_STRING;
- tmp.refcount = 0;
+ Z_SET_REFCOUNT(tmp, 0);
zend_hash_update(&configuration_hash, "cfg_file_path", sizeof("cfg_file_path"), (void *) &tmp, sizeof(zval), NULL);
if (php_ini_opened_path) {
}
MAKE_STD_ZVAL(zpath);
ZVAL_STRINGL(zpath, path, path_len, 0);
- zpath->is_ref = 0;
- zpath->refcount = 1;
+ Z_UNSET_ISREF_P(zpath);
+ Z_SET_REFCOUNT_P(zpath, 1);
/* Replace the param stack with the new zval */
zval_ptr_dtor(ppzval);
*ppzval = zpath;
} else if (Z_TYPE_PP(ppzval) != IS_STRING) {
- if ((*ppzval)->is_ref ||
- (*ppzval)->refcount > 1) {
+ if (Z_ISREF_PP(ppzval) ||
+ Z_REFCOUNT_PP(ppzval) > 1) {
zval *zpath;
/* Produce a new zval of type string */
*zpath = **ppzval;
zval_copy_ctor(zpath);
convert_to_string(zpath);
- zpath->is_ref = 0;
- zpath->refcount = 1;
+ Z_UNSET_ISREF_P(zpath);
+ Z_SET_REFCOUNT_P(zpath, 1);
/* Replace the param stack with it */
zval_ptr_dtor(ppzval);
Z_TYPE_P(argc) = IS_LONG;
if (SG(request_info).argc) {
- arr->refcount++;
- argc->refcount++;
+ Z_ADDREF_P(arr);
+ Z_ADDREF_P(argc);
zend_ascii_hash_update(&EG(symbol_table), "argv", sizeof("argv"), &arr, sizeof(zval *), NULL);
zend_ascii_hash_add(&EG(symbol_table), "argc", sizeof("argc"), &argc, sizeof(zval *), NULL);
}
if (track_vars_array) {
- arr->refcount++;
- argc->refcount++;
+ Z_ADDREF_P(arr);
+ Z_ADDREF_P(argc);
zend_ascii_hash_update(Z_ARRVAL_P(track_vars_array), "argv", sizeof("argv"), &arr, sizeof(zval *), NULL);
zend_ascii_hash_update(Z_ARRVAL_P(track_vars_array), "argc", sizeof("argc"), &argc, sizeof(zval *), NULL);
}
|| (key_type == HASH_KEY_IS_LONG && zend_hash_index_find(dest, num_key, (void **)&dest_entry) != SUCCESS)
|| Z_TYPE_PP(dest_entry) != IS_ARRAY
) {
- (*src_entry)->refcount++;
+ Z_ADDREF_PP(src_entry);
if (key_type == HASH_KEY_IS_STRING || key_type == HASH_KEY_IS_UNICODE) {
zend_u_hash_update(dest, key_type, string_key, string_key_len, src_entry, sizeof(zval *), NULL);
} else {
INIT_PZVAL(PG(http_globals)[i]);
}
- PG(http_globals)[i]->refcount++;
+ Z_ADDREF_P(PG(http_globals)[i]);
zend_ascii_hash_update(&EG(symbol_table), auto_global_records[i].name, auto_global_records[i].name_len, &PG(http_globals)[i], sizeof(zval *), NULL);
}
if (zend_ascii_hash_find(&EG(symbol_table), "argc", sizeof("argc"), (void**)&argc) == SUCCESS &&
zend_ascii_hash_find(&EG(symbol_table), "argv", sizeof("argv"), (void**)&argv) == SUCCESS) {
- (*argc)->refcount++;
- (*argv)->refcount++;
+ Z_ADDREF_PP(argc);
+ Z_ADDREF_PP(argv);
zend_ascii_hash_update(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_SERVER]), "argv", sizeof("argv"), argv, sizeof(zval *), NULL);
zend_ascii_hash_update(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_SERVER]), "argc", sizeof("argc"), argc, sizeof(zval *), NULL);
}
}
zend_ascii_hash_update(&EG(symbol_table), name, name_len + 1, &PG(http_globals)[TRACK_VARS_SERVER], sizeof(zval *), NULL);
- PG(http_globals)[TRACK_VARS_SERVER]->refcount++;
+ Z_ADDREF_P(PG(http_globals)[TRACK_VARS_SERVER]);
return 0; /* don't rearm */
}
}
zend_ascii_hash_update(&EG(symbol_table), name, name_len + 1, &PG(http_globals)[TRACK_VARS_ENV], sizeof(zval *), NULL);
- PG(http_globals)[TRACK_VARS_ENV]->refcount++;
+ Z_ADDREF_P(PG(http_globals)[TRACK_VARS_ENV]);
return 0; /* don't rearm */
}
PHPAPI php_stream_bucket *php_stream_bucket_new_unicode(php_stream *stream, UChar *buf, int32_t buflen, int own_buf, int buf_persistent TSRMLS_DC);
PHPAPI int php_stream_bucket_split(php_stream_bucket *in, php_stream_bucket **left, php_stream_bucket **right, size_t length TSRMLS_DC);
PHPAPI void php_stream_bucket_delref(php_stream_bucket *bucket TSRMLS_DC);
-#define php_stream_bucket_addref(bucket) (bucket)->refcount++
+#define php_stream_bucket_addref(bucket) Z_ADDREF_P((bucket))
PHPAPI void php_stream_bucket_prepend(php_stream_bucket_brigade *brigade, php_stream_bucket *bucket TSRMLS_DC);
PHPAPI void php_stream_bucket_append(php_stream_bucket_brigade *brigade, php_stream_bucket *bucket TSRMLS_DC);
PHPAPI void php_stream_bucket_unlink(php_stream_bucket *bucket TSRMLS_DC);
/* create an instance of our class */
ALLOC_ZVAL(us->object);
object_init_ex(us->object, uwrap->ce);
- ZVAL_REFCOUNT(us->object) = 1;
- PZVAL_IS_REF(us->object) = 1;
+ Z_SET_REFCOUNT_P(us->object, 1);
+ Z_SET_ISREF_P(us->object);
if (uwrap->ce->constructor) {
zend_fcall_info fci;
args[2] = &zoptions;
MAKE_STD_ZVAL(zopened);
- ZVAL_REFCOUNT(zopened) = 1;
- PZVAL_IS_REF(zopened) = 1;
+ Z_SET_REFCOUNT_P(zopened, 1);
+ Z_SET_ISREF_P(zopened);
ZVAL_NULL(zopened);
args[3] = &zopened;
/* create an instance of our class */
ALLOC_ZVAL(us->object);
object_init_ex(us->object, uwrap->ce);
- ZVAL_REFCOUNT(us->object) = 1;
- PZVAL_IS_REF(us->object) = 1;
+ Z_SET_REFCOUNT_P(us->object, 1);
+ Z_SET_ISREF_P(us->object);
if (context) {
MAKE_STD_ZVAL(zcontext);
/* create an instance of our class */
ALLOC_ZVAL(object);
object_init_ex(object, uwrap->ce);
- ZVAL_REFCOUNT(object) = 1;
- PZVAL_IS_REF(object) = 1;
+ Z_SET_REFCOUNT_P(object, 1);
+ Z_SET_ISREF_P(object);
if (context) {
MAKE_STD_ZVAL(zcontext);
/* create an instance of our class */
ALLOC_ZVAL(object);
object_init_ex(object, uwrap->ce);
- ZVAL_REFCOUNT(object) = 1;
- PZVAL_IS_REF(object) = 1;
+ Z_SET_REFCOUNT_P(object, 1);
+ Z_SET_ISREF_P(object);
if (context) {
MAKE_STD_ZVAL(zcontext);
/* create an instance of our class */
ALLOC_ZVAL(object);
object_init_ex(object, uwrap->ce);
- ZVAL_REFCOUNT(object) = 1;
- PZVAL_IS_REF(object) = 1;
+ Z_SET_REFCOUNT_P(object, 1);
+ Z_SET_ISREF_P(object);
if (context) {
MAKE_STD_ZVAL(zcontext);
/* create an instance of our class */
ALLOC_ZVAL(object);
object_init_ex(object, uwrap->ce);
- ZVAL_REFCOUNT(object) = 1;
- PZVAL_IS_REF(object) = 1;
+ Z_SET_REFCOUNT_P(object, 1);
+ Z_SET_ISREF_P(object);
if (context) {
MAKE_STD_ZVAL(zcontext);
/* create an instance of our class */
ALLOC_ZVAL(object);
object_init_ex(object, uwrap->ce);
- ZVAL_REFCOUNT(object) = 1;
- PZVAL_IS_REF(object) = 1;
+ Z_SET_REFCOUNT_P(object, 1);
+ Z_SET_ISREF_P(object);
if (context) {
MAKE_STD_ZVAL(zcontext);
zend_hash_get_current_key_ex(parent_ht, &index, &index_len, &num, 0, &pos) == HASH_KEY_IS_STRING;
zend_hash_move_forward_ex(parent_ht, &pos)) {
if (zend_hash_add(ht, index, index_len, data, sizeof(zval*), NULL) == SUCCESS) {
- (*data)->refcount++;
+ Z_ADDREF_PP(data);
}
}
}
projects / php / commitdiff