<form method="POST">
    <h3>Editing: CompiledUrlMatcherDumper.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\Routing\Matcher\Dumper;

use Symfony\Component\ExpressionLanguage\ExpressionFunctionProviderInterface;
use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
use Symfony\Component\Routing\Route;
use Symfony\Component\Routing\RouteCollection;

/**
 * CompiledUrlMatcherDumper creates PHP arrays to be used with CompiledUrlMatcher.
 *
 * @author Fabien Potencier &lt;fabien@symfony.com&gt;
 * @author Tobias Schultze &lt;http://tobion.de&gt;
 * @author Arnaud Le Blanc &lt;arnaud.lb@gmail.com&gt;
 * @author Nicolas Grekas &lt;p@tchwork.com&gt;
 */
class CompiledUrlMatcherDumper extends MatcherDumper
{
    private $expressionLanguage;
    private $signalingException;

    /**
     * @var ExpressionFunctionProviderInterface[]
     */
    private $expressionLanguageProviders = [];

    /**
     * {@inheritdoc}
     */
    public function dump(array $options = [])
    {
        return &lt;&lt;&lt;EOF
&lt;?php

/**
 * This file has been auto-generated
 * by the Symfony Routing Component.
 */

return [
{$this-&gt;generateCompiledRoutes()}];

EOF;
    }

    public function addExpressionLanguageProvider(ExpressionFunctionProviderInterface $provider)
    {
        $this-&gt;expressionLanguageProviders[] = $provider;
    }

    /**
     * Generates the arrays for CompiledUrlMatcher's constructor.
     */
    public function getCompiledRoutes(bool $forDump = false): array
    {
        // Group hosts by same-suffix, re-order when possible
        $matchHost = false;
        $routes = new StaticPrefixCollection();
        foreach ($this-&gt;getRoutes()-&gt;all() as $name =&gt; $route) {
            if ($host = $route-&gt;getHost()) {
                $matchHost = true;
                $host = '/'.strtr(strrev($host), '}.{', '(/)');
            }

            $routes-&gt;addRoute($host ?: '/(.*)', [$name, $route]);
        }

        if ($matchHost) {
            $compiledRoutes = [true];
            $routes = $routes-&gt;populateCollection(new RouteCollection());
        } else {
            $compiledRoutes = [false];
            $routes = $this-&gt;getRoutes();
        }

        [$staticRoutes, $dynamicRoutes] = $this-&gt;groupStaticRoutes($routes);

        $conditions = [null];
        $compiledRoutes[] = $this-&gt;compileStaticRoutes($staticRoutes, $conditions);
        $chunkLimit = \count($dynamicRoutes);

        while (true) {
            try {
                $this-&gt;signalingException = new \RuntimeException('Compilation failed: regular expression is too large');
                $compiledRoutes = array_merge($compiledRoutes, $this-&gt;compileDynamicRoutes($dynamicRoutes, $matchHost, $chunkLimit, $conditions));

                break;
            } catch (\Exception $e) {
                if (1 &lt; $chunkLimit &amp;&amp; $this-&gt;signalingException === $e) {
                    $chunkLimit = 1 + ($chunkLimit &gt;&gt; 1);
                    continue;
                }
                throw $e;
            }
        }

        if ($forDump) {
            $compiledRoutes[2] = $compiledRoutes[4];
        }
        unset($conditions[0]);

        if ($conditions) {
            foreach ($conditions as $expression =&gt; $condition) {
                $conditions[$expression] = &quot;case {$condition}: return {$expression};&quot;;
            }

            $checkConditionCode = &lt;&lt;&lt;EOF
    static function (\$condition, \$context, \$request) { // \$checkCondition
        switch (\$condition) {
{$this-&gt;indent(implode(&quot;\n&quot;, $conditions), 3)}
        }
    }
EOF;
            $compiledRoutes[4] = $forDump ? $checkConditionCode.&quot;,\n&quot; : eval('return '.$checkConditionCode.';');
        } else {
            $compiledRoutes[4] = $forDump ? &quot;    null, // \$checkCondition\n&quot; : null;
        }

        return $compiledRoutes;
    }

    private function generateCompiledRoutes(): string
    {
        [$matchHost, $staticRoutes, $regexpCode, $dynamicRoutes, $checkConditionCode] = $this-&gt;getCompiledRoutes(true);

        $code = self::export($matchHost).', // $matchHost'.&quot;\n&quot;;

        $code .= '[ // $staticRoutes'.&quot;\n&quot;;
        foreach ($staticRoutes as $path =&gt; $routes) {
            $code .= sprintf(&quot;    %s =&gt; [\n&quot;, self::export($path));
            foreach ($routes as $route) {
                $code .= vsprintf(&quot;        [%s, %s, %s, %s, %s, %s, %s],\n&quot;, array_map([__CLASS__, 'export'], $route));
            }
            $code .= &quot;    ],\n&quot;;
        }
        $code .= &quot;],\n&quot;;

        $code .= sprintf(&quot;[ // \$regexpList%s\n],\n&quot;, $regexpCode);

        $code .= '[ // $dynamicRoutes'.&quot;\n&quot;;
        foreach ($dynamicRoutes as $path =&gt; $routes) {
            $code .= sprintf(&quot;    %s =&gt; [\n&quot;, self::export($path));
            foreach ($routes as $route) {
                $code .= vsprintf(&quot;        [%s, %s, %s, %s, %s, %s, %s],\n&quot;, array_map([__CLASS__, 'export'], $route));
            }
            $code .= &quot;    ],\n&quot;;
        }
        $code .= &quot;],\n&quot;;
        $code = preg_replace('/ =&gt; \[\n        (\[.+?),\n    \],/', ' =&gt; [$1],', $code);

        return $this-&gt;indent($code, 1).$checkConditionCode;
    }

    /**
     * Splits static routes from dynamic routes, so that they can be matched first, using a simple switch.
     */
    private function groupStaticRoutes(RouteCollection $collection): array
    {
        $staticRoutes = $dynamicRegex = [];
        $dynamicRoutes = new RouteCollection();

        foreach ($collection-&gt;all() as $name =&gt; $route) {
            $compiledRoute = $route-&gt;compile();
            $staticPrefix = rtrim($compiledRoute-&gt;getStaticPrefix(), '/');
            $hostRegex = $compiledRoute-&gt;getHostRegex();
            $regex = $compiledRoute-&gt;getRegex();
            if ($hasTrailingSlash = '/' !== $route-&gt;getPath()) {
                $pos = strrpos($regex, '$');
                $hasTrailingSlash = '/' === $regex[$pos - 1];
                $regex = substr_replace($regex, '/?$', $pos - $hasTrailingSlash, 1 + $hasTrailingSlash);
            }

            if (!$compiledRoute-&gt;getPathVariables()) {
                $host = !$compiledRoute-&gt;getHostVariables() ? $route-&gt;getHost() : '';
                $url = $route-&gt;getPath();
                if ($hasTrailingSlash) {
                    $url = substr($url, 0, -1);
                }
                foreach ($dynamicRegex as [$hostRx, $rx, $prefix]) {
                    if (('' === $prefix || str_starts_with($url, $prefix)) &amp;&amp; (preg_match($rx, $url) || preg_match($rx, $url.'/')) &amp;&amp; (!$host || !$hostRx || preg_match($hostRx, $host))) {
                        $dynamicRegex[] = [$hostRegex, $regex, $staticPrefix];
                        $dynamicRoutes-&gt;add($name, $route);
                        continue 2;
                    }
                }

                $staticRoutes[$url][$name] = [$route, $hasTrailingSlash];
            } else {
                $dynamicRegex[] = [$hostRegex, $regex, $staticPrefix];
                $dynamicRoutes-&gt;add($name, $route);
            }
        }

        return [$staticRoutes, $dynamicRoutes];
    }

    /**
     * Compiles static routes in a switch statement.
     *
     * Condition-less paths are put in a static array in the switch's default, with generic matching logic.
     * Paths that can match two or more routes, or have user-specified conditions are put in separate switch's cases.
     *
     * @throws \LogicException
     */
    private function compileStaticRoutes(array $staticRoutes, array &amp;$conditions): array
    {
        if (!$staticRoutes) {
            return [];
        }
        $compiledRoutes = [];

        foreach ($staticRoutes as $url =&gt; $routes) {
            $compiledRoutes[$url] = [];
            foreach ($routes as $name =&gt; [$route, $hasTrailingSlash]) {
                $compiledRoutes[$url][] = $this-&gt;compileRoute($route, $name, (!$route-&gt;compile()-&gt;getHostVariables() ? $route-&gt;getHost() : $route-&gt;compile()-&gt;getHostRegex()) ?: null, $hasTrailingSlash, false, $conditions);
            }
        }

        return $compiledRoutes;
    }

    /**
     * Compiles a regular expression followed by a switch statement to match dynamic routes.
     *
     * The regular expression matches both the host and the pathinfo at the same time. For stellar performance,
     * it is built as a tree of patterns, with re-ordering logic to group same-prefix routes together when possible.
     *
     * Patterns are named so that we know which one matched (https://pcre.org/current/doc/html/pcre2syntax.html#SEC23).
     * This name is used to &quot;switch&quot; to the additional logic required to match the final route.
     *
     * Condition-less paths are put in a static array in the switch's default, with generic matching logic.
     * Paths that can match two or more routes, or have user-specified conditions are put in separate switch's cases.
     *
     * Last but not least:
     *  - Because it is not possible to mix unicode/non-unicode patterns in a single regexp, several of them can be generated.
     *  - The same regexp can be used several times when the logic in the switch rejects the match. When this happens, the
     *    matching-but-failing subpattern is excluded by replacing its name by &quot;(*F)&quot;, which forces a failure-to-match.
     *    To ease this backlisting operation, the name of subpatterns is also the string offset where the replacement should occur.
     */
    private function compileDynamicRoutes(RouteCollection $collection, bool $matchHost, int $chunkLimit, array &amp;$conditions): array
    {
        if (!$collection-&gt;all()) {
            return [[], [], ''];
        }
        $regexpList = [];
        $code = '';
        $state = (object) [
            'regexMark' =&gt; 0,
            'regex' =&gt; [],
            'routes' =&gt; [],
            'mark' =&gt; 0,
            'markTail' =&gt; 0,
            'hostVars' =&gt; [],
            'vars' =&gt; [],
        ];
        $state-&gt;getVars = static function ($m) use ($state) {
            if ('_route' === $m[1]) {
                return '?:';
            }

            $state-&gt;vars[] = $m[1];

            return '';
        };

        $chunkSize = 0;
        $prev = null;
        $perModifiers = [];
        foreach ($collection-&gt;all() as $name =&gt; $route) {
            preg_match('#[a-zA-Z]*$#', $route-&gt;compile()-&gt;getRegex(), $rx);
            if ($chunkLimit &lt; ++$chunkSize || $prev !== $rx[0] &amp;&amp; $route-&gt;compile()-&gt;getPathVariables()) {
                $chunkSize = 1;
                $routes = new RouteCollection();
                $perModifiers[] = [$rx[0], $routes];
                $prev = $rx[0];
            }
            $routes-&gt;add($name, $route);
        }

        foreach ($perModifiers as [$modifiers, $routes]) {
            $prev = false;
            $perHost = [];
            foreach ($routes-&gt;all() as $name =&gt; $route) {
                $regex = $route-&gt;compile()-&gt;getHostRegex();
                if ($prev !== $regex) {
                    $routes = new RouteCollection();
                    $perHost[] = [$regex, $routes];
                    $prev = $regex;
                }
                $routes-&gt;add($name, $route);
            }
            $prev = false;
            $rx = '{^(?';
            $code .= &quot;\n    {$state-&gt;mark} =&gt; &quot;.self::export($rx);
            $startingMark = $state-&gt;mark;
            $state-&gt;mark += \strlen($rx);
            $state-&gt;regex = $rx;

            foreach ($perHost as [$hostRegex, $routes]) {
                if ($matchHost) {
                    if ($hostRegex) {
                        preg_match('#^.\^(.*)\$.[a-zA-Z]*$#', $hostRegex, $rx);
                        $state-&gt;vars = [];
                        $hostRegex = '(?i:'.preg_replace_callback('#\?P&lt;([^&gt;]++)&gt;#', $state-&gt;getVars, $rx[1]).')\.';
                        $state-&gt;hostVars = $state-&gt;vars;
                    } else {
                        $hostRegex = '(?:(?:[^./]*+\.)++)';
                        $state-&gt;hostVars = [];
                    }
                    $state-&gt;mark += \strlen($rx = ($prev ? ')' : '').&quot;|{$hostRegex}(?&quot;);
                    $code .= &quot;\n        .&quot;.self::export($rx);
                    $state-&gt;regex .= $rx;
                    $prev = true;
                }

                $tree = new StaticPrefixCollection();
                foreach ($routes-&gt;all() as $name =&gt; $route) {
                    preg_match('#^.\^(.*)\$.[a-zA-Z]*$#', $route-&gt;compile()-&gt;getRegex(), $rx);

                    $state-&gt;vars = [];
                    $regex = preg_replace_callback('#\?P&lt;([^&gt;]++)&gt;#', $state-&gt;getVars, $rx[1]);
                    if ($hasTrailingSlash = '/' !== $regex &amp;&amp; '/' === $regex[-1]) {
                        $regex = substr($regex, 0, -1);
                    }
                    $hasTrailingVar = (bool) preg_match('#\{\w+\}/?$#', $route-&gt;getPath());

                    $tree-&gt;addRoute($regex, [$name, $regex, $state-&gt;vars, $route, $hasTrailingSlash, $hasTrailingVar]);
                }

                $code .= $this-&gt;compileStaticPrefixCollection($tree, $state, 0, $conditions);
            }
            if ($matchHost) {
                $code .= &quot;\n        .')'&quot;;
                $state-&gt;regex .= ')';
            }
            $rx = &quot;)/?$}{$modifiers}&quot;;
            $code .= &quot;\n        .'{$rx}',&quot;;
            $state-&gt;regex .= $rx;
            $state-&gt;markTail = 0;

            // if the regex is too large, throw a signaling exception to recompute with smaller chunk size
            set_error_handler(function ($type, $message) { throw str_contains($message, $this-&gt;signalingException-&gt;getMessage()) ? $this-&gt;signalingException : new \ErrorException($message); });
            try {
                preg_match($state-&gt;regex, '');
            } finally {
                restore_error_handler();
            }

            $regexpList[$startingMark] = $state-&gt;regex;
        }

        $state-&gt;routes[$state-&gt;mark][] = [null, null, null, null, false, false, 0];
        unset($state-&gt;getVars);

        return [$regexpList, $state-&gt;routes, $code];
    }

    /**
     * Compiles a regexp tree of subpatterns that matches nested same-prefix routes.
     *
     * @param \stdClass $state A simple state object that keeps track of the progress of the compilation,
     *                         and gathers the generated switch's &quot;case&quot; and &quot;default&quot; statements
     */
    private function compileStaticPrefixCollection(StaticPrefixCollection $tree, \stdClass $state, int $prefixLen, array &amp;$conditions): string
    {
        $code = '';
        $prevRegex = null;
        $routes = $tree-&gt;getRoutes();

        foreach ($routes as $i =&gt; $route) {
            if ($route instanceof StaticPrefixCollection) {
                $prevRegex = null;
                $prefix = substr($route-&gt;getPrefix(), $prefixLen);
                $state-&gt;mark += \strlen($rx = &quot;|{$prefix}(?&quot;);
                $code .= &quot;\n            .&quot;.self::export($rx);
                $state-&gt;regex .= $rx;
                $code .= $this-&gt;indent($this-&gt;compileStaticPrefixCollection($route, $state, $prefixLen + \strlen($prefix), $conditions));
                $code .= &quot;\n            .')'&quot;;
                $state-&gt;regex .= ')';
                ++$state-&gt;markTail;
                continue;
            }

            [$name, $regex, $vars, $route, $hasTrailingSlash, $hasTrailingVar] = $route;
            $compiledRoute = $route-&gt;compile();
            $vars = array_merge($state-&gt;hostVars, $vars);

            if ($compiledRoute-&gt;getRegex() === $prevRegex) {
                $state-&gt;routes[$state-&gt;mark][] = $this-&gt;compileRoute($route, $name, $vars, $hasTrailingSlash, $hasTrailingVar, $conditions);
                continue;
            }

            $state-&gt;mark += 3 + $state-&gt;markTail + \strlen($regex) - $prefixLen;
            $state-&gt;markTail = 2 + \strlen($state-&gt;mark);
            $rx = sprintf('|%s(*:%s)', substr($regex, $prefixLen), $state-&gt;mark);
            $code .= &quot;\n            .&quot;.self::export($rx);
            $state-&gt;regex .= $rx;

            $prevRegex = $compiledRoute-&gt;getRegex();
            $state-&gt;routes[$state-&gt;mark] = [$this-&gt;compileRoute($route, $name, $vars, $hasTrailingSlash, $hasTrailingVar, $conditions)];
        }

        return $code;
    }

    /**
     * Compiles a single Route to PHP code used to match it against the path info.
     */
    private function compileRoute(Route $route, string $name, $vars, bool $hasTrailingSlash, bool $hasTrailingVar, array &amp;$conditions): array
    {
        $defaults = $route-&gt;getDefaults();

        if (isset($defaults['_canonical_route'])) {
            $name = $defaults['_canonical_route'];
            unset($defaults['_canonical_route']);
        }

        if ($condition = $route-&gt;getCondition()) {
            $condition = $this-&gt;getExpressionLanguage()-&gt;compile($condition, ['context', 'request']);
            $condition = $conditions[$condition] ?? $conditions[$condition] = (str_contains($condition, '$request') ? 1 : -1) * \count($conditions);
        } else {
            $condition = null;
        }

        return [
            ['_route' =&gt; $name] + $defaults,
            $vars,
            array_flip($route-&gt;getMethods()) ?: null,
            array_flip($route-&gt;getSchemes()) ?: null,
            $hasTrailingSlash,
            $hasTrailingVar,
            $condition,
        ];
    }

    private function getExpressionLanguage(): ExpressionLanguage
    {
        if (null === $this-&gt;expressionLanguage) {
            if (!class_exists(ExpressionLanguage::class)) {
                throw new \LogicException('Unable to use expressions as the Symfony ExpressionLanguage component is not installed.');
            }
            $this-&gt;expressionLanguage = new ExpressionLanguage(null, $this-&gt;expressionLanguageProviders);
        }

        return $this-&gt;expressionLanguage;
    }

    private function indent(string $code, int $level = 1): string
    {
        return preg_replace('/^./m', str_repeat('    ', $level).'$0', $code);
    }

    /**
     * @internal
     */
    public static function export($value): string
    {
        if (null === $value) {
            return 'null';
        }
        if (!\is_array($value)) {
            if (\is_object($value)) {
                throw new \InvalidArgumentException('Symfony\Component\Routing\Route cannot contain objects.');
            }

            return str_replace(&quot;\n&quot;, '\'.&quot;\n&quot;.\'', var_export($value, true));
        }
        if (!$value) {
            return '[]';
        }

        $i = 0;
        $export = '[';

        foreach ($value as $k =&gt; $v) {
            if ($i === $k) {
                ++$i;
            } else {
                $export .= self::export($k).' =&gt; ';

                if (\is_int($k) &amp;&amp; $i &lt; $k) {
                    $i = 1 + $k;
                }
            }

            $export .= self::export($v).', ';
        }

        return substr_replace($export, ']', -2);
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>