Class luya\web\ErrorHandler

                public function __call($name, $params)
{
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $object) {
        if ($object->hasMethod($name)) {
            return call_user_func_array([$object, $name], $params);
        }
    }
    throw new UnknownMethodException('Calling unknown method: ' . get_class($this) . "::$name()");
}

            

                public function __clone()
{
    $this->_events = [];
    $this->_eventWildcards = [];
    $this->_behaviors = null;
}

            

                public function __construct($config = [])
{
    if (!empty($config)) {
        Yii::configure($this, $config);
    }
    $this->init();
}

            

                public function __get($name)
{
    $getter = 'get' . $name;
    if (method_exists($this, $getter)) {
        // read property, e.g. getName()
        return $this->$getter();
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canGetProperty($name)) {
            return $behavior->$name;
        }
    }
    if (method_exists($this, 'set' . $name)) {
        throw new InvalidCallException('Getting write-only property: ' . get_class($this) . '::' . $name);
    }
    throw new UnknownPropertyException('Getting unknown property: ' . get_class($this) . '::' . $name);
}

            

                public function __isset($name)
{
    $getter = 'get' . $name;
    if (method_exists($this, $getter)) {
        return $this->$getter() !== null;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canGetProperty($name)) {
            return $behavior->$name !== null;
        }
    }
    return false;
}

            

                public function __set($name, $value)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        // set property
        $this->$setter($value);
        return;
    } elseif (strncmp($name, 'on ', 3) === 0) {
        // on event: attach event handler
        $this->on(trim(substr($name, 3)), $value);
        return;
    } elseif (strncmp($name, 'as ', 3) === 0) {
        // as behavior: attach behavior
        $name = trim(substr($name, 3));
        $this->attachBehavior($name, $value instanceof Behavior ? $value : Yii::createObject($value));
        return;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canSetProperty($name)) {
            $behavior->$name = $value;
            return;
        }
    }
    if (method_exists($this, 'get' . $name)) {
        throw new InvalidCallException('Setting read-only property: ' . get_class($this) . '::' . $name);
    }
    throw new UnknownPropertyException('Setting unknown property: ' . get_class($this) . '::' . $name);
}

            

                public function __unset($name)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        $this->$setter(null);
        return;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canSetProperty($name)) {
            $behavior->$name = null;
            return;
        }
    }
    throw new InvalidCallException('Unsetting an unknown or read-only property: ' . get_class($this) . '::' . $name);
}

            

                public function addTypeLinks($code)
{
    if (preg_match('/(.*?)::([^(]+)/', $code, $matches)) {
        $class = $matches[1];
        $method = $matches[2];
        $text = $this->htmlEncode($class) . '::' . $this->htmlEncode($method);
    } else {
        $class = $code;
        $method = null;
        $text = $this->htmlEncode($class);
    }
    $url = null;
    $shouldGenerateLink = true;
    if ($method !== null && substr_compare($method, '{closure}', -9) !== 0) {
        $reflection = new \ReflectionClass($class);
        if ($reflection->hasMethod($method)) {
            $reflectionMethod = $reflection->getMethod($method);
            $shouldGenerateLink = $reflectionMethod->isPublic() || $reflectionMethod->isProtected();
        } else {
            $shouldGenerateLink = false;
        }
    }
    if ($shouldGenerateLink) {
        $url = $this->getTypeUrl($class, $method);
    }
    if ($url === null) {
        return $text;
    }
    return '<a href="' . $url . '" target="_blank">' . $text . '</a>';
}

            

                public function argumentsToString($args)
{
    $count = 0;
    $isAssoc = $args !== array_values($args);
    foreach ($args as $key => $value) {
        $count++;
        if ($count >= 5) {
            if ($count > 5) {
                unset($args[$key]);
            } else {
                $args[$key] = '...';
            }
            continue;
        }
        if (is_object($value)) {
            $args[$key] = '<span class="title">' . $this->htmlEncode(get_class($value)) . '</span>';
        } elseif (is_bool($value)) {
            $args[$key] = '<span class="keyword">' . ($value ? 'true' : 'false') . '</span>';
        } elseif (is_string($value)) {
            $fullValue = $this->htmlEncode($value);
            if (mb_strlen($value, 'UTF-8') > 32) {
                $displayValue = $this->htmlEncode(mb_substr($value, 0, 32, 'UTF-8')) . '...';
                $args[$key] = "<span class=\"string\" title=\"$fullValue\">'$displayValue'</span>";
            } else {
                $args[$key] = "<span class=\"string\">'$fullValue'</span>";
            }
        } elseif (is_array($value)) {
            $args[$key] = '[' . $this->argumentsToString($value) . ']';
        } elseif ($value === null) {
            $args[$key] = '<span class="keyword">null</span>';
        } elseif (is_resource($value)) {
            $args[$key] = '<span class="keyword">resource</span>';
        } else {
            $args[$key] = '<span class="number">' . $value . '</span>';
        }
        if (is_string($key)) {
            $args[$key] = '<span class="string">\'' . $this->htmlEncode($key) . "'</span> => $args[$key]";
        } elseif ($isAssoc) {
            $args[$key] = "<span class=\"number\">$key</span> => $args[$key]";
        }
    }
    return implode(', ', $args);
}

            

                public function attachBehavior($name, $behavior)
{
    $this->ensureBehaviors();
    return $this->attachBehaviorInternal($name, $behavior);
}

            

                public function attachBehaviors($behaviors)
{
    $this->ensureBehaviors();
    foreach ($behaviors as $name => $behavior) {
        $this->attachBehaviorInternal($name, $behavior);
    }
}

            

                public function behaviors()
{
    return [];
}

            

                public function canGetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if (method_exists($this, 'get' . $name) || $checkVars && property_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->canGetProperty($name, $checkVars)) {
                return true;
            }
        }
    }
    return false;
}

            

                public function canSetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if (method_exists($this, 'set' . $name) || $checkVars && property_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->canSetProperty($name, $checkVars)) {
                return true;
            }
        }
    }
    return false;
}

            

                public static function className()
{
    return get_called_class();
}

            

                public function clearOutput()
{
    // the following manual level counting is to deal with zlib.output_compression set to On
    for ($level = ob_get_level(); $level > 0; --$level) {
        if (!@ob_end_clean()) {
            ob_clean();
        }
    }
}

            

                protected function convertExceptionToArray($exception)
{
    if (!YII_DEBUG && !$exception instanceof UserException && !$exception instanceof HttpException) {
        $exception = new HttpException(500, Yii::t('yii', 'An internal server error occurred.'));
    }
    $array = [
        'name' => ($exception instanceof Exception || $exception instanceof ErrorException) ? $exception->getName() : 'Exception',
        'message' => $exception->getMessage(),
        'code' => $exception->getCode(),
    ];
    if ($exception instanceof HttpException) {
        $array['status'] = $exception->statusCode;
    }
    if (YII_DEBUG) {
        $array['type'] = get_class($exception);
        if (!$exception instanceof UserException) {
            $array['file'] = $exception->getFile();
            $array['line'] = $exception->getLine();
            $array['stack-trace'] = explode("\n", $exception->getTraceAsString());
            if ($exception instanceof \yii\db\Exception) {
                $array['error-info'] = $exception->errorInfo;
            }
        }
    }
    if (($prev = $exception->getPrevious()) !== null) {
        $array['previous'] = $this->convertExceptionToArray($prev);
    }
    return $array;
}

            

                public static function convertExceptionToError($exception)
{
    trigger_error(static::convertExceptionToString($exception), E_USER_ERROR);
}

            

                public static function convertExceptionToString($exception)
{
    if ($exception instanceof UserException) {
        return "{$exception->getName()}: {$exception->getMessage()}";
    }
    if (YII_DEBUG) {
        return static::convertExceptionToVerboseString($exception);
    }
    return 'An internal server error occurred.';
}

            

                public static function convertExceptionToVerboseString($exception)
{
    if ($exception instanceof Exception) {
        $message = "Exception ({$exception->getName()})";
    } elseif ($exception instanceof ErrorException) {
        $message = (string)$exception->getName();
    } else {
        $message = 'Exception';
    }
    $message .= " '" . get_class($exception) . "' with message '{$exception->getMessage()}' \n\nin "
        . $exception->getFile() . ':' . $exception->getLine() . "\n\n"
        . "Stack trace:\n" . $exception->getTraceAsString();
    return $message;
}

            

                public function createFrameworkVersionLink()
{
    return '<a href="https://github.com/yiisoft/yii2/" target="_blank">' . $this->htmlEncode(Yii::getVersion()) . '</a>';
}

            

                public function createHttpStatusLink($statusCode, $statusDescription)
{
    return '<a href="https://en.wikipedia.org/wiki/List_of_HTTP_status_codes#' . (int) $statusCode . '" target="_blank">HTTP ' . (int) $statusCode . ' &ndash; ' . $statusDescription . '</a>';
}

            

                public function createServerInformationLink()
{
    $serverUrls = [
        'https://httpd.apache.org/' => ['apache'],
        'https://nginx.org/' => ['nginx'],
        'https://www.lighttpd.net/' => ['lighttpd'],
        'http://gwan.com/' => ['g-wan', 'gwan'],
        'https://www.iis.net/' => ['iis', 'services'],
        'https://www.php.net/manual/en/features.commandline.webserver.php' => ['development'],
    ];
    if (isset($_SERVER['SERVER_SOFTWARE'])) {
        foreach ($serverUrls as $url => $keywords) {
            foreach ($keywords as $keyword) {
                if (stripos($_SERVER['SERVER_SOFTWARE'], $keyword) !== false) {
                    return '<a href="' . $url . '" target="_blank">' . $this->htmlEncode($_SERVER['SERVER_SOFTWARE']) . '</a>';
                }
            }
        }
    }
    return '';
}

            

                public function detachBehavior($name)
{
    $this->ensureBehaviors();
    if (isset($this->_behaviors[$name])) {
        $behavior = $this->_behaviors[$name];
        unset($this->_behaviors[$name]);
        $behavior->detach();
        return $behavior;
    }
    return null;
}

            

                public function detachBehaviors()
{
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $name => $behavior) {
        $this->detachBehavior($name);
    }
}

            

                public function ensureBehaviors()
{
    if ($this->_behaviors === null) {
        $this->_behaviors = [];
        foreach ($this->behaviors() as $name => $behavior) {
            $this->attachBehaviorInternal($name, $behavior);
        }
    }
}

            

                public function getBehavior($name)
{
    $this->ensureBehaviors();
    return isset($this->_behaviors[$name]) ? $this->_behaviors[$name] : null;
}

            

                public function getBehaviors()
{
    $this->ensureBehaviors();
    return $this->_behaviors;
}

            

                public function getExceptionArray($exception)
{
    $_message = 'Uknonwn exception object, not instance of \Exception.';
    $_file = 'unknown';
    $_line = 0;
    $_trace = [];
    $_previousException = [];
    $_exceptionClassName = 'Unknown';
    
    if (is_object($exception)) {
        $_exceptionClassName = get_class($exception);
        $prev = $exception->getPrevious();
        
        if (!empty($prev)) {
            $_previousException = [
                'message' => $prev->getMessage(),
                'file' => $prev->getFile(),
                'line' => $prev->getLine(),
                'trace' => $this->buildTrace($prev),
            ];
        }
        
        $_trace = $this->buildTrace($exception);
        $_message = $exception->getMessage();
        $_file = $exception->getFile();
        $_line = $exception->getLine();
    } elseif (is_string($exception)) {
        $_message = 'exception string: ' . $exception;
    } elseif (is_array($exception)) {
        $_message = isset($exception['message']) ? $exception['message'] : 'exception array dump: ' . print_r($exception, true);
        $_file = isset($exception['file']) ? $exception['file'] : __FILE__;
        $_line = isset($exception['line']) ? $exception['line'] : __LINE__;
    }
    $exceptionName = 'Exception';
    if ($exception instanceof Exception) {
        $exceptionName = $exception->getName();
    } elseif ($exception instanceof ErrorException) {
        $exceptionName = $exception->getName();
    }
    return [
        'message' => $_message,
        'file' => $_file,
        'line' => $_line,
        'requestUri' => isset($_SERVER['REQUEST_URI']) ? $_SERVER['REQUEST_URI'] : null,
        'serverName' => isset($_SERVER['SERVER_NAME']) ? $_SERVER['SERVER_NAME'] : null,
        'date' => date('d.m.Y H:i'),
        'trace' => $_trace,
        'previousException' => $_previousException,
        'ip' => isset($_SERVER['REMOTE_ADDR']) ? $_SERVER['REMOTE_ADDR'] : null,
        'get' => isset($_GET) ? ArrayHelper::coverSensitiveValues($_GET, $this->sensitiveKeys) : [],
        'post' => isset($_POST) ? ArrayHelper::coverSensitiveValues($_POST, $this->sensitiveKeys) : [],
        'bodyParams' => Yii::$app instanceof Application ? ArrayHelper::coverSensitiveValues(Yii::$app->request->bodyParams) : [],
        'session' => isset($_SESSION) ? ArrayHelper::coverSensitiveValues($_SESSION, $this->sensitiveKeys) : [],
        'server' => isset($_SERVER) ? ArrayHelper::coverSensitiveValues($_SERVER, $this->sensitiveKeys) : [],
        // since 1.0.20
        'yii_debug' => YII_DEBUG,
        'yii_env' => YII_ENV,
        'status_code' => $exception instanceof HttpException ? $exception->statusCode : 500,
        'exception_name' => $exceptionName,
        'exception_class_name' => $_exceptionClassName,
        'php_version' => phpversion(),
        'luya_version' => Boot::VERSION,
        'yii_version' => Yii::getVersion(),
        'app_version' => Yii::$app->version,
    ];
}

            

                public function getExceptionName($exception)
{
    if ($exception instanceof \yii\base\Exception || $exception instanceof \yii\base\InvalidCallException || $exception instanceof \yii\base\InvalidParamException || $exception instanceof \yii\base\UnknownMethodException) {
        return $exception->getName();
    }
    return null;
}

            

                protected function getTypeUrl($class, $method)
{
    if (strncmp($class, 'yii\\', 4) !== 0) {
        return null;
    }
    $page = $this->htmlEncode(strtolower(str_replace('\\', '-', $class)));
    $url = "https://www.yiiframework.com/doc-2.0/$page.html";
    if ($method) {
        $url .= "#$method()-detail";
    }
    return $url;
}

            

                public function handleError($code, $message, $file, $line)
{
    if (error_reporting() & $code) {
        // load ErrorException manually here because autoloading them will not work
        // when error occurs while autoloading a class
        if (!class_exists('yii\\base\\ErrorException', false)) {
            require_once __DIR__ . '/ErrorException.php';
        }
        $exception = new ErrorException($message, $code, $code, $file, $line);
        if (PHP_VERSION_ID < 70400) {
            // prior to PHP 7.4 we can't throw exceptions inside of __toString() - it will result a fatal error
            $trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);
            array_shift($trace);
            foreach ($trace as $frame) {
                if ($frame['function'] === '__toString') {
                    $this->handleException($exception);
                    if (defined('HHVM_VERSION')) {
                        flush();
                    }
                    exit(1);
                }
            }
        }
        throw $exception;
    }
    return false;
}

            

                public function handleException($exception)
{
    if ($exception instanceof ExitException) {
        return;
    }
    $this->exception = $exception;
    // disable error capturing to avoid recursive errors while handling exceptions
    $this->unregister();
    // set preventive HTTP status code to 500 in case error handling somehow fails and headers are sent
    // HTTP exceptions will override this value in renderException()
    if (PHP_SAPI !== 'cli') {
        http_response_code(500);
    }
    try {
        $this->logException($exception);
        if ($this->discardExistingOutput) {
            $this->clearOutput();
        }
        $this->renderException($exception);
        if (!$this->silentExitOnException) {
            \Yii::getLogger()->flush(true);
            if (defined('HHVM_VERSION')) {
                flush();
            }
            exit(1);
        }
    } catch (\Exception $e) {
        // an other exception could be thrown while displaying the exception
        $this->handleFallbackExceptionMessage($e, $exception);
    } catch (\Throwable $e) {
        // additional check for \Throwable introduced in PHP 7
        $this->handleFallbackExceptionMessage($e, $exception);
    }
    $this->exception = null;
}

            

                protected function handleFallbackExceptionMessage($exception, $previousException)
{
    $msg = "An Error occurred while handling another error:\n";
    $msg .= (string) $exception;
    $msg .= "\nPrevious exception:\n";
    $msg .= (string) $previousException;
    if (YII_DEBUG) {
        if (PHP_SAPI === 'cli') {
            echo $msg . "\n";
        } else {
            echo '<pre>' . htmlspecialchars($msg, ENT_QUOTES, Yii::$app->charset) . '</pre>';
        }
        $msg .= "\n\$_SERVER = " . VarDumper::export($_SERVER);
    } else {
        echo 'An internal server error occurred.';
    }
    error_log($msg);
    if (defined('HHVM_VERSION')) {
        flush();
    }
    exit(1);
}

            

                public function handleFatalError()
{
    unset($this->_memoryReserve);
    if (isset($this->_workingDirectory)) {
        // fix working directory for some Web servers e.g. Apache
        chdir($this->_workingDirectory);
        // flush memory
        unset($this->_workingDirectory);
    }
    $error = error_get_last();
    if ($error === null) {
        return;
    }
    // load ErrorException manually here because autoloading them will not work
    // when error occurs while autoloading a class
    if (!class_exists('yii\\base\\ErrorException', false)) {
        require_once __DIR__ . '/ErrorException.php';
    }
    if (!ErrorException::isFatalError($error)) {
        return;
    }
    if (!empty($this->_hhvmException)) {
        $this->exception = $this->_hhvmException;
    } else {
        $this->exception = new ErrorException(
            $error['message'],
            $error['type'],
            $error['type'],
            $error['file'],
            $error['line']
        );
    }
    unset($error);
    $this->logException($this->exception);
    if ($this->discardExistingOutput) {
        $this->clearOutput();
    }
    $this->renderException($this->exception);
    // need to explicitly flush logs because exit() next will terminate the app immediately
    Yii::getLogger()->flush(true);
    if (defined('HHVM_VERSION')) {
        flush();
    }
    $this->trigger(static::EVENT_SHUTDOWN);
    // ensure it is called after user-defined shutdown functions
    register_shutdown_function(function () {
        exit(1);
    });
}

            

                public function handleHhvmError($code, $message, $file, $line, $context, $backtrace)
{
    if ($this->handleError($code, $message, $file, $line)) {
        return true;
    }
    if (E_ERROR & $code) {
        $exception = new ErrorException($message, $code, $code, $file, $line);
        $ref = new \ReflectionProperty('\Exception', 'trace');
        $ref->setAccessible(true);
        $ref->setValue($exception, $backtrace);
        $this->_hhvmException = $exception;
    }
    return false;
}

            

                public function hasEventHandlers($name)
{
    $this->ensureBehaviors();
    if (!empty($this->_events[$name])) {
        return true;
    }
    foreach ($this->_eventWildcards as $wildcard => $handlers) {
        if (!empty($handlers) && StringHelper::matchWildcard($wildcard, $name)) {
            return true;
        }
    }
    return Event::hasHandlers($this, $name);
}

            

                public function hasMethod($name, $checkBehaviors = true)
{
    if (method_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->hasMethod($name)) {
                return true;
            }
        }
    }
    return false;
}

            

                public function hasProperty($name, $checkVars = true, $checkBehaviors = true)
{
    return $this->canGetProperty($name, $checkVars, $checkBehaviors) || $this->canSetProperty($name, false, $checkBehaviors);
}

            

                public function htmlEncode($text)
{
    return htmlspecialchars($text, ENT_NOQUOTES | ENT_SUBSTITUTE | ENT_HTML5, 'UTF-8');
}

            

                public function init()
{
    $this->silentExitOnException = $this->silentExitOnException !== null ? $this->silentExitOnException : YII_ENV_TEST;
    parent::init();
}

            

                public function isCoreFile($file)
{
    return $file === null || strpos(realpath($file), YII2_PATH . DIRECTORY_SEPARATOR) === 0;
}

            

                public function isExceptionWhitelisted($exception)
{
    if (!is_object($exception)) {
        return false;
    }
    if (ObjectHelper::isInstanceOf($exception, WhitelistedException::class, false)) {
        return true;
    }
    return ObjectHelper::isInstanceOf($exception, $this->whitelist, false);
}

            

                public function logException($exception)
{
    $category = get_class($exception);
    if ($exception instanceof HttpException) {
        $category = 'yii\\web\\HttpException:' . $exception->statusCode;
    } elseif ($exception instanceof \ErrorException) {
        $category .= ':' . $exception->getSeverity();
    }
    Yii::error($exception, $category);
}

            

                public function off($name, $handler = null)
{
    $this->ensureBehaviors();
    if (empty($this->_events[$name]) && empty($this->_eventWildcards[$name])) {
        return false;
    }
    if ($handler === null) {
        unset($this->_events[$name], $this->_eventWildcards[$name]);
        return true;
    }
    $removed = false;
    // plain event names
    if (isset($this->_events[$name])) {
        foreach ($this->_events[$name] as $i => $event) {
            if ($event[0] === $handler) {
                unset($this->_events[$name][$i]);
                $removed = true;
            }
        }
        if ($removed) {
            $this->_events[$name] = array_values($this->_events[$name]);
            return true;
        }
    }
    // wildcard event names
    if (isset($this->_eventWildcards[$name])) {
        foreach ($this->_eventWildcards[$name] as $i => $event) {
            if ($event[0] === $handler) {
                unset($this->_eventWildcards[$name][$i]);
                $removed = true;
            }
        }
        if ($removed) {
            $this->_eventWildcards[$name] = array_values($this->_eventWildcards[$name]);
            // remove empty wildcards to save future redundant regex checks:
            if (empty($this->_eventWildcards[$name])) {
                unset($this->_eventWildcards[$name]);
            }
        }
    }
    return $removed;
}

            

                public function on($name, $handler, $data = null, $append = true)
{
    $this->ensureBehaviors();
    if (strpos($name, '*') !== false) {
        if ($append || empty($this->_eventWildcards[$name])) {
            $this->_eventWildcards[$name][] = [$handler, $data];
        } else {
            array_unshift($this->_eventWildcards[$name], [$handler, $data]);
        }
        return;
    }
    if ($append || empty($this->_events[$name])) {
        $this->_events[$name][] = [$handler, $data];
    } else {
        array_unshift($this->_events[$name], [$handler, $data]);
    }
}

            

                public function register()
{
    if (!$this->_registered) {
        ini_set('display_errors', false);
        set_exception_handler([$this, 'handleException']);
        if (defined('HHVM_VERSION')) {
            set_error_handler([$this, 'handleHhvmError']);
        } else {
            set_error_handler([$this, 'handleError']);
        }
        if ($this->memoryReserveSize > 0) {
            $this->_memoryReserve = str_pad('', $this->memoryReserveSize, 'x');
        }
        // to restore working directory in shutdown handler
        if (PHP_SAPI !== 'cli') {
            $this->_workingDirectory = getcwd();
        }
        register_shutdown_function([$this, 'handleFatalError']);
        $this->_registered = true;
    }
}

            

                public function renderCallStack($exception)
{
    $out = '<ul>';
    $out .= $this->renderCallStackItem($exception->getFile(), $exception->getLine(), null, null, [], 1);
    for ($i = 0, $trace = $exception->getTrace(), $length = count($trace); $i < $length; ++$i) {
        $file = !empty($trace[$i]['file']) ? $trace[$i]['file'] : null;
        $line = !empty($trace[$i]['line']) ? $trace[$i]['line'] : null;
        $class = !empty($trace[$i]['class']) ? $trace[$i]['class'] : null;
        $function = null;
        if (!empty($trace[$i]['function']) && $trace[$i]['function'] !== 'unknown') {
            $function = $trace[$i]['function'];
        }
        $args = !empty($trace[$i]['args']) ? $trace[$i]['args'] : [];
        $out .= $this->renderCallStackItem($file, $line, $class, $function, $args, $i + 2);
    }
    $out .= '</ul>';
    return $out;
}

            

                public function renderCallStackItem($file, $line, $class, $method, $args, $index)
{
    $lines = [];
    $begin = $end = 0;
    if ($file !== null && $line !== null) {
        $line--; // adjust line number from one-based to zero-based
        $lines = @file($file);
        if ($line < 0 || $lines === false || ($lineCount = count($lines)) < $line) {
            return '';
        }
        $half = (int) (($index === 1 ? $this->maxSourceLines : $this->maxTraceSourceLines) / 2);
        $begin = $line - $half > 0 ? $line - $half : 0;
        $end = $line + $half < $lineCount ? $line + $half : $lineCount - 1;
    }
    return $this->renderFile($this->callStackItemView, [
        'file' => $file,
        'line' => $line,
        'class' => $class,
        'method' => $method,
        'index' => $index,
        'lines' => $lines,
        'begin' => $begin,
        'end' => $end,
        'args' => $args,
    ]);
}

            

                public function renderFile($_file_, $_params_)
{
    $_params_['handler'] = $this;
    if ($this->exception instanceof ErrorException || !Yii::$app->has('view')) {
        ob_start();
        ob_implicit_flush(false);
        extract($_params_, EXTR_OVERWRITE);
        require Yii::getAlias($_file_);
        return ob_get_clean();
    }
    $view = Yii::$app->getView();
    $view->clear();
    return $view->renderFile($_file_, $_params_, $this);
}

            

                public function renderPreviousExceptions($exception)
{
    if (($previous = $exception->getPrevious()) !== null) {
        return $this->renderFile($this->previousExceptionView, ['exception' => $previous]);
    }
    return '';
}

            

                public function renderRequest()
{
    $request = '';
    foreach ($this->displayVars as $name) {
        if (!empty($GLOBALS[$name])) {
            $request .= '$' . $name . ' = ' . VarDumper::export($GLOBALS[$name]) . ";\n\n";
        }
    }
    return '<pre>' . $this->htmlEncode(rtrim($request, "\n")) . '</pre>';
}

            

                protected function shouldRenderSimpleHtml()
{
    return YII_ENV_TEST || Yii::$app->request->getIsAjax();
}

            

                public function transferMessage($message, $file = __FILE__, $line = __LINE__)
{
    return $this->apiServerSendData($this->getExceptionArray([
        'message' => $message,
        'file' => $file,
        'line' => $line,
    ]));
}

            

                public function trigger($name, Event $event = null)
{
    $this->ensureBehaviors();
    $eventHandlers = [];
    foreach ($this->_eventWildcards as $wildcard => $handlers) {
        if (StringHelper::matchWildcard($wildcard, $name)) {
            $eventHandlers[] = $handlers;
        }
    }
    if (!empty($this->_events[$name])) {
        $eventHandlers[] = $this->_events[$name];
    }
    if (!empty($eventHandlers)) {
        $eventHandlers = call_user_func_array('array_merge', $eventHandlers);
        if ($event === null) {
            $event = new Event();
        }
        if ($event->sender === null) {
            $event->sender = $this;
        }
        $event->handled = false;
        $event->name = $name;
        foreach ($eventHandlers as $handler) {
            $event->data = $handler[1];
            call_user_func($handler[0], $event);
            // stop further handling if the event is handled
            if ($event->handled) {
                return;
            }
        }
    }
    // invoke class-level attached handlers
    Event::trigger($this, $name, $event);
}

            

                public function unregister()
{
    if ($this->_registered) {
        $this->_memoryReserve = null;
        $this->_workingDirectory = null;
        restore_error_handler();
        restore_exception_handler();
        $this->_registered = false;
    }
}