Changeset 1281 for trunk


Ignore:
Timestamp:
2013-07-08T10:00:36+02:00 (17 months ago)
Author:
moo
Message:

remove php 4 support completely

Location:
trunk
Files:
1 deleted
25 edited

Legend:

Unmodified
Added
Removed
  • trunk/ChangeLog

    r1277 r1281  
    22ChangeLog 
    33======== 
     4 * drop support for PHP_4 in source code 
    45 * disassembler: fixes crash with nested sandbox 
    56 * adds support for PHP_5_5 
     
    78 * support for __FILE__ __DIR__ handling after files moved/hardlinked (without xcache.experimental) 
    89 
    9 3.0.3 2013-16.18 
     103.0.3 2013-16-18 
    1011======== 
    1112 * clean files in release (fix htdocs config) 
  • trunk/Makefile.frag.deps

    r1270 r1281  
    66mod_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) 
    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_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_extension.h $(srcdir)/xcache/xc_ini.h $(srcdir)/xcache/xc_lock.h $(srcdir)/xcache/xc_shm.h $(srcdir)/xcache/xc_utils.h 
     8mod_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_shm.h $(srcdir)/xcache/xc_utils.h $(XCACHE_PROC_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 
     
    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.5.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_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 
  • trunk/NEWS

    r1277 r1281  
    66 * support for __FILE__ __DIR__ handling after files moved/hardlinked 
    77 
    8 3.0.3 2013-16.18 
     83.0.3 2013-16-18 
    99======== 
    1010 * clean files in release (fix htdocs config) 
  • trunk/devel/prepare.cfg.example

    r1237 r1281  
    11# copy this file as prepare.cfg before modifying 
    2 PHP4_x_DIR= 
    32PHP5_0_DIR= 
    43PHP5_1_DIR= 
  • trunk/devel/prepare.mak

    r1254 r1281  
    1818.PHONY: xc_const_string 
    1919xc_const_string: \ 
    20     xcache/xc_const_string_opcodes_php4.x.h \ 
    2120    xcache/xc_const_string_opcodes_php5.0.h \ 
    2221    xcache/xc_const_string_opcodes_php5.1.h \ 
     
    3332    $(AWK) -f ./devel/gen_xc_opcode_spec.awk < "$<" > "$@".tmp 
    3433    mv "$@".tmp "$@" 
    35 endif 
    36  
    37 ifeq (${PHP4_x_DIR},) 
    38 xcache/xc_const_string_opcodes_php4.x.h: dummy 
    39     @echo "Skipped $@: PHP_4_x_DIR not set" 
    40 else 
    41 xcache/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" "$@" 
    4434endif 
    4535 
  • trunk/devel/run

    r1273 r1281  
    9797 
    9898                case "$dependency" in 
     99                *xc_const_string_opcodes_php*) 
     100                    for dependency in xcache/xc_const_string_*.h; do 
     101                        echo '$(srcdir)/'$dependency 
     102                    done 
     103                    ;; 
     104 
    99105                /*) ;; 
    100106                $sourceFile) ;; 
  • trunk/lib/Decompiler.class.php

    r982 r1281  
    14081408                $EX['called_scope'] = null; 
    14091409                $EX['fbc'] = 'new ' . unquoteName($this->getOpVal($op1, $EX), $EX); 
    1410                 if (!ZEND_ENGINE_2) { 
    1411                     $resvar = '$new object$'; 
    1412                 } 
    14131410                break; 
    14141411                // }}} 
     
    14811478                } 
    14821479                else { 
    1483                     $fetchtype = $op2[!ZEND_ENGINE_2 ? 'fetch_type' : 'EA.type']; 
     1480                    $fetchtype = $op2['EA.type']; 
    14841481                } 
    14851482                switch ($fetchtype) { 
     
    17021699                } 
    17031700 
    1704                 switch ((!ZEND_ENGINE_2 ? $op['op2']['var'] /* constant */ : $ext) & (ZEND_ISSET|ZEND_ISEMPTY)) { 
     1701                switch (($ext & (ZEND_ISSET|ZEND_ISEMPTY))) { 
    17051702                case ZEND_ISSET: 
    17061703                    $rvalue = "isset(" . str($rvalue) . ")"; 
     
    17551752            case XC_INIT_FCALL_BY_NAME: // {{{ 
    17561753                array_push($EX['arg_types_stack'], array($EX['fbc'], $EX['object'], $EX['called_scope'])); 
    1757                 if (!ZEND_ENGINE_2 && ($ext & ZEND_CTOR_CALL)) { 
    1758                     break; 
    1759                 } 
    17601754                $EX['object'] = null; 
    17611755                $EX['called_scope'] = null; 
     
    24762470 
    24772471                $mangled = false; 
    2478                 if (!ZEND_ENGINE_2) { 
    2479                     echo 'var '; 
    2480                 } 
    2481                 else if (!isset($info)) { 
     2472                if (!isset($info)) { 
    24822473                    echo 'public '; 
    24832474                } 
     
    26402631define('ZEND_ENGINE_2_2', ZEND_ENGINE_2_3 || PHP_VERSION >= "5.2."); 
    26412632define('ZEND_ENGINE_2_1', ZEND_ENGINE_2_2 || PHP_VERSION >= "5.1."); 
    2642 define('ZEND_ENGINE_2',   ZEND_ENGINE_2_1 || PHP_VERSION >= "5.0."); 
    26432633 
    26442634define('ZEND_ACC_STATIC',         0x01); 
     
    27382728define('IS_LONG',     1); 
    27392729define('IS_DOUBLE',   2); 
    2740 define('IS_BOOL',     ZEND_ENGINE_2 ? 3 : 6); 
     2730define('IS_BOOL',     3); 
    27412731define('IS_ARRAY',    4); 
    27422732define('IS_OBJECT',   5); 
    2743 define('IS_STRING',   ZEND_ENGINE_2 ? 6 : 3); 
     2733define('IS_STRING',   6); 
    27442734define('IS_RESOURCE', 7); 
    27452735define('IS_CONSTANT', 8); 
  • trunk/mod_cacher/xc_cache.h

    r1238 r1281  
    3737typedef struct { 
    3838#ifdef IS_UNICODE 
    39     zend_uchar   type; 
    40 #endif 
    41     const24_zstr key; 
    42     zend_uint    key_size; 
    43     ulong        h; 
    44     zend_uint  methodinfo_cnt; 
     39    zend_uchar          type; 
     40#endif 
     41    const24_zstr        key; 
     42    zend_uint           key_size; 
     43    ulong               h; 
     44    zend_uint           methodinfo_cnt; 
    4545    xc_op_array_info_t *methodinfos; 
    46     xc_cest_t    cest; 
     46    zend_class_entry   *class_entry; 
    4747#ifndef ZEND_COMPILE_DELAYED_BINDING 
    48     int          oplineno; 
     48    int                 oplineno; 
    4949#endif 
    5050} xc_classinfo_t; 
     
    190190/* {{{ xc_gc_op_array_t */ 
    191191typedef struct { 
    192 #ifdef ZEND_ENGINE_2 
    193192    zend_uint num_args; 
    194193    zend_arg_info *arg_info; 
    195 #endif 
    196194#ifdef ZEND_ENGINE_2_4 
    197195    zend_literal *literals; 
  • trunk/mod_cacher/xc_cacher.c

    r1277 r1281  
    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 
    770765 
    771766    CG(active_op_array) = p->op_array; 
     
    790785    for (i = 0; i < p->classinfo_cnt; i ++) { 
    791786        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 
    802787#ifdef ZEND_COMPILE_DELAYED_BINDING 
    803         xc_install_class(entry_php->entry.name.str.val, &ci->cest, -1, 
     788        xc_install_class(entry_php->entry.name.str.val, ci->class_entry, -1, 
    804789                UNISW(0, ci->type), ci->key, ci->key_size, ci->h TSRMLS_CC); 
    805790#else 
    806         xc_install_class(entry_php->entry.name.str.val, &ci->cest, ci->oplineno, 
     791        xc_install_class(entry_php->entry.name.str.val, ci->class_entry, ci->oplineno, 
    807792                UNISW(0, ci->type), ci->key, ci->key_size, ci->h TSRMLS_CC); 
    808793#endif 
     
    826811#endif 
    827812 
    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 
    836813    CG(active_op_array) = old_active_op_array; 
    837814    return p->op_array; 
     
    12981275    zend_uint i; 
    12991276    int class_len; 
    1300     xc_cest_t cest; 
     1277    zend_class_entry *class_entry; 
    13011278    xc_entry_data_php_t *php = (xc_entry_data_php_t *) data; 
    13021279 
    13031280    class_name = Z_OP_CONSTANT(opline->op1).value.str.val; 
    13041281    class_len  = Z_OP_CONSTANT(opline->op1).value.str.len; 
    1305     if (zend_hash_find(CG(class_table), class_name, class_len, (void **) &cest) == FAILURE) { 
     1282    if (zend_hash_find(CG(class_table), class_name, class_len, (void **) &class_entry) == FAILURE) { 
    13061283        assert(0); 
    13071284    } 
     
    17461723 
    17471724#ifdef HAVE_XCACHE_CONSTANT 
    1748         b = EG(zend_constants)->pListHead; COPY_H(xc_constinfo_t, constinfos, constinfo_cnt, constant, zend_constant); 
    1749 #endif 
    1750         b = CG(function_table)->pListHead; COPY_H(xc_funcinfo_t,  funcinfos,  funcinfo_cnt,  func,     zend_function); 
    1751         b = CG(class_table)->pListHead;    COPY_H(xc_classinfo_t, classinfos, classinfo_cnt, cest,     xc_cest_t); 
     1725        b = EG(zend_constants)->pListHead; COPY_H(xc_constinfo_t, constinfos, constinfo_cnt, constant,    zend_constant); 
     1726#endif 
     1727        b = CG(function_table)->pListHead; COPY_H(xc_funcinfo_t,  funcinfos,  funcinfo_cnt,  func,        zend_function); 
     1728        b = CG(class_table)->pListHead;    COPY_H(xc_classinfo_t, classinfos, classinfo_cnt, class_entry, zend_class_entry *); 
    17521729 
    17531730#undef COPY_H 
    1754  
    1755         /* for ZE1, cest need to be fixed inside store */ 
    17561731 
    17571732#ifdef ZEND_ENGINE_2_1 
     
    17911766        for (i = 0; i < compiler->new_php.classinfo_cnt; i ++) { 
    17921767            xc_classinfo_t *classinfo = &compiler->new_php.classinfos[i]; 
    1793             zend_class_entry *ce = CestToCePtr(classinfo->cest); 
    1794             classinfo->methodinfo_cnt = ce->function_table.nTableSize; 
     1768            classinfo->methodinfo_cnt = classinfo->class_entry->function_table.nTableSize; 
    17951769            if (classinfo->methodinfo_cnt) { 
    17961770                int j; 
     
    18011775                } 
    18021776 
    1803                 for (j = 0, b = ce->function_table.pListHead; b; j ++, b = b->pListNext) { 
     1777                for (j = 0, b = classinfo->class_entry->function_table.pListHead; b; j ++, b = b->pListNext) { 
    18041778                    xc_collect_op_array_info(compiler, &const_usage, &classinfo->methodinfos[j], (zend_op_array *) b->pData TSRMLS_CC); 
    18051779                } 
     
    20011975        /* discard newly compiled result, restore from stored one */ 
    20021976        if (compiler->new_php.op_array) { 
    2003 #ifdef ZEND_ENGINE_2 
    20041977            destroy_op_array(compiler->new_php.op_array TSRMLS_CC); 
    2005 #else 
    2006             destroy_op_array(compiler->new_php.op_array); 
    2007 #endif 
    20081978            efree(compiler->new_php.op_array); 
    20091979            compiler->new_php.op_array = NULL; 
     
    22692239    xc_gc_op_array_t *op_array = (xc_gc_op_array_t *) pDest; 
    22702240    zend_uint i; 
    2271 #ifdef ZEND_ENGINE_2 
    22722241    if (op_array->arg_info) { 
    22732242        for (i = 0; i < op_array->num_args; i++) { 
     
    22792248        efree(op_array->arg_info); 
    22802249    } 
    2281 #endif 
    22822250    if (op_array->opcodes) { 
    22832251        efree(op_array->opcodes); 
     
    27952763{ 
    27962764    if (!XG(internal_table_copied)) { 
    2797         zend_function tmp_func; 
    2798         xc_cest_t tmp_cest; 
     2765        zend_function dummy_func; 
     2766        zend_class_entry *dummy_class_entry; 
    27992767 
    28002768#ifdef HAVE_XCACHE_CONSTANT 
     
    28132781        xc_copy_internal_zend_constants(&XG(internal_constant_table), EG(zend_constants)); 
    28142782#endif 
    2815         zend_hash_copy(&XG(internal_function_table), CG(function_table), NULL, &tmp_func, sizeof(tmp_func)); 
    2816         zend_hash_copy(&XG(internal_class_table), CG(class_table), NULL, &tmp_cest, sizeof(tmp_cest)); 
     2783        zend_hash_copy(&XG(internal_function_table), CG(function_table), NULL, &dummy_func, sizeof(dummy_func)); 
     2784        zend_hash_copy(&XG(internal_class_table), CG(class_table), NULL, &dummy_class_entry, sizeof(dummy_class_entry)); 
    28172785 
    28182786        XG(internal_table_copied) = 1; 
     
    28202788    xc_holds_init(TSRMLS_C); 
    28212789    xc_var_namespace_init(TSRMLS_C); 
    2822 #ifdef ZEND_ENGINE_2 
    28232790    zend_llist_init(&XG(gc_op_arrays), sizeof(xc_gc_op_array_t), xc_gc_op_array, 0); 
    2824 #endif 
    28252791 
    28262792#if PHP_API_VERSION <= 20041225 
     
    28432809    xc_gc_deletes(TSRMLS_C); 
    28442810    xc_var_namespace_destroy(TSRMLS_C); 
    2845 #ifdef ZEND_ENGINE_2 
    28462811    zend_llist_destroy(&XG(gc_op_arrays)); 
    2847 #endif 
    28482812} 
    28492813/* }}} */ 
     
    37763740} 
    37773741/* }}} */ 
    3778 /* {{{ static PHP_RSHUTDOWN_FUNCTION(xcache_cacher) */ 
    3779 #ifndef ZEND_ENGINE_2 
    3780 static PHP_RSHUTDOWN_FUNCTION(xcache_cacher) 
    3781 #else 
     3742/* {{{ static ZEND_MODULE_POST_ZEND_DEACTIVATE_D(xcache_cacher) */ 
    37823743static ZEND_MODULE_POST_ZEND_DEACTIVATE_D(xcache_cacher) 
    3783 #endif 
    3784 { 
    3785 #ifdef ZEND_ENGINE_2 
     3744{ 
    37863745    TSRMLS_FETCH(); 
    3787 #endif 
    37883746 
    37893747    xc_request_shutdown(TSRMLS_C); 
     
    37983756    PHP_MSHUTDOWN(xcache_cacher), 
    37993757    PHP_RINIT(xcache_cacher), 
    3800 #ifndef ZEND_ENGINE_2 
    3801     PHP_RSHUTDOWN(xcache_cacher), 
    3802 #else 
    38033758    NULL, 
    3804 #endif 
    38053759    PHP_MINFO(xcache_cacher), 
    38063760    XCACHE_VERSION, 
     
    38083762    NO_MODULE_GLOBALS, 
    38093763#endif 
    3810 #ifdef ZEND_ENGINE_2 
    38113764    ZEND_MODULE_POST_ZEND_DEACTIVATE_N(xcache_cacher), 
    3812 #else 
    3813     NULL, 
    3814     NULL, 
    3815 #endif 
    38163765    STANDARD_MODULE_PROPERTIES_EX 
    38173766}; 
  • trunk/mod_coverager/xc_coverager.c

    r1207 r1281  
    703703    NO_MODULE_GLOBALS, 
    704704#endif 
    705 #ifdef ZEND_ENGINE_2 
    706705    NULL, 
    707 #else 
    708     NULL, 
    709     NULL, 
    710 #endif 
    711706    STANDARD_MODULE_PROPERTIES_EX 
    712707}; 
  • trunk/mod_disassembler/xc_disassembler.c

    r1043 r1281  
    7676        ALLOC_INIT_ZVAL(zv); 
    7777        array_init(zv); 
    78         xc_dasm_zend_class_entry(&dasm, zv, CestToCePtr(*(xc_cest_t *)b->pData) TSRMLS_CC); 
     78        xc_dasm_zend_class_entry(&dasm, zv, *(zend_class_entry **)b->pData TSRMLS_CC); 
    7979 
    8080        keysize = BUCKET_KEY_SIZE(b) + 2; 
     
    151151 
    152152    /* free */ 
    153 #ifdef ZEND_ENGINE_2 
    154153    destroy_op_array(op_array TSRMLS_CC); 
    155 #else 
    156     destroy_op_array(op_array); 
    157 #endif 
    158154    efree(op_array); 
    159155 
     
    251247    NO_MODULE_GLOBALS, 
    252248#endif 
    253 #ifdef ZEND_ENGINE_2 
    254     NULL, 
    255 #else 
    256     NULL, 
    257     NULL, 
    258 #endif 
     249    NULL, 
    259250    STANDARD_MODULE_PROPERTIES_EX 
    260251}; 
  • trunk/mod_optimizer/xc_optimizer.c

    r1280 r1281  
    1 #if 1 
     1#if 0 
    22#   define XCACHE_DEBUG 
    33#endif 
     
    4444 
    4545    bbid_t     fall; 
    46 #ifdef ZEND_ENGINE_2 
    4746    bbid_t     catch; 
    48 #endif 
    4947#ifdef ZEND_ENGINE_2_5 
    5048    bbid_t     finally; 
     
    300298 
    301299    bb->fall       = BBID_INVALID; 
    302 #ifdef ZEND_ENGINE_2 
    303300    bb->catch      = BBID_INVALID; 
    304 #endif 
    305301#ifdef ZEND_ENGINE_2_5 
    306302    bb->finally    = BBID_INVALID; 
     
    336332    op_flowinfo_t fi; 
    337333    zend_op *last = bb->opcodes + bb->count - 1; 
    338     bbid_t catchbbid = ZESW(BBID_INVALID, bb->catch); 
     334    bbid_t catchbbid = bb->catch; 
    339335    bbid_t finallybbid; 
    340336#ifdef ZEND_ENGINE_2_5 
     337    finallybbid = bb->finally; 
     338#else 
    341339    finallybbid = BBID_INVALID; 
    342 #else 
    343     finallybbid = bb->finally; 
    344340#endif 
    345341 
     
    413409        zend_bool isbbhead; 
    414410        bbid_t bbid; 
    415 #ifdef ZEND_ENGINE_2 
    416411        bbid_t catchbbid; 
    417 #endif 
    418412#ifdef ZEND_ENGINE_2_5 
    419413        bbid_t finallybbid; 
     
    442436        } 
    443437    } 
    444 #ifdef ZEND_ENGINE_2 
    445438    /* mark try start */ 
    446439    for (i = 0; i < op_array->last_try_catch; i ++) { 
    447440        oplineinfos[op_array->try_catch_array[i].try_op].isbbhead = 1; 
    448441    } 
    449 #endif 
    450442    /* }}} */ 
    451443    /* {{{ fill op lines with newly allocated id */ 
     
    463455    } 
    464456    /* }}} */ 
    465 #ifdef ZEND_ENGINE_2 
    466457    /* {{{ fill op lines with catch id */ 
    467458    for (i = 0; i < count; i ++) { 
     
    494485#endif 
    495486    /* }}} */ 
    496 #endif 
    497487    /* {{{ create basic blocks */ 
    498488    start = 0; 
     
    506496        opline = op_array->opcodes + start; 
    507497        bb = bbs_new_bb_ex(bbs, opline, i - start); 
    508 #ifdef ZEND_ENGINE_2 
    509498        bb->catch = oplineinfos[start].catchbbid; 
    510 #endif 
    511499#ifdef ZEND_ENGINE_2_5 
    512500        bb->finally = oplineinfos[start].finallybbid; 
     
    549537{ 
    550538    int i; 
    551 #ifdef ZEND_ENGINE_2 
    552539    bbid_t lasttrybbid; 
    553540    bbid_t lastcatchbbid; 
    554 #endif 
    555541#ifdef ZEND_ENGINE_2_5 
    556542    bbid_t lastfinallybbid; 
     
    578564    } 
    579565 
    580 #ifdef ZEND_ENGINE_2 
    581566    lasttrybbid   = BBID_INVALID; 
    582567    lastcatchbbid = BBID_INVALID; 
     
    608593    } 
    609594    /* it is impossible to have last bb catched */ 
    610 #endif 
    611595} 
    612596/* }}} */ 
     
    624608 
    625609#ifdef XCACHE_DEBUG 
     610    xc_fix_opcode(op_array TSRMLS_CC); 
    626611#   if 0 
    627612    TRACE("optimize file: %s", op_array->filename); 
     
    654639#   endif 
    655640    op_print(op_array, 0, op_array->opcodes, op_array->opcodes + op_array->last); 
     641    xc_undo_fix_opcode(op_array TSRMLS_CC); 
    656642#endif 
    657643    return 0; 
     
    737723    NO_MODULE_GLOBALS, 
    738724#endif 
    739 #ifdef ZEND_ENGINE_2 
    740725    NULL, 
    741 #else 
    742     NULL, 
    743     NULL, 
    744 #endif 
    745726    STANDARD_MODULE_PROPERTIES_EX 
    746727}; 
  • trunk/processor/head.m4

    r1211 r1281  
    248248    } 
    249249    for (i = 0; i < php->classinfo_cnt; i ++) { 
    250         ceptr = CestToCePtr(php->classinfos[i].cest); 
    251         if (ZCEP_REFCOUNT_PTR(ceptr) == ZCEP_REFCOUNT_PTR(ce)) { 
     250        ceptr = php->classinfos[i].class_entry; 
     251        if (ceptr == ce) { 
    252252            processor->cache_ce = ceptr; 
    253253            processor->cache_class_index = i; 
     
    261261/* }}} */ 
    262262/* {{{ xc_get_class */ 
    263 #ifdef ZEND_ENGINE_2 
    264263static zend_class_entry *xc_get_class(xc_processor_t *processor, zend_ulong class_num) { 
    265264    /* must be parent or currrent class */ 
    266265    assert(class_num <= processor->active_class_index + 1); 
    267     return CestToCePtr(processor->php_dst->classinfos[class_num - 1].cest); 
    268 } 
    269 #endif 
     266    return processor->php_dst->classinfos[class_num - 1].class_entry; 
     267} 
    270268define(`xc_get_class', `xc_get_classNOTDEFINED') 
    271269/* }}} */ 
    272 #ifdef ZEND_ENGINE_2 
    273270/* fix method on store */ 
    274271static void xc_fix_method(xc_processor_t *processor, zend_op_array *dst TSRMLS_DC) /* {{{ */ 
     
    345342} 
    346343/* }}} */ 
    347 #endif 
    348344/* {{{ call op_array ctor handler */ 
    349345extern zend_bool xc_have_op_array_ctor; 
  • trunk/processor/processor.m4

    r1240 r1281  
    1212DECL_STRUCT_P_FUNC(`xc_entry_var_t') 
    1313DECL_STRUCT_P_FUNC(`xc_entry_php_t') 
    14 #ifdef ZEND_ENGINE_2 
    1514DECL_STRUCT_P_FUNC(`zend_property_info') 
    16 #endif 
    1715/* }}} */ 
    1816dnl ==================================================== 
     
    3432') 
    3533dnl }}} 
    36 #ifndef ZEND_ENGINE_2 
    37 DEF_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 ') 
    45 dnl }}} 
    46 #endif 
    47 #ifdef ZEND_ENGINE_2 
    4834DEF_STRUCT_P_FUNC(`zend_try_catch_element', , `dnl {{{ 
    4935    PROCESS(zend_uint, try_op) 
     
    5541') 
    5642dnl }}} 
    57 #endif 
    5843DEF_STRUCT_P_FUNC(`zend_brk_cont_element', , `dnl {{{ 
    5944#ifdef ZEND_ENGINE_2_2 
     
    6752DEF_HASH_TABLE_FUNC(`HashTable_zval_ptr',           `zval_ptr') 
    6853DEF_HASH_TABLE_FUNC(`HashTable_zend_function',      `zend_function') 
    69 #ifdef ZEND_ENGINE_2 
    7054DEF_HASH_TABLE_FUNC(`HashTable_zend_property_info', `zend_property_info') 
    71 #endif 
    7255DEF_STRUCT_P_FUNC(`zval', , `dnl {{{ 
    7356    IFDASM(`do { 
     
    133116                IFNOTMEMCPY(`IFCOPY(`memcpy(dst, src, sizeof(src[0]));')') 
    134117                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 
    139118                break; 
    140119 
     
    154133#ifdef ZEND_ENGINE_2_3 
    155134        PROCESS(zend_uint, refcount__gc) 
    156 #elif defined(ZEND_ENGINE_2) 
     135#else 
    157136        PROCESS(zend_uint, refcount) 
    158 #else 
    159         PROCESS(zend_ushort, refcount) 
    160137#endif 
    161138    ')dnl IFDASM 
     
    226203') 
    227204dnl }}} 
    228 #ifdef ZEND_ENGINE_2 
    229205DEF_STRUCT_P_FUNC(`zend_arg_info', , `dnl {{{ 
    230206    PROCESS(zend_uint, name_len) 
     
    245221') 
    246222dnl }}} 
    247 #endif 
    248223#ifdef HAVE_XCACHE_CONSTANT 
    249224DEF_STRUCT_P_FUNC(`zend_constant', , `dnl {{{ 
     
    279254') 
    280255dnl }}} 
    281 #ifdef ZEND_ENGINE_2 
    282256DEF_STRUCT_P_FUNC(`zend_property_info', , `dnl {{{ 
    283257    PROCESS(zend_uint, flags) 
     
    298272') 
    299273dnl }}} 
    300 #endif 
    301274#ifdef ZEND_ENGINE_2_4 
    302275DEF_STRUCT_P_FUNC(`zend_trait_method_reference', , `dnl {{{ 
     
    361334    PROCESS(zend_uint, name_length) 
    362335    PROC_ZSTRING_L(, name, name_length) 
    363     IFRESTORE(` 
    364 #ifndef ZEND_ENGINE_2 
    365         /* just copy parent and resolve on install_class */ 
    366         COPY(parent) 
    367 #else 
    368         PROC_CLASS_ENTRY_P(parent) 
    369 #endif 
    370     ', ` 
    371         PROC_CLASS_ENTRY_P(parent) 
    372     ') 
    373 #ifdef ZEND_ENGINE_2 
     336    PROC_CLASS_ENTRY_P(parent) 
    374337    PROCESS(int, refcount) 
    375 #else 
    376     STRUCT_P(int, refcount) 
    377 #endif 
    378338#ifndef ZEND_ENGINE_2_4 
    379339    PROCESS(zend_bool, constants_updated) 
    380340#endif 
    381 #ifdef ZEND_ENGINE_2 
    382341    PROCESS(zend_uint, ce_flags) 
    383 #endif 
    384  
    385 #ifdef ZEND_ENGINE_2 
     342 
    386343    STRUCT(HashTable, properties_info, HashTable_zend_property_info) 
    387 #endif 
    388344 
    389345#ifdef ZEND_ENGINE_2_4 
     
    402358    IFCOPY(`dst->static_members = &dst->default_static_members;') 
    403359    DONE(static_members) 
    404 #   elif defined(ZEND_ENGINE_2) 
     360#   else 
    405361    STRUCT_P(HashTable, static_members, HashTable_zval_ptr) 
    406362#   endif 
    407363#endif /* ZEND_ENGINE_2_4 */ 
    408364 
    409 #ifdef ZEND_ENGINE_2 
    410365    STRUCT(HashTable, constants_table, HashTable_zval_ptr) 
    411366 
     
    490445    COPY(module) 
    491446#   endif 
    492 #else /* ZEND_ENGINE_2 */ 
    493     COPY(handle_function_call) 
    494     COPY(handle_property_get) 
    495     COPY(handle_property_set) 
    496 #endif 
    497447    dnl must do after SETNULL(constructor) and dst->parent 
    498448    STRUCT(HashTable, function_table, HashTable_zend_function) 
     
    601551            IFDASM(`PROCESS(zend_uint, u.var)') 
    602552            PROCESS(zend_uint, u.opline_num) 
    603 #ifndef ZEND_ENGINE_2 
    604             PROCESS(zend_uint, u.fetch_type) 
    605 #endif 
    606553            PROCESS(zend_uint, u.EA.type) 
    607554            break; 
     
    665612            case ZEND_FAST_CALL: 
    666613#endif 
    667 #ifdef ZEND_ENGINE_2 
    668614                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); 
    669615                Z_OP(dst->op1).jmp_addr = processor->active_op_array_dst->opcodes + (Z_OP(src->op1).jmp_addr - processor->active_op_array_src->opcodes); 
    670616                assert(Z_OP(dst->op1).jmp_addr >= processor->active_op_array_dst->opcodes && Z_OP(dst->op1).jmp_addr - processor->active_op_array_dst->opcodes < processor->active_op_array_dst->last); 
    671 #endif 
    672617                break; 
    673618 
     
    682627            case ZEND_JMP_SET_VAR: 
    683628#endif 
    684 #ifdef ZEND_ENGINE_2 
    685629                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); 
    686630                Z_OP(dst->op2).jmp_addr = processor->active_op_array_dst->opcodes + (Z_OP(src->op2).jmp_addr - processor->active_op_array_src->opcodes); 
    687631                assert(Z_OP(dst->op2).jmp_addr >= processor->active_op_array_dst->opcodes && Z_OP(dst->op2).jmp_addr - processor->active_op_array_dst->opcodes < processor->active_op_array_dst->last); 
    688 #endif 
    689632                break; 
    690633 
     
    741684        /* deep */ 
    742685        STRUCT_P(HashTable, static_variables, HashTable_zval_ptr) 
    743 #ifdef ZEND_ENGINE_2 
    744686        STRUCT_ARRAY(zend_uint, num_args, zend_arg_info, arg_info) 
    745687        gc_arg_info = 1; 
    746 #endif 
    747688        dst->filename = processor->entry_php_src->filepath; 
    748689#ifdef ZEND_ENGINE_2_4 
     
    788729                    case ZEND_FAST_CALL: 
    789730#endif 
    790 #ifdef ZEND_ENGINE_2 
    791731                        Z_OP(opline->op1).jmp_addr = &dst->opcodes[Z_OP(opline->op1).jmp_addr - src->opcodes]; 
    792 #endif 
    793732                        break; 
    794733 
     
    803742            case ZEND_JMP_SET_VAR: 
    804743#endif 
    805 #ifdef ZEND_ENGINE_2 
    806744                        Z_OP(opline->op2).jmp_addr = &dst->opcodes[Z_OP(opline->op2).jmp_addr - src->opcodes]; 
    807 #endif 
    808745                        break; 
    809746 
     
    819756        ) { 
    820757            xc_gc_op_array_t gc_op_array; 
    821 #ifdef ZEND_ENGINE_2 
    822758            gc_op_array.num_args = gc_arg_info ? dst->num_args : 0; 
    823759            gc_op_array.arg_info = gc_arg_info ? dst->arg_info : NULL; 
    824 #endif 
    825760            gc_op_array.opcodes  = gc_opcodes ? dst->opcodes : NULL; 
    826761#ifdef ZEND_ENGINE_2_4 
     
    839774    PROCESS(zend_uchar, type) 
    840775    PROC_ZSTRING(, function_name) 
    841 #ifdef ZEND_ENGINE_2 
    842776    PROCESS(zend_uint, fn_flags) 
    843777    STRUCT_ARRAY(zend_uint, num_args, zend_arg_info, arg_info) 
     
    847781    PROCESS(zend_bool, pass_rest_by_reference) 
    848782#   endif 
    849 #else 
    850     if (src->arg_types) { 
    851         ALLOC(dst->arg_types, zend_uchar, src->arg_types[0] + 1) 
    852         IFCOPY(`memcpy(dst->arg_types, src->arg_types, sizeof(src->arg_types[0]) * (src->arg_types[0]+1));') 
    853         IFDASM(`do { 
    854             int i; 
    855             zval *zv; 
    856             ALLOC_INIT_ZVAL(zv); 
    857             array_init(zv); 
    858             for (i = 0; i < src->arg_types[0]; i ++) { 
    859                 add_next_index_long(zv, src->arg_types[i + 1]); 
    860             } 
    861             add_assoc_zval_ex(dst, ZEND_STRS("arg_types"), zv); 
    862         } while (0);') 
    863         DONE(arg_types) 
    864     } 
    865     else { 
    866         COPYNULL(arg_types) 
    867     } 
    868 #endif 
    869783#ifndef ZEND_ENGINE_2_4 
    870784    PROCESS(unsigned char, return_reference) 
     
    917831    PROCESS(zend_uint, current_brk_cont) 
    918832#endif 
    919 #ifndef ZEND_ENGINE_2 
    920     PROCESS(zend_bool, uses_globals) 
    921 #endif 
    922  
    923 #ifdef ZEND_ENGINE_2 
     833 
    924834    STRUCT_ARRAY(int, last_try_catch, zend_try_catch_element, try_catch_array) 
    925835    PROCESS(int, last_try_catch) 
    926 #endif 
    927836#ifdef ZEND_ENGINE_2_5 
    928837    PROCESS(zend_bool, has_finally_block) 
     
    955864    ') 
    956865#endif 
    957 #ifdef ZEND_ENGINE_2 
    958866    PROCESS(zend_uint, line_start) 
    959867    PROCESS(zend_uint, line_end) 
    960868    PROCESS(int, doc_comment_len) 
    961869    PROC_ZSTRING_L(, doc_comment, doc_comment_len) 
    962 #endif 
    963870#ifdef ZEND_COMPILE_DELAYED_BINDING 
    964871    PROCESS(zend_uint, early_binding); 
     
    977884    IFRESTORE(`xc_fix_op_array_info(processor->entry_php_src, processor->php_src, dst, shallow_copy, op_array_info TSRMLS_CC);') 
    978885 
    979 #ifdef ZEND_ENGINE_2 
    980886    dnl mark it as -1 on store, and lookup parent on restore 
    981887    IFSTORE(`dst->prototype = (processor->active_class_entry_src && src->prototype) ? (zend_function *) -1 : NULL;', ` 
     
    1006912    DONE(prototype) 
    1007913 
    1008 #endif 
    1009  
    1010 #ifdef ZEND_ENGINE_2 
    1011914    PROC_CLASS_ENTRY_P(scope) 
    1012915    IFCOPY(` 
     
    1015918        } 
    1016919    ') 
    1017 #endif 
    1018920 
    1019921    IFRESTORE(` 
     
    11001002        processor->active_op_array_index = 0; 
    11011003    ') 
    1102 #ifdef ZEND_ENGINE_2 
    1103     STRUCT_P(zend_class_entry, cest) 
    1104 #else 
    1105     STRUCT(zend_class_entry, cest) 
    1106 #endif 
     1004    STRUCT_P(zend_class_entry, class_entry) 
    11071005#ifndef ZEND_COMPILE_DELAYED_BINDING 
    11081006    PROCESS(int, oplineno) 
  • trunk/xcache.c

    r1278 r1281  
    115115/* }}} */ 
    116116/* {{{ PHP_GINIT_FUNCTION(xcache) */ 
    117 #pragma GCC push_options 
    118 #pragma GCC diagnostic ignored "-Wshadow" 
    119  
     117#define xcache_globals xcacheglobals 
    120118#ifdef PHP_GINIT_FUNCTION 
    121119static PHP_GINIT_FUNCTION(xcache) 
    122120#else 
    123 static void xc_init_globals(zend_xcache_globals* xcache_globals TSRMLS_DC) 
    124 #endif 
    125 { 
    126 #pragma GCC pop_options 
    127  
     121static void xc_init_globals(zend_xcache_globals *xcache_globals TSRMLS_DC) 
     122#endif 
     123{ 
    128124    memset(xcache_globals, 0, sizeof(zend_xcache_globals)); 
    129125 
     
    134130    zend_hash_init_ex(&xcache_globals->internal_class_table,    1, NULL, NULL, 1, 0); 
    135131} 
     132#undef xcache_globals 
    136133/* }}} */ 
    137134/* {{{ PHP_GSHUTDOWN_FUNCTION(xcache) */ 
    138135static 
    139136#ifdef PHP_GSHUTDOWN_FUNCTION 
     137#define xcache_globals xcacheglobals 
    140138PHP_GSHUTDOWN_FUNCTION(xcache) 
    141139#else 
     
    171169    } 
    172170} 
     171#undef xcache_globals 
    173172/* }}} */ 
    174173 
     
    887886    PHP_GSHUTDOWN(xcache), 
    888887#endif 
    889 #ifdef ZEND_ENGINE_2 
    890888    NULL /* ZEND_MODULE_POST_ZEND_DEACTIVATE_N */, 
    891 #else 
    892     NULL, 
    893     NULL, 
    894 #endif 
    895889    STANDARD_MODULE_PROPERTIES_EX 
    896890}; 
  • trunk/xcache/xc_compatibility.c

    r991 r1281  
    22 
    33#ifndef ZEND_ENGINE_2_3 
    4 #include "ext/standard/php_string.h" 
    5 size_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  
    164long xc_atol(const char *str, int str_len) /* {{{ */ 
    175{ 
  • trunk/xcache/xc_compatibility.h

    r1280 r1281  
    2828 
    2929#define NOTHING 
    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 
     30/* ZendEngine version code Switcher */ 
    3631#ifdef ZEND_ENGINE_2_4 
    3732#   define ZEND_24(pre24, v24) v24 
     
    112107#   define Z_CLASS_INFO(className) (className) 
    113108 
    114 static inline int php_output_start_default(TSRMLS_D) { php_start_ob_buffer(NULL, 0, 1 TSRMLS_CC); } 
    115 static inline int php_output_get_contents(zval *p TSRMLS_DC) { php_ob_get_buffer(p TSRMLS_CC); } 
    116 static inline int php_output_discard(TSRMLS_D) { php_end_ob_buffer(0, 0 TSRMLS_CC); } 
     109static inline int php_output_start_default(TSRMLS_D) { return php_start_ob_buffer(NULL, 0, 1 TSRMLS_CC); } 
     110static inline int php_output_get_contents(zval *p TSRMLS_DC) { return php_ob_get_buffer(p TSRMLS_CC); } 
     111static inline int php_output_discard(TSRMLS_D) { php_end_ob_buffer(0, 0 TSRMLS_CC); return SUCCESS; } 
    117112#endif 
    118113 
     
    213208/* }}} */ 
    214209 
    215 /* the class entry type to be stored in class_table */ 
    216 typedef 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  
    230210#ifndef ZEND_ENGINE_2_3 
    231 size_t xc_dirname(char *path, size_t len); 
    232 #define zend_dirname xc_dirname 
     211#include "ext/standard/php_string.h" 
     212static inline size_t zend_dirname(char *path, size_t len) { return php_dirname(path, len); } 
    233213long xc_atol(const char *str, int len); 
    234214#define zend_atol xc_atol 
     
    240220 
    241221#ifndef PHP_FE_END 
    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 
     222#   define PHP_FE_END {NULL, NULL, NULL, 0, 0} 
    247223#endif 
    248224 
  • trunk/xcache/xc_const_string.c

    r1254 r1281  
    7272#elif defined(ZEND_ENGINE_2_1) 
    7373#   include "xc_const_string_opcodes_php5.1.h" 
    74 #elif defined(ZEND_ENGINE_2) 
     74#else 
    7575#   include "xc_const_string_opcodes_php5.0.h" 
    76 #else 
    77 #   include "xc_const_string_opcodes_php4.x.h" 
    7876#endif 
    7977 
  • trunk/xcache/xc_const_string_opcodes_php5.3.h

    r1095 r1281  
    152152/* 149 */   "HANDLE_EXCEPTION", 
    153153/* 150 */   "USER_OPCODE", 
     154#ifdef ZEND_ENGINE_2_3 
    154155/* 151 */   "UNDEF", 
    155156/* 152 */   "JMP_SET", 
    156157/* 153 */   "DECLARE_LAMBDA_FUNCTION" 
     158#endif 
    157159}; 
  • trunk/xcache/xc_ini.h

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

    r982 r1281  
    55/* {{{ opcode_spec */ 
    66#define OPSPEC(ext, op1, op2, res) { OPSPEC_##ext, OPSPEC_##op1, OPSPEC_##op2, OPSPEC_##res }, 
    7 #ifdef ZEND_ENGINE_2 
    8 #   define OPSPEC_VAR_2 OPSPEC_STD 
    9 #else 
    10 #   define OPSPEC_VAR_2 OPSPEC_VAR 
    11 #endif 
     7#define OPSPEC_VAR_2 OPSPEC_STD 
    128#include "xc_opcode_spec_def.h" 
    139 
  • trunk/xcache/xc_opcode_spec_def.h

    r1213 r1281  
    2323    OPSPEC(      CAST,        STD,     UNUSED,        TMP) /* 21 CAST                           */ 
    2424    OPSPEC(    UNUSED,        STD,     UNUSED,        TMP) /* 22 QM_ASSIGN                      */ 
    25 #ifdef ZEND_ENGINE_2 
    2625    OPSPEC(    ASSIGN,        STD,        STD,        VAR) /* 23 ASSIGN_ADD                     */ 
    2726    OPSPEC(    ASSIGN,        STD,        STD,        VAR) /* 24 ASSIGN_SUB                     */ 
     
    3534    OPSPEC(    ASSIGN,        STD,        STD,        VAR) /* 32 ASSIGN_BW_AND                  */ 
    3635    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 
    5036    OPSPEC(    UNUSED,        VAR,     UNUSED,        VAR) /* 34 PRE_INC                        */ 
    5137    OPSPEC(    UNUSED,        VAR,     UNUSED,        VAR) /* 35 PRE_DEC                        */ 
     
    5642    OPSPEC(    UNUSED,        STD,     UNUSED,     UNUSED) /* 40 ECHO                           */ 
    5743    OPSPEC(    UNUSED,        STD,     UNUSED,        TMP) /* 41 PRINT                          */ 
    58 #ifdef ZEND_ENGINE_2 
    5944    OPSPEC(    UNUSED,    JMPADDR,     UNUSED,     UNUSED) /* 42 JMP                            */ 
    6045    OPSPEC(    UNUSED,        STD,    JMPADDR,     UNUSED) /* 43 JMPZ                           */ 
    6146    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 
    6747    OPSPEC(    OPLINE,        STD,     OPLINE,     UNUSED) /* 45 JMPZNZ                         */ 
    68 #ifdef ZEND_ENGINE_2 
    6948    OPSPEC(    UNUSED,        STD,    JMPADDR,        TMP) /* 46 JMPZ_EX                        */ 
    7049    OPSPEC(    UNUSED,        STD,    JMPADDR,        TMP) /* 47 JMPNZ_EX                       */ 
    71 #else 
    72     OPSPEC(    UNUSED,        STD,     OPLINE,        TMP) 
    73     OPSPEC(    UNUSED,        STD,     OPLINE,        TMP) 
    74 #endif 
    7550    OPSPEC(    UNUSED,        STD,        STD,        TMP) /* 48 CASE                           */ 
    7651    OPSPEC(       BIT,        STD,     UNUSED,     UNUSED) /* 49 SWITCH_FREE                    */ 
     
    8560    OPSPEC(    UNUSED,        TMP,     UNUSED,     UNUSED) /* 58 END_SILENCE                    */ 
    8661    OPSPEC(INIT_FCALL,        STD,        STD,     UNUSED) /* 59 INIT_FCALL_BY_NAME             */ 
    87 #ifdef ZEND_ENGINE_2 
    8862    OPSPEC(     FCALL,        STD,     OPLINE,        VAR) /* 60 DO_FCALL                       */ 
    8963    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 
    9464    OPSPEC(    UNUSED,        STD,     UNUSED,     UNUSED) /* 62 RETURN                         */ 
    9565    OPSPEC(    UNUSED,        ARG,     UNUSED,        VAR) /* 63 RECV                           */ 
     
    9868    OPSPEC(      SEND,        VAR,        ARG,     UNUSED) /* 66 SEND_VAR                       */ 
    9969    OPSPEC(      SEND,        VAR,        ARG,     UNUSED) /* 67 SEND_REF                       */ 
    100 #ifdef ZEND_ENGINE_2 
    10170    OPSPEC(    UNUSED,      CLASS,     UNUSED,        VAR) /* 68 NEW                            */ 
    102 #else 
    103     OPSPEC(    UNUSED,        STD,     UNUSED,        VAR) 
    104 #endif 
    10571#ifdef ZEND_ENGINE_2_3 
    10672    OPSPEC(       STD,        STD,        STD,     UNUSED) /* 69 INIT_NS_FCALL_BY_NAME          */ 
     
    149115#ifdef ZEND_ENGINE_2_3 
    150116    OPSPEC(    UNUSED,      VAR_2,        STD,        TMP) /* 99 FETCH_CONSTANT                 */ 
    151 #elif defined(ZEND_ENGINE_2) 
     117#else 
    152118    OPSPEC(    UNUSED,     UCLASS,        STD,        TMP) /* 99 FETCH_CONSTANT                 */ 
    153 #else 
    154     OPSPEC(    UNUSED,        STD,     UNUSED,        TMP) /* 99 FETCH_CONSTANT                 */ 
    155119#endif 
    156120#ifdef ZEND_ENGINE_2_3 
     
    165129    OPSPEC(    UNUSED,        STD,     UNUSED,     UNUSED) /* 105 TICKS                          */ 
    166130    OPSPEC(SEND_NOREF,        VAR,        ARG,     UNUSED) /* 106 SEND_VAR_NO_REF                */ 
    167 #ifdef ZEND_ENGINE_2 
    168131    OPSPEC(    OPLINE,      CLASS,        STD,     UNUSED) /* 107 CATCH                          */ 
    169132    OPSPEC(    UNUSED,        STD,     OPLINE,     UNUSED) /* 108 THROW                          */ 
     
    178141 
    179142    OPSPEC(    UNUSED,        STD,        STD,        VAR) /* 112 INIT_METHOD_CALL               */ 
    180 #   ifdef ZEND_ENGINE_2_3 
     143#ifdef ZEND_ENGINE_2_3 
    181144    OPSPEC(    UNUSED,        STD,        STD,     UNUSED) /* 113 INIT_STATIC_METHOD_CALL        */ 
    182 #   else 
     145#else 
    183146    OPSPEC(    UNUSED,     UCLASS,        STD,     UNUSED) /* 113 INIT_STATIC_METHOD_CALL        */ 
    184 #   endif 
     147#endif 
    185148    OPSPEC(     ISSET,        STD,      FETCH,        TMP) /* 114 ISSET_ISEMPTY_VAR              */ 
    186149    OPSPEC(     ISSET,        STD,        STD,        TMP) /* 115 ISSET_ISEMPTY_DIM_OBJ          */ 
     
    234197    OPSPEC(       STD,     UNUSED,     UNUSED,        STD) /* 149 HANDLE_EXCEPTION               */ 
    235198    OPSPEC(       STD,     UNUSED,     UNUSED,        STD) /* 150 USER_OPCODE                    */ 
    236 # ifdef ZEND_ENGINE_2_3 
     199#ifdef ZEND_ENGINE_2_3 
    237200    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 151 UNDEF                          */ 
    238201    OPSPEC(    UNUSED,        STD,    JMPADDR,        TMP) /* 152 JMP_SET                        */ 
    239202    OPSPEC(    UNUSED,        STD,        STD,        TMP) /* 153 DECLARE_LAMBDA_FUNCTION        */ 
    240 # endif 
    241 # ifdef ZEND_ENGINE_2_4 
     203#endif 
     204#ifdef ZEND_ENGINE_2_4 
    242205    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 154 ADD_TRAIT                      */ 
    243206    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 155 BIND_TRAITS                    */ 
     
    245208    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 157 QM_ASSIGN_VAR                  */ 
    246209    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 158 JMP_SET_VAR                    */ 
    247 # endif 
    248 # ifdef ZEND_ENGINE_2_5 
     210#endif 
     211#ifdef ZEND_ENGINE_2_5 
    249212    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 159 DISCARD_EXCEPTION              */ 
    250213    OPSPEC(    UNUSED,        STD,        STD,     UNUSED) /* 160 YIELD                          */ 
     
    252215    OPSPEC(    UNUSED,    JMPADDR,     UNUSED,     UNUSED) /* 162 FAST_CALL                      */ 
    253216    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 163 FAST_RET                       */ 
    254 # endif 
    255 #else 
    256     OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 107 UNDEF                          */ 
    257     OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 108 UNDEF                          */ 
    258     OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 109 UNDEF                          */ 
    259     OPSPEC(     FCALL,        STD,     OPLINE,        VAR) /* 61 DO_FCALL_BY_FUNC                */ 
    260     OPSPEC(INIT_FCALL,        STD,        STD,     UNUSED) /* 111 INIT_FCALL_BY_FUNC             */ 
    261     OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 112 UNDEF                          */ 
    262217#endif 
    263218}; 
  • trunk/xcache/xc_sandbox.c

    r1275 r1281  
    195195#if 0 && TODO 
    196196    { 
    197         xc_cest_t tmp_cest; 
    198         zend_hash_copy(&TG(class_table), &XG(internal_class_table), NULL, (void *) &tmp_cest, sizeof(tmp_cest)); 
     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)); 
    199199    } 
    200200#endif 
     
    278278    /* install class */ 
    279279    while (b != NULL) { 
    280         xc_install_class(sandbox->filename, (xc_cest_t*) b->pData, -1, 
     280        xc_install_class(sandbox->filename, *(zend_class_entry **)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

    r1213 r1281  
    7878{ 
    7979    /* avoid duplicate apply for shadowed method */ 
    80 #ifdef ZEND_ENGINE_2 
    8180    if (mi->ce != zf->common.scope) { 
    8281        /* fprintf(stderr, "avoided duplicate %s\n", zf->common.function_name); */ 
    8382        return 0; 
    8483    } 
    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 
    9984    return xc_apply_function(zf, &mi->fi TSRMLS_CC); 
    10085} 
    10186/* }}} */ 
    102 static int xc_apply_cest(xc_cest_t *cest, xc_apply_func_info *fi TSRMLS_DC) /* {{{ */ 
     87static int xc_apply_class(zend_class_entry **ce, xc_apply_func_info *fi TSRMLS_DC) /* {{{ */ 
    10388{ 
    10489    xc_apply_method_info mi; 
    10590 
    10691    mi.fi = *fi; 
    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); 
     92    mi.ce = *ce; 
     93    zend_hash_apply_with_argument(&((*ce)->function_table), (apply_func_arg_t) xc_apply_method, &mi TSRMLS_CC); 
    10994    return 0; 
    11095} 
     
    115100    fi.applyer = applyer; 
    116101    zend_hash_apply_with_argument(cr->function_table, (apply_func_arg_t) xc_apply_function, &fi TSRMLS_CC); 
    117     zend_hash_apply_with_argument(cr->class_table, (apply_func_arg_t) xc_apply_cest, &fi TSRMLS_CC); 
     102    zend_hash_apply_with_argument(cr->class_table, (apply_func_arg_t) xc_apply_class, &fi TSRMLS_CC); 
    118103 
    119104    return applyer(cr->op_array TSRMLS_CC); 
     
    278263static 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) /* {{{ */ 
    279264{ 
    280 #ifdef ZEND_ENGINE_2 
    281265    if ((*op_type != IS_UNUSED && (spec == OPSPEC_UCLASS || spec == OPSPEC_CLASS)) || 
    282266            spec == OPSPEC_FETCH) { 
     
    304288        } 
    305289    } 
    306 #endif 
    307290} 
    308291/* }}} */ 
     
    380363                break; 
    381364 
    382 #ifdef ZEND_ENGINE_2 
    383365            case ZEND_DECLARE_INHERITED_CLASS: 
    384366                callback(opline, opline - begin, data TSRMLS_CC); 
    385367                break; 
    386 #else 
    387             case ZEND_DECLARE_FUNCTION_OR_CLASS: 
    388                 if (opline->extended_value == ZEND_DECLARE_INHERITED_CLASS) { 
    389                     callback(opline, opline - begin, data TSRMLS_CC); 
    390                 } 
    391                 break; 
    392 #endif 
    393368        } 
    394369 
     
    415390 
    416391    switch (opline->opcode) { 
    417 #ifdef ZEND_ENGINE_2 
    418392    case ZEND_DECLARE_INHERITED_CLASS: 
    419393        { 
     
    464438            ZEND_VM_SET_OPCODE_HANDLER(abstract_op); 
    465439        } 
    466 #else 
    467     case ZEND_DECLARE_FUNCTION_OR_CLASS: 
    468         if (do_bind_function_or_class(opline, NULL, class_table, 1) == FAILURE) { 
    469             return FAILURE; 
    470         } 
    471 #endif 
    472440        break; 
    473441 
     
    531499                    NULL 
    532500                    ) == FAILURE) { 
    533             CG(zend_lineno) = ZESW(func->op_array.opcodes[0].lineno, func->op_array.line_start); 
     501            CG(zend_lineno) = func->op_array.line_start; 
    534502#ifdef IS_UNICODE 
    535503            zend_error(E_ERROR, "Cannot redeclare %R()", type, key); 
     
    541509} 
    542510/* }}} */ 
    543 ZESW(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) /* {{{ */ 
     511void 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) /* {{{ */ 
    544512{ 
    545513    zend_bool istmpkey; 
    546     zend_class_entry *cep = CestToCePtr(*cest); 
    547     ZESW(void *stored_ce_ptr, NOTHING); 
    548514 
    549515#ifdef IS_UNICODE 
     
    554520    if (istmpkey) { 
    555521        zend_u_hash_quick_update(CG(class_table), type, key, len, h, 
    556                     cest, sizeof(xc_cest_t), 
    557                     ZESW(&stored_ce_ptr, NULL) 
     522                    ce, sizeof(zend_class_entry *), 
     523                    NULL 
    558524                    ); 
    559525#ifndef ZEND_COMPILE_DELAYED_BINDING 
     
    564530    } 
    565531    else if (zend_u_hash_quick_add(CG(class_table), type, key, len, h, 
    566                 cest, sizeof(xc_cest_t), 
    567                 ZESW(&stored_ce_ptr, NULL) 
     532                ce, sizeof(zend_class_entry *), 
     533                NULL 
    568534                ) == FAILURE) { 
    569         CG(zend_lineno) = ZESW(0, Z_CLASS_INFO(*cep).line_start); 
     535        CG(zend_lineno) = Z_CLASS_INFO(*ce).line_start; 
    570536#ifdef IS_UNICODE 
    571         zend_error(E_ERROR, "Cannot redeclare class %R", type, cep->name); 
    572 #else 
    573         zend_error(E_ERROR, "Cannot redeclare class %s", cep->name); 
     537        zend_error(E_ERROR, "Cannot redeclare class %R", type, ce->name); 
     538#else 
     539        zend_error(E_ERROR, "Cannot redeclare class %s", ce->name); 
    574540#endif 
    575541        assert(oplineno == -1); 
    576542    } 
    577     ZESW(return (xc_cest_t *) stored_ce_ptr, NOTHING); 
    578543} 
    579544/* }}} */ 
  • trunk/xcache/xc_utils.h

    r1051 r1281  
    4040#endif 
    4141void xc_install_function(ZEND_24(NOTHING, const) char *filename, zend_function *func, zend_uchar type, const24_zstr key, uint len, ulong h TSRMLS_DC); 
    42 ZESW(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); 
     42void 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); 
    4343 
    4444typedef zend_bool (*xc_if_func_t)(void *data); 
Note: See TracChangeset for help on using the changeset viewer.