/*

  Simple DirectMedia Layer

  Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>

  This software is provided 'as-is', without any express or implied

  warranty.  In no event will the authors be held liable for any damages

  arising from the use of this software.

  Permission is granted to anyone to use this software for any purpose,

  including commercial applications, and to alter it and redistribute it

  freely, subject to the following restrictions:

  1. The origin of this software must not be misrepresented; you must not

     claim that you wrote the original software. If you use this software

     in a product, an acknowledgment in the product documentation would be

     appreciated but is not required.

  2. Altered source versions must be plainly marked as such, and must not be

     misrepresented as being the original software.

  3. This notice may not be removed or altered from any source distribution.

*/

#include "SDL_config.h"

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

#include "SDL_stdinc.h"

/* these are always #defined, make them real symbol in the library, too... */

#undef SDL_itoa

#undef SDL_uitoa

#undef SDL_atoi

#undef SDL_atof

char *SDL_itoa(int value, char *str, int radix) { return SDL_itoa_inline(value, str, radix); }

char *SDL_uitoa(unsigned int value, char *str, int radix) { return SDL_uitoa_inline(value, str, radix); }

int SDL_atoi(const char *str) { return SDL_atoi_inline(str); }

double SDL_atof(const char *str) { return SDL_atof_inline(str); }

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

static 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(SDL_sscanf) || !defined(SDL_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(SDL_sscanf) || !defined(SDL_strtoul) || !defined(SDL_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 SDL_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

#if !defined(SDL_sscanf) || !defined(SDL_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(SDL_sscanf) || !defined(SDL_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

#if !defined(SDL_sscanf) || !defined(SDL_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

#ifdef SDL_memset

#undef SDL_memset

void *SDL_memset(void *dst, int c, size_t len) { return SDL_memset_inline(dst, c, len); }

#else

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

#ifdef SDL_memcpy

#undef SDL_memcpy

void *SDL_memcpy(void *dst, const void *src, size_t len) { return SDL_memcpy_inline(dst, src, len); }

#else

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

#ifdef SDL_memmove

#undef SDL_memmove

void *SDL_memmove(void *dst, const void *src, size_t len) { return SDL_memmove_inline(dst, src, len); }

#else

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

#ifdef SDL_memcmp

#undef SDL_memcmp

int SDL_memcmp(const void *s1, const void *s2, size_t len) { return SDL_memcmp_inline(s1, s2, len); }

#else

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

#ifdef SDL_strlen

#undef SDL_strlen

size_t SDL_strlen(const char *string) { return SDL_strlen_inline(string); }

#else

size_t

SDL_strlen(const char *string)

{

    size_t len = 0;

    while (*string++) {

        ++len;

    }

    return len;

}

#endif

#ifdef SDL_wcslen

#undef SDL_wcslen

size_t SDL_wcslen(const wchar_t * string) { return SDL_wcslen_inline(string); }

#else

size_t

SDL_wcslen(const wchar_t * string)

{

    size_t len = 0;

    while (*string++) {

        ++len;

    }

    return len;

}

#endif

#ifdef SDL_wcslcpy

#undef SDL_wcslcpy

size_t SDL_wcslcpy(wchar_t *dst, const wchar_t *src, size_t maxlen) { return SDL_wcslcpy_inline(dst, src, maxlen); }

#else

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

#ifdef SDL_wcslcat

#undef SDL_wcslcat

size_t SDL_wcslcat(wchar_t *dst, const wchar_t *src, size_t maxlen) { return SDL_wcslcat_inline(dst, src, maxlen); }

#else

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

#ifdef SDL_strlcpy

#undef SDL_strlcpy

size_t SDL_strlcpy(char *dst, const char *src, size_t maxlen) { return SDL_strlcpy_inline(dst, src, maxlen); }

#else

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;

}