zval *object;
zval *property = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
- zval tmp;
znode *result = &opline->result;
zval **retval = &EX_T(result->u.var).var.ptr;
int have_get_ptr = 0;
}
} else {
/* here we are sure we are dealing with an object */
- switch (IS_CONST) {
- case IS_CONST:
- /* already a constant string */
- break;
- case IS_CV:
- case IS_VAR:
- tmp = *property;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- property = &tmp;
- break;
- case IS_TMP_VAR:
- convert_to_string(property);
- break;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
}
/* here property is a string */
}
}
- if (property == &tmp) {
- zval_dtor(property);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
}
-
- ;
FREE_OP(free_op_data1);
}
return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
} else {
zend_op *op_data = opline+1;
+ zval *dim = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_RW TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), &free_op_data2, BP_VAR_RW);
increment_opline = 1;
/* here we are sure we are dealing with an object */
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
if (zptr != NULL) { /* NULL means no success in getting PTR */
}
}
- ;
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
}
/* here we are sure we are dealing with an object */
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
if (zptr != NULL) { /* NULL means no success in getting PTR */
}
}
- ;
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_VAR != IS_CV) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
}
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_R TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_R TSRMLS_CC);
;
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_W TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_W TSRMLS_CC);
;
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_RW TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
;
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_IS TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_IS TSRMLS_CC);
;
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
int type = ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)?BP_VAR_W:BP_VAR_R;
+ zval *dim = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), type TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, type TSRMLS_CC);
;
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
/* Not needed in DIM_UNSET
if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
}
*/
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_UNSET TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_UNSET TSRMLS_CC);
;
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
if (EX_T(opline->result.u.var).var.ptr_ptr == NULL) {
if (container->type != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
zend_error(E_NOTICE, "Trying to get property of non-object");
*retval = EG(uninitialized_zval_ptr);
+ SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
+ AI_USE_PTR(EX_T(opline->result.u.var).var);
} else {
zend_free_op free_op2;
zval *offset = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zval tmp;
- switch (IS_CONST) {
- case IS_CONST:
- /* already a constant string */
- break;
- case IS_CV:
- case IS_VAR:
- tmp = *offset;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- offset = &tmp;
- break;
- case IS_TMP_VAR:
- convert_to_string(offset);
- break;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
}
/* here we are sure we are dealing with an object */
*retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
- if (offset == &tmp) {
- zval_dtor(offset);
- }
- ;
if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
zval_dtor(*retval);
FREE_ZVAL(*retval);
- ZEND_VM_NEXT_OPCODE();
+ } else {
+ SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
+ AI_USE_PTR(EX_T(opline->result.u.var).var);
+ }
+
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ ;
}
}
- SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
- AI_USE_PTR(EX_T(opline->result.u.var).var);
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_VAR != IS_CV) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
}
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_CONST, BP_VAR_W TSRMLS_CC);
- ;
+
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_CONST, BP_VAR_RW TSRMLS_CC);
- ;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_RW TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
}
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
/* Behave like FETCH_OBJ_W */
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_CONST, BP_VAR_W TSRMLS_CC);
- ;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
} else {
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2, free_res;
+ zval *property = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_CONST, BP_VAR_R TSRMLS_CC);
- ;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_R TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
} else {
zend_free_op free_op2, free_op_data1;
zval *value;
+ zval *dim = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_W TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 0, BP_VAR_W TSRMLS_CC);
;
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
long index;
if (container) {
- HashTable *ht;
if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
SEPARATE_ZVAL_IF_NOT_REF(container);
}
if (opline->extended_value == ZEND_UNSET_DIM) {
switch (Z_TYPE_PP(container)) {
- case IS_ARRAY:
- ht = Z_ARRVAL_PP(container);
+ case IS_ARRAY: {
+ HashTable *ht = Z_ARRVAL_PP(container);
+
+ switch (offset->type) {
+ case IS_DOUBLE:
+ case IS_RESOURCE:
+ case IS_BOOL:
+ case IS_LONG:
+ if (offset->type == IS_DOUBLE) {
+ index = (long) offset->value.dval;
+ } else {
+ index = offset->value.lval;
+ }
+
+ zend_hash_index_del(ht, index);
+ break;
+ case IS_STRING:
+ if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
+ ht == &EG(symbol_table)) {
+ zend_execute_data *ex;
+ ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
+
+ for (ex = execute_data; ex; ex = ex->prev_execute_data) {
+ if (ex->symbol_table == ht) {
+ int i;
+
+ for (i = 0; i < ex->op_array->last_var; i++) {
+ if (ex->op_array->vars[i].hash_value == hash_value &&
+ ex->op_array->vars[i].name_len == offset->value.str.len &&
+ !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
+ ex->CVs[i] = NULL;
+ break;
+ }
+ }
+ }
+ }
+ }
+ break;
+ case IS_NULL:
+ zend_hash_del(ht, "", sizeof(""));
+ break;
+ default:
+ zend_error(E_WARNING, "Illegal offset type in unset");
+ break;
+ }
+ ;
break;
+ }
case IS_OBJECT:
- ht = NULL;
if (!Z_OBJ_HT_P(*container)->unset_dimension) {
zend_error_noreturn(E_ERROR, "Cannot use object as array");
}
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ ;
+ }
break;
case IS_STRING:
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
ZEND_VM_CONTINUE(); /* bailed out before */
default:
- ht = NULL;
+ ;
break;
}
} else { /* ZEND_UNSET_OBJ */
- ht = NULL;
if (Z_TYPE_PP(container) == IS_OBJECT) {
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
- }
- }
- if (ht) {
- switch (offset->type) {
- case IS_DOUBLE:
- case IS_RESOURCE:
- case IS_BOOL:
- case IS_LONG:
- if (offset->type == IS_DOUBLE) {
- index = (long) offset->value.dval;
- } else {
- index = offset->value.lval;
- }
-
- zend_hash_index_del(ht, index);
- break;
- case IS_STRING:
- if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
- ht == &EG(symbol_table)) {
- zend_execute_data *ex;
- ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
-
- for (ex = execute_data; ex; ex = ex->prev_execute_data) {
- if (ex->symbol_table == ht) {
- int i;
-
- for (i = 0; i < ex->op_array->last_var; i++) {
- if (ex->op_array->vars[i].hash_value == hash_value &&
- ex->op_array->vars[i].name_len == offset->value.str.len &&
- !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
- ex->CVs[i] = NULL;
- break;
- }
- }
- }
- }
- }
- break;
- case IS_NULL:
- zend_hash_del(ht, "", sizeof(""));
- break;
- default:
- zend_error(E_WARNING, "Illegal offset type in unset");
- break;
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ ;
+ }
}
}
} else {
/* overloaded element */
+ ;
}
- ;
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
static int zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
{
zend_op *opline = EX(opline);
- zend_free_op free_op1, free_op2;
+ zend_free_op free_op1;
zval **container = _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
- zval *offset = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
zval **value = NULL;
int result = 0;
long index;
if (container) {
+ zend_free_op free_op2;
+ zval *offset = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
+
if ((*container)->type == IS_ARRAY) {
HashTable *ht;
int isset = 0;
}
break;
}
+ ;
} else if ((*container)->type == IS_OBJECT) {
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
if (prop_dim) {
result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
} else {
result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
}
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ ;
+ }
} else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
zval tmp;
break;
}
}
+ ;
+ } else {
+ ;
}
}
break;
}
- ;
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
zval *object;
zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
- zval tmp;
znode *result = &opline->result;
zval **retval = &EX_T(result->u.var).var.ptr;
int have_get_ptr = 0;
}
} else {
/* here we are sure we are dealing with an object */
- switch (IS_TMP_VAR) {
- case IS_CONST:
- /* already a constant string */
- break;
- case IS_CV:
- case IS_VAR:
- tmp = *property;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- property = &tmp;
- break;
- case IS_TMP_VAR:
- convert_to_string(property);
- break;
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(property);
}
/* here property is a string */
}
}
- if (property == &tmp) {
- zval_dtor(property);
+ if (1) {
+ zval_ptr_dtor(&property);
+ } else {
+ zval_dtor(free_op2.var);
}
-
- zval_dtor(free_op2.var);
FREE_OP(free_op_data1);
}
return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
} else {
zend_op *op_data = opline+1;
+ zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_RW TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 1, BP_VAR_RW TSRMLS_CC);
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), &free_op_data2, BP_VAR_RW);
increment_opline = 1;
/* here we are sure we are dealing with an object */
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
if (zptr != NULL) { /* NULL means no success in getting PTR */
}
}
- zval_dtor(free_op2.var);
+ if (1) {
+ zval_ptr_dtor(&property);
+ } else {
+ zval_dtor(free_op2.var);
+ }
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
}
/* here we are sure we are dealing with an object */
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
if (zptr != NULL) { /* NULL means no success in getting PTR */
}
}
- zval_dtor(free_op2.var);
+ if (1) {
+ zval_ptr_dtor(&property);
+ } else {
+ zval_dtor(free_op2.var);
+ }
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_VAR != IS_CV) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
}
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_R TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 1, BP_VAR_R TSRMLS_CC);
zval_dtor(free_op2.var);
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_W TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 1, BP_VAR_W TSRMLS_CC);
zval_dtor(free_op2.var);
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_RW TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 1, BP_VAR_RW TSRMLS_CC);
zval_dtor(free_op2.var);
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_IS TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 1, BP_VAR_IS TSRMLS_CC);
zval_dtor(free_op2.var);
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
int type = ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)?BP_VAR_W:BP_VAR_R;
+ zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), type TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 1, type TSRMLS_CC);
zval_dtor(free_op2.var);
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
/* Not needed in DIM_UNSET
if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
}
*/
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_UNSET TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 1, BP_VAR_UNSET TSRMLS_CC);
zval_dtor(free_op2.var);
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
if (EX_T(opline->result.u.var).var.ptr_ptr == NULL) {
if (container->type != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
zend_error(E_NOTICE, "Trying to get property of non-object");
*retval = EG(uninitialized_zval_ptr);
+ SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
+ AI_USE_PTR(EX_T(opline->result.u.var).var);
} else {
zend_free_op free_op2;
zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zval tmp;
- switch (IS_TMP_VAR) {
- case IS_CONST:
- /* already a constant string */
- break;
- case IS_CV:
- case IS_VAR:
- tmp = *offset;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- offset = &tmp;
- break;
- case IS_TMP_VAR:
- convert_to_string(offset);
- break;
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(offset);
}
/* here we are sure we are dealing with an object */
*retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
- if (offset == &tmp) {
- zval_dtor(offset);
- }
- zval_dtor(free_op2.var);
if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
zval_dtor(*retval);
FREE_ZVAL(*retval);
- ZEND_VM_NEXT_OPCODE();
+ } else {
+ SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
+ AI_USE_PTR(EX_T(opline->result.u.var).var);
+ }
+
+ if (1) {
+ zval_ptr_dtor(&offset);
+ } else {
+ zval_dtor(free_op2.var);
}
}
- SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
- AI_USE_PTR(EX_T(opline->result.u.var).var);
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_VAR != IS_CV) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
}
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_W TSRMLS_CC);
- zval_dtor(free_op2.var);
+
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
+ if (1) {
+ zval_ptr_dtor(&property);
+ } else {
+ zval_dtor(free_op2.var);
+ }
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_RW TSRMLS_CC);
- zval_dtor(free_op2.var);
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_RW TSRMLS_CC);
+ if (1) {
+ zval_ptr_dtor(&property);
+ } else {
+ zval_dtor(free_op2.var);
+ }
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
}
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
/* Behave like FETCH_OBJ_W */
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_W TSRMLS_CC);
- zval_dtor(free_op2.var);
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
+ if (1) {
+ zval_ptr_dtor(&property);
+ } else {
+ zval_dtor(free_op2.var);
+ }
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
} else {
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2, free_res;
+ zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
- zval_dtor(free_op2.var);
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_R TSRMLS_CC);
+ if (1) {
+ zval_ptr_dtor(&property);
+ } else {
+ zval_dtor(free_op2.var);
+ }
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
} else {
zend_free_op free_op2, free_op_data1;
zval *value;
+ zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_W TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 1, BP_VAR_W TSRMLS_CC);
zval_dtor(free_op2.var);
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
long index;
if (container) {
- HashTable *ht;
if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
SEPARATE_ZVAL_IF_NOT_REF(container);
}
if (opline->extended_value == ZEND_UNSET_DIM) {
switch (Z_TYPE_PP(container)) {
- case IS_ARRAY:
- ht = Z_ARRVAL_PP(container);
+ case IS_ARRAY: {
+ HashTable *ht = Z_ARRVAL_PP(container);
+
+ switch (offset->type) {
+ case IS_DOUBLE:
+ case IS_RESOURCE:
+ case IS_BOOL:
+ case IS_LONG:
+ if (offset->type == IS_DOUBLE) {
+ index = (long) offset->value.dval;
+ } else {
+ index = offset->value.lval;
+ }
+
+ zend_hash_index_del(ht, index);
+ break;
+ case IS_STRING:
+ if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
+ ht == &EG(symbol_table)) {
+ zend_execute_data *ex;
+ ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
+
+ for (ex = execute_data; ex; ex = ex->prev_execute_data) {
+ if (ex->symbol_table == ht) {
+ int i;
+
+ for (i = 0; i < ex->op_array->last_var; i++) {
+ if (ex->op_array->vars[i].hash_value == hash_value &&
+ ex->op_array->vars[i].name_len == offset->value.str.len &&
+ !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
+ ex->CVs[i] = NULL;
+ break;
+ }
+ }
+ }
+ }
+ }
+ break;
+ case IS_NULL:
+ zend_hash_del(ht, "", sizeof(""));
+ break;
+ default:
+ zend_error(E_WARNING, "Illegal offset type in unset");
+ break;
+ }
+ zval_dtor(free_op2.var);
break;
+ }
case IS_OBJECT:
- ht = NULL;
if (!Z_OBJ_HT_P(*container)->unset_dimension) {
zend_error_noreturn(E_ERROR, "Cannot use object as array");
}
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
+ if (1) {
+ zval_ptr_dtor(&offset);
+ } else {
+ zval_dtor(free_op2.var);
+ }
break;
case IS_STRING:
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
ZEND_VM_CONTINUE(); /* bailed out before */
default:
- ht = NULL;
+ zval_dtor(free_op2.var);
break;
}
} else { /* ZEND_UNSET_OBJ */
- ht = NULL;
if (Z_TYPE_PP(container) == IS_OBJECT) {
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
- }
- }
- if (ht) {
- switch (offset->type) {
- case IS_DOUBLE:
- case IS_RESOURCE:
- case IS_BOOL:
- case IS_LONG:
- if (offset->type == IS_DOUBLE) {
- index = (long) offset->value.dval;
- } else {
- index = offset->value.lval;
- }
-
- zend_hash_index_del(ht, index);
- break;
- case IS_STRING:
- if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
- ht == &EG(symbol_table)) {
- zend_execute_data *ex;
- ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
-
- for (ex = execute_data; ex; ex = ex->prev_execute_data) {
- if (ex->symbol_table == ht) {
- int i;
-
- for (i = 0; i < ex->op_array->last_var; i++) {
- if (ex->op_array->vars[i].hash_value == hash_value &&
- ex->op_array->vars[i].name_len == offset->value.str.len &&
- !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
- ex->CVs[i] = NULL;
- break;
- }
- }
- }
- }
- }
- break;
- case IS_NULL:
- zend_hash_del(ht, "", sizeof(""));
- break;
- default:
- zend_error(E_WARNING, "Illegal offset type in unset");
- break;
+ if (1) {
+ zval_ptr_dtor(&offset);
+ } else {
+ zval_dtor(free_op2.var);
+ }
}
}
} else {
/* overloaded element */
+ zval_dtor(free_op2.var);
}
- zval_dtor(free_op2.var);
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
static int zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
{
zend_op *opline = EX(opline);
- zend_free_op free_op1, free_op2;
+ zend_free_op free_op1;
zval **container = _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
- zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
zval **value = NULL;
int result = 0;
long index;
if (container) {
+ zend_free_op free_op2;
+ zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
+
if ((*container)->type == IS_ARRAY) {
HashTable *ht;
int isset = 0;
}
break;
}
+ zval_dtor(free_op2.var);
} else if ((*container)->type == IS_OBJECT) {
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
if (prop_dim) {
result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
} else {
result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
}
+ if (1) {
+ zval_ptr_dtor(&offset);
+ } else {
+ zval_dtor(free_op2.var);
+ }
} else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
zval tmp;
break;
}
}
+ zval_dtor(free_op2.var);
+ } else {
+ zval_dtor(free_op2.var);
}
}
break;
}
- zval_dtor(free_op2.var);
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
zval *object;
zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
- zval tmp;
znode *result = &opline->result;
zval **retval = &EX_T(result->u.var).var.ptr;
int have_get_ptr = 0;
}
} else {
/* here we are sure we are dealing with an object */
- switch (IS_VAR) {
- case IS_CONST:
- /* already a constant string */
- break;
- case IS_CV:
- case IS_VAR:
- tmp = *property;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- property = &tmp;
- break;
- case IS_TMP_VAR:
- convert_to_string(property);
- break;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
}
/* here property is a string */
}
}
- if (property == &tmp) {
- zval_dtor(property);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
}
-
- if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
FREE_OP(free_op_data1);
}
return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
} else {
zend_op *op_data = opline+1;
+ zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_RW TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), &free_op_data2, BP_VAR_RW);
increment_opline = 1;
/* here we are sure we are dealing with an object */
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
if (zptr != NULL) { /* NULL means no success in getting PTR */
}
}
- if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ }
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
}
/* here we are sure we are dealing with an object */
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
if (zptr != NULL) { /* NULL means no success in getting PTR */
}
}
- if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ }
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_VAR != IS_CV) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
}
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_R TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_R TSRMLS_CC);
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_W TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_W TSRMLS_CC);
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_RW TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_IS TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_IS TSRMLS_CC);
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
int type = ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)?BP_VAR_W:BP_VAR_R;
+ zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), type TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, type TSRMLS_CC);
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
/* Not needed in DIM_UNSET
if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
}
*/
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_UNSET TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_UNSET TSRMLS_CC);
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
if (EX_T(opline->result.u.var).var.ptr_ptr == NULL) {
if (container->type != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
zend_error(E_NOTICE, "Trying to get property of non-object");
*retval = EG(uninitialized_zval_ptr);
+ SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
+ AI_USE_PTR(EX_T(opline->result.u.var).var);
} else {
zend_free_op free_op2;
zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zval tmp;
- switch (IS_VAR) {
- case IS_CONST:
- /* already a constant string */
- break;
- case IS_CV:
- case IS_VAR:
- tmp = *offset;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- offset = &tmp;
- break;
- case IS_TMP_VAR:
- convert_to_string(offset);
- break;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
}
/* here we are sure we are dealing with an object */
*retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
- if (offset == &tmp) {
- zval_dtor(offset);
- }
- if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
zval_dtor(*retval);
FREE_ZVAL(*retval);
- ZEND_VM_NEXT_OPCODE();
+ } else {
+ SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
+ AI_USE_PTR(EX_T(opline->result.u.var).var);
+ }
+
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
}
}
- SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
- AI_USE_PTR(EX_T(opline->result.u.var).var);
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_VAR != IS_CV) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
}
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_W TSRMLS_CC);
- if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ }
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_RW TSRMLS_CC);
- if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_RW TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ }
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
}
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
/* Behave like FETCH_OBJ_W */
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_W TSRMLS_CC);
- if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ }
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
} else {
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2, free_res;
+ zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
- if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_R TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ }
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
} else {
zend_free_op free_op2, free_op_data1;
zval *value;
+ zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_W TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 0, BP_VAR_W TSRMLS_CC);
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
long index;
if (container) {
- HashTable *ht;
if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
SEPARATE_ZVAL_IF_NOT_REF(container);
}
if (opline->extended_value == ZEND_UNSET_DIM) {
switch (Z_TYPE_PP(container)) {
- case IS_ARRAY:
- ht = Z_ARRVAL_PP(container);
+ case IS_ARRAY: {
+ HashTable *ht = Z_ARRVAL_PP(container);
+
+ switch (offset->type) {
+ case IS_DOUBLE:
+ case IS_RESOURCE:
+ case IS_BOOL:
+ case IS_LONG:
+ if (offset->type == IS_DOUBLE) {
+ index = (long) offset->value.dval;
+ } else {
+ index = offset->value.lval;
+ }
+
+ zend_hash_index_del(ht, index);
+ break;
+ case IS_STRING:
+ if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
+ ht == &EG(symbol_table)) {
+ zend_execute_data *ex;
+ ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
+
+ for (ex = execute_data; ex; ex = ex->prev_execute_data) {
+ if (ex->symbol_table == ht) {
+ int i;
+
+ for (i = 0; i < ex->op_array->last_var; i++) {
+ if (ex->op_array->vars[i].hash_value == hash_value &&
+ ex->op_array->vars[i].name_len == offset->value.str.len &&
+ !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
+ ex->CVs[i] = NULL;
+ break;
+ }
+ }
+ }
+ }
+ }
+ break;
+ case IS_NULL:
+ zend_hash_del(ht, "", sizeof(""));
+ break;
+ default:
+ zend_error(E_WARNING, "Illegal offset type in unset");
+ break;
+ }
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
break;
+ }
case IS_OBJECT:
- ht = NULL;
if (!Z_OBJ_HT_P(*container)->unset_dimension) {
zend_error_noreturn(E_ERROR, "Cannot use object as array");
}
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ }
break;
case IS_STRING:
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
ZEND_VM_CONTINUE(); /* bailed out before */
default:
- ht = NULL;
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
break;
}
} else { /* ZEND_UNSET_OBJ */
- ht = NULL;
if (Z_TYPE_PP(container) == IS_OBJECT) {
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
- }
- }
- if (ht) {
- switch (offset->type) {
- case IS_DOUBLE:
- case IS_RESOURCE:
- case IS_BOOL:
- case IS_LONG:
- if (offset->type == IS_DOUBLE) {
- index = (long) offset->value.dval;
- } else {
- index = offset->value.lval;
- }
-
- zend_hash_index_del(ht, index);
- break;
- case IS_STRING:
- if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
- ht == &EG(symbol_table)) {
- zend_execute_data *ex;
- ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
-
- for (ex = execute_data; ex; ex = ex->prev_execute_data) {
- if (ex->symbol_table == ht) {
- int i;
-
- for (i = 0; i < ex->op_array->last_var; i++) {
- if (ex->op_array->vars[i].hash_value == hash_value &&
- ex->op_array->vars[i].name_len == offset->value.str.len &&
- !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
- ex->CVs[i] = NULL;
- break;
- }
- }
- }
- }
- }
- break;
- case IS_NULL:
- zend_hash_del(ht, "", sizeof(""));
- break;
- default:
- zend_error(E_WARNING, "Illegal offset type in unset");
- break;
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ }
}
}
} else {
/* overloaded element */
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
}
- if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
static int zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
{
zend_op *opline = EX(opline);
- zend_free_op free_op1, free_op2;
+ zend_free_op free_op1;
zval **container = _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
- zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
zval **value = NULL;
int result = 0;
long index;
if (container) {
+ zend_free_op free_op2;
+ zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
+
if ((*container)->type == IS_ARRAY) {
HashTable *ht;
int isset = 0;
}
break;
}
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
} else if ((*container)->type == IS_OBJECT) {
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
if (prop_dim) {
result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
} else {
result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
}
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ }
} else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
zval tmp;
break;
}
}
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
}
}
break;
}
- if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
zval *object;
zval *property = _get_zval_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
- zval tmp;
znode *result = &opline->result;
zval **retval = &EX_T(result->u.var).var.ptr;
int have_get_ptr = 0;
}
} else {
/* here we are sure we are dealing with an object */
- switch (IS_UNUSED) {
- case IS_CONST:
- /* already a constant string */
- break;
- case IS_CV:
- case IS_VAR:
- tmp = *property;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- property = &tmp;
- break;
- case IS_TMP_VAR:
- convert_to_string(property);
- break;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
}
/* here property is a string */
}
}
- if (property == &tmp) {
- zval_dtor(property);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
}
-
- ;
FREE_OP(free_op_data1);
}
return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
} else {
zend_op *op_data = opline+1;
+ zval *dim = _get_zval_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_RW TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), &free_op_data2, BP_VAR_RW);
increment_opline = 1;
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_W TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_W TSRMLS_CC);
;
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
} else {
zend_free_op free_op2, free_op_data1;
zval *value;
+ zval *dim = _get_zval_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, _get_zval_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_W TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 0, BP_VAR_W TSRMLS_CC);
;
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
zval *object;
zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
- zval tmp;
znode *result = &opline->result;
zval **retval = &EX_T(result->u.var).var.ptr;
int have_get_ptr = 0;
}
} else {
/* here we are sure we are dealing with an object */
- switch (IS_CV) {
- case IS_CONST:
- /* already a constant string */
- break;
- case IS_CV:
- case IS_VAR:
- tmp = *property;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- property = &tmp;
- break;
- case IS_TMP_VAR:
- convert_to_string(property);
- break;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
}
/* here property is a string */
}
}
- if (property == &tmp) {
- zval_dtor(property);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
}
-
- ;
FREE_OP(free_op_data1);
}
return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
} else {
zend_op *op_data = opline+1;
+ zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC), BP_VAR_RW TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), &free_op_data2, BP_VAR_RW);
increment_opline = 1;
/* here we are sure we are dealing with an object */
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
if (zptr != NULL) { /* NULL means no success in getting PTR */
}
}
- ;
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
}
/* here we are sure we are dealing with an object */
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
if (zptr != NULL) { /* NULL means no success in getting PTR */
}
}
- ;
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_VAR != IS_CV) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
}
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC), BP_VAR_R TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_R TSRMLS_CC);
;
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC), BP_VAR_W TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_W TSRMLS_CC);
;
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC), BP_VAR_RW TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
;
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC), BP_VAR_IS TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_IS TSRMLS_CC);
;
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
int type = ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)?BP_VAR_W:BP_VAR_R;
+ zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC), type TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, type TSRMLS_CC);
;
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
/* Not needed in DIM_UNSET
if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
}
*/
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC), BP_VAR_UNSET TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_UNSET TSRMLS_CC);
;
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
if (EX_T(opline->result.u.var).var.ptr_ptr == NULL) {
if (container->type != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
zend_error(E_NOTICE, "Trying to get property of non-object");
*retval = EG(uninitialized_zval_ptr);
+ SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
+ AI_USE_PTR(EX_T(opline->result.u.var).var);
} else {
zend_free_op free_op2;
zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
- zval tmp;
- switch (IS_CV) {
- case IS_CONST:
- /* already a constant string */
- break;
- case IS_CV:
- case IS_VAR:
- tmp = *offset;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- offset = &tmp;
- break;
- case IS_TMP_VAR:
- convert_to_string(offset);
- break;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
}
/* here we are sure we are dealing with an object */
*retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
- if (offset == &tmp) {
- zval_dtor(offset);
- }
- ;
if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
zval_dtor(*retval);
FREE_ZVAL(*retval);
- ZEND_VM_NEXT_OPCODE();
+ } else {
+ SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
+ AI_USE_PTR(EX_T(opline->result.u.var).var);
+ }
+
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ ;
}
}
- SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
- AI_USE_PTR(EX_T(opline->result.u.var).var);
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_VAR != IS_CV) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
}
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC), IS_CV, BP_VAR_W TSRMLS_CC);
- ;
+
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC), IS_CV, BP_VAR_RW TSRMLS_CC);
- ;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_RW TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
}
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
/* Behave like FETCH_OBJ_W */
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC), IS_CV, BP_VAR_W TSRMLS_CC);
- ;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
} else {
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2, free_res;
+ zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
- ;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_R TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
} else {
zend_free_op free_op2, free_op_data1;
zval *value;
+ zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC), BP_VAR_W TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 0, BP_VAR_W TSRMLS_CC);
;
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
long index;
if (container) {
- HashTable *ht;
if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
SEPARATE_ZVAL_IF_NOT_REF(container);
}
if (opline->extended_value == ZEND_UNSET_DIM) {
switch (Z_TYPE_PP(container)) {
- case IS_ARRAY:
- ht = Z_ARRVAL_PP(container);
+ case IS_ARRAY: {
+ HashTable *ht = Z_ARRVAL_PP(container);
+
+ switch (offset->type) {
+ case IS_DOUBLE:
+ case IS_RESOURCE:
+ case IS_BOOL:
+ case IS_LONG:
+ if (offset->type == IS_DOUBLE) {
+ index = (long) offset->value.dval;
+ } else {
+ index = offset->value.lval;
+ }
+
+ zend_hash_index_del(ht, index);
+ break;
+ case IS_STRING:
+ if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
+ ht == &EG(symbol_table)) {
+ zend_execute_data *ex;
+ ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
+
+ for (ex = execute_data; ex; ex = ex->prev_execute_data) {
+ if (ex->symbol_table == ht) {
+ int i;
+
+ for (i = 0; i < ex->op_array->last_var; i++) {
+ if (ex->op_array->vars[i].hash_value == hash_value &&
+ ex->op_array->vars[i].name_len == offset->value.str.len &&
+ !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
+ ex->CVs[i] = NULL;
+ break;
+ }
+ }
+ }
+ }
+ }
+ break;
+ case IS_NULL:
+ zend_hash_del(ht, "", sizeof(""));
+ break;
+ default:
+ zend_error(E_WARNING, "Illegal offset type in unset");
+ break;
+ }
+ ;
break;
+ }
case IS_OBJECT:
- ht = NULL;
if (!Z_OBJ_HT_P(*container)->unset_dimension) {
zend_error_noreturn(E_ERROR, "Cannot use object as array");
}
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ ;
+ }
break;
case IS_STRING:
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
ZEND_VM_CONTINUE(); /* bailed out before */
default:
- ht = NULL;
+ ;
break;
}
} else { /* ZEND_UNSET_OBJ */
- ht = NULL;
if (Z_TYPE_PP(container) == IS_OBJECT) {
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
- }
- }
- if (ht) {
- switch (offset->type) {
- case IS_DOUBLE:
- case IS_RESOURCE:
- case IS_BOOL:
- case IS_LONG:
- if (offset->type == IS_DOUBLE) {
- index = (long) offset->value.dval;
- } else {
- index = offset->value.lval;
- }
-
- zend_hash_index_del(ht, index);
- break;
- case IS_STRING:
- if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
- ht == &EG(symbol_table)) {
- zend_execute_data *ex;
- ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
-
- for (ex = execute_data; ex; ex = ex->prev_execute_data) {
- if (ex->symbol_table == ht) {
- int i;
-
- for (i = 0; i < ex->op_array->last_var; i++) {
- if (ex->op_array->vars[i].hash_value == hash_value &&
- ex->op_array->vars[i].name_len == offset->value.str.len &&
- !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
- ex->CVs[i] = NULL;
- break;
- }
- }
- }
- }
- }
- break;
- case IS_NULL:
- zend_hash_del(ht, "", sizeof(""));
- break;
- default:
- zend_error(E_WARNING, "Illegal offset type in unset");
- break;
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ ;
+ }
}
}
} else {
/* overloaded element */
+ ;
}
- ;
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
static int zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
{
zend_op *opline = EX(opline);
- zend_free_op free_op1, free_op2;
+ zend_free_op free_op1;
zval **container = _get_obj_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
- zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
zval **value = NULL;
int result = 0;
long index;
if (container) {
+ zend_free_op free_op2;
+ zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
+
if ((*container)->type == IS_ARRAY) {
HashTable *ht;
int isset = 0;
}
break;
}
+ ;
} else if ((*container)->type == IS_OBJECT) {
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
if (prop_dim) {
result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
} else {
result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
}
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ ;
+ }
} else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
zval tmp;
break;
}
}
+ ;
+ } else {
+ ;
}
}
break;
}
- ;
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
zval *object;
zval *property = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
- zval tmp;
znode *result = &opline->result;
zval **retval = &EX_T(result->u.var).var.ptr;
int have_get_ptr = 0;
}
} else {
/* here we are sure we are dealing with an object */
- switch (IS_CONST) {
- case IS_CONST:
- /* already a constant string */
- break;
- case IS_CV:
- case IS_VAR:
- tmp = *property;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- property = &tmp;
- break;
- case IS_TMP_VAR:
- convert_to_string(property);
- break;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
}
/* here property is a string */
}
}
- if (property == &tmp) {
- zval_dtor(property);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
}
-
- ;
FREE_OP(free_op_data1);
}
return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
} else {
zend_op *op_data = opline+1;
+ zval *dim = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_RW TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), &free_op_data2, BP_VAR_RW);
increment_opline = 1;
/* here we are sure we are dealing with an object */
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
if (zptr != NULL) { /* NULL means no success in getting PTR */
}
}
- ;
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
;
ZEND_VM_NEXT_OPCODE();
}
/* here we are sure we are dealing with an object */
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
if (zptr != NULL) { /* NULL means no success in getting PTR */
}
}
- ;
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
;
ZEND_VM_NEXT_OPCODE();
}
if (container->type != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
zend_error(E_NOTICE, "Trying to get property of non-object");
*retval = EG(uninitialized_zval_ptr);
+ SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
+ AI_USE_PTR(EX_T(opline->result.u.var).var);
} else {
zend_free_op free_op2;
zval *offset = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zval tmp;
- switch (IS_CONST) {
- case IS_CONST:
- /* already a constant string */
- break;
- case IS_CV:
- case IS_VAR:
- tmp = *offset;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- offset = &tmp;
- break;
- case IS_TMP_VAR:
- convert_to_string(offset);
- break;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
}
/* here we are sure we are dealing with an object */
*retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
- if (offset == &tmp) {
- zval_dtor(offset);
- }
- ;
if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
zval_dtor(*retval);
FREE_ZVAL(*retval);
- ZEND_VM_NEXT_OPCODE();
+ } else {
+ SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
+ AI_USE_PTR(EX_T(opline->result.u.var).var);
+ }
+
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ ;
}
}
- SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
- AI_USE_PTR(EX_T(opline->result.u.var).var);
;
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_UNUSED != IS_CV) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
}
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_CONST, BP_VAR_W TSRMLS_CC);
- ;
+
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
;
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_CONST, BP_VAR_RW TSRMLS_CC);
- ;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_RW TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
;
ZEND_VM_NEXT_OPCODE();
}
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
/* Behave like FETCH_OBJ_W */
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_CONST, BP_VAR_W TSRMLS_CC);
- ;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
;
ZEND_VM_NEXT_OPCODE();
} else {
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2, free_res;
+ zval *property = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_CONST, BP_VAR_R TSRMLS_CC);
- ;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_R TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
;
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
} else {
zend_free_op free_op2, free_op_data1;
zval *value;
+ zval *dim = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_W TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 0, BP_VAR_W TSRMLS_CC);
;
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
long index;
if (container) {
- HashTable *ht;
if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
SEPARATE_ZVAL_IF_NOT_REF(container);
}
if (opline->extended_value == ZEND_UNSET_DIM) {
switch (Z_TYPE_PP(container)) {
- case IS_ARRAY:
- ht = Z_ARRVAL_PP(container);
+ case IS_ARRAY: {
+ HashTable *ht = Z_ARRVAL_PP(container);
+
+ switch (offset->type) {
+ case IS_DOUBLE:
+ case IS_RESOURCE:
+ case IS_BOOL:
+ case IS_LONG:
+ if (offset->type == IS_DOUBLE) {
+ index = (long) offset->value.dval;
+ } else {
+ index = offset->value.lval;
+ }
+
+ zend_hash_index_del(ht, index);
+ break;
+ case IS_STRING:
+ if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
+ ht == &EG(symbol_table)) {
+ zend_execute_data *ex;
+ ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
+
+ for (ex = execute_data; ex; ex = ex->prev_execute_data) {
+ if (ex->symbol_table == ht) {
+ int i;
+
+ for (i = 0; i < ex->op_array->last_var; i++) {
+ if (ex->op_array->vars[i].hash_value == hash_value &&
+ ex->op_array->vars[i].name_len == offset->value.str.len &&
+ !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
+ ex->CVs[i] = NULL;
+ break;
+ }
+ }
+ }
+ }
+ }
+ break;
+ case IS_NULL:
+ zend_hash_del(ht, "", sizeof(""));
+ break;
+ default:
+ zend_error(E_WARNING, "Illegal offset type in unset");
+ break;
+ }
+ ;
break;
+ }
case IS_OBJECT:
- ht = NULL;
if (!Z_OBJ_HT_P(*container)->unset_dimension) {
zend_error_noreturn(E_ERROR, "Cannot use object as array");
}
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ ;
+ }
break;
case IS_STRING:
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
ZEND_VM_CONTINUE(); /* bailed out before */
default:
- ht = NULL;
+ ;
break;
}
} else { /* ZEND_UNSET_OBJ */
- ht = NULL;
if (Z_TYPE_PP(container) == IS_OBJECT) {
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
- }
- }
- if (ht) {
- switch (offset->type) {
- case IS_DOUBLE:
- case IS_RESOURCE:
- case IS_BOOL:
- case IS_LONG:
- if (offset->type == IS_DOUBLE) {
- index = (long) offset->value.dval;
- } else {
- index = offset->value.lval;
- }
-
- zend_hash_index_del(ht, index);
- break;
- case IS_STRING:
- if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
- ht == &EG(symbol_table)) {
- zend_execute_data *ex;
- ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
-
- for (ex = execute_data; ex; ex = ex->prev_execute_data) {
- if (ex->symbol_table == ht) {
- int i;
-
- for (i = 0; i < ex->op_array->last_var; i++) {
- if (ex->op_array->vars[i].hash_value == hash_value &&
- ex->op_array->vars[i].name_len == offset->value.str.len &&
- !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
- ex->CVs[i] = NULL;
- break;
- }
- }
- }
- }
- }
- break;
- case IS_NULL:
- zend_hash_del(ht, "", sizeof(""));
- break;
- default:
- zend_error(E_WARNING, "Illegal offset type in unset");
- break;
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ ;
+ }
}
}
} else {
/* overloaded element */
+ ;
}
;
- ;
ZEND_VM_NEXT_OPCODE();
}
static int zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
{
zend_op *opline = EX(opline);
- zend_free_op free_op1, free_op2;
+ zend_free_op free_op1;
zval **container = _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
- zval *offset = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
zval **value = NULL;
int result = 0;
long index;
if (container) {
+ zend_free_op free_op2;
+ zval *offset = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
+
if ((*container)->type == IS_ARRAY) {
HashTable *ht;
int isset = 0;
}
break;
}
+ ;
} else if ((*container)->type == IS_OBJECT) {
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
if (prop_dim) {
result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
} else {
result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
}
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ ;
+ }
} else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
zval tmp;
break;
}
}
+ ;
+ } else {
+ ;
}
}
break;
}
- ;
;
ZEND_VM_NEXT_OPCODE();
zval *object;
zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
- zval tmp;
znode *result = &opline->result;
zval **retval = &EX_T(result->u.var).var.ptr;
int have_get_ptr = 0;
}
} else {
/* here we are sure we are dealing with an object */
- switch (IS_TMP_VAR) {
- case IS_CONST:
- /* already a constant string */
- break;
- case IS_CV:
- case IS_VAR:
- tmp = *property;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- property = &tmp;
- break;
- case IS_TMP_VAR:
- convert_to_string(property);
- break;
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(property);
}
/* here property is a string */
}
}
- if (property == &tmp) {
- zval_dtor(property);
+ if (1) {
+ zval_ptr_dtor(&property);
+ } else {
+ zval_dtor(free_op2.var);
}
-
- zval_dtor(free_op2.var);
FREE_OP(free_op_data1);
}
return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
} else {
zend_op *op_data = opline+1;
+ zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_RW TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 1, BP_VAR_RW TSRMLS_CC);
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), &free_op_data2, BP_VAR_RW);
increment_opline = 1;
/* here we are sure we are dealing with an object */
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
if (zptr != NULL) { /* NULL means no success in getting PTR */
}
}
- zval_dtor(free_op2.var);
+ if (1) {
+ zval_ptr_dtor(&property);
+ } else {
+ zval_dtor(free_op2.var);
+ }
;
ZEND_VM_NEXT_OPCODE();
}
/* here we are sure we are dealing with an object */
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
if (zptr != NULL) { /* NULL means no success in getting PTR */
}
}
- zval_dtor(free_op2.var);
+ if (1) {
+ zval_ptr_dtor(&property);
+ } else {
+ zval_dtor(free_op2.var);
+ }
;
ZEND_VM_NEXT_OPCODE();
}
if (container->type != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
zend_error(E_NOTICE, "Trying to get property of non-object");
*retval = EG(uninitialized_zval_ptr);
+ SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
+ AI_USE_PTR(EX_T(opline->result.u.var).var);
} else {
zend_free_op free_op2;
zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zval tmp;
- switch (IS_TMP_VAR) {
- case IS_CONST:
- /* already a constant string */
- break;
- case IS_CV:
- case IS_VAR:
- tmp = *offset;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- offset = &tmp;
- break;
- case IS_TMP_VAR:
- convert_to_string(offset);
- break;
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(offset);
}
/* here we are sure we are dealing with an object */
*retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
- if (offset == &tmp) {
- zval_dtor(offset);
- }
- zval_dtor(free_op2.var);
if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
zval_dtor(*retval);
FREE_ZVAL(*retval);
- ZEND_VM_NEXT_OPCODE();
+ } else {
+ SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
+ AI_USE_PTR(EX_T(opline->result.u.var).var);
+ }
+
+ if (1) {
+ zval_ptr_dtor(&offset);
+ } else {
+ zval_dtor(free_op2.var);
}
}
- SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
- AI_USE_PTR(EX_T(opline->result.u.var).var);
;
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_UNUSED != IS_CV) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
}
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_W TSRMLS_CC);
- zval_dtor(free_op2.var);
+
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
+ if (1) {
+ zval_ptr_dtor(&property);
+ } else {
+ zval_dtor(free_op2.var);
+ }
;
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_RW TSRMLS_CC);
- zval_dtor(free_op2.var);
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_RW TSRMLS_CC);
+ if (1) {
+ zval_ptr_dtor(&property);
+ } else {
+ zval_dtor(free_op2.var);
+ }
;
ZEND_VM_NEXT_OPCODE();
}
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
/* Behave like FETCH_OBJ_W */
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_W TSRMLS_CC);
- zval_dtor(free_op2.var);
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
+ if (1) {
+ zval_ptr_dtor(&property);
+ } else {
+ zval_dtor(free_op2.var);
+ }
;
ZEND_VM_NEXT_OPCODE();
} else {
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2, free_res;
+ zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
- zval_dtor(free_op2.var);
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_R TSRMLS_CC);
+ if (1) {
+ zval_ptr_dtor(&property);
+ } else {
+ zval_dtor(free_op2.var);
+ }
;
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
} else {
zend_free_op free_op2, free_op_data1;
zval *value;
+ zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_W TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 1, BP_VAR_W TSRMLS_CC);
zval_dtor(free_op2.var);
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
long index;
if (container) {
- HashTable *ht;
if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
SEPARATE_ZVAL_IF_NOT_REF(container);
}
if (opline->extended_value == ZEND_UNSET_DIM) {
switch (Z_TYPE_PP(container)) {
- case IS_ARRAY:
- ht = Z_ARRVAL_PP(container);
+ case IS_ARRAY: {
+ HashTable *ht = Z_ARRVAL_PP(container);
+
+ switch (offset->type) {
+ case IS_DOUBLE:
+ case IS_RESOURCE:
+ case IS_BOOL:
+ case IS_LONG:
+ if (offset->type == IS_DOUBLE) {
+ index = (long) offset->value.dval;
+ } else {
+ index = offset->value.lval;
+ }
+
+ zend_hash_index_del(ht, index);
+ break;
+ case IS_STRING:
+ if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
+ ht == &EG(symbol_table)) {
+ zend_execute_data *ex;
+ ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
+
+ for (ex = execute_data; ex; ex = ex->prev_execute_data) {
+ if (ex->symbol_table == ht) {
+ int i;
+
+ for (i = 0; i < ex->op_array->last_var; i++) {
+ if (ex->op_array->vars[i].hash_value == hash_value &&
+ ex->op_array->vars[i].name_len == offset->value.str.len &&
+ !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
+ ex->CVs[i] = NULL;
+ break;
+ }
+ }
+ }
+ }
+ }
+ break;
+ case IS_NULL:
+ zend_hash_del(ht, "", sizeof(""));
+ break;
+ default:
+ zend_error(E_WARNING, "Illegal offset type in unset");
+ break;
+ }
+ zval_dtor(free_op2.var);
break;
+ }
case IS_OBJECT:
- ht = NULL;
if (!Z_OBJ_HT_P(*container)->unset_dimension) {
zend_error_noreturn(E_ERROR, "Cannot use object as array");
}
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
+ if (1) {
+ zval_ptr_dtor(&offset);
+ } else {
+ zval_dtor(free_op2.var);
+ }
break;
case IS_STRING:
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
ZEND_VM_CONTINUE(); /* bailed out before */
default:
- ht = NULL;
+ zval_dtor(free_op2.var);
break;
}
} else { /* ZEND_UNSET_OBJ */
- ht = NULL;
if (Z_TYPE_PP(container) == IS_OBJECT) {
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
- }
- }
- if (ht) {
- switch (offset->type) {
- case IS_DOUBLE:
- case IS_RESOURCE:
- case IS_BOOL:
- case IS_LONG:
- if (offset->type == IS_DOUBLE) {
- index = (long) offset->value.dval;
- } else {
- index = offset->value.lval;
- }
-
- zend_hash_index_del(ht, index);
- break;
- case IS_STRING:
- if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
- ht == &EG(symbol_table)) {
- zend_execute_data *ex;
- ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
-
- for (ex = execute_data; ex; ex = ex->prev_execute_data) {
- if (ex->symbol_table == ht) {
- int i;
-
- for (i = 0; i < ex->op_array->last_var; i++) {
- if (ex->op_array->vars[i].hash_value == hash_value &&
- ex->op_array->vars[i].name_len == offset->value.str.len &&
- !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
- ex->CVs[i] = NULL;
- break;
- }
- }
- }
- }
- }
- break;
- case IS_NULL:
- zend_hash_del(ht, "", sizeof(""));
- break;
- default:
- zend_error(E_WARNING, "Illegal offset type in unset");
- break;
+ if (1) {
+ zval_ptr_dtor(&offset);
+ } else {
+ zval_dtor(free_op2.var);
+ }
}
}
} else {
/* overloaded element */
+ zval_dtor(free_op2.var);
}
- zval_dtor(free_op2.var);
;
ZEND_VM_NEXT_OPCODE();
static int zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
{
zend_op *opline = EX(opline);
- zend_free_op free_op1, free_op2;
+ zend_free_op free_op1;
zval **container = _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
- zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
zval **value = NULL;
int result = 0;
long index;
if (container) {
+ zend_free_op free_op2;
+ zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
+
if ((*container)->type == IS_ARRAY) {
HashTable *ht;
int isset = 0;
}
break;
}
+ zval_dtor(free_op2.var);
} else if ((*container)->type == IS_OBJECT) {
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
if (prop_dim) {
result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
} else {
result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
}
+ if (1) {
+ zval_ptr_dtor(&offset);
+ } else {
+ zval_dtor(free_op2.var);
+ }
} else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
zval tmp;
break;
}
}
+ zval_dtor(free_op2.var);
+ } else {
+ zval_dtor(free_op2.var);
}
}
break;
}
- zval_dtor(free_op2.var);
;
ZEND_VM_NEXT_OPCODE();
zval *object;
zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
- zval tmp;
znode *result = &opline->result;
zval **retval = &EX_T(result->u.var).var.ptr;
int have_get_ptr = 0;
}
} else {
/* here we are sure we are dealing with an object */
- switch (IS_VAR) {
- case IS_CONST:
- /* already a constant string */
- break;
- case IS_CV:
- case IS_VAR:
- tmp = *property;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- property = &tmp;
- break;
- case IS_TMP_VAR:
- convert_to_string(property);
- break;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
}
/* here property is a string */
}
}
- if (property == &tmp) {
- zval_dtor(property);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
}
-
- if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
FREE_OP(free_op_data1);
}
return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
} else {
zend_op *op_data = opline+1;
+ zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_RW TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), &free_op_data2, BP_VAR_RW);
increment_opline = 1;
/* here we are sure we are dealing with an object */
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
if (zptr != NULL) { /* NULL means no success in getting PTR */
}
}
- if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ }
;
ZEND_VM_NEXT_OPCODE();
}
/* here we are sure we are dealing with an object */
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
if (zptr != NULL) { /* NULL means no success in getting PTR */
}
}
- if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ }
;
ZEND_VM_NEXT_OPCODE();
}
if (container->type != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
zend_error(E_NOTICE, "Trying to get property of non-object");
*retval = EG(uninitialized_zval_ptr);
+ SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
+ AI_USE_PTR(EX_T(opline->result.u.var).var);
} else {
zend_free_op free_op2;
zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zval tmp;
- switch (IS_VAR) {
- case IS_CONST:
- /* already a constant string */
- break;
- case IS_CV:
- case IS_VAR:
- tmp = *offset;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- offset = &tmp;
- break;
- case IS_TMP_VAR:
- convert_to_string(offset);
- break;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
}
/* here we are sure we are dealing with an object */
*retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
- if (offset == &tmp) {
- zval_dtor(offset);
- }
- if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
zval_dtor(*retval);
FREE_ZVAL(*retval);
- ZEND_VM_NEXT_OPCODE();
+ } else {
+ SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
+ AI_USE_PTR(EX_T(opline->result.u.var).var);
+ }
+
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
}
}
- SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
- AI_USE_PTR(EX_T(opline->result.u.var).var);
;
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_UNUSED != IS_CV) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
}
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_W TSRMLS_CC);
- if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ }
;
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_RW TSRMLS_CC);
- if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_RW TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ }
;
ZEND_VM_NEXT_OPCODE();
}
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
/* Behave like FETCH_OBJ_W */
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_W TSRMLS_CC);
- if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ }
;
ZEND_VM_NEXT_OPCODE();
} else {
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2, free_res;
+ zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
- if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_R TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ }
;
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
} else {
zend_free_op free_op2, free_op_data1;
zval *value;
+ zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_W TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 0, BP_VAR_W TSRMLS_CC);
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
long index;
if (container) {
- HashTable *ht;
if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
SEPARATE_ZVAL_IF_NOT_REF(container);
}
if (opline->extended_value == ZEND_UNSET_DIM) {
switch (Z_TYPE_PP(container)) {
- case IS_ARRAY:
- ht = Z_ARRVAL_PP(container);
- break;
- case IS_OBJECT:
- ht = NULL;
- if (!Z_OBJ_HT_P(*container)->unset_dimension) {
- zend_error_noreturn(E_ERROR, "Cannot use object as array");
- }
- Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
- break;
- case IS_STRING:
- zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
- ZEND_VM_CONTINUE(); /* bailed out before */
- default:
- ht = NULL;
- break;
- }
- } else { /* ZEND_UNSET_OBJ */
- ht = NULL;
- if (Z_TYPE_PP(container) == IS_OBJECT) {
- Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
- }
- }
- if (ht) {
- switch (offset->type) {
- case IS_DOUBLE:
- case IS_RESOURCE:
- case IS_BOOL:
- case IS_LONG:
- if (offset->type == IS_DOUBLE) {
- index = (long) offset->value.dval;
- } else {
- index = offset->value.lval;
- }
+ case IS_ARRAY: {
+ HashTable *ht = Z_ARRVAL_PP(container);
+
+ switch (offset->type) {
+ case IS_DOUBLE:
+ case IS_RESOURCE:
+ case IS_BOOL:
+ case IS_LONG:
+ if (offset->type == IS_DOUBLE) {
+ index = (long) offset->value.dval;
+ } else {
+ index = offset->value.lval;
+ }
- zend_hash_index_del(ht, index);
- break;
- case IS_STRING:
- if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
- ht == &EG(symbol_table)) {
- zend_execute_data *ex;
- ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
-
- for (ex = execute_data; ex; ex = ex->prev_execute_data) {
- if (ex->symbol_table == ht) {
- int i;
-
- for (i = 0; i < ex->op_array->last_var; i++) {
- if (ex->op_array->vars[i].hash_value == hash_value &&
- ex->op_array->vars[i].name_len == offset->value.str.len &&
- !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
- ex->CVs[i] = NULL;
- break;
+ zend_hash_index_del(ht, index);
+ break;
+ case IS_STRING:
+ if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
+ ht == &EG(symbol_table)) {
+ zend_execute_data *ex;
+ ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
+
+ for (ex = execute_data; ex; ex = ex->prev_execute_data) {
+ if (ex->symbol_table == ht) {
+ int i;
+
+ for (i = 0; i < ex->op_array->last_var; i++) {
+ if (ex->op_array->vars[i].hash_value == hash_value &&
+ ex->op_array->vars[i].name_len == offset->value.str.len &&
+ !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
+ ex->CVs[i] = NULL;
+ break;
+ }
+ }
}
}
}
- }
+ break;
+ case IS_NULL:
+ zend_hash_del(ht, "", sizeof(""));
+ break;
+ default:
+ zend_error(E_WARNING, "Illegal offset type in unset");
+ break;
}
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
break;
- case IS_NULL:
- zend_hash_del(ht, "", sizeof(""));
+ }
+ case IS_OBJECT:
+ if (!Z_OBJ_HT_P(*container)->unset_dimension) {
+ zend_error_noreturn(E_ERROR, "Cannot use object as array");
+ }
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
+ Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ }
break;
+ case IS_STRING:
+ zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
+ ZEND_VM_CONTINUE(); /* bailed out before */
default:
- zend_error(E_WARNING, "Illegal offset type in unset");
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
break;
}
+ } else { /* ZEND_UNSET_OBJ */
+ if (Z_TYPE_PP(container) == IS_OBJECT) {
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
+ Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ }
+ }
}
} else {
/* overloaded element */
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
}
- if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
;
ZEND_VM_NEXT_OPCODE();
static int zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
{
zend_op *opline = EX(opline);
- zend_free_op free_op1, free_op2;
+ zend_free_op free_op1;
zval **container = _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
- zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
zval **value = NULL;
int result = 0;
long index;
if (container) {
+ zend_free_op free_op2;
+ zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
+
if ((*container)->type == IS_ARRAY) {
HashTable *ht;
int isset = 0;
}
break;
}
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
} else if ((*container)->type == IS_OBJECT) {
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
if (prop_dim) {
result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
} else {
result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
}
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ }
} else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
zval tmp;
break;
}
}
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
}
}
break;
}
- if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
;
ZEND_VM_NEXT_OPCODE();
zval *object;
zval *property = _get_zval_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
- zval tmp;
znode *result = &opline->result;
zval **retval = &EX_T(result->u.var).var.ptr;
int have_get_ptr = 0;
}
} else {
/* here we are sure we are dealing with an object */
- switch (IS_UNUSED) {
- case IS_CONST:
- /* already a constant string */
- break;
- case IS_CV:
- case IS_VAR:
- tmp = *property;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- property = &tmp;
- break;
- case IS_TMP_VAR:
- convert_to_string(property);
- break;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
}
/* here property is a string */
}
}
- if (property == &tmp) {
- zval_dtor(property);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
}
-
- ;
FREE_OP(free_op_data1);
}
return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
} else {
zend_op *op_data = opline+1;
+ zval *dim = _get_zval_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_RW TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), &free_op_data2, BP_VAR_RW);
increment_opline = 1;
} else {
zend_free_op free_op2, free_op_data1;
zval *value;
+ zval *dim = _get_zval_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, _get_zval_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_W TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 0, BP_VAR_W TSRMLS_CC);
;
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
zval *object;
zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
- zval tmp;
znode *result = &opline->result;
zval **retval = &EX_T(result->u.var).var.ptr;
int have_get_ptr = 0;
}
} else {
/* here we are sure we are dealing with an object */
- switch (IS_CV) {
- case IS_CONST:
- /* already a constant string */
- break;
- case IS_CV:
- case IS_VAR:
- tmp = *property;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- property = &tmp;
- break;
- case IS_TMP_VAR:
- convert_to_string(property);
- break;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
}
/* here property is a string */
}
}
- if (property == &tmp) {
- zval_dtor(property);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
}
-
- ;
FREE_OP(free_op_data1);
}
return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
} else {
zend_op *op_data = opline+1;
+ zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC), BP_VAR_RW TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), &free_op_data2, BP_VAR_RW);
increment_opline = 1;
/* here we are sure we are dealing with an object */
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
if (zptr != NULL) { /* NULL means no success in getting PTR */
}
}
- ;
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
;
ZEND_VM_NEXT_OPCODE();
}
/* here we are sure we are dealing with an object */
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
if (zptr != NULL) { /* NULL means no success in getting PTR */
}
}
- ;
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
;
ZEND_VM_NEXT_OPCODE();
}
if (container->type != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
zend_error(E_NOTICE, "Trying to get property of non-object");
*retval = EG(uninitialized_zval_ptr);
+ SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
+ AI_USE_PTR(EX_T(opline->result.u.var).var);
} else {
zend_free_op free_op2;
zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
- zval tmp;
- switch (IS_CV) {
- case IS_CONST:
- /* already a constant string */
- break;
- case IS_CV:
- case IS_VAR:
- tmp = *offset;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- offset = &tmp;
- break;
- case IS_TMP_VAR:
- convert_to_string(offset);
- break;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
}
/* here we are sure we are dealing with an object */
*retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
- if (offset == &tmp) {
- zval_dtor(offset);
- }
- ;
if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
zval_dtor(*retval);
FREE_ZVAL(*retval);
- ZEND_VM_NEXT_OPCODE();
+ } else {
+ SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
+ AI_USE_PTR(EX_T(opline->result.u.var).var);
+ }
+
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ ;
}
}
- SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
- AI_USE_PTR(EX_T(opline->result.u.var).var);
;
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_UNUSED != IS_CV) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
}
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC), IS_CV, BP_VAR_W TSRMLS_CC);
- ;
+
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
;
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC), IS_CV, BP_VAR_RW TSRMLS_CC);
- ;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_RW TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
;
ZEND_VM_NEXT_OPCODE();
}
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
/* Behave like FETCH_OBJ_W */
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC), IS_CV, BP_VAR_W TSRMLS_CC);
- ;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
;
ZEND_VM_NEXT_OPCODE();
} else {
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2, free_res;
+ zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
- ;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC), property, BP_VAR_R TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
;
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
} else {
zend_free_op free_op2, free_op_data1;
zval *value;
+ zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC), BP_VAR_W TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 0, BP_VAR_W TSRMLS_CC);
;
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
long index;
if (container) {
- HashTable *ht;
if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
SEPARATE_ZVAL_IF_NOT_REF(container);
}
if (opline->extended_value == ZEND_UNSET_DIM) {
switch (Z_TYPE_PP(container)) {
- case IS_ARRAY:
- ht = Z_ARRVAL_PP(container);
+ case IS_ARRAY: {
+ HashTable *ht = Z_ARRVAL_PP(container);
+
+ switch (offset->type) {
+ case IS_DOUBLE:
+ case IS_RESOURCE:
+ case IS_BOOL:
+ case IS_LONG:
+ if (offset->type == IS_DOUBLE) {
+ index = (long) offset->value.dval;
+ } else {
+ index = offset->value.lval;
+ }
+
+ zend_hash_index_del(ht, index);
+ break;
+ case IS_STRING:
+ if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
+ ht == &EG(symbol_table)) {
+ zend_execute_data *ex;
+ ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
+
+ for (ex = execute_data; ex; ex = ex->prev_execute_data) {
+ if (ex->symbol_table == ht) {
+ int i;
+
+ for (i = 0; i < ex->op_array->last_var; i++) {
+ if (ex->op_array->vars[i].hash_value == hash_value &&
+ ex->op_array->vars[i].name_len == offset->value.str.len &&
+ !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
+ ex->CVs[i] = NULL;
+ break;
+ }
+ }
+ }
+ }
+ }
+ break;
+ case IS_NULL:
+ zend_hash_del(ht, "", sizeof(""));
+ break;
+ default:
+ zend_error(E_WARNING, "Illegal offset type in unset");
+ break;
+ }
+ ;
break;
+ }
case IS_OBJECT:
- ht = NULL;
if (!Z_OBJ_HT_P(*container)->unset_dimension) {
zend_error_noreturn(E_ERROR, "Cannot use object as array");
}
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ ;
+ }
break;
case IS_STRING:
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
ZEND_VM_CONTINUE(); /* bailed out before */
default:
- ht = NULL;
+ ;
break;
}
} else { /* ZEND_UNSET_OBJ */
- ht = NULL;
if (Z_TYPE_PP(container) == IS_OBJECT) {
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
- }
- }
- if (ht) {
- switch (offset->type) {
- case IS_DOUBLE:
- case IS_RESOURCE:
- case IS_BOOL:
- case IS_LONG:
- if (offset->type == IS_DOUBLE) {
- index = (long) offset->value.dval;
- } else {
- index = offset->value.lval;
- }
-
- zend_hash_index_del(ht, index);
- break;
- case IS_STRING:
- if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
- ht == &EG(symbol_table)) {
- zend_execute_data *ex;
- ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
-
- for (ex = execute_data; ex; ex = ex->prev_execute_data) {
- if (ex->symbol_table == ht) {
- int i;
-
- for (i = 0; i < ex->op_array->last_var; i++) {
- if (ex->op_array->vars[i].hash_value == hash_value &&
- ex->op_array->vars[i].name_len == offset->value.str.len &&
- !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
- ex->CVs[i] = NULL;
- break;
- }
- }
- }
- }
- }
- break;
- case IS_NULL:
- zend_hash_del(ht, "", sizeof(""));
- break;
- default:
- zend_error(E_WARNING, "Illegal offset type in unset");
- break;
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ ;
+ }
}
}
} else {
/* overloaded element */
+ ;
}
;
- ;
ZEND_VM_NEXT_OPCODE();
}
static int zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
{
zend_op *opline = EX(opline);
- zend_free_op free_op1, free_op2;
+ zend_free_op free_op1;
zval **container = _get_obj_zval_ptr_ptr_unused(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
- zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
zval **value = NULL;
int result = 0;
long index;
if (container) {
+ zend_free_op free_op2;
+ zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
+
if ((*container)->type == IS_ARRAY) {
HashTable *ht;
int isset = 0;
}
break;
}
+ ;
} else if ((*container)->type == IS_OBJECT) {
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
if (prop_dim) {
result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
} else {
result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
}
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ ;
+ }
} else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
zval tmp;
break;
}
}
+ ;
+ } else {
+ ;
}
}
break;
}
- ;
;
ZEND_VM_NEXT_OPCODE();
zval *object;
zval *property = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
- zval tmp;
znode *result = &opline->result;
zval **retval = &EX_T(result->u.var).var.ptr;
int have_get_ptr = 0;
}
} else {
/* here we are sure we are dealing with an object */
- switch (IS_CONST) {
- case IS_CONST:
- /* already a constant string */
- break;
- case IS_CV:
- case IS_VAR:
- tmp = *property;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- property = &tmp;
- break;
- case IS_TMP_VAR:
- convert_to_string(property);
- break;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
}
/* here property is a string */
}
}
- if (property == &tmp) {
- zval_dtor(property);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
}
-
- ;
FREE_OP(free_op_data1);
}
return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
} else {
zend_op *op_data = opline+1;
+ zval *dim = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW TSRMLS_CC), _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_RW TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), &free_op_data2, BP_VAR_RW);
increment_opline = 1;
/* here we are sure we are dealing with an object */
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
if (zptr != NULL) { /* NULL means no success in getting PTR */
}
}
- ;
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
;
ZEND_VM_NEXT_OPCODE();
}
/* here we are sure we are dealing with an object */
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
if (zptr != NULL) { /* NULL means no success in getting PTR */
}
}
- ;
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
;
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_CV != IS_CV) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
}
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_R TSRMLS_CC), _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_R TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_R TSRMLS_CC), dim, 0, BP_VAR_R TSRMLS_CC);
;
;
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_W TSRMLS_CC), _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_W TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_W TSRMLS_CC), dim, 0, BP_VAR_W TSRMLS_CC);
;
;
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW TSRMLS_CC), _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_RW TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
;
;
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_IS TSRMLS_CC), _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_IS TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_IS TSRMLS_CC), dim, 0, BP_VAR_IS TSRMLS_CC);
;
;
ZEND_VM_NEXT_OPCODE();
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
int type = ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)?BP_VAR_W:BP_VAR_R;
+ zval *dim = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, type TSRMLS_CC), _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), type TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, type TSRMLS_CC), dim, 0, type TSRMLS_CC);
;
;
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
/* Not needed in DIM_UNSET
if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
}
*/
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_UNSET TSRMLS_CC), _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_UNSET TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_UNSET TSRMLS_CC), dim, 0, BP_VAR_UNSET TSRMLS_CC);
;
;
if (EX_T(opline->result.u.var).var.ptr_ptr == NULL) {
if (container->type != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
zend_error(E_NOTICE, "Trying to get property of non-object");
*retval = EG(uninitialized_zval_ptr);
+ SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
+ AI_USE_PTR(EX_T(opline->result.u.var).var);
} else {
zend_free_op free_op2;
zval *offset = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zval tmp;
- switch (IS_CONST) {
- case IS_CONST:
- /* already a constant string */
- break;
- case IS_CV:
- case IS_VAR:
- tmp = *offset;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- offset = &tmp;
- break;
- case IS_TMP_VAR:
- convert_to_string(offset);
- break;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
}
/* here we are sure we are dealing with an object */
*retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
- if (offset == &tmp) {
- zval_dtor(offset);
- }
- ;
if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
zval_dtor(*retval);
FREE_ZVAL(*retval);
- ZEND_VM_NEXT_OPCODE();
+ } else {
+ SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
+ AI_USE_PTR(EX_T(opline->result.u.var).var);
+ }
+
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ ;
}
}
- SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
- AI_USE_PTR(EX_T(opline->result.u.var).var);
;
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_CV != IS_CV) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
}
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_W TSRMLS_CC), _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_CONST, BP_VAR_W TSRMLS_CC);
- ;
+
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_W TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
;
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW TSRMLS_CC), _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_CONST, BP_VAR_RW TSRMLS_CC);
- ;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW TSRMLS_CC), property, BP_VAR_RW TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
;
ZEND_VM_NEXT_OPCODE();
}
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
/* Behave like FETCH_OBJ_W */
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_W TSRMLS_CC), _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_CONST, BP_VAR_W TSRMLS_CC);
- ;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_W TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
;
ZEND_VM_NEXT_OPCODE();
} else {
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2, free_res;
+ zval *property = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_R TSRMLS_CC), _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_CONST, BP_VAR_R TSRMLS_CC);
- ;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_R TSRMLS_CC), property, BP_VAR_R TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
;
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
} else {
zend_free_op free_op2, free_op_data1;
zval *value;
+ zval *dim = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_W TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 0, BP_VAR_W TSRMLS_CC);
;
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
long index;
if (container) {
- HashTable *ht;
if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
SEPARATE_ZVAL_IF_NOT_REF(container);
}
if (opline->extended_value == ZEND_UNSET_DIM) {
switch (Z_TYPE_PP(container)) {
- case IS_ARRAY:
- ht = Z_ARRVAL_PP(container);
- break;
- case IS_OBJECT:
- ht = NULL;
- if (!Z_OBJ_HT_P(*container)->unset_dimension) {
- zend_error_noreturn(E_ERROR, "Cannot use object as array");
- }
- Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
- break;
- case IS_STRING:
- zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
- ZEND_VM_CONTINUE(); /* bailed out before */
- default:
- ht = NULL;
- break;
- }
- } else { /* ZEND_UNSET_OBJ */
- ht = NULL;
- if (Z_TYPE_PP(container) == IS_OBJECT) {
- Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
- }
- }
- if (ht) {
- switch (offset->type) {
- case IS_DOUBLE:
- case IS_RESOURCE:
- case IS_BOOL:
- case IS_LONG:
- if (offset->type == IS_DOUBLE) {
- index = (long) offset->value.dval;
- } else {
- index = offset->value.lval;
- }
+ case IS_ARRAY: {
+ HashTable *ht = Z_ARRVAL_PP(container);
+
+ switch (offset->type) {
+ case IS_DOUBLE:
+ case IS_RESOURCE:
+ case IS_BOOL:
+ case IS_LONG:
+ if (offset->type == IS_DOUBLE) {
+ index = (long) offset->value.dval;
+ } else {
+ index = offset->value.lval;
+ }
- zend_hash_index_del(ht, index);
- break;
- case IS_STRING:
- if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
- ht == &EG(symbol_table)) {
- zend_execute_data *ex;
- ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
-
- for (ex = execute_data; ex; ex = ex->prev_execute_data) {
- if (ex->symbol_table == ht) {
- int i;
-
- for (i = 0; i < ex->op_array->last_var; i++) {
- if (ex->op_array->vars[i].hash_value == hash_value &&
- ex->op_array->vars[i].name_len == offset->value.str.len &&
- !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
- ex->CVs[i] = NULL;
- break;
+ zend_hash_index_del(ht, index);
+ break;
+ case IS_STRING:
+ if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
+ ht == &EG(symbol_table)) {
+ zend_execute_data *ex;
+ ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
+
+ for (ex = execute_data; ex; ex = ex->prev_execute_data) {
+ if (ex->symbol_table == ht) {
+ int i;
+
+ for (i = 0; i < ex->op_array->last_var; i++) {
+ if (ex->op_array->vars[i].hash_value == hash_value &&
+ ex->op_array->vars[i].name_len == offset->value.str.len &&
+ !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
+ ex->CVs[i] = NULL;
+ break;
+ }
+ }
}
}
}
- }
+ break;
+ case IS_NULL:
+ zend_hash_del(ht, "", sizeof(""));
+ break;
+ default:
+ zend_error(E_WARNING, "Illegal offset type in unset");
+ break;
}
+ ;
break;
- case IS_NULL:
- zend_hash_del(ht, "", sizeof(""));
+ }
+ case IS_OBJECT:
+ if (!Z_OBJ_HT_P(*container)->unset_dimension) {
+ zend_error_noreturn(E_ERROR, "Cannot use object as array");
+ }
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
+ Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ ;
+ }
break;
+ case IS_STRING:
+ zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
+ ZEND_VM_CONTINUE(); /* bailed out before */
default:
- zend_error(E_WARNING, "Illegal offset type in unset");
+ ;
break;
}
+ } else { /* ZEND_UNSET_OBJ */
+ if (Z_TYPE_PP(container) == IS_OBJECT) {
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
+ Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ ;
+ }
+ }
}
} else {
/* overloaded element */
+ ;
}
;
- ;
ZEND_VM_NEXT_OPCODE();
}
static int zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
{
zend_op *opline = EX(opline);
- zend_free_op free_op1, free_op2;
+ zend_free_op free_op1;
zval **container = _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_IS TSRMLS_CC);
- zval *offset = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
zval **value = NULL;
int result = 0;
long index;
if (container) {
+ zend_free_op free_op2;
+ zval *offset = _get_zval_ptr_const(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
+
if ((*container)->type == IS_ARRAY) {
HashTable *ht;
int isset = 0;
}
break;
}
+ ;
} else if ((*container)->type == IS_OBJECT) {
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
if (prop_dim) {
result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
} else {
result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
}
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ ;
+ }
} else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
zval tmp;
break;
}
}
+ ;
+ } else {
+ ;
}
}
break;
}
- ;
;
ZEND_VM_NEXT_OPCODE();
zval *object;
zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
- zval tmp;
znode *result = &opline->result;
zval **retval = &EX_T(result->u.var).var.ptr;
int have_get_ptr = 0;
}
} else {
/* here we are sure we are dealing with an object */
- switch (IS_TMP_VAR) {
- case IS_CONST:
- /* already a constant string */
- break;
- case IS_CV:
- case IS_VAR:
- tmp = *property;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- property = &tmp;
- break;
- case IS_TMP_VAR:
- convert_to_string(property);
- break;
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(property);
}
/* here property is a string */
}
}
- if (property == &tmp) {
- zval_dtor(property);
+ if (1) {
+ zval_ptr_dtor(&property);
+ } else {
+ zval_dtor(free_op2.var);
}
-
- zval_dtor(free_op2.var);
FREE_OP(free_op_data1);
}
return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
} else {
zend_op *op_data = opline+1;
+ zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW TSRMLS_CC), _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_RW TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW TSRMLS_CC), dim, 1, BP_VAR_RW TSRMLS_CC);
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), &free_op_data2, BP_VAR_RW);
increment_opline = 1;
/* here we are sure we are dealing with an object */
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
if (zptr != NULL) { /* NULL means no success in getting PTR */
}
}
- zval_dtor(free_op2.var);
+ if (1) {
+ zval_ptr_dtor(&property);
+ } else {
+ zval_dtor(free_op2.var);
+ }
;
ZEND_VM_NEXT_OPCODE();
}
/* here we are sure we are dealing with an object */
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
if (zptr != NULL) { /* NULL means no success in getting PTR */
}
}
- zval_dtor(free_op2.var);
+ if (1) {
+ zval_ptr_dtor(&property);
+ } else {
+ zval_dtor(free_op2.var);
+ }
;
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_CV != IS_CV) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
}
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_R TSRMLS_CC), _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_R TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_R TSRMLS_CC), dim, 1, BP_VAR_R TSRMLS_CC);
zval_dtor(free_op2.var);
;
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_W TSRMLS_CC), _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_W TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_W TSRMLS_CC), dim, 1, BP_VAR_W TSRMLS_CC);
zval_dtor(free_op2.var);
;
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW TSRMLS_CC), _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_RW TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW TSRMLS_CC), dim, 1, BP_VAR_RW TSRMLS_CC);
zval_dtor(free_op2.var);
;
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_IS TSRMLS_CC), _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_IS TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_IS TSRMLS_CC), dim, 1, BP_VAR_IS TSRMLS_CC);
zval_dtor(free_op2.var);
;
ZEND_VM_NEXT_OPCODE();
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
int type = ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)?BP_VAR_W:BP_VAR_R;
+ zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, type TSRMLS_CC), _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), type TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, type TSRMLS_CC), dim, 1, type TSRMLS_CC);
zval_dtor(free_op2.var);
;
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
/* Not needed in DIM_UNSET
if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
}
*/
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_UNSET TSRMLS_CC), _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_UNSET TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_UNSET TSRMLS_CC), dim, 1, BP_VAR_UNSET TSRMLS_CC);
zval_dtor(free_op2.var);
;
if (EX_T(opline->result.u.var).var.ptr_ptr == NULL) {
if (container->type != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
zend_error(E_NOTICE, "Trying to get property of non-object");
*retval = EG(uninitialized_zval_ptr);
+ SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
+ AI_USE_PTR(EX_T(opline->result.u.var).var);
} else {
zend_free_op free_op2;
zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zval tmp;
- switch (IS_TMP_VAR) {
- case IS_CONST:
- /* already a constant string */
- break;
- case IS_CV:
- case IS_VAR:
- tmp = *offset;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- offset = &tmp;
- break;
- case IS_TMP_VAR:
- convert_to_string(offset);
- break;
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(offset);
}
/* here we are sure we are dealing with an object */
*retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
- if (offset == &tmp) {
- zval_dtor(offset);
- }
- zval_dtor(free_op2.var);
if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
zval_dtor(*retval);
FREE_ZVAL(*retval);
- ZEND_VM_NEXT_OPCODE();
+ } else {
+ SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
+ AI_USE_PTR(EX_T(opline->result.u.var).var);
+ }
+
+ if (1) {
+ zval_ptr_dtor(&offset);
+ } else {
+ zval_dtor(free_op2.var);
}
}
- SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
- AI_USE_PTR(EX_T(opline->result.u.var).var);
;
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_CV != IS_CV) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
}
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_W TSRMLS_CC), _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_W TSRMLS_CC);
- zval_dtor(free_op2.var);
+
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_W TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
+ if (1) {
+ zval_ptr_dtor(&property);
+ } else {
+ zval_dtor(free_op2.var);
+ }
;
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW TSRMLS_CC), _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_RW TSRMLS_CC);
- zval_dtor(free_op2.var);
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW TSRMLS_CC), property, BP_VAR_RW TSRMLS_CC);
+ if (1) {
+ zval_ptr_dtor(&property);
+ } else {
+ zval_dtor(free_op2.var);
+ }
;
ZEND_VM_NEXT_OPCODE();
}
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
/* Behave like FETCH_OBJ_W */
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_W TSRMLS_CC), _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_W TSRMLS_CC);
- zval_dtor(free_op2.var);
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_W TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
+ if (1) {
+ zval_ptr_dtor(&property);
+ } else {
+ zval_dtor(free_op2.var);
+ }
;
ZEND_VM_NEXT_OPCODE();
} else {
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2, free_res;
+ zval *property = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_R TSRMLS_CC), _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
- zval_dtor(free_op2.var);
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_R TSRMLS_CC), property, BP_VAR_R TSRMLS_CC);
+ if (1) {
+ zval_ptr_dtor(&property);
+ } else {
+ zval_dtor(free_op2.var);
+ }
;
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
} else {
zend_free_op free_op2, free_op_data1;
zval *value;
+ zval *dim = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_W TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 1, BP_VAR_W TSRMLS_CC);
zval_dtor(free_op2.var);
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
long index;
if (container) {
- HashTable *ht;
if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
SEPARATE_ZVAL_IF_NOT_REF(container);
}
if (opline->extended_value == ZEND_UNSET_DIM) {
switch (Z_TYPE_PP(container)) {
- case IS_ARRAY:
- ht = Z_ARRVAL_PP(container);
+ case IS_ARRAY: {
+ HashTable *ht = Z_ARRVAL_PP(container);
+
+ switch (offset->type) {
+ case IS_DOUBLE:
+ case IS_RESOURCE:
+ case IS_BOOL:
+ case IS_LONG:
+ if (offset->type == IS_DOUBLE) {
+ index = (long) offset->value.dval;
+ } else {
+ index = offset->value.lval;
+ }
+
+ zend_hash_index_del(ht, index);
+ break;
+ case IS_STRING:
+ if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
+ ht == &EG(symbol_table)) {
+ zend_execute_data *ex;
+ ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
+
+ for (ex = execute_data; ex; ex = ex->prev_execute_data) {
+ if (ex->symbol_table == ht) {
+ int i;
+
+ for (i = 0; i < ex->op_array->last_var; i++) {
+ if (ex->op_array->vars[i].hash_value == hash_value &&
+ ex->op_array->vars[i].name_len == offset->value.str.len &&
+ !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
+ ex->CVs[i] = NULL;
+ break;
+ }
+ }
+ }
+ }
+ }
+ break;
+ case IS_NULL:
+ zend_hash_del(ht, "", sizeof(""));
+ break;
+ default:
+ zend_error(E_WARNING, "Illegal offset type in unset");
+ break;
+ }
+ zval_dtor(free_op2.var);
break;
+ }
case IS_OBJECT:
- ht = NULL;
if (!Z_OBJ_HT_P(*container)->unset_dimension) {
zend_error_noreturn(E_ERROR, "Cannot use object as array");
}
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
+ if (1) {
+ zval_ptr_dtor(&offset);
+ } else {
+ zval_dtor(free_op2.var);
+ }
break;
case IS_STRING:
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
ZEND_VM_CONTINUE(); /* bailed out before */
default:
- ht = NULL;
+ zval_dtor(free_op2.var);
break;
}
} else { /* ZEND_UNSET_OBJ */
- ht = NULL;
if (Z_TYPE_PP(container) == IS_OBJECT) {
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
- }
- }
- if (ht) {
- switch (offset->type) {
- case IS_DOUBLE:
- case IS_RESOURCE:
- case IS_BOOL:
- case IS_LONG:
- if (offset->type == IS_DOUBLE) {
- index = (long) offset->value.dval;
- } else {
- index = offset->value.lval;
- }
-
- zend_hash_index_del(ht, index);
- break;
- case IS_STRING:
- if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
- ht == &EG(symbol_table)) {
- zend_execute_data *ex;
- ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
-
- for (ex = execute_data; ex; ex = ex->prev_execute_data) {
- if (ex->symbol_table == ht) {
- int i;
-
- for (i = 0; i < ex->op_array->last_var; i++) {
- if (ex->op_array->vars[i].hash_value == hash_value &&
- ex->op_array->vars[i].name_len == offset->value.str.len &&
- !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
- ex->CVs[i] = NULL;
- break;
- }
- }
- }
- }
- }
- break;
- case IS_NULL:
- zend_hash_del(ht, "", sizeof(""));
- break;
- default:
- zend_error(E_WARNING, "Illegal offset type in unset");
- break;
+ if (1) {
+ zval_ptr_dtor(&offset);
+ } else {
+ zval_dtor(free_op2.var);
+ }
}
}
} else {
/* overloaded element */
+ zval_dtor(free_op2.var);
}
- zval_dtor(free_op2.var);
;
ZEND_VM_NEXT_OPCODE();
static int zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
{
zend_op *opline = EX(opline);
- zend_free_op free_op1, free_op2;
+ zend_free_op free_op1;
zval **container = _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_IS TSRMLS_CC);
- zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
zval **value = NULL;
int result = 0;
long index;
if (container) {
+ zend_free_op free_op2;
+ zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
+
if ((*container)->type == IS_ARRAY) {
HashTable *ht;
int isset = 0;
}
break;
}
+ zval_dtor(free_op2.var);
} else if ((*container)->type == IS_OBJECT) {
+ if (1) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
if (prop_dim) {
result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
} else {
result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
}
+ if (1) {
+ zval_ptr_dtor(&offset);
+ } else {
+ zval_dtor(free_op2.var);
+ }
} else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
zval tmp;
break;
}
}
+ zval_dtor(free_op2.var);
+ } else {
+ zval_dtor(free_op2.var);
}
}
break;
}
- zval_dtor(free_op2.var);
;
ZEND_VM_NEXT_OPCODE();
zval *object;
zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
- zval tmp;
znode *result = &opline->result;
zval **retval = &EX_T(result->u.var).var.ptr;
int have_get_ptr = 0;
}
} else {
/* here we are sure we are dealing with an object */
- switch (IS_VAR) {
- case IS_CONST:
- /* already a constant string */
- break;
- case IS_CV:
- case IS_VAR:
- tmp = *property;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- property = &tmp;
- break;
- case IS_TMP_VAR:
- convert_to_string(property);
- break;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
}
/* here property is a string */
}
}
- if (property == &tmp) {
- zval_dtor(property);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
}
-
- if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
FREE_OP(free_op_data1);
}
return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
} else {
zend_op *op_data = opline+1;
+ zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW TSRMLS_CC), _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_RW TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), &free_op_data2, BP_VAR_RW);
increment_opline = 1;
/* here we are sure we are dealing with an object */
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
if (zptr != NULL) { /* NULL means no success in getting PTR */
}
}
- if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ }
;
ZEND_VM_NEXT_OPCODE();
}
/* here we are sure we are dealing with an object */
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
if (zptr != NULL) { /* NULL means no success in getting PTR */
}
}
- if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ }
;
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_CV != IS_CV) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
}
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_R TSRMLS_CC), _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_R TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_R TSRMLS_CC), dim, 0, BP_VAR_R TSRMLS_CC);
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
;
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_W TSRMLS_CC), _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_W TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_W TSRMLS_CC), dim, 0, BP_VAR_W TSRMLS_CC);
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
;
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW TSRMLS_CC), _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_RW TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
;
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_IS TSRMLS_CC), _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_IS TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_IS TSRMLS_CC), dim, 0, BP_VAR_IS TSRMLS_CC);
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
;
ZEND_VM_NEXT_OPCODE();
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
int type = ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)?BP_VAR_W:BP_VAR_R;
+ zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, type TSRMLS_CC), _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), type TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, type TSRMLS_CC), dim, 0, type TSRMLS_CC);
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
;
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
/* Not needed in DIM_UNSET
if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
}
*/
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_UNSET TSRMLS_CC), _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_UNSET TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_UNSET TSRMLS_CC), dim, 0, BP_VAR_UNSET TSRMLS_CC);
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
;
if (EX_T(opline->result.u.var).var.ptr_ptr == NULL) {
if (container->type != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
zend_error(E_NOTICE, "Trying to get property of non-object");
*retval = EG(uninitialized_zval_ptr);
+ SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
+ AI_USE_PTR(EX_T(opline->result.u.var).var);
} else {
zend_free_op free_op2;
zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zval tmp;
- switch (IS_VAR) {
- case IS_CONST:
- /* already a constant string */
- break;
- case IS_CV:
- case IS_VAR:
- tmp = *offset;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- offset = &tmp;
- break;
- case IS_TMP_VAR:
- convert_to_string(offset);
- break;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
}
/* here we are sure we are dealing with an object */
*retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
- if (offset == &tmp) {
- zval_dtor(offset);
- }
- if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
zval_dtor(*retval);
FREE_ZVAL(*retval);
- ZEND_VM_NEXT_OPCODE();
+ } else {
+ SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
+ AI_USE_PTR(EX_T(opline->result.u.var).var);
+ }
+
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
}
}
- SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
- AI_USE_PTR(EX_T(opline->result.u.var).var);
;
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_CV != IS_CV) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
}
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_W TSRMLS_CC), _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_W TSRMLS_CC);
- if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_W TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ }
;
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW TSRMLS_CC), _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_RW TSRMLS_CC);
- if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW TSRMLS_CC), property, BP_VAR_RW TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ }
;
ZEND_VM_NEXT_OPCODE();
}
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
/* Behave like FETCH_OBJ_W */
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_W TSRMLS_CC), _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_W TSRMLS_CC);
- if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_W TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ }
;
ZEND_VM_NEXT_OPCODE();
} else {
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2, free_res;
+ zval *property = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_R TSRMLS_CC), _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
- if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_R TSRMLS_CC), property, BP_VAR_R TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ }
;
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
} else {
zend_free_op free_op2, free_op_data1;
zval *value;
+ zval *dim = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_W TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 0, BP_VAR_W TSRMLS_CC);
if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
long index;
if (container) {
- HashTable *ht;
if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
SEPARATE_ZVAL_IF_NOT_REF(container);
}
if (opline->extended_value == ZEND_UNSET_DIM) {
switch (Z_TYPE_PP(container)) {
- case IS_ARRAY:
- ht = Z_ARRVAL_PP(container);
+ case IS_ARRAY: {
+ HashTable *ht = Z_ARRVAL_PP(container);
+
+ switch (offset->type) {
+ case IS_DOUBLE:
+ case IS_RESOURCE:
+ case IS_BOOL:
+ case IS_LONG:
+ if (offset->type == IS_DOUBLE) {
+ index = (long) offset->value.dval;
+ } else {
+ index = offset->value.lval;
+ }
+
+ zend_hash_index_del(ht, index);
+ break;
+ case IS_STRING:
+ if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
+ ht == &EG(symbol_table)) {
+ zend_execute_data *ex;
+ ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
+
+ for (ex = execute_data; ex; ex = ex->prev_execute_data) {
+ if (ex->symbol_table == ht) {
+ int i;
+
+ for (i = 0; i < ex->op_array->last_var; i++) {
+ if (ex->op_array->vars[i].hash_value == hash_value &&
+ ex->op_array->vars[i].name_len == offset->value.str.len &&
+ !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
+ ex->CVs[i] = NULL;
+ break;
+ }
+ }
+ }
+ }
+ }
+ break;
+ case IS_NULL:
+ zend_hash_del(ht, "", sizeof(""));
+ break;
+ default:
+ zend_error(E_WARNING, "Illegal offset type in unset");
+ break;
+ }
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
break;
+ }
case IS_OBJECT:
- ht = NULL;
if (!Z_OBJ_HT_P(*container)->unset_dimension) {
zend_error_noreturn(E_ERROR, "Cannot use object as array");
}
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ }
break;
case IS_STRING:
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
ZEND_VM_CONTINUE(); /* bailed out before */
default:
- ht = NULL;
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
break;
}
} else { /* ZEND_UNSET_OBJ */
- ht = NULL;
if (Z_TYPE_PP(container) == IS_OBJECT) {
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
- }
- }
- if (ht) {
- switch (offset->type) {
- case IS_DOUBLE:
- case IS_RESOURCE:
- case IS_BOOL:
- case IS_LONG:
- if (offset->type == IS_DOUBLE) {
- index = (long) offset->value.dval;
- } else {
- index = offset->value.lval;
- }
-
- zend_hash_index_del(ht, index);
- break;
- case IS_STRING:
- if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
- ht == &EG(symbol_table)) {
- zend_execute_data *ex;
- ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
-
- for (ex = execute_data; ex; ex = ex->prev_execute_data) {
- if (ex->symbol_table == ht) {
- int i;
-
- for (i = 0; i < ex->op_array->last_var; i++) {
- if (ex->op_array->vars[i].hash_value == hash_value &&
- ex->op_array->vars[i].name_len == offset->value.str.len &&
- !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
- ex->CVs[i] = NULL;
- break;
- }
- }
- }
- }
- }
- break;
- case IS_NULL:
- zend_hash_del(ht, "", sizeof(""));
- break;
- default:
- zend_error(E_WARNING, "Illegal offset type in unset");
- break;
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ }
}
}
} else {
/* overloaded element */
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
}
- if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
;
ZEND_VM_NEXT_OPCODE();
static int zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
{
zend_op *opline = EX(opline);
- zend_free_op free_op1, free_op2;
+ zend_free_op free_op1;
zval **container = _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_IS TSRMLS_CC);
- zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
zval **value = NULL;
int result = 0;
long index;
if (container) {
+ zend_free_op free_op2;
+ zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
+
if ((*container)->type == IS_ARRAY) {
HashTable *ht;
int isset = 0;
}
break;
}
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
} else if ((*container)->type == IS_OBJECT) {
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
if (prop_dim) {
result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
} else {
result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
}
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ }
} else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
zval tmp;
break;
}
}
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+ } else {
+ if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
}
}
break;
}
- if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
;
ZEND_VM_NEXT_OPCODE();
zval *object;
zval *property = _get_zval_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
- zval tmp;
znode *result = &opline->result;
zval **retval = &EX_T(result->u.var).var.ptr;
int have_get_ptr = 0;
}
} else {
/* here we are sure we are dealing with an object */
- switch (IS_UNUSED) {
- case IS_CONST:
- /* already a constant string */
- break;
- case IS_CV:
- case IS_VAR:
- tmp = *property;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- property = &tmp;
- break;
- case IS_TMP_VAR:
- convert_to_string(property);
- break;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
}
/* here property is a string */
}
}
- if (property == &tmp) {
- zval_dtor(property);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
}
-
- ;
FREE_OP(free_op_data1);
}
return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
} else {
zend_op *op_data = opline+1;
+ zval *dim = _get_zval_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW TSRMLS_CC), _get_zval_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_RW TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), &free_op_data2, BP_VAR_RW);
increment_opline = 1;
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_W TSRMLS_CC), _get_zval_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_W TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_W TSRMLS_CC), dim, 0, BP_VAR_W TSRMLS_CC);
;
;
ZEND_VM_NEXT_OPCODE();
} else {
zend_free_op free_op2, free_op_data1;
zval *value;
+ zval *dim = _get_zval_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, _get_zval_ptr_unused(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC), BP_VAR_W TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 0, BP_VAR_W TSRMLS_CC);
;
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
zval *object;
zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
- zval tmp;
znode *result = &opline->result;
zval **retval = &EX_T(result->u.var).var.ptr;
int have_get_ptr = 0;
}
} else {
/* here we are sure we are dealing with an object */
- switch (IS_CV) {
- case IS_CONST:
- /* already a constant string */
- break;
- case IS_CV:
- case IS_VAR:
- tmp = *property;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- property = &tmp;
- break;
- case IS_TMP_VAR:
- convert_to_string(property);
- break;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
}
/* here property is a string */
}
}
- if (property == &tmp) {
- zval_dtor(property);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
}
-
- ;
FREE_OP(free_op_data1);
}
return zend_binary_assign_op_obj_helper_SPEC_CV_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
} else {
zend_op *op_data = opline+1;
+ zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW TSRMLS_CC), _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC), BP_VAR_RW TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), &free_op_data2, BP_VAR_RW);
increment_opline = 1;
/* here we are sure we are dealing with an object */
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
if (zptr != NULL) { /* NULL means no success in getting PTR */
}
}
- ;
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
;
ZEND_VM_NEXT_OPCODE();
}
/* here we are sure we are dealing with an object */
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
if (zptr != NULL) { /* NULL means no success in getting PTR */
}
}
- ;
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
;
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_CV != IS_CV) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
}
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_R TSRMLS_CC), _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC), BP_VAR_R TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_R TSRMLS_CC), dim, 0, BP_VAR_R TSRMLS_CC);
;
;
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_W TSRMLS_CC), _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC), BP_VAR_W TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_W TSRMLS_CC), dim, 0, BP_VAR_W TSRMLS_CC);
;
;
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW TSRMLS_CC), _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC), BP_VAR_RW TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW TSRMLS_CC), dim, 0, BP_VAR_RW TSRMLS_CC);
;
;
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_IS TSRMLS_CC), _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC), BP_VAR_IS TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_IS TSRMLS_CC), dim, 0, BP_VAR_IS TSRMLS_CC);
;
;
ZEND_VM_NEXT_OPCODE();
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
int type = ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)?BP_VAR_W:BP_VAR_R;
+ zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, type TSRMLS_CC), _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC), type TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, type TSRMLS_CC), dim, 0, type TSRMLS_CC);
;
;
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
/* Not needed in DIM_UNSET
if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
}
*/
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_UNSET TSRMLS_CC), _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC), BP_VAR_UNSET TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_UNSET TSRMLS_CC), dim, 0, BP_VAR_UNSET TSRMLS_CC);
;
;
if (EX_T(opline->result.u.var).var.ptr_ptr == NULL) {
if (container->type != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
zend_error(E_NOTICE, "Trying to get property of non-object");
*retval = EG(uninitialized_zval_ptr);
+ SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
+ AI_USE_PTR(EX_T(opline->result.u.var).var);
} else {
zend_free_op free_op2;
zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
- zval tmp;
- switch (IS_CV) {
- case IS_CONST:
- /* already a constant string */
- break;
- case IS_CV:
- case IS_VAR:
- tmp = *offset;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- offset = &tmp;
- break;
- case IS_TMP_VAR:
- convert_to_string(offset);
- break;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
}
/* here we are sure we are dealing with an object */
*retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
- if (offset == &tmp) {
- zval_dtor(offset);
- }
- ;
if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
zval_dtor(*retval);
FREE_ZVAL(*retval);
- ZEND_VM_NEXT_OPCODE();
+ } else {
+ SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
+ AI_USE_PTR(EX_T(opline->result.u.var).var);
+ }
+
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ ;
}
}
- SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
- AI_USE_PTR(EX_T(opline->result.u.var).var);
;
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
if (opline->extended_value == ZEND_FETCH_ADD_LOCK && IS_CV != IS_CV) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
}
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_W TSRMLS_CC), _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC), IS_CV, BP_VAR_W TSRMLS_CC);
- ;
+
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_W TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
;
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW TSRMLS_CC), _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC), IS_CV, BP_VAR_RW TSRMLS_CC);
- ;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW TSRMLS_CC), property, BP_VAR_RW TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
;
ZEND_VM_NEXT_OPCODE();
}
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
/* Behave like FETCH_OBJ_W */
zend_free_op free_op1, free_op2;
+ zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_W TSRMLS_CC), _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC), IS_CV, BP_VAR_W TSRMLS_CC);
- ;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_W TSRMLS_CC), property, BP_VAR_W TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
;
ZEND_VM_NEXT_OPCODE();
} else {
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2, free_res;
+ zval *property = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_R TSRMLS_CC), _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
- ;
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_R TSRMLS_CC), property, BP_VAR_R TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&property);
+ } else {
+ ;
+ }
;
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
} else {
zend_free_op free_op2, free_op_data1;
zval *value;
+ zval *dim = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC), BP_VAR_W TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, 0, BP_VAR_W TSRMLS_CC);
;
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
long index;
if (container) {
- HashTable *ht;
if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
SEPARATE_ZVAL_IF_NOT_REF(container);
}
if (opline->extended_value == ZEND_UNSET_DIM) {
switch (Z_TYPE_PP(container)) {
- case IS_ARRAY:
- ht = Z_ARRVAL_PP(container);
+ case IS_ARRAY: {
+ HashTable *ht = Z_ARRVAL_PP(container);
+
+ switch (offset->type) {
+ case IS_DOUBLE:
+ case IS_RESOURCE:
+ case IS_BOOL:
+ case IS_LONG:
+ if (offset->type == IS_DOUBLE) {
+ index = (long) offset->value.dval;
+ } else {
+ index = offset->value.lval;
+ }
+
+ zend_hash_index_del(ht, index);
+ break;
+ case IS_STRING:
+ if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
+ ht == &EG(symbol_table)) {
+ zend_execute_data *ex;
+ ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
+
+ for (ex = execute_data; ex; ex = ex->prev_execute_data) {
+ if (ex->symbol_table == ht) {
+ int i;
+
+ for (i = 0; i < ex->op_array->last_var; i++) {
+ if (ex->op_array->vars[i].hash_value == hash_value &&
+ ex->op_array->vars[i].name_len == offset->value.str.len &&
+ !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
+ ex->CVs[i] = NULL;
+ break;
+ }
+ }
+ }
+ }
+ }
+ break;
+ case IS_NULL:
+ zend_hash_del(ht, "", sizeof(""));
+ break;
+ default:
+ zend_error(E_WARNING, "Illegal offset type in unset");
+ break;
+ }
+ ;
break;
+ }
case IS_OBJECT:
- ht = NULL;
if (!Z_OBJ_HT_P(*container)->unset_dimension) {
zend_error_noreturn(E_ERROR, "Cannot use object as array");
}
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ ;
+ }
break;
case IS_STRING:
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
ZEND_VM_CONTINUE(); /* bailed out before */
default:
- ht = NULL;
+ ;
break;
}
} else { /* ZEND_UNSET_OBJ */
- ht = NULL;
if (Z_TYPE_PP(container) == IS_OBJECT) {
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
- }
- }
- if (ht) {
- switch (offset->type) {
- case IS_DOUBLE:
- case IS_RESOURCE:
- case IS_BOOL:
- case IS_LONG:
- if (offset->type == IS_DOUBLE) {
- index = (long) offset->value.dval;
- } else {
- index = offset->value.lval;
- }
-
- zend_hash_index_del(ht, index);
- break;
- case IS_STRING:
- if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
- ht == &EG(symbol_table)) {
- zend_execute_data *ex;
- ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
-
- for (ex = execute_data; ex; ex = ex->prev_execute_data) {
- if (ex->symbol_table == ht) {
- int i;
-
- for (i = 0; i < ex->op_array->last_var; i++) {
- if (ex->op_array->vars[i].hash_value == hash_value &&
- ex->op_array->vars[i].name_len == offset->value.str.len &&
- !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
- ex->CVs[i] = NULL;
- break;
- }
- }
- }
- }
- }
- break;
- case IS_NULL:
- zend_hash_del(ht, "", sizeof(""));
- break;
- default:
- zend_error(E_WARNING, "Illegal offset type in unset");
- break;
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ ;
+ }
}
}
} else {
/* overloaded element */
+ ;
}
;
- ;
ZEND_VM_NEXT_OPCODE();
}
static int zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
{
zend_op *opline = EX(opline);
- zend_free_op free_op1, free_op2;
+ zend_free_op free_op1;
zval **container = _get_obj_zval_ptr_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_IS TSRMLS_CC);
- zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
zval **value = NULL;
int result = 0;
long index;
if (container) {
+ zend_free_op free_op2;
+ zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), &free_op2, BP_VAR_R TSRMLS_CC);
+
if ((*container)->type == IS_ARRAY) {
HashTable *ht;
int isset = 0;
}
break;
}
+ ;
} else if ((*container)->type == IS_OBJECT) {
+ if (0) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
if (prop_dim) {
result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
} else {
result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
}
+ if (0) {
+ zval_ptr_dtor(&offset);
+ } else {
+ ;
+ }
} else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
zval tmp;
break;
}
}
+ ;
+ } else {
+ ;
}
}
break;
}
- ;
;
ZEND_VM_NEXT_OPCODE();
zval *object;
zval *property = get_zval_ptr(&opline->op2, EX(Ts), &free_op2, BP_VAR_R);
zval *value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
- zval tmp;
znode *result = &opline->result;
zval **retval = &EX_T(result->u.var).var.ptr;
int have_get_ptr = 0;
}
} else {
/* here we are sure we are dealing with an object */
- switch (opline->op2.op_type) {
- case IS_CONST:
- /* already a constant string */
- break;
- case IS_CV:
- case IS_VAR:
- tmp = *property;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- property = &tmp;
- break;
- case IS_TMP_VAR:
- convert_to_string(property);
- break;
+ if (IS_TMP_FREE(free_op2)) {
+ MAKE_REAL_ZVAL_PTR(property);
}
/* here property is a string */
}
}
- if (property == &tmp) {
- zval_dtor(property);
+ if (IS_TMP_FREE(free_op2)) {
+ zval_ptr_dtor(&property);
+ } else {
+ FREE_OP(free_op2);
}
-
- FREE_OP(free_op2);
FREE_OP(free_op_data1);
}
return zend_binary_assign_op_obj_helper(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
} else {
zend_op *op_data = opline+1;
+ zval *dim = get_zval_ptr(&opline->op2, EX(Ts), &free_op2, BP_VAR_R);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), get_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW), get_zval_ptr(&opline->op2, EX(Ts), &free_op2, BP_VAR_R), BP_VAR_RW TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), get_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW), dim, IS_TMP_FREE(free_op2), BP_VAR_RW TSRMLS_CC);
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
var_ptr = get_zval_ptr_ptr(&op_data->op2, EX(Ts), &free_op_data2, BP_VAR_RW);
increment_opline = 1;
/* here we are sure we are dealing with an object */
+ if (IS_TMP_FREE(free_op2)) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
if (zptr != NULL) { /* NULL means no success in getting PTR */
}
}
- FREE_OP(free_op2);
+ if (IS_TMP_FREE(free_op2)) {
+ zval_ptr_dtor(&property);
+ } else {
+ FREE_OP(free_op2);
+ }
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
}
/* here we are sure we are dealing with an object */
+ if (IS_TMP_FREE(free_op2)) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+
if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property TSRMLS_CC);
if (zptr != NULL) { /* NULL means no success in getting PTR */
}
}
- FREE_OP(free_op2);
+ if (IS_TMP_FREE(free_op2)) {
+ zval_ptr_dtor(&property);
+ } else {
+ FREE_OP(free_op2);
+ }
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = get_zval_ptr(&opline->op2, EX(Ts), &free_op2, BP_VAR_R);
if (opline->extended_value == ZEND_FETCH_ADD_LOCK && opline->op1.op_type != IS_CV) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
}
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), get_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1, BP_VAR_R), get_zval_ptr(&opline->op2, EX(Ts), &free_op2, BP_VAR_R), BP_VAR_R TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), get_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1, BP_VAR_R), dim, IS_TMP_FREE(free_op2), BP_VAR_R TSRMLS_CC);
FREE_OP(free_op2);
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = get_zval_ptr(&opline->op2, EX(Ts), &free_op2, BP_VAR_R);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), get_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1, BP_VAR_W), get_zval_ptr(&opline->op2, EX(Ts), &free_op2, BP_VAR_R), BP_VAR_W TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), get_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1, BP_VAR_W), dim, IS_TMP_FREE(free_op2), BP_VAR_W TSRMLS_CC);
FREE_OP(free_op2);
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = get_zval_ptr(&opline->op2, EX(Ts), &free_op2, BP_VAR_R);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), get_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW), get_zval_ptr(&opline->op2, EX(Ts), &free_op2, BP_VAR_R), BP_VAR_RW TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), get_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW), dim, IS_TMP_FREE(free_op2), BP_VAR_RW TSRMLS_CC);
FREE_OP(free_op2);
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = get_zval_ptr(&opline->op2, EX(Ts), &free_op2, BP_VAR_R);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), get_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1, BP_VAR_IS), get_zval_ptr(&opline->op2, EX(Ts), &free_op2, BP_VAR_R), BP_VAR_IS TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), get_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1, BP_VAR_IS), dim, IS_TMP_FREE(free_op2), BP_VAR_IS TSRMLS_CC);
FREE_OP(free_op2);
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
int type = ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)?BP_VAR_W:BP_VAR_R;
+ zval *dim = get_zval_ptr(&opline->op2, EX(Ts), &free_op2, BP_VAR_R);
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), get_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1, type), get_zval_ptr(&opline->op2, EX(Ts), &free_op2, BP_VAR_R), type TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), get_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1, type), dim, IS_TMP_FREE(free_op2), type TSRMLS_CC);
FREE_OP(free_op2);
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *dim = get_zval_ptr(&opline->op2, EX(Ts), &free_op2, BP_VAR_R);
/* Not needed in DIM_UNSET
if (opline->extended_value == ZEND_FETCH_ADD_LOCK) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
}
*/
- zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), get_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1, BP_VAR_UNSET), get_zval_ptr(&opline->op2, EX(Ts), &free_op2, BP_VAR_R), BP_VAR_UNSET TSRMLS_CC);
+ zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), get_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1, BP_VAR_UNSET), dim, IS_TMP_FREE(free_op2), BP_VAR_UNSET TSRMLS_CC);
FREE_OP(free_op2);
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
if (EX_T(opline->result.u.var).var.ptr_ptr == NULL) {
if (container->type != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
zend_error(E_NOTICE, "Trying to get property of non-object");
*retval = EG(uninitialized_zval_ptr);
+ SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
+ AI_USE_PTR(EX_T(opline->result.u.var).var);
} else {
zend_free_op free_op2;
zval *offset = get_zval_ptr(&opline->op2, EX(Ts), &free_op2, BP_VAR_R);
- zval tmp;
- switch (opline->op2.op_type) {
- case IS_CONST:
- /* already a constant string */
- break;
- case IS_CV:
- case IS_VAR:
- tmp = *offset;
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- offset = &tmp;
- break;
- case IS_TMP_VAR:
- convert_to_string(offset);
- break;
+ if (IS_TMP_FREE(free_op2)) {
+ MAKE_REAL_ZVAL_PTR(offset);
}
/* here we are sure we are dealing with an object */
*retval = Z_OBJ_HT_P(container)->read_property(container, offset, type TSRMLS_CC);
- if (offset == &tmp) {
- zval_dtor(offset);
- }
- FREE_OP(free_op2);
if (RETURN_VALUE_UNUSED(&opline->result) && ((*retval)->refcount == 0)) {
zval_dtor(*retval);
FREE_ZVAL(*retval);
- ZEND_VM_NEXT_OPCODE();
+ } else {
+ SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
+ AI_USE_PTR(EX_T(opline->result.u.var).var);
+ }
+
+ if (IS_TMP_FREE(free_op2)) {
+ zval_ptr_dtor(&offset);
+ } else {
+ FREE_OP(free_op2);
}
}
- SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
- AI_USE_PTR(EX_T(opline->result.u.var).var);
FREE_OP(free_op1);
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *property = get_zval_ptr(&opline->op2, EX(Ts), &free_op2, BP_VAR_R);
if (opline->extended_value == ZEND_FETCH_ADD_LOCK && opline->op1.op_type != IS_CV) {
PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
EX_T(opline->op1.u.var).var.ptr = *EX_T(opline->op1.u.var).var.ptr_ptr;
}
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), get_obj_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1, BP_VAR_W), get_zval_ptr(&opline->op2, EX(Ts), &free_op2, BP_VAR_R), opline->op2.op_type, BP_VAR_W TSRMLS_CC);
- FREE_OP(free_op2);
+
+ if (IS_TMP_FREE(free_op2)) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), get_obj_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1, BP_VAR_W), property, BP_VAR_W TSRMLS_CC);
+ if (IS_TMP_FREE(free_op2)) {
+ zval_ptr_dtor(&property);
+ } else {
+ FREE_OP(free_op2);
+ }
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
}
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2;
+ zval *property = get_zval_ptr(&opline->op2, EX(Ts), &free_op2, BP_VAR_R);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), get_obj_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW), get_zval_ptr(&opline->op2, EX(Ts), &free_op2, BP_VAR_R), opline->op2.op_type, BP_VAR_RW TSRMLS_CC);
- FREE_OP(free_op2);
+ if (IS_TMP_FREE(free_op2)) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), get_obj_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1, BP_VAR_RW), property, BP_VAR_RW TSRMLS_CC);
+ if (IS_TMP_FREE(free_op2)) {
+ zval_ptr_dtor(&property);
+ } else {
+ FREE_OP(free_op2);
+ }
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
}
if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)) {
/* Behave like FETCH_OBJ_W */
zend_free_op free_op1, free_op2;
+ zval *property = get_zval_ptr(&opline->op2, EX(Ts), &free_op2, BP_VAR_R);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), get_obj_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1, BP_VAR_W), get_zval_ptr(&opline->op2, EX(Ts), &free_op2, BP_VAR_R), opline->op2.op_type, BP_VAR_W TSRMLS_CC);
- FREE_OP(free_op2);
+ if (IS_TMP_FREE(free_op2)) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), get_obj_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1, BP_VAR_W), property, BP_VAR_W TSRMLS_CC);
+ if (IS_TMP_FREE(free_op2)) {
+ zval_ptr_dtor(&property);
+ } else {
+ FREE_OP(free_op2);
+ }
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
} else {
{
zend_op *opline = EX(opline);
zend_free_op free_op1, free_op2, free_res;
+ zval *property = get_zval_ptr(&opline->op2, EX(Ts), &free_op2, BP_VAR_R);
- zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), get_obj_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1, BP_VAR_R), get_zval_ptr(&opline->op2, EX(Ts), &free_op2, BP_VAR_R), opline->op2.op_type, BP_VAR_R TSRMLS_CC);
- FREE_OP(free_op2);
+ if (IS_TMP_FREE(free_op2)) {
+ MAKE_REAL_ZVAL_PTR(property);
+ }
+ zend_fetch_property_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), get_obj_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1, BP_VAR_R), property, BP_VAR_R TSRMLS_CC);
+ if (IS_TMP_FREE(free_op2)) {
+ zval_ptr_dtor(&property);
+ } else {
+ FREE_OP(free_op2);
+ }
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
PZVAL_UNLOCK(*EX_T(opline->result.u.var).var.ptr_ptr, &free_res);
} else {
zend_free_op free_op2, free_op_data1;
zval *value;
+ zval *dim = get_zval_ptr(&opline->op2, EX(Ts), &free_op2, BP_VAR_R);
- zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, get_zval_ptr(&opline->op2, EX(Ts), &free_op2, BP_VAR_R), BP_VAR_W TSRMLS_CC);
+ zend_fetch_dimension_address(&EX_T(op_data->op2.u.var), object_ptr, dim, IS_TMP_FREE(free_op2), BP_VAR_W TSRMLS_CC);
FREE_OP(free_op2);
value = get_zval_ptr(&op_data->op1, EX(Ts), &free_op_data1, BP_VAR_R);
long index;
if (container) {
- HashTable *ht;
if (opline->op1.op_type == IS_CV && container != &EG(uninitialized_zval_ptr)) {
SEPARATE_ZVAL_IF_NOT_REF(container);
}
if (opline->extended_value == ZEND_UNSET_DIM) {
switch (Z_TYPE_PP(container)) {
- case IS_ARRAY:
- ht = Z_ARRVAL_PP(container);
+ case IS_ARRAY: {
+ HashTable *ht = Z_ARRVAL_PP(container);
+
+ switch (offset->type) {
+ case IS_DOUBLE:
+ case IS_RESOURCE:
+ case IS_BOOL:
+ case IS_LONG:
+ if (offset->type == IS_DOUBLE) {
+ index = (long) offset->value.dval;
+ } else {
+ index = offset->value.lval;
+ }
+
+ zend_hash_index_del(ht, index);
+ break;
+ case IS_STRING:
+ if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
+ ht == &EG(symbol_table)) {
+ zend_execute_data *ex;
+ ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
+
+ for (ex = execute_data; ex; ex = ex->prev_execute_data) {
+ if (ex->symbol_table == ht) {
+ int i;
+
+ for (i = 0; i < ex->op_array->last_var; i++) {
+ if (ex->op_array->vars[i].hash_value == hash_value &&
+ ex->op_array->vars[i].name_len == offset->value.str.len &&
+ !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
+ ex->CVs[i] = NULL;
+ break;
+ }
+ }
+ }
+ }
+ }
+ break;
+ case IS_NULL:
+ zend_hash_del(ht, "", sizeof(""));
+ break;
+ default:
+ zend_error(E_WARNING, "Illegal offset type in unset");
+ break;
+ }
+ FREE_OP(free_op2);
break;
+ }
case IS_OBJECT:
- ht = NULL;
if (!Z_OBJ_HT_P(*container)->unset_dimension) {
zend_error_noreturn(E_ERROR, "Cannot use object as array");
}
+ if (IS_TMP_FREE(free_op2)) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
+ if (IS_TMP_FREE(free_op2)) {
+ zval_ptr_dtor(&offset);
+ } else {
+ FREE_OP(free_op2);
+ }
break;
case IS_STRING:
zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
ZEND_VM_CONTINUE(); /* bailed out before */
default:
- ht = NULL;
+ FREE_OP(free_op2);
break;
}
} else { /* ZEND_UNSET_OBJ */
- ht = NULL;
if (Z_TYPE_PP(container) == IS_OBJECT) {
+ if (IS_TMP_FREE(free_op2)) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
Z_OBJ_HT_P(*container)->unset_property(*container, offset TSRMLS_CC);
- }
- }
- if (ht) {
- switch (offset->type) {
- case IS_DOUBLE:
- case IS_RESOURCE:
- case IS_BOOL:
- case IS_LONG:
- if (offset->type == IS_DOUBLE) {
- index = (long) offset->value.dval;
- } else {
- index = offset->value.lval;
- }
-
- zend_hash_index_del(ht, index);
- break;
- case IS_STRING:
- if (zend_symtable_del(ht, offset->value.str.val, offset->value.str.len+1) == SUCCESS &&
- ht == &EG(symbol_table)) {
- zend_execute_data *ex;
- ulong hash_value = zend_inline_hash_func(offset->value.str.val, offset->value.str.len+1);
-
- for (ex = execute_data; ex; ex = ex->prev_execute_data) {
- if (ex->symbol_table == ht) {
- int i;
-
- for (i = 0; i < ex->op_array->last_var; i++) {
- if (ex->op_array->vars[i].hash_value == hash_value &&
- ex->op_array->vars[i].name_len == offset->value.str.len &&
- !memcmp(ex->op_array->vars[i].name, offset->value.str.val, offset->value.str.len)) {
- ex->CVs[i] = NULL;
- break;
- }
- }
- }
- }
- }
- break;
- case IS_NULL:
- zend_hash_del(ht, "", sizeof(""));
- break;
- default:
- zend_error(E_WARNING, "Illegal offset type in unset");
- break;
+ if (IS_TMP_FREE(free_op2)) {
+ zval_ptr_dtor(&offset);
+ } else {
+ FREE_OP(free_op2);
+ }
}
}
} else {
/* overloaded element */
+ FREE_OP(free_op2);
}
- FREE_OP(free_op2);
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
static int zend_isset_isempty_dim_prop_obj_handler(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
{
zend_op *opline = EX(opline);
- zend_free_op free_op1, free_op2;
+ zend_free_op free_op1;
zval **container = get_obj_zval_ptr_ptr(&opline->op1, EX(Ts), &free_op1, BP_VAR_IS);
- zval *offset = get_zval_ptr(&opline->op2, EX(Ts), &free_op2, BP_VAR_R);
zval **value = NULL;
int result = 0;
long index;
if (container) {
+ zend_free_op free_op2;
+ zval *offset = get_zval_ptr(&opline->op2, EX(Ts), &free_op2, BP_VAR_R);
+
if ((*container)->type == IS_ARRAY) {
HashTable *ht;
int isset = 0;
}
break;
}
+ FREE_OP(free_op2);
} else if ((*container)->type == IS_OBJECT) {
+ if (IS_TMP_FREE(free_op2)) {
+ MAKE_REAL_ZVAL_PTR(offset);
+ }
if (prop_dim) {
result = Z_OBJ_HT_P(*container)->has_property(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
} else {
result = Z_OBJ_HT_P(*container)->has_dimension(*container, offset, (opline->extended_value == ZEND_ISEMPTY) TSRMLS_CC);
}
+ if (IS_TMP_FREE(free_op2)) {
+ zval_ptr_dtor(&offset);
+ } else {
+ FREE_OP(free_op2);
+ }
} else if ((*container)->type == IS_STRING && !prop_dim) { /* string offsets */
zval tmp;
break;
}
}
+ FREE_OP(free_op2);
+ } else {
+ FREE_OP(free_op2);
}
}
break;
}
- FREE_OP(free_op2);
if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
ZEND_VM_NEXT_OPCODE();
projects / php / commitdiff