Use zend_error_noreturn() for fatal errors

diff --git a/Zend/zend_API.c b/Zend/zend_API.c
index 001cb656172b198824f1703cdf660fb1cc5f506b..37de396d1c86c2d2bb2050d7e7e82f8f632e9d4c 100644 (file)
--- a/Zend/zend_API.c
+++ b/Zend/zend_API.c
@@ -1020,7 +1020,7 @@ ZEND_API int zend_parse_method_parameters(int num_args, zval *this_ptr, const ch
                *object = this_ptr;
 
                if (ce && !instanceof_function(Z_OBJCE_P(this_ptr), ce)) {
-                       zend_error(E_CORE_ERROR, "%s::%s() must be derived from %s::%s",
+                       zend_error_noreturn(E_CORE_ERROR, "%s::%s() must be derived from %s::%s",
                                Z_OBJCE_P(this_ptr)->name->val, get_active_function_name(), ce->name->val, get_active_function_name());
                }
 
@@ -1057,7 +1057,7 @@ ZEND_API int zend_parse_method_parameters_ex(int flags, int num_args, zval *this
 
                if (ce && !instanceof_function(Z_OBJCE_P(this_ptr), ce)) {
                        if (!(flags & ZEND_PARSE_PARAMS_QUIET)) {
-                               zend_error(E_CORE_ERROR, "%s::%s() must be derived from %s::%s",
+                               zend_error_noreturn(E_CORE_ERROR, "%s::%s() must be derived from %s::%s",
                                        ce->name->val, get_active_function_name(), Z_OBJCE_P(this_ptr)->name->val, get_active_function_name());
                        }
                        va_end(va);
@@ -1840,7 +1840,7 @@ ZEND_API int zend_startup_module_ex(zend_module_entry *module) /* {{{ */
        if (module->module_startup_func) {
                EG(current_module) = module;
                if (module->module_startup_func(module->type, module->module_number)==FAILURE) {
-                       zend_error(E_CORE_ERROR,"Unable to start %s module", module->name);
+                       zend_error_noreturn(E_CORE_ERROR,"Unable to start %s module", module->name);
                        EG(current_module) = NULL;
                        return FAILURE;
                }
@@ -2189,7 +2189,7 @@ ZEND_API int zend_register_functions(zend_class_entry *scope, const zend_functio
                                if (info->class_name) {
                                        ZEND_ASSERT(info->type_hint == IS_OBJECT);
                                        if (!scope && (!strcasecmp(info->class_name, "self") || !strcasecmp(info->class_name, "parent"))) {
-                                               zend_error(E_CORE_ERROR, "Cannot declare a return type of %s outside of a class scope", info->class_name);
+                                               zend_error_noreturn(E_CORE_ERROR, "Cannot declare a return type of %s outside of a class scope", info->class_name);
                                        }
                                }
 
@@ -2399,15 +2399,15 @@ ZEND_API int zend_register_functions(zend_class_entry *scope, const zend_functio
                }
 
                if (ctor && ctor->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE && ctor->common.fn_flags & ZEND_ACC_CTOR) {
-                       zend_error(E_CORE_ERROR, "Constructor %s::%s() cannot declare a return type", scope->name->val, ctor->common.function_name->val);
+                       zend_error_noreturn(E_CORE_ERROR, "Constructor %s::%s() cannot declare a return type", scope->name->val, ctor->common.function_name->val);
                }
 
                if (dtor && dtor->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE && dtor->common.fn_flags & ZEND_ACC_DTOR) {
-                       zend_error(E_CORE_ERROR, "Destructor %s::%s() cannot declare a return type", scope->name->val, dtor->common.function_name->val);
+                       zend_error_noreturn(E_CORE_ERROR, "Destructor %s::%s() cannot declare a return type", scope->name->val, dtor->common.function_name->val);
                }
 
                if (clone && clone->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE && dtor->common.fn_flags & ZEND_ACC_DTOR) {
-                       zend_error(E_CORE_ERROR, "%s::%s() cannot declare a return type", scope->name->val, clone->common.function_name->val);
+                       zend_error_noreturn(E_CORE_ERROR, "%s::%s() cannot declare a return type", scope->name->val, clone->common.function_name->val);
                }
                efree((char*)lc_class_name);
        }
@@ -3092,7 +3092,7 @@ get_function_via_handler:
                                        zend_spprintf(error, 0, "cannot call abstract method %s::%s()", fcc->calling_scope->name->val, fcc->function_handler->common.function_name->val);
                                        retval = 0;
                                } else {
-                                       zend_error(E_ERROR, "Cannot call abstract method %s::%s()", fcc->calling_scope->name->val, fcc->function_handler->common.function_name->val);
+                                       zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", fcc->calling_scope->name->val, fcc->function_handler->common.function_name->val);
                                }
                        } else if (!fcc->object && !(fcc->function_handler->common.fn_flags & ZEND_ACC_STATIC)) {
                                int severity;
@@ -3636,7 +3636,7 @@ ZEND_API int zend_declare_property_ex(zend_class_entry *ce, zend_string *name, z
                        case IS_ARRAY:
                        case IS_OBJECT:
                        case IS_RESOURCE:
-                               zend_error(E_CORE_ERROR, "Internal zval's can't be arrays, objects or resources");
+                               zend_error_noreturn(E_CORE_ERROR, "Internal zval's can't be arrays, objects or resources");
                                break;
                        default:
                                break;
@@ -3798,7 +3798,7 @@ ZEND_API void zend_update_property(zend_class_entry *scope, zval *object, const
        EG(scope) = scope;
 
        if (!Z_OBJ_HT_P(object)->write_property) {
-               zend_error(E_CORE_ERROR, "Property %s of class %s cannot be updated", name, Z_OBJCE_P(object)->name->val);
+               zend_error_noreturn(E_CORE_ERROR, "Property %s of class %s cannot be updated", name, Z_OBJCE_P(object)->name->val);
        }
        ZVAL_STRINGL(&property, name, name_length);
        Z_OBJ_HT_P(object)->write_property(object, &property, value, NULL);
@@ -3976,7 +3976,7 @@ ZEND_API zval *zend_read_property(zend_class_entry *scope, zval *object, const c
        EG(scope) = scope;
 
        if (!Z_OBJ_HT_P(object)->read_property) {
-               zend_error(E_CORE_ERROR, "Property %s of class %s cannot be read", name, Z_OBJCE_P(object)->name->val);
+               zend_error_noreturn(E_CORE_ERROR, "Property %s of class %s cannot be read", name, Z_OBJCE_P(object)->name->val);
        }
 
        ZVAL_STRINGL(&property, name, name_length);

diff --git a/Zend/zend_ast.c b/Zend/zend_ast.c
index f888fda28907b42d7f34cee442702e908b61524b..b8a2d45474e7369b18b909f347fff2536d776097 100644 (file)
--- a/Zend/zend_ast.c
+++ b/Zend/zend_ast.c
@@ -203,7 +203,7 @@ static void zend_ast_add_array_element(zval *result, zval *offset, zval *expr)
                        zend_hash_index_update(Z_ARRVAL_P(result), zend_dval_to_lval(Z_DVAL_P(offset)), expr);
                        break;
                default:
-                       zend_error(E_ERROR, "Illegal offset type");
+                       zend_error_noreturn(E_ERROR, "Illegal offset type");
                        break;
        }
 }
@@ -338,7 +338,7 @@ ZEND_API void zend_ast_evaluate(zval *result, zend_ast *ast, zend_class_entry *s
                        zval_dtor(&op2);
                        break;
                default:
-                       zend_error(E_ERROR, "Unsupported constant expression");
+                       zend_error_noreturn(E_ERROR, "Unsupported constant expression");
        }
 }
 

diff --git a/Zend/zend_builtin_functions.c b/Zend/zend_builtin_functions.c
index e131e97bee2bab8eaf70c791c728b914e73da884..275fcf9cffe37746226488dd5ef1e8a001953263 100644 (file)
--- a/Zend/zend_builtin_functions.c
+++ b/Zend/zend_builtin_functions.c
@@ -1949,7 +1949,7 @@ ZEND_FUNCTION(create_function)
 
                func = zend_hash_str_find_ptr(EG(function_table), LAMBDA_TEMP_FUNCNAME, sizeof(LAMBDA_TEMP_FUNCNAME)-1);
                if (!func) {
-                       zend_error(E_ERROR, "Unexpected inconsistency in create_function()");
+                       zend_error_noreturn(E_ERROR, "Unexpected inconsistency in create_function()");
                        RETURN_FALSE;
                }
                if (func->refcount) {

diff --git a/Zend/zend_closures.c b/Zend/zend_closures.c
index 84e35a85d543440f7458a096446c09f0658ecfc5..37b2407313c678ad1a9cb51e1872b253f019978a 100644 (file)
--- a/Zend/zend_closures.c
+++ b/Zend/zend_closures.c
@@ -269,7 +269,7 @@ static void zend_closure_free_storage(zend_object *object) /* {{{ */
                zend_execute_data *ex = EG(current_execute_data);
                while (ex) {
                        if (ex->func == &closure->func) {
-                               zend_error(E_ERROR, "Cannot destroy active lambda function");
+                               zend_error_noreturn(E_ERROR, "Cannot destroy active lambda function");
                        }
                        ex = ex->prev_execute_data;
                }

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index e3e2abfc01ca9cc5f8ac47a8d6f632f87498a86a..f77d603d0d0b39960c97275c9f712f7cb55c0dce 100644 (file)
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -4490,7 +4490,7 @@ static void zend_begin_func_decl(znode *result, zend_op_array *op_array, zend_as
        if (CG(current_import_function)) {
                zend_string *import_name = zend_hash_find_ptr(CG(current_import_function), lcname);
                if (import_name && !zend_string_equals_ci(lcname, import_name)) {
-                       zend_error(E_COMPILE_ERROR, "Cannot declare function %s "
+                       zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare function %s "
                                "because the name is already in use", name->val);
                }
        }
@@ -5229,7 +5229,7 @@ void zend_compile_const_decl(zend_ast *ast) /* {{{ */
                        && (import_name = zend_hash_find_ptr(CG(current_import_const), name))
                ) {
                        if (!zend_string_equals(import_name, name)) {
-                               zend_error(E_COMPILE_ERROR, "Cannot declare const %s because "
+                               zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare const %s because "
                                        "the name is already in use", name->val);
                        }
                }
@@ -5499,7 +5499,7 @@ static zend_bool zend_try_ct_eval_array(zval *result, zend_ast *ast) /* {{{ */
                                        zend_hash_update(Z_ARRVAL_P(result), STR_EMPTY_ALLOC(), value);
                                        break;
                                default:
-                                       zend_error(E_COMPILE_ERROR, "Illegal offset type");
+                                       zend_error_noreturn(E_COMPILE_ERROR, "Illegal offset type");
                                        break;
                        }
                } else {

diff --git a/Zend/zend_constants.c b/Zend/zend_constants.c
index bf4e26a0e861943f47fd1c1017c3a4482609498c..cd8b58803da2e04c785c72047b8fdbc15d97b97c 100644 (file)
--- a/Zend/zend_constants.c
+++ b/Zend/zend_constants.c
@@ -334,14 +334,14 @@ ZEND_API zval *zend_get_constant_ex(zend_string *cname, zend_class_entry *scope,
                        if (scope) {
                                ce = scope;
                        } else {
-                               zend_error(E_ERROR, "Cannot access self:: when no class scope is active");
+                               zend_error_noreturn(E_ERROR, "Cannot access self:: when no class scope is active");
                        }
                } else if (class_name_len == sizeof("parent")-1 &&
                           !memcmp(lcname, "parent", sizeof("parent")-1)) {
                        if (!scope) {
-                               zend_error(E_ERROR, "Cannot access parent:: when no class scope is active");
+                               zend_error_noreturn(E_ERROR, "Cannot access parent:: when no class scope is active");
                        } else if (!scope->parent) {
-                               zend_error(E_ERROR, "Cannot access parent:: when current class scope has no parent");
+                               zend_error_noreturn(E_ERROR, "Cannot access parent:: when current class scope has no parent");
                        } else {
                                ce = scope->parent;
                        }
@@ -350,7 +350,7 @@ ZEND_API zval *zend_get_constant_ex(zend_string *cname, zend_class_entry *scope,
                        if (EG(current_execute_data) && EG(current_execute_data)->called_scope) {
                                ce = EG(current_execute_data)->called_scope;
                        } else {
-                               zend_error(E_ERROR, "Cannot access static:: when no class scope is active");
+                               zend_error_noreturn(E_ERROR, "Cannot access static:: when no class scope is active");
                        }
                } else {
                        ce = zend_fetch_class(class_name, flags);
@@ -360,7 +360,7 @@ ZEND_API zval *zend_get_constant_ex(zend_string *cname, zend_class_entry *scope,
                        ret_constant = zend_hash_find(&ce->constants_table, constant_name);
                        if (ret_constant == NULL) {
                                if ((flags & ZEND_FETCH_CLASS_SILENT) == 0) {
-                                       zend_error(E_ERROR, "Undefined class constant '%s::%s'", class_name->val, constant_name->val);
+                                       zend_error_noreturn(E_ERROR, "Undefined class constant '%s::%s'", class_name->val, constant_name->val);
                                }
                        } else if (Z_ISREF_P(ret_constant)) {
                                ret_constant = Z_REFVAL_P(ret_constant);

diff --git a/Zend/zend_exceptions.c b/Zend/zend_exceptions.c
index b88c13e6d0ddd676ca84d4b00fe744a4a7199d8c..a139c623227170f1f6553bcfbecc7c3c052a2c2c 100644 (file)
--- a/Zend/zend_exceptions.c
+++ b/Zend/zend_exceptions.c
@@ -48,7 +48,7 @@ void zend_exception_set_previous(zend_object *exception, zend_object *add_previo
        }
        ZVAL_OBJ(&tmp, add_previous);
        if (!instanceof_function(Z_OBJCE(tmp), base_exception_ce)) {
-               zend_error(E_ERROR, "Cannot set non exception as previous exception");
+               zend_error_noreturn(E_ERROR, "Cannot set non exception as previous exception");
                return;
        }
        ZVAL_OBJ(&zv, exception);
@@ -116,7 +116,7 @@ ZEND_API void zend_throw_exception_internal(zval *exception) /* {{{ */
                if(EG(exception)) {
                        zend_exception_error(EG(exception), E_ERROR);
                }
-               zend_error(E_ERROR, "Exception thrown without a stack frame");
+               zend_error_noreturn(E_ERROR, "Exception thrown without a stack frame");
        }
 
        if (zend_throw_exception_hook) {
@@ -215,7 +215,7 @@ ZEND_METHOD(exception, __construct)
        int    argc = ZEND_NUM_ARGS();
 
        if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc, "|SlO!", &message, &code, &previous, base_exception_ce) == FAILURE) {
-               zend_error(E_ERROR, "Wrong parameters for Exception([string $exception [, long $code [, Exception $previous = NULL]]])");
+               zend_error_noreturn(E_ERROR, "Wrong parameters for Exception([string $exception [, long $code [, Exception $previous = NULL]]])");
        }
 
        object = getThis();
@@ -245,7 +245,7 @@ ZEND_METHOD(error_exception, __construct)
        size_t message_len, filename_len;
 
        if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc, "|sllslO!", &message, &message_len, &code, &severity, &filename, &filename_len, &lineno, &previous, base_exception_ce) == FAILURE) {
-               zend_error(E_ERROR, "Wrong parameters for ErrorException([string $exception [, long $code, [ long $severity, [ string $filename, [ long $lineno  [, Exception $previous = NULL]]]]]])");
+               zend_error_noreturn(E_ERROR, "Wrong parameters for ErrorException([string $exception [, long $code, [ long $severity, [ string $filename, [ long $lineno  [, Exception $previous = NULL]]]]]])");
        }
 
        object = getThis();
@@ -972,13 +972,13 @@ ZEND_API void zend_throw_exception_object(zval *exception) /* {{{ */
        zend_class_entry *exception_ce;
 
        if (exception == NULL || Z_TYPE_P(exception) != IS_OBJECT) {
-               zend_error(E_ERROR, "Need to supply an object when throwing an exception");
+               zend_error_noreturn(E_ERROR, "Need to supply an object when throwing an exception");
        }
 
        exception_ce = Z_OBJCE_P(exception);
 
        if (!exception_ce || !instanceof_function(exception_ce, base_exception_ce)) {
-               zend_error(E_ERROR, "Exceptions must be valid objects derived from the Exception base class");
+               zend_error_noreturn(E_ERROR, "Exceptions must be valid objects derived from the Exception base class");
        }
        zend_throw_exception_internal(exception);
 }

diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index 593ed9d33d8e0bdfb226b5130aa8e3a65d6d56ee..384476478a16e1e3ed8ec1ea2dff0cd4b8fe2e6c 100644 (file)
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -880,7 +880,7 @@ ZEND_API void zend_verify_internal_return_error(const zend_function *zf, const c
                fclass = "";
        }
 
-       zend_error(E_CORE_ERROR, "Return value of %s%s%s() must %s%s, %s%s returned",
+       zend_error_noreturn(E_CORE_ERROR, "Return value of %s%s%s() must %s%s, %s%s returned",
                fclass, fsep, fname, need_msg, need_kind, returned_msg, returned_kind);
 }
 

diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c
index ff447e22cd8e17b44801aae886e71c74a1b8c93e..dcf972b8be05c6df1132c1a269b862c245f91239 100644 (file)
--- a/Zend/zend_execute_API.c
+++ b/Zend/zend_execute_API.c
@@ -527,7 +527,7 @@ ZEND_API int zval_update_constant_ex(zval *p, zend_bool inline_change, zend_clas
        char *colon;
 
        if (IS_CONSTANT_VISITED(p)) {
-               zend_error(E_ERROR, "Cannot declare self-referencing constant '%s'", Z_STRVAL_P(p));
+               zend_error_noreturn(E_ERROR, "Cannot declare self-referencing constant '%s'", Z_STRVAL_P(p));
        } else if (Z_TYPE_P(p) == IS_CONSTANT) {
                int refcount;
 
@@ -550,7 +550,7 @@ ZEND_API int zval_update_constant_ex(zval *p, zend_bool inline_change, zend_clas
                        if ((colon = (char*)zend_memrchr(Z_STRVAL_P(p), ':', Z_STRLEN_P(p)))) {
                                size_t len;
 
-                               zend_error(E_ERROR, "Undefined class constant '%s'", Z_STRVAL_P(p));
+                               zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL_P(p));
                                len = Z_STRLEN_P(p) - ((colon - Z_STRVAL_P(p)) + 1);
                                if (inline_change) {
                                        zend_string *tmp = zend_string_init(colon + 1, len, 0);
@@ -584,9 +584,9 @@ ZEND_API int zval_update_constant_ex(zval *p, zend_bool inline_change, zend_clas
                                }
                                if ((Z_CONST_FLAGS_P(p) & IS_CONSTANT_UNQUALIFIED) == 0) {
                                        if (save->val[0] == '\\') {
-                                               zend_error(E_ERROR, "Undefined constant '%s'", save->val + 1);
+                                               zend_error_noreturn(E_ERROR, "Undefined constant '%s'", save->val + 1);
                                        } else {
-                                               zend_error(E_ERROR, "Undefined constant '%s'", save->val);
+                                               zend_error_noreturn(E_ERROR, "Undefined constant '%s'", save->val);
                                        }
                                        if (inline_change) {
                                                zend_string_release(save);
@@ -698,7 +698,7 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache) /
                case sizeof(zend_fcall_info):
                        break; /* nothing to do currently */
                default:
-                       zend_error(E_ERROR, "Corrupted fcall_info provided to zend_call_function()");
+                       zend_error_noreturn(E_ERROR, "Corrupted fcall_info provided to zend_call_function()");
                        break;
        }
 
@@ -1182,7 +1182,7 @@ ZEND_API void zend_timeout(int dummy) /* {{{ */
                zend_on_timeout(EG(timeout_seconds));
        }
 
-       zend_error(E_ERROR, "Maximum execution time of %pd second%s exceeded", EG(timeout_seconds), EG(timeout_seconds) == 1 ? "" : "s");
+       zend_error_noreturn(E_ERROR, "Maximum execution time of %pd second%s exceeded", EG(timeout_seconds), EG(timeout_seconds) == 1 ? "" : "s");
 }
 /* }}} */
 
@@ -1224,7 +1224,7 @@ void zend_set_timeout(zend_long seconds, int reset_signals) /* {{{ */
                if (!DeleteTimerQueueTimer(NULL, tq_timer, NULL)) {
                        EG(timed_out) = 0;
                        tq_timer = NULL;
-                       zend_error(E_ERROR, "Could not delete queued timer");
+                       zend_error_noreturn(E_ERROR, "Could not delete queued timer");
                        return;
                }
                tq_timer = NULL;
@@ -1234,7 +1234,7 @@ void zend_set_timeout(zend_long seconds, int reset_signals) /* {{{ */
        if (!CreateTimerQueueTimer(&tq_timer, NULL, (WAITORTIMERCALLBACK)tq_timer_cb, (VOID*)&EG(timed_out), seconds*1000, 0, WT_EXECUTEONLYONCE)) {
                EG(timed_out) = 0;
                tq_timer = NULL;
-               zend_error(E_ERROR, "Could not queue new timer");
+               zend_error_noreturn(E_ERROR, "Could not queue new timer");
                return;
        }
        EG(timed_out) = 0;
@@ -1283,7 +1283,7 @@ void zend_unset_timeout(void) /* {{{ */
                if (!DeleteTimerQueueTimer(NULL, tq_timer, NULL)) {
                        EG(timed_out) = 0;
                        tq_timer = NULL;
-                       zend_error(E_ERROR, "Could not delete queued timer");
+                       zend_error_noreturn(E_ERROR, "Could not delete queued timer");
                        return;
                }
                tq_timer = NULL;
@@ -1319,20 +1319,20 @@ check_fetch_type:
        switch (fetch_type) {
                case ZEND_FETCH_CLASS_SELF:
                        if (!EG(scope)) {
-                               zend_error(E_ERROR, "Cannot access self:: when no class scope is active");
+                               zend_error_noreturn(E_ERROR, "Cannot access self:: when no class scope is active");
                        }
                        return EG(scope);
                case ZEND_FETCH_CLASS_PARENT:
                        if (!EG(scope)) {
-                               zend_error(E_ERROR, "Cannot access parent:: when no class scope is active");
+                               zend_error_noreturn(E_ERROR, "Cannot access parent:: when no class scope is active");
                        }
                        if (!EG(scope)->parent) {
-                               zend_error(E_ERROR, "Cannot access parent:: when current class scope has no parent");
+                               zend_error_noreturn(E_ERROR, "Cannot access parent:: when current class scope has no parent");
                        }
                        return EG(scope)->parent;
                case ZEND_FETCH_CLASS_STATIC:
                        if (!EG(current_execute_data) || !EG(current_execute_data)->called_scope) {
-                               zend_error(E_ERROR, "Cannot access static:: when no class scope is active");
+                               zend_error_noreturn(E_ERROR, "Cannot access static:: when no class scope is active");
                        }
                        return EG(current_execute_data)->called_scope;
                case ZEND_FETCH_CLASS_AUTO: {
@@ -1348,11 +1348,11 @@ check_fetch_type:
                if (use_autoload) {
                        if (!silent && !EG(exception)) {
                                if (fetch_type == ZEND_FETCH_CLASS_INTERFACE) {
-                                       zend_error(E_ERROR, "Interface '%s' not found", class_name->val);
+                                       zend_error_noreturn(E_ERROR, "Interface '%s' not found", class_name->val);
                                } else if (fetch_type == ZEND_FETCH_CLASS_TRAIT) {
-                       zend_error(E_ERROR, "Trait '%s' not found", class_name->val);
+                                       zend_error_noreturn(E_ERROR, "Trait '%s' not found", class_name->val);
                 } else {
-                                       zend_error(E_ERROR, "Class '%s' not found", class_name->val);
+                                       zend_error_noreturn(E_ERROR, "Class '%s' not found", class_name->val);
                                }
                        }
                }
@@ -1371,11 +1371,11 @@ zend_class_entry *zend_fetch_class_by_name(zend_string *class_name, const zval *
                if (use_autoload) {
                        if ((fetch_type & ZEND_FETCH_CLASS_SILENT) == 0 && !EG(exception)) {
                                if ((fetch_type & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_INTERFACE) {
-                                       zend_error(E_ERROR, "Interface '%s' not found", class_name->val);
+                                       zend_error_noreturn(E_ERROR, "Interface '%s' not found", class_name->val);
                                } else if ((fetch_type & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_TRAIT) {
-                                       zend_error(E_ERROR, "Trait '%s' not found", class_name->val);
+                                       zend_error_noreturn(E_ERROR, "Trait '%s' not found", class_name->val);
                                } else {
-                                       zend_error(E_ERROR, "Class '%s' not found", class_name->val);
+                                       zend_error_noreturn(E_ERROR, "Class '%s' not found", class_name->val);
                                }
                        }
                }
@@ -1432,7 +1432,7 @@ void zend_verify_abstract_class(zend_class_entry *ce) /* {{{ */
                } ZEND_HASH_FOREACH_END();
 
                if (ai.cnt) {
-                       zend_error(E_ERROR, "Class %s contains %d abstract method%s and must therefore be declared abstract or implement the remaining methods (" MAX_ABSTRACT_INFO_FMT MAX_ABSTRACT_INFO_FMT MAX_ABSTRACT_INFO_FMT ")",
+                       zend_error_noreturn(E_ERROR, "Class %s contains %d abstract method%s and must therefore be declared abstract or implement the remaining methods (" MAX_ABSTRACT_INFO_FMT MAX_ABSTRACT_INFO_FMT MAX_ABSTRACT_INFO_FMT ")",
                                ce->name->val, ai.cnt,
                                ai.cnt > 1 ? "s" : "",
                                DISPLAY_ABSTRACT_FN(0),

diff --git a/Zend/zend_generators.c b/Zend/zend_generators.c
index 1ec0539a7121104774c8a6401de6f2da6f5889c2..b1fcdea056854b1a6b7908e2142c9a4291b1f8ac 100644 (file)
--- a/Zend/zend_generators.c
+++ b/Zend/zend_generators.c
@@ -303,7 +303,7 @@ ZEND_API void zend_generator_resume(zend_generator *generator) /* {{{ */
        }
 
        if (generator->flags & ZEND_GENERATOR_CURRENTLY_RUNNING) {
-               zend_error(E_ERROR, "Cannot resume an already running generator");
+               zend_error_noreturn(E_ERROR, "Cannot resume an already running generator");
        }
 
        /* Drop the AT_FIRST_YIELD flag */

diff --git a/Zend/zend_interfaces.c b/Zend/zend_interfaces.c
index 7d73f073b31fba6bc93093617ee96c6064b5cd81..28f651cc850785ca57f6c3b340fcba64227b4ee2 100644 (file)
--- a/Zend/zend_interfaces.c
+++ b/Zend/zend_interfaces.c
@@ -78,7 +78,7 @@ ZEND_API zval* zend_call_method(zval *object, zend_class_entry *obj_ce, zend_fun
                if (!fn_proxy || !*fn_proxy) {
                        if ((fcic.function_handler = zend_hash_find_ptr(function_table, Z_STR(fci.function_name))) == NULL) {
                                /* error at c-level */
-                               zend_error(E_CORE_ERROR, "Couldn't find implementation for method %s%s%s", obj_ce ? obj_ce->name->val : "", obj_ce ? "::" : "", function_name);
+                               zend_error_noreturn(E_CORE_ERROR, "Couldn't find implementation for method %s%s%s", obj_ce ? obj_ce->name->val : "", obj_ce ? "::" : "", function_name);
                        }
                        if (fn_proxy) {
                                *fn_proxy = fcic.function_handler;
@@ -107,7 +107,7 @@ ZEND_API zval* zend_call_method(zval *object, zend_class_entry *obj_ce, zend_fun
                        obj_ce = object ? Z_OBJCE_P(object) : NULL;
                }
                if (!EG(exception)) {
-                       zend_error(E_CORE_ERROR, "Couldn't execute method %s%s%s", obj_ce ? obj_ce->name->val : "", obj_ce ? "::" : "", function_name);
+                       zend_error_noreturn(E_CORE_ERROR, "Couldn't execute method %s%s%s", obj_ce ? obj_ce->name->val : "", obj_ce ? "::" : "", function_name);
                }
        }
        /* copy arguments back, they might be changed by references */
@@ -259,7 +259,7 @@ static zend_object_iterator *zend_user_it_get_iterator(zend_class_entry *ce, zva
        zend_user_iterator *iterator;
 
        if (by_ref) {
-               zend_error(E_ERROR, "An iterator cannot be used with foreach by reference");
+               zend_error_noreturn(E_ERROR, "An iterator cannot be used with foreach by reference");
        }
 
        iterator = emalloc(sizeof(zend_user_iterator));
@@ -312,7 +312,7 @@ static int zend_implement_traversable(zend_class_entry *interface, zend_class_en
                        return SUCCESS;
                }
        }
-       zend_error(E_CORE_ERROR, "Class %s must implement interface %s as part of either %s or %s",
+       zend_error_noreturn(E_CORE_ERROR, "Class %s must implement interface %s as part of either %s or %s",
                class_type->name->val,
                zend_ce_traversable->name->val,
                zend_ce_iterator->name->val,
@@ -336,7 +336,7 @@ static int zend_implement_aggregate(zend_class_entry *interface, zend_class_entr
                        if (class_type->num_interfaces) {
                                for (i = 0; i < class_type->num_interfaces; i++) {
                                        if (class_type->interfaces[i] == zend_ce_iterator) {
-                                               zend_error(E_ERROR, "Class %s cannot implement both %s and %s at the same time",
+                                               zend_error_noreturn(E_ERROR, "Class %s cannot implement both %s and %s at the same time",
                                                                        class_type->name->val,
                                                                        interface->name->val,
                                                                        zend_ce_iterator->name->val);
@@ -368,7 +368,7 @@ static int zend_implement_iterator(zend_class_entry *interface, zend_class_entry
                } else {
                        /* c-level get_iterator cannot be changed */
                        if (class_type->get_iterator == zend_user_it_get_new_iterator) {
-                               zend_error(E_ERROR, "Class %s cannot implement both %s and %s at the same time",
+                               zend_error_noreturn(E_ERROR, "Class %s cannot implement both %s and %s at the same time",
                                                        class_type->name->val,
                                                        interface->name->val,
                                                        zend_ce_aggregate->name->val);

diff --git a/Zend/zend_language_scanner.c b/Zend/zend_language_scanner.c
index edde9ca870994a5554a312553a028d7473760240..75bd8d0ea61b28a7c16756cd25b2abcfe3265ded 100644 (file)
--- a/Zend/zend_language_scanner.c
+++ b/Zend/zend_language_scanner.c
@@ -988,7 +988,7 @@ static void zend_scan_escape_string(zval *zendlval, char *str, int len, char quo
                                                }
 
                                                if (!valid) {
-                                                       zend_error(E_COMPILE_ERROR, "Invalid UTF-8 codepoint escape sequence");
+                                                       zend_error_noreturn(E_COMPILE_ERROR, "Invalid UTF-8 codepoint escape sequence");
                                                }
 
                                                errno = 0;

diff --git a/Zend/zend_language_scanner.l b/Zend/zend_language_scanner.l
index 941a6cbceaebd9c17741baf4b967615796b8bd2d..f0104272181197244acaa21cc51151a777586d3c 100644 (file)
--- a/Zend/zend_language_scanner.l
+++ b/Zend/zend_language_scanner.l
@@ -986,7 +986,7 @@ static void zend_scan_escape_string(zval *zendlval, char *str, int len, char quo
                                                }
 
                                                if (!valid) {
-                                                       zend_error(E_COMPILE_ERROR, "Invalid UTF-8 codepoint escape sequence");
+                                                       zend_error_noreturn(E_COMPILE_ERROR, "Invalid UTF-8 codepoint escape sequence");
                                                }
 
                                                errno = 0;

diff --git a/Zend/zend_object_handlers.c b/Zend/zend_object_handlers.c
index 41d791a9303eb9eda88886cb0cc20a5a404b6b06..07d503996126328860f9d9b7035e3383cbaff37e 100644 (file)
--- a/Zend/zend_object_handlers.c
+++ b/Zend/zend_object_handlers.c
@@ -42,7 +42,7 @@
 #define Z_OBJ_PROTECT_RECURSION(zval_p) \
        do { \
                if (Z_OBJ_APPLY_COUNT_P(zval_p) >= 3) { \
-                       zend_error(E_ERROR, "Nesting level too deep - recursive dependency?"); \
+                       zend_error_noreturn(E_ERROR, "Nesting level too deep - recursive dependency?"); \
                } \
                Z_OBJ_INC_APPLY_COUNT_P(zval_p); \
        } while (0)
@@ -170,7 +170,7 @@ ZEND_API HashTable *zend_std_get_debug_info(zval *object, int *is_temp) /* {{{ *
                return ht;
        }
 
-       zend_error(E_ERROR, ZEND_DEBUGINFO_FUNC_NAME "() must return an array");
+       zend_error_noreturn(E_ERROR, ZEND_DEBUGINFO_FUNC_NAME "() must return an array");
 
        return NULL; /* Compilers are dumb and don't understand that noreturn means that the function does NOT need a return value... */
 }

diff --git a/Zend/zend_objects.c b/Zend/zend_objects.c
index aec3811087640650cba14f4b5952584de3b04a20..6f95e440cc573a4dcbd1b94b27f5ce62baac3a73 100644 (file)
--- a/Zend/zend_objects.c
+++ b/Zend/zend_objects.c
@@ -117,7 +117,7 @@ ZEND_API void zend_objects_destroy_object(zend_object *object)
                old_exception = NULL;
                if (EG(exception)) {
                        if (EG(exception) == object) {
-                               zend_error(E_ERROR, "Attempt to destruct pending exception");
+                               zend_error_noreturn(E_ERROR, "Attempt to destruct pending exception");
                        } else {
                                old_exception = EG(exception);
                                EG(exception) = NULL;

diff --git a/Zend/zend_signal.c b/Zend/zend_signal.c
index 881930335149d89cf6c9644afc4f17b86f06c5c3..1280a7085fc8d9779059c33677179c1c5ccc7125 100644 (file)
--- a/Zend/zend_signal.c
+++ b/Zend/zend_signal.c
@@ -214,7 +214,7 @@ ZEND_API int zend_sigaction(int signo, const struct sigaction *act, struct sigac
                sa.sa_mask      = global_sigmask;
 
                if (sigaction(signo, &sa, NULL) < 0) {
-                       zend_error(E_ERROR, "Error installing signal handler for %d", signo);
+                       zend_error_noreturn(E_ERROR, "Error installing signal handler for %d", signo);
                }
 
                /* unsure this signal is not blocked */
@@ -266,7 +266,7 @@ static int zend_signal_register(int signo, void (*handler)(int, siginfo_t*, void
                sa.sa_mask      = global_sigmask;
 
                if (sigaction(signo, &sa, NULL) < 0) {
-                       zend_error(E_ERROR, "Error installing signal handler for %d", signo);
+                       zend_error_noreturn(E_ERROR, "Error installing signal handler for %d", signo);
                }
 
                return SUCCESS;

diff --git a/Zend/zend_strtod.c b/Zend/zend_strtod.c
index b8a30a8efd319977fed048f2ba7f75e55aa3919d..4fa9ee311d1a8b8378f8a8b6521915357e5925b6 100644 (file)
--- a/Zend/zend_strtod.c
+++ b/Zend/zend_strtod.c
@@ -600,7 +600,7 @@ Balloc
                rv = (Bigint *)MALLOC(sizeof(Bigint) + (x-1)*sizeof(ULong));
                if (!rv) {
                        FREE_DTOA_LOCK(0);
-                       zend_error(E_ERROR, "Balloc() failed to allocate memory");
+                       zend_error_noreturn(E_ERROR, "Balloc() failed to allocate memory");
                }
 #else
                len = (sizeof(Bigint) + (x-1)*sizeof(ULong) + sizeof(double) - 1)
@@ -613,7 +613,7 @@ Balloc
                        rv = (Bigint*)MALLOC(len*sizeof(double));
                        if (!rv) {
                                FREE_DTOA_LOCK(0);
-                               zend_error(E_ERROR, "Balloc() failed to allocate memory");
+                               zend_error_noreturn(E_ERROR, "Balloc() failed to allocate memory");
                        }
 #endif
                rv->k = k;

diff --git a/Zend/zend_variables.c b/Zend/zend_variables.c
index 38c8f42d9fa98aac4c72d52863ab4de571e8c1be..b15c761bec3b1f7889f46145ef113181719d7e3b 100644 (file)
--- a/Zend/zend_variables.c
+++ b/Zend/zend_variables.c
@@ -147,7 +147,7 @@ ZEND_API void _zval_internal_dtor(zval *zvalue ZEND_FILE_LINE_DC)
                case IS_CONSTANT_AST:
                case IS_OBJECT:
                case IS_RESOURCE:
-                       zend_error(E_CORE_ERROR, "Internal zval's can't be arrays, objects or resources");
+                       zend_error_noreturn(E_CORE_ERROR, "Internal zval's can't be arrays, objects or resources");
                        break;
                case IS_REFERENCE: {
                                zend_reference *ref = (zend_reference*)Z_REF_P(zvalue);
@@ -178,7 +178,7 @@ ZEND_API void _zval_internal_dtor_for_ptr(zval *zvalue ZEND_FILE_LINE_DC)
                case IS_CONSTANT_AST:
                case IS_OBJECT:
                case IS_RESOURCE:
-                       zend_error(E_CORE_ERROR, "Internal zval's can't be arrays, objects or resources");
+                       zend_error_noreturn(E_CORE_ERROR, "Internal zval's can't be arrays, objects or resources");
                        break;
                case IS_REFERENCE: {
                                zend_reference *ref = (zend_reference*)Z_REF_P(zvalue);