errorAction
This action is called if an exception is generated on a
production system and no error template was found.

@return Symfony\Component\HttpFoundation\Response $res;
189557
public function errorAction()
    {
        $res = $this->getResponse();
        $res->setStatusCode(Response::HTTP_INTERNAL_SERVER_ERROR);
        $res->setContent(self::ERROR_CONTENT);

        return($res);
    }
1112938
public function IsErrorDispatched () {
		$toolClass = $this->toolClass;
		$defaultCtrlName = $toolClass::GetDashedFromPascalCase($this->defaultControllerName);
		$errorActionName = $toolClass::GetDashedFromPascalCase($this->defaultControllerErrorActionName);
		return $this->request->GetControllerName() == $defaultCtrlName &&
			$this->request->GetActionName() == $errorActionName;
	}
1285459
private function _exceptionHandler($e)
    {
        $this->_errorController->setParams(array('e' => $e));
        $action = FrontController::EXCEPTION_HANDLER_ACTION . 'Action';
        $this->_response->setStatusCode(500);

        return $this->_errorController->$action();
    }
941776
public function findError()
    {
        $requiredEnvironmentError = $this->ensureRequiredEnvironment();
        if ($requiredEnvironmentError !== null) {
            return $this->setErrorTitle($requiredEnvironmentError, 'Environment requirements not fulfilled');
        }

        $filePermissionsError = $this->checkFilePermissions();
        if ($filePermissionsError !== null) {
            return $this->setErrorTitle($filePermissionsError, 'Error with file system permissions');
        }

        return null;
    }
1217547
protected function renderError()
    {
        $errMessage = $this->errMessage;
        $errFile = $this->errFile;
        $errLine = $this->errLine;

        \ob_start();
        require __DIR__ . '/templates/trace.error.phtml';

        return \ob_get_clean();
    }
1169454
protected function getErrorResponse()
    {
        if (Request::ajax()) {
            throw new AjaxException('Element not found');
        }

        return Response::make($this->controller->run('404')->getContent(), 404);
    }
265177
function onMvcErrorInjectResponse($e)
    {
        // Do nothing if no error in the event
        $error = $e->getError();
        if(empty($error) || !$error instanceof \Exception)
            // We do nothing without Exception
            return;

        if ($e->getResult() instanceof Response)
            $e->setResponse($e->getResult());

        // Set Response Status Code >>>> {
        /** @var \Zend\Http\PhpEnvironment\Response $response */
        $response = $e->getResponse();
        if (!$response) {
            $response = new Response();
            $e->setResponse($response);
        }

        if ($response->getStatusCode() === 200)
            // Change Response Code only if is Success
            $response->setStatusCode(
                $this->__getResponseCodeFromException($error)
            );
        // <<<< }

        $this->error = $error;
    }
743595
public function getErrorDescription()
    {
        if (isset($this->responseObj->code) && !empty($this->responseObj->code)) {
            return Constants\Errors::getErrorDescription($this->responseObj->code);
        }

        if (isset($this->responseObj->response_code) && !empty($this->responseObj->response_code)) {
            return Constants\Errors::getIssuerResponseCode($this->responseObj->response_code);
        }

        return null;
    }
1332941
public function handleException($e)
    {
        if ($e instanceof Action) {
            return $this->error(Code::NOT_FOUND);
        }

        return $this->error($e->getCode(), $e->getMessage());
    }
106216
public function getError() : ?string 
    {
        if ( ! $this->hasError()) {
            $this->setError($this->getDefaultError());
        }
        return $this->error;
    }
1003804
protected function getError() {
		if ($this->_error === false) {
			if (is_resource($this->stmt)) {
				$this->_error = @oci_error($this->stmt);
			}
			else {
				$this->_error = @oci_error();
			}
		}

		return $this->_error;
	}
862158
public function errorAction() {
		$validationResults = $this->arguments->getValidationResults()->getFlattenedErrors();
		$result = array();
		/** @var \Neos\Error\Messages\Error  $validationResult */
		foreach ($validationResults as $key => $validationResult) {
			/** @var \Neos\Flow\Validation\Error $error */
			foreach ($validationResult as $error) {
				// Check Current Package Validation Errors
				$translatedMessage = $this->translator->translateById($error->getCode(), $error->getArguments(), NULL, NULL, 'ValidationErrors', $this->request->getControllerPackageKey());

				// Check Flow Validation Errors
				if ($translatedMessage === $error->getCode()) {
					$translatedMessage = $this->translator->translateById($error->getCode(), $error->getArguments(), NULL, NULL, 'ValidationErrors', 'Neos.Flow');
				}

				// Use default error message
				if ($translatedMessage === $error->getCode()) {
					$translatedMessage = $error->render();
				}

				$result['errors'][$key][] = array(
					'code' => $error->getCode(),
					'message' => $translatedMessage
				);
			}
		}
		$result['success'] = FALSE;
		$this->view->assign('value', $result);
		$this->response->setStatus(400);
	}
1177325
public function deleteAction()
    {
        // Check current user authorization
        if (null !== $response = $this->checkAuth(AdminResources::MODULE, Team::getModuleCode(),
                AccessManager::DELETE)
        ) {
            return $response;
        }

        $con = Propel::getConnection();
        $con->beginTransaction();
        try {
            // Check token
            $this->getTokenProvider()->checkToken(
                $this->getRequest()->query->get("_token")
            );

            $this->getService()->deleteFromId($this->getRequest()->request->get(static::CONTROLLER_ENTITY_NAME . "_id"));
            $con->commit();
            if ($response == null) {
                return $this->redirectToListTemplate();
            } else {
                return $response;
            }
        } catch (\Exception $e) {
            $con->rollBack();

            return $this->renderAfterDeleteError($e);
        }
    }
101419
public function error() {
        $error = $this->request->url(2);
        $error_layout = Config::get('Error.layout');
        $this->view->setLayout($error_layout ? $error_layout : 'error');
        
        if ( in_array($error, [500, 404]) ) {
            $this->response->defaultHeader($error);
            $this->view->setTemplate( is_file(PO_PATH_TEMPLATES . DS . 'error' . DS . 'error-' . $error . '.phtml') ? 
                    'error-' . $error : 'default', 'error');
        } else {
            $this->view->setTemplate('default', 'error');
        }
    }
55735
public function _error(){
		$model = new ViewModel('application/error');
		$model->addVariable('error_type','error');
		$model->addVariable('error',ErrorController::$errors);
		return $model;
	}
697997
public function _handleFailure()
    {
        if($this->isEnabled(self::TYPE_FAILURE))
        {
            $error = error_get_last();

            // Make sure error happened after we started handling them
            if ($error && md5(serialize($error)) !== $this->__last_unhandled_error)
            {
                $level = $error['type'];

                if ($this->getErrorReporting() & $level)
                {
                    $exception = new ExceptionFailure(
                        $error['message'], HttpResponse::INTERNAL_SERVER_ERROR, $level, $error['file'], $error['line']
                    );

                    $this->handleException($exception);
                }
            }
        }
    }
751571
protected function getError()
	{
		return $this->form->error(
			$this->model,
			$this->attribute,
			$this->errorOptions,
			$this->enableAjaxValidation,
			$this->enableClientValidation
		);
	}