From a855d6202536ff28e5aae4f22a0f31d8f5b325d0 Mon Sep 17 00:00:00 2001 From: Franklin Wei Date: Sat, 21 Jan 2017 15:18:31 -0500 Subject: Port of Duke Nukem 3D This ports Fabien Sanglard's Chocolate Duke to run on a version of SDL for Rockbox. Change-Id: I8f2c4c78af19de10c1633ed7bb7a997b43256dd9 --- apps/plugins/sdl/src/stdlib/SDL_string.c | 1248 ++++++++++++++++++++++++++++++ 1 file changed, 1248 insertions(+) create mode 100644 apps/plugins/sdl/src/stdlib/SDL_string.c (limited to 'apps/plugins/sdl/src/stdlib/SDL_string.c') diff --git a/apps/plugins/sdl/src/stdlib/SDL_string.c b/apps/plugins/sdl/src/stdlib/SDL_string.c new file mode 100644 index 0000000000..550a623a95 --- /dev/null +++ b/apps/plugins/sdl/src/stdlib/SDL_string.c @@ -0,0 +1,1248 @@ +/* + SDL - Simple DirectMedia Layer + Copyright (C) 1997-2012 Sam Lantinga + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + Sam Lantinga + slouken@libsdl.org +*/ +#include "SDL_config.h" + +/* This file contains portable string manipulation functions for SDL */ + +#include "SDL_stdinc.h" + + +#define SDL_isupperhex(X) (((X) >= 'A') && ((X) <= 'F')) +#define SDL_islowerhex(X) (((X) >= 'a') && ((X) <= 'f')) + +#if !defined(HAVE_SSCANF) || !defined(HAVE_STRTOL) +static size_t SDL_ScanLong(const char *text, int radix, long *valuep) +{ + const char *textstart = text; + long value = 0; + SDL_bool negative = SDL_FALSE; + + if ( *text == '-' ) { + negative = SDL_TRUE; + ++text; + } + if ( radix == 16 && SDL_strncmp(text, "0x", 2) == 0 ) { + text += 2; + } + for ( ; ; ) { + int v; + if ( SDL_isdigit((unsigned char) *text) ) { + v = *text - '0'; + } else if ( radix == 16 && SDL_isupperhex(*text) ) { + v = 10 + (*text - 'A'); + } else if ( radix == 16 && SDL_islowerhex(*text) ) { + v = 10 + (*text - 'a'); + } else { + break; + } + value *= radix; + value += v; + ++text; + } + if ( valuep ) { + if ( negative && value ) { + *valuep = -value; + } else { + *valuep = value; + } + } + return (text - textstart); +} +#endif + +#if !defined(HAVE_SSCANF) || !defined(HAVE_STRTOUL) || !defined(HAVE_STRTOD) +static size_t SDL_ScanUnsignedLong(const char *text, int radix, unsigned long *valuep) +{ + const char *textstart = text; + unsigned long value = 0; + + if ( radix == 16 && SDL_strncmp(text, "0x", 2) == 0 ) { + text += 2; + } + for ( ; ; ) { + int v; + if ( SDL_isdigit((unsigned char) *text) ) { + v = *text - '0'; + } else if ( radix == 16 && SDL_isupperhex(*text) ) { + v = 10 + (*text - 'A'); + } else if ( radix == 16 && SDL_islowerhex(*text) ) { + v = 10 + (*text - 'a'); + } else { + break; + } + value *= radix; + value += v; + ++text; + } + if ( valuep ) { + *valuep = value; + } + return (text - textstart); +} +#endif + +#ifndef HAVE_SSCANF +static size_t SDL_ScanUintPtrT(const char *text, int radix, uintptr_t *valuep) +{ + const char *textstart = text; + uintptr_t value = 0; + + if ( radix == 16 && SDL_strncmp(text, "0x", 2) == 0 ) { + text += 2; + } + for ( ; ; ) { + int v; + if ( SDL_isdigit((unsigned char) *text) ) { + v = *text - '0'; + } else if ( radix == 16 && SDL_isupperhex(*text) ) { + v = 10 + (*text - 'A'); + } else if ( radix == 16 && SDL_islowerhex(*text) ) { + v = 10 + (*text - 'a'); + } else { + break; + } + value *= radix; + value += v; + ++text; + } + if ( valuep ) { + *valuep = value; + } + return (text - textstart); +} +#endif + +#ifdef SDL_HAS_64BIT_TYPE +#if !defined(HAVE_SSCANF) || !defined(HAVE_STRTOLL) +static size_t SDL_ScanLongLong(const char *text, int radix, Sint64 *valuep) +{ + const char *textstart = text; + Sint64 value = 0; + SDL_bool negative = SDL_FALSE; + + if ( *text == '-' ) { + negative = SDL_TRUE; + ++text; + } + if ( radix == 16 && SDL_strncmp(text, "0x", 2) == 0 ) { + text += 2; + } + for ( ; ; ) { + int v; + if ( SDL_isdigit((unsigned char) *text) ) { + v = *text - '0'; + } else if ( radix == 16 && SDL_isupperhex(*text) ) { + v = 10 + (*text - 'A'); + } else if ( radix == 16 && SDL_islowerhex(*text) ) { + v = 10 + (*text - 'a'); + } else { + break; + } + value *= radix; + value += v; + ++text; + } + if ( valuep ) { + if ( negative && value ) { + *valuep = -value; + } else { + *valuep = value; + } + } + return (text - textstart); +} +#endif + +#if !defined(HAVE_SSCANF) || !defined(HAVE_STRTOULL) +static size_t SDL_ScanUnsignedLongLong(const char *text, int radix, Uint64 *valuep) +{ + const char *textstart = text; + Uint64 value = 0; + + if ( radix == 16 && SDL_strncmp(text, "0x", 2) == 0 ) { + text += 2; + } + for ( ; ; ) { + int v; + if ( SDL_isdigit((unsigned char) *text) ) { + v = *text - '0'; + } else if ( radix == 16 && SDL_isupperhex(*text) ) { + v = 10 + (*text - 'A'); + } else if ( radix == 16 && SDL_islowerhex(*text) ) { + v = 10 + (*text - 'a'); + } else { + break; + } + value *= radix; + value += v; + ++text; + } + if ( valuep ) { + *valuep = value; + } + return (text - textstart); +} +#endif +#endif /* SDL_HAS_64BIT_TYPE */ + +#if !defined(HAVE_SSCANF) || !defined(HAVE_STRTOD) +static size_t SDL_ScanFloat(const char *text, double *valuep) +{ + const char *textstart = text; + unsigned long lvalue = 0; + double value = 0.0; + SDL_bool negative = SDL_FALSE; + + if ( *text == '-' ) { + negative = SDL_TRUE; + ++text; + } + text += SDL_ScanUnsignedLong(text, 10, &lvalue); + value += lvalue; + if ( *text == '.' ) { + int mult = 10; + ++text; + while ( SDL_isdigit((unsigned char) *text) ) { + lvalue = *text - '0'; + value += (double)lvalue / mult; + mult *= 10; + ++text; + } + } + if ( valuep ) { + if ( negative && value ) { + *valuep = -value; + } else { + *valuep = value; + } + } + return (text - textstart); +} +#endif + +#ifndef SDL_memset +void *SDL_memset(void *dst, int c, size_t len) +{ + size_t left = (len % 4); + if ( len >= 4 ) { + Uint32 value = 0; + Uint32 *dstp = (Uint32 *)dst; + int i; + for (i = 0; i < 4; ++i) { + value <<= 8; + value |= c; + } + len /= 4; + while ( len-- ) { + *dstp++ = value; + } + } + if ( left > 0 ) { + Uint8 value = (Uint8)c; + Uint8 *dstp = (Uint8 *)dst; + switch(left) { + case 3: + *dstp++ = value; + case 2: + *dstp++ = value; + case 1: + *dstp++ = value; + } + } + return dst; +} +#endif + +#ifndef SDL_memcpy +void *SDL_memcpy(void *dst, const void *src, size_t len) +{ + char *srcp = (char *)src; + char *dstp = (char *)dst; + while ( len-- ) { + *dstp++ = *srcp++; + } + return dst; +} +#endif + +#ifndef SDL_revcpy +void *SDL_revcpy(void *dst, const void *src, size_t len) +{ + char *srcp = (char *)src; + char *dstp = (char *)dst; + srcp += len-1; + dstp += len-1; + while ( len-- ) { + *dstp-- = *srcp--; + } + return dst; +} +#endif + +#ifndef SDL_memcmp +int SDL_memcmp(const void *s1, const void *s2, size_t len) +{ + char *s1p = (char *)s1; + char *s2p = (char *)s2; + while ( len-- ) { + if ( *s1p != *s2p ) { + return (*s1p - *s2p); + } + ++s1p; + ++s2p; + } + return 0; +} +#endif + +#ifndef HAVE_STRLEN +size_t SDL_strlen(const char *string) +{ + size_t len = 0; + while ( *string++ ) { + ++len; + } + return len; +} +#endif + +#ifndef HAVE_STRLCPY +size_t SDL_strlcpy(char *dst, const char *src, size_t maxlen) +{ + size_t srclen = SDL_strlen(src); + if ( maxlen > 0 ) { + size_t len = SDL_min(srclen, maxlen-1); + SDL_memcpy(dst, src, len); + dst[len] = '\0'; + } + return srclen; +} +#endif + +#ifndef HAVE_STRLCAT +size_t SDL_strlcat(char *dst, const char *src, size_t maxlen) +{ + size_t dstlen = SDL_strlen(dst); + size_t srclen = SDL_strlen(src); + if ( dstlen < maxlen ) { + SDL_strlcpy(dst+dstlen, src, maxlen-dstlen); + } + return dstlen+srclen; +} +#endif + +#ifndef HAVE_STRDUP +char *SDL_strdup(const char *string) +{ + size_t len = SDL_strlen(string)+1; + char *newstr = SDL_malloc(len); + if ( newstr ) { + SDL_strlcpy(newstr, string, len); + } + return newstr; +} +#endif + +#ifndef HAVE__STRREV +char *SDL_strrev(char *string) +{ + size_t len = SDL_strlen(string); + char *a = &string[0]; + char *b = &string[len-1]; + len /= 2; + while ( len-- ) { + char c = *a; + *a++ = *b; + *b-- = c; + } + return string; +} +#endif + +#ifndef HAVE__STRUPR +char *SDL_strupr(char *string) +{ + char *bufp = string; + while ( *bufp ) { + *bufp = SDL_toupper((unsigned char) *bufp); + ++bufp; + } + return string; +} +#endif + +#ifndef HAVE__STRLWR +char *SDL_strlwr(char *string) +{ + char *bufp = string; + while ( *bufp ) { + *bufp = SDL_tolower((unsigned char) *bufp); + ++bufp; + } + return string; +} +#endif + +#ifndef HAVE_STRCHR +char *SDL_strchr(const char *string, int c) +{ + while ( *string ) { + if ( *string == c ) { + return (char *)string; + } + ++string; + } + return NULL; +} +#endif + +#ifndef HAVE_STRRCHR +char *SDL_strrchr(const char *string, int c) +{ + const char *bufp = string + SDL_strlen(string) - 1; + while ( bufp >= string ) { + if ( *bufp == c ) { + return (char *)bufp; + } + --bufp; + } + return NULL; +} +#endif + +#ifndef HAVE_STRSTR +char *SDL_strstr(const char *haystack, const char *needle) +{ + size_t length = SDL_strlen(needle); + while ( *haystack ) { + if ( SDL_strncmp(haystack, needle, length) == 0 ) { + return (char *)haystack; + } + ++haystack; + } + return NULL; +} +#endif + +#if !defined(HAVE__LTOA) || !defined(HAVE__I64TOA) || \ + !defined(HAVE__ULTOA) || !defined(HAVE__UI64TOA) +static const char ntoa_table[] = { + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', + 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', + 'U', 'V', 'W', 'X', 'Y', 'Z' +}; +#endif /* ntoa() conversion table */ + +#ifndef HAVE__LTOA +char *SDL_ltoa(long value, char *string, int radix) +{ + char *bufp = string; + + if ( value < 0 ) { + *bufp++ = '-'; + value = -value; + } + if ( value ) { + while ( value > 0 ) { + *bufp++ = ntoa_table[value % radix]; + value /= radix; + } + } else { + *bufp++ = '0'; + } + *bufp = '\0'; + + /* The numbers went into the string backwards. :) */ + if ( *string == '-' ) { + SDL_strrev(string+1); + } else { + SDL_strrev(string); + } + + return string; +} +#endif + +#ifndef HAVE__ULTOA +char *SDL_ultoa(unsigned long value, char *string, int radix) +{ + char *bufp = string; + + if ( value ) { + while ( value > 0 ) { + *bufp++ = ntoa_table[value % radix]; + value /= radix; + } + } else { + *bufp++ = '0'; + } + *bufp = '\0'; + + /* The numbers went into the string backwards. :) */ + SDL_strrev(string); + + return string; +} +#endif + +#ifndef HAVE_STRTOL +long SDL_strtol(const char *string, char **endp, int base) +{ + size_t len; + long value; + + if ( !base ) { + if ( (SDL_strlen(string) > 2) && (SDL_strncmp(string, "0x", 2) == 0) ) { + base = 16; + } else { + base = 10; + } + } + + len = SDL_ScanLong(string, base, &value); + if ( endp ) { + *endp = (char *)string + len; + } + return value; +} +#endif + +#ifndef HAVE_STRTOUL +unsigned long SDL_strtoul(const char *string, char **endp, int base) +{ + size_t len; + unsigned long value; + + 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 + +#ifdef SDL_HAS_64BIT_TYPE + +#ifndef HAVE__I64TOA +char *SDL_lltoa(Sint64 value, char *string, int radix) +{ + char *bufp = string; + + if ( value < 0 ) { + *bufp++ = '-'; + value = -value; + } + if ( value ) { + while ( value > 0 ) { + *bufp++ = ntoa_table[value % radix]; + value /= radix; + } + } else { + *bufp++ = '0'; + } + *bufp = '\0'; + + /* The numbers went into the string backwards. :) */ + if ( *string == '-' ) { + SDL_strrev(string+1); + } else { + SDL_strrev(string); + } + + return string; +} +#endif + +#ifndef HAVE__UI64TOA +char *SDL_ulltoa(Uint64 value, char *string, int radix) +{ + char *bufp = string; + + if ( value ) { + while ( value > 0 ) { + *bufp++ = ntoa_table[value % radix]; + value /= radix; + } + } else { + *bufp++ = '0'; + } + *bufp = '\0'; + + /* The numbers went into the string backwards. :) */ + SDL_strrev(string); + + return string; +} +#endif + +#ifndef HAVE_STRTOLL +Sint64 SDL_strtoll(const char *string, char **endp, int base) +{ + size_t len; + Sint64 value; + + 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 + +#ifndef HAVE_STRTOULL +Uint64 SDL_strtoull(const char *string, char **endp, int base) +{ + size_t len; + Uint64 value; + + 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 + +#endif /* SDL_HAS_64BIT_TYPE */ + +#ifndef HAVE_STRTOD +double SDL_strtod(const char *string, char **endp) +{ + size_t len; + double value; + + len = SDL_ScanFloat(string, &value); + if ( endp ) { + *endp = (char *)string + len; + } + return value; +} +#endif + +#ifndef HAVE_STRCMP +int SDL_strcmp(const char *str1, const char *str2) +{ + while (*str1 && *str2) { + if ( *str1 != *str2 ) + break; + ++str1; + ++str2; + } + return (int)((unsigned char)*str1 - (unsigned char)*str2); +} +#endif + +#ifndef HAVE_STRNCMP +int SDL_strncmp(const char *str1, const char *str2, size_t maxlen) +{ + while ( *str1 && *str2 && maxlen ) { + if ( *str1 != *str2 ) + break; + ++str1; + ++str2; + --maxlen; + } + if ( ! maxlen ) { + return 0; + } + return (int)((unsigned char)*str1 - (unsigned char)*str2); +} +#endif + +#if !defined(HAVE_STRCASECMP) && !defined(HAVE__STRICMP) +int SDL_strcasecmp(const char *str1, const char *str2) +{ + char a = 0; + char b = 0; + while ( *str1 && *str2 ) { + a = SDL_tolower((unsigned char) *str1); + b = SDL_tolower((unsigned char) *str2); + if ( a != b ) + break; + ++str1; + ++str2; + } + return (int)((unsigned char)a - (unsigned char)b); +} +#endif + +#if !defined(HAVE_STRNCASECMP) && !defined(HAVE__STRNICMP) +int SDL_strncasecmp(const char *str1, const char *str2, size_t maxlen) +{ + 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; + } + return (int)((unsigned char)a - (unsigned char)b); +} +#endif + +#ifndef HAVE_SSCANF +int SDL_sscanf(const char *text, const char *fmt, ...) +{ + va_list ap; + int retval = 0; + + va_start(ap, fmt); + 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; + 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': +#ifdef SDL_HAS_64BIT_TYPE + if ( inttype == DO_LONGLONG ) { + Sint64 value; + text += SDL_ScanLongLong(text, radix, &value); + if ( ! suppress ) { + Sint64 *valuep = va_arg(ap, Sint64*); + *valuep = value; + ++retval; + } + } + else +#endif /* SDL_HAS_64BIT_TYPE */ + { + long value; + text += SDL_ScanLong(text, radix, &value); + if ( ! 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': +#ifdef SDL_HAS_64BIT_TYPE + if ( inttype == DO_LONGLONG ) { + Uint64 value; + text += SDL_ScanUnsignedLongLong(text, radix, &value); + if ( ! suppress ) { + Uint64 *valuep = va_arg(ap, Uint64*); + *valuep = value; + ++retval; + } + } + else +#endif /* SDL_HAS_64BIT_TYPE */ + { + unsigned long value; + text += SDL_ScanUnsignedLong(text, radix, &value); + if ( ! 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; + text += SDL_ScanUintPtrT(text, 16, &value); + if ( ! suppress ) { + void** valuep = va_arg(ap, void**); + *valuep = (void*)value; + ++retval; + } + } + done = SDL_TRUE; + break; + case 'f': + { + double value; + text += SDL_ScanFloat(text, &value); + if ( ! 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; + } + va_end(ap); + + return retval; +} +#endif + +#ifndef HAVE_SNPRINTF +int SDL_snprintf(char *text, size_t maxlen, const char *fmt, ...) +{ + va_list ap; + int retval; + + va_start(ap, fmt); + retval = SDL_vsnprintf(text, maxlen, fmt, ap); + va_end(ap); + + return retval; +} +#endif + +#ifndef HAVE_VSNPRINTF +static size_t SDL_PrintLong(char *text, long value, int radix, size_t maxlen) +{ + char num[130]; + size_t size; + + SDL_ltoa(value, num, radix); + size = SDL_strlen(num); + if ( size >= maxlen ) { + size = maxlen-1; + } + SDL_strlcpy(text, num, size+1); + + return size; +} +static size_t SDL_PrintUnsignedLong(char *text, unsigned long value, int radix, size_t maxlen) +{ + char num[130]; + size_t size; + + SDL_ultoa(value, num, radix); + size = SDL_strlen(num); + if ( size >= maxlen ) { + size = maxlen-1; + } + SDL_strlcpy(text, num, size+1); + + return size; +} +#ifdef SDL_HAS_64BIT_TYPE +static size_t SDL_PrintLongLong(char *text, Sint64 value, int radix, size_t maxlen) +{ + char num[130]; + size_t size; + + SDL_lltoa(value, num, radix); + size = SDL_strlen(num); + if ( size >= maxlen ) { + size = maxlen-1; + } + SDL_strlcpy(text, num, size+1); + + return size; +} +static size_t SDL_PrintUnsignedLongLong(char *text, Uint64 value, int radix, size_t maxlen) +{ + char num[130]; + size_t size; + + SDL_ulltoa(value, num, radix); + size = SDL_strlen(num); + if ( size >= maxlen ) { + size = maxlen-1; + } + SDL_strlcpy(text, num, size+1); + + return size; +} +#endif /* SDL_HAS_64BIT_TYPE */ +static size_t SDL_PrintFloat(char *text, double arg, size_t maxlen) +{ + char *textstart = text; + if ( arg ) { + /* This isn't especially accurate, but hey, it's easy. :) */ + const double precision = 0.00000001; + size_t len; + unsigned long value; + + if ( arg < 0 ) { + *text++ = '-'; + --maxlen; + arg = -arg; + } + value = (unsigned long)arg; + len = SDL_PrintUnsignedLong(text, value, 10, maxlen); + text += len; + maxlen -= len; + arg -= value; + if ( arg > precision && maxlen ) { + int mult = 10; + *text++ = '.'; + while ( (arg > precision) && maxlen ) { + value = (unsigned long)(arg * mult); + len = SDL_PrintUnsignedLong(text, value, 10, maxlen); + text += len; + maxlen -= len; + arg -= (double)value / mult; + mult *= 10; + } + } + } else { + *text++ = '0'; + } + return (text - textstart); +} +static size_t SDL_PrintString(char *text, const char *string, size_t maxlen) +{ + char *textstart = text; + while ( *string && maxlen-- ) { + *text++ = *string++; + } + return (text - textstart); +} +int SDL_vsnprintf(char *text, size_t maxlen, const char *fmt, va_list ap) +{ + char *textstart = text; + if ( maxlen <= 0 ) { + return 0; + } + --maxlen; /* For the trailing '\0' */ + while ( *fmt && maxlen ) { + if ( *fmt == '%' ) { + SDL_bool done = SDL_FALSE; + size_t len = 0; + SDL_bool do_lowercase = SDL_FALSE; + int radix = 10; + enum { + DO_INT, + DO_LONG, + DO_LONGLONG + } inttype = DO_INT; + + ++fmt; + /* FIXME: implement more of the format specifiers */ + while ( *fmt == '.' || (*fmt >= '0' && *fmt <= '9') ) { + ++fmt; + } + while (!done) { + switch(*fmt) { + case '%': + *text = '%'; + len = 1; + done = SDL_TRUE; + break; + case 'c': + /* char is promoted to int when passed through (...) */ + *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': + switch (inttype) { + case DO_INT: + len = SDL_PrintLong(text, (long)va_arg(ap, int), radix, maxlen); + break; + case DO_LONG: + len = SDL_PrintLong(text, va_arg(ap, long), radix, maxlen); + break; + case DO_LONGLONG: +#ifdef SDL_HAS_64BIT_TYPE + len = SDL_PrintLongLong(text, va_arg(ap, Sint64), radix, maxlen); +#else + len = SDL_PrintLong(text, va_arg(ap, long), radix, maxlen); +#endif + break; + } + done = SDL_TRUE; + break; + case 'p': + case 'x': + do_lowercase = SDL_TRUE; + /* Fall through to 'X' handling */ + case 'X': + if ( radix == 10 ) { + radix = 16; + } + if ( *fmt == 'p' ) { + inttype = DO_LONG; + } + /* Fall through to unsigned handling */ + case 'o': + if ( radix == 10 ) { + radix = 8; + } + /* Fall through to unsigned handling */ + case 'u': + switch (inttype) { + case DO_INT: + len = SDL_PrintUnsignedLong(text, (unsigned long)va_arg(ap, unsigned int), radix, maxlen); + break; + case DO_LONG: + len = SDL_PrintUnsignedLong(text, va_arg(ap, unsigned long), radix, maxlen); + break; + case DO_LONGLONG: +#ifdef SDL_HAS_64BIT_TYPE + len = SDL_PrintUnsignedLongLong(text, va_arg(ap, Uint64), radix, maxlen); +#else + len = SDL_PrintUnsignedLong(text, va_arg(ap, unsigned long), radix, maxlen); +#endif + break; + } + if ( do_lowercase ) { + SDL_strlwr(text); + } + done = SDL_TRUE; + break; + case 'f': + len = SDL_PrintFloat(text, va_arg(ap, double), maxlen); + done = SDL_TRUE; + break; + case 's': + len = SDL_PrintString(text, va_arg(ap, char*), maxlen); + done = SDL_TRUE; + break; + default: + done = SDL_TRUE; + break; + } + ++fmt; + } + text += len; + maxlen -= len; + } else { + *text++ = *fmt++; + --maxlen; + } + } + *text = '\0'; + + return (text - textstart); +} +#endif -- cgit v1.2.3