SDL_string.c File Reference

#include "../SDL_internal.h"
#include "SDL_stdinc.h"

Include dependency graph for SDL_string.c:

Go to the source code of this file.

Data Structures
struct	SDL_FormatInfo

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

Enumerations
enum	SDL_letter_case {   SDL_CASE_NOCHANGE ,   SDL_CASE_LOWER ,   SDL_CASE_UPPER }

Functions
static int	UTF8_TrailingBytes (unsigned char c)
static size_t	SDL_ScanLong (const char *text, int radix, long *valuep)
static size_t	SDL_ScanUnsignedLong (const char *text, int radix, unsigned long *valuep)
static size_t	SDL_ScanUintPtrT (const char *text, int radix, uintptr_t *valuep)
static size_t	SDL_ScanLongLong (const char *text, int radix, Sint64 *valuep)
static size_t	SDL_ScanUnsignedLongLong (const char *text, int radix, Uint64 *valuep)
static size_t	SDL_ScanFloat (const char *text, double *valuep)
void *	SDL_memset (SDL_OUT_BYTECAP(len) void *dst, int c, size_t len)
void *	SDL_memcpy (SDL_OUT_BYTECAP(len) void *dst, SDL_IN_BYTECAP(len) const void *src, size_t len)
void *	SDL_memmove (SDL_OUT_BYTECAP(len) void *dst, SDL_IN_BYTECAP(len) const void *src, size_t len)
int	SDL_memcmp (const void *s1, const void *s2, size_t len)
size_t	SDL_strlen (const char *string)
size_t	SDL_wcslen (const wchar_t *string)
size_t	SDL_wcslcpy (SDL_OUT_Z_CAP(maxlen) wchar_t *dst, const wchar_t *src, size_t maxlen)
size_t	SDL_wcslcat (SDL_INOUT_Z_CAP(maxlen) wchar_t *dst, const wchar_t *src, size_t maxlen)
wchar_t *	SDL_wcsdup (const wchar_t *string)
wchar_t *	SDL_wcsstr (const wchar_t *haystack, const wchar_t *needle)
int	SDL_wcscmp (const wchar_t *str1, const wchar_t *str2)
int	SDL_wcsncmp (const wchar_t *str1, const wchar_t *str2, size_t maxlen)
int	SDL_wcscasecmp (const wchar_t *str1, const wchar_t *str2)
int	SDL_wcsncasecmp (const wchar_t *str1, const wchar_t *str2, size_t maxlen)
size_t	SDL_strlcpy (SDL_OUT_Z_CAP(maxlen) char *dst, const char *src, size_t maxlen)
size_t	SDL_utf8strlcpy (SDL_OUT_Z_CAP(dst_bytes) char *dst, const char *src, size_t dst_bytes)
size_t	SDL_utf8strlen (const char *str)
size_t	SDL_strlcat (SDL_INOUT_Z_CAP(maxlen) char *dst, const char *src, size_t maxlen)
char *	SDL_strdup (const char *string)
char *	SDL_strrev (char *string)
char *	SDL_strupr (char *string)
char *	SDL_strlwr (char *string)
char *	SDL_strchr (const char *string, int c)
char *	SDL_strrchr (const char *string, int c)
char *	SDL_strstr (const char *haystack, const char *needle)
char *	SDL_itoa (int value, char *string, int radix)
char *	SDL_uitoa (unsigned int value, char *string, int radix)
char *	SDL_ltoa (long value, char *string, int radix)
char *	SDL_ultoa (unsigned long value, char *string, int radix)
char *	SDL_lltoa (Sint64 value, char *string, int radix)
char *	SDL_ulltoa (Uint64 value, char *string, int radix)
int	SDL_atoi (const char *string)
double	SDL_atof (const char *string)
long	SDL_strtol (const char *string, char **endp, int base)
unsigned long	SDL_strtoul (const char *string, char **endp, int base)
Sint64	SDL_strtoll (const char *string, char **endp, int base)
Uint64	SDL_strtoull (const char *string, char **endp, int base)
double	SDL_strtod (const char *string, char **endp)
int	SDL_strcmp (const char *str1, const char *str2)
int	SDL_strncmp (const char *str1, const char *str2, size_t maxlen)
int	SDL_strcasecmp (const char *str1, const char *str2)
int	SDL_strncasecmp (const char *str1, const char *str2, size_t maxlen)
int	SDL_sscanf (const char *text, SDL_SCANF_FORMAT_STRING const char *fmt,...)
int	SDL_vsscanf (const char *text, const char *fmt, va_list ap)
int	SDL_snprintf (SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, SDL_PRINTF_FORMAT_STRING const char *fmt,...)
static size_t	SDL_PrintString (char *text, size_t maxlen, SDL_FormatInfo *info, const char *string)
static void	SDL_IntPrecisionAdjust (char *num, size_t maxlen, SDL_FormatInfo *info)
static size_t	SDL_PrintLong (char *text, size_t maxlen, SDL_FormatInfo *info, long value)
static size_t	SDL_PrintUnsignedLong (char *text, size_t maxlen, SDL_FormatInfo *info, unsigned long value)
static size_t	SDL_PrintLongLong (char *text, size_t maxlen, SDL_FormatInfo *info, Sint64 value)
static size_t	SDL_PrintUnsignedLongLong (char *text, size_t maxlen, SDL_FormatInfo *info, Uint64 value)
static size_t	SDL_PrintFloat (char *text, size_t maxlen, SDL_FormatInfo *info, double arg)
int	SDL_vsnprintf (SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, const char *fmt, va_list ap)

Variables
static const char	ntoa_table []

Macro Definition Documentation

SDL_islowerhex

#define SDL_islowerhex

(

X

)

(((X) >= 'a') && ((X) <= 'f'))

Definition at line 33 of file SDL_string.c.

SDL_isupperhex

#define SDL_isupperhex

(

X

)

(((X) >= 'A') && ((X) <= 'F'))

Definition at line 32 of file SDL_string.c.

UTF8_IsLeadByte

#define UTF8_IsLeadByte

(

c

)

((c) >= 0xC0 && (c) <= 0xF4)

Definition at line 36 of file SDL_string.c.

UTF8_IsTrailingByte

#define UTF8_IsTrailingByte

(

c

)

((c) >= 0x80 && (c) <= 0xBF)

Definition at line 37 of file SDL_string.c.

Enumeration Type Documentation

SDL_letter_case

enum SDL_letter_case

Enumerator
SDL_CASE_NOCHANGE
SDL_CASE_LOWER
SDL_CASE_UPPER

Definition at line 1476 of file SDL_string.c.

{
    SDL_CASE_NOCHANGE,
    SDL_CASE_LOWER,
    SDL_CASE_UPPER
} SDL_letter_case;

Function Documentation

SDL_atof()

double SDL_atof

(

const char *

string

)

Definition at line 935 of file SDL_string.c.

{
#ifdef HAVE_ATOF
    return atof(string);
#else
    return SDL_strtod(string, NULL);
#endif /* HAVE_ATOF */
}

References NULL, and SDL_strtod().

SDL_atoi()

int SDL_atoi

(

const char *

string

)

Definition at line 926 of file SDL_string.c.

{
#ifdef HAVE_ATOI
    return atoi(string);
#else
    return SDL_strtol(string, NULL, 0);
#endif /* HAVE_ATOI */
}

References NULL, and SDL_strtol().

SDL_IntPrecisionAdjust()

static void SDL_IntPrecisionAdjust ( char *  num, size_t  maxlen, SDL_FormatInfo *  info  )

static

Definition at line 1542 of file SDL_string.c.

{/* left-pad num with zeroes. */
    size_t sz, pad, have_sign;
 
    if (!info)
        return;
 
    have_sign = 0;
    if (*num == '-' || *num == '+') {
        have_sign = 1;
        ++num;
        --maxlen;
    }
    sz = SDL_strlen(num);
    if (info->precision > 0 && sz < (size_t)info->precision) {
        pad = (size_t)info->precision - sz;
        if (pad + sz + 1 <= maxlen) { /* otherwise ignore the precision */
            SDL_memmove(num + pad, num, sz + 1);
            SDL_memset(num, '0', pad);
        }
    }
    info->precision = -1;/* so that SDL_PrintString() doesn't make a mess. */
 
    if (info->pad_zeroes && info->width > 0 && (size_t)info->width > sz + have_sign) {
    /* handle here: spaces are added before the sign
       but zeroes must be placed _after_ the sign. */
    /* sz hasn't changed: we ignore pad_zeroes if a precision is given. */
        pad = (size_t)info->width - sz - have_sign;
        if (pad + sz + 1 <= maxlen) {
            SDL_memmove(num + pad, num, sz + 1);
            SDL_memset(num, '0', pad);
        }
        info->width = 0; /* so that SDL_PrintString() doesn't make a mess. */
    }
}

References if, SDL_FormatInfo::pad_zeroes, SDL_FormatInfo::precision, SDL_memmove(), SDL_memset(), SDL_strlen(), and SDL_FormatInfo::width.

Referenced by SDL_PrintLong(), SDL_PrintLongLong(), SDL_PrintUnsignedLong(), and SDL_PrintUnsignedLongLong().

SDL_itoa()

char* SDL_itoa	(	int	value,
		char *	string,
		int	radix
	)

Definition at line 819 of file SDL_string.c.

{
#ifdef HAVE_ITOA
    return itoa(value, string, radix);
#else
    return SDL_ltoa((long)value, string, radix);
#endif /* HAVE_ITOA */
}

References SDL_ltoa().

SDL_lltoa()

char* SDL_lltoa	(	Sint64	value,
		char *	string,
		int	radix
	)

Definition at line 883 of file SDL_string.c.

{
#if defined(HAVE__I64TOA)
    return _i64toa(value, string, radix);
#else
    char *bufp = string;
 
    if (value < 0) {
        *bufp++ = '-';
        SDL_ulltoa(-value, bufp, radix);
    } else {
        SDL_ulltoa(value, bufp, radix);
    }
 
    return string;
#endif /* HAVE__I64TOA */
}

References SDL_ulltoa().

Referenced by SDL_PrintLongLong().

SDL_ltoa()

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

Definition at line 839 of file SDL_string.c.

{
#if defined(HAVE__LTOA)
    return _ltoa(value, string, radix);
#else
    char *bufp = string;
 
    if (value < 0) {
        *bufp++ = '-';
        SDL_ultoa(-value, bufp, radix);
    } else {
        SDL_ultoa(value, bufp, radix);
    }
 
    return string;
#endif /* HAVE__LTOA */
}

References SDL_ultoa().

Referenced by SDL_itoa(), and SDL_PrintLong().

SDL_memcmp()

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

Definition at line 392 of file SDL_string.c.

{
#if defined(HAVE_MEMCMP)
    return memcmp(s1, s2, len);
#else
    char *s1p = (char *) s1;
    char *s2p = (char *) s2;
    while (len--) {
        if (*s1p != *s2p) {
            return (*s1p - *s2p);
        }
        ++s1p;
        ++s2p;
    }
    return 0;
#endif /* HAVE_MEMCMP */
}

SDL_memcpy()

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

Definition at line 315 of file SDL_string.c.

{
#ifdef __GNUC__
    /* Presumably this is well tuned for speed.
       On my machine this is twice as fast as the C code below.
     */
    return __builtin_memcpy(dst, src, len);
#elif defined(HAVE_MEMCPY)
    return memcpy(dst, src, len);
#elif defined(HAVE_BCOPY)
    bcopy(src, dst, len);
    return dst;
#else
    /* GCC 4.9.0 with -O3 will generate movaps instructions with the loop
       using Uint32* pointers, so we need to make sure the pointers are
       aligned before we loop using them.
     */
    if (((intptr_t)src & 0x3) || ((intptr_t)dst & 0x3)) {
        /* Do an unaligned byte copy */
        Uint8 *srcp1 = (Uint8 *)src;
        Uint8 *dstp1 = (Uint8 *)dst;
 
        while (len--) {
            *dstp1++ = *srcp1++;
        }
    } else {
        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 /* __GNUC__ */
}

References memcpy.

Referenced by SDL_memcpy4(), SDL_strdup(), SDL_strlcpy(), SDL_utf8strlcpy(), SDL_wcsdup(), and SDL_wcslcpy().

SDL_memmove()

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

Definition at line 368 of file SDL_string.c.

{
#if defined(HAVE_MEMMOVE)
    return memmove(dst, src, len);
#else
    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 /* HAVE_MEMMOVE */
}

References memmove.

Referenced by SDL_IntPrecisionAdjust().

SDL_memset()

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

Definition at line 266 of file SDL_string.c.

{
#if defined(HAVE_MEMSET)
    return memset(dst, c, len);
#else
    size_t left;
    Uint32 *dstp4;
    Uint8 *dstp1 = (Uint8 *) dst;
    Uint8 value1;
    Uint32 value4;
 
    /* The value used in memset() is a byte, passed as an int */
    c &= 0xff;
 
    /* The destination pointer needs to be aligned on a 4-byte boundary to
     * execute a 32-bit set. Set first bytes manually if needed until it is
     * aligned. */
    value1 = (Uint8)c;
    while ((intptr_t)dstp1 & 0x3) {
        if (len--) {
            *dstp1++ = value1;
        } else {
            return dst;
        }
    }
 
    value4 = (c | (c << 8) | (c << 16) | (c << 24));
    dstp4 = (Uint32 *) dstp1;
    left = (len % 4);
    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 /* HAVE_MEMSET */
}

References memset.

Referenced by SDL_IntPrecisionAdjust(), SDL_PrintFloat(), and SDL_PrintString().

SDL_PrintFloat()

static size_t SDL_PrintFloat ( char *  text, size_t  maxlen, SDL_FormatInfo *  info, double  arg  )

static

Definition at line 1627 of file SDL_string.c.

{
    int width;
    size_t len;
    size_t left = maxlen;
    char *textstart = text;
 
    if (arg) {
        /* This isn't especially accurate, but hey, it's easy. :) */
        unsigned long value;
 
        if (arg < 0) {
            if (left > 1) {
                *text = '-';
                --left;
            }
            ++text;
            arg = -arg;
        } else if (info->force_sign) {
            if (left > 1) {
                *text = '+';
                --left;
            }
            ++text;
        }
        value = (unsigned long) arg;
        len = SDL_PrintUnsignedLong(text, left, NULL, value);
        if (len >= left) {
            text += (left > 1) ? left - 1 : 0;
            left = SDL_min(left, 1);
        } else {
            text += len;
            left -= len;
        }
        arg -= value;
        if (info->precision < 0) {
            info->precision = 6;
        }
        if (info->force_type || info->precision > 0) {
            int mult = 10;
            if (left > 1) {
                *text = '.';
                --left;
            }
            ++text;
            while (info->precision-- > 0) {
                value = (unsigned long) (arg * mult);
                len = SDL_PrintUnsignedLong(text, left, NULL, value);
                if (len >= left) {
                    text += (left > 1) ? left - 1 : 0;
                    left = SDL_min(left, 1);
                } else {
                    text += len;
                    left -= len;
                }
                arg -= (double) value / mult;
                mult *= 10;
            }
        }
    } else {
        if (left > 1) {
            *text = '0';
            --left;
        }
        ++text;
        if (info->force_type) {
            if (left > 1) {
                *text = '.';
                --left;
            }
            ++text;
        }
    }
 
    width = info->width - (int)(text - textstart);
    if (width > 0) {
        const char fill = info->pad_zeroes ? '0' : ' ';
        char *end = text+left-1;
        len = (text - textstart);
        for (len = (text - textstart); len--; ) {
            if ((textstart+len+width) < end) {
                *(textstart+len+width) = *(textstart+len);
            }
        }
        len = (size_t)width;
        if (len >= left) {
            text += (left > 1) ? left - 1 : 0;
            left = SDL_min(left, 1);
        } else {
            text += len;
            left -= len;
        }
 
        if (end != textstart) {
            const size_t filllen = SDL_min(len, ((size_t) (end - textstart)) - 1);
            SDL_memset(textstart, fill, filllen);
        }
    }
 
    return (text - textstart);
}

References SDL_FormatInfo::force_sign, SDL_FormatInfo::force_type, int(), NULL, SDL_FormatInfo::pad_zeroes, SDL_FormatInfo::precision, SDL_memset(), SDL_min, SDL_PrintUnsignedLong(), text, and SDL_FormatInfo::width.

Referenced by SDL_vsnprintf().

SDL_PrintLong()

static size_t SDL_PrintLong ( char *  text, size_t  maxlen, SDL_FormatInfo *  info, long  value  )

static

Definition at line 1579 of file SDL_string.c.

{
    char num[130], *p = num;
 
    if (info->force_sign && value >= 0L) {
        *p++ = '+';
    }
 
    SDL_ltoa(value, p, info ? info->radix : 10);
    SDL_IntPrecisionAdjust(num, maxlen, info);
    return SDL_PrintString(text, maxlen, info, num);
}

References SDL_FormatInfo::force_sign, SDL_FormatInfo::radix, SDL_IntPrecisionAdjust(), SDL_ltoa(), SDL_PrintString(), and text.

Referenced by SDL_vsnprintf().

SDL_PrintLongLong()

static size_t SDL_PrintLongLong ( char *  text, size_t  maxlen, SDL_FormatInfo *  info, Sint64  value  )

static

Definition at line 1603 of file SDL_string.c.

{
    char num[130], *p = num;
 
    if (info->force_sign && value >= (Sint64)0) {
        *p++ = '+';
    }
 
    SDL_lltoa(value, p, info ? info->radix : 10);
    SDL_IntPrecisionAdjust(num, maxlen, info);
    return SDL_PrintString(text, maxlen, info, num);
}

References SDL_FormatInfo::force_sign, SDL_FormatInfo::radix, SDL_IntPrecisionAdjust(), SDL_lltoa(), SDL_PrintString(), and text.

Referenced by SDL_vsnprintf().

SDL_PrintString()

static size_t SDL_PrintString ( char *  text, size_t  maxlen, SDL_FormatInfo *  info, const char *  string  )

static

Definition at line 1496 of file SDL_string.c.

{
    size_t length = 0;
    size_t slen, sz;
 
    if (string == NULL) {
        string = "(null)";
    }
 
    sz = SDL_strlen(string);
    if (info && info->width > 0 && (size_t)info->width > sz) {
        const char fill = info->pad_zeroes ? '0' : ' ';
        size_t width = info->width - sz;
        size_t filllen;
 
        if (info->precision >= 0 && (size_t)info->precision < sz)
            width += sz - (size_t)info->precision;
 
        filllen = SDL_min(width, maxlen);
        SDL_memset(text, fill, filllen);
        text += filllen;
        length += filllen;
        maxlen -= filllen;
    }
 
    slen = SDL_strlcpy(text, string, maxlen);
    length += SDL_min(slen, maxlen);
 
    if (info) {
        if (info->precision >= 0 && (size_t)info->precision < sz) {
            slen = (size_t)info->precision;
            if (slen < maxlen) {
                text[slen] = 0;
                length -= (sz - slen);
            }
        }
        if (info->force_case == SDL_CASE_LOWER) {
            SDL_strlwr(text);
        } else if (info->force_case == SDL_CASE_UPPER) {
            SDL_strupr(text);
        }
    }
    return length;
}

References SDL_FormatInfo::force_case, if, NULL, SDL_FormatInfo::pad_zeroes, SDL_FormatInfo::precision, SDL_CASE_LOWER, SDL_CASE_UPPER, SDL_memset(), SDL_min, SDL_strlcpy(), SDL_strlen(), SDL_strlwr(), SDL_strupr(), text, and SDL_FormatInfo::width.

Referenced by SDL_PrintLong(), SDL_PrintLongLong(), SDL_PrintUnsignedLong(), SDL_PrintUnsignedLongLong(), and SDL_vsnprintf().

SDL_PrintUnsignedLong()

static size_t SDL_PrintUnsignedLong ( char *  text, size_t  maxlen, SDL_FormatInfo *  info, unsigned long  value  )

static

Definition at line 1593 of file SDL_string.c.

{
    char num[130];
 
    SDL_ultoa(value, num, info ? info->radix : 10);
    SDL_IntPrecisionAdjust(num, maxlen, info);
    return SDL_PrintString(text, maxlen, info, num);
}

References SDL_FormatInfo::radix, SDL_IntPrecisionAdjust(), SDL_PrintString(), SDL_ultoa(), and text.

Referenced by SDL_PrintFloat(), and SDL_vsnprintf().

SDL_PrintUnsignedLongLong()

static size_t SDL_PrintUnsignedLongLong ( char *  text, size_t  maxlen, SDL_FormatInfo *  info, Uint64  value  )

static

Definition at line 1617 of file SDL_string.c.

{
    char num[130];
 
    SDL_ulltoa(value, num, info ? info->radix : 10);
    SDL_IntPrecisionAdjust(num, maxlen, info);
    return SDL_PrintString(text, maxlen, info, num);
}

References SDL_FormatInfo::radix, SDL_IntPrecisionAdjust(), SDL_PrintString(), SDL_ulltoa(), and text.

Referenced by SDL_vsnprintf().

SDL_ScanFloat()

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

static

Definition at line 231 of file SDL_string.c.

{
    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 && text > textstart) {
        if (negative && value) {
            *valuep = -value;
        } else {
            *valuep = value;
        }
    }
    return (text - textstart);
}

References SDL_FALSE, SDL_isdigit, SDL_ScanUnsignedLong(), SDL_TRUE, and text.

Referenced by SDL_strtod(), and SDL_vsscanf().

SDL_ScanLong()

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

static

Definition at line 53 of file SDL_string.c.

{
    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 && text > textstart) {
        if (negative && value) {
            *valuep = -value;
        } else {
            *valuep = value;
        }
    }
    return (text - textstart);
}

References SDL_FALSE, SDL_isdigit, SDL_islowerhex, SDL_isupperhex, SDL_strncmp(), SDL_TRUE, and text.

Referenced by SDL_strtol(), and SDL_vsscanf().

SDL_ScanLongLong()

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

static

Definition at line 158 of file SDL_string.c.

{
    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 && text > textstart) {
        if (negative && value) {
            *valuep = -value;
        } else {
            *valuep = value;
        }
    }
    return (text - textstart);
}

References SDL_FALSE, SDL_isdigit, SDL_islowerhex, SDL_isupperhex, SDL_strncmp(), SDL_TRUE, and text.

Referenced by SDL_strtoll(), and SDL_vsscanf().

SDL_ScanUintPtrT()

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

static

Definition at line 126 of file SDL_string.c.

{
    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 && text > textstart) {
        *valuep = value;
    }
    return (text - textstart);
}

References SDL_isdigit, SDL_islowerhex, SDL_isupperhex, SDL_strncmp(), and text.

Referenced by SDL_vsscanf().

SDL_ScanUnsignedLong()

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

static

Definition at line 94 of file SDL_string.c.

{
    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 && text > textstart) {
        *valuep = value;
    }
    return (text - textstart);
}

References SDL_isdigit, SDL_islowerhex, SDL_isupperhex, SDL_strncmp(), and text.

Referenced by SDL_ScanFloat(), SDL_strtoul(), and SDL_vsscanf().

SDL_ScanUnsignedLongLong()

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

static

Definition at line 199 of file SDL_string.c.

{
    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 && text > textstart) {
        *valuep = value;
    }
    return (text - textstart);
}

References SDL_isdigit, SDL_islowerhex, SDL_isupperhex, SDL_strncmp(), and text.

Referenced by SDL_strtoull(), and SDL_vsscanf().

SDL_snprintf()

int SDL_snprintf	(	SDL_OUT_Z_CAP(maxlen) char *	text,
		size_t	maxlen,
		SDL_PRINTF_FORMAT_STRING const char *	fmt,
			...
	)

Definition at line 1443 of file SDL_string.c.

{
    va_list ap;
    int retval;
 
    va_start(ap, fmt);
    retval = SDL_vsnprintf(text, maxlen, fmt, ap);
    va_end(ap);
 
    return retval;
}

References retval, SDL_vsnprintf(), and text.

SDL_sscanf()

int SDL_sscanf	(	const char *	text,
		SDL_SCANF_FORMAT_STRING const char *	fmt,
			...
	)

Definition at line 1151 of file SDL_string.c.

{
    int rc;
    va_list ap;
    va_start(ap, fmt);
    rc = SDL_vsscanf(text, fmt, ap);
    va_end(ap);
    return rc;
}

References SDL_vsscanf(), and text.

SDL_strcasecmp()

int SDL_strcasecmp	(	const char *	str1,
		const char *	str2
	)

Definition at line 1098 of file SDL_string.c.

{
#ifdef HAVE_STRCASECMP
    return strcasecmp(str1, str2);
#elif defined(HAVE__STRICMP)
    return _stricmp(str1, str2);
#else
    char a = 0;
    char b = 0;
    while (*str1 && *str2) {
        a = SDL_toupper((unsigned char) *str1);
        b = SDL_toupper((unsigned char) *str2);
        if (a != b)
            break;
        ++str1;
        ++str2;
    }
    a = SDL_toupper(*str1);
    b = SDL_toupper(*str2);
    return (int) ((unsigned char) a - (unsigned char) b);
#endif /* HAVE_STRCASECMP */
}

References SDL_toupper.

SDL_strchr()

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

Definition at line 755 of file SDL_string.c.

{
#ifdef HAVE_STRCHR
    return SDL_const_cast(char*,strchr(string, c));
#elif defined(HAVE_INDEX)
    return SDL_const_cast(char*,index(string, c));
#else
    while (*string) {
        if (*string == c) {
            return (char *) string;
        }
        ++string;
    }
    return NULL;
#endif /* HAVE_STRCHR */
}

References NULL, and SDL_const_cast.

SDL_strcmp()

int SDL_strcmp	(	const char *	str1,
		const char *	str2
	)

Definition at line 1062 of file SDL_string.c.

{
#if defined(HAVE_STRCMP)
    return strcmp(str1, str2);
#else
    while (*str1 && *str2) {
        if (*str1 != *str2)
            break;
        ++str1;
        ++str2;
    }
    return (int)((unsigned char) *str1 - (unsigned char) *str2);
#endif /* HAVE_STRCMP */
}

SDL_strdup()

char* SDL_strdup

(

const char *

string

)

Definition at line 695 of file SDL_string.c.

{
    size_t len = SDL_strlen(string) + 1;
    char *newstr = (char *)SDL_malloc(len);
    if (newstr) {
        SDL_memcpy(newstr, string, len);
    }
    return newstr;
}

References SDL_malloc, SDL_memcpy(), and SDL_strlen().

SDL_strlcat()

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

Definition at line 680 of file SDL_string.c.

{
#if defined(HAVE_STRLCAT)
    return strlcat(dst, src, maxlen);
#else
    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 /* HAVE_STRLCAT */
}

References SDL_strlcpy(), and SDL_strlen().

SDL_strlcpy()

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

Definition at line 614 of file SDL_string.c.

{
#if defined(HAVE_STRLCPY)
    return strlcpy(dst, src, maxlen);
#else
    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 /* HAVE_STRLCPY */
}

References SDL_memcpy(), SDL_min, and SDL_strlen().

Referenced by SDL_PrintString(), and SDL_strlcat().

SDL_strlen()

size_t SDL_strlen

(

const char *

string

)

Definition at line 411 of file SDL_string.c.

{
#if defined(HAVE_STRLEN)
    return strlen(string);
#else
    size_t len = 0;
    while (*string++) {
        ++len;
    }
    return len;
#endif /* HAVE_STRLEN */
}

Referenced by SDL_IntPrecisionAdjust(), SDL_PrintString(), SDL_strdup(), SDL_strlcat(), SDL_strlcpy(), SDL_strrchr(), SDL_strrev(), SDL_strstr(), SDL_strtol(), SDL_strtoll(), SDL_strtoul(), SDL_strtoull(), and SDL_utf8strlcpy().

SDL_strlwr()

char* SDL_strlwr

(

char *

string

)

Definition at line 740 of file SDL_string.c.

{
#if defined(HAVE__STRLWR)
    return _strlwr(string);
#else
    char *bufp = string;
    while (*bufp) {
        *bufp = SDL_tolower((unsigned char) *bufp);
        ++bufp;
    }
    return string;
#endif /* HAVE__STRLWR */
}

References SDL_tolower.

Referenced by SDL_PrintString().

SDL_strncasecmp()

int SDL_strncasecmp	(	const char *	str1,
		const char *	str2,
		size_t	maxlen
	)

Definition at line 1122 of file SDL_string.c.

{
#ifdef HAVE_STRNCASECMP
    return strncasecmp(str1, str2, maxlen);
#elif defined(HAVE__STRNICMP)
    return _strnicmp(str1, str2, maxlen);
#else
    char a = 0;
    char b = 0;
    while (*str1 && *str2 && maxlen) {
        a = SDL_tolower((unsigned char) *str1);
        b = SDL_tolower((unsigned char) *str2);
        if (a != b)
            break;
        ++str1;
        ++str2;
        --maxlen;
    }
    if (maxlen == 0) {
        return 0;
    } else {
        a = SDL_tolower((unsigned char) *str1);
        b = SDL_tolower((unsigned char) *str2);
        return (int) ((unsigned char) a - (unsigned char) b);
    }
#endif /* HAVE_STRNCASECMP */
}

References SDL_tolower.

SDL_strncmp()

int SDL_strncmp	(	const char *	str1,
		const char *	str2,
		size_t	maxlen
	)

Definition at line 1078 of file SDL_string.c.

{
#if defined(HAVE_STRNCMP)
    return strncmp(str1, str2, maxlen);
#else
    while (*str1 && *str2 && maxlen) {
        if (*str1 != *str2)
            break;
        ++str1;
        ++str2;
        --maxlen;
    }
    if (!maxlen) {
        return 0;
    }
    return (int) ((unsigned char) *str1 - (unsigned char) *str2);
#endif /* HAVE_STRNCMP */
}

Referenced by SDL_ScanLong(), SDL_ScanLongLong(), SDL_ScanUintPtrT(), SDL_ScanUnsignedLong(), SDL_ScanUnsignedLongLong(), SDL_strstr(), SDL_strtol(), SDL_strtoll(), SDL_strtoul(), SDL_strtoull(), SDL_vsnprintf(), and SDL_vsscanf().

SDL_strrchr()

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

Definition at line 773 of file SDL_string.c.

{
#ifdef HAVE_STRRCHR
    return SDL_const_cast(char*,strrchr(string, c));
#elif defined(HAVE_RINDEX)
    return SDL_const_cast(char*,rindex(string, c));
#else
    const char *bufp = string + SDL_strlen(string) - 1;
    while (bufp >= string) {
        if (*bufp == c) {
            return (char *) bufp;
        }
        --bufp;
    }
    return NULL;
#endif /* HAVE_STRRCHR */
}

References NULL, SDL_const_cast, and SDL_strlen().

SDL_strrev()

char* SDL_strrev

(

char *

string

)

Definition at line 706 of file SDL_string.c.

{
#if defined(HAVE__STRREV)
    return _strrev(string);
#else
    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 /* HAVE__STRREV */
}

References SDL_strlen().

Referenced by SDL_ulltoa(), and SDL_ultoa().

SDL_strstr()

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

Definition at line 792 of file SDL_string.c.

{
#if defined(HAVE_STRSTR)
    return SDL_const_cast(char*,strstr(haystack, needle));
#else
    size_t length = SDL_strlen(needle);
    while (*haystack) {
        if (SDL_strncmp(haystack, needle, length) == 0) {
            return (char *) haystack;
        }
        ++haystack;
    }
    return NULL;
#endif /* HAVE_STRSTR */
}

References NULL, SDL_const_cast, SDL_strlen(), and SDL_strncmp().

SDL_strtod()

double SDL_strtod	(	const char *	string,
		char **	endp
	)

Definition at line 1045 of file SDL_string.c.

{
#if defined(HAVE_STRTOD)
    return strtod(string, endp);
#else
    size_t len;
    double value = 0.0;
 
    len = SDL_ScanFloat(string, &value);
    if (endp) {
        *endp = (char *) string + len;
    }
    return value;
#endif /* HAVE_STRTOD */
}

References SDL_ScanFloat().

Referenced by SDL_atof().

SDL_strtol()

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

Definition at line 945 of file SDL_string.c.

{
#if defined(HAVE_STRTOL)
    return strtol(string, endp, base);
#else
    size_t len;
    long value = 0;
 
    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 /* HAVE_STRTOL */
}

References base, SDL_ScanLong(), SDL_strlen(), and SDL_strncmp().

Referenced by SDL_atoi(), and SDL_vsnprintf().

SDL_strtoll()

Sint64 SDL_strtoll	(	const char *	string,
		char **	endp,
		int	base
	)

Definition at line 995 of file SDL_string.c.

{
#if defined(HAVE_STRTOLL)
    return strtoll(string, endp, base);
#else
    size_t len;
    Sint64 value = 0;
 
    if (!base) {
        if ((SDL_strlen(string) > 2) && (SDL_strncmp(string, "0x", 2) == 0)) {
            base = 16;
        } else {
            base = 10;
        }
    }
 
    len = SDL_ScanLongLong(string, base, &value);
    if (endp) {
        *endp = (char *) string + len;
    }
    return value;
#endif /* HAVE_STRTOLL */
}

References base, SDL_ScanLongLong(), SDL_strlen(), and SDL_strncmp().

SDL_strtoul()

unsigned long SDL_strtoul	(	const char *	string,
		char **	endp,
		int	base
	)

Definition at line 970 of file SDL_string.c.

{
#if defined(HAVE_STRTOUL)
    return strtoul(string, endp, base);
#else
    size_t len;
    unsigned long value = 0;
 
    if (!base) {
        if ((SDL_strlen(string) > 2) && (SDL_strncmp(string, "0x", 2) == 0)) {
            base = 16;
        } else {
            base = 10;
        }
    }
 
    len = SDL_ScanUnsignedLong(string, base, &value);
    if (endp) {
        *endp = (char *) string + len;
    }
    return value;
#endif /* HAVE_STRTOUL */
}

References base, SDL_ScanUnsignedLong(), SDL_strlen(), and SDL_strncmp().

SDL_strtoull()

Uint64 SDL_strtoull	(	const char *	string,
		char **	endp,
		int	base
	)

Definition at line 1020 of file SDL_string.c.

{
#if defined(HAVE_STRTOULL)
    return strtoull(string, endp, base);
#else
    size_t len;
    Uint64 value = 0;
 
    if (!base) {
        if ((SDL_strlen(string) > 2) && (SDL_strncmp(string, "0x", 2) == 0)) {
            base = 16;
        } else {
            base = 10;
        }
    }
 
    len = SDL_ScanUnsignedLongLong(string, base, &value);
    if (endp) {
        *endp = (char *) string + len;
    }
    return value;
#endif /* HAVE_STRTOULL */
}

References base, SDL_ScanUnsignedLongLong(), SDL_strlen(), and SDL_strncmp().

SDL_strupr()

char* SDL_strupr

(

char *

string

)

Definition at line 725 of file SDL_string.c.

{
#if defined(HAVE__STRUPR)
    return _strupr(string);
#else
    char *bufp = string;
    while (*bufp) {
        *bufp = SDL_toupper((unsigned char) *bufp);
        ++bufp;
    }
    return string;
#endif /* HAVE__STRUPR */
}

References SDL_toupper.

Referenced by SDL_PrintString().

SDL_uitoa()

char* SDL_uitoa	(	unsigned int	value,
		char *	string,
		int	radix
	)

Definition at line 829 of file SDL_string.c.

{
#ifdef HAVE__UITOA
    return _uitoa(value, string, radix);
#else
    return SDL_ultoa((unsigned long)value, string, radix);
#endif /* HAVE__UITOA */
}

References SDL_ultoa().

SDL_ulltoa()

char* SDL_ulltoa	(	Uint64	value,
		char *	string,
		int	radix
	)

Definition at line 902 of file SDL_string.c.

{
#if defined(HAVE__UI64TOA)
    return _ui64toa(value, string, radix);
#else
    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 /* HAVE__UI64TOA */
}

References ntoa_table, and SDL_strrev().

Referenced by SDL_lltoa(), and SDL_PrintUnsignedLongLong().

SDL_ultoa()

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

Definition at line 858 of file SDL_string.c.

{
#if defined(HAVE__ULTOA)
    return _ultoa(value, string, radix);
#else
    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 /* HAVE__ULTOA */
}

References ntoa_table, and SDL_strrev().

Referenced by SDL_ltoa(), SDL_PrintUnsignedLong(), and SDL_uitoa().

SDL_utf8strlcpy()

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

Definition at line 630 of file SDL_string.c.

{
    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;
}

References i, SDL_memcpy(), SDL_min, SDL_strlen(), UTF8_IsLeadByte, UTF8_IsTrailingByte, and UTF8_TrailingBytes().

SDL_utf8strlen()

size_t SDL_utf8strlen

(

const char *

str

)

Definition at line 663 of file SDL_string.c.

{
    size_t retval = 0;
    const char *p = str;
    char ch;
 
    while ((ch = *(p++)) != 0) {
        /* if top two bits are 1 and 0, it's a continuation byte. */
        if ((ch & 0xc0) != 0x80) {
            retval++;
        }
    }
    
    return retval;
}

References retval.

SDL_vsnprintf()

int SDL_vsnprintf	(	SDL_OUT_Z_CAP(maxlen) char *	text,
		size_t	maxlen,
		const char *	fmt,
		va_list	ap
	)

Definition at line 1730 of file SDL_string.c.

{
    size_t left = maxlen;
    char *textstart = text;
 
    if (!fmt) {
        fmt = "";
    }
    while (*fmt && left > 1) {
        if (*fmt == '%') {
            SDL_bool done = SDL_FALSE;
            size_t len = 0;
            SDL_bool check_flag;
            SDL_FormatInfo info;
            enum
            {
                DO_INT,
                DO_LONG,
                DO_LONGLONG
            } inttype = DO_INT;
 
            SDL_zero(info);
            info.radix = 10;
            info.precision = -1;
 
            check_flag = SDL_TRUE;
            while (check_flag) {
                ++fmt;
                switch (*fmt) {
                case '-':
                    info.left_justify = SDL_TRUE;
                    break;
                case '+':
                    info.force_sign = SDL_TRUE;
                    break;
                case '#':
                    info.force_type = SDL_TRUE;
                    break;
                case '0':
                    info.pad_zeroes = SDL_TRUE;
                    break;
                default:
                    check_flag = SDL_FALSE;
                    break;
                }
            }
 
            if (*fmt >= '0' && *fmt <= '9') {
                info.width = SDL_strtol(fmt, (char **)&fmt, 0);
            }
            else if (*fmt == '*') {
                ++fmt;
                info.width = va_arg(ap, int);
            }
 
            if (*fmt == '.') {
                ++fmt;
                if (*fmt >= '0' && *fmt <= '9') {
                    info.precision = SDL_strtol(fmt, (char **)&fmt, 0);
                } else if (*fmt == '*') {
                    ++fmt;
                    info.precision = va_arg(ap, int);
                } else {
                    info.precision = 0;
                }
                if (info.precision < 0) {
                    info.precision = 0;
                }
            }
 
            while (!done) {
                switch (*fmt) {
                case '%':
                    if (left > 1) {
                        *text = '%';
                    }
                    len = 1;
                    done = SDL_TRUE;
                    break;
                case 'c':
                    /* char is promoted to int when passed through (...) */
                    if (left > 1) {
                        *text = (char) va_arg(ap, int);
                    }
                    len = 1;
                    done = SDL_TRUE;
                    break;
                case 'h':
                    /* short is promoted to int when passed through (...) */
                    break;
                case 'l':
                    if (inttype < DO_LONGLONG) {
                        ++inttype;
                    }
                    break;
                case 'I':
                    if (SDL_strncmp(fmt, "I64", 3) == 0) {
                        fmt += 2;
                        inttype = DO_LONGLONG;
                    }
                    break;
                case 'i':
                case 'd':
                    if (info.precision >= 0) {
                        info.pad_zeroes = SDL_FALSE;
                    }
                    switch (inttype) {
                    case DO_INT:
                        len = SDL_PrintLong(text, left, &info,
                                            (long) va_arg(ap, int));
                        break;
                    case DO_LONG:
                        len = SDL_PrintLong(text, left, &info,
                                            va_arg(ap, long));
                        break;
                    case DO_LONGLONG:
                        len = SDL_PrintLongLong(text, left, &info,
                                                va_arg(ap, Sint64));
                        break;
                    }
                    done = SDL_TRUE;
                    break;
                case 'p':
                case 'x':
                    info.force_case = SDL_CASE_LOWER;
                    /* Fall through to 'X' handling */
                case 'X':
                    if (info.force_case == SDL_CASE_NOCHANGE) {
                        info.force_case = SDL_CASE_UPPER;
                    }
                    if (info.radix == 10) {
                        info.radix = 16;
                    }
                    if (*fmt == 'p') {
                        inttype = DO_LONG;
                    }
                    /* Fall through to unsigned handling */
                case 'o':
                    if (info.radix == 10) {
                        info.radix = 8;
                    }
                    /* Fall through to unsigned handling */
                case 'u':
                    info.force_sign = SDL_FALSE;
                    if (info.precision >= 0) {
                        info.pad_zeroes = SDL_FALSE;
                    }
                    switch (inttype) {
                    case DO_INT:
                        len = SDL_PrintUnsignedLong(text, left, &info,
                                                    (unsigned long)
                                                    va_arg(ap, unsigned int));
                        break;
                    case DO_LONG:
                        len = SDL_PrintUnsignedLong(text, left, &info,
                                                    va_arg(ap, unsigned long));
                        break;
                    case DO_LONGLONG:
                        len = SDL_PrintUnsignedLongLong(text, left, &info,
                                                        va_arg(ap, Uint64));
                        break;
                    }
                    done = SDL_TRUE;
                    break;
                case 'f':
                    len = SDL_PrintFloat(text, left, &info, va_arg(ap, double));
                    done = SDL_TRUE;
                    break;
                case 'S':
                    {
                        /* In practice this is used on Windows for WCHAR strings */
                        wchar_t *wide_arg = va_arg(ap, wchar_t *);
                        if (wide_arg) {
                            char *arg = SDL_iconv_string("UTF-8", "UTF-16LE", (char *)(wide_arg), (SDL_wcslen(wide_arg)+1)*sizeof(*wide_arg));
                            info.pad_zeroes = SDL_FALSE;
                            len = SDL_PrintString(text, left, &info, arg);
                            SDL_free(arg);
                        } else {
                            info.pad_zeroes = SDL_FALSE;
                            len = SDL_PrintString(text, left, &info, NULL);
                        }
                        done = SDL_TRUE;
                    }
                    break;
                case 's':
                    info.pad_zeroes = SDL_FALSE;
                    len = SDL_PrintString(text, left, &info, va_arg(ap, char *));
                    done = SDL_TRUE;
                    break;
                default:
                    done = SDL_TRUE;
                    break;
                }
                ++fmt;
            }
            if (len >= left) {
                text += (left > 1) ? left - 1 : 0;
                left = SDL_min(left, 1);
            } else {
                text += len;
                left -= len;
            }
        } else {
            *text++ = *fmt++;
            --left;
        }
    }
    if (left > 0) {
        *text = '\0';
    }
    return (int)(text - textstart);
}

References done, SDL_FormatInfo::force_case, SDL_FormatInfo::force_sign, SDL_FormatInfo::force_type, SDL_FormatInfo::left_justify, NULL, SDL_FormatInfo::pad_zeroes, SDL_FormatInfo::precision, SDL_FormatInfo::radix, SDL_CASE_LOWER, SDL_CASE_NOCHANGE, SDL_CASE_UPPER, SDL_FALSE, SDL_free, SDL_iconv_string, SDL_min, SDL_PrintFloat(), SDL_PrintLong(), SDL_PrintLongLong(), SDL_PrintString(), SDL_PrintUnsignedLong(), SDL_PrintUnsignedLongLong(), SDL_strncmp(), SDL_strtol(), SDL_TRUE, SDL_wcslen(), SDL_zero, text, and SDL_FormatInfo::width.

Referenced by SDL_snprintf().

SDL_vsscanf()

int SDL_vsscanf	(	const char *	text,
		const char *	fmt,
		va_list	ap
	)

Definition at line 1169 of file SDL_string.c.

{
    int retval = 0;
 
    if (!text || !*text) {
        return -1;
    }
 
    while (*fmt) {
        if (*fmt == ' ') {
            while (SDL_isspace((unsigned char) *text)) {
                ++text;
            }
            ++fmt;
            continue;
        }
        if (*fmt == '%') {
            SDL_bool done = SDL_FALSE;
            long count = 0;
            int radix = 10;
            enum
            {
                DO_SHORT,
                DO_INT,
                DO_LONG,
                DO_LONGLONG
            } inttype = DO_INT;
            size_t advance;
            SDL_bool suppress = SDL_FALSE;
 
            ++fmt;
            if (*fmt == '%') {
                if (*text == '%') {
                    ++text;
                    ++fmt;
                    continue;
                }
                break;
            }
            if (*fmt == '*') {
                suppress = SDL_TRUE;
                ++fmt;
            }
            fmt += SDL_ScanLong(fmt, 10, &count);
 
            if (*fmt == 'c') {
                if (!count) {
                    count = 1;
                }
                if (suppress) {
                    while (count--) {
                        ++text;
                    }
                } else {
                    char *valuep = va_arg(ap, char *);
                    while (count--) {
                        *valuep++ = *text++;
                    }
                    ++retval;
                }
                continue;
            }
 
            while (SDL_isspace((unsigned char) *text)) {
                ++text;
            }
 
            /* FIXME: implement more of the format specifiers */
            while (!done) {
                switch (*fmt) {
                case '*':
                    suppress = SDL_TRUE;
                    break;
                case 'h':
                    if (inttype > DO_SHORT) {
                        ++inttype;
                    }
                    break;
                case 'l':
                    if (inttype < DO_LONGLONG) {
                        ++inttype;
                    }
                    break;
                case 'I':
                    if (SDL_strncmp(fmt, "I64", 3) == 0) {
                        fmt += 2;
                        inttype = DO_LONGLONG;
                    }
                    break;
                case 'i':
                    {
                        int index = 0;
                        if (text[index] == '-') {
                            ++index;
                        }
                        if (text[index] == '0') {
                            if (SDL_tolower((unsigned char) text[index + 1]) == 'x') {
                                radix = 16;
                            } else {
                                radix = 8;
                            }
                        }
                    }
                    /* Fall through to %d handling */
                case 'd':
                    if (inttype == DO_LONGLONG) {
                        Sint64 value;
                        advance = SDL_ScanLongLong(text, radix, &value);
                        text += advance;
                        if (advance && !suppress) {
                            Sint64 *valuep = va_arg(ap, Sint64 *);
                            *valuep = value;
                            ++retval;
                        }
                    } else {
                        long value;
                        advance = SDL_ScanLong(text, radix, &value);
                        text += advance;
                        if (advance && !suppress) {
                            switch (inttype) {
                            case DO_SHORT:
                                {
                                    short *valuep = va_arg(ap, short *);
                                    *valuep = (short) value;
                                }
                                break;
                            case DO_INT:
                                {
                                    int *valuep = va_arg(ap, int *);
                                    *valuep = (int) value;
                                }
                                break;
                            case DO_LONG:
                                {
                                    long *valuep = va_arg(ap, long *);
                                    *valuep = value;
                                }
                                break;
                            case DO_LONGLONG:
                                /* Handled above */
                                break;
                            }
                            ++retval;
                        }
                    }
                    done = SDL_TRUE;
                    break;
                case 'o':
                    if (radix == 10) {
                        radix = 8;
                    }
                    /* Fall through to unsigned handling */
                case 'x':
                case 'X':
                    if (radix == 10) {
                        radix = 16;
                    }
                    /* Fall through to unsigned handling */
                case 'u':
                    if (inttype == DO_LONGLONG) {
                        Uint64 value = 0;
                        advance = SDL_ScanUnsignedLongLong(text, radix, &value);
                        text += advance;
                        if (advance && !suppress) {
                            Uint64 *valuep = va_arg(ap, Uint64 *);
                            *valuep = value;
                            ++retval;
                        }
                    } else {
                        unsigned long value = 0;
                        advance = SDL_ScanUnsignedLong(text, radix, &value);
                        text += advance;
                        if (advance && !suppress) {
                            switch (inttype) {
                            case DO_SHORT:
                                {
                                    short *valuep = va_arg(ap, short *);
                                    *valuep = (short) value;
                                }
                                break;
                            case DO_INT:
                                {
                                    int *valuep = va_arg(ap, int *);
                                    *valuep = (int) value;
                                }
                                break;
                            case DO_LONG:
                                {
                                    long *valuep = va_arg(ap, long *);
                                    *valuep = value;
                                }
                                break;
                            case DO_LONGLONG:
                                /* Handled above */
                                break;
                            }
                            ++retval;
                        }
                    }
                    done = SDL_TRUE;
                    break;
                case 'p':
                    {
                        uintptr_t value = 0;
                        advance = SDL_ScanUintPtrT(text, 16, &value);
                        text += advance;
                        if (advance && !suppress) {
                            void **valuep = va_arg(ap, void **);
                            *valuep = (void *) value;
                            ++retval;
                        }
                    }
                    done = SDL_TRUE;
                    break;
                case 'f':
                    {
                        double value;
                        advance = SDL_ScanFloat(text, &value);
                        text += advance;
                        if (advance && !suppress) {
                            float *valuep = va_arg(ap, float *);
                            *valuep = (float) value;
                            ++retval;
                        }
                    }
                    done = SDL_TRUE;
                    break;
                case 's':
                    if (suppress) {
                        while (!SDL_isspace((unsigned char) *text)) {
                            ++text;
                            if (count) {
                                if (--count == 0) {
                                    break;
                                }
                            }
                        }
                    } else {
                        char *valuep = va_arg(ap, char *);
                        while (!SDL_isspace((unsigned char) *text)) {
                            *valuep++ = *text++;
                            if (count) {
                                if (--count == 0) {
                                    break;
                                }
                            }
                        }
                        *valuep = '\0';
                        ++retval;
                    }
                    done = SDL_TRUE;
                    break;
                default:
                    done = SDL_TRUE;
                    break;
                }
                ++fmt;
            }
            continue;
        }
        if (*text == *fmt) {
            ++text;
            ++fmt;
            continue;
        }
        /* Text didn't match format specifier */
        break;
    }
 
    return retval;
}

References done, int(), retval, SDL_FALSE, SDL_isspace, SDL_ScanFloat(), SDL_ScanLong(), SDL_ScanLongLong(), SDL_ScanUintPtrT(), SDL_ScanUnsignedLong(), SDL_ScanUnsignedLongLong(), SDL_strncmp(), SDL_tolower, SDL_TRUE, and text.

Referenced by SDL_sscanf().

SDL_wcscasecmp()

int SDL_wcscasecmp	(	const wchar_t *	str1,
		const wchar_t *	str2
	)

Definition at line 535 of file SDL_string.c.

{
#if defined(HAVE_WCSCASECMP)
    return wcscasecmp(str1, str2);
#elif defined(HAVE__WCSICMP)
    return _wcsicmp(str1, str2);
#else
    wchar_t a = 0;
    wchar_t b = 0;
    while (*str1 && *str2) {
        /* FIXME: This doesn't actually support wide characters */
        if (*str1 >= 0x80 || *str2 >= 0x80) {
            a = *str1;
            b = *str2;
        } else {
            a = SDL_toupper((unsigned char) *str1);
            b = SDL_toupper((unsigned char) *str2);
        }
        if (a != b)
            break;
        ++str1;
        ++str2;
    }
 
    /* FIXME: This doesn't actually support wide characters */
    if (*str1 >= 0x80 || *str2 >= 0x80) {
        a = *str1;
        b = *str2;
    } else {
        a = SDL_toupper((unsigned char) *str1);
        b = SDL_toupper((unsigned char) *str2);
    }
    return (int) ((unsigned int) a - (unsigned int) b);
#endif /* HAVE__WCSICMP */
}

References int(), and SDL_toupper.

SDL_wcscmp()

int SDL_wcscmp	(	const wchar_t *	str1,
		const wchar_t *	str2
	)

Definition at line 498 of file SDL_string.c.

{
#if defined(HAVE_WCSCMP)
    return wcscmp(str1, str2);
#else
    while (*str1 && *str2) {
        if (*str1 != *str2)
            break;
        ++str1;
        ++str2;
    }
    return (int)(*str1 - *str2);
#endif /* HAVE_WCSCMP */
}

SDL_wcsdup()

wchar_t* SDL_wcsdup

(

const wchar_t *

string

)

Definition at line 470 of file SDL_string.c.

{
    size_t len = ((SDL_wcslen(string) + 1) * sizeof(wchar_t));
    wchar_t *newstr = (wchar_t *)SDL_malloc(len);
    if (newstr) {
        SDL_memcpy(newstr, string, len);
    }
    return newstr;
}

References SDL_malloc, SDL_memcpy(), and SDL_wcslen().

SDL_wcslcat()

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

Definition at line 455 of file SDL_string.c.

{
#if defined(HAVE_WCSLCAT)
    return wcslcat(dst, src, maxlen);
#else
    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 /* HAVE_WCSLCAT */
}

References SDL_wcslcpy(), and SDL_wcslen().

SDL_wcslcpy()

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

Definition at line 439 of file SDL_string.c.

{
#if defined(HAVE_WCSLCPY)
    return wcslcpy(dst, src, maxlen);
#else
    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 /* HAVE_WCSLCPY */
}

References SDL_memcpy(), SDL_min, and SDL_wcslen().

Referenced by SDL_wcslcat().

SDL_wcslen()

size_t SDL_wcslen

(

const wchar_t *

string

)

Definition at line 425 of file SDL_string.c.

{
#if defined(HAVE_WCSLEN)
    return wcslen(string);
#else
    size_t len = 0;
    while (*string++) {
        ++len;
    }
    return len;
#endif /* HAVE_WCSLEN */
}

Referenced by SDL_vsnprintf(), SDL_wcsdup(), SDL_wcslcat(), SDL_wcslcpy(), and SDL_wcsstr().

SDL_wcsncasecmp()

int SDL_wcsncasecmp	(	const wchar_t *	str1,
		const wchar_t *	str2,
		size_t	maxlen
	)

Definition at line 572 of file SDL_string.c.

{
#if defined(HAVE_WCSNCASECMP)
    return wcsncasecmp(str1, str2, maxlen);
#elif defined(HAVE__WCSNICMP)
    return _wcsnicmp(str1, str2, maxlen);
#else
    wchar_t a = 0;
    wchar_t b = 0;
    while (*str1 && *str2 && maxlen) {
        /* FIXME: This doesn't actually support wide characters */
        if (*str1 >= 0x80 || *str2 >= 0x80) {
            a = *str1;
            b = *str2;
        } else {
            a = SDL_toupper((unsigned char) *str1);
            b = SDL_toupper((unsigned char) *str2);
        }
        if (a != b)
            break;
        ++str1;
        ++str2;
        --maxlen;
    }
 
    if (maxlen == 0) {
        return 0;
    } else {
        /* FIXME: This doesn't actually support wide characters */
        if (*str1 >= 0x80 || *str2 >= 0x80) {
            a = *str1;
            b = *str2;
        } else {
            a = SDL_toupper((unsigned char) *str1);
            b = SDL_toupper((unsigned char) *str2);
        }
        return (int) ((unsigned int) a - (unsigned int) b);
    }
#endif /* HAVE__WCSNICMP */
}

References int(), and SDL_toupper.

SDL_wcsncmp()

int SDL_wcsncmp	(	const wchar_t *	str1,
		const wchar_t *	str2,
		size_t	maxlen
	)

Definition at line 514 of file SDL_string.c.

{
#if defined(HAVE_WCSNCMP)
    return wcsncmp(str1, str2, maxlen);
#else
    while (*str1 && *str2 && maxlen) {
        if (*str1 != *str2)
            break;
        ++str1;
        ++str2;
        --maxlen;
    }
    if (!maxlen) {
        return 0;
    }
    return (int) (*str1 - *str2);
 
#endif /* HAVE_WCSNCMP */
}

Referenced by SDL_wcsstr().

SDL_wcsstr()

wchar_t* SDL_wcsstr	(	const wchar_t *	haystack,
		const wchar_t *	needle
	)

Definition at line 481 of file SDL_string.c.

{
#if defined(HAVE_WCSSTR)
    return SDL_const_cast(wchar_t*,wcsstr(haystack, needle));
#else
    size_t length = SDL_wcslen(needle);
    while (*haystack) {
        if (SDL_wcsncmp(haystack, needle, length) == 0) {
            return (wchar_t *)haystack;
        }
        ++haystack;
    }
    return NULL;
#endif /* HAVE_WCSSTR */
}

References NULL, SDL_const_cast, SDL_wcslen(), and SDL_wcsncmp().

UTF8_TrailingBytes()

static int UTF8_TrailingBytes ( unsigned char  c )

static

Definition at line 39 of file SDL_string.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;
}

Referenced by SDL_utf8strlcpy().

Variable Documentation

ntoa_table

const char ntoa_table[]

static

Initial value:

= {
    '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'
}

Definition at line 810 of file SDL_string.c.

Referenced by SDL_ulltoa(), and SDL_ultoa().