| /* | |
| Simple DirectMedia Layer | |
| Copyright (C) 1997-2026 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_internal.h" | |
| // This file contains portable string manipulation functions for SDL | |
| #include "SDL_vacopy.h" | |
| #ifdef SDL_PLATFORM_VITA | |
| #include <psp2/kernel/clib.h> | |
| #endif | |
| #include "SDL_sysstdlib.h" | |
| #include "SDL_casefolding.h" | |
| #if defined(__SIZEOF_WCHAR_T__) | |
| #define SDL_SIZEOF_WCHAR_T __SIZEOF_WCHAR_T__ | |
| #elif defined(SDL_PLATFORM_NGAGE) | |
| #define SDL_SIZEOF_WCHAR_T 2 | |
| #elif defined(SDL_PLATFORM_WINDOWS) || defined(SDL_PLATFORM_DOS) | |
| #define SDL_SIZEOF_WCHAR_T 2 | |
| #else // assume everything else is UTF-32 (add more tests if compiler-assert fails below!) | |
| #define SDL_SIZEOF_WCHAR_T 4 | |
| #endif | |
| SDL_COMPILE_TIME_ASSERT(sizeof_wchar_t, sizeof(wchar_t) == SDL_SIZEOF_WCHAR_T); | |
| char *SDL_UCS4ToUTF8(Uint32 codepoint, char *dst) | |
| { | |
| if (!dst) { | |
| return NULL; // I guess...? | |
| } else if (codepoint > 0x10FFFF) { // Outside the range of Unicode codepoints (also, larger than can be encoded in 4 bytes of UTF-8!). | |
| codepoint = SDL_INVALID_UNICODE_CODEPOINT; | |
| } else if ((codepoint >= 0xD800) && (codepoint <= 0xDFFF)) { // UTF-16 surrogate values are illegal in UTF-8. | |
| codepoint = SDL_INVALID_UNICODE_CODEPOINT; | |
| } | |
| Uint8 *p = (Uint8 *)dst; | |
| if (codepoint <= 0x7F) { | |
| *p = (Uint8)codepoint; | |
| ++dst; | |
| } else if (codepoint <= 0x7FF) { | |
| p[0] = 0xC0 | (Uint8)((codepoint >> 6) & 0x1F); | |
| p[1] = 0x80 | (Uint8)(codepoint & 0x3F); | |
| dst += 2; | |
| } else if (codepoint <= 0xFFFF) { | |
| p[0] = 0xE0 | (Uint8)((codepoint >> 12) & 0x0F); | |
| p[1] = 0x80 | (Uint8)((codepoint >> 6) & 0x3F); | |
| p[2] = 0x80 | (Uint8)(codepoint & 0x3F); | |
| dst += 3; | |
| } else { | |
| SDL_assert(codepoint <= 0x10FFFF); | |
| p[0] = 0xF0 | (Uint8)((codepoint >> 18) & 0x07); | |
| p[1] = 0x80 | (Uint8)((codepoint >> 12) & 0x3F); | |
| p[2] = 0x80 | (Uint8)((codepoint >> 6) & 0x3F); | |
| p[3] = 0x80 | (Uint8)(codepoint & 0x3F); | |
| dst += 4; | |
| } | |
| return dst; | |
| } | |
| // this expects `from` and `to` to be UTF-32 encoding! | |
| int SDL_CaseFoldUnicode(Uint32 from, Uint32 *to) | |
| { | |
| // !!! FIXME: since the hashtable is static, maybe we should binary | |
| // !!! FIXME: search it instead of walking the whole bucket. | |
| if (from < 128) { // low-ASCII, easy! | |
| if ((from >= 'A') && (from <= 'Z')) { | |
| *to = 'a' + (from - 'A'); | |
| return 1; | |
| } | |
| } else if (from <= 0xFFFF) { // the Basic Multilingual Plane. | |
| const Uint8 hash = ((from ^ (from >> 8)) & 0xFF); | |
| const Uint16 from16 = (Uint16) from; | |
| // see if it maps to a single char (most common)... | |
| { | |
| const CaseFoldHashBucket1_16 *bucket = &case_fold_hash1_16[hash]; | |
| const int count = (int) bucket->count; | |
| for (int i = 0; i < count; i++) { | |
| const CaseFoldMapping1_16 *mapping = &bucket->list[i]; | |
| if (mapping->from == from16) { | |
| *to = mapping->to0; | |
| return 1; | |
| } | |
| } | |
| } | |
| // see if it folds down to two chars... | |
| { | |
| const CaseFoldHashBucket2_16 *bucket = &case_fold_hash2_16[hash & 15]; | |
| const int count = (int) bucket->count; | |
| for (int i = 0; i < count; i++) { | |
| const CaseFoldMapping2_16 *mapping = &bucket->list[i]; | |
| if (mapping->from == from16) { | |
| to[0] = mapping->to0; | |
| to[1] = mapping->to1; | |
| return 2; | |
| } | |
| } | |
| } | |
| // okay, maybe it's _three_ characters! | |
| { | |
| const CaseFoldHashBucket3_16 *bucket = &case_fold_hash3_16[hash & 3]; | |
| const int count = (int) bucket->count; | |
| for (int i = 0; i < count; i++) { | |
| const CaseFoldMapping3_16 *mapping = &bucket->list[i]; | |
| if (mapping->from == from16) { | |
| to[0] = mapping->to0; | |
| to[1] = mapping->to1; | |
| to[2] = mapping->to2; | |
| return 3; | |
| } | |
| } | |
| } | |
| } else { // codepoint that doesn't fit in 16 bits. | |
| const Uint8 hash = ((from ^ (from >> 8)) & 0xFF); | |
| const CaseFoldHashBucket1_32 *bucket = &case_fold_hash1_32[hash & 15]; | |
| const int count = (int) bucket->count; | |
| for (int i = 0; i < count; i++) { | |
| const CaseFoldMapping1_32 *mapping = &bucket->list[i]; | |
| if (mapping->from == from) { | |
| *to = mapping->to0; | |
| return 1; | |
| } | |
| } | |
| } | |
| // Not found...there's no folding needed for this codepoint. | |
| *to = from; | |
| return 1; | |
| } | |
| #define UNICODE_STRCASECMP(bits, slen1, slen2, update_slen1, update_slen2) \ | |
| Uint32 folded1[3], folded2[3]; \ | |
| int head1 = 0, tail1 = 0, head2 = 0, tail2 = 0; \ | |
| while (true) { \ | |
| Uint32 cp1, cp2; \ | |
| if (head1 != tail1) { \ | |
| cp1 = folded1[tail1++]; \ | |
| } else { \ | |
| const Uint##bits *str1start = (const Uint##bits *) str1; \ | |
| head1 = SDL_CaseFoldUnicode(StepUTF##bits(&str1, slen1), folded1); \ | |
| update_slen1; \ | |
| cp1 = folded1[0]; \ | |
| tail1 = 1; \ | |
| } \ | |
| if (head2 != tail2) { \ | |
| cp2 = folded2[tail2++]; \ | |
| } else { \ | |
| const Uint##bits *str2start = (const Uint##bits *) str2; \ | |
| head2 = SDL_CaseFoldUnicode(StepUTF##bits(&str2, slen2), folded2); \ | |
| update_slen2; \ | |
| cp2 = folded2[0]; \ | |
| tail2 = 1; \ | |
| } \ | |
| if (cp1 < cp2) { \ | |
| return -1; \ | |
| } else if (cp1 > cp2) { \ | |
| return 1; \ | |
| } else if (cp1 == 0) { \ | |
| break; /* complete match. */ \ | |
| } \ | |
| } \ | |
| return 0 | |
| static Uint32 StepUTF8(const char **_str, const size_t slen) | |
| { | |
| /* | |
| * From rfc3629, the UTF-8 spec: | |
| * https://www.ietf.org/rfc/rfc3629.txt | |
| * | |
| * Char. number range | UTF-8 octet sequence | |
| * (hexadecimal) | (binary) | |
| * --------------------+--------------------------------------------- | |
| * 0000 0000-0000 007F | 0xxxxxxx | |
| * 0000 0080-0000 07FF | 110xxxxx 10xxxxxx | |
| * 0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx | |
| * 0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx | |
| */ | |
| const Uint8 *str = (const Uint8 *) *_str; | |
| const Uint32 octet = (Uint32) (slen ? *str : 0); | |
| if (octet == 0) { // null terminator, end of string. | |
| return 0; // don't advance `*_str`. | |
| } else if ((octet & 0x80) == 0) { // 0xxxxxxx: one byte codepoint. | |
| (*_str)++; | |
| return octet; | |
| } else if (((octet & 0xE0) == 0xC0) && (slen >= 2)) { // 110xxxxx 10xxxxxx: two byte codepoint. | |
| const Uint8 str1 = str[1]; | |
| if ((str1 & 0xC0) == 0x80) { // If trailing bytes aren't 10xxxxxx, sequence is bogus. | |
| const Uint32 result = ((octet & 0x1F) << 6) | (str1 & 0x3F); | |
| if (result >= 0x0080) { // rfc3629 says you can't use overlong sequences for smaller values. | |
| *_str += 2; | |
| return result; | |
| } | |
| } | |
| } else if (((octet & 0xF0) == 0xE0) && (slen >= 3)) { // 1110xxxx 10xxxxxx 10xxxxxx: three byte codepoint. | |
| const Uint8 str1 = str[1]; | |
| const Uint8 str2 = str[2]; | |
| if (((str1 & 0xC0) == 0x80) && ((str2 & 0xC0) == 0x80)) { // If trailing bytes aren't 10xxxxxx, sequence is bogus. | |
| const Uint32 octet2 = ((Uint32) (str1 & 0x3F)) << 6; | |
| const Uint32 octet3 = ((Uint32) (str2 & 0x3F)); | |
| const Uint32 result = ((octet & 0x0F) << 12) | octet2 | octet3; | |
| if (result >= 0x800) { // rfc3629 says you can't use overlong sequences for smaller values. | |
| if ((result < 0xD800) || (result > 0xDFFF)) { // UTF-16 surrogate values are illegal in UTF-8. | |
| *_str += 3; | |
| return result; | |
| } | |
| } | |
| } | |
| } else if (((octet & 0xF8) == 0xF0) && (slen >= 4)) { // 11110xxxx 10xxxxxx 10xxxxxx 10xxxxxx: four byte codepoint. | |
| const Uint8 str1 = str[1]; | |
| const Uint8 str2 = str[2]; | |
| const Uint8 str3 = str[3]; | |
| if (((str1 & 0xC0) == 0x80) && ((str2 & 0xC0) == 0x80) && ((str3 & 0xC0) == 0x80)) { // If trailing bytes aren't 10xxxxxx, sequence is bogus. | |
| const Uint32 octet2 = ((Uint32) (str1 & 0x3F)) << 12; | |
| const Uint32 octet3 = ((Uint32) (str2 & 0x3F)) << 6; | |
| const Uint32 octet4 = ((Uint32) (str3 & 0x3F)); | |
| const Uint32 result = ((octet & 0x07) << 18) | octet2 | octet3 | octet4; | |
| if (result >= 0x10000) { // rfc3629 says you can't use overlong sequences for smaller values. | |
| *_str += 4; | |
| return result; | |
| } | |
| } | |
| } | |
| // bogus byte, skip ahead, return a REPLACEMENT CHARACTER. | |
| (*_str)++; | |
| return SDL_INVALID_UNICODE_CODEPOINT; | |
| } | |
| Uint32 SDL_StepUTF8(const char **pstr, size_t *pslen) | |
| { | |
| if (!pslen) { | |
| return StepUTF8(pstr, 4); // 4 == max codepoint size. | |
| } | |
| const char *origstr = *pstr; | |
| const Uint32 result = StepUTF8(pstr, *pslen); | |
| *pslen -= (size_t) (*pstr - origstr); | |
| return result; | |
| } | |
| Uint32 SDL_StepBackUTF8(const char *start, const char **pstr) | |
| { | |
| if (!pstr || *pstr <= start) { | |
| return 0; | |
| } | |
| // Step back over the previous UTF-8 character | |
| const char *str = *pstr; | |
| do { | |
| if (str == start) { | |
| break; | |
| } | |
| --str; | |
| } while ((*str & 0xC0) == 0x80); | |
| size_t length = (*pstr - str); | |
| *pstr = str; | |
| return StepUTF8(&str, length); | |
| } | |
| #if (SDL_SIZEOF_WCHAR_T == 2) | |
| static Uint32 StepUTF16(const Uint16 **_str, const size_t slen) | |
| { | |
| const Uint16 *str = *_str; | |
| Uint32 cp = (Uint32) *(str++); | |
| if (cp == 0) { | |
| return 0; // don't advance string pointer. | |
| } else if ((cp >= 0xDC00) && (cp <= 0xDFFF)) { | |
| cp = SDL_INVALID_UNICODE_CODEPOINT; // Orphaned second half of surrogate pair | |
| } else if ((cp >= 0xD800) && (cp <= 0xDBFF)) { // start of surrogate pair! | |
| const Uint32 pair = (Uint32) *str; | |
| if ((pair == 0) || ((pair < 0xDC00) || (pair > 0xDFFF))) { | |
| cp = SDL_INVALID_UNICODE_CODEPOINT; | |
| } else { | |
| str++; // eat the other surrogate. | |
| cp = 0x10000 + (((cp - 0xD800) << 10) | (pair - 0xDC00)); | |
| } | |
| } | |
| *_str = str; | |
| return (cp > 0x10FFFF) ? SDL_INVALID_UNICODE_CODEPOINT : cp; | |
| } | |
| #elif (SDL_SIZEOF_WCHAR_T == 4) | |
| static Uint32 StepUTF32(const Uint32 **_str, const size_t slen) | |
| { | |
| if (!slen) { | |
| return 0; | |
| } | |
| const Uint32 *str = *_str; | |
| const Uint32 cp = *str; | |
| if (cp == 0) { | |
| return 0; // don't advance string pointer. | |
| } | |
| (*_str)++; | |
| return (cp > 0x10FFFF) ? SDL_INVALID_UNICODE_CODEPOINT : cp; | |
| } | |
| #endif | |
| #define UTF8_IsLeadByte(c) ((c) >= 0xC0 && (c) <= 0xF4) | |
| #define UTF8_IsTrailingByte(c) ((c) >= 0x80 && (c) <= 0xBF) | |
| static size_t UTF8_GetTrailingBytes(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; | |
| } | |
| return 0; | |
| } | |
| #if !defined(HAVE_VSSCANF) || !defined(HAVE_STRTOL) || !defined(HAVE_STRTOUL) || !defined(HAVE_STRTOLL) || !defined(HAVE_STRTOULL) || !defined(HAVE_STRTOD) | |
| /** | |
| * Parses an unsigned long long and returns the unsigned value and sign bit. | |
| * | |
| * Positive values are clamped to ULLONG_MAX. | |
| * The result `value == 0 && negative` indicates negative overflow | |
| * and might need to be handled differently depending on whether a | |
| * signed or unsigned integer is being parsed. | |
| */ | |
| static size_t SDL_ScanUnsignedLongLongInternal(const char *text, int count, int radix, unsigned long long *valuep, bool *negativep) | |
| { | |
| const unsigned long long ullong_max = ~0ULL; | |
| const char *text_start = text; | |
| const char *number_start = text_start; | |
| unsigned long long value = 0; | |
| bool negative = false; | |
| bool overflow = false; | |
| if (radix == 0 || (radix >= 2 && radix <= 36)) { | |
| while (SDL_isspace(*text)) { | |
| ++text; | |
| } | |
| if (*text == '-' || *text == '+') { | |
| negative = *text == '-'; | |
| ++text; | |
| } | |
| if ((radix == 0 || radix == 16) && *text == '0' && (text[1] == 'x' || text[1] == 'X')) { | |
| text += 2; | |
| radix = 16; | |
| } else if (radix == 0 && *text == '0' && (text[1] >= '0' && text[1] <= '9')) { | |
| ++text; | |
| radix = 8; | |
| } else if (radix == 0) { | |
| radix = 10; | |
| } | |
| number_start = text; | |
| do { | |
| unsigned long long digit; | |
| if (*text >= '0' && *text <= '9') { | |
| digit = *text - '0'; | |
| } else if (radix > 10) { | |
| if (*text >= 'A' && *text < 'A' + (radix - 10)) { | |
| digit = 10 + (*text - 'A'); | |
| } else if (*text >= 'a' && *text < 'a' + (radix - 10)) { | |
| digit = 10 + (*text - 'a'); | |
| } else { | |
| break; | |
| } | |
| } else { | |
| break; | |
| } | |
| if (value != 0 && radix > ullong_max / value) { | |
| overflow = true; | |
| } else { | |
| value *= radix; | |
| if (digit > ullong_max - value) { | |
| overflow = true; | |
| } else { | |
| value += digit; | |
| } | |
| } | |
| ++text; | |
| } while (count == 0 || (text - text_start) != count); | |
| } | |
| if (text == number_start) { | |
| if (radix == 16 && text > text_start && (*(text - 1) == 'x' || *(text - 1) == 'X')) { | |
| // the string was "0x"; consume the '0' but not the 'x' | |
| --text; | |
| } else { | |
| // no number was parsed, and thus no characters were consumed | |
| text = text_start; | |
| } | |
| } | |
| if (overflow) { | |
| if (negative) { | |
| value = 0; | |
| } else { | |
| value = ullong_max; | |
| } | |
| } else if (value == 0) { | |
| negative = false; | |
| } | |
| *valuep = value; | |
| *negativep = negative; | |
| return text - text_start; | |
| } | |
| #endif | |
| #if !defined(HAVE_WCSTOL) || !defined (HAVE_WCSTOLL) || !defined(HAVE_WCSTOUL) || !defined(HAVE_WCSTOULL) | |
| // SDL_ScanUnsignedLongLongInternalW assumes that wchar_t can be converted to int without truncating bits | |
| SDL_COMPILE_TIME_ASSERT(wchar_t_int, sizeof(wchar_t) <= sizeof(int)); | |
| /** | |
| * Parses an unsigned long long and returns the unsigned value and sign bit. | |
| * | |
| * Positive values are clamped to ULLONG_MAX. | |
| * The result `value == 0 && negative` indicates negative overflow | |
| * and might need to be handled differently depending on whether a | |
| * signed or unsigned integer is being parsed. | |
| */ | |
| static size_t SDL_ScanUnsignedLongLongInternalW(const wchar_t *text, int count, int radix, unsigned long long *valuep, bool *negativep) | |
| { | |
| const unsigned long long ullong_max = ~0ULL; | |
| const wchar_t *text_start = text; | |
| const wchar_t *number_start = text_start; | |
| unsigned long long value = 0; | |
| bool negative = false; | |
| bool overflow = false; | |
| if (radix == 0 || (radix >= 2 && radix <= 36)) { | |
| while (SDL_isspace(*text)) { | |
| ++text; | |
| } | |
| if (*text == '-' || *text == '+') { | |
| negative = *text == '-'; | |
| ++text; | |
| } | |
| if ((radix == 0 || radix == 16) && *text == '0' && (text[1] == 'x' || text[1] == 'X')) { | |
| text += 2; | |
| radix = 16; | |
| } else if (radix == 0 && *text == '0' && (text[1] >= '0' && text[1] <= '9')) { | |
| ++text; | |
| radix = 8; | |
| } else if (radix == 0) { | |
| radix = 10; | |
| } | |
| number_start = text; | |
| do { | |
| unsigned long long digit; | |
| if (*text >= '0' && *text <= '9') { | |
| digit = *text - '0'; | |
| } else if (radix > 10) { | |
| if (*text >= 'A' && *text < 'A' + (radix - 10)) { | |
| digit = 10 + (*text - 'A'); | |
| } else if (*text >= 'a' && *text < 'a' + (radix - 10)) { | |
| digit = 10 + (*text - 'a'); | |
| } else { | |
| break; | |
| } | |
| } else { | |
| break; | |
| } | |
| if (value != 0 && radix > ullong_max / value) { | |
| overflow = true; | |
| } else { | |
| value *= radix; | |
| if (digit > ullong_max - value) { | |
| overflow = true; | |
| } else { | |
| value += digit; | |
| } | |
| } | |
| ++text; | |
| } while (count == 0 || (text - text_start) != count); | |
| } | |
| if (text == number_start) { | |
| if (radix == 16 && text > text_start && (*(text - 1) == 'x' || *(text - 1) == 'X')) { | |
| // the string was "0x"; consume the '0' but not the 'x' | |
| --text; | |
| } else { | |
| // no number was parsed, and thus no characters were consumed | |
| text = text_start; | |
| } | |
| } | |
| if (overflow) { | |
| if (negative) { | |
| value = 0; | |
| } else { | |
| value = ullong_max; | |
| } | |
| } else if (value == 0) { | |
| negative = false; | |
| } | |
| *valuep = value; | |
| *negativep = negative; | |
| return text - text_start; | |
| } | |
| #endif | |
| #if !defined(HAVE_VSSCANF) || !defined(HAVE_STRTOL) | |
| static size_t SDL_ScanLong(const char *text, int count, int radix, long *valuep) | |
| { | |
| const unsigned long long_max = (~0UL) >> 1; | |
| unsigned long long value; | |
| bool negative; | |
| size_t len = SDL_ScanUnsignedLongLongInternal(text, count, radix, &value, &negative); | |
| if (negative) { | |
| const unsigned long abs_long_min = long_max + 1; | |
| if (value == 0 || value > abs_long_min) { | |
| value = 0ULL - abs_long_min; | |
| } else { | |
| value = 0ULL - value; | |
| } | |
| } else if (value > long_max) { | |
| value = long_max; | |
| } | |
| *valuep = (long)value; | |
| return len; | |
| } | |
| #endif | |
| #ifndef HAVE_WCSTOL | |
| static size_t SDL_ScanLongW(const wchar_t *text, int count, int radix, long *valuep) | |
| { | |
| const unsigned long long_max = (~0UL) >> 1; | |
| unsigned long long value; | |
| bool negative; | |
| size_t len = SDL_ScanUnsignedLongLongInternalW(text, count, radix, &value, &negative); | |
| if (negative) { | |
| const unsigned long abs_long_min = long_max + 1; | |
| if (value == 0 || value > abs_long_min) { | |
| value = 0ULL - abs_long_min; | |
| } else { | |
| value = 0ULL - value; | |
| } | |
| } else if (value > long_max) { | |
| value = long_max; | |
| } | |
| *valuep = (long)value; | |
| return len; | |
| } | |
| #endif | |
| #if !defined(HAVE_VSSCANF) || !defined(HAVE_STRTOUL) | |
| static size_t SDL_ScanUnsignedLong(const char *text, int count, int radix, unsigned long *valuep) | |
| { | |
| const unsigned long ulong_max = ~0UL; | |
| unsigned long long value; | |
| bool negative; | |
| size_t len = SDL_ScanUnsignedLongLongInternal(text, count, radix, &value, &negative); | |
| if (negative) { | |
| if (value == 0 || value > ulong_max) { | |
| value = ulong_max; | |
| } else if (value == ulong_max) { | |
| value = 1; | |
| } else { | |
| value = 0ULL - value; | |
| } | |
| } else if (value > ulong_max) { | |
| value = ulong_max; | |
| } | |
| *valuep = (unsigned long)value; | |
| return len; | |
| } | |
| #endif | |
| #ifndef HAVE_WCSTOUL | |
| static size_t SDL_ScanUnsignedLongW(const wchar_t *text, int count, int radix, unsigned long *valuep) | |
| { | |
| const unsigned long ulong_max = ~0UL; | |
| unsigned long long value; | |
| bool negative; | |
| size_t len = SDL_ScanUnsignedLongLongInternalW(text, count, radix, &value, &negative); | |
| if (negative) { | |
| if (value == 0 || value > ulong_max) { | |
| value = ulong_max; | |
| } else if (value == ulong_max) { | |
| value = 1; | |
| } else { | |
| value = 0ULL - value; | |
| } | |
| } else if (value > ulong_max) { | |
| value = ulong_max; | |
| } | |
| *valuep = (unsigned long)value; | |
| return len; | |
| } | |
| #endif | |
| #ifndef HAVE_VSSCANF | |
| static size_t SDL_ScanUintPtrT(const char *text, uintptr_t *valuep) | |
| { | |
| const uintptr_t uintptr_max = ~(uintptr_t)0; | |
| unsigned long long value; | |
| bool negative; | |
| size_t len = SDL_ScanUnsignedLongLongInternal(text, 0, 16, &value, &negative); | |
| if (negative) { | |
| if (value == 0 || value > uintptr_max) { | |
| value = uintptr_max; | |
| } else if (value == uintptr_max) { | |
| value = 1; | |
| } else { | |
| value = 0ULL - value; | |
| } | |
| } else if (value > uintptr_max) { | |
| value = uintptr_max; | |
| } | |
| *valuep = (uintptr_t)value; | |
| return len; | |
| } | |
| #endif | |
| #if !defined(HAVE_VSSCANF) || !defined(HAVE_STRTOLL) | |
| static size_t SDL_ScanLongLong(const char *text, int count, int radix, long long *valuep) | |
| { | |
| const unsigned long long llong_max = (~0ULL) >> 1; | |
| unsigned long long value; | |
| bool negative; | |
| size_t len = SDL_ScanUnsignedLongLongInternal(text, count, radix, &value, &negative); | |
| if (negative) { | |
| const unsigned long long abs_llong_min = llong_max + 1; | |
| if (value == 0 || value > abs_llong_min) { | |
| value = 0ULL - abs_llong_min; | |
| } else { | |
| value = 0ULL - value; | |
| } | |
| } else if (value > llong_max) { | |
| value = llong_max; | |
| } | |
| *valuep = value; | |
| return len; | |
| } | |
| #endif | |
| #ifndef HAVE_WCSTOLL | |
| static size_t SDL_ScanLongLongW(const wchar_t *text, int count, int radix, long long *valuep) | |
| { | |
| const unsigned long long llong_max = (~0ULL) >> 1; | |
| unsigned long long value; | |
| bool negative; | |
| size_t len = SDL_ScanUnsignedLongLongInternalW(text, count, radix, &value, &negative); | |
| if (negative) { | |
| const unsigned long long abs_llong_min = llong_max + 1; | |
| if (value == 0 || value > abs_llong_min) { | |
| value = 0ULL - abs_llong_min; | |
| } else { | |
| value = 0ULL - value; | |
| } | |
| } else if (value > llong_max) { | |
| value = llong_max; | |
| } | |
| *valuep = value; | |
| return len; | |
| } | |
| #endif | |
| #if !defined(HAVE_VSSCANF) || !defined(HAVE_STRTOULL) || !defined(HAVE_STRTOD) | |
| static size_t SDL_ScanUnsignedLongLong(const char *text, int count, int radix, unsigned long long *valuep) | |
| { | |
| const unsigned long long ullong_max = ~0ULL; | |
| bool negative; | |
| size_t len = SDL_ScanUnsignedLongLongInternal(text, count, radix, valuep, &negative); | |
| if (negative) { | |
| if (*valuep == 0) { | |
| *valuep = ullong_max; | |
| } else { | |
| *valuep = 0ULL - *valuep; | |
| } | |
| } | |
| return len; | |
| } | |
| #endif | |
| #ifndef HAVE_WCSTOULL | |
| static size_t SDL_ScanUnsignedLongLongW(const wchar_t *text, int count, int radix, unsigned long long *valuep) | |
| { | |
| const unsigned long long ullong_max = ~0ULL; | |
| bool negative; | |
| size_t len = SDL_ScanUnsignedLongLongInternalW(text, count, radix, valuep, &negative); | |
| if (negative) { | |
| if (*valuep == 0) { | |
| *valuep = ullong_max; | |
| } else { | |
| *valuep = 0ULL - *valuep; | |
| } | |
| } | |
| return len; | |
| } | |
| #endif | |
| #if !defined(HAVE_VSSCANF) || !defined(HAVE_STRTOD) | |
| static size_t SDL_ScanFloat(const char *text, double *valuep) | |
| { | |
| const char *text_start = text; | |
| const char *number_start = text_start; | |
| double value = 0.0; | |
| bool negative = false; | |
| while (SDL_isspace(*text)) { | |
| ++text; | |
| } | |
| if (*text == '-' || *text == '+') { | |
| negative = *text == '-'; | |
| ++text; | |
| } | |
| number_start = text; | |
| if (SDL_isdigit(*text)) { | |
| value += SDL_strtoull(text, (char **)(&text), 10); | |
| if (*text == '.') { | |
| double denom = 10; | |
| ++text; | |
| while (SDL_isdigit(*text)) { | |
| value += (double)(*text - '0') / denom; | |
| denom *= 10; | |
| ++text; | |
| } | |
| } | |
| } | |
| if (text == number_start) { | |
| // no number was parsed, and thus no characters were consumed | |
| text = text_start; | |
| } else if (negative) { | |
| value = -value; | |
| } | |
| *valuep = value; | |
| return text - text_start; | |
| } | |
| #endif | |
| int SDL_memcmp(const void *s1, const void *s2, size_t len) | |
| { | |
| #ifdef SDL_PLATFORM_VITA | |
| /* | |
| Using memcmp on NULL is UB per POSIX / C99 7.21.1/2. | |
| But, both linux and bsd allow that, with an exception: | |
| zero length strings are always identical, so NULLs are never dereferenced. | |
| sceClibMemcmp on PSVita doesn't allow that, so we check ourselves. | |
| */ | |
| if (len == 0) { | |
| return 0; | |
| } | |
| return sceClibMemcmp(s1, s2, len); | |
| #elif 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 // SDL_PLATFORM_VITA | |
| } | |
| size_t SDL_strlen(const char *string) | |
| { | |
| #ifdef HAVE_STRLEN | |
| return strlen(string); | |
| #else | |
| size_t len = 0; | |
| while (*string++) { | |
| ++len; | |
| } | |
| return len; | |
| #endif // HAVE_STRLEN | |
| } | |
| size_t SDL_strnlen(const char *string, size_t maxlen) | |
| { | |
| #ifdef HAVE_STRNLEN | |
| return strnlen(string, maxlen); | |
| #else | |
| size_t len = 0; | |
| while (len < maxlen && *string++) { | |
| ++len; | |
| } | |
| return len; | |
| #endif // HAVE_STRNLEN | |
| } | |
| size_t SDL_wcslen(const wchar_t *string) | |
| { | |
| #ifdef HAVE_WCSLEN | |
| return wcslen(string); | |
| #else | |
| size_t len = 0; | |
| while (*string++) { | |
| ++len; | |
| } | |
| return len; | |
| #endif // HAVE_WCSLEN | |
| } | |
| size_t SDL_wcsnlen(const wchar_t *string, size_t maxlen) | |
| { | |
| #ifdef HAVE_WCSNLEN | |
| return wcsnlen(string, maxlen); | |
| #else | |
| size_t len = 0; | |
| while (len < maxlen && *string++) { | |
| ++len; | |
| } | |
| return len; | |
| #endif // HAVE_WCSNLEN | |
| } | |
| size_t SDL_wcslcpy(SDL_OUT_Z_CAP(maxlen) wchar_t *dst, const wchar_t *src, size_t maxlen) | |
| { | |
| #ifdef 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 | |
| } | |
| size_t SDL_wcslcat(SDL_INOUT_Z_CAP(maxlen) wchar_t *dst, const wchar_t *src, size_t maxlen) | |
| { | |
| #ifdef 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 | |
| } | |
| wchar_t *SDL_wcsdup(const wchar_t *string) | |
| { | |
| 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; | |
| } | |
| wchar_t *SDL_wcsnstr(const wchar_t *haystack, const wchar_t *needle, size_t maxlen) | |
| { | |
| size_t length = SDL_wcslen(needle); | |
| if (length == 0) { | |
| return (wchar_t *)haystack; | |
| } | |
| while (maxlen >= length && *haystack) { | |
| if (maxlen >= length && SDL_wcsncmp(haystack, needle, length) == 0) { | |
| return (wchar_t *)haystack; | |
| } | |
| ++haystack; | |
| --maxlen; | |
| } | |
| return NULL; | |
| } | |
| wchar_t *SDL_wcsstr(const wchar_t *haystack, const wchar_t *needle) | |
| { | |
| #ifdef HAVE_WCSSTR | |
| return SDL_const_cast(wchar_t *, wcsstr(haystack, needle)); | |
| #else | |
| return SDL_wcsnstr(haystack, needle, SDL_wcslen(haystack)); | |
| #endif // HAVE_WCSSTR | |
| } | |
| int SDL_wcscmp(const wchar_t *str1, const wchar_t *str2) | |
| { | |
| #ifdef HAVE_WCSCMP | |
| return wcscmp(str1, str2); | |
| #else | |
| while (*str1 && *str2) { | |
| if (*str1 != *str2) { | |
| break; | |
| } | |
| ++str1; | |
| ++str2; | |
| } | |
| return *str1 - *str2; | |
| #endif // HAVE_WCSCMP | |
| } | |
| int SDL_wcsncmp(const wchar_t *str1, const wchar_t *str2, size_t maxlen) | |
| { | |
| #ifdef HAVE_WCSNCMP | |
| return wcsncmp(str1, str2, maxlen); | |
| #else | |
| while (*str1 && *str2 && maxlen) { | |
| if (*str1 != *str2) { | |
| break; | |
| } | |
| ++str1; | |
| ++str2; | |
| --maxlen; | |
| } | |
| if (!maxlen) { | |
| return 0; | |
| } | |
| return *str1 - *str2; | |
| #endif // HAVE_WCSNCMP | |
| } | |
| int SDL_wcscasecmp(const wchar_t *wstr1, const wchar_t *wstr2) | |
| { | |
| #if (SDL_SIZEOF_WCHAR_T == 2) | |
| const Uint16 *str1 = (const Uint16 *) wstr1; | |
| const Uint16 *str2 = (const Uint16 *) wstr2; | |
| UNICODE_STRCASECMP(16, 2, 2, (void) str1start, (void) str2start); // always NULL-terminated, no need to adjust lengths. | |
| #elif (SDL_SIZEOF_WCHAR_T == 4) | |
| const Uint32 *str1 = (const Uint32 *) wstr1; | |
| const Uint32 *str2 = (const Uint32 *) wstr2; | |
| UNICODE_STRCASECMP(32, 1, 1, (void) str1start, (void) str2start); // always NULL-terminated, no need to adjust lengths. | |
| #else | |
| #error Unexpected wchar_t size | |
| return -1; | |
| #endif | |
| } | |
| int SDL_wcsncasecmp(const wchar_t *wstr1, const wchar_t *wstr2, size_t maxlen) | |
| { | |
| size_t slen1 = maxlen; | |
| size_t slen2 = maxlen; | |
| #if (SDL_SIZEOF_WCHAR_T == 2) | |
| const Uint16 *str1 = (const Uint16 *) wstr1; | |
| const Uint16 *str2 = (const Uint16 *) wstr2; | |
| UNICODE_STRCASECMP(16, slen1, slen2, slen1 -= (size_t) (str1 - str1start), slen2 -= (size_t) (str2 - str2start)); | |
| #elif (SDL_SIZEOF_WCHAR_T == 4) | |
| const Uint32 *str1 = (const Uint32 *) wstr1; | |
| const Uint32 *str2 = (const Uint32 *) wstr2; | |
| UNICODE_STRCASECMP(32, slen1, slen2, slen1 -= (size_t) (str1 - str1start), slen2 -= (size_t) (str2 - str2start)); | |
| #else | |
| #error Unexpected wchar_t size | |
| return -1; | |
| #endif | |
| } | |
| long SDL_wcstol(const wchar_t *string, wchar_t **endp, int base) | |
| { | |
| #ifdef HAVE_WCSTOL | |
| return wcstol(string, endp, base); | |
| #else | |
| long value = 0; | |
| size_t len = SDL_ScanLongW(string, 0, base, &value); | |
| if (endp) { | |
| *endp = (wchar_t *)string + len; | |
| } | |
| return value; | |
| #endif // HAVE_WCSTOL | |
| } | |
| unsigned long SDL_wcstoul(const wchar_t *string, wchar_t **endp, int base) | |
| { | |
| #ifdef HAVE_WCSTOUL | |
| return wcstoul(string, endp, base); | |
| #else | |
| unsigned long value = 0; | |
| size_t len = SDL_ScanUnsignedLongW(string, 0, base, &value); | |
| if (endp) { | |
| *endp = (wchar_t *)string + len; | |
| } | |
| return value; | |
| #endif // HAVE_WCSTOUL | |
| } | |
| long long SDL_wcstoll(const wchar_t *string, wchar_t **endp, int base) | |
| { | |
| #ifdef HAVE_WCSTOLL | |
| return wcstoll(string, endp, base); | |
| #else | |
| long long value = 0; | |
| size_t len = SDL_ScanLongLongW(string, 0, base, &value); | |
| if (endp) { | |
| *endp = (wchar_t *)string + len; | |
| } | |
| return value; | |
| #endif // HAVE_WCSTOLL | |
| } | |
| unsigned long long SDL_wcstoull(const wchar_t *string, wchar_t **endp, int base) | |
| { | |
| #ifdef HAVE_WCSTOULL | |
| return wcstoull(string, endp, base); | |
| #else | |
| unsigned long long value = 0; | |
| size_t len = SDL_ScanUnsignedLongLongW(string, 0, base, &value); | |
| if (endp) { | |
| *endp = (wchar_t *)string + len; | |
| } | |
| return value; | |
| #endif // HAVE_WCSTOULL | |
| } | |
| size_t SDL_strlcpy(SDL_OUT_Z_CAP(maxlen) char *dst, const char *src, size_t maxlen) | |
| { | |
| #ifdef 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 | |
| } | |
| size_t SDL_utf8strlcpy(SDL_OUT_Z_CAP(dst_bytes) char *dst, const char *src, size_t dst_bytes) | |
| { | |
| size_t bytes = 0; | |
| if (dst_bytes > 0) { | |
| size_t src_bytes = SDL_strlen(src); | |
| size_t i = 0; | |
| size_t trailing_bytes = 0; | |
| bytes = SDL_min(src_bytes, dst_bytes - 1); | |
| 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_GetTrailingBytes(c); | |
| if (trailing_bytes) { | |
| if ((bytes - i) != (trailing_bytes + 1)) { | |
| bytes = i; | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| SDL_memcpy(dst, src, bytes); | |
| } | |
| dst[bytes] = '\0'; | |
| } | |
| return bytes; | |
| } | |
| size_t SDL_utf8strlen(const char *str) | |
| { | |
| size_t result = 0; | |
| while (SDL_StepUTF8(&str, NULL)) { | |
| result++; | |
| } | |
| return result; | |
| } | |
| size_t SDL_utf8strnlen(const char *str, size_t bytes) | |
| { | |
| size_t result = 0; | |
| while (SDL_StepUTF8(&str, &bytes)) { | |
| result++; | |
| } | |
| return result; | |
| } | |
| size_t SDL_strlcat(SDL_INOUT_Z_CAP(maxlen) char *dst, const char *src, size_t maxlen) | |
| { | |
| #ifdef 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 | |
| } | |
| char *SDL_strdup(const char *string) | |
| { | |
| size_t len = SDL_strlen(string) + 1; | |
| char *newstr = (char *)SDL_malloc(len); | |
| if (newstr) { | |
| SDL_memcpy(newstr, string, len); | |
| } | |
| return newstr; | |
| } | |
| char *SDL_strndup(const char *string, size_t maxlen) | |
| { | |
| size_t len = SDL_strnlen(string, maxlen); | |
| char *newstr = (char *)SDL_malloc(len + 1); | |
| if (newstr) { | |
| SDL_memcpy(newstr, string, len); | |
| newstr[len] = '\0'; | |
| } | |
| return newstr; | |
| } | |
| char *SDL_strrev(char *string) | |
| { | |
| #ifdef 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--) { | |
| const char c = *a; // NOLINT(clang-analyzer-core.uninitialized.Assign) | |
| *a++ = *b; | |
| *b-- = c; | |
| } | |
| return string; | |
| #endif // HAVE__STRREV | |
| } | |
| char *SDL_strupr(char *string) | |
| { | |
| char *bufp = string; | |
| while (*bufp) { | |
| *bufp = (char)SDL_toupper((unsigned char)*bufp); | |
| ++bufp; | |
| } | |
| return string; | |
| } | |
| char *SDL_strlwr(char *string) | |
| { | |
| char *bufp = string; | |
| while (*bufp) { | |
| *bufp = (char)SDL_tolower((unsigned char)*bufp); | |
| ++bufp; | |
| } | |
| return string; | |
| } | |
| char *SDL_strchr(const char *string, int 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; | |
| } | |
| if (c == '\0') { | |
| return (char *)string; | |
| } | |
| return NULL; | |
| #endif // HAVE_STRCHR | |
| } | |
| char *SDL_strrchr(const char *string, int 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); | |
| while (bufp >= string) { | |
| if (*bufp == c) { | |
| return (char *)bufp; | |
| } | |
| --bufp; | |
| } | |
| return NULL; | |
| #endif // HAVE_STRRCHR | |
| } | |
| char *SDL_strnstr(const char *haystack, const char *needle, size_t maxlen) | |
| { | |
| #ifdef HAVE_STRNSTR | |
| return SDL_const_cast(char *, strnstr(haystack, needle, maxlen)); | |
| #else | |
| size_t length = SDL_strlen(needle); | |
| if (length == 0) { | |
| return (char *)haystack; | |
| } | |
| while (maxlen >= length && *haystack) { | |
| if (SDL_strncmp(haystack, needle, length) == 0) { | |
| return (char *)haystack; | |
| } | |
| ++haystack; | |
| --maxlen; | |
| } | |
| return NULL; | |
| #endif // HAVE_STRNSTR | |
| } | |
| char *SDL_strstr(const char *haystack, const char *needle) | |
| { | |
| #ifdef HAVE_STRSTR | |
| return SDL_const_cast(char *, strstr(haystack, needle)); | |
| #else | |
| return SDL_strnstr(haystack, needle, SDL_strlen(haystack)); | |
| #endif // HAVE_STRSTR | |
| } | |
| char *SDL_strcasestr(const char *haystack, const char *needle) | |
| { | |
| const size_t length = SDL_strlen(needle); | |
| do { | |
| if (SDL_strncasecmp(haystack, needle, length) == 0) { | |
| return (char *)haystack; | |
| } | |
| } while (SDL_StepUTF8(&haystack, NULL)); // move ahead by a full codepoint at a time, regardless of bytes. | |
| return NULL; | |
| } | |
| #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 | |
| char *SDL_uitoa(unsigned int value, char *string, int radix) | |
| { | |
| return SDL_ultoa((unsigned long)value, string, radix); | |
| } | |
| #ifdef _MSC_VER | |
| #pragma warning(push) | |
| #pragma warning(disable:4996) // Ignore warning about deprecated itoa, _ltoa, _ultoa, _i64toa, _ui64toa | |
| #endif | |
| char *SDL_itoa(int value, char *string, int radix) | |
| { | |
| #ifdef HAVE_ITOA | |
| return itoa(value, string, radix); | |
| #else | |
| return SDL_ltoa((long)value, string, radix); | |
| #endif // HAVE_ITOA | |
| } | |
| char *SDL_ltoa(long value, char *string, int radix) | |
| { | |
| #ifdef 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 | |
| } | |
| char *SDL_ultoa(unsigned long value, char *string, int radix) | |
| { | |
| #ifdef 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 | |
| } | |
| char *SDL_lltoa(long long value, char *string, int radix) | |
| { | |
| #ifdef 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 | |
| } | |
| char *SDL_ulltoa(unsigned long long value, char *string, int radix) | |
| { | |
| #ifdef 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 | |
| } | |
| #ifdef _MSC_VER | |
| #pragma warning(pop) | |
| #endif | |
| int SDL_atoi(const char *string) | |
| { | |
| #ifdef HAVE_ATOI | |
| return atoi(string); | |
| #else | |
| return SDL_strtol(string, NULL, 10); | |
| #endif // HAVE_ATOI | |
| } | |
| double SDL_atof(const char *string) | |
| { | |
| #ifdef HAVE_ATOF | |
| return atof(string); | |
| #else | |
| return SDL_strtod(string, NULL); | |
| #endif // HAVE_ATOF | |
| } | |
| long SDL_strtol(const char *string, char **endp, int base) | |
| { | |
| #ifdef HAVE_STRTOL | |
| return strtol(string, endp, base); | |
| #else | |
| long value = 0; | |
| size_t len = SDL_ScanLong(string, 0, base, &value); | |
| if (endp) { | |
| *endp = (char *)string + len; | |
| } | |
| return value; | |
| #endif // HAVE_STRTOL | |
| } | |
| unsigned long SDL_strtoul(const char *string, char **endp, int base) | |
| { | |
| #ifdef HAVE_STRTOUL | |
| return strtoul(string, endp, base); | |
| #else | |
| unsigned long value = 0; | |
| size_t len = SDL_ScanUnsignedLong(string, 0, base, &value); | |
| if (endp) { | |
| *endp = (char *)string + len; | |
| } | |
| return value; | |
| #endif // HAVE_STRTOUL | |
| } | |
| long long SDL_strtoll(const char *string, char **endp, int base) | |
| { | |
| #ifdef HAVE_STRTOLL | |
| return strtoll(string, endp, base); | |
| #else | |
| long long value = 0; | |
| size_t len = SDL_ScanLongLong(string, 0, base, &value); | |
| if (endp) { | |
| *endp = (char *)string + len; | |
| } | |
| return value; | |
| #endif // HAVE_STRTOLL | |
| } | |
| unsigned long long SDL_strtoull(const char *string, char **endp, int base) | |
| { | |
| #ifdef HAVE_STRTOULL | |
| return strtoull(string, endp, base); | |
| #else | |
| unsigned long long value = 0; | |
| size_t len = SDL_ScanUnsignedLongLong(string, 0, base, &value); | |
| if (endp) { | |
| *endp = (char *)string + len; | |
| } | |
| return value; | |
| #endif // HAVE_STRTOULL | |
| } | |
| double SDL_strtod(const char *string, char **endp) | |
| { | |
| #ifdef HAVE_STRTOD | |
| return strtod(string, endp); | |
| #else | |
| double value; | |
| size_t len = SDL_ScanFloat(string, &value); | |
| if (endp) { | |
| *endp = (char *)string + len; | |
| } | |
| return value; | |
| #endif // HAVE_STRTOD | |
| } | |
| int SDL_strcmp(const char *str1, const char *str2) | |
| { | |
| #ifdef HAVE_STRCMP | |
| return strcmp(str1, str2); | |
| #else | |
| int result; | |
| while (1) { | |
| result = ((unsigned char)*str1 - (unsigned char)*str2); | |
| if (result != 0 || (*str1 == '\0' /* && *str2 == '\0'*/)) { | |
| break; | |
| } | |
| ++str1; | |
| ++str2; | |
| } | |
| return result; | |
| #endif // HAVE_STRCMP | |
| } | |
| int SDL_strncmp(const char *str1, const char *str2, size_t maxlen) | |
| { | |
| #ifdef HAVE_STRNCMP | |
| return strncmp(str1, str2, maxlen); | |
| #else | |
| int result = 0; | |
| while (maxlen) { | |
| result = (int)(unsigned char)*str1 - (unsigned char)*str2; | |
| if (result != 0 || *str1 == '\0' /* && *str2 == '\0'*/) { | |
| break; | |
| } | |
| ++str1; | |
| ++str2; | |
| --maxlen; | |
| } | |
| return result; | |
| #endif // HAVE_STRNCMP | |
| } | |
| int SDL_strcasecmp(const char *str1, const char *str2) | |
| { | |
| UNICODE_STRCASECMP(8, 4, 4, (void) str1start, (void) str2start); // always NULL-terminated, no need to adjust lengths. | |
| } | |
| int SDL_strncasecmp(const char *str1, const char *str2, size_t maxlen) | |
| { | |
| size_t slen1 = maxlen; | |
| size_t slen2 = maxlen; | |
| UNICODE_STRCASECMP(8, slen1, slen2, slen1 -= (size_t) (str1 - ((const char *) str1start)), slen2 -= (size_t) (str2 - ((const char *) str2start))); | |
| } | |
| int SDL_sscanf(const char *text, SDL_SCANF_FORMAT_STRING const char *fmt, ...) | |
| { | |
| int rc; | |
| va_list ap; | |
| va_start(ap, fmt); | |
| rc = SDL_vsscanf(text, fmt, ap); | |
| va_end(ap); | |
| return rc; | |
| } | |
| #ifdef HAVE_VSSCANF | |
| int SDL_vsscanf(const char *text, const char *fmt, va_list ap) | |
| { | |
| return vsscanf(text, fmt, ap); | |
| } | |
| #else | |
| static bool CharacterMatchesSet(char c, const char *set, size_t set_len) | |
| { | |
| bool invert = false; | |
| bool result = false; | |
| if (*set == '^') { | |
| invert = true; | |
| ++set; | |
| --set_len; | |
| } | |
| while (set_len > 0 && !result) { | |
| if (set_len >= 3 && set[1] == '-') { | |
| char low_char = SDL_min(set[0], set[2]); | |
| char high_char = SDL_max(set[0], set[2]); | |
| if (c >= low_char && c <= high_char) { | |
| result = true; | |
| } | |
| set += 3; | |
| set_len -= 3; | |
| } else { | |
| if (c == *set) { | |
| result = true; | |
| } | |
| ++set; | |
| --set_len; | |
| } | |
| } | |
| if (invert) { | |
| result = !result; | |
| } | |
| return result; | |
| } | |
| // NOLINTNEXTLINE(readability-non-const-parameter) | |
| int SDL_vsscanf(const char *text, SDL_SCANF_FORMAT_STRING const char *fmt, va_list ap) | |
| { | |
| const char *start = text; | |
| int result = 0; | |
| if (!text || !*text) { | |
| return -1; | |
| } | |
| while (*fmt) { | |
| if (*fmt == ' ') { | |
| while (SDL_isspace((unsigned char)*text)) { | |
| ++text; | |
| } | |
| ++fmt; | |
| continue; | |
| } | |
| if (*fmt == '%') { | |
| bool done = false; | |
| long count = 0; | |
| int radix = 10; | |
| enum | |
| { | |
| DO_SHORT, | |
| DO_INT, | |
| DO_LONG, | |
| DO_LONGLONG, | |
| DO_SIZE_T | |
| } inttype = DO_INT; | |
| size_t advance; | |
| bool suppress = false; | |
| ++fmt; | |
| if (*fmt == '%') { | |
| if (*text == '%') { | |
| ++text; | |
| ++fmt; | |
| continue; | |
| } | |
| break; | |
| } | |
| if (*fmt == '*') { | |
| suppress = true; | |
| ++fmt; | |
| } | |
| fmt += SDL_ScanLong(fmt, 0, 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++; | |
| } | |
| ++result; | |
| } | |
| continue; | |
| } | |
| while (SDL_isspace((unsigned char)*text)) { | |
| ++text; | |
| } | |
| // FIXME: implement more of the format specifiers | |
| while (!done) { | |
| switch (*fmt) { | |
| case '*': | |
| suppress = true; | |
| break; | |
| case 'h': | |
| if (inttype == DO_INT) { | |
| inttype = DO_SHORT; | |
| } else 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 'z': | |
| inttype = DO_SIZE_T; | |
| 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; | |
| } | |
| } | |
| } | |
| SDL_FALLTHROUGH; | |
| case 'd': | |
| if (inttype == DO_LONGLONG) { | |
| long long value = 0; | |
| advance = SDL_ScanLongLong(text, count, radix, &value); | |
| text += advance; | |
| if (advance && !suppress) { | |
| Sint64 *valuep = va_arg(ap, Sint64 *); | |
| *valuep = value; | |
| ++result; | |
| } | |
| } else if (inttype == DO_SIZE_T) { | |
| long long value = 0; | |
| advance = SDL_ScanLongLong(text, count, radix, &value); | |
| text += advance; | |
| if (advance && !suppress) { | |
| size_t *valuep = va_arg(ap, size_t *); | |
| *valuep = (size_t)value; | |
| ++result; | |
| } | |
| } else { | |
| long value = 0; | |
| advance = SDL_ScanLong(text, count, 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: | |
| case DO_SIZE_T: | |
| // Handled above | |
| break; | |
| } | |
| ++result; | |
| } | |
| } | |
| done = true; | |
| break; | |
| case 'o': | |
| if (radix == 10) { | |
| radix = 8; | |
| } | |
| SDL_FALLTHROUGH; | |
| case 'x': | |
| case 'X': | |
| if (radix == 10) { | |
| radix = 16; | |
| } | |
| SDL_FALLTHROUGH; | |
| case 'u': | |
| if (inttype == DO_LONGLONG) { | |
| unsigned long long value = 0; | |
| advance = SDL_ScanUnsignedLongLong(text, count, radix, &value); | |
| text += advance; | |
| if (advance && !suppress) { | |
| Uint64 *valuep = va_arg(ap, Uint64 *); | |
| *valuep = value; | |
| ++result; | |
| } | |
| } else if (inttype == DO_SIZE_T) { | |
| unsigned long long value = 0; | |
| advance = SDL_ScanUnsignedLongLong(text, count, radix, &value); | |
| text += advance; | |
| if (advance && !suppress) { | |
| size_t *valuep = va_arg(ap, size_t *); | |
| *valuep = (size_t)value; | |
| ++result; | |
| } | |
| } else { | |
| unsigned long value = 0; | |
| advance = SDL_ScanUnsignedLong(text, count, 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: | |
| case DO_SIZE_T: | |
| // Handled above | |
| break; | |
| } | |
| ++result; | |
| } | |
| } | |
| done = true; | |
| break; | |
| case 'p': | |
| { | |
| uintptr_t value = 0; | |
| advance = SDL_ScanUintPtrT(text, &value); | |
| text += advance; | |
| if (advance && !suppress) { | |
| void **valuep = va_arg(ap, void **); | |
| *valuep = (void *)value; | |
| ++result; | |
| } | |
| } | |
| done = true; | |
| break; | |
| case 'f': | |
| { | |
| double value = 0.0; | |
| advance = SDL_ScanFloat(text, &value); | |
| text += advance; | |
| if (advance && !suppress) { | |
| float *valuep = va_arg(ap, float *); | |
| *valuep = (float)value; | |
| ++result; | |
| } | |
| } | |
| done = 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'; | |
| ++result; | |
| } | |
| done = true; | |
| break; | |
| case 'n': | |
| switch (inttype) { | |
| case DO_SHORT: | |
| { | |
| short *valuep = va_arg(ap, short *); | |
| *valuep = (short)(text - start); | |
| } break; | |
| case DO_INT: | |
| { | |
| int *valuep = va_arg(ap, int *); | |
| *valuep = (int)(text - start); | |
| } break; | |
| case DO_LONG: | |
| { | |
| long *valuep = va_arg(ap, long *); | |
| *valuep = (long)(text - start); | |
| } break; | |
| case DO_LONGLONG: | |
| { | |
| long long *valuep = va_arg(ap, long long *); | |
| *valuep = (long long)(text - start); | |
| } break; | |
| case DO_SIZE_T: | |
| { | |
| size_t *valuep = va_arg(ap, size_t *); | |
| *valuep = (size_t)(text - start); | |
| } break; | |
| } | |
| done = true; | |
| break; | |
| case '[': | |
| { | |
| const char *set = fmt + 1; | |
| while (*fmt && *fmt != ']') { | |
| ++fmt; | |
| } | |
| if (*fmt) { | |
| size_t set_len = (fmt - set); | |
| if (suppress) { | |
| while (CharacterMatchesSet(*text, set, set_len)) { | |
| ++text; | |
| if (count) { | |
| if (--count == 0) { | |
| break; | |
| } | |
| } | |
| } | |
| } else { | |
| bool had_match = false; | |
| char *valuep = va_arg(ap, char *); | |
| while (CharacterMatchesSet(*text, set, set_len)) { | |
| had_match = true; | |
| *valuep++ = *text++; | |
| if (count) { | |
| if (--count == 0) { | |
| break; | |
| } | |
| } | |
| } | |
| *valuep = '\0'; | |
| if (had_match) { | |
| ++result; | |
| } | |
| } | |
| } | |
| } | |
| done = true; | |
| break; | |
| default: | |
| done = true; | |
| break; | |
| } | |
| ++fmt; | |
| } | |
| continue; | |
| } | |
| if (*text == *fmt) { | |
| ++text; | |
| ++fmt; | |
| continue; | |
| } | |
| // Text didn't match format specifier | |
| break; | |
| } | |
| return result; | |
| } | |
| #endif // HAVE_VSSCANF | |
| int SDL_snprintf(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) | |
| { | |
| va_list ap; | |
| int result; | |
| va_start(ap, fmt); | |
| result = SDL_vsnprintf(text, maxlen, fmt, ap); | |
| va_end(ap); | |
| return result; | |
| } | |
| int SDL_swprintf(SDL_OUT_Z_CAP(maxlen) wchar_t *text, size_t maxlen, SDL_PRINTF_FORMAT_STRING const wchar_t *fmt, ...) | |
| { | |
| va_list ap; | |
| int result; | |
| va_start(ap, fmt); | |
| result = SDL_vswprintf(text, maxlen, fmt, ap); | |
| va_end(ap); | |
| return result; | |
| } | |
| #if defined(HAVE_VSNPRINTF) | |
| int SDL_vsnprintf(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, const char *fmt, va_list ap) | |
| { | |
| if (!fmt) { | |
| fmt = ""; | |
| } | |
| return vsnprintf(text, maxlen, fmt, ap); | |
| } | |
| #else | |
| #define TEXT_AND_LEN_ARGS (length < maxlen) ? &text[length] : NULL, (length < maxlen) ? (maxlen - length) : 0 | |
| // FIXME: implement more of the format specifiers | |
| typedef enum | |
| { | |
| SDL_CASE_NOCHANGE, | |
| SDL_CASE_LOWER, | |
| SDL_CASE_UPPER | |
| } SDL_letter_case; | |
| typedef struct | |
| { | |
| bool left_justify; | |
| bool force_sign; | |
| bool force_type; // for now: used only by float printer, ignored otherwise. | |
| bool pad_zeroes; | |
| SDL_letter_case force_case; | |
| int width; | |
| int radix; | |
| int precision; | |
| } SDL_FormatInfo; | |
| static size_t SDL_PrintString(char *text, size_t maxlen, SDL_FormatInfo *info, const char *string) | |
| { | |
| const char fill = (info && info->pad_zeroes) ? '0' : ' '; | |
| size_t width = 0; | |
| size_t filllen = 0; | |
| size_t length = 0; | |
| size_t slen, sz; | |
| if (!string) { | |
| string = "(null)"; | |
| } | |
| sz = SDL_strlen(string); | |
| if (info && info->width > 0 && (size_t)info->width > sz) { | |
| width = info->width - sz; | |
| if (info->precision >= 0 && (size_t)info->precision < sz) { | |
| width += sz - (size_t)info->precision; | |
| } | |
| filllen = SDL_min(width, maxlen); | |
| if (!info->left_justify) { | |
| SDL_memset(text, fill, filllen); | |
| text += filllen; | |
| maxlen -= filllen; | |
| length += width; | |
| filllen = 0; | |
| } | |
| } | |
| SDL_strlcpy(text, string, maxlen); | |
| length += sz; | |
| if (filllen > 0) { | |
| SDL_memset(text + sz, fill, filllen); | |
| length += width; | |
| } | |
| 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 (maxlen > 1) { | |
| if (info->force_case == SDL_CASE_LOWER) { | |
| SDL_strlwr(text); | |
| } else if (info->force_case == SDL_CASE_UPPER) { | |
| SDL_strupr(text); | |
| } | |
| } | |
| } | |
| return length; | |
| } | |
| static size_t SDL_PrintStringW(char *text, size_t maxlen, SDL_FormatInfo *info, const wchar_t *wide_string) | |
| { | |
| size_t length = 0; | |
| if (wide_string) { | |
| char *string = SDL_iconv_string("UTF-8", "WCHAR_T", (char *)(wide_string), (SDL_wcslen(wide_string) + 1) * sizeof(*wide_string)); | |
| length = SDL_PrintString(TEXT_AND_LEN_ARGS, info, string); | |
| SDL_free(string); | |
| } else { | |
| length = SDL_PrintString(TEXT_AND_LEN_ARGS, info, NULL); | |
| } | |
| return length; | |
| } | |
| static void SDL_IntPrecisionAdjust(char *num, size_t maxlen, SDL_FormatInfo *info) | |
| { // 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. | |
| } | |
| } | |
| static size_t SDL_PrintLong(char *text, size_t maxlen, SDL_FormatInfo *info, long value) | |
| { | |
| char num[130], *p = num; | |
| if (info->force_sign && value >= 0L) { | |
| *p++ = '+'; | |
| } | |
| SDL_ltoa(value, p, info ? info->radix : 10); | |
| SDL_IntPrecisionAdjust(num, sizeof(num), info); | |
| return SDL_PrintString(text, maxlen, info, num); | |
| } | |
| static size_t SDL_PrintUnsignedLong(char *text, size_t maxlen, SDL_FormatInfo *info, unsigned long value) | |
| { | |
| char num[130]; | |
| SDL_ultoa(value, num, info ? info->radix : 10); | |
| SDL_IntPrecisionAdjust(num, sizeof(num), info); | |
| return SDL_PrintString(text, maxlen, info, num); | |
| } | |
| static size_t SDL_PrintLongLong(char *text, size_t maxlen, SDL_FormatInfo *info, long long value) | |
| { | |
| char num[130], *p = num; | |
| if (info->force_sign && value >= (Sint64)0) { | |
| *p++ = '+'; | |
| } | |
| SDL_lltoa(value, p, info ? info->radix : 10); | |
| SDL_IntPrecisionAdjust(num, sizeof(num), info); | |
| return SDL_PrintString(text, maxlen, info, num); | |
| } | |
| static size_t SDL_PrintUnsignedLongLong(char *text, size_t maxlen, SDL_FormatInfo *info, unsigned long long value) | |
| { | |
| char num[130]; | |
| SDL_ulltoa(value, num, info ? info->radix : 10); | |
| SDL_IntPrecisionAdjust(num, sizeof(num), info); | |
| return SDL_PrintString(text, maxlen, info, num); | |
| } | |
| static size_t SDL_PrintFloat(char *text, size_t maxlen, SDL_FormatInfo *info, double arg, bool g) | |
| { | |
| char num[327]; | |
| size_t length = 0; | |
| size_t integer_length; | |
| int precision = info->precision; | |
| // This isn't especially accurate, but hey, it's easy. :) | |
| unsigned long long value; | |
| if (arg < 0.0 || (arg == 0.0 && 1.0 / arg < 0.0)) { // additional check for signed zero | |
| num[length++] = '-'; | |
| arg = -arg; | |
| } else if (info->force_sign) { | |
| num[length++] = '+'; | |
| } | |
| value = (unsigned long long)arg; | |
| integer_length = SDL_PrintUnsignedLongLong(&num[length], sizeof(num) - length, NULL, value); | |
| length += integer_length; | |
| arg -= value; | |
| if (precision < 0) { | |
| precision = 6; | |
| } | |
| if (g) { | |
| // The precision includes the integer portion | |
| precision -= SDL_min((int)integer_length, precision); | |
| } | |
| if (info->force_type || precision > 0) { | |
| const char decimal_separator = '.'; | |
| double integer_value; | |
| SDL_assert(length < sizeof(num)); | |
| num[length++] = decimal_separator; | |
| while (precision > 1) { | |
| arg *= 10.0; | |
| arg = SDL_modf(arg, &integer_value); | |
| SDL_assert(length < sizeof(num)); | |
| num[length++] = '0' + (char)integer_value; | |
| --precision; | |
| } | |
| if (precision == 1) { | |
| arg *= 10.0; | |
| integer_value = SDL_round(arg); | |
| if (integer_value == 10.0) { | |
| // Carry the one... | |
| size_t i; | |
| for (i = length; i--; ) { | |
| if (num[i] == decimal_separator) { | |
| continue; | |
| } | |
| if (num[i] == '9') { | |
| num[i] = '0'; | |
| if (i == 0 || num[i - 1] == '-' || num[i - 1] == '+') { | |
| SDL_memmove(&num[i+1], &num[i], length - i); | |
| num[i] = '1'; | |
| ++length; | |
| break; | |
| } | |
| } else { | |
| ++num[i]; | |
| break; | |
| } | |
| } | |
| SDL_assert(length < sizeof(num)); | |
| num[length++] = '0'; | |
| } else { | |
| SDL_assert(length < sizeof(num)); | |
| num[length++] = '0' + (char)integer_value; | |
| } | |
| } | |
| if (g) { | |
| // Trim trailing zeroes and decimal separator | |
| size_t i; | |
| for (i = length - 1; num[i] != decimal_separator; --i) { | |
| if (num[i] == '0') { | |
| --length; | |
| } else { | |
| break; | |
| } | |
| } | |
| if (num[i] == decimal_separator) { | |
| --length; | |
| } | |
| } | |
| } | |
| num[length] = '\0'; | |
| info->precision = -1; | |
| length = SDL_PrintString(text, maxlen, info, num); | |
| if (info->width > 0 && (size_t)info->width > length) { | |
| const char fill = info->pad_zeroes ? '0' : ' '; | |
| size_t width = info->width - length; | |
| size_t filllen, movelen; | |
| filllen = SDL_min(width, maxlen); | |
| movelen = SDL_min(length, (maxlen - filllen)); | |
| SDL_memmove(&text[filllen], text, movelen); | |
| SDL_memset(text, fill, filllen); | |
| length += width; | |
| } | |
| return length; | |
| } | |
| static size_t SDL_PrintPointer(char *text, size_t maxlen, SDL_FormatInfo *info, const void *value) | |
| { | |
| char num[130]; | |
| size_t length; | |
| if (!value) { | |
| return SDL_PrintString(text, maxlen, info, NULL); | |
| } | |
| SDL_ulltoa((unsigned long long)(uintptr_t)value, num, 16); | |
| length = SDL_PrintString(text, maxlen, info, "0x"); | |
| return length + SDL_PrintString(TEXT_AND_LEN_ARGS, info, num); | |
| } | |
| // NOLINTNEXTLINE(readability-non-const-parameter) | |
| int SDL_vsnprintf(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, SDL_PRINTF_FORMAT_STRING const char *fmt, va_list ap) | |
| { | |
| size_t length = 0; | |
| if (!text) { | |
| maxlen = 0; | |
| } | |
| if (!fmt) { | |
| fmt = ""; | |
| } | |
| while (*fmt) { | |
| if (*fmt == '%') { | |
| bool done = false; | |
| bool check_flag; | |
| SDL_FormatInfo info; | |
| enum | |
| { | |
| DO_INT, | |
| DO_LONG, | |
| DO_LONGLONG, | |
| DO_SIZE_T | |
| } inttype = DO_INT; | |
| SDL_zero(info); | |
| info.radix = 10; | |
| info.precision = -1; | |
| check_flag = true; | |
| while (check_flag) { | |
| ++fmt; | |
| switch (*fmt) { | |
| case '-': | |
| info.left_justify = true; | |
| break; | |
| case '+': | |
| info.force_sign = true; | |
| break; | |
| case '#': | |
| info.force_type = true; | |
| break; | |
| case '0': | |
| info.pad_zeroes = true; | |
| break; | |
| default: | |
| check_flag = 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 (length < maxlen) { | |
| text[length] = '%'; | |
| } | |
| ++length; | |
| done = true; | |
| break; | |
| case 'c': | |
| // char is promoted to int when passed through (...) | |
| if (length < maxlen) { | |
| text[length] = (char)va_arg(ap, int); | |
| } | |
| ++length; | |
| done = 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 'z': | |
| inttype = DO_SIZE_T; | |
| break; | |
| case 'i': | |
| case 'd': | |
| if (info.precision >= 0) { | |
| info.pad_zeroes = false; | |
| } | |
| switch (inttype) { | |
| case DO_INT: | |
| length += SDL_PrintLong(TEXT_AND_LEN_ARGS, &info, | |
| (long)va_arg(ap, int)); | |
| break; | |
| case DO_LONG: | |
| length += SDL_PrintLong(TEXT_AND_LEN_ARGS, &info, | |
| va_arg(ap, long)); | |
| break; | |
| case DO_LONGLONG: | |
| length += SDL_PrintLongLong(TEXT_AND_LEN_ARGS, &info, | |
| va_arg(ap, long long)); | |
| break; | |
| case DO_SIZE_T: | |
| length += SDL_PrintLongLong(TEXT_AND_LEN_ARGS, &info, | |
| va_arg(ap, size_t)); | |
| break; | |
| } | |
| done = true; | |
| break; | |
| case 'p': | |
| info.force_case = SDL_CASE_LOWER; | |
| length += SDL_PrintPointer(TEXT_AND_LEN_ARGS, &info, va_arg(ap, void *)); | |
| done = true; | |
| break; | |
| case 'x': | |
| info.force_case = SDL_CASE_LOWER; | |
| SDL_FALLTHROUGH; | |
| case 'X': | |
| if (info.force_case == SDL_CASE_NOCHANGE) { | |
| info.force_case = SDL_CASE_UPPER; | |
| } | |
| if (info.radix == 10) { | |
| info.radix = 16; | |
| } | |
| SDL_FALLTHROUGH; | |
| case 'o': | |
| if (info.radix == 10) { | |
| info.radix = 8; | |
| } | |
| SDL_FALLTHROUGH; | |
| case 'u': | |
| info.force_sign = false; | |
| if (info.precision >= 0) { | |
| info.pad_zeroes = false; | |
| } | |
| switch (inttype) { | |
| case DO_INT: | |
| length += SDL_PrintUnsignedLong(TEXT_AND_LEN_ARGS, &info, | |
| va_arg(ap, unsigned int)); | |
| break; | |
| case DO_LONG: | |
| length += SDL_PrintUnsignedLong(TEXT_AND_LEN_ARGS, &info, | |
| va_arg(ap, unsigned long)); | |
| break; | |
| case DO_LONGLONG: | |
| length += SDL_PrintUnsignedLongLong(TEXT_AND_LEN_ARGS, &info, | |
| va_arg(ap, unsigned long long)); | |
| break; | |
| case DO_SIZE_T: | |
| length += SDL_PrintUnsignedLongLong(TEXT_AND_LEN_ARGS, &info, | |
| va_arg(ap, size_t)); | |
| break; | |
| } | |
| done = true; | |
| break; | |
| case 'f': | |
| length += SDL_PrintFloat(TEXT_AND_LEN_ARGS, &info, va_arg(ap, double), false); | |
| done = true; | |
| break; | |
| case 'g': | |
| length += SDL_PrintFloat(TEXT_AND_LEN_ARGS, &info, va_arg(ap, double), true); | |
| done = true; | |
| break; | |
| case 'S': | |
| info.pad_zeroes = false; | |
| length += SDL_PrintStringW(TEXT_AND_LEN_ARGS, &info, va_arg(ap, wchar_t *)); | |
| done = true; | |
| break; | |
| case 's': | |
| info.pad_zeroes = false; | |
| if (inttype > DO_INT) { | |
| length += SDL_PrintStringW(TEXT_AND_LEN_ARGS, &info, va_arg(ap, wchar_t *)); | |
| } else { | |
| length += SDL_PrintString(TEXT_AND_LEN_ARGS, &info, va_arg(ap, char *)); | |
| } | |
| done = true; | |
| break; | |
| default: | |
| done = true; | |
| break; | |
| } | |
| ++fmt; | |
| } | |
| } else { | |
| if (length < maxlen) { | |
| text[length] = *fmt; | |
| } | |
| ++fmt; | |
| ++length; | |
| } | |
| } | |
| if (length < maxlen) { | |
| text[length] = '\0'; | |
| } else if (maxlen > 0) { | |
| text[maxlen - 1] = '\0'; | |
| } | |
| return (int)length; | |
| } | |
| #undef TEXT_AND_LEN_ARGS | |
| #endif // HAVE_VSNPRINTF | |
| int SDL_vswprintf(SDL_OUT_Z_CAP(maxlen) wchar_t *text, size_t maxlen, const wchar_t *fmt, va_list ap) | |
| { | |
| if (text) { | |
| text[0] = 0; | |
| } | |
| char *fmt_utf8 = NULL; | |
| if (fmt) { | |
| fmt_utf8 = SDL_iconv_string("UTF-8", "WCHAR_T", (const char *)fmt, (SDL_wcslen(fmt) + 1) * sizeof(wchar_t)); | |
| if (!fmt_utf8) { | |
| return -1; | |
| } | |
| } | |
| char tinybuf[64]; // for really small strings, calculate it once. | |
| // generate the text to find the final text length | |
| va_list aq; | |
| va_copy(aq, ap); | |
| const int utf8len = SDL_vsnprintf(tinybuf, sizeof (tinybuf), fmt_utf8, aq); | |
| va_end(aq); | |
| if (utf8len < 0) { | |
| SDL_free(fmt_utf8); | |
| return -1; | |
| } | |
| bool isstack = false; | |
| char *smallbuf = NULL; | |
| char *utf8buf; | |
| int result; | |
| if (utf8len < sizeof (tinybuf)) { // whole thing fit in the stack buffer, just use that copy. | |
| utf8buf = tinybuf; | |
| } else { // didn't fit in the stack buffer, allocate the needed space and run it again. | |
| utf8buf = smallbuf = SDL_small_alloc(char, utf8len + 1, &isstack); | |
| if (!smallbuf) { | |
| SDL_free(fmt_utf8); | |
| return -1; // oh well. | |
| } | |
| const int utf8len2 = SDL_vsnprintf(smallbuf, utf8len + 1, fmt_utf8, ap); | |
| if (utf8len2 > utf8len) { | |
| SDL_free(fmt_utf8); | |
| return SDL_SetError("Formatted output changed between two runs"); // race condition on the parameters, and we no longer have room...yikes. | |
| } | |
| } | |
| SDL_free(fmt_utf8); | |
| wchar_t *wbuf = (wchar_t *)SDL_iconv_string("WCHAR_T", "UTF-8", utf8buf, utf8len + 1); | |
| if (wbuf) { | |
| if (text) { | |
| SDL_wcslcpy(text, wbuf, maxlen); | |
| } | |
| result = (int)SDL_wcslen(wbuf); | |
| SDL_free(wbuf); | |
| } else { | |
| result = -1; | |
| } | |
| if (smallbuf != NULL) { | |
| SDL_small_free(smallbuf, isstack); | |
| } | |
| return result; | |
| } | |
| int SDL_asprintf(char **strp, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) | |
| { | |
| va_list ap; | |
| int result; | |
| va_start(ap, fmt); | |
| result = SDL_vasprintf(strp, fmt, ap); | |
| va_end(ap); | |
| return result; | |
| } | |
| int SDL_vasprintf(char **strp, SDL_PRINTF_FORMAT_STRING const char *fmt, va_list ap) | |
| { | |
| int result; | |
| int size = 100; // Guess we need no more than 100 bytes | |
| char *p, *np; | |
| va_list aq; | |
| *strp = NULL; | |
| p = (char *)SDL_malloc(size); | |
| if (!p) { | |
| return -1; | |
| } | |
| while (1) { | |
| // Try to print in the allocated space | |
| va_copy(aq, ap); | |
| result = SDL_vsnprintf(p, size, fmt, aq); | |
| va_end(aq); | |
| // Check error code | |
| if (result < 0) { | |
| SDL_free(p); | |
| return result; | |
| } | |
| // If that worked, return the string | |
| if (result < size) { | |
| *strp = p; | |
| return result; | |
| } | |
| // Else try again with more space | |
| size = result + 1; // Precisely what is needed | |
| np = (char *)SDL_realloc(p, size); | |
| if (!np) { | |
| SDL_free(p); | |
| return -1; | |
| } else { | |
| p = np; | |
| } | |
| } | |
| } | |
| char * SDL_strpbrk(const char *str, const char *breakset) | |
| { | |
| #ifdef HAVE_STRPBRK | |
| return SDL_const_cast(char *, strpbrk(str, breakset)); | |
| #else | |
| for (; *str; str++) { | |
| const char *b; | |
| for (b = breakset; *b; b++) { | |
| if (*str == *b) { | |
| return (char *) str; | |
| } | |
| } | |
| } | |
| return NULL; | |
| #endif | |
| } |