{

// {{{

var $errorToOutput = true;

var $target;

function Decompiler_Output($target)

{

$this->target = $target;

}

// }}}

var $indent = "";

function indent() // {{{

{

$this->indent .= INDENT;

}

// }}}

function outdent() // {{{

{

$this->indent = substr($this->indent, 0, -strlen(INDENT));

}

// }}}

function writeOne_($code) // {{{

{

if ($this->target == STDOUT) {

echo $code;

}

else {

fwrite($this->target, $code);

}

}

// }}}

var $writes = 0;

function write() // {{{

{

++$this->writes;

foreach (func_get_args() as $code) {

if (is_object($code)) {

$s = $code;

$code = $code->toCode($this->indent);

}

if (is_array($code)) {

call_user_func_array(array(&$this, 'write'), $code);

}

else {

$this->writeOne_((string) $code);

}

}

}

// }}}

function writeln() // {{{

{

if ($this->codeTypeCurrent != $this->codeTypeNext) {

if ($this->codeTypeCurrent && $this->codeTypeNext == 'line') {

$this->writeOne_(PHP_EOL);

}

$this->codeTypeCurrent = $this->codeTypeNext;

}

$this->writeOne_($this->indent);

$args = func_get_args();

call_user_func_array(array(&$this, 'write'), $args);

$this->writeOne_(PHP_EOL);

}

// }}}

function printfError($format) // {{{

{

$args = func_get_args();

unset($args[0]);

foreach ($args as $i => $arg) {

unset($arg);

if (is_object($args[$i])) {

$args[$i] = $args[$i]->toCode($this->indent);

}

}

$error = implode("", $args);

trigger_error($error);

if ($this->errorToOutput) {

$this->beginComment();

fwrite($this->target, $error);

$this->endComment();

}

}

// }}}

var $inComment = 0;

function beginComment() // {{{

{

if (!$this->inComment++) {

$this->writeln("/*");

}

}

// }}}

function endComment() // {{{

{

if (!--$this->inComment) {

$this->writeln("*/");

}

}

// }}}

var $scopeStack = array();

var $codeTypeCurrent = null;

var $codeTypeNext = 'line';

/*

function beginBlock_($isComplex) // {{{

{

// array_push($this->scopeStack, array($this->codeTypeCurrent, $this->codeTypeNext));

array_push($this->scopeStack, $this->codeTypeNext);

$this->codeTypeCurrent = null;

$this->codeTypeNext = $isComplex ? 'complexblock' : 'line';

}

// }}}

function endBlock_() // {{{

{

// list($this->codeTypeCurrent, $this->codeTypeNext) = array_pop($this->scopeStack);

$this->codeTypeNext = array_pop($this->scopeStack);

}

// }}}

function beginScope() // {{{

{

$this->beginBlock_(false);

$this->indent();

}

// }}}

function endScope() // {{{

{

$this->outdent();

$this->endBlock_();

}

// }}}

function beginComplexBlock() // {{{

{

if (isset($this->codeTypeCurrent)) {

$this->writeOne_(PHP_EOL);

}

$this->beginBlock_(true);

}

// }}}

function endComplexBlock() // {{{

{

$this->endBlock_();

}

// }}}

{

function Decompiler_Backtrace()

{

$this->backtrace = debug_backtrace();

array_shift($this->backtrace);

}

function toCode($indent)

{

$code = array();

foreach ($this->backtrace as $stack) {

$args = array();

foreach ($stack['args'] as $arg) {

if (is_scalar($arg)) {

$args[] = var_export($arg, true);

}

else if (is_array($arg)) {

$array = array();

foreach ($arg as $key => $value) {

$array[] = var_export($key, true) . " => " . (is_scalar($value) ? var_export($value, true) : gettype($value));

if (count($array) >= 5) {

$array[] = '...';

break;

}

}

$args[] = "array(" . implode(', ', $array) . ')';

}

else {

$args[] = gettype($arg);

}

}

$code[] = sprintf("%s%d: %s::%s(%s)" . PHP_EOL

, $indent

, $stack['line']

, isset($stack['class']) ? $stack['class'] : ''

, $stack['function']

, implode(', ', $args)

);

}

return implode("", $code);

}

{

$decompiler = &$GLOBALS['__xcache_decompiler'];

$decompiler->output->beginComment();

$decompiler->output->write(new Decompiler_Backtrace());

$decompiler->output->endComment();

{

$kind = $ast['kind'];

$children = $ast['children'];

unset($ast['kind']);

unset($ast['children']);

$decompiler = &$GLOBALS['__xcache_decompiler'];

switch ($kind) {

case ZEND_CONST:

return value($ast[0]);

case XC_INIT_ARRAY:

$array = new Decompiler_Array($decompiler);

for ($i = 0; $i < $children; $i += 2) {

if (isset($ast[$i + 1])) {

$key = decompileAst($ast[$i]);

$value = decompileAst($ast[$i + 1]);

$array->value[] = array($key, $value, '');

}

else {

$array->value[] = array(null, decompileAst($ast[$i]), '');

}

}

return $array;

// ZEND_BOOL_AND: handled in binop

// ZEND_BOOL_OR: handled in binop

case ZEND_SELECT:

return new Decompiler_TernaryOp($decompiler

, decompileAst($ast[0])

, decompileAst($ast[1])

, decompileAst($ast[2])

);

case ZEND_UNARY_PLUS:

return new Decompiler_UnaryOp($decompiler, XC_ADD, decompileAst($ast[0]));

case ZEND_UNARY_MINUS:

return new Decompiler_UnaryOp($decompiler, XC_SUB, decompileAst($ast[0]));

default:

if (isset($decompiler->binaryOp[$kind])) {

return new Decompiler_BinaryOp($decompiler

, decompileAst($ast[0])

, $kind

, decompileAst($ast[1])

);

}

return "un-handled kind $kind in zend_ast";

}

{

if (ZEND_ENGINE_2_6 && (xcache_get_type($value) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT_AST) {

return decompileAst(xcache_dasm_ast($value));

}

$decompiler = &$GLOBALS['__xcache_decompiler'];

$originalValue = xcache_get_special_value($value);

if (isset($originalValue)) {

if ((xcache_get_type($value) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT) {

// constant

return new Decompiler_Code($decompiler, $decompiler->stripNamespace($originalValue));

}

$value = $originalValue;

}

if (is_a($value, 'Decompiler_Object')) {

// use as is

}

else if (is_array($value)) {

$value = new Decompiler_ConstArray($decompiler, $value);

}

else {

if (is_scalar($value) && ($constant = $decompiler->value2constant($value)) && isset($constant)) {

$value = new Decompiler_Code($decompiler, $constant);

}

else {

$value = new Decompiler_Value($decompiler, $value);

}

}

return $value;

{

$str = is_object($str) ? $str->toCode($indent) : $str;

if (preg_match("!^'[\\w_][\\w\\d_\\\\]*'\$!", $str)) {

return str_replace('\\\\', '\\', substr($str, 1, -1));

}

else if ($asVariableName) {

return "{" . $str . "}";

}

else {

return $str;

}

{

function toCode($indent)

{

return "";

}

{

var $value;

function Decompiler_Value(&$decompiler, $value = null)

{

$this->decompiler = &$decompiler;

$this->value = $value;

}

function toCode($indent)

{

$code = var_export($this->value, true);

if (gettype($this->value) == 'string') {

$code = preg_replace_callback("![\t\r\n]+!", array(&$this, 'convertNewline'), $code);

$code = preg_replace_callback("![\\x01-\\x1f]+!", array(&$this, 'escapeString'), $code);

$code = preg_replace_callback("![\\x7f-\\xff]+!", array(&$this, 'escape8BitString'), $code);

$code = preg_replace("!^'' \\. \"|\" \\. ''\$!", '"', $code);

}

return $code;

}

function convertNewline($m)

{

return "' . \"" . strtr($m[0], array("\t" => "\\t", "\r" => "\\r", "\n" => "\\n")) . "\" . '";

}

function escape8BitString($m)

{

if (function_exists("iconv") && @iconv("UTF-8", "UTF-8//IGNORE", $m[0]) == $m[0]) {

return $m[0];

}

return $this->escapeString($m);

}

function escapeString($m)

{

$s = $m[0];

$escaped = '';

for ($i = 0, $c = strlen($s); $i < $c; ++$i) {

$escaped .= "\\x" . dechex(ord($s[$i]));

}

return "' . \"" . $escaped . "\" . '";

}

{

var $src;

function Decompiler_Code(&$decompiler, $src)

{

$this->decompiler = &$decompiler;

if (!assert('isset($src)')) {

printBacktrace();

}

$this->src = $src;

}

function toCode($indent)

{

return $this->src;

}

{

var $src;

function toCode($indent)

{

$code = array();

foreach ($this->src as $i => $src) {

if ($i) {

$code[] = ', ';

}

$code[] = $src;

}

return $code;

}

{

var $opc;

var $op;

function Decompiler_UnaryOp(&$decompiler, $opc, $op)

{

$this->decompiler = &$decompiler;

$this->opc = $opc;

$this->op = $op;

}

function toCode($indent)

{

$opstr = $this->decompiler->unaryOp[$this->opc];

if (is_a($this->op, 'Decompiler_TernaryOp') || is_a($this->op, 'Decompiler_BinaryOp') && $this->op->opc != $this->opc) {

$op = array("(", $this->op, ")");

}

else {

$op = $this->op;

}

return array($opstr, $op);

}

{

var $opc;

var $op1;

var $op2;

function Decompiler_BinaryOp(&$decompiler, $op1, $opc, $op2)

{

$this->decompiler = &$decompiler;

$this->opc = $opc;

$this->op1 = $op1;

$this->op2 = $op2;

}

function toCode($indent)

{

$opstr = $this->decompiler->binaryOp[$this->opc];

if (is_a($this->op1, 'Decompiler_TernaryOp') || is_a($this->op1, 'Decompiler_BinaryOp') && $this->op1->opc != $this->opc) {

$op1 = array("(", $this->op1, ")");

}

else {

$op1 = $this->op1;

}

if (is_a($this->op2, 'Decompiler_TernaryOp') || is_a($this->op2, 'Decompiler_BinaryOp') && $this->op2->opc != $this->opc && substr($opstr, -1) != '=') {

$op2 = array("(", $this->op2, ")");

}

else {

$op2 = $this->op2;

}

if (is_a($op1, 'Decompiler_Value') && $op1->value == '0' && ($this->opc == XC_ADD || $this->opc == XC_SUB)) {

$unaryOp = new Decompiler_UnaryOp($this->decompiler, $this->opc, $op2);

return $unaryOp->toCode($indent);

}

return array($op1, ' ', $opstr, ($this->opc == XC_ASSIGN_REF ? '' : ' '), $op2);

}

{

var $condition;

var $trueValue;

var $falseValue;

function Decompiler_TernaryOp(&$decompiler, $condition, $trueValue, $falseValue)

{

$this->decompiler = &$decompiler;

$this->condition = $condition;

$this->trueValue = $trueValue;

$this->falseValue = $falseValue;

}

function toCode($indent)

{

$trueValue = $this->trueValue;

if (is_a($this->trueValue, 'Decompiler_TernaryOp')) {

$trueValue = array("(", $trueValue, ")");

}

$falseValue = $this->falseValue;

if (is_a($this->falseValue, 'Decompiler_TernaryOp')) {

$falseValue = array("(", $falseValue, ")");

}

return array($this->condition, ' ? ', $trueValue, ' : ', $falseValue);

}

{

var $fetchType;

var $name;

var $scope;

function Decompiler_Fetch(&$decompiler, $scope, $name, $type)

{

$this->decompiler = &$decompiler;

$this->scope = $scope;

$this->name = $name;

unset($this->src);

$this->fetchType = $type;

}

function toCode($indent)

{

switch ($this->fetchType) {

case XC_FETCH_PROPERTY:

return array($this->scope, '->', $this->name);

case ZEND_FETCH_STATIC_MEMBER:

return array($this->scope, '::$', $this->name);

case ZEND_FETCH_LOCAL:

return array('$', $this->name);

case ZEND_FETCH_STATIC:

if (ZEND_ENGINE_2_3) {

// closure local variable?

return 'STR' . $this->name;

}

else {

return value($this->name);

}

die('static fetch cant to string');

case ZEND_FETCH_GLOBAL:

case ZEND_FETCH_GLOBAL_LOCK:

return xcache_is_autoglobal($this->name) ? array('$', $this->name) : array("\$GLOBALS[", value($this->name), "]");

default:

var_dump($this->fetchType);

assert(0);

}

}

{

var $obj;

function Decompiler_Box(&$decompiler, &$obj)

{

$this->decompiler = &$decompiler;

$this->obj = &$obj;

}

function toCode($indent)

{

return $this->obj->toCode($indent);

}

{

var $offsets = array();

var $isLast = false;

var $isObject = false;

var $assign = null;

function toCode($indent)

{

if (is_a($this->value, 'Decompiler_ListBox')) {

$exp = array($this->value->obj->src);

}

else {

$exp = array($this->value);

}

$last = count($this->offsets) - 1;

foreach ($this->offsets as $i => $dim) {

if ($this->isObject && $i == $last) {

$exp[] = '->';

$exp[] = unquoteVariableName($dim, $indent);

}

else {

$exp[] = '[';

$exp[] = $dim;

$exp[] = ']';

}

}

return $exp;

}

{

var $src;

var $dims = array();

var $everLocked = false;

function toCode($indent)

{

if (count($this->dims) == 1 && !$this->everLocked) {

$dim = $this->dims[0];

unset($dim->value);

$dim->value = $this->src;

if (!isset($dim->assign)) {

return $dim;

}

return array($this->dims[0]->assign, ' = ', $dim);

}

/* flatten dims */

$assigns = array();

foreach ($this->dims as $dim) {

$assign = &$assigns;

foreach ($dim->offsets as $offset) {

$assign = &$assign[$offset];

}

$assign = $dim->assign;

}

return array($this->toList($assigns), ' = ', $this->src);

}

function toList($assigns)

{

$keys = array_keys($assigns);

if (count($keys) < 2) {

$keys[] = 0;

}

$max = call_user_func_array('max', $keys);

$code = array("list(");

for ($i = 0; $i <= $max; $i++) {

if ($i) {

$code[] = ', ';

}

if (!isset($assigns[$i])) {

continue;

}

if (is_array($assigns[$i])) {

$code[] = $this->toList($assigns[$i]);

}

else {

$code[] = $assigns[$i];

}

}

$code[] = ')';

return $code;

}

{

// elements

function Decompiler_Array(&$decompiler)

{

$this->decompiler = &$decompiler;

$this->value = array();

}

function toCode($indent)

{

$subindent = $indent . INDENT;

$elementsCode = array();

$index = 0;

foreach ($this->value as $element) {

$key = $element[0];

if (isset($key)) {

$key = value($key);

$keyCode = $key->toCode($subindent);

}

else {

$keyCode = $index++;

}

$element[0] = $keyCode;

$elementsCode[] = $element;

}

$code = array("array(");

$indent = $indent . INDENT;

$assocWidth = 0;

$multiline = 0;

$i = 0;

foreach ($elementsCode as $element) {

$keyCode = $element[0];

if (is_array($keyCode) || (string) $i !== (string) $keyCode) {

$assocWidth = 1;

break;

}

++$i;

}

foreach ($elementsCode as $element) {

list($keyCode, $value) = $element;

if ($assocWidth && !is_array($keyCode)) {

$len = strlen($keyCode);

if ($assocWidth < $len) {

$assocWidth = $len;

}

}

if (is_array($value) || is_a($value, 'Decompiler_Array')) {

$multiline++;

}

}

$i = 0;

foreach ($elementsCode as $element) {

list($keyCode, $value, $ref) = $element;

if ($multiline) {

if ($i) {

$code[] = ",";

}

$code[] = PHP_EOL;

$code[] = $indent;

}

else {

if ($i) {

$code[] = ", ";

}

}

if ($assocWidth) {

if ($multiline && !is_array($keyCode)) {

$code[] = sprintf("%-{$assocWidth}s => ", $keyCode);

}

else {

$code[] = $keyCode;

$code[] = ' => ';

}

}

$code[] = $ref;

$value = value($value);

$code[] = $value->toCode($subindent);

$i++;

}

if ($multiline) {

$code[] = PHP_EOL . "$indent)";

}

else {

$code[] = ")";

}

return $code;

}

{

function Decompiler_ConstArray(&$decompiler, $array)

{

$this->decompiler = &$decompiler;

$elements = array();

foreach ($array as $key => $value) {

if ((xcache_get_type($value) & IS_CONSTANT_INDEX)) {

$keyCode = new Decompiler_Code($this, $GLOBALS['__xcache_decompiler']->stripNamespace(

ZEND_ENGINE_2_3

? substr($key, 0, -2)

: $key

));

}

else {

$keyCode = $key;

}

$elements[] = array($keyCode, value($value), '');

}

$this->value = $elements;

}

{

var $iskey;

function toCode($indent)

{

return '#foreachBox#';

}

{

$this->outputPhp = in_array('php', $outputTypes);

$this->outputOpcode = in_array('opcode', $outputTypes);

$this->output = new Decompiler_Output(STDOUT);

$GLOBALS['__xcache_decompiler'] = $this;

// {{{ testing

// XC_UNDEF XC_OP_DATA

$this->test = !empty($_ENV['XCACHE_DECOMPILER_TEST']);

$this->usedOps = array();

if ($this->test) {

$content = file_get_contents(__FILE__);

for ($i = 0; $opname = xcache_get_opcode($i); $i++) {

if (!preg_match("/\\bXC_" . $opname . "\\b(?!')/", $content)) {

echo "not recognized opcode ", $opname, PHP_EOL;

}

}

}

// }}}

// {{{ opinfo

$this->unaryOp = array(

XC_BW_NOT => '~',

XC_BOOL_NOT => '!',

XC_ADD => "+",

XC_SUB => "-",

XC_NEW => "new ",

XC_THROW => "throw ",

XC_CLONE => "clone ",

);

$this->binaryOp = 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_POW => "**",

XC_ASSIGN_POW => "*=",

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",

XC_ASSIGN => "=",

XC_ASSIGN_DIM => "=",

XC_ASSIGN_OBJ => "=",

XC_ASSIGN_REF => "= &",

XC_JMP_SET => "?:",

XC_JMP_SET_VAR => "?:",

XC_JMPZ_EX => "&&",

XC_JMPNZ_EX => "||",

XC_INSTANCEOF => "instanceof",

);

if (defined('IS_CONSTANT_AST')) {

$this->binaryOp[ZEND_BOOL_AND] = '&&';

$this->binaryOp[ZEND_BOOL_OR] = '||';

}

// }}}

$this->includeTypes = array( // {{{

ZEND_EVAL => 'eval',

ZEND_INCLUDE => 'include',

ZEND_INCLUDE_ONCE => 'include_once',

ZEND_REQUIRE => 'require',

ZEND_REQUIRE_ONCE => 'require_once',

);

// }}}

{

if ($this->namespaceDecided) {

return;

}

if (strpos($name, '\\') !== false) {

$namespace = strtok($name, '\\');

if ($namespace == $this->namespace) {

return;

}

$this->namespace = $namespace;

$this->output->beginComplexBlock();

$this->output->writeln('namespace ', $this->namespace, ";");

$this->output->endComplexBlock();

}

$this->namespaceDecided = true;

{

if (!isset($name)) {

return $name;

}

$len = strlen($this->namespace) + 1;

if (!is_string($name)) {

printBacktrace();

exit;

}

if (strncasecmp($name, $this->namespace . '\\', $len) == 0) {

return substr($name, $len);

}

else {

return $name;

}

{

if (isset($this->EX) && isset($this->EX['value2constant'][$value])) {

return $this->EX['value2constant'][$value];

}

else if (isset($this->value2constant[$value])) {

return $this->value2constant[$value];

}

{

$curticks = 0;

for ($i = $range[0]; $i <= $range[1]; $i++) {

$op = $this->EX['opcodes'][$i];

if (isset($op['gofrom'])) {

$this->output->beginComplexBlock();

echo 'label' . $i, ":", PHP_EOL;

$this->output->endComplexBlock();

}

if (isset($op['php'])) {

$toticks = isset($op['ticks']) ? (int) $op['ticks'] : 0;

if ($curticks != $toticks) {

if ($curticks) {

$this->output->endScope();

$this->output->writeln("}");

$this->output->endComplexBlock();

}

$curticks = $toticks;

if ($curticks) {

$this->output->beginComplexBlock();

$this->output->writeln("declare (ticks=$curticks) {");

$this->output->beginScope();

}

}

$this->output->writeln($op['php'], ';');

unset($op['php']);

}

}

if ($curticks) {

$this->output->endScope();

$this->output->writeln("}");