/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997-2006 Sam Lantinga

    This library is free software; you can redistribute it and/or

    modify it under the terms of the GNU Lesser General Public

    License as published by the Free Software Foundation; either

    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public

    License along with this library; if not, write to the Free Software

    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    Sam Lantinga

    slouken@libsdl.org

*/

#include "SDL_config.h"

/* This file contains portable string manipulation functions for SDL */

#include "SDL_stdinc.h"

#define SDL_isupperhex(X)   (((X) >= 'A') && ((X) <= 'F'))

#define SDL_islowerhex(X)   (((X) >= 'a') && ((X) <= 'f'))

#if !defined(HAVE_SSCANF) || !defined(HAVE_STRTOL)

static size_t SDL_ScanLong(const char *text, int radix, long *valuep)

{

    const char *textstart = text;

    long value = 0;

    SDL_bool negative = SDL_FALSE;

    if ( *text == '-' ) {

        negative = SDL_TRUE;

        ++text;

    }

    if ( radix == 16 && SDL_strncmp(text, "0x", 2) == 0 ) {

        text += 2;

    }

    for ( ; ; ) {

        int v;

        if ( SDL_isdigit((unsigned char) *text) ) {

            v = *text - '0';

        } else if ( radix == 16 && SDL_isupperhex(*text) ) {

            v = 10 + (*text - 'A');

        } else if ( radix == 16 && SDL_islowerhex(*text) ) {

            v = 10 + (*text - 'a');

        } else {

            break;

        }

        value *= radix;

        value += v;

        ++text;

    }

    if ( valuep ) {

        if ( negative && value ) {

            *valuep = -value;

        } else {

            *valuep = value;

        }

    }

    return (text - textstart);

}

#endif

#if !defined(HAVE_SSCANF) || !defined(HAVE_STRTOUL) || !defined(HAVE_STRTOD)

static size_t SDL_ScanUnsignedLong(const char *text, int radix, unsigned long *valuep)

{

    const char *textstart = text;

    unsigned long value = 0;

    if ( radix == 16 && SDL_strncmp(text, "0x", 2) == 0 ) {

        text += 2;

    }

    for ( ; ; ) {

        int v;

        if ( SDL_isdigit((unsigned char) *text) ) {

            v = *text - '0';

        } else if ( radix == 16 && SDL_isupperhex(*text) ) {

            v = 10 + (*text - 'A');

        } else if ( radix == 16 && SDL_islowerhex(*text) ) {

            v = 10 + (*text - 'a');

        } else {

            break;

        }

        value *= radix;

        value += v;

        ++text;

    }

    if ( valuep ) {

        *valuep = value;

    }

    return (text - textstart);

}

#endif

#ifndef HAVE_SSCANF

static size_t SDL_ScanUintPtrT(const char *text, int radix, uintptr_t *valuep)

{

    const char *textstart = text;

    uintptr_t value = 0;

    if ( radix == 16 && SDL_strncmp(text, "0x", 2) == 0 ) {

        text += 2;

    }

    for ( ; ; ) {

        int v;

        if ( SDL_isdigit((unsigned char) *text) ) {

            v = *text - '0';

        } else if ( radix == 16 && SDL_isupperhex(*text) ) {

            v = 10 + (*text - 'A');

        } else if ( radix == 16 && SDL_islowerhex(*text) ) {

            v = 10 + (*text - 'a');

        } else {

            break;

        }

        value *= radix;

        value += v;

        ++text;

    }

    if ( valuep ) {

        *valuep = value;

    }

    return (text - textstart);

}

#endif

#ifdef SDL_HAS_64BIT_TYPE

#if !defined(HAVE_SSCANF) || !defined(HAVE_STRTOLL)

static size_t SDL_ScanLongLong(const char *text, int radix, Sint64 *valuep)

{

    const char *textstart = text;

    Sint64 value = 0;

    SDL_bool negative = SDL_FALSE;

    if ( *text == '-' ) {

        negative = SDL_TRUE;

        ++text;

    }

    if ( radix == 16 && SDL_strncmp(text, "0x", 2) == 0 ) {

        text += 2;

    }

    for ( ; ; ) {

        int v;

        if ( SDL_isdigit((unsigned char) *text) ) {

            v = *text - '0';

        } else if ( radix == 16 && SDL_isupperhex(*text) ) {

            v = 10 + (*text - 'A');

        } else if ( radix == 16 && SDL_islowerhex(*text) ) {

            v = 10 + (*text - 'a');

        } else {

            break;

        }

        value *= radix;

        value += v;

        ++text;

    }

    if ( valuep ) {

        if ( negative && value ) {

            *valuep = -value;

        } else {

            *valuep = value;

        }

    }

    return (text - textstart);

}

#endif

#if !defined(HAVE_SSCANF) || !defined(HAVE_STRTOULL)

static size_t SDL_ScanUnsignedLongLong(const char *text, int radix, Uint64 *valuep)

{

    const char *textstart = text;

    Uint64 value = 0;

    if ( radix == 16 && SDL_strncmp(text, "0x", 2) == 0 ) {

        text += 2;

    }

    for ( ; ; ) {

        int v;

        if ( SDL_isdigit((unsigned char) *text) ) {

            v = *text - '0';

        } else if ( radix == 16 && SDL_isupperhex(*text) ) {

            v = 10 + (*text - 'A');

        } else if ( radix == 16 && SDL_islowerhex(*text) ) {

            v = 10 + (*text - 'a');

        } else {

            break;

        }

        value *= radix;

        value += v;

        ++text;

    }

    if ( valuep ) {

        *valuep = value;

    }

    return (text - textstart);

}

#endif

#endif /* SDL_HAS_64BIT_TYPE */

#if !defined(HAVE_SSCANF) || !defined(HAVE_STRTOD)

static size_t SDL_ScanFloat(const char *text, double *valuep)

{

    const char *textstart = text;

    unsigned long lvalue = 0;

    double value = 0.0;

    SDL_bool negative = SDL_FALSE;

    if ( *text == '-' ) {

        negative = SDL_TRUE;

        ++text;

    }

    text += SDL_ScanUnsignedLong(text, 10, &lvalue);

    value += lvalue;

    if ( *text == '.' ) {

        int mult = 10;

        ++text;

        while ( SDL_isdigit((unsigned char) *text) ) {

            lvalue = *text - '0';

            value += (double)lvalue / mult;

            mult *= 10;

            ++text;

        }

    }

    if ( valuep ) {

        if ( negative && value ) {

            *valuep = -value;

        } else {

            *valuep = value;

        }

    }

    return (text - textstart);

}

#endif

#ifndef SDL_memset

void *SDL_memset(void *dst, int c, size_t len)

{

    size_t left = (len % 4);

    if ( len >= 4 ) {

        Uint32 value = 0;

        Uint32 *dstp = (Uint32 *)dst;

        int i;

        for (i = 0; i < 4; ++i) {

            value <<= 8;

            value |= c;

        }

        len /= 4;

        while ( len-- ) {

            *dstp++ = value;

        }

    }

    if ( left > 0 ) {

        Uint8 value = (Uint8)c;

        Uint8 *dstp = (Uint8 *)dst;

	switch(left) {

	case 3:

            *dstp++ = value;

	case 2:

            *dstp++ = value;

	case 1:

            *dstp++ = value;

        }

    }

    return dst;

}

#endif

#ifndef SDL_memcpy

void *SDL_memcpy(void *dst, const void *src, size_t len)

{

    char *srcp = (char *)src;

    char *dstp = (char *)dst;

    while ( len-- ) {

        *dstp++ = *srcp++;

    }

    return dst;

}

#endif

#ifndef SDL_revcpy

void *SDL_revcpy(void *dst, const void *src, size_t len)

{

    char *srcp = (char *)src;

    char *dstp = (char *)dst;

    srcp += len-1;

    dstp += len-1;

    while ( len-- ) {

        *dstp-- = *srcp--;

    }

    return dst;

}

#endif

#ifndef SDL_memcmp

int SDL_memcmp(const void *s1, const void *s2, size_t len)

{

    char *s1p = (char *)s1;

    char *s2p = (char *)s2;

    while ( len-- ) {

        if ( *s1p != *s2p ) {

            return (*s1p - *s2p);

    }

    ++s1p;

    ++s2p;

    }

    return 0;

}

#endif

#ifndef HAVE_STRLEN

size_t SDL_strlen(const char *string)

{

    size_t len = 0;

    while ( *string++ ) {

        ++len;

    }

    return len;

}

#endif

#ifndef HAVE_STRLCPY

size_t SDL_strlcpy(char *dst, const char *src, size_t maxlen)

{

    size_t srclen = SDL_strlen(src);

    if ( maxlen > 0 ) {

        size_t len = SDL_min(srclen, maxlen-1);

        SDL_memcpy(dst, src, len);

        dst[len] = '\0';

    }

    return srclen;

}

#endif

#ifndef HAVE_STRLCAT

size_t SDL_strlcat(char *dst, const char *src, size_t maxlen)

{

    size_t dstlen = SDL_strlen(dst);

    size_t srclen = SDL_strlen(src);

    if ( dstlen < maxlen ) {

        SDL_strlcpy(dst+dstlen, src, maxlen-dstlen);

    }

    return dstlen+srclen;

}

#endif

#ifndef HAVE_STRDUP

char *SDL_strdup(const char *string)

{

    size_t len = SDL_strlen(string)+1;

    char *newstr = SDL_malloc(len);

    if ( newstr ) {

        SDL_strlcpy(newstr, string, len);

    }

    return newstr;

}

#endif

#ifndef HAVE__STRREV

char *SDL_strrev(char *string)

{

    size_t len = SDL_strlen(string);

    char *a = &string[0];

    char *b = &string[len-1];

    len /= 2;

    while ( len-- ) {

        char c = *a;

        *a++ = *b;

        *b-- = c;

    }

    return string;

}

#endif

#ifndef HAVE__STRUPR

char *SDL_strupr(char *string)

{

    char *bufp = string;

    while ( *bufp ) {

        *bufp = SDL_toupper((unsigned char) *bufp);

	++bufp;

    }

    return string;

}

#endif

#ifndef HAVE__STRLWR

char *SDL_strlwr(char *string)

{

    char *bufp = string;

    while ( *bufp ) {

        *bufp = SDL_tolower((unsigned char) *bufp);

	++bufp;

    }

    return string;

}

#endif

#ifndef HAVE_STRCHR

char *SDL_strchr(const char *string, int c)

{

    while ( *string ) {

        if ( *string == c ) {

            return (char *)string;

        }

	++string;

    }

    return NULL;

}

#endif

#ifndef HAVE_STRRCHR

char *SDL_strrchr(const char *string, int c)

{

    const char *bufp = string + SDL_strlen(string) - 1;

    while ( bufp >= string ) {

        if ( *bufp == c ) {

            return (char *)bufp;

        }

	--bufp;

    }

    return NULL;

}

#endif

#ifndef HAVE_STRSTR

char *SDL_strstr(const char *haystack, const char *needle)

{

    size_t length = SDL_strlen(needle);

    while ( *haystack ) {

        if ( SDL_strncmp(haystack, needle, length) == 0 ) {

            return (char *)haystack;

        }

	++haystack;

    }

    return NULL;

}

#endif

#if !defined(HAVE__LTOA)  || !defined(HAVE__I64TOA) || \

    !defined(HAVE__ULTOA) || !defined(HAVE__UI64TOA)

static const char ntoa_table[] = {

    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',

    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',

    'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',

    'U', 'V', 'W', 'X', 'Y', 'Z'

};

#endif /* ntoa() conversion table */

#ifndef HAVE__LTOA

char *SDL_ltoa(long value, char *string, int radix)

{

    char *bufp = string;

    if ( value < 0 ) {

        *bufp++ = '-';

        value = -value;

    }

    if ( value ) {

        while ( value > 0 ) {

            *bufp++ = ntoa_table[value % radix];

            value /= radix;

        }

    } else {

        *bufp++ = '0';

    }

    *bufp = '\0';

    /* The numbers went into the string backwards. :) */

    if ( *string == '-' ) {

        SDL_strrev(string+1);

    } else {

        SDL_strrev(string);

    }

    return string;

}

#endif

#ifndef HAVE__ULTOA

char *SDL_ultoa(unsigned long value, char *string, int radix)

{

    char *bufp = string;

    if ( value ) {

        while ( value > 0 ) {

            *bufp++ = ntoa_table[value % radix];

            value /= radix;

        }

    } else {

        *bufp++ = '0';

    }

    *bufp = '\0';

    /* The numbers went into the string backwards. :) */

    SDL_strrev(string);

    return string;

}

#endif

#ifndef HAVE_STRTOL

long SDL_strtol(const char *string, char **endp, int base)

{

    size_t len;

    long value;

    if ( !base ) {

        if ( (SDL_strlen(string) > 2) && (SDL_strncmp(string, "0x", 2) == 0) ) {

            base = 16;

        } else {

            base = 10;

        }

    }

    len = SDL_ScanLong(string, base, &value);

    if ( endp ) {

        *endp = (char *)string + len;

    }

    return value;

}

#endif