vendor/symfony/yaml/Inline.php line 638

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\DumpException;
  15. use Symfony\Component\Yaml\Exception\ParseException;
  16. use Symfony\Component\Yaml\Tag\TaggedValue;
  18. /**
  19. * Inline implements a YAML parser/dumper for the YAML inline syntax.
  20. *
  21. * @author Fabien Potencier <fabien@symfony.com>
  22. *
  23. * @internal
  24. */
  25. class Inline
  26. {
  27. public const REGEX_QUOTED_STRING = '(?:"([^"\\\\]*+(?:\\\\.[^"\\\\]*+)*+)"|\'([^\']*+(?:\'\'[^\']*+)*+)\')';
  29. public static $parsedLineNumber = -1;
  30. public static $parsedFilename;
  32. private static $exceptionOnInvalidType = false;
  33. private static $objectSupport = false;
  34. private static $objectForMap = false;
  35. private static $constantSupport = false;
  37. public static function initialize(int $flags, ?int $parsedLineNumber = null, ?string $parsedFilename = null)
  38. {
  39. self::$exceptionOnInvalidType = (bool) (Yaml::PARSE_EXCEPTION_ON_INVALID_TYPE & $flags);
  40. self::$objectSupport = (bool) (Yaml::PARSE_OBJECT & $flags);
  41. self::$objectForMap = (bool) (Yaml::PARSE_OBJECT_FOR_MAP & $flags);
  42. self::$constantSupport = (bool) (Yaml::PARSE_CONSTANT & $flags);
  43. self::$parsedFilename = $parsedFilename;
  45. if (null !== $parsedLineNumber) {
  46. self::$parsedLineNumber = $parsedLineNumber;
  47. }
  48. }
  50. /**
  51. * Converts a YAML string to a PHP value.
  52. *
  53. * @param string|null $value A YAML string
  54. * @param int $flags A bit field of Yaml::PARSE_* constants to customize the YAML parser behavior
  55. * @param array $references Mapping of variable names to values
  56. *
  57. * @return mixed
  58. *
  59. * @throws ParseException
  60. */
  61. public static function parse(?string $value = null, int $flags = 0, array &$references = [])
  62. {
  63. if (null === $value) {
  64. return '';
  65. }
  67. self::initialize($flags);
  69. $value = trim($value);
  71. if ('' === $value) {
  72. return '';
  73. }
  75. if (2 /* MB_OVERLOAD_STRING */ & (int) \ini_get('mbstring.func_overload')) {
  76. $mbEncoding = mb_internal_encoding();
  77. mb_internal_encoding('ASCII');
  78. }
  80. try {
  81. $i = 0;
  82. $tag = self::parseTag($value, $i, $flags);
  83. switch ($value[$i]) {
  84. case '[':
  85. $result = self::parseSequence($value, $flags, $i, $references);
  86. ++$i;
  87. break;
  88. case '{':
  89. $result = self::parseMapping($value, $flags, $i, $references);
  90. ++$i;
  91. break;
  92. default:
  93. $result = self::parseScalar($value, $flags, null, $i, true, $references);
  94. }
  96. // some comments are allowed at the end
  97. if (preg_replace('/\s*#.*$/A', '', substr($value, $i))) {
  98. throw new ParseException(sprintf('Unexpected characters near "%s".', substr($value, $i)), self::$parsedLineNumber + 1, $value, self::$parsedFilename);
  99. }
  101. if (null !== $tag && '' !== $tag) {
  102. return new TaggedValue($tag, $result);
  103. }
  105. return $result;
  106. } finally {
  107. if (isset($mbEncoding)) {
  108. mb_internal_encoding($mbEncoding);
  109. }
  110. }
  111. }
  113. /**
  114. * Dumps a given PHP variable to a YAML string.
  115. *
  116. * @param mixed $value The PHP variable to convert
  117. * @param int $flags A bit field of Yaml::DUMP_* constants to customize the dumped YAML string
  118. *
  119. * @throws DumpException When trying to dump PHP resource
  120. */
  121. public static function dump($value, int $flags = 0): string
  122. {
  123. switch (true) {
  124. case \is_resource($value):
  125. if (Yaml::DUMP_EXCEPTION_ON_INVALID_TYPE & $flags) {
  126. throw new DumpException(sprintf('Unable to dump PHP resources in a YAML file ("%s").', get_resource_type($value)));
  127. }
  129. return self::dumpNull($flags);
  130. case $value instanceof \DateTimeInterface:
  131. return $value->format('c');
  132. case $value instanceof \UnitEnum:
  133. return sprintf('!php/const %s::%s', \get_class($value), $value->name);
  134. case \is_object($value):
  135. if ($value instanceof TaggedValue) {
  136. return '!'.$value->getTag().' '.self::dump($value->getValue(), $flags);
  137. }
  139. if (Yaml::DUMP_OBJECT & $flags) {
  140. return '!php/object '.self::dump(serialize($value));
  141. }
  143. if (Yaml::DUMP_OBJECT_AS_MAP & $flags && ($value instanceof \stdClass || $value instanceof \ArrayObject)) {
  144. $output = [];
  146. foreach ($value as $key => $val) {
  147. $output[] = sprintf('%s: %s', self::dump($key, $flags), self::dump($val, $flags));
  148. }
  150. return sprintf('{ %s }', implode(', ', $output));
  151. }
  153. if (Yaml::DUMP_EXCEPTION_ON_INVALID_TYPE & $flags) {
  154. throw new DumpException('Object support when dumping a YAML file has been disabled.');
  155. }
  157. return self::dumpNull($flags);
  158. case \is_array($value):
  159. return self::dumpArray($value, $flags);
  160. case null === $value:
  161. return self::dumpNull($flags);
  162. case true === $value:
  163. return 'true';
  164. case false === $value:
  165. return 'false';
  166. case \is_int($value):
  167. return $value;
  168. case is_numeric($value) && false === strpbrk($value, "\f\n\r\t\v"):
  169. $locale = setlocale(\LC_NUMERIC, 0);
  170. if (false !== $locale) {
  171. setlocale(\LC_NUMERIC, 'C');
  172. }
  173. if (\is_float($value)) {
  174. $repr = (string) $value;
  175. if (is_infinite($value)) {
  176. $repr = str_ireplace('INF', '.Inf', $repr);
  177. } elseif (floor($value) == $value && $repr == $value) {
  178. // Preserve float data type since storing a whole number will result in integer value.
  179. if (false === strpos($repr, 'E')) {
  180. $repr = $repr.'.0';
  181. }
  182. }
  183. } else {
  184. $repr = \is_string($value) ? "'$value'" : (string) $value;
  185. }
  186. if (false !== $locale) {
  187. setlocale(\LC_NUMERIC, $locale);
  188. }
  190. return $repr;
  191. case '' == $value:
  192. return "''";
  193. case self::isBinaryString($value):
  194. return '!!binary '.base64_encode($value);
  195. case Escaper::requiresDoubleQuoting($value):
  196. return Escaper::escapeWithDoubleQuotes($value);
  197. case Escaper::requiresSingleQuoting($value):
  198. case Parser::preg_match('{^[0-9]+[_0-9]*$}', $value):
  199. case Parser::preg_match(self::getHexRegex(), $value):
  200. case Parser::preg_match(self::getTimestampRegex(), $value):
  201. return Escaper::escapeWithSingleQuotes($value);
  202. default:
  203. return $value;
  204. }
  205. }
  207. /**
  208. * Check if given array is hash or just normal indexed array.
  209. *
  210. * @param array|\ArrayObject|\stdClass $value The PHP array or array-like object to check
  211. */
  212. public static function isHash($value): bool
  213. {
  214. if ($value instanceof \stdClass || $value instanceof \ArrayObject) {
  215. return true;
  216. }
  218. $expectedKey = 0;
  220. foreach ($value as $key => $val) {
  221. if ($key !== $expectedKey++) {
  222. return true;
  223. }
  224. }
  226. return false;
  227. }
  229. /**
  230. * Dumps a PHP array to a YAML string.
  231. *
  232. * @param array $value The PHP array to dump
  233. * @param int $flags A bit field of Yaml::DUMP_* constants to customize the dumped YAML string
  234. */
  235. private static function dumpArray(array $value, int $flags): string
  236. {
  237. // array
  238. if (($value || Yaml::DUMP_EMPTY_ARRAY_AS_SEQUENCE & $flags) && !self::isHash($value)) {
  239. $output = [];
  240. foreach ($value as $val) {
  241. $output[] = self::dump($val, $flags);
  242. }
  244. return sprintf('[%s]', implode(', ', $output));
  245. }
  247. // hash
  248. $output = [];
  249. foreach ($value as $key => $val) {
  250. $output[] = sprintf('%s: %s', self::dump($key, $flags), self::dump($val, $flags));
  251. }
  253. return sprintf('{ %s }', implode(', ', $output));
  254. }
  256. private static function dumpNull(int $flags): string
  257. {
  258. if (Yaml::DUMP_NULL_AS_TILDE & $flags) {
  259. return '~';
  260. }
  262. return 'null';
  263. }
  265. /**
  266. * Parses a YAML scalar.
  267. *
  268. * @return mixed
  269. *
  270. * @throws ParseException When malformed inline YAML string is parsed
  271. */
  272. public static function parseScalar(string $scalar, int $flags = 0, ?array $delimiters = null, int &$i = 0, bool $evaluate = true, array &$references = [], ?bool &$isQuoted = null)
  273. {
  274. if (\in_array($scalar[$i], ['"', "'"], true)) {
  275. // quoted scalar
  276. $isQuoted = true;
  277. $output = self::parseQuotedScalar($scalar, $i);
  279. if (null !== $delimiters) {
  280. $tmp = ltrim(substr($scalar, $i), " \n");
  281. if ('' === $tmp) {
  282. throw new ParseException(sprintf('Unexpected end of line, expected one of "%s".', implode('', $delimiters)), self::$parsedLineNumber + 1, $scalar, self::$parsedFilename);
  283. }
  284. if (!\in_array($tmp[0], $delimiters)) {
  285. throw new ParseException(sprintf('Unexpected characters (%s).', substr($scalar, $i)), self::$parsedLineNumber + 1, $scalar, self::$parsedFilename);
  286. }
  287. }
  288. } else {
  289. // "normal" string
  290. $isQuoted = false;
  292. if (!$delimiters) {
  293. $output = substr($scalar, $i);
  294. $i += \strlen($output);
  296. // remove comments
  297. if (Parser::preg_match('/[ \t]+#/', $output, $match, \PREG_OFFSET_CAPTURE)) {
  298. $output = substr($output, 0, $match[0][1]);
  299. }
  300. } elseif (Parser::preg_match('/^(.*?)('.implode('|', $delimiters).')/', substr($scalar, $i), $match)) {
  301. $output = $match[1];
  302. $i += \strlen($output);
  303. $output = trim($output);
  304. } else {
  305. throw new ParseException(sprintf('Malformed inline YAML string: "%s".', $scalar), self::$parsedLineNumber + 1, null, self::$parsedFilename);
  306. }
  308. // a non-quoted string cannot start with @ or ` (reserved) nor with a scalar indicator (| or >)
  309. if ($output && ('@' === $output[0] || '`' === $output[0] || '|' === $output[0] || '>' === $output[0] || '%' === $output[0])) {
  310. throw new ParseException(sprintf('The reserved indicator "%s" cannot start a plain scalar; you need to quote the scalar.', $output[0]), self::$parsedLineNumber + 1, $output, self::$parsedFilename);
  311. }
  313. if ($evaluate) {
  314. $output = self::evaluateScalar($output, $flags, $references, $isQuoted);
  315. }
  316. }
  318. return $output;
  319. }
  321. /**
  322. * Parses a YAML quoted scalar.
  323. *
  324. * @throws ParseException When malformed inline YAML string is parsed
  325. */
  326. private static function parseQuotedScalar(string $scalar, int &$i = 0): string
  327. {
  328. if (!Parser::preg_match('/'.self::REGEX_QUOTED_STRING.'/Au', substr($scalar, $i), $match)) {
  329. throw new ParseException(sprintf('Malformed inline YAML string: "%s".', substr($scalar, $i)), self::$parsedLineNumber + 1, $scalar, self::$parsedFilename);
  330. }
  332. $output = substr($match[0], 1, -1);
  334. $unescaper = new Unescaper();
  335. if ('"' == $scalar[$i]) {
  336. $output = $unescaper->unescapeDoubleQuotedString($output);
  337. } else {
  338. $output = $unescaper->unescapeSingleQuotedString($output);
  339. }
  341. $i += \strlen($match[0]);
  343. return $output;
  344. }
  346. /**
  347. * Parses a YAML sequence.
  348. *
  349. * @throws ParseException When malformed inline YAML string is parsed
  350. */
  351. private static function parseSequence(string $sequence, int $flags, int &$i = 0, array &$references = []): array
  352. {
  353. $output = [];
  354. $len = \strlen($sequence);
  355. ++$i;
  357. // [foo, bar, ...]
  358. while ($i < $len) {
  359. if (']' === $sequence[$i]) {
  360. return $output;
  361. }
  362. if (',' === $sequence[$i] || ' ' === $sequence[$i]) {
  363. ++$i;
  365. continue;
  366. }
  368. $tag = self::parseTag($sequence, $i, $flags);
  369. switch ($sequence[$i]) {
  370. case '[':
  371. // nested sequence
  372. $value = self::parseSequence($sequence, $flags, $i, $references);
  373. break;
  374. case '{':
  375. // nested mapping
  376. $value = self::parseMapping($sequence, $flags, $i, $references);
  377. break;
  378. default:
  379. $value = self::parseScalar($sequence, $flags, [',', ']'], $i, null === $tag, $references, $isQuoted);
  381. // the value can be an array if a reference has been resolved to an array var
  382. if (\is_string($value) && !$isQuoted && false !== strpos($value, ': ')) {
  383. // embedded mapping?
  384. try {
  385. $pos = 0;
  386. $value = self::parseMapping('{'.$value.'}', $flags, $pos, $references);
  387. } catch (\InvalidArgumentException $e) {
  388. // no, it's not
  389. }
  390. }
  392. if (!$isQuoted && \is_string($value) && '' !== $value && '&' === $value[0] && Parser::preg_match(Parser::REFERENCE_PATTERN, $value, $matches)) {
  393. $references[$matches['ref']] = $matches['value'];
  394. $value = $matches['value'];
  395. }
  397. --$i;
  398. }
  400. if (null !== $tag && '' !== $tag) {
  401. $value = new TaggedValue($tag, $value);
  402. }
  404. $output[] = $value;
  406. ++$i;
  407. }
  409. throw new ParseException(sprintf('Malformed inline YAML string: "%s".', $sequence), self::$parsedLineNumber + 1, null, self::$parsedFilename);
  410. }
  412. /**
  413. * Parses a YAML mapping.
  414. *
  415. * @return array|\stdClass
  416. *
  417. * @throws ParseException When malformed inline YAML string is parsed
  418. */
  419. private static function parseMapping(string $mapping, int $flags, int &$i = 0, array &$references = [])
  420. {
  421. $output = [];
  422. $len = \strlen($mapping);
  423. ++$i;
  424. $allowOverwrite = false;
  426. // {foo: bar, bar:foo, ...}
  427. while ($i < $len) {
  428. switch ($mapping[$i]) {
  429. case ' ':
  430. case ',':
  431. case "\n":
  432. ++$i;
  433. continue 2;
  434. case '}':
  435. if (self::$objectForMap) {
  436. return (object) $output;
  437. }
  439. return $output;
  440. }
  442. // key
  443. $offsetBeforeKeyParsing = $i;
  444. $isKeyQuoted = \in_array($mapping[$i], ['"', "'"], true);
  445. $key = self::parseScalar($mapping, $flags, [':', ' '], $i, false);
  447. if ($offsetBeforeKeyParsing === $i) {
  448. throw new ParseException('Missing mapping key.', self::$parsedLineNumber + 1, $mapping);
  449. }
  451. if ('!php/const' === $key) {
  452. $key .= ' '.self::parseScalar($mapping, $flags, [':'], $i, false);
  453. $key = self::evaluateScalar($key, $flags);
  454. }
  456. if (false === $i = strpos($mapping, ':', $i)) {
  457. break;
  458. }
  460. if (!$isKeyQuoted) {
  461. $evaluatedKey = self::evaluateScalar($key, $flags, $references);
  463. if ('' !== $key && $evaluatedKey !== $key && !\is_string($evaluatedKey) && !\is_int($evaluatedKey)) {
  464. throw new ParseException('Implicit casting of incompatible mapping keys to strings is not supported. Quote your evaluable mapping keys instead.', self::$parsedLineNumber + 1, $mapping);
  465. }
  466. }
  468. if (!$isKeyQuoted && (!isset($mapping[$i + 1]) || !\in_array($mapping[$i + 1], [' ', ',', '[', ']', '{', '}', "\n"], true))) {
  469. throw new ParseException('Colons must be followed by a space or an indication character (i.e. " ", ",", "[", "]", "{", "}").', self::$parsedLineNumber + 1, $mapping);
  470. }
  472. if ('<<' === $key) {
  473. $allowOverwrite = true;
  474. }
  476. while ($i < $len) {
  477. if (':' === $mapping[$i] || ' ' === $mapping[$i] || "\n" === $mapping[$i]) {
  478. ++$i;
  480. continue;
  481. }
  483. $tag = self::parseTag($mapping, $i, $flags);
  484. switch ($mapping[$i]) {
  485. case '[':
  486. // nested sequence
  487. $value = self::parseSequence($mapping, $flags, $i, $references);
  488. // Spec: Keys MUST be unique; first one wins.
  489. // Parser cannot abort this mapping earlier, since lines
  490. // are processed sequentially.
  491. // But overwriting is allowed when a merge node is used in current block.
  492. if ('<<' === $key) {
  493. foreach ($value as $parsedValue) {
  494. $output += $parsedValue;
  495. }
  496. } elseif ($allowOverwrite || !isset($output[$key])) {
  497. if (null !== $tag) {
  498. $output[$key] = new TaggedValue($tag, $value);
  499. } else {
  500. $output[$key] = $value;
  501. }
  502. } elseif (isset($output[$key])) {
  503. throw new ParseException(sprintf('Duplicate key "%s" detected.', $key), self::$parsedLineNumber + 1, $mapping);
  504. }
  505. break;
  506. case '{':
  507. // nested mapping
  508. $value = self::parseMapping($mapping, $flags, $i, $references);
  509. // Spec: Keys MUST be unique; first one wins.
  510. // Parser cannot abort this mapping earlier, since lines
  511. // are processed sequentially.
  512. // But overwriting is allowed when a merge node is used in current block.
  513. if ('<<' === $key) {
  514. $output += $value;
  515. } elseif ($allowOverwrite || !isset($output[$key])) {
  516. if (null !== $tag) {
  517. $output[$key] = new TaggedValue($tag, $value);
  518. } else {
  519. $output[$key] = $value;
  520. }
  521. } elseif (isset($output[$key])) {
  522. throw new ParseException(sprintf('Duplicate key "%s" detected.', $key), self::$parsedLineNumber + 1, $mapping);
  523. }
  524. break;
  525. default:
  526. $value = self::parseScalar($mapping, $flags, [',', '}', "\n"], $i, null === $tag, $references, $isValueQuoted);
  527. // Spec: Keys MUST be unique; first one wins.
  528. // Parser cannot abort this mapping earlier, since lines
  529. // are processed sequentially.
  530. // But overwriting is allowed when a merge node is used in current block.
  531. if ('<<' === $key) {
  532. $output += $value;
  533. } elseif ($allowOverwrite || !isset($output[$key])) {
  534. if (!$isValueQuoted && \is_string($value) && '' !== $value && '&' === $value[0] && !self::isBinaryString($value) && Parser::preg_match(Parser::REFERENCE_PATTERN, $value, $matches)) {
  535. $references[$matches['ref']] = $matches['value'];
  536. $value = $matches['value'];
  537. }
  539. if (null !== $tag) {
  540. $output[$key] = new TaggedValue($tag, $value);
  541. } else {
  542. $output[$key] = $value;
  543. }
  544. } elseif (isset($output[$key])) {
  545. throw new ParseException(sprintf('Duplicate key "%s" detected.', $key), self::$parsedLineNumber + 1, $mapping);
  546. }
  547. --$i;
  548. }
  549. ++$i;
  551. continue 2;
  552. }
  553. }
  555. throw new ParseException(sprintf('Malformed inline YAML string: "%s".', $mapping), self::$parsedLineNumber + 1, null, self::$parsedFilename);
  556. }
  558. /**
  559. * Evaluates scalars and replaces magic values.
  560. *
  561. * @return mixed
  562. *
  563. * @throws ParseException when object parsing support was disabled and the parser detected a PHP object or when a reference could not be resolved
  564. */
  565. private static function evaluateScalar(string $scalar, int $flags, array &$references = [], ?bool &$isQuotedString = null)
  566. {
  567. $isQuotedString = false;
  568. $scalar = trim($scalar);
  570. if (0 === strpos($scalar, '*')) {
  571. if (false !== $pos = strpos($scalar, '#')) {
  572. $value = substr($scalar, 1, $pos - 2);
  573. } else {
  574. $value = substr($scalar, 1);
  575. }
  577. // an unquoted *
  578. if (false === $value || '' === $value) {
  579. throw new ParseException('A reference must contain at least one character.', self::$parsedLineNumber + 1, $value, self::$parsedFilename);
  580. }
  582. if (!\array_key_exists($value, $references)) {
  583. throw new ParseException(sprintf('Reference "%s" does not exist.', $value), self::$parsedLineNumber + 1, $value, self::$parsedFilename);
  584. }
  586. return $references[$value];
  587. }
  589. $scalarLower = strtolower($scalar);
  591. switch (true) {
  592. case 'null' === $scalarLower:
  593. case '' === $scalar:
  594. case '~' === $scalar:
  595. return null;
  596. case 'true' === $scalarLower:
  597. return true;
  598. case 'false' === $scalarLower:
  599. return false;
  600. case '!' === $scalar[0]:
  601. switch (true) {
  602. case 0 === strpos($scalar, '!!str '):
  603. $s = (string) substr($scalar, 6);
  605. if (\in_array($s[0] ?? '', ['"', "'"], true)) {
  606. $isQuotedString = true;
  607. $s = self::parseQuotedScalar($s);
  608. }
  610. return $s;
  611. case 0 === strpos($scalar, '! '):
  612. return substr($scalar, 2);
  613. case 0 === strpos($scalar, '!php/object'):
  614. if (self::$objectSupport) {
  615. if (!isset($scalar[12])) {
  616. trigger_deprecation('symfony/yaml', '5.1', 'Using the !php/object tag without a value is deprecated.');
  618. return false;
  619. }
  621. return unserialize(self::parseScalar(substr($scalar, 12)));
  622. }
  624. if (self::$exceptionOnInvalidType) {
  625. throw new ParseException('Object support when parsing a YAML file has been disabled.', self::$parsedLineNumber + 1, $scalar, self::$parsedFilename);
  626. }
  628. return null;
  629. case 0 === strpos($scalar, '!php/const'):
  630. if (self::$constantSupport) {
  631. if (!isset($scalar[11])) {
  632. trigger_deprecation('symfony/yaml', '5.1', 'Using the !php/const tag without a value is deprecated.');
  634. return '';
  635. }
  637. $i = 0;
  638. if (\defined($const = self::parseScalar(substr($scalar, 11), 0, null, $i, false))) {
  639. return \constant($const);
  640. }
  642. throw new ParseException(sprintf('The constant "%s" is not defined.', $const), self::$parsedLineNumber + 1, $scalar, self::$parsedFilename);
  643. }
  644. if (self::$exceptionOnInvalidType) {
  645. throw new ParseException(sprintf('The string "%s" could not be parsed as a constant. Did you forget to pass the "Yaml::PARSE_CONSTANT" flag to the parser?', $scalar), self::$parsedLineNumber + 1, $scalar, self::$parsedFilename);
  646. }
  648. return null;
  649. case 0 === strpos($scalar, '!!float '):
  650. return (float) substr($scalar, 8);
  651. case 0 === strpos($scalar, '!!binary '):
  652. return self::evaluateBinaryScalar(substr($scalar, 9));
  653. }
  655. throw new ParseException(sprintf('The string "%s" could not be parsed as it uses an unsupported built-in tag.', $scalar), self::$parsedLineNumber, $scalar, self::$parsedFilename);
  656. case preg_match('/^(?:\+|-)?0o(?P<value>[0-7_]++)$/', $scalar, $matches):
  657. $value = str_replace('_', '', $matches['value']);
  659. if ('-' === $scalar[0]) {
  660. return -octdec($value);
  661. }
  663. return octdec($value);
  664. case \in_array($scalar[0], ['+', '-', '.'], true) || is_numeric($scalar[0]):
  665. if (Parser::preg_match('{^[+-]?[0-9][0-9_]*$}', $scalar)) {
  666. $scalar = str_replace('_', '', $scalar);
  667. }
  669. switch (true) {
  670. case ctype_digit($scalar):
  671. if (preg_match('/^0[0-7]+$/', $scalar)) {
  672. trigger_deprecation('symfony/yaml', '5.1', 'Support for parsing numbers prefixed with 0 as octal numbers. They will be parsed as strings as of 6.0. Use "%s" to represent the octal number.', '0o'.substr($scalar, 1));
  674. return octdec($scalar);
  675. }
  677. $cast = (int) $scalar;
  679. return ($scalar === (string) $cast) ? $cast : $scalar;
  680. case '-' === $scalar[0] && ctype_digit(substr($scalar, 1)):
  681. if (preg_match('/^-0[0-7]+$/', $scalar)) {
  682. trigger_deprecation('symfony/yaml', '5.1', 'Support for parsing numbers prefixed with 0 as octal numbers. They will be parsed as strings as of 6.0. Use "%s" to represent the octal number.', '-0o'.substr($scalar, 2));
  684. return -octdec(substr($scalar, 1));
  685. }
  687. $cast = (int) $scalar;
  689. return ($scalar === (string) $cast) ? $cast : $scalar;
  690. case is_numeric($scalar):
  691. case Parser::preg_match(self::getHexRegex(), $scalar):
  692. $scalar = str_replace('_', '', $scalar);
  694. return '0x' === $scalar[0].$scalar[1] ? hexdec($scalar) : (float) $scalar;
  695. case '.inf' === $scalarLower:
  696. case '.nan' === $scalarLower:
  697. return -log(0);
  698. case '-.inf' === $scalarLower:
  699. return log(0);
  700. case Parser::preg_match('/^(-|\+)?[0-9][0-9_]*(\.[0-9_]+)?$/', $scalar):
  701. return (float) str_replace('_', '', $scalar);
  702. case Parser::preg_match(self::getTimestampRegex(), $scalar):
  703. try {
  704. // When no timezone is provided in the parsed date, YAML spec says we must assume UTC.
  705. $time = new \DateTime($scalar, new \DateTimeZone('UTC'));
  706. } catch (\Exception $e) {
  707. // Some dates accepted by the regex are not valid dates.
  708. throw new ParseException(\sprintf('The date "%s" could not be parsed as it is an invalid date.', $scalar), self::$parsedLineNumber + 1, $scalar, self::$parsedFilename, $e);
  709. }
  711. if (Yaml::PARSE_DATETIME & $flags) {
  712. return $time;
  713. }
  715. try {
  716. if (false !== $scalar = $time->getTimestamp()) {
  717. return $scalar;
  718. }
  719. } catch (\ValueError $e) {
  720. // no-op
  721. }
  723. return $time->format('U');
  724. }
  725. }
  727. return (string) $scalar;
  728. }
  730. private static function parseTag(string $value, int &$i, int $flags): ?string
  731. {
  732. if ('!' !== $value[$i]) {
  733. return null;
  734. }
  736. $tagLength = strcspn($value, " \t\n[]{},", $i + 1);
  737. $tag = substr($value, $i + 1, $tagLength);
  739. $nextOffset = $i + $tagLength + 1;
  740. $nextOffset += strspn($value, ' ', $nextOffset);
  742. if ('' === $tag && (!isset($value[$nextOffset]) || \in_array($value[$nextOffset], [']', '}', ','], true))) {
  743. throw new ParseException('Using the unquoted scalar value "!" is not supported. You must quote it.', self::$parsedLineNumber + 1, $value, self::$parsedFilename);
  744. }
  746. // Is followed by a scalar and is a built-in tag
  747. if ('' !== $tag && (!isset($value[$nextOffset]) || !\in_array($value[$nextOffset], ['[', '{'], true)) && ('!' === $tag[0] || 'str' === $tag || 'php/const' === $tag || 'php/object' === $tag)) {
  748. // Manage in {@link self::evaluateScalar()}
  749. return null;
  750. }
  752. $i = $nextOffset;
  754. // Built-in tags
  755. if ('' !== $tag && '!' === $tag[0]) {
  756. throw new ParseException(sprintf('The built-in tag "!%s" is not implemented.', $tag), self::$parsedLineNumber + 1, $value, self::$parsedFilename);
  757. }
  759. if ('' !== $tag && !isset($value[$i])) {
  760. throw new ParseException(sprintf('Missing value for tag "%s".', $tag), self::$parsedLineNumber + 1, $value, self::$parsedFilename);
  761. }
  763. if ('' === $tag || Yaml::PARSE_CUSTOM_TAGS & $flags) {
  764. return $tag;
  765. }
  767. throw new ParseException(sprintf('Tags support is not enabled. Enable the "Yaml::PARSE_CUSTOM_TAGS" flag to use "!%s".', $tag), self::$parsedLineNumber + 1, $value, self::$parsedFilename);
  768. }
  770. public static function evaluateBinaryScalar(string $scalar): string
  771. {
  772. $parsedBinaryData = self::parseScalar(preg_replace('/\s/', '', $scalar));
  774. if (0 !== (\strlen($parsedBinaryData) % 4)) {
  775. throw new ParseException(sprintf('The normalized base64 encoded data (data without whitespace characters) length must be a multiple of four (%d bytes given).', \strlen($parsedBinaryData)), self::$parsedLineNumber + 1, $scalar, self::$parsedFilename);
  776. }
  778. if (!Parser::preg_match('#^[A-Z0-9+/]+={0,2}$#i', $parsedBinaryData)) {
  779. throw new ParseException(sprintf('The base64 encoded data (%s) contains invalid characters.', $parsedBinaryData), self::$parsedLineNumber + 1, $scalar, self::$parsedFilename);
  780. }
  782. return base64_decode($parsedBinaryData, true);
  783. }
  785. private static function isBinaryString(string $value): bool
  786. {
  787. return !preg_match('//u', $value) || preg_match('/[^\x00\x07-\x0d\x1B\x20-\xff]/', $value);
  788. }
  790. /**
  791. * Gets a regex that matches a YAML date.
  792. *
  793. * @see http://www.yaml.org/spec/1.2/spec.html#id2761573
  794. */
  795. private static function getTimestampRegex(): string
  796. {
  797. return <<<EOF
  798. ~^
  799. (?P<year>[0-9][0-9][0-9][0-9])
  800. -(?P<month>[0-9][0-9]?)
  801. -(?P<day>[0-9][0-9]?)
  802. (?:(?:[Tt]|[ \t]+)
  803. (?P<hour>[0-9][0-9]?)
  804. :(?P<minute>[0-9][0-9])
  805. :(?P<second>[0-9][0-9])
  806. (?:\.(?P<fraction>[0-9]*))?
  807. (?:[ \t]*(?P<tz>Z|(?P<tz_sign>[-+])(?P<tz_hour>[0-9][0-9]?)
  808. (?::(?P<tz_minute>[0-9][0-9]))?))?)?
  809. $~x
  810. EOF;
  811. }
  813. /**
  814. * Gets a regex that matches a YAML number in hexadecimal notation.
  815. */
  816. private static function getHexRegex(): string
  817. {
  818. return '~^0x[0-9a-f_]++$~i';
  819. }
  820. }