Changeset 1281 in svn


Ignore:
Timestamp:
2013-07-08T10:00:36+02:00 (2 years ago)
Author:
Xuefer
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.