Changeset 766 in svn for branches/1.3/Decompiler.class.php


Ignore:
Timestamp:
2011-04-18T04:29:25Z (4 years ago)
Author:
Xuefer
Message:

merge changes from trunk

Location:
branches/1.3
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • branches/1.3

  • branches/1.3/Decompiler.class.php

    r739 r766  
    1111function str($code, $indent = '') // {{{
    1212{
     13    if (is_array($code)) {
     14        $array = array();
     15        foreach ($code as $key => $value) {
     16            $array[$key] = str($value, $indent);
     17        }
     18        return $array;
     19    }
    1320    if (is_object($code)) {
    14         if (get_class($code) != 'Decompiler_Code') {
    15             $code = toCode($code, $indent);
    16         }
    17         return $code->__toString();
     21        $code = foldToCode($code, $indent);
     22        return $code->toCode($indent);
    1823    }
    1924
     
    2126}
    2227// }}}
    23 function toCode($src, $indent = '') // {{{
     28function foldToCode($src, $indent = '') // {{{ wrap or rewrap anything to Decompiler_Code
    2429{
    2530    if (is_array($indent)) {
     
    2732    }
    2833
    29     if (is_object($src)) {
    30         if (!method_exists($src, 'toCode')) {
    31             var_dump($src);
    32             exit('no toCode');
    33         }
    34         return new Decompiler_Code($src->toCode($indent));
    35     }
    36 
    37     return new Decompiler_Code($src);
     34    if (!is_object($src)) {
     35        return new Decompiler_Code($src);
     36    }
     37
     38    if (!method_exists($src, 'toCode')) {
     39        var_dump($src);
     40        exit('no toCode');
     41    }
     42    if (get_class($src) != 'Decompiler_Code') {
     43        // rewrap it
     44        $src = new Decompiler_Code($src->toCode($indent));
     45    }
     46
     47    return $src;
    3848}
    3949// }}}
     
    6171}
    6272// }}}
     73function unquoteName_($str, $asVariableName, $indent = '') // {{{
     74{
     75    $str = str($str, $indent);
     76    if (preg_match("!^'[\\w_][\\w\\d_\\\\]*'\$!", $str)) {
     77        return str_replace('\\\\', '\\', substr($str, 1, -1));
     78    }
     79    else if ($asVariableName) {
     80        return "{" . $str . "}";
     81    }
     82    else {
     83        return $str;
     84    }
     85}
     86// }}}
     87function unquoteVariableName($str, $indent = '') // {{{
     88{
     89    return unquoteName_($str, true, $indent);
     90}
     91// }}}
     92function unquoteName($str, $indent = '') // {{{
     93{
     94    return unquoteName_($str, false, $indent);
     95}
     96// }}}
    6397class Decompiler_Object // {{{
    6498{
     
    76110    function toCode($indent)
    77111    {
    78         return var_export($this->value, true);
     112        $code = var_export($this->value, true);
     113        if (gettype($this->value) == 'string') {
     114            switch ($this->value) {
     115            case "\r":
     116                return '"\\r"';
     117            case "\n":
     118                return '"\\n"';
     119            case "\r\n":
     120                return '"\\r\\n"';
     121            }
     122            $code = str_replace("\r\n", '\' . "\\r\\n" . \'', $code);
     123            $code = str_replace("\r", '\' . "\\r" . \'', $code);
     124            $code = str_replace("\n", '\' . "\\n" . \'', $code);
     125        }
     126        return $code;
    79127    }
    80128}
     
    86134    function Decompiler_Code($src)
    87135    {
     136        assert('isset($src)');
    88137        $this->src = $src;
    89138    }
    90139
    91140    function toCode($indent)
    92     {
    93         return $this;
    94     }
    95 
    96     function __toString()
    97141    {
    98142        return $this->src;
     
    118162    function toCode($indent)
    119163    {
    120         $op1 = toCode($this->op1, $indent);
     164        $opstr = $this->parent->binops[$this->opc];
     165
     166        $op1 = foldToCode($this->op1, $indent);
    121167        if (is_a($this->op1, 'Decompiler_Binop') && $this->op1->opc != $this->opc) {
    122             $op1 = "($op1)";
    123         }
    124         $opstr = $this->parent->binops[$this->opc];
    125         if ($op1 == '0' && $this->opc == XC_SUB) {
    126             return $opstr . toCode($this->op2, $indent);
    127         }
    128         return $op1 . ' ' . $opstr . ' ' . toCode($this->op2, $indent);
     168            $op1 = "(" . str($op1, $indent) . ")";
     169        }
     170        $op2 = foldToCode($this->op2, $indent);
     171        if (is_a($this->op2, 'Decompiler_Binop') && $this->op2->opc != $this->opc && substr($opstr, -1) != '=') {
     172            $op2 = "(" . str($op2, $indent) . ")";
     173        }
     174
     175        if (str($op1) == '0' && ($this->opc == XC_ADD || $this->opc == XC_SUB)) {
     176            return $opstr . str($op2, $indent);
     177        }
     178
     179        return str($op1) . ' ' . $opstr . ' ' . str($op2);
    129180    }
    130181}
     
    148199            return '$' . substr($this->src, 1, -1);
    149200        case ZEND_FETCH_STATIC:
     201            if (ZEND_ENGINE_2_3) {
     202                // closure local variable?
     203                return str($this->src);
     204            }
    150205            die('static fetch cant to string');
    151206        case ZEND_FETCH_GLOBAL:
     
    178233    var $offsets = array();
    179234    var $isLast = false;
     235    var $isObject = false;
    180236    var $assign = null;
    181237
     
    183239    {
    184240        if (is_a($this->value, 'Decompiler_ListBox')) {
    185             $exp = toCode($this->value->obj->src, $indent);
     241            $exp = str($this->value->obj->src, $indent);
    186242        }
    187243        else {
    188             $exp = toCode($this->value, $indent);
    189         }
    190         foreach ($this->offsets as $dim) {
    191             $exp .= '[' . toCode($dim, $indent) . ']';
     244            $exp = str($this->value, $indent);
     245        }
     246        $last = count($this->offsets) - 1;
     247        foreach ($this->offsets as $i => $dim) {
     248            if ($this->isObject && $i == $last) {
     249                $exp .= '->' . unquoteVariableName($dim, $indent);
     250            }
     251            else {
     252                $exp .= '[' . str($dim, $indent) . ']';
     253            }
    192254        }
    193255        return $exp;
     
    212274            $dim->value = $this->src;
    213275            if (!isset($dim->assign)) {
    214                 return toCode($dim, $indent);
    215             }
    216             return toCode($this->dims[0]->assign, $indent) . ' = ' . toCode($dim, $indent);
     276                return str($dim, $indent);
     277            }
     278            return str($this->dims[0]->assign, $indent) . ' = ' . str($dim, $indent);
    217279        }
    218280        /* flatten dims */
     
    223285                $assign = &$assign[$offset];
    224286            }
    225             $assign = toCode($dim->assign, $indent);
    226         }
    227         return $this->toList($assigns) . ' = ' . toCode($this->src, $indent);
     287            $assign = foldToCode($dim->assign, $indent);
     288        }
     289        return str($this->toList($assigns)) . ' = ' . str($this->src, $indent);
    228290    }
    229291
     
    370432class Decompiler
    371433{
    372     var $rName = '!^[\\w_][\\w\\d_]*$!';
    373     var $rQuotedName = "!^'[\\w_][\\w\\d_]*'\$!";
     434    var $namespace;
     435    var $namespaceDecided;
    374436
    375437    function Decompiler()
    376438    {
     439        // {{{ testing
     440        // XC_UNDEF XC_OP_DATA
     441        $this->test = !empty($_ENV['XCACHE_DECOMPILER_TEST']);
     442        $this->usedOps = array();
     443
     444        if ($this->test) {
     445            $content = file_get_contents(__FILE__);
     446            for ($i = 0; $opname = xcache_get_opcode($i); $i ++) {
     447                if (!preg_match("/\\bXC_" . $opname . "\\b(?!')/", $content)) {
     448                    echo "not recognized opcode ", $opname, "\n";
     449                }
     450            }
     451        }
     452        // }}}
    377453        // {{{ opinfo
    378454        $this->unaryops = array(
     
    421497                // }}}
    422498    }
     499    function detectNamespace($name) // {{{
     500    {
     501        if ($this->namespaceDecided) {
     502            return;
     503        }
     504
     505        if (strpos($name, '\\') !== false) {
     506            $this->namespace = strtok($name, '\\');
     507            echo 'namespace ', $this->namespace, ";\n\n";
     508        }
     509
     510        $this->namespaceDecided = true;
     511    }
     512    // }}}
     513    function stripNamespace($name) // {{{
     514    {
     515        $len = strlen($this->namespace) + 1;
     516        if (substr($name, 0, $len) == $this->namespace . '\\') {
     517            return substr($name, $len);
     518        }
     519        else {
     520            return $name;
     521        }
     522    }
     523    // }}}
    423524    function outputPhp(&$opcodes, $opline, $last, $indent) // {{{
    424525    {
     
    428529            $op = $opcodes[$i];
    429530            if (isset($op['php'])) {
    430                 $toticks = isset($op['ticks']) ? $op['ticks'] : 0;
     531                $toticks = isset($op['ticks']) ? (int) str($op['ticks']) : 0;
    431532                if ($curticks != $toticks) {
    432                     if (!$toticks) {
    433                         echo $origindent, "}\n";
     533                    $oldticks = $curticks;
     534                    $curticks = $toticks;
     535                    if (!$curticks) {
     536                        echo $origindent, "}\n\n";
    434537                        $indent = $origindent;
    435538                    }
    436539                    else {
    437                         if ($curticks) {
    438                             echo $origindent, "}\n";
    439                         }
    440                         else if (!$curticks) {
     540                        if ($oldticks) {
     541                            echo $origindent, "}\n\n";
     542                        }
     543                        else if (!$oldticks) {
    441544                            $indent .= INDENT;
    442545                        }
    443                         echo $origindent, "declare(ticks=$curticks) {\n";
    444                     }
    445                     $curticks = $toticks;
    446                 }
    447                 echo $indent, toCode($op['php'], $indent), ";\n";
     546                        echo $origindent, "declare (ticks=$curticks) {\n";
     547                    }
     548                }
     549                echo $indent, str($op['php'], $indent), ";\n";
    448550            }
    449551        }
     
    457559        switch ($op['op_type']) {
    458560        case XC_IS_CONST:
    459             return toCode(value($op['constant']), $EX);
     561            return foldToCode(value($op['constant']), $EX);
    460562
    461563        case XC_IS_VAR:
     
    464566            $ret = $T[$op['var']];
    465567            if ($tostr) {
    466                 $ret = toCode($ret, $EX);
     568                $ret = foldToCode($ret, $EX);
    467569            }
    468570            if ($free) {
     
    531633            $last = count($opcodes) - 1;
    532634            if ($opcodes[$last]['opcode'] == XC_HANDLE_EXCEPTION) {
    533                 unset($opcodes[$last]);
     635                $this->usedOps[XC_HANDLE_EXCEPTION] = true;
     636                $opcodes[$last]['opcode'] = XC_NOP;
    534637                --$last;
    535638            }
     
    537640                $op1 = $opcodes[$last]['op1'];
    538641                if ($op1['op_type'] == XC_IS_CONST && array_key_exists('constant', $op1) && $op1['constant'] === $defaultReturnValue) {
    539                     unset($opcodes[$last]);
     642                    $opcodes[$last]['opcode'] = XC_NOP;
    540643                    --$last;
    541644                }
     
    562665            $op['line'] = $i;
    563666            switch ($op['opcode']) {
     667            case XC_CONT:
     668            case XC_BRK:
     669                $op['jmpouts'] = array();
     670                break;
     671
     672            case XC_GOTO:
    564673            case XC_JMP:
    565674                $target = $op['op1']['var'];
     
    580689            case XC_JMPZ_EX:
    581690            case XC_JMPNZ_EX:
     691            case XC_JMP_SET:
    582692            // case XC_FE_RESET:
    583693            case XC_FE_FETCH:
     
    678788            $body = ob_get_clean();
    679789
    680             $as = toCode($op['fe_as'], $EX);
     790            $as = foldToCode($op['fe_as'], $EX);
    681791            if (isset($op['fe_key'])) {
    682                 $as = toCode($op['fe_key'], $EX) . ' => ' . $as;
    683             }
    684             echo "{$indent}foreach (" . toCode($op['fe_src'], $EX) . " as $as) {\n";
     792                $as = str($op['fe_key'], $EX) . ' => ' . str($as);
     793            }
     794            echo "{$indent}foreach (" . str($op['fe_src'], $EX) . " as $as) {\n";
    685795            echo $body;
    686796            echo "{$indent}}";
     
    711821            return;
    712822        }
    713         if (!empty($op['jmpouts']) && isset($op['isjmp'])) {
     823        if (isset($op['jmpouts']) && isset($op['isjmp'])) {
    714824            if (isset($op['cond'])) {
    715                 echo "{$indent}check ($op[cond]) {\n";
     825                echo "{$indent}check (" . str($op["cond"]) . ") {\n";
    716826                echo INDENT;
    717827            }
    718             echo $indent;
    719             echo xcache_get_opcode($op['opcode']), ' line', $op['jmpouts'][0];
    720             if (isset($op['jmpouts'][1])) {
    721                 echo ', line', $op['jmpouts'][1];
    722             }
    723             echo ";";
    724             // echo ' // <- line', $op['line'];
    725             echo "\n";
     828            switch ($op['opcode']) {
     829            case XC_CONT:
     830            case XC_BRK:
     831                break;
     832
     833            case XC_GOTO:
     834                echo $indent, 'goto', ' line', $op['jmpouts'][0], ';', "\n";
     835                break;
     836
     837            default:
     838                echo $indent;
     839                echo xcache_get_opcode($op['opcode']), ' line', $op['jmpouts'][0];
     840                if (isset($op['jmpouts'][1])) {
     841                    echo ', line', $op['jmpouts'][1];
     842                }
     843                echo ";";
     844                // echo ' // <- line', $op['line'];
     845                echo "\n";
     846            }
    726847            if (isset($op['cond'])) echo "$indent}\n";
    727848        }
     
    751872            // $this->dumpop($op, $EX);
    752873            // any true comes here, so it's a "or"
    753             $cond = implode(' and ', $op['cond_false']);
     874            $cond = implode(' and ', str($op['cond_false']));
    754875            // var_dump($op['cond'] = $cond);
    755876            /*
     
    765886    }
    766887    // }}}
    767     function unquoteName($str) // {{{
    768     {
    769         if (preg_match($this->rQuotedName, $str)) {
    770             $str = substr($str, 1, -1);
    771         }
    772         return $str;
    773     }
    774     // }}}
    775888    function dasmBasicBlock(&$EX, $opline, $last) // {{{
    776889    {
     
    784897            $opc = $op['opcode'];
    785898            if ($opc == XC_NOP) {
     899                $this->usedOps[$opc] = true;
    786900                continue;
    787901            }
     
    799913                continue;
    800914            }
    801             // $this->dumpop($op, $EX); //var_dump($op);
     915            // echo $i, ' '; $this->dumpop($op, $EX); //var_dump($op);
    802916
    803917            $resvar = null;
     
    813927            $call = array(&$this, $opname);
    814928            if (is_callable($call)) {
     929                $this->usedOps[$opc] = true;
    815930                $this->{$opname}($op, $EX);
    816931            }
    817932            else if (isset($this->binops[$opc])) { // {{{
     933                $this->usedOps[$opc] = true;
    818934                $op1val = $this->getOpVal($op1, $EX, false);
    819935                $op2val = $this->getOpVal($op2, $EX, false);
     
    823939            }
    824940            else if (isset($this->unaryops[$opc])) { // {{{
     941                $this->usedOps[$opc] = true;
    825942                $op1val = $this->getOpVal($op1, $EX);
    826943                $myop = $this->unaryops[$opc];
    827                 $rvalue = "$myop$op1val";
     944                $rvalue = $myop . str($op1val);
    828945                $resvar = $rvalue;
    829946                // }}}
    830947            }
    831948            else {
     949                $covered = true;
    832950                switch ($opc) {
    833951                case XC_NEW: // {{{
     
    835953                    $EX['object'] = (int) $res['var'];
    836954                    $EX['called_scope'] = null;
    837                     $EX['fbc'] = 'new ' . $this->unquoteName($this->getOpVal($op1, $EX));
     955                    $EX['fbc'] = 'new ' . unquoteName($this->getOpVal($op1, $EX), $EX);
    838956                    if (!ZEND_ENGINE_2) {
    839957                        $resvar = '$new object$';
    840958                    }
     959                    break;
     960                    // }}}
     961                case XC_THROW: // {{{
     962                    $resvar = 'throw ' . str($this->getOpVal($op1, $EX));
     963                    break;
     964                    // }}}
     965                case XC_CLONE: // {{{
     966                    $resvar = 'clone ' . str($this->getOpVal($op1, $EX));
     967                    break;
     968                    // }}}
     969                case XC_CATCH: // {{{
     970                    $resvar = 'catch (' . str($this->getOpVal($op1, $EX)) . ' ' . str($this->getOpVal($op2, $EX)) . ')';
     971                    break;
     972                    // }}}
     973                case XC_INSTANCEOF: // {{{
     974                    $resvar = str($this->getOpVal($op1, $EX)) . ' instanceof ' . str($this->getOpVal($op2, $EX));
    841975                    break;
    842976                    // }}}
     
    857991                    }
    858992                    else {
    859                         $class = $op2['constant'];
    860                         if (is_object($class)) {
    861                             $class = get_class($class);
     993                        $class = $this->getOpVal($op2, $EX);
     994                        if (isset($op2['constant'])) {
     995                            $class = $this->stripNamespace(unquoteName($class));
    862996                        }
    863997                    }
     
    8661000                    // }}}
    8671001                case XC_FETCH_CONSTANT: // {{{
     1002                    if ($op1['op_type'] == XC_IS_UNUSED) {
     1003                        $resvar = $this->stripNamespace($op2['constant']);
     1004                        break;
     1005                    }
     1006
    8681007                    if ($op1['op_type'] == XC_IS_CONST) {
    869                         $resvar = $op1['constant'];
    870                     }
    871                     else if ($op1['op_type'] == XC_IS_UNUSED) {
    872                         $resvar = $op2['constant'];
     1008                        $resvar = $this->stripNamespace($op1['constant']);
    8731009                    }
    8741010                    else {
    875                         $class = $T[$op1['var']];
    876                         assert($class[0] == 'class');
    877                         $resvar = $class[1] . '::' . $op2['constant'];
    878                     }
     1011                        $resvar = $this->getOpVal($op1, $EX);
     1012                    }
     1013
     1014                    $resvar = str($resvar) . '::' . unquoteName($this->getOpVal($op2, $EX));
    8791015                    break;
    8801016                    // }}}
     
    8971033                    case ZEND_FETCH_STATIC_MEMBER:
    8981034                        $class = $this->getOpVal($op2, $EX);
    899                         $rvalue = $class . '::$' . $this->unquoteName($rvalue);
     1035                        $rvalue = str($class) . '::$' . unquoteName($rvalue, $EX);
    9001036                        break;
    9011037                    default:
    902                         $name = $this->unquoteName($rvalue);
    903                         $globalname = xcache_is_autoglobal($name) ? "\$$name" : "\$GLOBALS[$rvalue]";
     1038                        $name = unquoteName($rvalue, $EX);
     1039                        $globalname = xcache_is_autoglobal($name) ? "\$$name" : "\$GLOBALS[" . str($rvalue) . "]";
    9041040                        $rvalue = new Decompiler_Fetch($rvalue, $fetchtype, $globalname);
    9051041                        break;
    9061042                    }
    9071043                    if ($opc == XC_UNSET_VAR) {
    908                         $op['php'] = "unset(" . toCode($rvalue, $EX) . ")";
     1044                        $op['php'] = "unset(" . str($rvalue, $EX) . ")";
    9091045                        $lastphpop = &$op;
    9101046                    }
     
    9231059                case XC_FETCH_DIM_IS:
    9241060                case XC_ASSIGN_DIM:
     1061                case XC_UNSET_DIM_OBJ: // PHP 4 only
    9251062                case XC_UNSET_DIM:
    926                 case XC_UNSET_DIM_OBJ:
     1063                case XC_UNSET_OBJ:
    9271064                    $src = $this->getOpVal($op1, $EX, false);
    9281065                    if (is_a($src, "Decompiler_ForeachBox")) {
     
    9311068                        break;
    9321069                    }
    933                     else if (is_a($src, "Decompiler_DimBox")) {
     1070
     1071                    if (is_a($src, "Decompiler_DimBox")) {
    9341072                        $dimbox = $src;
    9351073                    }
    9361074                    else {
    9371075                        if (!is_a($src, "Decompiler_ListBox")) {
    938                             $list = new Decompiler_List($this->getOpVal($op1, $EX, false));
     1076                            $op1val = $this->getOpVal($op1, $EX, false);
     1077                            $list = new Decompiler_List(isset($op1val) ? $op1val : '$this');
    9391078
    9401079                            $src = new Decompiler_ListBox($list);
     
    9601099                        $dim->isLast = true;
    9611100                    }
     1101                    if ($opc == XC_UNSET_OBJ) {
     1102                        $dim->isObject = true;
     1103                    }
    9621104                    unset($dim);
    9631105                    $rvalue = $dimbox;
     1106                    unset($dimbox);
    9641107
    9651108                    if ($opc == XC_ASSIGN_DIM) {
     
    9671110                        ++ $i;
    9681111                        $rvalue = $this->getOpVal($opcodes[$i]['op1'], $EX);
    969                         $resvar = toCode($lvalue, $EX) . ' = ' . $rvalue;
    970                     }
    971                     else if ($opc == XC_UNSET_DIM) {
    972                         $op['php'] = "unset(" . toCode($rvalue, $EX) . ")";
     1112                        $resvar = str($lvalue, $EX) . ' = ' . str($rvalue);
     1113                    }
     1114                    else if ($opc == XC_UNSET_DIM || $opc == XC_UNSET_OBJ) {
     1115                        $op['php'] = "unset(" . str($rvalue, $EX) . ")";
    9731116                        $lastphpop = &$op;
    9741117                    }
     
    9911134                        $dim->assign = $lvalue;
    9921135                        if ($dim->isLast) {
    993                             $resvar = toCode($dim->value, $EX);
     1136                            $resvar = foldToCode($dim->value, $EX);
    9941137                        }
    9951138                        unset($dim);
    9961139                        break;
    9971140                    }
    998                     $resvar = "$lvalue = " . toCode($rvalue, $EX);
     1141                    $resvar = "$lvalue = " . str($rvalue, $EX);
    9991142                    break;
    10001143                    // }}}
     
    10031146                    $rvalue = $this->getOpVal($op2, $EX, false);
    10041147                    if (is_a($rvalue, 'Decompiler_Fetch')) {
    1005                         $src = toCode($rvalue->src, $EX);
    1006                         if (substr($src, 1, -1) == substr($lvalue, 1)) {
     1148                        $src = str($rvalue->src, $EX);
     1149                        if ('$' . unquoteName($src) == $lvalue) {
    10071150                            switch ($rvalue->fetchType) {
    10081151                            case ZEND_FETCH_GLOBAL:
     
    10131156                                $statics = &$EX['op_array']['static_variables'];
    10141157                                $resvar = 'static ' . $lvalue;
    1015                                 $name = substr($src, 1, -1);
     1158                                $name = unquoteName($src);
    10161159                                if (isset($statics[$name])) {
    10171160                                    $var = $statics[$name];
    10181161                                    $resvar .= ' = ';
    1019                                     $resvar .= toCode(value($var), $EX);
     1162                                    $resvar .= str(value($var), $EX);
    10201163                                }
    10211164                                unset($statics);
     
    10261169                    }
    10271170                    // TODO: PHP_6 global
    1028                     $rvalue = toCode($rvalue, $EX);
     1171                    $rvalue = str($rvalue, $EX);
    10291172                    $resvar = "$lvalue = &$rvalue";
    10301173                    break;
     
    10421185                        $obj = '$this';
    10431186                    }
    1044                     $prop = $this->getOpVal($op2, $EX);
    1045                     if (preg_match($this->rQuotedName, $prop)) {
    1046                         $prop = substr($prop, 1, -1);;
    1047                         $rvalue = "{$obj}->$prop";
    1048                     }
    1049                     else {
    1050                         $rvalue = "{$obj}->{" . "$prop}";
    1051                     }
     1187                    $rvalue = str($obj) . "->" . unquoteVariableName($this->getOpVal($op2, $EX), $EX);
    10521188                    if ($res['op_type'] != XC_IS_UNUSED) {
    10531189                        $resvar = $rvalue;
     
    10571193                        $lvalue = $rvalue;
    10581194                        $rvalue = $this->getOpVal($opcodes[$i]['op1'], $EX);
    1059                         $resvar = "$lvalue = $rvalue";
     1195                        $resvar = "$lvalue = " . str($rvalue);
    10601196                    }
    10611197                    break;
     
    10661202                case XC_ISSET_ISEMPTY_VAR: // {{{
    10671203                    if ($opc == XC_ISSET_ISEMPTY_VAR) {
    1068                         $rvalue = $this->getOpVal($op1, $EX);;
    1069                         if (preg_match($this->rQuotedName, $rvalue)) {
    1070                             $rvalue = '$' . substr($rvalue, 1, -1);
    1071                         }
    1072                         else {
    1073                             $rvalue = '${' . $rvalue . '}';
    1074                         }
     1204                        $rvalue = $this->getOpVal($op1, $EX);
    10751205                        if ($op2['EA.type'] == ZEND_FETCH_STATIC_MEMBER) {
    10761206                            $class = $this->getOpVal($op2, $EX);
     
    10851215                        $dim = $this->getOpVal($op2, $EX);
    10861216                        if ($opc == XC_ISSET_ISEMPTY_PROP_OBJ) {
    1087                             if (preg_match($this->rQuotedName, $dim)) {
    1088                                 $rvalue = $container . "->" . substr($dim, 1, -1);
     1217                            if (!isset($container)) {
     1218                                $container = '$this';
    10891219                            }
    1090                             else {
    1091                                 $rvalue = $container . "->{" . $dim . "}";
    1092                             }
     1220                            $rvalue = $container . "->" . unquoteVariableName($dim);
    10931221                        }
    10941222                        else {
    1095                             $rvalue = $container . "[$dim]";
     1223                            $rvalue = $container . '[' . str($dim) .']';
    10961224                        }
    10971225                    }
     
    11131241                case XC_SEND_VAR: // {{{
    11141242                    $ref = ($opc == XC_SEND_REF ? '&' : '');
    1115                     $EX['argstack'][] = $ref . $this->getOpVal($op1, $EX);
     1243                    $EX['argstack'][] = $ref . str($this->getOpVal($op1, $EX));
    11161244                    break;
    11171245                    // }}}
    11181246                case XC_INIT_STATIC_METHOD_CALL:
    1119                 case XC_INIT_METHOD_CALL:
    1120                 case XC_INIT_FCALL_BY_FUNC:
    1121                 case XC_INIT_FCALL_BY_NAME: // {{{
    1122                     if (($ext & ZEND_CTOR_CALL)) {
    1123                         break;
    1124                     }
     1247                case XC_INIT_METHOD_CALL: // {{{
    11251248                    array_push($EX['arg_types_stack'], array($EX['fbc'], $EX['object'], $EX['called_scope']));
    11261249                    if ($opc == XC_INIT_STATIC_METHOD_CALL || $opc == XC_INIT_METHOD_CALL || $op1['op_type'] != XC_IS_UNUSED) {
     
    11311254                        if ($opc == XC_INIT_STATIC_METHOD_CALL || /* PHP4 */ isset($op1['constant'])) {
    11321255                            $EX['object'] = null;
    1133                             $EX['called_scope'] = $this->unquoteName($obj);
     1256                            $EX['called_scope'] = $this->stripNamespace(unquoteName($obj, $EX));
    11341257                        }
    11351258                        else {
     
    11461269                    }
    11471270
    1148                     if ($opc == XC_INIT_FCALL_BY_FUNC) {
    1149                         $which = $op1['var'];
    1150                         $EX['fbc'] = $EX['op_array']['funcs'][$which]['name'];
    1151                     }
    1152                     else {
    1153                         $EX['fbc'] = $this->getOpVal($op2, $EX, false);
    1154                     }
     1271                    $EX['fbc'] = $this->getOpVal($op2, $EX, false);
     1272                    if (($opc == XC_INIT_STATIC_METHOD_CALL || $opc == XC_INIT_METHOD_CALL) && !isset($EX['fbc'])) {
     1273                        $EX['fbc'] = '__construct';
     1274                    }
     1275                    break;
     1276                    // }}}
     1277                case XC_INIT_NS_FCALL_BY_NAME:
     1278                case XC_INIT_FCALL_BY_NAME: // {{{
     1279                    array_push($EX['arg_types_stack'], array($EX['fbc'], $EX['object'], $EX['called_scope']));
     1280                    if (!ZEND_ENGINE_2 && ($ext & ZEND_CTOR_CALL)) {
     1281                        break;
     1282                    }
     1283                    $EX['object'] = null;
     1284                    $EX['called_scope'] = null;
     1285                    $EX['fbc'] = $this->getOpVal($op2, $EX);
     1286                    break;
     1287                    // }}}
     1288                case XC_INIT_FCALL_BY_FUNC: // {{{ deprecated even in PHP 4?
     1289                    $EX['object'] = null;
     1290                    $EX['called_scope'] = null;
     1291                    $which = $op1['var'];
     1292                    $EX['fbc'] = $EX['op_array']['funcs'][$which]['name'];
    11551293                    break;
    11561294                    // }}}
     
    11621300                    break;
    11631301                case XC_DO_FCALL:
    1164                     $fname = $this->unquoteName($this->getOpVal($op1, $EX, false));
     1302                    $fname = unquoteName($this->getOpVal($op1, $EX, false), $EX);
    11651303                    $args = $this->popargs($EX, $ext);
    11661304                    $resvar = $fname . "($args)";
     
    11691307                    $object = null;
    11701308
    1171                     $fname = $this->unquoteName($EX['fbc']);
     1309                    $fname = unquoteName($EX['fbc'], $EX);
    11721310                    if (!is_int($EX['object'])) {
    11731311                        $object = $EX['object'];
     
    11761314                    $args = $this->popargs($EX, $ext);
    11771315
    1178                     $resvar =
    1179                         (isset($object) ? $object . '->' : '' )
    1180                         . (isset($EX['called_scope']) ? $EX['called_scope'] . '::' : '' )
    1181                         . $fname . "($args)";
     1316                    $prefix = (isset($object) ? $object . '->' : '' )
     1317                        . (isset($EX['called_scope']) ? $EX['called_scope'] . '::' : '' );
     1318                    $resvar = $prefix
     1319                        . (!$prefix ? $this->stripNamespace($fname) : $fname)
     1320                        . "($args)";
    11821321                    unset($args);
    11831322
     
    12031342                    }
    12041343                    $class = &$this->dc['class_table'][$key];
    1205                     $class['name'] = $this->unquoteName($this->getOpVal($op2, $EX));
     1344                    if (!isset($class['name'])) {
     1345                        $class['name'] = unquoteName($this->getOpVal($op2, $EX), $EX);
     1346                    }
    12061347                    if ($opc == XC_DECLARE_INHERITED_CLASS || $opc == XC_DECLARE_INHERITED_CLASS_DELAYED) {
    12071348                        $ext /= XC_SIZEOF_TEMP_VARIABLE;
     
    12131354                    }
    12141355
    1215                     while ($i + 2 < $ic
    1216                      && $opcodes[$i + 2]['opcode'] == XC_ADD_INTERFACE
    1217                      && $opcodes[$i + 2]['op1']['var'] == $res['var']
    1218                      && $opcodes[$i + 1]['opcode'] == XC_FETCH_CLASS) {
     1356                    for (;;) {
     1357                        if ($i + 1 < $ic
     1358                         && $opcodes[$i + 1]['opcode'] == XC_ADD_INTERFACE
     1359                         && $opcodes[$i + 1]['op1']['var'] == $res['var']) {
     1360                            // continue
     1361                        }
     1362                        else if ($i + 2 < $ic
     1363                         && $opcodes[$i + 2]['opcode'] == XC_ADD_INTERFACE
     1364                         && $opcodes[$i + 2]['op1']['var'] == $res['var']
     1365                         && $opcodes[$i + 1]['opcode'] == XC_FETCH_CLASS) {
     1366                            // continue
     1367                        }
     1368                        else {
     1369                            break;
     1370                        }
     1371                        $this->usedOps[XC_ADD_INTERFACE] = true;
     1372
    12191373                        $fetchop = &$opcodes[$i + 1];
    1220                         $impl = $this->unquoteName($this->getOpVal($fetchop['op2'], $EX));
     1374                        $interface = $this->stripNamespace(unquoteName($this->getOpVal($fetchop['op2'], $EX), $EX));
    12211375                        $addop = &$opcodes[$i + 2];
    1222                         $class['interfaces'][$addop['extended_value']] = $impl;
     1376                        $class['interfaces'][$addop['extended_value']] = $interface;
    12231377                        unset($fetchop, $addop);
    12241378                        $i += 2;
    12251379                    }
    12261380                    $this->dclass($class);
     1381                    echo "\n";
    12271382                    unset($class);
    12281383                    break;
     
    12391394                    switch ($opc) {
    12401395                    case XC_ADD_CHAR:
    1241                         $op2val = toCode(chr($op2val), $EX);
     1396                        $op2val = value(chr(str($op2val)));
    12421397                        break;
    12431398                    case XC_ADD_STRING:
    1244                         $op2val = toCode($op2val, $EX);
    12451399                        break;
    12461400                    case XC_ADD_VAR:
    12471401                        break;
    12481402                    }
    1249                     if ($op1val == "''") {
     1403                    if (str($op1val) == "''") {
    12501404                        $rvalue = $op2val;
    12511405                    }
    1252                     else if ($op2val == "''") {
     1406                    else if (str($op2val) == "''") {
    12531407                        $rvalue = $op1val;
    12541408                    }
    12551409                    else {
    1256                         $rvalue = $op1val . ' . ' . $op2val;
     1410                        $rvalue = str($op1val) . ' . ' . str($op2val);
    12571411                    }
    12581412                    $resvar = $rvalue;
     
    12611415                case XC_PRINT: // {{{
    12621416                    $op1val = $this->getOpVal($op1, $EX);
    1263                     $resvar = "print($op1val)";
     1417                    $resvar = "print(" . str($op1val) . ")";
    12641418                    break;
    12651419                    // }}}
    12661420                case XC_ECHO: // {{{
    12671421                    $op1val = $this->getOpVal($op1, $EX);
    1268                     $resvar = "echo $op1val";
     1422                    $resvar = "echo " . str($op1val);
    12691423                    break;
    12701424                    // }}}
     
    13141468                    // }}}
    13151469                case XC_RETURN: // {{{
    1316                     $resvar = "return " . $this->getOpVal($op1, $EX);
     1470                    $resvar = "return " . str($this->getOpVal($op1, $EX));
    13171471                    break;
    13181472                    // }}}
     
    13201474                    $type = $op2['var']; // hack
    13211475                    $keyword = $this->includeTypes[$type];
    1322                     $resvar = "$keyword(" . $this->getOpVal($op1, $EX) . ")";
     1476                    $resvar = "$keyword " . str($this->getOpVal($op1, $EX));
    13231477                    break;
    13241478                    // }}}
     
    13571511                    // }}}
    13581512                case XC_JMP_NO_CTOR:
     1513                    break;
     1514                case XC_JMP_SET: // ?:
     1515                    $resvar = $this->getOpVal($op1, $EX);
     1516                    $op['cond'] = $resvar;
     1517                    $op['isjmp'] = true;
    13591518                    break;
    13601519                case XC_JMPNZ: // while
     
    13791538                        var_dump($op);// exit;
    13801539                    }
    1381                     if ($opc == XC_JMPZ_EX || $opc == XC_JMPNZ_EX || $opc == XC_JMPZ) {
     1540                    if ($opc == XC_JMPZ_EX || $opc == XC_JMPNZ_EX) {
    13821541                        $targetop = &$EX['opcodes'][$op2['opline_num']];
    13831542                        if ($opc == XC_JMPNZ_EX) {
    1384                             $targetop['cond_true'][] = toCode($rvalue, $EX);
     1543                            $targetop['cond_true'][] = foldToCode($rvalue, $EX);
    13851544                        }
    13861545                        else {
    1387                             $targetop['cond_false'][] = toCode($rvalue, $EX);
     1546                            $targetop['cond_false'][] = foldToCode($rvalue, $EX);
    13881547                        }
    13891548                        unset($targetop);
     
    13951554                    break;
    13961555                    // }}}
     1556                case XC_CONT:
     1557                case XC_BRK:
     1558                    $op['cond'] = null;
     1559                    $op['isjmp'] = true;
     1560                    $resvar = $opc == XC_CONT ? 'continue' : 'break';
     1561                    $count = str($this->getOpVal($op2, $EX));
     1562                    if ($count != '1') {
     1563                        $resvar .= ' ' . $count;
     1564                    }
     1565                    break;
     1566                case XC_GOTO:
    13971567                case XC_JMP: // {{{
    13981568                    $op['cond'] = null;
     
    14011571                    // }}}
    14021572                case XC_CASE:
    1403                 case XC_BRK:
     1573                    $switchValue = $this->getOpVal($op1, $EX);
     1574                    $caseValue = $this->getOpVal($op2, $EX);
     1575                    $resvar = str($switchValue) . ' == ' . str($caseValue);
    14041576                    break;
    14051577                case XC_RECV_INIT:
     
    14251597                    $flags = array_flip(explode('_', $opname));
    14261598                    if (isset($flags['OBJ'])) {
    1427                         $resvar = $this->getOpVal($op1, $EX);
    1428                         $prop = $this->unquoteName($this->getOpVal($op2, $EX));
    1429                         if ($prop{0} == '$') {
    1430                             $resvar = $resvar . "{" . $prop . "}";
    1431                         }
    1432                         else {
    1433                             $resvar = $resvar . "->" . $prop;
    1434                         }
     1599                        $resvar = $this->getOpVal($op1, $EX) . '->' . unquoteVariableName($this->getOpVal($op2, $EX), $EX);
    14351600                    }
    14361601                    else {
     
    14391604                    $opstr = isset($flags['DEC']) ? '--' : '++';
    14401605                    if (isset($flags['POST'])) {
    1441                         $resvar .= ' ' . $opstr;
     1606                        $resvar .= $opstr;
    14421607                    }
    14431608                    else {
    1444                         $resvar = "$opstr $resvar";
     1609                        $resvar = "$opstr$resvar";
    14451610                    }
    14461611                    break;
     
    14531618                case XC_END_SILENCE: // {{{
    14541619                    $EX['silence'] --;
    1455                     $lastresvar = '@' . toCode($lastresvar, $EX);
    1456                     break;
    1457                     // }}}
    1458                 case XC_CONT: // {{{
     1620                    $lastresvar = '@' . str($lastresvar, $EX);
    14591621                    break;
    14601622                    // }}}
     
    14801642                case XC_EXT_NOP:
    14811643                    break;
     1644                case XC_DECLARE_FUNCTION:
     1645                    $this->dfunction($this->dc['function_table'][$op1['constant']], $EX['indent']);
     1646                    break;
     1647                case XC_DECLARE_LAMBDA_FUNCTION: // {{{
     1648                    ob_start();
     1649                    $this->dfunction($this->dc['function_table'][$op1['constant']], $EX['indent']);
     1650                    $resvar = ob_get_clean();
     1651                    $istmpres = true;
     1652                    break;
     1653                    // }}}
     1654                case XC_DECLARE_CONST:
     1655                    $name = $this->stripNamespace(unquoteName($this->getOpVal($op1, $EX), $EX));
     1656                    $value = str($this->getOpVal($op2, $EX));
     1657                    $resvar = 'const ' . $name . ' = ' . $value;
     1658                    break;
    14821659                case XC_DECLARE_FUNCTION_OR_CLASS:
    14831660                    /* always removed by compiler */
     
    14871664                    // $EX['tickschanged'] = true;
    14881665                    break;
     1666                case XC_RAISE_ABSTRACT_ERROR:
     1667                    // abstract function body is empty, don't need this code
     1668                    break;
     1669                case XC_USER_OPCODE:
     1670                    echo '// ZEND_USER_OPCODE, impossible to decompile';
     1671                    break;
     1672                case XC_OP_DATA:
     1673                    break;
    14891674                default: // {{{
    14901675                    echo "\x1B[31m * TODO ", $opname, "\x1B[0m\n";
    1491                     // }}}
     1676                    $covered = false;
     1677                    // }}}
     1678                }
     1679                if ($covered) {
     1680                    $this->usedOps[$opc] = true;
    14921681                }
    14931682            }
     
    15231712            $a = array_pop($EX['argstack']);
    15241713            if (is_array($a)) {
    1525                 array_unshift($args, toCode($a, $EX));
     1714                array_unshift($args, foldToCode($a, $EX));
    15261715            }
    15271716            else {
     
    15361725        $op1 = $op['op1'];
    15371726        $op2 = $op['op2'];
    1538         $d = array('opname' => xcache_get_opcode($op['opcode']), 'opcode' => $op['opcode']);
    1539 
    1540         foreach (array('op1' => 'op1', 'op2' => 'op2', 'result' => 'res') as $k => $kk) {
     1727        $d = array(xcache_get_opcode($op['opcode']), $op['opcode']);
     1728
     1729        foreach (array('op1' => '1:', 'op2' => '2:', 'result' => '>') as $k => $kk) {
    15411730            switch ($op[$k]['op_type']) {
    15421731            case XC_IS_UNUSED:
    1543                 $d[$kk] = '*UNUSED* ' . $op[$k]['opline_num'];
     1732                $d[$kk] = 'U:' . $op[$k]['opline_num'];
    15441733                break;
    15451734
    15461735            case XC_IS_VAR:
    15471736                $d[$kk] = '$' . $op[$k]['var'];
    1548                 if ($kk != 'res') {
    1549                     $d[$kk] .= ':' . $this->getOpVal($op[$k], $EX);
     1737                if ($k != 'result') {
     1738                    $d[$kk] .= ':' . str($this->getOpVal($op[$k], $EX));
    15501739                }
    15511740                break;
     
    15531742            case XC_IS_TMP_VAR:
    15541743                $d[$kk] = '#' . $op[$k]['var'];
    1555                 if ($kk != 'res') {
    1556                     $d[$kk] .= ':' . $this->getOpVal($op[$k], $EX);
     1744                if ($k != 'result') {
     1745                    $d[$kk] .= ':' . str($this->getOpVal($op[$k], $EX));
    15571746                }
    15581747                break;
     
    15631752
    15641753            default:
    1565                 if ($kk == 'res') {
     1754                if ($k == 'result') {
    15661755                    var_dump($op);
    15671756                    exit;
     
    15731762            }
    15741763        }
    1575         $d['ext'] = $op['extended_value'];
    1576 
    1577         var_dump($d);
     1764        $d[';'] = $op['extended_value'];
     1765
     1766        foreach ($d as $k => $v) {
     1767            echo is_int($k) ? '' : $k, str($v), "\t";
     1768        }
     1769        echo PHP_EOL;
    15781770    }
    15791771    // }}}
     
    16021794                $ai = $op_array['arg_info'][$i];
    16031795                if (!empty($ai['class_name'])) {
    1604                     echo $ai['class_name'], ' ';
     1796                    echo $this->stripNamespace($ai['class_name']), ' ';
    16051797                    if (!ZEND_ENGINE_2_2 && $ai['allow_null']) {
    16061798                        echo 'or NULL ';
     
    16381830                    }
    16391831                }
    1640                 echo toCode($arg[0], $indent);
     1832                echo str($arg[0], $indent);
    16411833            }
    16421834            if (isset($arg[1])) {
    1643                 echo ' = ', toCode($arg[1], $indent);
     1835                echo ' = ', str($arg[1], $indent);
    16441836            }
    16451837        }
     
    16481840    function dfunction($func, $indent = '', $nobody = false) // {{{
    16491841    {
     1842        $this->detectNamespace($func['op_array']['function_name']);
     1843
    16501844        if ($nobody) {
    1651             $body = ";\n";
    16521845            $EX = array();
    16531846            $EX['op_array'] = &$func['op_array'];
     
    16641857        }
    16651858
    1666         echo 'function ', $func['op_array']['function_name'], '(';
     1859        $functionName = $this->stripNamespace($func['op_array']['function_name']);
     1860        if ($functionName == '{closure}') {
     1861            $functionName = '';
     1862        }
     1863        echo 'function ', $functionName, '(';
    16671864        $this->dargs($EX, $indent);
    1668         echo ")\n";
    1669         echo $indent, "{\n";
    1670         echo $body;
    1671         echo "$indent}\n";
     1865        echo ")";
     1866        if ($nobody) {
     1867            echo ";\n";
     1868        }
     1869        else {
     1870            if ($functionName !== '') {
     1871                echo "\n";
     1872                echo $indent, "{\n";
     1873            }
     1874            else {
     1875                echo " {\n";
     1876            }
     1877
     1878            echo $body;
     1879            echo "$indent}";
     1880            if ($functionName !== '') {
     1881                echo "\n";
     1882            }
     1883        }
    16721884    }
    16731885    // }}}
    16741886    function dclass($class, $indent = '') // {{{
    16751887    {
     1888        $this->detectNamespace($class['name']);
     1889
    16761890        // {{{ class decl
    16771891        if (!empty($class['doc_comment'])) {
     
    16831897        if (!empty($class['ce_flags'])) {
    16841898            if ($class['ce_flags'] & ZEND_ACC_INTERFACE) {
    1685                 echo 'interface ';
    16861899                $isinterface = true;
    16871900            }
    16881901            else {
    1689                 if ($class['ce_flags'] & ZEND_ACC_IMPLICIT_ABSTRACT) {
     1902                if ($class['ce_flags'] & ZEND_ACC_IMPLICIT_ABSTRACT_CLASS) {
    16901903                    echo "abstract ";
    16911904                }
    1692                 if ($class['ce_flags'] & ZEND_ACC_FINAL) {
     1905                if ($class['ce_flags'] & ZEND_ACC_FINAL_CLASS) {
    16931906                    echo "final ";
    16941907                }
    16951908            }
    16961909        }
    1697         echo 'class ', $class['name'];
     1910        echo $isinterface ? 'interface ' : 'class ', $this->stripNamespace($class['name']);
    16981911        if ($class['parent']) {
    16991912            echo ' extends ', $class['parent'];
     
    17171930                    echo $newindent;
    17181931                    echo $prefix, $name, ' = ';
    1719                     echo toCode(value($v), $newindent);
     1932                    echo str(value($v), $newindent);
    17201933                    echo ";\n";
    17211934                }
     
    17912004                if (isset($value)) {
    17922005                    echo ' = ';
    1793                     echo toCode(value($value), $newindent);
     2006                    echo str(value($value), $newindent);
    17942007                }
    17952008                echo ";\n";
     
    18102023                    }
    18112024                    echo $newindent;
     2025                    $isAbstractMethod = false;
    18122026                    if (isset($opa['fn_flags'])) {
    1813                         if ($opa['fn_flags'] & ZEND_ACC_ABSTRACT) {
     2027                        if (($opa['fn_flags'] & ZEND_ACC_ABSTRACT) && !$isinterface) {
    18142028                            echo "abstract ";
     2029                            $isAbstractMethod = true;
    18152030                        }
    18162031                        if ($opa['fn_flags'] & ZEND_ACC_FINAL) {
     
    18362051                        }
    18372052                    }
    1838                     $this->dfunction($func, $newindent, $isinterface);
     2053                    $this->dfunction($func, $newindent, $isinterface || $isAbstractMethod);
    18392054                    if ($opa['function_name'] == 'Decompiler') {
    18402055                        //exit;
     
    18672082    function output() // {{{
    18682083    {
    1869         echo "<?". "php\n";
     2084        echo "<?". "php\n\n";
    18702085        foreach ($this->dc['class_table'] as $key => $class) {
    18712086            if ($key{0} != "\0") {
     2087                $this->dclass($class);
    18722088                echo "\n";
    1873                 $this->dclass($class);
    18742089            }
    18752090        }
     
    18772092        foreach ($this->dc['function_table'] as $key => $func) {
    18782093            if ($key{0} != "\0") {
     2094                $this->dfunction($func);
    18792095                echo "\n";
    1880                 $this->dfunction($func);
    1881             }
    1882         }
    1883 
    1884         echo "\n";
     2096            }
     2097        }
     2098
    18852099        $this->dop_array($this->dc['op_array']);
    18862100        echo "\n?" . ">\n";
     2101
     2102        if (!empty($this->test)) {
     2103            $this->outputUnusedOp();
     2104        }
    18872105        return true;
    18882106    }
    18892107    // }}}
     2108    function outputUnusedOp() // {{{
     2109    {
     2110        for ($i = 0; $opname = xcache_get_opcode($i); $i ++) {
     2111            if ($opname == 'UNDEF')  {
     2112                continue;
     2113            }
     2114
     2115            if (!isset($this->usedOps[$i])) {
     2116                echo "not covered opcode ", $opname, "\n";
     2117            }
     2118        }
     2119    }
     2120    // }}}
    18902121}
    18912122
    18922123// {{{ defines
    1893 define('ZEND_ACC_STATIC',         0x01);
    1894 define('ZEND_ACC_ABSTRACT',       0x02);
    1895 define('ZEND_ACC_FINAL',          0x04);
    1896 define('ZEND_ACC_IMPLEMENTED_ABSTRACT',       0x08);
    1897 
    1898 define('ZEND_ACC_IMPLICIT_ABSTRACT_CLASS',    0x10);
    1899 define('ZEND_ACC_EXPLICIT_ABSTRACT_CLASS',    0x20);
    1900 define('ZEND_ACC_FINAL_CLASS',                0x40);
    1901 define('ZEND_ACC_INTERFACE',                  0x80);
    1902 define('ZEND_ACC_PUBLIC',     0x100);
    1903 define('ZEND_ACC_PROTECTED',  0x200);
    1904 define('ZEND_ACC_PRIVATE',    0x400);
    1905 define('ZEND_ACC_PPP_MASK',  (ZEND_ACC_PUBLIC | ZEND_ACC_PROTECTED | ZEND_ACC_PRIVATE));
    1906 
    1907 define('ZEND_ACC_CHANGED',    0x800);
    1908 define('ZEND_ACC_IMPLICIT_PUBLIC',    0x1000);
    1909 
    1910 define('ZEND_ACC_CTOR',       0x2000);
    1911 define('ZEND_ACC_DTOR',       0x4000);
    1912 define('ZEND_ACC_CLONE',      0x8000);
    1913 
    1914 define('ZEND_ACC_ALLOW_STATIC',   0x10000);
    1915 
    1916 define('ZEND_ACC_SHADOW', 0x2000);
    1917 
    19182124define('ZEND_ENGINE_2_4', PHP_VERSION >= "5.3.99");
    19192125define('ZEND_ENGINE_2_3', ZEND_ENGINE_2_4 || PHP_VERSION >= "5.3.");
     
    19212127define('ZEND_ENGINE_2_1', ZEND_ENGINE_2_2 || PHP_VERSION >= "5.1.");
    19222128define('ZEND_ENGINE_2',   ZEND_ENGINE_2_1 || PHP_VERSION >= "5.0.");
     2129
     2130define('ZEND_ACC_STATIC',         0x01);
     2131define('ZEND_ACC_ABSTRACT',       0x02);
     2132define('ZEND_ACC_FINAL',          0x04);
     2133define('ZEND_ACC_IMPLEMENTED_ABSTRACT',       0x08);
     2134
     2135define('ZEND_ACC_IMPLICIT_ABSTRACT_CLASS',    0x10);
     2136define('ZEND_ACC_EXPLICIT_ABSTRACT_CLASS',    0x20);
     2137define('ZEND_ACC_FINAL_CLASS',                0x40);
     2138define('ZEND_ACC_INTERFACE',                  0x80);
     2139if (ZEND_ENGINE_2_4) {
     2140    define('ZEND_ACC_TRAIT',                  0x120);
     2141}
     2142define('ZEND_ACC_PUBLIC',     0x100);
     2143define('ZEND_ACC_PROTECTED',  0x200);
     2144define('ZEND_ACC_PRIVATE',    0x400);
     2145define('ZEND_ACC_PPP_MASK',  (ZEND_ACC_PUBLIC | ZEND_ACC_PROTECTED | ZEND_ACC_PRIVATE));
     2146
     2147define('ZEND_ACC_CHANGED',    0x800);
     2148define('ZEND_ACC_IMPLICIT_PUBLIC',    0x1000);
     2149
     2150define('ZEND_ACC_CTOR',       0x2000);
     2151define('ZEND_ACC_DTOR',       0x4000);
     2152define('ZEND_ACC_CLONE',      0x8000);
     2153
     2154define('ZEND_ACC_ALLOW_STATIC',   0x10000);
     2155
     2156define('ZEND_ACC_SHADOW', 0x2000);
    19232157
    19242158if (ZEND_ENGINE_2_4) {
     
    19902224define('IS_LONG',     1);
    19912225define('IS_DOUBLE',   2);
    1992 define('IS_STRING',   3);
     2226define('IS_BOOL',     ZEND_ENGINE_2 ? 3 : 6);
    19932227define('IS_ARRAY',    4);
    19942228define('IS_OBJECT',   5);
    1995 define('IS_BOOL',     6);
     2229define('IS_STRING',   ZEND_ENGINE_2 ? 6 : 3);
    19962230define('IS_RESOURCE', 7);
    19972231define('IS_CONSTANT', 8);
     
    20192253    'XC_ASSIGN_DIM' => -1,
    20202254    'XC_UNSET_DIM' => -1,
    2021     'XC_FETCH_OBJ_' => -1,
     2255    'XC_UNSET_OBJ' => -1,
    20222256    'XC_ASSIGN_OBJ' => -1,
    20232257    'XC_ISSET_ISEMPTY_DIM_OBJ' => -1,
     
    20402274    'XC_FETCH_DIM_' => -1,
    20412275    'XC_UNSET_DIM_OBJ' => -1,
    2042     'XC_FETCH_OBJ_' => -1,
    20432276    'XC_ISSET_ISEMPTY' => -1,
    20442277    'XC_INIT_FCALL_BY_FUNC' => -1,
    20452278    'XC_DO_FCALL_BY_FUNC' => -1,
    20462279    'XC_DECLARE_FUNCTION_OR_CLASS' => -1,
     2280    'XC_INIT_NS_FCALL_BY_NAME' => -1,
     2281    'XC_GOTO' => -1,
     2282    'XC_CATCH' => -1,
     2283    'XC_THROW' => -1,
     2284    'XC_INSTANCEOF' => -1,
     2285    'XC_DECLARE_FUNCTION' => -1,
     2286    'XC_RAISE_ABSTRACT_ERROR' => -1,
     2287    'XC_DECLARE_CONST' => -1,
     2288    'XC_USER_OPCODE' => -1,
     2289    'XC_JMP_SET' => -1,
     2290    'XC_DECLARE_LAMBDA_FUNCTION' => -1,
    20472291) as $k => $v) {
    20482292    if (!defined($k)) {
     
    20502294    }
    20512295}
    2052 
    2053 /* XC_UNDEF XC_OP_DATA
    2054 $content = file_get_contents(__FILE__);
    2055 for ($i = 0; $opname = xcache_get_opcode($i); $i ++) {
    2056     if (!preg_match("/\\bXC_" . $opname . "\\b(?!')/", $content)) {
    2057         echo "not done ", $opname, "\n";
    2058     }
    2059 }
    2060 // */
    20612296// }}}
    20622297
Note: See TracChangeset for help on using the changeset viewer.