vendor/twig/twig/src/Compiler.php line 103

  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\Node\Node;
  17. /**
  18.  * @author Fabien Potencier <fabien@symfony.com>
  19.  */
  20. class Compiler
  21. {
  22.     private $lastLine;
  23.     private $source;
  24.     private $indentation;
  25.     private $env;
  26.     private $debugInfo = [];
  27.     private $sourceOffset;
  28.     private $sourceLine;
  29.     private $varNameSalt = 0;
  30.     private $didUseEcho = false;
  31.     private $didUseEchoStack = [];
  33.     public function __construct(Environment $env)
  34.     {
  35.         $this->env = $env;
  36.     }
  38.     public function getEnvironment(): Environment
  39.     {
  40.         return $this->env;
  41.     }
  43.     public function getSource(): string
  44.     {
  45.         return $this->source;
  46.     }
  48.     /**
  49.      * @return $this
  50.      */
  51.     public function reset(int $indentation = 0)
  52.     {
  53.         $this->lastLine = null;
  54.         $this->source = '';
  55.         $this->debugInfo = [];
  56.         $this->sourceOffset = 0;
  57.         // source code starts at 1 (as we then increment it when we encounter new lines)
  58.         $this->sourceLine = 1;
  59.         $this->indentation = $indentation;
  60.         $this->varNameSalt = 0;
  62.         return $this;
  63.     }
  65.     /**
  66.      * @return $this
  67.      */
  68.     public function compile(Node $node, int $indentation = 0)
  69.     {
  70.         $this->reset($indentation);
  71.         $this->didUseEchoStack[] = $this->didUseEcho;
  73.         try {
  74.             $this->didUseEcho = false;
  75.             $node->compile($this);
  77.             if ($this->didUseEcho) {
  78.                 trigger_deprecation('twig/twig', '3.9', 'Using "%s" is deprecated, use "yield" instead in "%s", then flag the class with #[YieldReady].', $this->didUseEcho, \get_class($node));
  79.             }
  81.             return $this;
  82.         } finally {
  83.             $this->didUseEcho = array_pop($this->didUseEchoStack);
  84.         }
  85.     }
  87.     /**
  88.      * @return $this
  89.      */
  90.     public function subcompile(Node $node, bool $raw = true)
  91.     {
  92.         if (!$raw) {
  93.             $this->source .= str_repeat(' ', $this->indentation * 4);
  94.         }
  96.         $this->didUseEchoStack[] = $this->didUseEcho;
  98.         try {
  99.             $this->didUseEcho = false;
  100.             $node->compile($this);
  102.             if ($this->didUseEcho) {
  103.                 trigger_deprecation('twig/twig', '3.9', 'Using "%s" is deprecated, use "yield" instead in "%s", then flag the class with #[YieldReady].', $this->didUseEcho, \get_class($node));
  104.             }
  106.             return $this;
  107.         } finally {
  108.             $this->didUseEcho = array_pop($this->didUseEchoStack);
  109.         }
  110.     }
  112.     /**
  113.      * Adds a raw string to the compiled code.
  114.      *
  115.      * @return $this
  116.      */
  117.     public function raw(string $string)
  118.     {
  119.         $this->checkForEcho($string);
  120.         $this->source .= $string;
  122.         return $this;
  123.     }
  125.     /**
  126.      * Writes a string to the compiled code by adding indentation.
  127.      *
  128.      * @return $this
  129.      */
  130.     public function write(...$strings)
  131.     {
  132.         foreach ($strings as $string) {
  133.             $this->checkForEcho($string);
  134.             $this->source .= str_repeat(' ', $this->indentation * 4).$string;
  135.         }
  137.         return $this;
  138.     }
  140.     /**
  141.      * Adds a quoted string to the compiled code.
  142.      *
  143.      * @return $this
  144.      */
  145.     public function string(string $value)
  146.     {
  147.         $this->source .= sprintf('"%s"', addcslashes($value, "\0\t\"\$\\"));
  149.         return $this;
  150.     }
  152.     /**
  153.      * Returns a PHP representation of a given value.
  154.      *
  155.      * @return $this
  156.      */
  157.     public function repr($value)
  158.     {
  159.         if (\is_int($value) || \is_float($value)) {
  160.             if (false !== $locale = setlocale(\LC_NUMERIC, '0')) {
  161.                 setlocale(\LC_NUMERIC, 'C');
  162.             }
  164.             $this->raw(var_export($value, true));
  166.             if (false !== $locale) {
  167.                 setlocale(\LC_NUMERIC, $locale);
  168.             }
  169.         } elseif (null === $value) {
  170.             $this->raw('null');
  171.         } elseif (\is_bool($value)) {
  172.             $this->raw($value ? 'true' : 'false');
  173.         } elseif (\is_array($value)) {
  174.             $this->raw('array(');
  175.             $first = true;
  176.             foreach ($value as $key => $v) {
  177.                 if (!$first) {
  178.                     $this->raw(', ');
  179.                 }
  180.                 $first = false;
  181.                 $this->repr($key);
  182.                 $this->raw(' => ');
  183.                 $this->repr($v);
  184.             }
  185.             $this->raw(')');
  186.         } else {
  187.             $this->string($value);
  188.         }
  190.         return $this;
  191.     }
  193.     /**
  194.      * @return $this
  195.      */
  196.     public function addDebugInfo(Node $node)
  197.     {
  198.         if ($node->getTemplateLine() != $this->lastLine) {
  199.             $this->write(sprintf("// line %d\n", $node->getTemplateLine()));
  201.             $this->sourceLine += substr_count($this->source, "\n", $this->sourceOffset);
  202.             $this->sourceOffset = \strlen($this->source);
  203.             $this->debugInfo[$this->sourceLine] = $node->getTemplateLine();
  205.             $this->lastLine = $node->getTemplateLine();
  206.         }
  208.         return $this;
  209.     }
  211.     public function getDebugInfo(): array
  212.     {
  213.         ksort($this->debugInfo);
  215.         return $this->debugInfo;
  216.     }
  218.     /**
  219.      * @return $this
  220.      */
  221.     public function indent(int $step = 1)
  222.     {
  223.         $this->indentation += $step;
  225.         return $this;
  226.     }
  228.     /**
  229.      * @return $this
  230.      *
  231.      * @throws \LogicException When trying to outdent too much so the indentation would become negative
  232.      */
  233.     public function outdent(int $step = 1)
  234.     {
  235.         // can't outdent by more steps than the current indentation level
  236.         if ($this->indentation < $step) {
  237.             throw new \LogicException('Unable to call outdent() as the indentation would become negative.');
  238.         }
  240.         $this->indentation -= $step;
  242.         return $this;
  243.     }
  245.     public function getVarName(): string
  246.     {
  247.         return sprintf('__internal_compile_%d', $this->varNameSalt++);
  248.     }
  250.     private function checkForEcho(string $string): void
  251.     {
  252.         if ($this->didUseEcho) {
  253.             return;
  254.         }
  256.         $this->didUseEcho = preg_match('/^\s*+(echo|print)\b/', $string, $m) ? $m[1] : false;
  257.     }
  258. }