Changeset 622


Ignore:
Timestamp:
2009-07-05T10:18:06+02:00 (5 years ago)
Author:
moo
Message:

merged r504:513 from trunk

Location:
branches/1.3
Files:
14 edited

Legend:

Unmodified
Added
Removed
  • branches/1.3

  • branches/1.3/const_string.c

    r618 r622  
    7070#elif defined(ZEND_ENGINE_2) 
    7171#   include "const_string_opcodes_php5.0.h" 
     72#else 
     73#   include "const_string_opcodes_php4.x.h" 
    7274#endif 
    7375 
  • branches/1.3/disassembler.c

    r394 r622  
    6666            } 
    6767        } 
    68         add_u_assoc_zval_ex(list, BUCKET_KEY_TYPE(b), buf, b->nKeyLength, zv); 
     68        add_u_assoc_zval_ex(list, BUCKET_KEY_TYPE(b), ZSTR(buf), b->nKeyLength, zv); 
    6969    } 
    7070    efree(buf); 
  • branches/1.3/processor/hashtable.m4

    r394 r622  
    6060                    } 
    6161                } 
    62                 add_u_assoc_zval_ex(dst, BUCKET_KEY_TYPE(b), buf, keysize, zv); 
     62                add_u_assoc_zval_ex(dst, BUCKET_KEY_TYPE(b), ZSTR(buf), keysize, zv); 
    6363            } 
    6464            ') 
  • branches/1.3/processor/head.m4

    r494 r622  
    114114static inline int xc_zstrlen_uchar(zstr s) 
    115115{ 
    116     int i; 
    117     UChar *p = ZSTR_U(s); 
    118     for (i = 0; *p; i ++, p++) { 
    119         /* empty */ 
    120     } 
    121     return i; 
     116    return u_strlen(ZSTR_U(s)); 
    122117} 
    123118/* }}} */ 
     
    215210#ifdef ZEND_ENGINE_2 
    216211/* fix method on store */ 
    217 static void xc_fix_method(xc_processor_t *processor, zend_op_array *dst) /* {{{ */ 
     212static void xc_fix_method(xc_processor_t *processor, zend_op_array *dst TSRMLS_DC) /* {{{ */ 
    218213{ 
    219214    zend_function *zf = (zend_function *) dst; 
    220215    zend_class_entry *ce = processor->active_class_entry_dst; 
     216    const zend_class_entry *srcce = processor->active_class_entry_src; 
    221217 
    222218    /* Fixing up the default functions for objects here since 
     
    239235    } 
    240236    else { 
    241 dnl FIXME: handle common.function_name here 
    242 #define SET_IF_SAME_NAME(member) \ 
    243         do { \ 
    244             if (!strcasecmp(ZSTR_S(zf->common.function_name), #member)) { \ 
    245                 ce->member = zf; \ 
    246             } \ 
    247         } \ 
    248         while(0) 
    249         /* if(ce->member && !strcmp(zf->common.function_name, ce->member->common.function_name)) { \ */ 
    250  
     237    pushdef(`SET_IF_SAME_NAMEs', ` 
    251238        SET_IF_SAME_NAME(__get); 
    252239        SET_IF_SAME_NAME(__set); 
     
    262249        SET_IF_SAME_NAME(__tostring); 
    263250#endif 
    264  
     251    ') 
     252#ifdef IS_UNICODE 
     253        if (UG(unicode)) { 
     254#define SET_IF_SAME_NAME(member) \ 
     255            do { \ 
     256                if (srcce->member && u_strcmp(ZSTR_U(zf->common.function_name), ZSTR_U(srcce->member->common.function_name)) == 0) { \ 
     257                    ce->member = zf; \ 
     258                } \ 
     259            } \ 
     260            while(0) 
     261 
     262            SET_IF_SAME_NAMEs() 
    265263#undef SET_IF_SAME_NAME 
     264        } 
     265        else 
     266#endif 
     267        do { 
     268#define SET_IF_SAME_NAME(member) \ 
     269            do { \ 
     270                if (srcce->member && strcmp(ZSTR_S(zf->common.function_name), ZSTR_S(srcce->member->common.function_name)) == 0) { \ 
     271                    ce->member = zf; \ 
     272                } \ 
     273            } \ 
     274            while(0) 
     275 
     276            SET_IF_SAME_NAMEs() 
     277#undef SET_IF_SAME_NAME 
     278        } while (0); 
     279 
     280    popdef(`SET_IF_SAME_NAMEs') 
     281 
    266282    } 
    267283} 
  • branches/1.3/processor/main.m4

    r593 r622  
    111111        IFSTORE(`$1 = (zend_class_entry *) xc_get_class_num(processor, $2);') 
    112112        IFRESTORE(`$1 = xc_get_class(processor, (zend_ulong) $2);') 
    113         IFDASM(`add_assoc_stringl_ex(dst, ZEND_STRS("$3"), $2->name, strlen($2->name), 1);') 
     113        IFDASM(`add_assoc_unicodel_ex(dst, ZEND_STRS("$3"), ZSTR_U($2->name), $2->name_length, 1);') 
    114114    } 
    115115    else { 
  • branches/1.3/processor/processor.m4

    r621 r622  
    5757DEF_STRUCT_P_FUNC(`zend_brk_cont_element', , ` 
    5858#ifdef ZEND_ENGINE_2_2 
    59 #ifndef IS_UNICODE 
    6059    DISPATCH(int, start) 
    61 #endif 
    6260#endif 
    6361    DISPATCH(int, cont) 
     
    243241    pushdef(`emalloc', `malloc($1)') 
    244242    pushdef(`ecalloc', `calloc($1, $2)') 
    245     PROC_ZSTRING_L(, name, name_len) 
     243    PROC_ZSTRING_N(, name, name_len) 
    246244    popdef(`ecalloc') 
    247245    popdef(`emalloc') 
     
    283281#endif 
    284282    dnl isnt in php6 yet 
    285 #if defined(ZEND_ENGINE_2_2) && !defined(IS_UNICODE) 
     283#if defined(ZEND_ENGINE_2_2) 
    286284    PROC_CLASS_ENTRY_P(ce) 
    287285#endif 
     
    511509        /* deep */ 
    512510        STRUCT_P(HashTable, static_variables, HashTable_zval_ptr) 
     511#ifdef ZEND_ENGINE_2 
    513512        STRUCT_ARRAY_I(num_args, zend_arg_info, arg_info) 
    514513        xc_gc_add_op_array(dst TSRMLS_CC); 
     514#endif 
    515515        define(`SKIPASSERT_ONCE') 
    516516    } 
     
    646646                 && zend_u_hash_find(&(processor->active_class_entry_dst->parent->function_table), 
    647647                        UG(unicode) ? IS_UNICODE : IS_STRING, 
    648                         src->function_name, xc_zstrlen(UG(unicode), src->function_name) + 1, 
     648                        src->function_name, xc_zstrlen(UG(unicode) ? IS_UNICODE : IS_STRING, src->function_name) + 1, 
    649649                        (void **) &parent) == SUCCESS) { 
    650650                    /* see do_inherit_method_check() */ 
     
    670670#endif 
    671671 
    672     IFRESTORE(` 
    673 #ifdef ZEND_ENGINE_2 
     672#ifdef ZEND_ENGINE_2 
     673    PROC_CLASS_ENTRY_P(scope) 
     674    IFCOPY(` 
    674675        if (src->scope) { 
    675             dst->scope = xc_get_class(processor, (zend_ulong) src->scope); 
    676             xc_fix_method(processor, dst); 
    677         } 
    678         DONE(scope) 
    679 #endif 
    680     ', ` 
    681 #ifdef ZEND_ENGINE_2 
    682         PROC_CLASS_ENTRY_P(scope) 
    683 #endif 
    684     ') 
     676            xc_fix_method(processor, dst TSRMLS_CC); 
     677        } 
     678    ') 
     679#endif 
    685680 
    686681    IFRESTORE(` 
     
    701696        PROC_ZSTRING_N(type, key, key_size) 
    702697    ') 
     698    DISPATCH(ulong, h) 
    703699    STRUCT(zend_constant, constant) 
    704700') 
     
    713709        PROC_ZSTRING_N(type, key, key_size) 
    714710    ') 
     711    DISPATCH(ulong, h) 
    715712    STRUCT(zend_function, func) 
    716713') 
     
    724721        PROC_ZSTRING_N(type, key, key_size) 
    725722    ') 
     723    DISPATCH(ulong, h) 
    726724#ifdef ZEND_ENGINE_2 
    727725    STRUCT_P(zend_class_entry, cest) 
     
    741739        PROC_ZSTRING_L(type, key, key_len) 
    742740    ') 
     741    DISPATCH(ulong, h) 
    743742') 
    744743dnl }}} 
  • branches/1.3/processor/string.m4

    r394 r622  
    3939 
    4040                INIT_ZVAL(zv); 
    41                 ZVAL_UNICODEL(&zv, (UChar *) ($2), $3 - 1, 1); 
     41                ZVAL_UNICODEL(&zv, ZSTR_U($2), $3 - 1, 1); 
    4242                zend_make_printable_zval(&zv, &reszv, &usecopy); 
    4343                fprintf(stderr, "string:%s:\t\"", "$1"); 
     
    6464        FIXPOINTER_EX(`PTRTYPE', DSTPTR) 
    6565        IFDASM(` 
    66                 ifelse(STRTYPE,zstr_uchar, ` 
    67                     add_assoc_unicodel_ex(dst, ZEND_STRS("$4"), $2, $3-1, 1); 
    68                     ', ` dnl else 
    69                     add_assoc_stringl_ex(dst, ZEND_STRS("$4"), $2, $3-1, 1);') 
     66            ifelse(STRTYPE,zstr_uchar, ` 
     67                add_assoc_unicodel_ex(dst, ZEND_STRS("$4"), ZSTR_U($2), $3-1, 1); 
     68                ', ` dnl else 
     69                ifelse(STRTYPE,zstr_char, ` 
     70                    add_assoc_stringl_ex(dst, ZEND_STRS("$4"), ZSTR_S($2), $3-1, 1); 
     71                    ', ` 
     72                    add_assoc_stringl_ex(dst, ZEND_STRS("$4"), $2, $3-1, 1); 
    7073                ') 
     74            ') 
     75        ') 
    7176    } 
    7277    popdef(`DSTPTR') 
  • branches/1.3/utils.c

    r617 r622  
    425425 
    426426#ifdef HAVE_XCACHE_CONSTANT 
    427 void xc_install_constant(char *filename, zend_constant *constant, zend_uchar type, zstr key, uint len TSRMLS_DC) /* {{{ */ 
     427void xc_install_constant(char *filename, zend_constant *constant, zend_uchar type, zstr key, uint len, ulong h TSRMLS_DC) /* {{{ */ 
    428428{ 
    429429    if (zend_u_hash_add(EG(zend_constants), type, key, len, 
     
    445445/* }}} */ 
    446446#endif 
    447 void xc_install_function(char *filename, zend_function *func, zend_uchar type, zstr key, uint len TSRMLS_DC) /* {{{ */ 
     447void xc_install_function(char *filename, zend_function *func, zend_uchar type, zstr key, uint len, ulong h TSRMLS_DC) /* {{{ */ 
    448448{ 
    449449    zend_bool istmpkey; 
     
    475475} 
    476476/* }}} */ 
    477 ZESW(xc_cest_t *, void) xc_install_class(char *filename, xc_cest_t *cest, int oplineno, zend_uchar type, zstr key, uint len TSRMLS_DC) /* {{{ */ 
     477ZESW(xc_cest_t *, void) xc_install_class(char *filename, xc_cest_t *cest, int oplineno, zend_uchar type, zstr key, uint len, ulong h TSRMLS_DC) /* {{{ */ 
    478478{ 
    479479    zend_bool istmpkey; 
     
    487487#endif 
    488488    if (istmpkey) { 
    489         zend_u_hash_update(CG(class_table), type, key, len, 
     489        zend_u_hash_quick_update(CG(class_table), type, key, len, h, 
    490490                    cest, sizeof(xc_cest_t), 
    491491                    ZESW(&stored_ce_ptr, NULL) 
     
    495495        } 
    496496    } 
    497     else if (zend_u_hash_add(CG(class_table), type, key, len, 
     497    else if (zend_u_hash_quick_add(CG(class_table), type, key, len, h, 
    498498                cest, sizeof(xc_cest_t), 
    499499                ZESW(&stored_ce_ptr, NULL) 
     
    541541#endif 
    542542 
    543 void xc_zend_class_add_ref(zend_class_entry ZESW(*ce, **ce)) 
    544 { 
    545 #ifdef ZEND_ENGINE_2 
    546     (*ce)->refcount++; 
    547 #else 
    548     (*ce->refcount)++; 
    549 #endif 
    550 } 
    551  
    552543xc_sandbox_t *xc_sandbox_init(xc_sandbox_t *sandbox, char *filename TSRMLS_DC) /* {{{ */ 
    553544{ 
     
    592583    { 
    593584        zend_function tmp_func; 
    594         zend_hash_copy(&TG(function_table), &XG(internal_function_table), (copy_ctor_func_t) function_add_ref, (void *) &tmp_func, sizeof(tmp_func)); 
     585        zend_hash_copy(&TG(function_table), &XG(internal_function_table), NULL, (void *) &tmp_func, sizeof(tmp_func)); 
    595586    } 
    596587    TG(internal_function_tail) = TG(function_table).pListTail; 
     
    601592    { 
    602593        xc_cest_t tmp_cest; 
    603         zend_hash_copy(&TG(class_table), &XG(internal_class_table), (copy_ctor_func_t) xc_zend_class_add_ref, (void *) &tmp_cest, sizeof(tmp_cest)); 
     594        zend_hash_copy(&TG(class_table), &XG(internal_class_table), NULL, (void *) &tmp_cest, sizeof(tmp_cest)); 
    604595    } 
    605596#endif 
     
    645636        zend_constant *c = (zend_constant*) b->pData; 
    646637        xc_install_constant(sandbox->filename, c, 
    647                 BUCKET_KEY_TYPE(b), ZSTR(BUCKET_KEY_S(b)), b->nKeyLength TSRMLS_CC); 
     638                BUCKET_KEY_TYPE(b), ZSTR(BUCKET_KEY_S(b)), b->nKeyLength, b->h TSRMLS_CC); 
    648639        b = b->pListNext; 
    649640    } 
     
    655646        zend_function *func = (zend_function*) b->pData; 
    656647        xc_install_function(sandbox->filename, func, 
    657                 BUCKET_KEY_TYPE(b), ZSTR(BUCKET_KEY_S(b)), b->nKeyLength TSRMLS_CC); 
     648                BUCKET_KEY_TYPE(b), ZSTR(BUCKET_KEY_S(b)), b->nKeyLength, b->h TSRMLS_CC); 
    658649        b = b->pListNext; 
    659650    } 
     
    663654    while (b != NULL) { 
    664655        xc_install_class(sandbox->filename, (xc_cest_t*) b->pData, -1, 
    665                 BUCKET_KEY_TYPE(b), ZSTR(BUCKET_KEY_S(b)), b->nKeyLength TSRMLS_CC); 
     656                BUCKET_KEY_TYPE(b), ZSTR(BUCKET_KEY_S(b)), b->nKeyLength, b->h TSRMLS_CC); 
    666657        b = b->pListNext; 
    667658    } 
  • branches/1.3/utils.h

    r600 r622  
    7272/* installer */ 
    7373#ifdef HAVE_XCACHE_CONSTANT 
    74 void xc_install_constant(char *filename, zend_constant *constant, zend_uchar type, zstr key, uint len TSRMLS_DC); 
     74void xc_install_constant(char *filename, zend_constant *constant, zend_uchar type, zstr key, uint len, ulong h TSRMLS_DC); 
    7575#endif 
    76 void xc_install_function(char *filename, zend_function *func, zend_uchar type, zstr key, uint len TSRMLS_DC); 
    77 ZESW(xc_cest_t *, void) xc_install_class(char *filename, xc_cest_t *cest, int oplineno, zend_uchar type, zstr key, uint len TSRMLS_DC); 
     76void xc_install_function(char *filename, zend_function *func, zend_uchar type, zstr key, uint len, ulong h TSRMLS_DC); 
     77ZESW(xc_cest_t *, void) xc_install_class(char *filename, xc_cest_t *cest, int oplineno, zend_uchar type, zstr key, uint len, ulong h TSRMLS_DC); 
    7878 
    7979/* sandbox */ 
  • branches/1.3/xcache-test.ini

    r234 r622  
    11auto_globals_jit = Off 
     2memory_limit = 256M 
    23 
    34[xcache] 
  • branches/1.3/xcache.c

    r620 r622  
    556556        xc_constinfo_t *ci = &p->constinfos[i]; 
    557557        xc_install_constant(xce->name.str.val, &ci->constant, 
    558                 UNISW(0, ci->type), ci->key, ci->key_size TSRMLS_CC); 
     558                UNISW(0, ci->type), ci->key, ci->key_size, ci->h TSRMLS_CC); 
    559559    } 
    560560#endif 
     
    564564        xc_funcinfo_t  *fi = &p->funcinfos[i]; 
    565565        xc_install_function(xce->name.str.val, &fi->func, 
    566                 UNISW(0, fi->type), fi->key, fi->key_size TSRMLS_CC); 
     566                UNISW(0, fi->type), fi->key, fi->key_size, fi->h TSRMLS_CC); 
    567567    } 
    568568 
     
    581581#endif 
    582582        xc_install_class(xce->name.str.val, &ci->cest, ci->oplineno, 
    583                 UNISW(0, ci->type), ci->key, ci->key_size TSRMLS_CC); 
     583                UNISW(0, ci->type), ci->key, ci->key_size, ci->h TSRMLS_CC); 
    584584    } 
    585585 
     
    590590        /* 
    591591        zend_auto_global *auto_global; 
    592         if (zend_u_hash_find(CG(auto_globals), aginfo->type, aginfo->key, aginfo->key_len+1, (void **) &auto_global)==SUCCESS) { 
     592        if (zend_u_hash_quick_find(CG(auto_globals), aginfo->type, aginfo->key, aginfo->key_len+1, aginfo->h, (void **) &auto_global)==SUCCESS) { 
    593593            if (auto_global->armed) { 
    594594                auto_global->armed = auto_global->auto_global_callback(auto_global->name, auto_global->name_len TSRMLS_CC); 
     
    10641064        }                                                     \ 
    10651065        data->key_size   = b->nKeyLength;                     \ 
     1066        data->h          = b->h;                              \ 
    10661067    }                                                         \ 
    10671068} while(0) 
     
    10961097                } 
    10971098                data->key_len = b->nKeyLength - 1; 
     1099                data->h       = b->h; 
    10981100            } 
    10991101        } 
     
    12661268/* }}} */ 
    12671269 
     1270#ifdef ZEND_ENGINE_2 
    12681271/* {{{ xc_gc_op_array_t */ 
    12691272typedef struct { 
     
    12771280    gc_op_array.num_args = op_array->num_args; 
    12781281    gc_op_array.arg_info = op_array->arg_info; 
     1282#ifdef ZEND_ENGINE_2 
    12791283    zend_hash_next_index_insert(&XG(gc_op_arrays), (void *) &gc_op_array, sizeof(gc_op_array), NULL); 
     1284#endif 
    12801285} 
    12811286/* }}} */ 
     
    12951300} 
    12961301/* }}} */ 
     1302#endif 
    12971303 
    12981304/* module helper function */ 
     
    15011507        zend_hash_destroy(&XG(internal_class_table)); 
    15021508 
    1503         zend_hash_init_ex(&XG(internal_function_table), 100, NULL, CG(function_table)->pDestructor, 1, 0); 
    1504         zend_hash_init_ex(&XG(internal_class_table),    10,  NULL, CG(class_table)->pDestructor,    1, 0); 
    1505  
    1506         zend_hash_copy(&XG(internal_function_table), CG(function_table), (copy_ctor_func_t) function_add_ref, &tmp_func, sizeof(tmp_func)); 
    1507         zend_hash_copy(&XG(internal_class_table), CG(class_table), (copy_ctor_func_t) xc_zend_class_add_ref, &tmp_cest, sizeof(tmp_cest)); 
     1509        zend_hash_init_ex(&XG(internal_function_table), 100, NULL, NULL, 1, 0); 
     1510        zend_hash_init_ex(&XG(internal_class_table),    10,  NULL, NULL, 1, 0); 
     1511 
     1512        zend_hash_copy(&XG(internal_function_table), CG(function_table), NULL, &tmp_func, sizeof(tmp_func)); 
     1513        zend_hash_copy(&XG(internal_class_table), CG(class_table), NULL, &tmp_cest, sizeof(tmp_cest)); 
    15081514 
    15091515        XG(internal_table_copied) = 1; 
     
    15231529    } 
    15241530 
     1531#ifdef ZEND_ENGINE_2 
    15251532    zend_hash_init(&XG(gc_op_arrays), 32, NULL, xc_gc_op_array, 0); 
     1533#endif 
    15261534 
    15271535#if PHP_API_VERSION <= 20041225 
     
    15391547{ 
    15401548    xc_entry_unholds(TSRMLS_C); 
     1549#ifdef ZEND_ENGINE_2 
    15411550    zend_hash_destroy(&XG(gc_op_arrays)); 
     1551#endif 
    15421552    xc_gc_expires_php(TSRMLS_C); 
    15431553    xc_gc_expires_var(TSRMLS_C); 
  • branches/1.3/xcache.h

    r619 r622  
    141141       zend_hash_add(ht, arKey, nKeyLength, pData, nDataSize, pDest) 
    142142 
     143#   define zend_u_hash_quick_add(ht, type, arKey, nKeyLength, h, pData, nDataSize, pDest) \ 
     144       zend_hash_quick_add(ht, arKey, nKeyLength, h, pData, nDataSize, pDest) 
     145 
    143146#   define zend_u_hash_update(ht, type, arKey, nKeyLength, pData, nDataSize, pDest) \ 
    144147       zend_hash_update(ht, arKey, nKeyLength, pData, nDataSize, pDest) 
     148 
     149#   define zend_u_hash_quick_update(ht, type, arKey, nKeyLength, h, pData, nDataSize, pDest) \ 
     150       zend_hash_quick_update(ht, arKey, nKeyLength, h, pData, nDataSize, pDest) 
    145151 
    146152#   define zend_u_hash_find(ht, type, arKey, nKeyLength, pData) \ 
     
    223229    zstr      key; 
    224230    zend_uint key_size; 
     231    ulong     h; 
    225232    xc_cest_t cest; 
    226233    int       oplineno; 
     
    235242    zstr      key; 
    236243    zend_uint key_size; 
     244    ulong     h; 
    237245    zend_constant constant; 
    238246} xc_constinfo_t; 
     
    246254    zstr      key; 
    247255    zend_uint key_size; 
     256    ulong     h; 
    248257    zend_function func; 
    249258} xc_funcinfo_t; 
     
    257266    zstr       key; 
    258267    zend_uint  key_len; 
     268    ulong      h; 
    259269} xc_autoglobal_t; 
    260270/* }}} */ 
  • branches/1.3/xcache_globals.h

    r619 r622  
    1818    zend_bool auth_enabled; 
    1919 
     20#ifdef ZEND_ENGINE_2 
    2021    HashTable gc_op_arrays; 
     22#endif 
    2123 
    2224    HashTable internal_function_table; 
Note: See TracChangeset for help on using the changeset viewer.