serial.c

/****************************************************************************

 \file      ctl/serial.c
 \ingroup   Patterns
 \brief     Serial support functions
 \author    David Mace

Serial Handling

Serial data is generally stored little-endian for this handling, to take 
advantage of the native format of Intel architecture, which is the most 
common type we'll find, and supports odd-aligned data accesses, which makes 
serializing it a piece of cake.  On most big-endian hardware, there is no 
savings possible, as odd data alignment will generate exceptions, so we 
take advantage of the most common target with the most lucrative feature.

Arrays of scalars and wide character strings are stored all lowest bytes as 
an array, then each more significant byte as a seperate array.  This 
generally helps the data compress better for many kinds of scalar data.

define SERIAL_BIG_ENDIAN If you want big-endian data
SERIAL_BIG_ENDIAN is the default.

define SERIAL_LITTLE_ENDIAN  If you want little-endian data

define SERIAL_NATIVE If your target platform doesn't mind reading/writing odd 
addresses, and you want its native endian-ness.

SERIAL_NATIVE is naturally the fastest for serial-intensive applications, but 
only supportable under certain situations.

For a Windows+Intel or Linux+Intel style computer, SERIAL_NATIVE is little-endian

*****************************************************************************/
#define SERIAL_C
#include "ctl/ctldef.h"
#include "ctl/dg/datagen.h"
#include "ctl/algorithm.temp.h"
#include "ctl/serial.h"

/*
 * Default serial error handler: Log packet and throw an assertion
 */
static void def_serial_exception( const struct ctl_serial* serial, const char* reason )
{
    serial_log( serial, LOG_ERROR, 
        "ctl_serial: %s\n"
        "\tbegin:%p\n"
        "\tcurr:%p\n"
        "\tend:%p\n",
        reason,
        serial->begin,
        serial->curr,
        serial->end
        );
    assert( !isdebugging() );
    /* longjmp back to setjmp handler... */
}

ctl_serial_exception ctl_serial_except = def_serial_exception; 
ctl_serial_exception ctl_serial_setexception( ctl_serial_exception except )
{
    ctl_serial_exception ctl_serial_except_prev = ctl_serial_except;
    ctl_serial_except = NULL == except ? def_serial_exception : except;
    assertcodeptr(ctl_serial_except);
    return ctl_serial_except_prev;
}

void serial_log( const ctl_serial* serial, unsigned mask, const char* fmt, ... )
{
    if( (mask & debug_getlogmask()) || 0 == mask )
    {
        ctl_serial dumpit = *serial;
        char printable[16];
        const uint8* pBuff;
        size_t size = serial->end - serial->begin;
        size_t curr = 0;
        size_t offAddress = 0;
        /* Attach whatever other diagnostic info */
        va_list args;
        va_start( args, fmt );
        debug_vlogalways( fmt, args );
        /* Clip dump down to a maximum size of dump, so we don't cripple ourselves reporting problems */
#ifndef SERIAL_MAX_DUMP
#define SERIAL_MAX_DUMP 80
#endif
        if( size > SERIAL_MAX_DUMP )
        {
            dumpit.begin = (uint8*)max(dumpit.begin,dumpit.curr-(SERIAL_MAX_DUMP/2));
            dumpit.end = (uint8*)min(dumpit.end,dumpit.curr+(SERIAL_MAX_DUMP/2));
            offAddress = dumpit.begin - serial->begin;
            size = SERIAL_MAX_DUMP;
        }
        /* Do hex dump */
        pBuff = (const uint8*)dumpit.begin;
        while( pBuff < dumpit.end )
        {
            unsigned ch = *pBuff++;
            if( 0 == (curr & 0xf) )
            {
                debug_logalways( "%08x:%c", curr+offAddress, pBuff == dumpit.curr-1 ? '>' : ' ' );
            }
            printable[curr&0xf] = isprint(ch) ? ch : '.';
            if( 0xf == (curr++ & 0xf) )
            {
                debug_logalways( "%02x | %16.16s\n", ch, printable );
            }
            else
            {
                debug_logalways( "%02x%c", ch, pBuff == dumpit.curr ? '>' : ' ' );
            }
        }
        /* Leftovers */
        if( 0 != (size & 0xf) )
        {
            for( curr = curr & 0xf; curr < 16; ++curr )
            {
                debug_logalways( "-- " );
                printable[curr] = ' ';
            }
            debug_logalways( "| %16.16s\n", printable );
        }
    }
}

void ctl_serial_copy( ctl_serial* dst, const ctl_serial* src )
{
    assertobjptr(dst);
    assertobjconst(src);
    if( src->buff )
    {
        size_t size = ctl_serial_total( src );
        ctl_serial_alloc( dst, size );
        memcpy( dst->buff, src->begin, size );
        dst->curr = (uint8*)dst->begin + (src->curr-src->begin);
    }
    else
    {
        *dst = *src;
        dst->buff = NULL;
    }
}

void ctl_serial_deref( ctl_serial* serial )
{
    assertobjptr(serial);
    if( NULL == serial->buff )
    {   /* Only operate if not already a reference */
        ctl_serial tmp = *serial;
        size_t size = ctl_serial_total( &tmp );
        ctl_serial_alloc( serial, size );
        memcpy( serial->buff, tmp.begin, size );
        serial->curr = (uint8*)serial->begin + (tmp.curr-tmp.begin);
    }
}


void ctl_serial_writesize( size_t size, ctl_serial* serial )
{
    /* There SHOULD have been enough pre-allocated */
    uint16 wsize = (uint16)size;
    assertobjptr(serial);
    assert( size < 65536 );
    assert( serial->curr + ctl_serial_size_size_size( size ) <= serial->end );
    uint16_serial_write( &wsize, serial );
}

size_t ctl_serial_peeksize( const ctl_serial* serial )
{
    uint16 wsize = 0;
    assertobjconst(serial);
    uint16_serial_peek( &wsize, serial );
    return wsize;
}

size_t ctl_serial_readsize( ctl_serial* serial )
{
    uint16 wsize = 0;
    assertobjptr(serial);
    uint16_serial_read( &wsize, serial );
    if( serial->curr + wsize > serial->end )
    {
        ctl_serial_except( serial, "Bound check failure getting size" );
        return 0;
    }
    return wsize;
}

size_t ctl_serial_calc_size( const ctl_serial* serial )
{
    assertobjconst(serial);
    return ctl_serial_size_size_size( ctl_serial_total( serial ) );
}

void ctl_serial_write_serial( ctl_serial* dst, const ctl_serial* src )
{
    assertobjptr(dst);
    assertobjconst(src);
    {
        size_t total = ctl_serial_total( src );
        ctl_serial_writesize( total, dst );
        memcpy( dst->curr, src->begin, total );
        dst->curr += total;
    }
}

bool ctl_serial_read_serial( ctl_serial* dst, ctl_serial* src )
{
    assertobjptr(dst);
    assertobjptr(src);
    {
        size_t total = ctl_serial_readsize( src );
        dst->begin = dst->curr = (uint8*)src->curr;
        dst->end = dst->begin + total;
        src->curr += total;
        return 0 != total;
    }
}

bool ctl_serial_peek_serial( ctl_serial* dst, const ctl_serial* src )
{
    assertobjptr(dst);
    assertobjconst(src);
    {
        size_t total = ctl_serial_peeksize( src );
        dst->begin = dst->curr = (uint8*)src->curr + ctl_serial_size_size( total );
        dst->end = dst->begin + total;
        return 0 != total;
    }
}


size_t bool_serial_sizearray( const bool*  array, size_t count)
{
    assertconst(array,count*sizeof(bool));
    return ctl_serial_size_size_size( count );
}
void bool_serial_writearray( const bool* array, size_t count, ctl_serial* serial )
{
    size_t size = count;
    assertconst(array,count*sizeof(bool));
    assertobjptr(serial);
    ctl_serial_writesize( size, serial );
    assert( serial->curr + size <= serial->end );
    {
        pointer_foreach_const(bool,array,count, curr )
        {
            *serial->curr++ = (uint8)*curr;
        }
    }
}
void bool_serial_readarray( bool* array, size_t count, ctl_serial* serial )
{
    size_t size;
    assertobjptr(serial);
    assertobjptr(array);
    size = ctl_serial_readsize( serial );
    if( size <= count )
    {
        pointer_foreach(bool,array,count, curr )
        {
            /* Probably should generate exception if these are not 0 or 1 */
            uint8 tmp = *serial->curr++;
            *curr = 0 != tmp;
        }
    }
    else
    {
        pointer_foreach(bool,array,size, curr )
        {
            /* Probably should generate exception if these are not 0 or 1 */
            uint8 tmp = *serial->curr++;
            *curr = 0 != tmp;
        }
        serial->curr += size-count;
    }
}

void uint8_serial_write( const uint8* pdata, ctl_serial* serial )
{
    assertobjptr(serial);
    assertconst(pdata,sizeof(*pdata));
    assert( serial->curr < serial->end );
    *serial->curr++ = *pdata;
}

void uint8_serial_read( uint8* pdata, ctl_serial* serial )
{
    assertobjptr(serial);
    assertptr(pdata,sizeof(*pdata));
    if( serial->curr < serial->end )
        *pdata = *serial->curr++;
    else
        ctl_serial_except( serial, "ctl_serial_read: Bound check failure" );
}

void uint8_serial_peek( uint8* pdata, const ctl_serial* serial )
{
    assertobjconst(serial);
    assertptr(pdata,sizeof(*pdata));
    if( serial->curr < serial->end )
        *pdata = *serial->curr;
    else
        ctl_serial_except( serial, "ctl_serial_read: Bound check failure" );
}

size_t uint8_serial_sizearray( const uint8* array, size_t count)
{
    size_t size = count;
    assertconst(array,count*sizeof(array));
    return ctl_serial_size_size_size( size );
}
void uint8_serial_writearray( const uint8*  array, size_t count, ctl_serial* serial )
{
    size_t size = count;
    assertobjptr(serial);
    assertconst(array,count*sizeof(array));
    ctl_serial_writesize( size, serial );
    assert( serial->curr + size <= serial->end );
    memcpy( serial->curr, array, size );
    serial->curr += size;
}

void uint8_serial_readarray( uint8* array, size_t count, ctl_serial* serial )
{
    size_t size = ctl_serial_readsize( serial );
    assertobjptr(serial);
    assertptr(array,count*sizeof(array));
    if( size > count )
        ctl_serial_except( serial, "serial_readarray: Too big" );
    count = min(count,size);
    memcpy( array, serial->curr, count );
    serial->curr += size;
}

void uint16_serial_write(const uint16* pdata, ctl_serial* serial )
{
    assertobjptr(serial);
    assertconst(pdata,sizeof(*pdata));
    assert( serial->curr+2 <= serial->end );
#if defined(SERIAL_LITTLE_ENDIAN)
    {
        uint8* curr = serial->curr;
        *curr++ = (uint8)(*pdata);
        *curr++ = (uint8)(*pdata>>8);
        serial->curr = curr;
    }
#elif defined(SERIAL_BIG_ENDIAN)
    {
        uint8* curr = serial->curr+1;
        *curr-- = (uint8)(*pdata);
        *curr = (uint8)(*pdata>>8);
        serial->curr += 2;
    }
#elif defined(SERIAL_NATIVE)
    *((uint16*)serial->curr) = *pdata;
    serial->curr += 2;
#endif
}

void uint16_serial_read(uint16* pdata, ctl_serial* serial )
{
    assertobjptr(serial);
    assertptr(pdata,sizeof(*pdata));
    if( serial->curr + 2 <= serial->end )
    {
#if defined(SERIAL_LITTLE_ENDIAN)
        const uint8* curr = serial->curr + 1;
        *pdata = (uint16)*curr--;
        *pdata <<= 8;
        *pdata |= (uint16)*curr;
        serial->curr += 2;
#elif defined(SERIAL_BIG_ENDIAN)
        const uint8* curr = serial->curr;
        *pdata = (uint16)*curr++;
        *pdata <<= 8;
        *pdata |= (uint16)*curr++;
        serial->curr = (uint8*)curr;
#elif defined(SERIAL_NATIVE)
        *pdata = *((uint16*)serial->curr);
        serial->curr += 2;
#endif
    }
    else
    {
        ctl_serial_except( serial, "ctl_serial_read: Bound check failure" );
    }
}

void uint16_serial_peek( uint16* pdata, const ctl_serial* serial )
{
    assertobjconst(serial);
    assertptr(pdata,sizeof(*pdata));
    {
        ctl_serial temp = *serial;
        uint16_serial_read( pdata, &temp );
    }
}

size_t uint16_serial_sizearray(const uint16* array, size_t count)
{
    size_t size = count * sizeof(uint16);
    assertconst(array,count*sizeof(array));
    return ctl_serial_size_size_size( size );
}

void uint16_serial_writearray(const uint16* array, size_t count, ctl_serial* serial )
{
    size_t size = count<<1;
    assertobjptr(serial);
    assertconst(array,count*sizeof(array));
    ctl_serial_writesize( size, serial );
    assert( serial->curr + size <= serial->end );
    {
        pointer_foreach_const(uint16,array,count, curr )
            uint16_serial_write(curr,serial);
    }
}

void uint16_serial_readarray(uint16* array, size_t count, ctl_serial* serial )
{
    size_t size;
    size_t serialCount;
    assertobjptr(serial);
    assertptr(array,count*sizeof(array));
    size = ctl_serial_readsize( serial );
    serialCount = size>>1;
    if( size & 1 )
        ctl_serial_except( serial, "uint16_serial_readarray: Odd size" );
    if( serialCount > count )
        serialCount = count;
    {
        pointer_foreach(uint16,array,serialCount, curr )
            uint16_serial_read(curr,serial);
    }
    if( serialCount < count )
    {
        size_t leftover = size - (count<<1);
        serial->curr += size - (count<<1);
        memset( array + count, 0, leftover );
    }
    else
    {
        serial->curr += size - (count<<1);
    }
}

void uint32_serial_write(const uint32* pdata, ctl_serial* serial )
{
    assertobjptr(serial);
    assertconst(pdata,sizeof(*pdata));
    assert( serial->curr+4 <= serial->end );
#if defined(SERIAL_LITTLE_ENDIAN)
    {
        register uint8* curr = serial->curr;
        register uint32 val = *pdata;
        *curr++ = (uint8)(val);
        val >>= 8;
        *curr++ = (uint8)(val);
        val >>= 8;
        *curr++ = (uint8)(val);
        val >>= 8;
        *curr++ = (uint8)(val);
        serial->curr = curr;
    }
#elif defined(SERIAL_BIG_ENDIAN)
    {
        register uint8* curr = serial->curr+3;
        register uint32 val = *pdata;
        *curr-- = (uint8)(val);
        val >>= 8;
        *curr-- = (uint8)(val);
        val >>= 8;
        *curr-- = (uint8)(val);
        val >>= 8;
        *curr = (uint8)(val);
        serial->curr += 4;
    }
#elif defined(SERIAL_NATIVE)
    *((uint32*)serial->curr) = *pdata;
    serial->curr += 4;
#endif
}

void uint32_serial_read(uint32* pdata, ctl_serial* serial )
{
    assertobjptr(serial);
    assertptr(pdata,sizeof(*pdata));
    if( serial->curr + 4 <= serial->end )
    {
#if defined(SERIAL_LITTLE_ENDIAN)
        register const uint8* curr = serial->curr + 3;
        register uint32 tmp = (uint32)*curr--;
        tmp <<= 8;
        tmp |= (uint32)*curr--;
        tmp <<= 8;
        tmp |= (uint32)*curr--;
        tmp <<= 8;
        tmp |= (uint32)*curr;
        *pdata = tmp;
        serial->curr += 4;
#elif defined(SERIAL_BIG_ENDIAN)
        register const uint8* curr = serial->curr;
        register uint32 tmp = (uint32)*curr++;
        tmp <<= 8;
        tmp |= (uint32)*curr++;
        tmp <<= 8;
        tmp |= (uint32)*curr++;
        tmp <<= 8;
        tmp |= (uint32)*curr++;
        *pdata = tmp;
        serial->curr = (uint8*)curr;
#elif defined(SERIAL_NATIVE)
        *pdata = *((uint32*)serial->curr);
        serial->curr += 4;
#endif
    }
    else
    {
        ctl_serial_except( serial, "ctl_serial_read: Bound check failure" );
    }
}

void uint32_serial_peek(uint32* pdata, ctl_serial* serial )
{
    assertobjptr(serial);
    assertptr(pdata,sizeof(*pdata));
    {
        ctl_serial temp = *serial;
        uint32_serial_read( pdata, &temp );
    }
}


size_t uint32_serial_sizearray(const uint32* array, size_t count)
{
    size_t size = count * sizeof(uint32);
    assertconst(array,count*sizeof(array));
    return ctl_serial_size_size_size( size );
}

void uint32_serial_writearray(const uint32* array, size_t count, ctl_serial* serial )
{
    size_t size = count<<2;
    assertobjptr(serial);
    assertconst(array,count*sizeof(array));
    ctl_serial_writesize( size, serial );
    assert( serial->curr + size <= serial->end );
    {
        pointer_foreach_const(uint32,array,count, curr )
            uint32_serial_write(curr,serial);
    }
}

void uint32_serial_readarray(uint32* array, size_t count, ctl_serial* serial )
{
    size_t size;
    size_t serialCount;
    assertobjptr(serial);
    assertptr(array,count*sizeof(array));
    size = ctl_serial_readsize( serial );
    serialCount = size>>2;
    if( size & 3 )
        ctl_serial_except( serial, "uint32_serial_readarray: Odd size" );
    if( serialCount > count )
        serialCount = count;
    {
        pointer_foreach(uint32,array,serialCount, curr )
            uint32_serial_read(curr,serial);
    }
    if( serialCount < count )
    {
        size_t leftover = size - (count<<2);
        serial->curr += size - (count<<2);
        memset( array + count, 0, leftover );
    }
    else
    {
        serial->curr += size - (count<<2);
    }
}

void uint64_serial_write(const uint64* pdata, ctl_serial* serial )
{
    assertobjptr(serial);
    assertconst(pdata,sizeof(*pdata));
    assert( serial->curr+8 <= serial->end );
#if defined(SERIAL_LITTLE_ENDIAN)
    {
        register uint8* curr = serial->curr;
        register uint64 val = *pdata;
        *curr++ = (uint8)(val);
        val >>= 8;
        *curr++ = (uint8)(val);
        val >>= 8;
        *curr++ = (uint8)(val);
        val >>= 8;
        *curr++ = (uint8)(val);
        val >>= 8;
        *curr++ = (uint8)(val);
        val >>= 8;
        *curr++ = (uint8)(val);
        val >>= 8;
        *curr++ = (uint8)(val);
        val >>= 8;
        *curr++ = (uint8)(val);
        serial->curr = curr;
    }
#elif defined(SERIAL_BIG_ENDIAN)
    {
        register uint8* curr = serial->curr+7;
        register uint64 val = *pdata;
        *curr-- = (uint8)(val);
        val >>= 8;
        *curr-- = (uint8)(val);
        val >>= 8;
        *curr-- = (uint8)(val);
        val >>= 8;
        *curr-- = (uint8)(val);
        val >>= 8;
        *curr-- = (uint8)(val);
        val >>= 8;
        *curr-- = (uint8)(val);
        val >>= 8;
        *curr-- = (uint8)(val);
        val >>= 8;
        *curr = (uint8)(val);
        serial->curr += 8;
    }
#elif defined(SERIAL_NATIVE)
    *((uint64*)serial->curr) = *pdata;
    serial->curr += 8;
#endif
}

void uint64_serial_read(uint64* pdata, ctl_serial* serial )
{
    assertobjptr(serial);
    assertptr(pdata,sizeof(*pdata));
    if( serial->curr + 8 <= serial->end )
    {
#if defined(SERIAL_LITTLE_ENDIAN)
        register const uint8* curr = serial->curr + 7;
        register uint64 tmp = (uint64)*curr--;
        tmp <<= 8;
        tmp |= (uint64)*curr--;
        tmp <<= 8;
        tmp |= (uint64)*curr--;
        tmp <<= 8;
        tmp |= (uint64)*curr--;
        tmp <<= 8;
        tmp |= (uint64)*curr--;
        tmp <<= 8;
        tmp |= (uint64)*curr--;
        tmp <<= 8;
        tmp |= (uint64)*curr--;
        tmp <<= 8;
        tmp |= (uint64)*curr;
        *pdata = tmp;
        serial->curr += 8;
#elif defined(SERIAL_BIG_ENDIAN)
        register const uint8* curr = serial->curr;
        register uint64 tmp = (uint64)*curr++;
        tmp <<= 8;
        tmp |= (uint64)*curr++;
        tmp <<= 8;
        tmp |= (uint64)*curr++;
        tmp <<= 8;
        tmp |= (uint64)*curr++;
        tmp <<= 8;
        tmp |= (uint64)*curr++;
        tmp <<= 8;
        tmp |= (uint64)*curr++;
        tmp <<= 8;
        tmp |= (uint64)*curr++;
        tmp <<= 8;
        tmp |= (uint64)*curr++;
        *pdata = tmp;
        serial->curr = (uint8*)curr;
#elif defined(SERIAL_NATIVE)
        *pdata = *((uint64*)serial->curr);
        serial->curr += 8;
#endif
    }
    else
    {
        ctl_serial_except( serial, "ctl_serial_read: Bound check failure" );
    }
}

void uint64_serial_peek(uint64* pdata, ctl_serial* serial )
{
    assertobjptr(serial);
    assertptr(pdata,sizeof(*pdata));
    {
        ctl_serial temp = *serial;
        uint64_serial_read( pdata, &temp );
    }
}

size_t uint64_serial_sizearray(const uint64* array, size_t count)
{
    size_t size = count * sizeof(uint64);
    assertconst(array,count*sizeof(array));
    return ctl_serial_size_size_size( size );
}

void uint64_serial_writearray(const uint64* array, size_t count, ctl_serial* serial )
{
    size_t size = count << 3;
    assertobjptr(serial);
    assertconst(array,count*sizeof(array));
    ctl_serial_writesize( size, serial );
    assert( serial->curr + size <= serial->end );
    {
        pointer_foreach_const(uint64,array,count, curr )
            uint64_serial_write(curr,serial);
    }
}


void uint64_serial_readarray(uint64* array, size_t count, ctl_serial* serial )
{
    size_t size;
    size_t serialCount;
    assertobjptr(serial);
    assertptr(array,count*sizeof(array));
    size = ctl_serial_readsize( serial );
    serialCount = size>>3;
    if( size & 7 )
        ctl_serial_except( serial, "uint64_serial_readarray: Odd size" );
    if( serialCount > count )
        serialCount = count;
    {
        pointer_foreach(uint64,array,serialCount, curr )
            uint64_serial_read(curr,serial);
    }
    if( serialCount < count )
    {
        size_t leftover = size - (count<<3);
        serial->curr += size - (count<<3);
        memset( array + count, 0, leftover );
    }
    else
    {
        serial->curr += size - (count<<3);
    }
}

size_t char_serial_size_string( const char* sz, size_t szmax )
{
    assertconst(sz,1);
    {
        size_t len = cstrnlen(char)(sz,szmax);
        return ctl_serial_size_size_size( len );
    }
}

size_t wchar_t_serial_size_string( const wchar_t* sz, size_t szmax )
{
    assertconst(sz,sizeof(wchar_t));
    {
        size_t len = cstrnlen(wchar_t)(sz,szmax) * 2;
        return ctl_serial_size_size_size( len );
    }
}

void char_serial_write_string( const char* sz, size_t szmax, ctl_serial* serial )
{
    size_t len;
    assertconst(sz,sizeof(char));
    assertobjptr(serial);
    len = cstrnlen(char)(sz,szmax);
    ctl_serial_writesize( (uint32)len, serial );
    assert( serial->curr + len <= serial->end );
    memcpy( serial->curr, sz, len );
    serial->curr += len;
}

void wchar_t_serial_write_string( const wchar_t* sz, size_t szmax, ctl_serial* serial )
{
    size_t count;
    assertconst(sz,sizeof(wchar_t));
    assertobjptr(serial);
    count = cstrnlen(wchar_t)(sz,szmax);
    ctl_serial_writesize( count*2, serial );
    assert( serial->curr + (count*2) <= serial->end );
    {
        uint16 ch;
        pointer_foreach_const(wchar_t,sz,count, curr )
        {
            ch = *curr;
            uint16_serial_write( &ch, serial );
        }
    }
}

void char_serial_read_string( char* sz, size_t szmax, ctl_serial* serial )
{
    size_t len;
    size_t toget;
    assertconst(sz,sizeof(char));
    assertobjptr(serial);
    len = ctl_serial_readsize( serial );
    toget = min(len,szmax);
    memcpy(sz,serial->curr,toget);
    if( toget < szmax )
        sz[toget] = 0;
    serial->curr += len;
}

void wchar_t_serial_read_string( wchar_t* sz, size_t count, ctl_serial* serial )
{
    size_t size;
    size_t readcount;
    assertconst(sz,sizeof(wchar_t));
    assertobjptr(serial);
    size = ctl_serial_readsize( serial );
    if( size & 1 )
        ctl_serial_except( serial, "ctl_serial_read_string: Odd size" );
    size>>=1;
    readcount = min(count,size);
    {
        pointer_foreach(wchar_t, sz, readcount, curr )
        {
            uint16 ch = 0;
            uint16_serial_read( &ch, serial );
            *curr = (wchar_t)ch;
        }
    }
    if( readcount < count )
        sz[readcount] = 0;
    serial->curr += (size-readcount)<<1;
}

void char_serial_read_gstring( ctl_gstring(char)* str, ctl_serial* serial )
{
    size_t msize;
    assertobjptr(str);
    assertobjptr(serial);
    msize = chslength(char,ctl_serial_peeksize( serial ));
    ctl_gstring_resize(char, str, msize );
    ppConcat(char,_serial_read_string)( str->begin, msize, serial );
}

void wchar_t_serial_read_gstring( ctl_gstring(wchar_t)* str, ctl_serial* serial )
{
    size_t msize;
    assertobjptr(str);
    assertobjptr(serial);
    msize = chslength(wchar_t,ctl_serial_peeksize( serial ));
    ctl_gstring_resize(wchar_t, str, msize );
    ppConcat(wchar_t,_serial_read_string)( str->begin, msize, serial );
}

void char_serial_read_fstring( ctl_gstring(char)* str, ctl_serial* serial )
{
    size_t msize;
    size_t maxsize;
    assertobjptr(str);
    assertobjptr(serial);
    msize = chslength(char,ctl_serial_peeksize( serial ));
    maxsize = ctl_fstring_maxsize(char,str);
    if( msize > maxsize )
        msize = maxsize;
    ppConcat(char,_serial_read_string)( str->begin, msize, serial );
}
void wchar_t_serial_read_fstring( ctl_gstring(wchar_t)* str, ctl_serial* serial )
{
    size_t msize;
    size_t maxsize;
    assertobjptr(str);
    assertobjptr(serial);
    msize = chslength(wchar_t,ctl_serial_peeksize( serial ));
    maxsize = ctl_fstring_maxsize(char,str);
    if( msize > maxsize )
        msize = maxsize;
    ppConcat(wchar_t,_serial_read_string)( str->begin, msize, serial );
}

void char_serial_peek_sconst( ctl_sconst( char )* str, ctl_serial* serial )
{
    size_t size;
    const char* pStr;
    assertobjptr(str);
    assertobjptr(serial);
    size = ctl_serial_peeksize( serial );
    pStr = (const char*)serial->curr + ctl_serial_size_size( size );
    ctl_sconst_init_pointers(char, str, pStr, pStr + size );
}
void wchar_t_serial_peek_sconst( ctl_sconst( wchar_t )* str, ctl_serial* serial )
{
    size_t size;
    const uint8* pStr;
    assertobjptr(str);
    assertobjptr(serial);
    size = ctl_serial_peeksize( serial );
    pStr = serial->curr + ctl_serial_size_size( size );
    if( size & 1 )
        ctl_serial_except( serial, "ctl_serial_peek_string: Odd size" );
    size>>=1;
    ctl_sconst_init_pointers(wchar_t, str, (wchar_t*)pStr, (wchar_t*)pStr + size );
}
void char_serial_read_sconst( ctl_sconst( char )* str, ctl_serial* serial )
{
    size_t size;
    const char* pStr;
    assertobjptr(str);
    assertobjptr(serial);
    size = ctl_serial_readsize( serial );
    pStr = (const char*)serial->curr;
    ctl_sconst_init_pointers(char, str, pStr, pStr + size );
    serial->curr += size;
}
void wchar_t_serial_read_sconst( ctl_sconst( wchar_t )* str, ctl_serial* serial )
{
    size_t size;
    const uint8* pStr;
    assertobjptr(str);
    assertobjptr(serial);
    size = ctl_serial_readsize( serial );
    pStr = serial->curr;
    if( size & 1 )
        ctl_serial_except( serial, "ctl_serial_read_string: Odd size" );
    size>>=1;
    ctl_sconst_init_pointers(wchar_t, str, (wchar_t*)pStr, (wchar_t*)pStr + size );
    serial->curr += size;
}