mirror of
https://github.com/libsdl-org/SDL.git
synced 2025-10-01 15:38:29 +00:00
2514 lines
73 KiB
C
2514 lines
73 KiB
C
/*
|
|
Simple DirectMedia Layer
|
|
Copyright (C) 1997-2025 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)
|
|
#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 & 0x1F)) << 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
|
|
|
|
#ifndef HAVE_WCSTOL
|
|
// 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_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
|
|
|
|
#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
|
|
|
|
#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 // HAVE_MEMCMP
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
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_STRSTR
|
|
}
|
|
|
|
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_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_uitoa(unsigned int value, char *string, int radix)
|
|
{
|
|
#ifdef HAVE__UITOA
|
|
return _uitoa(value, string, radix);
|
|
#else
|
|
return SDL_ultoa((unsigned long)value, string, radix);
|
|
#endif // HAVE__UITOA
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
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_LIBC) && defined(__WATCOMC__)
|
|
// _vsnprintf() doesn't ensure nul termination
|
|
int SDL_vsnprintf(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, const char *fmt, va_list ap)
|
|
{
|
|
int result;
|
|
if (!fmt) {
|
|
fmt = "";
|
|
}
|
|
result = _vsnprintf(text, maxlen, fmt, ap);
|
|
if (maxlen > 0) {
|
|
text[maxlen - 1] = '\0';
|
|
}
|
|
if (result < 0) {
|
|
result = (int)maxlen;
|
|
}
|
|
return result;
|
|
}
|
|
#elif 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)
|
|
{
|
|
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 strpbrk(str, breakset);
|
|
#else
|
|
|
|
for (; *str; str++) {
|
|
const char *b;
|
|
|
|
for (b = breakset; *b; b++) {
|
|
if (*str == *b) {
|
|
return (char *) str;
|
|
}
|
|
}
|
|
}
|
|
return NULL;
|
|
#endif
|
|
}
|