switch (Z_TYPE_P(expr)) {
case IS_ARRAY:
ZEND_PUTS("Array (");
- if (++Z_ARRVAL_P(expr)->u.v.nApplyCount>1) {
+ if (ZEND_HASH_APPLY_PROTECTION(Z_ARRVAL_P(expr)) &&
+ ++Z_ARRVAL_P(expr)->u.v.nApplyCount>1) {
ZEND_PUTS(" *RECURSION*");
Z_ARRVAL_P(expr)->u.v.nApplyCount--;
return;
}
print_flat_hash(Z_ARRVAL_P(expr) TSRMLS_CC);
ZEND_PUTS(")");
- Z_ARRVAL_P(expr)->u.v.nApplyCount--;
+ if (ZEND_HASH_APPLY_PROTECTION(Z_ARRVAL_P(expr))) {
+ Z_ARRVAL_P(expr)->u.v.nApplyCount--;
+ }
break;
case IS_OBJECT:
{
switch (Z_TYPE_P(expr)) {
case IS_ARRAY:
ZEND_PUTS_EX("Array\n");
- if (++Z_ARRVAL_P(expr)->u.v.nApplyCount>1) {
+ if (ZEND_HASH_APPLY_PROTECTION(Z_ARRVAL_P(expr)) &&
+ ++Z_ARRVAL_P(expr)->u.v.nApplyCount>1) {
ZEND_PUTS_EX(" *RECURSION*");
Z_ARRVAL_P(expr)->u.v.nApplyCount--;
return;
}
print_hash(write_func, Z_ARRVAL_P(expr), indent, 0 TSRMLS_CC);
- Z_ARRVAL_P(expr)->u.v.nApplyCount--;
+ if (ZEND_HASH_APPLY_PROTECTION(Z_ARRVAL_P(expr))) {
+ Z_ARRVAL_P(expr)->u.v.nApplyCount--;
+ }
break;
case IS_OBJECT:
{
zval_copy_ctor_func(_zv); \
} \
} \
+ } else if (Z_IMMUTABLE_P(_zv)) { \
+ zval_copy_ctor_func(_zv); \
} \
} while (0)
#define SEPARATE_ZVAL_IF_NOT_REF(zv) do { \
zval *_zv = (zv); \
- if (!Z_ISREF_P(_zv) && \
- Z_COPYABLE_P(_zv) && \
- Z_REFCOUNT_P(_zv) > 1) { \
- Z_DELREF_P(_zv); \
- zval_copy_ctor_func(_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); \
+ } else if (Z_IMMUTABLE_P(_zv)) { \
+ zval_copy_ctor_func(_zv); \
+ } \
+ } \
} while (0)
#define SEPARATE_ZVAL_IF_REF(zv) do { \
#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) { \
- ZVAL_NEW_REF(__zv, __zv); \
- } else { \
+ if (Z_COPYABLE_P(__zv) && \
+ Z_REFCOUNT_P(__zv) > 1) { \
Z_DELREF_P(__zv); \
- ZVAL_NEW_REF(__zv, __zv); \
- zval_copy_ctor_func(Z_REFVAL_P(__zv)); \
+ zval_copy_ctor_func(__zv); \
} \
+ ZVAL_NEW_REF(__zv, __zv); \
} \
} while (0)
void zend_do_end_array(znode *result, const znode *array_node TSRMLS_DC) /* {{{ */
{
+ int next_op_num = get_next_op_number(CG(active_op_array));
zend_op *init_opline = &CG(active_op_array)->opcodes[array_node->u.op.opline_num];
- GET_NODE(result, init_opline->result);
+ zend_op *opline;
+ int i;
+ int constant_array = 0;
+ zval array;
+ zend_constant *c;
+
+ /* check if constructed array consists only from constants */
+ if ((init_opline->op1_type & (IS_UNUSED | IS_CONST)) &&
+ (init_opline->op2_type & (IS_UNUSED | IS_CONST))) {
+ if (next_op_num == array_node->u.op.opline_num + 1) {
+ constant_array = 1;
+ } else if ((init_opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT) == next_op_num - array_node->u.op.opline_num) {
+ opline = init_opline + 1;
+ i = next_op_num - array_node->u.op.opline_num - 1;
+ while (i > 0) {
+ if (opline->opcode != ZEND_ADD_ARRAY_ELEMENT ||
+ opline->op1_type != IS_CONST ||
+ !(opline->op2_type & (IS_UNUSED | IS_CONST))) {
+ break;
+ }
+ opline++;
+ i--;
+ }
+ if (i == 0) {
+ constant_array = 1;
+ }
+ }
+ }
+
+ if (constant_array) {
+ /* try to construct constant array */
+ zend_uint size;
+ long num;
+ zend_string *str;
+
+ if (init_opline->op1_type != IS_UNUSED) {
+ size = init_opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
+ } else {
+ size = 0;
+ }
+ ZVAL_NEW_ARR(&array);
+ zend_hash_init(Z_ARRVAL(array), size, NULL, ZVAL_PTR_DTOR, 0);
+
+ if (init_opline->op1_type != IS_UNUSED) {
+ /* Explicitly initialize array as not-packed if flag is set */
+ if (init_opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+ zend_hash_real_init(Z_ARRVAL(array), 0);
+ }
+
+ opline = init_opline;
+ i = next_op_num - array_node->u.op.opline_num;
+ while (i > 0 && constant_array) {
+ if (opline->op2_type == IS_CONST) {
+ switch (Z_TYPE(CONSTANT(opline->op2.constant))) {
+ case IS_LONG:
+ num = Z_LVAL(CONSTANT(opline->op2.constant));
+num_index:
+ zend_hash_index_update(Z_ARRVAL(array), num, &CONSTANT(opline->op1.constant));
+ if (Z_REFCOUNTED(CONSTANT(opline->op1.constant))) Z_ADDREF(CONSTANT(opline->op1.constant));
+ break;
+ case IS_STRING:
+ str = Z_STR(CONSTANT(opline->op2.constant));
+str_index:
+ zend_hash_update(Z_ARRVAL(array), str, &CONSTANT(opline->op1.constant));
+ if (Z_REFCOUNTED(CONSTANT(opline->op1.constant))) Z_ADDREF(CONSTANT(opline->op1.constant));
+ break;
+ case IS_DOUBLE:
+ num = zend_dval_to_lval(Z_DVAL(CONSTANT(opline->op2.constant)));
+ goto num_index;
+ case IS_FALSE:
+ num = 0;
+ goto num_index;
+ case IS_TRUE:
+ num = 1;
+ goto num_index;
+ case IS_NULL:
+ str = STR_EMPTY_ALLOC();
+ goto str_index;
+ default:
+ constant_array = 0;
+ break;
+ }
+ } else {
+ zend_hash_next_index_insert(Z_ARRVAL(array), &CONSTANT(opline->op1.constant));
+ if (Z_REFCOUNTED(CONSTANT(opline->op1.constant))) Z_ADDREF(CONSTANT(opline->op1.constant));
+ }
+ opline++;
+ i--;
+ }
+ if (!constant_array) {
+ zval_dtor(&array);
+ }
+ }
+ }
+
+ if (constant_array) {
+ /* remove run-time array construction and use constant array instead */
+ opline = &CG(active_op_array)->opcodes[next_op_num-1];
+ while (opline != init_opline) {
+ if (opline->op2_type == IS_CONST) {
+ zend_del_literal(CG(active_op_array), opline->op2.constant);
+ }
+ zend_del_literal(CG(active_op_array), opline->op1.constant);
+ opline--;
+ }
+ if (opline->op2_type == IS_CONST) {
+ zend_del_literal(CG(active_op_array), opline->op2.constant);
+ }
+ if (opline->op1_type == IS_CONST) {
+ zend_del_literal(CG(active_op_array), opline->op1.constant);
+ }
+ CG(active_op_array)->last = array_node->u.op.opline_num;
+
+ zend_make_immutable_array(&array TSRMLS_CC);
+
+ result->op_type = IS_CONST;
+ ZVAL_COPY_VALUE(&result->u.constant, &array);
+ } else {
+ GET_NODE(result, init_opline->result);
+ }
}
/* }}} */
}
/* }}} */
+ZEND_API void zend_make_immutable_array(zval *zv TSRMLS_DC) /* {{{ */
+{
+ zend_constant *c;
+
+ if (Z_IMMUTABLE_P(zv)) {
+ return;
+ }
+
+ Z_TYPE_FLAGS_P(zv) = IS_TYPE_IMMUTABLE;
+ Z_ARRVAL_P(zv)->u.flags &= ~HASH_FLAG_APPLY_PROTECTION;
+
+ /* store as an anounimus constant */
+ c = emalloc(sizeof(zend_constant));
+ ZVAL_COPY_VALUE(&c->value, zv);
+ c->flags = 0;
+ c->name = NULL;
+ c->module_number = PHP_USER_CONSTANT;
+ zend_hash_next_index_insert_ptr(EG(zend_constants), c);
+}
+/* }}} */
+
+void zend_make_immutable_array_r(zval *zv TSRMLS_DC) /* {{{ */
+{
+ zval *el;
+
+ if (Z_IMMUTABLE_P(zv)) {
+ return;
+ }
+ zend_make_immutable_array(zv TSRMLS_CC);
+ ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(zv), el) {
+ if (Z_TYPE_P(el) == IS_ARRAY) {
+ zend_make_immutable_array_r(el TSRMLS_CC);
+ }
+ } ZEND_HASH_FOREACH_END();
+}
+/* }}} */
+
void zend_do_constant_expression(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
{
if (ast->kind == ZEND_CONST) {
} else if (zend_ast_is_ct_constant(ast)) {
zend_ast_evaluate(&result->u.constant, ast, NULL TSRMLS_CC);
zend_ast_destroy(ast);
+ if (Z_TYPE(result->u.constant) == IS_ARRAY) {
+ zend_make_immutable_array_r(&result->u.constant TSRMLS_CC);
+ }
} else {
ZVAL_NEW_AST(&result->u.constant, ast);
}
typedef int (*binary_op_type)(zval *, zval *, zval * TSRMLS_DC);
ZEND_API unary_op_type get_unary_op(int opcode);
ZEND_API binary_op_type get_binary_op(int opcode);
+ZEND_API void zend_make_immutable_array(zval *zv TSRMLS_DC);
void zend_do_while_cond(znode *expr, znode *close_bracket_token TSRMLS_DC);
void zend_do_while_end(const znode *while_token, const znode *close_bracket_token TSRMLS_DC);
zend_constant *c = Z_PTR_P(zv);
if (!(c->flags & CONST_PERSISTENT)) {
- zval_dtor(&c->value);
+ if (Z_REFCOUNTED(c->value) || Z_IMMUTABLE(c->value)) {
+ _zval_dtor_func(Z_COUNTED(c->value) ZEND_FILE_LINE_CC);
+ }
} else {
zval_internal_dtor(&c->value);
}
ZVAL_DEREF(container);
if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
- if (container == container_ptr) {
+ if (Z_IMMUTABLE_P(container)) {
+ zval_copy_ctor(container);
+ } else if (container == container_ptr) {
SEPARATE_ZVAL(container);
}
fetch_from_array:
target->nTableSize = source->nTableSize;
target->pDestructor = source->pDestructor;
target->nInternalPointer = INVALID_IDX;
- target->u.flags = (source->u.flags & ~HASH_FLAG_PERSISTENT);
+ target->u.flags = (source->u.flags & ~HASH_FLAG_PERSISTENT) | HASH_FLAG_APPLY_PROTECTION;
target_idx = 0;
if (target->nTableMask) {
_key = _p->key; \
_val = _z;
+#define ZEND_HASH_APPLY_PROTECTION(ht) \
+ ((ht)->u.flags & HASH_FLAG_APPLY_PROTECTION)
+
#define ZEND_HASH_APPLY_SHIFT 8
-#define ZEND_HASH_GET_APPLY_COUNT(ht) (ht->u.flags >> ZEND_HASH_APPLY_SHIFT)
-#define ZEND_HASH_INC_APPLY_COUNT(ht) (ht->u.flags += (1 << ZEND_HASH_APPLY_SHIFT))
-#define ZEND_HASH_DEC_APPLY_COUNT(ht) (ht->u.flags -= (1 << ZEND_HASH_APPLY_SHIFT))
+#define ZEND_HASH_GET_APPLY_COUNT(ht) ((ht)->u.flags >> ZEND_HASH_APPLY_SHIFT)
+#define ZEND_HASH_INC_APPLY_COUNT(ht) ((ht)->u.flags += (1 << ZEND_HASH_APPLY_SHIFT))
+#define ZEND_HASH_DEC_APPLY_COUNT(ht) ((ht)->u.flags -= (1 << ZEND_HASH_APPLY_SHIFT))
#endif /* ZEND_HASH_H */
#define IS_TYPE_REFCOUNTED (1<<1)
#define IS_TYPE_COLLECTABLE (1<<2)
#define IS_TYPE_COPYABLE (1<<3)
+#define IS_TYPE_IMMUTABLE (1<<4)
/* extended types */
#define IS_INTERNED_STRING_EX IS_STRING
#define Z_COPYABLE(zval) ((Z_TYPE_FLAGS(zval) & IS_TYPE_COPYABLE) != 0)
#define Z_COPYABLE_P(zval_p) Z_COPYABLE(*(zval_p))
+#define Z_IMMUTABLE(zval) ((Z_TYPE_FLAGS(zval) & IS_TYPE_IMMUTABLE) != 0)
+#define Z_IMMUTABLE_P(zval_p) Z_IMMUTABLE(*(zval_p))
+
/* the following Z_OPT_* macros make better code when Z_TYPE_INFO accessed before */
#define Z_OPT_TYPE(zval) (Z_TYPE_INFO(zval) & 0xff)
#define Z_OPT_TYPE_P(zval_p) Z_OPT_TYPE(*(zval_p))
#define Z_OPT_COPYABLE(zval) ((Z_TYPE_INFO(zval) & (IS_TYPE_COPYABLE << Z_TYPE_FLAGS_SHIFT)) != 0)
#define Z_OPT_COPYABLE_P(zval_p) Z_OPT_COPYABLE(*(zval_p))
+#define Z_OPT_IMMUTABLE(zval) ((Z_TYPE_INFO(zval) & (IS_TYPE_IMMUTABLE << Z_TYPE_FLAGS_SHIFT)) != 0)
+#define Z_OPT_IMMUTABLE_P(zval_p) Z_OPT_IMMUTABLE(*(zval_p))
+
#define Z_ISREF(zval) (Z_TYPE(zval) == IS_REFERENCE)
#define Z_ISREF_P(zval_p) Z_ISREF(*(zval_p))
static zend_always_inline void _zval_copy_ctor(zval *zvalue ZEND_FILE_LINE_DC)
{
- if (Z_REFCOUNTED_P(zvalue)) {
- if (Z_COPYABLE_P(zvalue)) {
+ if (Z_REFCOUNTED_P(zvalue) || Z_IMMUTABLE_P(zvalue)) {
+ if (Z_COPYABLE_P(zvalue) || Z_IMMUTABLE_P(zvalue)) {
_zval_copy_ctor_func(zvalue ZEND_FILE_LINE_RELAY_CC);
} else {
Z_ADDREF_P(zvalue);
static zend_always_inline void _zval_opt_copy_ctor(zval *zvalue ZEND_FILE_LINE_DC)
{
- if (Z_OPT_REFCOUNTED_P(zvalue)) {
- if (Z_OPT_COPYABLE_P(zvalue)) {
+ if (Z_OPT_REFCOUNTED_P(zvalue) || Z_OPT_IMMUTABLE_P(zvalue)) {
+ if (Z_OPT_COPYABLE_P(zvalue) || Z_OPT_IMMUTABLE_P(zvalue)) {
_zval_copy_ctor_func(zvalue ZEND_FILE_LINE_RELAY_CC);
} else {
Z_ADDREF_P(zvalue);
top = zend_vm_stack_top_inc(TSRMLS_C);
ZVAL_COPY_VALUE(top, value);
if (OP1_TYPE == IS_CONST) {
- zval_opt_copy_ctor(top);
+ /* Immutable arrays may be passed without copying ??? */
+ /* some internal functions may try to modify them !!! */
+ if (!Z_OPT_IMMUTABLE_P(top)) {
+ zval_opt_copy_ctor(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_DUP(top, Z_REFVAL_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 !!! */
+ if (!Z_OPT_IMMUTABLE_P(top)) {
+ zval_opt_copy_ctor(top);
+ }
FREE_OP1();
} else {
ZVAL_COPY_VALUE(top, varptr);
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));
+ }
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);
- ZVAL_COPY_VALUE(top, varptr);
- zval_opt_copy_ctor(top);
+ // TODO: Try to avoid copying of immutable arrays ???
+ ZVAL_DUP(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 &&
ZVAL_COPY_VALUE(top, varptr);
SEPARATE_ZVAL_TO_MAKE_IS_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);
Z_ADDREF_P(varptr);
ZVAL_COPY_VALUE(top, varptr);
varptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
top = zend_vm_stack_top_inc(TSRMLS_C);
if (Z_ISREF_P(varptr)) {
- ZVAL_DUP(top, Z_REFVAL_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 !!! */
+ if (!Z_OPT_IMMUTABLE_P(top)) {
+ zval_opt_copy_ctor(top);
+ }
FREE_OP1();
} else {
ZVAL_COPY_VALUE(top, varptr);
ZEND_VM_STACK_GROW_IF_NEEDED(zend_hash_num_elements(ht));
+ if (OP1_TYPE != IS_CONST && OP1_TYPE != IS_TMP_VAR && Z_IMMUTABLE_P(args)) {
+ int i;
+ int separate = 0;
+
+ /* check if any of arguments are going to be passed by reference */
+ for (i = 0; i < zend_hash_num_elements(ht); i++) {
+ if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, arg_num + i)) {
+ separate = 1;
+ break;
+ }
+ }
+ if (separate) {
+ zval_copy_ctor(args);
+ ht = Z_ARRVAL_P(args);
+ }
+ }
+
ZEND_HASH_FOREACH_STR_KEY_VAL(ht, name, arg) {
if (name) {
zend_error(E_RECOVERABLE_ERROR, "Cannot unpack array with string keys");
top = zend_vm_stack_top_inc(TSRMLS_C);
if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, arg_num)) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(arg);
- Z_ADDREF_P(arg);
- ZVAL_COPY_VALUE(top, arg);
+ if (!Z_IMMUTABLE_P(args)) {
+ SEPARATE_ZVAL_TO_MAKE_IS_REF(arg);
+ Z_ADDREF_P(arg);
+ ZVAL_COPY_VALUE(top, arg);
+ } else {
+ ZVAL_DUP(top, arg);
+ }
} else if (Z_ISREF_P(arg)) {
ZVAL_DUP(top, Z_REFVAL_P(arg));
} else {
{
USE_OPLINE
zend_free_op free_op1;
- zval *array_ptr, *array_ref, iterator;
+ zval *array_ptr, *array_ref, iterator, tmp;
HashTable *fe_ht;
zend_object_iterator *iter = NULL;
zend_class_entry *ce = NULL;
array_ref = array_ptr;
array_ptr = Z_REFVAL_P(array_ptr);
}
+ } else if (Z_IMMUTABLE_P(array_ptr)) {
+ zval_copy_ctor(array_ptr);
}
if (Z_REFCOUNTED_P(array_ref)) Z_ADDREF_P(array_ref);
} else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
array_ptr = array_ref = GET_OP1_ZVAL_PTR(BP_VAR_R);
ZVAL_DEREF(array_ptr);
if (IS_OP1_TMP_FREE()) { /* IS_TMP_VAR */
- zval tmp;
-
ZVAL_COPY_VALUE(&tmp, array_ptr);
array_ptr = &tmp;
if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
Z_ADDREF_P(array_ref);
}
}
+ } else if (Z_IMMUTABLE_P(array_ref)) {
+ if (OP1_TYPE == IS_CV) {
+ zval_copy_ctor(array_ref);
+ Z_ADDREF_P(array_ref);
+ } else {
+ ZVAL_DUP(&tmp, array_ref);
+ array_ptr = array_ref = &tmp;
+ }
} else if (Z_REFCOUNTED_P(array_ref)) {
if (OP1_TYPE == IS_CONST ||
(OP1_TYPE == IS_CV &&
(OP1_TYPE == IS_VAR &&
!Z_ISREF_P(array_ref) &&
Z_REFCOUNT_P(array_ref) > 2)) {
- zval tmp;
-
if (OP1_TYPE == IS_VAR) {
Z_DELREF_P(array_ref);
}
ZVAL_UNREF(array_ref);
array_ptr = array_ref;
}
+ if (Z_IMMUTABLE_P(array_ptr)) {
+ zval_copy_ctor(array_ptr);
+ }
Z_ADDREF_P(array_ref);
}
}
ZEND_VM_STACK_GROW_IF_NEEDED(zend_hash_num_elements(ht));
+ if (opline->op1_type != IS_CONST && opline->op1_type != IS_TMP_VAR && Z_IMMUTABLE_P(args)) {
+ int i;
+ int separate = 0;
+
+ /* check if any of arguments are going to be passed by reference */
+ for (i = 0; i < zend_hash_num_elements(ht); i++) {
+ if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, arg_num + i)) {
+ separate = 1;
+ break;
+ }
+ }
+ if (separate) {
+ zval_copy_ctor(args);
+ ht = Z_ARRVAL_P(args);
+ }
+ }
+
ZEND_HASH_FOREACH_STR_KEY_VAL(ht, name, arg) {
if (name) {
zend_error(E_RECOVERABLE_ERROR, "Cannot unpack array with string keys");
top = zend_vm_stack_top_inc(TSRMLS_C);
if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, arg_num)) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(arg);
- Z_ADDREF_P(arg);
- ZVAL_COPY_VALUE(top, arg);
+ if (!Z_IMMUTABLE_P(args)) {
+ SEPARATE_ZVAL_TO_MAKE_IS_REF(arg);
+ Z_ADDREF_P(arg);
+ ZVAL_COPY_VALUE(top, arg);
+ } else {
+ ZVAL_DUP(top, arg);
+ }
} else if (Z_ISREF_P(arg)) {
ZVAL_DUP(top, Z_REFVAL_P(arg));
} else {
top = zend_vm_stack_top_inc(TSRMLS_C);
ZVAL_COPY_VALUE(top, value);
if (IS_CONST == IS_CONST) {
- zval_opt_copy_ctor(top);
+ /* Immutable arrays may be passed without copying ??? */
+ /* some internal functions may try to modify them !!! */
+ if (!Z_OPT_IMMUTABLE_P(top)) {
+ zval_opt_copy_ctor(top);
+ }
}
ZEND_VM_NEXT_OPCODE();
}
{
USE_OPLINE
- zval *array_ptr, *array_ref, iterator;
+ zval *array_ptr, *array_ref, iterator, tmp;
HashTable *fe_ht;
zend_object_iterator *iter = NULL;
zend_class_entry *ce = NULL;
array_ref = array_ptr;
array_ptr = Z_REFVAL_P(array_ptr);
}
+ } else if (Z_IMMUTABLE_P(array_ptr)) {
+ zval_copy_ctor(array_ptr);
}
if (Z_REFCOUNTED_P(array_ref)) Z_ADDREF_P(array_ref);
} else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
array_ptr = array_ref = opline->op1.zv;
ZVAL_DEREF(array_ptr);
if (0) { /* IS_TMP_VAR */
- zval tmp;
-
ZVAL_COPY_VALUE(&tmp, array_ptr);
array_ptr = &tmp;
if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
Z_ADDREF_P(array_ref);
}
}
+ } else if (Z_IMMUTABLE_P(array_ref)) {
+ if (IS_CONST == IS_CV) {
+ zval_copy_ctor(array_ref);
+ Z_ADDREF_P(array_ref);
+ } else {
+ ZVAL_DUP(&tmp, array_ref);
+ array_ptr = array_ref = &tmp;
+ }
} else if (Z_REFCOUNTED_P(array_ref)) {
if (IS_CONST == IS_CONST ||
(IS_CONST == IS_CV &&
(IS_CONST == IS_VAR &&
!Z_ISREF_P(array_ref) &&
Z_REFCOUNT_P(array_ref) > 2)) {
- zval tmp;
-
if (IS_CONST == IS_VAR) {
Z_DELREF_P(array_ref);
}
ZVAL_UNREF(array_ref);
array_ptr = array_ref;
}
+ if (Z_IMMUTABLE_P(array_ptr)) {
+ zval_copy_ctor(array_ptr);
+ }
Z_ADDREF_P(array_ref);
}
}
top = zend_vm_stack_top_inc(TSRMLS_C);
ZVAL_COPY_VALUE(top, value);
if (IS_TMP_VAR == IS_CONST) {
- zval_opt_copy_ctor(top);
+ /* Immutable arrays may be passed without copying ??? */
+ /* some internal functions may try to modify them !!! */
+ if (!Z_OPT_IMMUTABLE_P(top)) {
+ zval_opt_copy_ctor(top);
+ }
}
ZEND_VM_NEXT_OPCODE();
}
{
USE_OPLINE
zend_free_op free_op1;
- zval *array_ptr, *array_ref, iterator;
+ zval *array_ptr, *array_ref, iterator, tmp;
HashTable *fe_ht;
zend_object_iterator *iter = NULL;
zend_class_entry *ce = NULL;
array_ref = array_ptr;
array_ptr = Z_REFVAL_P(array_ptr);
}
+ } else if (Z_IMMUTABLE_P(array_ptr)) {
+ zval_copy_ctor(array_ptr);
}
if (Z_REFCOUNTED_P(array_ref)) Z_ADDREF_P(array_ref);
} else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
array_ptr = array_ref = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
ZVAL_DEREF(array_ptr);
if (1) { /* IS_TMP_VAR */
- zval tmp;
-
ZVAL_COPY_VALUE(&tmp, array_ptr);
array_ptr = &tmp;
if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
Z_ADDREF_P(array_ref);
}
}
+ } else if (Z_IMMUTABLE_P(array_ref)) {
+ if (IS_TMP_VAR == IS_CV) {
+ zval_copy_ctor(array_ref);
+ Z_ADDREF_P(array_ref);
+ } else {
+ ZVAL_DUP(&tmp, array_ref);
+ array_ptr = array_ref = &tmp;
+ }
} else if (Z_REFCOUNTED_P(array_ref)) {
if (IS_TMP_VAR == IS_CONST ||
(IS_TMP_VAR == IS_CV &&
(IS_TMP_VAR == IS_VAR &&
!Z_ISREF_P(array_ref) &&
Z_REFCOUNT_P(array_ref) > 2)) {
- zval tmp;
-
if (IS_TMP_VAR == IS_VAR) {
Z_DELREF_P(array_ref);
}
ZVAL_UNREF(array_ref);
array_ptr = array_ref;
}
+ if (Z_IMMUTABLE_P(array_ptr)) {
+ zval_copy_ctor(array_ptr);
+ }
Z_ADDREF_P(array_ref);
}
}
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_DUP(top, Z_REFVAL_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 !!! */
+ if (!Z_OPT_IMMUTABLE_P(top)) {
+ zval_opt_copy_ctor(top);
+ }
zval_ptr_dtor_nogc(free_op1.var);
} else {
ZVAL_COPY_VALUE(top, varptr);
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));
+ }
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);
- ZVAL_COPY_VALUE(top, varptr);
- zval_opt_copy_ctor(top);
+ // TODO: Try to avoid copying of immutable arrays ???
+ ZVAL_DUP(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 &&
ZVAL_COPY_VALUE(top, varptr);
SEPARATE_ZVAL_TO_MAKE_IS_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);
Z_ADDREF_P(varptr);
ZVAL_COPY_VALUE(top, varptr);
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_DUP(top, Z_REFVAL_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 !!! */
+ if (!Z_OPT_IMMUTABLE_P(top)) {
+ zval_opt_copy_ctor(top);
+ }
zval_ptr_dtor_nogc(free_op1.var);
} else {
ZVAL_COPY_VALUE(top, varptr);
{
USE_OPLINE
zend_free_op free_op1;
- zval *array_ptr, *array_ref, iterator;
+ zval *array_ptr, *array_ref, iterator, tmp;
HashTable *fe_ht;
zend_object_iterator *iter = NULL;
zend_class_entry *ce = NULL;
array_ref = array_ptr;
array_ptr = Z_REFVAL_P(array_ptr);
}
+ } else if (Z_IMMUTABLE_P(array_ptr)) {
+ zval_copy_ctor(array_ptr);
}
if (Z_REFCOUNTED_P(array_ref)) Z_ADDREF_P(array_ref);
} else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
array_ptr = array_ref = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
ZVAL_DEREF(array_ptr);
if (0) { /* IS_TMP_VAR */
- zval tmp;
-
ZVAL_COPY_VALUE(&tmp, array_ptr);
array_ptr = &tmp;
if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
Z_ADDREF_P(array_ref);
}
}
+ } else if (Z_IMMUTABLE_P(array_ref)) {
+ if (IS_VAR == IS_CV) {
+ zval_copy_ctor(array_ref);
+ Z_ADDREF_P(array_ref);
+ } else {
+ ZVAL_DUP(&tmp, array_ref);
+ array_ptr = array_ref = &tmp;
+ }
} else if (Z_REFCOUNTED_P(array_ref)) {
if (IS_VAR == IS_CONST ||
(IS_VAR == IS_CV &&
(IS_VAR == IS_VAR &&
!Z_ISREF_P(array_ref) &&
Z_REFCOUNT_P(array_ref) > 2)) {
- zval tmp;
-
if (IS_VAR == IS_VAR) {
Z_DELREF_P(array_ref);
}
ZVAL_UNREF(array_ref);
array_ptr = array_ref;
}
+ if (Z_IMMUTABLE_P(array_ptr)) {
+ zval_copy_ctor(array_ptr);
+ }
Z_ADDREF_P(array_ref);
}
}
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_DUP(top, Z_REFVAL_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 !!! */
+ if (!Z_OPT_IMMUTABLE_P(top)) {
+ zval_opt_copy_ctor(top);
+ }
} else {
ZVAL_COPY_VALUE(top, varptr);
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));
+ }
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);
- ZVAL_COPY_VALUE(top, varptr);
- zval_opt_copy_ctor(top);
+ // TODO: Try to avoid copying of immutable arrays ???
+ ZVAL_DUP(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 &&
ZVAL_COPY_VALUE(top, varptr);
SEPARATE_ZVAL_TO_MAKE_IS_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);
Z_ADDREF_P(varptr);
ZVAL_COPY_VALUE(top, varptr);
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_DUP(top, Z_REFVAL_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 !!! */
+ if (!Z_OPT_IMMUTABLE_P(top)) {
+ zval_opt_copy_ctor(top);
+ }
} else {
ZVAL_COPY_VALUE(top, varptr);
{
USE_OPLINE
- zval *array_ptr, *array_ref, iterator;
+ zval *array_ptr, *array_ref, iterator, tmp;
HashTable *fe_ht;
zend_object_iterator *iter = NULL;
zend_class_entry *ce = NULL;
array_ref = array_ptr;
array_ptr = Z_REFVAL_P(array_ptr);
}
+ } else if (Z_IMMUTABLE_P(array_ptr)) {
+ zval_copy_ctor(array_ptr);
}
if (Z_REFCOUNTED_P(array_ref)) Z_ADDREF_P(array_ref);
} else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
array_ptr = array_ref = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
ZVAL_DEREF(array_ptr);
if (0) { /* IS_TMP_VAR */
- zval tmp;
-
ZVAL_COPY_VALUE(&tmp, array_ptr);
array_ptr = &tmp;
if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
Z_ADDREF_P(array_ref);
}
}
+ } else if (Z_IMMUTABLE_P(array_ref)) {
+ if (IS_CV == IS_CV) {
+ zval_copy_ctor(array_ref);
+ Z_ADDREF_P(array_ref);
+ } else {
+ ZVAL_DUP(&tmp, array_ref);
+ array_ptr = array_ref = &tmp;
+ }
} else if (Z_REFCOUNTED_P(array_ref)) {
if (IS_CV == IS_CONST ||
(IS_CV == IS_CV &&
(IS_CV == IS_VAR &&
!Z_ISREF_P(array_ref) &&
Z_REFCOUNT_P(array_ref) > 2)) {
- zval tmp;
-
if (IS_CV == IS_VAR) {
Z_DELREF_P(array_ref);
}
ZVAL_UNREF(array_ref);
array_ptr = array_ref;
}
+ if (Z_IMMUTABLE_P(array_ptr)) {
+ zval_copy_ctor(array_ptr);
+ }
Z_ADDREF_P(array_ref);
}
}
ZEND_HASH_FOREACH_KEY_VAL_IND(myht, index, key, data) {
ZVAL_DEREF(data);
tmp_ht = HASH_OF(data);
- if (tmp_ht) {
+ if (tmp_ht && ZEND_HASH_APPLY_PROTECTION(tmp_ht)) {
ZEND_HASH_INC_APPLY_COUNT(tmp_ht);
}
}
}
- if (tmp_ht) {
+ if (tmp_ht && ZEND_HASH_APPLY_PROTECTION(tmp_ht)) {
ZEND_HASH_DEC_APPLY_COUNT(tmp_ht);
}
} ZEND_HASH_FOREACH_END();
int i = op_array->last_literal;
op_array->last_literal++;
op_array->literals = (zval*)erealloc(op_array->literals, op_array->last_literal * sizeof(zval));
+ if (Z_TYPE_P(zv) == IS_ARRAY) {
+ zend_make_immutable_array(zv TSRMLS_CC);
+ }
ZVAL_COPY_VALUE(&op_array->literals[i], zv);
Z_CACHE_SLOT(op_array->literals[i]) = -1;
//??? Z_SET_REFCOUNT(op_array->literals[i].constant, 2);
if (c->flags & CONST_PERSISTENT) {
return ZEND_HASH_APPLY_STOP;
} else {
- STR_RELEASE(c->name);
return ZEND_HASH_APPLY_REMOVE;
}
}
{
void *ptr;
+ if (Z_IMMUTABLE_P(src)) {
+ return;
+ }
+
#if ZEND_EXTENSION_API_NO >= PHP_5_3_X_API_NO
switch (Z_TYPE_P(src)) {
#else
}
}
+static void zend_hash_persist_immutable(HashTable *ht, zend_persist_func_t pPersistElement TSRMLS_DC)
+{
+ uint idx;
+ Bucket *p;
+
+ if (!ht->nTableMask) {
+ ht->arHash = (zend_uint*)&uninitialized_bucket;
+ return;
+ }
+ if (ht->u.flags & HASH_FLAG_PACKED) {
+ ht->arData = zend_accel_memdup(ht->arData, sizeof(Bucket) * ht->nTableSize);
+ ht->arHash = (zend_uint*)&uninitialized_bucket;
+ } else {
+ ht->arData = zend_accel_memdup(ht->arData, (sizeof(Bucket) + sizeof(zend_uint)) * ht->nTableSize);
+ ht->arHash = (zend_uint*)(ht->arData + ht->nTableSize);
+ }
+ for (idx = 0; idx < ht->nNumUsed; idx++) {
+ p = ht->arData + idx;
+ if (Z_TYPE(p->val) == IS_UNDEF) continue;
+
+ /* persist bucket and key */
+ if (p->key) {
+ zend_accel_store_interned_string(p->key);
+ }
+
+ /* persist the data itself */
+ pPersistElement(&p->val TSRMLS_CC);
+ }
+}
+
#if ZEND_EXTENSION_API_NO > PHP_5_5_X_API_NO
static zend_ast *zend_persist_ast(zend_ast *ast TSRMLS_DC)
{
if (new_ptr) {
Z_ARR_P(z) = new_ptr;
} else {
- zend_accel_store(Z_ARR_P(z), sizeof(zend_array));
- zend_hash_persist(Z_ARRVAL_P(z), zend_persist_zval TSRMLS_CC);
+ if (Z_IMMUTABLE_P(z)) {
+ Z_ARR_P(z) = zend_accel_memdup(Z_ARR_P(z), sizeof(zend_array));
+ zend_hash_persist_immutable(Z_ARRVAL_P(z), zend_persist_zval TSRMLS_CC);
+ } else {
+ zend_accel_store(Z_ARR_P(z), sizeof(zend_array));
+ zend_hash_persist(Z_ARRVAL_P(z), zend_persist_zval TSRMLS_CC);
+ }
}
break;
#if ZEND_EXTENSION_API_NO > PHP_5_5_X_API_NO
cnt = zend_hash_num_elements(Z_ARRVAL_P(array));
if (mode == COUNT_RECURSIVE) {
ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(array), element) {
- Z_ARRVAL_P(array)->u.v.nApplyCount++;
+ 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);
- Z_ARRVAL_P(array)->u.v.nApplyCount--;
+ if (ZEND_HASH_APPLY_PROTECTION(Z_ARRVAL_P(array))) {
+ Z_ARRVAL_P(array)->u.v.nApplyCount--;
+ }
} ZEND_HASH_FOREACH_END();
}
}
return;
}
- Z_ARRVAL_P(entry)->u.v.nApplyCount++;
-
+ if (ZEND_HASH_APPLY_PROTECTION(Z_ARRVAL_P(entry))) {
+ Z_ARRVAL_P(entry)->u.v.nApplyCount++;
+ }
ZEND_HASH_FOREACH_VAL_IND(Z_ARRVAL_P(entry), value_ptr) {
php_compact_var(eg_active_symbol_table, return_value, value_ptr TSRMLS_CC);
} ZEND_HASH_FOREACH_END();
- Z_ARRVAL_P(entry)->u.v.nApplyCount--;
+ if (ZEND_HASH_APPLY_PROTECTION(Z_ARRVAL_P(entry))) {
+ Z_ARRVAL_P(entry)->u.v.nApplyCount--;
+ }
}
}
/* }}} */
zval *dest_zval = dest_entry;
HashTable *thash;
zval tmp;
+ int ret;
ZVAL_DEREF(src_zval);
ZVAL_DEREF(dest_zval);
src_zval = &tmp;
}
if (Z_TYPE_P(src_zval) == IS_ARRAY) {
- if (thash) {
+ if (thash && ZEND_HASH_APPLY_PROTECTION(thash)) {
thash->u.v.nApplyCount++;
}
- if (!php_array_merge(Z_ARRVAL_P(dest_zval), Z_ARRVAL_P(src_zval), 1 TSRMLS_CC)) {
- if (thash) {
- thash->u.v.nApplyCount--;
- }
- return 0;
- }
- if (thash) {
+ ret = php_array_merge(Z_ARRVAL_P(dest_zval), Z_ARRVAL_P(src_zval), 1 TSRMLS_CC);
+ if (thash && ZEND_HASH_APPLY_PROTECTION(thash)) {
thash->u.v.nApplyCount--;
}
+ if (!ret) {
+ return 0;
+ }
} else {
if (Z_REFCOUNTED_P(src_entry)) {
Z_ADDREF_P(src_entry);
if (Z_REFCOUNTED_P(src_entry)) {
Z_ADDREF_P(src_entry);
}
- zend_hash_update(dest, string_key, src_entry);
+ zend_hash_add_new(dest, string_key, src_entry);
}
} else {
if (Z_REFCOUNTED_P(src_entry)) {
zval *src_entry, *dest_entry, *src_zval, *dest_zval;
zend_string *string_key;
ulong num_key;
+ int ret;
ZEND_HASH_FOREACH_KEY_VAL(src, num_key, string_key, src_entry) {
src_zval = src_entry;
return 0;
}
SEPARATE_ZVAL(dest_zval);
- Z_ARRVAL_P(dest_zval)->u.v.nApplyCount++;
- Z_ARRVAL_P(src_zval)->u.v.nApplyCount++;
-
- if (!php_array_replace_recursive(Z_ARRVAL_P(dest_zval), Z_ARRVAL_P(src_zval) TSRMLS_CC)) {
+ if (ZEND_HASH_APPLY_PROTECTION(Z_ARRVAL_P(dest_zval))) {
+ Z_ARRVAL_P(dest_zval)->u.v.nApplyCount++;
+ }
+ if (ZEND_HASH_APPLY_PROTECTION(Z_ARRVAL_P(src_zval))) {
+ Z_ARRVAL_P(src_zval)->u.v.nApplyCount++;
+ }
+
+ ret = php_array_replace_recursive(Z_ARRVAL_P(dest_zval), Z_ARRVAL_P(src_zval) TSRMLS_CC);
+
+ if (ZEND_HASH_APPLY_PROTECTION(Z_ARRVAL_P(dest_zval))) {
Z_ARRVAL_P(dest_zval)->u.v.nApplyCount--;
+ }
+ if (ZEND_HASH_APPLY_PROTECTION(Z_ARRVAL_P(src_zval))) {
Z_ARRVAL_P(src_zval)->u.v.nApplyCount--;
+ }
+
+ if (!ret) {
return 0;
}
- Z_ARRVAL_P(dest_zval)->u.v.nApplyCount--;
- Z_ARRVAL_P(src_zval)->u.v.nApplyCount--;
} ZEND_HASH_FOREACH_END();
return 1;
ZVAL_DEREF(arg);
if (Z_TYPE_P(arg) == IS_ARRAY) {
+ if (Z_IMMUTABLE_P(arg)) {
+ zval_copy_ctor(arg);
+ }
/* We see the next array, so we update the sort flags of
* the previous array and reset the sort flags. */
if (i > 0) {
*(p++) = 'B';
*p = '\0';
}
- ht->u.v.nApplyCount++;
+ if (ZEND_HASH_APPLY_PROTECTION(ht)) {
+ ht->u.v.nApplyCount++;
+ }
php_url_encode_hash_ex(HASH_OF(zdata), formstr, NULL, 0, newprefix, newprefix_len, "%5D", 3, (Z_TYPE_P(zdata) == IS_OBJECT ? zdata : NULL), arg_sep, enc_type TSRMLS_CC);
- ht->u.v.nApplyCount--;
+ if (ZEND_HASH_APPLY_PROTECTION(ht)) {
+ ht->u.v.nApplyCount--;
+ }
efree(newprefix);
} else if (Z_TYPE_P(zdata) == IS_NULL || Z_TYPE_P(zdata) == IS_RESOURCE) {
/* Skip these types */
break;
case IS_ARRAY:
myht = Z_ARRVAL_P(struc);
- if (++myht->u.v.nApplyCount > 1) {
+ if (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();
- --myht->u.v.nApplyCount;
+ if (ZEND_HASH_APPLY_PROTECTION(myht)) {
+ --myht->u.v.nApplyCount;
+ }
if (is_temp) {
zend_hash_destroy(myht);
efree(myht);
break;
case IS_ARRAY:
myht = Z_ARRVAL_P(struc);
- if (myht->u.v.nApplyCount++ > 1) {
+ if (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();
- myht->u.v.nApplyCount--;
+ if (ZEND_HASH_APPLY_PROTECTION(myht)) {
+ myht->u.v.nApplyCount--;
+ }
if (is_temp) {
zend_hash_destroy(myht);
efree(myht);
break;
case IS_ARRAY:
myht = Z_ARRVAL_P(struc);
- if (myht->u.v.nApplyCount++ > 0) {
+ if (ZEND_HASH_APPLY_PROTECTION(myht) && myht->u.v.nApplyCount++ > 0) {
myht->u.v.nApplyCount--;
smart_str_appendl(buf, "NULL", 4);
zend_error(E_WARNING, "var_export does not handle circular references");
ZEND_HASH_FOREACH_KEY_VAL_IND(myht, index, key, val) {
php_array_element_export(val, index, key, level, buf TSRMLS_CC);
} ZEND_HASH_FOREACH_END();
- myht->u.v.nApplyCount--;
+ if (ZEND_HASH_APPLY_PROTECTION(myht)) {
+ myht->u.v.nApplyCount--;
+ }
if (level > 1) {
buffer_append_spaces(buf, level - 1);
}
) {
smart_str_appendl(buf, "N;", 2);
} else {
- if (Z_TYPE_P(data) == IS_ARRAY) {
+ if (Z_TYPE_P(data) == IS_ARRAY && ZEND_HASH_APPLY_PROTECTION(Z_ARRVAL_P(data))) {
Z_ARRVAL_P(data)->u.v.nApplyCount++;
}
php_var_serialize_intern(buf, data, var_hash TSRMLS_CC);
- if (Z_TYPE_P(data) == IS_ARRAY) {
+ if (Z_TYPE_P(data) == IS_ARRAY && ZEND_HASH_APPLY_PROTECTION(Z_ARRVAL_P(data))) {
Z_ARRVAL_P(data)->u.v.nApplyCount--;
}
}
php_error_docref(NULL TSRMLS_CC, E_RECOVERABLE_ERROR, "WDDX doesn't support circular references");
return;
}
- ht->u.v.nApplyCount++;
+ if (ZEND_HASH_APPLY_PROTECTION(ht)) {
+ ht->u.v.nApplyCount++;
+ }
php_wddx_serialize_array(packet, var);
- ht->u.v.nApplyCount--;
+ if (ZEND_HASH_APPLY_PROTECTION(ht)) {
+ ht->u.v.nApplyCount--;
+ }
break;
case IS_OBJECT:
return;
}
- ZEND_HASH_FOREACH_VAL(target_hash, val) {
- if (is_array) {
- target_hash->u.v.nApplyCount++;
- }
+ if (Z_IMMUTABLE_P(name_var)) {
+ ZEND_HASH_FOREACH_VAL(target_hash, val) {
+ php_wddx_add_var(packet, val);
+ } ZEND_HASH_FOREACH_END();
+ } else {
+ ZEND_HASH_FOREACH_VAL(target_hash, val) {
+ if (is_array) {
+ target_hash->u.v.nApplyCount++;
+ }
- ZVAL_DEREF(val);
- php_wddx_add_var(packet, val);
+ ZVAL_DEREF(val);
+ php_wddx_add_var(packet, val);
- if (is_array) {
- target_hash->u.v.nApplyCount--;
- }
- } ZEND_HASH_FOREACH_END();
+ if (is_array) {
+ target_hash->u.v.nApplyCount--;
+ }
+ } ZEND_HASH_FOREACH_END();
+ }
}
}
/* }}} */
projects / php / commitdiff