yc_string.c

一个类STL的多平台可移植的算法容器库,主要用于嵌入式系统编程时的内存管理等方面

        if( self->strobj.m_ncstr.len + count <= STATIC_NCSTR_LEN )
        {
            ylib_memcopy( self->strobj.m_ncstr.data + index + count,
                          self->strobj.m_ncstr.data + index,
                          (self->strobj.m_ncstr.len - index) * sizeof(char) );
            ylib_memcopy( self->strobj.m_ncstr.data + index, src,
                          sizeof(char) * count );
            self->strobj.m_ncstr.len += (unsigned char)count;
        }
        else
        {
            if( false == static_to_dynamic(self, self->strobj.m_ncstr.len
                                           + count, false) )
                return false;
            return dymemarr_insert_array( &(self->strobj.m_dystr), index,
                                          src, count );
        }
    }

    return true;
}

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

bool ncstr_resize( ncstring* self, size_t new_length, const char value )
{
    if( true == self->m_dynamic )
        return dymemarr_resize( &(self->strobj.m_dystr), new_length, &value );
    else
    {
        if( new_length < (size_t)(self->strobj.m_ncstr.len) )
            ncstr_erase_range( self, new_length, self->strobj.m_ncstr.len );
        else if( new_length > (size_t)(self->strobj.m_ncstr.len) )
            return ncstr_insert_value( self, self->strobj.m_ncstr.len, value,
                                       new_length - self->strobj.m_ncstr.len );
    }

    return true;
}

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

bool ncstr_replace_fill( ncstring* self, size_t index, size_t old_count,
                         const char value, size_t new_count )
{
    size_t new_len, old_len = ncstr_size( self );

    if( index > old_len )
        return false;

    if( true == self->m_dynamic )
        return dymemarr_replace_fill( &(self->strobj.m_dystr), index,
                                      old_count, &value, new_count );
    else
    {
        if( old_count > old_len - index )
            old_count = old_len - index;

        if( old_len - old_count > ncstr_max_size() - new_count )
            return false;

        new_len = old_len - old_count + new_count;

        if( new_len <= STATIC_NCSTR_LEN )
        {
            ylib_memmove( self->strobj.m_ncstr.data + index + new_count,
                          self->strobj.m_ncstr.data + index + old_count,
                          (old_len - index - old_count) * sizeof(char) );
            ylib_memset( self->strobj.m_ncstr.data + index, value,
                         sizeof(char) * new_count );
            self->strobj.m_ncstr.len = (unsigned char)new_len;
        }
        else
        {
            if( false == static_to_dynamic(self, new_len, false) )
                return false;
            return dymemarr_replace_fill( &(self->strobj.m_dystr), index,
                                          old_count, &value, new_count );
        }
    }

    return true;
}

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

bool ncstr_replace_array( ncstring* self, size_t index, size_t old_count,
                          const char* src, size_t new_count )
{
    size_t new_len, old_len = ncstr_size( self );

    if( index > old_len )
        return false;

    if( true == self->m_dynamic )
        return dymemarr_replace_array( &(self->strobj.m_dystr), index,
                                       old_count, src, new_count );
    else
    {
        if( old_count > old_len - index )
            old_count = old_len - index;

        if( old_len - old_count > ncstr_max_size() - new_count )
            return false;

        new_len = old_len - old_count + new_count;

        if( new_len <= STATIC_NCSTR_LEN )
        {
            ylib_memmove( self->strobj.m_ncstr.data + index + new_count,
                          self->strobj.m_ncstr.data + index + old_count,
                          (old_len - index - old_count) * sizeof(char) );
            ylib_memcopy( self->strobj.m_ncstr.data + index, src,
                          sizeof(char) * new_count );
            self->strobj.m_ncstr.len = (unsigned char)new_len;
        }
        else
        {
            if( false == static_to_dynamic(self, new_len, false) )
                return false;
            return dymemarr_replace_array( &(self->strobj.m_dystr), index,
                                           old_count, src, new_count );
        }
    }

    return true;
}

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

bool ncstr_trim( ncstring* self, size_t index, const char* chars, size_t count )
{
    size_t len = ncstr_size( self );

    if( index >= len )
        return false;
    else
    {
        size_t i;
        char *d, *s = ncstr_index( self, index );

        for( ; index < len; ++index,++s )
        {
            for( i = 0; i < count; ++i )
            {
                if( chars[i] == *s )
                    break;
            }
            if( i != count )
                break;
        }

        if( index < len )
        {
            for( d = s; index < len; ++index )
            {
                for( i = 0; i < count; ++i )
                {
                    if( chars[i] == *s )
                        break;
                }
                if( i != count )
                    ++s;
                else
                    *d++ = *s++;
            }

            if( true == self->m_dynamic )
                self->strobj.m_dystr.m_finish = d;
            else
                self->strobj.m_ncstr.len = d - self->strobj.m_ncstr.data;
        }
    }

    return true;
}

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

static int _stoi( const char** s )
{
    int i = 0;

    while( isdigit(**s) )
        i = i * 10 + *((*s)++) - '0';

    return i;
}

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

/* format：%[flags] [width] .[precision] [qualifier] [type_char] */
bool ncstr_format( ncstring* self, const char* format, ... )
{
    va_list args, arg;
    const char* fmt = format;
    size_t count = 0, len = 0;
    int width, precision, qualifier, result;

    if( false == self->m_dynamic )
        self->strobj.m_ncstr.len = 0;
    else
        dymemarr_erase_range( &(self->strobj.m_dystr), 0, SIZE_MAX );

    va_start( args, format );
    va_start( arg, format );

    for( ; *fmt; ++fmt )
    {
        if( '%' != *fmt )
        {
            ++count;
            continue;
        }

GET_NEXT:
        switch( *(++fmt) )
        {
            case '-':
                goto GET_NEXT;
            case '0':
                goto GET_NEXT;
            case '+':
                goto GET_NEXT;
            case ' ':
                goto GET_NEXT;
            case '#':
                count += 2;
                goto GET_NEXT;
        }

        width = 0;
        if( isdigit(*fmt) )
            width = _stoi( &fmt );
        else if( '*' == *fmt )
        {
            width = va_arg( args, int );
            if( width < 0 )
                width = -width;
        }

        precision = -1;
        if( '.' == *fmt )
        {
            ++fmt;
            if( isdigit(*fmt) )
                precision = _stoi( &fmt );
            else if( '*' == *fmt )
                precision = va_arg( args, int );
            if( precision < 0 )
                precision = 0;
        }

        qualifier = 0;
        if( 'h' == *fmt || 'l' == *fmt || 'L' == *fmt )
        {
            qualifier = *fmt;
            ++fmt;
        }

        switch( *fmt )
        {
            case 'c':
                len = width > 1 ? width : 1;
                break;
            case 's':
            {
                char* s = va_arg( args, char* );
                len = s ? strlen(s) : 6; /* "<null>" */
                if( (int)len > precision )
                    len = precision;
                if( (int)len < width )
                    len = width;
                break;
            }
            case 'd':
            case 'i':
            case 'u':
            case 'o':
                if( 'l' == qualifier )
                    len = sizeof(long) * 3;
                else if( 'h' == qualifier )
                    len = sizeof(short) * 3;
                else
                    len = sizeof(int) * 3;
                if( (int)len < precision)
                    len = precision;
                len += 2;
                break;
            case 'x':
            case 'X':
                if( 'l' == qualifier )
                    len = sizeof(long) * 2;
                else if( 'h' == qualifier )
                    len = sizeof(short) * 2;
                else
                    len = sizeof(int) * 2;
                if( (int)len < precision)
                    len = precision;
                len += 2;
                break;
            case 'p':
                len = sizeof(void*) * 2 + 4;
                break;
            case 'f':
            case 'F':
                len = (size_t)( LDBL_MAX_10_EXP * 2 /* 浮点数的整数加小数最大占用的位数 */
                                + 16 /* 符号、小数点等 */
                                + precision );
                break;
            case 'g':
            case 'G':
            case 'e':
            case 'E':
                len = width + precision + 12;
                if( len < 63 )
                    len = 63;
                break;
            case '#':
                len = 1;
            default:
                len = 0;
                break;
        }   /* end switch */

        count += len;
    } /* end for */

    if( false == ncstr_reserve(self, count) )
        return false;

    result = vsprintf( false == self->m_dynamic ? self->strobj.m_ncstr.data
                       : (char*)(self->strobj.m_dystr.m_start), format, arg );
    if( result < 0 )
        result = 0;

    if( false == self->m_dynamic )
        self->strobj.m_ncstr.len = (unsigned char)result;
    else
        self->strobj.m_dystr.m_finish = (char*)(self->strobj.m_dystr.m_start)
                                        + result;

    va_end( arg );
    return true;
}

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

#ifdef __MACRO_C_YOUNG_LIBRARY_COMPILER_SUPPORT_C95_WIDE_CHARACTER__
void ncstr_to_wcstr( ncstring* self )
{
    char* str_end;
    wchar_t* wstr_end;
    size_t i, len = ncstr_size( self );

    ncstr_reserve( self, sizeof(wchar_t) * len );

    str_end = ncstr_end( self );
    wstr_end = (wchar_t*)( ncstr_begin(self) + sizeof(wchar_t) * len );

    for( i = 0; i < len; ++i )
        *--wstr_end = *--str_end;

    if( true == self->m_dynamic )
        self->strobj.m_dystr.m_finish = (wchar_t*)(self->strobj.m_dystr.m_start)
                                        + len;
}
#endif

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

#ifdef __MACRO_C_YOUNG_LIBRARY_COMPILER_SUPPORT_INPUT_OUTPUT_SYSTEM__
void ncstr_put( ncstring* self )
{
    size_t len = ncstr_size( self );
    char* str = ncstr_begin( self );

    for( ; len > 0; --len,++str )
        putchar( *str );
}

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

bool ncstr_getline( ncstring* self, const char delimiter )
{
    char c = 0;
    bool result = true;

    if( false == self->m_dynamic )
        self->strobj.m_ncstr.len = 0;
    else
        dymemarr_erase_range( &(self->strobj.m_dystr), 0, SIZE_MAX );

    while( EOF != (c = (char)getchar()) && c != delimiter )
    {
        if( false == self->m_dynamic )
        {
            if( self->strobj.m_ncstr.len < STATIC_NCSTR_LEN )
            {
                self->strobj.m_ncstr.data[self->strobj.m_ncstr.len] = c;
                ++( self->strobj.m_ncstr.len );
                continue;
            }
            else
            {
                if( false == static_to_dynamic( self, STATIC_NCSTR_LEN + 1,
                                                false ) )
                    return false;
            }
        }

        DYMEMARR_PUSH_BACK( self->strobj.m_dystr, c, char, result );

        if( false == result )
            return false;
    }

    return true;
}
#endif  /* SUPPORT_IO_SYSTEM */

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

#ifdef __MACRO_C_YOUNG_LIBRARY_COMPILER_SUPPORT_FILE_SYSTEM__
bool ncstr_fgetline( ncstring* self, FILE* fp, const char delimiter )
{
    char c = 0;
    bool result = true;

    if( false == self->m_dynamic )
        self->strobj.m_ncstr.len = 0;
    else
        dymemarr_erase_range( &(self->strobj.m_dystr), 0, SIZE_MAX );

    if( feof(fp) )
        return true;

    while( EOF != (c = (char)getc(fp)) && c != delimiter )
    {
        if( false == self->m_dynamic )
        {
            if( self->strobj.m_ncstr.len < STATIC_NCSTR_LEN )
            {
                self->strobj.m_ncstr.data[self->strobj.m_ncstr.len] = c;
                ++( self->strobj.m_ncstr.len );
                continue;