Changeset 1397


Ignore:
Timestamp:
Jun 28, 2007 12:50:10 AM (12 years ago)
Author:
bennylp
Message:

Fixed ticket #348: various bugs in string comparison functions

Location:
pjproject/trunk/pjlib
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • pjproject/trunk/pjlib/include/pj/string.h

    r1210 r1397  
    342342 
    343343/** 
    344  * Perform lowercase comparison to the strings. 
     344 * Perform case-insensitive comparison to the strings. 
    345345 * 
    346346 * @param str1      The string to compare. 
     
    399399 
    400400/** 
    401  * Perform lowercase comparison to the strings. 
     401 * Perform case-insensitive comparison to the strings. 
    402402 * 
    403403 * @param str1      The string to compare. 
     
    412412 
    413413/** 
    414  * Perform lowercase comparison to the strings. 
     414 * Perform case-insensitive comparison to the strings. 
    415415 * 
    416416 * @param str1      The string to compare. 
     
    427427 
    428428/** 
    429  * Perform lowercase comparison to the strings. 
     429 * Perform case-insensitive comparison to the strings. 
    430430 * 
    431431 * @param str1      The string to compare. 
  • pjproject/trunk/pjlib/include/pj/string_i.h

    r974 r1397  
    136136PJ_IDEF(int) pj_strcmp( const pj_str_t *str1, const pj_str_t *str2) 
    137137{ 
    138     pj_ssize_t diff; 
    139  
    140     diff = str1->slen - str2->slen; 
    141     if (diff) { 
    142         return diff > 0 ? 1 : -1; 
    143     } else if (str1->ptr && str1->slen) { 
    144         return memcmp(str1->ptr, str2->ptr, str1->slen); 
    145     } else { 
    146         return 0; 
     138    if (str1->slen == 0) { 
     139        return str2->slen==0 ? 0 : -1; 
     140    } else if (str2->slen == 0) { 
     141        return 1; 
     142    } else { 
     143        int min = (str1->slen < str2->slen)? str1->slen : str2->slen; 
     144        int res = pj_memcmp(str1->ptr, str2->ptr, min); 
     145        if (res == 0) { 
     146            return (str1->slen < str2->slen) ? -1 : 
     147                    (str1->slen == str2->slen ? 0 : 1); 
     148        } else { 
     149            return res; 
     150        } 
    147151    } 
    148152} 
     
    151155                         pj_size_t len) 
    152156{ 
    153     if (str1->ptr && str2->ptr) 
    154         return memcmp(str1->ptr, str2->ptr, len); 
    155     else if (str2->ptr) 
    156         return str2->slen==0 ? 0 : -1; 
    157     else if (str1->ptr) 
    158         return str1->slen==0 ? 0 : 1; 
    159     else 
    160         return 0; 
     157    pj_str_t copy1, copy2; 
     158 
     159    if (len < (unsigned)str1->slen) { 
     160        copy1.ptr = str1->ptr; 
     161        copy1.slen = len; 
     162        str1 = &copy1; 
     163    } 
     164 
     165    if (len < (unsigned)str2->slen) { 
     166        copy2.ptr = str2->ptr; 
     167        copy2.slen = len; 
     168        str2 = &copy2; 
     169    } 
     170 
     171    return pj_strcmp(str1, str2); 
    161172} 
    162173 
     
    164175                          pj_size_t len) 
    165176{ 
    166     if (len == 0)  
    167         return 0; 
    168     else if (str1->ptr && str2) 
    169         return memcmp(str1->ptr, str2, len); 
    170     else if (str1->ptr) 
    171         return str1->slen==0 ? 0 : 1; 
    172     else if (str2) 
    173         return *str2=='\0' ? 0 : -1; 
    174     else 
    175         return 0; 
     177    pj_str_t copy2; 
     178 
     179    if (str2) { 
     180        copy2.ptr = (char*)str2; 
     181        copy2.slen = pj_ansi_strlen(str2); 
     182    } else { 
     183        copy2.slen = 0; 
     184    } 
     185 
     186    return pj_strncmp(str1, &copy2, len); 
    176187} 
    177188 
    178189PJ_IDEF(int) pj_strcmp2( const pj_str_t *str1, const char *str2 ) 
    179190{ 
     191    pj_str_t copy2; 
     192 
     193    if (str2) { 
     194        copy2.ptr = (char*)str2; 
     195        copy2.slen = pj_ansi_strlen(str2); 
     196    } else { 
     197        copy2.slen = 0; 
     198    } 
     199 
     200    return pj_strcmp(str1, &copy2); 
     201} 
     202 
     203PJ_IDEF(int) pj_stricmp( const pj_str_t *str1, const pj_str_t *str2) 
     204{ 
    180205    if (str1->slen == 0) { 
    181         return (!str2 || *str2=='\0') ? 0 : -1; 
    182     } else 
    183         return pj_strncmp2( str1, str2, str1->slen); 
    184 } 
    185  
    186 PJ_IDEF(int) pj_stricmp( const pj_str_t *str1, const pj_str_t *str2) 
    187 { 
    188     register int len = str1->slen; 
    189     if (len != str2->slen) { 
    190         return (int)(len - str2->slen); 
    191     } else if (len == 0) { 
    192         return 0; 
    193     } else { 
    194         return pj_ansi_strnicmp(str1->ptr, str2->ptr, len); 
     206        return str2->slen==0 ? 0 : -1; 
     207    } else if (str2->slen == 0) { 
     208        return 1; 
     209    } else { 
     210        int min = (str1->slen < str2->slen)? str1->slen : str2->slen; 
     211        int res = pj_ansi_strnicmp(str1->ptr, str2->ptr, min); 
     212        if (res == 0) { 
     213            return (str1->slen < str2->slen) ? -1 : 
     214                    (str1->slen == str2->slen ? 0 : 1); 
     215        } else { 
     216            return res; 
     217        } 
    195218    } 
    196219} 
     
    269292PJ_IDEF(int) pj_stricmp2( const pj_str_t *str1, const char *str2) 
    270293{ 
    271     if (str1->ptr && str2) 
    272         return pj_ansi_strnicmp(str1->ptr, str2, str1->slen); 
    273     else if (str2) 
    274         return (*str2=='\0') ? 0 : -1; 
    275     else if (str1->ptr) 
    276         return (str1->slen==0) ? 0 : 1; 
    277     else 
    278         return 0; 
     294    pj_str_t copy2; 
     295 
     296    if (str2) { 
     297        copy2.ptr = (char*)str2; 
     298        copy2.slen = pj_ansi_strlen(str2); 
     299    } else { 
     300        copy2.slen = 0; 
     301    } 
     302 
     303    return pj_stricmp(str1, &copy2); 
    279304} 
    280305 
     
    282307                          pj_size_t len) 
    283308{ 
    284     if (str1->ptr && str2->ptr) 
    285         return pj_ansi_strnicmp(str1->ptr, str2->ptr, len); 
    286     else if (str2->ptr) 
    287         return str2->slen==0 ? 0 : -1; 
    288     else if (str1->ptr) 
    289         return str1->slen==0 ? 0 : 1; 
    290     else 
    291         return 0; 
     309    pj_str_t copy1, copy2; 
     310 
     311    if (len < (unsigned)str1->slen) { 
     312        copy1.ptr = str1->ptr; 
     313        copy1.slen = len; 
     314        str1 = &copy1; 
     315    } 
     316 
     317    if (len < (unsigned)str2->slen) { 
     318        copy2.ptr = str2->ptr; 
     319        copy2.slen = len; 
     320        str2 = &copy2; 
     321    } 
     322 
     323    return pj_stricmp(str1, str2); 
    292324} 
    293325 
     
    295327                           pj_size_t len) 
    296328{ 
    297     if (len == 0)  
    298         return 0; 
    299     else if (str1->ptr && str2) 
    300         return pj_ansi_strnicmp(str1->ptr, str2, len); 
    301     else if (str1->ptr) 
    302         return str1->slen==0 ? 0 : 1; 
    303     else if (str2) 
    304         return *str2=='\0' ? 0 : -1; 
    305     else 
    306         return 0; 
    307  
     329    pj_str_t copy2; 
     330 
     331    if (str2) { 
     332        copy2.ptr = (char*)str2; 
     333        copy2.slen = pj_ansi_strlen(str2); 
     334    } else { 
     335        copy2.slen = 0; 
     336    } 
     337 
     338    return pj_strnicmp(str1, &copy2, len); 
    308339} 
    309340 
     
    318349PJ_IDEF(void) pj_strcat2(pj_str_t *dst, const char *str) 
    319350{ 
    320     unsigned len = pj_ansi_strlen(str); 
     351    unsigned len = str? pj_ansi_strlen(str) : 0; 
    321352    if (len) { 
    322353        pj_memcpy(dst->ptr + dst->slen, str, len); 
  • pjproject/trunk/pjlib/src/pjlib-test/string.c

    r1266 r1397  
    7272PJ_INLINE(int) cmp(const char *expr, int i, int j) 
    7373{ 
    74     i = !((i>0 && j>0) || (i<0 && j<0) || (i==0 && j==0)); 
    75     if (i) { 
     74    int r = !((i>0 && j>0) || (i<0 && j<0) || (i==0 && j==0)); 
     75    if (r) { 
    7676        PJ_LOG(3,(THIS_FILE,"   error: %s: expecting %d, got %d", expr, j, i)); 
    7777    } 
    78     return i; 
     78    return r; 
    7979} 
    8080#else 
     
    9595 * pj_strnicmp2(). 
    9696 */ 
    97 #define STRTEST(res,S1,S2,code) \ 
     97#define STRTEST(res,res2,S1,S2,code)    \ 
    9898            do { \ 
    9999                s1.ptr=S1; s1.slen=(S1)?len:0; \ 
     
    109109                pj_sub_timestamp(&t2, &t1); \ 
    110110                pj_add_timestamp(&e2, &t2); \ 
    111                 if (C(pj_stricmp2(&s1,S2),res)) return code*10; \ 
     111                if (C(pj_stricmp2(&s1,S2),res2)) return code*10; \ 
    112112                if (C(pj_strnicmp(&s1,&s2,len),res)) return code*100; \ 
    113113                if (C(pj_strnicmp2(&s1,S2,len),res)) return code*1000; \ 
     
    128128    /* Compare empty strings. */ 
    129129    len=0; 
    130     STRTEST( 0, "","",-500); 
    131     STRTEST( 0, SNULL,"",-502); 
    132     STRTEST( 0, "",SNULL,-504); 
    133     STRTEST( 0, SNULL,SNULL,-506); 
    134     STRTEST( 0, "hello","world",-508); 
     130    STRTEST( 0, 0, "","",-500); 
     131    STRTEST( 0, 0, SNULL,"",-502); 
     132    STRTEST( 0, 0, "",SNULL,-504); 
     133    STRTEST( 0, 0, SNULL,SNULL,-506); 
     134    STRTEST( 0, -1, "hello","world",-508); 
    135135 
    136136    /* equal, length=1  
     
    139139    buf = "a""A"; 
    140140    len=1; 
    141     STRTEST( 0, "a",buf+0,-510); 
    142     STRTEST( 0, "a",buf+1,-512); 
    143     STRTEST( -1, "O", "P", -514); 
    144     STRTEST(-1, SNULL, "a", -516); 
    145     STRTEST(1, "a", SNULL, -518); 
     141    STRTEST( 0,  -1, "a",buf+0,-510); 
     142    STRTEST( 0,  0, "a",buf+1,-512); 
     143    STRTEST(-1, -1, "O", "P", -514); 
     144    STRTEST(-1, -1, SNULL, "a", -516); 
     145    STRTEST( 1,  1, "a", SNULL, -518); 
    146146 
    147147    /* equal, length=2  
     
    150150    buf = "aa""Aa""aA""AA"; 
    151151    len=2; 
    152     STRTEST( 0, "aa",buf+0,-520); 
    153     STRTEST( 0, "aa",buf+2,-522); 
    154     STRTEST( 0, "aa",buf+4,-524); 
    155     STRTEST( 0, "aa",buf+6,-524); 
     152    STRTEST( 0, -1, "aa",buf+0,-520); 
     153    STRTEST( 0, -1, "aa",buf+2,-522); 
     154    STRTEST( 0, -1, "aa",buf+4,-524); 
     155    STRTEST( 0, 0, "aa",buf+6,-524); 
    156156 
    157157    /* equal, length=3  
     
    160160    buf = "aaa""Aaa""aAa""aaA""AAa""aAA""AaA""AAA"; 
    161161    len=3; 
    162     STRTEST( 0, "aaa",buf+0,-530); 
    163     STRTEST( 0, "aaa",buf+3,-532); 
    164     STRTEST( 0, "aaa",buf+6,-534); 
    165     STRTEST( 0, "aaa",buf+9,-536); 
    166     STRTEST( 0, "aaa",buf+12,-538); 
    167     STRTEST( 0, "aaa",buf+15,-540); 
    168     STRTEST( 0, "aaa",buf+18,-542); 
    169     STRTEST( 0, "aaa",buf+21,-534); 
     162    STRTEST( 0, -1, "aaa",buf+0,-530); 
     163    STRTEST( 0, -1, "aaa",buf+3,-532); 
     164    STRTEST( 0, -1, "aaa",buf+6,-534); 
     165    STRTEST( 0, -1, "aaa",buf+9,-536); 
     166    STRTEST( 0, -1, "aaa",buf+12,-538); 
     167    STRTEST( 0, -1, "aaa",buf+15,-540); 
     168    STRTEST( 0, -1, "aaa",buf+18,-542); 
     169    STRTEST( 0, 0, "aaa",buf+21,-534); 
    170170 
    171171    /* equal, length=4 */ 
    172172    len=4; 
    173     STRTEST( 0, "aaaa","aaaa",-540); 
    174     STRTEST( 0, "aaaa","Aaaa",-542); 
    175     STRTEST( 0, "aaaa","aAaa",-544); 
    176     STRTEST( 0, "aaaa","aaAa",-546); 
    177     STRTEST( 0, "aaaa","aaaA",-548); 
    178     STRTEST( 0, "aaaa","AAaa",-550); 
    179     STRTEST( 0, "aaaa","aAAa",-552); 
    180     STRTEST( 0, "aaaa","aaAA",-554); 
    181     STRTEST( 0, "aaaa","AaAa",-556); 
    182     STRTEST( 0, "aaaa","aAaA",-558); 
    183     STRTEST( 0, "aaaa","AaaA",-560); 
    184     STRTEST( 0, "aaaa","AAAa",-562); 
    185     STRTEST( 0, "aaaa","aAAA",-564); 
    186     STRTEST( 0, "aaaa","AAaA",-566); 
    187     STRTEST( 0, "aaaa","AaAA",-568); 
    188     STRTEST( 0, "aaaa","AAAA",-570); 
     173    STRTEST( 0, 0, "aaaa","aaaa",-540); 
     174    STRTEST( 0, 0, "aaaa","Aaaa",-542); 
     175    STRTEST( 0, 0, "aaaa","aAaa",-544); 
     176    STRTEST( 0, 0, "aaaa","aaAa",-546); 
     177    STRTEST( 0, 0, "aaaa","aaaA",-548); 
     178    STRTEST( 0, 0, "aaaa","AAaa",-550); 
     179    STRTEST( 0, 0, "aaaa","aAAa",-552); 
     180    STRTEST( 0, 0, "aaaa","aaAA",-554); 
     181    STRTEST( 0, 0, "aaaa","AaAa",-556); 
     182    STRTEST( 0, 0, "aaaa","aAaA",-558); 
     183    STRTEST( 0, 0, "aaaa","AaaA",-560); 
     184    STRTEST( 0, 0, "aaaa","AAAa",-562); 
     185    STRTEST( 0, 0, "aaaa","aAAA",-564); 
     186    STRTEST( 0, 0, "aaaa","AAaA",-566); 
     187    STRTEST( 0, 0, "aaaa","AaAA",-568); 
     188    STRTEST( 0, 0, "aaaa","AAAA",-570); 
    189189 
    190190    /* equal, length=5 */ 
    191191    buf = "aaaAa""AaaaA""AaAaA""AAAAA"; 
    192192    len=5; 
    193     STRTEST( 0, "aaaaa",buf+0,-580); 
    194     STRTEST( 0, "aaaaa",buf+5,-582); 
    195     STRTEST( 0, "aaaaa",buf+10,-584); 
    196     STRTEST( 0, "aaaaa",buf+15,-586); 
     193    STRTEST( 0, -1, "aaaaa",buf+0,-580); 
     194    STRTEST( 0, -1, "aaaaa",buf+5,-582); 
     195    STRTEST( 0, -1, "aaaaa",buf+10,-584); 
     196    STRTEST( 0, 0, "aaaaa",buf+15,-586); 
    197197 
    198198    /* not equal, length=1 */ 
    199199    len=1; 
    200     STRTEST( -1, "a", "b", -600); 
     200    STRTEST( -1, -1, "a", "b", -600); 
    201201 
    202202    /* not equal, length=2 */ 
    203203    buf = "ab""ba"; 
    204204    len=2; 
    205     STRTEST( -1, "aa", buf+0, -610); 
    206     STRTEST( -1, "aa", buf+2, -612); 
     205    STRTEST( -1, -1, "aa", buf+0, -610); 
     206    STRTEST( -1, -1, "aa", buf+2, -612); 
    207207 
    208208    /* not equal, length=3 */ 
    209209    buf = "aab""aba""baa"; 
    210210    len=3; 
    211     STRTEST( -1, "aaa", buf+0, -620); 
    212     STRTEST( -1, "aaa", buf+3, -622); 
    213     STRTEST( -1, "aaa", buf+6, -624); 
     211    STRTEST( -1, -1, "aaa", buf+0, -620); 
     212    STRTEST( -1, -1, "aaa", buf+3, -622); 
     213    STRTEST( -1, -1, "aaa", buf+6, -624); 
    214214 
    215215    /* not equal, length=4 */ 
    216216    buf = "aaab""aaba""abaa""baaa"; 
    217217    len=4; 
    218     STRTEST( -1, "aaaa", buf+0, -630); 
    219     STRTEST( -1, "aaaa", buf+4, -632); 
    220     STRTEST( -1, "aaaa", buf+8, -634); 
    221     STRTEST( -1, "aaaa", buf+12, -636); 
     218    STRTEST( -1, -1, "aaaa", buf+0, -630); 
     219    STRTEST( -1, -1, "aaaa", buf+4, -632); 
     220    STRTEST( -1, -1, "aaaa", buf+8, -634); 
     221    STRTEST( -1, -1, "aaaa", buf+12, -636); 
    222222 
    223223    /* not equal, length=5 */ 
    224224    buf="aaaab""aaaba""aabaa""abaaa""baaaa"; 
    225225    len=5; 
    226     STRTEST( -1, "aaaaa", buf+0, -640); 
    227     STRTEST( -1, "aaaaa", buf+5, -642); 
    228     STRTEST( -1, "aaaaa", buf+10, -644); 
    229     STRTEST( -1, "aaaaa", buf+15, -646); 
    230     STRTEST( -1, "aaaaa", buf+20, -648); 
     226    STRTEST( -1, -1, "aaaaa", buf+0, -640); 
     227    STRTEST( -1, -1, "aaaaa", buf+5, -642); 
     228    STRTEST( -1, -1, "aaaaa", buf+10, -644); 
     229    STRTEST( -1, -1, "aaaaa", buf+15, -646); 
     230    STRTEST( -1, -1, "aaaaa", buf+20, -648); 
    231231 
    232232    zero.u32.hi = zero.u32.lo = 0; 
Note: See TracChangeset for help on using the changeset viewer.