} \
} while (0)
+#define ZVAL_MAKE_REF(zv) do { \
+ zval *__zv = (zv); \
+ if (!Z_ISREF_P(__zv)) { \
+ ZVAL_NEW_REF(__zv, __zv); \
+ } \
+ } while (0)
+
#define ZVAL_UNREF(z) do { \
zval *_z = (z); \
zend_reference *ref; \
efree(ref); \
} while (0)
+#define SEPARATE_STRING(zv) do { \
+ zval *_zv = (zv); \
+ if (Z_REFCOUNTED_P(_zv) && \
+ Z_REFCOUNT_P(_zv) > 1) { \
+ Z_DELREF_P(_zv); \
+ zval_copy_ctor_func(_zv); \
+ } \
+ } while (0)
+
+#define SEPARATE_ARRAY(zv) do { \
+ zval *_zv = (zv); \
+ if (Z_IMMUTABLE_P(_zv)) { \
+ zval_copy_ctor_func(_zv); \
+ } else if (Z_REFCOUNT_P(_zv) > 1) { \
+ Z_DELREF_P(_zv); \
+ zval_copy_ctor_func(_zv); \
+ } \
+ } while (0)
+
+#define SEPARATE_ZVAL_NOREF(zv) do { \
+ zval *_zv = (zv); \
+ if (Z_COPYABLE_P(_zv) || \
+ Z_IMMUTABLE_P(_zv)) { \
+ if (Z_IMMUTABLE_P(_zv)) { \
+ zval_copy_ctor_func(_zv); \
+ } else if (Z_REFCOUNT_P(_zv) > 1) { \
+ Z_DELREF_P(_zv); \
+ zval_copy_ctor_func(_zv); \
+ } \
+ } \
+ } while (0)
+
#define SEPARATE_ZVAL(zv) do { \
zval *_zv = (zv); \
if (Z_REFCOUNTED_P(_zv) || \
} \
} while (0)
-#define SEPARATE_ZVAL_IF_REF(zv) do { \
- zval *__zv = (zv); \
- if (Z_ISREF_P(__zv)) { \
- if (Z_REFCOUNT_P(__zv) == 1) { \
- ZVAL_UNREF(__zv); \
- } else { \
- Z_DELREF_P(__zv); \
- ZVAL_DUP(__zv, Z_REFVAL_P(__zv)); \
- } \
- } \
- } while (0)
-
-#define SEPARATE_ZVAL_TO_MAKE_IS_REF(zv) do { \
- zval *__zv = (zv); \
- if (!Z_ISREF_P(__zv)) { \
- if (Z_COPYABLE_P(__zv) && \
- Z_REFCOUNT_P(__zv) > 1) { \
- Z_DELREF_P(__zv); \
- zval_copy_ctor_func(__zv); \
- } \
- ZVAL_NEW_REF(__zv, __zv); \
- } \
- } while (0)
-
#define SEPARATE_ARG_IF_REF(varptr) do { \
- zval *_varptr = (varptr); \
- if (Z_ISREF_P(_varptr)) { \
- zval tmp; \
- ZVAL_DUP(&tmp, Z_REFVAL_P(_varptr)); \
- varptr = &tmp; \
- } else if (Z_REFCOUNTED_P(_varptr)) { \
- Z_ADDREF_P(_varptr); \
+ ZVAL_DEREF(varptr); \
+ if (Z_REFCOUNTED_P(varptr)) { \
+ Z_ADDREF_P(varptr); \
} \
} while (0)
}
/* Standard PHP objects */
if (Z_OBJ_HT_P(arg) == &std_object_handlers || !Z_OBJ_HANDLER_P(arg, cast_object)) {
- SEPARATE_ZVAL_IF_NOT_REF(arg);
+ SEPARATE_ZVAL_NOREF(arg);
if (zend_std_cast_object_tostring(arg, arg, type TSRMLS_CC) == SUCCESS) {
*pl = Z_STRLEN_P(arg);
*p = Z_STRVAL_P(arg);
}
/* Standard PHP objects */
if (Z_OBJ_HT_P(arg) == &std_object_handlers || !Z_OBJ_HANDLER_P(arg, cast_object)) {
- SEPARATE_ZVAL_IF_NOT_REF(arg);
+ SEPARATE_ZVAL_NOREF(arg);
if (zend_std_cast_object_tostring(arg, arg, type TSRMLS_CC) == SUCCESS) {
*str = Z_STR_P(arg);
return SUCCESS;
zval *real_arg = arg;
/* scan through modifiers */
+ ZVAL_DEREF(arg);
while (1) {
if (*spec_walk == '/') {
- SEPARATE_ZVAL_IF_NOT_REF(arg);
+ SEPARATE_ZVAL(arg);
+ real_arg = arg;
} else if (*spec_walk == '!') {
check_null = 1;
} else {
spec_walk++;
}
- ZVAL_DEREF(arg);
-
switch (c) {
case 'l':
case 'L':
case IS_TRUE:
convert_to_string_ex(arg);
case IS_STRING:
- if (UNEXPECTED(Z_ISREF_P(arg))) {
- /* it's dangerous to return pointers to string
- buffer of referenced variable, because it can
- be clobbered throug magic callbacks */
- SEPARATE_ZVAL(arg);
- }
*p = Z_STRVAL_P(arg);
*pl = Z_STRLEN_P(arg);
if (c == 'p' && CHECK_ZVAL_NULL_PATH(arg)) {
case IS_TRUE:
convert_to_string_ex(arg);
case IS_STRING:
- if (UNEXPECTED(Z_ISREF_P(arg))) {
- /* it's dangerous to return pointers to string
- buffer of referenced variable, because it can
- be clobbered throug magic callbacks */
- SEPARATE_ZVAL(arg);
- }
*str = Z_STR_P(arg);
if (c == 'P' && CHECK_ZVAL_NULL_PATH(arg)) {
return "a valid path";
if (num_symbol_tables <= 0) return FAILURE;
- if (is_ref && !Z_ISREF_P(symbol)) {
- ZVAL_NEW_REF(symbol, symbol);
+ if (is_ref) {
+ ZVAL_MAKE_REF(symbol);
}
va_start(symbol_table_list, num_symbol_tables);
HashTable *target_hash;
zend_string *key;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &array) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z/", &array) == FAILURE) {
return;
}
- ZVAL_DEREF(array);
target_hash = HASH_OF(array);
if (!target_hash) {
zend_error(E_WARNING,"Variable passed to each() is not an array or object");
}
}
for (i = 0; i < parent_ce->default_static_members_count; i++) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(&CE_STATIC_MEMBERS(parent_ce)[i]);
+ ZVAL_MAKE_REF(&CE_STATIC_MEMBERS(parent_ce)[i]);
ce->default_static_members_table[i] = CE_STATIC_MEMBERS(parent_ce)[i];
Z_ADDREF(ce->default_static_members_table[i]);
}
}
}
for (i = 0; i < parent_ce->default_static_members_count; i++) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(&parent_ce->default_static_members_table[i]);
+ ZVAL_MAKE_REF(&parent_ce->default_static_members_table[i]);
ce->default_static_members_table[i] = parent_ce->default_static_members_table[i];
Z_ADDREF(ce->default_static_members_table[i]);
}
zend_class_entry *iface = va_arg(args, zend_class_entry *);
if (hash_key->key && do_inherit_constant_check(&ce->constants_table, zv, hash_key, iface)) {
- if (!Z_ISREF_P(zv)) {
- ZVAL_NEW_REF(zv, zv);
- }
+ ZVAL_MAKE_REF(zv);
Z_ADDREF_P(zv);
zend_hash_update(&ce->constants_table, hash_key->key, zv);
}
if (ast->kind == ZEND_CONST) {
ZVAL_COPY_VALUE(&result->u.constant, &ast->u.val);
efree(ast);
+ if (Z_TYPE(result->u.constant) == IS_ARRAY) {
+ zend_make_immutable_array_r(&result->u.constant TSRMLS_CC);
+ }
} else if (zend_ast_is_ct_constant(ast)) {
zend_ast_evaluate(&result->u.constant, ast, NULL TSRMLS_CC);
zend_ast_destroy(ast);
#define IS_TMP_FREE(should_free) ((zend_uintptr_t)should_free.var & 1L)
-#define MAKE_REAL_ZVAL_PTR(val) \
- do { \
- zval _tmp; \
- ZVAL_COPY_VALUE(&_tmp, (val)); \
- (val) = &_tmp; \
- } while (0)
-
/* End of zend_execute_locks.h */
#define CV_DEF_OF(i) (EG(active_op_array)->vars[i])
static inline void zend_assign_to_variable_reference(zval *variable_ptr, zval *value_ptr TSRMLS_DC)
{
if (EXPECTED(variable_ptr != value_ptr)) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
+ ZVAL_MAKE_REF(value_ptr);
Z_ADDREF_P(value_ptr);
zval_ptr_dtor(variable_ptr);
- ZVAL_COPY_VALUE(variable_ptr, value_ptr);
- } else if (!Z_ISREF_P(variable_ptr)) {
- ZVAL_NEW_REF(variable_ptr, variable_ptr);
+ ZVAL_REF(variable_ptr, Z_REF_P(value_ptr));
+ } else {
+ ZVAL_MAKE_REF(variable_ptr);
}
}
if (Z_TYPE_P(object) == IS_NULL
|| Z_TYPE_P(object) == IS_FALSE
|| (Z_TYPE_P(object) == IS_STRING && Z_STRLEN_P(object) == 0)) {
- if (EXPECTED(object == object_ptr)) {
- /* object_ptr is not a reference */
- SEPARATE_ZVAL(object);
- }
- zval_dtor(object);
+ zval_ptr_dtor_nogc(object);
object_init(object);
zend_error(E_WARNING, "Creating default object from empty value");
}
value = &tmp;
} else if (value_type == IS_CONST) {
if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
- ZVAL_DUP(&tmp, value);
+ ZVAL_COPY_VALUE(&tmp, value);
+ zval_copy_ctor_func(&tmp);
value = &tmp;
}
} else if (Z_REFCOUNTED_P(value)) {
}
if (Z_TYPE_P(value) != IS_STRING) {
- zval tmp;
+ zend_string *tmp = zval_get_string(value);
- ZVAL_COPY_VALUE(&tmp, value);
- if (value_type != IS_TMP_VAR) {
- zval_opt_copy_ctor(&tmp);
- }
- convert_to_string(&tmp);
- Z_STRVAL_P(str)[offset] = Z_STRVAL(tmp)[0];
- zval_dtor(&tmp);
+ Z_STRVAL_P(str)[offset] = tmp->val[0];
+ STR_RELEASE(tmp);
} else {
Z_STRVAL_P(str)[offset] = Z_STRVAL_P(value)[0];
if (value_type == IS_TMP_VAR) {
ZVAL_COPY_VALUE(variable_ptr, value);
/* IS_CONST can't be IS_OBJECT, IS_RESOURCE or IS_REFERENCE */
if (UNEXPECTED(Z_OPT_COPYABLE_P(variable_ptr))) {
- _zval_copy_ctor_func(variable_ptr ZEND_FILE_LINE_CC);
+ zval_copy_ctor_func(variable_ptr);
}
_zval_dtor_func(garbage ZEND_FILE_LINE_CC);
return variable_ptr;
ZVAL_COPY_VALUE(variable_ptr, value);
/* IS_CONST can't be IS_OBJECT, IS_RESOURCE or IS_REFERENCE */
if (UNEXPECTED(Z_OPT_COPYABLE_P(variable_ptr))) {
- _zval_copy_ctor_func(variable_ptr ZEND_FILE_LINE_CC);
+ zval_copy_ctor_func(variable_ptr);
}
return variable_ptr;
static inline zval* zend_assign_to_variable(zval *variable_ptr, zval *value TSRMLS_DC)
{
zend_refcounted *garbage;
- zval *is_ref = NULL;
if (EXPECTED(!Z_REFCOUNTED_P(variable_ptr))) {
- if (EXPECTED(!Z_ISREF_P(value))) {
- ZVAL_COPY(variable_ptr, value);
- } else {
- goto assign_ref;
- }
+ goto assign_simple;
+ } else if (UNEXPECTED(variable_ptr == value)) {
return variable_ptr;
- } else if (Z_ISREF_P(variable_ptr)) {
- is_ref = variable_ptr;
+ }
+ if (Z_ISREF_P(variable_ptr)) {
variable_ptr = Z_REFVAL_P(variable_ptr);
+ if (EXPECTED(!Z_REFCOUNTED_P(variable_ptr))) {
+ goto assign_simple;
+ }
}
- if (EXPECTED(!Z_REFCOUNTED_P(variable_ptr))) {
- goto assign_simple;
- } else if (Z_TYPE_P(variable_ptr) == IS_OBJECT &&
+ if (Z_TYPE_P(variable_ptr) == IS_OBJECT &&
UNEXPECTED(Z_OBJ_HANDLER_P(variable_ptr, set) != NULL)) {
Z_OBJ_HANDLER_P(variable_ptr, set)(variable_ptr, value TSRMLS_CC);
} else if (EXPECTED(variable_ptr != value)) {
if (Z_REFCOUNT_P(variable_ptr)==1) {
garbage = Z_COUNTED_P(variable_ptr);
if (EXPECTED(!Z_ISREF_P(value))) {
- if (!is_ref) {
- ZVAL_COPY(variable_ptr, value);
- } else {
- ZVAL_DUP(variable_ptr, value);
- }
- } else if (is_ref == value) {
- return variable_ptr;
+ ZVAL_COPY(variable_ptr, value);
} else {
if (Z_REFCOUNT_P(value) == 1) {
ZVAL_UNREF(value);
ZVAL_COPY(variable_ptr, value);
} else {
- ZVAL_DUP(variable_ptr, Z_REFVAL_P(value));
+ ZVAL_COPY(variable_ptr, Z_REFVAL_P(value));
}
}
_zval_dtor_func(garbage ZEND_FILE_LINE_CC);
GC_ZVAL_CHECK_POSSIBLE_ROOT(variable_ptr);
assign_simple:
if (EXPECTED(!Z_ISREF_P(value))) {
- if (!is_ref) {
- ZVAL_COPY(variable_ptr, value);
- } else {
- ZVAL_DUP(variable_ptr, value);
- }
- } else if (is_ref != value) {
-assign_ref:
+ ZVAL_COPY(variable_ptr, value);
+ } else {
if (Z_REFCOUNT_P(value) == 1) {
ZVAL_UNREF(value);
ZVAL_COPY(variable_ptr, value);
} else {
- ZVAL_DUP(variable_ptr, Z_REFVAL_P(value));
+ ZVAL_COPY(variable_ptr, Z_REFVAL_P(value));
}
}
}
ZVAL_DEREF(container);
if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
- if (Z_IMMUTABLE_P(container)) {
- zval_copy_ctor_func(container);
- } else if (Z_REFCOUNT_P(container) > 1) {
- Z_DELREF_P(container);
- zval_copy_ctor_func(container);
- }
+ SEPARATE_ARRAY(container);
fetch_from_array:
if (dim == NULL) {
retval = zend_hash_next_index_insert(Z_ARRVAL_P(container), &EG(uninitialized_zval));
retval = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, dim_type, type TSRMLS_CC);
}
if (is_ref) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
- ZVAL_COPY(result, retval);
+ ZVAL_MAKE_REF(retval);
+ Z_ADDREF_P(retval);
+ ZVAL_REF(result, Z_REF_P(retval));
} else {
ZVAL_INDIRECT(result, retval);
}
} else if (EXPECTED(Z_TYPE_P(container) == IS_STRING)) {
+ long offset;
+
if (type != BP_VAR_UNSET && UNEXPECTED(Z_STRLEN_P(container) == 0)) {
convert_to_array:
zval_dtor(container);
}
if (type != BP_VAR_UNSET) {
- if (container == container_ptr) {
- SEPARATE_ZVAL(container);
- }
+ SEPARATE_STRING(container);
}
if (UNEXPECTED(Z_TYPE_P(dim) != IS_LONG)) {
- zval tmp;
-
switch(Z_TYPE_P(dim)) {
case IS_STRING:
if (IS_LONG == is_numeric_string(Z_STRVAL_P(dim), Z_STRLEN_P(dim), NULL, NULL, -1)) {
break;
}
- ZVAL_DUP(&tmp, dim);
- convert_to_long(&tmp);
- dim = &tmp;
+ offset = zval_get_long(dim);
+ } else {
+ offset = Z_LVAL_P(dim);
}
if (!IS_INTERNED(Z_STR_P(container))) STR_ADDREF(Z_STR_P(container));
- ZVAL_STR_OFFSET(result, container, Z_LVAL_P(dim));
+ ZVAL_STR_OFFSET(result, container, offset);
} else if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
if (!Z_OBJ_HT_P(container)->read_dimension) {
zend_error_noreturn(E_ERROR, "Cannot use object as array");
}
if (result != retval) {
if (is_ref) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
- ZVAL_COPY(result, retval);
+ ZVAL_MAKE_REF(retval);
+ Z_ADDREF_P(retval);
+ ZVAL_REF(result, Z_REF_P(retval));
} else {
ZVAL_INDIRECT(result, retval);
}
retval = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, dim_type, type TSRMLS_CC);
ZVAL_COPY(result, retval);
} else if (EXPECTED(Z_TYPE_P(container) == IS_STRING)) {
- if (UNEXPECTED(Z_TYPE_P(dim) != IS_LONG)) {
- zval tmp;
+ long offset;
+ if (UNEXPECTED(Z_TYPE_P(dim) != IS_LONG)) {
switch(Z_TYPE_P(dim)) {
/* case IS_LONG: */
case IS_STRING:
break;
}
- ZVAL_DUP(&tmp, dim);
- convert_to_long(&tmp);
- dim = &tmp;
+ offset = zval_get_long(dim);
+ } else {
+ offset = Z_LVAL_P(dim);
}
- if (UNEXPECTED(Z_LVAL_P(dim) < 0) || UNEXPECTED(Z_STRLEN_P(container) <= Z_LVAL_P(dim))) {
+ if (UNEXPECTED(offset < 0) || UNEXPECTED(Z_STRLEN_P(container) <= offset)) {
if (type != BP_VAR_IS) {
- zend_error(E_NOTICE, "Uninitialized string offset: %ld", Z_LVAL_P(dim));
+ zend_error(E_NOTICE, "Uninitialized string offset: %ld", offset);
}
ZVAL_EMPTY_STRING(result);
} else {
- zend_uchar c = (zend_uchar)Z_STRVAL_P(container)[Z_LVAL_P(dim)];
+ zend_uchar c = (zend_uchar)Z_STRVAL_P(container)[offset];
if (CG(one_char_string)[c]) {
ZVAL_INT_STR(result, CG(one_char_string)[c]);
} else {
- ZVAL_NEW_STR(result, STR_INIT(Z_STRVAL_P(container) + Z_LVAL_P(dim), 1, 0));
+ ZVAL_NEW_STR(result, STR_INIT(Z_STRVAL_P(container) + offset, 1, 0));
}
}
} else if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
((Z_TYPE_P(container) == IS_NULL ||
Z_TYPE_P(container) == IS_FALSE ||
(Z_TYPE_P(container) == IS_STRING && Z_STRLEN_P(container)==0)))) {
- if (container == container_ptr) {
- SEPARATE_ZVAL(container);
- }
+ zval_ptr_dtor_nogc(container);
object_init(container);
} else {
zend_error(E_WARNING, "Attempt to modify property of non-object");
(ptr = Z_OBJ_HT_P(container)->read_property(container, prop_ptr, type, cache_slot, result TSRMLS_CC)) != NULL) {
if (ptr != result) {
if (is_ref && ptr != &EG(uninitialized_zval)) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(ptr);
- ZVAL_COPY(result, ptr);
+ ZVAL_MAKE_REF(ptr);
+ Z_ADDREF_P(ptr);
+ ZVAL_REF(result, Z_REF_P(ptr));
} else {
ZVAL_INDIRECT(result, ptr);
}
}
} else {
if (is_ref) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(ptr);
- ZVAL_COPY(result, ptr);
+ ZVAL_MAKE_REF(ptr);
+ Z_ADDREF_P(ptr);
+ ZVAL_REF(result, Z_REF_P(ptr));
} else {
ZVAL_INDIRECT(result, ptr);
}
zval *ptr = Z_OBJ_HT_P(container)->read_property(container, prop_ptr, type, cache_slot, result TSRMLS_CC);
if (ptr != result) {
if (is_ref && ptr != &EG(uninitialized_zval)) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(ptr);
- ZVAL_COPY(result, ptr);
+ ZVAL_MAKE_REF(ptr);
+ Z_ADDREF_P(ptr);
+ ZVAL_REF(result, Z_REF_P(ptr));
} else {
ZVAL_INDIRECT(result, ptr);
}
{
HashTable *target = va_arg(args, HashTable *);
- SEPARATE_ZVAL_TO_MAKE_IS_REF(var);
+ ZVAL_MAKE_REF(var);
Z_ADDREF_P(var);
zend_hash_update(target, key->key, var);
return 0;
q->key = NULL;
if (Z_OPT_REFCOUNTED_P(data)) {
if (Z_ISREF_P(data) && Z_REFCOUNT_P(data) == 1) {
- ZVAL_DUP(&q->val, Z_REFVAL_P(data));
+ ZVAL_COPY(&q->val, Z_REFVAL_P(data));
} else {
ZVAL_COPY(&q->val, data);
}
target->arHash[nIndex] = target_idx;
if (Z_OPT_REFCOUNTED_P(data)) {
if (Z_ISREF_P(data) && Z_REFCOUNT_P(data) == 1) {
- ZVAL_DUP(&q->val, Z_REFVAL_P(data));
+ ZVAL_COPY(&q->val, Z_REFVAL_P(data));
} else {
ZVAL_COPY(&q->val, data);
}
} else if (ht->nInternalPointer != ptr->pos) {
IS_CONSISTENT(ht);
if (ht->u.flags & HASH_FLAG_PACKED) {
- if (Z_TYPE(ht->arData[ptr->h].val) != IS_UNDEF) {
+ if (ptr->h < ht->nNumUsed &&
+ Z_TYPE(ht->arData[ptr->h].val) != IS_UNDEF) {
ht->nInternalPointer = ptr->h;
return 1;
}
} else {
idx = ht->arHash[ptr->h & ht->nTableMask];
while (idx != INVALID_IDX) {
- if (idx == ptr->pos) {
+ if (ht->arData[idx].h == ptr->h && idx == ptr->pos) {
ht->nInternalPointer = idx;
return 1;
}
it should return whether the call was successfull or not
*/
- SEPARATE_ARG_IF_REF(member);
+ if (Z_REFCOUNTED_P(member)) Z_ADDREF_P(member);
zend_call_method_with_1_params(object, ce, &ce->__get, ZEND_GET_FUNC_NAME, retval, member);
int result;
zend_class_entry *ce = Z_OBJCE_P(object);
- SEPARATE_ARG_IF_REF(member);
+ if (Z_REFCOUNTED_P(member)) Z_ADDREF_P(member);
if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
/* __set handler is called with two arguments:
property name
*/
- SEPARATE_ARG_IF_REF(member);
+ if (Z_REFCOUNTED_P(member)) Z_ADDREF_P(member);
zend_call_method_with_1_params(object, ce, &ce->__unset, ZEND_UNSET_FUNC_NAME, NULL, member);
it should return whether the property is set or not
*/
- SEPARATE_ARG_IF_REF(member);
+ if (Z_REFCOUNTED_P(member)) Z_ADDREF_P(member);
zend_call_method_with_1_params(object, ce, &ce->__isset, ZEND_ISSET_FUNC_NAME, retval, member);
{
if (Z_REFCOUNTED_P(p)) {
if (Z_ISREF_P(p) && Z_REFCOUNT_P(p) == 1) {
- ZVAL_DUP(p, Z_REFVAL_P(p));
+ ZVAL_COPY(p, Z_REFVAL_P(p));
} else {
Z_ADDREF_P(p);
}
}
}
if (is_ref) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(p);
+ ZVAL_MAKE_REF(p);
Z_ADDREF_P(p);
} else if (Z_ISREF_P(p)) {
ZVAL_DUP(&tmp, Z_REFVAL_P(p));
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
var_ptr = Z_REFVAL_P(var_ptr);
} else {
- SEPARATE_ZVAL(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
}
if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
var_ptr = Z_REFVAL_P(var_ptr);
} else {
- SEPARATE_ZVAL(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
}
if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
ZVAL_DUP(retval, var_ptr);
} else {
ZVAL_DUP(retval, var_ptr);
- SEPARATE_ZVAL(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
}
if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
ZVAL_DUP(retval, var_ptr);
} else {
ZVAL_DUP(retval, var_ptr);
- SEPARATE_ZVAL(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
}
if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
ZVAL_COPY(EX_VAR(opline->result.var), retval);
} else {
if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+ ZVAL_MAKE_REF(retval);
}
ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
}
if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_TMP_VAR) {
ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
if (OP1_TYPE == IS_CONST) {
- zval_opt_copy_ctor_no_imm(EX(return_value));
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(EX(return_value)))) {
+ zval_copy_ctor_func(EX(return_value));
+ }
}
} else if (Z_ISREF_P(retval_ptr)) {
- ZVAL_DUP(EX(return_value), Z_REFVAL_P(retval_ptr));
+ ZVAL_COPY(EX(return_value), Z_REFVAL_P(retval_ptr));
FREE_OP1_IF_VAR();
} else {
ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
}
if (EX(return_value)) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
- ZVAL_COPY(EX(return_value), retval_ptr);
+ ZVAL_MAKE_REF(retval_ptr);
+ Z_ADDREF_P(retval_ptr);
+ ZVAL_REF(EX(return_value), Z_REF_P(retval_ptr));
}
} while (0);
top = zend_vm_stack_top_inc(TSRMLS_C);
ZVAL_COPY_VALUE(top, value);
if (OP1_TYPE == IS_CONST) {
- /* Immutable arrays may be passed without copying ??? */
- /* some internal functions may try to modify them !!! */
- zval_opt_copy_ctor_no_imm(top);
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(top))) {
+ zval_copy_ctor_func(top);
+ }
}
ZEND_VM_NEXT_OPCODE();
}
varptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
top = zend_vm_stack_top_inc(TSRMLS_C);
if (Z_ISREF_P(varptr)) {
- ZVAL_COPY_VALUE(top, Z_REFVAL_P(varptr));
- /* Immutable arrays may be passed without copying ??? */
- /* some internal functions may try to modify them !!! */
- zval_opt_copy_ctor_no_imm(top);
+ ZVAL_COPY(top, Z_REFVAL_P(varptr));
FREE_OP1();
} else {
ZVAL_COPY_VALUE(top, varptr);
Z_TYPE_P(varptr) == IS_OBJECT ||
(Z_REFCOUNTED_P(varptr) && Z_REFCOUNT_P(varptr) == 1))) {
- if (!Z_ISREF_P(varptr)) {
- ZVAL_NEW_REF(varptr, varptr);
- }
- // TODO: Try to avoid copying of immutable arrays ???
- if (Z_OPT_IMMUTABLE_P(Z_REFVAL_P(varptr))) {
- zval_opt_copy_ctor(Z_REFVAL_P(varptr));
- }
+ ZVAL_MAKE_REF(varptr);
if (OP1_TYPE == IS_CV) {
Z_ADDREF_P(varptr);
}
zend_error(E_STRICT, "Only variables should be passed by reference");
}
top = zend_vm_stack_top_inc(TSRMLS_C);
- // TODO: Try to avoid copying of immutable arrays ???
- ZVAL_DUP(top, varptr);
+ ZVAL_COPY(top, varptr);
FREE_OP1_IF_VAR();
}
CHECK_EXCEPTION();
}
if (Z_ISREF_P(varptr)) {
- // TODO: Try to avoid copying of immutable arrays ???
- if (Z_OPT_IMMUTABLE_P(Z_REFVAL_P(varptr))) {
- zval_opt_copy_ctor(Z_REFVAL_P(varptr));
- }
Z_ADDREF_P(varptr);
ZVAL_COPY_VALUE(top, varptr);
} else if (OP1_TYPE == IS_VAR &&
UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
ZVAL_COPY_VALUE(top, varptr);
- SEPARATE_ZVAL_TO_MAKE_IS_REF(top);
+ ZVAL_MAKE_REF(top);
} else {
- // TODO: Try to avoid copying of immutable arrays ???
- if (Z_OPT_IMMUTABLE_P(varptr)) {
- zval_opt_copy_ctor(varptr);
- }
- SEPARATE_ZVAL_TO_MAKE_IS_REF(varptr);
+ ZVAL_MAKE_REF(varptr);
Z_ADDREF_P(varptr);
- ZVAL_COPY_VALUE(top, varptr);
+ ZVAL_REF(top, Z_REF_P(varptr));
}
FREE_OP1_VAR_PTR();
varptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
top = zend_vm_stack_top_inc(TSRMLS_C);
if (Z_ISREF_P(varptr)) {
- ZVAL_COPY_VALUE(top, Z_REFVAL_P(varptr));
- /* Immutable arrays may be passed without copying ??? */
- /* some internal functions may try to modify them !!! */
- zval_opt_copy_ctor_no_imm(top);
+ ZVAL_COPY(top, Z_REFVAL_P(varptr));
FREE_OP1();
} else {
ZVAL_COPY_VALUE(top, varptr);
top = zend_vm_stack_top_inc(TSRMLS_C);
if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, arg_num)) {
if (!Z_IMMUTABLE_P(args)) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(arg);
+ ZVAL_MAKE_REF(arg);
Z_ADDREF_P(arg);
- ZVAL_COPY_VALUE(top, arg);
+ ZVAL_REF(top, Z_REF_P(arg));
} else {
ZVAL_DUP(top, arg);
}
} else {
/* IS_CONST can't be IS_OBJECT, IS_RESOURCE or IS_REFERENCE */
if (UNEXPECTED(Z_OPT_COPYABLE_P(var_ptr))) {
- _zval_copy_ctor_func(var_ptr ZEND_FILE_LINE_CC);
+ zval_copy_ctor_func(var_ptr);
}
}
} else {
CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), c);
}
retval = EX_VAR(opline->result.var);
- ZVAL_DUP(retval, &c->value);
+ ZVAL_COPY_VALUE(retval, &c->value);
+ if (Z_OPT_COPYABLE_P(retval) || Z_OPT_REFCOUNTED_P(retval)) {
+ if (Z_OPT_COPYABLE_P(retval) && (c->flags & CONST_PERSISTENT)) {
+ zval_copy_ctor_func(retval);
+ } else {
+ Z_ADDREF_P(retval);
+ }
+ }
} else {
/* class constant */
zend_class_entry *ce;
if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
}
- SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
+ ZVAL_MAKE_REF(expr_ptr);
Z_ADDREF_P(expr_ptr);
FREE_OP1_VAR_PTR();
} else {
{
USE_OPLINE
zend_free_op free_op1;
- zval *expr;
+ zval *expr, tmp;
zval *result = EX_VAR(opline->result.var);
SAVE_OPLINE();
- expr = GET_OP1_ZVAL_PTR(BP_VAR_R);
+ expr = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
switch (opline->extended_value) {
case IS_NULL:
if (Z_TYPE_P(expr) == opline->extended_value) {
ZVAL_COPY_VALUE(result, expr);
if (OP1_TYPE == IS_CONST) {
- zval_opt_copy_ctor(result);
- } else if (OP1_TYPE == IS_CV) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(result))) {
+ zval_copy_ctor_func(result);
+ }
+ } else if (OP1_TYPE != IS_TMP_VAR) {
if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
}
+ FREE_OP1();
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
- if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) {
- ZVAL_DEREF(expr);
- }
- ZVAL_COPY_VALUE(result, expr);
- if (!IS_OP1_TMP_FREE()) {
- zval_opt_copy_ctor(result);
- }
-
if (opline->extended_value == IS_ARRAY) {
- convert_to_array(result);
+ if (Z_TYPE_P(expr) != IS_OBJECT) {
+ ZVAL_NEW_ARR(result);
+ zend_hash_init(Z_ARRVAL_P(result), 8, NULL, ZVAL_PTR_DTOR, 0);
+ if (Z_TYPE_P(expr) != IS_NULL) {
+ expr = zend_hash_index_add_new(Z_ARRVAL_P(result), 0, expr);
+ if (OP1_TYPE == IS_CONST) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(expr))) {
+ zval_copy_ctor_func(expr);
+ }
+ } else if (OP1_TYPE != IS_TMP_VAR) {
+ if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
+ }
+ }
+ } else {
+ ZVAL_COPY_VALUE(result, expr);
+ if (!IS_OP1_TMP_FREE()) {
+ zval_opt_copy_ctor(result);
+ }
+ convert_to_array(result);
+ }
} else {
- convert_to_object(result);
+ if (Z_TYPE_P(expr) != IS_ARRAY) {
+ object_init(result);
+ if (Z_TYPE_P(expr) != IS_NULL) {
+ expr = zend_hash_str_add_new(Z_OBJPROP_P(result), "scalar", sizeof("scalar")-1, expr);
+ if (OP1_TYPE == IS_CONST) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(expr))) {
+ zval_copy_ctor_func(expr);
+ }
+ } else if (OP1_TYPE != IS_TMP_VAR) {
+ if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
+ }
+ }
+ } else {
+ ZVAL_COPY_VALUE(result, expr);
+ if (!IS_OP1_TMP_FREE()) {
+ zval_opt_copy_ctor(result);
+ }
+ convert_to_object(result);
+ }
}
FREE_OP1_IF_VAR();
ZVAL_DEREF(array_ptr);
if (Z_TYPE_P(array_ptr) == IS_ARRAY) {
if (!Z_ISREF_P(array_ref)) {
- SEPARATE_ZVAL(array_ptr);
+ SEPARATE_ZVAL_NOREF(array_ptr);
array_ref = array_ptr;
if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
ZVAL_NEW_REF(array_ptr, array_ptr);
ce = Z_OBJCE_P(array_ptr);
if (!ce || ce->get_iterator == NULL) {
if (!Z_ISREF_P(array_ref)) {
- SEPARATE_ZVAL(array_ptr);
+ SEPARATE_ZVAL_NOREF(array_ptr);
}
Z_ADDREF_P(array_ptr);
}
zval *key = NULL;
array = array_ref = EX_VAR(opline->op1.var);
- ZVAL_DEREF(array);
+ if (Z_ISREF_P(array)) {
+ array = Z_REFVAL_P(array);
+ // TODO: referenced value might be changed to different array ???
+ if (Z_IMMUTABLE_P(array)) {
+ zval_copy_ctor(array);
+ }
+ }
if (opline->extended_value & ZEND_FE_FETCH_WITH_KEY) {
key = EX_VAR((opline+1)->result.var);
}
}
if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(value);
+ ZVAL_MAKE_REF(value);
+ Z_ADDREF_P(value);
+ ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(value));
+ } else {
+ ZVAL_COPY(EX_VAR(opline->result.var), value);
}
- ZVAL_COPY(EX_VAR(opline->result.var), value);
CHECK_EXCEPTION();
ZEND_VM_INC_OPCODE();
if (i_zend_is_true(value TSRMLS_CC)) {
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
- if (!IS_OP1_TMP_FREE()) {
- zval_opt_copy_ctor(EX_VAR(opline->result.var));
+ if (OP1_TYPE == IS_CONST) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
+ zval_copy_ctor_func(EX_VAR(opline->result.var));
+ }
+ } else if (OP1_TYPE == IS_CV) {
+ if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
}
- FREE_OP1_IF_VAR();
ZEND_VM_JMP(opline->op2.jmp_addr);
}
value = GET_OP1_ZVAL_PTR(BP_VAR_R);
if (i_zend_is_true(value TSRMLS_CC)) {
- if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) {
- ZVAL_COPY(EX_VAR(opline->result.var), value);
- } else {
- ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
- if (!IS_OP1_TMP_FREE()) {
- zval_opt_copy_ctor(EX_VAR(opline->result.var));
+ ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
+ if (OP1_TYPE == IS_CONST) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
+ zval_copy_ctor_func(EX_VAR(opline->result.var));
}
+ } else if (OP1_TYPE == IS_CV) {
+ if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
}
- FREE_OP1_IF_VAR();
ZEND_VM_JMP(opline->op2.jmp_addr);
}
value = GET_OP1_ZVAL_PTR(BP_VAR_R);
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
- if (!IS_OP1_TMP_FREE()) {
- zval_opt_copy_ctor_no_imm(EX_VAR(opline->result.var));
+ if (OP1_TYPE == IS_CONST) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
+ zval_copy_ctor_func(EX_VAR(opline->result.var));
+ }
+ } else if (OP1_TYPE == IS_CV) {
+ if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
}
- FREE_OP1_IF_VAR();
- CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
SAVE_OPLINE();
value = GET_OP1_ZVAL_PTR(BP_VAR_R);
- if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) {
- ZVAL_COPY(EX_VAR(opline->result.var), value);
- } else {
- ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
- if (!IS_OP1_TMP_FREE()) {
- zval_opt_copy_ctor_no_imm(EX_VAR(opline->result.var));
+ ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
+ if (OP1_TYPE == IS_CONST) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
+ zval_copy_ctor_func(EX_VAR(opline->result.var));
}
+ } else if (OP1_TYPE == IS_CV) {
+ if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
}
-
- FREE_OP1_IF_VAR();
- CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
} else {
/* IS_CONST can't be IS_OBJECT, IS_RESOURCE or IS_REFERENCE */
if (UNEXPECTED(Z_OPT_COPYABLE(c.value))) {
- _zval_copy_ctor_func(&c.value ZEND_FILE_LINE_CC);
+ zval_copy_ctor_func(&c.value);
}
}
c.flags = CONST_CS; /* non persistent, case sensetive */
&& (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
} else {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
+ ZVAL_MAKE_REF(value_ptr);
}
ZVAL_COPY(&generator->value, value_ptr);
top = zend_vm_stack_top_inc(TSRMLS_C);
if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, arg_num)) {
if (!Z_IMMUTABLE_P(args)) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(arg);
+ ZVAL_MAKE_REF(arg);
Z_ADDREF_P(arg);
- ZVAL_COPY_VALUE(top, arg);
+ ZVAL_REF(top, Z_REF_P(arg));
} else {
ZVAL_DUP(top, arg);
}
} else {
/* IS_CONST can't be IS_OBJECT, IS_RESOURCE or IS_REFERENCE */
if (UNEXPECTED(Z_OPT_COPYABLE_P(var_ptr))) {
- _zval_copy_ctor_func(var_ptr ZEND_FILE_LINE_CC);
+ zval_copy_ctor_func(var_ptr);
}
}
} else {
if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
if (IS_CONST == IS_CONST) {
- zval_opt_copy_ctor_no_imm(EX(return_value));
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(EX(return_value)))) {
+ zval_copy_ctor_func(EX(return_value));
+ }
}
} else if (Z_ISREF_P(retval_ptr)) {
- ZVAL_DUP(EX(return_value), Z_REFVAL_P(retval_ptr));
+ ZVAL_COPY(EX(return_value), Z_REFVAL_P(retval_ptr));
} else {
ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
}
if (EX(return_value)) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
- ZVAL_COPY(EX(return_value), retval_ptr);
+ ZVAL_MAKE_REF(retval_ptr);
+ Z_ADDREF_P(retval_ptr);
+ ZVAL_REF(EX(return_value), Z_REF_P(retval_ptr));
}
} while (0);
top = zend_vm_stack_top_inc(TSRMLS_C);
ZVAL_COPY_VALUE(top, value);
if (IS_CONST == IS_CONST) {
- /* Immutable arrays may be passed without copying ??? */
- /* some internal functions may try to modify them !!! */
- zval_opt_copy_ctor_no_imm(top);
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(top))) {
+ zval_copy_ctor_func(top);
+ }
}
ZEND_VM_NEXT_OPCODE();
}
{
USE_OPLINE
- zval *expr;
+ zval *expr, tmp;
zval *result = EX_VAR(opline->result.var);
SAVE_OPLINE();
if (Z_TYPE_P(expr) == opline->extended_value) {
ZVAL_COPY_VALUE(result, expr);
if (IS_CONST == IS_CONST) {
- zval_opt_copy_ctor(result);
- } else if (IS_CONST == IS_CV) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(result))) {
+ zval_copy_ctor_func(result);
+ }
+ } else if (IS_CONST != IS_TMP_VAR) {
if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
}
ZEND_VM_NEXT_OPCODE();
}
- if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
- ZVAL_DEREF(expr);
- }
- ZVAL_COPY_VALUE(result, expr);
- if (!0) {
- zval_opt_copy_ctor(result);
- }
-
if (opline->extended_value == IS_ARRAY) {
- convert_to_array(result);
+ if (Z_TYPE_P(expr) != IS_OBJECT) {
+ ZVAL_NEW_ARR(result);
+ zend_hash_init(Z_ARRVAL_P(result), 8, NULL, ZVAL_PTR_DTOR, 0);
+ if (Z_TYPE_P(expr) != IS_NULL) {
+ expr = zend_hash_index_add_new(Z_ARRVAL_P(result), 0, expr);
+ if (IS_CONST == IS_CONST) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(expr))) {
+ zval_copy_ctor_func(expr);
+ }
+ } else if (IS_CONST != IS_TMP_VAR) {
+ if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
+ }
+ }
+ } else {
+ ZVAL_COPY_VALUE(result, expr);
+ if (!0) {
+ zval_opt_copy_ctor(result);
+ }
+ convert_to_array(result);
+ }
} else {
- convert_to_object(result);
+ if (Z_TYPE_P(expr) != IS_ARRAY) {
+ object_init(result);
+ if (Z_TYPE_P(expr) != IS_NULL) {
+ expr = zend_hash_str_add_new(Z_OBJPROP_P(result), "scalar", sizeof("scalar")-1, expr);
+ if (IS_CONST == IS_CONST) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(expr))) {
+ zval_copy_ctor_func(expr);
+ }
+ } else if (IS_CONST != IS_TMP_VAR) {
+ if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
+ }
+ }
+ } else {
+ ZVAL_COPY_VALUE(result, expr);
+ if (!0) {
+ zval_opt_copy_ctor(result);
+ }
+ convert_to_object(result);
+ }
}
CHECK_EXCEPTION();
ZVAL_DEREF(array_ptr);
if (Z_TYPE_P(array_ptr) == IS_ARRAY) {
if (!Z_ISREF_P(array_ref)) {
- SEPARATE_ZVAL(array_ptr);
+ SEPARATE_ZVAL_NOREF(array_ptr);
array_ref = array_ptr;
if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
ZVAL_NEW_REF(array_ptr, array_ptr);
ce = Z_OBJCE_P(array_ptr);
if (!ce || ce->get_iterator == NULL) {
if (!Z_ISREF_P(array_ref)) {
- SEPARATE_ZVAL(array_ptr);
+ SEPARATE_ZVAL_NOREF(array_ptr);
}
Z_ADDREF_P(array_ptr);
}
if (i_zend_is_true(value TSRMLS_CC)) {
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
- if (!0) {
- zval_opt_copy_ctor(EX_VAR(opline->result.var));
+ if (IS_CONST == IS_CONST) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
+ zval_copy_ctor_func(EX_VAR(opline->result.var));
+ }
+ } else if (IS_CONST == IS_CV) {
+ if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
}
-
ZEND_VM_JMP(opline->op2.jmp_addr);
}
value = opline->op1.zv;
if (i_zend_is_true(value TSRMLS_CC)) {
- if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
- ZVAL_COPY(EX_VAR(opline->result.var), value);
- } else {
- ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
- if (!0) {
- zval_opt_copy_ctor(EX_VAR(opline->result.var));
+ ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
+ if (IS_CONST == IS_CONST) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
+ zval_copy_ctor_func(EX_VAR(opline->result.var));
}
+ } else if (IS_CONST == IS_CV) {
+ if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
}
-
ZEND_VM_JMP(opline->op2.jmp_addr);
}
value = opline->op1.zv;
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
- if (!0) {
- zval_opt_copy_ctor_no_imm(EX_VAR(opline->result.var));
+ if (IS_CONST == IS_CONST) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
+ zval_copy_ctor_func(EX_VAR(opline->result.var));
+ }
+ } else if (IS_CONST == IS_CV) {
+ if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
}
-
- CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
SAVE_OPLINE();
value = opline->op1.zv;
- if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
- ZVAL_COPY(EX_VAR(opline->result.var), value);
- } else {
- ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
- if (!0) {
- zval_opt_copy_ctor_no_imm(EX_VAR(opline->result.var));
+ ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
+ if (IS_CONST == IS_CONST) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
+ zval_copy_ctor_func(EX_VAR(opline->result.var));
}
+ } else if (IS_CONST == IS_CV) {
+ if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
}
-
- CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
ZVAL_COPY(EX_VAR(opline->result.var), retval);
} else {
if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+ ZVAL_MAKE_REF(retval);
}
ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
}
CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), c);
}
retval = EX_VAR(opline->result.var);
- ZVAL_DUP(retval, &c->value);
+ ZVAL_COPY_VALUE(retval, &c->value);
+ if (Z_OPT_COPYABLE_P(retval) || Z_OPT_REFCOUNTED_P(retval)) {
+ if (Z_OPT_COPYABLE_P(retval) && (c->flags & CONST_PERSISTENT)) {
+ zval_copy_ctor_func(retval);
+ } else {
+ Z_ADDREF_P(retval);
+ }
+ }
} else {
/* class constant */
zend_class_entry *ce;
if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
}
- SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
+ ZVAL_MAKE_REF(expr_ptr);
Z_ADDREF_P(expr_ptr);
} else {
} else {
/* IS_CONST can't be IS_OBJECT, IS_RESOURCE or IS_REFERENCE */
if (UNEXPECTED(Z_OPT_COPYABLE(c.value))) {
- _zval_copy_ctor_func(&c.value ZEND_FILE_LINE_CC);
+ zval_copy_ctor_func(&c.value);
}
}
c.flags = CONST_CS; /* non persistent, case sensetive */
&& (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
} else {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
+ ZVAL_MAKE_REF(value_ptr);
}
ZVAL_COPY(&generator->value, value_ptr);
if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
}
- SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
+ ZVAL_MAKE_REF(expr_ptr);
Z_ADDREF_P(expr_ptr);
} else {
&& (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
} else {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
+ ZVAL_MAKE_REF(value_ptr);
}
ZVAL_COPY(&generator->value, value_ptr);
ZVAL_COPY(EX_VAR(opline->result.var), retval);
} else {
if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+ ZVAL_MAKE_REF(retval);
}
ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
}
if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
}
- SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
+ ZVAL_MAKE_REF(expr_ptr);
Z_ADDREF_P(expr_ptr);
} else {
&& (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
} else {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
+ ZVAL_MAKE_REF(value_ptr);
}
ZVAL_COPY(&generator->value, value_ptr);
ZVAL_COPY(EX_VAR(opline->result.var), retval);
} else {
if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+ ZVAL_MAKE_REF(retval);
}
ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
}
if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
}
- SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
+ ZVAL_MAKE_REF(expr_ptr);
Z_ADDREF_P(expr_ptr);
} else {
&& (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
} else {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
+ ZVAL_MAKE_REF(value_ptr);
}
ZVAL_COPY(&generator->value, value_ptr);
if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
}
- SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
+ ZVAL_MAKE_REF(expr_ptr);
Z_ADDREF_P(expr_ptr);
} else {
&& (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
} else {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
+ ZVAL_MAKE_REF(value_ptr);
}
ZVAL_COPY(&generator->value, value_ptr);
if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
if (IS_TMP_VAR == IS_CONST) {
- zval_opt_copy_ctor_no_imm(EX(return_value));
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(EX(return_value)))) {
+ zval_copy_ctor_func(EX(return_value));
+ }
}
} else if (Z_ISREF_P(retval_ptr)) {
- ZVAL_DUP(EX(return_value), Z_REFVAL_P(retval_ptr));
+ ZVAL_COPY(EX(return_value), Z_REFVAL_P(retval_ptr));
} else {
ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
}
if (EX(return_value)) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
- ZVAL_COPY(EX(return_value), retval_ptr);
+ ZVAL_MAKE_REF(retval_ptr);
+ Z_ADDREF_P(retval_ptr);
+ ZVAL_REF(EX(return_value), Z_REF_P(retval_ptr));
}
} while (0);
top = zend_vm_stack_top_inc(TSRMLS_C);
ZVAL_COPY_VALUE(top, value);
if (IS_TMP_VAR == IS_CONST) {
- /* Immutable arrays may be passed without copying ??? */
- /* some internal functions may try to modify them !!! */
- zval_opt_copy_ctor_no_imm(top);
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(top))) {
+ zval_copy_ctor_func(top);
+ }
}
ZEND_VM_NEXT_OPCODE();
}
{
USE_OPLINE
zend_free_op free_op1;
- zval *expr;
+ zval *expr, tmp;
zval *result = EX_VAR(opline->result.var);
SAVE_OPLINE();
if (Z_TYPE_P(expr) == opline->extended_value) {
ZVAL_COPY_VALUE(result, expr);
if (IS_TMP_VAR == IS_CONST) {
- zval_opt_copy_ctor(result);
- } else if (IS_TMP_VAR == IS_CV) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(result))) {
+ zval_copy_ctor_func(result);
+ }
+ } else if (IS_TMP_VAR != IS_TMP_VAR) {
if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
}
+ zval_dtor(free_op1.var);
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
- if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
- ZVAL_DEREF(expr);
- }
- ZVAL_COPY_VALUE(result, expr);
- if (!1) {
- zval_opt_copy_ctor(result);
- }
-
if (opline->extended_value == IS_ARRAY) {
- convert_to_array(result);
+ if (Z_TYPE_P(expr) != IS_OBJECT) {
+ ZVAL_NEW_ARR(result);
+ zend_hash_init(Z_ARRVAL_P(result), 8, NULL, ZVAL_PTR_DTOR, 0);
+ if (Z_TYPE_P(expr) != IS_NULL) {
+ expr = zend_hash_index_add_new(Z_ARRVAL_P(result), 0, expr);
+ if (IS_TMP_VAR == IS_CONST) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(expr))) {
+ zval_copy_ctor_func(expr);
+ }
+ } else if (IS_TMP_VAR != IS_TMP_VAR) {
+ if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
+ }
+ }
+ } else {
+ ZVAL_COPY_VALUE(result, expr);
+ if (!1) {
+ zval_opt_copy_ctor(result);
+ }
+ convert_to_array(result);
+ }
} else {
- convert_to_object(result);
+ if (Z_TYPE_P(expr) != IS_ARRAY) {
+ object_init(result);
+ if (Z_TYPE_P(expr) != IS_NULL) {
+ expr = zend_hash_str_add_new(Z_OBJPROP_P(result), "scalar", sizeof("scalar")-1, expr);
+ if (IS_TMP_VAR == IS_CONST) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(expr))) {
+ zval_copy_ctor_func(expr);
+ }
+ } else if (IS_TMP_VAR != IS_TMP_VAR) {
+ if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
+ }
+ }
+ } else {
+ ZVAL_COPY_VALUE(result, expr);
+ if (!1) {
+ zval_opt_copy_ctor(result);
+ }
+ convert_to_object(result);
+ }
}
CHECK_EXCEPTION();
ZVAL_DEREF(array_ptr);
if (Z_TYPE_P(array_ptr) == IS_ARRAY) {
if (!Z_ISREF_P(array_ref)) {
- SEPARATE_ZVAL(array_ptr);
+ SEPARATE_ZVAL_NOREF(array_ptr);
array_ref = array_ptr;
if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
ZVAL_NEW_REF(array_ptr, array_ptr);
ce = Z_OBJCE_P(array_ptr);
if (!ce || ce->get_iterator == NULL) {
if (!Z_ISREF_P(array_ref)) {
- SEPARATE_ZVAL(array_ptr);
+ SEPARATE_ZVAL_NOREF(array_ptr);
}
Z_ADDREF_P(array_ptr);
}
if (i_zend_is_true(value TSRMLS_CC)) {
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
- if (!1) {
- zval_opt_copy_ctor(EX_VAR(opline->result.var));
+ if (IS_TMP_VAR == IS_CONST) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
+ zval_copy_ctor_func(EX_VAR(opline->result.var));
+ }
+ } else if (IS_TMP_VAR == IS_CV) {
+ if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
}
-
ZEND_VM_JMP(opline->op2.jmp_addr);
}
value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
if (i_zend_is_true(value TSRMLS_CC)) {
- if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
- ZVAL_COPY(EX_VAR(opline->result.var), value);
- } else {
- ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
- if (!1) {
- zval_opt_copy_ctor(EX_VAR(opline->result.var));
+ ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
+ if (IS_TMP_VAR == IS_CONST) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
+ zval_copy_ctor_func(EX_VAR(opline->result.var));
}
+ } else if (IS_TMP_VAR == IS_CV) {
+ if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
}
-
ZEND_VM_JMP(opline->op2.jmp_addr);
}
value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
- if (!1) {
- zval_opt_copy_ctor_no_imm(EX_VAR(opline->result.var));
+ if (IS_TMP_VAR == IS_CONST) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
+ zval_copy_ctor_func(EX_VAR(opline->result.var));
+ }
+ } else if (IS_TMP_VAR == IS_CV) {
+ if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
}
-
- CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
SAVE_OPLINE();
value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
- ZVAL_COPY(EX_VAR(opline->result.var), value);
- } else {
- ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
- if (!1) {
- zval_opt_copy_ctor_no_imm(EX_VAR(opline->result.var));
+ ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
+ if (IS_TMP_VAR == IS_CONST) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
+ zval_copy_ctor_func(EX_VAR(opline->result.var));
}
+ } else if (IS_TMP_VAR == IS_CV) {
+ if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
}
-
- CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
ZVAL_COPY(EX_VAR(opline->result.var), retval);
} else {
if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+ ZVAL_MAKE_REF(retval);
}
ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
}
if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
}
- SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
+ ZVAL_MAKE_REF(expr_ptr);
Z_ADDREF_P(expr_ptr);
} else {
&& (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
} else {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
+ ZVAL_MAKE_REF(value_ptr);
}
ZVAL_COPY(&generator->value, value_ptr);
if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
}
- SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
+ ZVAL_MAKE_REF(expr_ptr);
Z_ADDREF_P(expr_ptr);
} else {
&& (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
} else {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
+ ZVAL_MAKE_REF(value_ptr);
}
ZVAL_COPY(&generator->value, value_ptr);
ZVAL_COPY(EX_VAR(opline->result.var), retval);
} else {
if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+ ZVAL_MAKE_REF(retval);
}
ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
}
if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
}
- SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
+ ZVAL_MAKE_REF(expr_ptr);
Z_ADDREF_P(expr_ptr);
} else {
&& (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
} else {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
+ ZVAL_MAKE_REF(value_ptr);
}
ZVAL_COPY(&generator->value, value_ptr);
ZVAL_COPY(EX_VAR(opline->result.var), retval);
} else {
if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+ ZVAL_MAKE_REF(retval);
}
ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
}
if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
}
- SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
+ ZVAL_MAKE_REF(expr_ptr);
Z_ADDREF_P(expr_ptr);
} else {
&& (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
} else {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
+ ZVAL_MAKE_REF(value_ptr);
}
ZVAL_COPY(&generator->value, value_ptr);
if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
}
- SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
+ ZVAL_MAKE_REF(expr_ptr);
Z_ADDREF_P(expr_ptr);
} else {
&& (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
} else {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
+ ZVAL_MAKE_REF(value_ptr);
}
ZVAL_COPY(&generator->value, value_ptr);
if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
var_ptr = Z_REFVAL_P(var_ptr);
} else {
- SEPARATE_ZVAL(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
}
if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
var_ptr = Z_REFVAL_P(var_ptr);
} else {
- SEPARATE_ZVAL(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
}
if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
ZVAL_DUP(retval, var_ptr);
} else {
ZVAL_DUP(retval, var_ptr);
- SEPARATE_ZVAL(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
}
if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
ZVAL_DUP(retval, var_ptr);
} else {
ZVAL_DUP(retval, var_ptr);
- SEPARATE_ZVAL(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
}
if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
if (IS_VAR == IS_CONST) {
- zval_opt_copy_ctor_no_imm(EX(return_value));
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(EX(return_value)))) {
+ zval_copy_ctor_func(EX(return_value));
+ }
}
} else if (Z_ISREF_P(retval_ptr)) {
- ZVAL_DUP(EX(return_value), Z_REFVAL_P(retval_ptr));
+ ZVAL_COPY(EX(return_value), Z_REFVAL_P(retval_ptr));
zval_ptr_dtor_nogc(free_op1.var);
} else {
ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
}
if (EX(return_value)) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
- ZVAL_COPY(EX(return_value), retval_ptr);
+ ZVAL_MAKE_REF(retval_ptr);
+ Z_ADDREF_P(retval_ptr);
+ ZVAL_REF(EX(return_value), Z_REF_P(retval_ptr));
}
} while (0);
varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
top = zend_vm_stack_top_inc(TSRMLS_C);
if (Z_ISREF_P(varptr)) {
- ZVAL_COPY_VALUE(top, Z_REFVAL_P(varptr));
- /* Immutable arrays may be passed without copying ??? */
- /* some internal functions may try to modify them !!! */
- zval_opt_copy_ctor_no_imm(top);
+ ZVAL_COPY(top, Z_REFVAL_P(varptr));
zval_ptr_dtor_nogc(free_op1.var);
} else {
ZVAL_COPY_VALUE(top, varptr);
Z_TYPE_P(varptr) == IS_OBJECT ||
(Z_REFCOUNTED_P(varptr) && Z_REFCOUNT_P(varptr) == 1))) {
- if (!Z_ISREF_P(varptr)) {
- ZVAL_NEW_REF(varptr, varptr);
- }
- // TODO: Try to avoid copying of immutable arrays ???
- if (Z_OPT_IMMUTABLE_P(Z_REFVAL_P(varptr))) {
- zval_opt_copy_ctor(Z_REFVAL_P(varptr));
- }
+ ZVAL_MAKE_REF(varptr);
if (IS_VAR == IS_CV) {
Z_ADDREF_P(varptr);
}
zend_error(E_STRICT, "Only variables should be passed by reference");
}
top = zend_vm_stack_top_inc(TSRMLS_C);
- // TODO: Try to avoid copying of immutable arrays ???
- ZVAL_DUP(top, varptr);
+ ZVAL_COPY(top, varptr);
zval_ptr_dtor_nogc(free_op1.var);
}
CHECK_EXCEPTION();
}
if (Z_ISREF_P(varptr)) {
- // TODO: Try to avoid copying of immutable arrays ???
- if (Z_OPT_IMMUTABLE_P(Z_REFVAL_P(varptr))) {
- zval_opt_copy_ctor(Z_REFVAL_P(varptr));
- }
Z_ADDREF_P(varptr);
ZVAL_COPY_VALUE(top, varptr);
} else if (IS_VAR == IS_VAR &&
UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
ZVAL_COPY_VALUE(top, varptr);
- SEPARATE_ZVAL_TO_MAKE_IS_REF(top);
+ ZVAL_MAKE_REF(top);
} else {
- // TODO: Try to avoid copying of immutable arrays ???
- if (Z_OPT_IMMUTABLE_P(varptr)) {
- zval_opt_copy_ctor(varptr);
- }
- SEPARATE_ZVAL_TO_MAKE_IS_REF(varptr);
+ ZVAL_MAKE_REF(varptr);
Z_ADDREF_P(varptr);
- ZVAL_COPY_VALUE(top, varptr);
+ ZVAL_REF(top, Z_REF_P(varptr));
}
if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
top = zend_vm_stack_top_inc(TSRMLS_C);
if (Z_ISREF_P(varptr)) {
- ZVAL_COPY_VALUE(top, Z_REFVAL_P(varptr));
- /* Immutable arrays may be passed without copying ??? */
- /* some internal functions may try to modify them !!! */
- zval_opt_copy_ctor_no_imm(top);
+ ZVAL_COPY(top, Z_REFVAL_P(varptr));
zval_ptr_dtor_nogc(free_op1.var);
} else {
ZVAL_COPY_VALUE(top, varptr);
{
USE_OPLINE
zend_free_op free_op1;
- zval *expr;
+ zval *expr, tmp;
zval *result = EX_VAR(opline->result.var);
SAVE_OPLINE();
- expr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+ expr = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
switch (opline->extended_value) {
case IS_NULL:
if (Z_TYPE_P(expr) == opline->extended_value) {
ZVAL_COPY_VALUE(result, expr);
if (IS_VAR == IS_CONST) {
- zval_opt_copy_ctor(result);
- } else if (IS_VAR == IS_CV) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(result))) {
+ zval_copy_ctor_func(result);
+ }
+ } else if (IS_VAR != IS_TMP_VAR) {
if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
}
+ zval_ptr_dtor_nogc(free_op1.var);
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
- if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
- ZVAL_DEREF(expr);
- }
- ZVAL_COPY_VALUE(result, expr);
- if (!0) {
- zval_opt_copy_ctor(result);
- }
-
if (opline->extended_value == IS_ARRAY) {
- convert_to_array(result);
+ if (Z_TYPE_P(expr) != IS_OBJECT) {
+ ZVAL_NEW_ARR(result);
+ zend_hash_init(Z_ARRVAL_P(result), 8, NULL, ZVAL_PTR_DTOR, 0);
+ if (Z_TYPE_P(expr) != IS_NULL) {
+ expr = zend_hash_index_add_new(Z_ARRVAL_P(result), 0, expr);
+ if (IS_VAR == IS_CONST) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(expr))) {
+ zval_copy_ctor_func(expr);
+ }
+ } else if (IS_VAR != IS_TMP_VAR) {
+ if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
+ }
+ }
+ } else {
+ ZVAL_COPY_VALUE(result, expr);
+ if (!0) {
+ zval_opt_copy_ctor(result);
+ }
+ convert_to_array(result);
+ }
} else {
- convert_to_object(result);
+ if (Z_TYPE_P(expr) != IS_ARRAY) {
+ object_init(result);
+ if (Z_TYPE_P(expr) != IS_NULL) {
+ expr = zend_hash_str_add_new(Z_OBJPROP_P(result), "scalar", sizeof("scalar")-1, expr);
+ if (IS_VAR == IS_CONST) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(expr))) {
+ zval_copy_ctor_func(expr);
+ }
+ } else if (IS_VAR != IS_TMP_VAR) {
+ if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
+ }
+ }
+ } else {
+ ZVAL_COPY_VALUE(result, expr);
+ if (!0) {
+ zval_opt_copy_ctor(result);
+ }
+ convert_to_object(result);
+ }
}
zval_ptr_dtor_nogc(free_op1.var);
ZVAL_DEREF(array_ptr);
if (Z_TYPE_P(array_ptr) == IS_ARRAY) {
if (!Z_ISREF_P(array_ref)) {
- SEPARATE_ZVAL(array_ptr);
+ SEPARATE_ZVAL_NOREF(array_ptr);
array_ref = array_ptr;
if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
ZVAL_NEW_REF(array_ptr, array_ptr);
ce = Z_OBJCE_P(array_ptr);
if (!ce || ce->get_iterator == NULL) {
if (!Z_ISREF_P(array_ref)) {
- SEPARATE_ZVAL(array_ptr);
+ SEPARATE_ZVAL_NOREF(array_ptr);
}
Z_ADDREF_P(array_ptr);
}
zval *key = NULL;
array = array_ref = EX_VAR(opline->op1.var);
- ZVAL_DEREF(array);
+ if (Z_ISREF_P(array)) {
+ array = Z_REFVAL_P(array);
+ // TODO: referenced value might be changed to different array ???
+ if (Z_IMMUTABLE_P(array)) {
+ zval_copy_ctor(array);
+ }
+ }
if (opline->extended_value & ZEND_FE_FETCH_WITH_KEY) {
key = EX_VAR((opline+1)->result.var);
}
}
if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(value);
+ ZVAL_MAKE_REF(value);
+ Z_ADDREF_P(value);
+ ZVAL_REF(EX_VAR(opline->result.var), Z_REF_P(value));
+ } else {
+ ZVAL_COPY(EX_VAR(opline->result.var), value);
}
- ZVAL_COPY(EX_VAR(opline->result.var), value);
CHECK_EXCEPTION();
ZEND_VM_INC_OPCODE();
if (i_zend_is_true(value TSRMLS_CC)) {
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
- if (!0) {
- zval_opt_copy_ctor(EX_VAR(opline->result.var));
+ if (IS_VAR == IS_CONST) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
+ zval_copy_ctor_func(EX_VAR(opline->result.var));
+ }
+ } else if (IS_VAR == IS_CV) {
+ if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
}
- zval_ptr_dtor_nogc(free_op1.var);
ZEND_VM_JMP(opline->op2.jmp_addr);
}
value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
if (i_zend_is_true(value TSRMLS_CC)) {
- if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
- ZVAL_COPY(EX_VAR(opline->result.var), value);
- } else {
- ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
- if (!0) {
- zval_opt_copy_ctor(EX_VAR(opline->result.var));
+ ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
+ if (IS_VAR == IS_CONST) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
+ zval_copy_ctor_func(EX_VAR(opline->result.var));
}
+ } else if (IS_VAR == IS_CV) {
+ if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
}
- zval_ptr_dtor_nogc(free_op1.var);
ZEND_VM_JMP(opline->op2.jmp_addr);
}
value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
- if (!0) {
- zval_opt_copy_ctor_no_imm(EX_VAR(opline->result.var));
+ if (IS_VAR == IS_CONST) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
+ zval_copy_ctor_func(EX_VAR(opline->result.var));
+ }
+ } else if (IS_VAR == IS_CV) {
+ if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
}
- zval_ptr_dtor_nogc(free_op1.var);
- CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
SAVE_OPLINE();
value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
- ZVAL_COPY(EX_VAR(opline->result.var), value);
- } else {
- ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
- if (!0) {
- zval_opt_copy_ctor_no_imm(EX_VAR(opline->result.var));
+ ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
+ if (IS_VAR == IS_CONST) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
+ zval_copy_ctor_func(EX_VAR(opline->result.var));
}
+ } else if (IS_VAR == IS_CV) {
+ if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
}
-
- zval_ptr_dtor_nogc(free_op1.var);
- CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
ZVAL_COPY(EX_VAR(opline->result.var), retval);
} else {
if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+ ZVAL_MAKE_REF(retval);
}
ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
}
CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), c);
}
retval = EX_VAR(opline->result.var);
- ZVAL_DUP(retval, &c->value);
+ ZVAL_COPY_VALUE(retval, &c->value);
+ if (Z_OPT_COPYABLE_P(retval) || Z_OPT_REFCOUNTED_P(retval)) {
+ if (Z_OPT_COPYABLE_P(retval) && (c->flags & CONST_PERSISTENT)) {
+ zval_copy_ctor_func(retval);
+ } else {
+ Z_ADDREF_P(retval);
+ }
+ }
} else {
/* class constant */
zend_class_entry *ce;
if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
}
- SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
+ ZVAL_MAKE_REF(expr_ptr);
Z_ADDREF_P(expr_ptr);
if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
} else {
&& (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
} else {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
+ ZVAL_MAKE_REF(value_ptr);
}
ZVAL_COPY(&generator->value, value_ptr);
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
}
- SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
+ ZVAL_MAKE_REF(expr_ptr);
Z_ADDREF_P(expr_ptr);
if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
} else {
&& (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
} else {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
+ ZVAL_MAKE_REF(value_ptr);
}
ZVAL_COPY(&generator->value, value_ptr);
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
ZVAL_COPY(EX_VAR(opline->result.var), retval);
} else {
if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+ ZVAL_MAKE_REF(retval);
}
ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
}
if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
}
- SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
+ ZVAL_MAKE_REF(expr_ptr);
Z_ADDREF_P(expr_ptr);
if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
} else {
&& (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
} else {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
+ ZVAL_MAKE_REF(value_ptr);
}
ZVAL_COPY(&generator->value, value_ptr);
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
ZVAL_COPY(EX_VAR(opline->result.var), retval);
} else {
if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+ ZVAL_MAKE_REF(retval);
}
ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
}
if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
}
- SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
+ ZVAL_MAKE_REF(expr_ptr);
Z_ADDREF_P(expr_ptr);
if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
} else {
&& (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
} else {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
+ ZVAL_MAKE_REF(value_ptr);
}
ZVAL_COPY(&generator->value, value_ptr);
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
}
- SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
+ ZVAL_MAKE_REF(expr_ptr);
Z_ADDREF_P(expr_ptr);
if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
} else {
&& (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
} else {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
+ ZVAL_MAKE_REF(value_ptr);
}
ZVAL_COPY(&generator->value, value_ptr);
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), c);
}
retval = EX_VAR(opline->result.var);
- ZVAL_DUP(retval, &c->value);
+ ZVAL_COPY_VALUE(retval, &c->value);
+ if (Z_OPT_COPYABLE_P(retval) || Z_OPT_REFCOUNTED_P(retval)) {
+ if (Z_OPT_COPYABLE_P(retval) && (c->flags & CONST_PERSISTENT)) {
+ zval_copy_ctor_func(retval);
+ } else {
+ Z_ADDREF_P(retval);
+ }
+ }
} else {
/* class constant */
zend_class_entry *ce;
&& (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
} else {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
+ ZVAL_MAKE_REF(value_ptr);
}
ZVAL_COPY(&generator->value, value_ptr);
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
&& (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
} else {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
+ ZVAL_MAKE_REF(value_ptr);
}
ZVAL_COPY(&generator->value, value_ptr);
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
&& (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
} else {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
+ ZVAL_MAKE_REF(value_ptr);
}
ZVAL_COPY(&generator->value, value_ptr);
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
&& (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
} else {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
+ ZVAL_MAKE_REF(value_ptr);
}
ZVAL_COPY(&generator->value, value_ptr);
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
&& (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
} else {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
+ ZVAL_MAKE_REF(value_ptr);
}
ZVAL_COPY(&generator->value, value_ptr);
if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
var_ptr = Z_REFVAL_P(var_ptr);
} else {
- SEPARATE_ZVAL(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
}
if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
var_ptr = Z_REFVAL_P(var_ptr);
} else {
- SEPARATE_ZVAL(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
}
if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
ZVAL_DUP(retval, var_ptr);
} else {
ZVAL_DUP(retval, var_ptr);
- SEPARATE_ZVAL(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
}
if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
ZVAL_DUP(retval, var_ptr);
} else {
ZVAL_DUP(retval, var_ptr);
- SEPARATE_ZVAL(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
}
if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
if (IS_CV == IS_CONST) {
- zval_opt_copy_ctor_no_imm(EX(return_value));
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(EX(return_value)))) {
+ zval_copy_ctor_func(EX(return_value));
+ }
}
} else if (Z_ISREF_P(retval_ptr)) {
- ZVAL_DUP(EX(return_value), Z_REFVAL_P(retval_ptr));
+ ZVAL_COPY(EX(return_value), Z_REFVAL_P(retval_ptr));
} else {
ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
}
if (EX(return_value)) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
- ZVAL_COPY(EX(return_value), retval_ptr);
+ ZVAL_MAKE_REF(retval_ptr);
+ Z_ADDREF_P(retval_ptr);
+ ZVAL_REF(EX(return_value), Z_REF_P(retval_ptr));
}
} while (0);
varptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
top = zend_vm_stack_top_inc(TSRMLS_C);
if (Z_ISREF_P(varptr)) {
- ZVAL_COPY_VALUE(top, Z_REFVAL_P(varptr));
- /* Immutable arrays may be passed without copying ??? */
- /* some internal functions may try to modify them !!! */
- zval_opt_copy_ctor_no_imm(top);
+ ZVAL_COPY(top, Z_REFVAL_P(varptr));
} else {
ZVAL_COPY_VALUE(top, varptr);
Z_TYPE_P(varptr) == IS_OBJECT ||
(Z_REFCOUNTED_P(varptr) && Z_REFCOUNT_P(varptr) == 1))) {
- if (!Z_ISREF_P(varptr)) {
- ZVAL_NEW_REF(varptr, varptr);
- }
- // TODO: Try to avoid copying of immutable arrays ???
- if (Z_OPT_IMMUTABLE_P(Z_REFVAL_P(varptr))) {
- zval_opt_copy_ctor(Z_REFVAL_P(varptr));
- }
+ ZVAL_MAKE_REF(varptr);
if (IS_CV == IS_CV) {
Z_ADDREF_P(varptr);
}
zend_error(E_STRICT, "Only variables should be passed by reference");
}
top = zend_vm_stack_top_inc(TSRMLS_C);
- // TODO: Try to avoid copying of immutable arrays ???
- ZVAL_DUP(top, varptr);
+ ZVAL_COPY(top, varptr);
}
CHECK_EXCEPTION();
}
if (Z_ISREF_P(varptr)) {
- // TODO: Try to avoid copying of immutable arrays ???
- if (Z_OPT_IMMUTABLE_P(Z_REFVAL_P(varptr))) {
- zval_opt_copy_ctor(Z_REFVAL_P(varptr));
- }
Z_ADDREF_P(varptr);
ZVAL_COPY_VALUE(top, varptr);
} else if (IS_CV == IS_VAR &&
UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
ZVAL_COPY_VALUE(top, varptr);
- SEPARATE_ZVAL_TO_MAKE_IS_REF(top);
+ ZVAL_MAKE_REF(top);
} else {
- // TODO: Try to avoid copying of immutable arrays ???
- if (Z_OPT_IMMUTABLE_P(varptr)) {
- zval_opt_copy_ctor(varptr);
- }
- SEPARATE_ZVAL_TO_MAKE_IS_REF(varptr);
+ ZVAL_MAKE_REF(varptr);
Z_ADDREF_P(varptr);
- ZVAL_COPY_VALUE(top, varptr);
+ ZVAL_REF(top, Z_REF_P(varptr));
}
ZEND_VM_NEXT_OPCODE();
varptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
top = zend_vm_stack_top_inc(TSRMLS_C);
if (Z_ISREF_P(varptr)) {
- ZVAL_COPY_VALUE(top, Z_REFVAL_P(varptr));
- /* Immutable arrays may be passed without copying ??? */
- /* some internal functions may try to modify them !!! */
- zval_opt_copy_ctor_no_imm(top);
+ ZVAL_COPY(top, Z_REFVAL_P(varptr));
} else {
ZVAL_COPY_VALUE(top, varptr);
{
USE_OPLINE
- zval *expr;
+ zval *expr, tmp;
zval *result = EX_VAR(opline->result.var);
SAVE_OPLINE();
- expr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+ expr = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
switch (opline->extended_value) {
case IS_NULL:
if (Z_TYPE_P(expr) == opline->extended_value) {
ZVAL_COPY_VALUE(result, expr);
if (IS_CV == IS_CONST) {
- zval_opt_copy_ctor(result);
- } else if (IS_CV == IS_CV) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(result))) {
+ zval_copy_ctor_func(result);
+ }
+ } else if (IS_CV != IS_TMP_VAR) {
if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
}
ZEND_VM_NEXT_OPCODE();
}
- if (IS_CV == IS_VAR || IS_CV == IS_CV) {
- ZVAL_DEREF(expr);
- }
- ZVAL_COPY_VALUE(result, expr);
- if (!0) {
- zval_opt_copy_ctor(result);
- }
-
if (opline->extended_value == IS_ARRAY) {
- convert_to_array(result);
+ if (Z_TYPE_P(expr) != IS_OBJECT) {
+ ZVAL_NEW_ARR(result);
+ zend_hash_init(Z_ARRVAL_P(result), 8, NULL, ZVAL_PTR_DTOR, 0);
+ if (Z_TYPE_P(expr) != IS_NULL) {
+ expr = zend_hash_index_add_new(Z_ARRVAL_P(result), 0, expr);
+ if (IS_CV == IS_CONST) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(expr))) {
+ zval_copy_ctor_func(expr);
+ }
+ } else if (IS_CV != IS_TMP_VAR) {
+ if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
+ }
+ }
+ } else {
+ ZVAL_COPY_VALUE(result, expr);
+ if (!0) {
+ zval_opt_copy_ctor(result);
+ }
+ convert_to_array(result);
+ }
} else {
- convert_to_object(result);
+ if (Z_TYPE_P(expr) != IS_ARRAY) {
+ object_init(result);
+ if (Z_TYPE_P(expr) != IS_NULL) {
+ expr = zend_hash_str_add_new(Z_OBJPROP_P(result), "scalar", sizeof("scalar")-1, expr);
+ if (IS_CV == IS_CONST) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(expr))) {
+ zval_copy_ctor_func(expr);
+ }
+ } else if (IS_CV != IS_TMP_VAR) {
+ if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
+ }
+ }
+ } else {
+ ZVAL_COPY_VALUE(result, expr);
+ if (!0) {
+ zval_opt_copy_ctor(result);
+ }
+ convert_to_object(result);
+ }
}
CHECK_EXCEPTION();
ZVAL_DEREF(array_ptr);
if (Z_TYPE_P(array_ptr) == IS_ARRAY) {
if (!Z_ISREF_P(array_ref)) {
- SEPARATE_ZVAL(array_ptr);
+ SEPARATE_ZVAL_NOREF(array_ptr);
array_ref = array_ptr;
if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
ZVAL_NEW_REF(array_ptr, array_ptr);
ce = Z_OBJCE_P(array_ptr);
if (!ce || ce->get_iterator == NULL) {
if (!Z_ISREF_P(array_ref)) {
- SEPARATE_ZVAL(array_ptr);
+ SEPARATE_ZVAL_NOREF(array_ptr);
}
Z_ADDREF_P(array_ptr);
}
if (i_zend_is_true(value TSRMLS_CC)) {
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
- if (!0) {
- zval_opt_copy_ctor(EX_VAR(opline->result.var));
+ if (IS_CV == IS_CONST) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
+ zval_copy_ctor_func(EX_VAR(opline->result.var));
+ }
+ } else if (IS_CV == IS_CV) {
+ if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
}
-
ZEND_VM_JMP(opline->op2.jmp_addr);
}
value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
if (i_zend_is_true(value TSRMLS_CC)) {
- if (IS_CV == IS_VAR || IS_CV == IS_CV) {
- ZVAL_COPY(EX_VAR(opline->result.var), value);
- } else {
- ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
- if (!0) {
- zval_opt_copy_ctor(EX_VAR(opline->result.var));
+ ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
+ if (IS_CV == IS_CONST) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
+ zval_copy_ctor_func(EX_VAR(opline->result.var));
}
+ } else if (IS_CV == IS_CV) {
+ if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
}
-
ZEND_VM_JMP(opline->op2.jmp_addr);
}
value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
- if (!0) {
- zval_opt_copy_ctor_no_imm(EX_VAR(opline->result.var));
+ if (IS_CV == IS_CONST) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
+ zval_copy_ctor_func(EX_VAR(opline->result.var));
+ }
+ } else if (IS_CV == IS_CV) {
+ if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
}
-
- CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
SAVE_OPLINE();
value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
- if (IS_CV == IS_VAR || IS_CV == IS_CV) {
- ZVAL_COPY(EX_VAR(opline->result.var), value);
- } else {
- ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
- if (!0) {
- zval_opt_copy_ctor_no_imm(EX_VAR(opline->result.var));
+ ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
+ if (IS_CV == IS_CONST) {
+ if (UNEXPECTED(Z_OPT_COPYABLE_P(value))) {
+ zval_copy_ctor_func(EX_VAR(opline->result.var));
}
+ } else if (IS_CV == IS_CV) {
+ if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
}
-
- CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
ZVAL_COPY(EX_VAR(opline->result.var), retval);
} else {
if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+ ZVAL_MAKE_REF(retval);
}
ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
}
if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
}
- SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
+ ZVAL_MAKE_REF(expr_ptr);
Z_ADDREF_P(expr_ptr);
} else {
&& (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
} else {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
+ ZVAL_MAKE_REF(value_ptr);
}
ZVAL_COPY(&generator->value, value_ptr);
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
}
- SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
+ ZVAL_MAKE_REF(expr_ptr);
Z_ADDREF_P(expr_ptr);
} else {
&& (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
} else {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
+ ZVAL_MAKE_REF(value_ptr);
}
ZVAL_COPY(&generator->value, value_ptr);
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
ZVAL_COPY(EX_VAR(opline->result.var), retval);
} else {
if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+ ZVAL_MAKE_REF(retval);
}
ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
}
if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
}
- SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
+ ZVAL_MAKE_REF(expr_ptr);
Z_ADDREF_P(expr_ptr);
} else {
&& (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
} else {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
+ ZVAL_MAKE_REF(value_ptr);
}
ZVAL_COPY(&generator->value, value_ptr);
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
ZVAL_COPY(EX_VAR(opline->result.var), retval);
} else {
if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+ ZVAL_MAKE_REF(retval);
}
ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
}
if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
}
- SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
+ ZVAL_MAKE_REF(expr_ptr);
Z_ADDREF_P(expr_ptr);
} else {
&& (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
} else {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
+ ZVAL_MAKE_REF(value_ptr);
}
ZVAL_COPY(&generator->value, value_ptr);
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
}
if (EXPECTED(!Z_ISREF_P(var_ptr))) {
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ SEPARATE_ZVAL_NOREF(var_ptr);
} else {
ZVAL_DEREF(var_ptr);
}
if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
}
- SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
+ ZVAL_MAKE_REF(expr_ptr);
Z_ADDREF_P(expr_ptr);
} else {
&& (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
zend_error(E_NOTICE, "Only variable references should be yielded by reference");
} else {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
+ ZVAL_MAKE_REF(value_ptr);
}
ZVAL_COPY(&generator->value, value_ptr);
int still_running;
int result;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz", &z_mh, &z_still_running) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz/", &z_mh, &z_still_running) == FAILURE) {
return;
}
ZEND_FETCH_RESOURCE(mh, php_curlm *, z_mh, -1, le_curl_multi_handle_name, le_curl_multi_handle);
- ZVAL_DEREF(z_still_running);
{
zend_llist_position pos;
int queued_msgs;
zval *zmsgs_in_queue = NULL;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|z", &z_mh, &zmsgs_in_queue) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|z/", &z_mh, &zmsgs_in_queue) == FAILURE) {
return;
}
char *string = NULL;
int argc = ZEND_NUM_ARGS();
- if (zend_parse_parameters(argc TSRMLS_CC, "zs|z", ®ex, &findin, &findin_len, &array) == FAILURE) {
+ if (zend_parse_parameters(argc TSRMLS_CC, "zs|z/", ®ex, &findin, &findin_len, &array) == FAILURE) {
return;
}
}
match_len = 1;
- if (array) {
- ZVAL_DEREF(array);
- }
-
if (array && err != REG_NOMATCH) {
match_len = (int) (subs[0].rm_eo - subs[0].rm_so);
string_len = findin_len + 1;
long size, ret;
zend_string *response = NULL;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl|z", &z_ftp, &size, &zresponse) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl|z/", &z_ftp, &size, &zresponse) == FAILURE) {
RETURN_FALSE;
}
ret = ftp_alloc(ftp, size, zresponse ? &response : NULL);
if (response) {
- ZVAL_DEREF(zresponse);
zval_dtor(zresponse);
ZVAL_STR(zresponse, response);
}
if (key) {
if (key->val[0] == '\0' && Z_TYPE_P(val) == IS_OBJECT) {
/* Skip protected and private members. */
- if (tmp_ht) {
+ if (tmp_ht && ZEND_HASH_APPLY_PROTECTION(tmp_ht)) {
ZEND_HASH_DEC_APPLY_COUNT(tmp_ht);
}
continue;
ldap_linkdata *ld;
long option;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlz", &link, &option, &retval) != SUCCESS) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlz/", &link, &option, &retval) != SUCCESS) {
return;
}
ZEND_FETCH_RESOURCE(ld, ldap_linkdata *, link, -1, "ldap link", le_link);
- ZVAL_DEREF(retval);
switch (option) {
/* options with int value */
case LDAP_OPT_DEREF:
char *lmatcheddn, *lerrmsg;
int rc, lerrcode, myargcount = ZEND_NUM_ARGS();
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrz|zzz", &link, &result, &errcode, &matcheddn, &errmsg, &referrals) != SUCCESS) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrz/|z/z/z/", &link, &result, &errcode, &matcheddn, &errmsg, &referrals) != SUCCESS) {
return;
}
RETURN_FALSE;
}
- ZVAL_DEREF(errcode);
zval_ptr_dtor(errcode);
ZVAL_LONG(errcode, lerrcode);
/* Reverse -> fall through */
switch (myargcount) {
case 6:
- ZVAL_DEREF(referrals);
zval_ptr_dtor(referrals);
array_init(referrals);
if (lreferrals != NULL) {
ldap_value_free(lreferrals);
}
case 5:
- ZVAL_DEREF(errmsg);
zval_ptr_dtor(errmsg);
if (lerrmsg == NULL) {
ZVAL_EMPTY_STRING(errmsg);
ldap_memfree(lerrmsg);
}
case 4:
- ZVAL_DEREF(matcheddn);
zval_ptr_dtor(matcheddn);
if (lmatcheddn == NULL) {
ZVAL_EMPTY_STRING(matcheddn);
ldap_resultentry *resultentry;
char **lreferrals, **refp;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrz", &link, &result_entry, &referrals) != SUCCESS) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rrz/", &link, &result_entry, &referrals) != SUCCESS) {
return;
}
RETURN_FALSE;
}
- ZVAL_DEREF(referrals);
zval_ptr_dtor(referrals);
array_init(referrals);
if (lreferrals != NULL) {
ber_tag_t tag;
int rc, lerrcode, myargcount = ZEND_NUM_ARGS();
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rr|zz", &link, &result, &cookie, &estimated) != SUCCESS) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rr|z/z/", &link, &result, &cookie, &estimated) != SUCCESS) {
return;
}
ZVAL_LONG(estimated, lestimated);
}
- ZVAL_DEREF(cookie);
zval_ptr_dtor(cookie);
if (lcookie.bv_len == 0) {
ZVAL_EMPTY_STRING(cookie);
const mbfl_encoding *detected;
track_vars_array = NULL;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z", &encstr, &encstr_len, &track_vars_array) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z/", &encstr, &encstr_len, &track_vars_array) == FAILURE) {
return;
}
if (track_vars_array != NULL) {
/* Clear out the array */
- ZVAL_DEREF(track_vars_array);
zval_dtor(track_vars_array);
array_init(track_vars_array);
}
if (stack_level <= 0) {
var = &args[n++];
ZVAL_DEREF(var);
+ SEPARATE_ZVAL_NOREF(var);
if (Z_TYPE_P(var) == IS_ARRAY || Z_TYPE_P(var) == IS_OBJECT) {
target_hash = HASH_OF(var);
if (target_hash != NULL) {
if (stack_level <= 0) {
var = &args[n++];
ZVAL_DEREF(var);
+ SEPARATE_ZVAL_NOREF(var);
if (Z_TYPE_P(var) == IS_ARRAY || Z_TYPE_P(var) == IS_OBJECT) {
target_hash = HASH_OF(var);
if (target_hash != NULL) {
array = NULL;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zs|z", &arg_pattern, &string, &string_len, &array) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zs|z/", &arg_pattern, &string, &string_len, &array) == FAILURE) {
RETURN_FALSE;
}
match_len = 1;
str = string;
if (array != NULL) {
- ZVAL_DEREF(array);
zval_dtor(array);
array_init(array);
BIO * bio_out;
zend_resource *certresource;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|b", &zcert, &zout, ¬ext) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz/|b", &zcert, &zout, ¬ext) == FAILURE) {
return;
}
- ZVAL_DEREF(zout);
RETVAL_FALSE;
cert = php_openssl_x509_from_zval(zcert, 0, &certresource TSRMLS_CC);
zval * item;
STACK_OF(X509) *ca = NULL;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzzs|a", &zcert, &zout, &zpkey, &pass, &pass_len, &args) == FAILURE)
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz/zs|a", &zcert, &zout, &zpkey, &pass, &pass_len, &args) == FAILURE)
return;
- ZVAL_DEREF(zout);
RETVAL_FALSE;
cert = php_openssl_x509_from_zval(zcert, 0, &certresource TSRMLS_CC);
BIO * bio_in = NULL;
int i;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szs", &zp12, &zp12_len, &zout, &pass, &pass_len) == FAILURE)
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz/s", &zp12, &zp12_len, &zout, &pass, &pass_len) == FAILURE)
return;
- ZVAL_DEREF(zout);
+
RETVAL_FALSE;
bio_in = BIO_new(BIO_s_mem());
BIO * bio_out;
zend_resource *csr_resource;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz|b", &zcsr, &zout, ¬ext) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz/|b", &zcsr, &zout, ¬ext) == FAILURE) {
return;
}
- ZVAL_DEREF(zout);
+
RETVAL_FALSE;
csr = php_openssl_csr_from_zval(zcsr, 0, &csr_resource TSRMLS_CC);
int we_made_the_key = 1;
zend_resource *key_resource;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "az|a!a!", &dn, &out_pkey, &args, &attribs) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "az/|a!a!", &dn, &out_pkey, &args, &attribs) == FAILURE) {
return;
}
- ZVAL_DEREF(out_pkey);
RETVAL_FALSE;
PHP_SSL_REQ_INIT(&req);
BIO * bio_out = NULL;
const EVP_CIPHER * cipher;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|s!a!", &zpkey, &out, &passphrase, &passphrase_len, &args) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz/|s!a!", &zpkey, &out, &passphrase, &passphrase_len, &args) == FAILURE) {
return;
}
- ZVAL_DEREF(out);
RETVAL_FALSE;
key = php_openssl_evp_from_zval(zpkey, 0, passphrase, 0, &key_resource TSRMLS_CC);
int data_len;
long padding = RSA_PKCS1_PADDING;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szz|l", &data, &data_len, &crypted, &key, &padding) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz/z|l", &data, &data_len, &crypted, &key, &padding) == FAILURE) {
return;
}
- ZVAL_DEREF(crypted);
RETVAL_FALSE;
pkey = php_openssl_evp_from_zval(key, 0, "", 0, &keyresource TSRMLS_CC);
char * data;
int data_len;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szz|l", &data, &data_len, &crypted, &key, &padding) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz/z|l", &data, &data_len, &crypted, &key, &padding) == FAILURE) {
return;
}
- ZVAL_DEREF(crypted);
RETVAL_FALSE;
pkey = php_openssl_evp_from_zval(key, 0, "", 0, &keyresource TSRMLS_CC);
char * data;
int data_len;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szz|l", &data, &data_len, &crypted, &key, &padding) == FAILURE)
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz/z|l", &data, &data_len, &crypted, &key, &padding) == FAILURE)
return;
- ZVAL_DEREF(crypted);
RETVAL_FALSE;
pkey = php_openssl_evp_from_zval(key, 1, NULL, 0, &keyresource TSRMLS_CC);
char * data;
int data_len;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szz|l", &data, &data_len, &crypted, &key, &padding) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz/z|l", &data, &data_len, &crypted, &key, &padding) == FAILURE) {
return;
}
- ZVAL_DEREF(crypted);
RETVAL_FALSE;
pkey = php_openssl_evp_from_zval(key, 1, NULL, 0, &keyresource TSRMLS_CC);
long signature_algo = OPENSSL_ALGO_SHA1;
const EVP_MD *mdtype;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szz|z", &data, &data_len, &signature, &key, &method) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz/z|z", &data, &data_len, &signature, &key, &method) == FAILURE) {
return;
}
- ZVAL_DEREF(signature);
pkey = php_openssl_evp_from_zval(key, 0, "", 0, &keyresource TSRMLS_CC);
if (pkey == NULL) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "supplied key param cannot be coerced into a private key");
const EVP_CIPHER *cipher;
EVP_CIPHER_CTX ctx;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szza/|s", &data, &data_len, &sealdata, &ekeys, &pubkeys, &method, &method_len) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz/z/a/|s", &data, &data_len, &sealdata, &ekeys, &pubkeys, &method, &method_len) == FAILURE) {
return;
}
- ZVAL_DEREF(sealdata);
- ZVAL_DEREF(ekeys);
pubkeysht = HASH_OF(pubkeys);
nkeys = pubkeysht ? zend_hash_num_elements(pubkeysht) : 0;
if (!nkeys) {
int method_len = 0;
const EVP_CIPHER *cipher;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szsz|s", &data, &data_len, &opendata, &ekey, &ekey_len, &privkey, &method, &method_len) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz/sz|s", &data, &data_len, &opendata, &ekey, &ekey_len, &privkey, &method, &method_len) == FAILURE) {
return;
}
- ZVAL_DEREF(opendata);
pkey = php_openssl_evp_from_zval(privkey, 0, "", 0, &keyresource TSRMLS_CC);
if (pkey == NULL) {
zval *zstrong_result_returned = NULL;
int strong_result = 0;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|z", &buffer_length, &zstrong_result_returned) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|z/", &buffer_length, &zstrong_result_returned) == FAILURE) {
return;
}
- ZVAL_DEREF(zstrong_result_returned);
if (buffer_length <= 0) {
RETURN_FALSE;
int status;
pid_t child_id;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lz|l", &pid, &z_status, &options) == FAILURE)
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lz/|l", &pid, &z_status, &options) == FAILURE)
return;
- ZVAL_DEREF(z_status);
convert_to_long_ex(z_status);
status = Z_LVAL_P(z_status);
int status;
pid_t child_id;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|l", &z_status, &options) == FAILURE)
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z/|l", &z_status, &options) == FAILURE)
return;
- ZVAL_DEREF(z_status);
convert_to_long_ex(z_status);
status = Z_LVAL_P(z_status);
zval *user_set, *user_oldset = NULL, *user_signo;
sigset_t set, oldset;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "la|z", &how, &user_set, &user_oldset) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "la|z/", &how, &user_set, &user_oldset) == FAILURE) {
return;
}
}
if (user_oldset != NULL) {
- ZVAL_DEREF(user_oldset);
if (Z_TYPE_P(user_oldset) != IS_ARRAY) {
zval_dtor(user_oldset);
array_init(user_oldset);
struct timespec timeout;
if (timedwait) {
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|zll", &user_set, &user_siginfo, &tv_sec, &tv_nsec) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|z/ll", &user_set, &user_siginfo, &tv_sec, &tv_nsec) == FAILURE) {
return;
}
} else {
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|z", &user_set, &user_siginfo) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|z/", &user_set, &user_siginfo) == FAILURE) {
return;
}
}
}
if (signo > 0 && user_siginfo) {
- ZVAL_DEREF(user_siginfo);
if (Z_TYPE_P(user_siginfo) != IS_ARRAY) {
zval_dtor(user_siginfo);
array_init(user_siginfo);
long flags = 0; /* Match control flags */
long start_offset = 0; /* Where the new search starts */
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Ss|zll", ®ex,
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Ss|z/ll", ®ex,
&subject, &subject_len, &subpats, &flags, &start_offset) == FAILURE) {
RETURN_FALSE;
}
RETURN_FALSE;
}
- if (subpats) {
- ZVAL_DEREF(subpats);
- }
php_pcre_match_impl(pce, subject, subject_len, return_value, subpats,
global, ZEND_NUM_ARGS() >= 4, flags, start_offset TSRMLS_CC);
}
int replace_count=0, old_replace_count;
/* Get function parameters and do error-checking. */
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz|lz", ®ex, &replace, &subject, &limit, &zcount) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz|lz/", ®ex, &replace, &subject, &limit, &zcount) == FAILURE) {
return;
}
}
}
if (ZEND_NUM_ARGS() > 4) {
- ZVAL_DEREF(zcount);
zval_dtor(zcount);
ZVAL_LONG(zcount, replace_count);
}
!Z_REFCOUNTED_P(data_ptr) ||
Z_COUNTED_P(data) != Z_COUNTED_P(data_ptr)) {
zval_ptr_dtor(data);
-//??? SEPARATE_ZVAL_TO_MAKE_IS_REF(data_ptr);
ZVAL_COPY(data, data_ptr);
return 1;
}
zend_bool free_soap_headers = 0;
zval *this_ptr;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sa|a!zz",
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sa|a!zz/",
&function, &function_len, &args, &options, &headers, &output_headers) == FAILURE) {
return;
}
struct err_s err = {0};
//ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ra|l",
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ra/|l",
&zsocket, &zmsg, &flags) == FAILURE) {
return;
}
int retval, sets = 0;
long usec = 0;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a!a!a!z!|l", &r_array, &w_array, &e_array, &sec, &usec) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/!a/!a/!z!|l", &r_array, &w_array, &e_array, &sec, &usec) == FAILURE) {
return;
}
char *addr_string;
socklen_t salen = sizeof(php_sockaddr_storage);
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz|z", &arg1, &addr, &port) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz/|z/", &arg1, &addr, &port) == FAILURE) {
return;
}
RETURN_FALSE;
}
- ZVAL_DEREF(addr);
if (port != NULL) {
ZVAL_DEREF(port);
}
char *addr_string;
socklen_t salen = sizeof(php_sockaddr_storage);
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz|z", &arg1, &arg2, &arg3) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz/|z/", &arg1, &arg2, &arg3) == FAILURE) {
return;
}
RETURN_FALSE;
}
- ZVAL_DEREF(arg2);
- ZVAL_DEREF(arg3);
switch (sa->sa_family) {
#if HAVE_IPV6
case AF_INET6:
int retval;
long len, flags;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rzll", &php_sock_res, &buf, &len, &flags) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz/ll", &php_sock_res, &buf, &len, &flags) == FAILURE) {
return;
}
recv_buf = STR_ALLOC(len, 0);
- ZVAL_DEREF(buf);
if ((retval = recv(php_sock->bsd_socket, recv_buf->val, len, flags)) < 1) {
efree(recv_buf);
char *address;
zend_string *recv_buf;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rzllz|z", &arg1, &arg2, &arg3, &arg4, &arg5, &arg6) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz/llz/|z/", &arg1, &arg2, &arg3, &arg4, &arg5, &arg6) == FAILURE) {
return;
}
recv_buf->len = retval;
recv_buf->val[recv_buf->len] = '\0';
- ZVAL_DEREF(arg2);
- ZVAL_DEREF(arg5);
zval_dtor(arg2);
zval_dtor(arg5);
recv_buf->len = retval;
recv_buf->val[recv_buf->len] = '\0';
- ZVAL_DEREF(arg2);
- ZVAL_DEREF(arg5);
- ZVAL_DEREF(arg6);
zval_dtor(arg2);
zval_dtor(arg5);
zval_dtor(arg6);
recv_buf->len = retval;
recv_buf->val[recv_buf->len] = '\0';
- ZVAL_DEREF(arg2);
- ZVAL_DEREF(arg5);
- ZVAL_DEREF(arg6);
zval_dtor(arg2);
zval_dtor(arg5);
zval_dtor(arg6);
PHP_SOCKET fds_array[2];
long domain, type, protocol;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lllz", &domain, &type, &protocol, &fds_array_zval) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lllz/", &domain, &type, &protocol, &fds_array_zval) == FAILURE) {
return;
}
php_sock[0] = php_create_socket();
php_sock[1] = php_create_socket();
- ZVAL_DEREF(fds_array_zval);
if (domain != AF_INET
#if HAVE_IPV6
&& domain != AF_INET6
return;
}
- SEPARATE_ZVAL_IF_REF(value);
-
intern = Z_SPLDLLIST_P(getThis());
spl_ptr_llist_push(intern->llist, value TSRMLS_CC);
return;
}
- SEPARATE_ZVAL_IF_REF(value);
-
intern = Z_SPLDLLIST_P(getThis());
spl_ptr_llist_unshift(intern->llist, value TSRMLS_CC);
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &zindex, &value) == FAILURE) {
return;
}
- SEPARATE_ZVAL_IF_REF(value);
intern = Z_SPLDLLIST_P(getThis());
if (!Z_ISUNDEF(intern->array->elements[index])) {
zval_ptr_dtor(&(intern->array->elements[index]));
}
- SEPARATE_ARG_IF_REF(value);
- ZVAL_COPY_VALUE(&intern->array->elements[index], value);
+ ZVAL_DEREF(value);
+ ZVAL_COPY(&intern->array->elements[index], value);
}
}
/* }}} */
spl_fixedarray_init(array, tmp TSRMLS_CC);
ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(data), num_index, str_index, element) {
- SEPARATE_ARG_IF_REF(element);
- ZVAL_COPY_VALUE(&array->elements[num_index], element);
+ ZVAL_DEREF(element);
+ ZVAL_COPY(&array->elements[num_index], element);
} ZEND_HASH_FOREACH_END();
} else if (num > 0 && !save_indexes) {
spl_fixedarray_init(array, num TSRMLS_CC);
ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(data), element) {
- SEPARATE_ARG_IF_REF(element);
- ZVAL_COPY_VALUE(&array->elements[i], element);
+ ZVAL_DEREF(element);
+ ZVAL_COPY(&array->elements[i], element);
i++;
} ZEND_HASH_FOREACH_END();
} else {
return;
}
- SEPARATE_ARG_IF_REF(value);
+ if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
spl_ptr_heap_insert(intern->heap, value, getThis() TSRMLS_CC);
RETURN_TRUE;
return;
}
- SEPARATE_ARG_IF_REF(data);
- SEPARATE_ARG_IF_REF(priority);
+ if (Z_REFCOUNTED_P(data)) Z_ADDREF_P(data);
+ if (Z_REFCOUNTED_P(priority)) Z_ADDREF_P(priority);
array_init(&elem);
add_assoc_zval_ex(&elem, "data", sizeof("data") - 1, data);
zval *array;
long sort_type = PHP_SORT_REGULAR;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|l", &array, &sort_type) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/|l", &array, &sort_type) == FAILURE) {
RETURN_FALSE;
}
zval *array;
long sort_type = PHP_SORT_REGULAR;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|l", &array, &sort_type) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/|l", &array, &sort_type) == FAILURE) {
RETURN_FALSE;
}
cnt = zend_hash_num_elements(Z_ARRVAL_P(array));
if (mode == COUNT_RECURSIVE) {
+ if (ZEND_HASH_APPLY_PROTECTION(Z_ARRVAL_P(array))) {
+ Z_ARRVAL_P(array)->u.v.nApplyCount++;
+ }
ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(array), element) {
- if (ZEND_HASH_APPLY_PROTECTION(Z_ARRVAL_P(array))) {
- Z_ARRVAL_P(array)->u.v.nApplyCount++;
- }
ZVAL_DEREF(element);
cnt += php_count_recursive(element, COUNT_RECURSIVE TSRMLS_CC);
- if (ZEND_HASH_APPLY_PROTECTION(Z_ARRVAL_P(array))) {
- Z_ARRVAL_P(array)->u.v.nApplyCount--;
- }
} ZEND_HASH_FOREACH_END();
+ if (ZEND_HASH_APPLY_PROTECTION(Z_ARRVAL_P(array))) {
+ Z_ARRVAL_P(array)->u.v.nApplyCount--;
+ }
}
}
{
zval *array;
long mode = COUNT_NORMAL;
+ long cnt;
+ zval *element;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|l", &array, &mode) == FAILURE) {
return;
RETURN_LONG(0);
break;
case IS_ARRAY:
- RETURN_LONG (php_count_recursive (array, mode TSRMLS_CC));
+ cnt = zend_hash_num_elements(Z_ARRVAL_P(array));
+ if (mode == COUNT_RECURSIVE) {
+ ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(array), element) {
+ ZVAL_DEREF(element);
+ cnt += php_count_recursive(element, COUNT_RECURSIVE TSRMLS_CC);
+ } ZEND_HASH_FOREACH_END();
+ }
+ RETURN_LONG(cnt);
break;
case IS_OBJECT: {
#ifdef HAVE_SPL
{
zval *array;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &array) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/", &array) == FAILURE) {
return;
}
zval *array;
long sort_type = PHP_SORT_REGULAR;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|l", &array, &sort_type) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/|l", &array, &sort_type) == FAILURE) {
RETURN_FALSE;
}
zval *array;
long sort_type = PHP_SORT_REGULAR;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|l", &array, &sort_type) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/|l", &array, &sort_type) == FAILURE) {
RETURN_FALSE;
}
zval *array;
long sort_type = PHP_SORT_REGULAR;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|l", &array, &sort_type) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/|l", &array, &sort_type) == FAILURE) {
RETURN_FALSE;
}
zval *array;
long sort_type = PHP_SORT_REGULAR;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|l", &array, &sort_type) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/|l", &array, &sort_type) == FAILURE) {
RETURN_FALSE;
}
PHP_ARRAY_CMP_FUNC_BACKUP();
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "af", &array, &BG(user_compare_fci), &BG(user_compare_fci_cache)) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/f", &array, &BG(user_compare_fci), &BG(user_compare_fci_cache)) == FAILURE) {
PHP_ARRAY_CMP_FUNC_RESTORE();
return;
}
PHP_ARRAY_CMP_FUNC_BACKUP();
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "af", &array, &BG(user_compare_fci), &BG(user_compare_fci_cache)) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/f", &array, &BG(user_compare_fci), &BG(user_compare_fci_cache)) == FAILURE) {
PHP_ARRAY_CMP_FUNC_RESTORE();
return;
}
PHP_ARRAY_CMP_FUNC_BACKUP();
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "af", &array, &BG(user_compare_fci), &BG(user_compare_fci_cache)) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/f", &array, &BG(user_compare_fci), &BG(user_compare_fci_cache)) == FAILURE) {
PHP_ARRAY_CMP_FUNC_RESTORE();
return;
}
HashTable *array;
zval *entry;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "H", &array) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "H/", &array) == FAILURE) {
return;
}
HashTable *array;
zval *entry;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "H", &array) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "H/", &array) == FAILURE) {
return;
}
HashTable *array;
zval *entry;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "H", &array) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "H/", &array) == FAILURE) {
return;
}
HashTable *array;
zval *entry;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "H", &array) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "H/", &array) == FAILURE) {
return;
}
HashTable *array;
zval *entry;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "H", &array) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "H/", &array) == FAILURE) {
return;
}
{
HashTable *array;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "H", &array) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "H/", &array) == FAILURE) {
return;
}
orig_array_walk_fci = BG(array_walk_fci);
orig_array_walk_fci_cache = BG(array_walk_fci_cache);
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Hf|z/", &array, &BG(array_walk_fci), &BG(array_walk_fci_cache), &userdata) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "H/f|z/", &array, &BG(array_walk_fci), &BG(array_walk_fci_cache), &userdata) == FAILURE) {
BG(array_walk_fci) = orig_array_walk_fci;
BG(array_walk_fci_cache) = orig_array_walk_fci_cache;
return;
orig_array_walk_fci = BG(array_walk_fci);
orig_array_walk_fci_cache = BG(array_walk_fci_cache);
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Hf|z/", &array, &BG(array_walk_fci), &BG(array_walk_fci_cache), &userdata) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "H/f|z/", &array, &BG(array_walk_fci), &BG(array_walk_fci_cache), &userdata) == FAILURE) {
BG(array_walk_fci) = orig_array_walk_fci;
BG(array_walk_fci_cache) = orig_array_walk_fci_cache;
return;
int var_exists, count = 0;
int extract_refs = 0;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|lz/", &var_array, &extract_type, &prefix) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/|lz/", &var_array, &extract_type, &prefix) == FAILURE) {
return;
}
zend_rebuild_symbol_table(TSRMLS_C);
}
- /* var_array is passed by ref for the needs of EXTR_REFS (needs to
- * work on the original array to create refs to its members)
- * simulate pass_by_value if EXTR_REFS is not used */
- if (!extract_refs) {
- SEPARATE_ARG_IF_REF(var_array);
- }
-
ZEND_HASH_FOREACH_KEY_VAL_IND(Z_ARRVAL_P(var_array), num_key, var_name, entry) {
zval final_name;
if (extract_refs) {
zval *orig_var;
- SEPARATE_ZVAL_TO_MAKE_IS_REF(entry);
+ ZVAL_MAKE_REF(entry);
Z_ADDREF_P(entry);
if ((orig_var = zend_hash_find(&EG(active_symbol_table)->ht, Z_STR(final_name))) != NULL) {
zend_hash_update(&EG(active_symbol_table)->ht, Z_STR(final_name), entry);
}
} else {
- ZVAL_DUP(&data, entry);
- zend_set_local_var(Z_STR(final_name), &data, 1 TSRMLS_CC);
+ if (Z_REFCOUNTED_P(entry)) Z_ADDREF_P(entry);
+ zend_set_local_var(Z_STR(final_name), entry, 1 TSRMLS_CC);
}
count++;
}
zval_dtor(&final_name);
} ZEND_HASH_FOREACH_END();
- if (!extract_refs) {
- zval_ptr_dtor(var_array);
- }
-
RETURN_LONG(count);
}
/* }}} */
{
zval *array;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &array) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/", &array) == FAILURE) {
RETURN_FALSE;
}
argc; /* Number of function arguments */
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a+", &stack, &args, &argc) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/+", &stack, &args, &argc) == FAILURE) {
return;
}
zend_string *key = NULL;
ulong index;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &stack) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/", &stack) == FAILURE) {
return;
}
HashTable old_hash;
int argc; /* Number of function arguments */
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a+", &stack, &args, &argc) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/+", &stack, &args, &argc) == FAILURE) {
return;
}
repl_num = 0; /* Number of replacement elements */
int num_in; /* Number of elements in the input array */
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "al|lz/", &array, &offset, &length, &repl_array) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/l|lz/", &array, &offset, &length, &repl_array) == FAILURE) {
return;
}
zval *args;
int (*intersect_data_compare_func)(zval *, zval * TSRMLS_DC) = NULL;
zend_bool ok;
- zval *data;
+ zval *val, *data;
int req_args;
char *param_spec;
for (idx = 0; idx < Z_ARRVAL(args[0])->nNumUsed; idx++) {
p = Z_ARRVAL(args[0])->arData + idx;
- if (Z_TYPE(p->val) == IS_UNDEF) continue;
+ val = &p->val;
+ if (Z_TYPE_P(val) == IS_UNDEF) continue;
+ if (Z_ISREF_P(val) && Z_REFCOUNT_P(val) == 1) {
+ ZVAL_UNREF(val);
+ }
if (p->key == NULL) {
ok = 1;
for (i = 1; i < argc; i++) {
if ((data = zend_hash_index_find(Z_ARRVAL(args[i]), p->h)) == NULL ||
(intersect_data_compare_func &&
- intersect_data_compare_func(&p->val, data TSRMLS_CC) != 0)
+ intersect_data_compare_func(val, data TSRMLS_CC) != 0)
) {
ok = 0;
break;
}
}
if (ok) {
- if (Z_REFCOUNTED(p->val)) {
- Z_ADDREF(p->val);
+ if (Z_REFCOUNTED_P(val)) {
+ Z_ADDREF_P(val);
}
- zend_hash_index_update(Z_ARRVAL_P(return_value), p->h, &p->val);
+ zend_hash_index_update(Z_ARRVAL_P(return_value), p->h, val);
}
} else {
ok = 1;
for (i = 1; i < argc; i++) {
if ((data = zend_hash_find(Z_ARRVAL(args[i]), p->key)) == NULL ||
(intersect_data_compare_func &&
- intersect_data_compare_func(&p->val, data TSRMLS_CC) != 0)
+ intersect_data_compare_func(val, data TSRMLS_CC) != 0)
) {
ok = 0;
break;
}
}
if (ok) {
- if (Z_REFCOUNTED(p->val)) {
- Z_ADDREF(p->val);
+ if (Z_REFCOUNTED_P(val)) {
+ Z_ADDREF_P(val);
}
- zend_hash_update(Z_ARRVAL_P(return_value), p->key, &p->val);
+ zend_hash_update(Z_ARRVAL_P(return_value), p->key, val);
}
}
}
zval *args;
int (*diff_data_compare_func)(zval *, zval * TSRMLS_DC) = NULL;
zend_bool ok;
- zval *data;
+ zval *val, *data;
/* Get the argument count */
argc = ZEND_NUM_ARGS();
for (idx = 0; idx < Z_ARRVAL(args[0])->nNumUsed; idx++) {
p = Z_ARRVAL(args[0])->arData + idx;
- if (Z_TYPE(p->val) == IS_UNDEF) continue;
+ val = &p->val;
+ if (Z_TYPE_P(val) == IS_UNDEF) continue;
+ if (Z_ISREF_P(val) && Z_REFCOUNT_P(val) == 1) {
+ ZVAL_UNREF(val);
+ }
if (p->key == NULL) {
ok = 1;
for (i = 1; i < argc; i++) {
if ((data = zend_hash_index_find(Z_ARRVAL(args[i]), p->h)) != NULL &&
(!diff_data_compare_func ||
- diff_data_compare_func(&p->val, data TSRMLS_CC) == 0)
+ diff_data_compare_func(val, data TSRMLS_CC) == 0)
) {
ok = 0;
break;
}
}
if (ok) {
- if (Z_REFCOUNTED(p->val)) {
- Z_ADDREF(p->val);
+ if (Z_REFCOUNTED_P(val)) {
+ Z_ADDREF_P(val);
}
- zend_hash_index_update(Z_ARRVAL_P(return_value), p->h, &p->val);
+ zend_hash_index_update(Z_ARRVAL_P(return_value), p->h, val);
}
} else {
ok = 1;
for (i = 1; i < argc; i++) {
if ((data = zend_hash_find(Z_ARRVAL(args[i]), p->key)) != NULL &&
(!diff_data_compare_func ||
- diff_data_compare_func(&p->val, data TSRMLS_CC) == 0)
+ diff_data_compare_func(val, data TSRMLS_CC) == 0)
) {
ok = 0;
break;
}
}
if (ok) {
- if (Z_REFCOUNTED(p->val)) {
- Z_ADDREF(p->val);
+ if (Z_REFCOUNTED_P(val)) {
+ Z_ADDREF_P(val);
}
- zend_hash_update(Z_ARRVAL_P(return_value), p->key, &p->val);
+ zend_hash_update(Z_ARRVAL_P(return_value), p->key, val);
}
}
}
ZEND_ARG_INFO(0, arr1) /* ARRAY_INFO(0, arg, 0) */
ZEND_ARG_VARIADIC_INFO(0, arrays)
ZEND_END_ARG_INFO()
-
+
ZEND_BEGIN_ARG_INFO_EX(arginfo_array_merge_recursive, 0, 0, 2)
ZEND_ARG_INFO(0, arr1) /* ARRAY_INFO(0, arg, 0) */
ZEND_ARG_VARIADIC_INFO(0, arrays)
struct __res_state *handle = &state;
#endif
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|z", &hostname, &hostname_len, &mx_list, &weight_list) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz/|z/", &hostname, &hostname_len, &mx_list, &weight_list) == FAILURE) {
return;
}
- mx_list = Z_REFVAL_P(mx_list);
zval_dtor(mx_list);
array_init(mx_list);
if (weight_list) {
- weight_list = Z_REFVAL_P(weight_list);
zval_dtor(weight_list);
array_init(weight_list);
}
if (!ret_array) {
ret = php_exec(mode, cmd, NULL, return_value TSRMLS_CC);
} else {
- ret_array = Z_REFVAL_P(ret_array);
if (Z_TYPE_P(ret_array) != IS_ARRAY) {
zval_dtor(ret_array);
array_init(ret_array);
ret = php_exec(2, cmd, ret_array, return_value TSRMLS_CC);
}
if (ret_code) {
- ret_code = Z_REFVAL_P(ret_code);
zval_dtor(ret_code);
ZVAL_LONG(ret_code, ret);
}
php_stream *stream;
long operation = 0;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl|z", &arg1, &operation, &arg3) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl|z/", &arg1, &operation, &arg3) == FAILURE) {
return;
}
RETURN_FALSE;
}
- if (arg3 && Z_ISREF_P(arg3)) {
- convert_to_long_ex(Z_REFVAL_P(arg3));
- Z_LVAL_P(Z_REFVAL_P(arg3)) = 0;
+ if (arg3) {
+ zval_dtor(arg3);
+ ZVAL_LONG(arg3, 0);
}
/* flock_values contains all possible actions if (operation & 4) we won't block on the lock */
act = flock_values[act - 1] | (operation & PHP_LOCK_NB ? LOCK_NB : 0);
if (php_stream_lock(stream, act)) {
- if (operation && errno == EWOULDBLOCK && arg3 && Z_ISREF_P(arg3)) {
- Z_LVAL_P(Z_REFVAL_P(arg3)) = 1;
+ if (operation && errno == EWOULDBLOCK && arg3) {
+ ZVAL_LONG(arg3, 1);
}
RETURN_FALSE;
}
z_format = &args[format_offset];
array = &args[1 + format_offset];
- SEPARATE_ZVAL(array);
- convert_to_array_ex(array);
+ if (Z_TYPE_P(array) != IS_ARRAY) {
+ SEPARATE_ZVAL(array);
+ convert_to_array(array);
+ }
argc = 1 + zend_hash_num_elements(Z_ARRVAL_P(array));
newargs = (zval *)safe_emalloc(argc, sizeof(zval), 0);
while (inpos < Z_STRLEN(args[format_offset])) {
int expprec = 0;
- zval tmp;
+ zval *tmp;
PRINTF_DEBUG(("sprintf: format[%d]='%c'\n", inpos, format[inpos]));
PRINTF_DEBUG(("sprintf: outpos=%d\n", outpos));
}
PRINTF_DEBUG(("sprintf: format character='%c'\n", format[inpos]));
/* now we expect to find a type specifier */
- //???? We don't hold zval** in args anymore
- //if (multiuse) {
- ZVAL_DUP(&tmp, &args[argnum]);
- //} else {
- // SEPARATE_ZVAL(&args[argnum]);
- // ZVAL_COPY_VALUE(&tmp, &args[argnum]);
- //}
-
+ tmp = &args[argnum];
switch (format[inpos]) {
case 's': {
- zend_string *str = zval_get_string(&tmp);
+ zend_string *str = zval_get_string(tmp);
php_sprintf_appendstring(&result, &outpos,
str->val,
width, precision, padding,
}
case 'd':
- convert_to_long(&tmp);
php_sprintf_appendint(&result, &outpos,
- Z_LVAL(tmp),
+ zval_get_long(tmp),
width, padding, alignment,
always_sign);
break;
case 'u':
- convert_to_long(&tmp);
php_sprintf_appenduint(&result, &outpos,
- Z_LVAL(tmp),
+ zval_get_long(tmp),
width, padding, alignment);
break;
case 'E':
case 'f':
case 'F':
- convert_to_double(&tmp);
php_sprintf_appenddouble(&result, &outpos,
- Z_DVAL(tmp),
+ zval_get_double(tmp),
width, padding, alignment,
precision, adjusting,
format[inpos], always_sign
break;
case 'c':
- convert_to_long(&tmp);
php_sprintf_appendchar(&result, &outpos,
- (char) Z_LVAL(tmp) TSRMLS_CC);
+ (char) zval_get_long(tmp) TSRMLS_CC);
break;
case 'o':
- convert_to_long(&tmp);
php_sprintf_append2n(&result, &outpos,
- Z_LVAL(tmp),
+ zval_get_long(tmp),
width, padding, alignment, 3,
hexchars, expprec);
break;
case 'x':
- convert_to_long(&tmp);
php_sprintf_append2n(&result, &outpos,
- Z_LVAL(tmp),
+ zval_get_long(tmp),
width, padding, alignment, 4,
hexchars, expprec);
break;
case 'X':
- convert_to_long(&tmp);
php_sprintf_append2n(&result, &outpos,
- Z_LVAL(tmp),
+ zval_get_long(tmp),
width, padding, alignment, 4,
HEXCHARS, expprec);
break;
case 'b':
- convert_to_long(&tmp);
php_sprintf_append2n(&result, &outpos,
- Z_LVAL(tmp),
+ zval_get_long(tmp),
width, padding, alignment, 1,
hexchars, expprec);
break;
default:
break;
}
- zval_ptr_dtor(&tmp);
inpos++;
}
}
RETVAL_FALSE;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|lzzd", &host, &host_len, &port, &zerrno, &zerrstr, &timeout) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|lz/z/d", &host, &host_len, &port, &zerrno, &zerrstr, &timeout) == FAILURE) {
RETURN_FALSE;
}
tv.tv_usec = conv % 1000000;
if (zerrno) {
- zerrno = Z_REFVAL_P(zerrno);
zval_dtor(zerrno);
ZVAL_LONG(zerrno, 0);
}
if (zerrstr) {
- zerrstr = Z_REFVAL_P(zerrstr);
zval_dtor(zerrstr);
ZVAL_EMPTY_STRING(zerrstr);
}
const char *file="";
int line=0;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|zz", &arg1, &arg2) == FAILURE)
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z/z/", &arg1, &arg2) == FAILURE)
return;
if (SG(headers_sent)) {
int input_len;
const int argc = ZEND_NUM_ARGS();
- if (zend_parse_parameters(argc TSRMLS_CC, "s|z", &input, &input_len, &info) == FAILURE) {
+ if (zend_parse_parameters(argc TSRMLS_CC, "s|z/", &input, &input_len, &info) == FAILURE) {
return;
}
if (argc == 2) {
- info = Z_REFVAL_P(info);
zval_dtor(info);
array_init(info);
}
php_file_descriptor_t slave_pty = -1;
#endif
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "saz|s!a!a!", &command,
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "saz/|s!a!a!", &command,
&command_len, &descriptorspec, &pipes, &cwd, &cwd_len, &environment,
&other_options) == FAILURE) {
RETURN_FALSE;
proc->env = env;
if (pipes != NULL) {
- ZVAL_DEREF(pipes);
zval_dtor(pipes);
}
if (numVars && objIndex >= argCount) {
break;
} else if (numVars) {
- current = &args[objIndex++];
- zval_dtor(Z_REFVAL_P(current));
- ZVAL_LONG(Z_REFVAL_P(current), (long)(string - baseString) );
-// Z_SET_REFCOUNT_P(current, refcount);
-//??? Z_SET_ISREF_P(current);
+ current = Z_REFVAL(args[objIndex++]);
+ zval_ptr_dtor(current);
+ ZVAL_LONG(current, (long)(string - baseString) );
} else {
add_index_long(return_value, objIndex++, string - baseString);
}
if (numVars && objIndex >= argCount) {
break;
} else if (numVars) {
- current = &args[objIndex++];
- zval_dtor(Z_REFVAL_P(current));
- ZVAL_STRINGL(Z_REFVAL_P(current), string, end-string);
-//??? Z_SET_REFCOUNT_P(current, refcount);
-//??? Z_SET_ISREF_PP(current);
+ current = Z_REFVAL(args[objIndex++]);
+ zval_ptr_dtor(current);
+ ZVAL_STRINGL(current, string, end-string);
} else {
add_index_stringl(return_value, objIndex++, string, end-string);
}
if (numVars && objIndex >= argCount) {
break;
} else if (numVars) {
- current = &args[objIndex++];
- zval_dtor(Z_REFVAL_P(current));
- ZVAL_STRINGL(Z_REFVAL_P(current), string, end-string);
+ current = Z_REFVAL(args[objIndex++]);
+ zval_ptr_dtor(current);
+ ZVAL_STRINGL(current, string, end-string);
} else {
add_index_stringl(return_value, objIndex++, string, end-string);
}
break;
} else if (numVars) {
/* change passed value type to string */
- current = &args[objIndex++];
- zval_dtor(Z_REFVAL_P(current));
- ZVAL_STRING(Z_REFVAL_P(current), buf);
+ current = Z_REFVAL(args[objIndex++]);
+ zval_ptr_dtor(current);
+ ZVAL_STRING(current, buf);
} else {
add_index_string(return_value, objIndex++, buf);
}
if (numVars && objIndex >= argCount) {
break;
} else if (numVars) {
- current = &args[objIndex++];
- zval_dtor(Z_REFVAL_P(current));
- ZVAL_LONG(Z_REFVAL_P(current), value);
+ current = Z_REFVAL(args[objIndex++]);
+ zval_ptr_dtor(current);
+ ZVAL_LONG(current, value);
} else {
add_index_long(return_value, objIndex++, value);
}
if (numVars && objIndex >= argCount) {
break;
} else if (numVars) {
- current = &args[objIndex++];
- zval_dtor(Z_REFVAL_P(current));
- ZVAL_DOUBLE(Z_REFVAL_P(current), dvalue);
+ current = Z_REFVAL(args[objIndex++]);
+ zval_ptr_dtor(current);
+ ZVAL_DOUBLE(current, dvalue);
} else {
add_index_double(return_value, objIndex++, dvalue );
}
RETVAL_FALSE;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|zzdlr", &host, &host_len, &zerrno, &zerrstr, &timeout, &flags, &zcontext) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z/z/dlr", &host, &host_len, &zerrno, &zerrstr, &timeout, &flags, &zcontext) == FAILURE) {
RETURN_FALSE;
}
tv.tv_usec = conv % 1000000;
#endif
if (zerrno) {
- zerrno = Z_REFVAL_P(zerrno);
zval_dtor(zerrno);
ZVAL_LONG(zerrno, 0);
}
if (zerrstr) {
- zerrstr = Z_REFVAL_P(zerrstr);
zval_dtor(zerrstr);
ZVAL_EMPTY_STRING(zerrstr);
}
RETVAL_FALSE;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|zzlr", &host, &host_len, &zerrno, &zerrstr, &flags, &zcontext) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z/z/lr", &host, &host_len, &zerrno, &zerrstr, &flags, &zcontext) == FAILURE) {
RETURN_FALSE;
}
char *errstr = NULL;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|dz", &zstream, &timeout, &zpeername) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|dz/", &zstream, &timeout, &zpeername) == FAILURE) {
RETURN_FALSE;
}
long flags = 0;
int recvd;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl|lz", &zstream, &to_read, &flags, &zremote) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl|lz/", &zstream, &to_read, &flags, &zremote) == FAILURE) {
RETURN_FALSE;
}
long usec = 0;
int set_count, max_set_count = 0;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a!a!a!z!|l", &r_array, &w_array, &e_array, &sec, &usec) == FAILURE)
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a/!a/!a/!z!|l", &r_array, &w_array, &e_array, &sec, &usec) == FAILURE)
return;
FD_ZERO(&rfds);
HashPosition pos_from, pos_repl, pos_len;
zval *tmp_str = NULL, *tmp_from = NULL, *tmp_repl = NULL, *tmp_len= NULL;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz|z", &str, &repl, &from, &len) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz|z/", &str, &repl, &from, &len) == FAILURE) {
return;
}
if (Z_TYPE_P(str) != IS_ARRAY) {
- SEPARATE_ZVAL_IF_REF(str);
convert_to_string_ex(str);
}
if (Z_TYPE_P(repl) != IS_ARRAY) {
- SEPARATE_ZVAL_IF_REF(repl);
convert_to_string_ex(repl);
}
if (Z_TYPE_P(from) != IS_ARRAY) {
- SEPARATE_ZVAL_IF_REF(from);
convert_to_long_ex(from);
}
if (argc > 3) {
- SEPARATE_ZVAL(len);
if (Z_TYPE_P(len) != IS_ARRAY) {
l = zval_get_long(len);
}
int sim;
int t1_len, t2_len;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|z", &t1, &t1_len, &t2, &t2_len, &percent) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|z/", &t1, &t1_len, &t2, &t2_len, &percent) == FAILURE) {
return;
}
if (ac > 2) {
- percent = Z_REFVAL_P(percent);
convert_to_double_ex(percent);
}
int count = 0;
int argc = ZEND_NUM_ARGS();
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz|z", &search, &replace, &subject, &zcount) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz|z/", &search, &replace, &subject, &zcount) == FAILURE) {
return;
}
php_str_replace_in_subject(search, replace, subject, return_value, case_sensitivity, (argc > 3) ? &count : NULL TSRMLS_CC);
}
if (argc > 3) {
- zval_dtor(Z_REFVAL_P(zcount));
- ZVAL_LONG(Z_REFVAL_P(zcount), count);
+ zval_dtor(zcount);
+ ZVAL_LONG(zcount, count);
}
}
/* }}} */
char *res = NULL;
int arglen;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z", &arg, &arglen, &arrayArg) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z/", &arg, &arglen, &arrayArg) == FAILURE) {
return;
}
} else {
zval ret;
- array_init(&ret);
- sapi_module.treat_data(PARSE_STRING, res, &ret TSRMLS_CC);
/* Clear out the array that was passed in. */
- ZVAL_DEREF(arrayArg);
zval_dtor(arrayArg);
+ array_init(&ret);
+ sapi_module.treat_data(PARSE_STRING, res, &ret TSRMLS_CC);
ZVAL_COPY_VALUE(arrayArg, &ret);
}
}
}
ZVAL_DEREF(var);
+ SEPARATE_ZVAL_NOREF(var);
if (!strcasecmp(type, "integer")) {
convert_to_long(var);
} else if (!strcasecmp(type, "int")) {
zend_bool syntax_only = 0;
int check_flags = 0;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|bz", &var,
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|bz/", &var,
&syntax_only, &callable_name) == FAILURE) {
return;
}
check_flags |= IS_CALLABLE_CHECK_SYNTAX_ONLY;
}
if (ZEND_NUM_ARGS() > 2) {
- ZVAL_DEREF(callable_name);
retval = zend_is_callable_ex(var, NULL, check_flags, &name, NULL, &error TSRMLS_CC);
zval_dtor(callable_name);
//??? is it necessary to be consistent with old PHP ("\0" support)
break;
case IS_ARRAY:
myht = Z_ARRVAL_P(struc);
- if (ZEND_HASH_APPLY_PROTECTION(myht) && ++myht->u.v.nApplyCount > 1) {
+ if (level > 1 && ZEND_HASH_APPLY_PROTECTION(myht) && ++myht->u.v.nApplyCount > 1) {
PUTS("*RECURSION*\n");
--myht->u.v.nApplyCount;
return;
ZEND_HASH_FOREACH_KEY_VAL_IND(myht, num, key, val) {
php_array_element_dump(val, num, key, level TSRMLS_CC);
} ZEND_HASH_FOREACH_END();
- if (ZEND_HASH_APPLY_PROTECTION(myht)) {
+ if (level > 1 && ZEND_HASH_APPLY_PROTECTION(myht)) {
--myht->u.v.nApplyCount;
}
if (is_temp) {
break;
case IS_ARRAY:
myht = Z_ARRVAL_P(struc);
- if (ZEND_HASH_APPLY_PROTECTION(myht) && myht->u.v.nApplyCount++ > 1) {
+ if (level > 1 && ZEND_HASH_APPLY_PROTECTION(myht) && myht->u.v.nApplyCount++ > 1) {
myht->u.v.nApplyCount--;
PUTS("*RECURSION*\n");
return;
ZEND_HASH_FOREACH_KEY_VAL_IND(myht, index, key, val) {
zval_array_element_dump(val, index, key, level TSRMLS_CC);
} ZEND_HASH_FOREACH_END();
- if (ZEND_HASH_APPLY_PROTECTION(myht)) {
+ if (level > 1 && ZEND_HASH_APPLY_PROTECTION(myht)) {
myht->u.v.nApplyCount--;
}
if (is_temp) {
php_unserialize_data_t var_hash;
zval *consumed = NULL;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z", &buf, &buf_len, &consumed) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z/", &buf, &buf_len, &consumed) == FAILURE) {
RETURN_FALSE;
}
}
PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
- if (consumed && Z_ISREF_P(consumed)) {
- zval_dtor(Z_REFVAL_P(consumed));
- ZVAL_LONG(Z_REFVAL_P(consumed), ((char*)p) - buf);
+ if (consumed) {
+ zval_dtor(consumed);
+ ZVAL_LONG(consumed, ((char*)p) - buf);
}
}
/* }}} */
RETVAL_FALSE;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlzlz|blz",
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlz/lz/|blz/",
&queue, &desiredmsgtype, &out_msgtype, &maxsize,
&out_message, &do_unserialize, &flags, &zerrcode) == FAILURE) {
return;
result = msgrcv(mq->id, messagebuffer, maxsize, desiredmsgtype, realflags);
- ZVAL_DEREF(out_msgtype);
- ZVAL_DEREF(out_message);
zval_dtor(out_msgtype);
zval_dtor(out_message);
ZVAL_LONG(out_msgtype, 0);
RETVAL_FALSE;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlz|bbz",
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlz|bbz/",
&queue, &msgtype, &message, &do_serialize, &blocking, &zerror) == FAILURE) {
return;
}
if (result == -1) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "msgsnd failed: %s", strerror(errno));
if (zerror) {
- ZVAL_DEREF(zerror);
ZVAL_LONG(zerror, errno);
}
} else {
xml_parser *parser;
zval *pind, *mythis;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ro", &pind, &mythis) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ro/", &pind, &mythis) == FAILURE) {
return;
}
char *data;
int data_len, ret;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsz|z", &pind, &data, &data_len, &xdata, &info) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsz/|z/", &pind, &data, &data_len, &xdata, &info) == FAILURE) {
return;
}
if (info) {
- ZVAL_DEREF(info);
zval_ptr_dtor(info);
array_init(info);
}
ZEND_FETCH_RESOURCE(parser, xml_parser *, pind, -1, "XML Parser", le_xml_parser);
- ZVAL_DEREF(xdata);
zval_ptr_dtor(xdata);
array_init(xdata);
zval *method;
int xml_len, encoding_len = 0;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|s", &xml, &xml_len, &method, &encoding, &encoding_len) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz/|s", &xml, &xml_len, &method, &encoding, &encoding_len) == FAILURE) {
return;
}
- ZVAL_DEREF(method);
-
if (USED_RET()) {
decode_request_worker(xml, xml_len, encoding_len ? encoding : NULL, method, return_value);
}
int type_len;
XMLRPC_VALUE_TYPE vtype;
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zs", &arg, &type, &type_len) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z/s", &arg, &type, &type_len) == FAILURE) {
return;
}
- ZVAL_DEREF(arg);
-
vtype = xmlrpc_str_as_type(type);
if (vtype != xmlrpc_none) {
if (set_zval_xmlrpc_type(arg, vtype) == SUCCESS) {
ZIP_FROM_OBJECT(intern, self);
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szz|l",
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz/z/|l",
&name, &name_len, &z_opsys, &z_attr, &flags) == FAILURE) {
return;
}
(zip_flags_t)flags, &opsys, &attr) < 0) {
RETURN_FALSE;
}
- ZVAL_DEREF(z_opsys);
zval_ptr_dtor(z_opsys);
ZVAL_LONG(z_opsys, opsys);
- ZVAL_DEREF(z_attr);
zval_ptr_dtor(z_attr);
ZVAL_LONG(z_attr, attr);
RETURN_TRUE;
ZIP_FROM_OBJECT(intern, self);
- if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lzz|l",
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lz/z/|l",
&index, &z_opsys, &z_attr, &flags) == FAILURE) {
return;
}
(zip_flags_t)flags, &opsys, &attr) < 0) {
RETURN_FALSE;
}
- ZVAL_DEREF(z_opsys);
zval_dtor(z_opsys);
ZVAL_LONG(z_opsys, opsys);
- ZVAL_DEREF(z_attr);
zval_dtor(z_attr);
ZVAL_LONG(z_attr, attr);
RETURN_TRUE;
projects / php / commitdiff