/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997-2011 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'))

#define UTF8_IsLeadByte(c) ((c) >= 0xC0 && (c) <= 0xF4)

#define UTF8_IsTrailingByte(c) ((c) >= 0x80 && (c) <= 0xBF)

int UTF8_TrailingBytes(unsigned char c)

{

    if (c >= 0xC0 && c<= 0xDF)

        return 1;

    else if (c >= 0xE0 && c <= 0xEF)

        return 2;

    else if (c >= 0xF0 && c <= 0xF4)

        return 3;

    else

        return 0;

}

#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);

    Uint32 *dstp4;

    Uint8 *dstp1;

    Uint32 value4 = (c | (c << 8) | (c << 16) | (c << 24));

    Uint8 value1 = (Uint8) c;

    dstp4 = (Uint32 *) dst;

    len /= 4;

    while (len--) {

        *dstp4++ = value4;

    }

    dstp1 = (Uint8 *) dstp4;

    switch (left) {

    case 3:

        *dstp1++ = value1;

    case 2:

        *dstp1++ = value1;

    case 1:

        *dstp1++ = value1;

    }

    return dst;

}

#endif

#ifndef SDL_memcpy

void *

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

{

    size_t left = (len % 4);

    Uint32 *srcp4, *dstp4;

    Uint8 *srcp1, *dstp1;

    srcp4 = (Uint32 *) src;

    dstp4 = (Uint32 *) dst;

    len /= 4;

    while (len--) {

        *dstp4++ = *srcp4++;

    }

    srcp1 = (Uint8 *) srcp4;

    dstp1 = (Uint8 *) dstp4;

    switch (left) {

    case 3:

        *dstp1++ = *srcp1++;

    case 2:

        *dstp1++ = *srcp1++;

    case 1:

        *dstp1++ = *srcp1++;

    }

    return dst;

}

#endif

#ifndef SDL_memmove

void *

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

{

    char *srcp = (char *) src;

    char *dstp = (char *) dst;

    if (src < dst) {

        srcp += len - 1;

        dstp += len - 1;

        while (len--) {

            *dstp-- = *srcp--;

        }

    } else {

        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_WCSLCPY

size_t

SDL_wcslcpy(wchar_t *dst, const wchar_t *src, size_t maxlen)

{

    size_t srclen = SDL_wcslen(src);

    if (maxlen > 0) {

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

        SDL_memcpy(dst, src, len * sizeof(wchar_t));

        dst[len] = '\0';

    }

    return srclen;

}

#endif

#ifndef HAVE_WCSLCAT

size_t

SDL_wcslcat(wchar_t *dst, const wchar_t *src, size_t maxlen)

{

    size_t dstlen = SDL_wcslen(dst);

    size_t srclen = SDL_wcslen(src);

    if (dstlen < maxlen) {

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

    }

    return dstlen + srclen;

}

#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

size_t SDL_utf8strlcpy(char *dst, const char *src, size_t dst_bytes)

{

    size_t src_bytes = SDL_strlen(src);

    size_t bytes = SDL_min(src_bytes, dst_bytes - 1);

    size_t i = 0;

    char trailing_bytes = 0;

    if (bytes)

    {

        unsigned char c = (unsigned char)src[bytes - 1];

        if (UTF8_IsLeadByte(c))

            --bytes;

        else if (UTF8_IsTrailingByte(c))

        {

            for (i = bytes - 1; i != 0; --i)

            {

                c = (unsigned char)src[i];

                trailing_bytes = UTF8_TrailingBytes(c);

                if (trailing_bytes)

                {

                    if (bytes - i != trailing_bytes + 1)

                        bytes = i;

                    break;

                }

            }

        }

        SDL_memcpy(dst, src, bytes);

    }

    dst[bytes] = '\0';

    return bytes;

}

#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;