private function Parser::doParse in Lockr 7.3

1 call to Parser::doParse()

Parser::parse in vendor/symfony/yaml/Parser.php

Parses a YAML string to a PHP value.

File

vendor/symfony/yaml/Parser.php, line 164

Class

Parser

Parser parses YAML strings to convert them to PHP arrays.

Namespace

Symfony\Component\Yaml

Code

private function doParse($value, $flags) {
  $this->currentLineNb = -1;
  $this->currentLine = '';
  $value = $this
    ->cleanup($value);
  $this->lines = explode("\n", $value);
  $this->locallySkippedLineNumbers = [];
  if (null === $this->totalNumberOfLines) {
    $this->totalNumberOfLines = \count($this->lines);
  }
  if (!$this
    ->moveToNextLine()) {
    return null;
  }
  $data = [];
  $context = null;
  $allowOverwrite = false;
  while ($this
    ->isCurrentLineEmpty()) {
    if (!$this
      ->moveToNextLine()) {
      return null;
    }
  }

  // Resolves the tag and returns if end of the document
  if (null !== ($tag = $this
    ->getLineTag($this->currentLine, $flags, false)) && !$this
    ->moveToNextLine()) {
    return new TaggedValue($tag, '');
  }
  do {
    if ($this
      ->isCurrentLineEmpty()) {
      continue;
    }

    // tab?
    if ("\t" === $this->currentLine[0]) {
      throw new ParseException('A YAML file cannot contain tabs as indentation.', $this
        ->getRealCurrentLineNb() + 1, $this->currentLine, $this->filename);
    }
    Inline::initialize($flags, $this
      ->getRealCurrentLineNb(), $this->filename);
    $isRef = $mergeNode = false;
    if (self::preg_match('#^\\-((?P<leadspaces>\\s+)(?P<value>.+))?$#u', rtrim($this->currentLine), $values)) {
      if ($context && 'mapping' == $context) {
        throw new ParseException('You cannot define a sequence item when in a mapping', $this
          ->getRealCurrentLineNb() + 1, $this->currentLine, $this->filename);
      }
      $context = 'sequence';
      if (isset($values['value']) && self::preg_match('#^&(?P<ref>[^ ]+) *(?P<value>.*)#u', $values['value'], $matches)) {
        $isRef = $matches['ref'];
        $this->refsBeingParsed[] = $isRef;
        $values['value'] = $matches['value'];
      }
      if (isset($values['value'][1]) && '?' === $values['value'][0] && ' ' === $values['value'][1]) {
        @trigger_error($this
          ->getDeprecationMessage('Starting an unquoted string with a question mark followed by a space is deprecated since Symfony 3.3 and will throw \\Symfony\\Component\\Yaml\\Exception\\ParseException in 4.0.'), E_USER_DEPRECATED);
      }

      // array
      if (!isset($values['value']) || '' == trim($values['value'], ' ') || 0 === strpos(ltrim($values['value'], ' '), '#')) {
        $data[] = $this
          ->parseBlock($this
          ->getRealCurrentLineNb() + 1, $this
          ->getNextEmbedBlock(null, true), $flags);
      }
      elseif (null !== ($subTag = $this
        ->getLineTag(ltrim($values['value'], ' '), $flags))) {
        $data[] = new TaggedValue($subTag, $this
          ->parseBlock($this
          ->getRealCurrentLineNb() + 1, $this
          ->getNextEmbedBlock(null, true), $flags));
      }
      else {
        if (isset($values['leadspaces']) && self::preg_match('#^(?P<key>' . Inline::REGEX_QUOTED_STRING . '|[^ \'"\\{\\[].*?) *\\:(\\s+(?P<value>.+?))?\\s*$#u', $this
          ->trimTag($values['value']), $matches)) {

          // this is a compact notation element, add to next block and parse
          $block = $values['value'];
          if ($this
            ->isNextLineIndented()) {
            $block .= "\n" . $this
              ->getNextEmbedBlock($this
              ->getCurrentLineIndentation() + \strlen($values['leadspaces']) + 1);
          }
          $data[] = $this
            ->parseBlock($this
            ->getRealCurrentLineNb(), $block, $flags);
        }
        else {
          $data[] = $this
            ->parseValue($values['value'], $flags, $context);
        }
      }
      if ($isRef) {
        $this->refs[$isRef] = end($data);
        array_pop($this->refsBeingParsed);
      }
    }
    elseif (self::preg_match('#^(?P<key>(?:![^\\s]++\\s++)?(?:' . Inline::REGEX_QUOTED_STRING . '|(?:!?!php/const:)?[^ \'"\\[\\{!].*?)) *\\:(\\s++(?P<value>.+))?$#u', rtrim($this->currentLine), $values) && (false === strpos($values['key'], ' #') || \in_array($values['key'][0], [
      '"',
      "'",
    ]))) {
      if ($context && 'sequence' == $context) {
        throw new ParseException('You cannot define a mapping item when in a sequence', $this->currentLineNb + 1, $this->currentLine, $this->filename);
      }
      $context = 'mapping';
      try {
        $i = 0;
        $evaluateKey = !(Yaml::PARSE_KEYS_AS_STRINGS & $flags);

        // constants in key will be evaluated anyway
        if (isset($values['key'][0]) && '!' === $values['key'][0] && Yaml::PARSE_CONSTANT & $flags) {
          $evaluateKey = true;
        }
        $key = Inline::parseScalar($values['key'], 0, null, $i, $evaluateKey);
      } catch (ParseException $e) {
        $e
          ->setParsedLine($this
          ->getRealCurrentLineNb() + 1);
        $e
          ->setSnippet($this->currentLine);
        throw $e;
      }
      if (!\is_string($key) && !\is_int($key)) {
        $keyType = is_numeric($key) ? 'numeric key' : 'non-string key';
        @trigger_error($this
          ->getDeprecationMessage(sprintf('Implicit casting of %s to string is deprecated since Symfony 3.3 and will throw \\Symfony\\Component\\Yaml\\Exception\\ParseException in 4.0. Quote your evaluable mapping keys instead.', $keyType)), E_USER_DEPRECATED);
      }

      // Convert float keys to strings, to avoid being converted to integers by PHP
      if (\is_float($key)) {
        $key = (string) $key;
      }
      if ('<<' === $key && (!isset($values['value']) || !self::preg_match('#^&(?P<ref>[^ ]+)#u', $values['value'], $refMatches))) {
        $mergeNode = true;
        $allowOverwrite = true;
        if (isset($values['value'][0]) && '*' === $values['value'][0]) {
          $refName = substr(rtrim($values['value']), 1);
          if (!\array_key_exists($refName, $this->refs)) {
            if (false !== ($pos = array_search($refName, $this->refsBeingParsed, true))) {
              throw new ParseException(sprintf('Circular reference [%s, %s] detected for reference "%s".', implode(', ', \array_slice($this->refsBeingParsed, $pos)), $refName, $refName), $this->currentLineNb + 1, $this->currentLine, $this->filename);
            }
            throw new ParseException(sprintf('Reference "%s" does not exist.', $refName), $this
              ->getRealCurrentLineNb() + 1, $this->currentLine, $this->filename);
          }
          $refValue = $this->refs[$refName];
          if (Yaml::PARSE_OBJECT_FOR_MAP & $flags && $refValue instanceof \stdClass) {
            $refValue = (array) $refValue;
          }
          if (!\is_array($refValue)) {
            throw new ParseException('YAML merge keys used with a scalar value instead of an array.', $this
              ->getRealCurrentLineNb() + 1, $this->currentLine, $this->filename);
          }
          $data += $refValue;

          // array union
        }
        else {
          if (isset($values['value']) && '' !== $values['value']) {
            $value = $values['value'];
          }
          else {
            $value = $this
              ->getNextEmbedBlock();
          }
          $parsed = $this
            ->parseBlock($this
            ->getRealCurrentLineNb() + 1, $value, $flags);
          if (Yaml::PARSE_OBJECT_FOR_MAP & $flags && $parsed instanceof \stdClass) {
            $parsed = (array) $parsed;
          }
          if (!\is_array($parsed)) {
            throw new ParseException('YAML merge keys used with a scalar value instead of an array.', $this
              ->getRealCurrentLineNb() + 1, $this->currentLine, $this->filename);
          }
          if (isset($parsed[0])) {

            // If the value associated with the merge key is a sequence, then this sequence is expected to contain mapping nodes
            // and each of these nodes is merged in turn according to its order in the sequence. Keys in mapping nodes earlier
            // in the sequence override keys specified in later mapping nodes.
            foreach ($parsed as $parsedItem) {
              if (Yaml::PARSE_OBJECT_FOR_MAP & $flags && $parsedItem instanceof \stdClass) {
                $parsedItem = (array) $parsedItem;
              }
              if (!\is_array($parsedItem)) {
                throw new ParseException('Merge items must be arrays.', $this
                  ->getRealCurrentLineNb() + 1, $parsedItem, $this->filename);
              }
              $data += $parsedItem;

              // array union
            }
          }
          else {

            // If the value associated with the key is a single mapping node, each of its key/value pairs is inserted into the
            // current mapping, unless the key already exists in it.
            $data += $parsed;

            // array union
          }
        }
      }
      elseif ('<<' !== $key && isset($values['value']) && self::preg_match('#^&(?P<ref>[^ ]++) *+(?P<value>.*)#u', $values['value'], $matches)) {
        $isRef = $matches['ref'];
        $this->refsBeingParsed[] = $isRef;
        $values['value'] = $matches['value'];
      }
      $subTag = null;
      if ($mergeNode) {

        // Merge keys
      }
      elseif (!isset($values['value']) || '' === $values['value'] || 0 === strpos($values['value'], '#') || null !== ($subTag = $this
        ->getLineTag($values['value'], $flags)) || '<<' === $key) {

        // hash
        // if next line is less indented or equal, then it means that the current value is null
        if (!$this
          ->isNextLineIndented() && !$this
          ->isNextLineUnIndentedCollection()) {

          // Spec: Keys MUST be unique; first one wins.
          // But overwriting is allowed when a merge node is used in current block.
          if ($allowOverwrite || !isset($data[$key])) {
            if (null !== $subTag) {
              $data[$key] = new TaggedValue($subTag, '');
            }
            else {
              $data[$key] = null;
            }
          }
          else {
            @trigger_error($this
              ->getDeprecationMessage(sprintf('Duplicate key "%s" detected whilst parsing YAML. Silent handling of duplicate mapping keys in YAML is deprecated since Symfony 3.2 and will throw \\Symfony\\Component\\Yaml\\Exception\\ParseException in 4.0.', $key)), E_USER_DEPRECATED);
          }
        }
        else {
          $value = $this
            ->parseBlock($this
            ->getRealCurrentLineNb() + 1, $this
            ->getNextEmbedBlock(), $flags);
          if ('<<' === $key) {
            $this->refs[$refMatches['ref']] = $value;
            if (Yaml::PARSE_OBJECT_FOR_MAP & $flags && $value instanceof \stdClass) {
              $value = (array) $value;
            }
            $data += $value;
          }
          elseif ($allowOverwrite || !isset($data[$key])) {

            // Spec: Keys MUST be unique; first one wins.
            // But overwriting is allowed when a merge node is used in current block.
            if (null !== $subTag) {
              $data[$key] = new TaggedValue($subTag, $value);
            }
            else {
              $data[$key] = $value;
            }
          }
          else {
            @trigger_error($this
              ->getDeprecationMessage(sprintf('Duplicate key "%s" detected whilst parsing YAML. Silent handling of duplicate mapping keys in YAML is deprecated since Symfony 3.2 and will throw \\Symfony\\Component\\Yaml\\Exception\\ParseException in 4.0.', $key)), E_USER_DEPRECATED);
          }
        }
      }
      else {
        $value = $this
          ->parseValue(rtrim($values['value']), $flags, $context);

        // Spec: Keys MUST be unique; first one wins.
        // But overwriting is allowed when a merge node is used in current block.
        if ($allowOverwrite || !isset($data[$key])) {
          $data[$key] = $value;
        }
        else {
          @trigger_error($this
            ->getDeprecationMessage(sprintf('Duplicate key "%s" detected whilst parsing YAML. Silent handling of duplicate mapping keys in YAML is deprecated since Symfony 3.2 and will throw \\Symfony\\Component\\Yaml\\Exception\\ParseException in 4.0.', $key)), E_USER_DEPRECATED);
        }
      }
      if ($isRef) {
        $this->refs[$isRef] = $data[$key];
        array_pop($this->refsBeingParsed);
      }
    }
    else {

      // multiple documents are not supported
      if ('---' === $this->currentLine) {
        throw new ParseException('Multiple documents are not supported.', $this->currentLineNb + 1, $this->currentLine, $this->filename);
      }
      if ($deprecatedUsage = isset($this->currentLine[1]) && '?' === $this->currentLine[0] && ' ' === $this->currentLine[1]) {
        @trigger_error($this
          ->getDeprecationMessage('Starting an unquoted string with a question mark followed by a space is deprecated since Symfony 3.3 and will throw \\Symfony\\Component\\Yaml\\Exception\\ParseException in 4.0.'), E_USER_DEPRECATED);
      }

      // 1-liner optionally followed by newline(s)
      if (\is_string($value) && $this->lines[0] === trim($value)) {
        try {
          $value = Inline::parse($this->lines[0], $flags, $this->refs);
        } catch (ParseException $e) {
          $e
            ->setParsedLine($this
            ->getRealCurrentLineNb() + 1);
          $e
            ->setSnippet($this->currentLine);
          throw $e;
        }
        return $value;
      }

      // try to parse the value as a multi-line string as a last resort
      if (0 === $this->currentLineNb) {
        $previousLineWasNewline = false;
        $previousLineWasTerminatedWithBackslash = false;
        $value = '';
        foreach ($this->lines as $line) {

          // If the indentation is not consistent at offset 0, it is to be considered as a ParseError
          if (0 === $this->offset && !$deprecatedUsage && isset($line[0]) && ' ' === $line[0]) {
            throw new ParseException('Unable to parse.', $this
              ->getRealCurrentLineNb() + 1, $this->currentLine, $this->filename);
          }
          if ('' === trim($line)) {
            $value .= "\n";
          }
          elseif (!$previousLineWasNewline && !$previousLineWasTerminatedWithBackslash) {
            $value .= ' ';
          }
          if ('' !== trim($line) && '\\' === substr($line, -1)) {
            $value .= ltrim(substr($line, 0, -1));
          }
          elseif ('' !== trim($line)) {
            $value .= trim($line);
          }
          if ('' === trim($line)) {
            $previousLineWasNewline = true;
            $previousLineWasTerminatedWithBackslash = false;
          }
          elseif ('\\' === substr($line, -1)) {
            $previousLineWasNewline = false;
            $previousLineWasTerminatedWithBackslash = true;
          }
          else {
            $previousLineWasNewline = false;
            $previousLineWasTerminatedWithBackslash = false;
          }
        }
        try {
          return Inline::parse(trim($value));
        } catch (ParseException $e) {

          // fall-through to the ParseException thrown below
        }
      }
      throw new ParseException('Unable to parse.', $this
        ->getRealCurrentLineNb() + 1, $this->currentLine, $this->filename);
    }
  } while ($this
    ->moveToNextLine());
  if (null !== $tag) {
    $data = new TaggedValue($tag, $data);
  }
  if (Yaml::PARSE_OBJECT_FOR_MAP & $flags && !\is_object($data) && 'mapping' === $context) {
    $object = new \stdClass();
    foreach ($data as $key => $value) {
      $object->{$key} = $value;
    }
    $data = $object;
  }
  return empty($data) ? null : $data;
}