From: Anthony Ferrara Date: Thu, 19 Mar 2015 17:30:11 +0000 (-0400) Subject: Refactor as to not use call info, but add the flag to the op_array. X-Git-Tag: PRE_PHP7_NSAPI_REMOVAL~573^2~11^2~5 X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=7044f9c6df52ab37a122881c313d008aa568185a;p=php Refactor as to not use call info, but add the flag to the op_array. --- diff --git a/Zend/zend.c b/Zend/zend.c index f54442a7ed..6bb614fab5 100644 --- a/Zend/zend.c +++ b/Zend/zend.c @@ -1297,7 +1297,7 @@ ZEND_API void zend_internal_type_error(zend_bool strict, const char *format, ... va_start(va, format); zend_vspprintf(&message, 0, format, va); if (strict) { - zend_throw_exception(zend_get_type_exception(), message, 0); + zend_throw_exception(zend_get_type_exception(), message, E_ERROR); } else { zend_error(E_WARNING, message); } diff --git a/Zend/zend_API.c b/Zend/zend_API.c index f86bb66c53..dac6f16754 100644 --- a/Zend/zend_API.c +++ b/Zend/zend_API.c @@ -151,7 +151,7 @@ ZEND_API int zend_copy_parameters_array(int param_count, zval *argument_array) / ZEND_API void zend_wrong_param_count(void) /* {{{ */ { - if (ZEND_CALL_INFO(EG(current_execute_data)) & ZEND_CALL_STRICT_TYPEHINTS) { + if (EX_PREV_USES_STRICT_TYPES()) { zend_wrong_param_count_ex(1); } else { zend_wrong_param_count_ex(0); @@ -802,7 +802,7 @@ ZEND_API int zend_parse_parameters_ex(int flags, int num_args, const char *type_ va_list va; int retval; - if (ZEND_CALL_INFO(EG(current_execute_data)) & ZEND_CALL_STRICT_TYPEHINTS) { + if (EX_PREV_USES_STRICT_TYPES()) { flags |= ZEND_PARSE_PARAMS_STRICT; } @@ -822,7 +822,7 @@ ZEND_API int zend_parse_parameters(int num_args, const char *type_spec, ...) /* int retval; int flags = 0; - if (ZEND_CALL_INFO(EG(current_execute_data)) & ZEND_CALL_STRICT_TYPEHINTS) { + if (EX_PREV_USES_STRICT_TYPES()) { flags |= ZEND_PARSE_PARAMS_STRICT; } @@ -851,7 +851,7 @@ ZEND_API int zend_parse_method_parameters(int num_args, zval *this_ptr, const ch * wrong branch here. */ zend_bool is_method = EG(current_execute_data)->func->common.scope != NULL; - if (ZEND_CALL_INFO(EG(current_execute_data)) & ZEND_CALL_STRICT_TYPEHINTS) { + if (EX_PREV_USES_STRICT_TYPES()) { flags |= ZEND_PARSE_PARAMS_STRICT; } @@ -891,7 +891,7 @@ ZEND_API int zend_parse_method_parameters_ex(int flags, int num_args, zval *this zval **object; zend_class_entry *ce; - if (ZEND_CALL_INFO(EG(current_execute_data)) & ZEND_CALL_STRICT_TYPEHINTS) { + if (EX_PREV_USES_STRICT_TYPES()) { flags |= ZEND_PARSE_PARAMS_STRICT; } diff --git a/Zend/zend_API.h b/Zend/zend_API.h index 810e9b850f..e0f39e98a2 100644 --- a/Zend/zend_API.h +++ b/Zend/zend_API.h @@ -720,7 +720,7 @@ ZEND_API void zend_wrong_callback_error(int severity, int num, char *error, zend #define ZPP_ERROR_WRONG_COUNT 5 #define ZEND_PARSE_PARAMETERS_START_EX(flags, min_num_args, max_num_args) do { \ - zend_bool _strict = (EX_CALL_INFO() & ZEND_CALL_STRICT_TYPEHINTS) ? 1 : 0; \ + zend_bool _strict = EX_PREV_USES_STRICT_TYPES(); \ const int _flags = (flags) | (_strict ? ZEND_PARSE_PARAMS_STRICT : 0); \ int _min_num_args = (min_num_args); \ int _max_num_args = (max_num_args); \ diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 5744ae3ad0..954412bf19 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -188,7 +188,6 @@ static zend_always_inline zend_uchar zend_lookup_scalar_typehint_by_name(const z static void init_compiler_declarables(void) /* {{{ */ { ZVAL_LONG(&CG(declarables).ticks, 0); - CG(declarables).strict_types = 0; } /* }}} */ @@ -1624,8 +1623,6 @@ void zend_do_end_compilation(void) /* {{{ */ { CG(has_bracketed_namespaces) = 0; zend_end_namespace(); - /* strict typehinting is per-file */ - CG(declarables).strict_types = 0; } /* }}} */ @@ -1926,8 +1923,7 @@ static void zend_emit_return_type_check(znode *expr, zend_arg_info *return_info) if (return_info->type_hint != IS_UNDEF) { zend_op *opline = zend_emit_op(NULL, ZEND_VERIFY_RETURN_TYPE, expr, NULL); - opline->extended_value = (CG(declarables).strict_types ? ZEND_RETURN_TYPE_STRICT : 0) - & (returns_reference ? ZEND_RETURN_TYPE_BYREF : 0); + opline->extended_value = (returns_reference ? ZEND_RETURN_REF : 0); } } /* }}} */ @@ -2716,8 +2712,7 @@ void zend_compile_call_common(znode *result, zend_ast *args_ast, zend_function * opline->op1.num = zend_vm_calc_used_stack(arg_count, fbc); } - call_flags = (opline->opcode == ZEND_NEW ? ZEND_CALL_CTOR : 0) - | (CG(declarables).strict_types ? ZEND_CALL_STRICT_TYPEHINTS : 0); + call_flags = (opline->opcode == ZEND_NEW ? ZEND_CALL_CTOR : 0); opline = zend_emit_op(result, zend_get_call_op(opline->opcode, fbc), NULL, NULL); opline->op1.num = call_flags; @@ -3405,7 +3400,7 @@ void zend_compile_return(zend_ast *ast) /* {{{ */ /* for scalar, weak return types, the value may be casted * thus, for constants, we need to store them in a tmp var */ - if (expr_node.op_type == IS_CONST && !CG(declarables).strict_types) { + if (expr_node.op_type == IS_CONST && !(CG(active_op_array)->fn_flags & ZEND_ACC_STRICT_TYPES)) { znode expr_node_copy = expr_node; zend_emit_op_tmp(&expr_node, ZEND_QM_ASSIGN, &expr_node_copy, NULL); @@ -4050,7 +4045,10 @@ void zend_compile_declare(zend_ast *ast) /* {{{ */ zend_error_noreturn(E_COMPILE_ERROR, "strict_types declaration must have 0 or 1 as its value"); } - CG(declarables).strict_types = Z_LVAL(value_zv); + if (Z_LVAL(value_zv) == 1) { + CG(active_op_array)->fn_flags |= ZEND_ACC_STRICT_TYPES; + } + } else { zend_error(E_COMPILE_WARNING, "Unsupported declare '%s'", name->val); } @@ -4525,6 +4523,7 @@ void zend_compile_func_decl(znode *result, zend_ast *ast) /* {{{ */ init_op_array(op_array, ZEND_USER_FUNCTION, INITIAL_OP_ARRAY_SIZE); + op_array->fn_flags |= (orig_op_array->fn_flags & ZEND_ACC_STRICT_TYPES); op_array->fn_flags |= decl->flags; op_array->line_start = decl->start_lineno; op_array->line_end = decl->end_lineno; diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h index 2de832854c..cedd5d6808 100644 --- a/Zend/zend_compile.h +++ b/Zend/zend_compile.h @@ -252,6 +252,9 @@ typedef struct _zend_try_catch_element { /* Function has a return type hint (or class has such non-private function) */ #define ZEND_ACC_HAS_RETURN_TYPE 0x40000000 +/* op_array uses strict mode types */ +#define ZEND_ACC_STRICT_TYPES 0x80000000 + char *zend_visibility_string(uint32_t fn_flags); typedef struct _zend_property_info { @@ -423,10 +426,6 @@ struct _zend_execute_data { #define ZEND_CALL_FREE_EXTRA_ARGS (1 << 2) /* equal to IS_TYPE_REFCOUNTED */ #define ZEND_CALL_CTOR (1 << 3) #define ZEND_CALL_CTOR_RESULT_UNUSED (1 << 4) -#define ZEND_CALL_STRICT_TYPEHINTS (1 << 5) - -#define ZEND_RETURN_TYPE_STRICT (1 << 0) -#define ZEND_RETURN_TYPE_BYREF (1 << 1) #define ZEND_CALL_INFO(call) \ (Z_TYPE_INFO((call)->This) >> 24) @@ -462,7 +461,10 @@ struct _zend_execute_data { #define EX_CALL_INFO() ZEND_CALL_INFO(execute_data) #define EX_CALL_KIND() ZEND_CALL_KIND(execute_data) #define EX_NUM_ARGS() ZEND_CALL_NUM_ARGS(execute_data) -#define EX_USES_STRICT_TYPES() ((EX_CALL_INFO() & ZEND_CALL_STRICT_TYPEHINTS) ? 1 : 0) + +#define EX_USES_STRICT_TYPES() _EX_USES_STRICT_TYPES(EG(current_execute_data)) +#define EX_PREV_USES_STRICT_TYPES() _EX_USES_STRICT_TYPES(EG(current_execute_data)->prev_execute_data) +#define _EX_USES_STRICT_TYPES(ex_data) ((ex_data) && (ex_data)->func && ZEND_USER_CODE((ex_data)->func->type) && ((ex_data)->func->op_array.fn_flags & ZEND_ACC_STRICT_TYPES) ? 1 : 0) #define EX_VAR(n) ZEND_CALL_VAR(execute_data, n) #define EX_VAR_NUM(n) ZEND_CALL_VAR_NUM(execute_data, n) diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index eb9f68e350..5b2cb561b2 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -3133,7 +3133,7 @@ ZEND_VM_HANDLER(118, ZEND_INIT_USER_CALL, CONST, CONST|TMPVAR|CV) } } } else { - zend_error(E_WARNING, "%s() expects parameter 1 to be a valid callback, %s", Z_STRVAL_P(EX_CONSTANT(opline->op1)), error); + zend_internal_type_error(EX_USES_STRICT_TYPES(), "%s() expects parameter 1 to be a valid callback, %s", Z_STRVAL_P(EX_CONSTANT(opline->op1)), error); efree(error); func = (zend_function*)&zend_pass_function; called_scope = NULL; @@ -3214,8 +3214,6 @@ ZEND_VM_HANDLER(129, ZEND_DO_ICALL, ANY, ANY) zend_function *fbc = call->func; zval *ret; - ZEND_ADD_CALL_FLAG(call, opline->op1.num & ZEND_CALL_STRICT_TYPEHINTS); - SAVE_OPLINE(); EX(call) = call->prev_execute_data; @@ -3263,8 +3261,6 @@ ZEND_VM_HANDLER(130, ZEND_DO_UCALL, ANY, ANY) zend_function *fbc = call->func; zval *ret; - ZEND_ADD_CALL_FLAG(call, opline->op1.num & ZEND_CALL_STRICT_TYPEHINTS); - SAVE_OPLINE(); EX(call) = call->prev_execute_data; @@ -3290,8 +3286,6 @@ ZEND_VM_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY) zend_function *fbc = call->func; zval *ret; - ZEND_ADD_CALL_FLAG(call, opline->op1.num & ZEND_CALL_STRICT_TYPEHINTS); - SAVE_OPLINE(); EX(call) = call->prev_execute_data; @@ -3396,8 +3390,6 @@ ZEND_VM_HANDLER(60, ZEND_DO_FCALL, ANY, ANY) zend_object *object = Z_OBJ(call->This); zval *ret; - ZEND_ADD_CALL_FLAG(call, opline->op1.num & ZEND_CALL_STRICT_TYPEHINTS); - SAVE_OPLINE(); EX(call) = call->prev_execute_data; if (UNEXPECTED((fbc->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_DEPRECATED)) != 0)) { @@ -3608,7 +3600,7 @@ ZEND_VM_HANDLER(124, ZEND_VERIFY_RETURN_TYPE, CONST|TMP|VAR|UNUSED|CV, UNUSED) retval_ptr = GET_OP1_ZVAL_PTR(BP_VAR_R); - if (EXPECTED((opline->extended_value & ZEND_RETURN_TYPE_BYREF) == 0)) { + if (EXPECTED((opline->extended_value & ZEND_RETURN_REF) == 0)) { /* Does not return by reference */ SEPARATE_ZVAL(retval_ptr); } else { @@ -3616,7 +3608,7 @@ ZEND_VM_HANDLER(124, ZEND_VERIFY_RETURN_TYPE, CONST|TMP|VAR|UNUSED|CV, UNUSED) SEPARATE_ZVAL_NOREF(retval_ptr); } - zend_verify_return_type(EX(func), retval_ptr, opline->extended_value & ZEND_RETURN_TYPE_STRICT); + zend_verify_return_type(EX(func), retval_ptr, EX_USES_STRICT_TYPES()); #endif } CHECK_EXCEPTION(); @@ -4189,7 +4181,7 @@ ZEND_VM_HANDLER(119, ZEND_SEND_ARRAY, ANY, ANY) ZEND_VM_C_GOTO(send_array); } } - zend_error(E_WARNING, "call_user_func_array() expects parameter 2 to be array, %s given", zend_get_type_by_const(Z_TYPE_P(args))); + zend_internal_type_error(EX_USES_STRICT_TYPES(), "call_user_func_array() expects parameter 2 to be array, %s given", zend_get_type_by_const(Z_TYPE_P(args))); if (EX(call)->func->common.fn_flags & ZEND_ACC_CLOSURE) { OBJ_RELEASE((zend_object*)EX(call)->func->common.prototype); } @@ -4388,7 +4380,7 @@ ZEND_VM_HANDLER(63, ZEND_RECV, ANY, ANY) } else if (UNEXPECTED((EX(func)->op_array.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) { zval *param = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->result.var); - zend_verify_arg_type(EX(func), arg_num, param, NULL, EX_USES_STRICT_TYPES()); + zend_verify_arg_type(EX(func), arg_num, param, NULL, EX_PREV_USES_STRICT_TYPES()); CHECK_EXCEPTION(); } @@ -4416,7 +4408,7 @@ ZEND_VM_HANDLER(64, ZEND_RECV_INIT, ANY, CONST) } if (UNEXPECTED((EX(func)->op_array.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) { - zend_verify_arg_type(EX(func), arg_num, param, EX_CONSTANT(opline->op2), EX_USES_STRICT_TYPES()); + zend_verify_arg_type(EX(func), arg_num, param, EX_CONSTANT(opline->op2), EX_PREV_USES_STRICT_TYPES()); } CHECK_EXCEPTION(); @@ -7269,7 +7261,7 @@ ZEND_VM_HANDLER(121, ZEND_STRLEN, CONST|TMPVAR|CV, ANY) ZEND_VM_C_LABEL(try_strlen): if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) { ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value)); - } else if (EXPECTED(0 == EX_USES_STRICT_TYPES())) { + } else if (EXPECTED(!EX_USES_STRICT_TYPES())) { if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) { value = Z_REFVAL_P(value); ZEND_VM_C_GOTO(try_strlen); @@ -7293,11 +7285,11 @@ ZEND_VM_C_LABEL(try_strlen): zval_dtor(&tmp); } else { ZEND_VM_C_LABEL(strlen_error): - zend_error(E_WARNING, "strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value))); + zend_internal_type_error(0, "strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value))); ZVAL_NULL(EX_VAR(opline->result.var)); } } else { - zend_type_error("strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value))); + zend_internal_type_error(1, "strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value))); } FREE_OP1(); CHECK_EXCEPTION(); diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 8eb8bf8826..89d42dd9db 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -545,8 +545,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_ICALL_SPEC_HANDLER(ZEND_OPC zend_function *fbc = call->func; zval *ret; - ZEND_ADD_CALL_FLAG(call, opline->op1.num & ZEND_CALL_STRICT_TYPEHINTS); - SAVE_OPLINE(); EX(call) = call->prev_execute_data; @@ -594,8 +592,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_HANDLER(ZEND_OPC zend_function *fbc = call->func; zval *ret; - ZEND_ADD_CALL_FLAG(call, opline->op1.num & ZEND_CALL_STRICT_TYPEHINTS); - SAVE_OPLINE(); EX(call) = call->prev_execute_data; @@ -621,8 +617,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER( zend_function *fbc = call->func; zval *ret; - ZEND_ADD_CALL_FLAG(call, opline->op1.num & ZEND_CALL_STRICT_TYPEHINTS); - SAVE_OPLINE(); EX(call) = call->prev_execute_data; @@ -727,8 +721,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_HANDLER(ZEND_OPC zend_object *object = Z_OBJ(call->This); zval *ret; - ZEND_ADD_CALL_FLAG(call, opline->op1.num & ZEND_CALL_STRICT_TYPEHINTS); - SAVE_OPLINE(); EX(call) = call->prev_execute_data; if (UNEXPECTED((fbc->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_DEPRECATED)) != 0)) { @@ -1106,7 +1098,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_ARRAY_SPEC_HANDLER(ZEND_O goto send_array; } } - zend_error(E_WARNING, "call_user_func_array() expects parameter 2 to be array, %s given", zend_get_type_by_const(Z_TYPE_P(args))); + zend_internal_type_error(EX_USES_STRICT_TYPES(), "call_user_func_array() expects parameter 2 to be array, %s given", zend_get_type_by_const(Z_TYPE_P(args))); if (EX(call)->func->common.fn_flags & ZEND_ACC_CLOSURE) { OBJ_RELEASE((zend_object*)EX(call)->func->common.prototype); } @@ -1226,7 +1218,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_SPEC_HANDLER(ZEND_OPCODE_ } else if (UNEXPECTED((EX(func)->op_array.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) { zval *param = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->result.var); - zend_verify_arg_type(EX(func), arg_num, param, NULL, EX_USES_STRICT_TYPES()); + zend_verify_arg_type(EX(func), arg_num, param, NULL, EX_PREV_USES_STRICT_TYPES()); CHECK_EXCEPTION(); } @@ -2084,7 +2076,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RECV_INIT_SPEC_CONST_HANDLER(Z } if (UNEXPECTED((EX(func)->op_array.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) { - zend_verify_arg_type(EX(func), arg_num, param, EX_CONSTANT(opline->op2), EX_USES_STRICT_TYPES()); + zend_verify_arg_type(EX(func), arg_num, param, EX_CONSTANT(opline->op2), EX_PREV_USES_STRICT_TYPES()); } CHECK_EXCEPTION(); @@ -3815,7 +3807,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_CONST_HANDLER(ZEND try_strlen: if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) { ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value)); - } else if (EXPECTED(0 == EX_USES_STRICT_TYPES())) { + } else if (EXPECTED(!EX_USES_STRICT_TYPES())) { if ((IS_CONST & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) { value = Z_REFVAL_P(value); goto try_strlen; @@ -3839,11 +3831,11 @@ try_strlen: zval_dtor(&tmp); } else { strlen_error: - zend_error(E_WARNING, "strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value))); + zend_internal_type_error(0, "strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value))); ZVAL_NULL(EX_VAR(opline->result.var)); } } else { - zend_type_error("strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value))); + zend_internal_type_error(1, "strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value))); } CHECK_EXCEPTION(); @@ -5107,7 +5099,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CONS } } } else { - zend_error(E_WARNING, "%s() expects parameter 1 to be a valid callback, %s", Z_STRVAL_P(EX_CONSTANT(opline->op1)), error); + zend_internal_type_error(EX_USES_STRICT_TYPES(), "%s() expects parameter 1 to be a valid callback, %s", Z_STRVAL_P(EX_CONSTANT(opline->op1)), error); efree(error); func = (zend_function*)&zend_pass_function; called_scope = NULL; @@ -6979,7 +6971,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_ retval_ptr = EX_CONSTANT(opline->op1); - if (EXPECTED((opline->extended_value & ZEND_RETURN_TYPE_BYREF) == 0)) { + if (EXPECTED((opline->extended_value & ZEND_RETURN_REF) == 0)) { /* Does not return by reference */ SEPARATE_ZVAL(retval_ptr); } else { @@ -6987,7 +6979,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_ SEPARATE_ZVAL_NOREF(retval_ptr); } - zend_verify_return_type(EX(func), retval_ptr, opline->extended_value & ZEND_RETURN_TYPE_STRICT); + zend_verify_return_type(EX(func), retval_ptr, EX_USES_STRICT_TYPES()); #endif } CHECK_EXCEPTION(); @@ -8437,7 +8429,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CV_H } } } else { - zend_error(E_WARNING, "%s() expects parameter 1 to be a valid callback, %s", Z_STRVAL_P(EX_CONSTANT(opline->op1)), error); + zend_internal_type_error(EX_USES_STRICT_TYPES(), "%s() expects parameter 1 to be a valid callback, %s", Z_STRVAL_P(EX_CONSTANT(opline->op1)), error); efree(error); func = (zend_function*)&zend_pass_function; called_scope = NULL; @@ -9950,7 +9942,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_TMPV } } } else { - zend_error(E_WARNING, "%s() expects parameter 1 to be a valid callback, %s", Z_STRVAL_P(EX_CONSTANT(opline->op1)), error); + zend_internal_type_error(EX_USES_STRICT_TYPES(), "%s() expects parameter 1 to be a valid callback, %s", Z_STRVAL_P(EX_CONSTANT(opline->op1)), error); efree(error); func = (zend_function*)&zend_pass_function; called_scope = NULL; @@ -11933,7 +11925,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UN retval_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1); - if (EXPECTED((opline->extended_value & ZEND_RETURN_TYPE_BYREF) == 0)) { + if (EXPECTED((opline->extended_value & ZEND_RETURN_REF) == 0)) { /* Does not return by reference */ SEPARATE_ZVAL(retval_ptr); } else { @@ -11941,7 +11933,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UN SEPARATE_ZVAL_NOREF(retval_ptr); } - zend_verify_return_type(EX(func), retval_ptr, opline->extended_value & ZEND_RETURN_TYPE_STRICT); + zend_verify_return_type(EX(func), retval_ptr, EX_USES_STRICT_TYPES()); #endif } CHECK_EXCEPTION(); @@ -17287,7 +17279,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UN retval_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1); - if (EXPECTED((opline->extended_value & ZEND_RETURN_TYPE_BYREF) == 0)) { + if (EXPECTED((opline->extended_value & ZEND_RETURN_REF) == 0)) { /* Does not return by reference */ SEPARATE_ZVAL(retval_ptr); } else { @@ -17295,7 +17287,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UN SEPARATE_ZVAL_NOREF(retval_ptr); } - zend_verify_return_type(EX(func), retval_ptr, opline->extended_value & ZEND_RETURN_TYPE_STRICT); + zend_verify_return_type(EX(func), retval_ptr, EX_USES_STRICT_TYPES()); #endif } CHECK_EXCEPTION(); @@ -22898,7 +22890,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED retval_ptr = NULL; - if (EXPECTED((opline->extended_value & ZEND_RETURN_TYPE_BYREF) == 0)) { + if (EXPECTED((opline->extended_value & ZEND_RETURN_REF) == 0)) { /* Does not return by reference */ SEPARATE_ZVAL(retval_ptr); } else { @@ -22906,7 +22898,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED SEPARATE_ZVAL_NOREF(retval_ptr); } - zend_verify_return_type(EX(func), retval_ptr, opline->extended_value & ZEND_RETURN_TYPE_STRICT); + zend_verify_return_type(EX(func), retval_ptr, EX_USES_STRICT_TYPES()); #endif } CHECK_EXCEPTION(); @@ -27302,7 +27294,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_CV_HANDLER(ZEND_OP try_strlen: if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) { ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value)); - } else if (EXPECTED(0 == EX_USES_STRICT_TYPES())) { + } else if (EXPECTED(!EX_USES_STRICT_TYPES())) { if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) { value = Z_REFVAL_P(value); goto try_strlen; @@ -27326,11 +27318,11 @@ try_strlen: zval_dtor(&tmp); } else { strlen_error: - zend_error(E_WARNING, "strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value))); + zend_internal_type_error(0, "strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value))); ZVAL_NULL(EX_VAR(opline->result.var)); } } else { - zend_type_error("strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value))); + zend_internal_type_error(1, "strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value))); } CHECK_EXCEPTION(); @@ -31838,7 +31830,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNU retval_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var); - if (EXPECTED((opline->extended_value & ZEND_RETURN_TYPE_BYREF) == 0)) { + if (EXPECTED((opline->extended_value & ZEND_RETURN_REF) == 0)) { /* Does not return by reference */ SEPARATE_ZVAL(retval_ptr); } else { @@ -31846,7 +31838,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNU SEPARATE_ZVAL_NOREF(retval_ptr); } - zend_verify_return_type(EX(func), retval_ptr, opline->extended_value & ZEND_RETURN_TYPE_STRICT); + zend_verify_return_type(EX(func), retval_ptr, EX_USES_STRICT_TYPES()); #endif } CHECK_EXCEPTION(); @@ -37563,7 +37555,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_TMPVAR_HANDLER(ZEN try_strlen: if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) { ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value)); - } else if (EXPECTED(0 == EX_USES_STRICT_TYPES())) { + } else if (EXPECTED(!EX_USES_STRICT_TYPES())) { if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) { value = Z_REFVAL_P(value); goto try_strlen; @@ -37587,11 +37579,11 @@ try_strlen: zval_dtor(&tmp); } else { strlen_error: - zend_error(E_WARNING, "strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value))); + zend_internal_type_error(0, "strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value))); ZVAL_NULL(EX_VAR(opline->result.var)); } } else { - zend_type_error("strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value))); + zend_internal_type_error(1, "strlen() expects parameter 1 to be string, %s given", zend_get_type_by_const(Z_TYPE_P(value))); } zval_ptr_dtor_nogc(free_op1); CHECK_EXCEPTION();