Changeset 716


Ignore:
Timestamp:
2011-04-09T09:07:48+02:00 (3 years ago)
Author:
moo
Message:

PHP 6: initial catch up with php 6 literals and trait

Location:
trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • trunk/ChangeLog

    r714 r716  
    12121.3.2 2011-??-?? 
    1313======== 
     14 * PHP_6: initial catch up with php 6 literals and trait 
    1415 * disassembler: DECLARE_INHERITED_CLASS/DELAYED class not found 
    1516 * disassembler: don't dump builtin functions 
  • trunk/Decompiler.class.php

    r714 r716  
    2828 
    2929    if (is_array($src)) { 
    30         die_error('array str'); 
     30        exit('array str'); 
    3131        $src = new Decompiler_Array($src, $indent); 
    3232        return $src->__toString(); 
     
    3636        if (!method_exists($src, '__toString')) { 
    3737            var_dump($src); 
    38             die_error('no __toString'); 
     38            exit('no __toString'); 
    3939        } 
    4040        return $src->__toString(); 
     
    426426        switch ($op['op_type']) { 
    427427        case XC_IS_CONST: 
    428             return str(value($op['u.constant'])); 
     428            return str(value($op['constant'])); 
    429429 
    430430        case XC_IS_VAR: 
    431431        case XC_IS_TMP_VAR: 
    432432            $T = &$EX['Ts']; 
    433             $ret = $T[$op['u.var']]; 
     433            $ret = $T[$op['var']]; 
    434434            if ($tostr) { 
    435435                $ret = str($ret, $EX); 
    436436            } 
    437437            if ($free) { 
    438                 unset($T[$op['u.var']]); 
     438                unset($T[$op['var']]); 
    439439            } 
    440440            return $ret; 
    441441 
    442442        case XC_IS_CV: 
    443             $var = $op['u.var']; 
     443            $var = $op['var']; 
    444444            $var = $EX['op_array']['vars'][$var]; 
    445445            return '$' . $var['name']; 
     
    448448            return null; 
    449449        } 
     450    } 
     451    // }}} 
     452    function removeKeyPrefix($array, $prefix) // {{{ 
     453    { 
     454        $prefixLen = strlen($prefix); 
     455        $ret = array(); 
     456        foreach ($array as $key => $value) { 
     457            if (substr($key, 0, $prefixLen) == $prefix) { 
     458                $key = substr($key, $prefixLen); 
     459            } 
     460            $ret[$key] = $value; 
     461        } 
     462        return $ret; 
    450463    } 
    451464    // }}} 
     
    458471        } 
    459472        $EX['indent'] = ''; 
    460         //for ($i = 0, $cnt = count($opcodes); $i < $cnt; $i ++) { 
    461         //  $opcodes[$i]['opcode'] = xcache_get_fixed_opcode($opcodes[$i]['opcode'], $i); 
    462         //} 
     473        for ($i = 0, $cnt = count($opcodes); $i < $cnt; $i ++) { 
     474            if (function_exists('xcache_get_fixed_opcode')) { 
     475                $opcodes[$i]['opcode'] = xcache_get_fixed_opcode($opcodes[$i]['opcode'], $i); 
     476            } 
     477            if (isset($opcodes[$i]['op1'])) { 
     478                $opcodes[$i]['op1'] = $this->removeKeyPrefix($opcodes[$i]['op1'], 'u.'); 
     479                $opcodes[$i]['op2'] = $this->removeKeyPrefix($opcodes[$i]['op2'], 'u.'); 
     480                $opcodes[$i]['result'] = $this->removeKeyPrefix($opcodes[$i]['result'], 'u.'); 
     481            } 
     482            else { 
     483                $op = array( 
     484                    'op1' => array(), 
     485                    'op2' => array(), 
     486                    'op3' => array(), 
     487                ); 
     488                foreach ($opcodes[$i] as $name => $value) { 
     489                    if (preg_match('!^(op1|op2|result)\\.(.*)!', $name, $m)) { 
     490                        list(, $which, $field) = $m; 
     491                        $op[$which][$field] = $value; 
     492                    } 
     493                    else if (preg_match('!^(op1|op2|result)_type$!', $name, $m)) { 
     494                        list(, $which) = $m; 
     495                        $op[$which]['op_type'] = $value; 
     496                    } 
     497                    else { 
     498                        $op[$name] = $value; 
     499                    } 
     500                } 
     501                $opcodes[$i] = $op; 
     502            } 
     503        } 
    463504        // {{{ build jmp array 
    464505        for ($i = 0, $cnt = count($opcodes); $i < $cnt; $i ++) { 
     
    474515            switch ($op['opcode']) { 
    475516            case XC_JMP: 
    476                 $target = $op['op1']['u.var']; 
     517                $target = $op['op1']['var']; 
    477518                $op['jmpouts'] = array($target); 
    478519                $opcodes[$target]['jmpins'][] = $i; 
     
    480521 
    481522            case XC_JMPZNZ: 
    482                 $jmpz = $op['op2']['u.opline_num']; 
     523                $jmpz = $op['op2']['opline_num']; 
    483524                $jmpnz = $op['extended_value']; 
    484525                $op['jmpouts'] = array($jmpz, $jmpnz); 
     
    494535            case XC_FE_FETCH: 
    495536            // case XC_JMP_NO_CTOR: 
    496                 $target = $op['op2']['u.opline_num']; 
     537                $target = $op['op2']['opline_num']; 
    497538                //if (!isset($target)) { 
    498539                //  $this->dumpop($op, $EX); 
     
    581622        if ($op['opcode'] == XC_FE_FETCH) { 
    582623            $opline = $next; 
    583             $next = $op['op2']['u.opline_num']; 
     624            $next = $op['op2']['opline_num']; 
    584625            $end = $next - 1; 
    585626 
     
    600641        /* 
    601642        if ($op['opcode'] == XC_JMPZ) { 
    602             $target = $op2['u.opline_num']; 
     643            $target = $op2['opline_num']; 
    603644            if ($line + 1) { 
    604645                $nextblock = $EX['nextbbs'][$next]; 
    605646                $jmpop = end($nextblock); 
    606647                if ($jmpop['opcode'] == XC_JMP) { 
    607                     $ifendline = $op2['u.opline_num']; 
     648                    $ifendline = $op2['opline_num']; 
    608649                    if ($ifendline >= $line) { 
    609650                        $cond = $op['cond']; 
     
    650691                } 
    651692 
    652                 $var = $fromop['result']['u.var']; 
     693                $var = $fromop['result']['var']; 
    653694                var_dump($EX['Ts'][$var]); 
    654695                $EX['Ts'][$var] = '(' . $fromop['and_or'] . " $opstr " . $EX['Ts'][$var] . ')'; 
     
    712753 
    713754            $resvar = null; 
    714             if (($res['u.EA.type'] & EXT_TYPE_UNUSED) || $res['op_type'] == XC_IS_UNUSED) { 
     755            if (isset($res['EA.type']) && ($res['EA.type'] & EXT_TYPE_UNUSED) || $res['op_type'] == XC_IS_UNUSED) { 
    715756                $istmpres = false; 
    716757            } 
     
    743784                case XC_NEW: // {{{ 
    744785                    array_push($EX['arg_types_stack'], array($EX['object'], $EX['fbc'])); 
    745                     $EX['object'] = (int) $res['u.var']; 
     786                    $EX['object'] = (int) $res['var']; 
    746787                    $EX['fbc'] = 'new ' . $this->unquoteName($this->getOpVal($op1, $EX)); 
    747788                    if (PHP_VERSION < 5) { 
     
    761802                    } 
    762803                    else { 
    763                         $class = $op2['u.constant']; 
     804                        $class = $op2['constant']; 
    764805                        if (is_object($class)) { 
    765806                            $class = get_class($class); 
     
    771812                case XC_FETCH_CONSTANT: // {{{ 
    772813                    if ($op1['op_type'] == XC_IS_CONST) { 
    773                         $resvar = $op1['u.constant']; 
     814                        $resvar = $op1['constant']; 
    774815                    } 
    775816                    else if ($op1['op_type'] == XC_IS_UNUSED) { 
    776                         $resvar = $op2['u.constant']; 
     817                        $resvar = $op2['constant']; 
    777818                    } 
    778819                    else { 
    779                         $class = $T[$op1['u.var']]; 
     820                        $class = $T[$op1['var']]; 
    780821                        assert($class[0] == 'class'); 
    781                         $resvar = $class[1] . '::' . $op2['u.constant']; 
     822                        $resvar = $class[1] . '::' . $op2['constant']; 
    782823                    } 
    783824                    break; 
     
    792833                case XC_UNSET_VAR: 
    793834                    $rvalue = $this->getOpVal($op1, $EX); 
    794                     $fetchtype = $op2[PHP_VERSION < 5 ? 'u.fetch_type' : 'u.EA.type']; 
     835                    $fetchtype = $op2[PHP_VERSION < 5 ? 'fetch_type' : 'EA.type']; 
    795836                    switch ($fetchtype) { 
    796837                    case ZEND_FETCH_STATIC_MEMBER: 
     
    838879 
    839880                            $src = new Decompiler_ListBox($list); 
    840                             if (!isset($op1['u.var'])) { 
     881                            if (!isset($op1['var'])) { 
    841882                                $this->dumpop($op, $EX); 
    842883                                var_dump($op); 
    843                                 die('missing u.var'); 
     884                                die('missing var'); 
    844885                            } 
    845                             $T[$op1['u.var']] = $src; 
     886                            $T[$op1['var']] = $src; 
    846887                            unset($list); 
    847888                        } 
     
    883924                        $type = $rvalue->iskey ? 'fe_key' : 'fe_as'; 
    884925                        $rvalue->obj[$type] = $lvalue; 
    885                         unset($T[$op2['u.var']]); 
     926                        unset($T[$op2['var']]); 
    886927                        break; 
    887928                    } 
     
    9691010                            $rvalue = "${" . $rvalue . "}"; 
    9701011                        } 
    971                         if ($op2['u.EA.type'] == ZEND_FETCH_STATIC_MEMBER) { 
     1012                        if ($op2['EA.type'] == ZEND_FETCH_STATIC_MEMBER) { 
    9721013                            $class = $this->getOpVal($op2, $EX); 
    9731014                            $rvalue = $class . '::' . $rvalue; 
     
    9831024                    } 
    9841025 
    985                     switch (PHP_VERSION < 5 ? $op['op2']['u.var'] /* u.constant */ : $ext) { 
     1026                    switch ((PHP_VERSION < 5 ? $op['op2']['var'] /* constant */ : $ext) & (ZEND_ISSET|ZEND_ISEMPTY)) { 
    9861027                    case ZEND_ISSET: 
    9871028                        $rvalue = "isset($rvalue)"; 
     
    9901031                        $rvalue = "empty($rvalue)"; 
    9911032                        break; 
    992                     default: 
    993                         $this->dumpop($op, $EX); 
    994                         die_error('1'); 
    9951033                    } 
    9961034                    $resvar = $rvalue; 
     
    10271065 
    10281066                    if ($opc == XC_INIT_FCALL_BY_FUNC) { 
    1029                         $which = $op1['u.var']; 
     1067                        $which = $op1['var']; 
    10301068                        $EX['fbc'] = $EX['op_array']['funcs'][$which]['name']; 
    10311069                    } 
     
    10361074                    // }}} 
    10371075                case XC_DO_FCALL_BY_FUNC: 
    1038                     $which = $op1['u.var']; 
     1076                    $which = $op1['var']; 
    10391077                    $fname = $EX['op_array']['funcs'][$which]['name']; 
    10401078                    $args = $this->popargs($EX, $ext); 
     
    10691107                    // }}} 
    10701108                case XC_VERIFY_ABSTRACT_CLASS: // {{{ 
    1071                     //unset($T[$op1['u.var']]); 
     1109                    //unset($T[$op1['var']]); 
    10721110                    break; 
    10731111                    // }}} 
     
    10751113                case XC_DECLARE_INHERITED_CLASS: 
    10761114                case XC_DECLARE_INHERITED_CLASS_DELAYED: // {{{ 
    1077                     $key = $op1['u.constant']; 
     1115                    $key = $op1['constant']; 
    10781116                    if (!isset($this->dc['class_table'][$key])) { 
    10791117                        echo 'class not found: ', $key, 'existing classes are:', "\n"; 
     
    10941132                    while ($i + 2 < $ic 
    10951133                     && $opcodes[$i + 2]['opcode'] == XC_ADD_INTERFACE 
    1096                      && $opcodes[$i + 2]['op1']['u.var'] == $res['u.var'] 
     1134                     && $opcodes[$i + 2]['op1']['var'] == $res['var'] 
    10971135                     && $opcodes[$i + 1]['opcode'] == XC_FETCH_CLASS) { 
    10981136                        $fetchop = &$opcodes[$i + 1]; 
     
    11601198                        $offset = $this->getOpVal($op2, $EX); 
    11611199                        if (isset($offset)) { 
    1162                             $T[$res['u.var']]->value[$offset] = $rvalue; 
     1200                            $T[$res['var']]->value[$offset] = $rvalue; 
    11631201                        } 
    11641202                        else { 
    1165                             $T[$res['u.var']]->value[] = $rvalue; 
     1203                            $T[$res['var']]->value[] = $rvalue; 
    11661204                        } 
    11671205                    } 
     
    11971235                    // }}} 
    11981236                case XC_INCLUDE_OR_EVAL: // {{{ 
    1199                     $type = $op2['u.var']; // hack 
     1237                    $type = $op2['var']; // hack 
    12001238                    $keyword = $this->includeTypes[$type]; 
    12011239                    $resvar = "$keyword(" . $this->getOpVal($op1, $EX) . ")"; 
     
    12101248                    $fe = new Decompiler_ForeachBox($op); 
    12111249                    $fe->iskey = false; 
    1212                     $T[$res['u.var']] = $fe; 
     1250                    $T[$res['var']] = $fe; 
    12131251 
    12141252                    ++ $i; 
     
    12181256 
    12191257                        $res = $opcodes[$i]['result']; 
    1220                         $T[$res['u.var']] = $fe; 
     1258                        $T[$res['var']] = $fe; 
    12211259                    } 
    12221260                    break; 
    12231261                    // }}} 
    12241262                case XC_SWITCH_FREE: // {{{ 
    1225                     // unset($T[$op1['u.var']]); 
     1263                    // unset($T[$op1['var']]); 
    12261264                    break; 
    12271265                    // }}} 
    12281266                case XC_FREE: // {{{ 
    1229                     $free = $T[$op1['u.var']]; 
     1267                    $free = $T[$op1['var']]; 
    12301268                    if (!is_a($free, 'Decompiler_Array') && !is_a($free, 'Decompiler_Box')) { 
    12311269                        $op['php'] = is_object($free) ? $free : $this->unquote($free, '(', ')'); 
    12321270                        $lastphpop = &$op; 
    12331271                    } 
    1234                     unset($T[$op1['u.var']], $free); 
     1272                    unset($T[$op1['var']], $free); 
    12351273                    break; 
    12361274                    // }}} 
     
    12581296                    } 
    12591297                    if ($opc == XC_JMPZ_EX || $opc == XC_JMPNZ_EX || $opc == XC_JMPZ) { 
    1260                         $targetop = &$EX['opcodes'][$op2['u.opline_num']]; 
     1298                        $targetop = &$EX['opcodes'][$op2['opline_num']]; 
    12611299                        if ($opc == XC_JMPNZ_EX) { 
    12621300                            $targetop['cond_true'][] = str($rvalue); 
     
    12861324                    $lvalue = $this->getOpVal($op['result'], $EX); 
    12871325                    if ($opc == XC_RECV_INIT) { 
    1288                         $default = value($op['op2']['u.constant']); 
     1326                        $default = value($op['op2']['constant']); 
    12891327                    } 
    12901328                    else { 
     
    13721410            if (isset($resvar)) { 
    13731411                if ($istmpres) { 
    1374                     $T[$res['u.var']] = $resvar; 
    1375                     $lastresvar = &$T[$res['u.var']]; 
     1412                    $T[$res['var']] = $resvar; 
     1413                    $lastresvar = &$T[$res['var']]; 
    13761414                } 
    13771415                else { 
     
    14191457            switch ($op[$k]['op_type']) { 
    14201458            case XC_IS_UNUSED: 
    1421                 $d[$kk] = '*UNUSED* ' . $op[$k]['u.opline_num']; 
     1459                $d[$kk] = '*UNUSED* ' . $op[$k]['opline_num']; 
    14221460                break; 
    14231461 
    14241462            case XC_IS_VAR: 
    1425                 $d[$kk] = '$' . $op[$k]['u.var']; 
     1463                $d[$kk] = '$' . $op[$k]['var']; 
    14261464                if ($kk != 'res') { 
    14271465                    $d[$kk] .= ':' . $this->getOpVal($op[$k], $EX); 
     
    14301468 
    14311469            case XC_IS_TMP_VAR: 
    1432                 $d[$kk] = '#' . $op[$k]['u.var']; 
     1470                $d[$kk] = '#' . $op[$k]['var']; 
    14331471                if ($kk != 'res') { 
    14341472                    $d[$kk] .= ':' . $this->getOpVal($op[$k], $EX); 
  • trunk/NEWS

    r714 r716  
    441.3.2 2011-??-?? 
    55======== 
     6 * PHP_6: catch up with php 6 devel 
    67 * memory leak on recompile 
    78 * disassembler fixes and updates for new PHP 
  • trunk/coverager.c

    r554 r716  
    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/* }}} */ 
  • trunk/optimizer.c

    r657 r716  
    6464            continue; 
    6565        } 
    66         if (opline->op2.op_type != IS_CONST 
    67          || opline->op2.u.constant.type != IS_LONG) { 
     66        if (Z_OP_TYPE(opline->op2) != IS_CONST 
     67         || Z_OP_CONSTANT(opline->op2).type != IS_LONG) { 
    6868            return FAILURE; 
    6969        } 
    7070 
    71         nest_levels = opline->op2.u.constant.value.lval; 
     71        nest_levels = Z_OP_CONSTANT(opline->op2).value.lval; 
    7272        original_nest_levels = nest_levels; 
    7373 
    74         array_offset = opline->op1.u.opline_num; 
     74        array_offset = Z_OP(opline->op1).opline_num; 
    7575        do { 
    7676            if (array_offset == -1) { 
     
    9696        /* rewrite to jmp */ 
    9797        if (opline->opcode == ZEND_BRK) { 
    98             opline->op1.u.opline_num = jmp_to->brk; 
     98            Z_OP(opline->op1).opline_num = jmp_to->brk; 
    9999        } 
    100100        else { 
    101             opline->op1.u.opline_num = jmp_to->cont; 
    102         } 
    103         opline->op2.op_type = IS_UNUSED; 
     101            Z_OP(opline->op1).opline_num = jmp_to->cont; 
     102        } 
     103        Z_OP_TYPE(opline->op2) = IS_UNUSED; 
    104104        opline->opcode = ZEND_JMP; 
    105105    } 
     
    143143 
    144144    case ZEND_JMP: 
    145         fi->jmpout_op1 = opline->op1.u.opline_num; 
     145        fi->jmpout_op1 = Z_OP(opline->op1).opline_num; 
    146146        return SUCCESS; /* no fall */ 
    147147 
    148148    case ZEND_JMPZNZ: 
    149         fi->jmpout_op2 = opline->op2.u.opline_num; 
     149        fi->jmpout_op2 = Z_OP(opline->op2).opline_num; 
    150150        fi->jmpout_ext = (int) opline->extended_value; 
    151151        return SUCCESS; /* no fall */ 
     
    168168#endif       
    169169    case ZEND_FE_FETCH: 
    170         fi->jmpout_op2 = opline->op2.u.opline_num; 
     170        fi->jmpout_op2 = Z_OP(opline->op2).opline_num; 
    171171        break; 
    172172 
     
    186186/* }}} */ 
    187187#ifdef XCACHE_DEBUG 
    188 static void op_snprint(char *buf, int size, znode *op) /* {{{ */ 
    189 { 
    190     switch (op->op_type) { 
     188static void op_snprint(char *buf, int size, zend_uchar op_type, znode_op *op) /* {{{ */ 
     189{ 
     190    switch (op_type) { 
    191191    case IS_CONST: 
    192192        { 
    193193            zval result; 
    194             zval *zv = &op->u.constant; 
     194            zval *zv = &Z_OP_CONSTANT(*op); 
    195195            TSRMLS_FETCH(); 
    196196 
     197            /* TODO: update for PHP 6 */ 
    197198            php_start_ob_buffer(NULL, 0, 1 TSRMLS_CC); 
    198199            php_var_export(&zv, 1 TSRMLS_CC); 
     
    206207 
    207208    case IS_TMP_VAR: 
    208         snprintf(buf, size, "t@%d", op->u.var); 
     209        snprintf(buf, size, "t@%d", Z_OP(*op).var); 
    209210        break; 
    210211 
    211212    case XCACHE_IS_CV: 
    212213    case IS_VAR: 
    213         snprintf(buf, size, "v@%d", op->u.var); 
     214        snprintf(buf, size, "v@%d", Z_OP(*op).var); 
    214215        break; 
    215216 
    216217    case IS_UNUSED: 
    217         if (op->u.opline_num) { 
    218             snprintf(buf, size, "u#%d", op->u.opline_num); 
     218        if (Z_OP(*op).opline_num) { 
     219            snprintf(buf, size, "u#%d", Z_OP(op).opline_num); 
    219220        } 
    220221        else { 
     
    224225 
    225226    default: 
    226         snprintf(buf, size, "%d %d", op->op_type, op->u.var); 
     227        snprintf(buf, size, "%d %d", op->op_type, Z_OP(op).var); 
    227228    } 
    228229} 
     
    235236        char buf_1[20]; 
    236237        char buf_2[20]; 
    237         op_snprint(buf_r, sizeof(buf_r), &opline->result); 
    238         op_snprint(buf_1, sizeof(buf_1), &opline->op1); 
    239         op_snprint(buf_2, sizeof(buf_2), &opline->op2); 
     238        op_snprint(buf_r, sizeof(buf_r), Z_OP_TYPE(opline->result), &opline->result); 
     239        op_snprint(buf_1, sizeof(buf_1), Z_OP_TYPE(opline->op1),    &opline->op1); 
     240        op_snprint(buf_2, sizeof(buf_2), Z_OP_TYPE(opline->op2),    &opline->op2); 
    240241        fprintf(stderr, 
    241242                "%3d %3d" 
     
    451452        if (op_get_flowinfo(&fi, opline) == SUCCESS) { 
    452453            if (fi.jmpout_op1 != XC_OPNUM_INVALID) { 
    453                 opline->op1.u.opline_num = bbids[fi.jmpout_op1]; 
    454                 assert(opline->op1.u.opline_num != BBID_INVALID); 
     454                Z_OP(opline->op1).opline_num = bbids[fi.jmpout_op1]; 
     455                assert(Z_OP(opline->op1).opline_num != BBID_INVALID); 
    455456            } 
    456457            if (fi.jmpout_op2 != XC_OPNUM_INVALID) { 
    457                 opline->op2.u.opline_num = bbids[fi.jmpout_op2]; 
    458                 assert(opline->op2.u.opline_num != BBID_INVALID); 
     458                Z_OP(opline->op2).opline_num = bbids[fi.jmpout_op2]; 
     459                assert(Z_OP(opline->op2).opline_num != BBID_INVALID); 
    459460            } 
    460461            if (fi.jmpout_ext != XC_OPNUM_INVALID) { 
     
    499500        if (op_get_flowinfo(&fi, last) == SUCCESS) { 
    500501            if (fi.jmpout_op1 != XC_OPNUM_INVALID) { 
    501                 last->op1.u.opline_num = bbs_get(bbs, fi.jmpout_op1)->opnum; 
    502                 assert(last->op1.u.opline_num != BBID_INVALID); 
     502                Z_OP(last->op1).opline_num = bbs_get(bbs, fi.jmpout_op1)->opnum; 
     503                assert(Z_OP(last->op1).opline_num != BBID_INVALID); 
    503504            } 
    504505            if (fi.jmpout_op2 != XC_OPNUM_INVALID) { 
    505                 last->op2.u.opline_num = bbs_get(bbs, fi.jmpout_op2)->opnum; 
    506                 assert(last->op2.u.opline_num != BBID_INVALID); 
     506                Z_OP(last->op2).opline_num = bbs_get(bbs, fi.jmpout_op2)->opnum; 
     507                assert(Z_OP(last->op2).opline_num != BBID_INVALID); 
    507508            } 
    508509            if (fi.jmpout_ext != XC_OPNUM_INVALID) { 
  • trunk/processor/processor.m4

    r713 r716  
    223223    DISPATCH(zend_uint, class_name_len) 
    224224    PROC_ZSTRING_L(, class_name, class_name_len) 
     225#ifdef ZEND_ENGINE_2_4 
     226    DISPATCH(zend_uchar, type_hint) 
     227#else 
    225228    DISPATCH(zend_bool, array_type_hint) 
     229#endif 
    226230    DISPATCH(zend_bool, allow_null) 
    227231    DISPATCH(zend_bool, pass_by_reference) 
     232#ifndef ZEND_ENGINE_2_4 
    228233    DISPATCH(zend_bool, return_reference) 
    229234    DISPATCH(int, required_num_args) 
     235#endif 
    230236') 
    231237#endif 
     
    273279    PROC_ZSTRING_L(, name, name_length) 
    274280    DISPATCH(ulong, h) 
     281#ifdef ZEND_ENGINE_2_4 
     282    DISPATCH(int, offset) 
     283#endif 
    275284#ifdef ZEND_ENGINE_2_1 
    276285    DISPATCH(int, doc_comment_len) 
     
    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    ') 
     
    351386            */ 
    352387            DONE(`interfaces') 
     388#   ifdef ZEND_ENGINE_2_4 
     389            DONE(`traits') 
     390            DONE(`trait_aliases') 
     391            DONE(`trait_precedences') 
     392#   endif 
    353393        } 
    354394        else { 
    355             COPYNULL(interfaces) 
     395            COPYNULL(`interfaces') 
     396#   ifdef ZEND_ENGINE_2_4 
     397            COPYNULL(`traits') 
     398            COPYNULL(`trait_aliases') 
     399            COPYNULL(`trait_precedences') 
     400#   endif 
    356401        } 
    357402    ') 
     
    359404        IFDASM(`', ` 
    360405            DONE(`interfaces') 
     406#   ifdef ZEND_ENGINE_2_4 
     407            DONE(`traits') 
     408            DONE(`trait_aliases') 
     409            DONE(`trait_precedences') 
     410#   endif 
    361411        ') 
    362412    ') 
    363413    DISPATCH(zend_uint, num_interfaces) 
    364  
     414#   ifdef ZEND_ENGINE_2_4 
     415    DISPATCH(zend_uint, num_traits) 
     416#   endif 
     417 
     418#   ifdef ZEND_ENGINE_2_4 
     419    DISABLECHECK(` 
     420    IFRESTORE(`dst->info.user.filename = processor->entry_src->filepath;', `PROC_STRING(info.user.filename)') 
     421    DISPATCH(zend_uint, info.user.line_start) 
     422    DISPATCH(zend_uint, info.user.line_end) 
     423    DISPATCH(zend_uint, info.user.doc_comment_len) 
     424    PROC_ZSTRING_L(, info.user.doc_comment, info.user.doc_comment_len) 
     425    ') 
     426    DONE(info) 
     427#   else 
    365428    IFRESTORE(`dst->filename = processor->entry_src->filepath;DONE(filename)', `PROC_STRING(filename)') 
    366429    DISPATCH(zend_uint, line_start) 
    367430    DISPATCH(zend_uint, line_end) 
    368 #ifdef ZEND_ENGINE_2_1 
     431#       ifdef ZEND_ENGINE_2_1 
    369432    DISPATCH(zend_uint, doc_comment_len) 
    370433    PROC_ZSTRING_L(, doc_comment, doc_comment_len) 
    371 #endif 
     434#       endif 
     435#   endif 
     436 
    372437    /* # NOT DONE */ 
    373438    COPY(serialize_func) 
     
    377442    COPY(get_iterator) 
    378443    COPY(interface_gets_implemented) 
    379 #ifdef ZEND_ENGINE_2_3 
     444#   ifdef ZEND_ENGINE_2_3 
    380445    COPY(get_static_method) 
    381 #endif 
     446#   endif 
    382447    COPY(serialize) 
    383448    COPY(unserialize) 
     
    389454    COPY(__set) 
    390455/* should be >5.1 */ 
    391 #ifdef ZEND_ENGINE_2_1 
     456#   ifdef ZEND_ENGINE_2_1 
    392457    COPY(__unset) 
    393458    COPY(__isset) 
    394 # if defined(ZEND_ENGINE_2_2) || PHP_MAJOR_VERSION >= 6 
     459#    if defined(ZEND_ENGINE_2_2) || PHP_MAJOR_VERSION >= 6 
    395460    COPY(__tostring) 
    396 # endif 
    397 #endif 
     461#    endif 
     462#   endif 
    398463    COPY(__call) 
    399 #ifdef ZEND_CALLSTATIC_FUNC_NAME 
     464#   ifdef ZEND_CALLSTATIC_FUNC_NAME 
    400465    COPY(__callstatic) 
    401 #endif 
     466#   endif 
     467#   ifndef ZEND_ENGINE_2_4 
    402468    /* # NOT DONE */ 
    403469    COPY(module) 
    404 #else 
     470#   endif 
     471#else /* ZEND_ENGINE_2 */ 
    405472    COPY(handle_function_call) 
    406473    COPY(handle_property_get) 
     
    416483') 
    417484dnl }}} 
     485#ifdef ZEND_ENGINE_2_4 
     486undefine(`UNION_znode_op') 
     487define(`UNION_znode_op', `dnl {{{ 
     488    assert(src->$1_type == IS_CONST || 
     489        src->$1_type == IS_VAR || 
     490        src->$1_type == IS_CV || 
     491        src->$1_type == IS_TMP_VAR || 
     492        src->$1_type == IS_UNUSED); 
     493    dnl dirty dispatch 
     494    DISABLECHECK(` 
     495    switch (src->$1_type) { 
     496        case IS_CONST: 
     497            dnl TODO: fix me, use literals 
     498            IFDASM(`{ 
     499                zval *zv; 
     500                ALLOC_INIT_ZVAL(zv); 
     501                *zv = ((zend_literal *) src->$1.ptr)->constant; 
     502                zval_copy_ctor(zv); 
     503                add_assoc_zval_ex(dst, ZEND_STRS("$1.constant"), zv); 
     504                } 
     505            ', ` 
     506                DISPATCH(zend_uint, $1.constant) 
     507            ') 
     508            break; 
     509        IFCOPY(` 
     510            IFNOTMEMCPY(` 
     511                default: 
     512                    *dst = *src; 
     513            ') 
     514        ', ` 
     515        case IS_VAR: 
     516        case IS_TMP_VAR: 
     517        case IS_CV: 
     518            DISPATCH(zend_uint, $1.var) 
     519            break; 
     520        case IS_UNUSED: 
     521            IFDASM(`DISPATCH(zend_uint, $1.var)') 
     522            DISPATCH(zend_uint, $1.opline_num) 
     523            break; 
     524        ') 
     525    } 
     526    ') 
     527    DONE($1) 
     528') 
     529dnl }}} 
     530#else 
    418531DEF_STRUCT_P_FUNC(`znode', , `dnl {{{ 
    419532    DISPATCH(int, op_type) 
     
    460573    ') 
    461574    DONE(u) 
     575#if 0 
     576    DONE(EA) 
     577#endif 
    462578#undef XCACHE_IS_CV 
    463579') 
    464580dnl }}} 
     581#endif 
    465582DEF_STRUCT_P_FUNC(`zend_op', , `dnl {{{ 
    466583    DISPATCH(zend_uchar, opcode) 
     584#ifdef ZEND_ENGINE_2_4 
     585    UNION_znode_op(result) 
     586    UNION_znode_op(op1) 
     587    UNION_znode_op(op2) 
     588#else 
    467589    STRUCT(znode, result) 
    468590    STRUCT(znode, op1) 
    469591    STRUCT(znode, op2) 
     592#endif 
    470593    DISPATCH(ulong, extended_value) 
    471594    DISPATCH(uint, lineno) 
    472595#ifdef ZEND_ENGINE_2_1 
     596#ifdef ZEND_ENGINE_2_4 
     597    DISPATCH(zend_uchar, op1_type) 
     598    DISPATCH(zend_uchar, op2_type) 
     599    DISPATCH(zend_uchar, result_type) 
     600#endif 
    473601    IFCOPY(` 
    474602        switch (src->opcode) { 
     
    477605#endif 
    478606            case ZEND_JMP: 
    479                 dst->op1.u.jmp_addr = processor->active_opcodes_dst + (src->op1.u.jmp_addr - processor->active_opcodes_src); 
     607                Z_OP(dst->op1).jmp_addr = processor->active_opcodes_dst + (Z_OP(src->op1).jmp_addr - processor->active_opcodes_src); 
    480608                break; 
    481609 
     
    487615            case ZEND_JMP_SET: 
    488616#endif 
    489                 dst->op2.u.jmp_addr = processor->active_opcodes_dst + (src->op2.u.jmp_addr - processor->active_opcodes_src); 
     617                Z_OP(dst->op2).jmp_addr = processor->active_opcodes_dst + (Z_OP(src->op2).jmp_addr - processor->active_opcodes_src); 
    490618                break; 
    491619 
     
    498626') 
    499627dnl }}} 
     628#ifdef ZEND_ENGINE_2_4 
     629DEF_STRUCT_P_FUNC(`zend_literal', , `dnl {{{ 
     630    STRUCT(zval, constant) 
     631    DISPATCH(zend_ulong, hash_value) 
     632    DISPATCH(zend_uint,  cache_slot) 
     633') 
     634dnl }}} 
     635#endif 
    500636DEF_STRUCT_P_FUNC(`zend_op_array', , `dnl {{{ 
    501637    IFRESTORE(` 
     
    552688    DISPATCH(zend_uint, num_args) 
    553689    DISPATCH(zend_uint, required_num_args) 
     690#   ifndef ZEND_ENGINE_2_4 
    554691    DISPATCH(zend_bool, pass_rest_by_reference) 
     692#   endif 
    555693#else 
    556694    if (src->arg_types) { 
     
    583721    } 
    584722#endif 
     723#ifndef ZEND_ENGINE_2_4 
    585724    DISPATCH(unsigned char, return_reference) 
     725#endif 
    586726    /* END of common elements */ 
    587727#ifdef IS_UNICODE 
     
    600740    popdef(`AFTER_ALLOC') 
    601741    DISPATCH(zend_uint, last) 
     742#ifndef ZEND_ENGINE_2_4 
    602743    IFCOPY(`dst->size = src->last;DONE(size)', `DISPATCH(zend_uint, size)') 
     744#endif 
    603745 
    604746#ifdef IS_CV 
    605747    STRUCT_ARRAY(last_var, zend_compiled_variable, vars) 
    606748    DISPATCH(int, last_var) 
     749#   ifndef ZEND_ENGINE_2_4 
    607750    IFCOPY(`dst->size_var = src->last_var;DONE(size_var)', `DISPATCH(zend_uint, size_var)') 
     751#   endif 
    608752#else 
    609753    dnl zend_cv.m4 is illegal to be made public, don not ask me for it 
     
    617761    STRUCT_ARRAY(last_brk_cont, zend_brk_cont_element, brk_cont_array) 
    618762    DISPATCH(zend_uint, last_brk_cont) 
     763#ifndef ZEND_ENGINE_2_4 
    619764    DISPATCH(zend_uint, current_brk_cont) 
     765#endif 
    620766#ifndef ZEND_ENGINE_2 
    621767    DISPATCH(zend_bool, uses_globals) 
     
    629775    STRUCT_P(HashTable, static_variables, HashTable_zval_ptr) 
    630776 
     777#ifndef ZEND_ENGINE_2_4 
    631778    COPY(start_op) 
    632779    DISPATCH(int, backpatch_count) 
     780#endif 
    633781#ifdef ZEND_ENGINE_2_3 
    634782    DISPATCH(zend_uint, this_var) 
    635783#endif 
    636784 
     785#ifndef ZEND_ENGINE_2_4 
    637786    DISPATCH(zend_bool, done_pass_two) 
     787#endif 
    638788    /* 5.0 <= ver < 5.3 */ 
    639789#if defined(ZEND_ENGINE_2) && !defined(ZEND_ENGINE_2_3) 
     
    697847            ') 
    698848    ') 
     849#ifdef ZEND_ENGINE_2_4 
     850    DISPATCH(int, last_literal) 
     851    IFRESTORE(`COPY(literals)', `STRUCT_ARRAY(last_literal, zend_literal, literals)') 
     852 
     853    COPYNULL(run_time_cache) 
     854    COPYNULL(last_cache_slot) 
     855#endif 
     856 
    699857#endif 
    700858 
  • trunk/utils.c

    r705 r716  
    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); 
  • trunk/xcache.c

    r713 r716  
    11541154    xc_entry_data_php_t *php = (xc_entry_data_php_t *) data; 
    11551155 
    1156     class_name = opline->op1.u.constant.value.str.val; 
    1157     class_len  = opline->op1.u.constant.value.str.len; 
     1156    class_name = Z_OP_CONSTANT(opline->op1).value.str.val; 
     1157    class_len  = Z_OP_CONSTANT(opline->op1).value.str.len; 
    11581158    if (zend_hash_find(CG(class_table), class_name, class_len, (void **) &cest) == FAILURE) { 
    11591159        assert(0); 
     
    11961196 
    11971197#define XCACHE_CHECK_OP(type, op) \ 
    1198     if (zend_binary_strcmp(Z_STRVAL(opline->op.u.constant), Z_STRLEN(opline->op.u.constant), xce->type##path, xce->type##path_len) == 0) { \ 
     1198    if (zend_binary_strcmp(Z_STRVAL(Z_OP_CONSTANT(opline->op)), Z_STRLEN(Z_OP_CONSTANT(opline->op)), xce->type##path, xce->type##path_len) == 0) { \ 
    11991199        usage->type##path_used = 1; \ 
    12001200        oplineinfo |= xcache_##op##_is_##type; \ 
     
    12021202 
    12031203#define XCACHE_U_CHECK_OP(type, op) \ 
    1204     if (zend_u_##binary_strcmp(Z_USTRVAL(opline->op.u.constant), Z_USTRLEN(opline->op.u.constant), xce->u##type##path, xce->u##type##path_len) == 0) { \ 
     1204    if (zend_u_##binary_strcmp(Z_USTRVAL(Z_OP_CONSTANT(opline->op)), Z_USTRLEN(Z_OP_CONSTANT(opline->op)), xce->u##type##path, xce->u##type##path_len) == 0) { \ 
    12051205        usage->u##type##path_used = 1; \ 
    12061206        oplineinfo |= xcache_##op##_is_##type; \ 
     
    12101210        zend_op *opline = &op_array->opcodes[oplineno]; 
    12111211        int oplineinfo = 0; 
    1212         if (opline->op1.op_type == IS_CONST) { 
    1213             if (Z_TYPE(opline->op1.u.constant) == IS_STRING) { 
     1212        if (Z_OP_TYPE(opline->op1) == IS_CONST) { 
     1213            if (Z_TYPE(Z_OP_CONSTANT(opline->op1)) == IS_STRING) { 
    12141214                XCACHE_CHECK_OP(file, op1) 
    12151215                else XCACHE_CHECK_OP(dir, op1) 
     
    12171217 
    12181218#ifdef IS_UNICODE 
    1219             else if (Z_TYPE(opline->op1.u.constant) == IS_UNICODE) { 
     1219            else if (Z_TYPE(Z_OP_CONSTANT(opline->op1)) == IS_UNICODE) { 
    12201220                XCACHE_U_CHECK_OP(file, op1) 
    12211221                else XCACHE_U_CHECK_OP(dir, op1) 
     
    12231223#endif 
    12241224        } 
    1225         if (opline->op2.op_type == IS_CONST) { 
    1226             if (Z_TYPE(opline->op2.u.constant) == IS_STRING) { 
     1225        if (Z_OP_TYPE(opline->op2) == IS_CONST) { 
     1226            if (Z_TYPE(Z_OP_CONSTANT(opline->op2)) == IS_STRING) { 
    12271227                XCACHE_CHECK_OP(file, op2) 
    12281228                else XCACHE_CHECK_OP(dir, op2) 
     
    12301230 
    12311231#ifdef IS_UNICODE 
    1232             else if (Z_TYPE(opline->op2.u.constant) == IS_UNICODE) { 
     1232            else if (Z_TYPE(Z_OP_CONSTANT(opline->op2)) == IS_UNICODE) { 
    12331233                XCACHE_U_CHECK_OP(file, op2) 
    12341234                else XCACHE_U_CHECK_OP(dir, op2) 
     
    12591259        zend_op *opline = &op_array->opcodes[oplineno]; 
    12601260        if ((oplineinfo & xcache_op1_is_file)) { 
    1261             assert(opline->op1.op_type == IS_CONST); 
     1261            assert(Z_OP_TYPE(opline->op1) == IS_CONST); 
    12621262            if (copy) { 
    1263                 efree(Z_STRVAL(opline->op1.u.constant)); 
    1264             } 
    1265             if (Z_TYPE(opline->op1.u.constant) == IS_STRING) { 
     1263                efree(Z_STRVAL(Z_OP_CONSTANT(opline->op1))); 
     1264            } 
     1265            if (Z_TYPE(Z_OP_CONSTANT(opline->op1)) == IS_STRING) { 
    12661266                assert(xce->filepath); 
    1267                 ZVAL_STRINGL(&opline->op1.u.constant, xce->filepath, xce->filepath_len, copy); 
     1267                ZVAL_STRINGL(&Z_OP_CONSTANT(opline->op1), xce->filepath, xce->filepath_len, copy); 
    12681268                TRACE("fixing op1 to %s", xce->filepath); 
    12691269            } 
    12701270#ifdef IS_UNICODE 
    1271             else if (Z_TYPE(opline->op1.u.constant) == IS_UNICODE) { 
     1271            else if (Z_TYPE(Z_OP_CONSTANT(opline->op1)) == IS_UNICODE) { 
    12721272                assert(xce->ufilepath); 
    1273                 ZVAL_UNICODEL(&opline->op1.u.constant, xce->ufilepath, xce->ufilepath_len, copy); 
     1273                ZVAL_UNICODEL(&Z_OP_CONSTANT(opline->op1), xce->ufilepath, xce->ufilepath_len, copy); 
    12741274            } 
    12751275#endif 
     
    12791279        } 
    12801280        else if ((oplineinfo & xcache_op1_is_dir)) { 
    1281             assert(opline->op1.op_type == IS_CONST); 
     1281            assert(Z_OP_TYPE(opline->op1) == IS_CONST); 
    12821282            if (copy) { 
    1283                 efree(Z_STRVAL(opline->op1.u.constant)); 
    1284             } 
    1285             if (Z_TYPE(opline->op1.u.constant) == IS_STRING) { 
     1283                efree(Z_STRVAL(Z_OP_CONSTANT(opline->op1))); 
     1284            } 
     1285            if (Z_TYPE(Z_OP_CONSTANT(opline->op1)) == IS_STRING) { 
    12861286                assert(xce->dirpath); 
    12871287                TRACE("fixing op1 to %s", xce->dirpath); 
    1288                 ZVAL_STRINGL(&opline->op1.u.constant, xce->dirpath, xce->dirpath_len, copy); 
     1288                ZVAL_STRINGL(&Z_OP_CONSTANT(opline->op1), xce->dirpath, xce->dirpath_len, copy); 
    12891289            } 
    12901290#ifdef IS_UNICODE 
    1291             else if (Z_TYPE(opline->op1.u.constant) == IS_UNICODE) { 
     1291            else if (Z_TYPE(Z_OP_CONSTANT(opline->op1)) == IS_UNICODE) { 
    12921292                assert(!xce->udirpath); 
    1293                 ZVAL_UNICODEL(&opline->op1.u.constant, xce->udirpath, xce->udirpath_len, copy); 
     1293                ZVAL_UNICODEL(&Z_OP_CONSTANT(opline->op1), xce->udirpath, xce->udirpath_len, copy); 
    12941294            } 
    12951295#endif 
     
    13001300 
    13011301        if ((oplineinfo & xcache_op2_is_file)) { 
    1302             assert(opline->op2.op_type == IS_CONST); 
     1302            assert(Z_OP_TYPE(opline->op2) == IS_CONST); 
    13031303            if (copy) { 
    1304                 efree(Z_STRVAL(opline->op2.u.constant)); 
    1305             } 
    1306             if (Z_TYPE(opline->op2.u.constant) == IS_STRING) { 
     1304                efree(Z_STRVAL(Z_OP_CONSTANT(opline->op2))); 
     1305            } 
     1306            if (Z_TYPE(Z_OP_CONSTANT(opline->op2)) == IS_STRING) { 
    13071307                assert(xce->filepath); 
    13081308                TRACE("fixing op2 to %s", xce->filepath); 
    1309                 ZVAL_STRINGL(&opline->op2.u.constant, xce->filepath, xce->filepath_len, copy); 
     1309                ZVAL_STRINGL(&Z_OP_CONSTANT(opline->op2), xce->filepath, xce->filepath_len, copy); 
    13101310            } 
    13111311#ifdef IS_UNICODE 
    1312             else if (Z_TYPE(opline->op2.u.constant) == IS_UNICODE) { 
     1312            else if (Z_TYPE(Z_OP_CONSTANT(opline->op2)) == IS_UNICODE) { 
    13131313                assert(xce->ufilepath); 
    1314                 ZVAL_UNICODEL(&opline->op2.u.constant, xce->ufilepath, xce->ufilepath_len, copy); 
     1314                ZVAL_UNICODEL(&Z_OP_CONSTANT(opline->op2), xce->ufilepath, xce->ufilepath_len, copy); 
    13151315            } 
    13161316#endif 
     
    13201320        } 
    13211321        else if ((oplineinfo & xcache_op2_is_dir)) { 
    1322             assert(opline->op2.op_type == IS_CONST); 
     1322            assert(Z_OP_TYPE(opline->op2) == IS_CONST); 
    13231323            if (copy) { 
    1324                 efree(Z_STRVAL(opline->op2.u.constant)); 
    1325             } 
    1326             if (Z_TYPE(opline->op2.u.constant) == IS_STRING) { 
     1324                efree(Z_STRVAL(Z_OP_CONSTANT(opline->op2))); 
     1325            } 
     1326            if (Z_TYPE(Z_OP_CONSTANT(opline->op2)) == IS_STRING) { 
    13271327                assert(!xce->dirpath); 
    13281328                TRACE("fixing op2 to %s", xce->dirpath); 
    1329                 ZVAL_STRINGL(&opline->op2.u.constant, xce->dirpath, xce->dirpath_len, copy); 
     1329                ZVAL_STRINGL(&Z_OP_CONSTANT(opline->op2), xce->dirpath, xce->dirpath_len, copy); 
    13301330            } 
    13311331#ifdef IS_UNICODE 
    1332             else if (Z_TYPE(opline->op2.u.constant) == IS_UNICODE) { 
     1332            else if (Z_TYPE(Z_OP_CONSTANT(opline->op2)) == IS_UNICODE) { 
    13331333                assert(!xce->udirpath); 
    1334                 ZVAL_UNICODEL(&opline->op2.u.constant, xce->udirpath, xce->udirpath_len, copy); 
     1334                ZVAL_UNICODEL(&Z_OP_CONSTANT(opline->op2), xce->udirpath, xce->udirpath_len, copy); 
    13351335            } 
    13361336#endif 
     
    30553055} 
    30563056/* }}} */ 
    3057 static function_entry xcache_functions[] = /* {{{ */ 
     3057static zend_function_entry xcache_functions[] = /* {{{ */ 
    30583058{ 
    30593059    PHP_FE(xcache_count,             NULL) 
  • trunk/xcache.h

    r684 r716  
    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.