/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997-2009 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_WCSLEN

size_t

SDL_wcslen(const wchar_t * 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;