Changeset 1321 for trunk


Ignore:
Timestamp:
2013-07-15T19:37:57+02:00 (13 months ago)
Author:
moo
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.