ZEND_VM_NEXT_OPCODE();
}
-static int ZEND_FASTCALL ZEND_PRE_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2), ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
- zend_free_op free_op1;
- zval **var_ptr;
+ zend_free_op free_op1, free_op_data1;
+ zval *object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+ zval *property = EX_CONSTANT(opline->op2);
+ zval *value;
+ zval *zptr;
- SAVE_OPLINE();
- var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+ if (IS_VAR == IS_VAR && UNEXPECTED(object == NULL)) {
+ zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an object");
+ FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
- if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
- zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
+ if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
+ HANDLE_EXCEPTION();
}
- if (IS_VAR == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
- if (RETURN_VALUE_USED(opline)) {
- PZVAL_LOCK(&EG(uninitialized_zval));
- EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+
+ do {
+ value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+
+ if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
+ ZVAL_DEREF(object);
+ if (UNEXPECTED(!make_real_object(object))) {
+ zend_error(E_WARNING, "Attempt to assign property of non-object");
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_NULL(EX_VAR(opline->result.var));
+ }
+ break;
+ }
}
- if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
- }
- SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+ /* here we are sure we are dealing with an object */
+ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
- if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
- && Z_OBJ_HANDLER_PP(var_ptr, get)
- && Z_OBJ_HANDLER_PP(var_ptr, set)) {
- /* proxy object */
- zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
- Z_ADDREF_P(val);
- fast_decrement_function(val);
- Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
- zval_ptr_dtor(&val);
- } else {
- fast_decrement_function(*var_ptr);
- }
+ ZVAL_DEREF(zptr);
+ SEPARATE_ZVAL_NOREF(zptr);
- if (RETURN_VALUE_USED(opline)) {
- PZVAL_LOCK(*var_ptr);
- EX_T(opline->result.var).var.ptr = *var_ptr;
- }
+ binary_op(zptr, zptr, value);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(EX_VAR(opline->result.var), zptr);
+ }
+ } else {
+ zval *z;
- zval rv;
++ zval rv, obj;
+
- if (Z_OBJ_HT_P(object)->read_property &&
- (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) {
++ ZVAL_COPY(&obj, object);
++ if (Z_OBJ_HT(obj)->read_property &&
++ (z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) {
+ if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
+ zval rv;
+ zval *value = Z_OBJ_HT_P(z)->get(z, &rv);
+
+ if (Z_REFCOUNT_P(z) == 0) {
+ zend_objects_store_del(Z_OBJ_P(z));
+ }
+ ZVAL_COPY_VALUE(z, value);
+ }
+ zptr = z;
+ ZVAL_DEREF(z);
+ SEPARATE_ZVAL_NOREF(z);
+ binary_op(z, z, value);
- Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ Z_OBJ_HT(obj)->write_property(&obj, property, z, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ zval_ptr_dtor(&obj);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(EX_VAR(opline->result.var), z);
+ }
+ zval_ptr_dtor(zptr);
+ } else {
+ zend_error(E_WARNING, "Attempt to assign property of non-object");
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_NULL(EX_VAR(opline->result.var));
+ }
+ }
+ }
+ } while (0);
- if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+ FREE_OP(free_op_data1);
+
+ if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
+ /* assign_obj has two opcodes! */
CHECK_EXCEPTION();
+ ZEND_VM_INC_OPCODE();
ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_NEXT_OPCODE();
}
-static int ZEND_FASTCALL ZEND_ECHO_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
+#if 0 || (IS_CONST != IS_UNUSED)
USE_OPLINE
- zend_free_op free_op1;
- zval *z;
-
- SAVE_OPLINE();
- z = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- if (IS_VAR == IS_TMP_VAR && Z_TYPE_P(z) == IS_OBJECT) {
- INIT_PZVAL(z);
+# if 0 || (IS_VAR != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_VAR_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
- zend_print_variable(z);
-
- zval_ptr_dtor_nogc(&free_op1.var);
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_PRINT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
+#if 0 || (IS_CONST != IS_UNUSED)
USE_OPLINE
- ZVAL_LONG(&EX_T(opline->result.var).tmp_var, 1);
- return ZEND_ECHO_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+# if 0 || (IS_VAR != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_VAR_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_JMPZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
+#if 0 || (IS_CONST != IS_UNUSED)
USE_OPLINE
- zend_free_op free_op1;
- zval *val;
- int ret;
- SAVE_OPLINE();
- val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-
- if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
- ret = Z_LVAL_P(val);
- } else {
- ret = i_zend_is_true(val);
- zval_ptr_dtor_nogc(&free_op1.var);
- if (UNEXPECTED(EG(exception) != NULL)) {
- HANDLE_EXCEPTION();
- }
+# if 0 || (IS_VAR != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_VAR_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
- if (!ret) {
-#if DEBUG_ZEND>=2
- printf("Conditional jmp to %d\n", opline->op2.opline_num);
-#endif
- ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
- ZEND_VM_CONTINUE();
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
-
- ZEND_VM_NEXT_OPCODE();
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_JMPNZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
+#if 0 || (IS_CONST != IS_UNUSED)
USE_OPLINE
- zend_free_op free_op1;
- zval *val;
- int ret;
- SAVE_OPLINE();
- val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-
- if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
- ret = Z_LVAL_P(val);
- } else {
- ret = i_zend_is_true(val);
- zval_ptr_dtor_nogc(&free_op1.var);
- if (UNEXPECTED(EG(exception) != NULL)) {
- HANDLE_EXCEPTION();
- }
+# if 0 || (IS_VAR != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_VAR_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
- if (ret) {
-#if DEBUG_ZEND>=2
- printf("Conditional jmp to %d\n", opline->op2.opline_num);
-#endif
- ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
- ZEND_VM_CONTINUE();
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
-
- ZEND_VM_NEXT_OPCODE();
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_JMPZNZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
+#if 0 || (IS_CONST != IS_UNUSED)
USE_OPLINE
- zend_free_op free_op1;
- zval *val;
- int retval;
- SAVE_OPLINE();
- val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-
- if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
- retval = Z_LVAL_P(val);
- } else {
- retval = i_zend_is_true(val);
- zval_ptr_dtor_nogc(&free_op1.var);
- if (UNEXPECTED(EG(exception) != NULL)) {
- HANDLE_EXCEPTION();
- }
+# if 0 || (IS_VAR != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_VAR_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
- if (EXPECTED(retval != 0)) {
-#if DEBUG_ZEND>=2
- printf("Conditional jmp on true to %d\n", opline->extended_value);
-#endif
- ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
- ZEND_VM_CONTINUE(); /* CHECK_ME */
- } else {
-#if DEBUG_ZEND>=2
- printf("Conditional jmp on false to %d\n", opline->op2.opline_num);
-#endif
- ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->op2.opline_num]);
- ZEND_VM_CONTINUE(); /* CHECK_ME */
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
+#if 0 || (IS_CONST != IS_UNUSED)
USE_OPLINE
- zend_free_op free_op1;
- zval *val;
- int retval;
- SAVE_OPLINE();
- val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-
- if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
- retval = Z_LVAL_P(val);
- } else {
- retval = i_zend_is_true(val);
- zval_ptr_dtor_nogc(&free_op1.var);
- if (UNEXPECTED(EG(exception) != NULL)) {
- HANDLE_EXCEPTION();
- }
+# if 0 || (IS_VAR != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_VAR_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
- Z_LVAL(EX_T(opline->result.var).tmp_var) = retval;
- Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
- if (!retval) {
-#if DEBUG_ZEND>=2
- printf("Conditional jmp to %d\n", opline->op2.opline_num);
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
#endif
- ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
- ZEND_VM_CONTINUE();
+}
+
+static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+#if 0 || (IS_CONST != IS_UNUSED)
+ USE_OPLINE
+
+# if 0 || (IS_VAR != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_VAR_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
- ZEND_VM_NEXT_OPCODE();
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
+#if 0 || (IS_CONST != IS_UNUSED)
USE_OPLINE
- zend_free_op free_op1;
- zval *val;
- int retval;
- SAVE_OPLINE();
- val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+# if 0 || (IS_VAR != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_VAR_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+}
- if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
- retval = Z_LVAL_P(val);
- } else {
- retval = i_zend_is_true(val);
- zval_ptr_dtor_nogc(&free_op1.var);
- if (UNEXPECTED(EG(exception) != NULL)) {
- HANDLE_EXCEPTION();
- }
+static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+#if 0 || (IS_CONST != IS_UNUSED)
+ USE_OPLINE
+
+# if 0 || (IS_VAR != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
- Z_LVAL(EX_T(opline->result.var).tmp_var) = retval;
- Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
- if (retval) {
-#if DEBUG_ZEND>=2
- printf("Conditional jmp to %d\n", opline->op2.opline_num);
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
#endif
- ZEND_VM_SET_OPCODE(opline->op2.jmp_addr);
- ZEND_VM_CONTINUE();
+}
+
+static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+#if 0 || (IS_CONST != IS_UNUSED)
+ USE_OPLINE
+
+# if 0 || (IS_VAR != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
- ZEND_VM_NEXT_OPCODE();
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_FREE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
+#if 0 || (IS_CONST != IS_UNUSED)
USE_OPLINE
- SAVE_OPLINE();
- if (IS_VAR == IS_TMP_VAR) {
- zendi_zval_dtor(EX_T(opline->op1.var).tmp_var);
- } else {
- zval_ptr_dtor(&EX_T(opline->op1.var).var.ptr);
+# if 0 || (IS_VAR != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
- zval *retval_ptr;
zend_free_op free_op1;
+ zval *object;
+ zval *property;
+ zval *retval;
+ zval *zptr;
SAVE_OPLINE();
- retval_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+ object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+ property = EX_CONSTANT(opline->op2);
+ retval = EX_VAR(opline->result.var);
- if (!EG(return_value_ptr_ptr)) {
- zval_ptr_dtor_nogc(&free_op1.var);
- } else {
- if (IS_VAR == IS_CONST ||
- IS_VAR == IS_TMP_VAR ||
- PZVAL_IS_REF(retval_ptr)) {
- zval *ret;
+ if (IS_VAR == IS_VAR && UNEXPECTED(object == NULL)) {
+ zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
- ALLOC_ZVAL(ret);
- INIT_PZVAL_COPY(ret, retval_ptr);
- if (IS_VAR != IS_TMP_VAR) {
- zval_copy_ctor(ret);
+ if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
+ HANDLE_EXCEPTION();
+ }
+
+ do {
+ if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
+ ZVAL_DEREF(object);
+ if (UNEXPECTED(!make_real_object(object))) {
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_NULL(retval);
+ }
+ break;
}
- *EG(return_value_ptr_ptr) = ret;
- zval_ptr_dtor_nogc(&free_op1.var);
- } else if ((IS_VAR == IS_CV || IS_VAR == IS_VAR) &&
- retval_ptr == &EG(uninitialized_zval)) {
- zval *ret;
+ }
- if (IS_VAR == IS_VAR) {
- Z_DELREF_P(retval_ptr);
+ /* here we are sure we are dealing with an object */
+
+ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
+
+ ZVAL_DEREF(zptr);
+ SEPARATE_ZVAL_NOREF(zptr);
+
+ incdec_op(zptr);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(retval, zptr);
}
- ALLOC_INIT_ZVAL(ret);
- *EG(return_value_ptr_ptr) = ret;
} else {
- *EG(return_value_ptr_ptr) = retval_ptr;
- if (IS_VAR == IS_CV) {
- Z_ADDREF_P(retval_ptr);
+ zval rv;
+
+ if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
- zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
++ zval *z, obj;
++
++ ZVAL_COPY(&obj, object);
++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
+
+ if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
+ zval rv;
+ zval *value = Z_OBJ_HT_P(z)->get(z, &rv);
+
+ if (Z_REFCOUNT_P(z) == 0) {
+ zend_objects_store_del(Z_OBJ_P(z));
+ }
+ ZVAL_COPY_VALUE(z, value);
+ }
+ ZVAL_DEREF(z);
+ SEPARATE_ZVAL_NOREF(z);
+ incdec_op(z);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(retval, z);
+ }
- Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ Z_OBJ_HT(obj)->write_property(&obj, property, z, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ zval_ptr_dtor(&obj);
+ zval_ptr_dtor(z);
+ } else {
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_NULL(retval);
+ }
}
}
- }
- return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } while (0);
+
+ if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
+ CHECK_EXCEPTION();
+ ZEND_VM_NEXT_OPCODE();
}
-static int ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ return zend_pre_incdec_property_helper_SPEC_VAR_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ return zend_pre_incdec_property_helper_SPEC_VAR_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
- zval *retval_ptr;
- zval **retval_ptr_ptr;
zend_free_op free_op1;
+ zval *object;
+ zval *property;
+ zval *retval;
+ zval *zptr;
SAVE_OPLINE();
+ object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+ property = EX_CONSTANT(opline->op2);
+ retval = EX_VAR(opline->result.var);
- do {
- if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR ||
- (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
- /* Not supposed to happen, but we'll allow it */
- zend_error(E_NOTICE, "Only variable references should be returned by reference");
-
- retval_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- if (!EG(return_value_ptr_ptr)) {
- if (IS_VAR == IS_TMP_VAR) {
- zval_ptr_dtor_nogc(&free_op1.var);
- }
- } else if (!0) { /* Not a temp var */
- zval *ret;
+ if (IS_VAR == IS_VAR && UNEXPECTED(object == NULL)) {
+ zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
- ALLOC_ZVAL(ret);
- INIT_PZVAL_COPY(ret, retval_ptr);
- zval_copy_ctor(ret);
- *EG(return_value_ptr_ptr) = ret;
- } else {
- zval *ret;
+ if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
+ HANDLE_EXCEPTION();
+ }
- ALLOC_ZVAL(ret);
- INIT_PZVAL_COPY(ret, retval_ptr);
- *EG(return_value_ptr_ptr) = ret;
+ do {
+ if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
+ ZVAL_DEREF(object);
+ if (UNEXPECTED(!make_real_object(object))) {
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ ZVAL_NULL(retval);
+ break;
}
- break;
}
- retval_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+ /* here we are sure we are dealing with an object */
+
+ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
- if (IS_VAR == IS_VAR && UNEXPECTED(retval_ptr_ptr == NULL)) {
- zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
- }
+ ZVAL_DEREF(zptr);
+ ZVAL_COPY_VALUE(retval, zptr);
+ zval_opt_copy_ctor(zptr);
-
+ incdec_op(zptr);
+ } else {
+ if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
- zval rv;
- zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
++ zval rv, obj;
++ zval *z;
+
- if (IS_VAR == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) {
- if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
- EX_T(opline->op1.var).var.fcall_returned_reference) {
- } else if (EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
- zend_error(E_NOTICE, "Only variable references should be returned by reference");
- if (EG(return_value_ptr_ptr)) {
- zval *ret;
++ ZVAL_COPY(&obj, object);
++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
+ zval z_copy;
- ALLOC_ZVAL(ret);
- INIT_PZVAL_COPY(ret, *retval_ptr_ptr);
- zval_copy_ctor(ret);
- *EG(return_value_ptr_ptr) = ret;
+ if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
+ zval rv;
+ zval *value = Z_OBJ_HT_P(z)->get(z, &rv);
-
+ if (Z_REFCOUNT_P(z) == 0) {
+ zend_objects_store_del(Z_OBJ_P(z));
+ }
+ ZVAL_COPY_VALUE(z, value);
}
- break;
+ ZVAL_DUP(retval, z);
+ ZVAL_DUP(&z_copy, z);
+ incdec_op(&z_copy);
+ if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
- Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ Z_OBJ_HT(obj)->write_property(&obj, property, &z_copy, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ zval_ptr_dtor(&obj);
+ zval_ptr_dtor(&z_copy);
+ zval_ptr_dtor(z);
+ } else {
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ ZVAL_NULL(retval);
}
}
+ } while (0);
- if (EG(return_value_ptr_ptr)) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
- Z_ADDREF_PP(retval_ptr_ptr);
+ if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
+ CHECK_EXCEPTION();
+ ZEND_VM_NEXT_OPCODE();
+}
- *EG(return_value_ptr_ptr) = *retval_ptr_ptr;
- }
- } while (0);
+static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ return zend_post_incdec_property_helper_SPEC_VAR_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
- if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
- return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ return zend_post_incdec_property_helper_SPEC_VAR_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
-static int ZEND_FASTCALL ZEND_THROW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
- zval *value;
- zval *exception;
zend_free_op free_op1;
+ zval *container;
SAVE_OPLINE();
- value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+ container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
- if (IS_VAR == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) {
- if (UNEXPECTED(EG(exception) != NULL)) {
- HANDLE_EXCEPTION();
- }
- zend_error_noreturn(E_ERROR, "Can only throw objects");
+ if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+ zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an array");
+ if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
+ HANDLE_EXCEPTION();
}
+ zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST);
- zend_exception_save(TSRMLS_C);
- /* Not sure if a complete copy is what we want here */
- ALLOC_ZVAL(exception);
- INIT_PZVAL_COPY(exception, value);
- if (!0) {
- zval_copy_ctor(exception);
+ if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
+ EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
-
- zend_throw_exception_object(exception TSRMLS_CC);
- zend_exception_restore(TSRMLS_C);
- zval_ptr_dtor_nogc(&free_op1.var);
- HANDLE_EXCEPTION();
+ if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
+ CHECK_EXCEPTION();
+ ZEND_VM_NEXT_OPCODE();
}
-static int ZEND_FASTCALL zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
- zval *varptr;
zend_free_op free_op1;
- varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+ zval *container;
- if (varptr == &EG(uninitialized_zval)) {
- if (IS_VAR == IS_VAR) {
- Z_DELREF_P(varptr);
- }
- ALLOC_INIT_ZVAL(varptr);
- } else if (PZVAL_IS_REF(varptr)) {
- if (IS_VAR == IS_CV ||
- (IS_VAR == IS_VAR && Z_REFCOUNT_P(varptr) > 2)) {
- zval *original_var = varptr;
+ SAVE_OPLINE();
+ container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
- ALLOC_ZVAL(varptr);
- INIT_PZVAL_COPY(varptr, original_var);
- zval_copy_ctor(varptr);
- zval_ptr_dtor_nogc(&free_op1.var);
- } else {
- Z_UNSET_ISREF_P(varptr);
- }
- } else if (IS_VAR == IS_CV) {
- Z_ADDREF_P(varptr);
+ if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+ zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an array");
+ if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
+ HANDLE_EXCEPTION();
}
- zend_vm_stack_push(varptr TSRMLS_CC);
+ zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST);
+ if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) {
+ EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
+ }
+ if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_NEXT_OPCODE();
}
-static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
- zend_free_op free_op1;
- zval **object_ptr;
- zval *property_name;
- SAVE_OPLINE();
- object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- property_name = opline->op2.zv;
+ /* The generator object is stored in EX(return_value) */
+ zend_generator *generator = (zend_generator *) EX(return_value);
- if (0) {
- MAKE_REAL_ZVAL_PTR(property_name);
- }
- if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
- zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
- }
- zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
- if (0) {
- zval_ptr_dtor(&property_name);
- } else {
+ if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
+ zend_error(E_EXCEPTION | E_ERROR, "Cannot yield from finally in a force-closed generator");
+ zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+ HANDLE_EXCEPTION();
}
- if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
- /* assign_obj has two opcodes! */
- CHECK_EXCEPTION();
- ZEND_VM_INC_OPCODE();
- ZEND_VM_NEXT_OPCODE();
-}
-static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- USE_OPLINE
- zend_free_op free_op1;
- zval **object_ptr;
+ /* Destroy the previously yielded value */
+ zval_ptr_dtor(&generator->value);
- SAVE_OPLINE();
- object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+ /* Destroy the previously yielded key */
+ zval_ptr_dtor(&generator->key);
- if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
- zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
- }
- if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
+ /* Set the new yielded value */
+ if (IS_VAR != IS_UNUSED) {
+ zend_free_op free_op1;
- zval *property_name = opline->op2.zv;
+ if (EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE) {
+ /* Constants and temporary variables aren't yieldable by reference,
+ * but we still allow them with a notice. */
+ if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
+ zval *value;
- if (0) {
- MAKE_REAL_ZVAL_PTR(property_name);
- }
- zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
- if (0) {
- zval_ptr_dtor(&property_name);
- } else {
+ zend_error(E_NOTICE, "Only variable references should be yielded by reference");
- }
- } else {
- zend_free_op free_op_data1, free_op_data2;
- zval *value;
- zval *dim = opline->op2.zv;
- zval **variable_ptr_ptr;
+ value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+ ZVAL_COPY_VALUE(&generator->value, value);
+ if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
+
+ /* Temporary variables don't need ctor copying */
+ if (IS_VAR != IS_TMP_VAR) {
+ zval_opt_copy_ctor(&generator->value);
+ }
+ } else {
+ zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
- zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_CONST, BP_VAR_W TSRMLS_CC);
+ if (IS_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
+ zend_error(E_EXCEPTION | E_ERROR, "Cannot yield string offsets by reference");
- value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
- variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
- if (UNEXPECTED(variable_ptr_ptr == NULL)) {
- if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
- if (RETURN_VALUE_USED(opline)) {
- zval *retval;
+ zval_ptr_dtor_nogc(free_op1);
+ HANDLE_EXCEPTION();
+ }
- ALLOC_ZVAL(retval);
- ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
- INIT_PZVAL(retval);
- EX_T(opline->result.var).var.ptr = retval;
+ /* If a function call result is yielded and the function did
+ * not return by reference we throw a notice. */
+ if (IS_VAR == IS_VAR &&
+ (value_ptr == &EG(uninitialized_zval) ||
+ (opline->extended_value == ZEND_RETURNS_FUNCTION &&
+ !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) {
+ zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+ } else {
+ ZVAL_MAKE_REF(value_ptr);
}
- } else if (RETURN_VALUE_USED(opline)) {
- PZVAL_LOCK(&EG(uninitialized_zval));
- EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
- }
- } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
- if (IS_TMP_FREE(free_op_data1)) {
- zval_dtor(value);
- }
- if (RETURN_VALUE_USED(opline)) {
- PZVAL_LOCK(&EG(uninitialized_zval));
- EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+ ZVAL_COPY(&generator->value, value_ptr);
+
+ if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
}
} else {
- if ((opline+1)->op1_type == IS_TMP_VAR) {
- value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
- } else if ((opline+1)->op1_type == IS_CONST) {
- value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
- } else {
- value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
- }
- if (RETURN_VALUE_USED(opline)) {
- PZVAL_LOCK(value);
- EX_T(opline->result.var).var.ptr = value;
+ zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1);
+
+ /* Consts, temporary variables and references need copying */
+ if (IS_VAR == IS_CONST) {
+ ZVAL_DUP(&generator->value, value);
+ } else if (IS_VAR == IS_TMP_VAR) {
+ ZVAL_COPY_VALUE(&generator->value, value);
+ } else if ((IS_VAR == IS_CV || IS_VAR == IS_VAR) && Z_ISREF_P(value)) {
+ ZVAL_DUP(&generator->value, Z_REFVAL_P(value));
+ zval_ptr_dtor_nogc(free_op1);
+ } else {
+ ZVAL_COPY_VALUE(&generator->value, value);
+ if (IS_VAR == IS_CV) {
+ if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
+ }
}
}
- FREE_OP_VAR_PTR(free_op_data2);
- FREE_OP_IF_VAR(free_op_data1);
+ } else {
+ /* If no value was specified yield null */
+ ZVAL_NULL(&generator->value);
}
- if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
- /* assign_dim has two opcodes! */
- CHECK_EXCEPTION();
- ZEND_VM_INC_OPCODE();
- ZEND_VM_NEXT_OPCODE();
-}
-static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- USE_OPLINE
- zend_free_op free_op1;
- zval *value;
- zval **variable_ptr_ptr;
+ /* Set the new yielded key */
+ if (IS_UNUSED != IS_UNUSED) {
- SAVE_OPLINE();
- value = opline->op2.zv;
- variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+ zval *key = NULL;
- if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) {
- if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_CONST TSRMLS_CC)) {
- if (RETURN_VALUE_USED(opline)) {
- zval *retval;
+ /* Consts, temporary variables and references need copying */
+ if (IS_UNUSED == IS_CONST) {
+ ZVAL_DUP(&generator->key, key);
+ } else if (IS_UNUSED == IS_TMP_VAR) {
+ ZVAL_COPY_VALUE(&generator->key, key);
+ } else if ((IS_UNUSED == IS_VAR || IS_UNUSED == IS_CV) && Z_ISREF_P(key)) {
+ ZVAL_DUP(&generator->key, Z_REFVAL_P(key));
- ALLOC_ZVAL(retval);
- ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
- INIT_PZVAL(retval);
- EX_T(opline->result.var).var.ptr = retval;
+ } else {
+ ZVAL_COPY_VALUE(&generator->key, key);
+ if (IS_UNUSED == IS_CV) {
+ if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
}
- } else if (RETURN_VALUE_USED(opline)) {
- PZVAL_LOCK(&EG(uninitialized_zval));
- EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
}
- } else if (IS_VAR == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
- if (0) {
- zval_dtor(value);
- }
- if (RETURN_VALUE_USED(opline)) {
- PZVAL_LOCK(&EG(uninitialized_zval));
- EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+
+ if (Z_TYPE(generator->key) == IS_LONG
+ && Z_LVAL(generator->key) > generator->largest_used_integer_key
+ ) {
+ generator->largest_used_integer_key = Z_LVAL(generator->key);
}
} else {
- if (IS_CONST == IS_TMP_VAR) {
- value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
- } else if (IS_CONST == IS_CONST) {
- value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
- } else {
- value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
- }
- if (RETURN_VALUE_USED(opline)) {
- PZVAL_LOCK(value);
- EX_T(opline->result.var).var.ptr = value;
- }
+ /* If no key was specified we use auto-increment keys */
+ generator->largest_used_integer_key++;
+ ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
}
- if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-
- /* zend_assign_to_variable() always takes care of op2, never free it! */
+ if (RETURN_VALUE_USED(opline)) {
+ /* If the return value of yield is used set the send
+ * target and initialize it to NULL */
+ generator->send_target = EX_VAR(opline->result.var);
+ ZVAL_NULL(generator->send_target);
+ } else {
+ generator->send_target = NULL;
+ }
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
-}
+ /* We increment to the next op, so we are at the correct position when the
+ * generator is resumed. */
+ ZEND_VM_INC_OPCODE();
-static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+ /* The GOTO VM uses a local opline variable. We need to set the opline
+ * variable in execute_data so we don't resume at an old position. */
+ SAVE_OPLINE();
+
+ ZEND_VM_RETURN();
+}
+
+static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
- zval *function_name;
- char *function_name_strval;
- int function_name_strlen;
zend_free_op free_op1;
- call_slot *call = EX(call_slots) + opline->result.num;
SAVE_OPLINE();
+ fast_is_identical_function(EX_VAR(opline->result.var),
+ _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1),
+ _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var));
+ zval_ptr_dtor_nogc(free_op1);
- function_name = opline->op2.zv;
+ CHECK_EXCEPTION();
+ ZEND_VM_NEXT_OPCODE();
+}
- if (IS_CONST != IS_CONST &&
- UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
- if (UNEXPECTED(EG(exception) != NULL)) {
- HANDLE_EXCEPTION();
- }
- zend_error_noreturn(E_ERROR, "Method name must be a string");
- }
+static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ USE_OPLINE
+ zend_free_op free_op1;
+ zval *result = EX_VAR(opline->result.var);
- function_name_strval = Z_STRVAL_P(function_name);
- function_name_strlen = Z_STRLEN_P(function_name);
+ SAVE_OPLINE();
+ fast_is_not_identical_function(result,
+ _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1),
+ _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var));
+ zval_ptr_dtor_nogc(free_op1);
- call->object = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+ CHECK_EXCEPTION();
+ ZEND_VM_NEXT_OPCODE();
+}
- if (EXPECTED(call->object != NULL) &&
- EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
- call->called_scope = Z_OBJCE_P(call->object);
+static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CV(int (*binary_op)(zval *result, zval *op1, zval *op2), ZEND_OPCODE_HANDLER_ARGS)
+{
+ USE_OPLINE
+ zend_free_op free_op1, free_op_data1;
+ zval *object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+ zval *property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+ zval *value;
+ zval *zptr;
- if (IS_CONST != IS_CONST ||
- (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
- zval *object = call->object;
+ if (IS_VAR == IS_VAR && UNEXPECTED(object == NULL)) {
+ zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an object");
+ FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
- if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
- zend_error_noreturn(E_ERROR, "Object does not support method calls");
- }
+ if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
+ HANDLE_EXCEPTION();
+ }
- /* First, locate the function. */
- call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
- if (UNEXPECTED(call->fbc == NULL)) {
- zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
- }
- if (IS_CONST == IS_CONST &&
- EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
- EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
- EXPECTED(call->object == object)) {
- CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+ do {
+ value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+
+ if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
+ ZVAL_DEREF(object);
+ if (UNEXPECTED(!make_real_object(object))) {
+ zend_error(E_WARNING, "Attempt to assign property of non-object");
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_NULL(EX_VAR(opline->result.var));
+ }
+ break;
}
}
- } else {
- if (UNEXPECTED(EG(exception) != NULL)) {
- HANDLE_EXCEPTION();
- }
- zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
- }
+ /* here we are sure we are dealing with an object */
+ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
- if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
- call->object = NULL;
- } else {
- if (!PZVAL_IS_REF(call->object)) {
- Z_ADDREF_P(call->object); /* For $this pointer */
+ ZVAL_DEREF(zptr);
+ SEPARATE_ZVAL_NOREF(zptr);
+
+ binary_op(zptr, zptr, value);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(EX_VAR(opline->result.var), zptr);
+ }
} else {
- zval *this_ptr;
- ALLOC_ZVAL(this_ptr);
- INIT_PZVAL_COPY(this_ptr, call->object);
- zval_copy_ctor(this_ptr);
- call->object = this_ptr;
- }
- }
+ zval *z;
- zval rv;
++ zval rv, obj;
- if (Z_OBJ_HT_P(object)->read_property &&
- (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) {
- call->num_additional_args = 0;
- call->is_ctor_call = 0;
- EX(call) = call;
++ ZVAL_COPY(&obj, object);
++ if (Z_OBJ_HT(obj)->read_property &&
++ (z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) {
+ if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
+ zval rv;
+ zval *value = Z_OBJ_HT_P(z)->get(z, &rv);
+
+ if (Z_REFCOUNT_P(z) == 0) {
+ zend_objects_store_del(Z_OBJ_P(z));
+ }
+ ZVAL_COPY_VALUE(z, value);
+ }
+ zptr = z;
+ ZVAL_DEREF(z);
+ SEPARATE_ZVAL_NOREF(z);
+ binary_op(z, z, value);
- Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ Z_OBJ_HT(obj)->write_property(&obj, property, z, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ zval_ptr_dtor(&obj);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(EX_VAR(opline->result.var), z);
+ }
+ zval_ptr_dtor(zptr);
+ } else {
+ zend_error(E_WARNING, "Attempt to assign property of non-object");
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_NULL(EX_VAR(opline->result.var));
+ }
+ }
+ }
+ } while (0);
- zval_ptr_dtor_nogc(&free_op1.var);
+ FREE_OP(free_op_data1);
+ if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
+ /* assign_obj has two opcodes! */
CHECK_EXCEPTION();
+ ZEND_VM_INC_OPCODE();
ZEND_VM_NEXT_OPCODE();
}
{
USE_OPLINE
zend_free_op free_op1;
- zval **container;
- zval *offset;
+ zval *object;
+ zval *property;
+ zval *retval;
+ zval *zptr;
SAVE_OPLINE();
- container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- offset = opline->op2.zv;
+ object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+ property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+ retval = EX_VAR(opline->result.var);
- if (IS_VAR != IS_VAR || container) {
- if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
- SEPARATE_ZVAL_IF_NOT_REF(container);
- }
- if (Z_TYPE_PP(container) == IS_OBJECT) {
- if (0) {
- MAKE_REAL_ZVAL_PTR(offset);
- }
- if (Z_OBJ_HT_P(*container)->unset_property) {
- Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
- } else {
- zend_error(E_NOTICE, "Trying to unset property of non-object");
- }
- if (0) {
- zval_ptr_dtor(&offset);
- } else {
+ if (IS_VAR == IS_VAR && UNEXPECTED(object == NULL)) {
+ zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
- }
- } else {
+ if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
+ HANDLE_EXCEPTION();
+ }
+ do {
+ if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
+ ZVAL_DEREF(object);
+ if (UNEXPECTED(!make_real_object(object))) {
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_NULL(retval);
+ }
+ break;
+ }
}
- } else {
-
- }
- if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
-}
+ /* here we are sure we are dealing with an object */
-static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- USE_OPLINE
- zval **value;
- zend_bool isset = 1;
+ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
- SAVE_OPLINE();
- if (IS_VAR == IS_CV &&
- IS_CONST == IS_UNUSED &&
- (opline->extended_value & ZEND_QUICK_SET)) {
- if (EX_CV(opline->op1.var)) {
- value = EX_CV(opline->op1.var);
- } else if (EG(active_symbol_table)) {
- zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
+ ZVAL_DEREF(zptr);
+ SEPARATE_ZVAL_NOREF(zptr);
- if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
- isset = 0;
+ incdec_op(zptr);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(retval, zptr);
}
} else {
- isset = 0;
- }
- } else {
- HashTable *target_symbol_table;
- zend_free_op free_op1;
- zval tmp, *varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+ zval rv;
- if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
- ZVAL_COPY_VALUE(&tmp, varname);
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- varname = &tmp;
- }
+ if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
- zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
++ zval *z, obj;
+
- if (IS_CONST != IS_UNUSED) {
- zend_class_entry *ce;
++ ZVAL_COPY(&obj, object);
++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
- if (IS_CONST == IS_CONST) {
- if (CACHED_PTR(opline->op2.literal->cache_slot)) {
- ce = CACHED_PTR(opline->op2.literal->cache_slot);
- } else {
- ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
- if (UNEXPECTED(ce == NULL)) {
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
+ if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
+ zval rv;
+ zval *value = Z_OBJ_HT_P(z)->get(z, &rv);
+
+ if (Z_REFCOUNT_P(z) == 0) {
+ zend_objects_store_del(Z_OBJ_P(z));
}
- CACHE_PTR(opline->op2.literal->cache_slot, ce);
+ ZVAL_COPY_VALUE(z, value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
+ ZVAL_DEREF(z);
+ SEPARATE_ZVAL_NOREF(z);
+ incdec_op(z);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(retval, z);
+ }
++ Z_OBJ_HT(obj)->write_property(&obj, property, z, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ zval_ptr_dtor(&obj);
+ zval_ptr_dtor(z);
} else {
- ce = EX_T(opline->op2.var).class_entry;
- }
- value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
- if (!value) {
- isset = 0;
- }
- } else {
- target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
- if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
- isset = 0;
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_NULL(retval);
+ }
}
}
+ } while (0);
- if (IS_VAR != IS_CONST && varname == &tmp) {
- zval_dtor(&tmp);
- }
- zval_ptr_dtor_nogc(&free_op1.var);
- }
-
- if (opline->extended_value & ZEND_ISSET) {
- if (isset && Z_TYPE_PP(value) != IS_NULL) {
- ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
- } else {
- ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
- }
- } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
- if (!isset || !i_zend_is_true(*value)) {
- ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
- } else {
- ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
- }
- }
-
+ if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
}
}
- } else if (Z_TYPE_P(container) == IS_OBJECT) {
- if (0) {
- MAKE_REAL_ZVAL_PTR(offset);
- }
- if (prop_dim) {
- if (Z_OBJ_HT_P(container)->has_property) {
- result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
- } else {
- zend_error(E_NOTICE, "Trying to check property of non-object");
- result = 0;
- }
- } else {
- if (Z_OBJ_HT_P(container)->has_dimension) {
- result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
- } else {
- zend_error(E_NOTICE, "Trying to check element of non-array");
- result = 0;
- }
- }
- if (0) {
- zval_ptr_dtor(&offset);
+ /* here we are sure we are dealing with an object */
+
+ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
+
+ ZVAL_DEREF(zptr);
+ ZVAL_COPY_VALUE(retval, zptr);
+ zval_opt_copy_ctor(zptr);
-
+ incdec_op(zptr);
} else {
- zval rv;
- zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
+ if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
- }
- } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
- zval tmp;
++ zval rv, obj;
++ zval *z;
+
++ ZVAL_COPY(&obj, object);
++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
+ zval z_copy;
- if (Z_TYPE_P(offset) != IS_LONG) {
- if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
- || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
- && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
- ZVAL_COPY_VALUE(&tmp, offset);
- zval_copy_ctor(&tmp);
- convert_to_long(&tmp);
- offset = &tmp;
- } else {
- /* can not be converted to proper offset, return "not set" */
- result = 0;
- }
- }
- if (Z_TYPE_P(offset) == IS_LONG) {
- if (opline->extended_value & ZEND_ISSET) {
- if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
- result = 1;
- }
- } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
- if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
- result = 1;
+ if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
+ zval rv;
+ zval *value = Z_OBJ_HT_P(z)->get(z, &rv);
-
+ if (Z_REFCOUNT_P(z) == 0) {
+ zend_objects_store_del(Z_OBJ_P(z));
+ }
+ ZVAL_COPY_VALUE(z, value);
}
- Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
+ ZVAL_DUP(retval, z);
+ ZVAL_DUP(&z_copy, z);
+ incdec_op(&z_copy);
+ if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
++ Z_OBJ_HT(obj)->write_property(&obj, property, &z_copy, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ zval_ptr_dtor(&obj);
+ zval_ptr_dtor(&z_copy);
+ zval_ptr_dtor(z);
+ } else {
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ ZVAL_NULL(retval);
}
}
+ } while (0);
- } else {
-
- }
-
- Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
- if (opline->extended_value & ZEND_ISSET) {
- Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
- } else {
- Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
- }
-
- zval_ptr_dtor_nogc(&free_op1.var);
-
+ if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
}
/* here we are sure we are dealing with an object */
- retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
- PZVAL_LOCK(retval);
- EX_T(opline->result.var).var.ptr = retval;
+ ZVAL_DEREF(zptr);
+ SEPARATE_ZVAL_NOREF(zptr);
- if (1) {
- zval_ptr_dtor(&offset);
+ binary_op(zptr, zptr, value);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(EX_VAR(opline->result.var), zptr);
+ }
} else {
- zval_dtor(free_op2.var);
+ zval *z;
- zval rv;
++ zval rv, obj;
+
- if (Z_OBJ_HT_P(object)->read_property &&
- (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) {
++ ZVAL_COPY(&obj, object);
++ if (Z_OBJ_HT(obj)->read_property &&
++ (z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) {
+ if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
+ zval rv;
+ zval *value = Z_OBJ_HT_P(z)->get(z, &rv);
+
+ if (Z_REFCOUNT_P(z) == 0) {
+ zend_objects_store_del(Z_OBJ_P(z));
+ }
+ ZVAL_COPY_VALUE(z, value);
+ }
+ zptr = z;
+ ZVAL_DEREF(z);
+ SEPARATE_ZVAL_NOREF(z);
+ binary_op(z, z, value);
- Z_OBJ_HT_P(object)->write_property(object, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ Z_OBJ_HT(obj)->write_property(&obj, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ zval_ptr_dtor(&obj);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(EX_VAR(opline->result.var), z);
+ }
+ zval_ptr_dtor(zptr);
+ } else {
+ zend_error(E_WARNING, "Attempt to assign property of non-object");
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_NULL(EX_VAR(opline->result.var));
+ }
+ }
}
- }
+ } while (0);
- zval_ptr_dtor_nogc(&free_op1.var);
+ FREE_OP(free_op_data1);
+ zval_ptr_dtor_nogc(free_op2);
+ if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
+ /* assign_obj has two opcodes! */
CHECK_EXCEPTION();
+ ZEND_VM_INC_OPCODE();
ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_NEXT_OPCODE();
}
-static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
+#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED)
USE_OPLINE
- zend_free_op free_op1, free_op2;
- zval **object_ptr;
- zval *property_name;
- SAVE_OPLINE();
- object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- property_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+# if 0 || (IS_VAR != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_VAR_TMPVAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+}
+
+static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED)
+ USE_OPLINE
- if (1) {
- MAKE_REAL_ZVAL_PTR(property_name);
+# if 0 || (IS_VAR != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
- if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
- zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_VAR_TMPVAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
- zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
- if (1) {
- zval_ptr_dtor(&property_name);
- } else {
- zval_dtor(free_op2.var);
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+}
+
+static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED)
+ USE_OPLINE
+
+# if 0 || (IS_VAR != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
- if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
- /* assign_obj has two opcodes! */
- CHECK_EXCEPTION();
- ZEND_VM_INC_OPCODE();
- ZEND_VM_NEXT_OPCODE();
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_VAR_TMPVAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
+#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED)
USE_OPLINE
- zend_free_op free_op1;
- zval **object_ptr;
- SAVE_OPLINE();
- object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+# if 0 || (IS_VAR != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_VAR_TMPVAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+}
- if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
- zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED)
+ USE_OPLINE
+
+# if 0 || (IS_VAR != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
- if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
- zend_free_op free_op2;
- zval *property_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_VAR_TMPVAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+}
- if (1) {
- MAKE_REAL_ZVAL_PTR(property_name);
- }
- zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
- if (1) {
- zval_ptr_dtor(&property_name);
- } else {
- zval_dtor(free_op2.var);
- }
- } else {
- zend_free_op free_op2, free_op_data1, free_op_data2;
- zval *value;
- zval *dim = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
- zval **variable_ptr_ptr;
+static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED)
+ USE_OPLINE
- zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_TMP_VAR, BP_VAR_W TSRMLS_CC);
- zval_dtor(free_op2.var);
+# if 0 || (IS_VAR != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_VAR_TMPVAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+}
- value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
- variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
- if (UNEXPECTED(variable_ptr_ptr == NULL)) {
- if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
- if (RETURN_VALUE_USED(opline)) {
- zval *retval;
+static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED)
+ USE_OPLINE
- ALLOC_ZVAL(retval);
- ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
- INIT_PZVAL(retval);
- EX_T(opline->result.var).var.ptr = retval;
- }
- } else if (RETURN_VALUE_USED(opline)) {
- PZVAL_LOCK(&EG(uninitialized_zval));
- EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
- }
- } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
- if (IS_TMP_FREE(free_op_data1)) {
- zval_dtor(value);
- }
- if (RETURN_VALUE_USED(opline)) {
- PZVAL_LOCK(&EG(uninitialized_zval));
- EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
- }
- } else {
- if ((opline+1)->op1_type == IS_TMP_VAR) {
- value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
- } else if ((opline+1)->op1_type == IS_CONST) {
- value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
- } else {
- value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
- }
- if (RETURN_VALUE_USED(opline)) {
- PZVAL_LOCK(value);
- EX_T(opline->result.var).var.ptr = value;
- }
- }
- FREE_OP_VAR_PTR(free_op_data2);
- FREE_OP_IF_VAR(free_op_data1);
+# if 0 || (IS_VAR != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
- if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
- /* assign_dim has two opcodes! */
- CHECK_EXCEPTION();
- ZEND_VM_INC_OPCODE();
- ZEND_VM_NEXT_OPCODE();
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_VAR_TMPVAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
+#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED)
USE_OPLINE
- zend_free_op free_op1, free_op2;
- zval *value;
- zval **variable_ptr_ptr;
- SAVE_OPLINE();
- value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
- variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+# if 0 || (IS_VAR != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_VAR_TMPVAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+}
- if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) {
- if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_TMP_VAR TSRMLS_CC)) {
- if (RETURN_VALUE_USED(opline)) {
- zval *retval;
+static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED)
+ USE_OPLINE
- ALLOC_ZVAL(retval);
- ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
- INIT_PZVAL(retval);
- EX_T(opline->result.var).var.ptr = retval;
- }
- } else if (RETURN_VALUE_USED(opline)) {
- PZVAL_LOCK(&EG(uninitialized_zval));
- EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
- }
- } else if (IS_VAR == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
- if (1) {
- zval_dtor(value);
- }
- if (RETURN_VALUE_USED(opline)) {
- PZVAL_LOCK(&EG(uninitialized_zval));
- EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
- }
- } else {
- if (IS_TMP_VAR == IS_TMP_VAR) {
- value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
- } else if (IS_TMP_VAR == IS_CONST) {
- value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
- } else {
- value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
- }
- if (RETURN_VALUE_USED(opline)) {
- PZVAL_LOCK(value);
- EX_T(opline->result.var).var.ptr = value;
- }
+# if 0 || (IS_VAR != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_VAR_TMPVAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+}
- if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED)
+ USE_OPLINE
- /* zend_assign_to_variable() always takes care of op2, never free it! */
+# if 0 || (IS_VAR != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_VAR_TMPVAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+}
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
+static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+#if 0 || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED)
+ USE_OPLINE
+
+# if 0 || (IS_VAR != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_VAR_TMPVAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_VAR_TMPVAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_VAR_TMPVAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_TMPVAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
- zval *function_name;
- char *function_name_strval;
- int function_name_strlen;
zend_free_op free_op1, free_op2;
- call_slot *call = EX(call_slots) + opline->result.num;
+ zval *object;
+ zval *property;
+ zval *retval;
+ zval *zptr;
SAVE_OPLINE();
+ object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+ property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+ retval = EX_VAR(opline->result.var);
- function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-
- if (IS_TMP_VAR != IS_CONST &&
- UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
- if (UNEXPECTED(EG(exception) != NULL)) {
- HANDLE_EXCEPTION();
- }
- zend_error_noreturn(E_ERROR, "Method name must be a string");
+ if (IS_VAR == IS_VAR && UNEXPECTED(object == NULL)) {
+ zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
+ zval_ptr_dtor_nogc(free_op2);
+ if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
+ HANDLE_EXCEPTION();
}
- function_name_strval = Z_STRVAL_P(function_name);
- function_name_strlen = Z_STRLEN_P(function_name);
+ do {
+ if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
+ ZVAL_DEREF(object);
+ if (UNEXPECTED(!make_real_object(object))) {
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_NULL(retval);
+ }
+ break;
+ }
+ }
- call->object = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+ /* here we are sure we are dealing with an object */
- if (EXPECTED(call->object != NULL) &&
- EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
- call->called_scope = Z_OBJCE_P(call->object);
+ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
- if (IS_TMP_VAR != IS_CONST ||
- (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
- zval *object = call->object;
+ ZVAL_DEREF(zptr);
+ SEPARATE_ZVAL_NOREF(zptr);
- if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
- zend_error_noreturn(E_ERROR, "Object does not support method calls");
+ incdec_op(zptr);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(retval, zptr);
}
+ } else {
+ zval rv;
- /* First, locate the function. */
- call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
- if (UNEXPECTED(call->fbc == NULL)) {
- zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
- }
- if (IS_TMP_VAR == IS_CONST &&
- EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
- EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
- EXPECTED(call->object == object)) {
- CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
- }
- }
- } else {
- if (UNEXPECTED(EG(exception) != NULL)) {
- zval_dtor(free_op2.var);
- HANDLE_EXCEPTION();
- }
- zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
- }
+ if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
- zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
++ zval *z, obj;
+
- if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
- call->object = NULL;
- } else {
- if (!PZVAL_IS_REF(call->object)) {
- Z_ADDREF_P(call->object); /* For $this pointer */
- } else {
- zval *this_ptr;
- ALLOC_ZVAL(this_ptr);
- INIT_PZVAL_COPY(this_ptr, call->object);
- zval_copy_ctor(this_ptr);
- call->object = this_ptr;
- }
- }
++ ZVAL_COPY(&obj, object);
++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
- call->num_additional_args = 0;
- call->is_ctor_call = 0;
- EX(call) = call;
+ if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
+ zval rv;
+ zval *value = Z_OBJ_HT_P(z)->get(z, &rv);
- zval_dtor(free_op2.var);
- zval_ptr_dtor_nogc(&free_op1.var);
+ if (Z_REFCOUNT_P(z) == 0) {
+ zend_objects_store_del(Z_OBJ_P(z));
+ }
+ ZVAL_COPY_VALUE(z, value);
+ }
+ ZVAL_DEREF(z);
+ SEPARATE_ZVAL_NOREF(z);
+ incdec_op(z);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(retval, z);
+ }
- Z_OBJ_HT_P(object)->write_property(object, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ Z_OBJ_HT(obj)->write_property(&obj, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ zval_ptr_dtor(&obj);
+ zval_ptr_dtor(z);
+ } else {
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_NULL(retval);
+ }
+ }
+ }
+ } while (0);
+ zval_ptr_dtor_nogc(free_op2);
+ if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
-static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ return zend_pre_incdec_property_helper_SPEC_VAR_TMPVAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ return zend_pre_incdec_property_helper_SPEC_VAR_TMPVAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_TMPVAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
- zval *function_name;
- zend_class_entry *ce;
- call_slot *call = EX(call_slots) + opline->result.num;
+ zend_free_op free_op1, free_op2;
+ zval *object;
+ zval *property;
+ zval *retval;
+ zval *zptr;
SAVE_OPLINE();
+ object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1);
+ property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+ retval = EX_VAR(opline->result.var);
- if (IS_VAR == IS_CONST) {
- /* no function found. try a static method in class */
- if (CACHED_PTR(opline->op1.literal->cache_slot)) {
- ce = CACHED_PTR(opline->op1.literal->cache_slot);
- } else {
- ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
- if (UNEXPECTED(EG(exception) != NULL)) {
- HANDLE_EXCEPTION();
- }
- if (UNEXPECTED(ce == NULL)) {
- zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
+ if (IS_VAR == IS_VAR && UNEXPECTED(object == NULL)) {
+ zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
+ zval_ptr_dtor_nogc(free_op2);
+ if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
+ HANDLE_EXCEPTION();
+ }
+
+ do {
+ if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
+ ZVAL_DEREF(object);
+ if (UNEXPECTED(!make_real_object(object))) {
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ ZVAL_NULL(retval);
+ break;
}
- CACHE_PTR(opline->op1.literal->cache_slot, ce);
}
- call->called_scope = ce;
- } else {
- ce = EX_T(opline->op1.var).class_entry;
- if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
- call->called_scope = EG(called_scope);
- } else {
- call->called_scope = ce;
- }
- }
+ /* here we are sure we are dealing with an object */
- if (IS_VAR == IS_CONST &&
- IS_TMP_VAR == IS_CONST &&
- CACHED_PTR(opline->op2.literal->cache_slot)) {
- call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
- } else if (IS_VAR != IS_CONST &&
- IS_TMP_VAR == IS_CONST &&
- (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
- /* do nothing */
- } else if (IS_TMP_VAR != IS_UNUSED) {
- char *function_name_strval = NULL;
- int function_name_strlen = 0;
- zend_free_op free_op2;
+ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
- if (IS_TMP_VAR == IS_CONST) {
- function_name_strval = Z_STRVAL_P(opline->op2.zv);
- function_name_strlen = Z_STRLEN_P(opline->op2.zv);
+ ZVAL_DEREF(zptr);
+ ZVAL_COPY_VALUE(retval, zptr);
+ zval_opt_copy_ctor(zptr);
-
+ incdec_op(zptr);
} else {
- function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+ if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
- zval rv;
- zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
++ zval rv, obj;
++ zval *z;
+
- if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
- if (UNEXPECTED(EG(exception) != NULL)) {
- HANDLE_EXCEPTION();
- }
- zend_error_noreturn(E_ERROR, "Function name must be a string");
- } else {
- function_name_strval = Z_STRVAL_P(function_name);
- function_name_strlen = Z_STRLEN_P(function_name);
- }
- }
++ ZVAL_COPY(&obj, object);
++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
+ zval z_copy;
- if (function_name_strval) {
- if (ce->get_static_method) {
- call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
- } else {
- call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
- }
- if (UNEXPECTED(call->fbc == NULL)) {
- zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
- }
- if (IS_TMP_VAR == IS_CONST &&
- EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
- EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
- if (IS_VAR == IS_CONST) {
- CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
- } else {
- CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
+ if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
+ zval rv;
+ zval *value = Z_OBJ_HT_P(z)->get(z, &rv);
-
+ if (Z_REFCOUNT_P(z) == 0) {
+ zend_objects_store_del(Z_OBJ_P(z));
+ }
+ ZVAL_COPY_VALUE(z, value);
}
- }
- }
- if (IS_TMP_VAR != IS_CONST) {
- zval_dtor(free_op2.var);
- }
- } else {
- if (UNEXPECTED(ce->constructor == NULL)) {
- zend_error_noreturn(E_ERROR, "Cannot call constructor");
- }
- if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
- zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
- }
- call->fbc = ce->constructor;
- }
-
- if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
- call->object = NULL;
- } else {
- if (EG(This) &&
- Z_OBJ_HT_P(EG(This))->get_class_entry &&
- !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
- /* We are calling method of the other (incompatible) class,
- but passing $this. This is done for compatibility with php-4. */
- if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
- zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
+ ZVAL_DUP(retval, z);
+ ZVAL_DUP(&z_copy, z);
+ incdec_op(&z_copy);
+ if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
- Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ Z_OBJ_HT(obj)->write_property(&obj, property, &z_copy, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ zval_ptr_dtor(&obj);
+ zval_ptr_dtor(&z_copy);
+ zval_ptr_dtor(z);
} else {
- /* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
- zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ ZVAL_NULL(retval);
}
}
- if ((call->object = EG(This))) {
- Z_ADDREF_P(call->object);
- call->called_scope = Z_OBJCE_P(call->object);
- }
- }
-
- call->num_additional_args = 0;
- call->is_ctor_call = 0;
- EX(call) = call;
+ } while (0);
+ zval_ptr_dtor_nogc(free_op2);
+ if (free_op1) {zval_ptr_dtor_nogc(free_op1);};
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
}
}
- if (!have_get_ptr) {
- zval *z = NULL;
+ /* here we are sure we are dealing with an object */
+ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
+
+ ZVAL_DEREF(zptr);
+ SEPARATE_ZVAL_NOREF(zptr);
- Z_ADDREF_P(object);
- if (opline->extended_value == ZEND_ASSIGN_OBJ) {
- if (Z_OBJ_HT_P(object)->read_property) {
- z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
- }
- } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
- if (Z_OBJ_HT_P(object)->read_dimension) {
- z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
- }
+ binary_op(zptr, zptr, value);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(EX_VAR(opline->result.var), zptr);
}
- if (z) {
+ } else {
+ zval *z;
- zval rv;
++ zval rv, obj;
+
- if (Z_OBJ_HT_P(object)->read_property &&
- (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) {
++ ZVAL_COPY(&obj, object);
++ if (Z_OBJ_HT(obj)->read_property &&
++ (z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) {
if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
- zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+ zval rv;
+ zval *value = Z_OBJ_HT_P(z)->get(z, &rv);
if (Z_REFCOUNT_P(z) == 0) {
- GC_REMOVE_ZVAL_FROM_BUFFER(z);
- zval_dtor(z);
- FREE_ZVAL(z);
+ zend_objects_store_del(Z_OBJ_P(z));
}
- z = value;
- }
- Z_ADDREF_P(z);
- SEPARATE_ZVAL_IF_NOT_REF(&z);
- binary_op(z, z, value TSRMLS_CC);
- if (opline->extended_value == ZEND_ASSIGN_OBJ) {
- Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
- } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
- Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
- }
- zval_ptr_dtor(&object);
- if (RETURN_VALUE_USED(opline)) {
- PZVAL_LOCK(z);
- EX_T(opline->result.var).var.ptr = z;
- }
- zval_ptr_dtor(&z);
+ ZVAL_COPY_VALUE(z, value);
+ }
+ zptr = z;
+ ZVAL_DEREF(z);
+ SEPARATE_ZVAL_NOREF(z);
+ binary_op(z, z, value);
- Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ Z_OBJ_HT(obj)->write_property(&obj, property, z, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ zval_ptr_dtor(&obj);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(EX_VAR(opline->result.var), z);
+ }
+ zval_ptr_dtor(zptr);
} else {
zend_error(E_WARNING, "Attempt to assign property of non-object");
- if (RETURN_VALUE_USED(opline)) {
- PZVAL_LOCK(&EG(uninitialized_zval));
- EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_NULL(EX_VAR(opline->result.var));
}
}
}
zval *object;
zval *property;
zval *retval;
- int have_get_ptr = 0;
+ zval *zptr;
SAVE_OPLINE();
- object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
- retval = &EX_T(opline->result.var).tmp_var;
+ object = _get_obj_zval_ptr_unused(execute_data);
+ property = EX_CONSTANT(opline->op2);
+ retval = EX_VAR(opline->result.var);
- if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
- zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
- }
+ if (IS_UNUSED == IS_VAR && UNEXPECTED(object == NULL)) {
+ zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
- make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
- object = *object_ptr;
- if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
- zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
- zval_ptr_dtor_nogc(&free_op2.var);
- ZVAL_NULL(retval);
- if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
+ HANDLE_EXCEPTION();
}
- /* here we are sure we are dealing with an object */
+ do {
+ if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
+ ZVAL_DEREF(object);
+ if (UNEXPECTED(!make_real_object(object))) {
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_NULL(retval);
+ }
+ break;
+ }
+ }
- if (0) {
- MAKE_REAL_ZVAL_PTR(property);
- }
+ /* here we are sure we are dealing with an object */
- if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
- zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
- if (zptr != NULL) { /* NULL means no success in getting PTR */
- have_get_ptr = 1;
- SEPARATE_ZVAL_IF_NOT_REF(zptr);
+ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
- ZVAL_COPY_VALUE(retval, *zptr);
- zendi_zval_copy_ctor(*retval);
+ ZVAL_DEREF(zptr);
+ SEPARATE_ZVAL_NOREF(zptr);
- incdec_op(*zptr);
+ incdec_op(zptr);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(retval, zptr);
+ }
+ } else {
+ zval rv;
- }
- }
+ if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
- zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
++ zval *z, obj;
+
- if (!have_get_ptr) {
- if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
- zval *z, *z_copy;
++ ZVAL_COPY(&obj, object);
++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
- Z_ADDREF_P(object);
- z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
- if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
- zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+ if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
+ zval rv;
+ zval *value = Z_OBJ_HT_P(z)->get(z, &rv);
- if (Z_REFCOUNT_P(z) == 0) {
- GC_REMOVE_ZVAL_FROM_BUFFER(z);
- zval_dtor(z);
- FREE_ZVAL(z);
+ if (Z_REFCOUNT_P(z) == 0) {
+ zend_objects_store_del(Z_OBJ_P(z));
+ }
+ ZVAL_COPY_VALUE(z, value);
+ }
+ ZVAL_DEREF(z);
+ SEPARATE_ZVAL_NOREF(z);
+ incdec_op(z);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(retval, z);
+ }
- Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ Z_OBJ_HT(obj)->write_property(&obj, property, z, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ zval_ptr_dtor(&obj);
+ zval_ptr_dtor(z);
+ } else {
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_NULL(retval);
}
- z = value;
}
- ZVAL_COPY_VALUE(retval, z);
- zendi_zval_copy_ctor(*retval);
- ALLOC_ZVAL(z_copy);
- INIT_PZVAL_COPY(z_copy, z);
- zendi_zval_copy_ctor(*z_copy);
- incdec_op(z_copy);
- Z_ADDREF_P(z);
- Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
- zval_ptr_dtor(&object);
- zval_ptr_dtor(&z_copy);
- zval_ptr_dtor(&z);
- } else {
- zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
- ZVAL_NULL(retval);
}
- }
+ } while (0);
+
- if (0) {
- zval_ptr_dtor(&property);
- } else {
- zval_ptr_dtor_nogc(&free_op2.var);
- }
- if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
-static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
- return zend_post_incdec_property_helper_SPEC_VAR_VAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ return zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
-static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
- return zend_post_incdec_property_helper_SPEC_VAR_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ return zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
-static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_VAR(int type, ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
- zend_free_op free_op1;
- zval *varname;
- zval **retval;
- zval tmp_varname;
- HashTable *target_symbol_table;
- ulong hash_value;
+
+ zval *object;
+ zval *property;
+ zval *retval;
+ zval *zptr;
SAVE_OPLINE();
- varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+ object = _get_obj_zval_ptr_unused(execute_data);
+ property = EX_CONSTANT(opline->op2);
+ retval = EX_VAR(opline->result.var);
- if (IS_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
- ZVAL_COPY_VALUE(&tmp_varname, varname);
- zval_copy_ctor(&tmp_varname);
- Z_SET_REFCOUNT(tmp_varname, 1);
- Z_UNSET_ISREF(tmp_varname);
- convert_to_string(&tmp_varname);
- varname = &tmp_varname;
- }
+ if (IS_UNUSED == IS_VAR && UNEXPECTED(object == NULL)) {
+ zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
- if (IS_VAR != IS_UNUSED) {
- zend_class_entry *ce;
- if (IS_VAR == IS_CONST) {
- if (CACHED_PTR(opline->op2.literal->cache_slot)) {
- ce = CACHED_PTR(opline->op2.literal->cache_slot);
- } else {
- ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
- if (UNEXPECTED(ce == NULL)) {
- if (IS_VAR != IS_CONST && varname == &tmp_varname) {
- zval_dtor(&tmp_varname);
- }
- zval_ptr_dtor_nogc(&free_op1.var);
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
- }
- CACHE_PTR(opline->op2.literal->cache_slot, ce);
- }
- } else {
- ce = EX_T(opline->op2.var).class_entry;
- }
- retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
- zval_ptr_dtor_nogc(&free_op1.var);
- } else {
- target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-/*
- if (!target_symbol_table) {
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
- }
-*/
- if (IS_VAR == IS_CONST) {
- hash_value = Z_HASH_P(varname);
- } else {
- hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
- }
+ HANDLE_EXCEPTION();
+ }
- if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
- switch (type) {
- case BP_VAR_R:
- case BP_VAR_UNSET:
- zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
- /* break missing intentionally */
- case BP_VAR_IS:
- retval = &EG(uninitialized_zval_ptr);
- break;
- case BP_VAR_RW:
- zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
- /* break missing intentionally */
- case BP_VAR_W:
- Z_ADDREF_P(&EG(uninitialized_zval));
- zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
- break;
- EMPTY_SWITCH_DEFAULT_CASE()
- }
- }
- switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
- case ZEND_FETCH_GLOBAL:
- if (IS_VAR != IS_TMP_VAR) {
- zval_ptr_dtor_nogc(&free_op1.var);
- }
- break;
- case ZEND_FETCH_LOCAL:
- zval_ptr_dtor_nogc(&free_op1.var);
- break;
- case ZEND_FETCH_STATIC:
- zval_update_constant(retval, 1 TSRMLS_CC);
- break;
- case ZEND_FETCH_GLOBAL_LOCK:
- if (IS_VAR == IS_VAR && !free_op1.var) {
- PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
- }
+ do {
+ if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
+ ZVAL_DEREF(object);
+ if (UNEXPECTED(!make_real_object(object))) {
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ ZVAL_NULL(retval);
break;
+ }
}
- }
+ /* here we are sure we are dealing with an object */
+
+ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
- if (IS_VAR != IS_CONST && varname == &tmp_varname) {
- zval_dtor(&tmp_varname);
- }
- if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
- }
- PZVAL_LOCK(*retval);
- switch (type) {
- case BP_VAR_R:
- case BP_VAR_IS:
- EX_T(opline->result.var).var.ptr = *retval;
- break;
- case BP_VAR_UNSET: {
- zend_free_op free_res;
+ ZVAL_DEREF(zptr);
+ ZVAL_COPY_VALUE(retval, zptr);
+ zval_opt_copy_ctor(zptr);
-
+ incdec_op(zptr);
+ } else {
+ if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
- zval rv;
- zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
++ zval rv, obj;
++ zval *z;
++
++ ZVAL_COPY(&obj, object);
++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
+ zval z_copy;
- PZVAL_UNLOCK(*retval, &free_res);
- if (retval != &EG(uninitialized_zval_ptr)) {
- SEPARATE_ZVAL_IF_NOT_REF(retval);
+ if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
+ zval rv;
+ zval *value = Z_OBJ_HT_P(z)->get(z, &rv);
-
+ if (Z_REFCOUNT_P(z) == 0) {
+ zend_objects_store_del(Z_OBJ_P(z));
+ }
+ ZVAL_COPY_VALUE(z, value);
+ }
+ ZVAL_DUP(retval, z);
+ ZVAL_DUP(&z_copy, z);
+ incdec_op(&z_copy);
+ if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
- Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ Z_OBJ_HT(obj)->write_property(&obj, property, &z_copy, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ zval_ptr_dtor(&obj);
+ zval_ptr_dtor(&z_copy);
+ zval_ptr_dtor(z);
+ } else {
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ ZVAL_NULL(retval);
}
- PZVAL_LOCK(*retval);
- FREE_OP_VAR_PTR(free_res);
}
- /* break missing intentionally */
- default:
- EX_T(opline->result.var).var.ptr_ptr = retval;
- break;
- }
+ } while (0);
+
+
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_NEXT_OPCODE();
}
-static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
- return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#if 0 || (IS_UNUSED != IS_UNUSED)
+ USE_OPLINE
+
+# if 0 || (IS_UNUSED != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
- return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#if 0 || (IS_UNUSED != IS_UNUSED)
+ USE_OPLINE
+
+# if 0 || (IS_UNUSED != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
- return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#if 0 || (IS_UNUSED != IS_UNUSED)
+ USE_OPLINE
+
+# if 0 || (IS_UNUSED != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
- return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#if 0 || (IS_UNUSED != IS_UNUSED)
+ USE_OPLINE
+
+# if 0 || (IS_UNUSED != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
- return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#if 0 || (IS_UNUSED != IS_UNUSED)
+ USE_OPLINE
+
+# if 0 || (IS_UNUSED != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
- return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#if 0 || (IS_UNUSED != IS_UNUSED)
+ USE_OPLINE
+
+# if 0 || (IS_UNUSED != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
- return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#if 0 || (IS_UNUSED != IS_UNUSED)
+ USE_OPLINE
+
+# if 0 || (IS_UNUSED != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
- return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#if 0 || (IS_UNUSED != IS_UNUSED)
+ USE_OPLINE
+
+# if 0 || (IS_UNUSED != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
- return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#if 0 || (IS_UNUSED != IS_UNUSED)
+ USE_OPLINE
+
+# if 0 || (IS_UNUSED != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
- return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#if 0 || (IS_UNUSED != IS_UNUSED)
+ USE_OPLINE
+
+# if 0 || (IS_UNUSED != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
- return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#if 0 || (IS_UNUSED != IS_UNUSED)
+ USE_OPLINE
+
+# if 0 || (IS_UNUSED != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_UNUSED(int type, ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
+#if 0 || (IS_UNUSED != IS_UNUSED)
USE_OPLINE
- zend_free_op free_op1;
- zval *varname;
- zval **retval;
- zval tmp_varname;
- HashTable *target_symbol_table;
- ulong hash_value;
-
+#endif
SAVE_OPLINE();
- varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+ if (IS_UNUSED == IS_UNUSED) {
+ zend_verify_missing_return_type(EX(func));
+ } else {
+ zval *retval_ptr;
- if (IS_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
- ZVAL_COPY_VALUE(&tmp_varname, varname);
- zval_copy_ctor(&tmp_varname);
- Z_SET_REFCOUNT(tmp_varname, 1);
- Z_UNSET_ISREF(tmp_varname);
- convert_to_string(&tmp_varname);
- varname = &tmp_varname;
+
+ retval_ptr = NULL;
+ zend_verify_return_type(EX(func), retval_ptr);
}
+ CHECK_EXCEPTION();
+ ZEND_VM_NEXT_OPCODE();
+}
- if (IS_UNUSED != IS_UNUSED) {
- zend_class_entry *ce;
+static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ zval *array;
+ uint32_t size;
+ USE_OPLINE
- if (IS_UNUSED == IS_CONST) {
- if (CACHED_PTR(opline->op2.literal->cache_slot)) {
- ce = CACHED_PTR(opline->op2.literal->cache_slot);
- } else {
- ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
- if (UNEXPECTED(ce == NULL)) {
- if (IS_VAR != IS_CONST && varname == &tmp_varname) {
- zval_dtor(&tmp_varname);
- }
- zval_ptr_dtor_nogc(&free_op1.var);
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
- }
- CACHE_PTR(opline->op2.literal->cache_slot, ce);
- }
- } else {
- ce = EX_T(opline->op2.var).class_entry;
- }
- retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
- zval_ptr_dtor_nogc(&free_op1.var);
+ array = EX_VAR(opline->result.var);
+ if (IS_UNUSED != IS_UNUSED) {
+ size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
} else {
- target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-/*
- if (!target_symbol_table) {
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
- }
-*/
- if (IS_VAR == IS_CONST) {
- hash_value = Z_HASH_P(varname);
- } else {
- hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
+ size = 0;
+ }
+ ZVAL_NEW_ARR(array);
+ zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0);
+
+ if (IS_UNUSED != IS_UNUSED) {
+ /* Explicitly initialize array as not-packed if flag is set */
+ if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+ zend_hash_real_init(Z_ARRVAL_P(array), 0);
}
+ }
- if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
- switch (type) {
- case BP_VAR_R:
- case BP_VAR_UNSET:
- zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
- /* break missing intentionally */
- case BP_VAR_IS:
- retval = &EG(uninitialized_zval_ptr);
- break;
- case BP_VAR_RW:
- zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
- /* break missing intentionally */
- case BP_VAR_W:
- Z_ADDREF_P(&EG(uninitialized_zval));
- zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
- break;
- EMPTY_SWITCH_DEFAULT_CASE()
- }
- }
- switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
- case ZEND_FETCH_GLOBAL:
- if (IS_VAR != IS_TMP_VAR) {
- zval_ptr_dtor_nogc(&free_op1.var);
- }
- break;
- case ZEND_FETCH_LOCAL:
- zval_ptr_dtor_nogc(&free_op1.var);
- break;
- case ZEND_FETCH_STATIC:
- zval_update_constant(retval, 1 TSRMLS_CC);
- break;
- case ZEND_FETCH_GLOBAL_LOCK:
- if (IS_VAR == IS_VAR && !free_op1.var) {
- PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
- }
- break;
- }
+ if (IS_UNUSED == IS_UNUSED) {
+ ZEND_VM_NEXT_OPCODE();
+#if 0 || (IS_UNUSED != IS_UNUSED)
+ } else {
+ return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
+}
+static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ USE_OPLINE
- if (IS_VAR != IS_CONST && varname == &tmp_varname) {
- zval_dtor(&tmp_varname);
- }
- if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
- }
- PZVAL_LOCK(*retval);
- switch (type) {
- case BP_VAR_R:
- case BP_VAR_IS:
- EX_T(opline->result.var).var.ptr = *retval;
- break;
- case BP_VAR_UNSET: {
- zend_free_op free_res;
+ /* The generator object is stored in EX(return_value) */
+ zend_generator *generator = (zend_generator *) EX(return_value);
- PZVAL_UNLOCK(*retval, &free_res);
- if (retval != &EG(uninitialized_zval_ptr)) {
- SEPARATE_ZVAL_IF_NOT_REF(retval);
- }
- PZVAL_LOCK(*retval);
- FREE_OP_VAR_PTR(free_res);
- }
- /* break missing intentionally */
- default:
- EX_T(opline->result.var).var.ptr_ptr = retval;
- break;
- }
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
-}
+ if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
+ zend_error(E_EXCEPTION | E_ERROR, "Cannot yield from finally in a force-closed generator");
-static int ZEND_FASTCALL ZEND_FETCH_R_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-static int ZEND_FASTCALL ZEND_FETCH_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
+ HANDLE_EXCEPTION();
+ }
-static int ZEND_FASTCALL ZEND_FETCH_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
+ /* Destroy the previously yielded value */
+ zval_ptr_dtor(&generator->value);
-static int ZEND_FASTCALL ZEND_FETCH_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- USE_OPLINE
+ /* Destroy the previously yielded key */
+ zval_ptr_dtor(&generator->key);
- return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
+ /* Set the new yielded value */
+ if (IS_UNUSED != IS_UNUSED) {
-static int ZEND_FASTCALL ZEND_FETCH_UNSET_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-static int ZEND_FASTCALL ZEND_FETCH_IS_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
+ if (EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE) {
+ /* Constants and temporary variables aren't yieldable by reference,
+ * but we still allow them with a notice. */
+ if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) {
+ zval *value;
-static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- USE_OPLINE
- zend_free_op free_op1;
- zval **container;
+ zend_error(E_NOTICE, "Only variable references should be yielded by reference");
- SAVE_OPLINE();
- container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+ value = NULL;
+ ZVAL_COPY_VALUE(&generator->value, value);
+ if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
- if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
- zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
- }
- zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_W TSRMLS_CC);
+ /* Temporary variables don't need ctor copying */
+ if (IS_UNUSED != IS_TMP_VAR) {
+ zval_opt_copy_ctor(&generator->value);
+ }
+ } else {
+ zval *value_ptr = NULL;
- if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
- EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
- }
- if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+ if (IS_UNUSED == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
+ zend_error(E_EXCEPTION | E_ERROR, "Cannot yield string offsets by reference");
- /* We are going to assign the result by reference */
- if (UNEXPECTED(opline->extended_value != 0)) {
- zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
- if (retval_ptr) {
- Z_DELREF_PP(retval_ptr);
- SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
- Z_ADDREF_PP(retval_ptr);
- }
- }
+ HANDLE_EXCEPTION();
+ }
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
-}
+ /* If a function call result is yielded and the function did
+ * not return by reference we throw a notice. */
+ if (IS_UNUSED == IS_VAR &&
+ (value_ptr == &EG(uninitialized_zval) ||
+ (opline->extended_value == ZEND_RETURNS_FUNCTION &&
+ !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) {
+ zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+ } else {
+ ZVAL_MAKE_REF(value_ptr);
+ }
+ ZVAL_COPY(&generator->value, value_ptr);
-static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- USE_OPLINE
- zend_free_op free_op1;
- zval **container;
+ }
+ } else {
+ zval *value = NULL;
- SAVE_OPLINE();
- container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+ /* Consts, temporary variables and references need copying */
+ if (IS_UNUSED == IS_CONST) {
+ ZVAL_DUP(&generator->value, value);
+ } else if (IS_UNUSED == IS_TMP_VAR) {
+ ZVAL_COPY_VALUE(&generator->value, value);
+ } else if ((IS_UNUSED == IS_CV || IS_UNUSED == IS_VAR) && Z_ISREF_P(value)) {
+ ZVAL_DUP(&generator->value, Z_REFVAL_P(value));
- if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
- zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+ } else {
+ ZVAL_COPY_VALUE(&generator->value, value);
+ if (IS_UNUSED == IS_CV) {
+ if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
+ }
+ }
+ }
+ } else {
+ /* If no value was specified yield null */
+ ZVAL_NULL(&generator->value);
}
- zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_RW TSRMLS_CC);
- if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
- EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
- }
- if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
-}
+ /* Set the new yielded key */
+ if (IS_UNUSED != IS_UNUSED) {
-static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- USE_OPLINE
- zend_free_op free_op1;
+ zval *key = NULL;
- SAVE_OPLINE();
+ /* Consts, temporary variables and references need copying */
+ if (IS_UNUSED == IS_CONST) {
+ ZVAL_DUP(&generator->key, key);
+ } else if (IS_UNUSED == IS_TMP_VAR) {
+ ZVAL_COPY_VALUE(&generator->key, key);
+ } else if ((IS_UNUSED == IS_VAR || IS_UNUSED == IS_CV) && Z_ISREF_P(key)) {
+ ZVAL_DUP(&generator->key, Z_REFVAL_P(key));
- if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
- zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
- zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+ } else {
+ ZVAL_COPY_VALUE(&generator->key, key);
+ if (IS_UNUSED == IS_CV) {
+ if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
+ }
}
- zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_W TSRMLS_CC);
- if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
- EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+
+ if (Z_TYPE(generator->key) == IS_LONG
+ && Z_LVAL(generator->key) > generator->largest_used_integer_key
+ ) {
+ generator->largest_used_integer_key = Z_LVAL(generator->key);
}
+ } else {
+ /* If no key was specified we use auto-increment keys */
+ generator->largest_used_integer_key++;
+ ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
+ }
- if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+ if (RETURN_VALUE_USED(opline)) {
+ /* If the return value of yield is used set the send
+ * target and initialize it to NULL */
+ generator->send_target = EX_VAR(opline->result.var);
+ ZVAL_NULL(generator->send_target);
} else {
- zval *container;
+ generator->send_target = NULL;
+ }
- if (IS_UNUSED == IS_UNUSED) {
- zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
- }
- container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_R TSRMLS_CC);
+ /* We increment to the next op, so we are at the correct position when the
+ * generator is resumed. */
+ ZEND_VM_INC_OPCODE();
- zval_ptr_dtor_nogc(&free_op1.var);
- }
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
+ /* The GOTO VM uses a local opline variable. We need to set the opline
+ * variable in execute_data so we don't resume at an old position. */
+ SAVE_OPLINE();
+
+ ZEND_VM_RETURN();
}
-static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(int (*binary_op)(zval *result, zval *op1, zval *op2), ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
- zend_free_op free_op1;
- zval **object_ptr;
+ zend_free_op free_op_data1;
+ zval *object = _get_obj_zval_ptr_unused(execute_data);
+ zval *property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+ zval *value;
+ zval *zptr;
- SAVE_OPLINE();
- object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+ if (IS_UNUSED == IS_VAR && UNEXPECTED(object == NULL)) {
+ zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an object");
+ FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
- if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
- zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
- }
- if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
- zval *property_name = NULL;
+ HANDLE_EXCEPTION();
+ }
- if (0) {
- MAKE_REAL_ZVAL_PTR(property_name);
- }
- zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
- if (0) {
- zval_ptr_dtor(&property_name);
- } else {
+ do {
+ value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+ if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
+ ZVAL_DEREF(object);
+ if (UNEXPECTED(!make_real_object(object))) {
+ zend_error(E_WARNING, "Attempt to assign property of non-object");
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_NULL(EX_VAR(opline->result.var));
+ }
+ break;
+ }
}
- } else {
- zend_free_op free_op_data1, free_op_data2;
- zval *value;
- zval *dim = NULL;
- zval **variable_ptr_ptr;
- zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_UNUSED, BP_VAR_W TSRMLS_CC);
+ /* here we are sure we are dealing with an object */
+ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
- value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
- variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
- if (UNEXPECTED(variable_ptr_ptr == NULL)) {
- if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
- if (RETURN_VALUE_USED(opline)) {
- zval *retval;
+ ZVAL_DEREF(zptr);
+ SEPARATE_ZVAL_NOREF(zptr);
- ALLOC_ZVAL(retval);
- ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
- INIT_PZVAL(retval);
- EX_T(opline->result.var).var.ptr = retval;
- }
- } else if (RETURN_VALUE_USED(opline)) {
- PZVAL_LOCK(&EG(uninitialized_zval));
- EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
- }
- } else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
- if (IS_TMP_FREE(free_op_data1)) {
- zval_dtor(value);
- }
- if (RETURN_VALUE_USED(opline)) {
- PZVAL_LOCK(&EG(uninitialized_zval));
- EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+ binary_op(zptr, zptr, value);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(EX_VAR(opline->result.var), zptr);
}
} else {
- if ((opline+1)->op1_type == IS_TMP_VAR) {
- value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
- } else if ((opline+1)->op1_type == IS_CONST) {
- value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+ zval *z;
- zval rv;
++ zval rv, obj;
+
- if (Z_OBJ_HT_P(object)->read_property &&
- (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) {
++ ZVAL_COPY(&obj, object);
++ if (Z_OBJ_HT(obj)->read_property &&
++ (z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) {
+ if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
+ zval rv;
+ zval *value = Z_OBJ_HT_P(z)->get(z, &rv);
+
+ if (Z_REFCOUNT_P(z) == 0) {
+ zend_objects_store_del(Z_OBJ_P(z));
+ }
+ ZVAL_COPY_VALUE(z, value);
+ }
+ zptr = z;
+ ZVAL_DEREF(z);
+ SEPARATE_ZVAL_NOREF(z);
+ binary_op(z, z, value);
- Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ Z_OBJ_HT(obj)->write_property(&obj, property, z, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ zval_ptr_dtor(&obj);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(EX_VAR(opline->result.var), z);
+ }
+ zval_ptr_dtor(zptr);
} else {
- value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
- }
- if (RETURN_VALUE_USED(opline)) {
- PZVAL_LOCK(value);
- EX_T(opline->result.var).var.ptr = value;
+ zend_error(E_WARNING, "Attempt to assign property of non-object");
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_NULL(EX_VAR(opline->result.var));
+ }
}
}
- FREE_OP_VAR_PTR(free_op_data2);
- FREE_OP_IF_VAR(free_op_data1);
- }
- if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
- /* assign_dim has two opcodes! */
+ } while (0);
+
+ FREE_OP(free_op_data1);
+
+
+ /* assign_obj has two opcodes! */
CHECK_EXCEPTION();
ZEND_VM_INC_OPCODE();
ZEND_VM_NEXT_OPCODE();
ZEND_VM_NEXT_OPCODE();
}
-static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
+#if 0 || (IS_CV != IS_UNUSED)
USE_OPLINE
- zend_free_op free_op1;
- zval *expr_ptr;
- SAVE_OPLINE();
- if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
- zval **expr_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-
- if (IS_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
- zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
- }
- SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
- expr_ptr = *expr_ptr_ptr;
- Z_ADDREF_P(expr_ptr);
- } else {
- expr_ptr=_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- if (0) { /* temporary variable */
- zval *new_expr;
-
- ALLOC_ZVAL(new_expr);
- INIT_PZVAL_COPY(new_expr, expr_ptr);
- expr_ptr = new_expr;
- } else if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
- zval *new_expr;
-
- ALLOC_ZVAL(new_expr);
- INIT_PZVAL_COPY(new_expr, expr_ptr);
- expr_ptr = new_expr;
- zendi_zval_copy_ctor(*expr_ptr);
- zval_ptr_dtor_nogc(&free_op1.var);
- } else if (IS_VAR == IS_CV) {
- Z_ADDREF_P(expr_ptr);
- }
+# if 0 || (IS_UNUSED != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_UNUSED_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+}
- if (IS_UNUSED != IS_UNUSED) {
-
- zval *offset = NULL;
- ulong hval;
-
- switch (Z_TYPE_P(offset)) {
- case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
- goto num_index;
- case IS_LONG:
- case IS_BOOL:
- hval = Z_LVAL_P(offset);
-num_index:
- zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
- break;
- case IS_STRING:
- if (IS_UNUSED == IS_CONST) {
- hval = Z_HASH_P(offset);
- } else {
- ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
- hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
- }
- zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
- break;
- case IS_NULL:
- zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
- break;
- default:
- zend_error(E_WARNING, "Illegal offset type");
- zval_ptr_dtor(&expr_ptr);
- /* do nothing */
- break;
- }
+static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+#if 0 || (IS_CV != IS_UNUSED)
+ USE_OPLINE
- } else {
- zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
+# if 0 || (IS_UNUSED != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_UNUSED_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
- if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
- if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
+#if 0 || (IS_CV != IS_UNUSED)
USE_OPLINE
- array_init(&EX_T(opline->result.var).tmp_var);
- if (IS_VAR == IS_UNUSED) {
- ZEND_VM_NEXT_OPCODE();
-#if 0 || IS_VAR != IS_UNUSED
- } else {
- return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-#endif
+# if 0 || (IS_UNUSED != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_UNUSED_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
+#if 0 || (IS_CV != IS_UNUSED)
USE_OPLINE
- zval tmp, *varname;
- HashTable *target_symbol_table;
- zend_free_op free_op1;
-
- SAVE_OPLINE();
- if (IS_VAR == IS_CV &&
- IS_UNUSED == IS_UNUSED &&
- (opline->extended_value & ZEND_QUICK_SET)) {
- if (EG(active_symbol_table)) {
- zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
- zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
- EX_CV(opline->op1.var) = NULL;
- } else if (EX_CV(opline->op1.var)) {
- zval_ptr_dtor(EX_CV(opline->op1.var));
- EX_CV(opline->op1.var) = NULL;
- }
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
+# if 0 || (IS_UNUSED != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_UNUSED_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
-
- varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-
- if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
- ZVAL_COPY_VALUE(&tmp, varname);
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- varname = &tmp;
- } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
- Z_ADDREF_P(varname);
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+}
- if (IS_UNUSED != IS_UNUSED) {
- zend_class_entry *ce;
-
- if (IS_UNUSED == IS_CONST) {
- if (CACHED_PTR(opline->op2.literal->cache_slot)) {
- ce = CACHED_PTR(opline->op2.literal->cache_slot);
- } else {
- ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
- if (UNEXPECTED(EG(exception) != NULL)) {
- if (IS_VAR != IS_CONST && varname == &tmp) {
- zval_dtor(&tmp);
- } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
- zval_ptr_dtor(&varname);
- }
- zval_ptr_dtor_nogc(&free_op1.var);
- HANDLE_EXCEPTION();
- }
- if (UNEXPECTED(ce == NULL)) {
- zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
- }
- CACHE_PTR(opline->op2.literal->cache_slot, ce);
- }
- } else {
- ce = EX_T(opline->op2.var).class_entry;
- }
- zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
- } else {
- ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
+static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+#if 0 || (IS_CV != IS_UNUSED)
+ USE_OPLINE
- target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
- zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
+# if 0 || (IS_UNUSED != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_UNUSED_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
-
- if (IS_VAR != IS_CONST && varname == &tmp) {
- zval_dtor(&tmp);
- } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
- zval_ptr_dtor(&varname);
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
- zval_ptr_dtor_nogc(&free_op1.var);
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
+#if 0 || (IS_CV != IS_UNUSED)
USE_OPLINE
- zval **value;
- zend_bool isset = 1;
-
- SAVE_OPLINE();
- if (IS_VAR == IS_CV &&
- IS_UNUSED == IS_UNUSED &&
- (opline->extended_value & ZEND_QUICK_SET)) {
- if (EX_CV(opline->op1.var)) {
- value = EX_CV(opline->op1.var);
- } else if (EG(active_symbol_table)) {
- zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
- if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
- isset = 0;
- }
- } else {
- isset = 0;
- }
- } else {
- HashTable *target_symbol_table;
- zend_free_op free_op1;
- zval tmp, *varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+# if 0 || (IS_UNUSED != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_UNUSED_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+}
- if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
- ZVAL_COPY_VALUE(&tmp, varname);
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- varname = &tmp;
- }
+static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+#if 0 || (IS_CV != IS_UNUSED)
+ USE_OPLINE
- if (IS_UNUSED != IS_UNUSED) {
- zend_class_entry *ce;
+# if 0 || (IS_UNUSED != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_UNUSED_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+}
- if (IS_UNUSED == IS_CONST) {
- if (CACHED_PTR(opline->op2.literal->cache_slot)) {
- ce = CACHED_PTR(opline->op2.literal->cache_slot);
- } else {
- ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
- if (UNEXPECTED(ce == NULL)) {
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
- }
- CACHE_PTR(opline->op2.literal->cache_slot, ce);
- }
- } else {
- ce = EX_T(opline->op2.var).class_entry;
- }
- value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
- if (!value) {
- isset = 0;
- }
- } else {
- target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
- if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
- isset = 0;
- }
- }
+static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+#if 0 || (IS_CV != IS_UNUSED)
+ USE_OPLINE
- if (IS_VAR != IS_CONST && varname == &tmp) {
- zval_dtor(&tmp);
- }
- zval_ptr_dtor_nogc(&free_op1.var);
+# if 0 || (IS_UNUSED != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_UNUSED_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
-
- if (opline->extended_value & ZEND_ISSET) {
- if (isset && Z_TYPE_PP(value) != IS_NULL) {
- ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
- } else {
- ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
- }
- } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
- if (!isset || !i_zend_is_true(*value)) {
- ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
- } else {
- ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
- }
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
-
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
+#if 0 || (IS_CV != IS_UNUSED)
USE_OPLINE
- zval *var_ptr, *new_zv;
-
- SAVE_OPLINE();
- var_ptr = EX_T(opline->op1.var).var.ptr;
- if (Z_TYPE_P(var_ptr) != IS_OBJECT &&
- !PZVAL_IS_REF(var_ptr) &&
- Z_REFCOUNT_P(var_ptr) > 1) {
- Z_DELREF_P(var_ptr);
- ALLOC_ZVAL(new_zv);
- INIT_PZVAL_COPY(new_zv, var_ptr);
- var_ptr = new_zv;
- zval_copy_ctor(var_ptr);
- EX_T(opline->op1.var).var.ptr = var_ptr;
+# if 0 || (IS_UNUSED != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
- ZEND_VM_NEXT_OPCODE();
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
+#if 0 || (IS_CV != IS_UNUSED)
USE_OPLINE
- /* The generator object is stored in return_value_ptr_ptr */
- zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
-
- if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
- zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
+# if 0 || (IS_UNUSED != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
-
- /* Destroy the previously yielded value */
- if (generator->value) {
- zval_ptr_dtor(&generator->value);
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+}
- /* Destroy the previously yielded key */
- if (generator->key) {
- zval_ptr_dtor(&generator->key);
+static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+#if 0 || (IS_CV != IS_UNUSED)
+ USE_OPLINE
+
+# if 0 || (IS_UNUSED != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+}
- /* Set the new yielded value */
- if (IS_VAR != IS_UNUSED) {
- zend_free_op free_op1;
+static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
+{
+ USE_OPLINE
- if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
- /* Constants and temporary variables aren't yieldable by reference,
- * but we still allow them with a notice. */
- if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
- zval *value, *copy;
+ zval *object;
+ zval *property;
+ zval *retval;
+ zval *zptr;
- zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+ SAVE_OPLINE();
+ object = _get_obj_zval_ptr_unused(execute_data);
+ property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+ retval = EX_VAR(opline->result.var);
- value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- ALLOC_ZVAL(copy);
- INIT_PZVAL_COPY(copy, value);
+ if (IS_UNUSED == IS_VAR && UNEXPECTED(object == NULL)) {
+ zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
- /* Temporary variables don't need ctor copying */
- if (!0) {
- zval_copy_ctor(copy);
- }
- generator->value = copy;
- } else {
- zval **value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+ HANDLE_EXCEPTION();
+ }
- if (IS_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
- zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
+ do {
+ if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
+ ZVAL_DEREF(object);
+ if (UNEXPECTED(!make_real_object(object))) {
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_NULL(retval);
}
+ break;
+ }
+ }
- /* If a function call result is yielded and the function did
- * not return by reference we throw a notice. */
- if (IS_VAR == IS_VAR && !Z_ISREF_PP(value_ptr)
- && !(opline->extended_value == ZEND_RETURNS_FUNCTION
- && EX_T(opline->op1.var).var.fcall_returned_reference)
- && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
- zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+ /* here we are sure we are dealing with an object */
- Z_ADDREF_PP(value_ptr);
- generator->value = *value_ptr;
- } else {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
- Z_ADDREF_PP(value_ptr);
- generator->value = *value_ptr;
- }
+ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
- if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+ ZVAL_DEREF(zptr);
+ SEPARATE_ZVAL_NOREF(zptr);
+
+ incdec_op(zptr);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(retval, zptr);
}
} else {
- zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+ zval rv;
- /* Consts, temporary variables and references need copying */
- if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR
- || PZVAL_IS_REF(value)
- ) {
- zval *copy;
+ if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
- zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
++ zval *z, obj;
+
- ALLOC_ZVAL(copy);
- INIT_PZVAL_COPY(copy, value);
++ ZVAL_COPY(&obj, object);
++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
- /* Temporary variables don't need ctor copying */
- if (!0) {
- zval_copy_ctor(copy);
- }
+ if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
+ zval rv;
+ zval *value = Z_OBJ_HT_P(z)->get(z, &rv);
- generator->value = copy;
- zval_ptr_dtor_nogc(&free_op1.var);
+ if (Z_REFCOUNT_P(z) == 0) {
+ zend_objects_store_del(Z_OBJ_P(z));
+ }
+ ZVAL_COPY_VALUE(z, value);
+ }
+ ZVAL_DEREF(z);
+ SEPARATE_ZVAL_NOREF(z);
+ incdec_op(z);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(retval, z);
+ }
- Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ Z_OBJ_HT(obj)->write_property(&obj, property, z, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ zval_ptr_dtor(&obj);
+ zval_ptr_dtor(z);
} else {
- if (IS_VAR == IS_CV) {
- Z_ADDREF_P(value);
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_NULL(retval);
}
- generator->value = value;
}
}
- } else {
- /* If no value was specified yield null */
- Z_ADDREF(EG(uninitialized_zval));
- generator->value = &EG(uninitialized_zval);
- }
+ } while (0);
- /* Set the new yielded key */
- if (IS_UNUSED != IS_UNUSED) {
- zval *key = NULL;
+ CHECK_EXCEPTION();
+ ZEND_VM_NEXT_OPCODE();
+}
- /* Consts, temporary variables and references need copying */
- if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR
- || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
- ) {
- zval *copy;
+static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ return zend_pre_incdec_property_helper_SPEC_UNUSED_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
- ALLOC_ZVAL(copy);
- INIT_PZVAL_COPY(copy, key);
+static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ return zend_pre_incdec_property_helper_SPEC_UNUSED_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
- /* Temporary variables don't need ctor copying */
- if (!0) {
- zval_copy_ctor(copy);
- }
+static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
+{
+ USE_OPLINE
- generator->key = copy;
- } else {
- Z_ADDREF_P(key);
- generator->key = key;
- }
+ zval *object;
+ zval *property;
+ zval *retval;
+ zval *zptr;
- if (Z_TYPE_P(generator->key) == IS_LONG
- && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
- ) {
- generator->largest_used_integer_key = Z_LVAL_P(generator->key);
- }
+ SAVE_OPLINE();
+ object = _get_obj_zval_ptr_unused(execute_data);
+ property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+ retval = EX_VAR(opline->result.var);
- } else {
- /* If no key was specified we use auto-increment keys */
- generator->largest_used_integer_key++;
+ if (IS_UNUSED == IS_VAR && UNEXPECTED(object == NULL)) {
+ zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
- ALLOC_INIT_ZVAL(generator->key);
- ZVAL_LONG(generator->key, generator->largest_used_integer_key);
+
+ HANDLE_EXCEPTION();
}
- if (RETURN_VALUE_USED(opline)) {
- /* If the return value of yield is used set the send
- * target and initialize it to NULL */
- generator->send_target = &EX_T(opline->result.var).var.ptr;
- Z_ADDREF(EG(uninitialized_zval));
- EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
- } else {
- generator->send_target = NULL;
- }
+ do {
+ if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
+ ZVAL_DEREF(object);
+ if (UNEXPECTED(!make_real_object(object))) {
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ ZVAL_NULL(retval);
+ break;
+ }
+ }
- /* We increment to the next op, so we are at the correct position when the
- * generator is resumed. */
- ZEND_VM_INC_OPCODE();
+ /* here we are sure we are dealing with an object */
- /* The GOTO VM uses a local opline variable. We need to set the opline
- * variable in execute_data so we don't resume at an old position. */
- SAVE_OPLINE();
+ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
- ZEND_VM_RETURN();
-}
+ ZVAL_DEREF(zptr);
+ ZVAL_COPY_VALUE(retval, zptr);
+ zval_opt_copy_ctor(zptr);
-
+ incdec_op(zptr);
+ } else {
+ if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
- zval rv;
- zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
++ zval rv, obj;
++ zval *z;
+
-static int ZEND_FASTCALL ZEND_ASSIGN_POW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(pow_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
++ ZVAL_COPY(&obj, object);
++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
+ zval z_copy;
-static int ZEND_FASTCALL ZEND_ADD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- USE_OPLINE
- zend_free_op free_op1;
+ if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
+ zval rv;
+ zval *value = Z_OBJ_HT_P(z)->get(z, &rv);
-
+ if (Z_REFCOUNT_P(z) == 0) {
+ zend_objects_store_del(Z_OBJ_P(z));
+ }
+ ZVAL_COPY_VALUE(z, value);
+ }
+ ZVAL_DUP(retval, z);
+ ZVAL_DUP(&z_copy, z);
+ incdec_op(&z_copy);
+ if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
- Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ Z_OBJ_HT(obj)->write_property(&obj, property, &z_copy, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ zval_ptr_dtor(&obj);
+ zval_ptr_dtor(&z_copy);
+ zval_ptr_dtor(z);
+ } else {
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ ZVAL_NULL(retval);
+ }
+ }
+ } while (0);
- SAVE_OPLINE();
- fast_add_function(&EX_T(opline->result.var).tmp_var,
- _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
- _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
- zval_ptr_dtor_nogc(&free_op1.var);
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
ZEND_VM_NEXT_OPCODE();
}
-static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
- return zend_pre_incdec_property_helper_SPEC_VAR_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
+ USE_OPLINE
-static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- return zend_pre_incdec_property_helper_SPEC_VAR_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
+ /* The generator object is stored in EX(return_value) */
+ zend_generator *generator = (zend_generator *) EX(return_value);
-static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
-{
- USE_OPLINE
- zend_free_op free_op1;
- zval **object_ptr;
- zval *object;
- zval *property;
- zval *retval;
- int have_get_ptr = 0;
+ if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
+ zend_error(E_EXCEPTION | E_ERROR, "Cannot yield from finally in a force-closed generator");
- SAVE_OPLINE();
- object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
- retval = &EX_T(opline->result.var).tmp_var;
- if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
- zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
+ HANDLE_EXCEPTION();
}
- make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
- object = *object_ptr;
+ /* Destroy the previously yielded value */
+ zval_ptr_dtor(&generator->value);
- if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
- zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ /* Destroy the previously yielded key */
+ zval_ptr_dtor(&generator->key);
- ZVAL_NULL(retval);
- if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
- }
+ /* Set the new yielded value */
+ if (IS_UNUSED != IS_UNUSED) {
- /* here we are sure we are dealing with an object */
- if (0) {
- MAKE_REAL_ZVAL_PTR(property);
- }
+ if (EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE) {
+ /* Constants and temporary variables aren't yieldable by reference,
+ * but we still allow them with a notice. */
+ if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) {
+ zval *value;
- if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
- zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
- if (zptr != NULL) { /* NULL means no success in getting PTR */
- have_get_ptr = 1;
- SEPARATE_ZVAL_IF_NOT_REF(zptr);
+ zend_error(E_NOTICE, "Only variable references should be yielded by reference");
- ZVAL_COPY_VALUE(retval, *zptr);
- zendi_zval_copy_ctor(*retval);
+ value = NULL;
+ ZVAL_COPY_VALUE(&generator->value, value);
+ if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
- incdec_op(*zptr);
+ /* Temporary variables don't need ctor copying */
+ if (IS_UNUSED != IS_TMP_VAR) {
+ zval_opt_copy_ctor(&generator->value);
+ }
+ } else {
+ zval *value_ptr = NULL;
- }
- }
+ if (IS_UNUSED == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
+ zend_error(E_EXCEPTION | E_ERROR, "Cannot yield string offsets by reference");
- if (!have_get_ptr) {
- if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
- zval *z, *z_copy;
- Z_ADDREF_P(object);
- z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
- if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
- zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+ HANDLE_EXCEPTION();
+ }
- if (Z_REFCOUNT_P(z) == 0) {
- GC_REMOVE_ZVAL_FROM_BUFFER(z);
- zval_dtor(z);
- FREE_ZVAL(z);
+ /* If a function call result is yielded and the function did
+ * not return by reference we throw a notice. */
+ if (IS_UNUSED == IS_VAR &&
+ (value_ptr == &EG(uninitialized_zval) ||
+ (opline->extended_value == ZEND_RETURNS_FUNCTION &&
+ !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF)))) {
+ zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+ } else {
+ ZVAL_MAKE_REF(value_ptr);
}
- z = value;
+ ZVAL_COPY(&generator->value, value_ptr);
+
}
- ZVAL_COPY_VALUE(retval, z);
- zendi_zval_copy_ctor(*retval);
- ALLOC_ZVAL(z_copy);
- INIT_PZVAL_COPY(z_copy, z);
- zendi_zval_copy_ctor(*z_copy);
- incdec_op(z_copy);
- Z_ADDREF_P(z);
- Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
- zval_ptr_dtor(&object);
- zval_ptr_dtor(&z_copy);
- zval_ptr_dtor(&z);
} else {
- zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
- ZVAL_NULL(retval);
+ zval *value = NULL;
+
+ /* Consts, temporary variables and references need copying */
+ if (IS_UNUSED == IS_CONST) {
+ ZVAL_DUP(&generator->value, value);
+ } else if (IS_UNUSED == IS_TMP_VAR) {
+ ZVAL_COPY_VALUE(&generator->value, value);
+ } else if ((IS_UNUSED == IS_CV || IS_UNUSED == IS_VAR) && Z_ISREF_P(value)) {
+ ZVAL_DUP(&generator->value, Z_REFVAL_P(value));
+
+ } else {
+ ZVAL_COPY_VALUE(&generator->value, value);
+ if (IS_UNUSED == IS_CV) {
+ if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value);
+ }
+ }
}
+ } else {
+ /* If no value was specified yield null */
+ ZVAL_NULL(&generator->value);
}
- if (0) {
- zval_ptr_dtor(&property);
+ /* Set the new yielded key */
+ if (IS_CV != IS_UNUSED) {
+
+ zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+
+ /* Consts, temporary variables and references need copying */
+ if (IS_CV == IS_CONST) {
+ ZVAL_DUP(&generator->key, key);
+ } else if (IS_CV == IS_TMP_VAR) {
+ ZVAL_COPY_VALUE(&generator->key, key);
+ } else if ((IS_CV == IS_VAR || IS_CV == IS_CV) && Z_ISREF_P(key)) {
+ ZVAL_DUP(&generator->key, Z_REFVAL_P(key));
+
+ } else {
+ ZVAL_COPY_VALUE(&generator->key, key);
+ if (IS_CV == IS_CV) {
+ if (Z_OPT_REFCOUNTED_P(key)) Z_ADDREF_P(key);
+ }
+ }
+
+ if (Z_TYPE(generator->key) == IS_LONG
+ && Z_LVAL(generator->key) > generator->largest_used_integer_key
+ ) {
+ generator->largest_used_integer_key = Z_LVAL(generator->key);
+ }
} else {
+ /* If no key was specified we use auto-increment keys */
+ generator->largest_used_integer_key++;
+ ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
+ }
+ if (RETURN_VALUE_USED(opline)) {
+ /* If the return value of yield is used set the send
+ * target and initialize it to NULL */
+ generator->send_target = EX_VAR(opline->result.var);
+ ZVAL_NULL(generator->send_target);
+ } else {
+ generator->send_target = NULL;
}
- if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
-}
-static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- return zend_post_incdec_property_helper_SPEC_VAR_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
+ /* We increment to the next op, so we are at the correct position when the
+ * generator is resumed. */
+ ZEND_VM_INC_OPCODE();
-static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- return zend_post_incdec_property_helper_SPEC_VAR_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ /* The GOTO VM uses a local opline variable. We need to set the opline
+ * variable in execute_data so we don't resume at an old position. */
+ SAVE_OPLINE();
+
+ ZEND_VM_RETURN();
}
-static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMPVAR(int (*binary_op)(zval *result, zval *op1, zval *op2), ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
- zend_free_op free_op1;
- zval *container;
+ zend_free_op free_op2, free_op_data1;
+ zval *object = _get_obj_zval_ptr_unused(execute_data);
+ zval *property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+ zval *value;
+ zval *zptr;
- SAVE_OPLINE();
- container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
+ if (IS_UNUSED == IS_VAR && UNEXPECTED(object == NULL)) {
+ zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an object");
+ FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
+ zval_ptr_dtor_nogc(free_op2);
- if (IS_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
- zval_ptr_dtor_nogc(&free_op1.var);
+ HANDLE_EXCEPTION();
}
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
-}
-static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- USE_OPLINE
- zend_free_op free_op1;
- zval **container;
+ do {
+ value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
- SAVE_OPLINE();
- container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+ if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
+ ZVAL_DEREF(object);
+ if (UNEXPECTED(!make_real_object(object))) {
+ zend_error(E_WARNING, "Attempt to assign property of non-object");
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_NULL(EX_VAR(opline->result.var));
+ }
+ break;
+ }
+ }
- if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
- zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
- }
- zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_W TSRMLS_CC);
+ /* here we are sure we are dealing with an object */
+ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
- if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
- EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
- }
- if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+ ZVAL_DEREF(zptr);
+ SEPARATE_ZVAL_NOREF(zptr);
+
+ binary_op(zptr, zptr, value);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(EX_VAR(opline->result.var), zptr);
+ }
+ } else {
+ zval *z;
- zval rv;
++ zval rv, obj;
- if (Z_OBJ_HT_P(object)->read_property &&
- (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) {
- /* We are going to assign the result by reference */
- if (UNEXPECTED(opline->extended_value != 0)) {
- zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
++ ZVAL_COPY(&obj, object);
++ if (Z_OBJ_HT(obj)->read_property &&
++ (z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) {
+ if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
+ zval rv;
+ zval *value = Z_OBJ_HT_P(z)->get(z, &rv);
- if (retval_ptr) {
- Z_DELREF_PP(retval_ptr);
- SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
- Z_ADDREF_PP(retval_ptr);
+ if (Z_REFCOUNT_P(z) == 0) {
+ zend_objects_store_del(Z_OBJ_P(z));
+ }
+ ZVAL_COPY_VALUE(z, value);
+ }
+ zptr = z;
+ ZVAL_DEREF(z);
+ SEPARATE_ZVAL_NOREF(z);
+ binary_op(z, z, value);
- Z_OBJ_HT_P(object)->write_property(object, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ Z_OBJ_HT(obj)->write_property(&obj, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ zval_ptr_dtor(&obj);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(EX_VAR(opline->result.var), z);
+ }
+ zval_ptr_dtor(zptr);
+ } else {
+ zend_error(E_WARNING, "Attempt to assign property of non-object");
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_NULL(EX_VAR(opline->result.var));
+ }
+ }
}
- }
+ } while (0);
+
+ FREE_OP(free_op_data1);
+ zval_ptr_dtor_nogc(free_op2);
+ /* assign_obj has two opcodes! */
CHECK_EXCEPTION();
+ ZEND_VM_INC_OPCODE();
ZEND_VM_NEXT_OPCODE();
}
}
/* here we are sure we are dealing with an object */
- retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
- PZVAL_LOCK(retval);
- EX_T(opline->result.var).var.ptr = retval;
+ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
+
+ ZVAL_DEREF(zptr);
+ SEPARATE_ZVAL_NOREF(zptr);
- if (0) {
- zval_ptr_dtor(&offset);
+ incdec_op(zptr);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(retval, zptr);
+ }
} else {
- zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
+ zval rv;
+
+ if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
++ zval *z, obj;
++
++ ZVAL_COPY(&obj, object);
++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
+
+ if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
+ zval rv;
+ zval *value = Z_OBJ_HT_P(z)->get(z, &rv);
- Z_OBJ_HT_P(object)->write_property(object, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
+ if (Z_REFCOUNT_P(z) == 0) {
+ zend_objects_store_del(Z_OBJ_P(z));
+ }
+ ZVAL_COPY_VALUE(z, value);
+ }
+ ZVAL_DEREF(z);
+ SEPARATE_ZVAL_NOREF(z);
+ incdec_op(z);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(retval, z);
+ }
++ Z_OBJ_HT(obj)->write_property(&obj, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ zval_ptr_dtor(&obj);
+ zval_ptr_dtor(z);
+ } else {
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_NULL(retval);
+ }
+ }
}
- }
+ } while (0);
+
+ zval_ptr_dtor_nogc(free_op2);
- zval_ptr_dtor_nogc(&free_op1.var);
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
-static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
- USE_OPLINE
-
- if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
- /* Behave like FETCH_OBJ_W */
- zend_free_op free_op1;
- zval *property;
- zval **container;
-
- SAVE_OPLINE();
- property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
- container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-
- if (0) {
- MAKE_REAL_ZVAL_PTR(property);
- }
- if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
- zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
- }
- zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
- if (0) {
- zval_ptr_dtor(&property);
- } else {
+ return zend_pre_incdec_property_helper_SPEC_UNUSED_TMPVAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
- }
- if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
- EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
- }
- if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
- } else {
- return zend_fetch_property_address_read_helper_SPEC_VAR_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
- }
+static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ return zend_pre_incdec_property_helper_SPEC_UNUSED_TMPVAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
-static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_TMPVAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
- zend_free_op free_op1, free_res;
- zval **container;
+ zend_free_op free_op2;
+ zval *object;
zval *property;
+ zval *retval;
+ zval *zptr;
SAVE_OPLINE();
- container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+ object = _get_obj_zval_ptr_unused(execute_data);
+ property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+ retval = EX_VAR(opline->result.var);
- if (IS_VAR == IS_CV) {
- if (container != &EG(uninitialized_zval_ptr)) {
- SEPARATE_ZVAL_IF_NOT_REF(container);
- }
- }
- if (0) {
- MAKE_REAL_ZVAL_PTR(property);
- }
- if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
- zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
- }
- zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
- if (0) {
- zval_ptr_dtor(&property);
- } else {
+ if (IS_UNUSED == IS_VAR && UNEXPECTED(object == NULL)) {
+ zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
+ zval_ptr_dtor_nogc(free_op2);
+ HANDLE_EXCEPTION();
}
- if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
- EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
- }
- if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
- PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
- if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
- SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
- }
- PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
- FREE_OP_VAR_PTR(free_res);
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
-}
+ do {
+ if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
+ ZVAL_DEREF(object);
+ if (UNEXPECTED(!make_real_object(object))) {
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ ZVAL_NULL(retval);
+ break;
+ }
+ }
-static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- USE_OPLINE
- zend_free_op free_op1;
- zval **object_ptr;
- zval *property_name;
+ /* here we are sure we are dealing with an object */
- SAVE_OPLINE();
- object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
- if (0) {
- MAKE_REAL_ZVAL_PTR(property_name);
- }
- if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
- zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
- }
- zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
- if (0) {
- zval_ptr_dtor(&property_name);
- } else {
+ ZVAL_DEREF(zptr);
+ ZVAL_COPY_VALUE(retval, zptr);
+ zval_opt_copy_ctor(zptr);
-
+ incdec_op(zptr);
+ } else {
+ if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
- zval rv;
- zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
++ zval rv, obj;
++ zval *z;
++
++ ZVAL_COPY(&obj, object);
++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
+ zval z_copy;
+
+ if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
+ zval rv;
+ zval *value = Z_OBJ_HT_P(z)->get(z, &rv);
-
+ if (Z_REFCOUNT_P(z) == 0) {
+ zend_objects_store_del(Z_OBJ_P(z));
+ }
+ ZVAL_COPY_VALUE(z, value);
+ }
+ ZVAL_DUP(retval, z);
+ ZVAL_DUP(&z_copy, z);
+ incdec_op(&z_copy);
+ if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
- Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ Z_OBJ_HT(obj)->write_property(&obj, property, &z_copy, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ zval_ptr_dtor(&obj);
+ zval_ptr_dtor(&z_copy);
+ zval_ptr_dtor(z);
+ } else {
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ ZVAL_NULL(retval);
+ }
+ }
+ } while (0);
+
+ zval_ptr_dtor_nogc(free_op2);
- }
- if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
- /* assign_obj has two opcodes! */
CHECK_EXCEPTION();
- ZEND_VM_INC_OPCODE();
ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_NEXT_OPCODE();
}
-static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_SPACESHIP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
- return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
+ USE_OPLINE
-static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
+ zval *result = EX_VAR(opline->result.var);
-static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
+ SAVE_OPLINE();
+ compare_function(result,
+ _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var),
+ EX_CONSTANT(opline->op2));
-static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ CHECK_EXCEPTION();
+ ZEND_VM_NEXT_OPCODE();
}
-static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
- return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
+ USE_OPLINE
-static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
+ SAVE_OPLINE();
+ bitwise_or_function(EX_VAR(opline->result.var),
+ _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var),
+ EX_CONSTANT(opline->op2));
-static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+
+ CHECK_EXCEPTION();
+ ZEND_VM_NEXT_OPCODE();
}
-static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
- return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ USE_OPLINE
+
+
+ SAVE_OPLINE();
+ bitwise_and_function(EX_VAR(opline->result.var),
+ _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var),
+ EX_CONSTANT(opline->op2));
+
+
+ CHECK_EXCEPTION();
+ ZEND_VM_NEXT_OPCODE();
}
-static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
- return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ USE_OPLINE
+
+
+ SAVE_OPLINE();
+ bitwise_xor_function(EX_VAR(opline->result.var),
+ _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var),
+ EX_CONSTANT(opline->op2));
+
+
+ CHECK_EXCEPTION();
+ ZEND_VM_NEXT_OPCODE();
}
-static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
- zend_free_op free_op2;
- zval **object_ptr;
- zval *object;
- zval *property;
- zval **retval;
- int have_get_ptr = 0;
+
SAVE_OPLINE();
- object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
- property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
- retval = &EX_T(opline->result.var).var.ptr;
+ boolean_xor_function(EX_VAR(opline->result.var),
+ _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var),
+ EX_CONSTANT(opline->op2));
- if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
- zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
- }
- make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
- object = *object_ptr;
+ CHECK_EXCEPTION();
+ ZEND_VM_NEXT_OPCODE();
+}
- if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
- zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
- zval_dtor(free_op2.var);
- if (RETURN_VALUE_USED(opline)) {
- PZVAL_LOCK(&EG(uninitialized_zval));
- *retval = &EG(uninitialized_zval);
- }
+static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2), ZEND_OPCODE_HANDLER_ARGS)
+{
+ USE_OPLINE
+ zend_free_op free_op_data1;
+ zval *object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var);
+ zval *property = EX_CONSTANT(opline->op2);
+ zval *value;
+ zval *zptr;
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
- }
+ if (IS_CV == IS_VAR && UNEXPECTED(object == NULL)) {
+ zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an object");
+ FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
- /* here we are sure we are dealing with an object */
- if (1) {
- MAKE_REAL_ZVAL_PTR(property);
+ HANDLE_EXCEPTION();
}
- if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
- zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
- if (zptr != NULL) { /* NULL means no success in getting PTR */
- SEPARATE_ZVAL_IF_NOT_REF(zptr);
+ do {
+ value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
- have_get_ptr = 1;
- incdec_op(*zptr);
- if (RETURN_VALUE_USED(opline)) {
- *retval = *zptr;
- PZVAL_LOCK(*retval);
+ if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
+ ZVAL_DEREF(object);
+ if (UNEXPECTED(!make_real_object(object))) {
+ zend_error(E_WARNING, "Attempt to assign property of non-object");
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_NULL(EX_VAR(opline->result.var));
+ }
+ break;
}
}
- }
-
- if (!have_get_ptr) {
- if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
- zval *z;
- Z_ADDREF_P(object);
- z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+ /* here we are sure we are dealing with an object */
+ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
- if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
- zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+ ZVAL_DEREF(zptr);
+ SEPARATE_ZVAL_NOREF(zptr);
- if (Z_REFCOUNT_P(z) == 0) {
- GC_REMOVE_ZVAL_FROM_BUFFER(z);
- zval_dtor(z);
- FREE_ZVAL(z);
- }
- z = value;
+ binary_op(zptr, zptr, value);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(EX_VAR(opline->result.var), zptr);
}
- Z_ADDREF_P(z);
- SEPARATE_ZVAL_IF_NOT_REF(&z);
- incdec_op(z);
- *retval = z;
- Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
- zval_ptr_dtor(&object);
- SELECTIVE_PZVAL_LOCK(*retval, opline);
- zval_ptr_dtor(&z);
} else {
- zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
- if (RETURN_VALUE_USED(opline)) {
- PZVAL_LOCK(&EG(uninitialized_zval));
- *retval = &EG(uninitialized_zval);
+ zval *z;
- zval rv;
++ zval rv, obj;
+
- if (Z_OBJ_HT_P(object)->read_property &&
- (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) {
++ ZVAL_COPY(&obj, object);
++ if (Z_OBJ_HT(obj)->read_property &&
++ (z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) {
+ if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
+ zval rv;
+ zval *value = Z_OBJ_HT_P(z)->get(z, &rv);
+
+ if (Z_REFCOUNT_P(z) == 0) {
+ zend_objects_store_del(Z_OBJ_P(z));
+ }
+ ZVAL_COPY_VALUE(z, value);
+ }
+ zptr = z;
+ ZVAL_DEREF(z);
+ SEPARATE_ZVAL_NOREF(z);
+ binary_op(z, z, value);
- Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ Z_OBJ_HT(obj)->write_property(&obj, property, z, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ zval_ptr_dtor(&obj);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(EX_VAR(opline->result.var), z);
+ }
+ zval_ptr_dtor(zptr);
+ } else {
+ zend_error(E_WARNING, "Attempt to assign property of non-object");
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_NULL(EX_VAR(opline->result.var));
+ }
}
}
- }
+ } while (0);
+
+ FREE_OP(free_op_data1);
- if (1) {
- zval_ptr_dtor(&property);
- } else {
- zval_dtor(free_op2.var);
- }
+ /* assign_obj has two opcodes! */
CHECK_EXCEPTION();
+ ZEND_VM_INC_OPCODE();
ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_NEXT_OPCODE();
}
-static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_ADD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
- return zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#if 0 || (IS_CONST != IS_UNUSED)
+ USE_OPLINE
+
+# if 0 || (IS_CV != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_CV_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_SUB_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
+#if 0 || (IS_CONST != IS_UNUSED)
USE_OPLINE
- zend_free_op free_op1, free_op2;
- zval *property;
- zval **container;
-
- SAVE_OPLINE();
- property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
- if (1) {
- MAKE_REAL_ZVAL_PTR(property);
+# if 0 || (IS_CV != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_CV_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
- container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
- if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
- zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+}
- zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
- if (1) {
- zval_ptr_dtor(&property);
- } else {
- zval_dtor(free_op2.var);
+static int ZEND_FASTCALL ZEND_ASSIGN_MUL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+#if 0 || (IS_CONST != IS_UNUSED)
+ USE_OPLINE
+
+# if 0 || (IS_CV != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_CV_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
- if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
- EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+}
- /* We are going to assign the result by reference */
- if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
- zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
+static int ZEND_FASTCALL ZEND_ASSIGN_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+#if 0 || (IS_CONST != IS_UNUSED)
+ USE_OPLINE
- Z_DELREF_PP(retval_ptr);
- SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
- Z_ADDREF_PP(retval_ptr);
- EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
- EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
+# if 0 || (IS_CV != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_CV_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
-
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_MOD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
+#if 0 || (IS_CONST != IS_UNUSED)
USE_OPLINE
- zend_free_op free_op1, free_op2;
- zval *property;
- zval **container;
- SAVE_OPLINE();
- property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
- container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
-
- if (1) {
- MAKE_REAL_ZVAL_PTR(property);
- }
- if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
- zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
- }
- zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
- if (1) {
- zval_ptr_dtor(&property);
- } else {
- zval_dtor(free_op2.var);
+# if 0 || (IS_CV != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_CV_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
- if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
- EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
-
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_SL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
+#if 0 || (IS_CONST != IS_UNUSED)
USE_OPLINE
- zval *container;
- zend_free_op free_op2;
- zval *offset;
-
- SAVE_OPLINE();
- container = _get_obj_zval_ptr_unused(TSRMLS_C);
- offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-
- if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
- UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
- PZVAL_LOCK(&EG(uninitialized_zval));
- EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
- zval_dtor(free_op2.var);
- } else {
- zval *retval;
-
- 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, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-
- PZVAL_LOCK(retval);
- EX_T(opline->result.var).var.ptr = retval;
-
- if (1) {
- zval_ptr_dtor(&offset);
- } else {
- zval_dtor(free_op2.var);
- }
+# if 0 || (IS_CV != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_CV_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
-
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_SR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
+#if 0 || (IS_CONST != IS_UNUSED)
USE_OPLINE
- if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
- /* Behave like FETCH_OBJ_W */
- zend_free_op free_op1, free_op2;
- zval *property;
- zval **container;
-
- SAVE_OPLINE();
- property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
- container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
-
- if (1) {
- MAKE_REAL_ZVAL_PTR(property);
- }
- if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
- zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
- }
- zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
- if (1) {
- zval_ptr_dtor(&property);
- } else {
- zval_dtor(free_op2.var);
- }
- if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
- EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
- }
-
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
- } else {
- return zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+# if 0 || (IS_CV != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_CV_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
+#if 0 || (IS_CONST != IS_UNUSED)
USE_OPLINE
- zend_free_op free_op1, free_op2, free_res;
- zval **container;
- zval *property;
-
- SAVE_OPLINE();
- container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
- property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
- if (IS_UNUSED == IS_CV) {
- if (container != &EG(uninitialized_zval_ptr)) {
- SEPARATE_ZVAL_IF_NOT_REF(container);
- }
- }
- if (1) {
- MAKE_REAL_ZVAL_PTR(property);
- }
- if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
- zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
- }
- zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
- if (1) {
- zval_ptr_dtor(&property);
- } else {
- zval_dtor(free_op2.var);
- }
- if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
- EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+# if 0 || (IS_CV != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_CV_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
-
- PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
- if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
- SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
- PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
- FREE_OP_VAR_PTR(free_res);
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
+#if 0 || (IS_CONST != IS_UNUSED)
USE_OPLINE
- zend_free_op free_op2;
- zval **object_ptr;
- zval *property_name;
- SAVE_OPLINE();
- object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
- property_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-
- if (1) {
- MAKE_REAL_ZVAL_PTR(property_name);
+# if 0 || (IS_CV != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
- if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
- zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
- }
- zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
- if (1) {
- zval_ptr_dtor(&property_name);
- } else {
- zval_dtor(free_op2.var);
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
-
- /* assign_obj has two opcodes! */
- CHECK_EXCEPTION();
- ZEND_VM_INC_OPCODE();
- ZEND_VM_NEXT_OPCODE();
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
+#if 0 || (IS_CONST != IS_UNUSED)
USE_OPLINE
- zend_free_op free_op2;
- zval *str = &EX_T(opline->result.var).tmp_var;
- zval *var;
- zval var_copy;
- int use_copy = 0;
- SAVE_OPLINE();
- var = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-
- if (IS_UNUSED == IS_UNUSED) {
- /* Initialize for erealloc in add_string_to_string */
- Z_STRVAL_P(str) = NULL;
- Z_STRLEN_P(str) = 0;
- Z_TYPE_P(str) = IS_STRING;
-
- INIT_PZVAL(str);
+# if 0 || (IS_CV != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ }
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+}
- if (Z_TYPE_P(var) != IS_STRING) {
- zend_make_printable_zval(var, &var_copy, &use_copy);
+static int ZEND_FASTCALL ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+#if 0 || (IS_CONST != IS_UNUSED)
+ USE_OPLINE
- if (use_copy) {
- var = &var_copy;
- }
+# if 0 || (IS_CV != IS_UNUSED)
+ if (EXPECTED(opline->extended_value == 0)) {
+ return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
- add_string_to_string(str, str, var);
-
- if (use_copy) {
- zval_dtor(var);
+# endif
+ if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+ return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ } else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+ return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
- /* original comment, possibly problematic:
- * FREE_OP is missing intentionally here - we're always working on the same temporary variable
- * (Zeev): I don't think it's problematic, we only use variables
- * which aren't affected by FREE_OP(Ts, )'s anyway, unless they're
- * string offsets or overloaded objects
- */
- zval_dtor(free_op2.var);
-
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
+#else
+ return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
}
-static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
- zval *function_name;
- char *function_name_strval;
- int function_name_strlen;
- zend_free_op free_op2;
- call_slot *call = EX(call_slots) + opline->result.num;
+
+ zval *object;
+ zval *property;
+ zval *retval;
+ zval *zptr;
SAVE_OPLINE();
+ object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var);
+ property = EX_CONSTANT(opline->op2);
+ retval = EX_VAR(opline->result.var);
- function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+ if (IS_CV == IS_VAR && UNEXPECTED(object == NULL)) {
+ zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
- if (IS_TMP_VAR != IS_CONST &&
- UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
- if (UNEXPECTED(EG(exception) != NULL)) {
- HANDLE_EXCEPTION();
- }
- zend_error_noreturn(E_ERROR, "Method name must be a string");
+
+ HANDLE_EXCEPTION();
}
- function_name_strval = Z_STRVAL_P(function_name);
- function_name_strlen = Z_STRLEN_P(function_name);
+ do {
+ if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
+ ZVAL_DEREF(object);
+ if (UNEXPECTED(!make_real_object(object))) {
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_NULL(retval);
+ }
+ break;
+ }
+ }
- call->object = _get_obj_zval_ptr_unused(TSRMLS_C);
+ /* here we are sure we are dealing with an object */
- if (EXPECTED(call->object != NULL) &&
- EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
- call->called_scope = Z_OBJCE_P(call->object);
+ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
- if (IS_TMP_VAR != IS_CONST ||
- (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
- zval *object = call->object;
+ ZVAL_DEREF(zptr);
+ SEPARATE_ZVAL_NOREF(zptr);
- if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
- zend_error_noreturn(E_ERROR, "Object does not support method calls");
+ incdec_op(zptr);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(retval, zptr);
}
+ } else {
+ zval rv;
- /* First, locate the function. */
- call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
- if (UNEXPECTED(call->fbc == NULL)) {
- zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
- }
- if (IS_TMP_VAR == IS_CONST &&
- EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
- EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
- EXPECTED(call->object == object)) {
- CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
- }
- }
- } else {
- if (UNEXPECTED(EG(exception) != NULL)) {
- zval_dtor(free_op2.var);
- HANDLE_EXCEPTION();
- }
- zend_error_noreturn(E_ERROR, "Call to a member function %s() on %s", function_name_strval, zend_get_type_by_const(Z_TYPE_P(call->object)));
- }
+ if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
- zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
++ zval *z, obj;
+
- if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
- call->object = NULL;
- } else {
- if (!PZVAL_IS_REF(call->object)) {
- Z_ADDREF_P(call->object); /* For $this pointer */
- } else {
- zval *this_ptr;
- ALLOC_ZVAL(this_ptr);
- INIT_PZVAL_COPY(this_ptr, call->object);
- zval_copy_ctor(this_ptr);
- call->object = this_ptr;
- }
- }
++ ZVAL_COPY(&obj, object);
++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
+
+ if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
+ zval rv;
+ zval *value = Z_OBJ_HT_P(z)->get(z, &rv);
- call->num_additional_args = 0;
- call->is_ctor_call = 0;
- EX(call) = call;
+ if (Z_REFCOUNT_P(z) == 0) {
+ zend_objects_store_del(Z_OBJ_P(z));
+ }
+ ZVAL_COPY_VALUE(z, value);
+ }
+ ZVAL_DEREF(z);
+ SEPARATE_ZVAL_NOREF(z);
+ incdec_op(z);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(retval, z);
+ }
- Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ Z_OBJ_HT(obj)->write_property(&obj, property, z, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ zval_ptr_dtor(&obj);
+ zval_ptr_dtor(z);
+ } else {
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_NULL(retval);
+ }
+ }
+ }
+ } while (0);
- zval_dtor(free_op2.var);
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
-static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
- USE_OPLINE
+ return zend_pre_incdec_property_helper_SPEC_CV_CONST(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
- array_init(&EX_T(opline->result.var).tmp_var);
- if (IS_UNUSED == IS_UNUSED) {
- ZEND_VM_NEXT_OPCODE();
-#if 0 || IS_UNUSED != IS_UNUSED
- } else {
- return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-#endif
- }
+static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ return zend_pre_incdec_property_helper_SPEC_CV_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
-static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
- zend_free_op free_op2;
- zval **container;
- zval *offset;
- ulong hval;
+
+ zval *object;
+ zval *property;
+ zval *retval;
+ zval *zptr;
SAVE_OPLINE();
- container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
- if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
- SEPARATE_ZVAL_IF_NOT_REF(container);
- }
- offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+ object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var);
+ property = EX_CONSTANT(opline->op2);
+ retval = EX_VAR(opline->result.var);
- if (IS_UNUSED != IS_VAR || container) {
- switch (Z_TYPE_PP(container)) {
- case IS_ARRAY: {
- HashTable *ht = Z_ARRVAL_PP(container);
+ if (IS_CV == IS_VAR && UNEXPECTED(object == NULL)) {
+ zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
- switch (Z_TYPE_P(offset)) {
- case IS_DOUBLE:
- hval = zend_dval_to_lval(Z_DVAL_P(offset));
- zend_hash_index_del(ht, hval);
- break;
- case IS_RESOURCE:
- case IS_BOOL:
- case IS_LONG:
- hval = Z_LVAL_P(offset);
- zend_hash_index_del(ht, hval);
- break;
- case IS_STRING:
- if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
- Z_ADDREF_P(offset);
- }
- if (IS_TMP_VAR == IS_CONST) {
- hval = Z_HASH_P(offset);
- } else {
- ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
- hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
- }
- if (ht == &EG(symbol_table)) {
- zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
- } else {
- zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
- }
- if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
- zval_ptr_dtor(&offset);
- }
- break;
-num_index_dim:
- zend_hash_index_del(ht, hval);
- if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
- zval_ptr_dtor(&offset);
- }
- 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);
+
+ HANDLE_EXCEPTION();
+ }
+
+ do {
+ if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
+ ZVAL_DEREF(object);
+ if (UNEXPECTED(!make_real_object(object))) {
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ ZVAL_NULL(retval);
break;
}
- case IS_OBJECT:
- if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
- 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:
- zval_dtor(free_op2.var);
- break;
}
- } else {
- zval_dtor(free_op2.var);
- }
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
-}
+ /* here we are sure we are dealing with an object */
-static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
- USE_OPLINE
- zend_free_op free_op2;
- zval **container;
- zval *offset;
+ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
- SAVE_OPLINE();
- container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
- offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+ ZVAL_DEREF(zptr);
+ ZVAL_COPY_VALUE(retval, zptr);
+ zval_opt_copy_ctor(zptr);
-
+ incdec_op(zptr);
+ } else {
+ if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
- zval rv;
- zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
++ zval rv, obj;
++ zval *z;
+
- if (IS_UNUSED != IS_VAR || container) {
- if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
- SEPARATE_ZVAL_IF_NOT_REF(container);
- }
- if (Z_TYPE_PP(container) == IS_OBJECT) {
- if (1) {
- MAKE_REAL_ZVAL_PTR(offset);
- }
- if (Z_OBJ_HT_P(*container)->unset_property) {
- Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
- } else {
- zend_error(E_NOTICE, "Trying to unset property of non-object");
- }
- if (1) {
- zval_ptr_dtor(&offset);
++ ZVAL_COPY(&obj, object);
++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
+ zval z_copy;
+
+ if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
+ zval rv;
+ zval *value = Z_OBJ_HT_P(z)->get(z, &rv);
-
+ if (Z_REFCOUNT_P(z) == 0) {
+ zend_objects_store_del(Z_OBJ_P(z));
+ }
+ ZVAL_COPY_VALUE(z, value);
+ }
+ ZVAL_DUP(retval, z);
+ ZVAL_DUP(&z_copy, z);
+ incdec_op(&z_copy);
+ if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
- Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ Z_OBJ_HT(obj)->write_property(&obj, property, &z_copy, ((IS_CONST == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ zval_ptr_dtor(&obj);
+ zval_ptr_dtor(&z_copy);
+ zval_ptr_dtor(z);
} else {
- zval_dtor(free_op2.var);
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ ZVAL_NULL(retval);
}
- } else {
- zval_dtor(free_op2.var);
}
- } else {
- zval_dtor(free_op2.var);
- }
+ } while (0);
+
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
}
- if (EG(return_value_ptr_ptr)) {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
- Z_ADDREF_PP(retval_ptr_ptr);
+ /* here we are sure we are dealing with an object */
+ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
+
+ ZVAL_DEREF(zptr);
+ SEPARATE_ZVAL_NOREF(zptr);
+
+ binary_op(zptr, zptr, value);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(EX_VAR(opline->result.var), zptr);
+ }
+ } else {
+ zval *z;
- zval rv;
++ zval rv, obj;
+
- if (Z_OBJ_HT_P(object)->read_property &&
- (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) {
++ ZVAL_COPY(&obj, object);
++ if (Z_OBJ_HT(obj)->read_property &&
++ (z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) {
+ if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
+ zval rv;
+ zval *value = Z_OBJ_HT_P(z)->get(z, &rv);
- *EG(return_value_ptr_ptr) = *retval_ptr_ptr;
+ if (Z_REFCOUNT_P(z) == 0) {
+ zend_objects_store_del(Z_OBJ_P(z));
+ }
+ ZVAL_COPY_VALUE(z, value);
+ }
+ zptr = z;
+ ZVAL_DEREF(z);
+ SEPARATE_ZVAL_NOREF(z);
+ binary_op(z, z, value);
- Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ Z_OBJ_HT(obj)->write_property(&obj, property, z, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ zval_ptr_dtor(&obj);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(EX_VAR(opline->result.var), z);
+ }
+ zval_ptr_dtor(zptr);
+ } else {
+ zend_error(E_WARNING, "Attempt to assign property of non-object");
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_NULL(EX_VAR(opline->result.var));
+ }
+ }
}
} while (0);
{
USE_OPLINE
- zval *expr;
- zval *result = &EX_T(opline->result.var).tmp_var;
+ zval *object;
+ zval *property;
+ zval *retval;
+ zval *zptr;
SAVE_OPLINE();
- expr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+ object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var);
+ property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+ retval = EX_VAR(opline->result.var);
- if (opline->extended_value != IS_STRING) {
- ZVAL_COPY_VALUE(result, expr);
- if (!0) {
- zendi_zval_copy_ctor(*result);
- }
+ if (IS_CV == IS_VAR && UNEXPECTED(object == NULL)) {
+ zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
+
+
+ HANDLE_EXCEPTION();
}
- switch (opline->extended_value) {
- case IS_NULL:
- convert_to_null(result);
- break;
- case IS_BOOL:
- convert_to_boolean(result);
- break;
- case IS_LONG:
- convert_to_long(result);
- break;
- case IS_DOUBLE:
- convert_to_double(result);
- break;
- case IS_STRING: {
- zval var_copy;
- int use_copy;
- zend_make_printable_zval(expr, &var_copy, &use_copy);
- if (use_copy) {
- ZVAL_COPY_VALUE(result, &var_copy);
- if (0) {
+ do {
+ if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
+ ZVAL_DEREF(object);
+ if (UNEXPECTED(!make_real_object(object))) {
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_NULL(retval);
+ }
+ break;
+ }
+ }
+
+ /* here we are sure we are dealing with an object */
+
+ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
+
+ ZVAL_DEREF(zptr);
+ SEPARATE_ZVAL_NOREF(zptr);
+
+ incdec_op(zptr);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(retval, zptr);
+ }
+ } else {
+ zval rv;
+
+ if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
- zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
++ zval *z, obj;
++
++ ZVAL_COPY(&obj, object);
++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
+ if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
+ zval rv;
+ zval *value = Z_OBJ_HT_P(z)->get(z, &rv);
+
+ if (Z_REFCOUNT_P(z) == 0) {
+ zend_objects_store_del(Z_OBJ_P(z));
+ }
+ ZVAL_COPY_VALUE(z, value);
+ }
+ ZVAL_DEREF(z);
+ SEPARATE_ZVAL_NOREF(z);
+ incdec_op(z);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(retval, z);
}
- Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ Z_OBJ_HT(obj)->write_property(&obj, property, z, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ zval_ptr_dtor(&obj);
+ zval_ptr_dtor(z);
} else {
- ZVAL_COPY_VALUE(result, expr);
- if (!0) {
- zendi_zval_copy_ctor(*result);
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_NULL(retval);
}
}
- break;
}
- case IS_ARRAY:
- convert_to_array(result);
- break;
- case IS_OBJECT:
- convert_to_object(result);
- break;
- }
+ } while (0);
+
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
-static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
- USE_OPLINE
- zend_op_array *new_op_array=NULL;
-
- zval *inc_filename;
- zval *tmp_inc_filename = NULL;
- zend_bool failure_retval=0;
-
- SAVE_OPLINE();
- inc_filename = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+ return zend_pre_incdec_property_helper_SPEC_CV_CV(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
- if (inc_filename->type!=IS_STRING) {
- MAKE_STD_ZVAL(tmp_inc_filename);
- ZVAL_COPY_VALUE(tmp_inc_filename, inc_filename);
- zval_copy_ctor(tmp_inc_filename);
- convert_to_string(tmp_inc_filename);
- inc_filename = tmp_inc_filename;
- }
+static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ return zend_pre_incdec_property_helper_SPEC_CV_CV(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
- if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) {
- if (opline->extended_value == ZEND_INCLUDE_ONCE || opline->extended_value == ZEND_INCLUDE) {
- zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
- } else {
- zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
- }
- } else {
- switch (opline->extended_value) {
- case ZEND_INCLUDE_ONCE:
- case ZEND_REQUIRE_ONCE: {
- zend_file_handle file_handle;
- char *resolved_path;
+static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
+{
+ USE_OPLINE
- resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC);
- if (resolved_path) {
- failure_retval = zend_hash_exists(&EG(included_files), resolved_path, strlen(resolved_path)+1);
- } else {
- resolved_path = Z_STRVAL_P(inc_filename);
- }
+ zval *object;
+ zval *property;
+ zval *retval;
+ zval *zptr;
- if (failure_retval) {
- /* do nothing, file already included */
- } else if (SUCCESS == zend_stream_open(resolved_path, &file_handle TSRMLS_CC)) {
+ SAVE_OPLINE();
+ object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var);
+ property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var);
+ retval = EX_VAR(opline->result.var);
- if (!file_handle.opened_path) {
- file_handle.opened_path = estrdup(resolved_path);
- }
+ if (IS_CV == IS_VAR && UNEXPECTED(object == NULL)) {
+ zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
- if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) {
- new_op_array = zend_compile_file(&file_handle, (opline->extended_value==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC);
- zend_destroy_file_handle(&file_handle TSRMLS_CC);
- } else {
- zend_file_handle_dtor(&file_handle TSRMLS_CC);
- failure_retval=1;
- }
- } else {
- if (opline->extended_value == ZEND_INCLUDE_ONCE) {
- zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
- } else {
- zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename) TSRMLS_CC);
- }
- }
- if (resolved_path != Z_STRVAL_P(inc_filename)) {
- efree(resolved_path);
- }
- }
- break;
- case ZEND_INCLUDE:
- case ZEND_REQUIRE:
- new_op_array = compile_filename(opline->extended_value, inc_filename TSRMLS_CC);
- break;
- case ZEND_EVAL: {
- char *eval_desc = zend_make_compiled_string_description("eval()'d code" TSRMLS_CC);
- new_op_array = zend_compile_string(inc_filename, eval_desc TSRMLS_CC);
- efree(eval_desc);
- }
- break;
- EMPTY_SWITCH_DEFAULT_CASE()
- }
- }
- if (tmp_inc_filename) {
- zval_ptr_dtor(&tmp_inc_filename);
+ HANDLE_EXCEPTION();
}
- if (UNEXPECTED(EG(exception) != NULL)) {
- HANDLE_EXCEPTION();
- } else if (EXPECTED(new_op_array != NULL)) {
- EX(original_return_value) = EG(return_value_ptr_ptr);
- EG(active_op_array) = new_op_array;
- if (RETURN_VALUE_USED(opline)) {
- EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
- EG(return_value_ptr_ptr) = EX_T(opline->result.var).var.ptr_ptr;
- } else {
- EG(return_value_ptr_ptr) = NULL;
+ do {
+ if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
+ ZVAL_DEREF(object);
+ if (UNEXPECTED(!make_real_object(object))) {
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ ZVAL_NULL(retval);
+ break;
+ }
}
- EX(function_state).function = (zend_function *) new_op_array;
- EX(object) = NULL;
+ /* here we are sure we are dealing with an object */
- if (!EG(active_symbol_table)) {
- zend_rebuild_symbol_table(TSRMLS_C);
- }
+ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
- if (EXPECTED(zend_execute_ex == execute_ex)) {
- ZEND_VM_ENTER();
+ ZVAL_DEREF(zptr);
+ ZVAL_COPY_VALUE(retval, zptr);
+ zval_opt_copy_ctor(zptr);
-
+ incdec_op(zptr);
} else {
- zend_execute(new_op_array TSRMLS_CC);
- }
+ if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
- zval rv;
- zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
++ zval rv, obj;
++ zval *z;
+
- EX(function_state).function = (zend_function *) EX(op_array);
++ ZVAL_COPY(&obj, object);
++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
+ zval z_copy;
- EG(opline_ptr) = &EX(opline);
- EG(active_op_array) = EX(op_array);
- EG(return_value_ptr_ptr) = EX(original_return_value);
- destroy_op_array(new_op_array TSRMLS_CC);
- efree(new_op_array);
- if (UNEXPECTED(EG(exception) != NULL)) {
- zend_throw_exception_internal(NULL TSRMLS_CC);
- HANDLE_EXCEPTION();
+ if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
+ zval rv;
+ zval *value = Z_OBJ_HT_P(z)->get(z, &rv);
-
+ if (Z_REFCOUNT_P(z) == 0) {
+ zend_objects_store_del(Z_OBJ_P(z));
+ }
+ ZVAL_COPY_VALUE(z, value);
+ }
+ ZVAL_DUP(retval, z);
+ ZVAL_DUP(&z_copy, z);
+ incdec_op(&z_copy);
+ if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
- Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ Z_OBJ_HT(obj)->write_property(&obj, property, &z_copy, ((IS_CV == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ zval_ptr_dtor(&obj);
+ zval_ptr_dtor(&z_copy);
+ zval_ptr_dtor(z);
+ } else {
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ ZVAL_NULL(retval);
+ }
}
+ } while (0);
- } else if (RETURN_VALUE_USED(opline)) {
- zval *retval;
- ALLOC_ZVAL(retval);
- ZVAL_BOOL(retval, failure_retval);
- INIT_PZVAL(retval);
- EX_T(opline->result.var).var.ptr = retval;
- }
+ CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
}
ZEND_VM_NEXT_OPCODE();
}
-static int ZEND_FASTCALL ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
+ zend_free_op free_op2;
- array_init(&EX_T(opline->result.var).tmp_var);
- if (IS_CV == IS_UNUSED) {
- ZEND_VM_NEXT_OPCODE();
-#if 0 || IS_CV != IS_UNUSED
- } else {
- return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-#endif
- }
+ SAVE_OPLINE();
+ boolean_xor_function(EX_VAR(opline->result.var),
+ _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var),
+ _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2));
+
+ zval_ptr_dtor_nogc(free_op2);
+ CHECK_EXCEPTION();
+ ZEND_VM_NEXT_OPCODE();
}
-static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_TMPVAR(int (*binary_op)(zval *result, zval *op1, zval *op2), ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
- zval tmp, *varname;
- HashTable *target_symbol_table;
+ zend_free_op free_op2, free_op_data1;
+ zval *object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var);
+ zval *property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+ zval *value;
+ zval *zptr;
+ if (IS_CV == IS_VAR && UNEXPECTED(object == NULL)) {
+ zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an object");
+ FREE_UNFETCHED_OP((opline+1)->op1_type, (opline+1)->op1.var);
+ zval_ptr_dtor_nogc(free_op2);
- SAVE_OPLINE();
- if (IS_CV == IS_CV &&
- IS_CONST == IS_UNUSED &&
- (opline->extended_value & ZEND_QUICK_SET)) {
- if (EG(active_symbol_table)) {
- zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
+ HANDLE_EXCEPTION();
+ }
+
+ do {
+ value = get_zval_ptr((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
- zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
- EX_CV(opline->op1.var) = NULL;
- } else if (EX_CV(opline->op1.var)) {
- zval_ptr_dtor(EX_CV(opline->op1.var));
- EX_CV(opline->op1.var) = NULL;
+ if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
+ ZVAL_DEREF(object);
+ if (UNEXPECTED(!make_real_object(object))) {
+ zend_error(E_WARNING, "Attempt to assign property of non-object");
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_NULL(EX_VAR(opline->result.var));
+ }
+ break;
+ }
}
- CHECK_EXCEPTION();
- ZEND_VM_NEXT_OPCODE();
- }
- varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+ /* here we are sure we are dealing with an object */
+ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
- if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
- ZVAL_COPY_VALUE(&tmp, varname);
- zval_copy_ctor(&tmp);
- convert_to_string(&tmp);
- varname = &tmp;
- } else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
- Z_ADDREF_P(varname);
- }
+ ZVAL_DEREF(zptr);
+ SEPARATE_ZVAL_NOREF(zptr);
- if (IS_CONST != IS_UNUSED) {
- zend_class_entry *ce;
+ binary_op(zptr, zptr, value);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(EX_VAR(opline->result.var), zptr);
+ }
+ } else {
+ zval *z;
- zval rv;
++ zval rv, obj;
- if (Z_OBJ_HT_P(object)->read_property &&
- (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) {
- if (IS_CONST == IS_CONST) {
- if (CACHED_PTR(opline->op2.literal->cache_slot)) {
- ce = CACHED_PTR(opline->op2.literal->cache_slot);
- } else {
- ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
- if (UNEXPECTED(EG(exception) != NULL)) {
- if (IS_CV != IS_CONST && varname == &tmp) {
- zval_dtor(&tmp);
- } else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
- zval_ptr_dtor(&varname);
- }
++ ZVAL_COPY(&obj, object);
++ if (Z_OBJ_HT(obj)->read_property &&
++ (z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv)) != NULL) {
+ if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
+ zval rv;
+ zval *value = Z_OBJ_HT_P(z)->get(z, &rv);
- HANDLE_EXCEPTION();
+ if (Z_REFCOUNT_P(z) == 0) {
+ zend_objects_store_del(Z_OBJ_P(z));
+ }
+ ZVAL_COPY_VALUE(z, value);
}
- if (UNEXPECTED(ce == NULL)) {
- zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
+ zptr = z;
+ ZVAL_DEREF(z);
+ SEPARATE_ZVAL_NOREF(z);
+ binary_op(z, z, value);
- Z_OBJ_HT_P(object)->write_property(object, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ Z_OBJ_HT(obj)->write_property(&obj, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ zval_ptr_dtor(&obj);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(EX_VAR(opline->result.var), z);
+ }
+ zval_ptr_dtor(zptr);
+ } else {
+ zend_error(E_WARNING, "Attempt to assign property of non-object");
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_NULL(EX_VAR(opline->result.var));
}
- CACHE_PTR(opline->op2.literal->cache_slot, ce);
}
- } else {
- ce = EX_T(opline->op2.var).class_entry;
}
- zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
- } else {
- ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
-
- target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
- zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
- }
+ } while (0);
- if (IS_CV != IS_CONST && varname == &tmp) {
- zval_dtor(&tmp);
- } else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
- zval_ptr_dtor(&varname);
- }
+ FREE_OP(free_op_data1);
+ zval_ptr_dtor_nogc(free_op2);
+ /* assign_obj has two opcodes! */
CHECK_EXCEPTION();
+ ZEND_VM_INC_OPCODE();
ZEND_VM_NEXT_OPCODE();
}
}
}
- } else if (Z_TYPE_P(container) == IS_OBJECT) {
- if (0) {
- MAKE_REAL_ZVAL_PTR(offset);
- }
- if (prop_dim) {
- if (Z_OBJ_HT_P(container)->has_property) {
- result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
- } else {
- zend_error(E_NOTICE, "Trying to check property of non-object");
- result = 0;
- }
- } else {
- if (Z_OBJ_HT_P(container)->has_dimension) {
- result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
- } else {
- zend_error(E_NOTICE, "Trying to check element of non-array");
- result = 0;
+ /* here we are sure we are dealing with an object */
+
+ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
+
+ ZVAL_DEREF(zptr);
+ SEPARATE_ZVAL_NOREF(zptr);
+
+ incdec_op(zptr);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(retval, zptr);
}
- }
- if (0) {
- zval_ptr_dtor(&offset);
} else {
+ zval rv;
- }
- } else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
- zval tmp;
+ if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
- zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
++ zval *z, obj;
+
- if (Z_TYPE_P(offset) != IS_LONG) {
- if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
- || (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
- && IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
- ZVAL_COPY_VALUE(&tmp, offset);
- zval_copy_ctor(&tmp);
- convert_to_long(&tmp);
- offset = &tmp;
- } else {
- /* can not be converted to proper offset, return "not set" */
- result = 0;
- }
- }
- if (Z_TYPE_P(offset) == IS_LONG) {
- if (opline->extended_value & ZEND_ISSET) {
- if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
- result = 1;
++ ZVAL_COPY(&obj, object);
++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
+
+ if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
+ zval rv;
+ zval *value = Z_OBJ_HT_P(z)->get(z, &rv);
+
+ if (Z_REFCOUNT_P(z) == 0) {
+ zend_objects_store_del(Z_OBJ_P(z));
+ }
+ ZVAL_COPY_VALUE(z, value);
}
- } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
- if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
- result = 1;
+ ZVAL_DEREF(z);
+ SEPARATE_ZVAL_NOREF(z);
+ incdec_op(z);
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_COPY(retval, z);
+ }
- Z_OBJ_HT_P(object)->write_property(object, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ Z_OBJ_HT(obj)->write_property(&obj, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ zval_ptr_dtor(&obj);
+ zval_ptr_dtor(z);
+ } else {
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+ ZVAL_NULL(retval);
}
}
}
ZEND_VM_NEXT_OPCODE();
}
-static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
- return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ return zend_pre_incdec_property_helper_SPEC_CV_TMPVAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
-static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_PRE_DEC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
- return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+ return zend_pre_incdec_property_helper_SPEC_CV_TMPVAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
}
-static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_TMPVAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
+ zend_free_op free_op2;
+ zval *object;
+ zval *property;
+ zval *retval;
+ zval *zptr;
- /* The generator object is stored in return_value_ptr_ptr */
- zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
-
- if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
- zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
- }
+ SAVE_OPLINE();
+ object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var);
+ property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2);
+ retval = EX_VAR(opline->result.var);
- /* Destroy the previously yielded value */
- if (generator->value) {
- zval_ptr_dtor(&generator->value);
- }
+ if (IS_CV == IS_VAR && UNEXPECTED(object == NULL)) {
+ zend_error(E_EXCEPTION | E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
+ zval_ptr_dtor_nogc(free_op2);
- /* Destroy the previously yielded key */
- if (generator->key) {
- zval_ptr_dtor(&generator->key);
+ HANDLE_EXCEPTION();
}
- /* Set the new yielded value */
- if (IS_CV != IS_UNUSED) {
+ do {
+ if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
+ ZVAL_DEREF(object);
+ if (UNEXPECTED(!make_real_object(object))) {
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ ZVAL_NULL(retval);
+ break;
+ }
+ }
+ /* here we are sure we are dealing with an object */
- if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
- /* Constants and temporary variables aren't yieldable by reference,
- * but we still allow them with a notice. */
- if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
- zval *value, *copy;
+ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr)
+ && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL))) != NULL)) {
- zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+ ZVAL_DEREF(zptr);
+ ZVAL_COPY_VALUE(retval, zptr);
+ zval_opt_copy_ctor(zptr);
-
+ incdec_op(zptr);
+ } else {
+ if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
- zval rv;
- zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
++ zval rv, obj;
++ zval *z;
+
- value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
- ALLOC_ZVAL(copy);
- INIT_PZVAL_COPY(copy, value);
++ ZVAL_COPY(&obj, object);
++ z = Z_OBJ_HT(obj)->read_property(&obj, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL), &rv);
+ zval z_copy;
- /* Temporary variables don't need ctor copying */
- if (!0) {
- zval_copy_ctor(copy);
+ if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
+ zval rv;
+ zval *value = Z_OBJ_HT_P(z)->get(z, &rv);
-
+ if (Z_REFCOUNT_P(z) == 0) {
+ zend_objects_store_del(Z_OBJ_P(z));
+ }
+ ZVAL_COPY_VALUE(z, value);
}
-
- generator->value = copy;
+ ZVAL_DUP(retval, z);
+ ZVAL_DUP(&z_copy, z);
+ incdec_op(&z_copy);
+ if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
- Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ Z_OBJ_HT(obj)->write_property(&obj, property, &z_copy, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(Z_CACHE_SLOT_P(property)) : NULL));
++ zval_ptr_dtor(&obj);
+ zval_ptr_dtor(&z_copy);
+ zval_ptr_dtor(z);
} else {
- zval **value_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+ zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
+ ZVAL_NULL(retval);
+ }
+ }
+ } while (0);
- if (IS_CV == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
- zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
- }
+ zval_ptr_dtor_nogc(free_op2);
- /* If a function call result is yielded and the function did
- * not return by reference we throw a notice. */
- if (IS_CV == IS_VAR && !Z_ISREF_PP(value_ptr)
- && !(opline->extended_value == ZEND_RETURNS_FUNCTION
- && EX_T(opline->op1.var).var.fcall_returned_reference)
- && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
- zend_error(E_NOTICE, "Only variable references should be yielded by reference");
+ CHECK_EXCEPTION();
+ ZEND_VM_NEXT_OPCODE();
+}
- Z_ADDREF_PP(value_ptr);
- generator->value = *value_ptr;
- } else {
- SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
- Z_ADDREF_PP(value_ptr);
- generator->value = *value_ptr;
- }
+static int ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ return zend_post_incdec_property_helper_SPEC_CV_TMPVAR(increment_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
- }
- } else {
- zval *value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+static int ZEND_FASTCALL ZEND_POST_DEC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ return zend_post_incdec_property_helper_SPEC_CV_TMPVAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
- /* Consts, temporary variables and references need copying */
- if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR
- || PZVAL_IS_REF(value)
- ) {
- zval *copy;
+static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ USE_OPLINE
+ zend_free_op free_op2;
+ zval *container;
- ALLOC_ZVAL(copy);
- INIT_PZVAL_COPY(copy, value);
+ SAVE_OPLINE();
+ container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var);
+ zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR));
+ zval_ptr_dtor_nogc(free_op2);
- /* Temporary variables don't need ctor copying */
- if (!0) {
- zval_copy_ctor(copy);
- }
+ CHECK_EXCEPTION();
+ ZEND_VM_NEXT_OPCODE();
+}
- generator->value = copy;
+static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+ USE_OPLINE
+ zend_free_op free_op1, free_op2;
+ zval *container;
- } else {
- if (IS_CV == IS_CV) {
- Z_ADDREF_P(value);
- }
- generator->value = value;
- }
- }
- } else {
- /* If no value was specified yield null */
- Z_ADDREF(EG(uninitialized_zval));
- generator->value = &EG(uninitialized_zval);
- }
-
- /* Set the new yielded key */
- if (IS_CONST != IS_UNUSED) {
-
- zval *key = opline->op2.zv;
-
- /* Consts, temporary variables and references need copying */
- if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR
- || (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
- ) {
- zval *copy;
-
- ALLOC_ZVAL(copy);
- INIT_PZVAL_COPY(copy, key);
-
- /* Temporary variables don't need ctor copying */
- if (!0) {
- zval_copy_ctor(copy);
- }
-
- generator->key = copy;
- } else {
- Z_ADDREF_P(key);
- generator->key = key;
- }
-
- if (Z_TYPE_P(generator->key) == IS_LONG
- && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
- ) {
- generator->largest_used_integer_key = Z_LVAL_P(generator->key);
- }
+ SAVE_OPLINE();
+ container = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var);
- } else {
- /* If no key was specified we use auto-increment keys */
- generator->largest_used_integer_key++;
+ if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+ zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an array");
- ALLOC_INIT_ZVAL(generator->key);
- ZVAL_LONG(generator->key, generator->largest_used_integer_key);
+ HANDLE_EXCEPTION();
}
-
- if (RETURN_VALUE_USED(opline)) {
- /* If the return value of yield is used set the send
- * target and initialize it to NULL */
- generator->send_target = &EX_T(opline->result.var).var.ptr;
- Z_ADDREF(EG(uninitialized_zval));
- EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
- } else {
- generator->send_target = NULL;
+ zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR));
+ zval_ptr_dtor_nogc(free_op2);
+ if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
+ EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
}
- /* We increment to the next op, so we are at the correct position when the
- * generator is resumed. */
- ZEND_VM_INC_OPCODE();
-
- /* The GOTO VM uses a local opline variable. We need to set the opline
- * variable in execute_data so we don't resume at an old position. */
- SAVE_OPLINE();
-
- ZEND_VM_RETURN();
+ CHECK_EXCEPTION();
+ ZEND_VM_NEXT_OPCODE();
}
-static int ZEND_FASTCALL ZEND_POW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+ zend_free_op free_op1, free_op2;
+ zval *container;
SAVE_OPLINE();
- pow_function(&EX_T(opline->result.var).tmp_var,
- _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
- opline->op2.zv TSRMLS_CC);
+ container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var);
+
+ if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+ zend_error(E_EXCEPTION | E_ERROR, "Cannot use string offset as an array");
+ HANDLE_EXCEPTION();
+ }
+ zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR));
+ zval_ptr_dtor_nogc(free_op2);
+ if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) {
+ EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
+ }
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
projects / php / commitdiff