vendor/symfony/yaml/Parser.php line 86

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\Yaml;
  14. use Symfony\Component\Yaml\Exception\ParseException;
  15. use Symfony\Component\Yaml\Tag\TaggedValue;
  17. /**
  18.  * Parser parses YAML strings to convert them to PHP arrays.
  19.  *
  20.  * @author Fabien Potencier <fabien@symfony.com>
  21.  *
  22.  * @final
  23.  */
  24. class Parser
  25. {
  26.     public const TAG_PATTERN = '(?P<tag>![\w!.\/:-]+)';
  27.     public const BLOCK_SCALAR_HEADER_PATTERN = '(?P<separator>\||>)(?P<modifiers>\+|\-|\d+|\+\d+|\-\d+|\d+\+|\d+\-)?(?P<comments> +#.*)?';
  28.     public const REFERENCE_PATTERN = '#^&(?P<ref>[^ ]++) *+(?P<value>.*)#u';
  30.     private ?string $filename = null;
  31.     private int $offset = 0;
  32.     private int $numberOfParsedLines = 0;
  33.     private ?int $totalNumberOfLines = null;
  34.     private array $lines = [];
  35.     private int $currentLineNb = -1;
  36.     private string $currentLine = '';
  37.     private array $refs = [];
  38.     private array $skippedLineNumbers = [];
  39.     private array $locallySkippedLineNumbers = [];
  40.     private array $refsBeingParsed = [];
  42.     /**
  43.      * Parses a YAML file into a PHP value.
  44.      *
  45.      * @param string $filename The path to the YAML file to be parsed
  46.      * @param int    $flags    A bit field of Yaml::PARSE_* constants to customize the YAML parser behavior
  47.      *
  48.      * @throws ParseException If the file could not be read or the YAML is not valid
  49.      */
  50.     public function parseFile(string $filename, int $flags = 0): mixed
  51.     {
  52.         if (!is_file($filename)) {
  53.             throw new ParseException(sprintf('File "%s" does not exist.', $filename));
  54.         }
  56.         if (!is_readable($filename)) {
  57.             throw new ParseException(sprintf('File "%s" cannot be read.', $filename));
  58.         }
  60.         $this->filename = $filename;
  62.         try {
  63.             return $this->parse(file_get_contents($filename), $flags);
  64.         } finally {
  65.             $this->filename = null;
  66.         }
  67.     }
  69.     /**
  70.      * Parses a YAML string to a PHP value.
  71.      *
  72.      * @param string $value A YAML string
  73.      * @param int    $flags A bit field of Yaml::PARSE_* constants to customize the YAML parser behavior
  74.      *
  75.      * @throws ParseException If the YAML is not valid
  76.      */
  77.     public function parse(string $value, int $flags = 0): mixed
  78.     {
  79.         if (false === preg_match('//u', $value)) {
  80.             throw new ParseException('The YAML value does not appear to be valid UTF-8.', -1, null, $this->filename);
  81.         }
  83.         $this->refs = [];
  85.         try {
  86.             $data = $this->doParse($value, $flags);
  87.         } finally {
  88.             $this->refsBeingParsed = [];
  89.             $this->offset = 0;
  90.             $this->lines = [];
  91.             $this->currentLine = '';
  92.             $this->numberOfParsedLines = 0;
  93.             $this->refs = [];
  94.             $this->skippedLineNumbers = [];
  95.             $this->locallySkippedLineNumbers = [];
  96.             $this->totalNumberOfLines = null;
  97.         }
  99.         return $data;
  100.     }
  102.     private function doParse(string $value, int $flags)
  103.     {
  104.         $this->currentLineNb = -1;
  105.         $this->currentLine = '';
  106.         $value = $this->cleanup($value);
  107.         $this->lines = explode("\n", $value);
  108.         $this->numberOfParsedLines = \count($this->lines);
  109.         $this->locallySkippedLineNumbers = [];
  111.         if (null === $this->totalNumberOfLines) {
  112.             $this->totalNumberOfLines = $this->numberOfParsedLines;
  113.         }
  115.         if (!$this->moveToNextLine()) {
  116.             return null;
  117.         }
  119.         $data = [];
  120.         $context = null;
  121.         $allowOverwrite = false;
  123.         while ($this->isCurrentLineEmpty()) {
  124.             if (!$this->moveToNextLine()) {
  125.                 return null;
  126.             }
  127.         }
  129.         // Resolves the tag and returns if end of the document
  130.         if (null !== ($tag = $this->getLineTag($this->currentLine, $flags, false)) && !$this->moveToNextLine()) {
  131.             return new TaggedValue($tag, '');
  132.         }
  134.         do {
  135.             if ($this->isCurrentLineEmpty()) {
  136.                 continue;
  137.             }
  139.             // tab?
  140.             if ("\t" === $this->currentLine[0]) {
  141.                 throw new ParseException('A YAML file cannot contain tabs as indentation.', $this->getRealCurrentLineNb() + 1, $this->currentLine, $this->filename);
  142.             }
  144.             Inline::initialize($flags, $this->getRealCurrentLineNb(), $this->filename);
  146.             $isRef = $mergeNode = false;
  147.             if ('-' === $this->currentLine[0] && self::preg_match('#^\-((?P<leadspaces>\s+)(?P<value>.+))?$#u', rtrim($this->currentLine), $values)) {
  148.                 if ($context && 'mapping' == $context) {
  149.                     throw new ParseException('You cannot define a sequence item when in a mapping.', $this->getRealCurrentLineNb() + 1, $this->currentLine, $this->filename);
  150.                 }
  151.                 $context = 'sequence';
  153.                 if (isset($values['value']) && '&' === $values['value'][0] && self::preg_match(self::REFERENCE_PATTERN, $values['value'], $matches)) {
  154.                     $isRef = $matches['ref'];
  155.                     $this->refsBeingParsed[] = $isRef;
  156.                     $values['value'] = $matches['value'];
  157.                 }
  159.                 if (isset($values['value'][1]) && '?' === $values['value'][0] && ' ' === $values['value'][1]) {
  160.                     throw new ParseException('Complex mappings are not supported.', $this->getRealCurrentLineNb() + 1, $this->currentLine);
  161.                 }
  163.                 // array
  164.                 if (isset($values['value']) && str_starts_with(ltrim($values['value'], ' '), '-')) {
  165.                     // Inline first child
  166.                     $currentLineNumber = $this->getRealCurrentLineNb();
  168.                     $sequenceIndentation = \strlen($values['leadspaces']) + 1;
  169.                     $sequenceYaml = substr($this->currentLine, $sequenceIndentation);
  170.                     $sequenceYaml .= "\n".$this->getNextEmbedBlock($sequenceIndentation, true);
  172.                     $data[] = $this->parseBlock($currentLineNumber, rtrim($sequenceYaml), $flags);
  173.                 } elseif (!isset($values['value']) || '' == trim($values['value'], ' ') || str_starts_with(ltrim($values['value'], ' '), '#')) {
  174.                     $data[] = $this->parseBlock($this->getRealCurrentLineNb() + 1, $this->getNextEmbedBlock(null, true) ?? '', $flags);
  175.                 } elseif (null !== $subTag = $this->getLineTag(ltrim($values['value'], ' '), $flags)) {
  176.                     $data[] = new TaggedValue(
  177.                         $subTag,
  178.                         $this->parseBlock($this->getRealCurrentLineNb() + 1, $this->getNextEmbedBlock(null, true), $flags)
  179.                     );
  180.                 } else {
  181.                     if (
  182.                         isset($values['leadspaces'])
  183.                         && (
  184.                             '!' === $values['value'][0]
  185.                             || self::preg_match('#^(?P<key>'.Inline::REGEX_QUOTED_STRING.'|[^ \'"\{\[].*?) *\:(\s+(?P<value>.+?))?\s*$#u', $this->trimTag($values['value']), $matches)
  186.                         )
  187.                     ) {
  188.                         // this is a compact notation element, add to next block and parse
  189.                         $block = $values['value'];
  190.                         if ($this->isNextLineIndented()) {
  191.                             $block .= "\n".$this->getNextEmbedBlock($this->getCurrentLineIndentation() + \strlen($values['leadspaces']) + 1);
  192.                         }
  194.                         $data[] = $this->parseBlock($this->getRealCurrentLineNb(), $block, $flags);
  195.                     } else {
  196.                         $data[] = $this->parseValue($values['value'], $flags, $context);
  197.                     }
  198.                 }
  199.                 if ($isRef) {
  200.                     $this->refs[$isRef] = end($data);
  201.                     array_pop($this->refsBeingParsed);
  202.                 }
  203.             } elseif (
  204.                 self::preg_match('#^(?P<key>(?:![^\s]++\s++)?(?:'.Inline::REGEX_QUOTED_STRING.'|(?:!?!php/const:)?[^ \'"\[\{!].*?)) *\:(( |\t)++(?P<value>.+))?$#u', rtrim($this->currentLine), $values)
  205.                 && (!str_contains($values['key'], ' #') || \in_array($values['key'][0], ['"', "'"]))
  206.             ) {
  207.                 if ($context && 'sequence' == $context) {
  208.                     throw new ParseException('You cannot define a mapping item when in a sequence.', $this->currentLineNb + 1, $this->currentLine, $this->filename);
  209.                 }
  210.                 $context = 'mapping';
  212.                 try {
  213.                     $key = Inline::parseScalar($values['key']);
  214.                 } catch (ParseException $e) {
  215.                     $e->setParsedLine($this->getRealCurrentLineNb() + 1);
  216.                     $e->setSnippet($this->currentLine);
  218.                     throw $e;
  219.                 }
  221.                 if (!\is_string($key) && !\is_int($key)) {
  222.                     throw new ParseException((is_numeric($key) ? 'Numeric' : 'Non-string').' keys are not supported. Quote your evaluable mapping keys instead.', $this->getRealCurrentLineNb() + 1, $this->currentLine);
  223.                 }
  225.                 // Convert float keys to strings, to avoid being converted to integers by PHP
  226.                 if (\is_float($key)) {
  227.                     $key = (string) $key;
  228.                 }
  230.                 if ('<<' === $key && (!isset($values['value']) || '&' !== $values['value'][0] || !self::preg_match('#^&(?P<ref>[^ ]+)#u', $values['value'], $refMatches))) {
  231.                     $mergeNode = true;
  232.                     $allowOverwrite = true;
  233.                     if (isset($values['value'][0]) && '*' === $values['value'][0]) {
  234.                         $refName = substr(rtrim($values['value']), 1);
  235.                         if (!\array_key_exists($refName, $this->refs)) {
  236.                             if (false !== $pos = array_search($refName, $this->refsBeingParsed, true)) {
  237.                                 throw new ParseException(sprintf('Circular reference [%s] detected for reference "%s".', implode(', ', array_merge(\array_slice($this->refsBeingParsed, $pos), [$refName])), $refName), $this->currentLineNb + 1, $this->currentLine, $this->filename);
  238.                             }
  240.                             throw new ParseException(sprintf('Reference "%s" does not exist.', $refName), $this->getRealCurrentLineNb() + 1, $this->currentLine, $this->filename);
  241.                         }
  243.                         $refValue = $this->refs[$refName];
  245.                         if (Yaml::PARSE_OBJECT_FOR_MAP & $flags && $refValue instanceof \stdClass) {
  246.                             $refValue = (array) $refValue;
  247.                         }
  249.                         if (!\is_array($refValue)) {
  250.                             throw new ParseException('YAML merge keys used with a scalar value instead of an array.', $this->getRealCurrentLineNb() + 1, $this->currentLine, $this->filename);
  251.                         }
  253.                         $data += $refValue; // array union
  254.                     } else {
  255.                         if (isset($values['value']) && '' !== $values['value']) {
  256.                             $value = $values['value'];
  257.                         } else {
  258.                             $value = $this->getNextEmbedBlock();
  259.                         }
  260.                         $parsed = $this->parseBlock($this->getRealCurrentLineNb() + 1, $value, $flags);
  262.                         if (Yaml::PARSE_OBJECT_FOR_MAP & $flags && $parsed instanceof \stdClass) {
  263.                             $parsed = (array) $parsed;
  264.                         }
  266.                         if (!\is_array($parsed)) {
  267.                             throw new ParseException('YAML merge keys used with a scalar value instead of an array.', $this->getRealCurrentLineNb() + 1, $this->currentLine, $this->filename);
  268.                         }
  270.                         if (isset($parsed[0])) {
  271.                             // If the value associated with the merge key is a sequence, then this sequence is expected to contain mapping nodes
  272.                             // and each of these nodes is merged in turn according to its order in the sequence. Keys in mapping nodes earlier
  273.                             // in the sequence override keys specified in later mapping nodes.
  274.                             foreach ($parsed as $parsedItem) {
  275.                                 if (Yaml::PARSE_OBJECT_FOR_MAP & $flags && $parsedItem instanceof \stdClass) {
  276.                                     $parsedItem = (array) $parsedItem;
  277.                                 }
  279.                                 if (!\is_array($parsedItem)) {
  280.                                     throw new ParseException('Merge items must be arrays.', $this->getRealCurrentLineNb() + 1, $parsedItem, $this->filename);
  281.                                 }
  283.                                 $data += $parsedItem; // array union
  284.                             }
  285.                         } else {
  286.                             // If the value associated with the key is a single mapping node, each of its key/value pairs is inserted into the
  287.                             // current mapping, unless the key already exists in it.
  288.                             $data += $parsed; // array union
  289.                         }
  290.                     }
  291.                 } elseif ('<<' !== $key && isset($values['value']) && '&' === $values['value'][0] && self::preg_match(self::REFERENCE_PATTERN, $values['value'], $matches)) {
  292.                     $isRef = $matches['ref'];
  293.                     $this->refsBeingParsed[] = $isRef;
  294.                     $values['value'] = $matches['value'];
  295.                 }
  297.                 $subTag = null;
  298.                 if ($mergeNode) {
  299.                     // Merge keys
  300.                 } elseif (!isset($values['value']) || '' === $values['value'] || str_starts_with($values['value'], '#') || (null !== $subTag = $this->getLineTag($values['value'], $flags)) || '<<' === $key) {
  301.                     // hash
  302.                     // if next line is less indented or equal, then it means that the current value is null
  303.                     if (!$this->isNextLineIndented() && !$this->isNextLineUnIndentedCollection()) {
  304.                         // Spec: Keys MUST be unique; first one wins.
  305.                         // But overwriting is allowed when a merge node is used in current block.
  306.                         if ($allowOverwrite || !isset($data[$key])) {
  307.                             if (null !== $subTag) {
  308.                                 $data[$key] = new TaggedValue($subTag, '');
  309.                             } else {
  310.                                 $data[$key] = null;
  311.                             }
  312.                         } else {
  313.                             throw new ParseException(sprintf('Duplicate key "%s" detected.', $key), $this->getRealCurrentLineNb() + 1, $this->currentLine);
  314.                         }
  315.                     } else {
  316.                         // remember the parsed line number here in case we need it to provide some contexts in error messages below
  317.                         $realCurrentLineNbKey = $this->getRealCurrentLineNb();
  318.                         $value = $this->parseBlock($this->getRealCurrentLineNb() + 1, $this->getNextEmbedBlock(), $flags);
  319.                         if ('<<' === $key) {
  320.                             $this->refs[$refMatches['ref']] = $value;
  322.                             if (Yaml::PARSE_OBJECT_FOR_MAP & $flags && $value instanceof \stdClass) {
  323.                                 $value = (array) $value;
  324.                             }
  326.                             $data += $value;
  327.                         } elseif ($allowOverwrite || !isset($data[$key])) {
  328.                             // Spec: Keys MUST be unique; first one wins.
  329.                             // But overwriting is allowed when a merge node is used in current block.
  330.                             if (null !== $subTag) {
  331.                                 $data[$key] = new TaggedValue($subTag, $value);
  332.                             } else {
  333.                                 $data[$key] = $value;
  334.                             }
  335.                         } else {
  336.                             throw new ParseException(sprintf('Duplicate key "%s" detected.', $key), $realCurrentLineNbKey + 1, $this->currentLine);
  337.                         }
  338.                     }
  339.                 } else {
  340.                     $value = $this->parseValue(rtrim($values['value']), $flags, $context);
  341.                     // Spec: Keys MUST be unique; first one wins.
  342.                     // But overwriting is allowed when a merge node is used in current block.
  343.                     if ($allowOverwrite || !isset($data[$key])) {
  344.                         $data[$key] = $value;
  345.                     } else {
  346.                         throw new ParseException(sprintf('Duplicate key "%s" detected.', $key), $this->getRealCurrentLineNb() + 1, $this->currentLine);
  347.                     }
  348.                 }
  349.                 if ($isRef) {
  350.                     $this->refs[$isRef] = $data[$key];
  351.                     array_pop($this->refsBeingParsed);
  352.                 }
  353.             } elseif ('"' === $this->currentLine[0] || "'" === $this->currentLine[0]) {
  354.                 if (null !== $context) {
  355.                     throw new ParseException('Unable to parse.', $this->getRealCurrentLineNb() + 1, $this->currentLine, $this->filename);
  356.                 }
  358.                 try {
  359.                     return Inline::parse($this->lexInlineQuotedString(), $flags, $this->refs);
  360.                 } catch (ParseException $e) {
  361.                     $e->setParsedLine($this->getRealCurrentLineNb() + 1);
  362.                     $e->setSnippet($this->currentLine);
  364.                     throw $e;
  365.                 }
  366.             } elseif ('{' === $this->currentLine[0]) {
  367.                 if (null !== $context) {
  368.                     throw new ParseException('Unable to parse.', $this->getRealCurrentLineNb() + 1, $this->currentLine, $this->filename);
  369.                 }
  371.                 try {
  372.                     $parsedMapping = Inline::parse($this->lexInlineMapping(), $flags, $this->refs);
  374.                     while ($this->moveToNextLine()) {
  375.                         if (!$this->isCurrentLineEmpty()) {
  376.                             throw new ParseException('Unable to parse.', $this->getRealCurrentLineNb() + 1, $this->currentLine, $this->filename);
  377.                         }
  378.                     }
  380.                     return $parsedMapping;
  381.                 } catch (ParseException $e) {
  382.                     $e->setParsedLine($this->getRealCurrentLineNb() + 1);
  383.                     $e->setSnippet($this->currentLine);
  385.                     throw $e;
  386.                 }
  387.             } elseif ('[' === $this->currentLine[0]) {
  388.                 if (null !== $context) {
  389.                     throw new ParseException('Unable to parse.', $this->getRealCurrentLineNb() + 1, $this->currentLine, $this->filename);
  390.                 }
  392.                 try {
  393.                     $parsedSequence = Inline::parse($this->lexInlineSequence(), $flags, $this->refs);
  395.                     while ($this->moveToNextLine()) {
  396.                         if (!$this->isCurrentLineEmpty()) {
  397.                             throw new ParseException('Unable to parse.', $this->getRealCurrentLineNb() + 1, $this->currentLine, $this->filename);
  398.                         }
  399.                     }
  401.                     return $parsedSequence;
  402.                 } catch (ParseException $e) {
  403.                     $e->setParsedLine($this->getRealCurrentLineNb() + 1);
  404.                     $e->setSnippet($this->currentLine);
  406.                     throw $e;
  407.                 }
  408.             } else {
  409.                 // multiple documents are not supported
  410.                 if ('---' === $this->currentLine) {
  411.                     throw new ParseException('Multiple documents are not supported.', $this->currentLineNb + 1, $this->currentLine, $this->filename);
  412.                 }
  414.                 if ($deprecatedUsage = (isset($this->currentLine[1]) && '?' === $this->currentLine[0] && ' ' === $this->currentLine[1])) {
  415.                     throw new ParseException('Complex mappings are not supported.', $this->getRealCurrentLineNb() + 1, $this->currentLine);
  416.                 }
  418.                 // 1-liner optionally followed by newline(s)
  419.                 if (\is_string($value) && $this->lines[0] === trim($value)) {
  420.                     try {
  421.                         $value = Inline::parse($this->lines[0], $flags, $this->refs);
  422.                     } catch (ParseException $e) {
  423.                         $e->setParsedLine($this->getRealCurrentLineNb() + 1);
  424.                         $e->setSnippet($this->currentLine);
  426.                         throw $e;
  427.                     }
  429.                     return $value;
  430.                 }
  432.                 // try to parse the value as a multi-line string as a last resort
  433.                 if (0 === $this->currentLineNb) {
  434.                     $previousLineWasNewline = false;
  435.                     $previousLineWasTerminatedWithBackslash = false;
  436.                     $value = '';
  438.                     foreach ($this->lines as $line) {
  439.                         $trimmedLine = trim($line);
  440.                         if ('#' === ($trimmedLine[0] ?? '')) {
  441.                             continue;
  442.                         }
  443.                         // If the indentation is not consistent at offset 0, it is to be considered as a ParseError
  444.                         if (0 === $this->offset && !$deprecatedUsage && isset($line[0]) && ' ' === $line[0]) {
  445.                             throw new ParseException('Unable to parse.', $this->getRealCurrentLineNb() + 1, $this->currentLine, $this->filename);
  446.                         }
  448.                         if (str_contains($line, ': ')) {
  449.                             throw new ParseException('Mapping values are not allowed in multi-line blocks.', $this->getRealCurrentLineNb() + 1, $this->currentLine, $this->filename);
  450.                         }
  452.                         if ('' === $trimmedLine) {
  453.                             $value .= "\n";
  454.                         } elseif (!$previousLineWasNewline && !$previousLineWasTerminatedWithBackslash) {
  455.                             $value .= ' ';
  456.                         }
  458.                         if ('' !== $trimmedLine && str_ends_with($line, '\\')) {
  459.                             $value .= ltrim(substr($line, 0, -1));
  460.                         } elseif ('' !== $trimmedLine) {
  461.                             $value .= $trimmedLine;
  462.                         }
  464.                         if ('' === $trimmedLine) {
  465.                             $previousLineWasNewline = true;
  466.                             $previousLineWasTerminatedWithBackslash = false;
  467.                         } elseif (str_ends_with($line, '\\')) {
  468.                             $previousLineWasNewline = false;
  469.                             $previousLineWasTerminatedWithBackslash = true;
  470.                         } else {
  471.                             $previousLineWasNewline = false;
  472.                             $previousLineWasTerminatedWithBackslash = false;
  473.                         }
  474.                     }
  476.                     try {
  477.                         return Inline::parse(trim($value));
  478.                     } catch (ParseException) {
  479.                         // fall-through to the ParseException thrown below
  480.                     }
  481.                 }
  483.                 throw new ParseException('Unable to parse.', $this->getRealCurrentLineNb() + 1, $this->currentLine, $this->filename);
  484.             }
  485.         } while ($this->moveToNextLine());
  487.         if (null !== $tag) {
  488.             $data = new TaggedValue($tag, $data);
  489.         }
  491.         if (Yaml::PARSE_OBJECT_FOR_MAP & $flags && 'mapping' === $context && !\is_object($data)) {
  492.             $object = new \stdClass();
  494.             foreach ($data as $key => $value) {
  495.                 $object->$key = $value;
  496.             }
  498.             $data = $object;
  499.         }
  501.         return empty($data) ? null : $data;
  502.     }
  504.     private function parseBlock(int $offset, string $yaml, int $flags)
  505.     {
  506.         $skippedLineNumbers = $this->skippedLineNumbers;
  508.         foreach ($this->locallySkippedLineNumbers as $lineNumber) {
  509.             if ($lineNumber < $offset) {
  510.                 continue;
  511.             }
  513.             $skippedLineNumbers[] = $lineNumber;
  514.         }
  516.         $parser = new self();
  517.         $parser->offset = $offset;
  518.         $parser->totalNumberOfLines = $this->totalNumberOfLines;
  519.         $parser->skippedLineNumbers = $skippedLineNumbers;
  520.         $parser->refs = &$this->refs;
  521.         $parser->refsBeingParsed = $this->refsBeingParsed;
  523.         return $parser->doParse($yaml, $flags);
  524.     }
  526.     /**
  527.      * Returns the current line number (takes the offset into account).
  528.      *
  529.      * @internal
  530.      */
  531.     public function getRealCurrentLineNb(): int
  532.     {
  533.         $realCurrentLineNumber = $this->currentLineNb + $this->offset;
  535.         foreach ($this->skippedLineNumbers as $skippedLineNumber) {
  536.             if ($skippedLineNumber > $realCurrentLineNumber) {
  537.                 break;
  538.             }
  540.             ++$realCurrentLineNumber;
  541.         }
  543.         return $realCurrentLineNumber;
  544.     }
  546.     private function getCurrentLineIndentation(): int
  547.     {
  548.         if (' ' !== ($this->currentLine[0] ?? '')) {
  549.             return 0;
  550.         }
  552.         return \strlen($this->currentLine) - \strlen(ltrim($this->currentLine, ' '));
  553.     }
  555.     /**
  556.      * Returns the next embed block of YAML.
  557.      *
  558.      * @param int|null $indentation The indent level at which the block is to be read, or null for default
  559.      * @param bool     $inSequence  True if the enclosing data structure is a sequence
  560.      *
  561.      * @throws ParseException When indentation problem are detected
  562.      */
  563.     private function getNextEmbedBlock(int $indentation = null, bool $inSequence = false): string
  564.     {
  565.         $oldLineIndentation = $this->getCurrentLineIndentation();
  567.         if (!$this->moveToNextLine()) {
  568.             return '';
  569.         }
  571.         if (null === $indentation) {
  572.             $newIndent = null;
  573.             $movements = 0;
  575.             do {
  576.                 $EOF = false;
  578.                 // empty and comment-like lines do not influence the indentation depth
  579.                 if ($this->isCurrentLineEmpty() || $this->isCurrentLineComment()) {
  580.                     $EOF = !$this->moveToNextLine();
  582.                     if (!$EOF) {
  583.                         ++$movements;
  584.                     }
  585.                 } else {
  586.                     $newIndent = $this->getCurrentLineIndentation();
  587.                 }
  588.             } while (!$EOF && null === $newIndent);
  590.             for ($i = 0; $i < $movements; ++$i) {
  591.                 $this->moveToPreviousLine();
  592.             }
  594.             $unindentedEmbedBlock = $this->isStringUnIndentedCollectionItem();
  596.             if (!$this->isCurrentLineEmpty() && 0 === $newIndent && !$unindentedEmbedBlock) {
  597.                 throw new ParseException('Indentation problem.', $this->getRealCurrentLineNb() + 1, $this->currentLine, $this->filename);
  598.             }
  599.         } else {
  600.             $newIndent = $indentation;
  601.         }
  603.         $data = [];
  605.         if ($this->getCurrentLineIndentation() >= $newIndent) {
  606.             $data[] = substr($this->currentLine, $newIndent ?? 0);
  607.         } elseif ($this->isCurrentLineEmpty() || $this->isCurrentLineComment()) {
  608.             $data[] = $this->currentLine;
  609.         } else {
  610.             $this->moveToPreviousLine();
  612.             return '';
  613.         }
  615.         if ($inSequence && $oldLineIndentation === $newIndent && isset($data[0][0]) && '-' === $data[0][0]) {
  616.             // the previous line contained a dash but no item content, this line is a sequence item with the same indentation
  617.             // and therefore no nested list or mapping
  618.             $this->moveToPreviousLine();
  620.             return '';
  621.         }
  623.         $isItUnindentedCollection = $this->isStringUnIndentedCollectionItem();
  624.         $isItComment = $this->isCurrentLineComment();
  626.         while ($this->moveToNextLine()) {
  627.             if ($isItComment && !$isItUnindentedCollection) {
  628.                 $isItUnindentedCollection = $this->isStringUnIndentedCollectionItem();
  629.                 $isItComment = $this->isCurrentLineComment();
  630.             }
  632.             $indent = $this->getCurrentLineIndentation();
  634.             if ($isItUnindentedCollection && !$this->isCurrentLineEmpty() && !$this->isStringUnIndentedCollectionItem() && $newIndent === $indent) {
  635.                 $this->moveToPreviousLine();
  636.                 break;
  637.             }
  639.             if ($this->isCurrentLineBlank()) {
  640.                 $data[] = substr($this->currentLine, $newIndent);
  641.                 continue;
  642.             }
  644.             if ($indent >= $newIndent) {
  645.                 $data[] = substr($this->currentLine, $newIndent);
  646.             } elseif ($this->isCurrentLineComment()) {
  647.                 $data[] = $this->currentLine;
  648.             } elseif (0 == $indent) {
  649.                 $this->moveToPreviousLine();
  651.                 break;
  652.             } else {
  653.                 throw new ParseException('Indentation problem.', $this->getRealCurrentLineNb() + 1, $this->currentLine, $this->filename);
  654.             }
  655.         }
  657.         return implode("\n", $data);
  658.     }
  660.     private function hasMoreLines(): bool
  661.     {
  662.         return (\count($this->lines) - 1) > $this->currentLineNb;
  663.     }
  665.     /**
  666.      * Moves the parser to the next line.
  667.      */
  668.     private function moveToNextLine(): bool
  669.     {
  670.         if ($this->currentLineNb >= $this->numberOfParsedLines - 1) {
  671.             return false;
  672.         }
  674.         $this->currentLine = $this->lines[++$this->currentLineNb];
  676.         return true;
  677.     }
  679.     /**
  680.      * Moves the parser to the previous line.
  681.      */
  682.     private function moveToPreviousLine(): bool
  683.     {
  684.         if ($this->currentLineNb < 1) {
  685.             return false;
  686.         }
  688.         $this->currentLine = $this->lines[--$this->currentLineNb];
  690.         return true;
  691.     }
  693.     /**
  694.      * Parses a YAML value.
  695.      *
  696.      * @param string $value   A YAML value
  697.      * @param int    $flags   A bit field of Yaml::PARSE_* constants to customize the YAML parser behavior
  698.      * @param string $context The parser context (either sequence or mapping)
  699.      *
  700.      * @throws ParseException When reference does not exist
  701.      */
  702.     private function parseValue(string $value, int $flags, string $context): mixed
  703.     {
  704.         if (str_starts_with($value, '*')) {
  705.             if (false !== $pos = strpos($value, '#')) {
  706.                 $value = substr($value, 1, $pos - 2);
  707.             } else {
  708.                 $value = substr($value, 1);
  709.             }
  711.             if (!\array_key_exists($value, $this->refs)) {
  712.                 if (false !== $pos = array_search($value, $this->refsBeingParsed, true)) {
  713.                     throw new ParseException(sprintf('Circular reference [%s] detected for reference "%s".', implode(', ', array_merge(\array_slice($this->refsBeingParsed, $pos), [$value])), $value), $this->currentLineNb + 1, $this->currentLine, $this->filename);
  714.                 }
  716.                 throw new ParseException(sprintf('Reference "%s" does not exist.', $value), $this->currentLineNb + 1, $this->currentLine, $this->filename);
  717.             }
  719.             return $this->refs[$value];
  720.         }
  722.         if (\in_array($value[0], ['!', '|', '>'], true) && self::preg_match('/^(?:'.self::TAG_PATTERN.' +)?'.self::BLOCK_SCALAR_HEADER_PATTERN.'$/', $value, $matches)) {
  723.             $modifiers = $matches['modifiers'] ?? '';
  725.             $data = $this->parseBlockScalar($matches['separator'], preg_replace('#\d+#', '', $modifiers), abs((int) $modifiers));
  727.             if ('' !== $matches['tag'] && '!' !== $matches['tag']) {
  728.                 if ('!!binary' === $matches['tag']) {
  729.                     return Inline::evaluateBinaryScalar($data);
  730.                 }
  732.                 return new TaggedValue(substr($matches['tag'], 1), $data);
  733.             }
  735.             return $data;
  736.         }
  738.         try {
  739.             if ('' !== $value && '{' === $value[0]) {
  740.                 $cursor = \strlen(rtrim($this->currentLine)) - \strlen(rtrim($value));
  742.                 return Inline::parse($this->lexInlineMapping($cursor), $flags, $this->refs);
  743.             } elseif ('' !== $value && '[' === $value[0]) {
  744.                 $cursor = \strlen(rtrim($this->currentLine)) - \strlen(rtrim($value));
  746.                 return Inline::parse($this->lexInlineSequence($cursor), $flags, $this->refs);
  747.             }
  749.             switch ($value[0] ?? '') {
  750.                 case '"':
  751.                 case "'":
  752.                     $cursor = \strlen(rtrim($this->currentLine)) - \strlen(rtrim($value));
  753.                     $parsedValue = Inline::parse($this->lexInlineQuotedString($cursor), $flags, $this->refs);
  755.                     if (isset($this->currentLine[$cursor]) && preg_replace('/\s*(#.*)?$/A', '', substr($this->currentLine, $cursor))) {
  756.                         throw new ParseException(sprintf('Unexpected characters near "%s".', substr($this->currentLine, $cursor)));
  757.                     }
  759.                     return $parsedValue;
  760.                 default:
  761.                     $lines = [];
  763.                     while ($this->moveToNextLine()) {
  764.                         // unquoted strings end before the first unindented line
  765.                         if (0 === $this->getCurrentLineIndentation()) {
  766.                             $this->moveToPreviousLine();
  768.                             break;
  769.                         }
  771.                         $lines[] = trim($this->currentLine);
  772.                     }
  774.                     for ($i = 0, $linesCount = \count($lines), $previousLineBlank = false; $i < $linesCount; ++$i) {
  775.                         if ('' === $lines[$i]) {
  776.                             $value .= "\n";
  777.                             $previousLineBlank = true;
  778.                         } elseif ($previousLineBlank) {
  779.                             $value .= $lines[$i];
  780.                             $previousLineBlank = false;
  781.                         } else {
  782.                             $value .= ' '.$lines[$i];
  783.                             $previousLineBlank = false;
  784.                         }
  785.                     }
  787.                     Inline::$parsedLineNumber = $this->getRealCurrentLineNb();
  789.                     $parsedValue = Inline::parse($value, $flags, $this->refs);
  791.                     if ('mapping' === $context && \is_string($parsedValue) && '"' !== $value[0] && "'" !== $value[0] && '[' !== $value[0] && '{' !== $value[0] && '!' !== $value[0] && str_contains($parsedValue, ': ')) {
  792.                         throw new ParseException('A colon cannot be used in an unquoted mapping value.', $this->getRealCurrentLineNb() + 1, $value, $this->filename);
  793.                     }
  795.                     return $parsedValue;
  796.             }
  797.         } catch (ParseException $e) {
  798.             $e->setParsedLine($this->getRealCurrentLineNb() + 1);
  799.             $e->setSnippet($this->currentLine);
  801.             throw $e;
  802.         }
  803.     }
  805.     /**
  806.      * Parses a block scalar.
  807.      *
  808.      * @param string $style       The style indicator that was used to begin this block scalar (| or >)
  809.      * @param string $chomping    The chomping indicator that was used to begin this block scalar (+ or -)
  810.      * @param int    $indentation The indentation indicator that was used to begin this block scalar
  811.      */
  812.     private function parseBlockScalar(string $style, string $chomping = '', int $indentation = 0): string
  813.     {
  814.         $notEOF = $this->moveToNextLine();
  815.         if (!$notEOF) {
  816.             return '';
  817.         }
  819.         $isCurrentLineBlank = $this->isCurrentLineBlank();
  820.         $blockLines = [];
  822.         // leading blank lines are consumed before determining indentation
  823.         while ($notEOF && $isCurrentLineBlank) {
  824.             // newline only if not EOF
  825.             if ($notEOF = $this->moveToNextLine()) {
  826.                 $blockLines[] = '';
  827.                 $isCurrentLineBlank = $this->isCurrentLineBlank();
  828.             }
  829.         }
  831.         // determine indentation if not specified
  832.         if (0 === $indentation) {
  833.             $currentLineLength = \strlen($this->currentLine);
  835.             for ($i = 0; $i < $currentLineLength && ' ' === $this->currentLine[$i]; ++$i) {
  836.                 ++$indentation;
  837.             }
  838.         }
  840.         if ($indentation > 0) {
  841.             $pattern = sprintf('/^ {%d}(.*)$/', $indentation);
  843.             while (
  844.                 $notEOF && (
  845.                     $isCurrentLineBlank ||
  846.                     self::preg_match($pattern, $this->currentLine, $matches)
  847.                 )
  848.             ) {
  849.                 if ($isCurrentLineBlank && \strlen($this->currentLine) > $indentation) {
  850.                     $blockLines[] = substr($this->currentLine, $indentation);
  851.                 } elseif ($isCurrentLineBlank) {
  852.                     $blockLines[] = '';
  853.                 } else {
  854.                     $blockLines[] = $matches[1];
  855.                 }
  857.                 // newline only if not EOF
  858.                 if ($notEOF = $this->moveToNextLine()) {
  859.                     $isCurrentLineBlank = $this->isCurrentLineBlank();
  860.                 }
  861.             }
  862.         } elseif ($notEOF) {
  863.             $blockLines[] = '';
  864.         }
  866.         if ($notEOF) {
  867.             $blockLines[] = '';
  868.             $this->moveToPreviousLine();
  869.         } elseif (!$notEOF && !$this->isCurrentLineLastLineInDocument()) {
  870.             $blockLines[] = '';
  871.         }
  873.         // folded style
  874.         if ('>' === $style) {
  875.             $text = '';
  876.             $previousLineIndented = false;
  877.             $previousLineBlank = false;
  879.             for ($i = 0, $blockLinesCount = \count($blockLines); $i < $blockLinesCount; ++$i) {
  880.                 if ('' === $blockLines[$i]) {
  881.                     $text .= "\n";
  882.                     $previousLineIndented = false;
  883.                     $previousLineBlank = true;
  884.                 } elseif (' ' === $blockLines[$i][0]) {
  885.                     $text .= "\n".$blockLines[$i];
  886.                     $previousLineIndented = true;
  887.                     $previousLineBlank = false;
  888.                 } elseif ($previousLineIndented) {
  889.                     $text .= "\n".$blockLines[$i];
  890.                     $previousLineIndented = false;
  891.                     $previousLineBlank = false;
  892.                 } elseif ($previousLineBlank || 0 === $i) {
  893.                     $text .= $blockLines[$i];
  894.                     $previousLineIndented = false;
  895.                     $previousLineBlank = false;
  896.                 } else {
  897.                     $text .= ' '.$blockLines[$i];
  898.                     $previousLineIndented = false;
  899.                     $previousLineBlank = false;
  900.                 }
  901.             }
  902.         } else {
  903.             $text = implode("\n", $blockLines);
  904.         }
  906.         // deal with trailing newlines
  907.         if ('' === $chomping) {
  908.             $text = preg_replace('/\n+$/', "\n", $text);
  909.         } elseif ('-' === $chomping) {
  910.             $text = preg_replace('/\n+$/', '', $text);
  911.         }
  913.         return $text;
  914.     }
  916.     /**
  917.      * Returns true if the next line is indented.
  918.      */
  919.     private function isNextLineIndented(): bool
  920.     {
  921.         $currentIndentation = $this->getCurrentLineIndentation();
  922.         $movements = 0;
  924.         do {
  925.             $EOF = !$this->moveToNextLine();
  927.             if (!$EOF) {
  928.                 ++$movements;
  929.             }
  930.         } while (!$EOF && ($this->isCurrentLineEmpty() || $this->isCurrentLineComment()));
  932.         if ($EOF) {
  933.             return false;
  934.         }
  936.         $ret = $this->getCurrentLineIndentation() > $currentIndentation;
  938.         for ($i = 0; $i < $movements; ++$i) {
  939.             $this->moveToPreviousLine();
  940.         }
  942.         return $ret;
  943.     }
  945.     private function isCurrentLineEmpty(): bool
  946.     {
  947.         return $this->isCurrentLineBlank() || $this->isCurrentLineComment();
  948.     }
  950.     private function isCurrentLineBlank(): bool
  951.     {
  952.         return '' === $this->currentLine || '' === trim($this->currentLine, ' ');
  953.     }
  955.     private function isCurrentLineComment(): bool
  956.     {
  957.         // checking explicitly the first char of the trim is faster than loops or strpos
  958.         $ltrimmedLine = '' !== $this->currentLine && ' ' === $this->currentLine[0] ? ltrim($this->currentLine, ' ') : $this->currentLine;
  960.         return '' !== $ltrimmedLine && '#' === $ltrimmedLine[0];
  961.     }
  963.     private function isCurrentLineLastLineInDocument(): bool
  964.     {
  965.         return ($this->offset + $this->currentLineNb) >= ($this->totalNumberOfLines - 1);
  966.     }
  968.     private function cleanup(string $value): string
  969.     {
  970.         $value = str_replace(["\r\n", "\r"], "\n", $value);
  972.         // strip YAML header
  973.         $count = 0;
  974.         $value = preg_replace('#^\%YAML[: ][\d\.]+.*\n#u', '', $value, -1, $count);
  975.         $this->offset += $count;
  977.         // remove leading comments
  978.         $trimmedValue = preg_replace('#^(\#.*?\n)+#s', '', $value, -1, $count);
  979.         if (1 === $count) {
  980.             // items have been removed, update the offset
  981.             $this->offset += substr_count($value, "\n") - substr_count($trimmedValue, "\n");
  982.             $value = $trimmedValue;
  983.         }
  985.         // remove start of the document marker (---)
  986.         $trimmedValue = preg_replace('#^\-\-\-.*?\n#s', '', $value, -1, $count);
  987.         if (1 === $count) {
  988.             // items have been removed, update the offset
  989.             $this->offset += substr_count($value, "\n") - substr_count($trimmedValue, "\n");
  990.             $value = $trimmedValue;
  992.             // remove end of the document marker (...)
  993.             $value = preg_replace('#\.\.\.\s*$#', '', $value);
  994.         }
  996.         return $value;
  997.     }
  999.     private function isNextLineUnIndentedCollection(): bool
  1000.     {
  1001.         $currentIndentation = $this->getCurrentLineIndentation();
  1002.         $movements = 0;
  1004.         do {
  1005.             $EOF = !$this->moveToNextLine();
  1007.             if (!$EOF) {
  1008.                 ++$movements;
  1009.             }
  1010.         } while (!$EOF && ($this->isCurrentLineEmpty() || $this->isCurrentLineComment()));
  1012.         if ($EOF) {
  1013.             return false;
  1014.         }
  1016.         $ret = $this->getCurrentLineIndentation() === $currentIndentation && $this->isStringUnIndentedCollectionItem();
  1018.         for ($i = 0; $i < $movements; ++$i) {
  1019.             $this->moveToPreviousLine();
  1020.         }
  1022.         return $ret;
  1023.     }
  1025.     private function isStringUnIndentedCollectionItem(): bool
  1026.     {
  1027.         return '-' === rtrim($this->currentLine) || str_starts_with($this->currentLine, '- ');
  1028.     }
  1030.     /**
  1031.      * A local wrapper for "preg_match" which will throw a ParseException if there
  1032.      * is an internal error in the PCRE engine.
  1033.      *
  1034.      * This avoids us needing to check for "false" every time PCRE is used
  1035.      * in the YAML engine
  1036.      *
  1037.      * @throws ParseException on a PCRE internal error
  1038.      *
  1039.      * @see preg_last_error()
  1040.      *
  1041.      * @internal
  1042.      */
  1043.     public static function preg_match(string $pattern, string $subject, array &$matches = null, int $flags = 0, int $offset = 0): int
  1044.     {
  1045.         if (false === $ret = preg_match($pattern, $subject, $matches, $flags, $offset)) {
  1046.             $error = match (preg_last_error()) {
  1047.                 \PREG_INTERNAL_ERROR => 'Internal PCRE error.',
  1048.                 \PREG_BACKTRACK_LIMIT_ERROR => 'pcre.backtrack_limit reached.',
  1049.                 \PREG_RECURSION_LIMIT_ERROR => 'pcre.recursion_limit reached.',
  1050.                 \PREG_BAD_UTF8_ERROR => 'Malformed UTF-8 data.',
  1051.                 \PREG_BAD_UTF8_OFFSET_ERROR => 'Offset doesn\'t correspond to the begin of a valid UTF-8 code point.',
  1052.                 default => 'Error.',
  1053.             };
  1055.             throw new ParseException($error);
  1056.         }
  1058.         return $ret;
  1059.     }
  1061.     /**
  1062.      * Trim the tag on top of the value.
  1063.      *
  1064.      * Prevent values such as "!foo {quz: bar}" to be considered as
  1065.      * a mapping block.
  1066.      */
  1067.     private function trimTag(string $value): string
  1068.     {
  1069.         if ('!' === $value[0]) {
  1070.             return ltrim(substr($value, 1, strcspn($value, " \r\n", 1)), ' ');
  1071.         }
  1073.         return $value;
  1074.     }
  1076.     private function getLineTag(string $value, int $flags, bool $nextLineCheck = true): ?string
  1077.     {
  1078.         if ('' === $value || '!' !== $value[0] || 1 !== self::preg_match('/^'.self::TAG_PATTERN.' *( +#.*)?$/', $value, $matches)) {
  1079.             return null;
  1080.         }
  1082.         if ($nextLineCheck && !$this->isNextLineIndented()) {
  1083.             return null;
  1084.         }
  1086.         $tag = substr($matches['tag'], 1);
  1088.         // Built-in tags
  1089.         if ($tag && '!' === $tag[0]) {
  1090.             throw new ParseException(sprintf('The built-in tag "!%s" is not implemented.', $tag), $this->getRealCurrentLineNb() + 1, $value, $this->filename);
  1091.         }
  1093.         if (Yaml::PARSE_CUSTOM_TAGS & $flags) {
  1094.             return $tag;
  1095.         }
  1097.         throw new ParseException(sprintf('Tags support is not enabled. You must use the flag "Yaml::PARSE_CUSTOM_TAGS" to use "%s".', $matches['tag']), $this->getRealCurrentLineNb() + 1, $value, $this->filename);
  1098.     }
  1100.     private function lexInlineQuotedString(int &$cursor = 0): string
  1101.     {
  1102.         $quotation = $this->currentLine[$cursor];
  1103.         $value = $quotation;
  1104.         ++$cursor;
  1106.         $previousLineWasNewline = true;
  1107.         $previousLineWasTerminatedWithBackslash = false;
  1108.         $lineNumber = 0;
  1110.         do {
  1111.             if (++$lineNumber > 1) {
  1112.                 $cursor += strspn($this->currentLine, ' ', $cursor);
  1113.             }
  1115.             if ($this->isCurrentLineBlank()) {
  1116.                 $value .= "\n";
  1117.             } elseif (!$previousLineWasNewline && !$previousLineWasTerminatedWithBackslash) {
  1118.                 $value .= ' ';
  1119.             }
  1121.             for (; \strlen($this->currentLine) > $cursor; ++$cursor) {
  1122.                 switch ($this->currentLine[$cursor]) {
  1123.                     case '\\':
  1124.                         if ("'" === $quotation) {
  1125.                             $value .= '\\';
  1126.                         } elseif (isset($this->currentLine[++$cursor])) {
  1127.                             $value .= '\\'.$this->currentLine[$cursor];
  1128.                         }
  1130.                         break;
  1131.                     case $quotation:
  1132.                         ++$cursor;
  1134.                         if ("'" === $quotation && isset($this->currentLine[$cursor]) && "'" === $this->currentLine[$cursor]) {
  1135.                             $value .= "''";
  1136.                             break;
  1137.                         }
  1139.                         return $value.$quotation;
  1140.                     default:
  1141.                         $value .= $this->currentLine[$cursor];
  1142.                 }
  1143.             }
  1145.             if ($this->isCurrentLineBlank()) {
  1146.                 $previousLineWasNewline = true;
  1147.                 $previousLineWasTerminatedWithBackslash = false;
  1148.             } elseif ('\\' === $this->currentLine[-1]) {
  1149.                 $previousLineWasNewline = false;
  1150.                 $previousLineWasTerminatedWithBackslash = true;
  1151.             } else {
  1152.                 $previousLineWasNewline = false;
  1153.                 $previousLineWasTerminatedWithBackslash = false;
  1154.             }
  1156.             if ($this->hasMoreLines()) {
  1157.                 $cursor = 0;
  1158.             }
  1159.         } while ($this->moveToNextLine());
  1161.         throw new ParseException('Malformed inline YAML string.');
  1162.     }
  1164.     private function lexUnquotedString(int &$cursor): string
  1165.     {
  1166.         $offset = $cursor;
  1167.         $cursor += strcspn($this->currentLine, '[]{},: ', $cursor);
  1169.         if ($cursor === $offset) {
  1170.             throw new ParseException('Malformed unquoted YAML string.');
  1171.         }
  1173.         return substr($this->currentLine, $offset, $cursor - $offset);
  1174.     }
  1176.     private function lexInlineMapping(int &$cursor = 0): string
  1177.     {
  1178.         return $this->lexInlineStructure($cursor, '}');
  1179.     }
  1181.     private function lexInlineSequence(int &$cursor = 0): string
  1182.     {
  1183.         return $this->lexInlineStructure($cursor, ']');
  1184.     }
  1186.     private function lexInlineStructure(int &$cursor, string $closingTag): string
  1187.     {
  1188.         $value = $this->currentLine[$cursor];
  1189.         ++$cursor;
  1191.         do {
  1192.             $this->consumeWhitespaces($cursor);
  1194.             while (isset($this->currentLine[$cursor])) {
  1195.                 switch ($this->currentLine[$cursor]) {
  1196.                     case '"':
  1197.                     case "'":
  1198.                         $value .= $this->lexInlineQuotedString($cursor);
  1199.                         break;
  1200.                     case ':':
  1201.                     case ',':
  1202.                         $value .= $this->currentLine[$cursor];
  1203.                         ++$cursor;
  1204.                         break;
  1205.                     case '{':
  1206.                         $value .= $this->lexInlineMapping($cursor);
  1207.                         break;
  1208.                     case '[':
  1209.                         $value .= $this->lexInlineSequence($cursor);
  1210.                         break;
  1211.                     case $closingTag:
  1212.                         $value .= $this->currentLine[$cursor];
  1213.                         ++$cursor;
  1215.                         return $value;
  1216.                     case '#':
  1217.                         break 2;
  1218.                     default:
  1219.                         $value .= $this->lexUnquotedString($cursor);
  1220.                 }
  1222.                 if ($this->consumeWhitespaces($cursor)) {
  1223.                     $value .= ' ';
  1224.                 }
  1225.             }
  1227.             if ($this->hasMoreLines()) {
  1228.                 $cursor = 0;
  1229.             }
  1230.         } while ($this->moveToNextLine());
  1232.         throw new ParseException('Malformed inline YAML string.');
  1233.     }
  1235.     private function consumeWhitespaces(int &$cursor): bool
  1236.     {
  1237.         $whitespacesConsumed = 0;
  1239.         do {
  1240.             $whitespaceOnlyTokenLength = strspn($this->currentLine, ' ', $cursor);
  1241.             $whitespacesConsumed += $whitespaceOnlyTokenLength;
  1242.             $cursor += $whitespaceOnlyTokenLength;
  1244.             if (isset($this->currentLine[$cursor])) {
  1245.                 return 0 < $whitespacesConsumed;
  1246.             }
  1248.             if ($this->hasMoreLines()) {
  1249.                 $cursor = 0;
  1250.             }
  1251.         } while ($this->moveToNextLine());
  1253.         return 0 < $whitespacesConsumed;
  1254.     }
  1255. }