vendor/twig/twig/src/Lexer.php line 559

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\ExpressionParser\ExpressionParsers;
  18. /**
  19. * @author Fabien Potencier <fabien@symfony.com>
  20. */
  21. class Lexer
  22. {
  23. private $isInitialized = false;
  25. private $tokens;
  26. private $code;
  27. private $cursor;
  28. private $lineno;
  29. private $end;
  30. private $state;
  31. private $states;
  32. private $brackets;
  33. private $env;
  34. private $source;
  35. private $options;
  36. private $regexes;
  37. private $position;
  38. private $positions;
  39. private $currentVarBlockLine;
  40. private array $openingBrackets = ['{', '(', '['];
  41. private array $closingBrackets = ['}', ')', ']'];
  43. public const STATE_DATA = 0;
  44. public const STATE_BLOCK = 1;
  45. public const STATE_VAR = 2;
  46. public const STATE_STRING = 3;
  47. public const STATE_INTERPOLATION = 4;
  49. public const REGEX_NAME = '/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/A';
  50. public const REGEX_STRING = '/"([^#"\\\\]*(?:\\\\.[^#"\\\\]*)*)"|\'([^\'\\\\]*(?:\\\\.[^\'\\\\]*)*)\'/As';
  52. public const REGEX_NUMBER = '/(?(DEFINE)
  53. (?<LNUM>[0-9]+(_[0-9]+)*) # Integers (with underscores) 123_456
  54. (?<FRAC>\.(?&LNUM)) # Fractional part .456
  55. (?<EXPONENT>[eE][+-]?(?&LNUM)) # Exponent part E+10
  56. (?<DNUM>(?&LNUM)(?:(?&FRAC))?) # Decimal number 123_456.456
  57. )(?:(?&DNUM)(?:(?&EXPONENT))?) # 123_456.456E+10
  58. /Ax';
  60. public const REGEX_DQ_STRING_DELIM = '/"/A';
  61. public const REGEX_DQ_STRING_PART = '/[^#"\\\\]*(?:(?:\\\\.|#(?!\{))[^#"\\\\]*)*/As';
  62. public const REGEX_INLINE_COMMENT = '/#[^\n]*/A';
  63. public const PUNCTUATION = '()[]{}?:.,|';
  65. private const REGEX_RAW_INLINE_COMMENT = '/#[^\r\n]*/A';
  67. private const SPECIAL_CHARS = [
  68. 'f' => "\f",
  69. 'n' => "\n",
  70. 'r' => "\r",
  71. 't' => "\t",
  72. 'v' => "\v",
  73. ];
  75. public function __construct(Environment $env, array $options = [])
  76. {
  77. $this->env = $env;
  79. $this->options = array_merge([
  80. 'tag_comment' => ['{#', '#}'],
  81. 'tag_block' => ['{%', '%}'],
  82. 'tag_variable' => ['{{', '}}'],
  83. 'whitespace_trim' => '-',
  84. 'whitespace_line_trim' => '~',
  85. 'whitespace_line_chars' => ' \t\0\x0B',
  86. 'interpolation' => ['#{', '}'],
  87. ], $options);
  88. }
  90. private function initialize(): void
  91. {
  92. if ($this->isInitialized) {
  93. return;
  94. }
  96. // when PHP 7.3 is the min version, we will be able to remove the '#' part in preg_quote as it's part of the default
  97. $this->regexes = [
  98. // }}
  99. 'lex_var' => '{
  100. \s*
  101. (?:'.
  102. preg_quote($this->options['whitespace_trim'].$this->options['tag_variable'][1], '#').'\s*'. // -}}\s*
  103. '|'.
  104. preg_quote($this->options['whitespace_line_trim'].$this->options['tag_variable'][1], '#').'['.$this->options['whitespace_line_chars'].']*'. // ~}}[ \t\0\x0B]*
  105. '|'.
  106. preg_quote($this->options['tag_variable'][1], '#'). // }}
  107. ')
  108. }Ax',
  110. // %}
  111. 'lex_block' => '{
  112. \s*
  113. (?:'.
  114. preg_quote($this->options['whitespace_trim'].$this->options['tag_block'][1], '#').'\s*\n?'. // -%}\s*\n?
  115. '|'.
  116. preg_quote($this->options['whitespace_line_trim'].$this->options['tag_block'][1], '#').'['.$this->options['whitespace_line_chars'].']*'. // ~%}[ \t\0\x0B]*
  117. '|'.
  118. preg_quote($this->options['tag_block'][1], '#').'(?:\r\n?|\n)?'. // %}(?:\r\n?|\n)?
  119. ')
  120. }Ax',
  122. // {% endverbatim %}
  123. 'lex_raw_data' => '{'.
  124. preg_quote($this->options['tag_block'][0], '#'). // {%
  125. '('.
  126. $this->options['whitespace_trim']. // -
  127. '|'.
  128. $this->options['whitespace_line_trim']. // ~
  129. ')?\s*endverbatim\s*'.
  130. '(?:'.
  131. preg_quote($this->options['whitespace_trim'].$this->options['tag_block'][1], '#').'\s*'. // -%}
  132. '|'.
  133. preg_quote($this->options['whitespace_line_trim'].$this->options['tag_block'][1], '#').'['.$this->options['whitespace_line_chars'].']*'. // ~%}[ \t\0\x0B]*
  134. '|'.
  135. preg_quote($this->options['tag_block'][1], '#'). // %}
  136. ')
  137. }sx',
  139. 'operator' => $this->getOperatorRegex(),
  141. // #}
  142. 'lex_comment' => '{
  143. (?:'.
  144. preg_quote($this->options['whitespace_trim'].$this->options['tag_comment'][1], '#').'\s*\n?'. // -#}\s*\n?
  145. '|'.
  146. preg_quote($this->options['whitespace_line_trim'].$this->options['tag_comment'][1], '#').'['.$this->options['whitespace_line_chars'].']*'. // ~#}[ \t\0\x0B]*
  147. '|'.
  148. preg_quote($this->options['tag_comment'][1], '#').'(?:\r\n?|\n)?'. // #}(?:\r\n?|\n)?
  149. ')
  150. }sx',
  152. // verbatim %}
  153. 'lex_block_raw' => '{
  154. \s*verbatim\s*
  155. (?:'.
  156. preg_quote($this->options['whitespace_trim'].$this->options['tag_block'][1], '#').'\s*'. // -%}\s*
  157. '|'.
  158. preg_quote($this->options['whitespace_line_trim'].$this->options['tag_block'][1], '#').'['.$this->options['whitespace_line_chars'].']*'. // ~%}[ \t\0\x0B]*
  159. '|'.
  160. preg_quote($this->options['tag_block'][1], '#'). // %}
  161. ')
  162. }Asx',
  164. 'lex_block_line' => '{\s*line\s+(\d+)\s*'.preg_quote($this->options['tag_block'][1], '#').'}As',
  166. // {{ or {% or {#
  167. 'lex_tokens_start' => '{
  168. ('.
  169. preg_quote($this->options['tag_variable'][0], '#'). // {{
  170. '|'.
  171. preg_quote($this->options['tag_block'][0], '#'). // {%
  172. '|'.
  173. preg_quote($this->options['tag_comment'][0], '#'). // {#
  174. ')('.
  175. preg_quote($this->options['whitespace_trim'], '#'). // -
  176. '|'.
  177. preg_quote($this->options['whitespace_line_trim'], '#'). // ~
  178. ')?
  179. }sx',
  180. 'interpolation_start' => '{'.preg_quote($this->options['interpolation'][0], '#').'\s*}A',
  181. 'interpolation_end' => '{\s*'.preg_quote($this->options['interpolation'][1], '#').'}A',
  182. ];
  184. $this->isInitialized = true;
  185. }
  187. public function tokenize(Source $source): TokenStream
  188. {
  189. $this->initialize();
  191. $this->source = $source;
  192. $this->code = $source->getCode();
  193. $this->cursor = 0;
  194. $this->lineno = 1;
  195. $this->end = \strlen($this->code);
  196. $this->tokens = [];
  197. $this->state = self::STATE_DATA;
  198. $this->states = [];
  199. $this->brackets = [];
  200. $this->position = -1;
  202. // find all token starts in one go
  203. preg_match_all($this->regexes['lex_tokens_start'], $this->code, $matches, \PREG_OFFSET_CAPTURE);
  204. $this->positions = $matches;
  206. while ($this->cursor < $this->end) {
  207. // dispatch to the lexing functions depending
  208. // on the current state
  209. switch ($this->state) {
  210. case self::STATE_DATA:
  211. $this->lexData();
  212. break;
  214. case self::STATE_BLOCK:
  215. $this->lexBlock();
  216. break;
  218. case self::STATE_VAR:
  219. $this->lexVar();
  220. break;
  222. case self::STATE_STRING:
  223. $this->lexString();
  224. break;
  226. case self::STATE_INTERPOLATION:
  227. $this->lexInterpolation();
  228. break;
  229. }
  230. }
  232. $this->pushToken(Token::EOF_TYPE);
  234. if ($this->brackets) {
  235. [$expect, $lineno] = array_pop($this->brackets);
  236. throw new SyntaxError(\sprintf('Unclosed "%s".', $expect), $lineno, $this->source);
  237. }
  239. return new TokenStream($this->tokens, $this->source);
  240. }
  242. private function lexData(): void
  243. {
  244. // if no matches are left we return the rest of the template as simple text token
  245. if ($this->position == \count($this->positions[0]) - 1) {
  246. $text = substr($this->code, $this->cursor);
  247. $this->pushToken(Token::TEXT_TYPE, $this->normalizeNewlines($text));
  248. $this->moveCursor($text);
  250. return;
  251. }
  253. // Find the first token after the current cursor
  254. $position = $this->positions[0][++$this->position];
  255. while ($position[1] < $this->cursor) {
  256. if ($this->position == \count($this->positions[0]) - 1) {
  257. return;
  258. }
  259. $position = $this->positions[0][++$this->position];
  260. }
  262. // push the template text first
  263. $text = $textContent = substr($this->code, $this->cursor, $position[1] - $this->cursor);
  265. // trim?
  266. if (isset($this->positions[2][$this->position][0])) {
  267. if ($this->options['whitespace_trim'] === $this->positions[2][$this->position][0]) {
  268. // whitespace_trim detected ({%-, {{- or {#-)
  269. $text = rtrim($text);
  270. } elseif ($this->options['whitespace_line_trim'] === $this->positions[2][$this->position][0]) {
  271. // whitespace_line_trim detected ({%~, {{~ or {#~)
  272. // don't trim \r and \n
  273. $text = rtrim($text, " \t\0\x0B");
  274. }
  275. }
  276. $this->pushToken(Token::TEXT_TYPE, $this->normalizeNewlines($text));
  277. $this->moveCursor($textContent);
  279. switch ($this->positions[1][$this->position][0]) {
  280. case $this->options['tag_comment'][0]:
  281. $this->moveCursor($position[0]);
  282. $this->lexComment();
  283. break;
  285. case $this->options['tag_block'][0]:
  286. $lineno = $this->lineno;
  287. $cursor = $this->cursor;
  288. $this->moveCursor($position[0]);
  290. // raw data?
  291. if (preg_match($this->regexes['lex_block_raw'], $this->code, $match, 0, $this->cursor)) {
  292. $this->moveCursor($match[0]);
  293. $this->lexRawData();
  294. // {% line \d+ %}
  295. } elseif (preg_match($this->regexes['lex_block_line'], $this->code, $match, 0, $this->cursor)) {
  296. $this->moveCursor($match[0]);
  297. $this->lineno = (int) $match[1];
  298. } else {
  299. $this->pushToken(Token::BLOCK_START_TYPE, '', $cursor, $lineno);
  300. $this->pushState(self::STATE_BLOCK);
  301. $this->currentVarBlockLine = $this->lineno;
  302. }
  303. break;
  305. case $this->options['tag_variable'][0]:
  306. $lineno = $this->lineno;
  307. $cursor = $this->cursor;
  308. $this->moveCursor($position[0]);
  309. $this->pushToken(Token::VAR_START_TYPE, '', $cursor, $lineno);
  310. $this->pushState(self::STATE_VAR);
  311. $this->currentVarBlockLine = $this->lineno;
  312. break;
  313. }
  314. }
  316. private function lexBlock(): void
  317. {
  318. if (!$this->brackets && preg_match($this->regexes['lex_block'], $this->code, $match, 0, $this->cursor)) {
  319. $this->pushClosingToken(Token::BLOCK_END_TYPE, $match[0]);
  320. $this->popState();
  321. } else {
  322. $this->lexExpression();
  323. }
  324. }
  326. private function lexVar(): void
  327. {
  328. if (!$this->brackets && preg_match($this->regexes['lex_var'], $this->code, $match, 0, $this->cursor)) {
  329. $this->pushClosingToken(Token::VAR_END_TYPE, $match[0]);
  330. $this->popState();
  331. } else {
  332. $this->lexExpression();
  333. }
  334. }
  336. private function lexExpression(): void
  337. {
  338. // whitespace
  339. if (preg_match('/\s+/A', $this->code, $match, 0, $this->cursor)) {
  340. $this->moveCursor($match[0]);
  342. if ($this->cursor >= $this->end) {
  343. throw new SyntaxError(\sprintf('Unclosed "%s".', self::STATE_BLOCK === $this->state ? 'block' : 'variable'), $this->currentVarBlockLine, $this->source);
  344. }
  345. }
  347. // operators
  348. if (preg_match($this->regexes['operator'], $this->code, $match, 0, $this->cursor)) {
  349. $operator = preg_replace('/\s+/', ' ', $match[0]);
  350. if (\in_array($operator, $this->openingBrackets, true)) {
  351. $this->checkBrackets($operator);
  352. }
  353. $this->pushToken(Token::OPERATOR_TYPE, $operator);
  354. $this->moveCursor($match[0]);
  355. }
  356. // names
  357. elseif (preg_match(self::REGEX_NAME, $this->code, $match, 0, $this->cursor)) {
  358. $this->pushToken(Token::NAME_TYPE, $match[0]);
  359. $this->moveCursor($match[0]);
  360. }
  361. // numbers
  362. elseif (preg_match(self::REGEX_NUMBER, $this->code, $match, 0, $this->cursor)) {
  363. $this->pushToken(Token::NUMBER_TYPE, 0 + str_replace('_', '', $match[0]));
  364. $this->moveCursor($match[0]);
  365. }
  366. // punctuation
  367. elseif (str_contains(self::PUNCTUATION, $this->code[$this->cursor])) {
  368. $this->checkBrackets($this->code[$this->cursor]);
  369. $this->pushToken(Token::PUNCTUATION_TYPE, $this->code[$this->cursor]);
  370. $this->moveCursor($this->code[$this->cursor]);
  371. }
  372. // strings
  373. elseif (preg_match(self::REGEX_STRING, $this->code, $match, 0, $this->cursor)) {
  374. $this->pushToken(Token::STRING_TYPE, $this->stripcslashes($this->normalizeNewlines(substr($match[0], 1, -1)), substr($match[0], 0, 1)));
  375. $this->moveCursor($match[0]);
  376. }
  377. // opening double quoted string
  378. elseif (preg_match(self::REGEX_DQ_STRING_DELIM, $this->code, $match, 0, $this->cursor)) {
  379. $this->brackets[] = ['"', $this->lineno];
  380. $this->pushState(self::STATE_STRING);
  381. $this->moveCursor($match[0]);
  382. }
  383. // inline comment
  384. elseif (preg_match(self::REGEX_RAW_INLINE_COMMENT, $this->code, $match, 0, $this->cursor)) {
  385. $this->moveCursor($match[0]);
  386. }
  387. // unlexable
  388. else {
  389. throw new SyntaxError(\sprintf('Unexpected character "%s".', $this->code[$this->cursor]), $this->lineno, $this->source, columnno: $this->source->getColumn($this->cursor));
  390. }
  391. }
  393. private function stripcslashes(string $str, string $quoteType): string
  394. {
  395. $result = '';
  396. $length = \strlen($str);
  398. $i = 0;
  399. while ($i < $length) {
  400. if (false === $pos = strpos($str, '\\', $i)) {
  401. $result .= substr($str, $i);
  402. break;
  403. }
  405. $result .= substr($str, $i, $pos - $i);
  406. $i = $pos + 1;
  408. if ($i >= $length) {
  409. $result .= '\\';
  410. break;
  411. }
  413. $nextChar = $str[$i];
  415. if (isset(self::SPECIAL_CHARS[$nextChar])) {
  416. $result .= self::SPECIAL_CHARS[$nextChar];
  417. } elseif ('\\' === $nextChar) {
  418. $result .= $nextChar;
  419. } elseif ("'" === $nextChar || '"' === $nextChar) {
  420. if ($nextChar !== $quoteType) {
  421. trigger_deprecation('twig/twig', '3.12', 'Character "%s" should not be escaped; the "\" character is ignored in Twig 3 but will not be in Twig 4. Please remove the extra "\" character at position %d in "%s" at line %d.', $nextChar, $i + 1, $this->source->getName(), $this->lineno);
  422. }
  423. $result .= $nextChar;
  424. } elseif ('#' === $nextChar && $i + 1 < $length && '{' === $str[$i + 1]) {
  425. $result .= '#{';
  426. ++$i;
  427. } elseif ('x' === $nextChar && $i + 1 < $length && ctype_xdigit($str[$i + 1])) {
  428. $hex = $str[++$i];
  429. if ($i + 1 < $length && ctype_xdigit($str[$i + 1])) {
  430. $hex .= $str[++$i];
  431. }
  432. $result .= \chr(hexdec($hex));
  433. } elseif (ctype_digit($nextChar) && $nextChar < '8') {
  434. $octal = $nextChar;
  435. while ($i + 1 < $length && ctype_digit($str[$i + 1]) && $str[$i + 1] < '8' && \strlen($octal) < 3) {
  436. $octal .= $str[++$i];
  437. }
  438. $result .= \chr(octdec($octal) % 256);
  439. } else {
  440. trigger_deprecation('twig/twig', '3.12', 'Character "%s" should not be escaped; the "\" character is ignored in Twig 3 but will not be in Twig 4. Please remove the extra "\" character at position %d in "%s" at line %d.', $nextChar, $i + 1, $this->source->getName(), $this->lineno);
  441. $result .= $nextChar;
  442. }
  444. ++$i;
  445. }
  447. return $result;
  448. }
  450. private function lexRawData(): void
  451. {
  452. if (!preg_match($this->regexes['lex_raw_data'], $this->code, $match, \PREG_OFFSET_CAPTURE, $this->cursor)) {
  453. throw new SyntaxError('Unexpected end of file: Unclosed "verbatim" block.', $this->lineno, $this->source);
  454. }
  456. $offset = $this->cursor;
  457. $text = substr($this->code, $this->cursor, $match[0][1] - $this->cursor);
  458. $this->moveCursor($text.$match[0][0]);
  460. // trim?
  461. if (isset($match[1][0])) {
  462. if ($this->options['whitespace_trim'] === $match[1][0]) {
  463. // whitespace_trim detected ({%-, {{- or {#-)
  464. $text = rtrim($text);
  465. } else {
  466. // whitespace_line_trim detected ({%~, {{~ or {#~)
  467. // don't trim \r and \n
  468. $text = rtrim($text, " \t\0\x0B");
  469. }
  470. }
  472. $this->pushToken(Token::TEXT_TYPE, $this->normalizeNewlines($text), $offset);
  473. }
  475. private function lexComment(): void
  476. {
  477. if (!preg_match($this->regexes['lex_comment'], $this->code, $match, \PREG_OFFSET_CAPTURE, $this->cursor)) {
  478. throw new SyntaxError('Unclosed comment.', $this->lineno, $this->source);
  479. }
  481. $this->moveCursor(substr($this->code, $this->cursor, $match[0][1] - $this->cursor).$match[0][0]);
  482. }
  484. private function lexString(): void
  485. {
  486. if (preg_match($this->regexes['interpolation_start'], $this->code, $match, 0, $this->cursor)) {
  487. $this->brackets[] = [$this->options['interpolation'][0], $this->lineno];
  488. $this->pushToken(Token::INTERPOLATION_START_TYPE);
  489. $this->moveCursor($match[0]);
  490. $this->pushState(self::STATE_INTERPOLATION);
  491. } elseif (preg_match(self::REGEX_DQ_STRING_PART, $this->code, $match, 0, $this->cursor) && '' !== $match[0]) {
  492. $this->pushToken(Token::STRING_TYPE, $this->stripcslashes($this->normalizeNewlines($match[0]), '"'));
  493. $this->moveCursor($match[0]);
  494. } elseif (preg_match(self::REGEX_DQ_STRING_DELIM, $this->code, $match, 0, $this->cursor)) {
  495. [$expect, $lineno] = array_pop($this->brackets);
  496. if ('"' != $this->code[$this->cursor]) {
  497. throw new SyntaxError(\sprintf('Unclosed "%s".', $expect), $lineno, $this->source);
  498. }
  500. $this->popState();
  501. $this->moveCursor($match[0]);
  502. } else {
  503. // unlexable
  504. throw new SyntaxError(\sprintf('Unexpected character "%s".', $this->code[$this->cursor]), $this->lineno, $this->source, columnno: $this->source->getColumn($this->cursor));
  505. }
  506. }
  508. private function lexInterpolation(): void
  509. {
  510. $bracket = end($this->brackets);
  511. if ($this->options['interpolation'][0] === $bracket[0] && preg_match($this->regexes['interpolation_end'], $this->code, $match, 0, $this->cursor)) {
  512. array_pop($this->brackets);
  513. $this->pushClosingToken(Token::INTERPOLATION_END_TYPE, $match[0]);
  514. $this->popState();
  515. } else {
  516. $this->lexExpression();
  517. }
  518. }
  520. private function pushToken($type, $value = '', ?int $offset = null, ?int $lineno = null): void
  521. {
  522. // do not push empty text tokens
  523. if (Token::TEXT_TYPE === $type && '' === $value) {
  524. return;
  525. }
  527. // by default the token starts at the current cursor; callers that
  528. // emit a token after consuming it must pass an explicit offset
  529. $this->tokens[] = new Token($type, $value, $lineno ?? $this->lineno, $offset ?? $this->cursor);
  530. }
  532. private function moveCursor($text): void
  533. {
  534. $this->cursor += \strlen($text);
  535. // count "\r\n" and "\r" as a single newline without allocating a
  536. // normalized copy when the chunk has no carriage return (common case)
  537. $this->lineno += str_contains($text, "\r") ? substr_count($this->normalizeNewlines($text), "\n") : substr_count($text, "\n");
  538. }
  540. private function normalizeNewlines(string $text): string
  541. {
  542. return str_replace(["\r\n", "\r"], "\n", $text);
  543. }
  545. private function pushClosingToken(int $type, string $match): void
  546. {
  547. $leadingWhitespaceLength = \strlen($match) - \strlen(ltrim($match));
  548. if ($leadingWhitespaceLength) {
  549. $this->moveCursor(substr($match, 0, $leadingWhitespaceLength));
  550. }
  552. $this->pushToken($type);
  553. $this->moveCursor(substr($match, $leadingWhitespaceLength));
  554. }
  556. private function getOperatorRegex(): string
  557. {
  558. $expressionParsers = [];
  559. foreach ($this->env->getExpressionParsers() as $expressionParser) {
  560. $expressionParsers = array_merge($expressionParsers, ExpressionParsers::getOperatorTokensFor($expressionParser));
  561. }
  563. $expressionParsers = array_combine($expressionParsers, array_map('strlen', $expressionParsers));
  564. arsort($expressionParsers);
  566. $regex = [];
  567. foreach ($expressionParsers as $expressionParser => $length) {
  568. // an operator that ends with a character must be followed by
  569. // a whitespace, a parenthesis, an opening map [ or sequence {
  570. $r = preg_quote($expressionParser, '/');
  571. if (ctype_alpha($expressionParser[$length - 1])) {
  572. $r .= '(?=[\s()\[{])';
  573. }
  575. // an operator that begins with a character must not have a dot or pipe before
  576. if (ctype_alpha($expressionParser[0])) {
  577. $r = '(?<![\.\|]\s|.[\.\|])'.$r;
  578. }
  580. // an operator with a space can be any amount of whitespaces
  581. $r = preg_replace('/\s+/', '\s+', $r);
  583. $regex[] = $r;
  584. }
  586. return '/'.implode('|', $regex).'/A';
  587. }
  589. private function pushState($state): void
  590. {
  591. $this->states[] = $this->state;
  592. $this->state = $state;
  593. }
  595. private function popState(): void
  596. {
  597. if (0 === \count($this->states)) {
  598. throw new \LogicException('Cannot pop state without a previous state.');
  599. }
  601. $this->state = array_pop($this->states);
  602. }
  604. private function checkBrackets(string $code): void
  605. {
  606. // opening bracket
  607. if (\in_array($code, $this->openingBrackets, true)) {
  608. $this->brackets[] = [$code, $this->lineno];
  609. } elseif (\in_array($code, $this->closingBrackets, true)) {
  610. // closing bracket
  611. if (!$this->brackets) {
  612. throw new SyntaxError(\sprintf('Unexpected "%s".', $code), $this->lineno, $this->source, columnno: $this->source->getColumn($this->cursor));
  613. }
  615. [$expect, $lineno] = array_pop($this->brackets);
  616. if ($code !== str_replace($this->openingBrackets, $this->closingBrackets, $expect)) {
  617. throw new SyntaxError(\sprintf('Unclosed "%s".', $expect), $lineno, $this->source);
  618. }
  619. }
  620. }
  621. }