Changeset 811 for trunk


Ignore:
Timestamp:
2011-04-27T09:55:20+02:00 (3 years ago)
Author:
moo
Message:

Decompiler: clean up unused code, fix line spacing, simplify indent

Location:
trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/Decompiler.class.php

    r810 r811  
    559559    } 
    560560    // }}} 
    561     function outputPhp(&$EX, $range, $indent) // {{{ 
     561    function outputPhp(&$EX, $range) // {{{ 
    562562    { 
    563563        $needBlankline = isset($EX['lastBlock']); 
    564         $origindent = $indent; 
     564        $indent = $EX['indent']; 
    565565        $curticks = 0; 
    566566        for ($i = $range[0]; $i <= $range[1]; $i ++) { 
     
    579579                    $curticks = $toticks; 
    580580                    if (!$curticks) { 
    581                         echo $origindent, "}\n\n"; 
    582                         $indent = $origindent; 
     581                        echo $EX['indent'], "}\n\n"; 
     582                        $indent = $EX['indent']; 
    583583                    } 
    584584                    else { 
    585585                        if ($oldticks) { 
    586                             echo $origindent, "}\n\n"; 
     586                            echo $EX['indent'], "}\n\n"; 
    587587                        } 
    588588                        else if (!$oldticks) { 
     
    593593                            echo PHP_EOL; 
    594594                        } 
    595                         echo $origindent, "declare (ticks=$curticks) {\n"; 
     595                        echo $EX['indent'], "declare (ticks=$curticks) {\n"; 
    596596                    } 
    597597                } 
     
    605605        } 
    606606        if ($curticks) { 
    607             echo $origindent, "}\n"; 
     607            echo $EX['indent'], "}\n"; 
    608608        } 
    609609    } 
     
    700700    } 
    701701    // }}} 
    702     function decompileBasicBlock(&$EX, $range, $indent, $unhandled = false) // {{{ 
     702    function decompileBasicBlock(&$EX, $range, $unhandled = false) // {{{ 
    703703    { 
    704704        $this->dasmBasicBlock($EX, $range); 
    705705        if ($unhandled) { 
    706             $this->dumpRange($EX, $range, $indent); 
    707         } 
    708         $this->outputPhp($EX, $range, $indent); 
     706            $this->dumpRange($EX, $range); 
     707        } 
     708        $this->outputPhp($EX, $range); 
    709709    } 
    710710    // }}} 
     
    731731    } 
    732732    // }}} 
     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    // }}} 
    733747    function beginComplexBlock(&$EX) // {{{ 
    734748    { 
     
    744758    } 
    745759    // }}} 
    746     function decompileComplexBlock(&$EX, $range, $indent) // {{{ 
     760    function decompileComplexBlock(&$EX, $range) // {{{ 
    747761    { 
    748762        $T = &$EX['Ts']; 
    749763        $opcodes = &$EX['opcodes']; 
     764        $indent = $EX['indent']; 
    750765 
    751766        $firstOp = &$opcodes[$range[0]]; 
     
    760775            $this->removeJmpInfo($EX, $range[0]); 
    761776 
    762             $this->recognizeAndDecompileClosedBlocks($EX, array($range[0], $range[0]), $indent . INDENT); 
     777            $this->recognizeAndDecompileClosedBlocks($EX, array($range[0], $range[0])); 
    763778            $op1 = $this->getOpVal($firstOp['result'], $EX, true); 
    764779 
    765             $this->recognizeAndDecompileClosedBlocks($EX, array($range[0] + 1, $range[1]), $indent . INDENT); 
     780            $this->recognizeAndDecompileClosedBlocks($EX, array($range[0] + 1, $range[1])); 
    766781            $op2 = $this->getOpVal($lastOp['result'], $EX, true); 
    767782 
     
    782797 
    783798            $condition = $this->getOpVal($firstOp['op1'], $EX); 
    784             $this->recognizeAndDecompileClosedBlocks($EX, $trueRange, $indent . INDENT); 
     799            $this->recognizeAndDecompileClosedBlocks($EX, $trueRange); 
    785800            $trueValue = $this->getOpVal($opcodes[$trueRange[1]]['result'], $EX, true); 
    786             $this->recognizeAndDecompileClosedBlocks($EX, $falseRange, $indent . INDENT); 
     801            $this->recognizeAndDecompileClosedBlocks($EX, $falseRange); 
    787802            $falseValue = $this->getOpVal($opcodes[$falseRange[1]]['result'], $EX, true); 
    788803            $T[$opcodes[$trueRange[1]]['result']['var']] = new Decompiler_TriOp($condition, $trueValue, $falseValue); 
     
    798813            $opcodes[$target]['gofrom'][] = $range[0]; 
    799814 
    800             $this->recognizeAndDecompileClosedBlocks($EX, $range, $indent); 
     815            $this->recognizeAndDecompileClosedBlocks($EX, $range); 
    801816            return false; 
    802817        } 
     
    814829 
    815830            $initial = ''; 
    816             $this->dasmBasicBlock($EX, $conditionRange, $indent . INDENT); 
     831            $this->beginScope($EX); 
     832            $this->dasmBasicBlock($EX, $conditionRange); 
    817833            $conditionCodes = array(); 
    818834            for ($i = $conditionRange[0]; $i <= $conditionRange[1]; ++$i) { 
     
    825841                $conditionCodes = array(); 
    826842            } 
    827  
    828             $this->dasmBasicBlock($EX, $nextRange, $indent . INDENT); 
     843            $this->endScope($EX); 
     844 
     845            $this->beginScope($EX); 
     846            $this->dasmBasicBlock($EX, $nextRange); 
    829847            $nextCodes = array(); 
    830848            for ($i = $nextRange[0]; $i <= $nextRange[1]; ++$i) { 
     
    833851                } 
    834852            } 
     853            $this->endScope($EX); 
     854 
    835855            $this->beginComplexBlock($EX); 
    836856            echo $indent, 'for (', str($initial, $EX), '; ', implode(', ', $conditionCodes), '; ', implode(', ', $nextCodes), ') ', '{', PHP_EOL; 
    837             $this->recognizeAndDecompileClosedBlocks($EX, $bodyRange, $indent . INDENT); 
     857            $this->beginScope($EX); 
     858            $this->recognizeAndDecompileClosedBlocks($EX, $bodyRange); 
     859            $this->endScope($EX); 
    838860            echo $indent, '}', PHP_EOL; 
    839861            $this->endComplexBlock($EX); 
     
    852874 
    853875                echo $indent, $isElseIf ? 'else if' : 'if', ' (', str($condition, $EX), ') ', '{', PHP_EOL; 
    854                 $this->recognizeAndDecompileClosedBlocks($EX, $ifRange, $indent . INDENT); 
     876                $this->beginScope($EX); 
     877                $this->recognizeAndDecompileClosedBlocks($EX, $ifRange); 
     878                $this->endScope($EX); 
    855879                $EX['lastBlock'] = null; 
    856880                echo $indent, '}', PHP_EOL; 
     
    873897                $elseRange = array($ifRange[1], $range[1]); 
    874898                echo $indent, 'else ', '{', PHP_EOL; 
    875                 $this->recognizeAndDecompileClosedBlocks($EX, $elseRange, $indent . INDENT); 
     899                $this->beginScope($EX); 
     900                $this->recognizeAndDecompileClosedBlocks($EX, $elseRange); 
     901                $this->endScope($EX); 
    876902                $EX['lastBlock'] = null; 
    877903                echo $indent, '}', PHP_EOL; 
     
    916942            $this->beginComplexBlock($EX); 
    917943            echo $indent, "try {", PHP_EOL; 
    918             $this->recognizeAndDecompileClosedBlocks($EX, $tryRange, $indent . INDENT); 
     944            $this->beginScope($EX); 
     945            $this->recognizeAndDecompileClosedBlocks($EX, $tryRange); 
     946            $this->endScope($EX); 
    919947            echo $indent, '}', PHP_EOL; 
    920948            foreach ($catchBlocks as $catchFirst => $catchInfo) { 
    921949                list($catchOpLine, $catchBodyLast) = $catchInfo; 
    922950                $catchBodyFirst = $catchOpLine + 1; 
    923                 $this->recognizeAndDecompileClosedBlocks($EX, array($catchFirst, $catchOpLine), $indent); 
     951                $this->dasmBasicBlock($EX, array($catchFirst, $catchOpLine)); 
    924952                $catchOp = &$opcodes[$catchOpLine]; 
    925953                echo $indent, 'catch (', str($this->getOpVal($catchOp['op1'], $EX)), ' ', str($this->getOpVal($catchOp['op2'], $EX)), ") {", PHP_EOL; 
     
    927955 
    928956                $EX['lastBlock'] = null; 
    929                 $this->recognizeAndDecompileClosedBlocks($EX, array($catchBodyFirst, $catchBodyLast), $indent . INDENT); 
     957                $this->beginScope($EX); 
     958                $this->recognizeAndDecompileClosedBlocks($EX, array($catchBodyFirst, $catchBodyLast)); 
     959                $this->endScope($EX); 
    930960                echo $indent, '}', PHP_EOL; 
    931961            } 
     
    9821012            $caseIsOut = false; 
    9831013            foreach ($cases as $caseFirst => $caseLast) { 
    984                 if ($caseIsOut && !empty($EX['lastBlock']) && empty($lastCaseFall)) { 
     1014                if ($caseIsOut && empty($lastCaseFall)) { 
    9851015                    echo PHP_EOL; 
    9861016                } 
    987                 unset($EX['lastBlock']); 
    9881017 
    9891018                $caseOp = $opcodes[$caseFirst]; 
     
    10251054                } 
    10261055 
    1027                 $this->recognizeAndDecompileClosedBlocks($EX, array($caseFirst, $caseLast), $indent . INDENT); 
     1056                $this->beginScope($EX); 
     1057                $this->recognizeAndDecompileClosedBlocks($EX, array($caseFirst, $caseLast)); 
     1058                $this->endScope($EX); 
    10281059                $caseIsOut = true; 
    10291060            } 
     
    10411072 
    10421073            echo $indent, "do {", PHP_EOL; 
    1043             $this->recognizeAndDecompileClosedBlocks($EX, $range, $indent . INDENT); 
     1074            $this->beginScope($EX); 
     1075            $this->recognizeAndDecompileClosedBlocks($EX, $range); 
     1076            $this->endScope($EX); 
    10441077            echo $indent, "} while (", str($this->getOpVal($lastOp['op1'], $EX)), ');', PHP_EOL; 
    10451078 
     
    10721105 
    10731106            ob_start(); 
    1074             $this->recognizeAndDecompileClosedBlocks($EX, $range, $indent . INDENT); 
     1107            $this->beginScope($EX); 
     1108            $this->recognizeAndDecompileClosedBlocks($EX, $range); 
     1109            $this->endScope($EX); 
    10751110            $body = ob_get_clean(); 
    10761111 
     
    10941129 
    10951130            ob_start(); 
    1096             $this->recognizeAndDecompileClosedBlocks($EX, $range, $indent . INDENT); 
     1131            $this->beginScope($EX); 
     1132            $this->recognizeAndDecompileClosedBlocks($EX, $range); 
     1133            $this->endScope($EX); 
    10971134            $body = ob_get_clean(); 
    10981135 
     
    11141151        // }}} 
    11151152 
    1116         $this->decompileBasicBlock($EX, $range, $indent, true); 
    1117     } 
    1118     // }}} 
    1119     function recognizeAndDecompileClosedBlocks(&$EX, $range, $indent) // {{{ decompile in a tree way 
     1153        $this->decompileBasicBlock($EX, $range, true); 
     1154    } 
     1155    // }}} 
     1156    function recognizeAndDecompileClosedBlocks(&$EX, $range) // {{{ decompile in a tree way 
    11201157    { 
    11211158        $opcodes = &$EX['opcodes']; 
     
    11481185                if ($blockLast >= $blockFirst) { 
    11491186                    if ($blockFirst > $starti) { 
    1150                         $this->decompileBasicBlock($EX, array($starti, $blockFirst - 1), $indent); 
    1151                     } 
    1152                     if ($this->decompileComplexBlock($EX, array($blockFirst, $blockLast), $indent) === false) { 
     1187                        $this->decompileBasicBlock($EX, array($starti, $blockFirst - 1)); 
     1188                    } 
     1189                    if ($this->decompileComplexBlock($EX, array($blockFirst, $blockLast)) === false) { 
    11531190                        if ($EX['lastBlock'] == 'complex') { 
    11541191                            echo PHP_EOL; 
     
    11681205        } 
    11691206        if ($starti <= $range[1]) { 
    1170             $this->decompileBasicBlock($EX, array($starti, $range[1]), $indent); 
     1207            $this->decompileBasicBlock($EX, array($starti, $range[1])); 
    11711208        } 
    11721209    } 
     
    12891326        $EX['argstack'] = array(); 
    12901327        $EX['arg_types_stack'] = array(); 
     1328        $EX['scopeStack'] = array(); 
    12911329        $EX['silence'] = 0; 
    12921330        $EX['recvs'] = array(); 
     
    13041342        $this->recognizeAndDecompileClosedBlocks($EX, $EX['range'], $EX['indent']); 
    13051343        return $EX; 
    1306     } 
    1307     // }}} 
    1308     function outputCode(&$EX, $range, $indent, $loop = false) // {{{ 
    1309     { 
    1310         $op = &$EX['opcodes'][$range[0]]; 
    1311         $next = $EX['nextbbs'][$range[0]]; 
    1312  
    1313         $end = $next - 1; 
    1314         if ($end > $range[1]) { 
    1315             $end = $range[1]; 
    1316         } 
    1317  
    1318         if (isset($op['jmpins'])) { 
    1319             echo "\nline", $op['line'], ":\n"; 
    1320         } 
    1321         else { 
    1322             // echo ";;;\n"; 
    1323         } 
    1324         $this->dasmBasicBlock($EX, array($opline, $end)); 
    1325         $this->outputPhp($EX, array($opline, $end), $indent); 
    1326         // jmpout op 
    1327         $op = &$EX['opcodes'][$end]; 
    1328         $op1 = $op['op1']; 
    1329         $op2 = $op['op2']; 
    1330         $ext = $op['extended_value']; 
    1331         $line = $op['line']; 
    1332  
    1333         if (isset($EX['opcodes'][$next])) { 
    1334             if (isset($range[1]) && $next > $range[1]) { 
    1335                 $next = null; 
    1336             } 
    1337         } 
    1338         else { 
    1339             $next = null; 
    1340         } 
    1341         /* 
    1342         if ($op['opcode'] == XC_JMPZ) { 
    1343             $target = $op2['opline_num']; 
    1344             if ($line + 1) { 
    1345                 $nextblock = $EX['nextbbs'][$next]; 
    1346                 $jmpop = end($nextblock); 
    1347                 if ($jmpop['opcode'] == XC_JMP) { 
    1348                     $ifendline = $op2['opline_num']; 
    1349                     if ($ifendline >= $line) { 
    1350                         $cond = $op['cond']; 
    1351                         echo "{$indent}if ($cond) {\n"; 
    1352                         $this->outputCode($EX, $next, $range[1], INDENT . $indent); 
    1353                         echo "$indent}\n"; 
    1354                         $this->outputCode($EX, $target, $range[1], $indent); 
    1355                         return; 
    1356                     } 
    1357                 } 
    1358             } 
    1359         } 
    1360         */ 
    1361         if (!isset($next)) { 
    1362             return; 
    1363         } 
    1364         if (isset($op['jmpouts']) && isset($op['isjmp'])) { 
    1365             if (isset($op['cond'])) { 
    1366                 echo "{$indent}check (" . str($op["cond"]) . ") {\n"; 
    1367                 echo INDENT; 
    1368             } 
    1369             switch ($op['opcode']) { 
    1370             case XC_CONT: 
    1371             case XC_BRK: 
    1372                 break; 
    1373  
    1374             default: 
    1375                 echo $indent; 
    1376                 echo xcache_get_opcode($op['opcode']), ' line', $op['jmpouts'][0]; 
    1377                 if (isset($op['jmpouts'][1])) { 
    1378                     echo ', line', $op['jmpouts'][1]; 
    1379                 } 
    1380                 echo ";"; 
    1381                 // echo ' // <- line', $op['line']; 
    1382                 echo "\n"; 
    1383             } 
    1384             if (isset($op['cond'])) echo "$indent}\n"; 
    1385         } 
    1386  
    1387         // proces JMPZ_EX/JMPNZ_EX for AND,OR 
    1388         $op = &$EX['opcodes'][$next]; 
    1389         /* 
    1390         if (isset($op['jmpins'])) { 
    1391             foreach (array_reverse($op['jmpins']) as $fromline) { 
    1392                 $fromop = $EX['opcodes'][$fromline]; 
    1393                 switch ($fromop['opcode']) { 
    1394                 case XC_JMPZ_EX: $opstr = 'and'; break; 
    1395                 case XC_JMPNZ_EX: $opstr = 'or'; break; 
    1396                 case XC_JMPZNZ: var_dump($fromop); exit; 
    1397                 default: continue 2; 
    1398                 } 
    1399  
    1400                 $var = $fromop['result']['var']; 
    1401                 var_dump($EX['Ts'][$var]); 
    1402                 $EX['Ts'][$var] = '(' . $fromop['and_or'] . " $opstr " . $EX['Ts'][$var] . ')'; 
    1403             } 
    1404             #$this->outputCode($EX, $next, $range[1], $indent); 
    1405             #return; 
    1406         } 
    1407         */ 
    1408         if (isset($op['cond_false'])) { 
    1409             // $this->dumpop($op, $EX); 
    1410             // any true comes here, so it's a "or" 
    1411             $cond = implode(' and ', str($op['cond_false'])); 
    1412             // var_dump($op['cond'] = $cond); 
    1413             /* 
    1414             $rvalue = implode(' or ', $op['cond_true']) . ' or ' . $rvalue; 
    1415             unset($op['cond_true']); 
    1416             */ 
    1417         } 
    1418  
    1419         $nextRange = array($next, $range[1]); 
    1420         if ($loop) { 
    1421             return $nextRange; 
    1422         } 
    1423         $this->outputCode($EX, $nextRange, $indent); 
    14241344    } 
    14251345    // }}} 
     
    19211841                    $i += 2; 
    19221842                } 
    1923                 $this->dclass($class); 
     1843                $this->dclass($class, $EX['indent']); 
    19241844                echo "\n"; 
    19251845                unset($class); 
     
    20701990            case XC_JMPZNZ: // for 
    20711991            case XC_JMPZ: // {{{ 
    2072                 if ($opc == XC_JMP_NO_CTOR && $EX['object']) { 
    2073                     $rvalue = $EX['object']; 
    2074                 } 
    2075                 else { 
    2076                     $rvalue = $this->getOpVal($op1, $EX); 
    2077                 } 
    2078  
    2079                 if (isset($op['cond_true'])) { 
    2080                     // any true comes here, so it's a "or" 
    2081                     $rvalue = implode(' or ', $op['cond_true']) . ' or ' . $rvalue; 
    2082                     unset($op['cond_true']); 
    2083                 } 
    2084                 if (isset($op['cond_false'])) { 
    2085                     echo "TODO(cond_false):\n"; 
    2086                     var_dump($op);// exit; 
    2087                 } 
    2088                 $op['cond'] = $rvalue;  
    2089                 $op['isjmp'] = true; 
    20901992                break; 
    20911993                // }}} 
    20921994            case XC_CONT: 
    20931995            case XC_BRK: 
    2094                 $op['cond'] = null; 
    2095                 $op['isjmp'] = true; 
    20961996                $resvar = $opc == XC_CONT ? 'continue' : 'break'; 
    20971997                $count = str($this->getOpVal($op2, $EX)); 
     
    21062006 
    21072007            case XC_JMP: // {{{ 
    2108                 $op['cond'] = null; 
    2109                 $op['isjmp'] = true; 
    21102008                break; 
    21112009                // }}} 
     
    23422240    } 
    23432241    // }}} 
    2344     function dumpRange(&$EX, $range, $indent = '') // {{{ 
     2242    function dumpRange(&$EX, $range) // {{{ 
    23452243    { 
    23462244        for ($i = $range[0]; $i <= $range[1]; ++$i) { 
    2347             echo $indent, $i, "\t"; $this->dumpop($EX['opcodes'][$i], $EX); 
    2348         } 
    2349         echo $indent, "==", PHP_EOL; 
    2350     } 
    2351     // }}} 
    2352     function dargs(&$EX, $indent) // {{{ 
     2245            echo $EX['indent'], $i, "\t"; $this->dumpop($EX['opcodes'][$i], $EX); 
     2246        } 
     2247        echo $EX['indent'], "==", PHP_EOL; 
     2248    } 
     2249    // }}} 
     2250    function dargs(&$EX) // {{{ 
    23532251    { 
    23542252        $op_array = &$EX['op_array']; 
     
    24102308                    } 
    24112309                } 
    2412                 echo str($arg[0], $indent); 
     2310                echo str($arg[0], $EX); 
    24132311            } 
    24142312            if (isset($arg[1])) { 
    2415                 echo ' = ', str($arg[1], $indent); 
    2416             } 
    2417         } 
    2418     } 
    2419     // }}} 
    2420     function duses(&$EX, $indent) // {{{ 
     2313                echo ' = ', str($arg[1], $EX); 
     2314            } 
     2315        } 
     2316    } 
     2317    // }}} 
     2318    function duses(&$EX) // {{{ 
    24212319    { 
    24222320        if ($EX['uses']) { 
     
    24252323    } 
    24262324    // }}} 
    2427     function dfunction($func, $indent = '', $nobody = false) // {{{ 
     2325    function dfunction($func, $indent = '', $decorations = array(), $nobody = false) // {{{ 
    24282326    { 
    24292327        $this->detectNamespace($func['op_array']['function_name']); 
     
    24372335        else { 
    24382336            ob_start(); 
    2439             $newindent = INDENT . $indent; 
    2440             $EX = &$this->dop_array($func['op_array'], $newindent); 
     2337            $EX = &$this->dop_array($func['op_array'], $indent . INDENT); 
    24412338            $body = ob_get_clean(); 
    24422339        } 
    24432340 
    24442341        $functionName = $this->stripNamespace($func['op_array']['function_name']); 
     2342        $isExpression = false; 
    24452343        if ($functionName == '{closure}') { 
    24462344            $functionName = ''; 
     2345            $isExpression = true; 
     2346        } 
     2347        echo $isExpression ? '' : $indent; 
     2348        if ($decorations) { 
     2349            echo implode(' ', $decorations), ' '; 
    24472350        } 
    24482351        echo 'function', $functionName ? ' ' . $functionName : '', '('; 
    2449         $this->dargs($EX, $indent); 
     2352        $this->dargs($EX); 
    24502353        echo ")"; 
    2451         $this->duses($EX, $indent); 
     2354        $this->duses($EX); 
    24522355        if ($nobody) { 
    24532356            echo ";\n"; 
    24542357        } 
    24552358        else { 
    2456             if ($functionName !== '') { 
     2359            if (!$isExpression) { 
    24572360                echo "\n"; 
    24582361                echo $indent, "{\n"; 
     
    24642367            echo $body; 
    24652368            echo "$indent}"; 
    2466             if ($functionName !== '') { 
     2369            if (!$isExpression) { 
    24672370                echo "\n"; 
    24682371            } 
     
    24802383            echo "\n"; 
    24812384        } 
    2482         $isinterface = false; 
     2385        $isInterface = false; 
     2386        $decorations = array(); 
    24832387        if (!empty($class['ce_flags'])) { 
    24842388            if ($class['ce_flags'] & ZEND_ACC_INTERFACE) { 
    2485                 $isinterface = true; 
     2389                $isInterface = true; 
    24862390            } 
    24872391            else { 
    24882392                if ($class['ce_flags'] & ZEND_ACC_IMPLICIT_ABSTRACT_CLASS) { 
    2489                     echo "abstract "; 
     2393                    $decorations[] = "abstract"; 
    24902394                } 
    24912395                if ($class['ce_flags'] & ZEND_ACC_FINAL_CLASS) { 
    2492                     echo "final "; 
    2493                 } 
    2494             } 
    2495         } 
    2496         echo $isinterface ? 'interface ' : 'class ', $this->stripNamespace($class['name']); 
     2396                    $decorations[] = "final"; 
     2397                } 
     2398            } 
     2399        } 
     2400 
     2401        echo $indent; 
     2402        if ($decorations) { 
     2403            echo implode(' ', $decorations), ' '; 
     2404        } 
     2405        echo $isInterface ? 'interface ' : 'class ', $this->stripNamespace($class['name']); 
    24972406        if ($class['parent']) { 
    24982407            echo ' extends ', $class['parent']; 
     
    26082517                        echo "\n"; 
    26092518                    } 
    2610                     echo $newindent; 
    26112519                    $isAbstractMethod = false; 
     2520                    $decorations = array(); 
    26122521                    if (isset($opa['fn_flags'])) { 
    2613                         if (($opa['fn_flags'] & ZEND_ACC_ABSTRACT) && !$isinterface) { 
    2614                             echo "abstract "; 
     2522                        if (($opa['fn_flags'] & ZEND_ACC_ABSTRACT) && !$isInterface) { 
     2523                            $decorations[] = "abstract"; 
    26152524                            $isAbstractMethod = true; 
    26162525                        } 
    26172526                        if ($opa['fn_flags'] & ZEND_ACC_FINAL) { 
    2618                             echo "final "; 
     2527                            $decorations[] = "final"; 
    26192528                        } 
    26202529                        if ($opa['fn_flags'] & ZEND_ACC_STATIC) { 
    2621                             echo "static "; 
     2530                            $decorations[] = "static"; 
    26222531                        } 
    26232532 
    26242533                        switch ($opa['fn_flags'] & ZEND_ACC_PPP_MASK) { 
    26252534                            case ZEND_ACC_PUBLIC: 
    2626                                 echo "public "; 
     2535                                $decorations[] = "public"; 
    26272536                                break; 
    26282537                            case ZEND_ACC_PRIVATE: 
    2629                                 echo "private "; 
     2538                                $decorations[] = "private"; 
    26302539                                break; 
    26312540                            case ZEND_ACC_PROTECTED: 
    2632                                 echo "protected "; 
     2541                                $decorations[] = "protected"; 
    26332542                                break; 
    26342543                            default: 
    2635                                 echo "<visibility error> "; 
     2544                                $decorations[] = "<visibility error>"; 
    26362545                                break; 
    26372546                        } 
    26382547                    } 
    2639                     $this->dfunction($func, $newindent, $isinterface || $isAbstractMethod); 
     2548                    $this->dfunction($func, $newindent, $decorations, $isInterface || $isAbstractMethod); 
    26402549                    if ($opa['function_name'] == 'Decompiler') { 
    26412550                        //exit; 
  • trunk/decompilesample.php

    r807 r811  
    6565    /** doc */ 
    6666    protected function protectedMethod(ClassName $a, $b = array( 
    67         array('array') 
    68         )) 
     67            array('array') 
     68            )) 
    6969    { 
    7070        $runtimeArray = array('1'); 
     
    155155 
    156156if ($late) { 
    157 class LateBindingClass 
    158 {} 
    159  
    160 function lateBindingFunction($arg) 
    161 { 
    162     echo 'lateFunction'; 
    163 } 
     157    class LateBindingClass 
     158    { 
     159        public function __construct() 
     160        { 
     161        } 
     162    } 
     163 
     164    function lateBindingFunction($arg) 
     165    { 
     166        echo 'lateFunction'; 
     167    } 
    164168} 
    165169 
     
    277281if (if_()) { 
    278282    echo 'if'; 
     283 
    279284    if (innerIf_()) { 
    280285        echo 'if innerIf'; 
     
    283288else if (elseif_()) { 
    284289    echo 'else if'; 
     290 
    285291    if (innerIf_()) { 
    286292        echo 'if innerIf'; 
     
    291297        echo 'if innerIf'; 
    292298    } 
     299 
    293300    echo 'else'; 
    294301} 
Note: See TracChangeset for help on using the changeset viewer.