mstring.temp.h

Go to the documentation of this file.

#ifndef tchar
#error These templates require 'tchar' to be defined so they know what sort of \
characters to make.  'tchar' may be 'wchar_t' or 'char'.
#endif

#ifndef handler
#error These templates require 'handler' to be defined so they know what to do \
when the end of the buffer is reached. 'handler' may be 'grow' or 'fixed'
#endif

#define ctl_mstring_growcode(tchar,handler, self, addLen)   ppConcat3(ctl_mstring_,handler,_growcode)(tchar, self, addLen )

#define ctl_mstring_check(tchar,handler, self, addLen)      ppConcat3(ctl_mstring_,handler,_check)(tchar, self, addLen )

#define ctl_mstring_checkabort(tchar,handler, self, addLen) ppConcat3(ctl_mstring_,handler,_checkabort)(tchar, self, addLen )

/* Handler to grow to meet needs */
#define ctl_mstring_grow_growcode(tchar, self, addLen ) \
{ \
    tchar* begin; \
    size_t need; \
    assertobjptr(self);\
    begin = (self)->begin; \
    need = ((self)->end+(addLen)+1-begin); \
    if( need > (size_t)((self)->endBuff - (self)->begin) ) \
    {\
        need += ctl_mstring_delta;\
        if( (self)->begin == ctl_mstring_(tchar,handler,0) )\
            (self)->begin = NULL;\
        ctl_realloc((self)->begin,ctl_chsize(tchar,need)); \
        (self)->end = (self)->begin + ((self)->end - begin);\
        *(self)->end = 0;\
        (self)->endBuff = (self)->begin + need-1;\
    }\
}
#define ctl_mstring_grow_check(tchar, self, addLen )        ctl_mstring_(tchar,grow, grow )( self, addLen )
#define ctl_mstring_grow_checkabort(tchar, self, addLen )   ctl_mstring_(tchar,grow, grow )( self, addLen )
#define ctl_mstring_delta   64

#define ctl_mstring_fixed_growcode(tchar, self, addLen ) {}

#define ctl_mstring_fixed_check(tchar, self, addLen )\
{ \
    assertobjptr(self);\
    if( (size_t)(addLen) > (size_t)((self)->endBuff-(self)->end) ) \
        (addLen) = (size_t)((self)->endBuff-(self)->end); \
    if( !(addLen) ) \
    {\
        *(self)->endBuff = 0;\
        return; \
    }\
}

#define ctl_mstring_fixed_checkabort(tchar, self, addLen )\
{ \
    assertobjptr(self);\
    if( (size_t)(addLen) > (size_t)((self)->endBuff-(self)->end) ) \
    {\
        *(self)->endBuff = 0;\
        return; \
    }\
}


ctl_mstring_xgrow(tchar,handler, const tchar ctl_mstring_(tchar,handler,0)[1] = szconst(tchar,""); ) /* Needed for empty/growable string */

void ctl_mstring_(tchar,handler, grow )( ctl_mstring(tchar,handler)* self, size_t addLen )  \
    ctl_mstring_growcode(tchar,handler, self, addLen)

void ctl_mstring_(tchar,handler, fill )( ctl_mstring(tchar,handler)* self, tchar fillVal, size_t count )
{
    ctl_mstring_check(tchar,handler, self, count );
    {
        tchar* p = self->end;
        const tchar* e = p + count;
        while( p < e )
            *p++ = fillVal;
        self->end = p;
        *p = 0;
    }
}

void ctl_mstring_(tchar,handler, filltab )( ctl_mstring(tchar,handler)* self, tchar fillVal, size_t tabPos )
{
    size_t index = self->end - self->begin;
    if( index < tabPos )
        ctl_mstring_(tchar,handler, fill )( self, fillVal, tabPos - index );
}

void ctl_mstring_(tchar,handler, putint32 )( ctl_mstring(tchar,handler)* self, int32 value )
{
    size_t need = int32_NumPlaces( value );
    size_t count = need;
    ctl_mstring_check(tchar,handler, self, count );
    ctl_mstring_xfixed(tchar,handler, if( count < need ) return );
    {
        tchar* p = self->end;
        if( value < 0 )
            *p++ = chconst(tchar,'-');
        p = self->end += need;
        *p-- = 0;
        do
        {
            int32 digit = abs_mod(int32,value,10);
            value = value/10;
            *p-- = (tchar)(chconst(tchar,'0')+digit);
        }
        while( value );
    }
}

void ctl_mstring_(tchar,handler, putuint32 )( ctl_mstring(tchar,handler)* self, uint32 value )
{
    size_t need = uint32_NumPlaces( value );
    size_t count = need;
    ctl_mstring_check(tchar,handler, self, count );
    ctl_mstring_xfixed(tchar,handler, if( count < need ) return );
    {
        tchar* p = self->end;
        p = self->end += need;
        *p-- = 0;
        do
        {
            uint32 digit = abs_mod(uint32,value,10);
            value = value/10;
            *p-- = (tchar)(chconst(tchar,'0')+digit);
        }
        while( value );
    }
}

void ctl_mstring_(tchar,handler, putint64 )( ctl_mstring(tchar,handler)* self, int64 value )
{
    size_t need = int64_NumPlaces( value );
    size_t count = need;
    ctl_mstring_check(tchar,handler, self, count );
    ctl_mstring_xfixed(tchar,handler, if( count < need ) return );
    {
        tchar* p = self->end;
        if( value < 0 )
            *p++ = chconst(tchar,'-');
        p = self->end += need;
        *p-- = 0;
        do
        {
            int64 digit = abs_mod(int64,value,10);
            value = value/10;
            *p-- = (tchar)(chconst(tchar,'0')+digit);
        }
        while( value );
    }
}

void ctl_mstring_(tchar,handler, putuint64 )( ctl_mstring(tchar,handler)* self, uint64 value )
{
    size_t need = uint64_NumPlaces( value );
    size_t count = need;
    ctl_mstring_check(tchar,handler, self, count );
    ctl_mstring_xfixed(tchar,handler, if( count < need ) return );
    {
        tchar* p = self->end;
        if( value < 0 )
            *p++ = chconst(tchar,'-');
        p = self->end += need;
        *p-- = 0;
        do
        {
            uint64 digit = abs_mod(uint64,value,10);
            value = value/10;
            *p-- = (tchar)(chconst(tchar,'0')+digit);
        }
        while( value );
    }
}

void ctl_mstring_(tchar,handler, putfloat64 )( ctl_mstring(tchar,handler)* self, float64 value )
{
    /* There is no wide snprintf, so make do. */
    char buff[32];
    /* It's SERIOUSLY screwed that there aren't wide-character sprintf things! */
    csnprintf(char)(buff,32, szconst(char,"%.6f"), (double)(value) ); 
    ppCtypeSelect(tchar,ctl_mstring_(tchar,handler, strncat )( self, buff, countof(buff) );,{ char* pbuff = buff; while( *pbuff ) { ctl_mstring_(tchar,handler, fill )((self), (tchar)*pbuff, 1 ); pbuff++; } })
}

void ctl_mstring_(tchar,handler, putxuint32 )( ctl_mstring(tchar,handler)* self, uint32 value, size_t places )
{
    size_t count = places;
    ctl_mstring_check(tchar,handler, self, count );
    ctl_mstring_xfixed(tchar,handler, if( count < places ) return );
    {
        tchar* p = self->end += places;
        *p-- = 0;
        while( p >= self->end )
        {
            tchar ch = (tchar)(chconst(tchar,'0') + (value & 0xf));
            if( ch > chconst(tchar,'9') )
                ch += (chconst(tchar,'A')-(chconst(tchar,'9')+1));
            *p-- = ch;
            value>>=4;
        }
    }
}

void ctl_mstring_(tchar,handler, putxuint64 )( ctl_mstring(tchar,handler)* self, uint64 value, size_t places )
{
    size_t count = places;
    ctl_mstring_check(tchar,handler, self, count );
    ctl_mstring_xfixed(tchar,handler, if( count < places ) return );
    {
        tchar* p = self->end += places;
        *p-- = 0;
        while( p >= self->end )
        {
            tchar ch = (tchar)(chconst(tchar,'0') + (value & 0xf));
            if( ch > chconst(tchar,'9') )
                ch += (chconst(tchar,'A')-(chconst(tchar,'9')+1));
            *p-- = ch;
            value>>=4;
        }
    }
}

void ctl_mstring_(tchar,handler, putenum )( ctl_mstring(tchar,handler)* self, int value, const tchar* const* const szzList, int max, const tchar* szUndefined )
{
    if( value >= max )
        ctl_mstring_(tchar,handler, strncat )( self, szUndefined, ~0u );
    else
        ctl_mstring_(tchar,handler, strncat )( self, szzList[value], ~0u );
}

void ctl_mstring_(tchar,handler, strncat )( ctl_mstring(tchar,handler)* self, const tchar* sz, size_t maxLen )
{
    size_t count = cstrnlen(tchar)(sz,maxLen);
    ctl_mstring_check(tchar,handler, self, count );
    cmemcpy(tchar, self->end, sz, count );
    self->end += count;
    *self->end = 0;
}

void ctl_mstring_(tchar,handler, strncpy )( ctl_mstring(tchar,handler)* self, const tchar* sz, size_t maxLen )
{
    size_t count;
    assertconst(sz,sizeof(tchar));
    count = cstrnlen(tchar)(sz,maxLen);
    ctl_mstring_check(tchar,handler, self, count );
    cmemcpy(tchar, self->begin, sz, count );
    self->end = self->begin + count;
    *self->end = 0;
}

void ctl_mstring_(tchar,handler, strninsert )( ctl_mstring(tchar,handler)* self, size_t position, const tchar* sz, size_t maxLen )
{
    size_t count;
    assertconst(sz,sizeof(tchar));
    count = cstrnlen(tchar)(sz,maxLen);
    ctl_mstring_check(tchar,handler, self, count );
    {
        size_t countAfter = (self->end-self->begin) - position;
        if( countAfter < 0 )
            ctl_mstring_(tchar,handler, fill )( self, szconst(tchar,' '), count );
        else if( countAfter > 0 )
            cmemmove(tchar, self->begin + position + count, self->begin + position, countAfter );
        cmemcpy(tchar, self->begin + position, sz, count );
        self->end += count;
        *self->end = 0;
    }
}

void ctl_mstring_(tchar,handler, vsprintf )( ctl_mstring(tchar,handler)* self, const tchar* fmt, va_list args )
{
    int count;
    int result;
    assertconst(fmt,sizeof(tchar));
    assertobjptr(self);
    count = (int)(self->endBuff - self->end);
    result = cvsnprintf(tchar)( self->end, count, fmt, args );
    if( 0 > result )
    {
        tchar* tmp = NULL;
        size_t len = 128;
        do {
            ctl_realloc(tmp,len);
            result = cvsnprintf(tchar)(tmp, len, fmt, args );
            len <<= 1;
        } while(result < 0);
        ctl_free(tmp);
    }
    if( result < count )
    {
        self->end += result;
        *self->end = 0;
        return;
    }
    ctl_mstring_checkabort(tchar,handler, self, result );
    ctl_mstring_xgrow(tchar,handler, self->end += cvsnprintf(tchar)(self->end, self->endBuff - self->end, fmt, args ); *self->end = 0; )
}
void ctl_mstring_(tchar,handler, sprintf )( ctl_mstring(tchar,handler)* self, const tchar* fmt, ... )
{
    va_list args;
    va_start(args, fmt);
    ctl_mstring_(tchar,handler, vsprintf )( self, fmt, args );
}

void ctl_mstring_(tchar,handler, makeClabel )( ctl_mstring(tchar,handler)* self )
{
    tchar* e, *p;
    assertobjptr(self);
    e = self->end;
    for( p = self->begin; p < e; ++p )
        if( !cisalpha(tchar)(*p) && !cisdigit(tchar)(*p) )
            *p = '_';
}

void ctl_mstring_(tchar,handler, truncate )( ctl_mstring(tchar,handler)* self, size_t newsize )
{
    assertobjptr(self);
    if( newsize <= (size_t)(self->end - self->begin) )
    {
        self->end = self->begin + newsize;
        *self->end = 0;
    }
}

int ctl_mstring_(tchar,handler, rcompare )( const ctl_mstring(tchar,handler)* p1, const ctl_mstring(tchar,handler)* p2 )
{
    assertobjconst(p1);
    assertobjconst(p2);
    return ctl_mstring_(tchar,handler, compare )( p1, p1 );
}

int ctl_mstring_(tchar,handler, compare )( const ctl_mstring(tchar,handler)* p1, const ctl_mstring(tchar,handler)* p2 )
{
    assertobjconst(p1);
    assertobjconst(p2);
    {
        int diff;
        size_t lenp1 = (p1->end-p1->begin);
        size_t lenp2 = (p2->end-p2->begin);
        size_t count = min(lenp1,lenp2);
        const tchar* pp1 = p1->begin;
        const tchar* pp2 = p2->begin;
        while( count-- )
        {
            diff = *pp1++ - *pp2++;
            if( diff )
                return diff;
        }
        if( lenp1 > lenp2 )
            return 1;
        if( lenp1 < lenp2 )
            return -1;
    }
    return 0;
}

int ctl_mstring_(tchar,handler, strncmp )( const ctl_mstring(tchar,handler)* p1, const tchar* p2, size_t p2len )
{
    assertobjconst(p1);
    assertconst(p2,sizeof(tchar));
    {
        const tchar* pp1 = p1->begin;
        const tchar* pp2 = p2;
        size_t lenp1 = (p1->end-p1->begin);
        size_t lenp2 = cstrnlen(tchar)(p2,p2len);
        size_t count = min(lenp2,lenp1);
        while( count-- )
        {
            int diff = *pp1++ - *pp2++;
            if( diff )
                return diff;
        }
        if( lenp1 > lenp2 )
            return 1;
        if( lenp1 < lenp2 )
            return -1;
    }
    return 0;
}

int ctl_mstring_(tchar,handler, strnicmp )( const ctl_mstring(tchar,handler)* p1, const tchar* p2, size_t p2len )
{
    assertobjconst(p1);
    assertconst(p2,sizeof(tchar));
    {
        const tchar* pp1 = p1->begin;
        const tchar* pp2 = p2;
        size_t lenp1 = (p1->end-p1->begin);
        size_t lenp2 = cstrnlen(tchar)(p2,p2len);
        size_t count = min(lenp2,lenp1);
        while( count-- )
        {
            int diff = toupper(*pp1++) - toupper(*pp2++);
            if( diff )
                return diff;
        }
        if( lenp1 > lenp2 )
            return 1;
        if( lenp1 < lenp2 )
            return -1;
    }
    return 0;
}