ctlstring.c

Go to the documentation of this file.

#include "ctl/ctldef.h"

#ifndef CTL_UNIT
#ifdef __GNUC__ /* A few other quirks */

size_t strnlen( const char* sz, size_t max )
{
    /* Special case: if max is UINT_MAX, just to normal strlen */
    if( max == ~0u )
        return strlen(sz);
    {
        const char* psz = sz++;
        while( *psz++ && max-- )
            ;
        return psz-sz;
    }
}

size_t wcsnlen( const wchar_t* sz, size_t max )
{
    /* Special case: if max is UINT_MAX, just to normal wcslen */
    if( max == ~0u )
        return wcslen(sz);
    {
        const wchar_t* psz = sz++;
        while( *psz++ && max-- )
            ;
        return psz-sz;
    }
}
#endif /* __GNUC__ */


char* strnlabel( char* buff, const char* src, size_t buffSize )
{
    char* ret = buff;
    if( !isalpha(*src) )
    {
        /* Firse char must be alphabetic */
        *buff++ = '_';
        buffSize--;
    }
    while( *src && buffSize-- )
    {
        if( isspace(*src) )
        {
            /* Eat embedded spaces */
            src++;
        }
        else if( !isalnum(*src) )
        {
            /* Translate non-alphanumeric characters (including '_') into '_' */
            *buff++ = '_';
            src++;
        }
        else
        {
            *buff++ = *src++;
        }
    }
    if( buffSize >= 0 )
        *buff = 0;
    return ret;
}

char* strnupper( char* buff, const char* src, size_t buffSize )
{
    char* ret = buff;
    while( *src && buffSize-- )
        *buff++ = (char)toupper(*src++);
    if( buffSize >= 0 )
        *buff = 0;
    return ret;
}

char* strnlower( char* buff, const char* src, size_t buffSize )
{
    char* ret = buff;
    while( *src && buffSize-- )
        *buff++ = (char)tolower(*src++);
    if( buffSize >= 0 )
        *buff = 0;
    return ret;
}

wchar_t* wcsnlabel( wchar_t* buff, const wchar_t* src, size_t buffSize )
{
    wchar_t* ret = buff;
    if( !cisalpha(wchar_t)(*src) )
    {
        /* Firse char must be alphabetic */
        *buff++ = '_';
        buffSize--;
    }
    while( *src && buffSize-- )
    {
        if( cisspace(wchar_t)(*src) )
        {
            /* Eat embedded spaces */
            src++;
        }
        if( !cisalnum(wchar_t)(*src) )
        {
            /* Translate non-alphanumeric characters (including '_') into '_' */
            *buff++ = '_';
            src++;
        }
        else
        {
            *buff++ = *src++;
        }
    }
    if( buffSize >= 0 )
        *buff = 0;
    return ret;
}

wchar_t* wcsnupper( wchar_t* buff, const wchar_t* src, size_t buffSize )
{
    wchar_t* ret = buff;
    while( *src && buffSize-- )
        *buff++ = ctoupper(wchar_t)(*src++);
    if( buffSize >= 0 )
        *buff = 0;
    return ret;
}

wchar_t* wcsnlower( wchar_t* buff, const wchar_t* src, size_t buffSize )
{
    wchar_t* ret = buff;
    while( *src && buffSize-- )
        *buff++ = ctolower(wchar_t)(*src++);
    if( buffSize >= 0 )
        *buff = 0;
    return ret;
}

#ifdef __GNUC__ /* A few other quirks */

int wcsncasecmp( const wchar_t* sz1, const wchar_t* sz2, size_t max )
{
    while( max-- )
    {
        int val = ctolower(wchar_t)(*sz1)-ctolower(wchar_t)(*sz2);
        if( val )
            return val;
        if( !*sz1 )
            break;
        sz1++;
        sz2++;
    }
    return 0;
}
double wcstod( const wchar_t* sz, wchar_t** ppsz )
{
    double ret;
    char buff[64];
    int max = 64;
    char* pbuff = buff;
    const wchar_t* psz = sz;
    while( max-- && *psz )
        *pbuff++ = (char)*psz++;
    if( max >= 0 )
        *pbuff = 0;
    ret = strtod( buff, &pbuff );
    *ppsz = (wchar_t*)sz + (pbuff-buff);
    return ret;
}
long wcstol( const wchar_t* sz, wchar_t** psz, int radix )
{
    long ret = 0;
    bool bneg = false;
    while( *sz && cisspace(wchar_t)(*sz) )
        sz++;
    if( *sz == '-' )
    {
        bneg = true;
        psz++;
    }
    while( *sz )
    {
        int digit;
        if( radix > 10 && *sz > 'a' )
            digit = 10 + *sz - 'a';
        else if( radix > 10 && *sz > 'A' )
            digit = 10 + *sz - 'A';
        else if( *sz-'0' < radix )
            digit = *sz-'0';
        else break;
        ret *= radix;
        ret += digit;
        sz++;
    }
    if( bneg )
        ret = -ret;
    *psz = (wchar_t*)sz;
    return ret;
}

#endif

#else   /* CTL_UNIT */
#include "unit/unit.h"
#include <math.h>

void spew(void);

#if 1

void Test_strings(void)
{
#define MFG_TestStrings(tchar)\
    {\
        const tchar* const sz = szconst(tchar,"I could have been your daddy.");\
        Test_Error( cstrnlen(tchar)(sz,~0u) == cstrlen(tchar)(sz) );\
        Test_Error( cstrnlen(tchar)(sz,4) == 4 );\
    }
    MFG_TestStrings(char);
    MFG_TestStrings(wchar_t);
}

void Test_sconst(void)
{
    /* Try out the basic string checkers */
#define MFG_TestStrCmps(tchar) \
    {\
        const tchar* const sz = szconst(tchar,"All I ever wanted was a Pepsi.");\
        ctl_sconst_auto_sz(tchar, sz, test1 );\
        ctl_sconst(tchar) strptst = test1;\
        Test_Error( !ctl_sconst_strcmp(tchar, &test1, sz ) );\
        Test_Error( !ctl_sconst_stricmp(tchar, &test1, sz ) );\
        Test_Error( ctl_sconst_strchr(tchar, &test1, chconst(tchar,'I') ) );\
        Test_Error( ctl_sconst_parse(tchar, &test1 ) == sz + 4 );\
        Test_Error( ctl_sconst_strichr(tchar, &test1, chconst(tchar,'V') ) );\
        Test_Error( ctl_sconst_parse(tchar, &test1 ) == sz + 7 );\
        Test_Error( ctl_sconst_strstr(tchar, &test1, szconst(tchar,"was") ) );\
        Test_Error( ctl_sconst_parse(tchar, &test1 ) == sz + 18 );\
        Test_Error( ctl_sconst_stristr(tchar, &test1, szconst(tchar,"pepsi") ) );\
        Test_Error( ctl_sconst_parse(tchar, &test1 ) == sz + 24 );\
        Test_Error( ctl_sconst_strpbrk(tchar, &strptst, szconst(tchar,"cab") ) );\
        Test_Error( ctl_sconst_parse(tchar, &strptst ) == sz + 12 );\
    }
    MFG_TestStrCmps(char);
    MFG_TestStrCmps(wchar_t);

#define MFG_TestSpaceWalks(tchar)\
    {\
        const tchar* const sz = szconst(tchar,"  a bb  ccc X    yy zzz");\
        ctl_sconst_auto_sz(tchar, sz, strTestSpace );\
        Test_Error( ctl_sconst_skipspace(tchar, &strTestSpace ) );\
        Test_Error( ctl_sconst_strchr(tchar, &strTestSpace, chconst(tchar,'a') ) );\
        Test_Error( ctl_sconst_nextspace(tchar, &strTestSpace ) );\
        Test_Error( ctl_sconst_skipspace(tchar, &strTestSpace ) );\
        Test_Error( !ctl_sconst_strncmp(tchar, &strTestSpace, szconst(tchar,"bb"), 2 ) );\
        Test_Error( ctl_sconst_nextspace(tchar, &strTestSpace ) );\
        Test_Error( ctl_sconst_skipspace(tchar, &strTestSpace ) );\
        Test_Error( !ctl_sconst_strncmp(tchar, &strTestSpace, szconst(tchar,"ccc"), 3 ) );\
        Test_Error( ctl_sconst_nextspace(tchar, &strTestSpace ) );\
        Test_Error( ctl_sconst_skipspace(tchar, &strTestSpace ) );\
        Test_Error( ctl_sconst_strchr(tchar, &strTestSpace, chconst(tchar,'X') ) );\
        Test_Error( ctl_sconst_nextspace(tchar, &strTestSpace ) );\
        Test_Error( ctl_sconst_skipspace(tchar, &strTestSpace ) );\
        Test_Error( !ctl_sconst_strncmp(tchar, &strTestSpace, szconst(tchar,"yy"), 2 ) );\
        Test_Error( ctl_sconst_nextspace(tchar, &strTestSpace ) );\
        Test_Error( ctl_sconst_skipspace(tchar, &strTestSpace ) );\
        Test_Error( !ctl_sconst_strncmp(tchar, &strTestSpace, szconst(tchar,"zzz"), 3 ) );\
    }
    MFG_TestSpaceWalks(char);
    MFG_TestSpaceWalks(wchar_t);

    /* See if dmatch works */
#define MFG_Dmatch(tchar)\
    {\
        const tchar* const sz = szconst(tchar,"{ a { b { c } } }");\
        ctl_sconst_auto_sz(tchar, sz, test );\
        ctl_sconst(tchar) a, b, c, tmp;\
        Test_Error( ctl_sconst_dmatch(tchar, &test, &a, chconst(tchar,'{'), chconst(tchar,'}') ) );\
        tmp = a;\
        Test_Error( ctl_sconst_dmatch(tchar, &tmp, &b, chconst(tchar,'{'), chconst(tchar,'}') ) );\
        tmp = b;\
        Test_Error( ctl_sconst_dmatch(tchar, &tmp, &c, chconst(tchar,'{'), chconst(tchar,'}') ) );\
        Test_Error( ctl_sconst_skipspace(tchar, &c ) );\
        Test_Error( ctl_sconst_skipspace(tchar, &b ) );\
        Test_Error( ctl_sconst_skipspace(tchar, &a ) );\
        Test_Error( *ctl_sconst_parse(tchar, &a ) == chconst(tchar,'a') );\
        Test_Error( *ctl_sconst_parse(tchar, &b ) == chconst(tchar,'b') );\
        Test_Error( *ctl_sconst_parse(tchar, &c ) == chconst(tchar,'c') );\
    }
    MFG_Dmatch(char);
    MFG_Dmatch(wchar_t);

    /* See if dmatchstr works */
#define MFG_Dmatchstr(tchar)\
    {\
        const tchar* const sz = szconst(tchar,"begin a begin b begin c end end end");\
        ctl_sconst_auto_sz(tchar, sz, test );\
        ctl_sconst(tchar) a, b, c, tmp;\
        Test_Error( ctl_sconst_dmatchstr(tchar, &test, &a, szconst(tchar,"begin"), szconst(tchar,"end") ) );\
        tmp = a;\
        Test_Error( ctl_sconst_dmatchstr(tchar, &tmp, &b, szconst(tchar,"begin"), szconst(tchar,"end") ) );\
        tmp = b;\
        Test_Error( ctl_sconst_dmatchstr(tchar, &tmp, &c, szconst(tchar,"begin"), szconst(tchar,"end") ) );\
        Test_Error( ctl_sconst_skipspace(tchar, &c ) );\
        Test_Error( ctl_sconst_skipspace(tchar, &b ) );\
        Test_Error( ctl_sconst_skipspace(tchar, &a ) );\
        Test_Error( *ctl_sconst_parse(tchar, &a ) == chconst(tchar,'a') );\
        Test_Error( *ctl_sconst_parse(tchar, &b ) == chconst(tchar,'b') );\
        Test_Error( *ctl_sconst_parse(tchar, &c ) == chconst(tchar,'c') );\
    }
    MFG_Dmatchstr(char);
    MFG_Dmatchstr(wchar_t);

    /* Manufacture tests for various decimal value types */
#define on 1
#define off 0
#define yes 1
#define no 0
#define TestList(def,tchar) \
    def(tchar, Equal, bool, false ) \
    def(tchar, Equal, bool, 1 ) \
    def(tchar, Equal, bool, true ) \
    def(tchar, Equal, bool, 0 ) \
    def(tchar, Equal, bool, yes ) \
    def(tchar, Equal, bool, off ) \
    def(tchar, Equal, bool, no ) \
    def(tchar, Equal, bool, on ) \
    def(tchar, Equal, int8, 127 ) \
    def(tchar, Equal, int8, -127 ) \
    def(tchar, Equal, uint8, 255 ) \
    def(tchar, Equal, uint8, 42 ) \
    def(tchar, Equal, int16, -1000 ) \
    def(tchar, Equal, int16, -32767 ) \
    def(tchar, Equal, uint16, 65535 ) \
    def(tchar, Equal, uint16, 2011 ) \
    def(tchar, Equal, int32, -100001000 ) \
    def(tchar, Equal, int32, -2000010000 ) \
    def(tchar, Equal, uint32, 1110204398 ) \
    def(tchar, Equal, uint32, 1000010000 ) \
    def(tchar, Equal, int64,  -1000101000 ) \
    def(tchar, Equal, uint64, 1234567890 )\
    def(tchar, Nearly, float32, 3.543 ) \
    def(tchar, Nearly, float64, 9999.123 )
#define Equal(v1,v2)    ((v1)==(v2))
#define Nearly(v1,v2)   (fabs((v1)-(v2)) <= float64_compare_epsilon)
#define XDEFSTR( tchar, howclose, type, value ) szconst(tchar,#value) szconst(tchar," ")
#define XDEFTEST( tchar, howclose, type, value )    \
    {\
        type tval = 0;\
        Test_Error( ppConcat(ctl_sconst_get,type)( tchar, &test, &tval ) );\
        /*forisfloat(type,printf( "%f == %f\n", value, tval ),printf( "%d == %d\n", value, tval ));*/\
        Test_Named( "ctl_sconst_get" #type " ", howclose ( tval, value ) );\
    }
#define MFG_StrToxxx(tchar)\
    {\
        const tchar* const sz = TestList(XDEFSTR,tchar);\
        ctl_sconst_auto_sz(tchar, sz, test );\
        TestList(XDEFTEST,tchar);\
    }
    MFG_StrToxxx(char);
    MFG_StrToxxx(wchar_t);
#undef TestList
#undef XDEFSTR
#undef XDEFTEST
#undef MFG_StrToxxx

    /* Manufacture tests for various hexadecimal value types */
#define TestXList1(def,tchar) \
    def(tchar, uint8,  42 ) \
    def(tchar, uint16, abcd ) \
    def(tchar, uint32, c05acbde ) \
    def(tchar, uint64, ff8e9dacbbcad9e8 )\
    def(tchar, int8,  42 ) \
    def(tchar, int16, 7bcd ) \
    def(tchar, int32, 605acbde ) \
    def(tchar, int64, 7f8e9dacbbcad9e8 )
#define XDEFSTR( tchar, type, value )   szconst(tchar,#value) szconst(tchar," ")
#define XDEFTEST( tchar, type, value )  \
    {\
        type tval = 0;\
        Test_Error( ppConcat(ctl_sconst_getx,type)( tchar, &test, &tval ) );\
        Test_Named( "ctl_sconst_get" #type " ", (uint64)tval == uint64const(ppConcat(0x,value)) );\
    }
#define MFG_XTests(tchar)\
    {\
        const tchar* const sz = TestXList1(XDEFSTR,tchar);\
        ctl_sconst_auto_sz(tchar, sz, test );\
        TestXList1(XDEFTEST,tchar);\
    }
    MFG_XTests(char);
    MFG_XTests(wchar_t);
#undef TestXList1
#undef XDEFSTR
#undef XDEFTEST
#undef MFG_XTests

    /* Try the character class searches */
#define MFG_FindClassTests(tchar)\
    {\
        const tchar* const sz = szconst(tchar,"   !  3  z   f");\
        ctl_sconst_auto_sz(tchar, sz, test );\
        Test_Error( ctl_sconst_findclass(tchar, &test, ispunct ) );\
        Test_Error( *ctl_sconst_parse(tchar, &test ) == chconst(tchar,'!') );\
        Test_Error( ctl_sconst_findclass(tchar, &test, isdigit ) );\
        Test_Error( *ctl_sconst_parse(tchar, &test ) == chconst(tchar,'3') );\
        ctl_sconst_reset(tchar, &test );\
        Test_Error( ctl_sconst_findclass(tchar, &test, isalpha ) );\
        Test_Error( *ctl_sconst_parse(tchar, &test ) == chconst(tchar,'z') );\
        Test_Error( ctl_sconst_findclass(tchar, &test, isxdigit ) );\
        Test_Error( *ctl_sconst_parse(tchar, &test ) == chconst(tchar,'f') );\
    }
    MFG_FindClassTests(char);
    MFG_FindClassTests(wchar_t);
}

void Test_mstring(void)
{
    /* Piece together some growable strings */
#define Test1(tchar)\
    {\
        const tchar testval[] = szconst(tchar,"All I ever wanted was a Pepsi.  Institutionalized.  Oohgah");\
        ctl_gstring_auto(tchar, testing );\
        ctl_gstring_sprintf(tchar, (&testing, szconst(tchar,"All I ever wanted was a %") szstrfmt(tchar) szconst(tchar,"."), szconst(tchar,"Pepsi") ) );\
        ctl_gstring_strcat(tchar, &testing, szconst(tchar,"  Institutionalized.") );\
        ctl_gstring_strncat(tchar, &testing, szconst(tchar,"  Oohgah-boogah"), 8 );\
        Test_Error( 0 == cstrcmp(tchar)( testing.begin, testval ) );\
        ctl_gstring_destroy(tchar, &testing );\
    }
    Test1(char);
    Test1(wchar_t)
#undef Test1

    /* Piece together some fixed */
#define Test2(tchar)\
    {\
        const tchar testval[] = szconst(tchar,"All I ever wanted was a Pepsi.  Institutionalized.  Oohgah");\
        ctl_fstring_auto(tchar, 128, testing );\
        ctl_fstring_sprintf(tchar, (&testing, szconst(tchar,"All I ever wanted was a %") szstrfmt(tchar) szconst(tchar,"."), szconst(tchar,"Pepsi") ) );\
        ctl_fstring_strcat(tchar, &testing, szconst(tchar,"  Institutionalized.") );\
        ctl_fstring_strncat(tchar, &testing, szconst(tchar,"  Oohgah-boogah"), 8 );\
        Test_Error( 0 == cstrcmp(tchar)( testing.begin, testval ) );\
    }
    Test2(char);
    Test2(wchar_t)
#undef Test2

    /* Piece together some fixed strings and verify they truncate correctly */
#define Test3(tchar)\
    {\
        const tchar testval[] = szconst(tchar,"All I ever wanted was a Pepsi. ");\
        ctl_fstring_auto(tchar, 32, testing );\
        ctl_fstring_sprintf(tchar, (&testing, szconst(tchar,"All I ever wanted was a %") szstrfmt(tchar) szconst(tchar,"."), szconst(tchar,"Pepsi") ) );\
        ctl_fstring_strcat(tchar, &testing, szconst(tchar,"  Institutionalized.") );\
        ctl_fstring_strncat(tchar, &testing, szconst(tchar,"  Oohgah-boogah"), 8 );\
        Test_Error( 0 == cstrcmp(tchar)(testing.begin, testval ) );\
    }
    Test3(char);
    Test3(wchar_t)
#undef Test3

/* Concatenate a string, then parse it again */
#define TestList(tchar,def) \
    def(tchar, Equal, bool, false ) \
    def(tchar, Equal, bool, true ) \
    def(tchar, Equal, int8, 127 ) \
    def(tchar, Equal, int8, -127 ) \
    def(tchar, Equal, uint8, 255 ) \
    def(tchar, Equal, uint8, 42 ) \
    def(tchar, Equal, int16, -1000 ) \
    def(tchar, Equal, int16, -32767 ) \
    def(tchar, Equal, uint16, 65535 ) \
    def(tchar, Equal, uint16, 2011 ) \
    def(tchar, Equal, int32, -100001000 ) \
    def(tchar, Equal, int32, -2000010000 ) \
    def(tchar, Equal, uint32, 1110204398 ) \
    def(tchar, Equal, uint32, 1000010000 ) \
    def(tchar, Equal, int64,  -1000101000 ) \
    def(tchar, Equal, uint64, 1234567890 )\
    def(tchar, Nearly, float32, 3.543 ) \
    def(tchar, Nearly, float64, 9999.123 )
#define Equal(v1,v2)    ((v1)==(v2))
#define Nearly(v1,v2)   (fabs((v1)-(v2)) <= float64_compare_epsilon)
#define XDEFPUT( tchar, howclose, type, value ) \
    {\
        ppConcat(ctl_gstring_put,type)(tchar, &testing, value);\
        ctl_assertmem(testing.begin);\
        ctl_gstring_add(tchar, &testing, chconst(tchar,' ') );\
        ctl_assertmem(testing.begin);\
    }
#define XDEFTEST( tchar, howclose, type, value )    \
    {\
        type tval = 0;\
        Test_Error( ppConcat(ctl_sconst_get,type)(tchar, &test, &tval ) );\
        Test_Named( "ctl_sconst_get" #type " ", howclose( tval, value ) );\
    }
#define MFG_StrToxxx(tchar)\
    {\
        ctl_gstring_auto(tchar, testing );\
        TestList(tchar,XDEFPUT);\
        /*cputs(tchar)( testing.begin );*/\
        {\
            ctl_sconst_auto_string(tchar, &testing, test );\
            TestList(tchar,XDEFTEST);\
        }\
        ctl_gstring_destroy(tchar, &testing );\
    }
    MFG_StrToxxx(char);
    MFG_StrToxxx(wchar_t);
#undef TestList
#undef XDEFPUT
#undef XDEFTEST
#undef MFG_StrToxxx
}

#else /* !1 */


#endif /* 1 */


#endif /* CTL_UNIT */