<form method="POST">
    <h3>Editing: FlattenException.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier &lt;fabien@symfony.com&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Symfony\Component\ErrorHandler\Exception;

use Symfony\Component\HttpFoundation\Exception\RequestExceptionInterface;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Exception\HttpExceptionInterface;

/**
 * FlattenException wraps a PHP Error or Exception to be able to serialize it.
 *
 * Basically, this class removes all objects from the trace.
 *
 * @author Fabien Potencier &lt;fabien@symfony.com&gt;
 */
class FlattenException
{
    /** @var string */
    private $message;

    /** @var int|string */
    private $code;

    /** @var self|null */
    private $previous;

    /** @var array */
    private $trace;

    /** @var string */
    private $traceAsString;

    /** @var string */
    private $class;

    /** @var int */
    private $statusCode;

    /** @var string */
    private $statusText;

    /** @var array */
    private $headers;

    /** @var string */
    private $file;

    /** @var int */
    private $line;

    /** @var string|null */
    private $asString;

    /**
     * @return static
     */
    public static function create(\Exception $exception, ?int $statusCode = null, array $headers = []): self
    {
        return static::createFromThrowable($exception, $statusCode, $headers);
    }

    /**
     * @return static
     */
    public static function createFromThrowable(\Throwable $exception, ?int $statusCode = null, array $headers = []): self
    {
        $e = new static();
        $e-&gt;setMessage($exception-&gt;getMessage());
        $e-&gt;setCode($exception-&gt;getCode());

        if ($exception instanceof HttpExceptionInterface) {
            $statusCode = $exception-&gt;getStatusCode();
            $headers = array_merge($headers, $exception-&gt;getHeaders());
        } elseif ($exception instanceof RequestExceptionInterface) {
            $statusCode = 400;
        }

        if (null === $statusCode) {
            $statusCode = 500;
        }

        if (class_exists(Response::class) &amp;&amp; isset(Response::$statusTexts[$statusCode])) {
            $statusText = Response::$statusTexts[$statusCode];
        } else {
            $statusText = 'Whoops, looks like something went wrong.';
        }

        $e-&gt;setStatusText($statusText);
        $e-&gt;setStatusCode($statusCode);
        $e-&gt;setHeaders($headers);
        $e-&gt;setTraceFromThrowable($exception);
        $e-&gt;setClass(\get_class($exception));
        $e-&gt;setFile($exception-&gt;getFile());
        $e-&gt;setLine($exception-&gt;getLine());

        $previous = $exception-&gt;getPrevious();

        if ($previous instanceof \Throwable) {
            $e-&gt;setPrevious(static::createFromThrowable($previous));
        }

        return $e;
    }

    public function toArray(): array
    {
        $exceptions = [];
        foreach (array_merge([$this], $this-&gt;getAllPrevious()) as $exception) {
            $exceptions[] = [
                'message' =&gt; $exception-&gt;getMessage(),
                'class' =&gt; $exception-&gt;getClass(),
                'trace' =&gt; $exception-&gt;getTrace(),
            ];
        }

        return $exceptions;
    }

    public function getStatusCode(): int
    {
        return $this-&gt;statusCode;
    }

    /**
     * @return $this
     */
    public function setStatusCode(int $code): self
    {
        $this-&gt;statusCode = $code;

        return $this;
    }

    public function getHeaders(): array
    {
        return $this-&gt;headers;
    }

    /**
     * @return $this
     */
    public function setHeaders(array $headers): self
    {
        $this-&gt;headers = $headers;

        return $this;
    }

    public function getClass(): string
    {
        return $this-&gt;class;
    }

    /**
     * @return $this
     */
    public function setClass(string $class): self
    {
        $this-&gt;class = false !== strpos($class, &quot;@anonymous\0&quot;) ? (get_parent_class($class) ?: key(class_implements($class)) ?: 'class').'@anonymous' : $class;

        return $this;
    }

    public function getFile(): string
    {
        return $this-&gt;file;
    }

    /**
     * @return $this
     */
    public function setFile(string $file): self
    {
        $this-&gt;file = $file;

        return $this;
    }

    public function getLine(): int
    {
        return $this-&gt;line;
    }

    /**
     * @return $this
     */
    public function setLine(int $line): self
    {
        $this-&gt;line = $line;

        return $this;
    }

    public function getStatusText(): string
    {
        return $this-&gt;statusText;
    }

    /**
     * @return $this
     */
    public function setStatusText(string $statusText): self
    {
        $this-&gt;statusText = $statusText;

        return $this;
    }

    public function getMessage(): string
    {
        return $this-&gt;message;
    }

    /**
     * @return $this
     */
    public function setMessage(string $message): self
    {
        if (false !== strpos($message, &quot;@anonymous\0&quot;)) {
            $message = preg_replace_callback('/[a-zA-Z_\x7f-\xff][\\\\a-zA-Z0-9_\x7f-\xff]*+@anonymous\x00.*?\.php(?:0x?|:[0-9]++\$)[0-9a-fA-F]++/', function ($m) {
                return class_exists($m[0], false) ? (get_parent_class($m[0]) ?: key(class_implements($m[0])) ?: 'class').'@anonymous' : $m[0];
            }, $message);
        }

        $this-&gt;message = $message;

        return $this;
    }

    /**
     * @return int|string int most of the time (might be a string with PDOException)
     */
    public function getCode()
    {
        return $this-&gt;code;
    }

    /**
     * @param int|string $code
     *
     * @return $this
     */
    public function setCode($code): self
    {
        $this-&gt;code = $code;

        return $this;
    }

    public function getPrevious(): ?self
    {
        return $this-&gt;previous;
    }

    /**
     * @return $this
     */
    public function setPrevious(?self $previous): self
    {
        $this-&gt;previous = $previous;

        return $this;
    }

    /**
     * @return self[]
     */
    public function getAllPrevious(): array
    {
        $exceptions = [];
        $e = $this;
        while ($e = $e-&gt;getPrevious()) {
            $exceptions[] = $e;
        }

        return $exceptions;
    }

    public function getTrace(): array
    {
        return $this-&gt;trace;
    }

    /**
     * @return $this
     */
    public function setTraceFromThrowable(\Throwable $throwable): self
    {
        $this-&gt;traceAsString = $throwable-&gt;getTraceAsString();

        return $this-&gt;setTrace($throwable-&gt;getTrace(), $throwable-&gt;getFile(), $throwable-&gt;getLine());
    }

    /**
     * @return $this
     */
    public function setTrace(array $trace, ?string $file, ?int $line): self
    {
        $this-&gt;trace = [];
        $this-&gt;trace[] = [
            'namespace' =&gt; '',
            'short_class' =&gt; '',
            'class' =&gt; '',
            'type' =&gt; '',
            'function' =&gt; '',
            'file' =&gt; $file,
            'line' =&gt; $line,
            'args' =&gt; [],
        ];
        foreach ($trace as $entry) {
            $class = '';
            $namespace = '';
            if (isset($entry['class'])) {
                $parts = explode('\\', $entry['class']);
                $class = array_pop($parts);
                $namespace = implode('\\', $parts);
            }

            $this-&gt;trace[] = [
                'namespace' =&gt; $namespace,
                'short_class' =&gt; $class,
                'class' =&gt; $entry['class'] ?? '',
                'type' =&gt; $entry['type'] ?? '',
                'function' =&gt; $entry['function'] ?? null,
                'file' =&gt; $entry['file'] ?? null,
                'line' =&gt; $entry['line'] ?? null,
                'args' =&gt; isset($entry['args']) ? $this-&gt;flattenArgs($entry['args']) : [],
            ];
        }

        return $this;
    }

    private function flattenArgs(array $args, int $level = 0, int &amp;$count = 0): array
    {
        $result = [];
        foreach ($args as $key =&gt; $value) {
            if (++$count &gt; 1e4) {
                return ['array', '*SKIPPED over 10000 entries*'];
            }
            if ($value instanceof \__PHP_Incomplete_Class) {
                $result[$key] = ['incomplete-object', $this-&gt;getClassNameFromIncomplete($value)];
            } elseif (\is_object($value)) {
                $result[$key] = ['object', \get_class($value)];
            } elseif (\is_array($value)) {
                if ($level &gt; 10) {
                    $result[$key] = ['array', '*DEEP NESTED ARRAY*'];
                } else {
                    $result[$key] = ['array', $this-&gt;flattenArgs($value, $level + 1, $count)];
                }
            } elseif (null === $value) {
                $result[$key] = ['null', null];
            } elseif (\is_bool($value)) {
                $result[$key] = ['boolean', $value];
            } elseif (\is_int($value)) {
                $result[$key] = ['integer', $value];
            } elseif (\is_float($value)) {
                $result[$key] = ['float', $value];
            } elseif (\is_resource($value)) {
                $result[$key] = ['resource', get_resource_type($value)];
            } else {
                $result[$key] = ['string', (string) $value];
            }
        }

        return $result;
    }

    private function getClassNameFromIncomplete(\__PHP_Incomplete_Class $value): string
    {
        $array = new \ArrayObject($value);

        return $array['__PHP_Incomplete_Class_Name'];
    }

    public function getTraceAsString(): string
    {
        return $this-&gt;traceAsString;
    }

    /**
     * @return $this
     */
    public function setAsString(?string $asString): self
    {
        $this-&gt;asString = $asString;

        return $this;
    }

    public function getAsString(): string
    {
        if (null !== $this-&gt;asString) {
            return $this-&gt;asString;
        }

        $message = '';
        $next = false;

        foreach (array_reverse(array_merge([$this], $this-&gt;getAllPrevious())) as $exception) {
            if ($next) {
                $message .= 'Next ';
            } else {
                $next = true;
            }
            $message .= $exception-&gt;getClass();

            if ('' != $exception-&gt;getMessage()) {
                $message .= ': '.$exception-&gt;getMessage();
            }

            $message .= ' in '.$exception-&gt;getFile().':'.$exception-&gt;getLine().
                &quot;\nStack trace:\n&quot;.$exception-&gt;getTraceAsString().&quot;\n\n&quot;;
        }

        return rtrim($message);
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>