3v4l.org

run code in 500+ PHP versions simultaneously
<?php enum Foo: int { case Foo = 0; } enum Bar: string { case Bar = 'baz'; } enum Baz { case Baz; } function get_backing_type(string $enum_class): ?string { return (new ReflectionEnum($enum_class))->getBackingType()?->getName(); } function is_int_enum(string $enum_class): bool { return get_backing_type($enum_class) === 'int'; } function is_string_enum(string $enum_class): bool { return get_backing_type($enum_class) === 'string'; } var_dump(get_backing_type(Foo::class)); var_dump(get_backing_type(Bar::class)); var_dump(get_backing_type(Baz::class)); var_dump(is_int_enum(Foo::class)); var_dump(is_string_enum(Bar::class));
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/YN3mA
function name:  (null)
number of ops:  34
compiled vars:  none
line      #* E I O op                               fetch          ext  return  operands
-----------------------------------------------------------------------------------------
    3     0  E >   DECLARE_CLASS                                                'foo'
    7     1        DECLARE_CLASS                                                'bar'
   11     2        DECLARE_CLASS                                                'baz'
   27     3        INIT_FCALL                                                   'var_dump'
          4        INIT_FCALL                                                   'get_backing_type'
          5        SEND_VAL                                                     'Foo'
          6        DO_FCALL                                          0  $0      
          7        SEND_VAR                                                     $0
          8        DO_ICALL                                                     
   28     9        INIT_FCALL                                                   'var_dump'
         10        INIT_FCALL                                                   'get_backing_type'
         11        SEND_VAL                                                     'Bar'
         12        DO_FCALL                                          0  $2      
         13        SEND_VAR                                                     $2
         14        DO_ICALL                                                     
   29    15        INIT_FCALL                                                   'var_dump'
         16        INIT_FCALL                                                   'get_backing_type'
         17        SEND_VAL                                                     'Baz'
         18        DO_FCALL                                          0  $4      
         19        SEND_VAR                                                     $4
         20        DO_ICALL                                                     
   31    21        INIT_FCALL                                                   'var_dump'
         22        INIT_FCALL                                                   'is_int_enum'
         23        SEND_VAL                                                     'Foo'
         24        DO_FCALL                                          0  $6      
         25        SEND_VAR                                                     $6
         26        DO_ICALL                                                     
   32    27        INIT_FCALL                                                   'var_dump'
         28        INIT_FCALL                                                   'is_string_enum'
         29        SEND_VAL                                                     'Bar'
         30        DO_FCALL                                          0  $8      
         31        SEND_VAR                                                     $8
         32        DO_ICALL                                                     
         33      > RETURN                                                       1

Function get_backing_type:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/YN3mA
function name:  get_backing_type
number of ops:  13
compiled vars:  !0 = $enum_class
line      #* E I O op                               fetch          ext  return  operands
-----------------------------------------------------------------------------------------
   15     0  E >   RECV                                                 !0      
   16     1        NEW                                                  $1      'ReflectionEnum'
          2        SEND_VAR_EX                                                  !0
          3        DO_FCALL                                          0          
          4        INIT_METHOD_CALL                                             $1, 'getBackingType'
          5        DO_FCALL                                          0  $3      
          6        JMP_NULL                                             $4      $3
          7        INIT_METHOD_CALL                                             $3, 'getName'
          8        DO_FCALL                                          0  $4      
          9        VERIFY_RETURN_TYPE                                           $4
         10      > RETURN                                                       $4
   17    11*       VERIFY_RETURN_TYPE                                           
         12*     > RETURN                                                       null

End of function get_backing_type

Function is_int_enum:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/YN3mA
function name:  is_int_enum
number of ops:  9
compiled vars:  !0 = $enum_class
line      #* E I O op                               fetch          ext  return  operands
-----------------------------------------------------------------------------------------
   19     0  E >   RECV                                                 !0      
   20     1        INIT_FCALL                                                   'get_backing_type'
          2        SEND_VAR                                                     !0
          3        DO_FCALL                                          0  $1      
          4        IS_IDENTICAL                                         ~2      $1, 'int'
          5        VERIFY_RETURN_TYPE                                           ~2
          6      > RETURN                                                       ~2
   21     7*       VERIFY_RETURN_TYPE                                           
          8*     > RETURN                                                       null

End of function is_int_enum

Function is_string_enum:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/YN3mA
function name:  is_string_enum
number of ops:  9
compiled vars:  !0 = $enum_class
line      #* E I O op                               fetch          ext  return  operands
-----------------------------------------------------------------------------------------
   23     0  E >   RECV                                                 !0      
   24     1        INIT_FCALL                                                   'get_backing_type'
          2        SEND_VAR                                                     !0
          3        DO_FCALL                                          0  $1      
          4        IS_IDENTICAL                                         ~2      $1, 'string'
          5        VERIFY_RETURN_TYPE                                           ~2
          6      > RETURN                                                       ~2
   25     7*       VERIFY_RETURN_TYPE                                           
          8*     > RETURN                                                       null

End of function is_string_enum

Class Foo: [no user functions]
Class Bar: [no user functions]
Class Baz: [no user functions]

Generated using Vulcan Logic Dumper, using php 8.5.0


preferences:
177.78 ms | 1325 KiB | 21 Q