mirror of
https://github.com/love2d/megasource.git
synced 2026-08-20 20:50:52 +02:00
update SDL3 to latest commit
This commit is contained in:
Sasha Szpakowski
+324
-7
@@ -20,20 +20,22 @@
|
||||
*/
|
||||
#include "SDL_internal.h"
|
||||
|
||||
#include "SDL_utils_c.h"
|
||||
#if defined(SDL_PLATFORM_UNIX) || defined(SDL_PLATFORM_APPLE)
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
/* Common utility functions that aren't in the public API */
|
||||
// Common utility functions that aren't in the public API
|
||||
|
||||
int SDL_powerof2(int x)
|
||||
{
|
||||
int value;
|
||||
|
||||
if (x <= 0) {
|
||||
/* Return some sane value - we shouldn't hit this in our use cases */
|
||||
// Return some sane value - we shouldn't hit this in our use cases
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* This trick works for 32-bit values */
|
||||
// This trick works for 32-bit values
|
||||
{
|
||||
SDL_COMPILE_TIME_ASSERT(SDL_powerof2, sizeof(x) == sizeof(Uint32));
|
||||
}
|
||||
@@ -49,15 +51,330 @@ int SDL_powerof2(int x)
|
||||
return value;
|
||||
}
|
||||
|
||||
SDL_bool SDL_endswith(const char *string, const char *suffix)
|
||||
Uint32 SDL_CalculateGCD(Uint32 a, Uint32 b)
|
||||
{
|
||||
if (b == 0) {
|
||||
return a;
|
||||
}
|
||||
return SDL_CalculateGCD(b, (a % b));
|
||||
}
|
||||
|
||||
// Algorithm adapted with thanks from John Cook's blog post:
|
||||
// http://www.johndcook.com/blog/2010/10/20/best-rational-approximation
|
||||
void SDL_CalculateFraction(float x, int *numerator, int *denominator)
|
||||
{
|
||||
const int N = 1000;
|
||||
int a = 0, b = 1;
|
||||
int c = 1, d = 0;
|
||||
|
||||
while (b <= N && d <= N) {
|
||||
float mediant = (float)(a + c) / (b + d);
|
||||
if (x == mediant) {
|
||||
if (b + d <= N) {
|
||||
*numerator = a + c;
|
||||
*denominator = b + d;
|
||||
} else if (d > b) {
|
||||
*numerator = c;
|
||||
*denominator = d;
|
||||
} else {
|
||||
*numerator = a;
|
||||
*denominator = b;
|
||||
}
|
||||
return;
|
||||
} else if (x > mediant) {
|
||||
a = a + c;
|
||||
b = b + d;
|
||||
} else {
|
||||
c = a + c;
|
||||
d = b + d;
|
||||
}
|
||||
}
|
||||
if (b > N) {
|
||||
*numerator = c;
|
||||
*denominator = d;
|
||||
} else {
|
||||
*numerator = a;
|
||||
*denominator = b;
|
||||
}
|
||||
}
|
||||
|
||||
bool SDL_startswith(const char *string, const char *prefix)
|
||||
{
|
||||
if (SDL_strncmp(string, prefix, SDL_strlen(prefix)) == 0) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool SDL_endswith(const char *string, const char *suffix)
|
||||
{
|
||||
size_t string_length = string ? SDL_strlen(string) : 0;
|
||||
size_t suffix_length = suffix ? SDL_strlen(suffix) : 0;
|
||||
|
||||
if (suffix_length > 0 && suffix_length <= string_length) {
|
||||
if (SDL_memcmp(string + string_length - suffix_length, suffix, suffix_length) == 0) {
|
||||
return SDL_TRUE;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return SDL_FALSE;
|
||||
return false;
|
||||
}
|
||||
|
||||
SDL_COMPILE_TIME_ASSERT(sizeof_object_id, sizeof(int) == sizeof(Uint32));
|
||||
|
||||
Uint32 SDL_GetNextObjectID(void)
|
||||
{
|
||||
static SDL_AtomicInt last_id;
|
||||
|
||||
Uint32 id = (Uint32)SDL_AtomicIncRef(&last_id) + 1;
|
||||
if (id == 0) {
|
||||
id = (Uint32)SDL_AtomicIncRef(&last_id) + 1;
|
||||
}
|
||||
return id;
|
||||
}
|
||||
|
||||
static SDL_HashTable *SDL_objects;
|
||||
|
||||
static Uint32 SDL_HashObject(const void *key, void *unused)
|
||||
{
|
||||
return (Uint32)(uintptr_t)key;
|
||||
}
|
||||
|
||||
static bool SDL_KeyMatchObject(const void *a, const void *b, void *unused)
|
||||
{
|
||||
return (a == b);
|
||||
}
|
||||
|
||||
void SDL_SetObjectValid(void *object, SDL_ObjectType type, bool valid)
|
||||
{
|
||||
SDL_assert(object != NULL);
|
||||
|
||||
if (valid) {
|
||||
if (!SDL_objects) {
|
||||
SDL_objects = SDL_CreateHashTable(NULL, 32, SDL_HashObject, SDL_KeyMatchObject, NULL, false);
|
||||
}
|
||||
|
||||
SDL_InsertIntoHashTable(SDL_objects, object, (void *)(uintptr_t)type);
|
||||
} else {
|
||||
if (SDL_objects) {
|
||||
SDL_RemoveFromHashTable(SDL_objects, object);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool SDL_ObjectValid(void *object, SDL_ObjectType type)
|
||||
{
|
||||
if (!object) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const void *object_type;
|
||||
if (!SDL_FindInHashTable(SDL_objects, object, &object_type)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return (((SDL_ObjectType)(uintptr_t)object_type) == type);
|
||||
}
|
||||
|
||||
void SDL_SetObjectsInvalid(void)
|
||||
{
|
||||
if (SDL_objects) {
|
||||
// Log any leaked objects
|
||||
const void *object, *object_type;
|
||||
void *iter = NULL;
|
||||
while (SDL_IterateHashTable(SDL_objects, &object, &object_type, &iter)) {
|
||||
const char *type;
|
||||
switch ((SDL_ObjectType)(uintptr_t)object_type) {
|
||||
case SDL_OBJECT_TYPE_WINDOW:
|
||||
type = "SDL_Window";
|
||||
break;
|
||||
case SDL_OBJECT_TYPE_RENDERER:
|
||||
type = "SDL_Renderer";
|
||||
break;
|
||||
case SDL_OBJECT_TYPE_TEXTURE:
|
||||
type = "SDL_Texture";
|
||||
break;
|
||||
case SDL_OBJECT_TYPE_JOYSTICK:
|
||||
type = "SDL_Joystick";
|
||||
break;
|
||||
case SDL_OBJECT_TYPE_GAMEPAD:
|
||||
type = "SDL_Gamepad";
|
||||
break;
|
||||
case SDL_OBJECT_TYPE_HAPTIC:
|
||||
type = "SDL_Haptic";
|
||||
break;
|
||||
case SDL_OBJECT_TYPE_SENSOR:
|
||||
type = "SDL_Sensor";
|
||||
break;
|
||||
case SDL_OBJECT_TYPE_HIDAPI_DEVICE:
|
||||
type = "hidapi device";
|
||||
break;
|
||||
case SDL_OBJECT_TYPE_HIDAPI_JOYSTICK:
|
||||
type = "hidapi joystick";
|
||||
break;
|
||||
default:
|
||||
type = "unknown object";
|
||||
break;
|
||||
}
|
||||
SDL_Log("Leaked %s (%p)\n", type, object);
|
||||
}
|
||||
SDL_assert(SDL_HashTableEmpty(SDL_objects));
|
||||
|
||||
SDL_DestroyHashTable(SDL_objects);
|
||||
SDL_objects = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
static int SDL_URIDecode(const char *src, char *dst, int len)
|
||||
{
|
||||
int ri, wi, di;
|
||||
char decode = '\0';
|
||||
if (!src || !dst || len < 0) {
|
||||
return -1;
|
||||
}
|
||||
if (len == 0) {
|
||||
len = (int)SDL_strlen(src);
|
||||
}
|
||||
for (ri = 0, wi = 0, di = 0; ri < len && wi < len; ri += 1) {
|
||||
if (di == 0) {
|
||||
// start decoding
|
||||
if (src[ri] == '%') {
|
||||
decode = '\0';
|
||||
di += 1;
|
||||
continue;
|
||||
}
|
||||
// normal write
|
||||
dst[wi] = src[ri];
|
||||
wi += 1;
|
||||
} else if (di == 1 || di == 2) {
|
||||
char off = '\0';
|
||||
char isa = src[ri] >= 'a' && src[ri] <= 'f';
|
||||
char isA = src[ri] >= 'A' && src[ri] <= 'F';
|
||||
char isn = src[ri] >= '0' && src[ri] <= '9';
|
||||
if (!(isa || isA || isn)) {
|
||||
// not a hexadecimal
|
||||
int sri;
|
||||
for (sri = ri - di; sri <= ri; sri += 1) {
|
||||
dst[wi] = src[sri];
|
||||
wi += 1;
|
||||
}
|
||||
di = 0;
|
||||
continue;
|
||||
}
|
||||
// itsy bitsy magicsy
|
||||
if (isn) {
|
||||
off = 0 - '0';
|
||||
} else if (isa) {
|
||||
off = 10 - 'a';
|
||||
} else if (isA) {
|
||||
off = 10 - 'A';
|
||||
}
|
||||
decode |= (src[ri] + off) << (2 - di) * 4;
|
||||
if (di == 2) {
|
||||
dst[wi] = decode;
|
||||
wi += 1;
|
||||
di = 0;
|
||||
} else {
|
||||
di += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
dst[wi] = '\0';
|
||||
return wi;
|
||||
}
|
||||
|
||||
int SDL_URIToLocal(const char *src, char *dst)
|
||||
{
|
||||
if (SDL_memcmp(src, "file:/", 6) == 0) {
|
||||
src += 6; // local file?
|
||||
} else if (SDL_strstr(src, ":/") != NULL) {
|
||||
return -1; // wrong scheme
|
||||
}
|
||||
|
||||
bool local = src[0] != '/' || (src[0] != '\0' && src[1] == '/');
|
||||
|
||||
// Check the hostname, if present. RFC 3986 states that the hostname component of a URI is not case-sensitive.
|
||||
if (!local && src[0] == '/' && src[2] != '/') {
|
||||
char *hostname_end = SDL_strchr(src + 1, '/');
|
||||
if (hostname_end) {
|
||||
const size_t src_len = hostname_end - (src + 1);
|
||||
size_t hostname_len;
|
||||
|
||||
#if defined(SDL_PLATFORM_UNIX) || defined(SDL_PLATFORM_APPLE)
|
||||
char hostname[257];
|
||||
if (gethostname(hostname, 255) == 0) {
|
||||
hostname[256] = '\0';
|
||||
hostname_len = SDL_strlen(hostname);
|
||||
if (hostname_len == src_len && SDL_strncasecmp(src + 1, hostname, src_len) == 0) {
|
||||
src = hostname_end + 1;
|
||||
local = true;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
if (!local) {
|
||||
static const char *localhost = "localhost";
|
||||
hostname_len = SDL_strlen(localhost);
|
||||
if (hostname_len == src_len && SDL_strncasecmp(src + 1, localhost, src_len) == 0) {
|
||||
src = hostname_end + 1;
|
||||
local = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (local) {
|
||||
// Convert URI escape sequences to real characters
|
||||
if (src[0] == '/') {
|
||||
src++;
|
||||
} else {
|
||||
src--;
|
||||
}
|
||||
return SDL_URIDecode(src, dst, 0);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
// This is a set of per-thread persistent strings that we can return from the SDL API.
|
||||
// This is used for short strings that might persist past the lifetime of the object
|
||||
// they are related to.
|
||||
|
||||
static SDL_TLSID SDL_string_storage;
|
||||
|
||||
static void SDL_FreePersistentStrings( void *value )
|
||||
{
|
||||
SDL_HashTable *strings = (SDL_HashTable *)value;
|
||||
SDL_DestroyHashTable(strings);
|
||||
}
|
||||
|
||||
const char *SDL_GetPersistentString(const char *string)
|
||||
{
|
||||
if (!string) {
|
||||
return NULL;
|
||||
}
|
||||
if (!*string) {
|
||||
return "";
|
||||
}
|
||||
|
||||
SDL_HashTable *strings = (SDL_HashTable *)SDL_GetTLS(&SDL_string_storage);
|
||||
if (!strings) {
|
||||
strings = SDL_CreateHashTable(NULL, 32, SDL_HashString, SDL_KeyMatchString, SDL_NukeFreeValue, false);
|
||||
if (!strings) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
SDL_SetTLS(&SDL_string_storage, strings, SDL_FreePersistentStrings);
|
||||
}
|
||||
|
||||
const char *result;
|
||||
if (!SDL_FindInHashTable(strings, string, (const void **)&result)) {
|
||||
char *new_string = SDL_strdup(string);
|
||||
if (!new_string) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// If the hash table insert fails, at least we can return the string we allocated
|
||||
SDL_InsertIntoHashTable(strings, new_string, new_string);
|
||||
result = new_string;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user