if (finally_op_num && (!catch_op_num || catch_op_num >= finally_op_num)) {
if (EX(delayed_exception)) {
zend_exception_set_previous(EG(exception), EX(delayed_exception) TSRMLS_CC);
- }
+ }
EX(delayed_exception) = EG(exception);
EG(exception) = NULL;
EX(fast_ret) = NULL;
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
} else {
-
+
zval *class_name = opline->op2.zv;
if (IS_CONST == IS_CONST) {
} else {
char *function_name_strval, *lcname;
int function_name_strlen;
-
+
SAVE_OPLINE();
function_name = opline->op2.zv;
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
} else {
-
+
zval *class_name = NULL;
if (IS_UNUSED == IS_CONST) {
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
} else {
-
+
zval *class_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
if (IS_CV == IS_CONST) {
} else {
char *function_name_strval, *lcname;
int function_name_strlen;
-
+
SAVE_OPLINE();
function_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
static int ZEND_FASTCALL ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
bitwise_not_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
boolean_not_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *z;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *val;
int ret;
if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
ret = Z_LVAL_P(val);
} else {
- ret = i_zend_is_true(val);
+ ret = i_zend_is_true(val TSRMLS_CC);
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
static int ZEND_FASTCALL ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *val;
int ret;
if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
ret = Z_LVAL_P(val);
} else {
- ret = i_zend_is_true(val);
+ ret = i_zend_is_true(val TSRMLS_CC);
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
static int ZEND_FASTCALL ZEND_JMPZNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *val;
int retval;
if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
retval = Z_LVAL_P(val);
} else {
- retval = i_zend_is_true(val);
+ retval = i_zend_is_true(val TSRMLS_CC);
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *val;
int retval;
if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
retval = Z_LVAL_P(val);
} else {
- retval = i_zend_is_true(val);
+ retval = i_zend_is_true(val TSRMLS_CC);
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
static int ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *val;
int retval;
if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
retval = Z_LVAL_P(val);
} else {
- retval = i_zend_is_true(val);
+ retval = i_zend_is_true(val TSRMLS_CC);
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
static int ZEND_FASTCALL ZEND_DO_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *fname = opline->op1.zv;
call_slot *call = EX(call_slots) + opline->op2.num;
{
USE_OPLINE
zval *retval_ptr;
-
+
SAVE_OPLINE();
retval_ptr = opline->op1.zv;
USE_OPLINE
zval *retval_ptr;
zval **retval_ptr_ptr;
-
+
SAVE_OPLINE();
do {
- if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR ||
+ if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR ||
(IS_CONST == 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");
USE_OPLINE
zval *value;
zval *exception;
-
+
SAVE_OPLINE();
value = opline->op1.zv;
{
zval *valptr;
zval *value;
-
+
value = opline->op1.zv;
static int ZEND_FASTCALL ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *retval = &EX_T(opline->result.var).tmp_var;
SAVE_OPLINE();
/* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
- ZVAL_BOOL(retval, i_zend_is_true(opline->op1.zv));
+ ZVAL_BOOL(retval, i_zend_is_true(opline->op1.zv TSRMLS_CC));
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
static int ZEND_FASTCALL ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *obj;
zend_class_entry *ce;
zend_function *clone;
static int ZEND_FASTCALL ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *expr;
zval *result = &EX_T(opline->result.var).tmp_var;
{
USE_OPLINE
zend_op_array *new_op_array=NULL;
-
+
zval *inc_filename;
zval *tmp_inc_filename = NULL;
zend_bool failure_retval=0;
static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *array_ptr, **array_ptr_ptr;
HashTable *fe_ht;
zend_object_iterator *iter = NULL;
}
}
} else if (IS_CONST == IS_CONST ||
- (IS_CONST == IS_CV &&
+ (IS_CONST == IS_CV &&
!Z_ISREF_P(array_ptr) &&
Z_REFCOUNT_P(array_ptr) > 1) ||
(IS_CONST == IS_VAR &&
SAVE_OPLINE();
if (IS_CONST != IS_UNUSED) {
-
+
zval *ptr = opline->op1.zv;
if (Z_TYPE_P(ptr) == IS_LONG) {
static int ZEND_FASTCALL ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *value;
SAVE_OPLINE();
value = opline->op1.zv;
- if (i_zend_is_true(value)) {
+ if (i_zend_is_true(value TSRMLS_CC)) {
ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
if (!0) {
zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var);
static int ZEND_FASTCALL ZEND_JMP_SET_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *value, *ret;
SAVE_OPLINE();
value = opline->op1.zv;
- if (i_zend_is_true(value)) {
+ if (i_zend_is_true(value TSRMLS_CC)) {
if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
Z_ADDREF_P(value);
EX_T(opline->result.var).var.ptr = value;
static int ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *value;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_QM_ASSIGN_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *value, *ret;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
fast_add_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_SUB_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
fast_sub_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_MUL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
fast_mul_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_DIV_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
fast_div_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_MOD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
fast_mod_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_SL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
shift_left_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_SR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
shift_right_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
concat_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
is_identical_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *result = &EX_T(opline->result.var).tmp_var;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *result = &EX_T(opline->result.var).tmp_var;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *result = &EX_T(opline->result.var).tmp_var;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *result = &EX_T(opline->result.var).tmp_var;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *result = &EX_T(opline->result.var).tmp_var;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
bitwise_or_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
bitwise_and_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
boolean_xor_function(&EX_T(opline->result.var).tmp_var,
if (IS_CONST == IS_CONST) {
hash_value = Z_HASH_P(varname);
} else {
- hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
+ hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
}
if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *container;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_FETCH_DIM_TMP_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *container;
SAVE_OPLINE();
PZVAL_LOCK(&EG(uninitialized_zval));
EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
} else {
-
+
zval *value = *zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
PZVAL_LOCK(value);
} else if (IS_CONST != IS_UNUSED) {
char *function_name_strval = NULL;
int function_name_strlen = 0;
-
+
if (IS_CONST == IS_CONST) {
function_name_strval = Z_STRVAL_P(opline->op2.zv);
static int ZEND_FASTCALL ZEND_CASE_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
is_equal_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *expr_ptr;
SAVE_OPLINE();
}
if (IS_CONST != IS_UNUSED) {
-
+
zval *offset = opline->op2.zv;
ulong hval;
USE_OPLINE
zval tmp, *varname;
HashTable *target_symbol_table;
-
+
SAVE_OPLINE();
if (IS_CONST == IS_CV &&
}
} else {
HashTable *target_symbol_table;
-
+
zval tmp, *varname = opline->op1.zv;
if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
}
} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
- if (!isset || !i_zend_is_true(*value)) {
+ if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
} else {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
static int ZEND_FASTCALL ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *name;
zval *val;
zend_constant c;
/* Set the new yielded value */
if (IS_CONST != IS_UNUSED) {
-
+
if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
/* Constants and temporary variables aren't yieldable by reference,
/* Set the new yielded key */
if (IS_CONST != IS_UNUSED) {
-
+
zval *key = opline->op2.zv;
/* Consts, temporary variables and references need copying */
static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *expr_ptr;
SAVE_OPLINE();
/* Set the new yielded value */
if (IS_CONST != IS_UNUSED) {
-
+
if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
/* Constants and temporary variables aren't yieldable by reference,
if (IS_CONST == IS_CONST) {
hash_value = Z_HASH_P(varname);
} else {
- hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
+ hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
}
if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *expr_ptr;
SAVE_OPLINE();
USE_OPLINE
zval tmp, *varname;
HashTable *target_symbol_table;
-
+
SAVE_OPLINE();
if (IS_CONST == IS_CV &&
}
} else {
HashTable *target_symbol_table;
-
+
zval tmp, *varname = opline->op1.zv;
if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
}
} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
- if (!isset || !i_zend_is_true(*value)) {
+ if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
} else {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
/* Set the new yielded value */
if (IS_CONST != IS_UNUSED) {
-
+
if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
/* Constants and temporary variables aren't yieldable by reference,
if (IS_CONST == IS_CONST) {
hash_value = Z_HASH_P(varname);
} else {
- hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
+ hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
}
if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
} else if (IS_UNUSED != IS_UNUSED) {
char *function_name_strval = NULL;
int function_name_strlen = 0;
-
+
if (IS_UNUSED == IS_CONST) {
function_name_strval = Z_STRVAL_P(opline->op2.zv);
static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *expr_ptr;
SAVE_OPLINE();
}
if (IS_UNUSED != IS_UNUSED) {
-
+
zval *offset = NULL;
ulong hval;
USE_OPLINE
zval tmp, *varname;
HashTable *target_symbol_table;
-
+
SAVE_OPLINE();
if (IS_CONST == IS_CV &&
}
} else {
HashTable *target_symbol_table;
-
+
zval tmp, *varname = opline->op1.zv;
if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
}
} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
- if (!isset || !i_zend_is_true(*value)) {
+ if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
} else {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
/* Set the new yielded value */
if (IS_CONST != IS_UNUSED) {
-
+
if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
/* Constants and temporary variables aren't yieldable by reference,
/* Set the new yielded key */
if (IS_UNUSED != IS_UNUSED) {
-
+
zval *key = NULL;
/* Consts, temporary variables and references need copying */
static int ZEND_FASTCALL ZEND_ADD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
fast_add_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_SUB_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
fast_sub_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_MUL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
fast_mul_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
fast_div_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_MOD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
fast_mod_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_SL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
shift_left_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_SR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
shift_right_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
concat_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
is_identical_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *result = &EX_T(opline->result.var).tmp_var;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *result = &EX_T(opline->result.var).tmp_var;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *result = &EX_T(opline->result.var).tmp_var;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *result = &EX_T(opline->result.var).tmp_var;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *result = &EX_T(opline->result.var).tmp_var;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
bitwise_or_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
bitwise_and_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
boolean_xor_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *container;
SAVE_OPLINE();
} else if (IS_CV != IS_UNUSED) {
char *function_name_strval = NULL;
int function_name_strlen = 0;
-
+
if (IS_CV == IS_CONST) {
function_name_strval = Z_STRVAL_P(opline->op2.zv);
static int ZEND_FASTCALL ZEND_CASE_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
is_equal_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *expr_ptr;
SAVE_OPLINE();
}
if (IS_CV != IS_UNUSED) {
-
+
zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
ulong hval;
/* Set the new yielded value */
if (IS_CONST != IS_UNUSED) {
-
+
if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
/* Constants and temporary variables aren't yieldable by reference,
/* Set the new yielded key */
if (IS_CV != IS_UNUSED) {
-
+
zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
/* Consts, temporary variables and references need copying */
if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
ret = Z_LVAL_P(val);
} else {
- ret = i_zend_is_true(val);
+ ret = i_zend_is_true(val TSRMLS_CC);
zval_dtor(free_op1.var);
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
ret = Z_LVAL_P(val);
} else {
- ret = i_zend_is_true(val);
+ ret = i_zend_is_true(val TSRMLS_CC);
zval_dtor(free_op1.var);
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
retval = Z_LVAL_P(val);
} else {
- retval = i_zend_is_true(val);
+ retval = i_zend_is_true(val TSRMLS_CC);
zval_dtor(free_op1.var);
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
retval = Z_LVAL_P(val);
} else {
- retval = i_zend_is_true(val);
+ retval = i_zend_is_true(val TSRMLS_CC);
zval_dtor(free_op1.var);
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
retval = Z_LVAL_P(val);
} else {
- retval = i_zend_is_true(val);
+ retval = i_zend_is_true(val TSRMLS_CC);
zval_dtor(free_op1.var);
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
SAVE_OPLINE();
do {
- if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR ||
+ if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR ||
(IS_TMP_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");
SAVE_OPLINE();
/* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
- ZVAL_BOOL(retval, i_zend_is_true(_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC)));
+ ZVAL_BOOL(retval, i_zend_is_true(_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC) TSRMLS_CC));
zval_dtor(free_op1.var);
CHECK_EXCEPTION();
}
}
} else if (IS_TMP_VAR == IS_CONST ||
- (IS_TMP_VAR == IS_CV &&
+ (IS_TMP_VAR == IS_CV &&
!Z_ISREF_P(array_ptr) &&
Z_REFCOUNT_P(array_ptr) > 1) ||
(IS_TMP_VAR == IS_VAR &&
SAVE_OPLINE();
value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- if (i_zend_is_true(value)) {
+ if (i_zend_is_true(value TSRMLS_CC)) {
ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
if (!1) {
zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var);
SAVE_OPLINE();
value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- if (i_zend_is_true(value)) {
+ if (i_zend_is_true(value TSRMLS_CC)) {
if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
Z_ADDREF_P(value);
EX_T(opline->result.var).var.ptr = value;
if (IS_TMP_VAR == IS_CONST) {
hash_value = Z_HASH_P(varname);
} else {
- hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
+ hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
}
if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
PZVAL_LOCK(&EG(uninitialized_zval));
EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
} else {
-
+
zval *value = *zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
PZVAL_LOCK(value);
}
if (IS_CONST != IS_UNUSED) {
-
+
zval *offset = opline->op2.zv;
ulong hval;
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
}
} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
- if (!isset || !i_zend_is_true(*value)) {
+ if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
} else {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
/* Set the new yielded key */
if (IS_CONST != IS_UNUSED) {
-
+
zval *key = opline->op2.zv;
/* Consts, temporary variables and references need copying */
if (IS_TMP_VAR == IS_CONST) {
hash_value = Z_HASH_P(varname);
} else {
- hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
+ hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
}
if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
}
} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
- if (!isset || !i_zend_is_true(*value)) {
+ if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
} else {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
if (IS_TMP_VAR == IS_CONST) {
hash_value = Z_HASH_P(varname);
} else {
- hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
+ hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
}
if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
}
if (IS_UNUSED != IS_UNUSED) {
-
+
zval *offset = NULL;
ulong hval;
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
}
} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
- if (!isset || !i_zend_is_true(*value)) {
+ if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
} else {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
/* Set the new yielded key */
if (IS_UNUSED != IS_UNUSED) {
-
+
zval *key = NULL;
/* Consts, temporary variables and references need copying */
static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *str = &EX_T(opline->result.var).tmp_var;
zval *var;
zval var_copy;
}
if (IS_CV != IS_UNUSED) {
-
+
zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
ulong hval;
/* Set the new yielded key */
if (IS_CV != IS_UNUSED) {
-
+
zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
/* Consts, temporary variables and references need copying */
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);
+ ret = i_zend_is_true(val TSRMLS_CC);
zval_ptr_dtor_nogc(&free_op1.var);
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
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);
+ ret = i_zend_is_true(val TSRMLS_CC);
zval_ptr_dtor_nogc(&free_op1.var);
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
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);
+ retval = i_zend_is_true(val TSRMLS_CC);
zval_ptr_dtor_nogc(&free_op1.var);
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
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);
+ retval = i_zend_is_true(val TSRMLS_CC);
zval_ptr_dtor_nogc(&free_op1.var);
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
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);
+ retval = i_zend_is_true(val TSRMLS_CC);
zval_ptr_dtor_nogc(&free_op1.var);
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
SAVE_OPLINE();
do {
- if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR ||
+ 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");
SAVE_OPLINE();
/* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
- ZVAL_BOOL(retval, i_zend_is_true(_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC)));
+ ZVAL_BOOL(retval, i_zend_is_true(_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC) TSRMLS_CC));
zval_ptr_dtor_nogc(&free_op1.var);
CHECK_EXCEPTION();
}
}
} else if (IS_VAR == IS_CONST ||
- (IS_VAR == IS_CV &&
+ (IS_VAR == IS_CV &&
!Z_ISREF_P(array_ptr) &&
Z_REFCOUNT_P(array_ptr) > 1) ||
(IS_VAR == IS_VAR &&
static int ZEND_FASTCALL ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *array = EX_T(opline->op1.var).fe.ptr;
zval **value;
HashTable *fe_ht;
SAVE_OPLINE();
value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- if (i_zend_is_true(value)) {
+ if (i_zend_is_true(value TSRMLS_CC)) {
ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
if (!0) {
zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var);
SAVE_OPLINE();
value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
- if (i_zend_is_true(value)) {
+ if (i_zend_is_true(value TSRMLS_CC)) {
if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
Z_ADDREF_P(value);
EX_T(opline->result.var).var.ptr = value;
if (IS_VAR == IS_CONST) {
hash_value = Z_HASH_P(varname);
} else {
- hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
+ hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
}
if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
USE_OPLINE
zend_free_op free_op1;
zval *container;
-
+
zval *offset;
SAVE_OPLINE();
USE_OPLINE
zend_free_op free_op1;
zval *container;
-
+
zval *offset;
SAVE_OPLINE();
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
}
if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
-
+
zval *property_name = opline->op2.zv;
if (0) {
} else if (IS_CONST != IS_UNUSED) {
char *function_name_strval = NULL;
int function_name_strlen = 0;
-
+
if (IS_CONST == IS_CONST) {
function_name_strval = Z_STRVAL_P(opline->op2.zv);
}
if (IS_CONST != IS_UNUSED) {
-
+
zval *offset = opline->op2.zv;
ulong hval;
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
}
} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
- if (!isset || !i_zend_is_true(*value)) {
+ if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
} else {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
result = isset;
}
} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
- if (!isset || !i_zend_is_true(*value)) {
+ if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
result = 0;
} else {
result = 1;
/* Set the new yielded key */
if (IS_CONST != IS_UNUSED) {
-
+
zval *key = opline->op2.zv;
/* Consts, temporary variables and references need copying */
result = isset;
}
} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
- if (!isset || !i_zend_is_true(*value)) {
+ if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
result = 0;
} else {
result = 1;
if (IS_VAR == IS_CONST) {
hash_value = Z_HASH_P(varname);
} else {
- hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
+ hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
}
if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
}
} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
- if (!isset || !i_zend_is_true(*value)) {
+ if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
} else {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
result = isset;
}
} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
- if (!isset || !i_zend_is_true(*value)) {
+ if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
result = 0;
} else {
result = 1;
if (IS_VAR == IS_CONST) {
hash_value = Z_HASH_P(varname);
} else {
- hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
+ hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
}
if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
}
if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
-
+
zval *property_name = NULL;
if (0) {
} else if (IS_UNUSED != IS_UNUSED) {
char *function_name_strval = NULL;
int function_name_strlen = 0;
-
+
if (IS_UNUSED == IS_CONST) {
function_name_strval = Z_STRVAL_P(opline->op2.zv);
}
if (IS_UNUSED != IS_UNUSED) {
-
+
zval *offset = NULL;
ulong hval;
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
}
} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
- if (!isset || !i_zend_is_true(*value)) {
+ if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
} else {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
/* Set the new yielded key */
if (IS_UNUSED != IS_UNUSED) {
-
+
zval *key = NULL;
/* Consts, temporary variables and references need copying */
USE_OPLINE
zend_free_op free_op1;
zval *container;
-
+
zval *offset;
SAVE_OPLINE();
USE_OPLINE
zend_free_op free_op1;
zval *container;
-
+
zval *offset;
SAVE_OPLINE();
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
}
if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
-
+
zval *property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
if (0) {
} else if (IS_CV != IS_UNUSED) {
char *function_name_strval = NULL;
int function_name_strlen = 0;
-
+
if (IS_CV == IS_CONST) {
function_name_strval = Z_STRVAL_P(opline->op2.zv);
}
if (IS_CV != IS_UNUSED) {
-
+
zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
ulong hval;
result = isset;
}
} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
- if (!isset || !i_zend_is_true(*value)) {
+ if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
result = 0;
} else {
result = 1;
/* Set the new yielded key */
if (IS_CV != IS_UNUSED) {
-
+
zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
/* Consts, temporary variables and references need copying */
static int ZEND_FASTCALL ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *obj;
zend_class_entry *ce;
zend_function *clone;
SAVE_OPLINE();
if (IS_UNUSED != IS_UNUSED) {
-
+
zval *ptr = NULL;
if (Z_TYPE_P(ptr) == IS_LONG) {
static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval **object_ptr;
zval *object;
zval *property;
static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval **object_ptr;
zval *object;
zval *property;
static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_CONST(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *container;
-
+
zval *offset;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *container;
-
+
zval *offset;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval **object_ptr;
zval *property_name;
zval *function_name;
char *function_name_strval;
int function_name_strlen;
-
+
call_slot *call = EX(call_slots) + opline->result.num;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval **container;
zval *offset;
ulong hval;
static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval **container;
zval *offset;
static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *container;
zval **value = NULL;
int result = 0;
result = isset;
}
} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
- if (!isset || !i_zend_is_true(*value)) {
+ if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
result = 0;
} else {
result = 1;
/* Set the new yielded value */
if (IS_UNUSED != IS_UNUSED) {
-
+
if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
/* Constants and temporary variables aren't yieldable by reference,
/* Set the new yielded key */
if (IS_CONST != IS_UNUSED) {
-
+
zval *key = opline->op2.zv;
/* Consts, temporary variables and references need copying */
static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *container;
zend_free_op free_op2;
zval *offset;
static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *container;
zend_free_op free_op2;
zval *offset;
result = isset;
}
} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
- if (!isset || !i_zend_is_true(*value)) {
+ if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
result = 0;
} else {
result = 1;
/* Set the new yielded value */
if (IS_UNUSED != IS_UNUSED) {
-
+
if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
/* Constants and temporary variables aren't yieldable by reference,
static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_VAR(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *container;
zend_free_op free_op2;
zval *offset;
static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *container;
zend_free_op free_op2;
zval *offset;
result = isset;
}
} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
- if (!isset || !i_zend_is_true(*value)) {
+ if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
result = 0;
} else {
result = 1;
/* Set the new yielded value */
if (IS_UNUSED != IS_UNUSED) {
-
+
if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
/* Constants and temporary variables aren't yieldable by reference,
/* Set the new yielded value */
if (IS_UNUSED != IS_UNUSED) {
-
+
if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
/* Constants and temporary variables aren't yieldable by reference,
/* Set the new yielded key */
if (IS_UNUSED != IS_UNUSED) {
-
+
zval *key = NULL;
/* Consts, temporary variables and references need copying */
static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval **object_ptr;
zval *object;
zval *property;
static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval **object_ptr;
zval *object;
zval *property;
static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_CV(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *container;
-
+
zval *offset;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *container;
-
+
zval *offset;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval **object_ptr;
zval *property_name;
static int ZEND_FASTCALL ZEND_ADD_VAR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *str = &EX_T(opline->result.var).tmp_var;
zval *var;
zval var_copy;
zval *function_name;
char *function_name_strval;
int function_name_strlen;
-
+
call_slot *call = EX(call_slots) + opline->result.num;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval **container;
zval *offset;
ulong hval;
static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval **container;
zval *offset;
static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *container;
zval **value = NULL;
int result = 0;
result = isset;
}
} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
- if (!isset || !i_zend_is_true(*value)) {
+ if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
result = 0;
} else {
result = 1;
/* Set the new yielded value */
if (IS_UNUSED != IS_UNUSED) {
-
+
if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
/* Constants and temporary variables aren't yieldable by reference,
/* Set the new yielded key */
if (IS_CV != IS_UNUSED) {
-
+
zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
/* Consts, temporary variables and references need copying */
static int ZEND_FASTCALL ZEND_BW_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
bitwise_not_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
boolean_not_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_PRE_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval **var_ptr;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_PRE_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval **var_ptr;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval **var_ptr, *retval;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval **var_ptr, *retval;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *z;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *val;
int ret;
if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
ret = Z_LVAL_P(val);
} else {
- ret = i_zend_is_true(val);
+ ret = i_zend_is_true(val TSRMLS_CC);
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
static int ZEND_FASTCALL ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *val;
int ret;
if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
ret = Z_LVAL_P(val);
} else {
- ret = i_zend_is_true(val);
+ ret = i_zend_is_true(val TSRMLS_CC);
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
static int ZEND_FASTCALL ZEND_JMPZNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *val;
int retval;
if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
retval = Z_LVAL_P(val);
} else {
- retval = i_zend_is_true(val);
+ retval = i_zend_is_true(val TSRMLS_CC);
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *val;
int retval;
if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
retval = Z_LVAL_P(val);
} else {
- retval = i_zend_is_true(val);
+ retval = i_zend_is_true(val TSRMLS_CC);
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
static int ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *val;
int retval;
if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
retval = Z_LVAL_P(val);
} else {
- retval = i_zend_is_true(val);
+ retval = i_zend_is_true(val TSRMLS_CC);
if (UNEXPECTED(EG(exception) != NULL)) {
HANDLE_EXCEPTION();
{
USE_OPLINE
zval *retval_ptr;
-
+
SAVE_OPLINE();
retval_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
USE_OPLINE
zval *retval_ptr;
zval **retval_ptr_ptr;
-
+
SAVE_OPLINE();
do {
- if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR ||
+ if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR ||
(IS_CV == 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");
USE_OPLINE
zval *value;
zval *exception;
-
+
SAVE_OPLINE();
value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
{
USE_OPLINE
zval *varptr;
-
+
varptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
if (varptr == &EG(uninitialized_zval)) {
static int ZEND_FASTCALL ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *varptr;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_SEND_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval **varptr_ptr;
zval *varptr;
static int ZEND_FASTCALL ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *retval = &EX_T(opline->result.var).tmp_var;
SAVE_OPLINE();
/* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
- ZVAL_BOOL(retval, i_zend_is_true(_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC)));
+ ZVAL_BOOL(retval, i_zend_is_true(_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC) TSRMLS_CC));
CHECK_EXCEPTION();
ZEND_VM_NEXT_OPCODE();
static int ZEND_FASTCALL ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *obj;
zend_class_entry *ce;
zend_function *clone;
static int ZEND_FASTCALL ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *expr;
zval *result = &EX_T(opline->result.var).tmp_var;
{
USE_OPLINE
zend_op_array *new_op_array=NULL;
-
+
zval *inc_filename;
zval *tmp_inc_filename = NULL;
zend_bool failure_retval=0;
static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *array_ptr, **array_ptr_ptr;
HashTable *fe_ht;
zend_object_iterator *iter = NULL;
}
}
} else if (IS_CV == IS_CONST ||
- (IS_CV == IS_CV &&
+ (IS_CV == IS_CV &&
!Z_ISREF_P(array_ptr) &&
Z_REFCOUNT_P(array_ptr) > 1) ||
(IS_CV == IS_VAR &&
SAVE_OPLINE();
if (IS_CV != IS_UNUSED) {
-
+
zval *ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
if (Z_TYPE_P(ptr) == IS_LONG) {
static int ZEND_FASTCALL ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *value;
SAVE_OPLINE();
value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
- if (i_zend_is_true(value)) {
+ if (i_zend_is_true(value TSRMLS_CC)) {
ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
if (!0) {
zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var);
static int ZEND_FASTCALL ZEND_JMP_SET_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *value, *ret;
SAVE_OPLINE();
value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
- if (i_zend_is_true(value)) {
+ if (i_zend_is_true(value TSRMLS_CC)) {
if (IS_CV == IS_VAR || IS_CV == IS_CV) {
Z_ADDREF_P(value);
EX_T(opline->result.var).var.ptr = value;
static int ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *value;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_QM_ASSIGN_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *value, *ret;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *expr;
zend_bool result;
static int ZEND_FASTCALL ZEND_ADD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
fast_add_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_SUB_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
fast_sub_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_MUL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
fast_mul_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
fast_div_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_MOD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
fast_mod_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_SL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
shift_left_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_SR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
shift_right_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
concat_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
is_identical_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *result = &EX_T(opline->result.var).tmp_var;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *result = &EX_T(opline->result.var).tmp_var;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *result = &EX_T(opline->result.var).tmp_var;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *result = &EX_T(opline->result.var).tmp_var;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *result = &EX_T(opline->result.var).tmp_var;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
bitwise_or_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
bitwise_and_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
boolean_xor_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval **object_ptr;
zval *object;
zval *property;
static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval **object_ptr;
zval *object;
zval *property;
if (IS_CV == IS_CONST) {
hash_value = Z_HASH_P(varname);
} else {
- hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
+ hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
}
if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *container;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *container;
SAVE_OPLINE();
static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CONST(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *container;
-
+
zval *offset;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *container;
-
+
zval *offset;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval **object_ptr;
zval *property_name;
static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval **object_ptr;
SAVE_OPLINE();
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
}
if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
-
+
zval *property_name = opline->op2.zv;
if (0) {
static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *value;
zval **variable_ptr_ptr;
zval *function_name;
char *function_name_strval;
int function_name_strlen;
-
+
call_slot *call = EX(call_slots) + opline->result.num;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_CASE_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
is_equal_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *expr_ptr;
SAVE_OPLINE();
}
if (IS_CONST != IS_UNUSED) {
-
+
zval *offset = opline->op2.zv;
ulong hval;
USE_OPLINE
zval tmp, *varname;
HashTable *target_symbol_table;
-
+
SAVE_OPLINE();
if (IS_CV == IS_CV &&
static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval **container;
zval *offset;
ulong hval;
static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval **container;
zval *offset;
}
} else {
HashTable *target_symbol_table;
-
+
zval tmp, *varname = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
}
} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
- if (!isset || !i_zend_is_true(*value)) {
+ if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
} else {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *container;
zval **value = NULL;
int result = 0;
result = isset;
}
} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
- if (!isset || !i_zend_is_true(*value)) {
+ if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
result = 0;
} else {
result = 1;
/* Set the new yielded value */
if (IS_CV != IS_UNUSED) {
-
+
if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
/* Constants and temporary variables aren't yieldable by reference,
/* Set the new yielded key */
if (IS_CONST != IS_UNUSED) {
-
+
zval *key = opline->op2.zv;
/* Consts, temporary variables and references need copying */
static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_TMP(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *container;
zend_free_op free_op2;
zval *offset;
static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *container;
zend_free_op free_op2;
zval *offset;
static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval **object_ptr;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *expr_ptr;
SAVE_OPLINE();
result = isset;
}
} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
- if (!isset || !i_zend_is_true(*value)) {
+ if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
result = 0;
} else {
result = 1;
/* Set the new yielded value */
if (IS_CV != IS_UNUSED) {
-
+
if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
/* Constants and temporary variables aren't yieldable by reference,
if (IS_CV == IS_CONST) {
hash_value = Z_HASH_P(varname);
} else {
- hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
+ hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
}
if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_VAR(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *container;
zend_free_op free_op2;
zval *offset;
static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *container;
zend_free_op free_op2;
zval *offset;
static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval **object_ptr;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *expr_ptr;
SAVE_OPLINE();
USE_OPLINE
zval tmp, *varname;
HashTable *target_symbol_table;
-
+
SAVE_OPLINE();
if (IS_CV == IS_CV &&
}
} else {
HashTable *target_symbol_table;
-
+
zval tmp, *varname = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
}
} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
- if (!isset || !i_zend_is_true(*value)) {
+ if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
} else {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
result = isset;
}
} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
- if (!isset || !i_zend_is_true(*value)) {
+ if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
result = 0;
} else {
result = 1;
/* Set the new yielded value */
if (IS_CV != IS_UNUSED) {
-
+
if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
/* Constants and temporary variables aren't yieldable by reference,
if (IS_CV == IS_CONST) {
hash_value = Z_HASH_P(varname);
} else {
- hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
+ hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
}
if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval **object_ptr;
SAVE_OPLINE();
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
}
if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
-
+
zval *property_name = NULL;
if (0) {
static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *expr_ptr;
SAVE_OPLINE();
}
if (IS_UNUSED != IS_UNUSED) {
-
+
zval *offset = NULL;
ulong hval;
USE_OPLINE
zval tmp, *varname;
HashTable *target_symbol_table;
-
+
SAVE_OPLINE();
if (IS_CV == IS_CV &&
}
} else {
HashTable *target_symbol_table;
-
+
zval tmp, *varname = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
}
} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
- if (!isset || !i_zend_is_true(*value)) {
+ if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
} else {
ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
/* Set the new yielded value */
if (IS_CV != IS_UNUSED) {
-
+
if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
/* Constants and temporary variables aren't yieldable by reference,
/* Set the new yielded key */
if (IS_UNUSED != IS_UNUSED) {
-
+
zval *key = NULL;
/* Consts, temporary variables and references need copying */
static int ZEND_FASTCALL ZEND_ADD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
fast_add_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_SUB_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
fast_sub_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_MUL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
fast_mul_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
fast_div_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_MOD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
fast_mod_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_SL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
shift_left_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_SR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
shift_right_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
concat_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
is_identical_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *result = &EX_T(opline->result.var).tmp_var;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *result = &EX_T(opline->result.var).tmp_var;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *result = &EX_T(opline->result.var).tmp_var;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *result = &EX_T(opline->result.var).tmp_var;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *result = &EX_T(opline->result.var).tmp_var;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
bitwise_or_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
bitwise_and_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
boolean_xor_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval **object_ptr;
zval *object;
zval *property;
static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval **object_ptr;
zval *object;
zval *property;
static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *container;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *container;
SAVE_OPLINE();
static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CV(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *container;
-
+
zval *offset;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *container;
-
+
zval *offset;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval **object_ptr;
zval *property_name;
static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval **object_ptr;
SAVE_OPLINE();
zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
}
if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
-
+
zval *property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
if (0) {
static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *value;
zval **variable_ptr_ptr;
zval *function_name;
char *function_name_strval;
int function_name_strlen;
-
+
call_slot *call = EX(call_slots) + opline->result.num;
SAVE_OPLINE();
static int ZEND_FASTCALL ZEND_CASE_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
SAVE_OPLINE();
is_equal_function(&EX_T(opline->result.var).tmp_var,
static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *expr_ptr;
SAVE_OPLINE();
}
if (IS_CV != IS_UNUSED) {
-
+
zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
ulong hval;
static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval **container;
zval *offset;
ulong hval;
static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval **container;
zval *offset;
static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
-
+
zval *container;
zval **value = NULL;
int result = 0;
result = isset;
}
} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
- if (!isset || !i_zend_is_true(*value)) {
+ if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
result = 0;
} else {
result = 1;
/* Set the new yielded value */
if (IS_CV != IS_UNUSED) {
-
+
if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
/* Constants and temporary variables aren't yieldable by reference,
/* Set the new yielded key */
if (IS_CV != IS_UNUSED) {
-
+
zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
/* Consts, temporary variables and references need copying */
projects / php / commitdiff