Changeset 716

Timestamp:

2011-04-09T09:07:48+02:00 (2 years ago)

Author:

moo

Message:

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

Location:

trunk

Files:

• ChangeLog (modified) (1 diff)
• Decompiler.class.php (modified) (35 diffs)
• NEWS (modified) (1 diff)
• coverager.c (modified) (2 diffs)
• optimizer.c (modified) (10 diffs)
• processor/processor.m4 (modified) (18 diffs)
• utils.c (modified) (19 diffs)
• xcache.c (modified) (12 diffs)
• xcache.h (modified) (2 diffs)

trunk/ChangeLog

@@ -12 +12 @@
 1.3.2 2011-??-??
 ========
+ * PHP_6: initial catch up with php 6 literals and trait
  * disassembler: DECLARE_INHERITED_CLASS/DELAYED class not found
  * disassembler: don't dump builtin functions

trunk/Decompiler.class.php

@@ -28 +28 @@
 
     if (is_array($src)) {
-        die_error('array str');
+        exit('array str');
         $src = new Decompiler_Array($src, $indent);
         return $src->__toString();
@@ -36 +36 @@
         if (!method_exists($src, '__toString')) {
             var_dump($src);
-            die_error('no __toString');
+            exit('no __toString');
         }
         return $src->__toString();
@@ -426 +426 @@
         switch ($op['op_type']) {
         case XC_IS_CONST:
-            return str(value($op['u.constant']));
+            return str(value($op['constant']));
 
         case XC_IS_VAR:
         case XC_IS_TMP_VAR:
             $T = &$EX['Ts'];
-            $ret = $T[$op['u.var']];
+            $ret = $T[$op['var']];
             if ($tostr) {
                 $ret = str($ret, $EX);
             }
             if ($free) {
-                unset($T[$op['u.var']]);
+                unset($T[$op['var']]);
             }
             return $ret;
 
         case XC_IS_CV:
-            $var = $op['u.var'];
+            $var = $op['var'];
             $var = $EX['op_array']['vars'][$var];
             return '$' . $var['name'];
@@ -448 +448 @@
             return null;
         }
+    }
+    // }}}
+    function removeKeyPrefix($array, $prefix) // {{{
+    {
+        $prefixLen = strlen($prefix);
+        $ret = array();
+        foreach ($array as $key => $value) {
+            if (substr($key, 0, $prefixLen) == $prefix) {
+                $key = substr($key, $prefixLen);
+            }
+            $ret[$key] = $value;
+        }
+        return $ret;
     }
     // }}}
@@ -458 +471 @@
         }
         $EX['indent'] = '';
-        //for ($i = 0, $cnt = count($opcodes); $i < $cnt; $i ++) {
-        //  $opcodes[$i]['opcode'] = xcache_get_fixed_opcode($opcodes[$i]['opcode'], $i);
-        //}
+        for ($i = 0, $cnt = count($opcodes); $i < $cnt; $i ++) {
+            if (function_exists('xcache_get_fixed_opcode')) {
+                $opcodes[$i]['opcode'] = xcache_get_fixed_opcode($opcodes[$i]['opcode'], $i);
+            }
+            if (isset($opcodes[$i]['op1'])) {
+                $opcodes[$i]['op1'] = $this->removeKeyPrefix($opcodes[$i]['op1'], 'u.');
+                $opcodes[$i]['op2'] = $this->removeKeyPrefix($opcodes[$i]['op2'], 'u.');
+                $opcodes[$i]['result'] = $this->removeKeyPrefix($opcodes[$i]['result'], 'u.');
+            }
+            else {
+                $op = array(
+                    'op1' => array(),
+                    'op2' => array(),
+                    'op3' => array(),
+                );
+                foreach ($opcodes[$i] as $name => $value) {
+                    if (preg_match('!^(op1|op2|result)\\.(.*)!', $name, $m)) {
+                        list(, $which, $field) = $m;
+                        $op[$which][$field] = $value;
+                    }
+                    else if (preg_match('!^(op1|op2|result)_type$!', $name, $m)) {
+                        list(, $which) = $m;
+                        $op[$which]['op_type'] = $value;
+                    }
+                    else {
+                        $op[$name] = $value;
+                    }
+                }
+                $opcodes[$i] = $op;
+            }
+        }
         // {{{ build jmp array
         for ($i = 0, $cnt = count($opcodes); $i < $cnt; $i ++) {
@@ -474 +515 @@
             switch ($op['opcode']) {
             case XC_JMP:
-                $target = $op['op1']['u.var'];
+                $target = $op['op1']['var'];
                 $op['jmpouts'] = array($target);
                 $opcodes[$target]['jmpins'][] = $i;
@@ -480 +521 @@
 
             case XC_JMPZNZ:
-                $jmpz = $op['op2']['u.opline_num'];
+                $jmpz = $op['op2']['opline_num'];
                 $jmpnz = $op['extended_value'];
                 $op['jmpouts'] = array($jmpz, $jmpnz);
@@ -494 +535 @@
             case XC_FE_FETCH:
             // case XC_JMP_NO_CTOR:
-                $target = $op['op2']['u.opline_num'];
+                $target = $op['op2']['opline_num'];
                 //if (!isset($target)) {
                 //  $this->dumpop($op, $EX);
@@ -581 +622 @@
         if ($op['opcode'] == XC_FE_FETCH) {
             $opline = $next;
-            $next = $op['op2']['u.opline_num'];
+            $next = $op['op2']['opline_num'];
             $end = $next - 1;
 
@@ -600 +641 @@
         /*
         if ($op['opcode'] == XC_JMPZ) {
-            $target = $op2['u.opline_num'];
+            $target = $op2['opline_num'];
             if ($line + 1) {
                 $nextblock = $EX['nextbbs'][$next];
                 $jmpop = end($nextblock);
                 if ($jmpop['opcode'] == XC_JMP) {
-                    $ifendline = $op2['u.opline_num'];
+                    $ifendline = $op2['opline_num'];
                     if ($ifendline >= $line) {
                         $cond = $op['cond'];
@@ -650 +691 @@
                 }
 
-                $var = $fromop['result']['u.var'];
+                $var = $fromop['result']['var'];
                 var_dump($EX['Ts'][$var]);
                 $EX['Ts'][$var] = '(' . $fromop['and_or'] . " $opstr " . $EX['Ts'][$var] . ')';
@@ -712 +753 @@
 
             $resvar = null;
-            if (($res['u.EA.type'] & EXT_TYPE_UNUSED) || $res['op_type'] == XC_IS_UNUSED) {
+            if (isset($res['EA.type']) && ($res['EA.type'] & EXT_TYPE_UNUSED) || $res['op_type'] == XC_IS_UNUSED) {
                 $istmpres = false;
             }
@@ -743 +784 @@
                 case XC_NEW: // {{{
                     array_push($EX['arg_types_stack'], array($EX['object'], $EX['fbc']));
-                    $EX['object'] = (int) $res['u.var'];
+                    $EX['object'] = (int) $res['var'];
                     $EX['fbc'] = 'new ' . $this->unquoteName($this->getOpVal($op1, $EX));
                     if (PHP_VERSION < 5) {
@@ -761 +802 @@
                     }
                     else {
-                        $class = $op2['u.constant'];
+                        $class = $op2['constant'];
                         if (is_object($class)) {
                             $class = get_class($class);
@@ -771 +812 @@
                 case XC_FETCH_CONSTANT: // {{{
                     if ($op1['op_type'] == XC_IS_CONST) {
-                        $resvar = $op1['u.constant'];
+                        $resvar = $op1['constant'];
                     }
                     else if ($op1['op_type'] == XC_IS_UNUSED) {
-                        $resvar = $op2['u.constant'];
+                        $resvar = $op2['constant'];
                     }
                     else {
-                        $class = $T[$op1['u.var']];
+                        $class = $T[$op1['var']];
                         assert($class[0] == 'class');
-                        $resvar = $class[1] . '::' . $op2['u.constant'];
+                        $resvar = $class[1] . '::' . $op2['constant'];
                     }
                     break;
@@ -792 +833 @@
                 case XC_UNSET_VAR:
                     $rvalue = $this->getOpVal($op1, $EX);
-                    $fetchtype = $op2[PHP_VERSION < 5 ? 'u.fetch_type' : 'u.EA.type'];
+                    $fetchtype = $op2[PHP_VERSION < 5 ? 'fetch_type' : 'EA.type'];
                     switch ($fetchtype) {
                     case ZEND_FETCH_STATIC_MEMBER:
@@ -838 +879 @@
 
                             $src = new Decompiler_ListBox($list);
-                            if (!isset($op1['u.var'])) {
+                            if (!isset($op1['var'])) {
                                 $this->dumpop($op, $EX);
                                 var_dump($op);
-                                die('missing u.var');
+                                die('missing var');
                             }
-                            $T[$op1['u.var']] = $src;
+                            $T[$op1['var']] = $src;
                             unset($list);
                         }
@@ -883 +924 @@
                         $type = $rvalue->iskey ? 'fe_key' : 'fe_as';
                         $rvalue->obj[$type] = $lvalue;
-                        unset($T[$op2['u.var']]);
+                        unset($T[$op2['var']]);
                         break;
                     }
@@ -969 +1010 @@
                             $rvalue = "${" . $rvalue . "}";
                         }
-                        if ($op2['u.EA.type'] == ZEND_FETCH_STATIC_MEMBER) {
+                        if ($op2['EA.type'] == ZEND_FETCH_STATIC_MEMBER) {
                             $class = $this->getOpVal($op2, $EX);
                             $rvalue = $class . '::' . $rvalue;
@@ -983 +1024 @@
                     }
 
-                    switch (PHP_VERSION < 5 ? $op['op2']['u.var'] /* u.constant */ : $ext) {
+                    switch ((PHP_VERSION < 5 ? $op['op2']['var'] /* constant */ : $ext) & (ZEND_ISSET|ZEND_ISEMPTY)) {
                     case ZEND_ISSET:
                         $rvalue = "isset($rvalue)";
@@ -990 +1031 @@
                         $rvalue = "empty($rvalue)";
                         break;
-                    default:
-                        $this->dumpop($op, $EX);
-                        die_error('1');
                     }
                     $resvar = $rvalue;
@@ -1027 +1065 @@
 
                     if ($opc == XC_INIT_FCALL_BY_FUNC) {
-                        $which = $op1['u.var'];
+                        $which = $op1['var'];
                         $EX['fbc'] = $EX['op_array']['funcs'][$which]['name'];
                     }
@@ -1036 +1074 @@
                     // }}}
                 case XC_DO_FCALL_BY_FUNC:
-                    $which = $op1['u.var'];
+                    $which = $op1['var'];
                     $fname = $EX['op_array']['funcs'][$which]['name'];
                     $args = $this->popargs($EX, $ext);
@@ -1069 +1107 @@
                     // }}}
                 case XC_VERIFY_ABSTRACT_CLASS: // {{{
-                    //unset($T[$op1['u.var']]);
+                    //unset($T[$op1['var']]);
                     break;
                     // }}}
@@ -1075 +1113 @@
                 case XC_DECLARE_INHERITED_CLASS:
                 case XC_DECLARE_INHERITED_CLASS_DELAYED: // {{{
-                    $key = $op1['u.constant'];
+                    $key = $op1['constant'];
                     if (!isset($this->dc['class_table'][$key])) {
                         echo 'class not found: ', $key, 'existing classes are:', "\n";
@@ -1094 +1132 @@
                     while ($i + 2 < $ic
                      && $opcodes[$i + 2]['opcode'] == XC_ADD_INTERFACE
-                     && $opcodes[$i + 2]['op1']['u.var'] == $res['u.var']
+                     && $opcodes[$i + 2]['op1']['var'] == $res['var']
                      && $opcodes[$i + 1]['opcode'] == XC_FETCH_CLASS) {
                         $fetchop = &$opcodes[$i + 1];
@@ -1160 +1198 @@
                         $offset = $this->getOpVal($op2, $EX);
                         if (isset($offset)) {
-                            $T[$res['u.var']]->value[$offset] = $rvalue;
+                            $T[$res['var']]->value[$offset] = $rvalue;
                         }
                         else {
-                            $T[$res['u.var']]->value[] = $rvalue;
+                            $T[$res['var']]->value[] = $rvalue;
                         }
                     }
@@ -1197 +1235 @@
                     // }}}
                 case XC_INCLUDE_OR_EVAL: // {{{
-                    $type = $op2['u.var']; // hack
+                    $type = $op2['var']; // hack
                     $keyword = $this->includeTypes[$type];
                     $resvar = "$keyword(" . $this->getOpVal($op1, $EX) . ")";
@@ -1210 +1248 @@
                     $fe = new Decompiler_ForeachBox($op);
                     $fe->iskey = false;
-                    $T[$res['u.var']] = $fe;
+                    $T[$res['var']] = $fe;
 
                     ++ $i;
@@ -1218 +1256 @@
 
                         $res = $opcodes[$i]['result'];
-                        $T[$res['u.var']] = $fe;
+                        $T[$res['var']] = $fe;
                     }
                     break;
                     // }}}
                 case XC_SWITCH_FREE: // {{{
-                    // unset($T[$op1['u.var']]);
+                    // unset($T[$op1['var']]);
                     break;
                     // }}}
                 case XC_FREE: // {{{
-                    $free = $T[$op1['u.var']];
+                    $free = $T[$op1['var']];
                     if (!is_a($free, 'Decompiler_Array') && !is_a($free, 'Decompiler_Box')) {
                         $op['php'] = is_object($free) ? $free : $this->unquote($free, '(', ')');
                         $lastphpop = &$op;
                     }
-                    unset($T[$op1['u.var']], $free);
+                    unset($T[$op1['var']], $free);
                     break;
                     // }}}
@@ -1258 +1296 @@
                     }
                     if ($opc == XC_JMPZ_EX || $opc == XC_JMPNZ_EX || $opc == XC_JMPZ) {
-                        $targetop = &$EX['opcodes'][$op2['u.opline_num']];
+                        $targetop = &$EX['opcodes'][$op2['opline_num']];
                         if ($opc == XC_JMPNZ_EX) {
                             $targetop['cond_true'][] = str($rvalue);
@@ -1286 +1324 @@
                     $lvalue = $this->getOpVal($op['result'], $EX);
                     if ($opc == XC_RECV_INIT) {
-                        $default = value($op['op2']['u.constant']);
+                        $default = value($op['op2']['constant']);
                     }
                     else {
@@ -1372 +1410 @@
             if (isset($resvar)) {
                 if ($istmpres) {
-                    $T[$res['u.var']] = $resvar;
-                    $lastresvar = &$T[$res['u.var']];
+                    $T[$res['var']] = $resvar;
+                    $lastresvar = &$T[$res['var']];
                 }
                 else {
@@ -1419 +1457 @@
             switch ($op[$k]['op_type']) {
             case XC_IS_UNUSED:
-                $d[$kk] = '*UNUSED* ' . $op[$k]['u.opline_num'];
+                $d[$kk] = '*UNUSED* ' . $op[$k]['opline_num'];
                 break;
 
             case XC_IS_VAR:
-                $d[$kk] = '$' . $op[$k]['u.var'];
+                $d[$kk] = '$' . $op[$k]['var'];
                 if ($kk != 'res') {
                     $d[$kk] .= ':' . $this->getOpVal($op[$k], $EX);
@@ -1430 +1468 @@
 
             case XC_IS_TMP_VAR:
-                $d[$kk] = '#' . $op[$k]['u.var'];
+                $d[$kk] = '#' . $op[$k]['var'];
                 if ($kk != 'res') {
                     $d[$kk] .= ':' . $this->getOpVal($op[$k], $EX);

trunk/NEWS

@@ -4 +4 @@
 1.3.2 2011-??-??
 ========
+ * PHP_6: catch up with php 6 devel
  * memory leak on recompile
  * disassembler fixes and updates for new PHP

trunk/coverager.c

@@ -379 +379 @@
 static int xc_coverager_get_op_array_size_no_tail(zend_op_array *op_array) /* {{{ */
 {
-    zend_uint size;
-
-    size = op_array->size;
+    zend_uint last = op_array->last;
     do {
 next_op:
-        if (size == 0) {
+        if (last == 0) {
             break;
         }
-        switch (op_array->opcodes[size - 1].opcode) {
+        switch (op_array->opcodes[last - 1].opcode) {
 #ifdef ZEND_HANDLE_EXCEPTION
             case ZEND_HANDLE_EXCEPTION:
@@ -393 +391 @@
             case ZEND_RETURN:
             case ZEND_EXT_STMT:
-                size --;
+                --last;
                 goto next_op;
         }
     } while (0);
-    return size;
+    return last;
 }
 /* }}} */

trunk/optimizer.c

@@ -64 +64 @@
             continue;
         }
-        if (opline->op2.op_type != IS_CONST
-         || opline->op2.u.constant.type != IS_LONG) {
+        if (Z_OP_TYPE(opline->op2) != IS_CONST
+         || Z_OP_CONSTANT(opline->op2).type != IS_LONG) {
             return FAILURE;
         }
 
-        nest_levels = opline->op2.u.constant.value.lval;
+        nest_levels = Z_OP_CONSTANT(opline->op2).value.lval;
         original_nest_levels = nest_levels;
 
-        array_offset = opline->op1.u.opline_num;
+        array_offset = Z_OP(opline->op1).opline_num;
         do {
             if (array_offset == -1) {
@@ -96 +96 @@
         /* rewrite to jmp */
         if (opline->opcode == ZEND_BRK) {
-            opline->op1.u.opline_num = jmp_to->brk;
+            Z_OP(opline->op1).opline_num = jmp_to->brk;
         }
         else {
-            opline->op1.u.opline_num = jmp_to->cont;
-        }
-        opline->op2.op_type = IS_UNUSED;
+            Z_OP(opline->op1).opline_num = jmp_to->cont;
+        }
+        Z_OP_TYPE(opline->op2) = IS_UNUSED;
         opline->opcode = ZEND_JMP;
     }
@@ -143 +143 @@
 
     case ZEND_JMP:
-        fi->jmpout_op1 = opline->op1.u.opline_num;
+        fi->jmpout_op1 = Z_OP(opline->op1).opline_num;
         return SUCCESS; /* no fall */
 
     case ZEND_JMPZNZ:
-        fi->jmpout_op2 = opline->op2.u.opline_num;
+        fi->jmpout_op2 = Z_OP(opline->op2).opline_num;
         fi->jmpout_ext = (int) opline->extended_value;
         return SUCCESS; /* no fall */
@@ -168 +168 @@
 #endif      
     case ZEND_FE_FETCH:
-        fi->jmpout_op2 = opline->op2.u.opline_num;
+        fi->jmpout_op2 = Z_OP(opline->op2).opline_num;
         break;
 
@@ -186 +186 @@
 /* }}} */
 #ifdef XCACHE_DEBUG
-static void op_snprint(char *buf, int size, znode *op) /* {{{ */
-{
-    switch (op->op_type) {
+static void op_snprint(char *buf, int size, zend_uchar op_type, znode_op *op) /* {{{ */
+{
+    switch (op_type) {
     case IS_CONST:
         {
             zval result;
-            zval *zv = &op->u.constant;
+            zval *zv = &Z_OP_CONSTANT(*op);
             TSRMLS_FETCH();
 
+            /* TODO: update for PHP 6 */
             php_start_ob_buffer(NULL, 0, 1 TSRMLS_CC);
             php_var_export(&zv, 1 TSRMLS_CC);
@@ -206 +207 @@
 
     case IS_TMP_VAR:
-        snprintf(buf, size, "t@%d", op->u.var);
+        snprintf(buf, size, "t@%d", Z_OP(*op).var);
         break;
 
     case XCACHE_IS_CV:
     case IS_VAR:
-        snprintf(buf, size, "v@%d", op->u.var);
+        snprintf(buf, size, "v@%d", Z_OP(*op).var);
         break;
 
     case IS_UNUSED:
-        if (op->u.opline_num) {
-            snprintf(buf, size, "u#%d", op->u.opline_num);
+        if (Z_OP(*op).opline_num) {
+            snprintf(buf, size, "u#%d", Z_OP(op).opline_num);
         }
         else {
@@ -224 +225 @@
 
     default:
-        snprintf(buf, size, "%d %d", op->op_type, op->u.var);
+        snprintf(buf, size, "%d %d", op->op_type, Z_OP(op).var);
     }
 }
@@ -235 +236 @@
         char buf_1[20];
         char buf_2[20];
-        op_snprint(buf_r, sizeof(buf_r), &opline->result);
-        op_snprint(buf_1, sizeof(buf_1), &opline->op1);
-        op_snprint(buf_2, sizeof(buf_2), &opline->op2);
+        op_snprint(buf_r, sizeof(buf_r), Z_OP_TYPE(opline->result), &opline->result);
+        op_snprint(buf_1, sizeof(buf_1), Z_OP_TYPE(opline->op1),    &opline->op1);
+        op_snprint(buf_2, sizeof(buf_2), Z_OP_TYPE(opline->op2),    &opline->op2);
         fprintf(stderr,
                 "%3d %3d"
@@ -451 +452 @@
         if (op_get_flowinfo(&fi, opline) == SUCCESS) {
             if (fi.jmpout_op1 != XC_OPNUM_INVALID) {
-                opline->op1.u.opline_num = bbids[fi.jmpout_op1];
-                assert(opline->op1.u.opline_num != BBID_INVALID);
+                Z_OP(opline->op1).opline_num = bbids[fi.jmpout_op1];
+                assert(Z_OP(opline->op1).opline_num != BBID_INVALID);
             }
             if (fi.jmpout_op2 != XC_OPNUM_INVALID) {
-                opline->op2.u.opline_num = bbids[fi.jmpout_op2];
-                assert(opline->op2.u.opline_num != BBID_INVALID);
+                Z_OP(opline->op2).opline_num = bbids[fi.jmpout_op2];
+                assert(Z_OP(opline->op2).opline_num != BBID_INVALID);
             }
             if (fi.jmpout_ext != XC_OPNUM_INVALID) {
@@ -499 +500 @@
         if (op_get_flowinfo(&fi, last) == SUCCESS) {
             if (fi.jmpout_op1 != XC_OPNUM_INVALID) {
-                last->op1.u.opline_num = bbs_get(bbs, fi.jmpout_op1)->opnum;
-                assert(last->op1.u.opline_num != BBID_INVALID);
+                Z_OP(last->op1).opline_num = bbs_get(bbs, fi.jmpout_op1)->opnum;
+                assert(Z_OP(last->op1).opline_num != BBID_INVALID);
             }
             if (fi.jmpout_op2 != XC_OPNUM_INVALID) {
-                last->op2.u.opline_num = bbs_get(bbs, fi.jmpout_op2)->opnum;
-                assert(last->op2.u.opline_num != BBID_INVALID);
+                Z_OP(last->op2).opline_num = bbs_get(bbs, fi.jmpout_op2)->opnum;
+                assert(Z_OP(last->op2).opline_num != BBID_INVALID);
             }
             if (fi.jmpout_ext != XC_OPNUM_INVALID) {

trunk/processor/processor.m4

@@ -223 +223 @@
     DISPATCH(zend_uint, class_name_len)
     PROC_ZSTRING_L(, class_name, class_name_len)
+#ifdef ZEND_ENGINE_2_4
+    DISPATCH(zend_uchar, type_hint)
+#else
     DISPATCH(zend_bool, array_type_hint)
+#endif
     DISPATCH(zend_bool, allow_null)
     DISPATCH(zend_bool, pass_by_reference)
+#ifndef ZEND_ENGINE_2_4
     DISPATCH(zend_bool, return_reference)
     DISPATCH(int, required_num_args)
+#endif
 ')
 #endif
@@ -273 +279 @@
     PROC_ZSTRING_L(, name, name_length)
     DISPATCH(ulong, h)
+#ifdef ZEND_ENGINE_2_4
+    DISPATCH(int, offset)
+#endif
 #ifdef ZEND_ENGINE_2_1
     DISPATCH(int, doc_comment_len)
@@ -307 +316 @@
     STRUCT_P(int, refcount)
 #endif
+#ifndef ZEND_ENGINE_2_4
     DISPATCH(zend_bool, constants_updated)
+#endif
 #ifdef ZEND_ENGINE_2
     DISPATCH(zend_uint, ce_flags)
 #endif
 
-    STRUCT(HashTable, default_properties, HashTable_zval_ptr)
+#ifdef ZEND_ENGINE_2_4
+    DISPATCH(int, default_properties_count)
+    STRUCT_ARRAY(default_properties_count, zval, default_properties_table)
+    DISPATCH(int, default_static_members_count)
+    STRUCT_ARRAY(default_static_members_count, zval, default_static_members_table)
+    IFCOPY(`dst->static_members_table = &dst->default_static_members_table;')
+    DONE(static_members_table)
+#else
     IFCOPY(`dst->builtin_functions = src->builtin_functions;')
     DONE(builtin_functions)
-#ifdef ZEND_ENGINE_2
+    STRUCT(HashTable, default_properties, HashTable_zval_ptr)
+#   ifdef ZEND_ENGINE_2
     STRUCT(HashTable, properties_info, HashTable_zend_property_info)
-#   ifdef ZEND_ENGINE_2_1
+#       ifdef ZEND_ENGINE_2_1
     STRUCT(HashTable, default_static_members, HashTable_zval_ptr)
     IFCOPY(`dst->static_members = &dst->default_static_members;')
     DONE(static_members)
-#   else
+#       else
     STRUCT_P(HashTable, static_members, HashTable_zval_ptr)
-#   endif
+#       endif
+#   endif
+#endif /* ZEND_ENGINE_2_4 */
+
+#ifdef ZEND_ENGINE_2
     STRUCT(HashTable, constants_table, HashTable_zval_ptr)
 
     dnl runtime binding: ADD_INTERFACE will deal with it
+    dnl runtime binding: ADD_TRAIT will deal with it
     IFRESTORE(`
         if (src->num_interfaces) {
             CALLOC(dst->interfaces, zend_class_entry*, src->num_interfaces)
             DONE(`interfaces')
+#   ifdef ZEND_ENGINE_2_4
+            CALLOC(dst->traits, zend_class_entry*, src->num_traits)
+            DONE(`traits')
+            DONE(`trait_aliases')
+            DONE(`trait_precedences')
+#   endif
         }
         else {
-            COPYNULL(interfaces)
+            COPYNULL(`interfaces')
+#   ifdef ZEND_ENGINE_2_4
+            COPYNULL(`traits')
+            COPYNULL(`trait_aliases')
+            COPYNULL(`trait_precedences')
+#   endif
         }
     ')
@@ -351 +386 @@
             */
             DONE(`interfaces')
+#   ifdef ZEND_ENGINE_2_4
+            DONE(`traits')
+            DONE(`trait_aliases')
+            DONE(`trait_precedences')
+#   endif
         }
         else {
-            COPYNULL(interfaces)
+            COPYNULL(`interfaces')
+#   ifdef ZEND_ENGINE_2_4
+            COPYNULL(`traits')
+            COPYNULL(`trait_aliases')
+            COPYNULL(`trait_precedences')
+#   endif
         }
     ')
@@ -359 +404 @@
         IFDASM(`', `
             DONE(`interfaces')
+#   ifdef ZEND_ENGINE_2_4
+            DONE(`traits')
+            DONE(`trait_aliases')
+            DONE(`trait_precedences')
+#   endif
         ')
     ')
     DISPATCH(zend_uint, num_interfaces)
-
+#   ifdef ZEND_ENGINE_2_4
+    DISPATCH(zend_uint, num_traits)
+#   endif
+
+#   ifdef ZEND_ENGINE_2_4
+    DISABLECHECK(`
+    IFRESTORE(`dst->info.user.filename = processor->entry_src->filepath;', `PROC_STRING(info.user.filename)')
+    DISPATCH(zend_uint, info.user.line_start)
+    DISPATCH(zend_uint, info.user.line_end)
+    DISPATCH(zend_uint, info.user.doc_comment_len)
+    PROC_ZSTRING_L(, info.user.doc_comment, info.user.doc_comment_len)
+    ')
+    DONE(info)
+#   else
     IFRESTORE(`dst->filename = processor->entry_src->filepath;DONE(filename)', `PROC_STRING(filename)')
     DISPATCH(zend_uint, line_start)
     DISPATCH(zend_uint, line_end)
-#ifdef ZEND_ENGINE_2_1
+#       ifdef ZEND_ENGINE_2_1
     DISPATCH(zend_uint, doc_comment_len)
     PROC_ZSTRING_L(, doc_comment, doc_comment_len)
-#endif
+#       endif
+#   endif
+
     /* # NOT DONE */
     COPY(serialize_func)
@@ -377 +442 @@
     COPY(get_iterator)
     COPY(interface_gets_implemented)
-#ifdef ZEND_ENGINE_2_3
+#   ifdef ZEND_ENGINE_2_3
     COPY(get_static_method)
-#endif
+#   endif
     COPY(serialize)
     COPY(unserialize)
@@ -389 +454 @@
     COPY(__set)
 /* should be >5.1 */
-#ifdef ZEND_ENGINE_2_1
+#   ifdef ZEND_ENGINE_2_1
     COPY(__unset)
     COPY(__isset)
-# if defined(ZEND_ENGINE_2_2) || PHP_MAJOR_VERSION >= 6
+#    if defined(ZEND_ENGINE_2_2) || PHP_MAJOR_VERSION >= 6
     COPY(__tostring)
-# endif
-#endif
+#    endif
+#   endif
     COPY(__call)
-#ifdef ZEND_CALLSTATIC_FUNC_NAME
+#   ifdef ZEND_CALLSTATIC_FUNC_NAME
     COPY(__callstatic)
-#endif
+#   endif
+#   ifndef ZEND_ENGINE_2_4
     /* # NOT DONE */
     COPY(module)
-#else
+#   endif
+#else /* ZEND_ENGINE_2 */
     COPY(handle_function_call)
     COPY(handle_property_get)
@@ -416 +483 @@
 ')
 dnl }}}
+#ifdef ZEND_ENGINE_2_4
+undefine(`UNION_znode_op')
+define(`UNION_znode_op', `dnl {{{
+    assert(src->$1_type == IS_CONST ||
+        src->$1_type == IS_VAR ||
+        src->$1_type == IS_CV ||
+        src->$1_type == IS_TMP_VAR ||
+        src->$1_type == IS_UNUSED);
+    dnl dirty dispatch
+    DISABLECHECK(`
+    switch (src->$1_type) {
+        case IS_CONST:
+            dnl TODO: fix me, use literals
+            IFDASM(`{
+                zval *zv;
+                ALLOC_INIT_ZVAL(zv);
+                *zv = ((zend_literal *) src->$1.ptr)->constant;
+                zval_copy_ctor(zv);
+                add_assoc_zval_ex(dst, ZEND_STRS("$1.constant"), zv);
+                }
+            ', `
+                DISPATCH(zend_uint, $1.constant)
+            ')
+            break;
+        IFCOPY(`
+            IFNOTMEMCPY(`
+                default:
+                    *dst = *src;
+            ')
+        ', `
+        case IS_VAR:
+        case IS_TMP_VAR:
+        case IS_CV:
+            DISPATCH(zend_uint, $1.var)
+            break;
+        case IS_UNUSED:
+            IFDASM(`DISPATCH(zend_uint, $1.var)')
+            DISPATCH(zend_uint, $1.opline_num)
+            break;
+        ')
+    }
+    ')
+    DONE($1)
+')
+dnl }}}
+#else
 DEF_STRUCT_P_FUNC(`znode', , `dnl {{{
     DISPATCH(int, op_type)
@@ -460 +573 @@
     ')
     DONE(u)
+#if 0
+    DONE(EA)
+#endif
 #undef XCACHE_IS_CV
 ')
 dnl }}}
+#endif
 DEF_STRUCT_P_FUNC(`zend_op', , `dnl {{{
     DISPATCH(zend_uchar, opcode)
+#ifdef ZEND_ENGINE_2_4
+    UNION_znode_op(result)
+    UNION_znode_op(op1)
+    UNION_znode_op(op2)
+#else
     STRUCT(znode, result)
     STRUCT(znode, op1)
     STRUCT(znode, op2)
+#endif
     DISPATCH(ulong, extended_value)
     DISPATCH(uint, lineno)
 #ifdef ZEND_ENGINE_2_1
+#ifdef ZEND_ENGINE_2_4
+    DISPATCH(zend_uchar, op1_type)
+    DISPATCH(zend_uchar, op2_type)
+    DISPATCH(zend_uchar, result_type)
+#endif
     IFCOPY(`
         switch (src->opcode) {
@@ -477 +605 @@
 #endif
             case ZEND_JMP:
-                dst->op1.u.jmp_addr = processor->active_opcodes_dst + (src->op1.u.jmp_addr - processor->active_opcodes_src);
+                Z_OP(dst->op1).jmp_addr = processor->active_opcodes_dst + (Z_OP(src->op1).jmp_addr - processor->active_opcodes_src);
                 break;
 
@@ -487 +615 @@
             case ZEND_JMP_SET:
 #endif
-                dst->op2.u.jmp_addr = processor->active_opcodes_dst + (src->op2.u.jmp_addr - processor->active_opcodes_src);
+                Z_OP(dst->op2).jmp_addr = processor->active_opcodes_dst + (Z_OP(src->op2).jmp_addr - processor->active_opcodes_src);
                 break;
 
@@ -498 +626 @@
 ')
 dnl }}}
+#ifdef ZEND_ENGINE_2_4
+DEF_STRUCT_P_FUNC(`zend_literal', , `dnl {{{
+    STRUCT(zval, constant)
+    DISPATCH(zend_ulong, hash_value)
+    DISPATCH(zend_uint,  cache_slot)
+')
+dnl }}}
+#endif
 DEF_STRUCT_P_FUNC(`zend_op_array', , `dnl {{{
     IFRESTORE(`
@@ -552 +688 @@
     DISPATCH(zend_uint, num_args)
     DISPATCH(zend_uint, required_num_args)
+#   ifndef ZEND_ENGINE_2_4
     DISPATCH(zend_bool, pass_rest_by_reference)
+#   endif
 #else
     if (src->arg_types) {
@@ -583 +721 @@
     }
 #endif
+#ifndef ZEND_ENGINE_2_4
     DISPATCH(unsigned char, return_reference)
+#endif
     /* END of common elements */
 #ifdef IS_UNICODE
@@ -600 +740 @@
     popdef(`AFTER_ALLOC')
     DISPATCH(zend_uint, last)
+#ifndef ZEND_ENGINE_2_4
     IFCOPY(`dst->size = src->last;DONE(size)', `DISPATCH(zend_uint, size)')
+#endif
 
 #ifdef IS_CV
     STRUCT_ARRAY(last_var, zend_compiled_variable, vars)
     DISPATCH(int, last_var)
+#   ifndef ZEND_ENGINE_2_4
     IFCOPY(`dst->size_var = src->last_var;DONE(size_var)', `DISPATCH(zend_uint, size_var)')
+#   endif
 #else
     dnl zend_cv.m4 is illegal to be made public, don not ask me for it
@@ -617 +761 @@
     STRUCT_ARRAY(last_brk_cont, zend_brk_cont_element, brk_cont_array)
     DISPATCH(zend_uint, last_brk_cont)
+#ifndef ZEND_ENGINE_2_4
     DISPATCH(zend_uint, current_brk_cont)
+#endif
 #ifndef ZEND_ENGINE_2
     DISPATCH(zend_bool, uses_globals)
@@ -629 +775 @@
     STRUCT_P(HashTable, static_variables, HashTable_zval_ptr)
 
+#ifndef ZEND_ENGINE_2_4
     COPY(start_op)
     DISPATCH(int, backpatch_count)
+#endif
 #ifdef ZEND_ENGINE_2_3
     DISPATCH(zend_uint, this_var)
 #endif
 
+#ifndef ZEND_ENGINE_2_4
     DISPATCH(zend_bool, done_pass_two)
+#endif
     /* 5.0 <= ver < 5.3 */
 #if defined(ZEND_ENGINE_2) && !defined(ZEND_ENGINE_2_3)
@@ -697 +847 @@
             ')
     ')
+#ifdef ZEND_ENGINE_2_4
+    DISPATCH(int, last_literal)
+    IFRESTORE(`COPY(literals)', `STRUCT_ARRAY(last_literal, zend_literal, literals)')
+
+    COPYNULL(run_time_cache)
+    COPYNULL(last_cache_slot)
+#endif
+
 #endif
 

trunk/utils.c

@@ -20 +20 @@
 
 #define OP_ZVAL_DTOR(op) do { \
-    Z_UNSET_ISREF((op).u.constant); \
-    zval_dtor(&(op).u.constant); \
+    Z_UNSET_ISREF(Z_OP_CONSTANT(op)); \
+    zval_dtor(&Z_OP_CONSTANT(op)); \
 } while(0)
 xc_compile_result_t *xc_compile_result_init(xc_compile_result_t *cr, /* {{{ */
@@ -135 +135 @@
     zend_op *opline, *end;
 
+#ifndef ZEND_ENGINE_2_4
     if (!op_array->done_pass_two) {
         return 0;
     }
+#endif
 
     opline = op_array->opcodes;
@@ -148 +150 @@
 #endif
             case ZEND_JMP:
-                opline->op1.u.opline_num = opline->op1.u.jmp_addr - op_array->opcodes;
-                assert(opline->op1.u.opline_num < op_array->last);
+                Z_OP(opline->op1).opline_num = Z_OP(opline->op1).jmp_addr - op_array->opcodes;
+                assert(Z_OP(opline->op1).opline_num < op_array->last);
                 break;
             case ZEND_JMPZ:
@@ -158 +160 @@
             case ZEND_JMP_SET:
 #endif
-                opline->op2.u.opline_num = opline->op2.u.jmp_addr - op_array->opcodes;
-                assert(opline->op2.u.opline_num < op_array->last);
+                Z_OP(opline->op2).opline_num = Z_OP(opline->op2).jmp_addr - op_array->opcodes;
+                assert(Z_OP(opline->op2).opline_num < op_array->last);
                 break;
         }
@@ -165 +167 @@
         opline++;
     }
+#ifndef ZEND_ENGINE_2_4
     op_array->done_pass_two = 0;
+#endif
 
     return 0;
@@ -174 +178 @@
     zend_op *opline, *end;
 
+#ifndef ZEND_ENGINE_2_4
     if (op_array->done_pass_two) {
         return 0;
     }
+#endif
 
     /*
@@ -186 +192 @@
     end = opline + op_array->last;
     while (opline < end) {
-        if (opline->op1.op_type == IS_CONST) {
-            Z_SET_ISREF(opline->op1.u.constant);
-            Z_SET_REFCOUNT(opline->op1.u.constant, 2); /* Make sure is_ref won't be reset */
-
-        }
-        if (opline->op2.op_type == IS_CONST) {
-            Z_SET_ISREF(opline->op2.u.constant);
-            Z_SET_REFCOUNT(opline->op2.u.constant, 2);
+        if (Z_OP_TYPE(opline->op1) == IS_CONST) {
+            Z_SET_ISREF(Z_OP_CONSTANT(opline->op1));
+            Z_SET_REFCOUNT(Z_OP_CONSTANT(opline->op1), 2); /* Make sure is_ref won't be reset */
+
+        }
+        if (Z_OP_TYPE(opline->op2) == IS_CONST) {
+            Z_SET_ISREF(Z_OP_CONSTANT(opline->op2));
+            Z_SET_REFCOUNT(Z_OP_CONSTANT(opline->op2), 2);
         }
 #ifdef ZEND_ENGINE_2_1
@@ -201 +207 @@
 #endif
             case ZEND_JMP:
-                assert(opline->op1.u.opline_num < op_array->last);
-                opline->op1.u.jmp_addr = op_array->opcodes + opline->op1.u.opline_num;
+                assert(Z_OP(opline->op1).opline_num < op_array->last);
+                Z_OP(opline->op1).jmp_addr = op_array->opcodes + Z_OP(opline->op1).opline_num;
                 break;
             case ZEND_JMPZ:
@@ -211 +217 @@
             case ZEND_JMP_SET:
 #endif
-                assert(opline->op2.u.opline_num < op_array->last);
-                opline->op2.u.jmp_addr = op_array->opcodes + opline->op2.u.opline_num;
+                assert(Z_OP(opline->op2).opline_num < op_array->last);
+                Z_OP(opline->op2).jmp_addr = op_array->opcodes + Z_OP(opline->op2).opline_num;
                 break;
         }
@@ -220 +226 @@
     }
 
+#ifndef ZEND_ENGINE_2_4
     op_array->done_pass_two = 1;
+#endif
     return 0;
 }
@@ -226 +234 @@
 
 #ifdef HAVE_XCACHE_OPCODE_SPEC_DEF
-static void xc_fix_opcode_ex_znode(int tofix, xc_op_spec_t spec, znode *znode, int type TSRMLS_DC) /* {{{ */
+static void xc_fix_opcode_ex_znode(int tofix, xc_op_spec_t spec, zend_uchar *op_type, znode_op *op, int type TSRMLS_DC) /* {{{ */
 {
 #ifdef ZEND_ENGINE_2
-    if ((znode->op_type != IS_UNUSED && (spec == OPSPEC_UCLASS || spec == OPSPEC_CLASS)) ||
+    if ((*op_type != IS_UNUSED && (spec == OPSPEC_UCLASS || spec == OPSPEC_CLASS)) ||
             spec == OPSPEC_FETCH) {
         if (tofix) {
-            switch (znode->op_type) {
+            switch (*op_type) {
             case IS_VAR:
             case IS_TMP_VAR:
@@ -239 +247 @@
             default:
                 /* TODO: data lost, find a way to keep it */
-                /* assert(znode->op_type == IS_CONST); */
-                znode->op_type = IS_TMP_VAR;
+                /* assert(*op_type == IS_CONST); */
+                *op_type = IS_TMP_VAR;
             }
         }
     }
-    switch (znode->op_type) {
+    switch (*op_type) {
     case IS_TMP_VAR:
     case IS_VAR:
         if (tofix) {
-            znode->u.var /= sizeof(temp_variable);
+            Z_OP(*op).var /= sizeof(temp_variable);
         }
         else {
-            znode->u.var *= sizeof(temp_variable);
+            Z_OP(*op).var *= sizeof(temp_variable);
         }
     }
@@ -270 +278 @@
             spec = xc_get_opcode_spec(opline->opcode);
 
-            xc_fix_opcode_ex_znode(tofix, spec->op1, &opline->op1, 0 TSRMLS_CC);
-            xc_fix_opcode_ex_znode(tofix, spec->op2, &opline->op2, 1 TSRMLS_CC);
-            xc_fix_opcode_ex_znode(tofix, spec->res, &opline->result, 2 TSRMLS_CC);
+            xc_fix_opcode_ex_znode(tofix, spec->op1, &Z_OP_TYPE(opline->op1),    &opline->op1, 0 TSRMLS_CC);
+            xc_fix_opcode_ex_znode(tofix, spec->op2, &Z_OP_TYPE(opline->op2),    &opline->op2, 1 TSRMLS_CC);
+            xc_fix_opcode_ex_znode(tofix, spec->res, &Z_OP_TYPE(opline->result), &opline->result, 2 TSRMLS_CC);
         }
     }
@@ -304 +312 @@
 #endif
             case ZEND_JMP:
-                next = begin + opline->op1.u.opline_num;
+                next = begin + Z_OP(opline->op1).opline_num;
                 break;
 
             case ZEND_JMPZNZ:
-                next = begin + max(opline->op2.u.opline_num, opline->extended_value);
+                next = begin + max(Z_OP(opline->op2).opline_num, opline->extended_value);
                 break;
 
@@ -318 +326 @@
             case ZEND_JMP_SET:
 #endif
-                next = begin + opline->op2.u.opline_num;
+                next = begin + Z_OP(opline->op2).opline_num;
                 break;
 
@@ -371 +379 @@
             }
 
-            parent_name = &(opline - 1)->op2.u.constant;
+            parent_name = &(Z_OP_CONSTANT((opline - 1)->op2));
             TRACE("binding with parent %s", Z_STRVAL_P(parent_name));
             if (zend_lookup_class(Z_STRVAL_P(parent_name), Z_STRLEN_P(parent_name), &pce TSRMLS_CC) == FAILURE) {
@@ -387 +395 @@
             zend_op *fetch_class_opline = opline - 1;
 
-            TRACE("%s %p", Z_STRVAL(fetch_class_opline->op2.u.constant), Z_STRVAL(fetch_class_opline->op2.u.constant));
+            TRACE("%s %p", Z_STRVAL(Z_OP_CONSTANT(fetch_class_opline->op2)), Z_STRVAL(Z_OP_CONSTANT(fetch_class_opline->op2)));
             OP_ZVAL_DTOR(fetch_class_opline->op2);
             fetch_class_opline->opcode = ZEND_NOP;
@@ -421 +429 @@
     }
 
-    zend_hash_del(class_table, opline->op1.u.constant.value.str.val, opline->op1.u.constant.value.str.len);
+    zend_hash_del(class_table, Z_OP_CONSTANT(opline->op1).value.str.val, Z_OP_CONSTANT(opline->op1).value.str.len);
     OP_ZVAL_DTOR(opline->op1);
     OP_ZVAL_DTOR(opline->op2);
@@ -512 +520 @@
                 ZESW(&stored_ce_ptr, NULL)
                 ) == FAILURE) {
-        CG(zend_lineno) = ZESW(0, cep->line_start);
+        CG(zend_lineno) = ZESW(0, Z_CLASS_INFO(*cep).line_start);
 #ifdef IS_UNICODE
         zend_error(E_ERROR, "Cannot redeclare class %R", type, cep->name);

trunk/xcache.c

@@ -1154 +1154 @@
     xc_entry_data_php_t *php = (xc_entry_data_php_t *) data;
 
-    class_name = opline->op1.u.constant.value.str.val;
-    class_len  = opline->op1.u.constant.value.str.len;
+    class_name = Z_OP_CONSTANT(opline->op1).value.str.val;
+    class_len  = Z_OP_CONSTANT(opline->op1).value.str.len;
     if (zend_hash_find(CG(class_table), class_name, class_len, (void **) &cest) == FAILURE) {
         assert(0);
@@ -1196 +1196 @@
 
 #define XCACHE_CHECK_OP(type, op) \
-    if (zend_binary_strcmp(Z_STRVAL(opline->op.u.constant), Z_STRLEN(opline->op.u.constant), xce->type##path, xce->type##path_len) == 0) { \
+    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) { \
         usage->type##path_used = 1; \
         oplineinfo |= xcache_##op##_is_##type; \
@@ -1202 +1202 @@
 
 #define XCACHE_U_CHECK_OP(type, op) \
-    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) { \
+    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) { \
         usage->u##type##path_used = 1; \
         oplineinfo |= xcache_##op##_is_##type; \
@@ -1210 +1210 @@
         zend_op *opline = &op_array->opcodes[oplineno];
         int oplineinfo = 0;
-        if (opline->op1.op_type == IS_CONST) {
-            if (Z_TYPE(opline->op1.u.constant) == IS_STRING) {
+        if (Z_OP_TYPE(opline->op1) == IS_CONST) {
+            if (Z_TYPE(Z_OP_CONSTANT(opline->op1)) == IS_STRING) {
                 XCACHE_CHECK_OP(file, op1)
                 else XCACHE_CHECK_OP(dir, op1)
@@ -1217 +1217 @@
 
 #ifdef IS_UNICODE
-            else if (Z_TYPE(opline->op1.u.constant) == IS_UNICODE) {
+            else if (Z_TYPE(Z_OP_CONSTANT(opline->op1)) == IS_UNICODE) {
                 XCACHE_U_CHECK_OP(file, op1)
                 else XCACHE_U_CHECK_OP(dir, op1)
@@ -1223 +1223 @@
 #endif
         }
-        if (opline->op2.op_type == IS_CONST) {
-            if (Z_TYPE(opline->op2.u.constant) == IS_STRING) {
+        if (Z_OP_TYPE(opline->op2) == IS_CONST) {
+            if (Z_TYPE(Z_OP_CONSTANT(opline->op2)) == IS_STRING) {
                 XCACHE_CHECK_OP(file, op2)
                 else XCACHE_CHECK_OP(dir, op2)
@@ -1230 +1230 @@
 
 #ifdef IS_UNICODE
-            else if (Z_TYPE(opline->op2.u.constant) == IS_UNICODE) {
+            else if (Z_TYPE(Z_OP_CONSTANT(opline->op2)) == IS_UNICODE) {
                 XCACHE_U_CHECK_OP(file, op2)
                 else XCACHE_U_CHECK_OP(dir, op2)
@@ -1259 +1259 @@
         zend_op *opline = &op_array->opcodes[oplineno];
         if ((oplineinfo & xcache_op1_is_file)) {
-            assert(opline->op1.op_type == IS_CONST);
+            assert(Z_OP_TYPE(opline->op1) == IS_CONST);
             if (copy) {
-                efree(Z_STRVAL(opline->op1.u.constant));
-            }
-            if (Z_TYPE(opline->op1.u.constant) == IS_STRING) {
+                efree(Z_STRVAL(Z_OP_CONSTANT(opline->op1)));
+            }
+            if (Z_TYPE(Z_OP_CONSTANT(opline->op1)) == IS_STRING) {
                 assert(xce->filepath);
-                ZVAL_STRINGL(&opline->op1.u.constant, xce->filepath, xce->filepath_len, copy);
+                ZVAL_STRINGL(&Z_OP_CONSTANT(opline->op1), xce->filepath, xce->filepath_len, copy);
                 TRACE("fixing op1 to %s", xce->filepath);
             }
 #ifdef IS_UNICODE
-            else if (Z_TYPE(opline->op1.u.constant) == IS_UNICODE) {
+            else if (Z_TYPE(Z_OP_CONSTANT(opline->op1)) == IS_UNICODE) {
                 assert(xce->ufilepath);
-                ZVAL_UNICODEL(&opline->op1.u.constant, xce->ufilepath, xce->ufilepath_len, copy);
+                ZVAL_UNICODEL(&Z_OP_CONSTANT(opline->op1), xce->ufilepath, xce->ufilepath_len, copy);
             }
 #endif
@@ -1279 +1279 @@
         }
         else if ((oplineinfo & xcache_op1_is_dir)) {
-            assert(opline->op1.op_type == IS_CONST);
+            assert(Z_OP_TYPE(opline->op1) == IS_CONST);
             if (copy) {
-                efree(Z_STRVAL(opline->op1.u.constant));
-            }
-            if (Z_TYPE(opline->op1.u.constant) == IS_STRING) {
+                efree(Z_STRVAL(Z_OP_CONSTANT(opline->op1)));
+            }
+            if (Z_TYPE(Z_OP_CONSTANT(opline->op1)) == IS_STRING) {
                 assert(xce->dirpath);
                 TRACE("fixing op1 to %s", xce->dirpath);
-                ZVAL_STRINGL(&opline->op1.u.constant, xce->dirpath, xce->dirpath_len, copy);
+                ZVAL_STRINGL(&Z_OP_CONSTANT(opline->op1), xce->dirpath, xce->dirpath_len, copy);
             }
 #ifdef IS_UNICODE
-            else if (Z_TYPE(opline->op1.u.constant) == IS_UNICODE) {
+            else if (Z_TYPE(Z_OP_CONSTANT(opline->op1)) == IS_UNICODE) {
                 assert(!xce->udirpath);
-                ZVAL_UNICODEL(&opline->op1.u.constant, xce->udirpath, xce->udirpath_len, copy);
+                ZVAL_UNICODEL(&Z_OP_CONSTANT(opline->op1), xce->udirpath, xce->udirpath_len, copy);
             }
 #endif
@@ -1300 +1300 @@
 
         if ((oplineinfo & xcache_op2_is_file)) {
-            assert(opline->op2.op_type == IS_CONST);
+            assert(Z_OP_TYPE(opline->op2) == IS_CONST);
             if (copy) {
-                efree(Z_STRVAL(opline->op2.u.constant));
-            }
-            if (Z_TYPE(opline->op2.u.constant) == IS_STRING) {
+                efree(Z_STRVAL(Z_OP_CONSTANT(opline->op2)));
+            }
+            if (Z_TYPE(Z_OP_CONSTANT(opline->op2)) == IS_STRING) {
                 assert(xce->filepath);
                 TRACE("fixing op2 to %s", xce->filepath);
-                ZVAL_STRINGL(&opline->op2.u.constant, xce->filepath, xce->filepath_len, copy);
+                ZVAL_STRINGL(&Z_OP_CONSTANT(opline->op2), xce->filepath, xce->filepath_len, copy);
             }
 #ifdef IS_UNICODE
-            else if (Z_TYPE(opline->op2.u.constant) == IS_UNICODE) {
+            else if (Z_TYPE(Z_OP_CONSTANT(opline->op2)) == IS_UNICODE) {
                 assert(xce->ufilepath);
-                ZVAL_UNICODEL(&opline->op2.u.constant, xce->ufilepath, xce->ufilepath_len, copy);
+                ZVAL_UNICODEL(&Z_OP_CONSTANT(opline->op2), xce->ufilepath, xce->ufilepath_len, copy);
             }
 #endif
@@ -1320 +1320 @@
         }
         else if ((oplineinfo & xcache_op2_is_dir)) {
-            assert(opline->op2.op_type == IS_CONST);
+            assert(Z_OP_TYPE(opline->op2) == IS_CONST);
             if (copy) {
-                efree(Z_STRVAL(opline->op2.u.constant));
-            }
-            if (Z_TYPE(opline->op2.u.constant) == IS_STRING) {
+                efree(Z_STRVAL(Z_OP_CONSTANT(opline->op2)));
+            }
+            if (Z_TYPE(Z_OP_CONSTANT(opline->op2)) == IS_STRING) {
                 assert(!xce->dirpath);
                 TRACE("fixing op2 to %s", xce->dirpath);
-                ZVAL_STRINGL(&opline->op2.u.constant, xce->dirpath, xce->dirpath_len, copy);
+                ZVAL_STRINGL(&Z_OP_CONSTANT(opline->op2), xce->dirpath, xce->dirpath_len, copy);
             }
 #ifdef IS_UNICODE
-            else if (Z_TYPE(opline->op2.u.constant) == IS_UNICODE) {
+            else if (Z_TYPE(Z_OP_CONSTANT(opline->op2)) == IS_UNICODE) {
                 assert(!xce->udirpath);
-                ZVAL_UNICODEL(&opline->op2.u.constant, xce->udirpath, xce->udirpath_len, copy);
+                ZVAL_UNICODEL(&Z_OP_CONSTANT(opline->op2), xce->udirpath, xce->udirpath_len, copy);
             }
 #endif
@@ -3055 +3055 @@
 }
 /* }}} */
-static function_entry xcache_functions[] = /* {{{ */
+static zend_function_entry xcache_functions[] = /* {{{ */
 {
     PHP_FE(xcache_count,             NULL)

trunk/xcache.h

@@ -22 +22 @@
 
 #define HAVE_INODE
-#if !defined(ZEND_ENGINE_2_1) && (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 1 || PHP_MAJOR_VERSION > 5)
+#if !defined(ZEND_ENGINE_2_4) && (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION == 3 && PHP_RELEASE_VERSION >= 99 || PHP_MAJOR_VERSION > 5)
+#   define ZEND_ENGINE_2_4
+#endif
+#if !defined(ZEND_ENGINE_2_3) && (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION == 3 || defined(ZEND_ENGINE_2_4))
+#   define ZEND_ENGINE_2_3
+#endif
+#if !defined(ZEND_ENGINE_2_2) && (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION == 2 || defined(ZEND_ENGINE_2_3))
+#   define ZEND_ENGINE_2_2
+#endif
+#if !defined(ZEND_ENGINE_2_1) && (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION == 1 || defined(ZEND_ENGINE_2_2))
 #   define ZEND_ENGINE_2_1
-#endif
-#if !defined(ZEND_ENGINE_2_2) && (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 2 || PHP_MAJOR_VERSION > 5)
-#   define ZEND_ENGINE_2_2
-#endif
-#if !defined(ZEND_ENGINE_2_3) && (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 3 || PHP_MAJOR_VERSION > 5)
-#   define ZEND_ENGINE_2_3
 #endif
 
@@ -89 +92 @@
 #   define add_assoc_null_ex my_add_assoc_null_ex
 #endif
+
+#ifdef ZEND_ENGINE_2_4
+#   define Z_OP(op) (op)
+#   define Z_OP_CONSTANT(op) (op).literal->constant
+#   define Z_OP_TYPE(op) op##_##type
+
+#   define Z_CLASS_INFO(className) (className).info.user
+#else
+#   define Z_OP(op) (op).u
+#   define Z_OP_CONSTANT(op) (op).u.constant
+#   define Z_OP_TYPE(op) (op).op_type
+typedef znode znode_op;
+
+#   define Z_CLASS_INFO(className) (className)
+#endif
+
 /* }}} */