source: vbox/trunk/src/VBox/GuestHost/OpenGL/util/string.c@ 53090

/* Copyright (c) 2001, Stanford University
 * All rights reserved
 *
 * See the file LICENSE.txt for information on redistributing this software.
 */

#include "cr_mem.h"
#include "cr_string.h"
#include "cr_error.h"

#include <string.h>
#include <stdio.h>
#include <stdlib.h>

int crStrlen( const char *str )
{
        const char *temp;
        if (!str) return 0;
        for (temp = str ; *temp ; temp++);
        return temp-str;
}

char *crStrdup( const char *str )
{
        int len;
        char *ret;
        
        /* Allow strdup'ing of NULL strings -- this makes the __fillin functions 
         * much cleaner. */
        
        if (str == NULL) return NULL;
        
        len = crStrlen(str);
        ret = (char*)crAlloc( len+1 );
        crMemcpy( ret, str, len );
        ret[len] = '\0';
        return ret;
}

char *crStrndup( const char *str, unsigned int len )
{
        char *ret = (char*)crAlloc( len+1 );
        crMemcpy( ret, str, len );
        ret[len] = '\0';
        return ret;
}

int crStrcmp( const char *str1, const char *str2 )
{
        while (*str1 && *str2)
        {
                if (*str1 != *str2)
                {
                        break;
                }
                str1++; str2++;
        }
        return (*str1 - *str2);
}

int crStrncmp( const char *str1, const char *str2, int n )
{
        int i = 0;
        while (*str1 && *str2 && i < n)
        {
                if (*str1 != *str2)
                {
                        break;
                }
                str1++; str2++; i++;
        }
        if (i == n) return 0;
        return (*str1 - *str2);
}

static char lowercase[256] = {
        '\000', '\001', '\002', '\003', '\004', '\005', '\006', '\007', 
        '\010', '\011', '\012', '\013', '\014', '\015', '\016', '\017', 
        '\020', '\021', '\022', '\023', '\024', '\025', '\026', '\027', 
        '\030', '\031', '\032', '\033', '\034', '\035', '\036', '\037', 
        '\040', '\041', '\042', '\043', '\044', '\045', '\046', '\047', 
        '\050', '\051', '\052', '\053', '\054', '\055', '\056', '\057', 
        '\060', '\061', '\062', '\063', '\064', '\065', '\066', '\067', 
        '\070', '\071', '\072', '\073', '\074', '\075', '\076', '\077', 
        '\100', '\141', '\142', '\143', '\144', '\145', '\146', '\147', 
        '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157', 
        '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167', 
        '\170', '\171', '\172', '\133', '\134', '\135', '\136', '\137', 
        '\140', '\141', '\142', '\143', '\144', '\145', '\146', '\147', 
        '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157', 
        '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167', 
        '\170', '\171', '\172', '\173', '\174', '\175', '\176', '\177', 
        '\200', '\201', '\202', '\203', '\204', '\205', '\206', '\207', 
        '\210', '\211', '\212', '\213', '\214', '\215', '\216', '\217', 
        '\220', '\221', '\222', '\223', '\224', '\225', '\226', '\227', 
        '\230', '\231', '\232', '\233', '\234', '\235', '\236', '\237', 
        '\240', '\241', '\242', '\243', '\244', '\245', '\246', '\247', 
        '\250', '\251', '\252', '\253', '\254', '\255', '\256', '\257', 
        '\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267', 
        '\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277', 
        '\300', '\301', '\302', '\303', '\304', '\305', '\306', '\307', 
        '\310', '\311', '\312', '\313', '\314', '\315', '\316', '\317', 
        '\320', '\321', '\322', '\323', '\324', '\325', '\326', '\327', 
        '\330', '\331', '\332', '\333', '\334', '\335', '\336', '\337', 
        '\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347', 
        '\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357', 
        '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367', 
        '\370', '\371', '\372', '\373', '\374', '\375', '\376', '\377' 
};

int crStrcasecmp( const char *str1, const char *str2 )
{
        while (*str1 && *str2)
        {
                if (lowercase[(int) *str1] != lowercase[(int) *str2])
                {
                        break;
                }
                str1++; str2++;
        }
        return (lowercase[(int) *str1] - lowercase[(int) *str2]);
}

void crStrcpy( char *dest, const char *src )
{
        while ((*dest++ = *src++))
                ;
}

void crStrncpy( char *dest, const char *src, unsigned int len )
{
        const unsigned int str_len = crStrlen(src);
        if (str_len > len - 1) {
                crMemcpy( dest, src, len );  /* NOTE: not null-terminated! */
        }
        else {
                crMemcpy( dest, src, str_len + 1 );  /* includes null terminator */
        }
}

void crStrcat( char *dest, const char *src )
{
        crStrcpy( dest + crStrlen(dest), src );
}

char *crStrjoin( const char *str1, const char *str2 )
{
        const int len1 = crStrlen(str1), len2 = crStrlen(str2);
        char *s = crAlloc(len1 + len2 + 1);
        if (s)
        {
                crMemcpy( s, str1, len1 );
                crMemcpy( s + len1, str2, len2 );
                s[len1 + len2] = '\0';
        }
        return s;
}

char *crStrjoin3( const char *str1, const char *str2, const char *str3 )
{
        const int len1 = crStrlen(str1), len2 = crStrlen(str2), len3 = crStrlen(str3);
        char *s = crAlloc(len1 + len2 + len3 + 1);
        if (s)
        {
                crMemcpy( s, str1, len1 );
                crMemcpy( s + len1, str2, len2 );
                crMemcpy( s + len1 + len2, str3, len3 );
                s[len1 + len2 + len3] = '\0';
        }
        return s;
}

char *crStrstr( const char *str, const char *pat )
{
        int pat_len = crStrlen( pat );
        const char *end = str + crStrlen(str) - pat_len;
        char first_char = *pat;
        if (!str) return NULL;
        for (; str <= end ; str++)
        {
                if (*str == first_char && !crMemcmp( str, pat, pat_len ))
                        return (char *) str;
        }
        return NULL;
}

char *crStrchr( const char *str, char c )
{
        for ( ; *str ; str++ )
        {
                if (*str == c)
                        return (char *) str;
        }
        return NULL;
}

char *crStrrchr( const char *str, char c )
{
        const char *temp = str + crStrlen( str );
        for ( ; temp >= str ; temp-- )
        {
                if (*temp == c)
                        return (char *) temp;
        }
        return NULL;
}

/* These functions are from the old wiregl net.c -- hexdumps?  Not sure quite yet. */
        
void crBytesToString( char *string, int nstring, void *data, int ndata )
{
        int i, offset;
        unsigned char *udata;

        offset = 0;
        udata = (unsigned char *) data;
        for ( i = 0; i < ndata && ( offset + 4 <= nstring ); i++ ) 
        {
                offset += sprintf( string + offset, "%02x ", udata[i] );
        }

        if ( i == ndata && offset > 0 )
                string[offset-1] = '\0';
        else
                crStrcpy( string + offset - 3, "..." );
}

void crWordsToString( char *string, int nstring, void *data, int ndata )
{
        int i, offset, ellipsis;
        unsigned int *udata;

        /* turn byte count into word count */
        ndata /= 4;

        /* we need an ellipsis if all the words won't fit in the string */
        ellipsis = ( ndata * 9 > nstring );
        if ( ellipsis )
        {
                ndata = nstring / 9;

                /* if the ellipsis won't fit then print one less word */
                if ( ndata * 9 + 3 > nstring )
                        ndata--;
        }
                
        offset = 0;
        udata = (unsigned int *) data;
        for ( i = 0; i < ndata; i++ ) 
        {
                offset += sprintf( string + offset, "%08x ", udata[i] );
        }

        if ( ellipsis )
                crStrcpy( string + offset, "..." );
        else if ( offset > 0 )
                string[offset-1] = 0;
}

int crStrToInt( const char *str )
{
        if (!str) return 0;

        return atoi(str);
}

float crStrToFloat( const char *str )
{
        if (!str) return 0.0f;

        return (float) atof(str);
}

static int __numOccurrences( const char *str, const char *substr )
{
        int ret = 0;
        char *temp = (char *) str;
        while ((temp = crStrstr( temp, substr )) != NULL )
        {
                temp += crStrlen(substr);
                ret++;
        }
        return ret;
}

/**
 * Split str into a NULL-terminated array of strings, using splitstr as
 * the separator.
 * It's the same as the Python call string.split(str, splitstr).
 * Note: crStrSplit("a b  c", " ") returns ["a", "b", "", "c", NULL] though!!!
 */
char **crStrSplit( const char *str, const char *splitstr )
{
        char  *temp = (char *) str;
        int num_args = __numOccurrences( str, splitstr ) + 1;
        char **faked_argv = (char **) crAlloc( (num_args + 1)*sizeof( *faked_argv ) );
        int i;

        for (i = 0 ; i < num_args ; i++)
        {
                char *end;
                end = crStrstr( temp, splitstr );
                if (!end)
                        end = temp + crStrlen( temp );
                faked_argv[i] = crStrndup( temp, end-temp );
                temp = end + crStrlen(splitstr);
        }
        faked_argv[num_args] = NULL;
        return faked_argv;
}

char **crStrSplitn( const char *str, const char *splitstr, int n )
{
        char **faked_argv;
        int i;
        char *temp = (char *) str;
        int num_args = __numOccurrences( str, splitstr );

        if (num_args > n)
                num_args = n;
        num_args++;

        faked_argv = (char **) crAlloc( (num_args + 1) * sizeof( *faked_argv ) );
        for (i = 0 ; i < num_args ; i++)
        {
                char *end;
                end = crStrstr( temp, splitstr );
                if (!end || i == num_args - 1 )
                        end = temp + crStrlen( temp );
                faked_argv[i] = crStrndup( temp, end-temp );
                temp = end + crStrlen(splitstr);
        }
        faked_argv[num_args] = NULL;
        return faked_argv;
}

/* Free an array of strings, as returned by crStrSplit() and crStrSplitn(). */
void crFreeStrings( char **strings )
{
        int i;
        for (i = 0; strings[i]; i++) {
                crFree(strings[i]);
        }
        crFree(strings);
}


/* Intersect two strings on a word-by-word basis (separated by spaces).
 * We typically use this to intersect OpenGL extension strings.
 * Example: if s1 = "apple banana plum pear"
 *         and s2 = "plum banana orange"
 *      then return "banana plum" (or "plum banana").
 */
char *crStrIntersect( const char *s1, const char *s2 )
{
        int len1, len2;
        int resultLen;
        char *result;
        char **exten1, **exten2;
        int i, j;

        if (!s1 || !s2) {
                /* null strings, no intersection */
                return NULL;
        }

        len1 = crStrlen(s1);
        len2 = crStrlen(s2);

        /* allocate storage for result (a conservative estimate) */
        resultLen = ((len1 > len2) ? len1 : len2) + 2;
        result = (char *) crAlloc(resultLen);
        if (!result)
        {
                return NULL;
        }
        result[0] = 0;

        /* split s1 and s2 at space chars */
        exten1 = crStrSplit(s1, " ");
        exten2 = crStrSplit(s2, " ");

        for (i = 0; exten1[i]; i++)
        {
                for (j = 0; exten2[j]; j++)
                {
                        if (crStrcmp(exten1[i], exten2[j]) == 0)
                        {
                                /* found an intersection, append to result */
                                crStrcat(result, exten1[i]);
                                crStrcat(result, " ");
                                break;
                        }
                }
        }

        /* free split strings */
        crFreeStrings( exten1 );
        crFreeStrings( exten2 );

        /*CRASSERT(crStrlen(result) < resultLen);*/

        /* all done! */
        return result;
}


int crIsDigit(char c)
{
  return c >= '0' && c <= '9';
}


static int crStrParseGlSubver(const char * ver, const char ** pNext, bool bSpacePrefixAllowed)
{
    const char * initVer = ver;
    int val = 0;

    for(;;++ver)
    {
        if(*ver >= '0' && *ver <= '9')
        {
            if(!val)
            {
                if(*ver == '0')
                    continue;
            }
            else
            {
                val *= 10;
            }
            val += *ver - '0';
        }
        else if(*ver == '.')
        {
            *pNext = ver+1;
            break;
        }
        else if(*ver == '\0')
        {
            *pNext = NULL;
            break;
        }
        else if(*ver == ' ' || *ver == '\t' ||  *ver == 0x0d || *ver == 0x0a)
        {
            if(bSpacePrefixAllowed)
            {
                if(!val)
                {
                    continue;
                }
            }

            /* treat this as the end of version string */
            *pNext = NULL;
            break;
        }
        else
        {
            crWarning("error parsing version %s", initVer);
            val = -1;
            break;
        }
    }

    return val;
}

int crStrParseGlVersion(const char * ver)
{
    const char * initVer = ver;
    int tmp;
    int iVer = crStrParseGlSubver(ver, &ver, true);
    if(iVer <= 0)
    {
        crWarning("parsing major version returned %d, '%s'", iVer, initVer);
        return iVer;
    }

    if (iVer > CR_GLVERSION_MAX_MAJOR)
    {
        crWarning("major version %d is bigger than the max supported %#x, this is somewhat not expected, failing", iVer, CR_GLVERSION_MAX_MAJOR);
        return -1;
    }

    iVer <<= CR_GLVERSION_OFFSET_MAJOR;
    if(!ver)
    {
        crDebug("no minor version supplied");
        goto done;
    }

    tmp = crStrParseGlSubver(ver, &ver, false);
    if (tmp < 0)
    {
        crWarning("parsing minor version failed, '%s'", initVer);
        return -1;
    }

    if (tmp > CR_GLVERSION_MAX_MINOR)
    {
        crWarning("minor version %d is bigger than the max supported %#x, this is somewhat not expected, failing", iVer, CR_GLVERSION_MAX_MAJOR);
        return -1;
    }

    iVer |= tmp << CR_GLVERSION_OFFSET_MINOR;

    if (!ver)
    {
        crDebug("no build version supplied");
        goto done;
    }

    tmp = crStrParseGlSubver(ver, &ver, false);
    if (tmp < 0)
    {
        crWarning("parsing build version failed, '%s', using 0", initVer);
        tmp = 0;
    }

    if (tmp > CR_GLVERSION_MAX_BUILD)
    {
        crWarning("build version %d is bigger than the max supported, using max supported val %#x", tmp, CR_GLVERSION_MAX_BUILD);
        tmp = CR_GLVERSION_MAX_MAJOR;
    }

    iVer |= tmp << CR_GLVERSION_OFFSET_BUILD;

done:
    crDebug("returning version %#x for string '%s'", iVer, initVer);

    return iVer;
}

int32_t crStrParseI32(const char *pszStr, const int32_t defaultVal)
{
    int32_t result = 0;
    bool neg = false;
    unsigned char iDigit = 0;
    if (!pszStr || pszStr[0] == '\0')
        return defaultVal;

    for (;;)
    {
        if (pszStr[0] == '\0')
            return defaultVal;

        if (pszStr[0] == ' ' || pszStr[0] == '\t' || pszStr[0] == '\n')
        {
            ++pszStr;
            continue;
        }

        if (pszStr[0] == '-')
        {
            if (neg)
                return defaultVal;

            neg = true;
            ++pszStr;
            continue;
        }

        break;
    }

    for (;;)
    {
        unsigned char digit;
        if (pszStr[0] == '\0')
        {
            if (!iDigit)
                return defaultVal;
            break;
        }

        digit = pszStr[0] - '0';
        if (digit > 9)
            return defaultVal;

        result *= 10;
        result += digit;
        ++iDigit;

        ++pszStr;
    }

    return !neg ? result : -result;
}