Exporter.php 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405
  1. <?php
  2. /*
  3. * This file is part of the Symfony package.
  4. *
  5. * (c) Fabien Potencier <fabien@symfony.com>
  6. *
  7. * For the full copyright and license information, please view the LICENSE
  8. * file that was distributed with this source code.
  9. */
  10. namespace Symfony\Component\VarExporter\Internal;
  11. use Symfony\Component\VarExporter\Exception\NotInstantiableTypeException;
  12. /**
  13. * @author Nicolas Grekas <p@tchwork.com>
  14. *
  15. * @internal
  16. */
  17. class Exporter
  18. {
  19. /**
  20. * Prepares an array of values for VarExporter.
  21. *
  22. * For performance this method is public and has no type-hints.
  23. *
  24. * @param array &$values
  25. * @param \SplObjectStorage $objectsPool
  26. * @param array &$refsPool
  27. * @param int &$objectsCount
  28. * @param bool &$valuesAreStatic
  29. *
  30. * @throws NotInstantiableTypeException When a value cannot be serialized
  31. */
  32. public static function prepare($values, $objectsPool, &$refsPool, &$objectsCount, &$valuesAreStatic): array
  33. {
  34. $refs = $values;
  35. foreach ($values as $k => $value) {
  36. if (\is_resource($value)) {
  37. throw new NotInstantiableTypeException(get_resource_type($value).' resource');
  38. }
  39. $refs[$k] = $objectsPool;
  40. if ($isRef = !$valueIsStatic = $values[$k] !== $objectsPool) {
  41. $values[$k] = &$value; // Break hard references to make $values completely
  42. unset($value); // independent from the original structure
  43. $refs[$k] = $value = $values[$k];
  44. if ($value instanceof Reference && 0 > $value->id) {
  45. $valuesAreStatic = false;
  46. ++$value->count;
  47. continue;
  48. }
  49. $refsPool[] = [&$refs[$k], $value, &$value];
  50. $refs[$k] = $values[$k] = new Reference(-\count($refsPool), $value);
  51. }
  52. if (\is_array($value)) {
  53. if ($value) {
  54. $value = self::prepare($value, $objectsPool, $refsPool, $objectsCount, $valueIsStatic);
  55. }
  56. goto handle_value;
  57. } elseif (!\is_object($value) && !$value instanceof \__PHP_Incomplete_Class) {
  58. goto handle_value;
  59. }
  60. $valueIsStatic = false;
  61. if (isset($objectsPool[$value])) {
  62. ++$objectsCount;
  63. $value = new Reference($objectsPool[$value][0]);
  64. goto handle_value;
  65. }
  66. $class = \get_class($value);
  67. $reflector = Registry::$reflectors[$class] ?? Registry::getClassReflector($class);
  68. if ($reflector->hasMethod('__serialize')) {
  69. if (!$reflector->getMethod('__serialize')->isPublic()) {
  70. throw new \Error(sprintf('Call to %s method %s::__serialize()', $reflector->getMethod('__serialize')->isProtected() ? 'protected' : 'private', $class));
  71. }
  72. if (!\is_array($properties = $value->__serialize())) {
  73. throw new \Typerror($class.'::__serialize() must return an array');
  74. }
  75. goto prepare_value;
  76. }
  77. $properties = [];
  78. $sleep = null;
  79. $arrayValue = (array) $value;
  80. $proto = Registry::$prototypes[$class];
  81. if (($value instanceof \ArrayIterator || $value instanceof \ArrayObject) && null !== $proto) {
  82. // ArrayIterator and ArrayObject need special care because their "flags"
  83. // option changes the behavior of the (array) casting operator.
  84. $properties = self::getArrayObjectProperties($value, $arrayValue, $proto);
  85. // populates Registry::$prototypes[$class] with a new instance
  86. Registry::getClassReflector($class, Registry::$instantiableWithoutConstructor[$class], Registry::$cloneable[$class]);
  87. } elseif ($value instanceof \SplObjectStorage && Registry::$cloneable[$class] && null !== $proto) {
  88. // By implementing Serializable, SplObjectStorage breaks
  89. // internal references; let's deal with it on our own.
  90. foreach (clone $value as $v) {
  91. $properties[] = $v;
  92. $properties[] = $value[$v];
  93. }
  94. $properties = ['SplObjectStorage' => ["\0" => $properties]];
  95. } elseif ($value instanceof \Serializable || $value instanceof \__PHP_Incomplete_Class) {
  96. ++$objectsCount;
  97. $objectsPool[$value] = [$id = \count($objectsPool), serialize($value), [], 0];
  98. $value = new Reference($id);
  99. goto handle_value;
  100. }
  101. if (method_exists($class, '__sleep')) {
  102. if (!\is_array($sleep = $value->__sleep())) {
  103. trigger_error('serialize(): __sleep should return an array only containing the names of instance-variables to serialize', E_USER_NOTICE);
  104. $value = null;
  105. goto handle_value;
  106. }
  107. foreach ($sleep as $name) {
  108. if (property_exists($value, $name) && !$reflector->hasProperty($name)) {
  109. $arrayValue[$name] = $value->$name;
  110. }
  111. }
  112. $sleep = array_flip($sleep);
  113. }
  114. $proto = (array) $proto;
  115. foreach ($arrayValue as $name => $v) {
  116. $i = 0;
  117. $n = (string) $name;
  118. if ('' === $n || "\0" !== $n[0]) {
  119. $c = 'stdClass';
  120. } elseif ('*' === $n[1]) {
  121. $n = substr($n, 3);
  122. $c = $reflector->getProperty($n)->class;
  123. if ('Error' === $c) {
  124. $c = 'TypeError';
  125. } elseif ('Exception' === $c) {
  126. $c = 'ErrorException';
  127. }
  128. } else {
  129. $i = strpos($n, "\0", 2);
  130. $c = substr($n, 1, $i - 1);
  131. $n = substr($n, 1 + $i);
  132. }
  133. if (null !== $sleep) {
  134. if (!isset($sleep[$n]) || ($i && $c !== $class)) {
  135. continue;
  136. }
  137. $sleep[$n] = false;
  138. }
  139. if (!\array_key_exists($name, $proto) || $proto[$name] !== $v || "\x00Error\x00trace" === $name || "\x00Exception\x00trace" === $name) {
  140. $properties[$c][$n] = $v;
  141. }
  142. }
  143. if ($sleep) {
  144. foreach ($sleep as $n => $v) {
  145. if (false !== $v) {
  146. trigger_error(sprintf('serialize(): "%s" returned as member variable from __sleep() but does not exist', $n), E_USER_NOTICE);
  147. }
  148. }
  149. }
  150. prepare_value:
  151. $objectsPool[$value] = [$id = \count($objectsPool)];
  152. $properties = self::prepare($properties, $objectsPool, $refsPool, $objectsCount, $valueIsStatic);
  153. ++$objectsCount;
  154. $objectsPool[$value] = [$id, $class, $properties, method_exists($class, '__unserialize') ? -$objectsCount : (method_exists($class, '__wakeup') ? $objectsCount : 0)];
  155. $value = new Reference($id);
  156. handle_value:
  157. if ($isRef) {
  158. unset($value); // Break the hard reference created above
  159. } elseif (!$valueIsStatic) {
  160. $values[$k] = $value;
  161. }
  162. $valuesAreStatic = $valueIsStatic && $valuesAreStatic;
  163. }
  164. return $values;
  165. }
  166. public static function export($value, string $indent = '')
  167. {
  168. switch (true) {
  169. case \is_int($value) || \is_float($value): return var_export($value, true);
  170. case [] === $value: return '[]';
  171. case false === $value: return 'false';
  172. case true === $value: return 'true';
  173. case null === $value: return 'null';
  174. case '' === $value: return "''";
  175. }
  176. if ($value instanceof Reference) {
  177. if (0 <= $value->id) {
  178. return '$o['.$value->id.']';
  179. }
  180. if (!$value->count) {
  181. return self::export($value->value, $indent);
  182. }
  183. $value = -$value->id;
  184. return '&$r['.$value.']';
  185. }
  186. $subIndent = $indent.' ';
  187. if (\is_string($value)) {
  188. $code = sprintf("'%s'", addcslashes($value, "'\\"));
  189. $code = preg_replace_callback('/([\0\r\n]++)(.)/', function ($m) use ($subIndent) {
  190. $m[1] = sprintf('\'."%s".\'', str_replace(
  191. ["\0", "\r", "\n", '\n\\'],
  192. ['\0', '\r', '\n', '\n"'."\n".$subIndent.'."\\'],
  193. $m[1]
  194. ));
  195. if ("'" === $m[2]) {
  196. return substr($m[1], 0, -2);
  197. }
  198. if ('n".\'' === substr($m[1], -4)) {
  199. return substr_replace($m[1], "\n".$subIndent.".'".$m[2], -2);
  200. }
  201. return $m[1].$m[2];
  202. }, $code, -1, $count);
  203. if ($count && 0 === strpos($code, "''.")) {
  204. $code = substr($code, 3);
  205. }
  206. return $code;
  207. }
  208. if (\is_array($value)) {
  209. $j = -1;
  210. $code = '';
  211. foreach ($value as $k => $v) {
  212. $code .= $subIndent;
  213. if (!\is_int($k) || 1 !== $k - $j) {
  214. $code .= self::export($k, $subIndent).' => ';
  215. }
  216. if (\is_int($k) && $k > $j) {
  217. $j = $k;
  218. }
  219. $code .= self::export($v, $subIndent).",\n";
  220. }
  221. return "[\n".$code.$indent.']';
  222. }
  223. if ($value instanceof Values) {
  224. $code = $subIndent."\$r = [],\n";
  225. foreach ($value->values as $k => $v) {
  226. $code .= $subIndent.'$r['.$k.'] = '.self::export($v, $subIndent).",\n";
  227. }
  228. return "[\n".$code.$indent.']';
  229. }
  230. if ($value instanceof Registry) {
  231. return self::exportRegistry($value, $indent, $subIndent);
  232. }
  233. if ($value instanceof Hydrator) {
  234. return self::exportHydrator($value, $indent, $subIndent);
  235. }
  236. throw new \UnexpectedValueException(sprintf('Cannot export value of type "%s".', \is_object($value) ? \get_class($value) : \gettype($value)));
  237. }
  238. private static function exportRegistry(Registry $value, string $indent, string $subIndent): string
  239. {
  240. $code = '';
  241. $serializables = [];
  242. $seen = [];
  243. $prototypesAccess = 0;
  244. $factoriesAccess = 0;
  245. $r = '\\'.Registry::class;
  246. $j = -1;
  247. foreach ($value as $k => $class) {
  248. if (':' === ($class[1] ?? null)) {
  249. $serializables[$k] = $class;
  250. continue;
  251. }
  252. if (!Registry::$instantiableWithoutConstructor[$class]) {
  253. if (is_subclass_of($class, 'Serializable') && !method_exists($class, '__unserialize')) {
  254. $serializables[$k] = 'C:'.\strlen($class).':"'.$class.'":0:{}';
  255. } else {
  256. $serializables[$k] = 'O:'.\strlen($class).':"'.$class.'":0:{}';
  257. }
  258. if (is_subclass_of($class, 'Throwable')) {
  259. $eol = is_subclass_of($class, 'Error') ? "\0Error\0" : "\0Exception\0";
  260. $serializables[$k] = substr_replace($serializables[$k], '1:{s:'.(5 + \strlen($eol)).':"'.$eol.'trace";a:0:{}}', -4);
  261. }
  262. continue;
  263. }
  264. $code .= $subIndent.(1 !== $k - $j ? $k.' => ' : '');
  265. $j = $k;
  266. $eol = ",\n";
  267. $c = '['.self::export($class).']';
  268. if ($seen[$class] ?? false) {
  269. if (Registry::$cloneable[$class]) {
  270. ++$prototypesAccess;
  271. $code .= 'clone $p'.$c;
  272. } else {
  273. ++$factoriesAccess;
  274. $code .= '$f'.$c.'()';
  275. }
  276. } else {
  277. $seen[$class] = true;
  278. if (Registry::$cloneable[$class]) {
  279. $code .= 'clone ('.($prototypesAccess++ ? '$p' : '($p = &'.$r.'::$prototypes)').$c.' ?? '.$r.'::p';
  280. } else {
  281. $code .= '('.($factoriesAccess++ ? '$f' : '($f = &'.$r.'::$factories)').$c.' ?? '.$r.'::f';
  282. $eol = '()'.$eol;
  283. }
  284. $code .= '('.substr($c, 1, -1).'))';
  285. }
  286. $code .= $eol;
  287. }
  288. if (1 === $prototypesAccess) {
  289. $code = str_replace('($p = &'.$r.'::$prototypes)', $r.'::$prototypes', $code);
  290. }
  291. if (1 === $factoriesAccess) {
  292. $code = str_replace('($f = &'.$r.'::$factories)', $r.'::$factories', $code);
  293. }
  294. if ('' !== $code) {
  295. $code = "\n".$code.$indent;
  296. }
  297. if ($serializables) {
  298. $code = $r.'::unserialize(['.$code.'], '.self::export($serializables, $indent).')';
  299. } else {
  300. $code = '['.$code.']';
  301. }
  302. return '$o = '.$code;
  303. }
  304. private static function exportHydrator(Hydrator $value, string $indent, string $subIndent): string
  305. {
  306. $code = '';
  307. foreach ($value->properties as $class => $properties) {
  308. $code .= $subIndent.' '.self::export($class).' => '.self::export($properties, $subIndent.' ').",\n";
  309. }
  310. $code = [
  311. self::export($value->registry, $subIndent),
  312. self::export($value->values, $subIndent),
  313. '' !== $code ? "[\n".$code.$subIndent.']' : '[]',
  314. self::export($value->value, $subIndent),
  315. self::export($value->wakeups, $subIndent),
  316. ];
  317. return '\\'.\get_class($value)."::hydrate(\n".$subIndent.implode(",\n".$subIndent, $code)."\n".$indent.')';
  318. }
  319. /**
  320. * @param \ArrayIterator|\ArrayObject $value
  321. * @param \ArrayIterator|\ArrayObject $proto
  322. */
  323. private static function getArrayObjectProperties($value, array &$arrayValue, $proto): array
  324. {
  325. $reflector = $value instanceof \ArrayIterator ? 'ArrayIterator' : 'ArrayObject';
  326. $reflector = Registry::$reflectors[$reflector] ?? Registry::getClassReflector($reflector);
  327. $properties = [
  328. $arrayValue,
  329. $reflector->getMethod('getFlags')->invoke($value),
  330. $value instanceof \ArrayObject ? $reflector->getMethod('getIteratorClass')->invoke($value) : 'ArrayIterator',
  331. ];
  332. $reflector = $reflector->getMethod('setFlags');
  333. $reflector->invoke($proto, \ArrayObject::STD_PROP_LIST);
  334. if ($properties[1] & \ArrayObject::STD_PROP_LIST) {
  335. $reflector->invoke($value, 0);
  336. $properties[0] = (array) $value;
  337. } else {
  338. $reflector->invoke($value, \ArrayObject::STD_PROP_LIST);
  339. $arrayValue = (array) $value;
  340. }
  341. $reflector->invoke($value, $properties[1]);
  342. if ([[], 0, 'ArrayIterator'] === $properties) {
  343. $properties = [];
  344. } else {
  345. if ('ArrayIterator' === $properties[2]) {
  346. unset($properties[2]);
  347. }
  348. $properties = [$reflector->class => ["\0" => $properties]];
  349. }
  350. return $properties;
  351. }
  352. }