Changeset 103 in svn


Ignore:
Timestamp:
2006-08-27T07:09:02+02:00 (9 years ago)
Author:
Xuefer
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.