Changeset 726


Ignore:
Timestamp:
2011-04-09T14:59:31+02:00 (3 years ago)
Author:
moo
Message:

merge from trunk

Location:
branches/1.3
Files:
19 edited

Legend:

Unmodified
Added
Removed
  • branches/1.3

  • branches/1.3/ChangeLog

    r708 r726  
    111.3.2 2011-??-?? 
    22======== 
     3 * disassembler: DECLARE_INHERITED_CLASS/DELAYED class not found 
     4 * disassembler: don't dump builtin functions 
    35 * fix win32 build against win32 native gnu tools 
    46 * compatibility fix: fix segv on shutdown when ionCube Loader is loaded 
  • branches/1.3/Decompiler.class.php

    r623 r726  
    2828 
    2929    if (is_array($src)) { 
    30         die_error('array str'); 
    31         $src = new Decompiler_Array($src, false, $indent); 
     30        exit('array str'); 
     31        $src = new Decompiler_Array($src, $indent); 
    3232        return $src->__toString(); 
    3333    } 
     
    3636        if (!method_exists($src, '__toString')) { 
    3737            var_dump($src); 
    38             die_error('no __toString'); 
    39         } 
    40         return $src->__toString($indent); 
     38            exit('no __toString'); 
     39        } 
     40        return $src->__toString(); 
    4141    } 
    4242 
     
    5555    } 
    5656 
    57     if (is_array($value)) { 
    58         $value = new Decompiler_Array($value, true); 
     57    if ($value instanceof Decompiler_Object) { 
     58        // use as is 
     59    } 
     60    else if (is_array($value)) { 
     61        $value = new Decompiler_Array($value); 
    5962    } 
    6063    else { 
    61         $value = new Decompiler_Value($value, true); 
     64        $value = new Decompiler_Value($value); 
    6265    } 
    6366    return $value; 
     
    257260class Decompiler_Array extends Decompiler_Value // {{{ 
    258261{ 
    259     var $needExport = false; 
    260262    var $indent = ''; 
    261263 
    262     function Decompiler_Array($value = array(), $needexport = false, $indent = '') 
     264    function Decompiler_Array($value = array(), $indent = '') 
    263265    { 
    264266        $this->value = $value; 
    265         $this->needExport = $needexport; 
    266267        $this->indent = $indent; 
    267268    } 
     
    286287            ++ $i; 
    287288        } 
    288         if ($assoclen && $this->needExport) { 
     289        if ($assoclen) { 
    289290            $assoclen += 2; 
    290291        } 
     
    306307            } 
    307308 
    308             if ($this->needExport) { 
    309                 $k = var_export($k, true); 
    310             } 
     309            $k = var_export($k, true); 
    311310            if ($multiline) { 
    312311                $exp .= sprintf("%{$assoclen}s => ", $k); 
     
    316315            } 
    317316 
    318             if (is_array($v)) { 
    319                 $v = new Decompiler_Array($v, $this->needExport); 
    320             } 
    321             $exp .= str($v, $subindent); 
     317            $exp .= str(value($v), $subindent); 
    322318 
    323319            $i ++; 
     
    433429        switch ($op['op_type']) { 
    434430        case XC_IS_CONST: 
    435             return str(value($op['u.constant'])); 
     431            return str(value($op['constant'])); 
    436432 
    437433        case XC_IS_VAR: 
    438434        case XC_IS_TMP_VAR: 
    439435            $T = &$EX['Ts']; 
    440             $ret = $T[$op['u.var']]; 
     436            $ret = $T[$op['var']]; 
    441437            if ($tostr) { 
    442438                $ret = str($ret, $EX); 
    443439            } 
    444440            if ($free) { 
    445                 unset($T[$op['u.var']]); 
     441                unset($T[$op['var']]); 
    446442            } 
    447443            return $ret; 
    448444 
    449445        case XC_IS_CV: 
    450             $var = $op['u.var']; 
     446            $var = $op['var']; 
    451447            $var = $EX['op_array']['vars'][$var]; 
    452448            return '$' . $var['name']; 
     
    455451            return null; 
    456452        } 
     453    } 
     454    // }}} 
     455    function removeKeyPrefix($array, $prefix) // {{{ 
     456    { 
     457        $prefixLen = strlen($prefix); 
     458        $ret = array(); 
     459        foreach ($array as $key => $value) { 
     460            if (substr($key, 0, $prefixLen) == $prefix) { 
     461                $key = substr($key, $prefixLen); 
     462            } 
     463            $ret[$key] = $value; 
     464        } 
     465        return $ret; 
    457466    } 
    458467    // }}} 
     
    465474        } 
    466475        $EX['indent'] = ''; 
    467         //for ($i = 0, $cnt = count($opcodes); $i < $cnt; $i ++) { 
    468         //  $opcodes[$i]['opcode'] = xcache_get_fixed_opcode($opcodes[$i]['opcode'], $i); 
    469         //} 
     476        for ($i = 0, $cnt = count($opcodes); $i < $cnt; $i ++) { 
     477            if (function_exists('xcache_get_fixed_opcode')) { 
     478                $opcodes[$i]['opcode'] = xcache_get_fixed_opcode($opcodes[$i]['opcode'], $i); 
     479            } 
     480            if (isset($opcodes[$i]['op1'])) { 
     481                $opcodes[$i]['op1'] = $this->removeKeyPrefix($opcodes[$i]['op1'], 'u.'); 
     482                $opcodes[$i]['op2'] = $this->removeKeyPrefix($opcodes[$i]['op2'], 'u.'); 
     483                $opcodes[$i]['result'] = $this->removeKeyPrefix($opcodes[$i]['result'], 'u.'); 
     484            } 
     485            else { 
     486                $op = array( 
     487                    'op1' => array(), 
     488                    'op2' => array(), 
     489                    'op3' => array(), 
     490                ); 
     491                foreach ($opcodes[$i] as $name => $value) { 
     492                    if (preg_match('!^(op1|op2|result)\\.(.*)!', $name, $m)) { 
     493                        list(, $which, $field) = $m; 
     494                        $op[$which][$field] = $value; 
     495                    } 
     496                    else if (preg_match('!^(op1|op2|result)_type$!', $name, $m)) { 
     497                        list(, $which) = $m; 
     498                        $op[$which]['op_type'] = $value; 
     499                    } 
     500                    else { 
     501                        $op[$name] = $value; 
     502                    } 
     503                } 
     504                $opcodes[$i] = $op; 
     505            } 
     506        } 
    470507        // {{{ build jmp array 
    471508        for ($i = 0, $cnt = count($opcodes); $i < $cnt; $i ++) { 
     
    481518            switch ($op['opcode']) { 
    482519            case XC_JMP: 
    483                 $target = $op['op1']['u.var']; 
     520                $target = $op['op1']['var']; 
    484521                $op['jmpouts'] = array($target); 
    485522                $opcodes[$target]['jmpins'][] = $i; 
     
    487524 
    488525            case XC_JMPZNZ: 
    489                 $jmpz = $op['op2']['u.opline_num']; 
     526                $jmpz = $op['op2']['opline_num']; 
    490527                $jmpnz = $op['extended_value']; 
    491528                $op['jmpouts'] = array($jmpz, $jmpnz); 
     
    501538            case XC_FE_FETCH: 
    502539            // case XC_JMP_NO_CTOR: 
    503                 $target = $op['op2']['u.opline_num']; 
     540                $target = $op['op2']['opline_num']; 
    504541                //if (!isset($target)) { 
    505542                //  $this->dumpop($op, $EX); 
     
    539576        // func call 
    540577        $EX['object'] = null; 
     578        $EX['called_scope'] = null; 
    541579        $EX['fbc'] = null; 
    542580        $EX['argstack'] = array(); 
     
    588626        if ($op['opcode'] == XC_FE_FETCH) { 
    589627            $opline = $next; 
    590             $next = $op['op2']['u.opline_num']; 
     628            $next = $op['op2']['opline_num']; 
    591629            $end = $next - 1; 
    592630 
     
    607645        /* 
    608646        if ($op['opcode'] == XC_JMPZ) { 
    609             $target = $op2['u.opline_num']; 
     647            $target = $op2['opline_num']; 
    610648            if ($line + 1) { 
    611649                $nextblock = $EX['nextbbs'][$next]; 
    612650                $jmpop = end($nextblock); 
    613651                if ($jmpop['opcode'] == XC_JMP) { 
    614                     $ifendline = $op2['u.opline_num']; 
     652                    $ifendline = $op2['opline_num']; 
    615653                    if ($ifendline >= $line) { 
    616654                        $cond = $op['cond']; 
     
    657695                } 
    658696 
    659                 $var = $fromop['result']['u.var']; 
     697                $var = $fromop['result']['var']; 
    660698                var_dump($EX['Ts'][$var]); 
    661699                $EX['Ts'][$var] = '(' . $fromop['and_or'] . " $opstr " . $EX['Ts'][$var] . ')'; 
     
    719757 
    720758            $resvar = null; 
    721             if (($res['u.EA.type'] & EXT_TYPE_UNUSED) || $res['op_type'] == XC_IS_UNUSED) { 
     759            if (isset($res['EA.type']) && ($res['EA.type'] & EXT_TYPE_UNUSED) || $res['op_type'] == XC_IS_UNUSED) { 
    722760                $istmpres = false; 
    723761            } 
     
    749787                switch ($opc) { 
    750788                case XC_NEW: // {{{ 
    751                     array_push($EX['arg_types_stack'], array($EX['object'], $EX['fbc'])); 
    752                     $EX['object'] = (int) $res['u.var']; 
     789                    array_push($EX['arg_types_stack'], array($EX['fbc'], $EX['object'], $EX['called_scope'])); 
     790                    $EX['object'] = (int) $res['var']; 
     791                    $EX['called_scope'] = null; 
    753792                    $EX['fbc'] = 'new ' . $this->unquoteName($this->getOpVal($op1, $EX)); 
    754793                    if (PHP_VERSION < 5) { 
     
    765804                        case ZEND_FETCH_CLASS_PARENT: 
    766805                            $class = 'parent'; 
    767                         } 
     806                            break; 
     807                        case ZEND_FETCH_CLASS_STATIC: 
     808                            $class = 'static'; 
     809                            break; 
     810                        } 
     811                        $istmpres = true; 
    768812                    } 
    769813                    else { 
    770                         $class = $op2['u.constant']; 
     814                        $class = $op2['constant']; 
    771815                        if (is_object($class)) { 
    772816                            $class = get_class($class); 
     
    778822                case XC_FETCH_CONSTANT: // {{{ 
    779823                    if ($op1['op_type'] == XC_IS_CONST) { 
    780                         $resvar = $op1['u.constant']; 
     824                        $resvar = $op1['constant']; 
    781825                    } 
    782826                    else if ($op1['op_type'] == XC_IS_UNUSED) { 
    783                         $resvar = $op2['u.constant']; 
     827                        $resvar = $op2['constant']; 
    784828                    } 
    785829                    else { 
    786                         $class = $T[$op1['u.var']]; 
     830                        $class = $T[$op1['var']]; 
    787831                        assert($class[0] == 'class'); 
    788                         $resvar = $class[1] . '::' . $op2['u.constant']; 
     832                        $resvar = $class[1] . '::' . $op2['constant']; 
    789833                    } 
    790834                    break; 
     
    799843                case XC_UNSET_VAR: 
    800844                    $rvalue = $this->getOpVal($op1, $EX); 
    801                     $fetchtype = $op2[PHP_VERSION < 5 ? 'u.fetch_type' : 'u.EA.type']; 
     845                    $fetchtype = $op2[PHP_VERSION < 5 ? 'fetch_type' : 'EA.type']; 
    802846                    switch ($fetchtype) { 
    803847                    case ZEND_FETCH_STATIC_MEMBER: 
     
    845889 
    846890                            $src = new Decompiler_ListBox($list); 
    847                             if (!isset($op1['u.var'])) { 
     891                            if (!isset($op1['var'])) { 
    848892                                $this->dumpop($op, $EX); 
    849893                                var_dump($op); 
    850                                 die('missing u.var'); 
     894                                die('missing var'); 
    851895                            } 
    852                             $T[$op1['u.var']] = $src; 
     896                            $T[$op1['var']] = $src; 
    853897                            unset($list); 
    854898                        } 
     
    890934                        $type = $rvalue->iskey ? 'fe_key' : 'fe_as'; 
    891935                        $rvalue->obj[$type] = $lvalue; 
    892                         unset($T[$op2['u.var']]); 
     936                        unset($T[$op2['var']]); 
    893937                        break; 
    894938                    } 
     
    9761020                            $rvalue = "${" . $rvalue . "}"; 
    9771021                        } 
    978                         if ($op2['u.EA.type'] == ZEND_FETCH_STATIC_MEMBER) { 
     1022                        if ($op2['EA.type'] == ZEND_FETCH_STATIC_MEMBER) { 
    9791023                            $class = $this->getOpVal($op2, $EX); 
    9801024                            $rvalue = $class . '::' . $rvalue; 
     
    9871031                        $container = $this->getOpVal($op1, $EX); 
    9881032                        $dim = $this->getOpVal($op2, $EX); 
    989                         $rvalue = $container . "[$dim]"; 
    990                     } 
    991  
    992                     switch (PHP_VERSION < 5 ? $op['op2']['u.var'] /* u.constant */ : $ext) { 
     1033                        if ($opc == XC_ISSET_ISEMPTY_PROP_OBJ) { 
     1034                            if (preg_match($this->rQuotedName, $dim)) { 
     1035                                $rvalue = $container . "->" . substr($dim, 1, -1); 
     1036                            } 
     1037                            else { 
     1038                                $rvalue = $container . "->{" . $dim . "}"; 
     1039                            } 
     1040                        } 
     1041                        else { 
     1042                            $rvalue = $container . "[$dim]"; 
     1043                        } 
     1044                    } 
     1045 
     1046                    switch ((PHP_VERSION < 5 ? $op['op2']['var'] /* constant */ : $ext) & (ZEND_ISSET|ZEND_ISEMPTY)) { 
    9931047                    case ZEND_ISSET: 
    9941048                        $rvalue = "isset($rvalue)"; 
     
    9971051                        $rvalue = "empty($rvalue)"; 
    9981052                        break; 
    999                     default: 
    1000                         $this->dumpop($op, $EX); 
    1001                         die_error('1'); 
    10021053                    } 
    10031054                    $resvar = $rvalue; 
     
    10121063                    break; 
    10131064                    // }}} 
     1065                case XC_INIT_STATIC_METHOD_CALL: 
    10141066                case XC_INIT_METHOD_CALL: 
    10151067                case XC_INIT_FCALL_BY_FUNC: 
     
    10181070                        break; 
    10191071                    } 
    1020                     array_push($EX['arg_types_stack'], array($EX['object'], $EX['fbc'])); 
    1021                     if ($opc == XC_INIT_METHOD_CALL || $op1['op_type'] != XC_IS_UNUSED) { 
     1072                    array_push($EX['arg_types_stack'], array($EX['fbc'], $EX['object'], $EX['called_scope'])); 
     1073                    if ($opc == XC_INIT_STATIC_METHOD_CALL || $opc == XC_INIT_METHOD_CALL || $op1['op_type'] != XC_IS_UNUSED) { 
    10221074                        $obj = $this->getOpVal($op1, $EX); 
    10231075                        if (!isset($obj)) { 
    10241076                            $obj = '$this'; 
    10251077                        } 
    1026                         $EX['object'] = $obj; 
     1078                        if ($opc == XC_INIT_STATIC_METHOD_CALL || /* PHP4 */ isset($op1['constant'])) { 
     1079                            $EX['object'] = null; 
     1080                            $EX['called_scope'] = $this->unquoteName($obj); 
     1081                        } 
     1082                        else { 
     1083                            $EX['object'] = $obj; 
     1084                            $EX['called_scope'] = null; 
     1085                        } 
    10271086                        if ($res['op_type'] != XC_IS_UNUSED) { 
    10281087                            $resvar = '$obj call$'; 
     
    10311090                    else { 
    10321091                        $EX['object'] = null; 
     1092                        $EX['called_scope'] = null; 
    10331093                    } 
    10341094 
    10351095                    if ($opc == XC_INIT_FCALL_BY_FUNC) { 
    1036                         $which = $op1['u.var']; 
     1096                        $which = $op1['var']; 
    10371097                        $EX['fbc'] = $EX['op_array']['funcs'][$which]['name']; 
    10381098                    } 
     
    10431103                    // }}} 
    10441104                case XC_DO_FCALL_BY_FUNC: 
    1045                     $which = $op1['u.var']; 
     1105                    $which = $op1['var']; 
    10461106                    $fname = $EX['op_array']['funcs'][$which]['name']; 
    10471107                    $args = $this->popargs($EX, $ext); 
     
    10651125                    $resvar = 
    10661126                        (isset($object) ? $object . '->' : '' ) 
     1127                        . (isset($EX['called_scope']) ? $EX['called_scope'] . '::' : '' ) 
    10671128                        . $fname . "($args)"; 
    10681129                    unset($args); 
     
    10721133                        $resvar = null; 
    10731134                    } 
    1074                     list($EX['object'], $EX['fbc']) = array_pop($EX['arg_types_stack']); 
     1135                    list($EX['fbc'], $EX['object'], $EX['called_scope']) = array_pop($EX['arg_types_stack']); 
    10751136                    break; 
    10761137                    // }}} 
    10771138                case XC_VERIFY_ABSTRACT_CLASS: // {{{ 
    1078                     //unset($T[$op1['u.var']]); 
     1139                    //unset($T[$op1['var']]); 
    10791140                    break; 
    10801141                    // }}} 
    10811142                case XC_DECLARE_CLASS:  
    1082                 case XC_DECLARE_INHERITED_CLASS: // {{{ 
    1083                     $key = $op1['u.constant']; 
     1143                case XC_DECLARE_INHERITED_CLASS: 
     1144                case XC_DECLARE_INHERITED_CLASS_DELAYED: // {{{ 
     1145                    $key = $op1['constant']; 
     1146                    if (!isset($this->dc['class_table'][$key])) { 
     1147                        echo 'class not found: ', $key, 'existing classes are:', "\n"; 
     1148                        var_dump(array_keys($this->dc['class_table'])); 
     1149                        exit; 
     1150                    } 
    10841151                    $class = &$this->dc['class_table'][$key]; 
    1085                     if (!isset($class)) { 
    1086                         echo 'class not found: ' . $key; 
    1087                         exit; 
    1088                     } 
    10891152                    $class['name'] = $this->unquoteName($this->getOpVal($op2, $EX)); 
    1090                     if ($opc == XC_DECLARE_INHERITED_CLASS) { 
     1153                    if ($opc == XC_DECLARE_INHERITED_CLASS || $opc == XC_DECLARE_INHERITED_CLASS_DELAYED) { 
    10911154                        $ext /= XC_SIZEOF_TEMP_VARIABLE; 
    10921155                        $class['parent'] = $T[$ext]; 
     
    10991162                    while ($i + 2 < $ic 
    11001163                     && $opcodes[$i + 2]['opcode'] == XC_ADD_INTERFACE 
    1101                      && $opcodes[$i + 2]['op1']['u.var'] == $res['u.var'] 
     1164                     && $opcodes[$i + 2]['op1']['var'] == $res['var'] 
    11021165                     && $opcodes[$i + 1]['opcode'] == XC_FETCH_CLASS) { 
    11031166                        $fetchop = &$opcodes[$i + 1]; 
     
    11651228                        $offset = $this->getOpVal($op2, $EX); 
    11661229                        if (isset($offset)) { 
    1167                             $T[$res['u.var']]->value[$offset] = $rvalue; 
     1230                            $T[$res['var']]->value[$offset] = $rvalue; 
    11681231                        } 
    11691232                        else { 
    1170                             $T[$res['u.var']]->value[] = $rvalue; 
     1233                            $T[$res['var']]->value[] = $rvalue; 
    11711234                        } 
    11721235                    } 
     
    12021265                    // }}} 
    12031266                case XC_INCLUDE_OR_EVAL: // {{{ 
    1204                     $type = $op2['u.var']; // hack 
     1267                    $type = $op2['var']; // hack 
    12051268                    $keyword = $this->includeTypes[$type]; 
    12061269                    $resvar = "$keyword(" . $this->getOpVal($op1, $EX) . ")"; 
     
    12151278                    $fe = new Decompiler_ForeachBox($op); 
    12161279                    $fe->iskey = false; 
    1217                     $T[$res['u.var']] = $fe; 
     1280                    $T[$res['var']] = $fe; 
    12181281 
    12191282                    ++ $i; 
     
    12231286 
    12241287                        $res = $opcodes[$i]['result']; 
    1225                         $T[$res['u.var']] = $fe; 
     1288                        $T[$res['var']] = $fe; 
    12261289                    } 
    12271290                    break; 
    12281291                    // }}} 
    12291292                case XC_SWITCH_FREE: // {{{ 
    1230                     // unset($T[$op1['u.var']]); 
     1293                    // unset($T[$op1['var']]); 
    12311294                    break; 
    12321295                    // }}} 
    12331296                case XC_FREE: // {{{ 
    1234                     $free = $T[$op1['u.var']]; 
     1297                    $free = $T[$op1['var']]; 
    12351298                    if (!is_a($free, 'Decompiler_Array') && !is_a($free, 'Decompiler_Box')) { 
    12361299                        $op['php'] = is_object($free) ? $free : $this->unquote($free, '(', ')'); 
    12371300                        $lastphpop = &$op; 
    12381301                    } 
    1239                     unset($T[$op1['u.var']], $free); 
     1302                    unset($T[$op1['var']], $free); 
    12401303                    break; 
    12411304                    // }}} 
     
    12601323                    } 
    12611324                    if (isset($op['cond_false'])) { 
     1325                        echo "TODO(cond_false):\n"; 
    12621326                        var_dump($op);// exit; 
    12631327                    } 
    12641328                    if ($opc == XC_JMPZ_EX || $opc == XC_JMPNZ_EX || $opc == XC_JMPZ) { 
    1265                         $targetop = &$EX['opcodes'][$op2['u.opline_num']]; 
     1329                        $targetop = &$EX['opcodes'][$op2['opline_num']]; 
    12661330                        if ($opc == XC_JMPNZ_EX) { 
    12671331                            $targetop['cond_true'][] = str($rvalue); 
     
    12911355                    $lvalue = $this->getOpVal($op['result'], $EX); 
    12921356                    if ($opc == XC_RECV_INIT) { 
    1293                         $default = value($op['op2']['u.constant']); 
     1357                        $default = value($op['op2']['constant']); 
    12941358                    } 
    12951359                    else { 
     
    13771441            if (isset($resvar)) { 
    13781442                if ($istmpres) { 
    1379                     $T[$res['u.var']] = $resvar; 
    1380                     $lastresvar = &$T[$res['u.var']]; 
     1443                    $T[$res['var']] = $resvar; 
     1444                    $lastresvar = &$T[$res['var']]; 
    13811445                } 
    13821446                else { 
     
    14241488            switch ($op[$k]['op_type']) { 
    14251489            case XC_IS_UNUSED: 
    1426                 $d[$kk] = '*UNUSED* ' . $op[$k]['u.opline_num']; 
     1490                $d[$kk] = '*UNUSED* ' . $op[$k]['opline_num']; 
    14271491                break; 
    14281492 
    14291493            case XC_IS_VAR: 
    1430                 $d[$kk] = '$' . $op[$k]['u.var']; 
     1494                $d[$kk] = '$' . $op[$k]['var']; 
    14311495                if ($kk != 'res') { 
    14321496                    $d[$kk] .= ':' . $this->getOpVal($op[$k], $EX); 
     
    14351499 
    14361500            case XC_IS_TMP_VAR: 
    1437                 $d[$kk] = '#' . $op[$k]['u.var']; 
     1501                $d[$kk] = '#' . $op[$k]['var']; 
    14381502                if ($kk != 'res') { 
    14391503                    $d[$kk] .= ':' . $this->getOpVal($op[$k], $EX); 
     
    16081672        if (!empty($class['default_properties'])) { 
    16091673            echo "\n"; 
    1610             $infos = empty($class['properties_info']) ? null : $class['properties_info']; 
    1611             foreach ($class['default_properties'] as $name => $v) { 
     1674            $infos = !empty($class['properties_info']) ? $class['properties_info'] : null; 
     1675            foreach (!empty($class['properties_info']) ? $class['properties_info'] : ($class['default_static_members'] + $class['default_properties']) as $name => $dummy) { 
    16121676                $info = (isset($infos) && isset($infos[$name])) ? $infos[$name] : null; 
    16131677                if (isset($info)) { 
     
    16201684 
    16211685                echo $newindent; 
     1686                $static = false; 
     1687                if (isset($info)) { 
     1688                    if ($info['flags'] & ZEND_ACC_STATIC) { 
     1689                        $static = true; 
     1690                    } 
     1691                } 
     1692                else if (isset($class['default_static_members'][$name])) { 
     1693                    $static = true; 
     1694                } 
     1695 
     1696                if ($static) { 
     1697                    echo "static "; 
     1698                } 
     1699 
     1700                $mangled = false; 
    16221701                if (PHP_VERSION < 5) { 
    16231702                    echo 'var '; 
     
    16361715                    case ZEND_ACC_PRIVATE: 
    16371716                        echo "private "; 
     1717                        $mangled = true; 
    16381718                        break; 
    16391719                    case ZEND_ACC_PROTECTED: 
    16401720                        echo "protected "; 
     1721                        $mangled = true; 
    16411722                        break; 
    16421723                    } 
    1643                     if ($info['flags'] & ZEND_ACC_STATIC) { 
    1644                         echo "static "; 
    1645                     } 
    16461724                } 
    16471725 
    16481726                echo '$', $name; 
    1649                 if (isset($v)) { 
     1727 
     1728                $key = isset($info) ? $info['name'] . ($mangled ? "\000" : "") : $name; 
     1729 
     1730                $value = $class[$static ? 'default_static_members' : 'default_properties'][$key]; 
     1731                if (isset($value)) { 
    16501732                    echo ' = '; 
    1651                     echo str(value($v)); 
     1733                    echo str(value($value)); 
    16521734                } 
    16531735                echo ";\n"; 
     
    17871869define('ZEND_FETCH_CLASS_AUTO',       5); 
    17881870define('ZEND_FETCH_CLASS_INTERFACE',  6); 
     1871define('ZEND_FETCH_CLASS_STATIC',     7); 
    17891872 
    17901873define('ZEND_EVAL',               (1<<0)); 
     
    18521935    'XC_ISSET_ISEMPTY_PROP_OBJ' => -1, 
    18531936    'XC_ISSET_ISEMPTY_VAR' => -1, 
     1937    'XC_INIT_STATIC_METHOD_CALL' => -1, 
    18541938    'XC_INIT_METHOD_CALL' => -1, 
    18551939    'XC_VERIFY_ABSTRACT_CLASS' => -1, 
    18561940    'XC_DECLARE_CLASS' => -1, 
    18571941    'XC_DECLARE_INHERITED_CLASS' => -1, 
     1942    'XC_DECLARE_INHERITED_CLASS_DELAYED' => -1, 
    18581943    'XC_ADD_INTERFACE' => -1, 
    18591944    'XC_POST_DEC_OBJ' => -1, 
  • branches/1.3/Makefile.frag

    r695 r726  
    3232disassembler.lo: $(XCACHE_PROC_H) $(srcdir)/processor.c 
    3333 
     34$(builddir)/opcode_spec.lo: $(srcdir)/xcache.h $(srcdir)/opcode_spec.c $(srcdir)/opcode_spec_def.h $(srcdir)/const_string.h 
     35opcode_spec.lo: $(srcdir)/xcache.h $(srcdir)/opcode_spec.c $(srcdir)/opcode_spec_def.h $(srcdir)/const_string.h 
     36 
    3437$(builddir)/xcache.lo: $(XCACHE_PROC_H) $(srcdir)/xc_shm.h $(srcdir)/stack.h $(srcdir)/xcache_globals.h $(srcdir)/xcache.c $(srcdir)/foreachcoresig.h $(srcdir)/utils.h 
    3538xcache.lo: $(XCACHE_PROC_H) $(srcdir)/xc_shm.h $(srcdir)/stack.h $(srcdir)/xcache_globals.h $(srcdir)/xcache.c $(srcdir)/foreachcoresig.h $(srcdir)/utils.h 
  • branches/1.3/NEWS

    r701 r726  
    111.3.2 2011-??-?? 
    22======== 
     3 * memory leak on recompile 
     4 * disassembler fixes and updates for new PHP 
    35 * win32 build fix 
    46 * improve compatibility with ionCube Loader 
  • branches/1.3/const_string_opcodes_php6.x.h

    r626 r726  
    1 /* size = 154 */ 
     1/* size = 157 */ 
    22static const char *const xc_opcode_names[] = { 
    33/* 0 */ "NOP", 
     
    112112/* 109 */   "FETCH_CLASS", 
    113113/* 110 */   "CLONE", 
    114 /* 111 */   "UNDEF", 
     114/* 111 */   "RETURN_BY_REF", 
    115115/* 112 */   "INIT_METHOD_CALL", 
    116116/* 113 */   "INIT_STATIC_METHOD_CALL", 
     
    152152/* 149 */   "HANDLE_EXCEPTION", 
    153153/* 150 */   "USER_OPCODE", 
    154 /* 151 */   "U_NORMALIZE", 
     154/* 151 */   "UNDEF", 
    155155/* 152 */   "JMP_SET", 
    156 /* 153 */   "DECLARE_LAMBDA_FUNCTION" 
     156/* 153 */   "DECLARE_LAMBDA_FUNCTION", 
     157/* 154 */   "ADD_TRAIT", 
     158/* 155 */   "BIND_TRAITS", 
     159/* 156 */   "SEPARATE" 
    157160}; 
  • branches/1.3/coverager.c

    r625 r726  
    379379static int xc_coverager_get_op_array_size_no_tail(zend_op_array *op_array) /* {{{ */ 
    380380{ 
    381     zend_uint size; 
    382  
    383     size = op_array->size; 
     381    zend_uint last = op_array->last; 
    384382    do { 
    385383next_op: 
    386         if (size == 0) { 
     384        if (last == 0) { 
    387385            break; 
    388386        } 
    389         switch (op_array->opcodes[size - 1].opcode) { 
     387        switch (op_array->opcodes[last - 1].opcode) { 
    390388#ifdef ZEND_HANDLE_EXCEPTION 
    391389            case ZEND_HANDLE_EXCEPTION: 
     
    393391            case ZEND_RETURN: 
    394392            case ZEND_EXT_STMT: 
    395                 size --; 
     393                --last; 
    396394                goto next_op; 
    397395        } 
    398396    } while (0); 
    399     return size; 
     397    return last; 
    400398} 
    401399/* }}} */ 
  • branches/1.3/disassembler.c

    r622 r726  
    66#define return_value dst 
    77 
     8/* sandbox {{{ */ 
     9#undef TG 
     10#undef OG 
     11#define TG(x) (sandbox->tmp_##x) 
     12#define OG(x) (sandbox->orig_##x) 
     13/* }}} */ 
     14 
    815#ifndef HAVE_XCACHE_OPCODE_SPEC_DEF 
    916#error disassembler cannot be built without xcache/opcode_spec_def.h 
    1017#endif 
    11 static void xc_dasm(zval *dst, zend_op_array *op_array TSRMLS_DC) /* {{{ */ 
     18static void xc_dasm(xc_sandbox_t *sandbox, zval *dst, zend_op_array *op_array TSRMLS_DC) /* {{{ */ 
    1219{ 
    1320    Bucket *b; 
     
    1623    int bufsize = 2; 
    1724    char *buf; 
    18     int keysize; 
    1925 
    2026    xc_compile_result_init_cur(&cr, op_array TSRMLS_CC); 
     
    3339    ALLOC_INIT_ZVAL(list); 
    3440    array_init(list); 
    35     xc_dasm_HashTable_zend_function(list, CG(function_table) TSRMLS_CC); 
     41    b = TG(internal_function_tail) ? TG(internal_function_tail)->pListNext : TG(function_table).pListHead; 
     42    for (; b; b = b->pListNext) { 
     43        ALLOC_INIT_ZVAL(zv); 
     44        array_init(zv); 
     45        xc_dasm_zend_function(zv, b->pData TSRMLS_CC); 
     46 
     47        add_u_assoc_zval_ex(list, BUCKET_KEY_TYPE(b), ZSTR(BUCKET_KEY_S(b)), b->nKeyLength, zv); 
     48    } 
    3649    add_assoc_zval_ex(dst, ZEND_STRS("function_table"), list); 
    3750     
     
    3952    ALLOC_INIT_ZVAL(list); 
    4053    array_init(list); 
    41     for (b = CG(class_table)->pListHead; b; b = b->pListNext) { 
     54    b = TG(internal_class_tail) ? TG(internal_class_tail)->pListNext : TG(class_table).pListHead; 
     55    for (; b; b = b->pListNext) { 
     56        int keysize, keyLength; 
     57 
    4258        ALLOC_INIT_ZVAL(zv); 
    4359        array_init(zv); 
     
    5369        memcpy(buf, BUCKET_KEY_S(b), keysize); 
    5470        buf[keysize - 2] = buf[keysize - 1] = ""[0]; 
    55         keysize = b->nKeyLength; 
     71        keyLength = b->nKeyLength; 
    5672#ifdef IS_UNICODE 
    5773        if (BUCKET_KEY_TYPE(b) == IS_UNICODE) { 
    5874            if (buf[0] == ""[0] && buf[1] == ""[0]) { 
    59                 keysize ++; 
     75                keyLength ++; 
    6076            } 
    6177        } else 
     
    6379        { 
    6480            if (buf[0] == ""[0]) { 
    65                 keysize ++; 
     81                keyLength ++; 
    6682            } 
    6783        } 
    68         add_u_assoc_zval_ex(list, BUCKET_KEY_TYPE(b), ZSTR(buf), b->nKeyLength, zv); 
     84        add_u_assoc_zval_ex(list, BUCKET_KEY_TYPE(b), ZSTR(buf), keyLength, zv); 
    6985    } 
    7086    efree(buf); 
     
    97113    } 
    98114 
    99     xc_dasm(dst, op_array TSRMLS_CC); 
     115    xc_dasm(&sandbox, dst, op_array TSRMLS_CC); 
    100116 
    101117    /* free */ 
     
    142158    } 
    143159 
    144     xc_dasm(dst, op_array TSRMLS_CC); 
     160    xc_dasm(&sandbox, dst, op_array TSRMLS_CC); 
    145161 
    146162    /* free */ 
  • branches/1.3/mkstructinfo.awk

    r394 r726  
    5050 
    5151            if (i == 0) { 
    52                 elms = buffer[i]; 
     52                elms = "\"" buffer[i] "\""; 
    5353            } 
    5454            else { 
    55                 elms = elms "," buffer[i]; 
     55                elms = elms "," "\"" buffer[i] "\""; 
    5656            } 
    5757        } 
  • branches/1.3/opcode_spec.c

    r394 r726  
    2020const xc_opcode_spec_t *xc_get_opcode_spec(zend_uchar opcode) 
    2121{ 
     22#ifndef NDEBUG 
     23    if (xc_get_opcode_count() != xc_get_opcode_spec_count()) { 
     24        fprintf(stderr, "count mismatch: xc_get_opcode_count=%d, xc_get_opcode_spec_count=%d\n", xc_get_opcode_count(), xc_get_opcode_spec_count()); 
     25    } 
     26#endif 
    2227    assert(xc_get_opcode_count() == xc_get_opcode_spec_count()); 
    2328    assert(opcode < xc_get_opcode_spec_count()); 
  • branches/1.3/opcode_spec_def.h

    r626 r726  
    104104#endif 
    105105#ifdef ZEND_ENGINE_2_3 
    106     OPSPEC(       STD,        STD,        STD,        STD) /* 69 INIT_NS_FCALL_BY_NAME          */ 
     106    OPSPEC(       STD,        STD,        STD,     UNUSED) /* 69 INIT_NS_FCALL_BY_NAME          */ 
    107107#else 
    108108    OPSPEC(    UNUSED,        STD,     OPLINE,     UNUSED) /* 69 JMP_NO_CTOR                    */ 
     
    147147    OPSPEC(    UNUSED,      VAR_2,        STD,        VAR) /* 97 FETCH_OBJ_UNSET                */ 
    148148    OPSPEC(    UNUSED,        STD,        STD,        VAR) /* 98 FETCH_DIM_TMP_VAR              */ 
    149  
    150149#ifdef ZEND_ENGINE_2 
    151150    OPSPEC(    UNUSED,     UCLASS,        STD,        TMP) /* 99 FETCH_CONSTANT                 */ 
     
    153152    OPSPEC(    UNUSED,        STD,     UNUSED,        TMP) /* 99 FETCH_CONSTANT                 */ 
    154153#endif 
     154#ifdef ZEND_ENGINE_2_3 
     155    OPSPEC(       STD,    JMPADDR,        STD,     UNUSED) /* 100 GOTO                           */ 
     156#else 
    155157    OPSPEC(   DECLARE,        STD,        STD,     UNUSED) /* 100 DECLARE_FUNCTION_OR_CLASS      */ 
     158#endif 
    156159    OPSPEC(       STD,        STD,        STD,        STD) /* 101 EXT_STMT                       */ 
    157160    OPSPEC(       STD,        STD,        STD,        STD) /* 102 EXT_FCALL_BEGIN                */ 
     
    165168    OPSPEC(    FCLASS,        STD,        STD,      CLASS) /* 109 FETCH_CLASS                    */ 
    166169    OPSPEC(    UNUSED,        STD,     UNUSED,        VAR) /* 110 CLONE                          */ 
     170 
    167171    OPSPEC(    UNUSED,        STD,     UNUSED,     UNUSED) /* 111 INIT_CTOR_CALL                 */ 
     172 
    168173    OPSPEC(    UNUSED,        STD,        STD,        VAR) /* 112 INIT_METHOD_CALL               */ 
     174#   ifdef ZEND_ENGINE_2_3 
     175    OPSPEC(    UNUSED,        STD,        STD,     UNUSED) /* 113 INIT_STATIC_METHOD_CALL        */ 
     176#   else 
    169177    OPSPEC(    UNUSED,     UCLASS,        STD,     UNUSED) /* 113 INIT_STATIC_METHOD_CALL        */ 
     178#   endif 
    170179    OPSPEC(     ISSET,        STD,      FETCH,        TMP) /* 114 ISSET_ISEMPTY_VAR              */ 
    171180    OPSPEC(     ISSET,        STD,        STD,        TMP) /* 115 ISSET_ISEMPTY_DIM_OBJ          */ 
     181 
    172182    OPSPEC(    UNUSED,      CLASS,        STD,     UNUSED) /* 116 IMPORT_FUNCTION                */ 
    173183    OPSPEC(    UNUSED,      CLASS,        STD,     UNUSED) /* 117 IMPORT_CLASS                   */ 
     
    186196    OPSPEC(    UNUSED,        STD,        STD,        VAR) /* 130 ASSIGN_BW_AND_OBJ              */ 
    187197    OPSPEC(    UNUSED,        STD,        STD,        VAR) /* 131 ASSIGN_BW_XOR_OBJ              */ 
     198 
    188199    OPSPEC(    UNUSED,        STD,        STD,        VAR) /* 132 PRE_INC_OBJ                    */ 
    189200    OPSPEC(    UNUSED,        STD,        STD,        VAR) /* 133 PRE_DEC_OBJ                    */ 
     
    200211    OPSPEC(   DECLARE,        STD,        STD,     UNUSED) /* 143 DECLARE_CONST                  */ 
    201212#else 
    202     OPSPEC(    UNUSED,        STD,     UNUSED,     UNUSED) /* 143 START_NAMESPACE                */ 
    203 #endif 
     213    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 143 UNDEF-143                      */ 
     214#endif 
     215#ifdef ZEND_ENGINE_2_3 
     216    OPSPEC(     IFACE,      CLASS,        STD,     UNUSED) /* 144 ADD_INTERFACE                  */ 
     217#else 
    204218    OPSPEC(     IFACE,      CLASS,      CLASS,     UNUSED) /* 144 ADD_INTERFACE                  */ 
     219#endif 
     220#ifdef ZEND_ENGINE_2_3 
     221    OPSPEC(     CLASS,        STD,        STD,     OPLINE) /* 145 DECLARE_INHERITED_CLASS_DELAYED */ 
     222#else 
    205223    OPSPEC(    UNUSED,      CLASS,        STD,     UNUSED) /* 145 VERIFY_INSTANCEOF              */ 
     224#endif 
    206225    OPSPEC(    UNUSED,      CLASS,     UNUSED,     UNUSED) /* 146 VERIFY_ABSTRACT_CLASS          */ 
    207226    OPSPEC(    UNUSED,        STD,        STD,        VAR) /* 147 ASSIGN_DIM                     */ 
    208227    OPSPEC(     ISSET,        STD,        STD,        TMP) /* 148 ISSET_ISEMPTY_PROP_OBJ         */ 
    209228    OPSPEC(       STD,     UNUSED,     UNUSED,        STD) /* 149 HANDLE_EXCEPTION               */ 
     229    OPSPEC(       STD,     UNUSED,     UNUSED,        STD) /* 150 USER_OPCODE                    */ 
    210230# ifdef ZEND_ENGINE_2_3 
    211     OPSPEC(       STD,     UNUSED,     UNUSED,        STD) /* 150 ZEND_USER_OPCODE               */ 
    212231    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 151 UNDEF                          */ 
    213     OPSPEC(    UNUSED,        STD,    JMPADDR,     UNUSED) /* 152 JMP_SET                        */ 
    214     OPSPEC(    UNUSED,        STD,        STD,     UNUSED) /* 153 DECLARE_LAMBDA_FUNCTION        */ 
     232    OPSPEC(    UNUSED,        STD,    JMPADDR,        TMP) /* 152 JMP_SET                        */ 
     233    OPSPEC(    UNUSED,        STD,        STD,        TMP) /* 153 DECLARE_LAMBDA_FUNCTION        */ 
     234# else 
     235    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 151 UNDEF                          */ 
     236    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 152 UNDEF                          */ 
     237    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 153 UNDEF                          */ 
    215238# endif 
     239#else 
     240    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 107 UNDEF                          */ 
     241    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 108 UNDEF                          */ 
     242    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 109 UNDEF                          */ 
     243    OPSPEC(     FCALL,        STD,     OPLINE,        VAR) /* 61 DO_FCALL_BY_FUNC                */ 
     244    OPSPEC(INIT_FCALL,        STD,        STD,     UNUSED) /* 111 INIT_FCALL_BY_FUNC             */ 
     245    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 112 UNDEF                          */ 
    216246#endif 
    217247}; 
  • branches/1.3/processor/hashtable.m4

    r623 r726  
    6565 
    6666            efree(buf); 
    67             return; /* no check size */ 
    6867        ', ` 
    6968        dnl }}} 
  • branches/1.3/processor/head.m4

    r691 r726  
    299299} 
    300300/* }}} */ 
     301/* {{{ field name checker */ 
     302IFASSERT(`dnl 
     303int xc_check_names(const char *file, int line, const char *functionName, const char **assert_names, int assert_names_count, HashTable *done_names) 
     304{ 
     305    int errors = 0; 
     306    if (assert_names_count) { 
     307        int i; 
     308        Bucket *b; 
     309 
     310        for (i = 0; i < assert_names_count; ++i) { 
     311            if (!zend_hash_exists(done_names, assert_names[i], strlen(assert_names[i]) + 1)) { 
     312                fprintf(stderr 
     313                    , "missing field at %s `#'%d %s`' : %s\n" 
     314                    , file, line, functionName 
     315                    , assert_names[i] 
     316                    ); 
     317                ++errors; 
     318            } 
     319        } 
     320 
     321        for (b = done_names->pListHead; b != NULL; b = b->pListNext) { 
     322            int known = 0; 
     323            int i; 
     324            for (i = 0; i < assert_names_count; ++i) { 
     325                if (strcmp(assert_names[i], BUCKET_KEY_S(b)) == 0) { 
     326                    known = 1; 
     327                    break; 
     328                } 
     329            } 
     330            if (!known) { 
     331                fprintf(stderr 
     332                    , "unknown field at %s `#'%d %s`' : %s\n" 
     333                    , file, line, functionName 
     334                    , BUCKET_KEY_S(b) 
     335                    ); 
     336                ++errors; 
     337            } 
     338        } 
     339    } 
     340    return errors; 
     341} 
     342') 
     343/* }}} */ 
    301344dnl ================ export API 
    302345/* export: xc_entry_t *xc_processor_store_xc_entry_t(xc_entry_t *src TSRMLS_DC); :export {{{ */ 
  • branches/1.3/processor/main.m4

    r691 r726  
    164164dnl }}} 
    165165dnl {{{ COPYNULL(1:elm) 
    166 # foreach(VAR, (LIST), STMT) 
    167 m4_define([foreach], 
    168        [m4_pushdef([$1])_foreach([$1], [$2], [$3])m4_popdef([$1])]) 
    169 m4_define([_arg1], [$1]) 
    170 m4_define([_foreach], 
    171        [ifelse([$2], [()], , 
    172        [m4_define([$1], _arg1$2)$3[]_foreach([$1], 
    173                                                        (shift$2), 
    174                                                        [$3])])]) 
    175166define(`COPYNULL', ` 
    176167    COPYNULL_EX(`dst->$1', `$2')DONE(`$1') 
     
    195186dnl }}} 
    196187dnl {{{ DONE_* 
    197 define(`DONE_SIZE', `IFASSERT(` 
     188define(`DONE_SIZE', `IFASSERT(`dnl 
    198189    done_size += $1`'; 
    199190    done_count ++; 
    200191')') 
    201192define(`DONE', ` 
    202     define(`ELEMENTS_DONE', defn(`ELEMENTS_DONE')`,$1') 
     193    define(`ELEMENTS_DONE', defn(`ELEMENTS_DONE')`,"$1"') 
     194    IFASSERT(`dnl 
     195        if (zend_hash_exists(&done_names, "$1", sizeof("$1"))) { 
     196            fprintf(stderr 
     197                , "duplicate field at %s `#'%d FUNC_NAME`' : %s\n" 
     198                , __FILE__, __LINE__ 
     199                , "$1" 
     200                ); 
     201        } 
     202        else { 
     203            zend_uchar b = 1; 
     204            zend_hash_add(&done_names, "$1", sizeof("$1"), (void*)&b, sizeof(b), NULL); 
     205        } 
     206    ') 
    203207    DONE_SIZE(`sizeof(src->$1)') 
    204208') 
  • branches/1.3/processor/processor.m4

    r646 r726  
    8585#endif 
    8686    } while(0); 
    87     return; 
    8887    ', ` 
    8988        dnl IFDASM else 
     
    223222    DISPATCH(zend_uint, class_name_len) 
    224223    PROC_ZSTRING_L(, class_name, class_name_len) 
     224#ifdef ZEND_ENGINE_2_4 
     225    DISPATCH(zend_uchar, type_hint) 
     226#else 
    225227    DISPATCH(zend_bool, array_type_hint) 
     228#endif 
    226229    DISPATCH(zend_bool, allow_null) 
    227230    DISPATCH(zend_bool, pass_by_reference) 
     231#ifndef ZEND_ENGINE_2_4 
    228232    DISPATCH(zend_bool, return_reference) 
    229233    DISPATCH(int, required_num_args) 
     234#endif 
    230235') 
    231236#endif 
     
    273278    PROC_ZSTRING_L(, name, name_length) 
    274279    DISPATCH(ulong, h) 
     280#ifdef ZEND_ENGINE_2_4 
     281    DISPATCH(int, offset) 
     282#endif 
    275283#ifdef ZEND_ENGINE_2_1 
    276284    DISPATCH(int, doc_comment_len) 
     
    285293dnl }}} 
    286294DEF_STRUCT_P_FUNC(`zend_class_entry', , `dnl {{{ 
     295    int i; 
    287296    IFCALCCOPY(` 
    288297        processor->active_class_entry_src = src; 
     
    307316    STRUCT_P(int, refcount) 
    308317#endif 
     318#ifndef ZEND_ENGINE_2_4 
    309319    DISPATCH(zend_bool, constants_updated) 
     320#endif 
    310321#ifdef ZEND_ENGINE_2 
    311322    DISPATCH(zend_uint, ce_flags) 
    312323#endif 
    313324 
    314     STRUCT(HashTable, default_properties, HashTable_zval_ptr) 
     325#ifdef ZEND_ENGINE_2_4 
     326    DISPATCH(int, default_properties_count) 
     327    STRUCT_ARRAY(default_properties_count, zval, default_properties_table) 
     328    DISPATCH(int, default_static_members_count) 
     329    STRUCT_ARRAY(default_static_members_count, zval, default_static_members_table) 
     330    IFCOPY(`dst->static_members_table = &dst->default_static_members_table;') 
     331    DONE(static_members_table) 
     332#else 
    315333    IFCOPY(`dst->builtin_functions = src->builtin_functions;') 
    316334    DONE(builtin_functions) 
    317 #ifdef ZEND_ENGINE_2 
     335    STRUCT(HashTable, default_properties, HashTable_zval_ptr) 
     336#   ifdef ZEND_ENGINE_2 
    318337    STRUCT(HashTable, properties_info, HashTable_zend_property_info) 
    319 #   ifdef ZEND_ENGINE_2_1 
     338#       ifdef ZEND_ENGINE_2_1 
    320339    STRUCT(HashTable, default_static_members, HashTable_zval_ptr) 
    321340    IFCOPY(`dst->static_members = &dst->default_static_members;') 
    322341    DONE(static_members) 
    323 #   else 
     342#       else 
    324343    STRUCT_P(HashTable, static_members, HashTable_zval_ptr) 
    325 #   endif 
     344#       endif 
     345#   endif 
     346#endif /* ZEND_ENGINE_2_4 */ 
     347 
     348#ifdef ZEND_ENGINE_2 
    326349    STRUCT(HashTable, constants_table, HashTable_zval_ptr) 
    327350 
    328351    dnl runtime binding: ADD_INTERFACE will deal with it 
     352    dnl runtime binding: ADD_TRAIT will deal with it 
    329353    IFRESTORE(` 
    330354        if (src->num_interfaces) { 
    331355            CALLOC(dst->interfaces, zend_class_entry*, src->num_interfaces) 
    332356            DONE(`interfaces') 
     357#   ifdef ZEND_ENGINE_2_4 
     358            CALLOC(dst->traits, zend_class_entry*, src->num_traits) 
     359            DONE(`traits') 
     360            DONE(`trait_aliases') 
     361            DONE(`trait_precedences') 
     362#   endif 
    333363        } 
    334364        else { 
    335             COPYNULL(interfaces) 
     365            COPYNULL(`interfaces') 
     366#   ifdef ZEND_ENGINE_2_4 
     367            COPYNULL(`traits') 
     368            COPYNULL(`trait_aliases') 
     369            COPYNULL(`trait_precedences') 
     370#   endif 
    336371        } 
    337372    ') 
     
    350385            */ 
    351386            DONE(`interfaces') 
     387#   ifdef ZEND_ENGINE_2_4 
     388            DONE(`traits') 
     389            DONE(`trait_aliases') 
     390            DONE(`trait_precedences') 
     391#   endif 
    352392        } 
    353393        else { 
    354             COPYNULL(interfaces) 
     394            COPYNULL(`interfaces') 
     395#   ifdef ZEND_ENGINE_2_4 
     396            COPYNULL(`traits') 
     397            COPYNULL(`trait_aliases') 
     398            COPYNULL(`trait_precedences') 
     399#   endif 
    355400        } 
    356401    ') 
     
    358403        IFDASM(`', ` 
    359404            DONE(`interfaces') 
     405#   ifdef ZEND_ENGINE_2_4 
     406            DONE(`traits') 
     407            DONE(`trait_aliases') 
     408            DONE(`trait_precedences') 
     409#   endif 
    360410        ') 
    361411    ') 
    362412    DISPATCH(zend_uint, num_interfaces) 
    363  
     413#   ifdef ZEND_ENGINE_2_4 
     414    DISPATCH(zend_uint, num_traits) 
     415#   endif 
     416 
     417#   ifdef ZEND_ENGINE_2_4 
     418    DISABLECHECK(` 
     419    IFRESTORE(`COPY(info.user.filename)', `PROC_STRING(info.user.filename)') 
     420    DISPATCH(zend_uint, info.user.line_start) 
     421    DISPATCH(zend_uint, info.user.line_end) 
     422    DISPATCH(zend_uint, info.user.doc_comment_len) 
     423    PROC_ZSTRING_L(, info.user.doc_comment, info.user.doc_comment_len) 
     424    ') 
     425    DONE(info) 
     426#   else 
    364427    IFRESTORE(`COPY(filename)', `PROC_STRING(filename)') 
    365428    DISPATCH(zend_uint, line_start) 
    366429    DISPATCH(zend_uint, line_end) 
    367 #ifdef ZEND_ENGINE_2_1 
     430#       ifdef ZEND_ENGINE_2_1 
    368431    DISPATCH(zend_uint, doc_comment_len) 
    369432    PROC_ZSTRING_L(, doc_comment, doc_comment_len) 
    370 #endif 
     433#       endif 
     434#   endif 
     435 
    371436    /* # NOT DONE */ 
    372437    COPY(serialize_func) 
     
    376441    COPY(get_iterator) 
    377442    COPY(interface_gets_implemented) 
    378 #ifdef ZEND_ENGINE_2_3 
     443#   ifdef ZEND_ENGINE_2_3 
    379444    COPY(get_static_method) 
    380 #endif 
     445#   endif 
    381446    COPY(serialize) 
    382447    COPY(unserialize) 
     
    388453    COPY(__set) 
    389454/* should be >5.1 */ 
    390 #ifdef ZEND_ENGINE_2_1 
     455#   ifdef ZEND_ENGINE_2_1 
    391456    COPY(__unset) 
    392457    COPY(__isset) 
    393 # if defined(ZEND_ENGINE_2_2) || PHP_MAJOR_VERSION >= 6 
     458#    if defined(ZEND_ENGINE_2_2) || PHP_MAJOR_VERSION >= 6 
    394459    COPY(__tostring) 
    395 # endif 
    396 #endif 
     460#    endif 
     461#   endif 
    397462    COPY(__call) 
    398 #ifdef ZEND_CALLSTATIC_FUNC_NAME 
     463#   ifdef ZEND_CALLSTATIC_FUNC_NAME 
    399464    COPY(__callstatic) 
    400 #endif 
     465#   endif 
     466#   ifndef ZEND_ENGINE_2_4 
    401467    /* # NOT DONE */ 
    402468    COPY(module) 
    403 #else 
     469#   endif 
     470#else /* ZEND_ENGINE_2 */ 
    404471    COPY(handle_function_call) 
    405472    COPY(handle_property_get) 
     
    415482') 
    416483dnl }}} 
     484#ifdef ZEND_ENGINE_2_4 
     485undefine(`UNION_znode_op') 
     486define(`UNION_znode_op', `dnl {{{ 
     487    assert(src->$1_type == IS_CONST || 
     488        src->$1_type == IS_VAR || 
     489        src->$1_type == IS_CV || 
     490        src->$1_type == IS_TMP_VAR || 
     491        src->$1_type == IS_UNUSED); 
     492    dnl dirty dispatch 
     493    DISABLECHECK(` 
     494    switch (src->$1_type) { 
     495        case IS_CONST: 
     496            dnl TODO: fix me, use literals 
     497            IFDASM(`{ 
     498                zval *zv; 
     499                ALLOC_INIT_ZVAL(zv); 
     500                *zv = ((zend_literal *) src->$1.ptr)->constant; 
     501                zval_copy_ctor(zv); 
     502                add_assoc_zval_ex(dst, ZEND_STRS("$1.constant"), zv); 
     503                } 
     504            ', ` 
     505                DISPATCH(zend_uint, $1.constant) 
     506            ') 
     507            break; 
     508        IFCOPY(` 
     509            IFNOTMEMCPY(` 
     510                default: 
     511                    *dst = *src; 
     512            ') 
     513        ', ` 
     514        case IS_VAR: 
     515        case IS_TMP_VAR: 
     516        case IS_CV: 
     517            DISPATCH(zend_uint, $1.var) 
     518            break; 
     519        case IS_UNUSED: 
     520            IFDASM(`DISPATCH(zend_uint, $1.var)') 
     521            DISPATCH(zend_uint, $1.opline_num) 
     522            break; 
     523        ') 
     524    } 
     525    ') 
     526    DONE($1) 
     527') 
     528dnl }}} 
     529#else 
    417530DEF_STRUCT_P_FUNC(`znode', , `dnl {{{ 
    418531    DISPATCH(int, op_type) 
     
    459572    ') 
    460573    DONE(u) 
     574#if 0 
     575    DONE(EA) 
     576#endif 
    461577#undef XCACHE_IS_CV 
    462578') 
    463579dnl }}} 
     580#endif 
    464581DEF_STRUCT_P_FUNC(`zend_op', , `dnl {{{ 
    465582    DISPATCH(zend_uchar, opcode) 
     583#ifdef ZEND_ENGINE_2_4 
     584    UNION_znode_op(result) 
     585    UNION_znode_op(op1) 
     586    UNION_znode_op(op2) 
     587#else 
    466588    STRUCT(znode, result) 
    467589    STRUCT(znode, op1) 
    468590    STRUCT(znode, op2) 
     591#endif 
    469592    DISPATCH(ulong, extended_value) 
    470593    DISPATCH(uint, lineno) 
    471594#ifdef ZEND_ENGINE_2_1 
     595#ifdef ZEND_ENGINE_2_4 
     596    DISPATCH(zend_uchar, op1_type) 
     597    DISPATCH(zend_uchar, op2_type) 
     598    DISPATCH(zend_uchar, result_type) 
     599#endif 
    472600    IFCOPY(` 
    473601        switch (src->opcode) { 
     
    476604#endif 
    477605            case ZEND_JMP: 
    478                 dst->op1.u.jmp_addr = processor->active_opcodes_dst + (src->op1.u.jmp_addr - processor->active_opcodes_src); 
     606                Z_OP(dst->op1).jmp_addr = processor->active_opcodes_dst + (Z_OP(src->op1).jmp_addr - processor->active_opcodes_src); 
    479607                break; 
    480608 
     
    486614            case ZEND_JMP_SET: 
    487615#endif 
    488                 dst->op2.u.jmp_addr = processor->active_opcodes_dst + (src->op2.u.jmp_addr - processor->active_opcodes_src); 
     616                Z_OP(dst->op2).jmp_addr = processor->active_opcodes_dst + (Z_OP(src->op2).jmp_addr - processor->active_opcodes_src); 
    489617                break; 
    490618 
     
    497625') 
    498626dnl }}} 
     627#ifdef ZEND_ENGINE_2_4 
     628DEF_STRUCT_P_FUNC(`zend_literal', , `dnl {{{ 
     629    STRUCT(zval, constant) 
     630    DISPATCH(zend_ulong, hash_value) 
     631    DISPATCH(zend_uint,  cache_slot) 
     632') 
     633dnl }}} 
     634#endif 
    499635DEF_STRUCT_P_FUNC(`zend_op_array', , `dnl {{{ 
    500636    IFRESTORE(` 
     
    535671    DISPATCH(zend_uint, num_args) 
    536672    DISPATCH(zend_uint, required_num_args) 
     673#   ifndef ZEND_ENGINE_2_4 
    537674    DISPATCH(zend_bool, pass_rest_by_reference) 
     675#   endif 
    538676#else 
    539677    if (src->arg_types) { 
     
    541679        IFCOPY(`memcpy(dst->arg_types, src->arg_types, sizeof(src->arg_types[0]) * (src->arg_types[0]+1));') 
    542680        IFDASM(`do { 
    543             zend_uint ii; 
    544681            int i; 
    545682            zval *zv; 
     
    567704    } 
    568705#endif 
     706#ifndef ZEND_ENGINE_2_4 
    569707    DISPATCH(unsigned char, return_reference) 
     708#endif 
    570709    /* END of common elements */ 
    571710#ifdef IS_UNICODE 
     
    584723    popdef(`AFTER_ALLOC') 
    585724    DISPATCH(zend_uint, last) 
     725#ifndef ZEND_ENGINE_2_4 
    586726    IFCOPY(`dst->size = src->last;DONE(size)', `DISPATCH(zend_uint, size)') 
     727#endif 
    587728 
    588729#ifdef IS_CV 
    589730    STRUCT_ARRAY(last_var, zend_compiled_variable, vars) 
    590731    DISPATCH(int, last_var) 
     732#   ifndef ZEND_ENGINE_2_4 
    591733    IFCOPY(`dst->size_var = src->last_var;DONE(size_var)', `DISPATCH(zend_uint, size_var)') 
     734#   endif 
    592735#else 
    593736    dnl zend_cv.m4 is illegal to be made public, don not ask me for it 
     
    601744    STRUCT_ARRAY_I(last_brk_cont, zend_brk_cont_element, brk_cont_array) 
    602745    DISPATCH(zend_uint, last_brk_cont) 
     746#ifndef ZEND_ENGINE_2_4 
    603747    DISPATCH(zend_uint, current_brk_cont) 
     748#endif 
    604749#ifndef ZEND_ENGINE_2 
    605750    DISPATCH(zend_bool, uses_globals) 
     
    613758    STRUCT_P(HashTable, static_variables, HashTable_zval_ptr) 
    614759 
     760#ifndef ZEND_ENGINE_2_4 
    615761    COPY(start_op) 
    616762    DISPATCH(int, backpatch_count) 
     763#endif 
    617764#ifdef ZEND_ENGINE_2_3 
    618765    DISPATCH(zend_uint, this_var) 
    619766#endif 
    620767 
     768#ifndef ZEND_ENGINE_2_4 
    621769    DISPATCH(zend_bool, done_pass_two) 
     770#endif 
    622771    /* 5.0 <= ver < 5.3 */ 
    623772#if defined(ZEND_ENGINE_2) && !defined(ZEND_ENGINE_2_3) 
     
    647796#if defined(HARDENING_PATCH) && HARDENING_PATCH 
    648797    DISPATCH(zend_bool, created_by_eval) 
     798#endif 
     799#ifdef ZEND_ENGINE_2_4 
     800    DISPATCH(int, last_literal) 
     801    IFRESTORE(`COPY(literals)', `STRUCT_ARRAY_I(last_literal, zend_literal, literals)') 
     802 
     803    COPYNULL(run_time_cache) 
     804    COPYNULL(last_cache_slot) 
    649805#endif 
    650806    } while (0); 
     
    680836            ') 
    681837    ') 
     838 
    682839#endif 
    683840 
  • branches/1.3/processor/struct.m4

    r623 r726  
    3030    { 
    3131        pushdef(`ELEMENTS_DONE') 
    32         ifdef(`SIZEOF_$1', , `m4_errprint(`AUTOCHECK WARN: $1: missing structinfo, dont panic')define(`SIZEOF_$1', 0)') 
    3332        IFASSERT(` 
    3433            /* {{{ init assert */ 
    35             ifdef(`SIZEOF_$1', , `m4_errprint(`missing SIZEOF_$1, safe to ignore')define(`SIZEOF_$1', 0)') 
    36             ifdef(`COUNTOF_$1', , `m4_errprint(`missing COUNTOF_$1, safe to ignore')define(`COUNTOF_$1', 0)') 
     34            ifdef(`SIZEOF_$1', , `m4_errprint(`missing SIZEOF_$1, safe to ignore')') 
     35            ifdef(`COUNTOF_$1', , `m4_errprint(`missing COUNTOF_$1, safe to ignore'))') 
    3736            dnl SIZEOF_x COUNTOF_x can be both defined or both not 
    3837            ifdef(`SIZEOF_$1', ` 
     
    4847            int assert_size = SIZEOF_$1, assert_count = COUNTOF_$1; 
    4948            int done_size = 0, done_count = 0; 
     49            const char *assert_names[] = { ifdef(`ELEMENTSOF_$1', `ELEMENTSOF_$1') }; 
     50            HashTable done_names; 
     51            zend_hash_init(&done_names, 0, NULL, NULL, 0); 
    5052            /* }}} */ 
    5153            IFRESTORE(`assert(xc_is_shm(src));') 
     
    5355            do { 
    5456        ') 
     57        ifdef(`SIZEOF_$1', , `m4_errprint(`AUTOCHECK WARN: $1: missing structinfo, dont panic')') 
    5558 
    5659        ifdef(`USEMEMCPY', `IFCOPY(` 
     
    6871            INDENT()fprintf(stderr, "}\n"); 
    6972        ') 
    70         ifdef(`SKIPASSERT_ONCE', `undefine(`SKIPASSERT_ONCE')', ` 
     73        ifdef(`SKIPASSERT_ONCE', ` 
     74            undefine(`SKIPASSERT_ONCE') 
    7175            IFASSERT(` 
    72                 /* {{{ check assert */ 
     76                zend_hash_destroy(&done_names); 
     77            ') 
     78        ', ` 
     79            IFASSERT(` 
     80            /* {{{ check assert */ do { 
     81                int name_check_errors = xc_check_names(__FILE__, __LINE__, "FUNC_NAME", assert_names, sizeof(assert_names) / sizeof(assert_names[0]), &done_names); 
     82                zend_hash_destroy(&done_names); 
     83 
    7384                if (done_count != assert_count) { 
    7485                    fprintf(stderr 
     
    8596                        ); 
    8697                } 
    87                 if (done_count != assert_count || done_size != assert_size) { 
     98                if (name_check_errors || done_count != assert_count || done_size != assert_size) { 
    8899                    assert(0); 
    89100                } 
    90                 /* }}} */ 
     101            } while (0); /* }}} */ 
    91102            ') 
    92103            ifdef(`ELEMENTSOF_$1', ` 
  • branches/1.3/utils.c

    r708 r726  
    2020 
    2121#define OP_ZVAL_DTOR(op) do { \ 
    22     Z_UNSET_ISREF((op).u.constant); \ 
    23     zval_dtor(&(op).u.constant); \ 
     22    Z_UNSET_ISREF(Z_OP_CONSTANT(op)); \ 
     23    zval_dtor(&Z_OP_CONSTANT(op)); \ 
    2424} while(0) 
    2525xc_compile_result_t *xc_compile_result_init(xc_compile_result_t *cr, /* {{{ */ 
     
    135135    zend_op *opline, *end; 
    136136 
     137#ifndef ZEND_ENGINE_2_4 
    137138    if (!op_array->done_pass_two) { 
    138139        return 0; 
    139140    } 
     141#endif 
    140142 
    141143    opline = op_array->opcodes; 
     
    148150#endif 
    149151            case ZEND_JMP: 
    150                 opline->op1.u.opline_num = opline->op1.u.jmp_addr - op_array->opcodes; 
    151                 assert(opline->op1.u.opline_num < op_array->last); 
     152                Z_OP(opline->op1).opline_num = Z_OP(opline->op1).jmp_addr - op_array->opcodes; 
     153                assert(Z_OP(opline->op1).opline_num < op_array->last); 
    152154                break; 
    153155            case ZEND_JMPZ: 
     
    158160            case ZEND_JMP_SET: 
    159161#endif 
    160                 opline->op2.u.opline_num = opline->op2.u.jmp_addr - op_array->opcodes; 
    161                 assert(opline->op2.u.opline_num < op_array->last); 
     162                Z_OP(opline->op2).opline_num = Z_OP(opline->op2).jmp_addr - op_array->opcodes; 
     163                assert(Z_OP(opline->op2).opline_num < op_array->last); 
    162164                break; 
    163165        } 
     
    165167        opline++; 
    166168    } 
     169#ifndef ZEND_ENGINE_2_4 
    167170    op_array->done_pass_two = 0; 
     171#endif 
    168172 
    169173    return 0; 
     
    174178    zend_op *opline, *end; 
    175179 
     180#ifndef ZEND_ENGINE_2_4 
    176181    if (op_array->done_pass_two) { 
    177182        return 0; 
    178183    } 
     184#endif 
    179185 
    180186    /* 
     
    186192    end = opline + op_array->last; 
    187193    while (opline < end) { 
    188         if (opline->op1.op_type == IS_CONST) { 
    189             Z_SET_ISREF(opline->op1.u.constant); 
    190             Z_SET_REFCOUNT(opline->op1.u.constant, 2); /* Make sure is_ref won't be reset */ 
    191  
    192         } 
    193         if (opline->op2.op_type == IS_CONST) { 
    194             Z_SET_ISREF(opline->op2.u.constant); 
    195             Z_SET_REFCOUNT(opline->op2.u.constant, 2); 
     194        if (Z_OP_TYPE(opline->op1) == IS_CONST) { 
     195            Z_SET_ISREF(Z_OP_CONSTANT(opline->op1)); 
     196            Z_SET_REFCOUNT(Z_OP_CONSTANT(opline->op1), 2); /* Make sure is_ref won't be reset */ 
     197 
     198        } 
     199        if (Z_OP_TYPE(opline->op2) == IS_CONST) { 
     200            Z_SET_ISREF(Z_OP_CONSTANT(opline->op2)); 
     201            Z_SET_REFCOUNT(Z_OP_CONSTANT(opline->op2), 2); 
    196202        } 
    197203#ifdef ZEND_ENGINE_2_1 
     
    201207#endif 
    202208            case ZEND_JMP: 
    203                 assert(opline->op1.u.opline_num < op_array->last); 
    204                 opline->op1.u.jmp_addr = op_array->opcodes + opline->op1.u.opline_num; 
     209                assert(Z_OP(opline->op1).opline_num < op_array->last); 
     210                Z_OP(opline->op1).jmp_addr = op_array->opcodes + Z_OP(opline->op1).opline_num; 
    205211                break; 
    206212            case ZEND_JMPZ: 
     
    211217            case ZEND_JMP_SET: 
    212218#endif 
    213                 assert(opline->op2.u.opline_num < op_array->last); 
    214                 opline->op2.u.jmp_addr = op_array->opcodes + opline->op2.u.opline_num; 
     219                assert(Z_OP(opline->op2).opline_num < op_array->last); 
     220                Z_OP(opline->op2).jmp_addr = op_array->opcodes + Z_OP(opline->op2).opline_num; 
    215221                break; 
    216222        } 
     
    220226    } 
    221227 
     228#ifndef ZEND_ENGINE_2_4 
    222229    op_array->done_pass_two = 1; 
     230#endif 
    223231    return 0; 
    224232} 
     
    226234 
    227235#ifdef HAVE_XCACHE_OPCODE_SPEC_DEF 
    228 static void xc_fix_opcode_ex_znode(int tofix, xc_op_spec_t spec, znode *znode, int type TSRMLS_DC) /* {{{ */ 
     236static void xc_fix_opcode_ex_znode(int tofix, xc_op_spec_t spec, zend_uchar *op_type, znode_op *op, int type TSRMLS_DC) /* {{{ */ 
    229237{ 
    230238#ifdef ZEND_ENGINE_2 
    231     if ((znode->op_type != IS_UNUSED && (spec == OPSPEC_UCLASS || spec == OPSPEC_CLASS)) || 
     239    if ((*op_type != IS_UNUSED && (spec == OPSPEC_UCLASS || spec == OPSPEC_CLASS)) || 
    232240            spec == OPSPEC_FETCH) { 
    233241        if (tofix) { 
    234             switch (znode->op_type) { 
     242            switch (*op_type) { 
    235243            case IS_VAR: 
    236244            case IS_TMP_VAR: 
     
    239247            default: 
    240248                /* TODO: data lost, find a way to keep it */ 
    241                 /* assert(znode->op_type == IS_CONST); */ 
    242                 znode->op_type = IS_TMP_VAR; 
     249                /* assert(*op_type == IS_CONST); */ 
     250                *op_type = IS_TMP_VAR; 
    243251            } 
    244252        } 
    245253    } 
    246     switch (znode->op_type) { 
     254    switch (*op_type) { 
    247255    case IS_TMP_VAR: 
    248256    case IS_VAR: 
    249257        if (tofix) { 
    250             znode->u.var /= sizeof(temp_variable); 
     258            Z_OP(*op).var /= sizeof(temp_variable); 
    251259        } 
    252260        else { 
    253             znode->u.var *= sizeof(temp_variable); 
     261            Z_OP(*op).var *= sizeof(temp_variable); 
    254262        } 
    255263    } 
     
    270278            spec = xc_get_opcode_spec(opline->opcode); 
    271279 
    272             xc_fix_opcode_ex_znode(tofix, spec->op1, &opline->op1, 0 TSRMLS_CC); 
    273             xc_fix_opcode_ex_znode(tofix, spec->op2, &opline->op2, 1 TSRMLS_CC); 
    274             xc_fix_opcode_ex_znode(tofix, spec->res, &opline->result, 2 TSRMLS_CC); 
     280            xc_fix_opcode_ex_znode(tofix, spec->op1, &Z_OP_TYPE(opline->op1),    &opline->op1, 0 TSRMLS_CC); 
     281            xc_fix_opcode_ex_znode(tofix, spec->op2, &Z_OP_TYPE(opline->op2),    &opline->op2, 1 TSRMLS_CC); 
     282            xc_fix_opcode_ex_znode(tofix, spec->res, &Z_OP_TYPE(opline->result), &opline->result, 2 TSRMLS_CC); 
    275283        } 
    276284    } 
     
    304312#endif 
    305313            case ZEND_JMP: 
    306                 next = begin + opline->op1.u.opline_num; 
     314                next = begin + Z_OP(opline->op1).opline_num; 
    307315                break; 
    308316 
    309317            case ZEND_JMPZNZ: 
    310                 next = begin + max(opline->op2.u.opline_num, opline->extended_value); 
     318                next = begin + max(Z_OP(opline->op2).opline_num, opline->extended_value); 
    311319                break; 
    312320 
     
    318326            case ZEND_JMP_SET: 
    319327#endif 
    320                 next = begin + opline->op2.u.opline_num; 
     328                next = begin + Z_OP(opline->op2).opline_num; 
    321329                break; 
    322330 
     
    371379            } 
    372380 
    373             parent_name = &(opline - 1)->op2.u.constant; 
     381            parent_name = &(Z_OP_CONSTANT((opline - 1)->op2)); 
    374382            TRACE("binding with parent %s", Z_STRVAL_P(parent_name)); 
    375383            if (zend_lookup_class(Z_STRVAL_P(parent_name), Z_STRLEN_P(parent_name), &pce TSRMLS_CC) == FAILURE) { 
     
    387395            zend_op *fetch_class_opline = opline - 1; 
    388396 
    389             TRACE("%s %p", Z_STRVAL(fetch_class_opline->op2.u.constant), Z_STRVAL(fetch_class_opline->op2.u.constant)); 
     397            TRACE("%s %p", Z_STRVAL(Z_OP_CONSTANT(fetch_class_opline->op2)), Z_STRVAL(Z_OP_CONSTANT(fetch_class_opline->op2))); 
    390398            OP_ZVAL_DTOR(fetch_class_opline->op2); 
    391399            fetch_class_opline->opcode = ZEND_NOP; 
     
    421429    } 
    422430 
    423     zend_hash_del(class_table, opline->op1.u.constant.value.str.val, opline->op1.u.constant.value.str.len); 
     431    zend_hash_del(class_table, Z_OP_CONSTANT(opline->op1).value.str.val, Z_OP_CONSTANT(opline->op1).value.str.len); 
    424432    OP_ZVAL_DTOR(opline->op1); 
    425433    OP_ZVAL_DTOR(opline->op2); 
     
    512520                ZESW(&stored_ce_ptr, NULL) 
    513521                ) == FAILURE) { 
    514         CG(zend_lineno) = ZESW(0, cep->line_start); 
     522        CG(zend_lineno) = ZESW(0, Z_CLASS_INFO(*cep).line_start); 
    515523#ifdef IS_UNICODE 
    516524        zend_error(E_ERROR, "Cannot redeclare class %R", type, cep->name); 
  • branches/1.3/xcache.c

    r701 r726  
    931931    xc_entry_data_php_t *php = (xc_entry_data_php_t *) data; 
    932932 
    933     class_name = opline->op1.u.constant.value.str.val; 
    934     class_len  = opline->op1.u.constant.value.str.len; 
     933    class_name = Z_OP_CONSTANT(opline->op1).value.str.val; 
     934    class_len  = Z_OP_CONSTANT(opline->op1).value.str.len; 
    935935    if (zend_hash_find(CG(class_table), class_name, class_len, (void **) &cest) == FAILURE) { 
    936936        assert(0); 
     
    24372437    } 
    24382438 
    2439     if (value->type == IS_CONSTANT) { 
     2439    switch ((Z_TYPE_P(value) & IS_CONSTANT_TYPE_MASK)) { 
     2440    case IS_CONSTANT: 
    24402441        *return_value = *value; 
    24412442        zval_copy_ctor(return_value); 
    24422443        return_value->type = UNISW(IS_STRING, UG(unicode) ? IS_UNICODE : IS_STRING); 
    2443         return; 
    2444     } 
    2445  
    2446     if (value->type == IS_CONSTANT_ARRAY) { 
     2444        break; 
     2445 
     2446    case IS_CONSTANT_ARRAY: 
    24472447        *return_value = *value; 
    24482448        zval_copy_ctor(return_value); 
    24492449        return_value->type = IS_ARRAY; 
    2450         return; 
    2451     } 
    2452  
    2453     RETURN_NULL(); 
     2450        break; 
     2451 
     2452    default: 
     2453        RETURN_NULL(); 
     2454    } 
    24542455} 
    24552456/* }}} */ 
     
    24782479} 
    24792480/* }}} */ 
    2480 static function_entry xcache_functions[] = /* {{{ */ 
     2481static zend_function_entry xcache_functions[] = /* {{{ */ 
    24812482{ 
    24822483    PHP_FE(xcache_count,             NULL) 
  • branches/1.3/xcache.h

    r700 r726  
    2222 
    2323#define HAVE_INODE 
    24 #if !defined(ZEND_ENGINE_2_1) && (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 1 || PHP_MAJOR_VERSION > 5) 
     24#if !defined(ZEND_ENGINE_2_4) && (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION == 3 && PHP_RELEASE_VERSION >= 99 || PHP_MAJOR_VERSION > 5) 
     25#   define ZEND_ENGINE_2_4 
     26#endif 
     27#if !defined(ZEND_ENGINE_2_3) && (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION == 3 || defined(ZEND_ENGINE_2_4)) 
     28#   define ZEND_ENGINE_2_3 
     29#endif 
     30#if !defined(ZEND_ENGINE_2_2) && (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION == 2 || defined(ZEND_ENGINE_2_3)) 
     31#   define ZEND_ENGINE_2_2 
     32#endif 
     33#if !defined(ZEND_ENGINE_2_1) && (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION == 1 || defined(ZEND_ENGINE_2_2)) 
    2534#   define ZEND_ENGINE_2_1 
    26 #endif 
    27 #if !defined(ZEND_ENGINE_2_2) && (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 2 || PHP_MAJOR_VERSION > 5) 
    28 #   define ZEND_ENGINE_2_2 
    29 #endif 
    30 #if !defined(ZEND_ENGINE_2_3) && (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 3 || PHP_MAJOR_VERSION > 5) 
    31 #   define ZEND_ENGINE_2_3 
    3235#endif 
    3336 
     
    8992#   define add_assoc_null_ex my_add_assoc_null_ex 
    9093#endif 
     94 
     95#ifdef ZEND_ENGINE_2_4 
     96#   define Z_OP(op) (op) 
     97#   define Z_OP_CONSTANT(op) (op).literal->constant 
     98#   define Z_OP_TYPE(op) op##_##type 
     99 
     100#   define Z_CLASS_INFO(className) (className).info.user 
     101#else 
     102#   define Z_OP(op) (op).u 
     103#   define Z_OP_CONSTANT(op) (op).u.constant 
     104#   define Z_OP_TYPE(op) (op).op_type 
     105typedef znode znode_op; 
     106 
     107#   define Z_CLASS_INFO(className) (className) 
     108#endif 
     109 
    91110/* }}} */ 
    92111 
Note: See TracChangeset for help on using the changeset viewer.