vendor/twig/twig/src/Parser.php line 58

  1. <?php
  3. /*
  4.  * This file is part of Twig.
  5.  *
  6.  * (c) Fabien Potencier
  7.  * (c) Armin Ronacher
  8.  *
  9.  * For the full copyright and license information, please view the LICENSE
  10.  * file that was distributed with this source code.
  11.  */
  13. namespace Twig;
  15. use Twig\Error\SyntaxError;
  16. use Twig\Node\BlockNode;
  17. use Twig\Node\BlockReferenceNode;
  18. use Twig\Node\BodyNode;
  19. use Twig\Node\Expression\AbstractExpression;
  20. use Twig\Node\MacroNode;
  21. use Twig\Node\ModuleNode;
  22. use Twig\Node\Node;
  23. use Twig\Node\NodeCaptureInterface;
  24. use Twig\Node\NodeOutputInterface;
  25. use Twig\Node\PrintNode;
  26. use Twig\Node\TextNode;
  27. use Twig\TokenParser\TokenParserInterface;
  28. use Twig\Util\ReflectionCallable;
  30. /**
  31.  * @author Fabien Potencier <fabien@symfony.com>
  32.  */
  33. class Parser
  34. {
  35.     private $stack = [];
  36.     private $stream;
  37.     private $parent;
  38.     private $visitors;
  39.     private $expressionParser;
  40.     private $blocks;
  41.     private $blockStack;
  42.     private $macros;
  43.     private $importedSymbols;
  44.     private $traits;
  45.     private $embeddedTemplates = [];
  46.     private $varNameSalt = 0;
  48.     public function __construct(
  49.         private Environment $env,
  50.     ) {
  51.     }
  53.     public function getVarName(): string
  54.     {
  55.         return \sprintf('__internal_parse_%d', $this->varNameSalt++);
  56.     }
  58.     public function parse(TokenStream $stream, $test = null, bool $dropNeedle = false): ModuleNode
  59.     {
  60.         $vars = get_object_vars($this);
  61.         unset($vars['stack'], $vars['env'], $vars['handlers'], $vars['visitors'], $vars['expressionParser'], $vars['reservedMacroNames'], $vars['varNameSalt']);
  62.         $this->stack[] = $vars;
  64.         // node visitors
  65.         if (null === $this->visitors) {
  66.             $this->visitors = $this->env->getNodeVisitors();
  67.         }
  69.         if (null === $this->expressionParser) {
  70.             $this->expressionParser = new ExpressionParser($this, $this->env);
  71.         }
  73.         $this->stream = $stream;
  74.         $this->parent = null;
  75.         $this->blocks = [];
  76.         $this->macros = [];
  77.         $this->traits = [];
  78.         $this->blockStack = [];
  79.         $this->importedSymbols = [[]];
  80.         $this->embeddedTemplates = [];
  82.         try {
  83.             $body = $this->subparse($test, $dropNeedle);
  85.             if (null !== $this->parent && null === $body = $this->filterBodyNodes($body)) {
  86.                 $body = new Node();
  87.             }
  88.         } catch (SyntaxError $e) {
  89.             if (!$e->getSourceContext()) {
  90.                 $e->setSourceContext($this->stream->getSourceContext());
  91.             }
  93.             if (!$e->getTemplateLine()) {
  94.                 $e->setTemplateLine($this->getCurrentToken()->getLine());
  95.             }
  97.             throw $e;
  98.         }
  100.         $node = new ModuleNode(new BodyNode([$body]), $this->parent, new Node($this->blocks), new Node($this->macros), new Node($this->traits), $this->embeddedTemplates, $stream->getSourceContext());
  102.         $traverser = new NodeTraverser($this->env, $this->visitors);
  104.         /**
  105.          * @var ModuleNode $node
  106.          */
  107.         $node = $traverser->traverse($node);
  109.         // restore previous stack so previous parse() call can resume working
  110.         foreach (array_pop($this->stack) as $key => $val) {
  111.             $this->$key = $val;
  112.         }
  114.         return $node;
  115.     }
  117.     public function subparse($test, bool $dropNeedle = false): Node
  118.     {
  119.         $lineno = $this->getCurrentToken()->getLine();
  120.         $rv = [];
  121.         while (!$this->stream->isEOF()) {
  122.             switch ($this->getCurrentToken()->getType()) {
  123.                 case Token::TEXT_TYPE:
  124.                     $token = $this->stream->next();
  125.                     $rv[] = new TextNode($token->getValue(), $token->getLine());
  126.                     break;
  128.                 case Token::VAR_START_TYPE:
  129.                     $token = $this->stream->next();
  130.                     $expr = $this->expressionParser->parseExpression();
  131.                     $this->stream->expect(Token::VAR_END_TYPE);
  132.                     $rv[] = new PrintNode($expr, $token->getLine());
  133.                     break;
  135.                 case Token::BLOCK_START_TYPE:
  136.                     $this->stream->next();
  137.                     $token = $this->getCurrentToken();
  139.                     if (Token::NAME_TYPE !== $token->getType()) {
  140.                         throw new SyntaxError('A block must start with a tag name.', $token->getLine(), $this->stream->getSourceContext());
  141.                     }
  143.                     if (null !== $test && $test($token)) {
  144.                         if ($dropNeedle) {
  145.                             $this->stream->next();
  146.                         }
  148.                         if (1 === \count($rv)) {
  149.                             return $rv[0];
  150.                         }
  152.                         return new Node($rv, [], $lineno);
  153.                     }
  155.                     if (!$subparser = $this->env->getTokenParser($token->getValue())) {
  156.                         if (null !== $test) {
  157.                             $e = new SyntaxError(\sprintf('Unexpected "%s" tag', $token->getValue()), $token->getLine(), $this->stream->getSourceContext());
  159.                             $callable = (new ReflectionCallable(new TwigTest('decision', $test)))->getCallable();
  160.                             if (\is_array($callable) && $callable[0] instanceof TokenParserInterface) {
  161.                                 $e->appendMessage(\sprintf(' (expecting closing tag for the "%s" tag defined near line %s).', $callable[0]->getTag(), $lineno));
  162.                             }
  163.                         } else {
  164.                             $e = new SyntaxError(\sprintf('Unknown "%s" tag.', $token->getValue()), $token->getLine(), $this->stream->getSourceContext());
  165.                             $e->addSuggestions($token->getValue(), array_keys($this->env->getTokenParsers()));
  166.                         }
  168.                         throw $e;
  169.                     }
  171.                     $this->stream->next();
  173.                     $subparser->setParser($this);
  174.                     $node = $subparser->parse($token);
  175.                     if (!$node) {
  176.                         trigger_deprecation('twig/twig', '3.12', 'Returning "null" from "%s" is deprecated and forbidden by "TokenParserInterface".', $subparser::class);
  177.                     } else {
  178.                         $node->setNodeTag($subparser->getTag());
  179.                         $rv[] = $node;
  180.                     }
  181.                     break;
  183.                 default:
  184.                     throw new SyntaxError('The lexer or the parser ended up in an unsupported state.', $this->getCurrentToken()->getLine(), $this->stream->getSourceContext());
  185.             }
  186.         }
  188.         if (1 === \count($rv)) {
  189.             return $rv[0];
  190.         }
  192.         return new Node($rv, [], $lineno);
  193.     }
  195.     public function getBlockStack(): array
  196.     {
  197.         trigger_deprecation('twig/twig', '3.12', 'Method "%s()" is deprecated.', __METHOD__);
  199.         return $this->blockStack;
  200.     }
  202.     public function peekBlockStack()
  203.     {
  204.         return $this->blockStack[\count($this->blockStack) - 1] ?? null;
  205.     }
  207.     public function popBlockStack(): void
  208.     {
  209.         array_pop($this->blockStack);
  210.     }
  212.     public function pushBlockStack($name): void
  213.     {
  214.         $this->blockStack[] = $name;
  215.     }
  217.     public function hasBlock(string $name): bool
  218.     {
  219.         trigger_deprecation('twig/twig', '3.12', 'Method "%s()" is deprecated.', __METHOD__);
  221.         return isset($this->blocks[$name]);
  222.     }
  224.     public function getBlock(string $name): Node
  225.     {
  226.         trigger_deprecation('twig/twig', '3.12', 'Method "%s()" is deprecated.', __METHOD__);
  228.         return $this->blocks[$name];
  229.     }
  231.     public function setBlock(string $name, BlockNode $value): void
  232.     {
  233.         if (isset($this->blocks[$name])) {
  234.             throw new SyntaxError(\sprintf("The block '%s' has already been defined line %d.", $name, $this->blocks[$name]->getTemplateLine()), $this->getCurrentToken()->getLine(), $this->blocks[$name]->getSourceContext());
  235.         }
  237.         $this->blocks[$name] = new BodyNode([$value], [], $value->getTemplateLine());
  238.     }
  240.     public function hasMacro(string $name): bool
  241.     {
  242.         trigger_deprecation('twig/twig', '3.12', 'Method "%s()" is deprecated.', __METHOD__);
  244.         return isset($this->macros[$name]);
  245.     }
  247.     public function setMacro(string $name, MacroNode $node): void
  248.     {
  249.         $this->macros[$name] = $node;
  250.     }
  252.     public function addTrait($trait): void
  253.     {
  254.         $this->traits[] = $trait;
  255.     }
  257.     public function hasTraits(): bool
  258.     {
  259.         trigger_deprecation('twig/twig', '3.12', 'Method "%s()" is deprecated.', __METHOD__);
  261.         return \count($this->traits) > 0;
  262.     }
  264.     public function embedTemplate(ModuleNode $template)
  265.     {
  266.         $template->setIndex(mt_rand());
  268.         $this->embeddedTemplates[] = $template;
  269.     }
  271.     public function addImportedSymbol(string $type, string $alias, ?string $name = null, ?AbstractExpression $node = null): void
  272.     {
  273.         $this->importedSymbols[0][$type][$alias] = ['name' => $name, 'node' => $node];
  274.     }
  276.     public function getImportedSymbol(string $type, string $alias)
  277.     {
  278.         // if the symbol does not exist in the current scope (0), try in the main/global scope (last index)
  279.         return $this->importedSymbols[0][$type][$alias] ?? ($this->importedSymbols[\count($this->importedSymbols) - 1][$type][$alias] ?? null);
  280.     }
  282.     public function isMainScope(): bool
  283.     {
  284.         return 1 === \count($this->importedSymbols);
  285.     }
  287.     public function pushLocalScope(): void
  288.     {
  289.         array_unshift($this->importedSymbols, []);
  290.     }
  292.     public function popLocalScope(): void
  293.     {
  294.         array_shift($this->importedSymbols);
  295.     }
  297.     public function getExpressionParser(): ExpressionParser
  298.     {
  299.         return $this->expressionParser;
  300.     }
  302.     public function getParent(): ?Node
  303.     {
  304.         trigger_deprecation('twig/twig', '3.12', 'Method "%s()" is deprecated.', __METHOD__);
  306.         return $this->parent;
  307.     }
  309.     public function hasInheritance()
  310.     {
  311.         return $this->parent || 0 < \count($this->traits);
  312.     }
  314.     public function setParent(?Node $parent): void
  315.     {
  316.         if (null === $parent) {
  317.             trigger_deprecation('twig/twig', '3.12', 'Passing "null" to "%s()" is deprecated.', __METHOD__);
  318.         }
  320.         if (null !== $this->parent) {
  321.             throw new SyntaxError('Multiple extends tags are forbidden.', $parent->getTemplateLine(), $parent->getSourceContext());
  322.         }
  324.         $this->parent = $parent;
  325.     }
  327.     public function getStream(): TokenStream
  328.     {
  329.         return $this->stream;
  330.     }
  332.     public function getCurrentToken(): Token
  333.     {
  334.         return $this->stream->getCurrent();
  335.     }
  337.     private function filterBodyNodes(Node $node, bool $nested = false): ?Node
  338.     {
  339.         // check that the body does not contain non-empty output nodes
  340.         if (
  341.             ($node instanceof TextNode && !ctype_space($node->getAttribute('data')))
  342.             || (!$node instanceof TextNode && !$node instanceof BlockReferenceNode && $node instanceof NodeOutputInterface)
  343.         ) {
  344.             if (str_contains((string) $node, \chr(0xEF).\chr(0xBB).\chr(0xBF))) {
  345.                 $t = substr($node->getAttribute('data'), 3);
  346.                 if ('' === $t || ctype_space($t)) {
  347.                     // bypass empty nodes starting with a BOM
  348.                     return null;
  349.                 }
  350.             }
  352.             throw new SyntaxError('A template that extends another one cannot include content outside Twig blocks. Did you forget to put the content inside a {% block %} tag?', $node->getTemplateLine(), $this->stream->getSourceContext());
  353.         }
  355.         // bypass nodes that "capture" the output
  356.         if ($node instanceof NodeCaptureInterface) {
  357.             // a "block" tag in such a node will serve as a block definition AND be displayed in place as well
  358.             return $node;
  359.         }
  361.         // "block" tags that are not captured (see above) are only used for defining
  362.         // the content of the block. In such a case, nesting it does not work as
  363.         // expected as the definition is not part of the default template code flow.
  364.         if ($nested && $node instanceof BlockReferenceNode) {
  365.             throw new SyntaxError('A block definition cannot be nested under non-capturing nodes.', $node->getTemplateLine(), $this->stream->getSourceContext());
  366.         }
  368.         if ($node instanceof NodeOutputInterface) {
  369.             return null;
  370.         }
  372.         // here, $nested means "being at the root level of a child template"
  373.         // we need to discard the wrapping "Node" for the "body" node
  374.         $nested = $nested || Node::class !== \get_class($node);
  375.         foreach ($node as $k => $n) {
  376.             if (null !== $n && null === $this->filterBodyNodes($n, $nested)) {
  377.                 $node->removeNode($k);
  378.             }
  379.         }
  381.         return $node;
  382.     }
  383. }