Context Navigation

source: svn/trunk/lib/Decompiler.class.php @ 1296

Last change on this file since 1296 was 1296, checked in by Xuefer, 5 years ago
Decompiler: remove PHP 4 support. adds XC_QM_ASSIGN_VAR
Property svn:eol-style set to `native`
File size: 70.6 KB

Line
1	<?php
2
3	define('INDENT', "\t");
4	ini_set('error_reporting', E_ALL);
5
6	function color($str, $color = 33)
7	{
8	return "\x1B[{$color}m$str\x1B[0m";
9	}
10
11	function str($code, $indent = '') // {{{
12	{
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	}
20	if (is_object($code)) {
21	$code = foldToCode($code, $indent);
22	return $code->toCode($indent);
23	}
24
25	return (string) $code;
26	}
27	// }}}
28	function foldToCode($src, $indent = '') // {{{ wrap or rewrap anything to Decompiler_Code
29	{
30	if (is_array($indent)) {
31	$indent = $indent['indent'];
32	}
33
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;
48	}
49	// }}}
50	function value($value) // {{{
51	{
52	$spec = xcache_get_special_value($value);
53	if (isset($spec)) {
54	$value = $spec;
55	if (!is_array($value)) {
56	// constant
57	return $value;
58	}
59	}
60
61	if (is_a($value, 'Decompiler_Object')) {
62	// use as is
63	}
64	else if (is_array($value)) {
65	$value = new Decompiler_ConstArray($value);
66	}
67	else {
68	$value = new Decompiler_Value($value);
69	}
70	return $value;
71	}
72	// }}}
73	function 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	// }}}
87	function unquoteVariableName($str, $indent = '') // {{{
88	{
89	return unquoteName_($str, true, $indent);
90	}
91	// }}}
92	function unquoteName($str, $indent = '') // {{{
93	{
94	return unquoteName_($str, false, $indent);
95	}
96	// }}}
97	class Decompiler_Object // {{{
98	{
99	}
100	// }}}
101	class Decompiler_Value extends Decompiler_Object // {{{
102	{
103	var $value;
104
105	function Decompiler_Value($value = null)
106	{
107	$this->value = $value;
108	}
109
110	function toCode($indent)
111	{
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;
127	}
128	}
129	// }}}
130	class Decompiler_Code extends Decompiler_Object // {{{
131	{
132	var $src;
133
134	function Decompiler_Code($src)
135	{
136	assert('isset($src)');
137	$this->src = $src;
138	}
139
140	function toCode($indent)
141	{
142	return $this->src;
143	}
144	}
145	// }}}
146	class Decompiler_Binop extends Decompiler_Code // {{{
147	{
148	var $opc;
149	var $op1;
150	var $op2;
151	var $parent;
152
153	function Decompiler_Binop($parent, $op1, $opc, $op2)
154	{
155	$this->parent = &$parent;
156	$this->opc = $opc;
157	$this->op1 = $op1;
158	$this->op2 = $op2;
159	}
160
161	function toCode($indent)
162	{
163	$opstr = $this->parent->binops[$this->opc];
164
165	if (is_a($this->op1, 'Decompiler_TriOp') \|\| is_a($this->op1, 'Decompiler_Binop') && $this->op1->opc != $this->opc) {
166	$op1 = "(" . str($this->op1, $indent) . ")";
167	}
168	else {
169	$op1 = $this->op1;
170	}
171
172	if (is_a($this->op2, 'Decompiler_TriOp') \|\| is_a($this->op2, 'Decompiler_Binop') && $this->op2->opc != $this->opc && substr($opstr, -1) != '=') {
173	$op2 = "(" . str($this->op2, $indent) . ")";
174	}
175	else {
176	$op2 = $this->op2;
177	}
178
179	if (str($op1) == '0' && ($this->opc == XC_ADD \|\| $this->opc == XC_SUB)) {
180	return $opstr . str($op2, $indent);
181	}
182
183	return str($op1, $indent) . ' ' . $opstr . ($this->opc == XC_ASSIGN_REF ? '' : ' ') . str($op2, $indent);
184	}
185	}
186	// }}}
187	class Decompiler_TriOp extends Decompiler_Code // {{{
188	{
189	var $condition;
190	var $trueValue;
191	var $falseValue;
192
193	function Decompiler_TriOp($condition, $trueValue, $falseValue)
194	{
195	$this->condition = $condition;
196	$this->trueValue = $trueValue;
197	$this->falseValue = $falseValue;
198	}
199
200	function toCode($indent)
201	{
202	$trueValue = $this->trueValue;
203	if (is_a($this->trueValue, 'Decompiler_TriOp')) {
204	$trueValue = "(" . str($trueValue, $indent) . ")";
205	}
206	$falseValue = $this->falseValue;
207	if (is_a($this->falseValue, 'Decompiler_TriOp')) {
208	$falseValue = "(" . str($falseValue, $indent) . ")";
209	}
210
211	return str($this->condition) . ' ? ' . str($trueValue) . ' : ' . str($falseValue);
212	}
213	}
214	// }}}
215	class Decompiler_Fetch extends Decompiler_Code // {{{
216	{
217	var $src;
218	var $fetchType;
219
220	function Decompiler_Fetch($src, $type, $globalsrc)
221	{
222	$this->src = $src;
223	$this->fetchType = $type;
224	$this->globalsrc = $globalsrc;
225	}
226
227	function toCode($indent)
228	{
229	switch ($this->fetchType) {
230	case ZEND_FETCH_LOCAL:
231	return '$' . substr($this->src, 1, -1);
232	case ZEND_FETCH_STATIC:
233	if (ZEND_ENGINE_2_3) {
234	// closure local variable?
235	return str($this->src);
236	}
237	die('static fetch cant to string');
238	case ZEND_FETCH_GLOBAL:
239	case ZEND_FETCH_GLOBAL_LOCK:
240	return $this->globalsrc;
241	default:
242	var_dump($this->fetchType);
243	assert(0);
244	}
245	}
246	}
247	// }}}
248	class Decompiler_Box // {{{
249	{
250	var $obj;
251
252	function Decompiler_Box(&$obj)
253	{
254	$this->obj = &$obj;
255	}
256
257	function toCode($indent)
258	{
259	return $this->obj->toCode($indent);
260	}
261	}
262	// }}}
263	class Decompiler_Dim extends Decompiler_Value // {{{
264	{
265	var $offsets = array();
266	var $isLast = false;
267	var $isObject = false;
268	var $assign = null;
269
270	function toCode($indent)
271	{
272	if (is_a($this->value, 'Decompiler_ListBox')) {
273	$exp = str($this->value->obj->src, $indent);
274	}
275	else {
276	$exp = str($this->value, $indent);
277	}
278	$last = count($this->offsets) - 1;
279	foreach ($this->offsets as $i => $dim) {
280	if ($this->isObject && $i == $last) {
281	$exp .= '->' . unquoteVariableName($dim, $indent);
282	}
283	else {
284	$exp .= '[' . str($dim, $indent) . ']';
285	}
286	}
287	return $exp;
288	}
289	}
290	// }}}
291	class Decompiler_DimBox extends Decompiler_Box // {{{
292	{
293	}
294	// }}}
295	class Decompiler_List extends Decompiler_Code // {{{
296	{
297	var $src;
298	var $dims = array();
299	var $everLocked = false;
300
301	function toCode($indent)
302	{
303	if (count($this->dims) == 1 && !$this->everLocked) {
304	$dim = $this->dims[0];
305	unset($dim->value);
306	$dim->value = $this->src;
307	if (!isset($dim->assign)) {
308	return str($dim, $indent);
309	}
310	return str($this->dims[0]->assign, $indent) . ' = ' . str($dim, $indent);
311	}
312	/* flatten dims */
313	$assigns = array();
314	foreach ($this->dims as $dim) {
315	$assign = &$assigns;
316	foreach ($dim->offsets as $offset) {
317	$assign = &$assign[$offset];
318	}
319	$assign = foldToCode($dim->assign, $indent);
320	}
321	return str($this->toList($assigns)) . ' = ' . str($this->src, $indent);
322	}
323
324	function toList($assigns)
325	{
326	$keys = array_keys($assigns);
327	if (count($keys) < 2) {
328	$keys[] = 0;
329	}
330	$max = call_user_func_array('max', $keys);
331	$list = 'list(';
332	for ($i = 0; $i <= $max; $i ++) {
333	if ($i) {
334	$list .= ', ';
335	}
336	if (!isset($assigns[$i])) {
337	continue;
338	}
339	if (is_array($assigns[$i])) {
340	$list .= $this->toList($assigns[$i]);
341	}
342	else {
343	$list .= $assigns[$i];
344	}
345	}
346	return $list . ')';
347	}
348	}
349	// }}}
350	class Decompiler_ListBox extends Decompiler_Box // {{{
351	{
352	}
353	// }}}
354	class Decompiler_Array extends Decompiler_Value // {{{
355	{
356	// emenets
357	function Decompiler_Array()
358	{
359	$this->value = array();
360	}
361
362	function toCode($indent)
363	{
364	$subindent = $indent . INDENT;
365
366	$elementsCode = array();
367	$index = 0;
368	foreach ($this->value as $element) {
369	list($key, $value) = $element;
370	if (!isset($key)) {
371	$key = $index++;
372	}
373	$elementsCode[] = array(str($key, $subindent), str($value, $subindent), $key, $value);
374	}
375
376	$exp = "array(";
377	$indent = $indent . INDENT;
378	$assocWidth = 0;
379	$multiline = 0;
380	$i = 0;
381	foreach ($elementsCode as $element) {
382	list($keyCode, $valueCode) = $element;
383	if ((string) $i !== $keyCode) {
384	$assocWidth = 1;
385	break;
386	}
387	++$i;
388	}
389	foreach ($elementsCode as $element) {
390	list($keyCode, $valueCode, $key, $value) = $element;
391	if ($assocWidth) {
392	$len = strlen($keyCode);
393	if ($assocWidth < $len) {
394	$assocWidth = $len;
395	}
396	}
397	if (is_array($value) \|\| is_a($value, 'Decompiler_Array')) {
398	$multiline ++;
399	}
400	}
401
402	$i = 0;
403	foreach ($elementsCode as $element) {
404	list($keyCode, $value) = $element;
405	if ($multiline) {
406	if ($i) {
407	$exp .= ",";
408	}
409	$exp .= "\n";
410	$exp .= $indent;
411	}
412	else {
413	if ($i) {
414	$exp .= ", ";
415	}
416	}
417
418	if ($assocWidth) {
419	if ($multiline) {
420	$exp .= sprintf("%-{$assocWidth}s => ", $keyCode);
421	}
422	else {
423	$exp .= $keyCode . ' => ';
424	}
425	}
426
427	$exp .= $value;
428
429	$i ++;
430	}
431	if ($multiline) {
432	$exp .= "\n$indent)";
433	}
434	else {
435	$exp .= ")";
436	}
437	return $exp;
438	}
439	}
440	// }}}
441	class Decompiler_ConstArray extends Decompiler_Array // {{{
442	{
443	function Decompiler_ConstArray($array)
444	{
445	$elements = array();
446	foreach ($array as $key => $value) {
447	$elements[] = array(value($key), value($value));
448	}
449	$this->value = $elements;
450	}
451	}
452	// }}}
453	class Decompiler_ForeachBox extends Decompiler_Box // {{{
454	{
455	var $iskey;
456
457	function toCode($indent)
458	{
459	return 'foreach (' . '';
460	}
461	}
462	// }}}
463
464	class Decompiler
465	{
466	var $namespace;
467	var $namespaceDecided;
468
469	function Decompiler()
470	{
471	// {{{ testing
472	// XC_UNDEF XC_OP_DATA
473	$this->test = !empty($_ENV['XCACHE_DECOMPILER_TEST']);
474	$this->usedOps = array();
475
476	if ($this->test) {
477	$content = file_get_contents(__FILE__);
478	for ($i = 0; $opname = xcache_get_opcode($i); $i ++) {
479	if (!preg_match("/\\bXC_" . $opname . "\\b(?!')/", $content)) {
480	echo "not recognized opcode ", $opname, "\n";
481	}
482	}
483	}
484	// }}}
485	// {{{ opinfo
486	$this->unaryops = array(
487	XC_BW_NOT => '~',
488	XC_BOOL_NOT => '!',
489	);
490	$this->binops = array(
491	XC_ADD => "+",
492	XC_ASSIGN_ADD => "+=",
493	XC_SUB => "-",
494	XC_ASSIGN_SUB => "-=",
495	XC_MUL => "*",
496	XC_ASSIGN_MUL => "*=",
497	XC_DIV => "/",
498	XC_ASSIGN_DIV => "/=",
499	XC_MOD => "%",
500	XC_ASSIGN_MOD => "%=",
501	XC_SL => "<<",
502	XC_ASSIGN_SL => "<<=",
503	XC_SR => ">>",
504	XC_ASSIGN_SR => ">>=",
505	XC_CONCAT => ".",
506	XC_ASSIGN_CONCAT => ".=",
507	XC_IS_IDENTICAL => "===",
508	XC_IS_NOT_IDENTICAL => "!==",
509	XC_IS_EQUAL => "==",
510	XC_IS_NOT_EQUAL => "!=",
511	XC_IS_SMALLER => "<",
512	XC_IS_SMALLER_OR_EQUAL => "<=",
513	XC_BW_OR => "\|",
514	XC_ASSIGN_BW_OR => "\|=",
515	XC_BW_AND => "&",
516	XC_ASSIGN_BW_AND => "&=",
517	XC_BW_XOR => "^",
518	XC_ASSIGN_BW_XOR => "^=",
519	XC_BOOL_XOR => "xor",
520	XC_ASSIGN => "=",
521	XC_ASSIGN_REF => "= &",
522	XC_JMP_SET => "?:",
523	XC_JMPZ_EX => "&&",
524	XC_JMPNZ_EX => "\|\|",
525	);
526	// }}}
527	$this->includeTypes = array( // {{{
528	ZEND_EVAL => 'eval',
529	ZEND_INCLUDE => 'include',
530	ZEND_INCLUDE_ONCE => 'include_once',
531	ZEND_REQUIRE => 'require',
532	ZEND_REQUIRE_ONCE => 'require_once',
533	);
534	// }}}
535	}
536	function detectNamespace($name) // {{{
537	{
538	if ($this->namespaceDecided) {
539	return;
540	}
541
542	if (strpos($name, '\\') !== false) {
543	$this->namespace = strtok($name, '\\');
544	echo 'namespace ', $this->namespace, ";\n\n";
545	}
546
547	$this->namespaceDecided = true;
548	}
549	// }}}
550	function stripNamespace($name) // {{{
551	{
552	$len = strlen($this->namespace) + 1;
553	if (substr($name, 0, $len) == $this->namespace . '\\') {
554	return substr($name, $len);
555	}
556	else {
557	return $name;
558	}
559	}
560	// }}}
561	function outputPhp(&$EX, $range) // {{{
562	{
563	$needBlankline = isset($EX['lastBlock']);
564	$indent = $EX['indent'];
565	$curticks = 0;
566	for ($i = $range[0]; $i <= $range[1]; $i ++) {
567	$op = $EX['opcodes'][$i];
568	if (isset($op['gofrom'])) {
569	if ($needBlankline) {
570	$needBlankline = false;
571	echo PHP_EOL;
572	}
573	echo 'label' . $i, ":\n";
574	}
575	if (isset($op['php'])) {
576	$toticks = isset($op['ticks']) ? (int) str($op['ticks']) : 0;
577	if ($curticks != $toticks) {
578	$oldticks = $curticks;
579	$curticks = $toticks;
580	if (!$curticks) {
581	echo $EX['indent'], "}\n\n";
582	$indent = $EX['indent'];
583	}
584	else {
585	if ($oldticks) {
586	echo $EX['indent'], "}\n\n";
587	}
588	else if (!$oldticks) {
589	$indent .= INDENT;
590	}
591	if ($needBlankline) {
592	$needBlankline = false;
593	echo PHP_EOL;
594	}
595	echo $EX['indent'], "declare (ticks=$curticks) {\n";
596	}
597	}
598	if ($needBlankline) {
599	$needBlankline = false;
600	echo PHP_EOL;
601	}
602	echo $indent, str($op['php'], $indent), ";\n";
603	$EX['lastBlock'] = 'basic';
604	}
605	}
606	if ($curticks) {
607	echo $EX['indent'], "}\n";
608	}
609	}
610	// }}}
611	function getOpVal($op, &$EX, $free = false) // {{{
612	{
613	switch ($op['op_type']) {
614	case XC_IS_CONST:
615	return value($op['constant']);
616
617	case XC_IS_VAR:
618	case XC_IS_TMP_VAR:
619	$T = &$EX['Ts'];
620	$ret = $T[$op['var']];
621	if ($free && empty($this->keepTs)) {
622	unset($T[$op['var']]);
623	}
624	return $ret;
625
626	case XC_IS_CV:
627	$var = $op['var'];
628	$var = $EX['op_array']['vars'][$var];
629	return '$' . $var['name'];
630
631	case XC_IS_UNUSED:
632	return null;
633	}
634	}
635	// }}}
636	function removeKeyPrefix($array, $prefix) // {{{
637	{
638	$prefixLen = strlen($prefix);
639	$ret = array();
640	foreach ($array as $key => $value) {
641	if (substr($key, 0, $prefixLen) == $prefix) {
642	$key = substr($key, $prefixLen);
643	}
644	$ret[$key] = $value;
645	}
646	return $ret;
647	}
648	// }}}
649	function &fixOpcode($opcodes, $removeTailing = false, $defaultReturnValue = null) // {{{
650	{
651	$last = count($opcodes) - 1;
652	for ($i = 0; $i <= $last; $i ++) {
653	if (function_exists('xcache_get_fixed_opcode')) {
654	$opcodes[$i]['opcode'] = xcache_get_fixed_opcode($opcodes[$i]['opcode'], $i);
655	}
656	if (isset($opcodes[$i]['op1'])) {
657	$opcodes[$i]['op1'] = $this->removeKeyPrefix($opcodes[$i]['op1'], 'u.');
658	$opcodes[$i]['op2'] = $this->removeKeyPrefix($opcodes[$i]['op2'], 'u.');
659	$opcodes[$i]['result'] = $this->removeKeyPrefix($opcodes[$i]['result'], 'u.');
660	}
661	else {
662	$op = array(
663	'op1' => array(),
664	'op2' => array(),
665	'op3' => array(),
666	);
667	foreach ($opcodes[$i] as $name => $value) {
668	if (preg_match('!^(op1\|op2\|result)\\.(.*)!', $name, $m)) {
669	list(, $which, $field) = $m;
670	$op[$which][$field] = $value;
671	}
672	else if (preg_match('!^(op1\|op2\|result)_type$!', $name, $m)) {
673	list(, $which) = $m;
674	$op[$which]['op_type'] = $value;
675	}
676	else {
677	$op[$name] = $value;
678	}
679	}
680	$opcodes[$i] = $op;
681	}
682	}
683
684	if ($removeTailing) {
685	$last = count($opcodes) - 1;
686	if ($opcodes[$last]['opcode'] == XC_HANDLE_EXCEPTION) {
687	$this->usedOps[XC_HANDLE_EXCEPTION] = true;
688	$opcodes[$last]['opcode'] = XC_NOP;
689	--$last;
690	}
691	if ($opcodes[$last]['opcode'] == XC_RETURN) {
692	$op1 = $opcodes[$last]['op1'];
693	if ($op1['op_type'] == XC_IS_CONST && array_key_exists('constant', $op1) && $op1['constant'] === $defaultReturnValue) {
694	$opcodes[$last]['opcode'] = XC_NOP;
695	--$last;
696	}
697	}
698	}
699	return $opcodes;
700	}
701	// }}}
702	function decompileBasicBlock(&$EX, $range, $unhandled = false) // {{{
703	{
704	$this->dasmBasicBlock($EX, $range);
705	if ($unhandled) {
706	$this->dumpRange($EX, $range);
707	}
708	$this->outputPhp($EX, $range);
709	}
710	// }}}
711	function isIfCondition(&$EX, $range) // {{{
712	{
713	$opcodes = &$EX['opcodes'];
714	$firstOp = &$opcodes[$range[0]];
715	return $firstOp['opcode'] == XC_JMPZ && !empty($firstOp['jmpouts']) && $opcodes[$firstOp['jmpouts'][0] - 1]['opcode'] == XC_JMP
716	&& !empty($opcodes[$firstOp['jmpouts'][0] - 1]['jmpouts'])
717	&& $opcodes[$firstOp['jmpouts'][0] - 1]['jmpouts'][0] == $range[1] + 1;
718	}
719	// }}}
720	function removeJmpInfo(&$EX, $line) // {{{
721	{
722	$opcodes = &$EX['opcodes'];
723	foreach ($opcodes[$line]['jmpouts'] as $jmpTo) {
724	$jmpins = &$opcodes[$jmpTo]['jmpins'];
725	$jmpins = array_flip($jmpins);
726	unset($jmpins[$line]);
727	$jmpins = array_keys($jmpins);
728	}
729	// $opcodes[$line]['opcode'] = XC_NOP;
730	unset($opcodes[$line]['jmpouts']);
731	}
732	// }}}
733	function beginScope(&$EX, $doIndent = true) // {{{
734	{
735	array_push($EX['scopeStack'], array($EX['lastBlock'], $EX['indent']));
736	if ($doIndent) {
737	$EX['indent'] .= INDENT;
738	}
739	$EX['lastBlock'] = null;
740	}
741	// }}}
742	function endScope(&$EX) // {{{
743	{
744	list($EX['lastBlock'], $EX['indent']) = array_pop($EX['scopeStack']);
745	}
746	// }}}
747	function beginComplexBlock(&$EX) // {{{
748	{
749	if (isset($EX['lastBlock'])) {
750	echo PHP_EOL;
751	$EX['lastBlock'] = null;
752	}
753	}
754	// }}}
755	function endComplexBlock(&$EX) // {{{
756	{
757	$EX['lastBlock'] = 'complex';
758	}
759	// }}}
760	function decompileComplexBlock(&$EX, $range) // {{{
761	{
762	$T = &$EX['Ts'];
763	$opcodes = &$EX['opcodes'];
764	$indent = $EX['indent'];
765
766	$firstOp = &$opcodes[$range[0]];
767	$lastOp = &$opcodes[$range[1]];
768
769	// {{{ && \|\| and or
770	if (($firstOp['opcode'] == XC_JMPZ_EX \|\| $firstOp['opcode'] == XC_JMPNZ_EX) && !empty($firstOp['jmpouts'])
771	&& $firstOp['jmpouts'][0] == $range[1] + 1
772	&& $lastOp['opcode'] == XC_BOOL
773	&& $firstOp['opcode']['result']['var'] == $lastOp['opcode']['result']['var']
774	) {
775	$this->removeJmpInfo($EX, $range[0]);
776
777	$this->recognizeAndDecompileClosedBlocks($EX, array($range[0], $range[0]));
778	$op1 = $this->getOpVal($firstOp['result'], $EX, true);
779
780	$this->recognizeAndDecompileClosedBlocks($EX, array($range[0] + 1, $range[1]));
781	$op2 = $this->getOpVal($lastOp['result'], $EX, true);
782
783	$T[$firstOp['result']['var']] = new Decompiler_Binop($this, $op1, $firstOp['opcode'], $op2);
784	return false;
785	}
786	// }}}
787	// {{{ ?: excluding JMP_SET
788	if ($firstOp['opcode'] == XC_JMPZ && !empty($firstOp['jmpouts'])
789	&& $range[1] >= $range[0] + 3
790	&& $opcodes[$firstOp['jmpouts'][0] - 2]['opcode'] == XC_QM_ASSIGN
791	&& $opcodes[$firstOp['jmpouts'][0] - 1]['opcode'] == XC_JMP && $opcodes[$firstOp['jmpouts'][0] - 1]['jmpouts'][0] == $range[1] + 1
792	&& $lastOp['opcode'] == XC_QM_ASSIGN
793	) {
794	$trueRange = array($range[0] + 1, $firstOp['jmpouts'][0] - 2);
795	$falseRange = array($firstOp['jmpouts'][0], $range[1]);
796	$this->removeJmpInfo($EX, $range[0]);
797
798	$condition = $this->getOpVal($firstOp['op1'], $EX);
799	$this->recognizeAndDecompileClosedBlocks($EX, $trueRange);
800	$trueValue = $this->getOpVal($opcodes[$trueRange[1]]['result'], $EX, true);
801	$this->recognizeAndDecompileClosedBlocks($EX, $falseRange);
802	$falseValue = $this->getOpVal($opcodes[$falseRange[1]]['result'], $EX, true);
803	$T[$opcodes[$trueRange[1]]['result']['var']] = new Decompiler_TriOp($condition, $trueValue, $falseValue);
804	return false;
805	}
806	// }}}
807	// {{{ goto
808	if ($firstOp['opcode'] == XC_JMP && !empty($firstOp['jmpouts']) && $firstOp['jmpouts'][0] == $range[1] + 1) {
809	$this->removeJmpInfo($EX, $range[0]);
810	$firstOp['opcode'] = XC_GOTO;
811	$target = $firstOp['op1']['var'];
812	$firstOp['goto'] = $target;
813	$opcodes[$target]['gofrom'][] = $range[0];
814
815	$this->recognizeAndDecompileClosedBlocks($EX, $range);
816	return false;
817	}
818	// }}}
819	// {{{ for
820	if (!empty($firstOp['jmpins']) && $opcodes[$firstOp['jmpins'][0]]['opcode'] == XC_JMP
821	&& $lastOp['opcode'] == XC_JMP && !empty($lastOp['jmpouts']) && $lastOp['jmpouts'][0] <= $firstOp['jmpins'][0]
822	&& !empty($opcodes[$range[1] + 1]['jmpins']) && $opcodes[$opcodes[$range[1] + 1]['jmpins'][0]]['opcode'] == XC_JMPZNZ
823	) {
824	$nextRange = array($lastOp['jmpouts'][0], $firstOp['jmpins'][0]);
825	$conditionRange = array($range[0], $nextRange[0] - 1);
826	$this->removeJmpInfo($EX, $conditionRange[1]);
827	$bodyRange = array($nextRange[1], $range[1]);
828	$this->removeJmpInfo($EX, $bodyRange[1]);
829
830	$initial = '';
831	$this->beginScope($EX);
832	$this->dasmBasicBlock($EX, $conditionRange);
833	$conditionCodes = array();
834	for ($i = $conditionRange[0]; $i <= $conditionRange[1]; ++$i) {
835	if (isset($opcodes[$i]['php'])) {
836	$conditionCodes[] = str($opcodes[$i]['php'], $EX);
837	}
838	}
839	$conditionCodes[] = str($this->getOpVal($opcodes[$conditionRange[1]]['op1'], $EX), $EX);
840	if (implode(',', $conditionCodes) == 'true') {
841	$conditionCodes = array();
842	}
843	$this->endScope($EX);
844
845	$this->beginScope($EX);
846	$this->dasmBasicBlock($EX, $nextRange);
847	$nextCodes = array();
848	for ($i = $nextRange[0]; $i <= $nextRange[1]; ++$i) {
849	if (isset($opcodes[$i]['php'])) {
850	$nextCodes[] = str($opcodes[$i]['php'], $EX);
851	}
852	}
853	$this->endScope($EX);
854
855	$this->beginComplexBlock($EX);
856	echo $indent, 'for (', str($initial, $EX), '; ', implode(', ', $conditionCodes), '; ', implode(', ', $nextCodes), ') ', '{', PHP_EOL;
857	$this->beginScope($EX);
858	$this->recognizeAndDecompileClosedBlocks($EX, $bodyRange);
859	$this->endScope($EX);
860	echo $indent, '}', PHP_EOL;
861	$this->endComplexBlock($EX);
862	return;
863	}
864	// }}}
865	// {{{ if/elseif/else
866	if ($this->isIfCondition($EX, $range)) {
867	$this->beginComplexBlock($EX);
868	$isElseIf = false;
869	do {
870	$ifRange = array($range[0], $opcodes[$range[0]]['jmpouts'][0] - 1);
871	$this->removeJmpInfo($EX, $ifRange[0]);
872	$this->removeJmpInfo($EX, $ifRange[1]);
873	$condition = $this->getOpVal($opcodes[$ifRange[0]]['op1'], $EX);
874
875	echo $indent, $isElseIf ? 'else if' : 'if', ' (', str($condition, $EX), ') ', '{', PHP_EOL;
876	$this->beginScope($EX);
877	$this->recognizeAndDecompileClosedBlocks($EX, $ifRange);
878	$this->endScope($EX);
879	$EX['lastBlock'] = null;
880	echo $indent, '}', PHP_EOL;
881
882	$isElseIf = true;
883	// search for else if
884	$range[0] = $ifRange[1] + 1;
885	for ($i = $ifRange[1] + 1; $i <= $range[1]; ++$i) {
886	// find first jmpout
887	if (!empty($opcodes[$i]['jmpouts'])) {
888	if ($this->isIfCondition($EX, array($i, $range[1]))) {
889	$this->dasmBasicBlock($EX, array($range[0], $i));
890	$range[0] = $i;
891	}
892	break;
893	}
894	}
895	} while ($this->isIfCondition($EX, $range));
896	if ($ifRange[1] < $range[1]) {
897	$elseRange = array($ifRange[1], $range[1]);
898	echo $indent, 'else ', '{', PHP_EOL;
899	$this->beginScope($EX);
900	$this->recognizeAndDecompileClosedBlocks($EX, $elseRange);
901	$this->endScope($EX);
902	$EX['lastBlock'] = null;
903	echo $indent, '}', PHP_EOL;
904	}
905	$this->endComplexBlock($EX);
906	return;
907	}
908	if ($firstOp['opcode'] == XC_JMPZ && !empty($firstOp['jmpouts'])
909	&& $firstOp['jmpouts'][0] - 1 == $range[1] && $opcodes[$firstOp['jmpouts'][0] - 1]['opcode'] == XC_RETURN) {
910	$this->beginComplexBlock($EX);
911	$this->removeJmpInfo($EX, $range[0]);
912	$condition = $this->getOpVal($opcodes[$range[0]]['op1'], $EX);
913
914	echo $indent, 'if (', str($condition, $EX), ') ', '{', PHP_EOL;
915	$this->beginScope($EX);
916	$this->recognizeAndDecompileClosedBlocks($EX, $range);
917	$this->endScope($EX);
918	echo $indent, '}', PHP_EOL;
919	$this->endComplexBlock($EX);
920	return;
921	}
922	// }}}
923	// {{{ try/catch
924	if (!empty($firstOp['jmpins']) && !empty($opcodes[$firstOp['jmpins'][0]]['isCatchBegin'])) {
925	$catchBlocks = array();
926	$catchFirst = $firstOp['jmpins'][0];
927
928	$tryRange = array($range[0], $catchFirst - 1);
929
930	// search for XC_CATCH
931	$this->removeJmpInfo($EX, $catchFirst);
932	for ($i = $catchFirst; $i <= $range[1]; ) {
933	if ($opcodes[$i]['opcode'] == XC_CATCH) {
934	$catchOpLine = $i;
935	$this->removeJmpInfo($EX, $catchOpLine);
936
937	$catchNext = $opcodes[$catchOpLine]['extended_value'];
938	$catchBodyLast = $catchNext - 1;
939	if ($opcodes[$catchBodyLast]['opcode'] == XC_JMP) {
940	--$catchBodyLast;
941	}
942
943	$catchBlocks[$catchFirst] = array($catchOpLine, $catchBodyLast);
944
945	$i = $catchFirst = $catchNext;
946	}
947	else {
948	++$i;
949	}
950	}
951
952	if ($opcodes[$tryRange[1]]['opcode'] == XC_JMP) {
953	--$tryRange[1];
954	}
955
956	$this->beginComplexBlock($EX);
957	echo $indent, "try {", PHP_EOL;
958	$this->beginScope($EX);
959	$this->recognizeAndDecompileClosedBlocks($EX, $tryRange);
960	$this->endScope($EX);
961	echo $indent, '}', PHP_EOL;
962	foreach ($catchBlocks as $catchFirst => $catchInfo) {
963	list($catchOpLine, $catchBodyLast) = $catchInfo;
964	$catchBodyFirst = $catchOpLine + 1;
965	$this->dasmBasicBlock($EX, array($catchFirst, $catchOpLine));
966	$catchOp = &$opcodes[$catchOpLine];
967	echo $indent, 'catch (', str($this->getOpVal($catchOp['op1'], $EX)), ' ', str($this->getOpVal($catchOp['op2'], $EX)), ") {", PHP_EOL;
968	unset($catchOp);
969
970	$EX['lastBlock'] = null;
971	$this->beginScope($EX);
972	$this->recognizeAndDecompileClosedBlocks($EX, array($catchBodyFirst, $catchBodyLast));
973	$this->endScope($EX);
974	echo $indent, '}', PHP_EOL;
975	}
976	$this->endComplexBlock($EX);
977	return;
978	}
979	// }}}
980	// {{{ switch/case
981	if ($firstOp['opcode'] == XC_SWITCH_FREE && isset($T[$firstOp['op1']['var']])) {
982	// TODO: merge this code to CASE code. use SWITCH_FREE to detect begin of switch by using $Ts if possible
983	$this->beginComplexBlock($EX);
984	echo $indent, 'switch (', str($this->getOpVal($firstOp['op1'], $EX)), ") {", PHP_EOL;
985	echo $indent, '}', PHP_EOL;
986	$this->endComplexBlock($EX);
987	return;
988	}
989
990	if (
991	($firstOp['opcode'] == XC_CASE
992	\|\| $firstOp['opcode'] == XC_JMP && !empty($firstOp['jmpouts']) && $opcodes[$firstOp['jmpouts'][0]]['opcode'] == XC_CASE
993	)
994	&& !empty($lastOp['jmpouts'])
995	) {
996	$cases = array();
997	$caseDefault = null;
998	$caseOp = null;
999	for ($i = $range[0]; $i <= $range[1]; ) {
1000	$op = $opcodes[$i];
1001	if ($op['opcode'] == XC_CASE) {
1002	if (!isset($caseOp)) {
1003	$caseOp = $op;
1004	}
1005	$jmpz = $opcodes[$i + 1];
1006	assert('$jmpz["opcode"] == XC_JMPZ');
1007	$caseNext = $jmpz['jmpouts'][0];
1008	$cases[$i] = $caseNext - 1;
1009	$i = $caseNext;
1010	}
1011	else if ($op['opcode'] == XC_JMP && $op['jmpouts'][0] >= $i) {
1012	// default
1013	$caseNext = $op['jmpouts'][0];
1014	$caseDefault = $i;
1015	$cases[$i] = $caseNext - 1;
1016	$i = $caseNext;
1017	}
1018	else {
1019	++$i;
1020	}
1021	}
1022
1023	$this->beginComplexBlock($EX);
1024
1025	echo $indent, 'switch (', str($this->getOpVal($caseOp['op1'], $EX), $EX), ") {", PHP_EOL;
1026	$caseIsOut = false;
1027	foreach ($cases as $caseFirst => $caseLast) {
1028	if ($caseIsOut && empty($lastCaseFall)) {
1029	echo PHP_EOL;
1030	}
1031
1032	$caseOp = $opcodes[$caseFirst];
1033
1034	echo $indent;
1035	if ($caseOp['opcode'] == XC_CASE) {
1036	echo 'case ';
1037	echo str($this->getOpVal($caseOp['op2'], $EX), $EX);
1038	echo ':', PHP_EOL;
1039
1040	$this->removeJmpInfo($EX, $caseFirst);
1041	++$caseFirst;
1042
1043	assert('$opcodes[$caseFirst]["opcode"] == XC_JMPZ');
1044	$this->removeJmpInfo($EX, $caseFirst);
1045	++$caseFirst;
1046	}
1047	else {
1048	echo 'default';
1049	echo ':', PHP_EOL;
1050
1051	assert('$opcodes[$caseFirst]["opcode"] == XC_JMP');
1052	$this->removeJmpInfo($EX, $caseFirst);
1053	++$caseFirst;
1054	}
1055
1056	assert('$opcodes[$caseLast]["opcode"] == XC_JMP');
1057	$this->removeJmpInfo($EX, $caseLast);
1058	--$caseLast;
1059	switch ($opcodes[$caseLast]['opcode']) {
1060	case XC_BRK:
1061	case XC_CONT:
1062	case XC_GOTO:
1063	$lastCaseFall = false;
1064	break;
1065
1066	default:
1067	$lastCaseFall = true;
1068	}
1069
1070	$this->beginScope($EX);
1071	$this->recognizeAndDecompileClosedBlocks($EX, array($caseFirst, $caseLast));
1072	$this->endScope($EX);
1073	$caseIsOut = true;
1074	}
1075	echo $indent, '}', PHP_EOL;
1076
1077	$this->endComplexBlock($EX);
1078	return;
1079	}
1080	// }}}
1081	// {{{ do/while
1082	if ($lastOp['opcode'] == XC_JMPNZ && !empty($lastOp['jmpouts'])
1083	&& $lastOp['jmpouts'][0] == $range[0]) {
1084	$this->removeJmpInfo($EX, $range[1]);
1085	$this->beginComplexBlock($EX);
1086
1087	echo $indent, "do {", PHP_EOL;
1088	$this->beginScope($EX);
1089	$this->recognizeAndDecompileClosedBlocks($EX, $range);
1090	$this->endScope($EX);
1091	echo $indent, "} while (", str($this->getOpVal($lastOp['op1'], $EX)), ');', PHP_EOL;
1092
1093	$this->endComplexBlock($EX);
1094	return;
1095	}
1096	// }}}
1097
1098	// {{{ search firstJmpOp
1099	$firstJmp = null;
1100	$firstJmpOp = null;
1101	for ($i = $range[0]; $i <= $range[1]; ++$i) {
1102	if (!empty($opcodes[$i]['jmpouts'])) {
1103	$firstJmp = $i;
1104	$firstJmpOp = &$opcodes[$firstJmp];
1105	break;
1106	}
1107	}
1108	// }}}
1109
1110	// {{{ while
1111	if (isset($firstJmpOp)
1112	&& $firstJmpOp['opcode'] == XC_JMPZ
1113	&& $firstJmpOp['jmpouts'][0] > $range[1]
1114	&& $lastOp['opcode'] == XC_JMP && !empty($lastOp['jmpouts'])
1115	&& $lastOp['jmpouts'][0] == $range[0]) {
1116	$this->removeJmpInfo($EX, $firstJmp);
1117	$this->removeJmpInfo($EX, $range[1]);
1118	$this->beginComplexBlock($EX);
1119
1120	ob_start();
1121	$this->beginScope($EX);
1122	$this->recognizeAndDecompileClosedBlocks($EX, $range);
1123	$this->endScope($EX);
1124	$body = ob_get_clean();
1125
1126	echo $indent, 'while (', str($this->getOpVal($firstJmpOp['op1'], $EX)), ") {", PHP_EOL;
1127	echo $body;
1128	echo $indent, '}', PHP_EOL;
1129
1130	$this->endComplexBlock($EX);
1131	return;
1132	}
1133	// }}}
1134	// {{{ foreach
1135	if (isset($firstJmpOp)
1136	&& $firstJmpOp['opcode'] == XC_FE_FETCH
1137	&& $firstJmpOp['jmpouts'][0] > $range[1]
1138	&& $lastOp['opcode'] == XC_JMP && !empty($lastOp['jmpouts'])
1139	&& $lastOp['jmpouts'][0] == $firstJmp) {
1140	$this->removeJmpInfo($EX, $firstJmp);
1141	$this->removeJmpInfo($EX, $range[1]);
1142	$this->beginComplexBlock($EX);
1143
1144	ob_start();
1145	$this->beginScope($EX);
1146	$this->recognizeAndDecompileClosedBlocks($EX, $range);
1147	$this->endScope($EX);
1148	$body = ob_get_clean();
1149
1150	$as = foldToCode($firstJmpOp['fe_as'], $EX);
1151	if (isset($firstJmpOp['fe_key'])) {
1152	$as = str($firstJmpOp['fe_key'], $EX) . ' => ' . str($as);
1153	}
1154
1155	echo $indent, 'foreach (', str($firstJmpOp['fe_src'], $EX), " as $as) {", PHP_EOL;
1156	echo $body;
1157	echo $indent, '}', PHP_EOL;
1158
1159	$this->endComplexBlock($EX);
1160	if ($opcodes[$range[1] + 1]['opcode'] == XC_SWITCH_FREE) {
1161	$this->removeJmpInfo($EX, $range[1] + 1);
1162	}
1163	return;
1164	}
1165	// }}}
1166
1167	$this->decompileBasicBlock($EX, $range, true);
1168	}
1169	// }}}
1170	function recognizeAndDecompileClosedBlocks(&$EX, $range) // {{{ decompile in a tree way
1171	{
1172	$opcodes = &$EX['opcodes'];
1173
1174	$starti = $range[0];
1175	for ($i = $starti; $i <= $range[1]; ) {
1176	if (!empty($opcodes[$i]['jmpins']) \|\| !empty($opcodes[$i]['jmpouts'])) {
1177	$blockFirst = $i;
1178	$blockLast = -1;
1179	$j = $blockFirst;
1180	do {
1181	$op = $opcodes[$j];
1182	if (!empty($op['jmpins'])) {
1183	// care about jumping from blocks behind, not before
1184	foreach ($op['jmpins'] as $oplineNumber) {
1185	if ($oplineNumber <= $range[1] && $blockLast < $oplineNumber) {
1186	$blockLast = $oplineNumber;
1187	}
1188	}
1189	}
1190	if (!empty($op['jmpouts'])) {
1191	$blockLast = max($blockLast, max($op['jmpouts']) - 1);
1192	}
1193	++$j;
1194	} while ($j <= $blockLast);
1195	if (!assert('$blockLast <= $range[1]')) {
1196	var_dump($blockLast, $range[1]);
1197	}
1198
1199	if ($blockLast >= $blockFirst) {
1200	if ($blockFirst > $starti) {
1201	$this->decompileBasicBlock($EX, array($starti, $blockFirst - 1));
1202	}
1203	if ($this->decompileComplexBlock($EX, array($blockFirst, $blockLast)) === false) {
1204	if ($EX['lastBlock'] == 'complex') {
1205	echo PHP_EOL;
1206	}
1207	$EX['lastBlock'] = null;
1208	}
1209	$starti = $blockLast + 1;
1210	$i = $starti;
1211	}
1212	else {
1213	++$i;
1214	}
1215	}
1216	else {
1217	++$i;
1218	}
1219	}
1220	if ($starti <= $range[1]) {
1221	$this->decompileBasicBlock($EX, array($starti, $range[1]));
1222	}
1223	}
1224	// }}}
1225	function &dop_array($op_array, $indent = '') // {{{
1226	{
1227	$op_array['opcodes'] = $this->fixOpcode($op_array['opcodes'], true, $indent == '' ? 1 : null);
1228	$opcodes = &$op_array['opcodes'];
1229	$last = count($opcodes) - 1;
1230	// {{{ build jmpins/jmpouts to op_array
1231	for ($i = 0; $i <= $last; $i ++) {
1232	$op = &$opcodes[$i];
1233	$op['line'] = $i;
1234	switch ($op['opcode']) {
1235	case XC_CONT:
1236	case XC_BRK:
1237	$op['jmpouts'] = array();
1238	break;
1239
1240	case XC_GOTO:
1241	$target = $op['op1']['var'];
1242	$op['goto'] = $target;
1243	$opcodes[$target]['gofrom'][] = $i;
1244	break;
1245
1246	case XC_JMP:
1247	$target = $op['op1']['var'];
1248	$op['jmpouts'] = array($target);
1249	$opcodes[$target]['jmpins'][] = $i;
1250	break;
1251
1252	case XC_JMPZNZ:
1253	$jmpz = $op['op2']['opline_num'];
1254	$jmpnz = $op['extended_value'];
1255	$op['jmpouts'] = array($jmpz, $jmpnz);
1256	$opcodes[$jmpz]['jmpins'][] = $i;
1257	$opcodes[$jmpnz]['jmpins'][] = $i;
1258	break;
1259
1260	case XC_JMPZ:
1261	case XC_JMPNZ:
1262	case XC_JMPZ_EX:
1263	case XC_JMPNZ_EX:
1264	// case XC_JMP_SET:
1265	// case XC_FE_RESET:
1266	case XC_FE_FETCH:
1267	// case XC_JMP_NO_CTOR:
1268	$target = $op['op2']['opline_num'];
1269	//if (!isset($target)) {
1270	// $this->dumpop($op, $EX);
1271	// var_dump($op); exit;
1272	//}
1273	$op['jmpouts'] = array($target);
1274	$opcodes[$target]['jmpins'][] = $i;
1275	break;
1276
1277	/*
1278	case XC_RETURN:
1279	$op['jmpouts'] = array();
1280	break;
1281	*/
1282
1283	case XC_SWITCH_FREE:
1284	$op['jmpouts'] = array($i + 1);
1285	$opcodes[$i + 1]['jmpins'][] = $i;
1286	break;
1287
1288	case XC_CASE:
1289	// just to link together
1290	$op['jmpouts'] = array($i + 2);
1291	$opcodes[$i + 2]['jmpins'][] = $i;
1292	break;
1293
1294	case XC_CATCH:
1295	$catchNext = $op['extended_value'];
1296	$op['jmpouts'] = array($catchNext);
1297	$opcodes[$catchNext]['jmpins'][] = $i;
1298	break;
1299	}
1300	/*
1301	if (!empty($op['jmpouts']) \|\| !empty($op['jmpins'])) {
1302	echo $i, "\t", xcache_get_opcode($op['opcode']), PHP_EOL;
1303	}
1304	// */
1305	}
1306	unset($op);
1307	if ($op_array['try_catch_array']) {
1308	foreach ($op_array['try_catch_array'] as $try_catch_element) {
1309	$catch_op = $try_catch_element['catch_op'];
1310	$try_op = $try_catch_element['try_op'];
1311	$opcodes[$try_op]['jmpins'][] = $catch_op;
1312	$opcodes[$catch_op]['jmpouts'][] = $try_op;
1313	$opcodes[$catch_op]['isCatchBegin'] = true;
1314	}
1315	}
1316	// }}}
1317	// build semi-basic blocks
1318	$nextbbs = array();
1319	$starti = 0;
1320	for ($i = 1; $i <= $last; $i ++) {
1321	if (isset($opcodes[$i]['jmpins'])
1322	\|\| isset($opcodes[$i - 1]['jmpouts'])) {
1323	$nextbbs[$starti] = $i;
1324	$starti = $i;
1325	}
1326	}
1327	$nextbbs[$starti] = $last + 1;
1328
1329	$EX = array();
1330	$EX['Ts'] = array();
1331	$EX['indent'] = $indent;
1332	$EX['nextbbs'] = $nextbbs;
1333	$EX['op_array'] = &$op_array;
1334	$EX['opcodes'] = &$opcodes;
1335	$EX['range'] = array(0, count($opcodes) - 1);
1336	// func call
1337	$EX['object'] = null;
1338	$EX['called_scope'] = null;
1339	$EX['fbc'] = null;
1340	$EX['argstack'] = array();
1341	$EX['arg_types_stack'] = array();
1342	$EX['scopeStack'] = array();
1343	$EX['silence'] = 0;
1344	$EX['recvs'] = array();
1345	$EX['uses'] = array();
1346	$EX['lastBlock'] = null;
1347
1348	/* dump whole array
1349	$this->keepTs = true;
1350	$this->dasmBasicBlock($EX, $range);
1351	for ($i = $range[0]; $i <= $range[1]; ++$i) {
1352	echo $i, "\t", $this->dumpop($opcodes[$i], $EX);
1353	}
1354	// */
1355	// decompile in a tree way
1356	$this->recognizeAndDecompileClosedBlocks($EX, $EX['range'], $EX['indent']);
1357	return $EX;
1358	}
1359	// }}}
1360	function dasmBasicBlock(&$EX, $range) // {{{
1361	{
1362	$T = &$EX['Ts'];
1363	$opcodes = &$EX['opcodes'];
1364	$lastphpop = null;
1365
1366	for ($i = $range[0]; $i <= $range[1]; $i ++) {
1367	// {{{ prepair
1368	$op = &$opcodes[$i];
1369	$opc = $op['opcode'];
1370	if ($opc == XC_NOP) {
1371	$this->usedOps[$opc] = true;
1372	continue;
1373	}
1374
1375	$op1 = $op['op1'];
1376	$op2 = $op['op2'];
1377	$res = $op['result'];
1378	$ext = $op['extended_value'];
1379
1380	$opname = xcache_get_opcode($opc);
1381
1382	if ($opname == 'UNDEF' \|\| !isset($opname)) {
1383	echo 'UNDEF OP:';
1384	$this->dumpop($op, $EX);
1385	continue;
1386	}
1387	// echo $i, ' '; $this->dumpop($op, $EX); //var_dump($op);
1388
1389	$resvar = null;
1390	unset($curResVar);
1391	if (array_key_exists($res['var'], $T)) {
1392	$curResVar = &$T[$res['var']];
1393	}
1394	if ((ZEND_ENGINE_2_4 ? ($res['op_type'] & EXT_TYPE_UNUSED) : ($res['EA.type'] & EXT_TYPE_UNUSED)) \|\| $res['op_type'] == XC_IS_UNUSED) {
1395	$istmpres = false;
1396	}
1397	else {
1398	$istmpres = true;
1399	}
1400	// }}}
1401	// echo $opname, "\n";
1402
1403	$notHandled = false;
1404	switch ($opc) {
1405	case XC_NEW: // {{{
1406	array_push($EX['arg_types_stack'], array($EX['fbc'], $EX['object'], $EX['called_scope']));
1407	$EX['object'] = (int) $res['var'];
1408	$EX['called_scope'] = null;
1409	$EX['fbc'] = 'new ' . unquoteName($this->getOpVal($op1, $EX), $EX);
1410	break;
1411	// }}}
1412	case XC_THROW: // {{{
1413	$resvar = 'throw ' . str($this->getOpVal($op1, $EX));
1414	break;
1415	// }}}
1416	case XC_CLONE: // {{{
1417	$resvar = 'clone ' . str($this->getOpVal($op1, $EX));
1418	break;
1419	// }}}
1420	case XC_CATCH: // {{{
1421	break;
1422	// }}}
1423	case XC_INSTANCEOF: // {{{
1424	$resvar = str($this->getOpVal($op1, $EX)) . ' instanceof ' . str($this->getOpVal($op2, $EX));
1425	break;
1426	// }}}
1427	case XC_FETCH_CLASS: // {{{
1428	if ($op2['op_type'] == XC_IS_UNUSED) {
1429	switch (($ext & (defined('ZEND_FETCH_CLASS_MASK') ? ZEND_FETCH_CLASS_MASK : 0xFF))) {
1430	case ZEND_FETCH_CLASS_SELF:
1431	$class = 'self';
1432	break;
1433	case ZEND_FETCH_CLASS_PARENT:
1434	$class = 'parent';
1435	break;
1436	case ZEND_FETCH_CLASS_STATIC:
1437	$class = 'static';
1438	break;
1439	}
1440	$istmpres = true;
1441	}
1442	else {
1443	$class = $this->getOpVal($op2, $EX);
1444	if (isset($op2['constant'])) {
1445	$class = $this->stripNamespace(unquoteName($class));
1446	}
1447	}
1448	$resvar = $class;
1449	break;
1450	// }}}
1451	case XC_FETCH_CONSTANT: // {{{
1452	if ($op1['op_type'] == XC_IS_UNUSED) {
1453	$resvar = $this->stripNamespace($op2['constant']);
1454	break;
1455	}
1456
1457	if ($op1['op_type'] == XC_IS_CONST) {
1458	$resvar = $this->stripNamespace($op1['constant']);
1459	}
1460	else {
1461	$resvar = $this->getOpVal($op1, $EX);
1462	}
1463
1464	$resvar = str($resvar) . '::' . unquoteName($this->getOpVal($op2, $EX));
1465	break;
1466	// }}}
1467	// {{{ case FETCH_*
1468	case XC_FETCH_R:
1469	case XC_FETCH_W:
1470	case XC_FETCH_RW:
1471	case XC_FETCH_FUNC_ARG:
1472	case XC_FETCH_UNSET:
1473	case XC_FETCH_IS:
1474	case XC_UNSET_VAR:
1475	$rvalue = $this->getOpVal($op1, $EX);
1476	if (defined('ZEND_FETCH_TYPE_MASK')) {
1477	$fetchtype = ($ext & ZEND_FETCH_TYPE_MASK);
1478	}
1479	else {
1480	$fetchtype = $op2['EA.type'];
1481	}
1482	switch ($fetchtype) {
1483	case ZEND_FETCH_STATIC_MEMBER:
1484	$class = $this->getOpVal($op2, $EX);
1485	$rvalue = str($class) . '::$' . unquoteName($rvalue, $EX);
1486	break;
1487	default:
1488	$name = unquoteName($rvalue, $EX);
1489	$globalname = xcache_is_autoglobal($name) ? "\$$name" : "\$GLOBALS[" . str($rvalue) . "]";
1490	$rvalue = new Decompiler_Fetch($rvalue, $fetchtype, $globalname);
1491	break;
1492	}
1493	if ($opc == XC_UNSET_VAR) {
1494	$op['php'] = "unset(" . str($rvalue, $EX) . ")";
1495	$lastphpop = &$op;
1496	}
1497	else if ($res['op_type'] != XC_IS_UNUSED) {
1498	$resvar = $rvalue;
1499	}
1500	break;
1501	// }}}
1502	// {{{ case FETCH_DIM_*
1503	case XC_FETCH_DIM_TMP_VAR:
1504	case XC_FETCH_DIM_R:
1505	case XC_FETCH_DIM_W:
1506	case XC_FETCH_DIM_RW:
1507	case XC_FETCH_DIM_FUNC_ARG:
1508	case XC_FETCH_DIM_UNSET:
1509	case XC_FETCH_DIM_IS:
1510	case XC_ASSIGN_DIM:
1511	case XC_UNSET_DIM_OBJ: // PHP 4 only
1512	case XC_UNSET_DIM:
1513	case XC_UNSET_OBJ:
1514	$src = $this->getOpVal($op1, $EX);
1515	if (is_a($src, "Decompiler_ForeachBox")) {
1516	$src->iskey = $this->getOpVal($op2, $EX);
1517	$resvar = $src;
1518	break;
1519	}
1520
1521	if (is_a($src, "Decompiler_DimBox")) {
1522	$dimbox = $src;
1523	}
1524	else {
1525	if (!is_a($src, "Decompiler_ListBox")) {
1526	$op1val = $this->getOpVal($op1, $EX);
1527	$list = new Decompiler_List(isset($op1val) ? $op1val : '$this');
1528
1529	$src = new Decompiler_ListBox($list);
1530	if (!isset($op1['var'])) {
1531	$this->dumpop($op, $EX);
1532	var_dump($op);
1533	die('missing var');
1534	}
1535	$T[$op1['var']] = $src;
1536	unset($list);
1537	}
1538	$dim = new Decompiler_Dim($src);
1539	$src->obj->dims[] = &$dim;
1540
1541	$dimbox = new Decompiler_DimBox($dim);
1542	}
1543	$dim = &$dimbox->obj;
1544	$dim->offsets[] = $this->getOpVal($op2, $EX);
1545	/* TODO: use type mask */
1546	if ($ext == ZEND_FETCH_ADD_LOCK) {
1547	$src->obj->everLocked = true;
1548	}
1549	else if ($ext == ZEND_FETCH_STANDARD) {
1550	$dim->isLast = true;
1551	}
1552	if ($opc == XC_UNSET_OBJ) {
1553	$dim->isObject = true;
1554	}
1555	unset($dim);
1556	$rvalue = $dimbox;
1557	unset($dimbox);
1558
1559	if ($opc == XC_ASSIGN_DIM) {
1560	$lvalue = $rvalue;
1561	++ $i;
1562	$rvalue = $this->getOpVal($opcodes[$i]['op1'], $EX);
1563	$resvar = str($lvalue, $EX) . ' = ' . str($rvalue);
1564	}
1565	else if ($opc == XC_UNSET_DIM \|\| $opc == XC_UNSET_OBJ) {
1566	$op['php'] = "unset(" . str($rvalue, $EX) . ")";
1567	$lastphpop = &$op;
1568	}
1569	else if ($res['op_type'] != XC_IS_UNUSED) {
1570	$resvar = $rvalue;
1571	}
1572	break;
1573	// }}}
1574	case XC_ASSIGN: // {{{
1575	$lvalue = $this->getOpVal($op1, $EX);
1576	$rvalue = $this->getOpVal($op2, $EX);
1577	if (is_a($rvalue, 'Decompiler_ForeachBox')) {
1578	$type = $rvalue->iskey ? 'fe_key' : 'fe_as';
1579	$rvalue->obj[$type] = $lvalue;
1580	unset($T[$op2['var']]);
1581	break;
1582	}
1583	if (is_a($rvalue, "Decompiler_DimBox")) {
1584	$dim = &$rvalue->obj;
1585	$dim->assign = $lvalue;
1586	if ($dim->isLast) {
1587	$resvar = foldToCode($dim->value, $EX);
1588	}
1589	unset($dim);
1590	break;
1591	}
1592	if (is_a($rvalue, 'Decompiler_Fetch')) {
1593	$src = str($rvalue->src, $EX);
1594	if ('$' . unquoteName($src) == $lvalue) {
1595	switch ($rvalue->fetchType) {
1596	case ZEND_FETCH_STATIC:
1597	$statics = &$EX['op_array']['static_variables'];
1598	if ((xcache_get_type($statics[$name]) & IS_LEXICAL_VAR)) {
1599	$EX['uses'][] = str($lvalue);
1600	unset($statics);
1601	break 2;
1602	}
1603	unset($statics);
1604	}
1605	}
1606	}
1607	$resvar = new Decompiler_Binop($this, $lvalue, XC_ASSIGN, $rvalue);
1608	break;
1609	// }}}
1610	case XC_ASSIGN_REF: // {{{
1611	$lvalue = $this->getOpVal($op1, $EX);
1612	$rvalue = $this->getOpVal($op2, $EX);
1613	if (is_a($rvalue, 'Decompiler_Fetch')) {
1614	$src = str($rvalue->src, $EX);
1615	if ('$' . unquoteName($src) == $lvalue) {
1616	switch ($rvalue->fetchType) {
1617	case ZEND_FETCH_GLOBAL:
1618	case ZEND_FETCH_GLOBAL_LOCK:
1619	$resvar = 'global ' . $lvalue;
1620	break 2;
1621	case ZEND_FETCH_STATIC:
1622	$statics = &$EX['op_array']['static_variables'];
1623	if ((xcache_get_type($statics[$name]) & IS_LEXICAL_REF)) {
1624	$EX['uses'][] = '&' . str($lvalue);
1625	unset($statics);
1626	break 2;
1627	}
1628
1629	$resvar = 'static ' . $lvalue;
1630	$name = unquoteName($src);
1631	if (isset($statics[$name])) {
1632	$var = $statics[$name];
1633	$resvar .= ' = ';
1634	$resvar .= str(value($var), $EX);
1635	}
1636	unset($statics);
1637	break 2;
1638	default:
1639	}
1640	}
1641	}
1642	// TODO: PHP_6 global
1643	$resvar = new Decompiler_Binop($this, $lvalue, XC_ASSIGN_REF, $rvalue);
1644	break;
1645	// }}}
1646	// {{{ case FETCH_OBJ_*
1647	case XC_FETCH_OBJ_R:
1648	case XC_FETCH_OBJ_W:
1649	case XC_FETCH_OBJ_RW:
1650	case XC_FETCH_OBJ_FUNC_ARG:
1651	case XC_FETCH_OBJ_UNSET:
1652	case XC_FETCH_OBJ_IS:
1653	case XC_ASSIGN_OBJ:
1654	$obj = $this->getOpVal($op1, $EX);
1655	if (!isset($obj)) {
1656	$obj = '$this';
1657	}
1658	$rvalue = str($obj) . "->" . unquoteVariableName($this->getOpVal($op2, $EX), $EX);
1659	if ($res['op_type'] != XC_IS_UNUSED) {
1660	$resvar = $rvalue;
1661	}
1662	if ($opc == XC_ASSIGN_OBJ) {
1663	++ $i;
1664	$lvalue = $rvalue;
1665	$rvalue = $this->getOpVal($opcodes[$i]['op1'], $EX);
1666	$resvar = "$lvalue = " . str($rvalue);
1667	}
1668	break;
1669	// }}}
1670	case XC_ISSET_ISEMPTY_DIM_OBJ:
1671	case XC_ISSET_ISEMPTY_PROP_OBJ:
1672	case XC_ISSET_ISEMPTY:
1673	case XC_ISSET_ISEMPTY_VAR: // {{{
1674	if ($opc == XC_ISSET_ISEMPTY_VAR) {
1675	$rvalue = $this->getOpVal($op1, $EX);
1676	// for < PHP_5_3
1677	if ($op1['op_type'] == XC_IS_CONST) {
1678	$rvalue = '$' . unquoteVariableName($this->getOpVal($op1, $EX));
1679	}
1680	if (!ZEND_ENGINE_2_4 && $op2['EA.type'] == ZEND_FETCH_STATIC_MEMBER) {
1681	$class = $this->getOpVal($op2, $EX);
1682	$rvalue = $class . '::' . $rvalue;
1683	}
1684	}
1685	else if ($opc == XC_ISSET_ISEMPTY) {
1686	$rvalue = $this->getOpVal($op1, $EX);
1687	}
1688	else {
1689	$container = $this->getOpVal($op1, $EX);
1690	$dim = $this->getOpVal($op2, $EX);
1691	if ($opc == XC_ISSET_ISEMPTY_PROP_OBJ) {
1692	if (!isset($container)) {
1693	$container = '$this';
1694	}
1695	$rvalue = str($container, $EX) . "->" . unquoteVariableName($dim);
1696	}
1697	else {
1698	$rvalue = str($container, $EX) . '[' . str($dim) .']';
1699	}
1700	}
1701
1702	/* TODO: use type mask */
1703	switch (($ext & ZEND_ISSET_ISEMPTY_MASK)) {
1704	case ZEND_ISSET:
1705	$rvalue = "isset(" . str($rvalue) . ")";
1706	break;
1707	case ZEND_ISEMPTY:
1708	$rvalue = "empty(" . str($rvalue) . ")";
1709	break;
1710	}
1711	$resvar = $rvalue;
1712	break;
1713	// }}}
1714	case XC_SEND_VAR_NO_REF:
1715	case XC_SEND_VAL:
1716	case XC_SEND_REF:
1717	case XC_SEND_VAR: // {{{
1718	$ref = ($opc == XC_SEND_REF ? '&' : '');
1719	$EX['argstack'][] = $ref . str($this->getOpVal($op1, $EX));
1720	break;
1721	// }}}
1722	case XC_INIT_STATIC_METHOD_CALL:
1723	case XC_INIT_METHOD_CALL: // {{{
1724	array_push($EX['arg_types_stack'], array($EX['fbc'], $EX['object'], $EX['called_scope']));
1725	if ($opc == XC_INIT_STATIC_METHOD_CALL \|\| $opc == XC_INIT_METHOD_CALL \|\| $op1['op_type'] != XC_IS_UNUSED) {
1726	$obj = $this->getOpVal($op1, $EX);
1727	if (!isset($obj)) {
1728	$obj = '$this';
1729	}
1730	if ($opc == XC_INIT_STATIC_METHOD_CALL \|\| /* PHP4 */ isset($op1['constant'])) {
1731	$EX['object'] = null;
1732	$EX['called_scope'] = $this->stripNamespace(unquoteName($obj, $EX));
1733	}
1734	else {
1735	$EX['object'] = $obj;
1736	$EX['called_scope'] = null;
1737	}
1738	if ($res['op_type'] != XC_IS_UNUSED) {
1739	$resvar = '$obj call$';
1740	}
1741	}
1742	else {
1743	$EX['object'] = null;
1744	$EX['called_scope'] = null;
1745	}
1746
1747	$EX['fbc'] = $this->getOpVal($op2, $EX);
1748	if (($opc == XC_INIT_STATIC_METHOD_CALL \|\| $opc == XC_INIT_METHOD_CALL) && !isset($EX['fbc'])) {
1749	$EX['fbc'] = '__construct';
1750	}
1751	break;
1752	// }}}
1753	case XC_INIT_NS_FCALL_BY_NAME:
1754	case XC_INIT_FCALL_BY_NAME: // {{{
1755	array_push($EX['arg_types_stack'], array($EX['fbc'], $EX['object'], $EX['called_scope']));
1756	$EX['object'] = null;
1757	$EX['called_scope'] = null;
1758	$EX['fbc'] = $this->getOpVal($op2, $EX);
1759	break;
1760	// }}}
1761	case XC_INIT_FCALL_BY_FUNC: // {{{ deprecated even in PHP 4?
1762	$EX['object'] = null;
1763	$EX['called_scope'] = null;
1764	$which = $op1['var'];
1765	$EX['fbc'] = $EX['op_array']['funcs'][$which]['name'];
1766	break;
1767	// }}}
1768	case XC_DO_FCALL_BY_FUNC:
1769	$which = $op1['var'];
1770	$fname = $EX['op_array']['funcs'][$which]['name'];
1771	$args = $this->popargs($EX, $ext);
1772	$resvar = $fname . "($args)";
1773	break;
1774	case XC_DO_FCALL:
1775	$fname = unquoteName($this->getOpVal($op1, $EX), $EX);
1776	$args = $this->popargs($EX, $ext);
1777	$resvar = $fname . "($args)";
1778	break;
1779	case XC_DO_FCALL_BY_NAME: // {{{
1780	$object = null;
1781
1782	$fname = unquoteName($EX['fbc'], $EX);
1783	if (!is_int($EX['object'])) {
1784	$object = $EX['object'];
1785	}
1786
1787	$args = $this->popargs($EX, $ext);
1788
1789	$prefix = (isset($object) ? $object . '->' : '' )
1790	. (isset($EX['called_scope']) ? $EX['called_scope'] . '::' : '' );
1791	$resvar = $prefix
1792	. (!$prefix ? $this->stripNamespace($fname) : $fname)
1793	. "($args)";
1794	unset($args);
1795
1796	if (is_int($EX['object'])) {
1797	$T[$EX['object']] = $resvar;
1798	$resvar = null;
1799	}
1800	list($EX['fbc'], $EX['object'], $EX['called_scope']) = array_pop($EX['arg_types_stack']);
1801	break;
1802	// }}}
1803	case XC_VERIFY_ABSTRACT_CLASS: // {{{
1804	//unset($T[$op1['var']]);
1805	break;
1806	// }}}
1807	case XC_DECLARE_CLASS:
1808	case XC_DECLARE_INHERITED_CLASS:
1809	case XC_DECLARE_INHERITED_CLASS_DELAYED: // {{{
1810	$key = $op1['constant'];
1811	if (!isset($this->dc['class_table'][$key])) {
1812	echo 'class not found: ', $key, 'existing classes are:', "\n";
1813	var_dump(array_keys($this->dc['class_table']));
1814	exit;
1815	}
1816	$class = &$this->dc['class_table'][$key];
1817	if (!isset($class['name'])) {
1818	$class['name'] = unquoteName($this->getOpVal($op2, $EX), $EX);
1819	}
1820	if ($opc == XC_DECLARE_INHERITED_CLASS \|\| $opc == XC_DECLARE_INHERITED_CLASS_DELAYED) {
1821	$ext /= XC_SIZEOF_TEMP_VARIABLE;
1822	$class['parent'] = $T[$ext];
1823	unset($T[$ext]);
1824	}
1825	else {
1826	$class['parent'] = null;
1827	}
1828
1829	for (;;) {
1830	if ($i + 1 <= $range[1]
1831	&& $opcodes[$i + 1]['opcode'] == XC_ADD_INTERFACE
1832	&& $opcodes[$i + 1]['op1']['var'] == $res['var']) {
1833	// continue
1834	}
1835	else if ($i + 2 <= $range[1]
1836	&& $opcodes[$i + 2]['opcode'] == XC_ADD_INTERFACE
1837	&& $opcodes[$i + 2]['op1']['var'] == $res['var']
1838	&& $opcodes[$i + 1]['opcode'] == XC_FETCH_CLASS) {
1839	// continue
1840	}
1841	else {
1842	break;
1843	}
1844	$this->usedOps[XC_ADD_INTERFACE] = true;
1845
1846	$fetchop = &$opcodes[$i + 1];
1847	$interface = $this->stripNamespace(unquoteName($this->getOpVal($fetchop['op2'], $EX), $EX));
1848	$addop = &$opcodes[$i + 2];
1849	$class['interfaces'][$addop['extended_value']] = $interface;
1850	unset($fetchop, $addop);
1851	$i += 2;
1852	}
1853	$this->dclass($class, $EX['indent']);
1854	echo "\n";
1855	unset($class);
1856	break;
1857	// }}}
1858	case XC_INIT_STRING: // {{{
1859	$resvar = "''";
1860	break;
1861	// }}}
1862	case XC_ADD_CHAR:
1863	case XC_ADD_STRING:
1864	case XC_ADD_VAR: // {{{
1865	$op1val = $this->getOpVal($op1, $EX);
1866	$op2val = $this->getOpVal($op2, $EX);
1867	switch ($opc) {
1868	case XC_ADD_CHAR:
1869	$op2val = value(chr(str($op2val)));
1870	break;
1871	case XC_ADD_STRING:
1872	break;
1873	case XC_ADD_VAR:
1874	break;
1875	}
1876	if (str($op1val) == "''") {
1877	$rvalue = $op2val;
1878	}
1879	else if (str($op2val) == "''") {
1880	$rvalue = $op1val;
1881	}
1882	else {
1883	$rvalue = str($op1val) . ' . ' . str($op2val);
1884	}
1885	$resvar = $rvalue;
1886	// }}}
1887	break;
1888	case XC_PRINT: // {{{
1889	$op1val = $this->getOpVal($op1, $EX);
1890	$resvar = "print(" . str($op1val) . ")";
1891	break;
1892	// }}}
1893	case XC_ECHO: // {{{
1894	$op1val = $this->getOpVal($op1, $EX);
1895	$resvar = "echo " . str($op1val);
1896	break;
1897	// }}}
1898	case XC_EXIT: // {{{
1899	$op1val = $this->getOpVal($op1, $EX);
1900	$resvar = "exit($op1val)";
1901	break;
1902	// }}}
1903	case XC_INIT_ARRAY:
1904	case XC_ADD_ARRAY_ELEMENT: // {{{
1905	$rvalue = $this->getOpVal($op1, $EX, true);
1906
1907	if ($opc == XC_ADD_ARRAY_ELEMENT) {
1908	$assoc = $this->getOpVal($op2, $EX);
1909	if (isset($assoc)) {
1910	$curResVar->value[] = array($assoc, $rvalue);
1911	}
1912	else {
1913	$curResVar->value[] = array(null, $rvalue);
1914	}
1915	}
1916	else {
1917	if ($opc == XC_INIT_ARRAY) {
1918	$resvar = new Decompiler_Array();
1919	if (!isset($rvalue)) {
1920	continue;
1921	}
1922	}
1923
1924	$assoc = $this->getOpVal($op2, $EX);
1925	if (isset($assoc)) {
1926	$resvar->value[] = array($assoc, $rvalue);
1927	}
1928	else {
1929	$resvar->value[] = array(null, $rvalue);
1930	}
1931	}
1932	break;
1933	// }}}
1934	case XC_QM_ASSIGN:
1935	case XC_QM_ASSIGN_VAR: // {{{
1936	if (isset($curResVar) && is_a($curResVar, 'Decompiler_Binop')) {
1937	$curResVar->op2 = $this->getOpVal($op1, $EX);
1938	}
1939	else {
1940	$resvar = $this->getOpVal($op1, $EX);
1941	}
1942	break;
1943	// }}}
1944	case XC_BOOL: // {{{
1945	$resvar = /'(bool) ' ./ $this->getOpVal($op1, $EX);
1946	break;
1947	// }}}
1948	case XC_RETURN: // {{{
1949	$resvar = "return " . str($this->getOpVal($op1, $EX));
1950	break;
1951	// }}}
1952	case XC_INCLUDE_OR_EVAL: // {{{
1953	$type = $op2['var']; // hack
1954	$keyword = $this->includeTypes[$type];
1955	$resvar = "$keyword " . str($this->getOpVal($op1, $EX));
1956	break;
1957	// }}}
1958	case XC_FE_RESET: // {{{
1959	$resvar = $this->getOpVal($op1, $EX);
1960	break;
1961	// }}}
1962	case XC_FE_FETCH: // {{{
1963	$op['fe_src'] = $this->getOpVal($op1, $EX, true);
1964	$fe = new Decompiler_ForeachBox($op);
1965	$fe->iskey = false;
1966	$T[$res['var']] = $fe;
1967
1968	++ $i;
1969	if (($ext & ZEND_FE_FETCH_WITH_KEY)) {
1970	$fe = new Decompiler_ForeachBox($op);
1971	$fe->iskey = true;
1972
1973	$res = $opcodes[$i]['result'];
1974	$T[$res['var']] = $fe;
1975	}
1976	break;
1977	// }}}
1978	case XC_SWITCH_FREE: // {{{
1979	break;
1980	// }}}
1981	case XC_FREE: // {{{
1982	$free = $T[$op1['var']];
1983	if (!is_a($free, 'Decompiler_Array') && !is_a($free, 'Decompiler_Box')) {
1984	$op['php'] = is_object($free) ? $free : $this->unquote($free, '(', ')');
1985	$lastphpop = &$op;
1986	}
1987	unset($T[$op1['var']], $free);
1988	break;
1989	// }}}
1990	case XC_JMP_NO_CTOR:
1991	break;
1992	case XC_JMP_SET: // ?:
1993	$resvar = new Decompiler_Binop($this, $this->getOpVal($op1, $EX), XC_JMP_SET, null);
1994	break;
1995	case XC_JMPZ_EX: // and
1996	case XC_JMPNZ_EX: // or
1997	$resvar = $this->getOpVal($op1, $EX);
1998	break;
1999
2000	case XC_JMPNZ: // while
2001	case XC_JMPZNZ: // for
2002	case XC_JMPZ: // {{{
2003	break;
2004	// }}}
2005	case XC_CONT:
2006	case XC_BRK:
2007	$resvar = $opc == XC_CONT ? 'continue' : 'break';
2008	$count = str($this->getOpVal($op2, $EX));
2009	if ($count != '1') {
2010	$resvar .= ' ' . $count;
2011	}
2012	break;
2013	case XC_GOTO:
2014	$resvar = 'goto label' . $op['op1']['var'];
2015	$istmpres = false;
2016	break;
2017
2018	case XC_JMP: // {{{
2019	break;
2020	// }}}
2021	case XC_CASE:
2022	// $switchValue = $this->getOpVal($op1, $EX);
2023	$caseValue = $this->getOpVal($op2, $EX);
2024	$resvar = $caseValue;
2025	break;
2026	case XC_RECV_INIT:
2027	case XC_RECV:
2028	$offset = $op1['var'];
2029	$lvalue = $this->getOpVal($op['result'], $EX);
2030	if ($opc == XC_RECV_INIT) {
2031	$default = value($op['op2']['constant']);
2032	}
2033	else {
2034	$default = null;
2035	}
2036	$EX['recvs'][$offset] = array($lvalue, $default);
2037	break;
2038	case XC_POST_DEC:
2039	case XC_POST_INC:
2040	case XC_POST_DEC_OBJ:
2041	case XC_POST_INC_OBJ:
2042	case XC_PRE_DEC:
2043	case XC_PRE_INC:
2044	case XC_PRE_DEC_OBJ:
2045	case XC_PRE_INC_OBJ: // {{{
2046	$flags = array_flip(explode('_', $opname));
2047	if (isset($flags['OBJ'])) {
2048	$resvar = $this->getOpVal($op1, $EX) . '->' . unquoteVariableName($this->getOpVal($op2, $EX), $EX);
2049	}
2050	else {
2051	$resvar = $this->getOpVal($op1, $EX);
2052	}
2053	$opstr = isset($flags['DEC']) ? '--' : '++';
2054	if (isset($flags['POST'])) {
2055	$resvar .= $opstr;
2056	}
2057	else {
2058	$resvar = "$opstr$resvar";
2059	}
2060	break;
2061	// }}}
2062
2063	case XC_BEGIN_SILENCE: // {{{
2064	$EX['silence'] ++;
2065	break;
2066	// }}}
2067	case XC_END_SILENCE: // {{{
2068	$EX['silence'] --;
2069	$lastresvar = '@' . str($lastresvar, $EX);
2070	break;
2071	// }}}
2072	case XC_CAST: // {{{
2073	$type = $ext;
2074	static $type2cast = array(
2075	IS_LONG => '(int)',
2076	IS_DOUBLE => '(double)',
2077	IS_STRING => '(string)',
2078	IS_ARRAY => '(array)',
2079	IS_OBJECT => '(object)',
2080	IS_BOOL => '(bool)',
2081	IS_NULL => '(unset)',
2082	);
2083	assert(isset($type2cast[$type]));
2084	$cast = $type2cast[$type];
2085	$resvar = $cast . ' ' . $this->getOpVal($op1, $EX);
2086	break;
2087	// }}}
2088	case XC_EXT_STMT:
2089	case XC_EXT_FCALL_BEGIN:
2090	case XC_EXT_FCALL_END:
2091	case XC_EXT_NOP:
2092	break;
2093	case XC_DECLARE_FUNCTION:
2094	$this->dfunction($this->dc['function_table'][$op1['constant']], $EX['indent']);
2095	break;
2096	case XC_DECLARE_LAMBDA_FUNCTION: // {{{
2097	ob_start();
2098	$this->dfunction($this->dc['function_table'][$op1['constant']], $EX['indent']);
2099	$resvar = ob_get_clean();
2100	$istmpres = true;
2101	break;
2102	// }}}
2103	case XC_DECLARE_CONST:
2104	$name = $this->stripNamespace(unquoteName($this->getOpVal($op1, $EX), $EX));
2105	$value = str($this->getOpVal($op2, $EX));
2106	$resvar = 'const ' . $name . ' = ' . $value;
2107	break;
2108	case XC_DECLARE_FUNCTION_OR_CLASS:
2109	/* always removed by compiler */
2110	break;
2111	case XC_TICKS:
2112	$lastphpop['ticks'] = $this->getOpVal($op1, $EX);
2113	// $EX['tickschanged'] = true;
2114	break;
2115	case XC_RAISE_ABSTRACT_ERROR:
2116	// abstract function body is empty, don't need this code
2117	break;
2118	case XC_USER_OPCODE:
2119	echo '// ZEND_USER_OPCODE, impossible to decompile';
2120	break;
2121	case XC_OP_DATA:
2122	break;
2123	default: // {{{
2124	$call = array(&$this, $opname);
2125	if (is_callable($call)) {
2126	$this->usedOps[$opc] = true;
2127	$this->{$opname}($op, $EX);
2128	}
2129	else if (isset($this->binops[$opc])) { // {{{
2130	$this->usedOps[$opc] = true;
2131	$op1val = $this->getOpVal($op1, $EX);
2132	$op2val = $this->getOpVal($op2, $EX);
2133	$rvalue = new Decompiler_Binop($this, $op1val, $opc, $op2val);
2134	$resvar = $rvalue;
2135	// }}}
2136	}
2137	else if (isset($this->unaryops[$opc])) { // {{{
2138	$this->usedOps[$opc] = true;
2139	$op1val = $this->getOpVal($op1, $EX);
2140	$myop = $this->unaryops[$opc];
2141	$rvalue = $myop . str($op1val);
2142	$resvar = $rvalue;
2143	// }}}
2144	}
2145	else {
2146	$notHandled = true;
2147	}
2148	// }}}
2149	}
2150	if ($notHandled) {
2151	echo "\x1B[31m * TODO ", $opname, "\x1B[0m\n";
2152	}
2153	else {
2154	$this->usedOps[$opc] = true;
2155	}
2156
2157	if (isset($resvar)) {
2158	if ($istmpres) {
2159	$T[$res['var']] = $resvar;
2160	$lastresvar = &$T[$res['var']];
2161	}
2162	else {
2163	$op['php'] = $resvar;
2164	$lastphpop = &$op;
2165	$lastresvar = &$op['php'];
2166	}
2167	}
2168	}
2169	return $T;
2170	}
2171	// }}}
2172	function unquote($str, $st, $ed) // {{{
2173	{
2174	$l1 = strlen($st);
2175	$l2 = strlen($ed);
2176	if (substr($str, 0, $l1) === $st && substr($str, -$l2) === $ed) {
2177	$str = substr($str, $l1, -$l2);
2178	}
2179	return $str;
2180	}
2181	// }}}
2182	function popargs(&$EX, $n) // {{{
2183	{
2184	$args = array();
2185	for ($i = 0; $i < $n; $i ++) {
2186	$a = array_pop($EX['argstack']);
2187	if (is_array($a)) {
2188	array_unshift($args, foldToCode($a, $EX));
2189	}
2190	else {
2191	array_unshift($args, $a);
2192	}
2193	}
2194	return implode(', ', $args);
2195	}
2196	// }}}
2197	function dumpop($op, &$EX) // {{{
2198	{
2199	assert('isset($op)');
2200	$op1 = $op['op1'];
2201	$op2 = $op['op2'];
2202	$d = array(xcache_get_opcode($op['opcode']), $op['opcode']);
2203
2204	foreach (array('op1' => '1:', 'op2' => '2:', 'result' => '>') as $k => $kk) {
2205	switch ($op[$k]['op_type']) {
2206	case XC_IS_UNUSED:
2207	$d[$kk] = 'U:' . $op[$k]['opline_num'];
2208	break;
2209
2210	case XC_IS_VAR:
2211	$d[$kk] = '$' . $op[$k]['var'];
2212	if ($k != 'result') {
2213	$d[$kk] .= ':' . str($this->getOpVal($op[$k], $EX));
2214	}
2215	break;
2216
2217	case XC_IS_TMP_VAR:
2218	$d[$kk] = '#' . $op[$k]['var'];
2219	if ($k != 'result') {
2220	$d[$kk] .= ':' . str($this->getOpVal($op[$k], $EX));
2221	}
2222	break;
2223
2224	case XC_IS_CV:
2225	$d[$kk] = $this->getOpVal($op[$k], $EX);
2226	break;
2227
2228	default:
2229	if ($k == 'result') {
2230	var_dump($op);
2231	assert(0);
2232	exit;
2233	}
2234	else {
2235	$d[$kk] = $this->getOpVal($op[$k], $EX);
2236	}
2237	}
2238	}
2239	$d[';'] = $op['extended_value'];
2240	if (!empty($op['jmpouts'])) {
2241	$d['>>'] = implode(',', $op['jmpouts']);
2242	}
2243	if (!empty($op['jmpins'])) {
2244	$d['<<'] = implode(',', $op['jmpins']);
2245	}
2246
2247	foreach ($d as $k => $v) {
2248	echo is_int($k) ? '' : $k, str($v), "\t";
2249	}
2250	echo PHP_EOL;
2251	}
2252	// }}}
2253	function dumpRange(&$EX, $range) // {{{
2254	{
2255	for ($i = $range[0]; $i <= $range[1]; ++$i) {
2256	echo $EX['indent'], $i, "\t"; $this->dumpop($EX['opcodes'][$i], $EX);
2257	}
2258	echo $EX['indent'], "==", PHP_EOL;
2259	}
2260	// }}}
2261	function dargs(&$EX) // {{{
2262	{
2263	$op_array = &$EX['op_array'];
2264
2265	if (isset($op_array['num_args'])) {
2266	$c = $op_array['num_args'];
2267	}
2268	else if (!empty($op_array['arg_types'])) {
2269	$c = count($op_array['arg_types']);
2270	}
2271	else {
2272	// php4
2273	$c = count($EX['recvs']);
2274	}
2275
2276	$refrest = false;
2277	for ($i = 0; $i < $c; $i ++) {
2278	if ($i) {
2279	echo ', ';
2280	}
2281	$arg = $EX['recvs'][$i + 1];
2282	if (isset($op_array['arg_info'])) {
2283	$ai = $op_array['arg_info'][$i];
2284	if (isset($ai['type_hint']) ? ($ai['type_hint'] == IS_CALLABLE \|\| $ai['type_hint'] == IS_OBJECT) : !empty($ai['class_name'])) {
2285	echo $this->stripNamespace($ai['class_name']), ' ';
2286	if (!ZEND_ENGINE_2_2 && $ai['allow_null']) {
2287	echo 'or NULL ';
2288	}
2289	}
2290	else if (isset($ai['type_hint']) ? $ai['type_hint'] == IS_ARRAY : !empty($ai['array_type_hint'])) {
2291	echo 'array ';
2292	if (!ZEND_ENGINE_2_2 && $ai['allow_null']) {
2293	echo 'or NULL ';
2294	}
2295	}
2296	if ($ai['pass_by_reference']) {
2297	echo '&';
2298	}
2299	printf("\$%s", $ai['name']);
2300	}
2301	else {
2302	if ($refrest) {
2303	echo '&';
2304	}
2305	else if (!empty($op_array['arg_types']) && isset($op_array['arg_types'][$i])) {
2306	switch ($op_array['arg_types'][$i]) {
2307	case BYREF_FORCE_REST:
2308	$refrest = true;
2309	/* fall */
2310	case BYREF_FORCE:
2311	echo '&';
2312	break;
2313
2314	case BYREF_NONE:
2315	case BYREF_ALLOW:
2316	break;
2317	default:
2318	assert(0);
2319	}
2320	}
2321	echo str($arg[0], $EX);
2322	}
2323	if (isset($arg[1])) {
2324	echo ' = ', str($arg[1], $EX);
2325	}
2326	}
2327	}
2328	// }}}
2329	function duses(&$EX) // {{{
2330	{
2331	if ($EX['uses']) {
2332	echo ' use(', implode(', ', $EX['uses']), ')';
2333	}
2334	}
2335	// }}}
2336	function dfunction($func, $indent = '', $decorations = array(), $nobody = false) // {{{
2337	{
2338	$this->detectNamespace($func['op_array']['function_name']);
2339
2340	if ($nobody) {
2341	$EX = array();
2342	$EX['op_array'] = &$func['op_array'];
2343	$EX['recvs'] = array();
2344	$EX['uses'] = array();
2345	}
2346	else {
2347	ob_start();
2348	$EX = &$this->dop_array($func['op_array'], $indent . INDENT);
2349	$body = ob_get_clean();
2350	}
2351
2352	$functionName = $this->stripNamespace($func['op_array']['function_name']);
2353	$isExpression = false;
2354	if ($functionName == '{closure}') {
2355	$functionName = '';
2356	$isExpression = true;
2357	}
2358	echo $isExpression ? '' : $indent;
2359	if ($decorations) {
2360	echo implode(' ', $decorations), ' ';
2361	}
2362	echo 'function', $functionName ? ' ' . $functionName : '', '(';
2363	$this->dargs($EX);
2364	echo ")";
2365	$this->duses($EX);
2366	if ($nobody) {
2367	echo ";\n";
2368	}
2369	else {
2370	if (!$isExpression) {
2371	echo "\n";
2372	echo $indent, "{\n";
2373	}
2374	else {
2375	echo " {\n";
2376	}
2377
2378	echo $body;
2379	echo "$indent}";
2380	if (!$isExpression) {
2381	echo "\n";
2382	}
2383	}
2384	}
2385	// }}}
2386	function dclass($class, $indent = '') // {{{
2387	{
2388	$this->detectNamespace($class['name']);
2389
2390	// {{{ class decl
2391	if (!empty($class['doc_comment'])) {
2392	echo $indent;
2393	echo $class['doc_comment'];
2394	echo "\n";
2395	}
2396	$isInterface = false;
2397	$decorations = array();
2398	if (!empty($class['ce_flags'])) {
2399	if ($class['ce_flags'] & ZEND_ACC_INTERFACE) {
2400	$isInterface = true;
2401	}
2402	else {
2403	if ($class['ce_flags'] & ZEND_ACC_IMPLICIT_ABSTRACT_CLASS) {
2404	$decorations[] = "abstract";
2405	}
2406	if ($class['ce_flags'] & ZEND_ACC_FINAL_CLASS) {
2407	$decorations[] = "final";
2408	}
2409	}
2410	}
2411
2412	echo $indent;
2413	if ($decorations) {
2414	echo implode(' ', $decorations), ' ';
2415	}
2416	echo $isInterface ? 'interface ' : 'class ', $this->stripNamespace($class['name']);
2417	if ($class['parent']) {
2418	echo ' extends ', $class['parent'];
2419	}
2420	/* TODO */
2421	if (!empty($class['interfaces'])) {
2422	echo ' implements ';
2423	echo implode(', ', $class['interfaces']);
2424	}
2425	echo "\n";
2426	echo $indent, "{";
2427	// }}}
2428	$newindent = INDENT . $indent;
2429	// {{{ const, static
2430	foreach (array('constants_table' => 'const '
2431	, 'static_members' => 'static $') as $type => $prefix) {
2432	if (!empty($class[$type])) {
2433	echo "\n";
2434	// TODO: skip shadow?
2435	foreach ($class[$type] as $name => $v) {
2436	echo $newindent;
2437	echo $prefix, $name, ' = ';
2438	echo str(value($v), $newindent);
2439	echo ";\n";
2440	}
2441	}
2442	}
2443	// }}}
2444	// {{{ properties
2445	$member_variables = isset($class['properties_info']) ? $class['properties_info'] : ($class['default_static_members'] + $class['default_properties']);
2446	if ($member_variables) {
2447	echo "\n";
2448	$infos = !empty($class['properties_info']) ? $class['properties_info'] : null;
2449	foreach ($member_variables as $name => $dummy) {
2450	$info = (isset($infos) && isset($infos[$name])) ? $infos[$name] : null;
2451	if (isset($info)) {
2452	if (!empty($info['doc_comment'])) {
2453	echo $newindent;
2454	echo $info['doc_comment'];
2455	echo "\n";
2456	}
2457	}
2458
2459	echo $newindent;
2460	$static = false;
2461	if (isset($info)) {
2462	if ($info['flags'] & ZEND_ACC_STATIC) {
2463	$static = true;
2464	}
2465	}
2466	else if (isset($class['default_static_members'][$name])) {
2467	$static = true;
2468	}
2469
2470	if ($static) {
2471	echo "static ";
2472	}
2473
2474	$mangled = false;
2475	if (!isset($info)) {
2476	echo 'public ';
2477	}
2478	else {
2479	if ($info['flags'] & ZEND_ACC_SHADOW) {
2480	continue;
2481	}
2482	switch ($info['flags'] & ZEND_ACC_PPP_MASK) {
2483	case ZEND_ACC_PUBLIC:
2484	echo "public ";
2485	break;
2486	case ZEND_ACC_PRIVATE:
2487	echo "private ";
2488	$mangled = true;
2489	break;
2490	case ZEND_ACC_PROTECTED:
2491	echo "protected ";
2492	$mangled = true;
2493	break;
2494	}
2495	}
2496
2497	echo '$', $name;
2498
2499	if (isset($info['offset'])) {
2500	$value = $class[$static ? 'default_static_members_table' : 'default_properties_table'][$info['offset']];
2501	}
2502	else {
2503	$key = isset($info) ? $info['name'] . ($mangled ? "\000" : "") : $name;
2504
2505	$value = $class[$static ? 'default_static_members' : 'default_properties'][$key];
2506	}
2507	if (isset($value)) {
2508	echo ' = ';
2509	echo str(value($value), $newindent);
2510	}
2511	echo ";\n";
2512	}
2513	}
2514	// }}}
2515	// {{{ function_table
2516	if (isset($class['function_table'])) {
2517	foreach ($class['function_table'] as $func) {
2518	if (!isset($func['scope']) \|\| $func['scope'] == $class['name']) {
2519	// TODO: skip shadow here
2520	echo "\n";
2521	$opa = $func['op_array'];
2522	if (!empty($opa['doc_comment'])) {
2523	echo $newindent;
2524	echo $opa['doc_comment'];
2525	echo "\n";
2526	}
2527	$isAbstractMethod = false;
2528	$decorations = array();
2529	if (isset($opa['fn_flags'])) {
2530	if (($opa['fn_flags'] & ZEND_ACC_ABSTRACT) && !$isInterface) {
2531	$decorations[] = "abstract";
2532	$isAbstractMethod = true;
2533	}
2534	if ($opa['fn_flags'] & ZEND_ACC_FINAL) {
2535	$decorations[] = "final";
2536	}
2537	if ($opa['fn_flags'] & ZEND_ACC_STATIC) {
2538	$decorations[] = "static";
2539	}
2540
2541	switch ($opa['fn_flags'] & ZEND_ACC_PPP_MASK) {
2542	case ZEND_ACC_PUBLIC:
2543	$decorations[] = "public";
2544	break;
2545	case ZEND_ACC_PRIVATE:
2546	$decorations[] = "private";
2547	break;
2548	case ZEND_ACC_PROTECTED:
2549	$decorations[] = "protected";
2550	break;
2551	default:
2552	$decorations[] = "<visibility error>";
2553	break;
2554	}
2555	}
2556	$this->dfunction($func, $newindent, $decorations, $isInterface \|\| $isAbstractMethod);
2557	if ($opa['function_name'] == 'Decompiler') {
2558	//exit;
2559	}
2560	}
2561	}
2562	}
2563	// }}}
2564	echo $indent, "}\n";
2565	}
2566	// }}}
2567	function decompileString($string) // {{{
2568	{
2569	$this->dc = xcache_dasm_string($string);
2570	if ($this->dc === false) {
2571	echo "error compling string\n";
2572	return false;
2573	}
2574	return true;
2575	}
2576	// }}}
2577	function decompileFile($file) // {{{
2578	{
2579	$this->dc = xcache_dasm_file($file);
2580	if ($this->dc === false) {
2581	echo "error compling $file\n";
2582	return false;
2583	}
2584	return true;
2585	}
2586	// }}}
2587	function decompileDasm($content) // {{{
2588	{
2589	$this->dc = $content;
2590	return true;
2591	}
2592	// }}}
2593	function output() // {{{
2594	{
2595	echo "<?". "php\n\n";
2596	foreach ($this->dc['class_table'] as $key => $class) {
2597	if ($key{0} != "\0") {
2598	$this->dclass($class);
2599	echo "\n";
2600	}
2601	}
2602
2603	foreach ($this->dc['function_table'] as $key => $func) {
2604	if ($key{0} != "\0") {
2605	$this->dfunction($func);
2606	echo "\n";
2607	}
2608	}
2609
2610	$this->dop_array($this->dc['op_array']);
2611	echo "\n?" . ">\n";
2612
2613	if (!empty($this->test)) {
2614	$this->outputUnusedOp();
2615	}
2616	return true;
2617	}
2618	// }}}
2619	function outputUnusedOp() // {{{
2620	{
2621	for ($i = 0; $opname = xcache_get_opcode($i); $i ++) {
2622	if ($opname == 'UNDEF') {
2623	continue;
2624	}
2625
2626	if (!isset($this->usedOps[$i])) {
2627	echo "not covered opcode ", $opname, "\n";
2628	}
2629	}
2630	}
2631	// }}}
2632	}
2633
2634	// {{{ defines
2635	define('ZEND_ENGINE_2_4', PHP_VERSION >= "5.4");
2636	define('ZEND_ENGINE_2_3', ZEND_ENGINE_2_4 \|\| PHP_VERSION >= "5.3.");
2637	define('ZEND_ENGINE_2_2', ZEND_ENGINE_2_3 \|\| PHP_VERSION >= "5.2.");
2638	define('ZEND_ENGINE_2_1', ZEND_ENGINE_2_2 \|\| PHP_VERSION >= "5.1.");
2639
2640	define('ZEND_ACC_STATIC', 0x01);
2641	define('ZEND_ACC_ABSTRACT', 0x02);
2642	define('ZEND_ACC_FINAL', 0x04);
2643	define('ZEND_ACC_IMPLEMENTED_ABSTRACT', 0x08);
2644
2645	define('ZEND_ACC_IMPLICIT_ABSTRACT_CLASS', 0x10);
2646	define('ZEND_ACC_EXPLICIT_ABSTRACT_CLASS', 0x20);
2647	define('ZEND_ACC_FINAL_CLASS', 0x40);
2648	define('ZEND_ACC_INTERFACE', 0x80);
2649	if (ZEND_ENGINE_2_4) {
2650	define('ZEND_ACC_TRAIT', 0x120);
2651	}
2652	define('ZEND_ACC_PUBLIC', 0x100);
2653	define('ZEND_ACC_PROTECTED', 0x200);
2654	define('ZEND_ACC_PRIVATE', 0x400);
2655	define('ZEND_ACC_PPP_MASK', (ZEND_ACC_PUBLIC \| ZEND_ACC_PROTECTED \| ZEND_ACC_PRIVATE));
2656
2657	define('ZEND_ACC_CHANGED', 0x800);
2658	define('ZEND_ACC_IMPLICIT_PUBLIC', 0x1000);
2659
2660	define('ZEND_ACC_CTOR', 0x2000);
2661	define('ZEND_ACC_DTOR', 0x4000);
2662	define('ZEND_ACC_CLONE', 0x8000);
2663
2664	define('ZEND_ACC_ALLOW_STATIC', 0x10000);
2665
2666	define('ZEND_ACC_SHADOW', 0x2000);
2667
2668	if (ZEND_ENGINE_2_4) {
2669	define('ZEND_FETCH_GLOBAL', 0x00000000);
2670	define('ZEND_FETCH_LOCAL', 0x10000000);
2671	define('ZEND_FETCH_STATIC', 0x20000000);
2672	define('ZEND_FETCH_STATIC_MEMBER', 0x30000000);
2673	define('ZEND_FETCH_GLOBAL_LOCK', 0x40000000);
2674	define('ZEND_FETCH_LEXICAL', 0x50000000);
2675
2676	define('ZEND_FETCH_TYPE_MASK', 0x70000000);
2677
2678	define('ZEND_FETCH_STANDARD', 0x00000000);
2679	define('ZEND_FETCH_ADD_LOCK', 0x08000000);
2680	define('ZEND_FETCH_MAKE_REF', 0x04000000);
2681	}
2682	else {
2683	define('ZEND_FETCH_GLOBAL', 0);
2684	define('ZEND_FETCH_LOCAL', 1);
2685	define('ZEND_FETCH_STATIC', 2);
2686	define('ZEND_FETCH_STATIC_MEMBER', 3);
2687	define('ZEND_FETCH_GLOBAL_LOCK', 4);
2688
2689	define('ZEND_FETCH_STANDARD', 0);
2690	define('ZEND_FETCH_ADD_LOCK', 1);
2691	}
2692
2693	if (ZEND_ENGINE_2_4) {
2694	define('ZEND_ISSET', 0x02000000);
2695	define('ZEND_ISEMPTY', 0x01000000);
2696	define('ZEND_ISSET_ISEMPTY_MASK', (ZEND_ISSET \| ZEND_ISEMPTY));
2697	define('ZEND_QUICK_SET', 0x00800000);
2698	}
2699	else {
2700	define('ZEND_ISSET', (1<<0));
2701	define('ZEND_ISEMPTY', (1<<1));
2702
2703	define('ZEND_ISSET_ISEMPTY_MASK', (ZEND_ISSET \| ZEND_ISEMPTY));
2704	}
2705
2706	define('ZEND_FETCH_CLASS_DEFAULT', 0);
2707	define('ZEND_FETCH_CLASS_SELF', 1);
2708	define('ZEND_FETCH_CLASS_PARENT', 2);
2709	define('ZEND_FETCH_CLASS_MAIN', 3);
2710	define('ZEND_FETCH_CLASS_GLOBAL', 4);
2711	define('ZEND_FETCH_CLASS_AUTO', 5);
2712	define('ZEND_FETCH_CLASS_INTERFACE', 6);
2713	define('ZEND_FETCH_CLASS_STATIC', 7);
2714	if (ZEND_ENGINE_2_4) {
2715	define('ZEND_FETCH_CLASS_TRAIT', 14);
2716	}
2717	if (ZEND_ENGINE_2_3) {
2718	define('ZEND_FETCH_CLASS_MASK', 0xF);
2719	}
2720
2721	define('ZEND_EVAL', (1<<0));
2722	define('ZEND_INCLUDE', (1<<1));
2723	define('ZEND_INCLUDE_ONCE', (1<<2));
2724	define('ZEND_REQUIRE', (1<<3));
2725	define('ZEND_REQUIRE_ONCE', (1<<4));
2726
2727	if (ZEND_ENGINE_2_4) {
2728	define('EXT_TYPE_UNUSED', (1<<5));
2729	}
2730	else {
2731	define('EXT_TYPE_UNUSED', (1<<0));
2732	}
2733
2734	define('ZEND_FE_FETCH_BYREF', 1);
2735	define('ZEND_FE_FETCH_WITH_KEY', 2);
2736
2737	define('ZEND_MEMBER_FUNC_CALL', 1<<0);
2738	define('ZEND_CTOR_CALL', 1<<1);
2739
2740	define('ZEND_ARG_SEND_BY_REF', (1<<0));
2741	define('ZEND_ARG_COMPILE_TIME_BOUND', (1<<1));
2742	define('ZEND_ARG_SEND_FUNCTION', (1<<2));
2743
2744	define('BYREF_NONE', 0);
2745	define('BYREF_FORCE', 1);
2746	define('BYREF_ALLOW', 2);
2747	define('BYREF_FORCE_REST', 3);
2748	define('IS_NULL', 0);
2749	define('IS_LONG', 1);
2750	define('IS_DOUBLE', 2);
2751	define('IS_BOOL', 3);
2752	define('IS_ARRAY', 4);
2753	define('IS_OBJECT', 5);
2754	define('IS_STRING', 6);
2755	define('IS_RESOURCE', 7);
2756	define('IS_CONSTANT', 8);
2757	define('IS_CONSTANT_ARRAY', 9);
2758	if (ZEND_ENGINE_2_4) {
2759	define('IS_CALLABLE', 10);
2760	}
2761	/* Ugly hack to support constants as static array indices */
2762	define('IS_CONSTANT_TYPE_MASK', 0x0f);
2763	define('IS_CONSTANT_UNQUALIFIED', 0x10);
2764	define('IS_CONSTANT_INDEX', 0x80);
2765	define('IS_LEXICAL_VAR', 0x20);
2766	define('IS_LEXICAL_REF', 0x40);
2767
2768	@define('XC_IS_CV', 16);
2769
2770	/*
2771	if (preg_match_all('!XC_[A-Z_]+!', file_get_contents(__FILE__), $ms)) {
2772	$verdiff = array();
2773	foreach ($ms[0] as $k) {
2774	if (!defined($k)) {
2775	$verdiff[$k] = -1;
2776	define($k, -1);
2777	}
2778	}
2779	var_export($verdiff);
2780	exit;
2781	}
2782	//*/
2783	foreach (array (
2784	'XC_DECLARE_FUNCTION_OR_CLASS' => -1,
2785	'XC_DECLARE_LAMBDA_FUNCTION' => -1,
2786	'XC_DO_FCALL_BY_FUNC' => -1,
2787	'XC_INIT_FCALL_BY_FUNC' => -1,
2788	'XC_ISSET_ISEMPTY' => -1,
2789	'XC_JMP_NO_CTOR' => -1,
2790	'XC_JMP_SET' => -1,
2791	'XC_QM_ASSIGN_VAR' => -1,
2792	'XC_UNSET_DIM_OBJ' => -1,
2793	) as $k => $v) {
2794	if (!defined($k)) {
2795	define($k, $v);
2796	}
2797	}
2798	// }}}
2799

Note: See TracBrowser for help on using the repository browser.

Download in other formats: