Changeset 1321 in svn


Ignore:
Timestamp:
2013-07-15T17:37:57Z (2 years ago)
Author:
Xuefer
Message:

add back PHP_4 code for disassembler

Location:
trunk
Files:
23 edited
1 copied

Legend:

Unmodified
Added
Removed
  • trunk/ChangeLog

    r1288 r1321  
    22ChangeLog
    33========
    4  * drop support for PHP_4 in source code
    54 * disassembler: fixes crash with nested sandbox
    65 * disassembler, Decompiler: improves support for PHP_5_4
     
    98 * support for __FILE__ __DIR__ handling after files moved/hardlinked (without xcache.experimental)
    109
    11 3.0.3 2013-16-18
     103.0.3 2013-16.18
    1211========
    1312 * clean files in release (fix htdocs config)
  • trunk/Makefile.frag.deps

    r1312 r1321  
    11$(XCACHE_INCLUDES_I) includes.lo $(builddir)/includes.lo: $(srcdir)/mod_cacher/xc_cache.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_utils.h
    22mod_assembler/xc_assembler.lo $(builddir)/mod_assembler/xc_assembler.lo:
    3 mod_cacher/xc_cacher.lo $(builddir)/mod_cacher/xc_cacher.lo: $(srcdir)/mod_cacher/xc_cache.h $(srcdir)/mod_cacher/xc_cacher.h $(srcdir)/util/xc_align.h $(srcdir)/util/xc_stack.h $(srcdir)/util/xc_trace.h $(srcdir)/util/xc_vector.h $(srcdir)/xcache_globals.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_allocator.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_extension.h $(srcdir)/xcache/xc_ini.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_sandbox.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_utils.h $(XCACHE_PROC_H)
     3mod_cacher/xc_cacher.lo $(builddir)/mod_cacher/xc_cacher.lo: $(srcdir)/mod_cacher/xc_cache.h $(srcdir)/mod_cacher/xc_cacher.h $(srcdir)/util/xc_align.h $(srcdir)/util/xc_stack.h $(srcdir)/util/xc_trace.h $(srcdir)/util/xc_vector.h $(srcdir)/xcache_globals.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_extension.h $(srcdir)/xcache/xc_ini.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_sandbox.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_utils.h
    44mod_coverager/xc_coverager.lo $(builddir)/mod_coverager/xc_coverager.lo: $(srcdir)/mod_coverager/xc_coverager.h $(srcdir)/util/xc_stack.h $(srcdir)/util/xc_trace.h $(srcdir)/xcache_globals.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_extension.h $(srcdir)/xcache/xc_ini.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_utils.h
    55mod_decoder/xc_decoder.lo $(builddir)/mod_decoder/xc_decoder.lo:
    6 mod_disassembler/xc_disassembler.lo $(builddir)/mod_disassembler/xc_disassembler.lo: $(srcdir)/mod_cacher/xc_cache.h $(srcdir)/mod_disassembler/xc_disassembler.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_allocator.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_ini.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_sandbox.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_utils.h $(XCACHE_PROC_H)
     6mod_disassembler/xc_disassembler.lo $(builddir)/mod_disassembler/xc_disassembler.lo: $(srcdir)/mod_disassembler/xc_disassembler.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_ini.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_sandbox.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_utils.h
    77mod_encoder/xc_encoder.lo $(builddir)/mod_encoder/xc_encoder.lo:
    8 mod_optimizer/xc_optimizer.lo $(builddir)/mod_optimizer/xc_optimizer.lo: $(srcdir)/mod_cacher/xc_cache.h $(srcdir)/mod_optimizer/xc_optimizer.h $(srcdir)/util/xc_stack.h $(srcdir)/util/xc_trace.h $(srcdir)/xcache_globals.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_allocator.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_const_string.h $(srcdir)/xcache/xc_extension.h $(srcdir)/xcache/xc_ini.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_opcode_spec.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_utils.h $(XCACHE_PROC_H)
     8mod_optimizer/xc_optimizer.lo $(builddir)/mod_optimizer/xc_optimizer.lo: $(srcdir)/mod_optimizer/xc_optimizer.h $(srcdir)/util/xc_stack.h $(srcdir)/util/xc_trace.h $(srcdir)/xcache_globals.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_const_string.h $(srcdir)/xcache/xc_extension.h $(srcdir)/xcache/xc_ini.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_opcode_spec.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_utils.h
    99util/xc_stack.lo $(builddir)/util/xc_stack.lo: $(srcdir)/util/xc_stack.h $(srcdir)/util/xc_trace.h
    1010util/xc_trace.lo $(builddir)/util/xc_trace.lo: $(srcdir)/util/xc_trace.h
    11 xcache.lo $(builddir)/xcache.lo: $(srcdir)/mod_cacher/xc_cache.h $(srcdir)/util/xc_foreachcoresig.h $(srcdir)/util/xc_stack.h $(srcdir)/xcache_globals.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_allocator.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_const_string.h $(srcdir)/xcache/xc_extension.h $(srcdir)/xcache/xc_ini.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_opcode_spec.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_utils.h $(XCACHE_PROC_H)
     11xcache.lo $(builddir)/xcache.lo: $(srcdir)/util/xc_foreachcoresig.h $(srcdir)/util/xc_stack.h $(srcdir)/xcache_globals.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_const_string.h $(srcdir)/xcache/xc_extension.h $(srcdir)/xcache/xc_ini.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_opcode_spec.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_utils.h
    1212xcache/xc_allocator_bestfit.lo $(builddir)/xcache/xc_allocator_bestfit.lo: $(srcdir)/util/xc_align.h $(srcdir)/util/xc_trace.h $(srcdir)/xcache/xc_allocator.h $(srcdir)/xcache/xc_shm.h
    1313xcache/xc_allocator.lo $(builddir)/xcache/xc_allocator.lo: $(srcdir)/xcache/xc_allocator.h $(srcdir)/xcache/xc_shm.h
    1414xcache/xc_compatibility.lo $(builddir)/xcache/xc_compatibility.lo: $(srcdir)/xcache/xc_compatibility.h
    15 xcache/xc_const_string.lo $(builddir)/xcache/xc_const_string.lo: $(srcdir)/xcache.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_const_string.h $(srcdir)/xcache/xc_const_string_opcodes_php5.0.h $(srcdir)/xcache/xc_const_string_opcodes_php5.1.h $(srcdir)/xcache/xc_const_string_opcodes_php5.3.h $(srcdir)/xcache/xc_const_string_opcodes_php5.4.h $(srcdir)/xcache/xc_const_string_opcodes_php5.5.h $(srcdir)/xcache/xc_const_string_opcodes_php6.x.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_shm.h
     15xcache/xc_const_string.lo $(builddir)/xcache/xc_const_string.lo: $(srcdir)/xcache.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_const_string.h $(srcdir)/xcache/xc_const_string_opcodes_php4.x.h $(srcdir)/xcache/xc_const_string_opcodes_php5.0.h $(srcdir)/xcache/xc_const_string_opcodes_php5.1.h $(srcdir)/xcache/xc_const_string_opcodes_php5.3.h $(srcdir)/xcache/xc_const_string_opcodes_php5.4.h $(srcdir)/xcache/xc_const_string_opcodes_php5.5.h $(srcdir)/xcache/xc_const_string_opcodes_php6.x.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_shm.h
    1616xcache/xc_extension.lo $(builddir)/xcache/xc_extension.lo: $(srcdir)/util/xc_stack.h $(srcdir)/util/xc_trace.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_extension.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_shm.h
    1717xcache/xc_ini.lo $(builddir)/xcache/xc_ini.lo: $(srcdir)/xcache/xc_ini.h
     
    1919xcache/xc_malloc.lo $(builddir)/xcache/xc_malloc.lo: $(srcdir)/util/xc_align.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_allocator.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_shm.h
    2020xcache/xc_opcode_spec.lo $(builddir)/xcache/xc_opcode_spec.lo: $(srcdir)/xcache.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_const_string.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_opcode_spec_def.h $(srcdir)/xcache/xc_opcode_spec.h $(srcdir)/xcache/xc_shm.h
    21 xcache/xc_processor.lo $(builddir)/xcache/xc_processor.lo: $(srcdir)/mod_cacher/xc_cache.h $(srcdir)/util/xc_align.h $(srcdir)/util/xc_stack.h $(srcdir)/xcache_globals.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_allocator.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_const_string.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_utils.h $(XCACHE_PROC_C) $(XCACHE_PROC_H)
     21xcache/xc_processor.lo $(builddir)/xcache/xc_processor.lo:
    2222xcache/xc_sandbox.lo $(builddir)/xcache/xc_sandbox.lo: $(srcdir)/util/xc_stack.h $(srcdir)/xcache_globals.h $(srcdir)/xcache.h $(srcdir)/xcache/xc_compatibility.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_sandbox.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_utils.h
    2323xcache/xc_shm.lo $(builddir)/xcache/xc_shm.lo: $(srcdir)/xcache/xc_shm.h
  • trunk/devel/prepare.cfg.example

    r1281 r1321  
    11# copy this file as prepare.cfg before modifying
     2PHP4_x_DIR=
    23PHP5_0_DIR=
    34PHP5_1_DIR=
  • trunk/devel/prepare.mak

    r1281 r1321  
    1818.PHONY: xc_const_string
    1919xc_const_string: \
     20    xcache/xc_const_string_opcodes_php4.x.h \
    2021    xcache/xc_const_string_opcodes_php5.0.h \
    2122    xcache/xc_const_string_opcodes_php5.1.h \
     
    3233    $(AWK) -f ./devel/gen_xc_opcode_spec.awk < "$<" > "$@".tmp
    3334    mv "$@".tmp "$@"
     35endif
     36
     37ifeq (${PHP4_x_DIR},)
     38xcache/xc_const_string_opcodes_php4.x.h: dummy
     39    @echo "Skipped $@: PHP_4_x_DIR not set"
     40else
     41xcache/xc_const_string_opcodes_php4.x.h: ${PHP4_x_DIR}/Zend/zend_compile.h
     42    $(AWK) -f ./devel/gen_const_string_opcodes.awk < "$<" > "$@.tmp"
     43    mv "$@.tmp" "$@"
    3444endif
    3545
  • trunk/lib/Decompiler.class.php

    r1319 r1321  
    146146class Decompiler_Value extends Decompiler_Object // {{{
    147147{
    148     public $value;
     148    var $value;
    149149
    150150    function Decompiler_Value($value = null)
     
    175175class Decompiler_Code extends Decompiler_Object // {{{
    176176{
    177     public $src;
     177    var $src;
    178178
    179179    function Decompiler_Code($src)
     
    193193class Decompiler_Binop extends Decompiler_Code // {{{
    194194{
    195     public $opc;
    196     public $op1;
    197     public $op2;
    198     public $parent;
     195    var $opc;
     196    var $op1;
     197    var $op2;
     198    var $parent;
    199199
    200200    function Decompiler_Binop($parent, $op1, $opc, $op2)
     
    234234class Decompiler_TriOp extends Decompiler_Code // {{{
    235235{
    236     public $condition;
    237     public $trueValue;
    238     public $falseValue;
     236    var $condition;
     237    var $trueValue;
     238    var $falseValue;
    239239
    240240    function Decompiler_TriOp($condition, $trueValue, $falseValue)
     
    262262class Decompiler_Fetch extends Decompiler_Code // {{{
    263263{
    264     public $src;
    265     public $fetchType;
     264    var $src;
     265    var $fetchType;
    266266
    267267    function Decompiler_Fetch($src, $type, $globalSrc)
     
    295295class Decompiler_Box // {{{
    296296{
    297     public $obj;
     297    var $obj;
    298298
    299299    function Decompiler_Box(&$obj)
     
    310310class Decompiler_Dim extends Decompiler_Value // {{{
    311311{
    312     public $offsets = array();
    313     public $isLast = false;
    314     public $isObject = false;
    315     public $assign = null;
     312    var $offsets = array();
     313    var $isLast = false;
     314    var $isObject = false;
     315    var $assign = null;
    316316
    317317    function toCode($indent)
     
    342342class Decompiler_List extends Decompiler_Code // {{{
    343343{
    344     public $src;
    345     public $dims = array();
    346     public $everLocked = false;
     344    var $src;
     345    var $dims = array();
     346    var $everLocked = false;
    347347
    348348    function toCode($indent)
     
    500500class Decompiler_ForeachBox extends Decompiler_Box // {{{
    501501{
    502     public $iskey;
     502    var $iskey;
    503503
    504504    function toCode($indent)
     
    511511class Decompiler
    512512{
    513     public $namespace;
    514     public $namespaceDecided;
    515     public $activeFile;
    516     public $activeClass;
    517     public $activeMethod;
    518     public $activeFunction;
     513    var $namespace;
     514    var $namespaceDecided;
     515    var $activeFile;
     516    var $activeClass;
     517    var $activeMethod;
     518    var $activeFunction;
    519519
    520520    function Decompiler()
     
    13751375        }
    13761376        unset($op);
    1377         if ($op_array['try_catch_array']) {
     1377        if (isset($op_array['try_catch_array'])) {
    13781378            foreach ($op_array['try_catch_array'] as $try_catch_element) {
    13791379                $catch_op = $try_catch_element['catch_op'];
     
    14931493                $EX['object'] = (int) $res['var'];
    14941494                $EX['called_scope'] = null;
    1495                 $EX['fbc'] = 'new ' . $this->stripNamespace($this->getOpVal($op1, $EX));
     1495                $EX['fbc'] = 'new ' . $this->stripNamespace(isset($op1['constant']) ? $op1['constant'] : $this->getOpVal($op1, $EX));
    14961496                break;
    14971497                // }}}
     
    15391539
    15401540                if ($op1['op_type'] == XC_IS_CONST) {
     1541                    if (!ZEND_ENGINE_2) {
     1542                        $resvar = $op1['constant'];
     1543                        break;
     1544                    }
    15411545                    $resvar = $this->stripNamespace($op1['constant']);
    15421546                }
     
    15551559            case XC_FETCH_UNSET:
    15561560            case XC_FETCH_IS:
    1557                 $fetchType = defined('ZEND_FETCH_TYPE_MASK') ? ($ext & ZEND_FETCH_TYPE_MASK) : $op2['EA.type'];
     1561                $fetchType = defined('ZEND_FETCH_TYPE_MASK') ? ($ext & ZEND_FETCH_TYPE_MASK) : $op2[!ZEND_ENGINE_2 ? 'fetch_type' : 'EA.type'];
    15581562                $name = isset($op1['constant']) ? $op1['constant'] : unquoteName($this->getOpVal($op1, $EX), $EX);
    15591563                if ($fetchType == ZEND_FETCH_STATIC_MEMBER) {
     
    16011605                if (is_a($src, "Decompiler_ForeachBox")) {
    16021606                    assert($opc == XC_FETCH_DIM_TMP_VAR);
    1603                     $src = clone $src;
     1607                    if (ZEND_ENGINE_2) {
     1608                        $src = clone($src);
     1609                    }
     1610                    else {
     1611                        $src = new Decompiler_ForeachBox($src->obj);
     1612                    }
    16041613                    $src->iskey = $op2['constant'];
    16051614                    $resvar = $src;
     
    16421651                }
    16431652                else if ($opc == XC_UNSET_DIM_OBJ) {
    1644                     $dim->isObject = $ext == ZEND_UNSET_OBJ;
     1653                    $dim->isObject = ZEND_ENGINE_2 ? $ext == ZEND_UNSET_OBJ : false /* cannot distingue */;
    16451654                }
    16461655                unset($dim);
     
    17921801                }
    17931802
    1794                 /* TODO: use type mask */
    1795                 switch (($ext & ZEND_ISSET_ISEMPTY_MASK)) {
     1803                switch (((!ZEND_ENGINE_2 ? $op['op2']['var'] /* constant */ : $ext) & ZEND_ISSET_ISEMPTY_MASK)) {
    17961804                case ZEND_ISSET:
    17971805                    $rvalue = "isset(" . str($rvalue) . ")";
     
    18451853            case XC_INIT_NS_FCALL_BY_NAME:
    18461854            case XC_INIT_FCALL_BY_NAME: // {{{
     1855                if (!ZEND_ENGINE_2 && ($ext & ZEND_CTOR_CALL)) {
     1856                    break;
     1857                }
    18471858                array_push($EX['arg_types_stack'], array($EX['fbc'], $EX['object'], $EX['called_scope']));
    18481859                $EX['object'] = null;
     
    25292540        // }}}
    25302541        // {{{ properties
    2531         if (!ZEND_ENGINE_2_4) {
     2542        if (ZEND_ENGINE_2 && !ZEND_ENGINE_2_4) {
    25322543            $default_static_members = $class[ZEND_ENGINE_2_1 ? 'default_static_members' : 'static_members'];
    25332544        }
    2534         $member_variables = $class['properties_info'];
     2545        $member_variables = $class[ZEND_ENGINE_2 ? 'properties_info' : 'default_properties'];
    25352546        if ($member_variables) {
    25362547            echo "\n";
    2537             foreach ($member_variables as $name => $info) {
    2538                 if (!empty($info['doc_comment'])) {
     2548            foreach ($member_variables as $name => $dummy) {
     2549                $info = isset($class['properties_info']) ? $class['properties_info'][$name] : null;
     2550                if (isset($info) && !empty($info['doc_comment'])) {
    25392551                    echo $newindent;
    25402552                    echo $info['doc_comment'];
     
    25432555
    25442556                echo $newindent;
    2545                 $static = ($info['flags'] & ZEND_ACC_STATIC);
    2546 
    2547                 if ($static) {
    2548                     echo "static ";
     2557                if (ZEND_ENGINE_2) {
     2558                    $static = ($info['flags'] & ZEND_ACC_STATIC);
     2559
     2560                    if ($static) {
     2561                        echo "static ";
     2562                    }
    25492563                }
    25502564
    25512565                $mangleSuffix = '';
    2552                 if (!isset($info)) {
     2566                if (!ZEND_ENGINE_2) {
     2567                    echo 'var ';
     2568                }
     2569                else if (!isset($info)) {
    25532570                    echo 'public ';
    25542571                }
     
    25762593                if (ZEND_ENGINE_2_4) {
    25772594                    $value = $class[$static ? 'default_static_members_table' : 'default_properties_table'][$info['offset']];
     2595                }
     2596                else if (!ZEND_ENGINE_2) {
     2597                    $value = $class['default_properties'][$name];
    25782598                }
    25792599                else {
     
    27292749define('ZEND_ENGINE_2_2', ZEND_ENGINE_2_3 || PHP_VERSION >= "5.2.");
    27302750define('ZEND_ENGINE_2_1', ZEND_ENGINE_2_2 || PHP_VERSION >= "5.1.");
     2751define('ZEND_ENGINE_2',   ZEND_ENGINE_2_1 || PHP_VERSION >= "5.0.");
    27312752
    27322753define('ZEND_ACC_STATIC',         0x01);
     
    28802901//*/
    28812902foreach (array (
     2903    'XC_ADD_INTERFACE' => -1,
     2904    'XC_ASSIGN_DIM' => -1,
     2905    'XC_ASSIGN_OBJ' => -1,
     2906    'XC_CATCH' => -1,
     2907    'XC_CLONE' => -1,
     2908    'XC_DECLARE_CLASS' => -1,
    28822909    'XC_DECLARE_CONST' => -1,
     2910    'XC_DECLARE_FUNCTION' => -1,
    28832911    'XC_DECLARE_FUNCTION_OR_CLASS' => -1,
     2912    'XC_DECLARE_INHERITED_CLASS' => -1,
    28842913    'XC_DECLARE_INHERITED_CLASS_DELAYED' => -1,
    28852914    'XC_DECLARE_LAMBDA_FUNCTION' => -1,
    28862915    'XC_DO_FCALL_BY_FUNC' => -1,
     2916    'XC_FETCH_CLASS' => -1,
    28872917    'XC_GOTO' => -1,
     2918    'XC_HANDLE_EXCEPTION' => -1,
    28882919    'XC_INIT_CTOR_CALL' => -1,
    28892920    'XC_INIT_FCALL_BY_FUNC' => -1,
     2921    'XC_INIT_METHOD_CALL' => -1,
    28902922    'XC_INIT_NS_FCALL_BY_NAME' => -1,
     2923    'XC_INIT_STATIC_METHOD_CALL' => -1,
     2924    'XC_INSTANCEOF' => -1,
    28912925    'XC_ISSET_ISEMPTY' => -1,
     2926    'XC_ISSET_ISEMPTY_DIM_OBJ' => -1,
     2927    'XC_ISSET_ISEMPTY_PROP_OBJ' => -1,
     2928    'XC_ISSET_ISEMPTY_VAR' => -1,
    28922929    'XC_JMP_NO_CTOR' => -1,
    28932930    'XC_JMP_SET' => -1,
    28942931    'XC_JMP_SET_VAR' => -1,
     2932    'XC_OP_DATA' => -1,
     2933    'XC_POST_DEC_OBJ' => -1,
     2934    'XC_POST_INC_OBJ' => -1,
     2935    'XC_PRE_DEC_OBJ' => -1,
     2936    'XC_PRE_INC_OBJ' => -1,
    28952937    'XC_QM_ASSIGN_VAR' => -1,
     2938    'XC_RAISE_ABSTRACT_ERROR' => -1,
     2939    'XC_THROW' => -1,
    28962940    'XC_UNSET_DIM' => -1,
    28972941    'XC_UNSET_DIM_OBJ' => -1,
    28982942    'XC_UNSET_OBJ' => -1,
    28992943    'XC_USER_OPCODE' => -1,
     2944    'XC_VERIFY_ABSTRACT_CLASS' => -1,
    29002945) as $k => $v) {
    29012946    if (!defined($k)) {
  • trunk/mod_cacher/xc_cache.h

    r1281 r1321  
    4444    zend_uint           methodinfo_cnt;
    4545    xc_op_array_info_t *methodinfos;
    46     zend_class_entry   *class_entry;
     46    xc_cest_t           cest;
    4747#ifndef ZEND_COMPILE_DELAYED_BINDING
    4848    int                 oplineno;
     
    190190/* {{{ xc_gc_op_array_t */
    191191typedef struct {
     192#ifdef ZEND_ENGINE_2
    192193    zend_uint num_args;
    193194    zend_arg_info *arg_info;
     195#endif
    194196#ifdef ZEND_ENGINE_2_4
    195197    zend_literal *literals;
  • trunk/mod_cacher/xc_cacher.c

    r1313 r1321  
    763763    xc_entry_data_php_t *p = entry_php->php;
    764764    zend_op_array *old_active_op_array = CG(active_op_array);
     765#ifndef ZEND_ENGINE_2
     766    ALLOCA_FLAG(use_heap)
     767    /* new ptr which is stored inside CG(class_table) */
     768    xc_cest_t **new_cest_ptrs = (xc_cest_t **)xc_do_alloca(sizeof(xc_cest_t*) * p->classinfo_cnt, use_heap);
     769#endif
    765770
    766771    CG(active_op_array) = p->op_array;
     
    785790    for (i = 0; i < p->classinfo_cnt; i ++) {
    786791        xc_classinfo_t *ci = &p->classinfos[i];
     792#ifndef ZEND_ENGINE_2
     793        zend_class_entry *ce = CestToCePtr(ci->cest);
     794        /* fix pointer to the be which inside class_table */
     795        if (ce->parent) {
     796            zend_uint class_idx = (/* class_num */ (int) (long) ce->parent) - 1;
     797            assert(class_idx < i);
     798            ci->cest.parent = new_cest_ptrs[class_idx];
     799        }
     800        new_cest_ptrs[i] =
     801#endif
    787802#ifdef ZEND_COMPILE_DELAYED_BINDING
    788         xc_install_class(entry_php->entry.name.str.val, ci->class_entry, -1,
     803        xc_install_class(entry_php->entry.name.str.val, &ci->cest, -1,
    789804                UNISW(0, ci->type), ci->key, ci->key_size, ci->h TSRMLS_CC);
    790805#else
    791         xc_install_class(entry_php->entry.name.str.val, ci->class_entry, ci->oplineno,
     806        xc_install_class(entry_php->entry.name.str.val, &ci->cest, ci->oplineno,
    792807                UNISW(0, ci->type), ci->key, ci->key_size, ci->h TSRMLS_CC);
    793808#endif
     
    811826#endif
    812827
     828    i = 1;
     829#ifndef ZEND_ENGINE_2_2
     830    zend_hash_add(&EG(included_files), entry_php->entry.name.str.val, entry_php->entry.name.str.len+1, (void *)&i, sizeof(int), NULL);
     831#endif
     832
     833#ifndef ZEND_ENGINE_2
     834    xc_free_alloca(new_cest_ptrs, use_heap);
     835#endif
    813836    CG(active_op_array) = old_active_op_array;
    814837    return p->op_array;
     
    9961019        wrapper = php_stream_locate_url_wrapper(filepath, &path_for_open, 0 TSRMLS_CC);
    9971020        if (wrapper && wrapper->wops->url_stat
    998          && wrapper->wops->url_stat(wrapper, path_for_open, PHP_STREAM_URL_STAT_QUIET, &ssb, NULL TSRMLS_CC) == SUCCESS) {
     1021#ifdef ZEND_ENGINE_2
     1022         && wrapper->wops->url_stat(wrapper, path_for_open, PHP_STREAM_URL_STAT_QUIET, &ssb, NULL TSRMLS_CC) == SUCCESS
     1023#else
     1024         && wrapper->wops->url_stat(wrapper, path_for_open, &ssb TSRMLS_CC) == SUCCESS
     1025#endif
     1026        ) {
    9991027            *statbuf = ssb.sb;
    10001028            return SUCCESS;
     
    12741302    zend_uint i;
    12751303    int class_len;
    1276     zend_class_entry *class_entry;
     1304    xc_cest_t cest;
    12771305    xc_entry_data_php_t *php = (xc_entry_data_php_t *) data;
    12781306
    12791307    class_name = Z_OP_CONSTANT(opline->op1).value.str.val;
    12801308    class_len  = Z_OP_CONSTANT(opline->op1).value.str.len;
    1281     if (zend_hash_find(CG(class_table), class_name, class_len, (void **) &class_entry) == FAILURE) {
     1309    if (zend_hash_find(CG(class_table), class_name, class_len, (void **) &cest) == FAILURE) {
    12821310        assert(0);
    12831311    }
     
    17221750
    17231751#ifdef HAVE_XCACHE_CONSTANT
    1724         b = EG(zend_constants)->pListHead; COPY_H(xc_constinfo_t, constinfos, constinfo_cnt, constant,    zend_constant);
    1725 #endif
    1726         b = CG(function_table)->pListHead; COPY_H(xc_funcinfo_t,  funcinfos,  funcinfo_cnt,  func,        zend_function);
    1727         b = CG(class_table)->pListHead;    COPY_H(xc_classinfo_t, classinfos, classinfo_cnt, class_entry, zend_class_entry *);
     1752        b = EG(zend_constants)->pListHead; COPY_H(xc_constinfo_t, constinfos, constinfo_cnt, constant, zend_constant);
     1753#endif
     1754        b = CG(function_table)->pListHead; COPY_H(xc_funcinfo_t,  funcinfos,  funcinfo_cnt,  func,     zend_function);
     1755        b = CG(class_table)->pListHead;    COPY_H(xc_classinfo_t, classinfos, classinfo_cnt, cest,     xc_cest_t);
    17281756
    17291757#undef COPY_H
     1758
     1759        /* for ZE1, cest need to be fixed inside store */
    17301760
    17311761#ifdef ZEND_ENGINE_2_1
     
    17651795        for (i = 0; i < compiler->new_php.classinfo_cnt; i ++) {
    17661796            xc_classinfo_t *classinfo = &compiler->new_php.classinfos[i];
    1767             classinfo->methodinfo_cnt = classinfo->class_entry->function_table.nTableSize;
     1797            zend_class_entry *ce = CestToCePtr(classinfo->cest);
     1798            classinfo->methodinfo_cnt = ce->function_table.nTableSize;
    17681799            if (classinfo->methodinfo_cnt) {
    17691800                int j;
     
    17741805                }
    17751806
    1776                 for (j = 0, b = classinfo->class_entry->function_table.pListHead; b; j ++, b = b->pListNext) {
     1807                for (j = 0, b = ce->function_table.pListHead; b; j ++, b = b->pListNext) {
    17771808                    xc_collect_op_array_info(compiler, &const_usage, &classinfo->methodinfos[j], (zend_op_array *) b->pData TSRMLS_CC);
    17781809                }
     
    19742005        /* discard newly compiled result, restore from stored one */
    19752006        if (compiler->new_php.op_array) {
     2007#ifdef ZEND_ENGINE_2
    19762008            destroy_op_array(compiler->new_php.op_array TSRMLS_CC);
     2009#else
     2010            destroy_op_array(compiler->new_php.op_array);
     2011#endif
    19772012            efree(compiler->new_php.op_array);
    19782013            compiler->new_php.op_array = NULL;
     
    21482183     || !h->filename
    21492184     || !SG(request_info).path_translated
    2150 
    21512185    ) {
    21522186        TRACE("%s", "cacher not enabled");
     
    22372271{
    22382272    xc_gc_op_array_t *op_array = (xc_gc_op_array_t *) pDest;
    2239     zend_uint i;
     2273#ifdef ZEND_ENGINE_2
    22402274    if (op_array->arg_info) {
     2275        zend_uint i;
    22412276        for (i = 0; i < op_array->num_args; i++) {
    22422277            efree((char *) ZSTR_V(op_array->arg_info[i].name));
     
    22472282        efree(op_array->arg_info);
    22482283    }
     2284#endif
    22492285    if (op_array->opcodes) {
    22502286        efree(op_array->opcodes);
     
    27622798{
    27632799    if (!XG(internal_table_copied)) {
    2764         zend_function dummy_func;
    2765         zend_class_entry *dummy_class_entry;
     2800        zend_function tmp_func;
     2801        xc_cest_t tmp_cest;
    27662802
    27672803#ifdef HAVE_XCACHE_CONSTANT
     
    27802816        xc_copy_internal_zend_constants(&XG(internal_constant_table), EG(zend_constants));
    27812817#endif
    2782         zend_hash_copy(&XG(internal_function_table), CG(function_table), NULL, &dummy_func, sizeof(dummy_func));
    2783         zend_hash_copy(&XG(internal_class_table), CG(class_table), NULL, &dummy_class_entry, sizeof(dummy_class_entry));
     2818        zend_hash_copy(&XG(internal_function_table), CG(function_table), NULL, &tmp_func, sizeof(tmp_func));
     2819        zend_hash_copy(&XG(internal_class_table), CG(class_table), NULL, &tmp_cest, sizeof(tmp_cest));
    27842820
    27852821        XG(internal_table_copied) = 1;
     
    27872823    xc_holds_init(TSRMLS_C);
    27882824    xc_var_namespace_init(TSRMLS_C);
     2825#ifdef ZEND_ENGINE_2
    27892826    zend_llist_init(&XG(gc_op_arrays), sizeof(xc_gc_op_array_t), xc_gc_op_array, 0);
     2827#endif
    27902828
    27912829#if PHP_API_VERSION <= 20041225
     
    28082846    xc_gc_deletes(TSRMLS_C);
    28092847    xc_var_namespace_destroy(TSRMLS_C);
     2848#ifdef ZEND_ENGINE_2
    28102849    zend_llist_destroy(&XG(gc_op_arrays));
     2850#endif
    28112851}
    28122852/* }}} */
     
    37393779}
    37403780/* }}} */
    3741 /* {{{ static ZEND_MODULE_POST_ZEND_DEACTIVATE_D(xcache_cacher) */
     3781/* {{{ static PHP_RSHUTDOWN_FUNCTION(xcache_cacher) */
     3782#ifndef ZEND_ENGINE_2
     3783static PHP_RSHUTDOWN_FUNCTION(xcache_cacher)
     3784#else
    37423785static ZEND_MODULE_POST_ZEND_DEACTIVATE_D(xcache_cacher)
    3743 {
     3786#endif
     3787{
     3788#ifdef ZEND_ENGINE_2
    37443789    TSRMLS_FETCH();
     3790#endif
    37453791
    37463792    xc_request_shutdown(TSRMLS_C);
     
    37553801    PHP_MSHUTDOWN(xcache_cacher),
    37563802    PHP_RINIT(xcache_cacher),
     3803#ifndef ZEND_ENGINE_2
     3804    PHP_RSHUTDOWN(xcache_cacher),
     3805#else
    37573806    NULL,
     3807#endif
    37583808    PHP_MINFO(xcache_cacher),
    37593809    XCACHE_VERSION,
     
    37613811    NO_MODULE_GLOBALS,
    37623812#endif
     3813#ifdef ZEND_ENGINE_2
    37633814    ZEND_MODULE_POST_ZEND_DEACTIVATE_N(xcache_cacher),
     3815#else
     3816    NULL,
     3817    NULL,
     3818#endif
    37643819    STANDARD_MODULE_PROPERTIES_EX
    37653820};
  • trunk/mod_coverager/xc_coverager.c

    r1281 r1321  
    703703    NO_MODULE_GLOBALS,
    704704#endif
     705#ifdef ZEND_ENGINE_2
    705706    NULL,
     707#else
     708    NULL,
     709    NULL,
     710#endif
    706711    STANDARD_MODULE_PROPERTIES_EX
    707712};
  • trunk/mod_disassembler/xc_disassembler.c

    r1313 r1321  
    7676        ALLOC_INIT_ZVAL(zv);
    7777        array_init(zv);
    78         xc_dasm_zend_class_entry(&dasm, zv, *(zend_class_entry **)b->pData TSRMLS_CC);
     78        xc_dasm_zend_class_entry(&dasm, zv, CestToCePtr(*(xc_cest_t *)b->pData) TSRMLS_CC);
    7979
    8080        keysize = BUCKET_KEY_SIZE(b) + 2;
     
    151151
    152152    /* free */
     153#ifdef ZEND_ENGINE_2
    153154    destroy_op_array(op_array TSRMLS_CC);
     155#else
     156    destroy_op_array(op_array);
     157#endif
    154158    efree(op_array);
    155159
     
    247251    NO_MODULE_GLOBALS,
    248252#endif
    249     NULL,
     253#ifdef ZEND_ENGINE_2
     254    NULL,
     255#else
     256    NULL,
     257    NULL,
     258#endif
    250259    STANDARD_MODULE_PROPERTIES_EX
    251260};
  • trunk/mod_optimizer/xc_optimizer.c

    r1310 r1321  
    4545
    4646    bbid_t     fall;
     47#ifdef ZEND_ENGINE_2
    4748    bbid_t     catch;
     49#endif
    4850#ifdef ZEND_ENGINE_2_5
    4951    bbid_t     finally;
     
    313315
    314316    bb->fall       = BBID_INVALID;
     317#ifdef ZEND_ENGINE_2
    315318    bb->catch      = BBID_INVALID;
     319#endif
    316320#ifdef ZEND_ENGINE_2_5
    317321    bb->finally    = BBID_INVALID;
     
    347351    op_flowinfo_t fi;
    348352    zend_op *last = bb->opcodes + bb->count - 1;
    349     bbid_t catchbbid = bb->catch;
     353    bbid_t catchbbid = ZESW(BBID_INVALID, bb->catch);
    350354    bbid_t finallybbid;
    351355#ifdef ZEND_ENGINE_2_5
     356    finallybbid = BBID_INVALID;
     357#else
    352358    finallybbid = bb->finally;
    353 #else
    354     finallybbid = BBID_INVALID;
    355359#endif
    356360
     
    424428        zend_bool isbbhead;
    425429        bbid_t bbid;
     430#ifdef ZEND_ENGINE_2
    426431        bbid_t catchbbid;
     432#endif
    427433#ifdef ZEND_ENGINE_2_5
    428434        bbid_t finallybbid;
     
    451457        }
    452458    }
     459#ifdef ZEND_ENGINE_2
    453460    /* mark try start */
    454461    for (i = 0; i < op_array->last_try_catch; i ++) {
     
    459466#endif
    460467    }
     468#endif
    461469    /* }}} */
    462470    /* {{{ fill op lines with newly allocated id */
     
    474482    }
    475483    /* }}} */
     484#ifdef ZEND_ENGINE_2
    476485    /* {{{ fill op lines with catch id */
    477486    for (i = 0; i < count; i ++) {
     
    502511#endif
    503512    /* }}} */
     513#endif
    504514    /* {{{ create basic blocks */
    505515    start = 0;
     
    513523        opline = op_array->opcodes + start;
    514524        bb = bbs_new_bb_ex(bbs, opline, i - start);
     525#ifdef ZEND_ENGINE_2
    515526        bb->catch = oplineinfos[start].catchbbid;
     527#endif
    516528#ifdef ZEND_ENGINE_2_5
    517529        bb->finally = oplineinfos[start].finallybbid;
     
    554566{
    555567    int bbid;
     568#ifdef ZEND_ENGINE_2
     569    bbid_t lasttrybbid;
    556570    bbid_t lastcatchbbid;
     571#endif
    557572#ifdef ZEND_ENGINE_2_5
    558573    bbid_t lastfinallybbid;
     
    580595    }
    581596
     597#ifdef ZEND_ENGINE_2
     598    lasttrybbid   = BBID_INVALID;
    582599    lastcatchbbid = BBID_INVALID;
    583 #ifdef ZEND_ENGINE_2_5
     600#   ifdef ZEND_ENGINE_2_5
    584601    lastfinallybbid = BBID_INVALID;
    585 #endif
     602#   endif
    586603    op_array->last_try_catch = 0;
    587604    for (bbid = 0; bbid < bbs_count(bbs); bbid ++) {
     
    589606
    590607        if (lastcatchbbid != bb->catch
    591 #ifdef ZEND_ENGINE_2_5
     608#   ifdef ZEND_ENGINE_2_5
    592609         || lastfinallybbid != bb->finally
    593 #endif
     610#   endif
    594611        ) {
    595612            if (bb->catch != BBID_INVALID
    596 #ifdef ZEND_ENGINE_2_5
     613#   ifdef ZEND_ENGINE_2_5
    597614             && bb->finally != BBID_INVALID
    598 #endif
     615#   endif
    599616            ) {
    600617                zend_uint try_op = bbs_get(bbs, bbid)->opnum;
    601618                zend_uint catch_op = bbs_get(bbs, bb->catch)->opnum;
    602 #ifdef ZEND_ENGINE_2_5
     619#   ifdef ZEND_ENGINE_2_5
    603620                zend_uint finally_op = bbs_get(bbs, bb->finally)->opnum;
    604 #endif
     621#   endif
    605622
    606623                zend_bool already_in_try_catch = 0;
     
    611628                    if (try_op >= element->try_op && try_op < element->catch_op
    612629                     && catch_op == element->catch_op
    613 #ifdef ZEND_ENGINE_2_5
     630#   ifdef ZEND_ENGINE_2_5
    614631                     && finally_op == element->finally_op
    615 #endif
     632#   endif
    616633                    ) {
    617634                        already_in_try_catch = 1;
     
    625642                    op_array->try_catch_array[try_catch_offset].try_op = try_op;
    626643                    op_array->try_catch_array[try_catch_offset].catch_op = catch_op;
    627 #ifdef ZEND_ENGINE_2_5
     644#   ifdef ZEND_ENGINE_2_5
    628645                    op_array->try_catch_array[try_catch_offset].finally_op = finally_op;
    629 #endif
     646#   endif
    630647                }
    631648            }
    632649            lastcatchbbid = bb->catch;
    633 #ifdef ZEND_ENGINE_2_5
     650#   ifdef ZEND_ENGINE_2_5
    634651            lastfinallybbid = bb->finally;
    635 #endif
     652#   endif
    636653        }
    637654    }
    638655    /* it is impossible to have last bb catched */
     656#endif /* ZEND_ENGINE_2 */
    639657}
    640658/* }}} */
     
    767785    NO_MODULE_GLOBALS,
    768786#endif
     787#ifdef ZEND_ENGINE_2
    769788    NULL,
     789#else
     790    NULL,
     791    NULL,
     792#endif
    770793    STANDARD_MODULE_PROPERTIES_EX
    771794};
  • trunk/processor/head.m4

    r1281 r1321  
    248248    }
    249249    for (i = 0; i < php->classinfo_cnt; i ++) {
    250         ceptr = php->classinfos[i].class_entry;
    251         if (ceptr == ce) {
     250        ceptr = CestToCePtr(php->classinfos[i].cest);
     251        if (ZCEP_REFCOUNT_PTR(ceptr) == ZCEP_REFCOUNT_PTR(ce)) {
    252252            processor->cache_ce = ceptr;
    253253            processor->cache_class_index = i;
     
    261261/* }}} */
    262262/* {{{ xc_get_class */
     263#ifdef ZEND_ENGINE_2
    263264static zend_class_entry *xc_get_class(xc_processor_t *processor, zend_ulong class_num) {
    264265    /* must be parent or currrent class */
    265266    assert(class_num <= processor->active_class_index + 1);
    266     return processor->php_dst->classinfos[class_num - 1].class_entry;
    267 }
     267    return CestToCePtr(processor->php_dst->classinfos[class_num - 1].cest);
     268}
     269#endif
    268270define(`xc_get_class', `xc_get_classNOTDEFINED')
    269271/* }}} */
     272#ifdef ZEND_ENGINE_2
    270273/* fix method on store */
    271274static void xc_fix_method(xc_processor_t *processor, zend_op_array *dst TSRMLS_DC) /* {{{ */
     
    342345}
    343346/* }}} */
     347#endif
    344348/* {{{ call op_array ctor handler */
    345349extern zend_bool xc_have_op_array_ctor;
  • trunk/processor/processor.m4

    r1313 r1321  
    1212DECL_STRUCT_P_FUNC(`xc_entry_var_t')
    1313DECL_STRUCT_P_FUNC(`xc_entry_php_t')
     14#ifdef ZEND_ENGINE_2
    1415DECL_STRUCT_P_FUNC(`zend_property_info')
     16#endif
    1517/* }}} */
    1618dnl ====================================================
     
    3234')
    3335dnl }}}
     36#ifndef ZEND_ENGINE_2
     37DEF_STRUCT_P_FUNC(`int', , `dnl {{{
     38    IFCOPY(`*dst = *src;')
     39    IFDPRINT(`
     40        INDENT()
     41        fprintf(stderr, "%d\n", src[0]);
     42    ')
     43    DONE_SIZE(sizeof(src[0]))
     44')
     45dnl }}}
     46#endif
     47#ifdef ZEND_ENGINE_2
    3448DEF_STRUCT_P_FUNC(`zend_try_catch_element', , `dnl {{{
    3549    PROCESS(zend_uint, try_op)
     
    4155')
    4256dnl }}}
     57#endif
    4358DEF_STRUCT_P_FUNC(`zend_brk_cont_element', , `dnl {{{
    4459#ifdef ZEND_ENGINE_2_2
     
    5267DEF_HASH_TABLE_FUNC(`HashTable_zval_ptr',           `zval_ptr')
    5368DEF_HASH_TABLE_FUNC(`HashTable_zend_function',      `zend_function')
     69#ifdef ZEND_ENGINE_2
    5470DEF_HASH_TABLE_FUNC(`HashTable_zend_property_info', `zend_property_info')
     71#endif
    5572DEF_STRUCT_P_FUNC(`zval', , `dnl {{{
    5673    IFDASM(`do {
     
    116133                IFNOTMEMCPY(`IFCOPY(`memcpy(dst, src, sizeof(src[0]));')')
    117134                dnl STRUCT(value.obj)
     135#ifndef ZEND_ENGINE_2
     136                STRUCT_P(zend_class_entry, value.obj.ce)
     137                STRUCT_P(HashTable, value.obj.properties, HashTable_zval_ptr)
     138#endif
    118139                break;
    119140
     
    133154#ifdef ZEND_ENGINE_2_3
    134155        PROCESS(zend_uint, refcount__gc)
    135 #else
     156#elif defined(ZEND_ENGINE_2)
    136157        PROCESS(zend_uint, refcount)
     158#else
     159        PROCESS(zend_ushort, refcount)
    137160#endif
    138161    ')dnl IFDASM
     
    185208                dnl fprintf(stderr, "copy from %p to %p\n", src[0], dst[0]);
    186209            ')
    187             IFDPRINT(`INDENT()`'fprintf(stderr, "[%p] ", src[0]);')
     210            IFDPRINT(`INDENT()`'fprintf(stderr, "[%p] ", (void *) src[0]);')
    188211            STRUCT_P_EX(zval, dst[0], src[0], `[0]', `', ` ')
    189212            FIXPOINTER_EX(zval, dst[0])
     
    205228')
    206229dnl }}}
     230#ifdef ZEND_ENGINE_2
    207231DEF_STRUCT_P_FUNC(`zend_arg_info', , `dnl {{{
    208232    PROCESS(zend_uint, name_len)
     
    223247')
    224248dnl }}}
     249#endif
    225250#ifdef HAVE_XCACHE_CONSTANT
    226251DEF_STRUCT_P_FUNC(`zend_constant', , `dnl {{{
     
    256281')
    257282dnl }}}
     283#ifdef ZEND_ENGINE_2
    258284DEF_STRUCT_P_FUNC(`zend_property_info', , `dnl {{{
    259285    PROCESS(zend_uint, flags)
     
    274300')
    275301dnl }}}
     302#endif
    276303#ifdef ZEND_ENGINE_2_4
    277304DEF_STRUCT_P_FUNC(`zend_trait_method_reference', , `dnl {{{
     
    336363    PROCESS(zend_uint, name_length)
    337364    PROC_ZSTRING_L(, name, name_length)
    338     PROC_CLASS_ENTRY_P(parent)
     365    IFRESTORE(`
     366#ifndef ZEND_ENGINE_2
     367        /* just copy parent and resolve on install_class */
     368        COPY(parent)
     369#else
     370        PROC_CLASS_ENTRY_P(parent)
     371#endif
     372    ', `
     373        PROC_CLASS_ENTRY_P(parent)
     374    ')
     375#ifdef ZEND_ENGINE_2
    339376    PROCESS(int, refcount)
     377#else
     378    STRUCT_P(int, refcount)
     379#endif
    340380#ifndef ZEND_ENGINE_2_4
    341381    PROCESS(zend_bool, constants_updated)
    342382#endif
     383#ifdef ZEND_ENGINE_2
    343384    PROCESS(zend_uint, ce_flags)
    344 
     385#endif
     386
     387#ifdef ZEND_ENGINE_2
    345388    STRUCT(HashTable, properties_info, HashTable_zend_property_info)
     389#endif
    346390
    347391#ifdef ZEND_ENGINE_2_4
     
    360404    IFCOPY(`dst->static_members = &dst->default_static_members;')
    361405    DONE(static_members)
    362 #   else
     406#   elif defined(ZEND_ENGINE_2)
    363407    STRUCT_P(HashTable, static_members, HashTable_zval_ptr)
    364408#   endif
    365409#endif /* ZEND_ENGINE_2_4 */
    366410
     411#ifdef ZEND_ENGINE_2
    367412    STRUCT(HashTable, constants_table, HashTable_zval_ptr)
    368413
     
    449494    COPY(module)
    450495#   endif
     496#else /* ZEND_ENGINE_2 */
     497    COPY(handle_function_call)
     498    COPY(handle_property_get)
     499    COPY(handle_property_set)
     500#endif
    451501    dnl must do after SETNULL(constructor) and dst->parent
    452502    STRUCT(HashTable, function_table, HashTable_zend_function)
     
    555605            IFDASM(`PROCESS(zend_uint, u.var)')
    556606            PROCESS(zend_uint, u.opline_num)
     607#ifndef ZEND_ENGINE_2
     608            PROCESS(zend_uint, u.fetch_type)
     609#endif
    557610            PROCESS(zend_uint, u.EA.type)
    558611            break;
     
    607660#endif
    608661        popdef(`UNION_znode_op_literal')
     662#ifdef ZEND_ENGINE_2
    609663        switch (src->opcode) {
    610 #ifdef ZEND_GOTO
     664#   ifdef ZEND_GOTO
    611665            case ZEND_GOTO:
    612 #endif
     666#   endif
    613667            case ZEND_JMP:
    614 #ifdef ZEND_FAST_CALL
     668#   ifdef ZEND_FAST_CALL
    615669            case ZEND_FAST_CALL:
    616 #endif
     670#   endif
    617671                assert(Z_OP(src->op1).jmp_addr >= processor->active_op_array_src->opcodes && Z_OP(src->op1).jmp_addr - processor->active_op_array_src->opcodes < processor->active_op_array_src->last);
    618672                Z_OP(dst->op1).jmp_addr = processor->active_op_array_dst->opcodes + (Z_OP(src->op1).jmp_addr - processor->active_op_array_src->opcodes);
     
    624678            case ZEND_JMPZ_EX:
    625679            case ZEND_JMPNZ_EX:
    626 #ifdef ZEND_JMP_SET
     680#   ifdef ZEND_JMP_SET
    627681            case ZEND_JMP_SET:
    628 #endif
    629 #ifdef ZEND_JMP_SET_VAR
     682#   endif
     683#   ifdef ZEND_JMP_SET_VAR
    630684            case ZEND_JMP_SET_VAR:
    631 #endif
     685#   endif
    632686                assert(Z_OP(src->op2).jmp_addr >= processor->active_op_array_src->opcodes && Z_OP(src->op2).jmp_addr - processor->active_op_array_src->opcodes < processor->active_op_array_src->last);
    633687                Z_OP(dst->op2).jmp_addr = processor->active_op_array_dst->opcodes + (Z_OP(src->op2).jmp_addr - processor->active_op_array_src->opcodes);
     
    638692                break;
    639693        }
    640     ')
     694#   endif
     695    ')
     696#ifdef ZEND_ENGINE_2
    641697    PROCESS(opcode_handler_t, handler)
     698#endif
    642699')
    643700dnl }}}
     
    686743        /* deep */
    687744        STRUCT_P(HashTable, static_variables, HashTable_zval_ptr)
     745#ifdef ZEND_ENGINE_2
    688746        STRUCT_ARRAY(zend_uint, num_args, zend_arg_info, arg_info)
    689747        gc_arg_info = 1;
     748#endif
    690749        dst->filename = processor->entry_php_src->filepath;
    691750#ifdef ZEND_ENGINE_2_4
     
    731790                    case ZEND_FAST_CALL:
    732791#endif
     792#ifdef ZEND_ENGINE_2
    733793                        Z_OP(opline->op1).jmp_addr = &dst->opcodes[Z_OP(opline->op1).jmp_addr - src->opcodes];
     794#endif
    734795                        break;
    735796
     
    744805            case ZEND_JMP_SET_VAR:
    745806#endif
     807#ifdef ZEND_ENGINE_2
    746808                        Z_OP(opline->op2).jmp_addr = &dst->opcodes[Z_OP(opline->op2).jmp_addr - src->opcodes];
     809#endif
    747810                        break;
    748811
     
    758821        ) {
    759822            xc_gc_op_array_t gc_op_array;
     823#ifdef ZEND_ENGINE_2
    760824            gc_op_array.num_args = gc_arg_info ? dst->num_args : 0;
    761825            gc_op_array.arg_info = gc_arg_info ? dst->arg_info : NULL;
     826#endif
    762827            gc_op_array.opcodes  = gc_opcodes ? dst->opcodes : NULL;
    763828#ifdef ZEND_ENGINE_2_4
     
    776841    PROCESS(zend_uchar, type)
    777842    PROC_ZSTRING(, function_name)
     843#ifdef ZEND_ENGINE_2
    778844    PROCESS(zend_uint, fn_flags)
    779845    STRUCT_ARRAY(zend_uint, num_args, zend_arg_info, arg_info)
     
    783849    PROCESS(zend_bool, pass_rest_by_reference)
    784850#   endif
     851#else
     852    if (src->arg_types) {
     853        ALLOC(dst->arg_types, zend_uchar, src->arg_types[0] + 1)
     854        IFCOPY(`memcpy(dst->arg_types, src->arg_types, sizeof(src->arg_types[0]) * (src->arg_types[0]+1));')
     855        IFDASM(`do {
     856            int i;
     857            zval *zv;
     858            ALLOC_INIT_ZVAL(zv);
     859            array_init(zv);
     860            for (i = 0; i < src->arg_types[0]; i ++) {
     861                add_next_index_long(zv, src->arg_types[i + 1]);
     862            }
     863            add_assoc_zval_ex(dst, ZEND_STRS("arg_types"), zv);
     864        } while (0);')
     865        DONE(arg_types)
     866    }
     867    else {
     868        COPYNULL(arg_types)
     869    }
     870#endif
    785871#ifndef ZEND_ENGINE_2_4
    786872    PROCESS(unsigned char, return_reference)
     
    833919    PROCESS(zend_uint, current_brk_cont)
    834920#endif
    835 
     921#ifndef ZEND_ENGINE_2
     922    PROCESS(zend_bool, uses_globals)
     923#endif
     924
     925#ifdef ZEND_ENGINE_2
    836926    STRUCT_ARRAY(int, last_try_catch, zend_try_catch_element, try_catch_array)
    837927    PROCESS(int, last_try_catch)
     928#endif
    838929#ifdef ZEND_ENGINE_2_5
    839930    PROCESS(zend_bool, has_finally_block)
     
    866957    ')
    867958#endif
     959#ifdef ZEND_ENGINE_2
    868960    PROCESS(zend_uint, line_start)
    869961    PROCESS(zend_uint, line_end)
    870962    PROCESS(int, doc_comment_len)
    871963    PROC_ZSTRING_L(, doc_comment, doc_comment_len)
     964#endif
    872965#ifdef ZEND_COMPILE_DELAYED_BINDING
    873966    PROCESS(zend_uint, early_binding);
     
    886979    IFRESTORE(`xc_fix_op_array_info(processor->entry_php_src, processor->php_src, dst, shallow_copy, op_array_info TSRMLS_CC);')
    887980
     981#ifdef ZEND_ENGINE_2
    888982    dnl mark it as -1 on store, and lookup parent on restore
    889983    IFSTORE(`dst->prototype = (processor->active_class_entry_src && src->prototype) ? (zend_function *) -1 : NULL;', `
     
    9141008    DONE(prototype)
    9151009
     1010#endif
     1011
     1012#ifdef ZEND_ENGINE_2
    9161013    PROC_CLASS_ENTRY_P(scope)
    9171014    IFCOPY(`
     
    9201017        }
    9211018    ')
     1019#endif
    9221020
    9231021    IFRESTORE(`
     
    10041102        processor->active_op_array_index = 0;
    10051103    ')
    1006     STRUCT_P(zend_class_entry, class_entry)
     1104#ifdef ZEND_ENGINE_2
     1105    STRUCT_P(zend_class_entry, cest)
     1106#else
     1107    STRUCT(zend_class_entry, cest)
     1108#endif
    10071109#ifndef ZEND_COMPILE_DELAYED_BINDING
    10081110    PROCESS(int, oplineno)
  • trunk/xcache.c

    r1313 r1321  
    115115/* }}} */
    116116/* {{{ PHP_GINIT_FUNCTION(xcache) */
    117 #define xcache_globals xcacheglobals
     117#pragma GCC push_options
     118#pragma GCC diagnostic ignored "-Wshadow"
     119
    118120#ifdef PHP_GINIT_FUNCTION
    119121static PHP_GINIT_FUNCTION(xcache)
    120122#else
    121 static void xc_init_globals(zend_xcache_globals *xcache_globals TSRMLS_DC)
    122 #endif
    123 {
     123static void xc_init_globals(zend_xcache_globals* xcache_globals TSRMLS_DC)
     124#endif
     125{
     126#pragma GCC pop_options
     127
    124128    memset(xcache_globals, 0, sizeof(zend_xcache_globals));
    125129
     
    130134    zend_hash_init_ex(&xcache_globals->internal_class_table,    1, NULL, NULL, 1, 0);
    131135}
    132 #undef xcache_globals
    133136/* }}} */
    134137/* {{{ PHP_GSHUTDOWN_FUNCTION(xcache) */
    135138static
    136139#ifdef PHP_GSHUTDOWN_FUNCTION
    137 #define xcache_globals xcacheglobals
    138140PHP_GSHUTDOWN_FUNCTION(xcache)
    139141#else
     
    169171    }
    170172}
    171 #undef xcache_globals
    172173/* }}} */
    173174
     
    885886    PHP_GSHUTDOWN(xcache),
    886887#endif
     888#ifdef ZEND_ENGINE_2
    887889    NULL /* ZEND_MODULE_POST_ZEND_DEACTIVATE_N */,
     890#else
     891    NULL,
     892    NULL,
     893#endif
    888894    STANDARD_MODULE_PROPERTIES_EX
    889895};
  • trunk/xcache/xc_compatibility.c

    r1281 r1321  
    22
    33#ifndef ZEND_ENGINE_2_3
     4#include "ext/standard/php_string.h"
     5size_t xc_dirname(char *path, size_t len) /* {{{ */
     6{
     7#ifdef ZEND_ENGINE_2
     8    return php_dirname(path, len);
     9#else
     10    php_dirname(path, len);
     11    return strlen(path);
     12#endif
     13}
     14/* }}} */
     15
    416long xc_atol(const char *str, int str_len) /* {{{ */
    517{
  • trunk/xcache/xc_compatibility.h

    r1281 r1321  
    2828
    2929#define NOTHING
    30 /* ZendEngine version code Switcher */
     30/* ZendEngine code Switcher */
     31#ifndef ZEND_ENGINE_2
     32#   define ZESW(v1, v2) v1
     33#else
     34#   define ZESW(v1, v2) v2
     35#endif
    3136#ifdef ZEND_ENGINE_2_4
    3237#   define ZEND_24(pre24, v24) v24
     
    208213/* }}} */
    209214
     215/* the class entry type to be stored in class_table */
     216typedef ZESW(zend_class_entry, zend_class_entry*) xc_cest_t;
     217
     218/* xc_cest_t to (zend_class_entry*) */
     219#define CestToCePtr(st) (ZESW(\
     220            &(st), \
     221            st \
     222            ) )
     223
     224/* ZCEP=zend class entry ptr */
     225#define ZCEP_REFCOUNT_PTR(pce) (ZESW( \
     226            (pce)->refcount, \
     227            &((pce)->refcount) \
     228            ))
     229
    210230#ifndef ZEND_ENGINE_2_3
    211 #include "ext/standard/php_string.h"
    212 static inline size_t zend_dirname(char *path, size_t len) { return php_dirname(path, len); }
     231size_t xc_dirname(char *path, size_t len);
     232#define zend_dirname xc_dirname
    213233long xc_atol(const char *str, int len);
    214234#define zend_atol xc_atol
     
    220240
    221241#ifndef PHP_FE_END
    222 #   define PHP_FE_END {NULL, NULL, NULL, 0, 0}
     242#   ifdef ZEND_ENGINE_2
     243#       define PHP_FE_END {NULL, NULL, NULL, 0, 0}
     244#   else
     245#       define PHP_FE_END {NULL, NULL, NULL}
     246#   endif
    223247#endif
    224248
  • trunk/xcache/xc_const_string.c

    r1281 r1321  
    7272#elif defined(ZEND_ENGINE_2_1)
    7373#   include "xc_const_string_opcodes_php5.1.h"
     74#elif defined(ZEND_ENGINE_2)
     75#   include "xc_const_string_opcodes_php5.0.h"
    7476#else
    75 #   include "xc_const_string_opcodes_php5.0.h"
     77#   include "xc_const_string_opcodes_php4.x.h"
    7678#endif
    7779
  • trunk/xcache/xc_const_string_opcodes_php5.3.h

    r1281 r1321  
    152152/* 149 */   "HANDLE_EXCEPTION",
    153153/* 150 */   "USER_OPCODE",
    154 #ifdef ZEND_ENGINE_2_3
    155154/* 151 */   "UNDEF",
    156155/* 152 */   "JMP_SET",
    157156/* 153 */   "DECLARE_LAMBDA_FUNCTION"
    158 #endif
    159157};
  • trunk/xcache/xc_ini.h

    r1281 r1321  
    1313PHP_INI_MH(xcache_OnUpdateBool);
    1414PHP_INI_MH(xcache_OnUpdateString);
     15#ifndef ZEND_ENGINE_2
     16#define OnUpdateLong OnUpdateInt
     17#endif
    1518
    1619#endif /* XC_INI_H_E208B8E597E7FAD950D249BE9C6B6F53 */
  • trunk/xcache/xc_opcode_spec.c

    r1306 r1321  
    55/* {{{ opcode_spec */
    66#define OPSPEC(ext, op1, op2, res) { OPSPEC_##ext, OPSPEC_##op1, OPSPEC_##op2, OPSPEC_##res },
    7 #define OPSPEC_VAR_2 OPSPEC_STD
     7#ifdef ZEND_ENGINE_2
     8#   define OPSPEC_VAR_2 OPSPEC_STD
     9#else
     10#   define OPSPEC_VAR_2 OPSPEC_VAR
     11#endif
    812#ifdef ZEND_ENGINE_2_4
    913#undef OPSPEC_FETCH
  • trunk/xcache/xc_opcode_spec_def.h

    r1319 r1321  
    2323    OPSPEC(      CAST,        STD,     UNUSED,        TMP) /* 21 CAST                           */
    2424    OPSPEC(    UNUSED,        STD,     UNUSED,        TMP) /* 22 QM_ASSIGN                      */
     25#ifdef ZEND_ENGINE_2
    2526    OPSPEC(    ASSIGN,        STD,        STD,        VAR) /* 23 ASSIGN_ADD                     */
    2627    OPSPEC(    ASSIGN,        STD,        STD,        VAR) /* 24 ASSIGN_SUB                     */
     
    3435    OPSPEC(    ASSIGN,        STD,        STD,        VAR) /* 32 ASSIGN_BW_AND                  */
    3536    OPSPEC(    ASSIGN,        STD,        STD,        VAR) /* 33 ASSIGN_BW_XOR                  */
     37#else
     38    OPSPEC(    UNUSED,        VAR,        STD,        VAR)
     39    OPSPEC(    UNUSED,        VAR,        STD,        VAR)
     40    OPSPEC(    UNUSED,        VAR,        STD,        VAR)
     41    OPSPEC(    UNUSED,        VAR,        STD,        VAR)
     42    OPSPEC(    UNUSED,        VAR,        STD,        VAR)
     43    OPSPEC(    UNUSED,        VAR,        STD,        VAR)
     44    OPSPEC(    UNUSED,        VAR,        STD,        VAR)
     45    OPSPEC(    UNUSED,        VAR,        STD,        VAR)
     46    OPSPEC(    UNUSED,        VAR,        STD,        VAR)
     47    OPSPEC(    UNUSED,        VAR,        STD,        VAR)
     48    OPSPEC(    UNUSED,        VAR,        STD,        VAR)
     49#endif
    3650    OPSPEC(    UNUSED,        VAR,     UNUSED,        VAR) /* 34 PRE_INC                        */
    3751    OPSPEC(    UNUSED,        VAR,     UNUSED,        VAR) /* 35 PRE_DEC                        */
     
    4256    OPSPEC(    UNUSED,        STD,     UNUSED,     UNUSED) /* 40 ECHO                           */
    4357    OPSPEC(    UNUSED,        STD,     UNUSED,        TMP) /* 41 PRINT                          */
     58#ifdef ZEND_ENGINE_2
    4459    OPSPEC(    UNUSED,    JMPADDR,     UNUSED,     UNUSED) /* 42 JMP                            */
    4560    OPSPEC(    UNUSED,        STD,    JMPADDR,     UNUSED) /* 43 JMPZ                           */
    4661    OPSPEC(    UNUSED,        STD,    JMPADDR,     UNUSED) /* 44 JMPNZ                          */
     62#else
     63    OPSPEC(    UNUSED,     OPLINE,     UNUSED,     UNUSED)
     64    OPSPEC(    UNUSED,        STD,     OPLINE,     UNUSED)
     65    OPSPEC(    UNUSED,        STD,     OPLINE,     UNUSED)
     66#endif
    4767    OPSPEC(    OPLINE,        STD,     OPLINE,     UNUSED) /* 45 JMPZNZ                         */
     68#ifdef ZEND_ENGINE_2
    4869    OPSPEC(    UNUSED,        STD,    JMPADDR,        TMP) /* 46 JMPZ_EX                        */
    4970    OPSPEC(    UNUSED,        STD,    JMPADDR,        TMP) /* 47 JMPNZ_EX                       */
     71#else
     72    OPSPEC(    UNUSED,        STD,     OPLINE,        TMP)
     73    OPSPEC(    UNUSED,        STD,     OPLINE,        TMP)
     74#endif
    5075    OPSPEC(    UNUSED,        STD,        STD,        TMP) /* 48 CASE                           */
    5176    OPSPEC(       BIT,        STD,     UNUSED,     UNUSED) /* 49 SWITCH_FREE                    */
     
    6085    OPSPEC(    UNUSED,        TMP,     UNUSED,     UNUSED) /* 58 END_SILENCE                    */
    6186    OPSPEC(INIT_FCALL,        STD,        STD,     UNUSED) /* 59 INIT_FCALL_BY_NAME             */
     87#ifdef ZEND_ENGINE_2
    6288    OPSPEC(     FCALL,        STD,     OPLINE,        VAR) /* 60 DO_FCALL                       */
    6389    OPSPEC(     FCALL,        STD,     OPLINE,        VAR) /* 61 DO_FCALL_BY_NAME               */
     90#else
     91    OPSPEC(     FCALL,        STD,     UNUSED,        VAR)
     92    OPSPEC(     FCALL,        STD,     UNUSED,        VAR)
     93#endif
    6494    OPSPEC(    UNUSED,        STD,     UNUSED,     UNUSED) /* 62 RETURN                         */
    6595    OPSPEC(    UNUSED,        ARG,     UNUSED,        VAR) /* 63 RECV                           */
     
    6898    OPSPEC(      SEND,        VAR,        ARG,     UNUSED) /* 66 SEND_VAR                       */
    6999    OPSPEC(      SEND,        VAR,        ARG,     UNUSED) /* 67 SEND_REF                       */
     100#ifdef ZEND_ENGINE_2
    70101    OPSPEC(    UNUSED,      CLASS,     UNUSED,        VAR) /* 68 NEW                            */
     102#else
     103    OPSPEC(    UNUSED,        STD,     UNUSED,        VAR)
     104#endif
    71105#ifdef ZEND_ENGINE_2_3
    72106    OPSPEC(       STD,        STD,        STD,     UNUSED) /* 69 INIT_NS_FCALL_BY_NAME          */
     
    115149#ifdef ZEND_ENGINE_2_3
    116150    OPSPEC(    UNUSED,      VAR_2,        STD,        TMP) /* 99 FETCH_CONSTANT                 */
    117 #else
     151#elif defined(ZEND_ENGINE_2)
    118152    OPSPEC(    UNUSED,     UCLASS,        STD,        TMP) /* 99 FETCH_CONSTANT                 */
     153#else
     154    OPSPEC(    UNUSED,        STD,     UNUSED,        TMP) /* 99 FETCH_CONSTANT                 */
    119155#endif
    120156#ifdef ZEND_ENGINE_2_3
     
    129165    OPSPEC(    UNUSED,        STD,     UNUSED,     UNUSED) /* 105 TICKS                          */
    130166    OPSPEC(SEND_NOREF,        VAR,        ARG,     UNUSED) /* 106 SEND_VAR_NO_REF                */
    131 #ifdef ZEND_ENGINE_2_4
     167#ifdef ZEND_ENGINE_2
     168#   ifdef ZEND_ENGINE_2_4
    132169    OPSPEC(    OPLINE,        STD,        STD,     UNUSED) /* 107 CATCH                          */
    133 #else
     170#   else
    134171    OPSPEC(    OPLINE,      CLASS,        STD,     UNUSED) /* 107 CATCH                          */
    135 #endif
     172#   endif
    136173    OPSPEC(    UNUSED,        STD,     OPLINE,     UNUSED) /* 108 THROW                          */
    137174    OPSPEC(    FCLASS,        STD,        STD,      CLASS) /* 109 FETCH_CLASS                    */
    138175    OPSPEC(    UNUSED,        STD,     UNUSED,        VAR) /* 110 CLONE                          */
    139176
    140 #ifdef ZEND_ENGINE_2_4
     177#   ifdef ZEND_ENGINE_2_4
    141178    OPSPEC(    UNUSED,        STD,     UNUSED,     UNUSED) /* 111 RETURN_BY_REF                  */
    142 #else
     179#   else
    143180    OPSPEC(    UNUSED,        STD,     UNUSED,     UNUSED) /* 111 INIT_CTOR_CALL                 */
    144 #endif
     181#   endif
    145182
    146183    OPSPEC(    UNUSED,        STD,        STD,        VAR) /* 112 INIT_METHOD_CALL               */
    147 #ifdef ZEND_ENGINE_2_3
     184#   ifdef ZEND_ENGINE_2_3
    148185    OPSPEC(    UNUSED,        STD,        STD,     UNUSED) /* 113 INIT_STATIC_METHOD_CALL        */
    149 #else
     186#   else
    150187    OPSPEC(    UNUSED,     UCLASS,        STD,     UNUSED) /* 113 INIT_STATIC_METHOD_CALL        */
    151 #endif
     188#   endif
    152189    OPSPEC(     ISSET,        STD,      FETCH,        TMP) /* 114 ISSET_ISEMPTY_VAR              */
    153190    OPSPEC(     ISSET,        STD,        STD,        TMP) /* 115 ISSET_ISEMPTY_DIM_OBJ          */
     
    181218    OPSPEC(    UNUSED,        STD,        STD,     UNUSED) /* 141 DECLARE_FUNCTION               */
    182219    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 142 RAISE_ABSTRACT_ERROR           */
    183 #ifdef ZEND_ENGINE_2_3
     220#   ifdef ZEND_ENGINE_2_3
    184221    OPSPEC(   DECLARE,        STD,        STD,     UNUSED) /* 143 DECLARE_CONST                  */
    185 #else
     222#   else
    186223    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 143 UNDEF-143                      */
    187 #endif
    188 #ifdef ZEND_ENGINE_2_3
     224#   endif
     225#   ifdef ZEND_ENGINE_2_3
    189226    OPSPEC(     IFACE,      CLASS,        STD,     UNUSED) /* 144 ADD_INTERFACE                  */
    190 #else
     227#   else
    191228    OPSPEC(     IFACE,      CLASS,      CLASS,     UNUSED) /* 144 ADD_INTERFACE                  */
    192 #endif
    193 #ifdef ZEND_ENGINE_2_3
     229#   endif
     230#   ifdef ZEND_ENGINE_2_3
    194231    OPSPEC(     CLASS,        STD,        STD,     OPLINE) /* 145 DECLARE_INHERITED_CLASS_DELAYED */
    195 #else
     232#   else
    196233    OPSPEC(    UNUSED,      CLASS,        STD,     UNUSED) /* 145 VERIFY_INSTANCEOF              */
    197 #endif
     234#   endif
    198235    OPSPEC(    UNUSED,      CLASS,     UNUSED,     UNUSED) /* 146 VERIFY_ABSTRACT_CLASS          */
    199236    OPSPEC(    UNUSED,        STD,        STD,        VAR) /* 147 ASSIGN_DIM                     */
    200237    OPSPEC(     ISSET,        STD,        STD,        TMP) /* 148 ISSET_ISEMPTY_PROP_OBJ         */
    201238    OPSPEC(       STD,     UNUSED,     UNUSED,        STD) /* 149 HANDLE_EXCEPTION               */
    202 #ifdef ZEND_ENGINE_2_1
     239#   ifdef ZEND_ENGINE_2_1
    203240    OPSPEC(       STD,     UNUSED,     UNUSED,        STD) /* 150 USER_OPCODE                    */
    204 #endif
    205 #ifdef ZEND_ENGINE_2_3
     241#   endif
     242#   ifdef ZEND_ENGINE_2_3
    206243    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 151 UNDEF                          */
    207244    OPSPEC(    UNUSED,        STD,    JMPADDR,        TMP) /* 152 JMP_SET                        */
    208245    OPSPEC(    UNUSED,        STD,        STD,        TMP) /* 153 DECLARE_LAMBDA_FUNCTION        */
    209 #endif
    210 #ifdef ZEND_ENGINE_2_4
     246#   endif
     247#   ifdef ZEND_ENGINE_2_4
    211248    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 154 ADD_TRAIT                      */
    212249    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 155 BIND_TRAITS                    */
     
    214251    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 157 QM_ASSIGN_VAR                  */
    215252    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 158 JMP_SET_VAR                    */
    216 #endif
    217 #ifdef ZEND_ENGINE_2_5
     253#   endif
     254#   ifdef ZEND_ENGINE_2_5
    218255    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 159 DISCARD_EXCEPTION              */
    219256    OPSPEC(    UNUSED,        STD,        STD,     UNUSED) /* 160 YIELD                          */
     
    221258    OPSPEC(    UNUSED,    JMPADDR,     UNUSED,     UNUSED) /* 162 FAST_CALL                      */
    222259    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 163 FAST_RET                       */
    223 #endif
     260#   endif
     261#else /* ZEND_ENGINE_2 */
     262    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 107 UNDEF                          */
     263    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 108 UNDEF                          */
     264    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 109 UNDEF                          */
     265    OPSPEC(     FCALL,        STD,     OPLINE,        VAR) /* 61 DO_FCALL_BY_FUNC                */
     266    OPSPEC(INIT_FCALL,        STD,        STD,     UNUSED) /* 111 INIT_FCALL_BY_FUNC             */
     267    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 112 UNDEF                          */
     268#endif /* ZEND_ENGINE_2 */
    224269};
  • trunk/xcache/xc_sandbox.c

    r1281 r1321  
    195195#if 0 && TODO
    196196    {
    197         zend_class_entry *dummy_class_entry;
    198         zend_hash_copy(&TG(class_table), &XG(internal_class_table), NULL, (void *) &dummy_class_entry, sizeof(dummy_class_entry));
     197        xc_cest_t tmp_cest;
     198        zend_hash_copy(&TG(class_table), &XG(internal_class_table), NULL, (void *) &tmp_cest, sizeof(tmp_cest));
    199199    }
    200200#endif
     
    278278    /* install class */
    279279    while (b != NULL) {
    280         xc_install_class(sandbox->filename, *(zend_class_entry **)b->pData, -1,
     280        xc_install_class(sandbox->filename, (xc_cest_t*) b->pData, -1,
    281281                BUCKET_KEY_TYPE(b), ZSTR(BUCKET_KEY_S(b)), b->nKeyLength, b->h TSRMLS_CC);
    282282        b = b->pListNext;
  • trunk/xcache/xc_utils.c

    r1314 r1321  
    7878{
    7979    /* avoid duplicate apply for shadowed method */
     80#ifdef ZEND_ENGINE_2
    8081    if (mi->ce != zf->common.scope) {
    8182        /* fprintf(stderr, "avoided duplicate %s\n", zf->common.function_name); */
    8283        return 0;
    8384    }
     85#else
     86    char *name = zf->common.function_name;
     87    int name_s = strlen(name) + 1;
     88    zend_class_entry *ce;
     89    zend_function *ptr;
     90
     91    for (ce = mi->ce->parent; ce; ce = ce->parent) {
     92        if (zend_hash_find(&ce->function_table, name, name_s, (void **) &ptr) == SUCCESS) {
     93            if (ptr->op_array.refcount == zf->op_array.refcount) {
     94                return 0;
     95            }
     96        }
     97    }
     98#endif
    8499    return xc_apply_function(zf, &mi->fi TSRMLS_CC);
    85100}
    86101/* }}} */
    87 static int xc_apply_class(zend_class_entry **ce, xc_apply_func_info *fi TSRMLS_DC) /* {{{ */
     102static int xc_apply_cest(xc_cest_t *cest, xc_apply_func_info *fi TSRMLS_DC) /* {{{ */
    88103{
    89104    xc_apply_method_info mi;
    90105
    91106    mi.fi = *fi;
    92     mi.ce = *ce;
    93     zend_hash_apply_with_argument(&((*ce)->function_table), (apply_func_arg_t) xc_apply_method, &mi TSRMLS_CC);
     107    mi.ce = CestToCePtr(*cest);
     108    zend_hash_apply_with_argument(&(CestToCePtr(*cest)->function_table), (apply_func_arg_t) xc_apply_method, &mi TSRMLS_CC);
    94109    return 0;
    95110}
     
    100115    fi.applyer = applyer;
    101116    zend_hash_apply_with_argument(cr->function_table, (apply_func_arg_t) xc_apply_function, &fi TSRMLS_CC);
    102     zend_hash_apply_with_argument(cr->class_table, (apply_func_arg_t) xc_apply_class, &fi TSRMLS_CC);
     117    zend_hash_apply_with_argument(cr->class_table, (apply_func_arg_t) xc_apply_cest, &fi TSRMLS_CC);
    103118
    104119    return applyer(cr->op_array TSRMLS_CC);
     
    107122int xc_undo_pass_two(zend_op_array *op_array TSRMLS_DC) /* {{{ */
    108123{
     124#ifdef ZEND_ENGINE_2
    109125    zend_op *opline, *opline_end;
     126#endif
    110127
    111128#ifdef ZEND_ENGINE_2_4
     
    119136#endif
    120137
     138#ifdef ZEND_ENGINE_2
    121139    opline = op_array->opcodes;
    122140    opline_end = opline + op_array->last;
    123141    while (opline < opline_end) {
    124 #ifdef ZEND_ENGINE_2_4
     142#   ifdef ZEND_ENGINE_2_4
    125143        if (opline->op1_type == IS_CONST) {
    126144            opline->op1.constant = opline->op1.literal - op_array->literals;
     
    129147            opline->op2.constant = opline->op2.literal - op_array->literals;
    130148        }
    131 #endif
     149#   endif
    132150
    133151        switch (opline->opcode) {
    134 #ifdef ZEND_GOTO
     152#   ifdef ZEND_GOTO
    135153            case ZEND_GOTO:
    136 #endif
     154#   endif
    137155            case ZEND_JMP:
    138 #ifdef ZEND_FAST_CALL
     156#   ifdef ZEND_FAST_CALL
    139157            case ZEND_FAST_CALL:
    140 #endif
     158#   endif
    141159                assert(Z_OP(opline->op1).jmp_addr >= op_array->opcodes && (zend_uint) (Z_OP(opline->op1).jmp_addr - op_array->opcodes) < op_array->last);
    142160                Z_OP(opline->op1).opline_num = Z_OP(opline->op1).jmp_addr - op_array->opcodes;
     
    146164            case ZEND_JMPZ_EX:
    147165            case ZEND_JMPNZ_EX:
    148 #ifdef ZEND_JMP_SET
     166#   ifdef ZEND_JMP_SET
    149167            case ZEND_JMP_SET:
    150 #endif
    151 #ifdef ZEND_JMP_SET_VAR
     168#   endif
     169#   ifdef ZEND_JMP_SET_VAR
    152170            case ZEND_JMP_SET_VAR:
    153 #endif
     171#   endif
    154172                assert(Z_OP(opline->op2).jmp_addr >= op_array->opcodes && (zend_uint) (Z_OP(opline->op2).jmp_addr - op_array->opcodes) < op_array->last);
    155173                Z_OP(opline->op2).opline_num = Z_OP(opline->op2).jmp_addr - op_array->opcodes;
     
    158176        opline++;
    159177    }
     178#endif /* ZEND_ENGINE_2 */
     179
    160180#ifdef ZEND_ENGINE_2_4
    161181    op_array->fn_flags &= ~ZEND_ACC_DONE_PASS_TWO;
     
    169189int xc_redo_pass_two(zend_op_array *op_array TSRMLS_DC) /* {{{ */
    170190{
     191#ifdef ZEND_ENGINE_2
    171192    zend_op *opline, *opline_end;
     193#endif
    172194#ifdef ZEND_ENGINE_2_4
    173195    zend_literal *literal = op_array->literals;
     
    199221#endif
    200222
     223#ifdef ZEND_ENGINE_2
    201224    opline = op_array->opcodes;
    202225    opline_end = opline + op_array->last;
    203226    while (opline < opline_end) {
    204 #ifdef ZEND_ENGINE_2_4
     227#   ifdef ZEND_ENGINE_2_4
    205228        if (opline->op1_type == IS_CONST) {
    206229            opline->op1.literal = op_array->literals + opline->op1.constant;
     
    209232            opline->op2.literal = op_array->literals + opline->op2.constant;
    210233        }
    211 #else
     234#   else
    212235        if (Z_OP_TYPE(opline->op1) == IS_CONST) {
    213236            Z_SET_ISREF(Z_OP_CONSTANT(opline->op1));
     
    218241            Z_SET_REFCOUNT(Z_OP_CONSTANT(opline->op2), 2);
    219242        }
    220 #endif
     243#   endif
     244        switch (opline->opcode) {
     245#   ifdef ZEND_GOTO
     246            case ZEND_GOTO:
     247#   endif
     248            case ZEND_JMP:
     249#   ifdef ZEND_FAST_CALL
     250            case ZEND_FAST_CALL:
     251#   endif
     252                assert(Z_OP(opline->op1).opline_num < op_array->last);
     253                Z_OP(opline->op1).jmp_addr = op_array->opcodes + Z_OP(opline->op1).opline_num;
     254                break;
     255            case ZEND_JMPZ:
     256            case ZEND_JMPNZ:
     257            case ZEND_JMPZ_EX:
     258            case ZEND_JMPNZ_EX:
     259#   ifdef ZEND_JMP_SET
     260            case ZEND_JMP_SET:
     261#   endif
     262#   ifdef ZEND_JMP_SET_VAR
     263            case ZEND_JMP_SET_VAR:
     264#   endif
     265                assert(Z_OP(opline->op2).opline_num < op_array->last);
     266                Z_OP(opline->op2).jmp_addr = op_array->opcodes + Z_OP(opline->op2).opline_num;
     267                break;
     268        }
     269        /* ZEND_VM_SET_OPCODE_HANDLER(opline); this is not undone, don't redo. only do this for loader */
     270        opline++;
     271    }
     272#endif /* ZEND_ENGINE_2 */
     273
     274#ifdef ZEND_ENGINE_2_4
     275    op_array->fn_flags |= ZEND_ACC_DONE_PASS_TWO;
     276#else
     277    op_array->done_pass_two = 1;
     278#endif
     279    return 0;
     280}
     281/* }}} */
     282
     283static void xc_fix_opcode_ex_znode(int tofix, xc_op_spec_t spec, Z_OP_TYPEOF_TYPE *op_type, znode_op *op, int type TSRMLS_DC) /* {{{ */
     284{
     285#ifdef ZEND_ENGINE_2
     286    if ((*op_type != IS_UNUSED && (spec == OPSPEC_UCLASS || spec == OPSPEC_CLASS)) ||
     287            spec == OPSPEC_FETCH) {
     288        if (tofix) {
     289            switch (*op_type) {
     290            case IS_VAR:
     291            case IS_TMP_VAR:
     292                break;
     293
     294            default:
     295                /* TODO: data lost, find a way to keep it */
     296                /* assert(*op_type == IS_CONST); */
     297                *op_type = IS_TMP_VAR;
     298            }
     299        }
     300    }
     301    switch (*op_type) {
     302    case IS_TMP_VAR:
     303    case IS_VAR:
     304        if (tofix) {
     305            Z_OP(*op).var /= sizeof(temp_variable);
     306        }
     307        else {
     308            Z_OP(*op).var *= sizeof(temp_variable);
     309        }
     310    }
     311#endif
     312}
     313/* }}} */
     314
     315static void xc_fix_opcode_ex(zend_op_array *op_array, int tofix TSRMLS_DC) /* {{{ */
     316{
     317    zend_op *opline;
     318    zend_uint i;
     319
     320    opline = op_array->opcodes;
     321    for (i = 0; i < op_array->last; i ++, opline ++) {
     322        /* 3rd optimizer may have ... */
     323        if (opline->opcode < xc_get_opcode_spec_count()) {
     324            const xc_opcode_spec_t *spec;
     325            spec = xc_get_opcode_spec(opline->opcode);
     326
     327            xc_fix_opcode_ex_znode(tofix, spec->op1, &Z_OP_TYPE(opline->op1),    &opline->op1, 0 TSRMLS_CC);
     328            xc_fix_opcode_ex_znode(tofix, spec->op2, &Z_OP_TYPE(opline->op2),    &opline->op2, 1 TSRMLS_CC);
     329            xc_fix_opcode_ex_znode(tofix, spec->res, &Z_OP_TYPE(opline->result), &opline->result, 2 TSRMLS_CC);
     330        }
     331    }
     332}
     333/* }}} */
     334int xc_fix_opcode(zend_op_array *op_array TSRMLS_DC) /* {{{ */
     335{
     336    xc_fix_opcode_ex(op_array, 1 TSRMLS_CC);
     337    return 0;
     338}
     339/* }}} */
     340int xc_undo_fix_opcode(zend_op_array *op_array TSRMLS_DC) /* {{{ */
     341{
     342    xc_fix_opcode_ex(op_array, 0 TSRMLS_CC);
     343
     344    return 0;
     345}
     346/* }}} */
     347
     348#ifndef ZEND_COMPILE_DELAYED_BINDING
     349int xc_foreach_early_binding_class(zend_op_array *op_array, xc_foreach_early_binding_class_cb callback, void *data TSRMLS_DC) /* {{{ */
     350{
     351    zend_op *opline, *begin, *opline_end, *next = NULL;
     352
     353    opline = begin = op_array->opcodes;
     354    opline_end = opline + op_array->last;
     355    while (opline < opline_end) {
    221356        switch (opline->opcode) {
    222357#ifdef ZEND_GOTO
     
    227362            case ZEND_FAST_CALL:
    228363#endif
    229                 assert(Z_OP(opline->op1).opline_num < op_array->last);
    230                 Z_OP(opline->op1).jmp_addr = op_array->opcodes + Z_OP(opline->op1).opline_num;
    231                 break;
     364                next = begin + Z_OP(opline->op1).opline_num;
     365                break;
     366
     367            case ZEND_JMPZNZ:
     368                next = begin + max(Z_OP(opline->op2).opline_num, opline->extended_value);
     369                break;
     370
    232371            case ZEND_JMPZ:
    233372            case ZEND_JMPNZ:
     
    240379            case ZEND_JMP_SET_VAR:
    241380#endif
    242                 assert(Z_OP(opline->op2).opline_num < op_array->last);
    243                 Z_OP(opline->op2).jmp_addr = op_array->opcodes + Z_OP(opline->op2).opline_num;
    244                 break;
    245         }
    246         /* ZEND_VM_SET_OPCODE_HANDLER(opline); this is not undone, don't redo. only do this for loader */
    247         opline++;
    248     }
    249 
    250 #ifdef ZEND_ENGINE_2_4
    251     op_array->fn_flags |= ZEND_ACC_DONE_PASS_TWO;
    252 #else
    253     op_array->done_pass_two = 1;
    254 #endif
    255     return 0;
    256 }
    257 /* }}} */
    258 
    259 static void xc_fix_opcode_ex_znode(int tofix, xc_op_spec_t spec, Z_OP_TYPEOF_TYPE *op_type, znode_op *op, int type TSRMLS_DC) /* {{{ */
    260 {
    261     if ((*op_type != IS_UNUSED && (spec == OPSPEC_UCLASS || spec == OPSPEC_CLASS)) ||
    262             spec == OPSPEC_FETCH) {
    263         if (tofix) {
    264             switch (*op_type) {
    265             case IS_VAR:
    266             case IS_TMP_VAR:
    267                 break;
    268 
    269             default:
    270                 /* TODO: data lost, find a way to keep it */
    271                 /* assert(*op_type == IS_CONST); */
    272                 *op_type = IS_TMP_VAR;
    273             }
    274         }
    275     }
    276     switch (*op_type) {
    277     case IS_TMP_VAR:
    278     case IS_VAR:
    279         if (tofix) {
    280             Z_OP(*op).var /= sizeof(temp_variable);
    281         }
    282         else {
    283             Z_OP(*op).var *= sizeof(temp_variable);
    284         }
    285     }
    286 }
    287 /* }}} */
    288 
    289 static void xc_fix_opcode_ex(zend_op_array *op_array, int tofix TSRMLS_DC) /* {{{ */
    290 {
    291     zend_op *opline;
    292     zend_uint i;
    293 
    294     opline = op_array->opcodes;
    295     for (i = 0; i < op_array->last; i ++, opline ++) {
    296         /* 3rd optimizer may have ... */
    297         if (opline->opcode < xc_get_opcode_spec_count()) {
    298             const xc_opcode_spec_t *spec;
    299             spec = xc_get_opcode_spec(opline->opcode);
    300 
    301             xc_fix_opcode_ex_znode(tofix, spec->op1, &Z_OP_TYPE(opline->op1),    &opline->op1, 0 TSRMLS_CC);
    302             xc_fix_opcode_ex_znode(tofix, spec->op2, &Z_OP_TYPE(opline->op2),    &opline->op2, 1 TSRMLS_CC);
    303             xc_fix_opcode_ex_znode(tofix, spec->res, &Z_OP_TYPE(opline->result), &opline->result, 2 TSRMLS_CC);
    304         }
    305     }
    306 }
    307 /* }}} */
    308 int xc_fix_opcode(zend_op_array *op_array TSRMLS_DC) /* {{{ */
    309 {
    310     xc_fix_opcode_ex(op_array, 1 TSRMLS_CC);
    311     return 0;
    312 }
    313 /* }}} */
    314 int xc_undo_fix_opcode(zend_op_array *op_array TSRMLS_DC) /* {{{ */
    315 {
    316     xc_fix_opcode_ex(op_array, 0 TSRMLS_CC);
    317 
    318     return 0;
    319 }
    320 /* }}} */
    321 
    322 #ifndef ZEND_COMPILE_DELAYED_BINDING
    323 int xc_foreach_early_binding_class(zend_op_array *op_array, xc_foreach_early_binding_class_cb callback, void *data TSRMLS_DC) /* {{{ */
    324 {
    325     zend_op *opline, *begin, *opline_end, *next = NULL;
    326 
    327     opline = begin = op_array->opcodes;
    328     opline_end = opline + op_array->last;
    329     while (opline < opline_end) {
    330         switch (opline->opcode) {
    331 #ifdef ZEND_GOTO
    332             case ZEND_GOTO:
    333 #endif
    334             case ZEND_JMP:
    335 #ifdef ZEND_FAST_CALL
    336             case ZEND_FAST_CALL:
    337 #endif
    338                 next = begin + Z_OP(opline->op1).opline_num;
    339                 break;
    340 
    341             case ZEND_JMPZNZ:
    342                 next = begin + max(Z_OP(opline->op2).opline_num, opline->extended_value);
    343                 break;
    344 
    345             case ZEND_JMPZ:
    346             case ZEND_JMPNZ:
    347             case ZEND_JMPZ_EX:
    348             case ZEND_JMPNZ_EX:
    349 #ifdef ZEND_JMP_SET
    350             case ZEND_JMP_SET:
    351 #endif
    352 #ifdef ZEND_JMP_SET_VAR
    353             case ZEND_JMP_SET_VAR:
    354 #endif
    355381                next = begin + Z_OP(opline->op2).opline_num;
    356382                break;
     
    360386                break;
    361387
     388#ifdef ZEND_ENGINE_2
    362389            case ZEND_DECLARE_INHERITED_CLASS:
    363390                callback(opline, opline - begin, data TSRMLS_CC);
    364391                break;
     392#else
     393            case ZEND_DECLARE_FUNCTION_OR_CLASS:
     394                if (opline->extended_value == ZEND_DECLARE_INHERITED_CLASS) {
     395                    callback(opline, opline - begin, data TSRMLS_CC);
     396                }
     397                break;
     398#endif
    365399        }
    366400
     
    386420
    387421    switch (opline->opcode) {
     422#ifdef ZEND_ENGINE_2
    388423    case ZEND_DECLARE_INHERITED_CLASS:
    389424        {
     
    434469            ZEND_VM_SET_OPCODE_HANDLER(abstract_op);
    435470        }
     471#else
     472    case ZEND_DECLARE_FUNCTION_OR_CLASS:
     473        if (do_bind_function_or_class(opline, NULL, class_table, 1) == FAILURE) {
     474            return FAILURE;
     475        }
     476#endif
    436477        break;
    437478
     
    495536                    NULL
    496537                    ) == FAILURE) {
    497             CG(zend_lineno) = func->op_array.line_start;
     538            CG(zend_lineno) = ZESW(func->op_array.opcodes[0].lineno, func->op_array.line_start);
    498539#ifdef IS_UNICODE
    499540            zend_error(E_ERROR, "Cannot redeclare %R()", type, key);
     
    505546}
    506547/* }}} */
    507 void xc_install_class(ZEND_24(NOTHING, const) char *filename, zend_class_entry *ce, int oplineno, zend_uchar type, const24_zstr key, uint len, ulong h TSRMLS_DC) /* {{{ */
     548ZESW(xc_cest_t *, void) xc_install_class(ZEND_24(NOTHING, const) char *filename, xc_cest_t *cest, int oplineno, zend_uchar type, const24_zstr key, uint len, ulong h TSRMLS_DC) /* {{{ */
    508549{
    509550    zend_bool istmpkey;
     551    zend_class_entry *cep = CestToCePtr(*cest);
     552    ZESW(void *stored_ce_ptr, NOTHING);
    510553
    511554#ifdef IS_UNICODE
     
    516559    if (istmpkey) {
    517560        zend_u_hash_quick_update(CG(class_table), type, key, len, h,
    518                     &ce, sizeof(zend_class_entry *),
    519                     NULL
     561                    cest, sizeof(xc_cest_t),
     562                    ZESW(&stored_ce_ptr, NULL)
    520563                    );
    521564#ifndef ZEND_COMPILE_DELAYED_BINDING
     
    526569    }
    527570    else if (zend_u_hash_quick_add(CG(class_table), type, key, len, h,
    528                 &ce, sizeof(zend_class_entry *),
    529                 NULL
     571                cest, sizeof(xc_cest_t),
     572                ZESW(&stored_ce_ptr, NULL)
    530573                ) == FAILURE) {
    531         CG(zend_lineno) = Z_CLASS_INFO(*ce).line_start;
     574        CG(zend_lineno) = ZESW(0, Z_CLASS_INFO(*cep).line_start);
    532575#ifdef IS_UNICODE
    533         zend_error(E_ERROR, "Cannot redeclare class %R", type, ce->name);
    534 #else
    535         zend_error(E_ERROR, "Cannot redeclare class %s", ce->name);
     576        zend_error(E_ERROR, "Cannot redeclare class %R", type, cep->name);
     577#else
     578        zend_error(E_ERROR, "Cannot redeclare class %s", cep->name);
    536579#endif
    537580        assert(oplineno == -1);
    538581    }
     582    ZESW(return (xc_cest_t *) stored_ce_ptr, NOTHING);
    539583}
    540584/* }}} */
  • trunk/xcache/xc_utils.h

    r1313 r1321  
    4343#endif
    4444void xc_install_function(ZEND_24(NOTHING, const) char *filename, zend_function *func, zend_uchar type, const24_zstr key, uint len, ulong h TSRMLS_DC);
    45 void xc_install_class(ZEND_24(NOTHING, const) char *filename, zend_class_entry *class_entry, int oplineno, zend_uchar type, const24_zstr key, uint len, ulong h TSRMLS_DC);
     45ZESW(xc_cest_t *, void) xc_install_class(ZEND_24(NOTHING, const) char *filename, xc_cest_t *cest, int oplineno, zend_uchar type, const24_zstr key, uint len, ulong h TSRMLS_DC);
    4646
    4747typedef zend_bool (*xc_if_func_t)(void *data);
Note: See TracChangeset for help on using the changeset viewer.