vendor/symfony/expression-language/Node/BinaryNode.php line 92

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  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 Symfony\Component\ExpressionLanguage\Node;
  14. use Symfony\Component\ExpressionLanguage\Compiler;
  15. use Symfony\Component\ExpressionLanguage\SyntaxError;
  17. /**
  18.  * @author Fabien Potencier <fabien@symfony.com>
  19.  *
  20.  * @internal
  21.  */
  22. class BinaryNode extends Node
  23. {
  24.     private const OPERATORS = [
  25.         '~' => '.',
  26.         'and' => '&&',
  27.         'or' => '||',
  28.     ];
  30.     private const FUNCTIONS = [
  31.         '**' => 'pow',
  32.         '..' => 'range',
  33.         'in' => 'in_array',
  34.         'not in' => '!in_array',
  35.     ];
  37.     public function __construct(string $operator, Node $left, Node $right)
  38.     {
  39.         parent::__construct(
  40.             ['left' => $left, 'right' => $right],
  41.             ['operator' => $operator]
  42.         );
  43.     }
  45.     public function compile(Compiler $compiler)
  46.     {
  47.         $operator = $this->attributes['operator'];
  49.         if ('matches' == $operator) {
  50.             if ($this->nodes['right'] instanceof ConstantNode) {
  51.                 $this->evaluateMatches($this->nodes['right']->evaluate([], []), '');
  52.             }
  54.             $compiler
  55.                 ->raw('(static function ($regexp, $str) { set_error_handler(function ($t, $m) use ($regexp, $str) { throw new \Symfony\Component\ExpressionLanguage\SyntaxError(sprintf(\'Regexp "%s" passed to "matches" is not valid\', $regexp).substr($m, 12)); }); try { return preg_match($regexp, (string) $str); } finally { restore_error_handler(); } })(')
  56.                 ->compile($this->nodes['right'])
  57.                 ->raw(', ')
  58.                 ->compile($this->nodes['left'])
  59.                 ->raw(')')
  60.             ;
  62.             return;
  63.         }
  65.         if (isset(self::FUNCTIONS[$operator])) {
  66.             $compiler
  67.                 ->raw(sprintf('%s(', self::FUNCTIONS[$operator]))
  68.                 ->compile($this->nodes['left'])
  69.                 ->raw(', ')
  70.                 ->compile($this->nodes['right'])
  71.                 ->raw(')')
  72.             ;
  74.             return;
  75.         }
  77.         if (isset(self::OPERATORS[$operator])) {
  78.             $operator = self::OPERATORS[$operator];
  79.         }
  81.         $compiler
  82.             ->raw('(')
  83.             ->compile($this->nodes['left'])
  84.             ->raw(' ')
  85.             ->raw($operator)
  86.             ->raw(' ')
  87.             ->compile($this->nodes['right'])
  88.             ->raw(')')
  89.         ;
  90.     }
  92.     public function evaluate(array $functions, array $values)
  93.     {
  94.         $operator = $this->attributes['operator'];
  95.         $left = $this->nodes['left']->evaluate($functions, $values);
  97.         if (isset(self::FUNCTIONS[$operator])) {
  98.             $right = $this->nodes['right']->evaluate($functions, $values);
  100.             if ('not in' === $operator) {
  101.                 return !\in_array($left, $right);
  102.             }
  103.             $f = self::FUNCTIONS[$operator];
  105.             return $f($left, $right);
  106.         }
  108.         switch ($operator) {
  109.             case 'or':
  110.             case '||':
  111.                 return $left || $this->nodes['right']->evaluate($functions, $values);
  112.             case 'and':
  113.             case '&&':
  114.                 return $left && $this->nodes['right']->evaluate($functions, $values);
  115.         }
  117.         $right = $this->nodes['right']->evaluate($functions, $values);
  119.         switch ($operator) {
  120.             case '|':
  121.                 return $left | $right;
  122.             case '^':
  123.                 return $left ^ $right;
  124.             case '&':
  125.                 return $left & $right;
  126.             case '==':
  127.                 return $left == $right;
  128.             case '===':
  129.                 return $left === $right;
  130.             case '!=':
  131.                 return $left != $right;
  132.             case '!==':
  133.                 return $left !== $right;
  134.             case '<':
  135.                 return $left < $right;
  136.             case '>':
  137.                 return $left > $right;
  138.             case '>=':
  139.                 return $left >= $right;
  140.             case '<=':
  141.                 return $left <= $right;
  142.             case 'not in':
  143.                 return !\in_array($left, $right);
  144.             case 'in':
  145.                 return \in_array($left, $right);
  146.             case '+':
  147.                 return $left + $right;
  148.             case '-':
  149.                 return $left - $right;
  150.             case '~':
  151.                 return $left.$right;
  152.             case '*':
  153.                 return $left * $right;
  154.             case '/':
  155.                 if (0 == $right) {
  156.                     throw new \DivisionByZeroError('Division by zero.');
  157.                 }
  159.                 return $left / $right;
  160.             case '%':
  161.                 if (0 == $right) {
  162.                     throw new \DivisionByZeroError('Modulo by zero.');
  163.                 }
  165.                 return $left % $right;
  166.             case 'matches':
  167.                 return $this->evaluateMatches($right, $left);
  168.         }
  169.     }
  171.     public function toArray()
  172.     {
  173.         return ['(', $this->nodes['left'], ' '.$this->attributes['operator'].' ', $this->nodes['right'], ')'];
  174.     }
  176.     private function evaluateMatches(string $regexp, ?string $str): int
  177.     {
  178.         set_error_handler(function ($t, $m) use ($regexp) {
  179.             throw new SyntaxError(sprintf('Regexp "%s" passed to "matches" is not valid', $regexp).substr($m, 12));
  180.         });
  181.         try {
  182.             return preg_match($regexp, (string) $str);
  183.         } finally {
  184.             restore_error_handler();
  185.         }
  186.     }
  187. }