Changeset 103


Ignore:
Timestamp:
2006-08-27T07:09:02+02:00 (8 years ago)
Author:
moo
Message:

PHP_6: builds again with php6. update UChar/void ptr to zstr.

Location:
trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/processor/head.m4

    r94 r103  
    4747typedef zval *zval_ptr; 
    4848typedef zend_uchar zval_data_type; 
     49#ifdef IS_UNICODE 
     50typedef UChar zstr_uchar; 
     51#endif 
     52typedef char  zstr_char; 
    4953 
    5054#define MAX_DUP_STR_LEN 256 
     
    8286#endif 
    8387/* }}} */ 
     88/* {{{ xc_zstrlen_char */ 
     89static inline int xc_zstrlen_char(zstr s) 
     90{ 
     91    return strlen(ZSTR_S(s)); 
     92} 
     93/* }}} */ 
     94#ifdef IS_UNICODE 
     95/* {{{ xc_zstrlen_uchar */ 
     96static inline int xc_zstrlen_uchar(zstr s) 
     97{ 
     98    int i; 
     99    UChar *p = ZSTR_U(s); 
     100    for (i = 0; *p; i ++, p++) { 
     101        /* empty */ 
     102    } 
     103    return i; 
     104} 
     105/* }}} */ 
     106/* {{{ xc_zstrlen */ 
     107static inline int xc_zstrlen(int type, zstr s) 
     108{ 
     109    return type == IS_UNICODE ? xc_zstrlen_uchar(s) : xc_zstrlen_char(s); 
     110} 
     111/* }}} */ 
     112#else 
     113/* {{{ xc_zstrlen */ 
     114#define xc_zstrlen(dummy, s) xc_zstrlen_char(s) 
     115/* }}} */ 
     116#endif 
    84117/* {{{ xc_calc_string_n */ 
    85118REDEF(`KIND', `calc') 
    86 static inline void xc_calc_string_n(processor_t *processor, zend_uchar type, char *str, long size IFASSERT(`, int relayline')) { 
     119static inline void xc_calc_string_n(processor_t *processor, zend_uchar type, zstr str, long size IFASSERT(`, int relayline')) { 
    87120    pushdef(`__LINE__', `relayline') 
    88121    int realsize = UNISW(size, (type == IS_UNICODE) ? UBYTES(size) : size); 
     122    long dummy = 1; 
    89123 
    90124    if (realsize > MAX_DUP_STR_LEN) { 
    91125        ALLOC(, char, realsize) 
    92126    } 
    93     else if (zend_u_hash_add(&processor->strings, type, str, size, (void*)&str, sizeof(char*), NULL) == SUCCESS) { 
     127    else if (zend_u_hash_add(&processor->strings, type, str, size, (void *) &dummy, sizeof(dummy), NULL) == SUCCESS) { 
    94128        /* new string */ 
    95129        ALLOC(, char, realsize) 
     
    97131    IFASSERT(` 
    98132        else { 
    99             dnl fprintf(stderr, "dupstr %s\n", str); 
     133            dnl fprintf(stderr, "dupstr %s\n", ZSTR_S(str)); 
    100134        } 
    101135    ') 
     
    105139/* {{{ xc_store_string_n */ 
    106140REDEF(`KIND', `store') 
    107 static inline char *xc_store_string_n(processor_t *processor, zend_uchar type, char *str, long size IFASSERT(`, int relayline')) { 
     141static inline zstr xc_store_string_n(processor_t *processor, zend_uchar type, zstr str, long size IFASSERT(`, int relayline')) { 
    108142    pushdef(`__LINE__', `relayline') 
    109143    int realsize = UNISW(size, (type == IS_UNICODE) ? UBYTES(size) : size); 
    110     char *s; 
     144    zstr ret, *pret; 
    111145 
    112146    if (realsize > MAX_DUP_STR_LEN) { 
    113         ALLOC(s, char, realsize) 
    114         memcpy(s, str, realsize); 
    115     } 
    116     else if (zend_u_hash_find(&processor->strings, type, str, size, (void*)&s) != SUCCESS) { 
    117         /* new string */ 
    118         ALLOC(s, char, realsize) 
    119         memcpy(s, str, realsize); 
    120         zend_u_hash_add(&processor->strings, type, str, size, (void*)&s, sizeof(char*), NULL); 
    121     } 
    122     else { 
    123         s = *(char**)s; 
    124     } 
    125     return s; 
     147        ALLOC(ZSTR_V(ret), char, realsize) 
     148        memcpy(ZSTR_V(ret), ZSTR_V(str), realsize); 
     149        return ret; 
     150    } 
     151 
     152    if (zend_u_hash_find(&processor->strings, type, str, size, (void **) &pret) == SUCCESS) { 
     153        return *pret; 
     154    } 
     155 
     156    /* new string */ 
     157    ALLOC(ZSTR_V(ret), char, realsize) 
     158    memcpy(ZSTR_V(ret), ZSTR_V(str), realsize); 
     159    zend_u_hash_add(&processor->strings, type, str, size, (void *) &ret, sizeof(zstr), NULL); 
     160    return ret; 
     161 
    126162    popdef(`__LINE__') 
    127163} 
     
    185221    } 
    186222    else { 
     223dnl FIXME: handle common.function_name here 
    187224#define SET_IF_SAME_NAME(member) \ 
    188225        do { \ 
    189             if(!strcasecmp(zf->common.function_name, #member)) { \ 
     226            if (!strcasecmp(ZSTR_S(zf->common.function_name), #member)) { \ 
    190227                ce->member = zf; \ 
    191228            } \ 
  • trunk/processor/processor.m4

    r99 r103  
    1919DEF_STRUCT_P_FUNC(`zend_compiled_variable', , ` 
    2020    DISPATCH(int, name_len) 
    21     PROC_USTRING_L(, name, name_len) 
     21    PROC_ZSTRING_L(, name, name_len) 
    2222    DISPATCH(ulong, hash_value) 
    2323') 
     
    115115            case IS_UNICODE: 
    116116proc_unicode: 
    117                 DISPATCH(int32_t, value.ustr.len) 
    118                 PROC_USTRING_L(1, value.ustr.val, value.ustr.len) 
     117                DISPATCH(int32_t, value.uni.len) 
     118                PROC_ZSTRING_L(1, value.uni.val, value.uni.len) 
    119119                break; 
    120120#endif 
     
    200200DEF_STRUCT_P_FUNC(`zend_arg_info', , ` 
    201201    DISPATCH(zend_uint, name_len) 
    202     PROC_USTRING_L(, name, name_len) 
     202    PROC_ZSTRING_L(, name, name_len) 
    203203    DISPATCH(zend_uint, class_name_len) 
    204     PROC_USTRING_L(, class_name, class_name_len) 
     204    PROC_ZSTRING_L(, class_name, class_name_len) 
    205205    DISPATCH(zend_bool, array_type_hint) 
    206206    DISPATCH(zend_bool, allow_null) 
     
    216216    DISPATCH(int, flags) 
    217217    DISPATCH(uint, name_len) 
    218     PROC_STRING_L(name, name_len) 
     218    PROC_ZSTRING_L(, name, name_len) 
    219219    zstr name; 
    220220    DISPATCH(int, module_number) 
     
    248248    DISPATCH(zend_uint, flags) 
    249249    DISPATCH(int, name_length) 
    250     PROC_USTRING_L(, name, name_length) 
     250    PROC_ZSTRING_L(, name, name_length) 
    251251    DISPATCH(ulong, h) 
    252252#ifdef ZEND_ENGINE_2_1 
    253253    DISPATCH(int, doc_comment_len) 
    254     PROC_USTRING_L(, doc_comment, doc_comment_len) 
     254    PROC_STRING_L(doc_comment, doc_comment_len) 
    255255#endif 
    256256    dnl isnt in php6 yet 
     
    268268    DISPATCH(char, type) 
    269269    DISPATCH(zend_uint, name_length) 
    270     PROC_USTRING_L(, name, name_length) 
     270    PROC_ZSTRING_L(, name, name_length) 
    271271    IFRESTORE(` 
    272272#ifndef ZEND_ENGINE_2 
     
    344344#ifdef ZEND_ENGINE_2_1 
    345345    DISPATCH(zend_uint, doc_comment_len) 
    346     PROC_USTRING_L(, doc_comment, doc_comment_len) 
     346    PROC_STRING_L(doc_comment, doc_comment_len) 
    347347#endif 
    348348    /* # NOT DONE */ 
     
    370370#endif 
    371371    COPY(__call) 
    372 #ifdef IS_UNICODE 
    373     SETNULL(u_twin) 
    374 #endif 
    375372    /* # NOT DONE */ 
    376373    COPY(module) 
     
    498495    /* Common elements */ 
    499496    DISPATCH(zend_uchar, type) 
    500     PROC_USTRING(, function_name) 
     497    PROC_ZSTRING(, function_name) 
    501498#ifdef ZEND_ENGINE_2 
    502499    IFRESTORE(` 
     
    517514                 && zend_u_hash_find(&(processor->active_class_entry_dst->parent->function_table), 
    518515                        UG(unicode) ? IS_UNICODE : IS_STRING, 
    519                         src->function_name, strlen(src->function_name) + 1, 
     516                        src->function_name, xc_zstrlen(UG(unicode), src->function_name) + 1, 
    520517                        (void **) &parent) == SUCCESS) { 
    521518                    /* see do_inherit_method_check() */ 
     
    574571    /* END of common elements */ 
    575572#ifdef IS_UNICODE 
    576     SETNULL(u_twin) 
     573    dnl SETNULL(u_twin) 
    577574#endif 
    578575 
     
    632629    DISPATCH(zend_uint, line_end) 
    633630    DISPATCH(int, doc_comment_len) 
    634     PROC_USTRING_L(, doc_comment, doc_comment_len) 
     631    PROC_STRING_L(doc_comment, doc_comment_len) 
    635632#endif 
    636633 
     
    651648#endif 
    652649    IFRESTORE(`COPY(key)', ` 
    653         PROC_USTRING_N(type, key, key_size) 
     650        PROC_ZSTRING_N(type, key, key_size) 
    654651    ') 
    655652    STRUCT(zend_constant, constant) 
     
    663660#endif 
    664661    IFRESTORE(`COPY(key)', ` 
    665         PROC_USTRING_N(type, key, key_size) 
     662        PROC_ZSTRING_N(type, key, key_size) 
    666663    ') 
    667664    STRUCT(zend_function, func) 
     
    674671#endif 
    675672    IFRESTORE(`COPY(key)', ` 
    676         PROC_USTRING_N(type, key, key_size) 
     673        PROC_ZSTRING_N(type, key, key_size) 
    677674    ') 
    678675#ifdef ZEND_ENGINE_2 
     
    765762        DISPATCH(int, name.str.len) 
    766763#endif 
    767         IFRESTORE(`COPY(name.str.val)', `PROC_USTRING_L(name_type, name.str.val, name.str.len)') 
     764        IFRESTORE(`COPY(name.str.val)', ` 
     765#ifdef IS_UNICODE 
     766            PROC_ZSTRING_L(name_type, name.uni.val, name.uni.len) 
     767#else 
     768            PROC_STRING_L(name.str.val, name.str.len) 
     769#endif 
     770        ') 
    768771    ') 
    769772    DONE(name) 
  • trunk/processor/string.m4

    r100 r103  
    33define(`PROC_STRING_N_EX', ` 
    44    pushdef(`STRTYPE', `ifelse(`$5',,`char',`$5')') 
    5     pushdef(`ISTYPE', ifelse(STRTYPE,`char',IS_STRING,IS_UNICODE)) 
    6     if ($2 == NULL) { 
     5    pushdef(`PTRTYPE', ifelse( 
     6            STRTYPE, `char',      `char', 
     7            STRTYPE, `zstr_char', `char', 
     8            `',      `',          `UChar')) 
     9    pushdef(`ISTYPE', ifelse(STRTYPE,`zstr_uchar',IS_UNICODE,IS_STRING)) 
     10    pushdef(`UNI_STRLEN', ifelse( 
     11            STRTYPE, `zstr_uchar', `xc_zstrlen_uchar', 
     12            STRTYPE, `zstr_char',  `xc_zstrlen_char', 
     13            `',      `',           `strlen')) 
     14    pushdef(`SRCSTR', ifelse(STRTYPE,`char',`ZSTR($2)',`$2')) 
     15    pushdef(`SRCPTR', ifelse( 
     16            STRTYPE, `zstr_uchar', `ZSTR_U($2)', 
     17            STRTYPE, `zstr_char',  `ZSTR_S($2)', 
     18            `',      `',           `$2')) 
     19    pushdef(`DSTPTR', ifelse( 
     20            STRTYPE, `zstr_uchar', `ZSTR_U($1)', 
     21            STRTYPE, `zstr_char',  `ZSTR_S($1)', 
     22            `',      `',           `$1')) 
     23    if (SRCPTR == NULL) { 
    724        IFNOTMEMCPY(`IFCOPY(` 
    8             $1 = NULL; 
     25            DSTPTR = NULL; 
    926        ')') 
    1027        IFDASM(` 
     
    1431    else { 
    1532        IFDPRINT(`INDENT() 
    16             ifelse(STRTYPE, `UChar', ` 
     33            ifelse(STRTYPE, `zstr_uchar', ` 
    1734#ifdef IS_UNICODE 
    1835            do { 
     
    3249#endif 
    3350            ', ` 
    34             fprintf(stderr, "string:%s:\t\"%s\" len=%d\n", "$1", $2, $3 - 1); 
     51            fprintf(stderr, "string:%s:\t\"%s\" len=%d\n", "$1", SRCPTR, $3 - 1); 
    3552            ') 
    3653        ') 
    37         IFCALC(`xc_calc_string_n(processor, ISTYPE, (void *) $2, `$3' IFASSERT(`, __LINE__'));') 
    38         IFSTORE(`$1 = (STRTYPE *) xc_store_string_n(processor, ISTYPE, (char *) $2, `$3' IFASSERT(`, __LINE__'));') 
     54        IFCALC(`xc_calc_string_n(processor, ISTYPE, SRCSTR, $3 IFASSERT(`, __LINE__'));') 
     55        IFSTORE(`DSTPTR = ifelse(PTRTYPE,`char',`ZSTR_S',`ZSTR_U')(xc_store_string_n(processor, ISTYPE, SRCSTR, $3 IFASSERT(`, __LINE__')));') 
    3956        IFRESTORE(` 
    40             ALLOC(`$1', `STRTYPE', `($3)') 
    41             memcpy($1, $2, sizeof(STRTYPE) * ($3)); 
     57            ALLOC(DSTPTR, `STRTYPE', `($3)') 
     58            memcpy(DSTPTR, SRCPTR, sizeof(STRTYPE) * ($3)); 
    4259        ') 
    43         FIXPOINTER_EX(`STRTYPE', `$1') 
     60        FIXPOINTER_EX(`PTRTYPE', DSTPTR) 
    4461        IFDASM(` 
    45                 ifelse(STRTYPE,UChar, ` 
     62                ifelse(STRTYPE,zstr_uchar, ` 
    4663                    add_assoc_unicodel_ex(dst, ZEND_STRS("$4"), $2, $3-1, 1); 
    4764                    ', ` dnl else 
     
    4966                ') 
    5067    } 
     68    popdef(`DSTPTR') 
     69    popdef(`SRCPTR') 
     70    popdef(`SRCSTR') 
     71    popdef(`UNI_STRLEN') 
    5172    popdef(`STRTYPE') 
    5273    popdef(`ISTYPE') 
     
    5980define(`PROC_STRING',   `DBG(`$0($*)') DONE(`$1')`'PROC_STRING_N_EX(`dst->$1', `src->$1', `strlen(src->$1) + 1', `$1', `char')') 
    6081 
    61 dnl {{{ PROC_USTRING_N(1:type, 2:name, 3:size, 4:size_type) 
    62 define(`PROC_USTRING_N', ` 
     82dnl {{{ PROC_ZSTRING_N(1:type, 2:name, 3:size, 4:size_type) 
     83define(`PROC_ZSTRING_N', ` 
    6384    DBG(`$0($*)') 
    6485#ifdef IS_UNICODE 
    6586    pushdef(`NSIZE', ifelse( 
    66             `$4', `strlen', `strlen(src->$2) + 1', 
     87            `$4', `strlen', `UNI_STRLEN (src->$2) + 1', 
    6788            `$4', `len',    `src->$3 + 1', 
    6889            `',   `',       `src->$3', 
    6990            )) 
    7091    DONE(`$2') 
    71     ifelse(`$1', `1', `PROC_STRING_N_EX(`dst->$2', `src->$2', NSIZE, `$2', `UChar') 
     92    ifelse(`$1', `1', `PROC_STRING_N_EX(`dst->$2', `src->$2', defn(`NSIZE'), `$2', `zstr_uchar') 
    7293    ', ` 
    73         if (ifelse(`$1', `', `UG(unicode)', `src->$1')) { 
    74             PROC_STRING_N_EX(`dst->$2', `src->$2', NSIZE, `$2', `UChar') 
     94        if (ifelse(`$1', `', `UG(unicode)', `src->$1 == IS_UNICODE')) { 
     95            PROC_STRING_N_EX(`dst->$2', `src->$2', defn(`NSIZE'), `$2', `zstr_uchar') 
    7596        } 
    7697        else { 
    77             PROC_STRING_N_EX(`dst->$2', `src->$2', NSIZE, `$2', `char') 
     98            PROC_STRING_N_EX(`dst->$2', `src->$2', defn(`NSIZE'), `$2', `zstr_char') 
    7899        } 
    79100    ') 
    80101#else 
    81102    DONE(`$2') 
    82     PROC_STRING_N_EX(`dst->$2', `src->$2', NSIZE, `$2', `char') 
     103    PROC_STRING_N_EX(`dst->$2', `src->$2', NSIZE, `$2', `zstr_char') 
    83104#endif 
    84105    popdef(`NSIZE') 
    85106') 
    86107// }}} 
    87 define(`PROC_USTRING_L', `DBG(`$0($*)') PROC_USTRING_N(`$1', `$2', `$3', `len')') 
    88 define(`PROC_USTRING', `DBG(`$0($*)') PROC_USTRING_N(`$1', `$2', , `strlen')') 
     108define(`PROC_ZSTRING_L', `DBG(`$0($*)') PROC_ZSTRING_N(`$1', `$2', `$3', `len')') 
     109define(`PROC_ZSTRING', `DBG(`$0($*)') PROC_ZSTRING_N(`$1', `$2', , `strlen')') 
  • trunk/utils.c

    r95 r103  
    266266 
    267267#ifdef HAVE_XCACHE_CONSTANT 
    268 void xc_install_constant(char *filename, zend_constant *constant, zend_uchar type, void *key, uint len TSRMLS_DC) /* {{{ */ 
     268void xc_install_constant(char *filename, zend_constant *constant, zend_uchar type, zstr key, uint len TSRMLS_DC) /* {{{ */ 
    269269{ 
    270270    if (zend_u_hash_add(EG(zend_constants), type, key, len, 
     
    275275        CG(compiled_filename) = filename; 
    276276        CG(zend_lineno) = 0; 
     277#ifdef IS_UNICODE 
     278        zend_error(E_NOTICE, "Constant %R already defined", type, key); 
     279#else 
    277280        zend_error(E_NOTICE, "Constant %s already defined", key); 
    278         free(constant->name); 
     281#endif 
     282        free(ZSTR_V(constant->name)); 
    279283        if (!(constant->flags & CONST_PERSISTENT)) { 
    280284            zval_dtor(&constant->value); 
     
    284288/* }}} */ 
    285289#endif 
    286 void xc_install_function(char *filename, zend_function *func, zend_uchar type, void *key, uint len TSRMLS_DC) /* {{{ */ 
    287 { 
     290void xc_install_function(char *filename, zend_function *func, zend_uchar type, zstr key, uint len TSRMLS_DC) /* {{{ */ 
     291{ 
     292    zend_bool istmpkey; 
     293 
    288294    if (func->type == ZEND_USER_FUNCTION) { 
    289         if (*(char *) key == '\0') { 
     295#ifdef IS_UNICODE 
     296        istmpkey = (type == IS_STRING && ZSTR_S(key)[0] == 0) || ZSTR_U(key)[0] == 0; 
     297#else 
     298        istmpkey = ZSTR_S(key)[0] == 0; 
     299#endif 
     300        if (istmpkey) { 
    290301            zend_u_hash_update(CG(function_table), type, key, len, 
    291302                        func, sizeof(zend_op_array), 
     
    300311            CG(compiled_filename) = filename; 
    301312            CG(zend_lineno) = ZESW(func->op_array.opcodes[0].lineno, func->op_array.line_start); 
     313#ifdef IS_UNICODE 
     314            zend_error(E_ERROR, "Cannot redeclare %R()", type, key); 
     315#else 
    302316            zend_error(E_ERROR, "Cannot redeclare %s()", key); 
    303         } 
    304     } 
    305 } 
    306 /* }}} */ 
    307 ZESW(xc_cest_t *, void) xc_install_class(char *filename, xc_cest_t *cest, zend_uchar type, void *key, uint len TSRMLS_DC) /* {{{ */ 
    308 { 
     317#endif 
     318        } 
     319    } 
     320} 
     321/* }}} */ 
     322ZESW(xc_cest_t *, void) xc_install_class(char *filename, xc_cest_t *cest, zend_uchar type, zstr key, uint len TSRMLS_DC) /* {{{ */ 
     323{ 
     324    zend_bool istmpkey; 
    309325    zend_class_entry *cep = CestToCePtr(*cest); 
    310326    ZESW(void *stored_ce_ptr, NOTHING); 
    311327 
    312     if (*(char *) key == '\0') { 
     328#ifdef IS_UNICODE 
     329    istmpkey = (type == IS_STRING && ZSTR_S(key)[0] == 0) || ZSTR_U(key)[0] == 0; 
     330#else 
     331    istmpkey = ZSTR_S(key)[0] == 0; 
     332#endif 
     333    if (istmpkey) { 
    313334        zend_u_hash_update(CG(class_table), type, key, len, 
    314335                    cest, sizeof(xc_cest_t), 
     
    323344        CG(compiled_filename) = filename; 
    324345        CG(zend_lineno) = ZESW(0, cep->line_start); 
    325         zend_error(E_ERROR, "Cannot redeclare class %s", (char *) cep->name); 
     346#ifdef IS_UNICODE 
     347        zend_error(E_ERROR, "Cannot redeclare class %R", type, cep->name); 
     348#else 
     349        zend_error(E_ERROR, "Cannot redeclare class %s", cep->name); 
     350#endif 
    326351    } 
    327352    ZESW(return (xc_cest_t *) stored_ce_ptr, NOTHING); 
     
    338363static void xc_constant_copy_ctor(zend_constant *c) /* {{{ */ 
    339364{ 
    340     c->name = zend_strndup(c->name, c->name_len - 1); 
     365#ifdef IS_UNICODE 
     366    if (UG(unicode)) { 
     367        ZSTR_U(c->name) = zend_ustrndup(ZSTR_U(c->name), c->name_len - 1); 
     368    } 
     369    else 
     370#endif 
     371    { 
     372        ZSTR_S(c->name) = zend_strndup(ZSTR_S(c->name), c->name_len - 1); 
     373    } 
    341374    if (!(c->flags & CONST_PERSISTENT)) { 
    342375        zval_copy_ctor(&c->value); 
     
    401434        zend_constant *c = (zend_constant*) b->pData; 
    402435        xc_install_constant(sandbox->filename, c, 
    403                 BUCKET_KEY_TYPE(b), BUCKET_KEY(b), b->nKeyLength TSRMLS_CC); 
     436                BUCKET_KEY_TYPE(b), ZSTR(BUCKET_KEY(b)), b->nKeyLength TSRMLS_CC); 
    404437        b = b->pListNext; 
    405438    } 
     
    411444        zend_function *func = (zend_function*) b->pData; 
    412445        xc_install_function(sandbox->filename, func, 
    413                 BUCKET_KEY_TYPE(b), BUCKET_KEY(b), b->nKeyLength TSRMLS_CC); 
     446                BUCKET_KEY_TYPE(b), ZSTR(BUCKET_KEY(b)), b->nKeyLength TSRMLS_CC); 
    414447        b = b->pListNext; 
    415448    } 
     
    419452    while (b != NULL) { 
    420453        xc_install_class(sandbox->filename, (xc_cest_t*)b->pData, 
    421                 BUCKET_KEY_TYPE(b), BUCKET_KEY(b), b->nKeyLength TSRMLS_CC); 
     454                BUCKET_KEY_TYPE(b), ZSTR(BUCKET_KEY(b)), b->nKeyLength TSRMLS_CC); 
    422455        b = b->pListNext; 
    423456    } 
  • trunk/utils.h

    r95 r103  
    2727/* installer */ 
    2828#ifdef HAVE_XCACHE_CONSTANT 
    29 void xc_install_constant(char *filename, zend_constant *constant, zend_uchar type, void *key, uint len TSRMLS_DC); 
     29void xc_install_constant(char *filename, zend_constant *constant, zend_uchar type, zstr key, uint len TSRMLS_DC); 
    3030#endif 
    31 void xc_install_function(char *filename, zend_function *func, zend_uchar type, void *key, uint len TSRMLS_DC); 
    32 ZESW(xc_cest_t *, void) xc_install_class(char *filename, xc_cest_t *cest, zend_uchar type, void *key, uint len TSRMLS_DC); 
     31void xc_install_function(char *filename, zend_function *func, zend_uchar type, zstr key, uint len TSRMLS_DC); 
     32ZESW(xc_cest_t *, void) xc_install_class(char *filename, xc_cest_t *cest, zend_uchar type, zstr key, uint len TSRMLS_DC); 
    3333 
    3434/* sandbox */ 
  • trunk/xcache.c

    r96 r103  
    503503static inline xc_hash_value_t xc_entry_hash_var(xc_entry_t *xce) /* {{{ */ 
    504504{ 
    505     return UNISW(NOTHING, UG(unicode) ? HASH_USTR_L(xce->name_type, (char *)xce->name.ustr.val, xce->name.ustr.len) :) 
     505    return UNISW(NOTHING, UG(unicode) ? HASH_USTR_L(xce->name_type, xce->name.uni.val, xce->name.uni.len) :) 
    506506        HASH_STR_L(xce->name.str.val, xce->name.str.len); 
    507507} 
     
    761761        memcpy(&data->name, b->pData, sizeof(datatype));      \ 
    762762        UNISW(NOTHING, data->type = b->key.type;)             \ 
    763         data->key        = BUCKET_KEY(b);                     \ 
     763        if (UNISW(1, b->key.type == IS_STRING)) {             \ 
     764            ZSTR_S(data->key)      = BUCKET_KEY(b);           \ 
     765        }                                                     \ 
     766        else {                                                \ 
     767            ZSTR_U(data->key)      = BUCKET_UKEY(b);          \ 
     768        }                                                     \ 
    764769        data->key_size   = b->nKeyLength;                     \ 
    765770    }                                                         \ 
  • trunk/xcache.h

    r95 r103  
    5252                : b->nKeyLength \ 
    5353                )) 
    54 #define BUCKET_KEY(b) (UNISW((b)->arKey, (b)->key.u.string)) 
    55 #define BUCKET_UKEY(b) (UNISW((b)->arKey, (b)->key.u.unicode)) 
     54#define BUCKET_KEY(b)  (UNISW((b)->arKey, (b)->key.arKey.s)) 
     55#define BUCKET_UKEY(b) (UNISW((b)->arKey, (b)->key.arKey.u)) 
    5656#define BUCKET_KEY_TYPE(b) (UNISW(0, (b)->key.type)) 
    5757#ifdef IS_UNICODE 
     
    6464#ifndef IS_UNICODE 
    6565typedef char *zstr; 
    66 #   define ZSTR_S(s) (s) 
    67 #   define ZSTR_U(s) (s) 
    68 #   define ZSTR_V(s) (s) 
    69 #else 
    70 #   define ZSTR_S(s) ((s)->s) 
    71 #   define ZSTR_U(s) ((s)->u) 
    72 #   define ZSTR_V(s) ((s)->v) 
     66#   define ZSTR_S(s)     (s) 
     67#   define ZSTR_U(s)     (s) 
     68#   define ZSTR_V(s)     (s) 
     69#   define ZSTR_PS(s)    (s) 
     70#   define ZSTR_PU(s)    (s) 
     71#   define ZSTR_PV(s)    (s) 
     72#else 
     73#   define ZSTR_S(zs)    ((zs).s) 
     74#   define ZSTR_U(zs)    ((zs).u) 
     75#   define ZSTR_V(zs)    ((zs).v) 
     76#   define ZSTR_PS(pzs)  ((pzs)->s) 
     77#   define ZSTR_PU(pzs)  ((pzs)->u) 
     78#   define ZSTR_PV(pzs)  ((pzs)->v) 
     79#endif 
     80 
     81#ifndef ZSTR 
     82#   define ZSTR(s)      (s) 
     83#endif 
     84 
     85#ifndef Z_UNIVAL 
     86#   define Z_UNIVAL(zval) (zval).value.str.val 
     87#   define Z_UNILEN(zval) (zval).value.str.len 
    7388#endif 
    7489 
     
    149164    zend_uchar type; 
    150165#endif 
    151     char *key; 
     166    zstr      key; 
    152167    zend_uint key_size; 
    153168    xc_cest_t cest; 
     
    160175    zend_uchar type; 
    161176#endif 
    162     char *key; 
     177    zstr      key; 
    163178    zend_uint key_size; 
    164179    zend_constant constant; 
     
    171186    zend_uchar type; 
    172187#endif 
    173     char *key; 
     188    zstr      key; 
    174189    zend_uint key_size; 
    175190    zend_function func; 
Note: See TracChangeset for help on using the changeset viewer.