root/tags/1.0.2/Decompiler.class.php

<?php

define('INDENT', "\t");
ini_set('error_reporting', E_ALL);

function color($str, $color = 33)
{
    return "\x1B[{$color}m$str\x1B[0m";
}

function str($src, $indent = '') // {{{
{
    if (is_array($indent)) {
        $indent = $indent['indent'];
    }

    /*
    $e = xcache_get_special_value($src);
    if (isset($e)) {
        if (is_array($e)) {
            $src = $e;
        }
        else {
            return $e;
        }
    }
    */

    if (is_array($src)) {
        die_error('array str');
        $src = new Decompiler_Array($src);
        return $src->__toString($indent);
    }

    if (is_object($src)) {
        if (!method_exists($src, '__toString')) {
            var_dump($src);
            die_error('no __toString');
        }
        return $src->__toString($indent);
    }

    return $src;
}
// }}}
function value($value) // {{{
{
    $spec = xcache_get_special_value($value);
    if (isset($spec)) {
        $value = $spec;
        if (!is_array($value)) {
            // constant
            return $value;
        }
    }

    if (is_array($value)) {
        $value = new Decompiler_Array($value, true);
    }
    else {
        $value = new Decompiler_Value($value, true);
    }
    return $value;
}
// }}}
class Decompiler_Object // {{{
{
}
// }}}
class Decompiler_Value extends Decompiler_Object // {{{
{
    var $value;

    function Decompiler_Value($value = null)
    {
        $this->value = $value;
    }

    function __toString()
    {
        return var_export($this->value, true);
    }
}
// }}}
class Decompiler_Code extends Decompiler_Object // {{{
{
    var $src;

    function Decompiler_Code($src)
    {
        $this->src = $src;
    }

    function __toString()
    {
        return $this->src;
    }
}
// }}}
class Decompiler_Binop extends Decompiler_Code // {{{
{
    var $opc;
    var $op1;
    var $op2;
    var $parent;

    function Decompiler_Binop($parent, $op1, $opc, $op2)
    {
        $this->parent = &$parent;
        $this->opc = $opc;
        $this->op1 = $op1;
        $this->op2 = $op2;
    }

    function __toString()
    {
        $op1 = str($this->op1);
        if (is_a($this->op1, 'Decompiler_Binop') && $this->op1->opc != $this->opc) {
            $op1 = "($op1)";
        }
        $opstr = $this->parent->binops[$this->opc];
        if ($op1 == '0' && $this->opc == XC_SUB) {
            return $opstr . str($this->op2);
        }
        return $op1 . ' ' . $opstr . ' ' . str($this->op2);
    }
}
// }}}
class Decompiler_Fetch extends Decompiler_Code // {{{
{
    var $src;
    var $fetchType;

    function Decompiler_Fetch($src, $type, $globalsrc)
    {
        $this->src = $src;
        $this->fetchType = $type;
        $this->globalsrc = $globalsrc;
    }

    function __toString()
    {
        switch ($this->fetchType) {
        case ZEND_FETCH_LOCAL:
            return '$' . substr($this->src, 1, -1);
        case ZEND_FETCH_STATIC:
            die('static fetch cant to string');
        case ZEND_FETCH_GLOBAL:
        case ZEND_FETCH_GLOBAL_LOCK:
            return $this->globalsrc;
        default:
            var_dump($this->fetchType);
            assert(0);
        }
    }
}
// }}}
class Decompiler_Box // {{{
{
    var $obj;

    function Decompiler_Box(&$obj)
    {
        $this->obj = &$obj;
    }

    function __toString($indent)
    {
        return $this->obj->__toString($indent);
    }
}
// }}}
class Decompiler_Dim extends Decompiler_Value // {{{
{
    var $offsets = array();
    var $isLast = false;
    var $assign = null;

    function __toString()
    {
        if (is_a($this->value, 'Decompiler_ListBox')) {
            $exp = str($this->value->obj->src);
        }
        else {
            $exp = str($this->value);
        }
        foreach ($this->offsets as $dim) {
            $exp .= '[' . str($dim) . ']';
        }
        return $exp;
    }
}
// }}}
class Decompiler_DimBox extends Decompiler_Box // {{{
{
}
// }}}
class Decompiler_List extends Decompiler_Code // {{{
{
    var $src;
    var $dims = array();
    var $everLocked = false;

    function __toString()
    {
        if (count($this->dims) == 1 && !$this->everLocked) {
            $dim = $this->dims[0];
            unset($dim->value);
            $dim->value = $this->src;
            if (!isset($dim->assign)) {
                return str($dim);
            }
            return str($this->dims[0]->assign) . ' = ' . str($dim);
        }
        /* flatten dims */
        $assigns = array();
        foreach ($this->dims as $dim) {
            $assign = &$assigns;
            foreach ($dim->offsets as $offset) {
                $assign = &$assign[$offset];
            }
            $assign = str($dim->assign);
        }
        return $this->toList($assigns) . ' = ' . str($this->src);
    }

    function toList($assigns)
    {
        $keys = array_keys($assigns);
        if (count($keys) < 2) {
            $keys[] = 0;
        }
        $max = call_user_func_array('max', $keys);
        $list = 'list(';
        for ($i = 0; $i <= $max; $i ++) {
            if ($i) {
                $list .= ', ';
            }
            if (!isset($assigns[$i])) {
                continue;
            }
            if (is_array($assigns[$i])) {
                $list .= $this->toList($assigns[$i]);
            }
            else {
                $list .= $assigns[$i];
            }
        }
        return $list . ')';
    }
}
// }}}
class Decompiler_ListBox extends Decompiler_Box // {{{
{
}
// }}}
class Decompiler_Array extends Decompiler_Value // {{{
{
    var $needExport = false;

    function Decompiler_Array($value = array(), $needexport = false)
    {
        $this->value = $value;
        $this->needExport = $needexport;
    }

    function __toString($indent)
    {
        $exp = "array(";
        $indent .= INDENT;
        $assoclen = 0;
        $multiline = 0;
        $i = 0;
        foreach ($this->value as $k => $v) {
            if ($i !== $k) {
                $len = strlen($k);
                if ($assoclen < $len) {
                    $assoclen = $len;
                }
            }
            if (is_array($v)) {
                $multiline ++;
            }
            ++ $i;
        }
        if ($assoclen && $this->needExport) {
            $assoclen += 2;
        }

        $i = 0;
        $subindent = $indent . INDENT;
        foreach ($this->value as $k => $v) {
            if ($multiline) {
                if ($i) {
                    $exp .= ",";
                }
                $exp .= "\n";
                $exp .= $indent;
            }
            else {
                if ($i) {
                    $exp .= ", ";
                }
            }

            if ($this->needExport) {
                $k = var_export($k, true);
            }
            if ($multiline) {
                $exp .= sprintf("%{$assoclen}s => ", $k);
            }
            else if ($assoclen) {
                $exp .= $k . ' => ';
            }

            if (is_array($v)) {
                $v = new Decompiler_Array($v, $this->needExport);
            }
            $exp .= str($v, $subindent);

            $i ++;
        }
        if ($multiline) {
            $exp .= "$indent);";
        }
        else {
            $exp .= ")";
        }
        return $exp;
    }
}
// }}}
class Decompiler_ForeachBox extends Decompiler_Box // {{{
{
    var $iskey;

    function __toString($indent)
    {
        return 'foreach (' . '';
    }
}
// }}}

class Decompiler
{
    var $rName = '!^[\\w_][\\w\\d_]*$!';
    var $rQuotedName = "!^'[\\w_][\\w\\d_]*'\$!";

    function Decompiler()
    {
        // {{{ opinfo
        $this->unaryops = array(
                XC_BW_NOT   => '~',
                XC_BOOL_NOT => '!',
                );
        $this->binops = array(
                XC_ADD                 => "+",
                XC_ASSIGN_ADD          => "+=",
                XC_SUB                 => "-",
                XC_ASSIGN_SUB          => "-=",
                XC_MUL                 => "*",
                XC_ASSIGN_MUL          => "*=",
                XC_DIV                 => "/",
                XC_ASSIGN_DIV          => "/=",
                XC_MOD                 => "%",
                XC_ASSIGN_MOD          => "%=",
                XC_SL                  => "<<",
                XC_ASSIGN_SL           => "<<=",
                XC_SR                  => ">>",
                XC_ASSIGN_SR           => ">>=",
                XC_CONCAT              => ".",
                XC_ASSIGN_CONCAT       => ".=",
                XC_IS_IDENTICAL        => "===",
                XC_IS_NOT_IDENTICAL    => "!==",
                XC_IS_EQUAL            => "==",
                XC_IS_NOT_EQUAL        => "!=",
                XC_IS_SMALLER          => "<",
                XC_IS_SMALLER_OR_EQUAL => "<=",
                XC_BW_OR               => "|",
                XC_ASSIGN_BW_OR        => "|=",
                XC_BW_AND              => "&",
                XC_ASSIGN_BW_AND       => "&=",
                XC_BW_XOR              => "^",
                XC_ASSIGN_BW_XOR       => "^=",
                XC_BOOL_XOR            => "xor",
                );
        // }}}
        $this->includeTypes = array( // {{{
                ZEND_EVAL         => 'eval',
                ZEND_INCLUDE      => 'include',
                ZEND_INCLUDE_ONCE => 'include_once',
                ZEND_REQUIRE      => 'require',
                ZEND_REQUIRE_ONCE => 'require_once',
                );
                // }}}
    }
    function outputPhp(&$opcodes, $opline, $last, $indent) // {{{
    {
        $origindent = $indent;
        $curticks = 0;
        for ($i = $opline; $i <= $last; $i ++) {
            $op = $opcodes[$i];
            if (isset($op['php'])) {
                $toticks = isset($op['ticks']) ? $op['ticks'] : 0;
                if ($curticks != $toticks) {
                    if (!$toticks) {
                        echo $origindent, "}\n";
                        $indent = $origindent;
                    }
                    else {
                        if ($curticks) {
                            echo $origindent, "}\n";
                        }
                        else if (!$curticks) {
                            $indent .= INDENT;
                        }
                        echo $origindent, "declare(ticks=$curticks) {\n";
                    }
                    $curticks = $toticks;
                }
                echo $indent, str($op['php']), ";\n";
            }
        }
        if ($curticks) {
            echo $origindent, "}\n";
        }
    }
    // }}}
    function getOpVal($op, &$EX, $tostr = true, $free = false) // {{{
    {
        switch ($op['op_type']) {
        case XC_IS_CONST:
            return str(value($op['u.constant']));

        case XC_IS_VAR:
        case XC_IS_TMP_VAR:
            $T = &$EX['Ts'];
            $ret = $T[$op['u.var']];
            if ($tostr) {
                $ret = str($ret, $EX);
            }
            if ($free) {
                unset($T[$op['u.var']]);
            }
            return $ret;

        case XC_IS_CV:
            $var = $op['u.var'];
            $var = $EX['op_array']['vars'][$var];
            return '$' . $var['name'];

        case XC_IS_UNUSED:
            return null;
        }
    }
    // }}}
    function &dop_array($op_array, $indent = '') // {{{
    {
        $opcodes = &$op_array['opcodes'];
        $last = count($opcodes) - 1;
        if ($opcodes[$last]['opcode'] == XC_HANDLE_EXCEPTION) {
            unset($opcodes[$last]);
        }
        $EX['indent'] = '';
        //for ($i = 0, $cnt = count($opcodes); $i < $cnt; $i ++) {
        //  $opcodes[$i]['opcode'] = xcache_get_fixed_opcode($opcodes[$i]['opcode'], $i);
        //}
        // {{{ build jmp array
        for ($i = 0, $cnt = count($opcodes); $i < $cnt; $i ++) {
            $op = &$opcodes[$i];
            /*
            if ($op['opcode'] == XC_JMPZ) {
                $this->dumpop($op, $EX);
                var_dump($op);
            }
            continue;
            */
            $op['line'] = $i;
            switch ($op['opcode']) {
            case XC_JMP:
                $target = $op['op1']['u.var'];
                $op['jmpouts'] = array($target);
                $opcodes[$target]['jmpins'][] = $i;
                break;

            case XC_JMPZNZ:
                $jmpz = $op['op2']['u.opline_num'];
                $jmpnz = $op['extended_value'];
                $op['jmpouts'] = array($jmpz, $jmpnz);
                $opcodes[$jmpz]['jmpins'][] = $i;
                $opcodes[$jmpnz]['jmpins'][] = $i;
                break;

            case XC_JMPZ:
            case XC_JMPNZ:
            case XC_JMPZ_EX:
            case XC_JMPNZ_EX:
            // case XC_FE_RESET:
            case XC_FE_FETCH:
            // case XC_JMP_NO_CTOR:
                $target = $op['op2']['u.opline_num'];
                //if (!isset($target)) {
                //  $this->dumpop($op, $EX);
                //  var_dump($op); exit;
                //}
                $op['jmpouts'] = array($target);
                $opcodes[$target]['jmpins'][] = $i;
                break;

            /*
            case XC_RETURN:
                $op['jmpouts'] = array();
                break;
            */
            }
        }
        unset($op);
        // }}}
        // build semi-basic blocks
        $nextbbs = array();
        $starti = 0;
        for ($i = 1, $cnt = count($opcodes); $i < $cnt; $i ++) {
            if (isset($opcodes[$i]['jmpins'])
             || isset($opcodes[$i - 1]['jmpouts'])) {
                $nextbbs[$starti] = $i;
                $starti = $i;
            }
        }
        $nextbbs[$starti] = $cnt;

        $EX = array();
        $EX['Ts'] = array();
        $EX['indent'] = $indent;
        $EX['nextbbs'] = $nextbbs;
        $EX['op_array'] = &$op_array;
        $EX['opcodes'] = &$opcodes;
        // func call
        $EX['object'] = null;
        $EX['fbc'] = null;
        $EX['argstack'] = array();
        $EX['arg_types_stack'] = array();
        $EX['last'] = count($opcodes) - 1;
        $EX['silence'] = 0;

        for ($next = 0, $last = $EX['last'];
                $loop = $this->outputCode($EX, $next, $last, $indent, true);
                list($next, $last) = $loop) {
            // empty
        }
        return $EX;
    }
    // }}}
    function outputCode(&$EX, $opline, $last, $indent, $loop = false) // {{{
    {
        $op = &$EX['opcodes'][$opline];
        $next = $EX['nextbbs'][$opline];

        $end = $next - 1;
        if ($end > $last) {
            $end = $last;
        }

        if (isset($op['jmpins'])) {
            echo "\nline", $op['line'], ":\n";
        }
        else {
            // echo ";;;\n";
        }
        $this->dasmBasicBlock($EX, $opline, $end);
        $this->outputPhp($EX['opcodes'], $opline, $end, $indent);
        // jmpout op
        $op = &$EX['opcodes'][$end];
        $op1 = $op['op1'];
        $op2 = $op['op2'];
        $ext = $op['extended_value'];
        $line = $op['line'];

        if (isset($EX['opcodes'][$next])) {
            if (isset($last) && $next > $last) {
                $next = null;
            }
        }
        else {
            $next = null;
        }
        if ($op['opcode'] == XC_FE_FETCH) {
            $opline = $next;
            $next = $op['op2']['u.opline_num'];
            $end = $next - 1;

            ob_start();
            $this->outputCode($EX, $opline, $end /* - 1 skip last jmp */, $indent . INDENT);
            $body = ob_get_clean();

            $as = str($op['fe_as']);
            if (isset($op['fe_key'])) {
                $as = str($op['fe_key']) . ' => ' . $as;
            }
            echo "{$indent}foreach (" . str($op['fe_src']) . " as $as) {\n";
            echo $body;
            echo "{$indent}}";
            // $this->outputCode($EX, $next, $last, $indent);
            // return;
        }
        /*
        if ($op['opcode'] == XC_JMPZ) {
            $target = $op2['u.opline_num'];
            if ($line + 1) {
                $nextblock = $EX['nextbbs'][$next];
                $jmpop = end($nextblock);
                if ($jmpop['opcode'] == XC_JMP) {
                    $ifendline = $op2['u.opline_num'];
                    if ($ifendline >= $line) {
                        $cond = $op['cond'];
                        echo "{$indent}if ($cond) {\n";
                        $this->outputCode($EX, $next, $last, INDENT . $indent);
                        echo "$indent}\n";
                        $this->outputCode($EX, $target, $last, $indent);
                        return;
                    }
                }
            }
        }
        */
        if (!isset($next)) {
            return;
        }
        if (!empty($op['jmpouts']) && isset($op['isjmp'])) {
            if (isset($op['cond'])) {
                echo "{$indent}check ($op[cond]) {\n";
                echo INDENT;
            }
            echo $indent;
            echo xcache_get_opcode($op['opcode']), ' line', $op['jmpouts'][0];
            if (isset($op['jmpouts'][1])) {
                echo ', line', $op['jmpouts'][1];
            }
            echo ";";
            // echo ' // <- line', $op['line'];
            echo "\n";
            if (isset($op['cond'])) echo "$indent}\n";
        }

        // proces JMPZ_EX/JMPNZ_EX for AND,OR
        $op = &$EX['opcodes'][$next];
        /*
        if (isset($op['jmpins'])) {
            foreach (array_reverse($op['jmpins']) as $fromline) {
                $fromop = $EX['opcodes'][$fromline];
                switch ($fromop['opcode']) {
                case XC_JMPZ_EX: $opstr = 'and'; break;
                case XC_JMPNZ_EX: $opstr = 'or'; break;
                case XC_JMPZNZ: var_dump($fromop); exit;
                default: continue 2;