vendor/twig/twig/src/ExpressionParser.php line 438

Open in your IDE?
  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\Expression\AbstractExpression;
  17. use Twig\Node\Expression\ArrayExpression;
  18. use Twig\Node\Expression\ArrowFunctionExpression;
  19. use Twig\Node\Expression\AssignNameExpression;
  20. use Twig\Node\Expression\Binary\ConcatBinary;
  21. use Twig\Node\Expression\BlockReferenceExpression;
  22. use Twig\Node\Expression\ConditionalExpression;
  23. use Twig\Node\Expression\ConstantExpression;
  24. use Twig\Node\Expression\GetAttrExpression;
  25. use Twig\Node\Expression\MethodCallExpression;
  26. use Twig\Node\Expression\NameExpression;
  27. use Twig\Node\Expression\ParentExpression;
  28. use Twig\Node\Expression\TestExpression;
  29. use Twig\Node\Expression\Unary\NegUnary;
  30. use Twig\Node\Expression\Unary\NotUnary;
  31. use Twig\Node\Expression\Unary\PosUnary;
  32. use Twig\Node\Node;
  34. /**
  35. * Parses expressions.
  36. *
  37. * This parser implements a "Precedence climbing" algorithm.
  38. *
  39. * @see https://www.engr.mun.ca/~theo/Misc/exp_parsing.htm
  40. * @see https://en.wikipedia.org/wiki/Operator-precedence_parser
  41. *
  42. * @author Fabien Potencier <fabien@symfony.com>
  43. *
  44. * @internal
  45. */
  46. class ExpressionParser
  47. {
  48. public const OPERATOR_LEFT = 1;
  49. public const OPERATOR_RIGHT = 2;
  51. private $parser;
  52. private $env;
  53. private $unaryOperators;
  54. private $binaryOperators;
  56. public function __construct(Parser $parser, Environment $env)
  57. {
  58. $this->parser = $parser;
  59. $this->env = $env;
  60. $this->unaryOperators = $env->getUnaryOperators();
  61. $this->binaryOperators = $env->getBinaryOperators();
  62. }
  64. public function parseExpression($precedence = 0, $allowArrow = false)
  65. {
  66. if ($allowArrow && $arrow = $this->parseArrow()) {
  67. return $arrow;
  68. }
  70. $expr = $this->getPrimary();
  71. $token = $this->parser->getCurrentToken();
  72. while ($this->isBinary($token) && $this->binaryOperators[$token->getValue()]['precedence'] >= $precedence) {
  73. $op = $this->binaryOperators[$token->getValue()];
  74. $this->parser->getStream()->next();
  76. if ('is not' === $token->getValue()) {
  77. $expr = $this->parseNotTestExpression($expr);
  78. } elseif ('is' === $token->getValue()) {
  79. $expr = $this->parseTestExpression($expr);
  80. } elseif (isset($op['callable'])) {
  81. $expr = $op['callable']($this->parser, $expr);
  82. } else {
  83. $expr1 = $this->parseExpression(self::OPERATOR_LEFT === $op['associativity'] ? $op['precedence'] + 1 : $op['precedence']);
  84. $class = $op['class'];
  85. $expr = new $class($expr, $expr1, $token->getLine());
  86. }
  88. $token = $this->parser->getCurrentToken();
  89. }
  91. if (0 === $precedence) {
  92. return $this->parseConditionalExpression($expr);
  93. }
  95. return $expr;
  96. }
  98. /**
  99. * @return ArrowFunctionExpression|null
  100. */
  101. private function parseArrow()
  102. {
  103. $stream = $this->parser->getStream();
  105. // short array syntax (one argument, no parentheses)?
  106. if ($stream->look(1)->test(/* Token::ARROW_TYPE */ 12)) {
  107. $line = $stream->getCurrent()->getLine();
  108. $token = $stream->expect(/* Token::NAME_TYPE */ 5);
  109. $names = [new AssignNameExpression($token->getValue(), $token->getLine())];
  110. $stream->expect(/* Token::ARROW_TYPE */ 12);
  112. return new ArrowFunctionExpression($this->parseExpression(0), new Node($names), $line);
  113. }
  115. // first, determine if we are parsing an arrow function by finding => (long form)
  116. $i = 0;
  117. if (!$stream->look($i)->test(/* Token::PUNCTUATION_TYPE */ 9, '(')) {
  118. return null;
  119. }
  120. ++$i;
  121. while (true) {
  122. // variable name
  123. ++$i;
  124. if (!$stream->look($i)->test(/* Token::PUNCTUATION_TYPE */ 9, ',')) {
  125. break;
  126. }
  127. ++$i;
  128. }
  129. if (!$stream->look($i)->test(/* Token::PUNCTUATION_TYPE */ 9, ')')) {
  130. return null;
  131. }
  132. ++$i;
  133. if (!$stream->look($i)->test(/* Token::ARROW_TYPE */ 12)) {
  134. return null;
  135. }
  137. // yes, let's parse it properly
  138. $token = $stream->expect(/* Token::PUNCTUATION_TYPE */ 9, '(');
  139. $line = $token->getLine();
  141. $names = [];
  142. while (true) {
  143. $token = $stream->expect(/* Token::NAME_TYPE */ 5);
  144. $names[] = new AssignNameExpression($token->getValue(), $token->getLine());
  146. if (!$stream->nextIf(/* Token::PUNCTUATION_TYPE */ 9, ',')) {
  147. break;
  148. }
  149. }
  150. $stream->expect(/* Token::PUNCTUATION_TYPE */ 9, ')');
  151. $stream->expect(/* Token::ARROW_TYPE */ 12);
  153. return new ArrowFunctionExpression($this->parseExpression(0), new Node($names), $line);
  154. }
  156. private function getPrimary(): AbstractExpression
  157. {
  158. $token = $this->parser->getCurrentToken();
  160. if ($this->isUnary($token)) {
  161. $operator = $this->unaryOperators[$token->getValue()];
  162. $this->parser->getStream()->next();
  163. $expr = $this->parseExpression($operator['precedence']);
  164. $class = $operator['class'];
  166. return $this->parsePostfixExpression(new $class($expr, $token->getLine()));
  167. } elseif ($token->test(/* Token::PUNCTUATION_TYPE */ 9, '(')) {
  168. $this->parser->getStream()->next();
  169. $expr = $this->parseExpression();
  170. $this->parser->getStream()->expect(/* Token::PUNCTUATION_TYPE */ 9, ')', 'An opened parenthesis is not properly closed');
  172. return $this->parsePostfixExpression($expr);
  173. }
  175. return $this->parsePrimaryExpression();
  176. }
  178. private function parseConditionalExpression($expr): AbstractExpression
  179. {
  180. while ($this->parser->getStream()->nextIf(/* Token::PUNCTUATION_TYPE */ 9, '?')) {
  181. if (!$this->parser->getStream()->nextIf(/* Token::PUNCTUATION_TYPE */ 9, ':')) {
  182. $expr2 = $this->parseExpression();
  183. if ($this->parser->getStream()->nextIf(/* Token::PUNCTUATION_TYPE */ 9, ':')) {
  184. $expr3 = $this->parseExpression();
  185. } else {
  186. $expr3 = new ConstantExpression('', $this->parser->getCurrentToken()->getLine());
  187. }
  188. } else {
  189. $expr2 = $expr;
  190. $expr3 = $this->parseExpression();
  191. }
  193. $expr = new ConditionalExpression($expr, $expr2, $expr3, $this->parser->getCurrentToken()->getLine());
  194. }
  196. return $expr;
  197. }
  199. private function isUnary(Token $token): bool
  200. {
  201. return $token->test(/* Token::OPERATOR_TYPE */ 8) && isset($this->unaryOperators[$token->getValue()]);
  202. }
  204. private function isBinary(Token $token): bool
  205. {
  206. return $token->test(/* Token::OPERATOR_TYPE */ 8) && isset($this->binaryOperators[$token->getValue()]);
  207. }
  209. public function parsePrimaryExpression()
  210. {
  211. $token = $this->parser->getCurrentToken();
  212. switch ($token->getType()) {
  213. case /* Token::NAME_TYPE */ 5:
  214. $this->parser->getStream()->next();
  215. switch ($token->getValue()) {
  216. case 'true':
  217. case 'TRUE':
  218. $node = new ConstantExpression(true, $token->getLine());
  219. break;
  221. case 'false':
  222. case 'FALSE':
  223. $node = new ConstantExpression(false, $token->getLine());
  224. break;
  226. case 'none':
  227. case 'NONE':
  228. case 'null':
  229. case 'NULL':
  230. $node = new ConstantExpression(null, $token->getLine());
  231. break;
  233. default:
  234. if ('(' === $this->parser->getCurrentToken()->getValue()) {
  235. $node = $this->getFunctionNode($token->getValue(), $token->getLine());
  236. } else {
  237. $node = new NameExpression($token->getValue(), $token->getLine());
  238. }
  239. }
  240. break;
  242. case /* Token::NUMBER_TYPE */ 6:
  243. $this->parser->getStream()->next();
  244. $node = new ConstantExpression($token->getValue(), $token->getLine());
  245. break;
  247. case /* Token::STRING_TYPE */ 7:
  248. case /* Token::INTERPOLATION_START_TYPE */ 10:
  249. $node = $this->parseStringExpression();
  250. break;
  252. case /* Token::OPERATOR_TYPE */ 8:
  253. if (preg_match(Lexer::REGEX_NAME, $token->getValue(), $matches) && $matches[0] == $token->getValue()) {
  254. // in this context, string operators are variable names
  255. $this->parser->getStream()->next();
  256. $node = new NameExpression($token->getValue(), $token->getLine());
  257. break;
  258. } elseif (isset($this->unaryOperators[$token->getValue()])) {
  259. $class = $this->unaryOperators[$token->getValue()]['class'];
  261. $ref = new \ReflectionClass($class);
  262. if (!(\in_array($ref->getName(), [NegUnary::class, PosUnary::class, 'Twig_Node_Expression_Unary_Neg', 'Twig_Node_Expression_Unary_Pos'])
  263. || $ref->isSubclassOf(NegUnary::class) || $ref->isSubclassOf(PosUnary::class)
  264. || $ref->isSubclassOf('Twig_Node_Expression_Unary_Neg') || $ref->isSubclassOf('Twig_Node_Expression_Unary_Pos'))
  265. ) {
  266. throw new SyntaxError(sprintf('Unexpected unary operator "%s".', $token->getValue()), $token->getLine(), $this->parser->getStream()->getSourceContext());
  267. }
  269. $this->parser->getStream()->next();
  270. $expr = $this->parsePrimaryExpression();
  272. $node = new $class($expr, $token->getLine());
  273. break;
  274. }
  276. // no break
  277. default:
  278. if ($token->test(/* Token::PUNCTUATION_TYPE */ 9, '[')) {
  279. $node = $this->parseArrayExpression();
  280. } elseif ($token->test(/* Token::PUNCTUATION_TYPE */ 9, '{')) {
  281. $node = $this->parseHashExpression();
  282. } elseif ($token->test(/* Token::OPERATOR_TYPE */ 8, '=') && ('==' === $this->parser->getStream()->look(-1)->getValue() || '!=' === $this->parser->getStream()->look(-1)->getValue())) {
  283. throw new SyntaxError(sprintf('Unexpected operator of value "%s". Did you try to use "===" or "!==" for strict comparison? Use "is same as(value)" instead.', $token->getValue()), $token->getLine(), $this->parser->getStream()->getSourceContext());
  284. } else {
  285. throw new SyntaxError(sprintf('Unexpected token "%s" of value "%s".', Token::typeToEnglish($token->getType()), $token->getValue()), $token->getLine(), $this->parser->getStream()->getSourceContext());
  286. }
  287. }
  289. return $this->parsePostfixExpression($node);
  290. }
  292. public function parseStringExpression()
  293. {
  294. $stream = $this->parser->getStream();
  296. $nodes = [];
  297. // a string cannot be followed by another string in a single expression
  298. $nextCanBeString = true;
  299. while (true) {
  300. if ($nextCanBeString && $token = $stream->nextIf(/* Token::STRING_TYPE */ 7)) {
  301. $nodes[] = new ConstantExpression($token->getValue(), $token->getLine());
  302. $nextCanBeString = false;
  303. } elseif ($stream->nextIf(/* Token::INTERPOLATION_START_TYPE */ 10)) {
  304. $nodes[] = $this->parseExpression();
  305. $stream->expect(/* Token::INTERPOLATION_END_TYPE */ 11);
  306. $nextCanBeString = true;
  307. } else {
  308. break;
  309. }
  310. }
  312. $expr = array_shift($nodes);
  313. foreach ($nodes as $node) {
  314. $expr = new ConcatBinary($expr, $node, $node->getTemplateLine());
  315. }
  317. return $expr;
  318. }
  320. public function parseArrayExpression()
  321. {
  322. $stream = $this->parser->getStream();
  323. $stream->expect(/* Token::PUNCTUATION_TYPE */ 9, '[', 'An array element was expected');
  325. $node = new ArrayExpression([], $stream->getCurrent()->getLine());
  326. $first = true;
  327. while (!$stream->test(/* Token::PUNCTUATION_TYPE */ 9, ']')) {
  328. if (!$first) {
  329. $stream->expect(/* Token::PUNCTUATION_TYPE */ 9, ',', 'An array element must be followed by a comma');
  331. // trailing ,?
  332. if ($stream->test(/* Token::PUNCTUATION_TYPE */ 9, ']')) {
  333. break;
  334. }
  335. }
  336. $first = false;
  338. $node->addElement($this->parseExpression());
  339. }
  340. $stream->expect(/* Token::PUNCTUATION_TYPE */ 9, ']', 'An opened array is not properly closed');
  342. return $node;
  343. }
  345. public function parseHashExpression()
  346. {
  347. $stream = $this->parser->getStream();
  348. $stream->expect(/* Token::PUNCTUATION_TYPE */ 9, '{', 'A hash element was expected');
  350. $node = new ArrayExpression([], $stream->getCurrent()->getLine());
  351. $first = true;
  352. while (!$stream->test(/* Token::PUNCTUATION_TYPE */ 9, '}')) {
  353. if (!$first) {
  354. $stream->expect(/* Token::PUNCTUATION_TYPE */ 9, ',', 'A hash value must be followed by a comma');
  356. // trailing ,?
  357. if ($stream->test(/* Token::PUNCTUATION_TYPE */ 9, '}')) {
  358. break;
  359. }
  360. }
  361. $first = false;
  363. // a hash key can be:
  364. //
  365. // * a number -- 12
  366. // * a string -- 'a'
  367. // * a name, which is equivalent to a string -- a
  368. // * an expression, which must be enclosed in parentheses -- (1 + 2)
  369. if ($token = $stream->nextIf(/* Token::NAME_TYPE */ 5)) {
  370. $key = new ConstantExpression($token->getValue(), $token->getLine());
  372. // {a} is a shortcut for {a:a}
  373. if ($stream->test(Token::PUNCTUATION_TYPE, [',', '}'])) {
  374. $value = new NameExpression($key->getAttribute('value'), $key->getTemplateLine());
  375. $node->addElement($value, $key);
  376. continue;
  377. }
  378. } elseif (($token = $stream->nextIf(/* Token::STRING_TYPE */ 7)) || $token = $stream->nextIf(/* Token::NUMBER_TYPE */ 6)) {
  379. $key = new ConstantExpression($token->getValue(), $token->getLine());
  380. } elseif ($stream->test(/* Token::PUNCTUATION_TYPE */ 9, '(')) {
  381. $key = $this->parseExpression();
  382. } else {
  383. $current = $stream->getCurrent();
  385. throw new SyntaxError(sprintf('A hash key must be a quoted string, a number, a name, or an expression enclosed in parentheses (unexpected token "%s" of value "%s".', Token::typeToEnglish($current->getType()), $current->getValue()), $current->getLine(), $stream->getSourceContext());
  386. }
  388. $stream->expect(/* Token::PUNCTUATION_TYPE */ 9, ':', 'A hash key must be followed by a colon (:)');
  389. $value = $this->parseExpression();
  391. $node->addElement($value, $key);
  392. }
  393. $stream->expect(/* Token::PUNCTUATION_TYPE */ 9, '}', 'An opened hash is not properly closed');
  395. return $node;
  396. }
  398. public function parsePostfixExpression($node)
  399. {
  400. while (true) {
  401. $token = $this->parser->getCurrentToken();
  402. if (/* Token::PUNCTUATION_TYPE */ 9 == $token->getType()) {
  403. if ('.' == $token->getValue() || '[' == $token->getValue()) {
  404. $node = $this->parseSubscriptExpression($node);
  405. } elseif ('|' == $token->getValue()) {
  406. $node = $this->parseFilterExpression($node);
  407. } else {
  408. break;
  409. }
  410. } else {
  411. break;
  412. }
  413. }
  415. return $node;
  416. }
  418. public function getFunctionNode($name, $line)
  419. {
  420. switch ($name) {
  421. case 'parent':
  422. $this->parseArguments();
  423. if (!\count($this->parser->getBlockStack())) {
  424. throw new SyntaxError('Calling "parent" outside a block is forbidden.', $line, $this->parser->getStream()->getSourceContext());
  425. }
  427. if (!$this->parser->getParent() && !$this->parser->hasTraits()) {
  428. throw new SyntaxError('Calling "parent" on a template that does not extend nor "use" another template is forbidden.', $line, $this->parser->getStream()->getSourceContext());
  429. }
  431. return new ParentExpression($this->parser->peekBlockStack(), $line);
  432. case 'block':
  433. $args = $this->parseArguments();
  434. if (\count($args) < 1) {
  435. throw new SyntaxError('The "block" function takes one argument (the block name).', $line, $this->parser->getStream()->getSourceContext());
  436. }
  438. return new BlockReferenceExpression($args->getNode(0), \count($args) > 1 ? $args->getNode(1) : null, $line);
  439. case 'attribute':
  440. $args = $this->parseArguments();
  441. if (\count($args) < 2) {
  442. throw new SyntaxError('The "attribute" function takes at least two arguments (the variable and the attributes).', $line, $this->parser->getStream()->getSourceContext());
  443. }
  445. return new GetAttrExpression($args->getNode(0), $args->getNode(1), \count($args) > 2 ? $args->getNode(2) : null, Template::ANY_CALL, $line);
  446. default:
  447. if (null !== $alias = $this->parser->getImportedSymbol('function', $name)) {
  448. $arguments = new ArrayExpression([], $line);
  449. foreach ($this->parseArguments() as $n) {
  450. $arguments->addElement($n);
  451. }
  453. $node = new MethodCallExpression($alias['node'], $alias['name'], $arguments, $line);
  454. $node->setAttribute('safe', true);
  456. return $node;
  457. }
  459. $args = $this->parseArguments(true);
  460. $class = $this->getFunctionNodeClass($name, $line);
  462. return new $class($name, $args, $line);
  463. }
  464. }
  466. public function parseSubscriptExpression($node)
  467. {
  468. $stream = $this->parser->getStream();
  469. $token = $stream->next();
  470. $lineno = $token->getLine();
  471. $arguments = new ArrayExpression([], $lineno);
  472. $type = Template::ANY_CALL;
  473. if ('.' == $token->getValue()) {
  474. $token = $stream->next();
  475. if (
  476. /* Token::NAME_TYPE */ 5 == $token->getType()
  477. ||
  478. /* Token::NUMBER_TYPE */ 6 == $token->getType()
  479. ||
  480. (/* Token::OPERATOR_TYPE */ 8 == $token->getType() && preg_match(Lexer::REGEX_NAME, $token->getValue()))
  481. ) {
  482. $arg = new ConstantExpression($token->getValue(), $lineno);
  484. if ($stream->test(/* Token::PUNCTUATION_TYPE */ 9, '(')) {
  485. $type = Template::METHOD_CALL;
  486. foreach ($this->parseArguments() as $n) {
  487. $arguments->addElement($n);
  488. }
  489. }
  490. } else {
  491. throw new SyntaxError(sprintf('Expected name or number, got value "%s" of type %s.', $token->getValue(), Token::typeToEnglish($token->getType())), $lineno, $stream->getSourceContext());
  492. }
  494. if ($node instanceof NameExpression && null !== $this->parser->getImportedSymbol('template', $node->getAttribute('name'))) {
  495. if (!$arg instanceof ConstantExpression) {
  496. throw new SyntaxError(sprintf('Dynamic macro names are not supported (called on "%s").', $node->getAttribute('name')), $token->getLine(), $stream->getSourceContext());
  497. }
  499. $name = $arg->getAttribute('value');
  501. $node = new MethodCallExpression($node, 'macro_'.$name, $arguments, $lineno);
  502. $node->setAttribute('safe', true);
  504. return $node;
  505. }
  506. } else {
  507. $type = Template::ARRAY_CALL;
  509. // slice?
  510. $slice = false;
  511. if ($stream->test(/* Token::PUNCTUATION_TYPE */ 9, ':')) {
  512. $slice = true;
  513. $arg = new ConstantExpression(0, $token->getLine());
  514. } else {
  515. $arg = $this->parseExpression();
  516. }
  518. if ($stream->nextIf(/* Token::PUNCTUATION_TYPE */ 9, ':')) {
  519. $slice = true;
  520. }
  522. if ($slice) {
  523. if ($stream->test(/* Token::PUNCTUATION_TYPE */ 9, ']')) {
  524. $length = new ConstantExpression(null, $token->getLine());
  525. } else {
  526. $length = $this->parseExpression();
  527. }
  529. $class = $this->getFilterNodeClass('slice', $token->getLine());
  530. $arguments = new Node([$arg, $length]);
  531. $filter = new $class($node, new ConstantExpression('slice', $token->getLine()), $arguments, $token->getLine());
  533. $stream->expect(/* Token::PUNCTUATION_TYPE */ 9, ']');
  535. return $filter;
  536. }
  538. $stream->expect(/* Token::PUNCTUATION_TYPE */ 9, ']');
  539. }
  541. return new GetAttrExpression($node, $arg, $arguments, $type, $lineno);
  542. }
  544. public function parseFilterExpression($node)
  545. {
  546. $this->parser->getStream()->next();
  548. return $this->parseFilterExpressionRaw($node);
  549. }
  551. public function parseFilterExpressionRaw($node, $tag = null)
  552. {
  553. while (true) {
  554. $token = $this->parser->getStream()->expect(/* Token::NAME_TYPE */ 5);
  556. $name = new ConstantExpression($token->getValue(), $token->getLine());
  557. if (!$this->parser->getStream()->test(/* Token::PUNCTUATION_TYPE */ 9, '(')) {
  558. $arguments = new Node();
  559. } else {
  560. $arguments = $this->parseArguments(true, false, true);
  561. }
  563. $class = $this->getFilterNodeClass($name->getAttribute('value'), $token->getLine());
  565. $node = new $class($node, $name, $arguments, $token->getLine(), $tag);
  567. if (!$this->parser->getStream()->test(/* Token::PUNCTUATION_TYPE */ 9, '|')) {
  568. break;
  569. }
  571. $this->parser->getStream()->next();
  572. }
  574. return $node;
  575. }
  577. /**
  578. * Parses arguments.
  579. *
  580. * @param bool $namedArguments Whether to allow named arguments or not
  581. * @param bool $definition Whether we are parsing arguments for a function definition
  582. *
  583. * @return Node
  584. *
  585. * @throws SyntaxError
  586. */
  587. public function parseArguments($namedArguments = false, $definition = false, $allowArrow = false)
  588. {
  589. $args = [];
  590. $stream = $this->parser->getStream();
  592. $stream->expect(/* Token::PUNCTUATION_TYPE */ 9, '(', 'A list of arguments must begin with an opening parenthesis');
  593. while (!$stream->test(/* Token::PUNCTUATION_TYPE */ 9, ')')) {
  594. if (!empty($args)) {
  595. $stream->expect(/* Token::PUNCTUATION_TYPE */ 9, ',', 'Arguments must be separated by a comma');
  597. // if the comma above was a trailing comma, early exit the argument parse loop
  598. if ($stream->test(/* Token::PUNCTUATION_TYPE */ 9, ')')) {
  599. break;
  600. }
  601. }
  603. if ($definition) {
  604. $token = $stream->expect(/* Token::NAME_TYPE */ 5, null, 'An argument must be a name');
  605. $value = new NameExpression($token->getValue(), $this->parser->getCurrentToken()->getLine());
  606. } else {
  607. $value = $this->parseExpression(0, $allowArrow);
  608. }
  610. $name = null;
  611. if ($namedArguments && $token = $stream->nextIf(/* Token::OPERATOR_TYPE */ 8, '=')) {
  612. if (!$value instanceof NameExpression) {
  613. throw new SyntaxError(sprintf('A parameter name must be a string, "%s" given.', \get_class($value)), $token->getLine(), $stream->getSourceContext());
  614. }
  615. $name = $value->getAttribute('name');
  617. if ($definition) {
  618. $value = $this->parsePrimaryExpression();
  620. if (!$this->checkConstantExpression($value)) {
  621. throw new SyntaxError('A default value for an argument must be a constant (a boolean, a string, a number, or an array).', $token->getLine(), $stream->getSourceContext());
  622. }
  623. } else {
  624. $value = $this->parseExpression(0, $allowArrow);
  625. }
  626. }
  628. if ($definition) {
  629. if (null === $name) {
  630. $name = $value->getAttribute('name');
  631. $value = new ConstantExpression(null, $this->parser->getCurrentToken()->getLine());
  632. }
  633. $args[$name] = $value;
  634. } else {
  635. if (null === $name) {
  636. $args[] = $value;
  637. } else {
  638. $args[$name] = $value;
  639. }
  640. }
  641. }
  642. $stream->expect(/* Token::PUNCTUATION_TYPE */ 9, ')', 'A list of arguments must be closed by a parenthesis');
  644. return new Node($args);
  645. }
  647. public function parseAssignmentExpression()
  648. {
  649. $stream = $this->parser->getStream();
  650. $targets = [];
  651. while (true) {
  652. $token = $this->parser->getCurrentToken();
  653. if ($stream->test(/* Token::OPERATOR_TYPE */ 8) && preg_match(Lexer::REGEX_NAME, $token->getValue())) {
  654. // in this context, string operators are variable names
  655. $this->parser->getStream()->next();
  656. } else {
  657. $stream->expect(/* Token::NAME_TYPE */ 5, null, 'Only variables can be assigned to');
  658. }
  659. $value = $token->getValue();
  660. if (\in_array(strtr($value, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'), ['true', 'false', 'none', 'null'])) {
  661. throw new SyntaxError(sprintf('You cannot assign a value to "%s".', $value), $token->getLine(), $stream->getSourceContext());
  662. }
  663. $targets[] = new AssignNameExpression($value, $token->getLine());
  665. if (!$stream->nextIf(/* Token::PUNCTUATION_TYPE */ 9, ',')) {
  666. break;
  667. }
  668. }
  670. return new Node($targets);
  671. }
  673. public function parseMultitargetExpression()
  674. {
  675. $targets = [];
  676. while (true) {
  677. $targets[] = $this->parseExpression();
  678. if (!$this->parser->getStream()->nextIf(/* Token::PUNCTUATION_TYPE */ 9, ',')) {
  679. break;
  680. }
  681. }
  683. return new Node($targets);
  684. }
  686. private function parseNotTestExpression(Node $node): NotUnary
  687. {
  688. return new NotUnary($this->parseTestExpression($node), $this->parser->getCurrentToken()->getLine());
  689. }
  691. private function parseTestExpression(Node $node): TestExpression
  692. {
  693. $stream = $this->parser->getStream();
  694. list($name, $test) = $this->getTest($node->getTemplateLine());
  696. $class = $this->getTestNodeClass($test);
  697. $arguments = null;
  698. if ($stream->test(/* Token::PUNCTUATION_TYPE */ 9, '(')) {
  699. $arguments = $this->parseArguments(true);
  700. } elseif ($test->hasOneMandatoryArgument()) {
  701. $arguments = new Node([0 => $this->parsePrimaryExpression()]);
  702. }
  704. if ('defined' === $name && $node instanceof NameExpression && null !== $alias = $this->parser->getImportedSymbol('function', $node->getAttribute('name'))) {
  705. $node = new MethodCallExpression($alias['node'], $alias['name'], new ArrayExpression([], $node->getTemplateLine()), $node->getTemplateLine());
  706. $node->setAttribute('safe', true);
  707. }
  709. return new $class($node, $name, $arguments, $this->parser->getCurrentToken()->getLine());
  710. }
  712. private function getTest(int $line): array
  713. {
  714. $stream = $this->parser->getStream();
  715. $name = $stream->expect(/* Token::NAME_TYPE */ 5)->getValue();
  717. if ($test = $this->env->getTest($name)) {
  718. return [$name, $test];
  719. }
  721. if ($stream->test(/* Token::NAME_TYPE */ 5)) {
  722. // try 2-words tests
  723. $name = $name.' '.$this->parser->getCurrentToken()->getValue();
  725. if ($test = $this->env->getTest($name)) {
  726. $stream->next();
  728. return [$name, $test];
  729. }
  730. }
  732. $e = new SyntaxError(sprintf('Unknown "%s" test.', $name), $line, $stream->getSourceContext());
  733. $e->addSuggestions($name, array_keys($this->env->getTests()));
  735. throw $e;
  736. }
  738. private function getTestNodeClass(TwigTest $test): string
  739. {
  740. if ($test->isDeprecated()) {
  741. $stream = $this->parser->getStream();
  742. $message = sprintf('Twig Test "%s" is deprecated', $test->getName());
  744. if (!\is_bool($test->getDeprecatedVersion())) {
  745. $message .= sprintf(' since version %s', $test->getDeprecatedVersion());
  746. }
  747. if ($test->getAlternative()) {
  748. $message .= sprintf('. Use "%s" instead', $test->getAlternative());
  749. }
  750. $src = $stream->getSourceContext();
  751. $message .= sprintf(' in %s at line %d.', $src->getPath() ?: $src->getName(), $stream->getCurrent()->getLine());
  753. @trigger_error($message, \E_USER_DEPRECATED);
  754. }
  756. return $test->getNodeClass();
  757. }
  759. private function getFunctionNodeClass(string $name, int $line): string
  760. {
  761. if (false === $function = $this->env->getFunction($name)) {
  762. $e = new SyntaxError(sprintf('Unknown "%s" function.', $name), $line, $this->parser->getStream()->getSourceContext());
  763. $e->addSuggestions($name, array_keys($this->env->getFunctions()));
  765. throw $e;
  766. }
  768. if ($function->isDeprecated()) {
  769. $message = sprintf('Twig Function "%s" is deprecated', $function->getName());
  770. if (!\is_bool($function->getDeprecatedVersion())) {
  771. $message .= sprintf(' since version %s', $function->getDeprecatedVersion());
  772. }
  773. if ($function->getAlternative()) {
  774. $message .= sprintf('. Use "%s" instead', $function->getAlternative());
  775. }
  776. $src = $this->parser->getStream()->getSourceContext();
  777. $message .= sprintf(' in %s at line %d.', $src->getPath() ?: $src->getName(), $line);
  779. @trigger_error($message, \E_USER_DEPRECATED);
  780. }
  782. return $function->getNodeClass();
  783. }
  785. private function getFilterNodeClass(string $name, int $line): string
  786. {
  787. if (false === $filter = $this->env->getFilter($name)) {
  788. $e = new SyntaxError(sprintf('Unknown "%s" filter.', $name), $line, $this->parser->getStream()->getSourceContext());
  789. $e->addSuggestions($name, array_keys($this->env->getFilters()));
  791. throw $e;
  792. }
  794. if ($filter->isDeprecated()) {
  795. $message = sprintf('Twig Filter "%s" is deprecated', $filter->getName());
  796. if (!\is_bool($filter->getDeprecatedVersion())) {
  797. $message .= sprintf(' since version %s', $filter->getDeprecatedVersion());
  798. }
  799. if ($filter->getAlternative()) {
  800. $message .= sprintf('. Use "%s" instead', $filter->getAlternative());
  801. }
  802. $src = $this->parser->getStream()->getSourceContext();
  803. $message .= sprintf(' in %s at line %d.', $src->getPath() ?: $src->getName(), $line);
  805. @trigger_error($message, \E_USER_DEPRECATED);
  806. }
  808. return $filter->getNodeClass();
  809. }
  811. // checks that the node only contains "constant" elements
  812. private function checkConstantExpression(Node $node): bool
  813. {
  814. if (!($node instanceof ConstantExpression || $node instanceof ArrayExpression
  815. || $node instanceof NegUnary || $node instanceof PosUnary
  816. )) {
  817. return false;
  818. }
  820. foreach ($node as $n) {
  821. if (!$this->checkConstantExpression($n)) {
  822. return false;
  823. }
  824. }
  826. return true;
  827. }
  828. }
  830. class_alias('Twig\ExpressionParser', 'Twig_ExpressionParser');