3v4l.org

run code in 300+ PHP versions simultaneously
<?php class Arr { public static function collapse($array, $prefix = '') { $output = []; foreach($array as $key => $value) { if (Assert::that($value)->array()->result()) { static::merge($output, static::collapse($value, $prefix . $key . '.')); } else { } } return $output; } public static function merge(...$arrays) { Assert::that($arrays)->items('array')->error(); $output = []; foreach($arrays as $array) { $output = array_merge($output, $array); } return $output; } public static function join($glue = '', $array = []) { return implode($glue, $array); } } class Funct { public static function getCaller($offset = 0, $full = false) { return static::nameFromBacktrace(debug_backtrace()[2 + $offset], $full); } public static function nameFromBacktrace($backtrace, $full = false) { if($full) { if(!array_key_exists('type', $backtrace)) return $backtrace['function']; if($backtrace['type'] === '::') { return $backtrace['class'] . '::' . $backtrace['function']; } elseif($backtrace['type'] === '->') { return [$backtrace['class'], $backtrace['function']]; } } return $backtrace['function']; } } class Assert { protected $variable; protected $invalidated = false; protected $invalidatedBy = []; protected function __construct($variable) { $this->variable = $variable; } public static function that($variable) { return new static($variable); } public function string() { return $this->check('is_string'); } public function array() { return $this->check('is_array'); } public function object() { return $this->check('is_object'); } public function boolean() { return $this->check('is_bool'); } public function callable() { return $this->check('is_callable'); } public function integer() { return $this->check('is_int'); } public function null() { return $this->check('is_null'); } public function float() { return $this->check('is_float'); } public function double() { return $this->check('is_double'); } public function resource() { return $this->check('is_resource'); } public function type($type) { return $this->check('is_a', $type); } public function items($type) { return $this->checkAll('is_a', $type); } protected function check(callable $function, ...$parameters) { array_unshift($parameters, $this->variable); if(!call_user_func_array($function, $parameters)) $this->invalidate(); return $this; } protected function checkAll(callable $function, ...$parameters) { foreach($this->variable as $value) { array_unshift($parameters, $value); if(!call_user_func_array($function, $parameters)) $this->invalidate(); break; } return $this; } public function result() { return !$this->invalidated; } public function error() { if(!$this->result()) throw new \AssertionError("The assertion failed at: " . Arr::join(', ', $this->invalidatedBy)); } protected function invalidate($by = null) { $this->invalidated = true; $this->invalidatedBy[] = Funct::getCaller(1); } }
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/eY20g
function name:  (null)
number of ops:  1
compiled vars:  none
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
  130     0  E > > RETURN                                                   1

Class Arr:
Function collapse:
Finding entry points
Branch analysis from position: 0
2 jumps found. (Code = 77) Position 1 = 4, Position 2 = 26
Branch analysis from position: 4
2 jumps found. (Code = 78) Position 1 = 5, Position 2 = 26
Branch analysis from position: 5
2 jumps found. (Code = 43) Position 1 = 14, Position 2 = 25
Branch analysis from position: 14
1 jumps found. (Code = 42) Position 1 = 25
Branch analysis from position: 25
1 jumps found. (Code = 42) Position 1 = 4
Branch analysis from position: 4
Branch analysis from position: 25
Branch analysis from position: 26
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 26
filename:       /in/eY20g
function name:  collapse
number of ops:  29
compiled vars:  !0 = $array, !1 = $prefix, !2 = $output, !3 = $value, !4 = $key
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
    5     0  E >   RECV                                             !0      
          1        RECV_INIT                                        !1      ''
    7     2        ASSIGN                                                   !2, <array>
    9     3      > FE_RESET_R                                       $6      !0, ->26
          4    > > FE_FETCH_R                                       ~7      $6, !3, ->26
          5    >   ASSIGN                                                   !4, ~7
   11     6        INIT_STATIC_METHOD_CALL                                  'Assert', 'that'
          7        SEND_VAR_EX                                              !3
          8        DO_FCALL                                      0  $9      
          9        INIT_METHOD_CALL                                         $9, 'array'
         10        DO_FCALL                                      0  $10     
         11        INIT_METHOD_CALL                                         $10, 'result'
         12        DO_FCALL                                      0  $11     
         13      > JMPZ                                                     $11, ->25
   12    14    >   INIT_STATIC_METHOD_CALL                                  'merge'
         15        SEND_VAR_EX                                              !2
         16        INIT_STATIC_METHOD_CALL                                  'collapse'
         17        SEND_VAR_EX                                              !3
         18        CONCAT                                           ~12     !1, !4
         19        CONCAT                                           ~13     ~12, '.'
         20        SEND_VAL_EX                                              ~13
         21        DO_FCALL                                      0  $14     
         22        SEND_VAR_NO_REF_EX                                       $14
         23        DO_FCALL                                      0          
         24      > JMP                                                      ->25
    9    25    > > JMP                                                      ->4
         26    >   FE_FREE                                                  $6
   18    27      > RETURN                                                   !2
   19    28*     > RETURN                                                   null

End of function collapse

Function merge:
Finding entry points
Branch analysis from position: 0
2 jumps found. (Code = 77) Position 1 = 11, Position 2 = 18
Branch analysis from position: 11
2 jumps found. (Code = 78) Position 1 = 12, Position 2 = 18
Branch analysis from position: 12
1 jumps found. (Code = 42) Position 1 = 11
Branch analysis from position: 11
Branch analysis from position: 18
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 18
filename:       /in/eY20g
function name:  merge
number of ops:  21
compiled vars:  !0 = $arrays, !1 = $output, !2 = $array
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   21     0  E >   RECV_VARIADIC                                    !0      
   23     1        INIT_STATIC_METHOD_CALL                                  'Assert', 'that'
          2        SEND_VAR_EX                                              !0
          3        DO_FCALL                                      0  $3      
          4        INIT_METHOD_CALL                                         $3, 'items'
          5        SEND_VAL_EX                                              'array'
          6        DO_FCALL                                      0  $4      
          7        INIT_METHOD_CALL                                         $4, 'error'
          8        DO_FCALL                                      0          
   25     9        ASSIGN                                                   !1, <array>
   27    10      > FE_RESET_R                                       $7      !0, ->18
         11    > > FE_FETCH_R                                               $7, !2, ->18
   28    12    >   INIT_FCALL                                               'array_merge'
         13        SEND_VAR                                                 !1
         14        SEND_VAR                                                 !2
         15        DO_ICALL                                         $8      
         16        ASSIGN                                                   !1, $8
   27    17      > JMP                                                      ->11
         18    >   FE_FREE                                                  $7
   31    19      > RETURN                                                   !1
   32    20*     > RETURN                                                   null

End of function merge

Function join:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/eY20g
function name:  join
number of ops:  8
compiled vars:  !0 = $glue, !1 = $array
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   34     0  E >   RECV_INIT                                        !0      ''
          1        RECV_INIT                                        !1      <array>
   36     2        INIT_FCALL                                               'implode'
          3        SEND_VAR                                                 !0
          4        SEND_VAR                                                 !1
          5        DO_ICALL                                         $2      
          6      > RETURN                                                   $2
   37     7*     > RETURN                                                   null

End of function join

End of class Arr.

Class Funct:
Function getcaller:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/eY20g
function name:  getCaller
number of ops:  14
compiled vars:  !0 = $offset, !1 = $full
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   42     0  E >   RECV_INIT                                        !0      0
          1        RECV_INIT                                        !1      <false>
   44     2        INIT_STATIC_METHOD_CALL                                  'nameFromBacktrace'
          3        CHECK_FUNC_ARG                                           
          4        INIT_FCALL                                               'debug_backtrace'
          5        DO_ICALL                                         $2      
          6        SEPARATE                                         $2      $2
          7        ADD                                              ~3      2, !0
          8        FETCH_DIM_FUNC_ARG                               $4      $2, ~3
          9        SEND_FUNC_ARG                                            $4
         10        SEND_VAR_EX                                              !1
         11        DO_FCALL                                      0  $5      
         12      > RETURN                                                   $5
   45    13*     > RETURN                                                   null

End of function getcaller

Function namefrombacktrace:
Finding entry points
Branch analysis from position: 0
2 jumps found. (Code = 43) Position 1 = 3, Position 2 = 25
Branch analysis from position: 3
2 jumps found. (Code = 43) Position 1 = 6, Position 2 = 8
Branch analysis from position: 6
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 8
2 jumps found. (Code = 43) Position 1 = 11, Position 2 = 17
Branch analysis from position: 11
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 17
2 jumps found. (Code = 43) Position 1 = 20, Position 2 = 25
Branch analysis from position: 20
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 25
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 25
filename:       /in/eY20g
function name:  nameFromBacktrace
number of ops:  28
compiled vars:  !0 = $backtrace, !1 = $full
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   47     0  E >   RECV                                             !0      
          1        RECV_INIT                                        !1      <false>
   49     2      > JMPZ                                                     !1, ->25
   50     3    >   ARRAY_KEY_EXISTS                                 ~2      'type', !0
          4        BOOL_NOT                                         ~3      ~2
          5      > JMPZ                                                     ~3, ->8
   51     6    >   FETCH_DIM_R                                      ~4      !0, 'function'
          7      > RETURN                                                   ~4
   53     8    >   FETCH_DIM_R                                      ~5      !0, 'type'
          9        IS_IDENTICAL                                             ~5, '%3A%3A'
         10      > JMPZ                                                     ~6, ->17
   54    11    >   FETCH_DIM_R                                      ~7      !0, 'class'
         12        CONCAT                                           ~8      ~7, '%3A%3A'
         13        FETCH_DIM_R                                      ~9      !0, 'function'
         14        CONCAT                                           ~10     ~8, ~9
         15      > RETURN                                                   ~10
         16*       JMP                                                      ->25
   55    17    >   FETCH_DIM_R                                      ~11     !0, 'type'
         18        IS_IDENTICAL                                             ~11, '-%3E'
         19      > JMPZ                                                     ~12, ->25
   56    20    >   FETCH_DIM_R                                      ~13     !0, 'class'
         21        INIT_ARRAY                                       ~14     ~13
         22        FETCH_DIM_R                                      ~15     !0, 'function'
         23        ADD_ARRAY_ELEMENT                                ~14     ~15
         24      > RETURN                                                   ~14
   60    25    >   FETCH_DIM_R                                      ~16     !0, 'function'
         26      > RETURN                                                   ~16
   61    27*     > RETURN                                                   null

End of function namefrombacktrace

End of class Funct.

Class Assert:
Function __construct:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/eY20g
function name:  __construct
number of ops:  4
compiled vars:  !0 = $variable
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   70     0  E >   RECV                                             !0      
   72     1        ASSIGN_OBJ                                               'variable'
          2        OP_DATA                                                  !0
   73     3      > RETURN                                                   null

End of function __construct

Function that:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/eY20g
function name:  that
number of ops:  6
compiled vars:  !0 = $variable
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   75     0  E >   RECV                                             !0      
          1        NEW                          static              $1      
          2        SEND_VAR_EX                                              !0
          3        DO_FCALL                                      0          
          4      > RETURN                                                   $1
          5*     > RETURN                                                   null

End of function that

Function string:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/eY20g
function name:  string
number of ops:  5
compiled vars:  none
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   77     0  E >   INIT_METHOD_CALL                                         'check'
          1        SEND_VAL_EX                                              'is_string'
          2        DO_FCALL                                      0  $0      
          3      > RETURN                                                   $0
          4*     > RETURN                                                   null

End of function string

Function array:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/eY20g
function name:  array
number of ops:  5
compiled vars:  none
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   78     0  E >   INIT_METHOD_CALL                                         'check'
          1        SEND_VAL_EX                                              'is_array'
          2        DO_FCALL                                      0  $0      
          3      > RETURN                                                   $0
          4*     > RETURN                                                   null

End of function array

Function object:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/eY20g
function name:  object
number of ops:  5
compiled vars:  none
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   79     0  E >   INIT_METHOD_CALL                                         'check'
          1        SEND_VAL_EX                                              'is_object'
          2        DO_FCALL                                      0  $0      
          3      > RETURN                                                   $0
          4*     > RETURN                                                   null

End of function object

Function boolean:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/eY20g
function name:  boolean
number of ops:  5
compiled vars:  none
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   80     0  E >   INIT_METHOD_CALL                                         'check'
          1        SEND_VAL_EX                                              'is_bool'
          2        DO_FCALL                                      0  $0      
          3      > RETURN                                                   $0
          4*     > RETURN                                                   null

End of function boolean

Function callable:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/eY20g
function name:  callable
number of ops:  5
compiled vars:  none
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   81     0  E >   INIT_METHOD_CALL                                         'check'
          1        SEND_VAL_EX                                              'is_callable'
          2        DO_FCALL                                      0  $0      
          3      > RETURN                                                   $0
          4*     > RETURN                                                   null

End of function callable

Function integer:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/eY20g
function name:  integer
number of ops:  5
compiled vars:  none
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   82     0  E >   INIT_METHOD_CALL                                         'check'
          1        SEND_VAL_EX                                              'is_int'
          2        DO_FCALL                                      0  $0      
          3      > RETURN                                                   $0
          4*     > RETURN                                                   null

End of function integer

Function null:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/eY20g
function name:  null
number of ops:  5
compiled vars:  none
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   83     0  E >   INIT_METHOD_CALL                                         'check'
          1        SEND_VAL_EX                                              'is_null'
          2        DO_FCALL                                      0  $0      
          3      > RETURN                                                   $0
          4*     > RETURN                                                   null

End of function null

Function float:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/eY20g
function name:  float
number of ops:  5
compiled vars:  none
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   84     0  E >   INIT_METHOD_CALL                                         'check'
          1        SEND_VAL_EX                                              'is_float'
          2        DO_FCALL                                      0  $0      
          3      > RETURN                                                   $0
          4*     > RETURN                                                   null

End of function float

Function double:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/eY20g
function name:  double
number of ops:  5
compiled vars:  none
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   85     0  E >   INIT_METHOD_CALL                                         'check'
          1        SEND_VAL_EX                                              'is_double'
          2        DO_FCALL                                      0  $0      
          3      > RETURN                                                   $0
          4*     > RETURN                                                   null

End of function double

Function resource:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/eY20g
function name:  resource
number of ops:  5
compiled vars:  none
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   86     0  E >   INIT_METHOD_CALL                                         'check'
          1        SEND_VAL_EX                                              'is_resource'
          2        DO_FCALL                                      0  $0      
          3      > RETURN                                                   $0
          4*     > RETURN                                                   null

End of function resource

Function type:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/eY20g
function name:  type
number of ops:  7
compiled vars:  !0 = $type
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   87     0  E >   RECV                                             !0      
          1        INIT_METHOD_CALL                                         'check'
          2        SEND_VAL_EX                                              'is_a'
          3        SEND_VAR_EX                                              !0
          4        DO_FCALL                                      0  $1      
          5      > RETURN                                                   $1
          6*     > RETURN                                                   null

End of function type

Function items:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/eY20g
function name:  items
number of ops:  7
compiled vars:  !0 = $type
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   89     0  E >   RECV                                             !0      
          1        INIT_METHOD_CALL                                         'checkAll'
          2        SEND_VAL_EX                                              'is_a'
          3        SEND_VAR_EX                                              !0
          4        DO_FCALL                                      0  $1      
          5      > RETURN                                                   $1
          6*     > RETURN                                                   null

End of function items

Function check:
Finding entry points
Branch analysis from position: 0
2 jumps found. (Code = 43) Position 1 = 13, Position 2 = 15
Branch analysis from position: 13
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 15
filename:       /in/eY20g
function name:  check
number of ops:  18
compiled vars:  !0 = $function, !1 = $parameters
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   91     0  E >   RECV                                             !0      
          1        RECV_VARIADIC                                    !1      
   93     2        INIT_FCALL                                               'array_unshift'
          3        SEND_REF                                                 !1
          4        FETCH_OBJ_R                                      ~2      'variable'
          5        SEND_VAL                                                 ~2
          6        DO_ICALL                                                 
   95     7        INIT_USER_CALL                                0          'call_user_func_array', !0
          8        SEND_ARRAY                                               !1
          9        CHECK_UNDEF_ARGS                                         
         10        DO_FCALL                                      0  $4      
         11        BOOL_NOT                                         ~5      $4
         12      > JMPZ                                                     ~5, ->15
   96    13    >   INIT_METHOD_CALL                                         'invalidate'
         14        DO_FCALL                                      0          
   98    15    >   FETCH_THIS                                       ~7      
         16      > RETURN                                                   ~7
   99    17*     > RETURN                                                   null

End of function check

Function checkall:
Finding entry points
Branch analysis from position: 0
2 jumps found. (Code = 77) Position 1 = 4, Position 2 = 19
Branch analysis from position: 4
2 jumps found. (Code = 78) Position 1 = 5, Position 2 = 19
Branch analysis from position: 5
2 jumps found. (Code = 43) Position 1 = 15, Position 2 = 17
Branch analysis from position: 15
1 jumps found. (Code = 42) Position 1 = 19
Branch analysis from position: 19
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 17
Branch analysis from position: 19
Branch analysis from position: 19
filename:       /in/eY20g
function name:  checkAll
number of ops:  23
compiled vars:  !0 = $function, !1 = $parameters, !2 = $value
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
  101     0  E >   RECV                                             !0      
          1        RECV_VARIADIC                                    !1      
  103     2        FETCH_OBJ_R                                      ~3      'variable'
          3      > FE_RESET_R                                       $4      ~3, ->19
          4    > > FE_FETCH_R                                               $4, !2, ->19
  104     5    >   INIT_FCALL                                               'array_unshift'
          6        SEND_REF                                                 !1
          7        SEND_VAR                                                 !2
          8        DO_ICALL                                                 
  106     9        INIT_USER_CALL                                0          'call_user_func_array', !0
         10        SEND_ARRAY                                               !1
         11        CHECK_UNDEF_ARGS                                         
         12        DO_FCALL                                      0  $6      
         13        BOOL_NOT                                         ~7      $6
         14      > JMPZ                                                     ~7, ->17
  107    15    >   INIT_METHOD_CALL                                         'invalidate'
         16        DO_FCALL                                      0          
  108    17    > > JMP                                                      ->19
  103    18*       JMP                                                      ->4
         19    >   FE_FREE                                                  $4
  111    20        FETCH_THIS                                       ~9      
         21      > RETURN                                                   ~9
  112    22*     > RETURN                                                   null

End of function checkall

Function result:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/eY20g
function name:  result
number of ops:  4
compiled vars:  none
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
  116     0  E >   FETCH_OBJ_R                                      ~0      'invalidated'
          1        BOOL_NOT                                         ~1      ~0
          2      > RETURN                                                   ~1
  117     3*     > RETURN                                                   null

End of function result

Function error:
Finding entry points
Branch analysis from position: 0
2 jumps found. (Code = 43) Position 1 = 4, Position 2 = 14
Branch analysis from position: 4
1 jumps found. (Code = 108) Position 1 = -2
Branch analysis from position: 14
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/eY20g
function name:  error
number of ops:  15
compiled vars:  none
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
  121     0  E >   INIT_METHOD_CALL                                         'result'
          1        DO_FCALL                                      0  $0      
          2        BOOL_NOT                                         ~1      $0
          3      > JMPZ                                                     ~1, ->14
  122     4    >   NEW                                              $2      'AssertionError'
          5        INIT_STATIC_METHOD_CALL                                  'Arr', 'join'
          6        SEND_VAL                                                 '%2C+'
          7        FETCH_OBJ_R                                      ~3      'invalidatedBy'
          8        SEND_VAL                                                 ~3
          9        DO_FCALL                                      0  $4      
         10        CONCAT                                           ~5      'The+assertion+failed+at%3A+', $4
         11        SEND_VAL_EX                                              ~5
         12        DO_FCALL                                      0          
         13      > THROW                                         0          $2
  123    14    > > RETURN                                                   null

End of function error

Function invalidate:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/eY20g
function name:  invalidate
number of ops:  10
compiled vars:  !0 = $by
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
  125     0  E >   RECV_INIT                                        !0      null
  127     1        ASSIGN_OBJ                                               'invalidated'
          2        OP_DATA                                                  <true>
  128     3        INIT_STATIC_METHOD_CALL                                  'Funct', 'getCaller'
          4        SEND_VAL                                                 1
          5        DO_FCALL                                      0  $4      
          6        FETCH_OBJ_W                                      $2      'invalidatedBy'
          7        ASSIGN_DIM                                               $2
          8        OP_DATA                                                  $4
  129     9      > RETURN                                                   null

End of function invalidate

End of class Assert.

Generated using Vulcan Logic Dumper, using php 8.0.0


preferences:
158.7 ms | 1424 KiB | 21 Q