vendor/twig/twig/src/Environment.php line 280

  1. <?php
  3. /*
  4.  * This file is part of Twig.
  5.  *
  6.  * (c) Fabien Potencier
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Twig;
  14. use Twig\Cache\CacheInterface;
  15. use Twig\Cache\FilesystemCache;
  16. use Twig\Cache\NullCache;
  17. use Twig\Error\Error;
  18. use Twig\Error\LoaderError;
  19. use Twig\Error\RuntimeError;
  20. use Twig\Error\SyntaxError;
  21. use Twig\Extension\CoreExtension;
  22. use Twig\Extension\EscaperExtension;
  23. use Twig\Extension\ExtensionInterface;
  24. use Twig\Extension\OptimizerExtension;
  25. use Twig\Loader\ArrayLoader;
  26. use Twig\Loader\ChainLoader;
  27. use Twig\Loader\LoaderInterface;
  28. use Twig\Node\Expression\Binary\AbstractBinary;
  29. use Twig\Node\Expression\Unary\AbstractUnary;
  30. use Twig\Node\ModuleNode;
  31. use Twig\Node\Node;
  32. use Twig\NodeVisitor\NodeVisitorInterface;
  33. use Twig\RuntimeLoader\RuntimeLoaderInterface;
  34. use Twig\TokenParser\TokenParserInterface;
  36. /**
  37.  * Stores the Twig configuration and renders templates.
  38.  *
  39.  * @author Fabien Potencier <fabien@symfony.com>
  40.  */
  41. class Environment
  42. {
  43.     public const VERSION = '3.5.0';
  44.     public const VERSION_ID = 30500;
  45.     public const MAJOR_VERSION = 3;
  46.     public const MINOR_VERSION = 5;
  47.     public const RELEASE_VERSION = 0;
  48.     public const EXTRA_VERSION = '';
  50.     private $charset;
  51.     private $loader;
  52.     private $debug;
  53.     private $autoReload;
  54.     private $cache;
  55.     private $lexer;
  56.     private $parser;
  57.     private $compiler;
  58.     /** @var array<string, mixed> */
  59.     private $globals = [];
  60.     private $resolvedGlobals;
  61.     private $loadedTemplates;
  62.     private $strictVariables;
  63.     private $templateClassPrefix = '__TwigTemplate_';
  64.     private $originalCache;
  65.     private $extensionSet;
  66.     private $runtimeLoaders = [];
  67.     private $runtimes = [];
  68.     private $optionsHash;
  70.     /**
  71.      * Constructor.
  72.      *
  73.      * Available options:
  74.      *
  75.      *  * debug: When set to true, it automatically set "auto_reload" to true as
  76.      *           well (default to false).
  77.      *
  78.      *  * charset: The charset used by the templates (default to UTF-8).
  79.      *
  80.      *  * cache: An absolute path where to store the compiled templates,
  81.      *           a \Twig\Cache\CacheInterface implementation,
  82.      *           or false to disable compilation cache (default).
  83.      *
  84.      *  * auto_reload: Whether to reload the template if the original source changed.
  85.      *                 If you don't provide the auto_reload option, it will be
  86.      *                 determined automatically based on the debug value.
  87.      *
  88.      *  * strict_variables: Whether to ignore invalid variables in templates
  89.      *                      (default to false).
  90.      *
  91.      *  * autoescape: Whether to enable auto-escaping (default to html):
  92.      *                  * false: disable auto-escaping
  93.      *                  * html, js: set the autoescaping to one of the supported strategies
  94.      *                  * name: set the autoescaping strategy based on the template name extension
  95.      *                  * PHP callback: a PHP callback that returns an escaping strategy based on the template "name"
  96.      *
  97.      *  * optimizations: A flag that indicates which optimizations to apply
  98.      *                   (default to -1 which means that all optimizations are enabled;
  99.      *                   set it to 0 to disable).
  100.      */
  101.     public function __construct(LoaderInterface $loader, $options = [])
  102.     {
  103.         $this->setLoader($loader);
  105.         $options = array_merge([
  106.             'debug' => false,
  107.             'charset' => 'UTF-8',
  108.             'strict_variables' => false,
  109.             'autoescape' => 'html',
  110.             'cache' => false,
  111.             'auto_reload' => null,
  112.             'optimizations' => -1,
  113.         ], $options);
  115.         $this->debug = (bool) $options['debug'];
  116.         $this->setCharset($options['charset'] ?? 'UTF-8');
  117.         $this->autoReload = null === $options['auto_reload'] ? $this->debug : (bool) $options['auto_reload'];
  118.         $this->strictVariables = (bool) $options['strict_variables'];
  119.         $this->setCache($options['cache']);
  120.         $this->extensionSet = new ExtensionSet();
  122.         $this->addExtension(new CoreExtension());
  123.         $this->addExtension(new EscaperExtension($options['autoescape']));
  124.         $this->addExtension(new OptimizerExtension($options['optimizations']));
  125.     }
  127.     /**
  128.      * Enables debugging mode.
  129.      */
  130.     public function enableDebug()
  131.     {
  132.         $this->debug = true;
  133.         $this->updateOptionsHash();
  134.     }
  136.     /**
  137.      * Disables debugging mode.
  138.      */
  139.     public function disableDebug()
  140.     {
  141.         $this->debug = false;
  142.         $this->updateOptionsHash();
  143.     }
  145.     /**
  146.      * Checks if debug mode is enabled.
  147.      *
  148.      * @return bool true if debug mode is enabled, false otherwise
  149.      */
  150.     public function isDebug()
  151.     {
  152.         return $this->debug;
  153.     }
  155.     /**
  156.      * Enables the auto_reload option.
  157.      */
  158.     public function enableAutoReload()
  159.     {
  160.         $this->autoReload = true;
  161.     }
  163.     /**
  164.      * Disables the auto_reload option.
  165.      */
  166.     public function disableAutoReload()
  167.     {
  168.         $this->autoReload = false;
  169.     }
  171.     /**
  172.      * Checks if the auto_reload option is enabled.
  173.      *
  174.      * @return bool true if auto_reload is enabled, false otherwise
  175.      */
  176.     public function isAutoReload()
  177.     {
  178.         return $this->autoReload;
  179.     }
  181.     /**
  182.      * Enables the strict_variables option.
  183.      */
  184.     public function enableStrictVariables()
  185.     {
  186.         $this->strictVariables = true;
  187.         $this->updateOptionsHash();
  188.     }
  190.     /**
  191.      * Disables the strict_variables option.
  192.      */
  193.     public function disableStrictVariables()
  194.     {
  195.         $this->strictVariables = false;
  196.         $this->updateOptionsHash();
  197.     }
  199.     /**
  200.      * Checks if the strict_variables option is enabled.
  201.      *
  202.      * @return bool true if strict_variables is enabled, false otherwise
  203.      */
  204.     public function isStrictVariables()
  205.     {
  206.         return $this->strictVariables;
  207.     }
  209.     /**
  210.      * Gets the current cache implementation.
  211.      *
  212.      * @param bool $original Whether to return the original cache option or the real cache instance
  213.      *
  214.      * @return CacheInterface|string|false A Twig\Cache\CacheInterface implementation,
  215.      *                                     an absolute path to the compiled templates,
  216.      *                                     or false to disable cache
  217.      */
  218.     public function getCache($original = true)
  219.     {
  220.         return $original ? $this->originalCache : $this->cache;
  221.     }
  223.     /**
  224.      * Sets the current cache implementation.
  225.      *
  226.      * @param CacheInterface|string|false $cache A Twig\Cache\CacheInterface implementation,
  227.      *                                           an absolute path to the compiled templates,
  228.      *                                           or false to disable cache
  229.      */
  230.     public function setCache($cache)
  231.     {
  232.         if (\is_string($cache)) {
  233.             $this->originalCache = $cache;
  234.             $this->cache = new FilesystemCache($cache, $this->autoReload ? FilesystemCache::FORCE_BYTECODE_INVALIDATION : 0);
  235.         } elseif (false === $cache) {
  236.             $this->originalCache = $cache;
  237.             $this->cache = new NullCache();
  238.         } elseif ($cache instanceof CacheInterface) {
  239.             $this->originalCache = $this->cache = $cache;
  240.         } else {
  241.             throw new \LogicException('Cache can only be a string, false, or a \Twig\Cache\CacheInterface implementation.');
  242.         }
  243.     }
  245.     /**
  246.      * Gets the template class associated with the given string.
  247.      *
  248.      * The generated template class is based on the following parameters:
  249.      *
  250.      *  * The cache key for the given template;
  251.      *  * The currently enabled extensions;
  252.      *  * Whether the Twig C extension is available or not;
  253.      *  * PHP version;
  254.      *  * Twig version;
  255.      *  * Options with what environment was created.
  256.      *
  257.      * @param string   $name  The name for which to calculate the template class name
  258.      * @param int|null $index The index if it is an embedded template
  259.      *
  260.      * @internal
  261.      */
  262.     public function getTemplateClass(string $name, int $index = null): string
  263.     {
  264.         $key = $this->getLoader()->getCacheKey($name).$this->optionsHash;
  266.         return $this->templateClassPrefix.hash(\PHP_VERSION_ID < 80100 ? 'sha256' : 'xxh128', $key).(null === $index ? '' : '___'.$index);
  267.     }
  269.     /**
  270.      * Renders a template.
  271.      *
  272.      * @param string|TemplateWrapper $name The template name
  273.      *
  274.      * @throws LoaderError  When the template cannot be found
  275.      * @throws SyntaxError  When an error occurred during compilation
  276.      * @throws RuntimeError When an error occurred during rendering
  277.      */
  278.     public function render($name, array $context = []): string
  279.     {
  280.         return $this->load($name)->render($context);
  281.     }
  283.     /**
  284.      * Displays a template.
  285.      *
  286.      * @param string|TemplateWrapper $name The template name
  287.      *
  288.      * @throws LoaderError  When the template cannot be found
  289.      * @throws SyntaxError  When an error occurred during compilation
  290.      * @throws RuntimeError When an error occurred during rendering
  291.      */
  292.     public function display($name, array $context = []): void
  293.     {
  294.         $this->load($name)->display($context);
  295.     }
  297.     /**
  298.      * Loads a template.
  299.      *
  300.      * @param string|TemplateWrapper $name The template name
  301.      *
  302.      * @throws LoaderError  When the template cannot be found
  303.      * @throws RuntimeError When a previously generated cache is corrupted
  304.      * @throws SyntaxError  When an error occurred during compilation
  305.      */
  306.     public function load($name): TemplateWrapper
  307.     {
  308.         if ($name instanceof TemplateWrapper) {
  309.             return $name;
  310.         }
  312.         return new TemplateWrapper($this, $this->loadTemplate($this->getTemplateClass($name), $name));
  313.     }
  315.     /**
  316.      * Loads a template internal representation.
  317.      *
  318.      * This method is for internal use only and should never be called
  319.      * directly.
  320.      *
  321.      * @param string $name  The template name
  322.      * @param int    $index The index if it is an embedded template
  323.      *
  324.      * @throws LoaderError  When the template cannot be found
  325.      * @throws RuntimeError When a previously generated cache is corrupted
  326.      * @throws SyntaxError  When an error occurred during compilation
  327.      *
  328.      * @internal
  329.      */
  330.     public function loadTemplate(string $cls, string $name, int $index = null): Template
  331.     {
  332.         $mainCls = $cls;
  333.         if (null !== $index) {
  334.             $cls .= '___'.$index;
  335.         }
  337.         if (isset($this->loadedTemplates[$cls])) {
  338.             return $this->loadedTemplates[$cls];
  339.         }
  341.         if (!class_exists($cls, false)) {
  342.             $key = $this->cache->generateKey($name, $mainCls);
  344.             if (!$this->isAutoReload() || $this->isTemplateFresh($name, $this->cache->getTimestamp($key))) {
  345.                 $this->cache->load($key);
  346.             }
  348.             $source = null;
  349.             if (!class_exists($cls, false)) {
  350.                 $source = $this->getLoader()->getSourceContext($name);
  351.                 $content = $this->compileSource($source);
  352.                 $this->cache->write($key, $content);
  353.                 $this->cache->load($key);
  355.                 if (!class_exists($mainCls, false)) {
  356.                     /* Last line of defense if either $this->bcWriteCacheFile was used,
  357.                      * $this->cache is implemented as a no-op or we have a race condition
  358.                      * where the cache was cleared between the above calls to write to and load from
  359.                      * the cache.
  360.                      */
  361.                     eval('?>'.$content);
  362.                 }
  364.                 if (!class_exists($cls, false)) {
  365.                     throw new RuntimeError(sprintf('Failed to load Twig template "%s", index "%s": cache might be corrupted.', $name, $index), -1, $source);
  366.                 }
  367.             }
  368.         }
  370.         $this->extensionSet->initRuntime();
  372.         return $this->loadedTemplates[$cls] = new $cls($this);
  373.     }
  375.     /**
  376.      * Creates a template from source.
  377.      *
  378.      * This method should not be used as a generic way to load templates.
  379.      *
  380.      * @param string $template The template source
  381.      * @param string $name     An optional name of the template to be used in error messages
  382.      *
  383.      * @throws LoaderError When the template cannot be found
  384.      * @throws SyntaxError When an error occurred during compilation
  385.      */
  386.     public function createTemplate(string $template, string $name = null): TemplateWrapper
  387.     {
  388.         $hash = hash(\PHP_VERSION_ID < 80100 ? 'sha256' : 'xxh128', $template, false);
  389.         if (null !== $name) {
  390.             $name = sprintf('%s (string template %s)', $name, $hash);
  391.         } else {
  392.             $name = sprintf('__string_template__%s', $hash);
  393.         }
  395.         $loader = new ChainLoader([
  396.             new ArrayLoader([$name => $template]),
  397.             $current = $this->getLoader(),
  398.         ]);
  400.         $this->setLoader($loader);
  401.         try {
  402.             return new TemplateWrapper($this, $this->loadTemplate($this->getTemplateClass($name), $name));
  403.         } finally {
  404.             $this->setLoader($current);
  405.         }
  406.     }
  408.     /**
  409.      * Returns true if the template is still fresh.
  410.      *
  411.      * Besides checking the loader for freshness information,
  412.      * this method also checks if the enabled extensions have
  413.      * not changed.
  414.      *
  415.      * @param int $time The last modification time of the cached template
  416.      */
  417.     public function isTemplateFresh(string $name, int $time): bool
  418.     {
  419.         return $this->extensionSet->getLastModified() <= $time && $this->getLoader()->isFresh($name, $time);
  420.     }
  422.     /**
  423.      * Tries to load a template consecutively from an array.
  424.      *
  425.      * Similar to load() but it also accepts instances of \Twig\Template and
  426.      * \Twig\TemplateWrapper, and an array of templates where each is tried to be loaded.
  427.      *
  428.      * @param string|TemplateWrapper|array $names A template or an array of templates to try consecutively
  429.      *
  430.      * @throws LoaderError When none of the templates can be found
  431.      * @throws SyntaxError When an error occurred during compilation
  432.      */
  433.     public function resolveTemplate($names): TemplateWrapper
  434.     {
  435.         if (!\is_array($names)) {
  436.             return $this->load($names);
  437.         }
  439.         $count = \count($names);
  440.         foreach ($names as $name) {
  441.             if ($name instanceof Template) {
  442.                 return $name;
  443.             }
  444.             if ($name instanceof TemplateWrapper) {
  445.                 return $name;
  446.             }
  448.             if (1 !== $count && !$this->getLoader()->exists($name)) {
  449.                 continue;
  450.             }
  452.             return $this->load($name);
  453.         }
  455.         throw new LoaderError(sprintf('Unable to find one of the following templates: "%s".', implode('", "', $names)));
  456.     }
  458.     public function setLexer(Lexer $lexer)
  459.     {
  460.         $this->lexer = $lexer;
  461.     }
  463.     /**
  464.      * @throws SyntaxError When the code is syntactically wrong
  465.      */
  466.     public function tokenize(Source $source): TokenStream
  467.     {
  468.         if (null === $this->lexer) {
  469.             $this->lexer = new Lexer($this);
  470.         }
  472.         return $this->lexer->tokenize($source);
  473.     }
  475.     public function setParser(Parser $parser)
  476.     {
  477.         $this->parser = $parser;
  478.     }
  480.     /**
  481.      * Converts a token stream to a node tree.
  482.      *
  483.      * @throws SyntaxError When the token stream is syntactically or semantically wrong
  484.      */
  485.     public function parse(TokenStream $stream): ModuleNode
  486.     {
  487.         if (null === $this->parser) {
  488.             $this->parser = new Parser($this);
  489.         }
  491.         return $this->parser->parse($stream);
  492.     }
  494.     public function setCompiler(Compiler $compiler)
  495.     {
  496.         $this->compiler = $compiler;
  497.     }
  499.     /**
  500.      * Compiles a node and returns the PHP code.
  501.      */
  502.     public function compile(Node $node): string
  503.     {
  504.         if (null === $this->compiler) {
  505.             $this->compiler = new Compiler($this);
  506.         }
  508.         return $this->compiler->compile($node)->getSource();
  509.     }
  511.     /**
  512.      * Compiles a template source code.
  513.      *
  514.      * @throws SyntaxError When there was an error during tokenizing, parsing or compiling
  515.      */
  516.     public function compileSource(Source $source): string
  517.     {
  518.         try {
  519.             return $this->compile($this->parse($this->tokenize($source)));
  520.         } catch (Error $e) {
  521.             $e->setSourceContext($source);
  522.             throw $e;
  523.         } catch (\Exception $e) {
  524.             throw new SyntaxError(sprintf('An exception has been thrown during the compilation of a template ("%s").', $e->getMessage()), -1, $source, $e);
  525.         }
  526.     }
  528.     public function setLoader(LoaderInterface $loader)
  529.     {
  530.         $this->loader = $loader;
  531.     }
  533.     public function getLoader(): LoaderInterface
  534.     {
  535.         return $this->loader;
  536.     }
  538.     public function setCharset(string $charset)
  539.     {
  540.         if ('UTF8' === $charset = null === $charset ? null : strtoupper($charset)) {
  541.             // iconv on Windows requires "UTF-8" instead of "UTF8"
  542.             $charset = 'UTF-8';
  543.         }
  545.         $this->charset = $charset;
  546.     }
  548.     public function getCharset(): string
  549.     {
  550.         return $this->charset;
  551.     }
  553.     public function hasExtension(string $class): bool
  554.     {
  555.         return $this->extensionSet->hasExtension($class);
  556.     }
  558.     public function addRuntimeLoader(RuntimeLoaderInterface $loader)
  559.     {
  560.         $this->runtimeLoaders[] = $loader;
  561.     }
  563.     /**
  564.      * @template TExtension of ExtensionInterface
  565.      *
  566.      * @param class-string<TExtension> $class
  567.      *
  568.      * @return TExtension
  569.      */
  570.     public function getExtension(string $class): ExtensionInterface
  571.     {
  572.         return $this->extensionSet->getExtension($class);
  573.     }
  575.     /**
  576.      * Returns the runtime implementation of a Twig element (filter/function/tag/test).
  577.      *
  578.      * @template TRuntime of object
  579.      *
  580.      * @param class-string<TRuntime> $class A runtime class name
  581.      *
  582.      * @return TRuntime The runtime implementation
  583.      *
  584.      * @throws RuntimeError When the template cannot be found
  585.      */
  586.     public function getRuntime(string $class)
  587.     {
  588.         if (isset($this->runtimes[$class])) {
  589.             return $this->runtimes[$class];
  590.         }
  592.         foreach ($this->runtimeLoaders as $loader) {
  593.             if (null !== $runtime = $loader->load($class)) {
  594.                 return $this->runtimes[$class] = $runtime;
  595.             }
  596.         }
  598.         throw new RuntimeError(sprintf('Unable to load the "%s" runtime.', $class));
  599.     }
  601.     public function addExtension(ExtensionInterface $extension)
  602.     {
  603.         $this->extensionSet->addExtension($extension);
  604.         $this->updateOptionsHash();
  605.     }
  607.     /**
  608.      * @param ExtensionInterface[] $extensions An array of extensions
  609.      */
  610.     public function setExtensions(array $extensions)
  611.     {
  612.         $this->extensionSet->setExtensions($extensions);
  613.         $this->updateOptionsHash();
  614.     }
  616.     /**
  617.      * @return ExtensionInterface[] An array of extensions (keys are for internal usage only and should not be relied on)
  618.      */
  619.     public function getExtensions(): array
  620.     {
  621.         return $this->extensionSet->getExtensions();
  622.     }
  624.     public function addTokenParser(TokenParserInterface $parser)
  625.     {
  626.         $this->extensionSet->addTokenParser($parser);
  627.     }
  629.     /**
  630.      * @return TokenParserInterface[]
  631.      *
  632.      * @internal
  633.      */
  634.     public function getTokenParsers(): array
  635.     {
  636.         return $this->extensionSet->getTokenParsers();
  637.     }
  639.     /**
  640.      * @internal
  641.      */
  642.     public function getTokenParser(string $name): ?TokenParserInterface
  643.     {
  644.         return $this->extensionSet->getTokenParser($name);
  645.     }
  647.     public function registerUndefinedTokenParserCallback(callable $callable): void
  648.     {
  649.         $this->extensionSet->registerUndefinedTokenParserCallback($callable);
  650.     }
  652.     public function addNodeVisitor(NodeVisitorInterface $visitor)
  653.     {
  654.         $this->extensionSet->addNodeVisitor($visitor);
  655.     }
  657.     /**
  658.      * @return NodeVisitorInterface[]
  659.      *
  660.      * @internal
  661.      */
  662.     public function getNodeVisitors(): array
  663.     {
  664.         return $this->extensionSet->getNodeVisitors();
  665.     }
  667.     public function addFilter(TwigFilter $filter)
  668.     {
  669.         $this->extensionSet->addFilter($filter);
  670.     }
  672.     /**
  673.      * @internal
  674.      */
  675.     public function getFilter(string $name): ?TwigFilter
  676.     {
  677.         return $this->extensionSet->getFilter($name);
  678.     }
  680.     public function registerUndefinedFilterCallback(callable $callable): void
  681.     {
  682.         $this->extensionSet->registerUndefinedFilterCallback($callable);
  683.     }
  685.     /**
  686.      * Gets the registered Filters.
  687.      *
  688.      * Be warned that this method cannot return filters defined with registerUndefinedFilterCallback.
  689.      *
  690.      * @return TwigFilter[]
  691.      *
  692.      * @see registerUndefinedFilterCallback
  693.      *
  694.      * @internal
  695.      */
  696.     public function getFilters(): array
  697.     {
  698.         return $this->extensionSet->getFilters();
  699.     }
  701.     public function addTest(TwigTest $test)
  702.     {
  703.         $this->extensionSet->addTest($test);
  704.     }
  706.     /**
  707.      * @return TwigTest[]
  708.      *
  709.      * @internal
  710.      */
  711.     public function getTests(): array
  712.     {
  713.         return $this->extensionSet->getTests();
  714.     }
  716.     /**
  717.      * @internal
  718.      */
  719.     public function getTest(string $name): ?TwigTest
  720.     {
  721.         return $this->extensionSet->getTest($name);
  722.     }
  724.     public function addFunction(TwigFunction $function)
  725.     {
  726.         $this->extensionSet->addFunction($function);
  727.     }
  729.     /**
  730.      * @internal
  731.      */
  732.     public function getFunction(string $name): ?TwigFunction
  733.     {
  734.         return $this->extensionSet->getFunction($name);
  735.     }
  737.     public function registerUndefinedFunctionCallback(callable $callable): void
  738.     {
  739.         $this->extensionSet->registerUndefinedFunctionCallback($callable);
  740.     }
  742.     /**
  743.      * Gets registered functions.
  744.      *
  745.      * Be warned that this method cannot return functions defined with registerUndefinedFunctionCallback.
  746.      *
  747.      * @return TwigFunction[]
  748.      *
  749.      * @see registerUndefinedFunctionCallback
  750.      *
  751.      * @internal
  752.      */
  753.     public function getFunctions(): array
  754.     {
  755.         return $this->extensionSet->getFunctions();
  756.     }
  758.     /**
  759.      * Registers a Global.
  760.      *
  761.      * New globals can be added before compiling or rendering a template;
  762.      * but after, you can only update existing globals.
  763.      *
  764.      * @param mixed $value The global value
  765.      */
  766.     public function addGlobal(string $name, $value)
  767.     {
  768.         if ($this->extensionSet->isInitialized() && !\array_key_exists($name, $this->getGlobals())) {
  769.             throw new \LogicException(sprintf('Unable to add global "%s" as the runtime or the extensions have already been initialized.', $name));
  770.         }
  772.         if (null !== $this->resolvedGlobals) {
  773.             $this->resolvedGlobals[$name] = $value;
  774.         } else {
  775.             $this->globals[$name] = $value;
  776.         }
  777.     }
  779.     /**
  780.      * @internal
  781.      *
  782.      * @return array<string, mixed>
  783.      */
  784.     public function getGlobals(): array
  785.     {
  786.         if ($this->extensionSet->isInitialized()) {
  787.             if (null === $this->resolvedGlobals) {
  788.                 $this->resolvedGlobals = array_merge($this->extensionSet->getGlobals(), $this->globals);
  789.             }
  791.             return $this->resolvedGlobals;
  792.         }
  794.         return array_merge($this->extensionSet->getGlobals(), $this->globals);
  795.     }
  797.     public function mergeGlobals(array $context): array
  798.     {
  799.         // we don't use array_merge as the context being generally
  800.         // bigger than globals, this code is faster.
  801.         foreach ($this->getGlobals() as $key => $value) {
  802.             if (!\array_key_exists($key, $context)) {
  803.                 $context[$key] = $value;
  804.             }
  805.         }
  807.         return $context;
  808.     }
  810.     /**
  811.      * @internal
  812.      *
  813.      * @return array<string, array{precedence: int, class: class-string<AbstractUnary>}>
  814.      */
  815.     public function getUnaryOperators(): array
  816.     {
  817.         return $this->extensionSet->getUnaryOperators();
  818.     }
  820.     /**
  821.      * @internal
  822.      *
  823.      * @return array<string, array{precedence: int, class: class-string<AbstractBinary>, associativity: ExpressionParser::OPERATOR_*}>
  824.      */
  825.     public function getBinaryOperators(): array
  826.     {
  827.         return $this->extensionSet->getBinaryOperators();
  828.     }
  830.     private function updateOptionsHash(): void
  831.     {
  832.         $this->optionsHash = implode(':', [
  833.             $this->extensionSet->getSignature(),
  834.             \PHP_MAJOR_VERSION,
  835.             \PHP_MINOR_VERSION,
  836.             self::VERSION,
  837.             (int) $this->debug,
  838.             (int) $this->strictVariables,
  839.         ]);
  840.     }
  841. }