3v4l.org

run code in 300+ PHP versions simultaneously
<?php class IDN { // adapt bias for punycode algorithm private static function punyAdapt( $delta, $numpoints, $firsttime ) { $delta = $firsttime ? $delta / 700 : $delta / 2; $delta += $delta / $numpoints; for ($k = 0; $delta > 455; $k += 36) $delta = intval($delta / 35); return $k + (36 * $delta) / ($delta + 38); } // make utf8 string from unicode codepoint number private static function utf8($cp) { if ($cp < 128) return chr($cp); if ($cp < 2048) return chr(192+($cp >> 6)).chr(128+($cp & 63)); if ($cp < 65536) return chr(224+($cp >> 12)). chr(128+(($cp >> 6) & 63)). chr(128+($cp & 63)); if ($cp < 2097152) return chr(240+($cp >> 18)). chr(128+(($cp >> 12) & 63)). chr(128+(($cp >> 6) & 63)). chr(128+($cp & 63)); // it should never get here } // main decoding function private static function decodePart($input) { if (substr($input, 0, 4) !== 'xn--') { return $input; } $input = substr($input, 4); if (false !== $nonBasicCharsStart = strrpos($input, '-')) { $output = str_split(substr($input, 0, $nonBasicCharsStart), 1); $nonBasicChars = substr($input, $nonBasicCharsStart + 1); } else { $output = []; $nonBasicChars = $input; } $n = 128; $i = 0; $bias = 72; for ($j = 0, $l = strlen($nonBasicChars); $j < $l;) { $oldi = $i; $w = 1; $k = 36; while (true) { if (!isset($nonBasicChars[$j++])) { return false; } $digit = ord($nonBasicChars[$j++]); if ($digit >= 0x61 && $digit <= 0x7A) { $digit -= 97; } else if ($digit >= 0x30 && $digit <= 0x39) { $digit -= 22; } else { return false; } $i += $digit * $w; if ($k <= $bias) { $t = 1; } else if ($k >= $bias + 26) { $t = 26; } else { $t = $k - $bias; } if ($digit < $t) { break; } $w *= (int) (36 - $t); $k += 36; } $c = count($output) + 1; $bias = IDN::punyAdapt($i - $oldi, $c, $oldi === 0); $n += (int)($i / $c); $i %= $c; array_splice($output, $i, 0, array(IDN::utf8($n))); $i++; } return implode("", $output); } public static function decodeIDN($name) { // split it, parse it and put it back together return implode( ".", array_map("IDN::decodePart",explode(".",$name)) ); } } echo IDN::decodeIDN("xn---with-SUPER-MONKEYS-pc58ag80a8qai00g7n9n");
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/ZTFW3
function name:  (null)
number of ops:  5
compiled vars:  none
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
  115     0  E >   INIT_STATIC_METHOD_CALL                                  'IDN', 'decodeIDN'
          1        SEND_VAL                                                 'xn---with-SUPER-MONKEYS-pc58ag80a8qai00g7n9n'
          2        DO_FCALL                                      0  $0      
          3        ECHO                                                     $0
          4      > RETURN                                                   1

Class IDN:
Function punyadapt:
Finding entry points
Branch analysis from position: 0
2 jumps found. (Code = 43) Position 1 = 4, Position 2 = 7
Branch analysis from position: 4
1 jumps found. (Code = 42) Position 1 = 9
Branch analysis from position: 9
1 jumps found. (Code = 42) Position 1 = 18
Branch analysis from position: 18
2 jumps found. (Code = 44) Position 1 = 20, Position 2 = 14
Branch analysis from position: 20
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 14
2 jumps found. (Code = 44) Position 1 = 20, Position 2 = 14
Branch analysis from position: 20
Branch analysis from position: 14
Branch analysis from position: 7
1 jumps found. (Code = 42) Position 1 = 18
Branch analysis from position: 18
filename:       /in/ZTFW3
function name:  punyAdapt
number of ops:  26
compiled vars:  !0 = $delta, !1 = $numpoints, !2 = $firsttime, !3 = $k
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
    5     0  E >   RECV                                             !0      
          1        RECV                                             !1      
          2        RECV                                             !2      
   10     3      > JMPZ                                                     !2, ->7
          4    >   DIV                                              ~4      !0, 700
          5        QM_ASSIGN                                        ~5      ~4
          6      > JMP                                                      ->9
          7    >   DIV                                              ~6      !0, 2
          8        QM_ASSIGN                                        ~5      ~6
          9    >   ASSIGN                                                   !0, ~5
   11    10        DIV                                              ~8      !0, !1
         11        ASSIGN_OP                                     1          !0, ~8
   12    12        ASSIGN                                                   !3, 0
         13      > JMP                                                      ->18
   13    14    >   DIV                                              ~11     !0, 35
         15        CAST                                          4  ~12     ~11
         16        ASSIGN                                                   !0, ~12
   12    17        ASSIGN_OP                                     1          !3, 36
         18    >   IS_SMALLER                                               455, !0
         19      > JMPNZ                                                    ~15, ->14
   14    20    >   MUL                                              ~16     !0, 36
         21        ADD                                              ~17     !0, 38
         22        DIV                                              ~18     ~16, ~17
         23        ADD                                              ~19     !3, ~18
         24      > RETURN                                                   ~19
   15    25*     > RETURN                                                   null

End of function punyadapt

Function utf8:
Finding entry points
Branch analysis from position: 0
2 jumps found. (Code = 43) Position 1 = 3, Position 2 = 7
Branch analysis from position: 3
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 7
2 jumps found. (Code = 43) Position 1 = 9, Position 2 = 21
Branch analysis from position: 9
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 21
2 jumps found. (Code = 43) Position 1 = 23, Position 2 = 42
Branch analysis from position: 23
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 42
2 jumps found. (Code = 43) Position 1 = 44, Position 2 = 70
Branch analysis from position: 44
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 70
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/ZTFW3
function name:  utf8
number of ops:  71
compiled vars:  !0 = $cp
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   18     0  E >   RECV                                             !0      
   19     1        IS_SMALLER                                               !0, 128
          2      > JMPZ                                                     ~1, ->7
          3    >   INIT_FCALL                                               'chr'
          4        SEND_VAR                                                 !0
          5        DO_ICALL                                         $2      
          6      > RETURN                                                   $2
   20     7    >   IS_SMALLER                                               !0, 2048
          8      > JMPZ                                                     ~3, ->21
   21     9    >   INIT_FCALL                                               'chr'
         10        SR                                               ~4      !0, 6
         11        ADD                                              ~5      192, ~4
         12        SEND_VAL                                                 ~5
         13        DO_ICALL                                         $6      
         14        INIT_FCALL                                               'chr'
         15        BW_AND                                           ~7      !0, 63
         16        ADD                                              ~8      128, ~7
         17        SEND_VAL                                                 ~8
         18        DO_ICALL                                         $9      
         19        CONCAT                                           ~10     $6, $9
         20      > RETURN                                                   ~10
   22    21    >   IS_SMALLER                                               !0, 65536
         22      > JMPZ                                                     ~11, ->42
   23    23    >   INIT_FCALL                                               'chr'
         24        SR                                               ~12     !0, 12
         25        ADD                                              ~13     224, ~12
         26        SEND_VAL                                                 ~13
         27        DO_ICALL                                         $14     
   24    28        INIT_FCALL                                               'chr'
         29        SR                                               ~15     !0, 6
         30        BW_AND                                           ~16     ~15, 63
         31        ADD                                              ~17     128, ~16
         32        SEND_VAL                                                 ~17
         33        DO_ICALL                                         $18     
         34        CONCAT                                           ~19     $14, $18
   25    35        INIT_FCALL                                               'chr'
         36        BW_AND                                           ~20     !0, 63
         37        ADD                                              ~21     128, ~20
         38        SEND_VAL                                                 ~21
         39        DO_ICALL                                         $22     
         40        CONCAT                                           ~23     ~19, $22
         41      > RETURN                                                   ~23
   26    42    >   IS_SMALLER                                               !0, 2097152
         43      > JMPZ                                                     ~24, ->70
   27    44    >   INIT_FCALL                                               'chr'
         45        SR                                               ~25     !0, 18
         46        ADD                                              ~26     240, ~25
         47        SEND_VAL                                                 ~26
         48        DO_ICALL                                         $27     
   28    49        INIT_FCALL                                               'chr'
         50        SR                                               ~28     !0, 12
         51        BW_AND                                           ~29     ~28, 63
         52        ADD                                              ~30     128, ~29
         53        SEND_VAL                                                 ~30
         54        DO_ICALL                                         $31     
         55        CONCAT                                           ~32     $27, $31
   29    56        INIT_FCALL                                               'chr'
         57        SR                                               ~33     !0, 6
         58        BW_AND                                           ~34     ~33, 63
         59        ADD                                              ~35     128, ~34
         60        SEND_VAL                                                 ~35
         61        DO_ICALL                                         $36     
         62        CONCAT                                           ~37     ~32, $36
   30    63        INIT_FCALL                                               'chr'
         64        BW_AND                                           ~38     !0, 63
         65        ADD                                              ~39     128, ~38
         66        SEND_VAL                                                 ~39
         67        DO_ICALL                                         $40     
         68        CONCAT                                           ~41     ~37, $40
         69      > RETURN                                                   ~41
   32    70    > > RETURN                                                   null

End of function utf8

Function decodepart:
Finding entry points
Branch analysis from position: 0
2 jumps found. (Code = 43) Position 1 = 8, Position 2 = 9
Branch analysis from position: 8
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 9
2 jumps found. (Code = 43) Position 1 = 21, Position 2 = 38
Branch analysis from position: 21
1 jumps found. (Code = 42) Position 1 = 40
Branch analysis from position: 40
1 jumps found. (Code = 42) Position 1 = 124
Branch analysis from position: 124
2 jumps found. (Code = 44) Position 1 = 126, Position 2 = 47
Branch analysis from position: 126
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 47
1 jumps found. (Code = 42) Position 1 = 97
Branch analysis from position: 97
2 jumps found. (Code = 44) Position 1 = 98, Position 2 = 51
Branch analysis from position: 98
2 jumps found. (Code = 44) Position 1 = 126, Position 2 = 47
Branch analysis from position: 126
Branch analysis from position: 47
Branch analysis from position: 51
2 jumps found. (Code = 43) Position 1 = 55, Position 2 = 56
Branch analysis from position: 55
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 56
2 jumps found. (Code = 46) Position 1 = 64, Position 2 = 66
Branch analysis from position: 64
2 jumps found. (Code = 43) Position 1 = 67, Position 2 = 69
Branch analysis from position: 67
1 jumps found. (Code = 42) Position 1 = 77
Branch analysis from position: 77
2 jumps found. (Code = 43) Position 1 = 81, Position 2 = 83
Branch analysis from position: 81
1 jumps found. (Code = 42) Position 1 = 90
Branch analysis from position: 90
2 jumps found. (Code = 43) Position 1 = 92, Position 2 = 93
Branch analysis from position: 92
1 jumps found. (Code = 42) Position 1 = 98
Branch analysis from position: 98
Branch analysis from position: 93
2 jumps found. (Code = 44) Position 1 = 98, Position 2 = 51
Branch analysis from position: 98
Branch analysis from position: 51
Branch analysis from position: 83
2 jumps found. (Code = 43) Position 1 = 86, Position 2 = 88
Branch analysis from position: 86
1 jumps found. (Code = 42) Position 1 = 90
Branch analysis from position: 90
Branch analysis from position: 88
2 jumps found. (Code = 43) Position 1 = 92, Position 2 = 93
Branch analysis from position: 92
Branch analysis from position: 93
Branch analysis from position: 69
2 jumps found. (Code = 46) Position 1 = 71, Position 2 = 73
Branch analysis from position: 71
2 jumps found. (Code = 43) Position 1 = 74, Position 2 = 76
Branch analysis from position: 74
1 jumps found. (Code = 42) Position 1 = 77
Branch analysis from position: 77
Branch analysis from position: 76
1 jumps found. (Code = 62) Position 1 = -2
Branch analysis from position: 73
Branch analysis from position: 66
Branch analysis from position: 38
1 jumps found. (Code = 42) Position 1 = 124
Branch analysis from position: 124
filename:       /in/ZTFW3
function name:  decodePart
number of ops:  132
compiled vars:  !0 = $input, !1 = $nonBasicCharsStart, !2 = $output, !3 = $nonBasicChars, !4 = $n, !5 = $i, !6 = $bias, !7 = $j, !8 = $l, !9 = $oldi, !10 = $w, !11 = $k, !12 = $digit, !13 = $t, !14 = $c
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
   35     0  E >   RECV                                             !0      
   36     1        INIT_FCALL                                               'substr'
          2        SEND_VAR                                                 !0
          3        SEND_VAL                                                 0
          4        SEND_VAL                                                 4
          5        DO_ICALL                                         $15     
          6        IS_NOT_IDENTICAL                                         $15, 'xn--'
          7      > JMPZ                                                     ~16, ->9
   37     8    > > RETURN                                                   !0
   39     9    >   INIT_FCALL                                               'substr'
         10        SEND_VAR                                                 !0
         11        SEND_VAL                                                 4
         12        DO_ICALL                                         $17     
         13        ASSIGN                                                   !0, $17
   41    14        INIT_FCALL                                               'strrpos'
         15        SEND_VAR                                                 !0
         16        SEND_VAL                                                 '-'
         17        DO_ICALL                                         $19     
         18        ASSIGN                                           ~20     !1, $19
         19        TYPE_CHECK                                  1018          ~20
         20      > JMPZ                                                     ~21, ->38
   42    21    >   INIT_FCALL                                               'str_split'
         22        INIT_FCALL                                               'substr'
         23        SEND_VAR                                                 !0
         24        SEND_VAL                                                 0
         25        SEND_VAR                                                 !1
         26        DO_ICALL                                         $22     
         27        SEND_VAR                                                 $22
         28        SEND_VAL                                                 1
         29        DO_ICALL                                         $23     
         30        ASSIGN                                                   !2, $23
   43    31        INIT_FCALL                                               'substr'
         32        SEND_VAR                                                 !0
         33        ADD                                              ~25     !1, 1
         34        SEND_VAL                                                 ~25
         35        DO_ICALL                                         $26     
         36        ASSIGN                                                   !3, $26
         37      > JMP                                                      ->40
   45    38    >   ASSIGN                                                   !2, <array>
   46    39        ASSIGN                                                   !3, !0
   49    40    >   ASSIGN                                                   !4, 128
   50    41        ASSIGN                                                   !5, 0
   51    42        ASSIGN                                                   !6, 72
   53    43        ASSIGN                                                   !7, 0
         44        STRLEN                                           ~34     !3
         45        ASSIGN                                                   !8, ~34
         46      > JMP                                                      ->124
   54    47    >   ASSIGN                                                   !9, !5
   55    48        ASSIGN                                                   !10, 1
   56    49        ASSIGN                                                   !11, 36
   58    50      > JMP                                                      ->97
   59    51    >   POST_INC                                         ~39     !7
         52        ISSET_ISEMPTY_DIM_OBJ                         0  ~40     !3, ~39
         53        BOOL_NOT                                         ~41     ~40
         54      > JMPZ                                                     ~41, ->56
   60    55    > > RETURN                                                   <false>
   63    56    >   INIT_FCALL                                               'ord'
         57        POST_INC                                         ~42     !7
         58        FETCH_DIM_R                                      ~43     !3, ~42
         59        SEND_VAL                                                 ~43
         60        DO_ICALL                                         $44     
         61        ASSIGN                                                   !12, $44
   65    62        IS_SMALLER_OR_EQUAL                              ~46     97, !12
         63      > JMPZ_EX                                          ~46     ~46, ->66
         64    >   IS_SMALLER_OR_EQUAL                              ~47     !12, 122
         65        BOOL                                             ~46     ~47
         66    > > JMPZ                                                     ~46, ->69
   66    67    >   ASSIGN_OP                                     2          !12, 97
         68      > JMP                                                      ->77
   67    69    >   IS_SMALLER_OR_EQUAL                              ~49     48, !12
         70      > JMPZ_EX                                          ~49     ~49, ->73
         71    >   IS_SMALLER_OR_EQUAL                              ~50     !12, 57
         72        BOOL                                             ~49     ~50
         73    > > JMPZ                                                     ~49, ->76
   68    74    >   ASSIGN_OP                                     2          !12, 22
         75      > JMP                                                      ->77
   70    76    > > RETURN                                                   <false>
   73    77    >   MUL                                              ~52     !12, !10
         78        ASSIGN_OP                                     1          !5, ~52
   75    79        IS_SMALLER_OR_EQUAL                                      !11, !6
         80      > JMPZ                                                     ~54, ->83
   76    81    >   ASSIGN                                                   !13, 1
         82      > JMP                                                      ->90
   77    83    >   ADD                                              ~56     !6, 26
         84        IS_SMALLER_OR_EQUAL                                      ~56, !11
         85      > JMPZ                                                     ~57, ->88
   78    86    >   ASSIGN                                                   !13, 26
         87      > JMP                                                      ->90
   80    88    >   SUB                                              ~59     !11, !6
         89        ASSIGN                                                   !13, ~59
   83    90    >   IS_SMALLER                                               !12, !13
         91      > JMPZ                                                     ~61, ->93
   84    92    > > JMP                                                      ->98
   87    93    >   SUB                                              ~62     36, !13
         94        CAST                                          4  ~63     ~62
         95        ASSIGN_OP                                     3          !10, ~63
   88    96        ASSIGN_OP                                     1          !11, 36
   58    97    > > JMPNZ                                                    <true>, ->51
   91    98    >   COUNT                                            ~66     !2
         99        ADD                                              ~67     ~66, 1
        100        ASSIGN                                                   !14, ~67
   93   101        INIT_STATIC_METHOD_CALL                                  'IDN', 'punyAdapt'
        102        SUB                                              ~69     !5, !9
        103        SEND_VAL                                                 ~69
        104        SEND_VAR                                                 !14
        105        IS_IDENTICAL                                     ~70     !9, 0
        106        SEND_VAL                                                 ~70
        107        DO_FCALL                                      0  $71     
        108        ASSIGN                                                   !6, $71
   94   109        DIV                                              ~73     !5, !14
        110        CAST                                          4  ~74     ~73
        111        ASSIGN_OP                                     1          !4, ~74
   95   112        ASSIGN_OP                                     5          !5, !14
   97   113        INIT_FCALL                                               'array_splice'
        114        SEND_REF                                                 !2
        115        SEND_VAR                                                 !5
        116        SEND_VAL                                                 0
        117        INIT_STATIC_METHOD_CALL                                  'IDN', 'utf8'
        118        SEND_VAR                                                 !4
        119        DO_FCALL                                      0  $77     
        120        INIT_ARRAY                                       ~78     $77
        121        SEND_VAL                                                 ~78
        122        DO_ICALL                                                 
   98   123        PRE_INC                                                  !5
   53   124    >   IS_SMALLER                                               !7, !8
        125      > JMPNZ                                                    ~81, ->47
  101   126    >   INIT_FCALL                                               'implode'
        127        SEND_VAL                                                 ''
        128        SEND_VAR                                                 !2
        129        DO_ICALL                                         $82     
        130      > RETURN                                                   $82
  102   131*     > RETURN                                                   null

End of function decodepart

Function decodeidn:
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/ZTFW3
function name:  decodeIDN
number of ops:  15
compiled vars:  !0 = $name
line      #* E I O op                           fetch          ext  return  operands
-------------------------------------------------------------------------------------
  104     0  E >   RECV                                             !0      
  107     1        INIT_FCALL                                               'implode'
  108     2        SEND_VAL                                                 '.'
  109     3        INIT_FCALL                                               'array_map'
          4        SEND_VAL                                                 'IDN%3A%3AdecodePart'
          5        INIT_FCALL                                               'explode'
          6        SEND_VAL                                                 '.'
          7        SEND_VAR                                                 !0
          8        DO_ICALL                                         $1      
          9        SEND_VAR                                                 $1
         10        DO_ICALL                                         $2      
         11        SEND_VAR                                                 $2
         12        DO_ICALL                                         $3      
         13      > RETURN                                                   $3
  111    14*     > RETURN                                                   null

End of function decodeidn

End of class IDN.

Generated using Vulcan Logic Dumper, using php 8.0.0


preferences:
159.12 ms | 1420 KiB | 31 Q