Changeset 716 for trunk


Ignore:
Timestamp:
2011-04-09T09:07:48+02:00 (4 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.