vendor/symfony/var-dumper/Cloner/VarCloner.php line 25

Open in your IDE?
  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\VarDumper\Cloner;
  11. /**
  12.  * @author Nicolas Grekas <p@tchwork.com>
  13.  */
  14. class VarCloner extends AbstractCloner
  15. {
  16.     private static $gid;
  17.     private static $arrayCache = [];
  18.     /**
  19.      * {@inheritdoc}
  20.      */
  21.     protected function doClone($var)
  22.     {
  23.         $len 1;                       // Length of $queue
  24.         $pos 0;                       // Number of cloned items past the minimum depth
  25.         $refsCounter 0;               // Hard references counter
  26.         $queue = [[$var]];    // This breadth-first queue is the return value
  27.         $hardRefs = [];            // Map of original zval ids to stub objects
  28.         $objRefs = [];             // Map of original object handles to their stub object counterpart
  29.         $objects = [];             // Keep a ref to objects to ensure their handle cannot be reused while cloning
  30.         $resRefs = [];             // Map of original resource handles to their stub object counterpart
  31.         $values = [];              // Map of stub objects' ids to original values
  32.         $maxItems $this->maxItems;
  33.         $maxString $this->maxString;
  34.         $minDepth $this->minDepth;
  35.         $currentDepth 0;              // Current tree depth
  36.         $currentDepthFinalIndex 0;    // Final $queue index for current tree depth
  37.         $minimumDepthReached === $minDepth// Becomes true when minimum tree depth has been reached
  38.         $cookie = (object) [];          // Unique object used to detect hard references
  39.         $a null;                      // Array cast for nested structures
  40.         $stub null;                   // Stub capturing the main properties of an original item value
  41.                                         // or null if the original value is used directly
  42.         if (!$gid self::$gid) {
  43.             $gid self::$gid md5(random_bytes(6)); // Unique string used to detect the special $GLOBALS variable
  44.         }
  45.         $arrayStub = new Stub();
  46.         $arrayStub->type Stub::TYPE_ARRAY;
  47.         $fromObjCast false;
  48.         for ($i 0$i $len; ++$i) {
  49.             // Detect when we move on to the next tree depth
  50.             if ($i $currentDepthFinalIndex) {
  51.                 ++$currentDepth;
  52.                 $currentDepthFinalIndex $len 1;
  53.                 if ($currentDepth >= $minDepth) {
  54.                     $minimumDepthReached true;
  55.                 }
  56.             }
  57.             $refs $vals $queue[$i];
  58.             foreach ($vals as $k => $v) {
  59.                 // $v is the original value or a stub object in case of hard references
  60.                 if (\PHP_VERSION_ID >= 70400) {
  61.                     $zvalIsRef null !== \ReflectionReference::fromArrayElement($vals$k);
  62.                 } else {
  63.                     $refs[$k] = $cookie;
  64.                     $zvalIsRef $vals[$k] === $cookie;
  65.                 }
  66.                 if ($zvalIsRef) {
  67.                     $vals[$k] = &$stub;         // Break hard references to make $queue completely
  68.                     unset($stub);               // independent from the original structure
  69.                     if ($v instanceof Stub && isset($hardRefs[spl_object_id($v)])) {
  70.                         $vals[$k] = $refs[$k] = $v;
  71.                         if ($v->value instanceof Stub && (Stub::TYPE_OBJECT === $v->value->type || Stub::TYPE_RESOURCE === $v->value->type)) {
  72.                             ++$v->value->refCount;
  73.                         }
  74.                         ++$v->refCount;
  75.                         continue;
  76.                     }
  77.                     $refs[$k] = $vals[$k] = new Stub();
  78.                     $refs[$k]->value $v;
  79.                     $h spl_object_id($refs[$k]);
  80.                     $hardRefs[$h] = &$refs[$k];
  81.                     $values[$h] = $v;
  82.                     $vals[$k]->handle = ++$refsCounter;
  83.                 }
  84.                 // Create $stub when the original value $v can not be used directly
  85.                 // If $v is a nested structure, put that structure in array $a
  86.                 switch (true) {
  87.                     case null === $v:
  88.                     case \is_bool($v):
  89.                     case \is_int($v):
  90.                     case \is_float($v):
  91.                         continue 2;
  92.                     case \is_string($v):
  93.                         if ('' === $v) {
  94.                             continue 2;
  95.                         }
  96.                         if (!preg_match('//u'$v)) {
  97.                             $stub = new Stub();
  98.                             $stub->type Stub::TYPE_STRING;
  99.                             $stub->class Stub::STRING_BINARY;
  100.                             if (<= $maxString && $cut \strlen($v) - $maxString) {
  101.                                 $stub->cut $cut;
  102.                                 $stub->value substr($v0, -$cut);
  103.                             } else {
  104.                                 $stub->value $v;
  105.                             }
  106.                         } elseif (<= $maxString && isset($v[+ ($maxString >> 2)]) && $cut mb_strlen($v'UTF-8') - $maxString) {
  107.                             $stub = new Stub();
  108.                             $stub->type Stub::TYPE_STRING;
  109.                             $stub->class Stub::STRING_UTF8;
  110.                             $stub->cut $cut;
  111.                             $stub->value mb_substr($v0$maxString'UTF-8');
  112.                         } else {
  113.                             continue 2;
  114.                         }
  115.                         $a null;
  116.                         break;
  117.                     case \is_array($v):
  118.                         if (!$v) {
  119.                             continue 2;
  120.                         }
  121.                         $stub $arrayStub;
  122.                         $stub->class Stub::ARRAY_INDEXED;
  123.                         $j = -1;
  124.                         foreach ($v as $gk => $gv) {
  125.                             if ($gk !== ++$j) {
  126.                                 $stub->class Stub::ARRAY_ASSOC;
  127.                                 break;
  128.                             }
  129.                         }
  130.                         $a $v;
  131.                         if (Stub::ARRAY_ASSOC === $stub->class) {
  132.                             // Copies of $GLOBALS have very strange behavior,
  133.                             // let's detect them with some black magic
  134.                             if (\PHP_VERSION_ID 80100 && ($a[$gid] = true) && isset($v[$gid])) {
  135.                                 unset($v[$gid]);
  136.                                 $a = [];
  137.                                 foreach ($v as $gk => &$gv) {
  138.                                     if ($v === $gv) {
  139.                                         unset($v);
  140.                                         $v = new Stub();
  141.                                         $v->value = [$v->cut \count($gv), Stub::TYPE_ARRAY => 0];
  142.                                         $v->handle = -1;
  143.                                         $gv = &$hardRefs[spl_object_id($v)];
  144.                                         $gv $v;
  145.                                     }
  146.                                     $a[$gk] = &$gv;
  147.                                 }
  148.                                 unset($gv);
  149.                             } else {
  150.                                 $a $v;
  151.                             }
  152.                         }
  153.                         break;
  154.                     case \is_object($v):
  155.                         if (empty($objRefs[$h spl_object_id($v)])) {
  156.                             $stub = new Stub();
  157.                             $stub->type Stub::TYPE_OBJECT;
  158.                             $stub->class \get_class($v);
  159.                             $stub->value $v;
  160.                             $stub->handle $h;
  161.                             $a $this->castObject($stub$i);
  162.                             if ($v !== $stub->value) {
  163.                                 if (Stub::TYPE_OBJECT !== $stub->type || null === $stub->value) {
  164.                                     break;
  165.                                 }
  166.                                 $stub->handle $h spl_object_id($stub->value);
  167.                             }
  168.                             $stub->value null;
  169.                             if (<= $maxItems && $maxItems <= $pos && $minimumDepthReached) {
  170.                                 $stub->cut \count($a);
  171.                                 $a null;
  172.                             }
  173.                         }
  174.                         if (empty($objRefs[$h])) {
  175.                             $objRefs[$h] = $stub;
  176.                             $objects[] = $v;
  177.                         } else {
  178.                             $stub $objRefs[$h];
  179.                             ++$stub->refCount;
  180.                             $a null;
  181.                         }
  182.                         break;
  183.                     default: // resource
  184.                         if (empty($resRefs[$h = (int) $v])) {
  185.                             $stub = new Stub();
  186.                             $stub->type Stub::TYPE_RESOURCE;
  187.                             if ('Unknown' === $stub->class = @get_resource_type($v)) {
  188.                                 $stub->class 'Closed';
  189.                             }
  190.                             $stub->value $v;
  191.                             $stub->handle $h;
  192.                             $a $this->castResource($stub$i);
  193.                             $stub->value null;
  194.                             if (<= $maxItems && $maxItems <= $pos && $minimumDepthReached) {
  195.                                 $stub->cut \count($a);
  196.                                 $a null;
  197.                             }
  198.                         }
  199.                         if (empty($resRefs[$h])) {
  200.                             $resRefs[$h] = $stub;
  201.                         } else {
  202.                             $stub $resRefs[$h];
  203.                             ++$stub->refCount;
  204.                             $a null;
  205.                         }
  206.                         break;
  207.                 }
  208.                 if ($a) {
  209.                     if (!$minimumDepthReached || $maxItems) {
  210.                         $queue[$len] = $a;
  211.                         $stub->position $len++;
  212.                     } elseif ($pos $maxItems) {
  213.                         if ($maxItems $pos += \count($a)) {
  214.                             $a \array_slice($a0$maxItems $postrue);
  215.                             if ($stub->cut >= 0) {
  216.                                 $stub->cut += $pos $maxItems;
  217.                             }
  218.                         }
  219.                         $queue[$len] = $a;
  220.                         $stub->position $len++;
  221.                     } elseif ($stub->cut >= 0) {
  222.                         $stub->cut += \count($a);
  223.                         $stub->position 0;
  224.                     }
  225.                 }
  226.                 if ($arrayStub === $stub) {
  227.                     if ($arrayStub->cut) {
  228.                         $stub = [$arrayStub->cut$arrayStub->class => $arrayStub->position];
  229.                         $arrayStub->cut 0;
  230.                     } elseif (isset(self::$arrayCache[$arrayStub->class][$arrayStub->position])) {
  231.                         $stub self::$arrayCache[$arrayStub->class][$arrayStub->position];
  232.                     } else {
  233.                         self::$arrayCache[$arrayStub->class][$arrayStub->position] = $stub = [$arrayStub->class => $arrayStub->position];
  234.                     }
  235.                 }
  236.                 if ($zvalIsRef) {
  237.                     $refs[$k]->value $stub;
  238.                 } else {
  239.                     $vals[$k] = $stub;
  240.                 }
  241.             }
  242.             if ($fromObjCast) {
  243.                 $fromObjCast false;
  244.                 $refs $vals;
  245.                 $vals = [];
  246.                 $j = -1;
  247.                 foreach ($queue[$i] as $k => $v) {
  248.                     foreach ([$k => true] as $gk => $gv) {
  249.                     }
  250.                     if ($gk !== $k) {
  251.                         $vals = (object) $vals;
  252.                         $vals->{$k} = $refs[++$j];
  253.                         $vals = (array) $vals;
  254.                     } else {
  255.                         $vals[$k] = $refs[++$j];
  256.                     }
  257.                 }
  258.             }
  259.             $queue[$i] = $vals;
  260.         }
  261.         foreach ($values as $h => $v) {
  262.             $hardRefs[$h] = $v;
  263.         }
  264.         return $queue;
  265.     }
  266. }