TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-07-11 14:44:36 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Updates the SDL library to the latest standard bugfix release

Browse source
This commit is contained in:
JeffR 2023-07-13 15:20:29 -05:00
parent cb766f2878
commit 083d2175ea
1280 changed files with 343926 additions and 179615 deletions
Download patch file Download diff file Expand all files Collapse all files

309
Engine/lib/sdl/src/file/SDL_rwops.c
View file

@ -1,6 +1,6 @@
/*
Simple DirectMedia Layer
Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
Copyright (C) 1997-2023 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
@ -30,7 +30,7 @@
#include "../SDL_internal.h"
#if defined(__WIN32__)
#if defined(__WIN32__) || defined(__GDK__)
#include "../core/windows/SDL_windows.h"
#endif
@ -53,6 +53,10 @@
#include "cocoa/SDL_rwopsbundlesupport.h"
#endif /* __APPLE__ */
#ifdef __3DS__
#include "n3ds/SDL_rwopsromfs.h"
#endif /* __3DS__ */
#ifdef __ANDROID__
#include "../core/android/SDL_android.h"
#include "SDL_system.h"
@ -62,7 +66,7 @@
#include "nacl_io/nacl_io.h"
#endif
#ifdef __WIN32__
#if defined(__WIN32__) || defined(__GDK__)
/* Functions to read/write Win32 API file pointers */
@ -70,21 +74,23 @@
#define INVALID_SET_FILE_POINTER 0xFFFFFFFF
#endif
#define READAHEAD_BUFFER_SIZE 1024
#define READAHEAD_BUFFER_SIZE 1024
static int SDLCALL
windows_file_open(SDL_RWops * context, const char *filename, const char *mode)
static int SDLCALL windows_file_open(SDL_RWops *context, const char *filename, const char *mode)
{
#if !defined(__XBOXONE__) && !defined(__XBOXSERIES__)
UINT old_error_mode;
#endif
HANDLE h;
DWORD r_right, w_right;
DWORD must_exist, truncate;
int a_mode;
if (!context)
return -1; /* failed (invalid call) */
if (context == NULL) {
return -1; /* failed (invalid call) */
}
context->hidden.windowsio.h = INVALID_HANDLE_VALUE; /* mark this as unusable */
context->hidden.windowsio.h = INVALID_HANDLE_VALUE; /* mark this as unusable */
context->hidden.windowsio.buffer.data = NULL;
context->hidden.windowsio.buffer.size = 0;
context->hidden.windowsio.buffer.left = 0;
@ -98,23 +104,25 @@ windows_file_open(SDL_RWops * context, const char *filename, const char *mode)
must_exist = (SDL_strchr(mode, 'r') != NULL) ? OPEN_EXISTING : 0;
truncate = (SDL_strchr(mode, 'w') != NULL) ? CREATE_ALWAYS : 0;
r_right = (SDL_strchr(mode, '+') != NULL
|| must_exist) ? GENERIC_READ : 0;
r_right = (SDL_strchr(mode, '+') != NULL || must_exist) ? GENERIC_READ : 0;
a_mode = (SDL_strchr(mode, 'a') != NULL) ? OPEN_ALWAYS : 0;
w_right = (a_mode || SDL_strchr(mode, '+')
|| truncate) ? GENERIC_WRITE : 0;
w_right = (a_mode || SDL_strchr(mode, '+') || truncate) ? GENERIC_WRITE : 0;
if (!r_right && !w_right) /* inconsistent mode */
return -1; /* failed (invalid call) */
if (!r_right && !w_right) {
return -1; /* inconsistent mode */
}
/* failed (invalid call) */
context->hidden.windowsio.buffer.data =
(char *) SDL_malloc(READAHEAD_BUFFER_SIZE);
(char *)SDL_malloc(READAHEAD_BUFFER_SIZE);
if (!context->hidden.windowsio.buffer.data) {
return SDL_OutOfMemory();
}
#if !defined(__XBOXONE__) && !defined(__XBOXSERIES__)
/* Do not open a dialog box if failure */
old_error_mode =
SetErrorMode(SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS);
#endif
{
LPTSTR tstr = WIN_UTF8ToString(filename);
@ -125,27 +133,28 @@ windows_file_open(SDL_RWops * context, const char *filename, const char *mode)
SDL_free(tstr);
}
#if !defined(__XBOXONE__) && !defined(__XBOXSERIES__)
/* restore old behavior */
SetErrorMode(old_error_mode);
#endif
if (h == INVALID_HANDLE_VALUE) {
SDL_free(context->hidden.windowsio.buffer.data);
context->hidden.windowsio.buffer.data = NULL;
SDL_SetError("Couldn't open %s", filename);
return -2; /* failed (CreateFile) */
return -2; /* failed (CreateFile) */
}
context->hidden.windowsio.h = h;
context->hidden.windowsio.append = a_mode ? SDL_TRUE : SDL_FALSE;
return 0; /* ok */
return 0; /* ok */
}
static Sint64 SDLCALL
windows_file_size(SDL_RWops * context)
static Sint64 SDLCALL windows_file_size(SDL_RWops *context)
{
LARGE_INTEGER size;
if (!context || context->hidden.windowsio.h == INVALID_HANDLE_VALUE) {
if (context == NULL || context->hidden.windowsio.h == INVALID_HANDLE_VALUE) {
return SDL_SetError("windows_file_size: invalid context/file not opened");
}
@ -156,13 +165,12 @@ windows_file_size(SDL_RWops * context)
return size.QuadPart;
}
static Sint64 SDLCALL
windows_file_seek(SDL_RWops * context, Sint64 offset, int whence)
static Sint64 SDLCALL windows_file_seek(SDL_RWops *context, Sint64 offset, int whence)
{
DWORD windowswhence;
LARGE_INTEGER windowsoffset;
if (!context || context->hidden.windowsio.h == INVALID_HANDLE_VALUE) {
if (context == NULL || context->hidden.windowsio.h == INVALID_HANDLE_VALUE) {
return SDL_SetError("windows_file_seek: invalid context/file not opened");
}
@ -194,7 +202,7 @@ windows_file_seek(SDL_RWops * context, Sint64 offset, int whence)
}
static size_t SDLCALL
windows_file_read(SDL_RWops * context, void *ptr, size_t size, size_t maxnum)
windows_file_read(SDL_RWops *context, void *ptr, size_t size, size_t maxnum)
{
size_t total_need;
size_t total_read = 0;
@ -203,14 +211,14 @@ windows_file_read(SDL_RWops * context, void *ptr, size_t size, size_t maxnum)
total_need = size * maxnum;
if (!context || context->hidden.windowsio.h == INVALID_HANDLE_VALUE || !total_need) {
if (context == NULL || context->hidden.windowsio.h == INVALID_HANDLE_VALUE || !total_need) {
return 0;
}
if (context->hidden.windowsio.buffer.left > 0) {
void *data = (char *) context->hidden.windowsio.buffer.data +
context->hidden.windowsio.buffer.size -
context->hidden.windowsio.buffer.left;
void *data = (char *)context->hidden.windowsio.buffer.data +
context->hidden.windowsio.buffer.size -
context->hidden.windowsio.buffer.left;
read_ahead =
SDL_min(total_need, context->hidden.windowsio.buffer.left);
SDL_memcpy(ptr, data, read_ahead);
@ -219,37 +227,35 @@ windows_file_read(SDL_RWops * context, void *ptr, size_t size, size_t maxnum)
if (read_ahead == total_need) {
return maxnum;
}
ptr = (char *) ptr + read_ahead;
ptr = (char *)ptr + read_ahead;
total_need -= read_ahead;
total_read += read_ahead;
}
if (total_need < READAHEAD_BUFFER_SIZE) {
if (!ReadFile
(context->hidden.windowsio.h, context->hidden.windowsio.buffer.data,
READAHEAD_BUFFER_SIZE, &byte_read, NULL)) {
if (!ReadFile(context->hidden.windowsio.h, context->hidden.windowsio.buffer.data,
READAHEAD_BUFFER_SIZE, &byte_read, NULL)) {
SDL_Error(SDL_EFREAD);
return 0;
}
read_ahead = SDL_min(total_need, (int) byte_read);
read_ahead = SDL_min(total_need, (int)byte_read);
SDL_memcpy(ptr, context->hidden.windowsio.buffer.data, read_ahead);
context->hidden.windowsio.buffer.size = byte_read;
context->hidden.windowsio.buffer.left = byte_read - read_ahead;
total_read += read_ahead;
} else {
if (!ReadFile
(context->hidden.windowsio.h, ptr, (DWORD)total_need, &byte_read, NULL)) {
if (!ReadFile(context->hidden.windowsio.h, ptr, (DWORD)total_need, &byte_read, NULL)) {
SDL_Error(SDL_EFREAD);
return 0;
}
total_read += byte_read;
}
return (total_read / size);
return total_read / size;
}
static size_t SDLCALL
windows_file_write(SDL_RWops * context, const void *ptr, size_t size,
size_t num)
windows_file_write(SDL_RWops *context, const void *ptr, size_t size,
size_t num)
{
size_t total_bytes;
@ -258,7 +264,7 @@ windows_file_write(SDL_RWops * context, const void *ptr, size_t size,
total_bytes = size * num;
if (!context || context->hidden.windowsio.h == INVALID_HANDLE_VALUE || !size || !total_bytes) {
if (context == NULL || context->hidden.windowsio.h == INVALID_HANDLE_VALUE || !size || !total_bytes) {
return 0;
}
@ -271,15 +277,15 @@ windows_file_write(SDL_RWops * context, const void *ptr, size_t size,
/* if in append mode, we must go to the EOF before write */
if (context->hidden.windowsio.append) {
if (SetFilePointer(context->hidden.windowsio.h, 0L, NULL, FILE_END) ==
INVALID_SET_FILE_POINTER) {
LARGE_INTEGER windowsoffset;
windowsoffset.QuadPart = 0;
if (!SetFilePointerEx(context->hidden.windowsio.h, windowsoffset, &windowsoffset, FILE_END)) {
SDL_Error(SDL_EFWRITE);
return 0;
}
}
if (!WriteFile
(context->hidden.windowsio.h, ptr, (DWORD)total_bytes, &byte_written, NULL)) {
if (!WriteFile(context->hidden.windowsio.h, ptr, (DWORD)total_bytes, &byte_written, NULL)) {
SDL_Error(SDL_EFWRITE);
return 0;
}
@ -288,14 +294,13 @@ windows_file_write(SDL_RWops * context, const void *ptr, size_t size,
return nwritten;
}
static int SDLCALL
windows_file_close(SDL_RWops * context)
static int SDLCALL windows_file_close(SDL_RWops *context)
{
if (context) {
if (context->hidden.windowsio.h != INVALID_HANDLE_VALUE) {
CloseHandle(context->hidden.windowsio.h);
context->hidden.windowsio.h = INVALID_HANDLE_VALUE; /* to be sure */
context->hidden.windowsio.h = INVALID_HANDLE_VALUE; /* to be sure */
}
SDL_free(context->hidden.windowsio.buffer.data);
context->hidden.windowsio.buffer.data = NULL;
@ -303,17 +308,17 @@ windows_file_close(SDL_RWops * context)
}
return 0;
}
#endif /* __WIN32__ */
#endif /* defined(__WIN32__) || defined(__GDK__) */
#ifdef HAVE_STDIO_H
#ifdef HAVE_FOPEN64
#define fopen fopen64
#define fopen fopen64
#endif
#ifdef HAVE_FSEEKO64
#define fseek_off_t off64_t
#define fseek fseeko64
#define ftell ftello64
#define fseek fseeko64
#define ftell ftello64
#elif defined(HAVE_FSEEKO)
#if defined(OFF_MIN) && defined(OFF_MAX)
#define FSEEK_OFF_MIN OFF_MIN
@ -326,15 +331,15 @@ windows_file_close(SDL_RWops * context)
* and eliminate the dead code if off_t has 64 bits.
*/
#define FSEEK_OFF_MAX (((((off_t)1 << (sizeof(off_t) * CHAR_BIT - 2)) - 1) << 1) + 1)
#define FSEEK_OFF_MIN (-(FSEEK_OFF_MAX) - 1)
#define FSEEK_OFF_MIN (-(FSEEK_OFF_MAX)-1)
#endif
#define fseek_off_t off_t
#define fseek fseeko
#define ftell ftello
#define fseek fseeko
#define ftell ftello
#elif defined(HAVE__FSEEKI64)
#define fseek_off_t __int64
#define fseek _fseeki64
#define ftell _ftelli64
#define fseek _fseeki64
#define ftell _ftelli64
#else
#ifdef HAVE_LIMITS_H
#define FSEEK_OFF_MIN LONG_MIN
@ -360,8 +365,7 @@ stdio_size(SDL_RWops * context)
return size;
}
static Sint64 SDLCALL
stdio_seek(SDL_RWops * context, Sint64 offset, int whence)
static Sint64 SDLCALL stdio_seek(SDL_RWops *context, Sint64 offset, int whence)
{
int stdiowhence;
@ -396,7 +400,7 @@ stdio_seek(SDL_RWops * context, Sint64 offset, int whence)
}
static size_t SDLCALL
stdio_read(SDL_RWops * context, void *ptr, size_t size, size_t maxnum)
stdio_read(SDL_RWops *context, void *ptr, size_t size, size_t maxnum)
{
size_t nread;
@ -408,7 +412,7 @@ stdio_read(SDL_RWops * context, void *ptr, size_t size, size_t maxnum)
}
static size_t SDLCALL
stdio_write(SDL_RWops * context, const void *ptr, size_t size, size_t num)
stdio_write(SDL_RWops *context, const void *ptr, size_t size, size_t num)
{
size_t nwrote;
@ -419,8 +423,7 @@ stdio_write(SDL_RWops * context, const void *ptr, size_t size, size_t num)
return nwrote;
}
static int SDLCALL
stdio_close(SDL_RWops * context)
static int SDLCALL stdio_close(SDL_RWops *context)
{
int status = 0;
if (context) {
@ -438,14 +441,12 @@ stdio_close(SDL_RWops * context)
/* Functions to read/write memory pointers */
static Sint64 SDLCALL
mem_size(SDL_RWops * context)
static Sint64 SDLCALL mem_size(SDL_RWops *context)
{
return (Sint64)(context->hidden.mem.stop - context->hidden.mem.base);
}
static Sint64 SDLCALL
mem_seek(SDL_RWops * context, Sint64 offset, int whence)
static Sint64 SDLCALL mem_seek(SDL_RWops *context, Sint64 offset, int whence)
{
Uint8 *newpos;
@ -473,7 +474,7 @@ mem_seek(SDL_RWops * context, Sint64 offset, int whence)
}
static size_t SDLCALL
mem_read(SDL_RWops * context, void *ptr, size_t size, size_t maxnum)
mem_read(SDL_RWops *context, void *ptr, size_t size, size_t maxnum)
{
size_t total_bytes;
size_t mem_available;
@ -491,11 +492,11 @@ mem_read(SDL_RWops * context, void *ptr, size_t size, size_t maxnum)
SDL_memcpy(ptr, context->hidden.mem.here, total_bytes);
context->hidden.mem.here += total_bytes;
return (total_bytes / size);
return total_bytes / size;
}
static size_t SDLCALL
mem_write(SDL_RWops * context, const void *ptr, size_t size, size_t num)
mem_write(SDL_RWops *context, const void *ptr, size_t size, size_t num)
{
if ((context->hidden.mem.here + (num * size)) > context->hidden.mem.stop) {
num = (context->hidden.mem.stop - context->hidden.mem.here) / size;
@ -506,14 +507,13 @@ mem_write(SDL_RWops * context, const void *ptr, size_t size, size_t num)
}
static size_t SDLCALL
mem_writeconst(SDL_RWops * context, const void *ptr, size_t size, size_t num)
mem_writeconst(SDL_RWops *context, const void *ptr, size_t size, size_t num)
{
SDL_SetError("Can't write to read-only memory");
return 0;
}
static int SDLCALL
mem_close(SDL_RWops * context)
static int SDLCALL mem_close(SDL_RWops *context)
{
if (context) {
SDL_FreeRW(context);
@ -521,14 +521,12 @@ mem_close(SDL_RWops * context)
return 0;
}
/* Functions to create SDL_RWops structures from various data sources */
SDL_RWops *
SDL_RWFromFile(const char *file, const char *mode)
SDL_RWops *SDL_RWFromFile(const char *file, const char *mode)
{
SDL_RWops *rwops = NULL;
if (!file || !*file || !mode || !*mode) {
if (file == NULL || !*file || mode == NULL || !*mode) {
SDL_SetError("SDL_RWFromFile(): No file or no mode specified");
return NULL;
}
@ -561,8 +559,10 @@ SDL_RWFromFile(const char *file, const char *mode)
/* Try to open the file from the asset system */
rwops = SDL_AllocRW();
if (!rwops)
return NULL; /* SDL_SetError already setup by SDL_AllocRW() */
if (rwops == NULL) {
return NULL; /* SDL_SetError already setup by SDL_AllocRW() */
}
if (Android_JNI_FileOpen(rwops, file, mode) < 0) {
SDL_FreeRW(rwops);
return NULL;
@ -574,10 +574,12 @@ SDL_RWFromFile(const char *file, const char *mode)
rwops->close = Android_JNI_FileClose;
rwops->type = SDL_RWOPS_JNIFILE;
#elif defined(__WIN32__)
#elif defined(__WIN32__) || defined(__GDK__)
rwops = SDL_AllocRW();
if (!rwops)
return NULL; /* SDL_SetError already setup by SDL_AllocRW() */
if (rwops == NULL) {
return NULL; /* SDL_SetError already setup by SDL_AllocRW() */
}
if (windows_file_open(rwops, file, mode) < 0) {
SDL_FreeRW(rwops);
return NULL;
@ -590,14 +592,16 @@ SDL_RWFromFile(const char *file, const char *mode)
rwops->type = SDL_RWOPS_WINFILE;
#elif HAVE_STDIO_H
{
#if __APPLE__ && !SDL_FILE_DISABLED // TODO: add dummy?
#if __APPLE__ && !SDL_FILE_DISABLED // TODO: add dummy?
FILE *fp = SDL_OpenFPFromBundleOrFallback(file, mode);
#elif __WINRT__
#elif __WINRT__
FILE *fp = NULL;
fopen_s(&fp, file, mode);
#else
#elif __3DS__
FILE *fp = N3DS_FileOpen(file, mode);
#else
FILE *fp = fopen(file, mode);
#endif
#endif
if (fp == NULL) {
SDL_SetError("Couldn't open %s", file);
} else {
@ -612,8 +616,7 @@ SDL_RWFromFile(const char *file, const char *mode)
}
#ifdef HAVE_STDIO_H
SDL_RWops *
SDL_RWFromFP(FILE * fp, SDL_bool autoclose)
SDL_RWops *SDL_RWFromFP(FILE * fp, SDL_bool autoclose)
{
SDL_RWops *rwops = NULL;
@ -631,25 +634,23 @@ SDL_RWFromFP(FILE * fp, SDL_bool autoclose)
return rwops;
}
#else
SDL_RWops *
SDL_RWFromFP(void * fp, SDL_bool autoclose)
SDL_RWops *SDL_RWFromFP(void * fp, SDL_bool autoclose)
{
SDL_SetError("SDL not compiled with stdio support");
return NULL;
}
#endif /* HAVE_STDIO_H */
SDL_RWops *
SDL_RWFromMem(void *mem, int size)
SDL_RWops *SDL_RWFromMem(void *mem, int size)
{
SDL_RWops *rwops = NULL;
if (!mem) {
SDL_InvalidParamError("mem");
return rwops;
if (mem == NULL) {
SDL_InvalidParamError("mem");
return rwops;
}
if (!size) {
SDL_InvalidParamError("size");
return rwops;
SDL_InvalidParamError("size");
return rwops;
}
rwops = SDL_AllocRW();
@ -659,7 +660,7 @@ SDL_RWFromMem(void *mem, int size)
rwops->read = mem_read;
rwops->write = mem_write;
rwops->close = mem_close;
rwops->hidden.mem.base = (Uint8 *) mem;
rwops->hidden.mem.base = (Uint8 *)mem;
rwops->hidden.mem.here = rwops->hidden.mem.base;
rwops->hidden.mem.stop = rwops->hidden.mem.base + size;
rwops->type = SDL_RWOPS_MEMORY;
@ -667,17 +668,16 @@ SDL_RWFromMem(void *mem, int size)
return rwops;
}
SDL_RWops *
SDL_RWFromConstMem(const void *mem, int size)
SDL_RWops *SDL_RWFromConstMem(const void *mem, int size)
{
SDL_RWops *rwops = NULL;
if (!mem) {
SDL_InvalidParamError("mem");
return rwops;
if (mem == NULL) {
SDL_InvalidParamError("mem");
return rwops;
}
if (!size) {
SDL_InvalidParamError("size");
return rwops;
SDL_InvalidParamError("size");
return rwops;
}
rwops = SDL_AllocRW();
@ -687,7 +687,7 @@ SDL_RWFromConstMem(const void *mem, int size)
rwops->read = mem_read;
rwops->write = mem_writeconst;
rwops->close = mem_close;
rwops->hidden.mem.base = (Uint8 *) mem;
rwops->hidden.mem.base = (Uint8 *)mem;
rwops->hidden.mem.here = rwops->hidden.mem.base;
rwops->hidden.mem.stop = rwops->hidden.mem.base + size;
rwops->type = SDL_RWOPS_MEMORY_RO;
@ -695,12 +695,11 @@ SDL_RWFromConstMem(const void *mem, int size)
return rwops;
}
SDL_RWops *
SDL_AllocRW(void)
SDL_RWops *SDL_AllocRW(void)
{
SDL_RWops *area;
area = (SDL_RWops *) SDL_malloc(sizeof *area);
area = (SDL_RWops *)SDL_malloc(sizeof(*area));
if (area == NULL) {
SDL_OutOfMemory();
} else {
@ -709,22 +708,20 @@ SDL_AllocRW(void)
return area;
}
void
SDL_FreeRW(SDL_RWops * area)
void SDL_FreeRW(SDL_RWops *area)
{
SDL_free(area);
}
/* Load all the data from an SDL data stream */
void *
SDL_LoadFile_RW(SDL_RWops * src, size_t *datasize, int freesrc)
void *SDL_LoadFile_RW(SDL_RWops *src, size_t *datasize, int freesrc)
{
const int FILE_CHUNK_SIZE = 1024;
static const Sint64 FILE_CHUNK_SIZE = 1024;
Sint64 size;
size_t size_read, size_total;
void *data = NULL, *newdata;
if (!src) {
if (src == NULL) {
SDL_InvalidParamError("src");
return NULL;
}
@ -740,7 +737,7 @@ SDL_LoadFile_RW(SDL_RWops * src, size_t *datasize, int freesrc)
if ((((Sint64)size_total) + FILE_CHUNK_SIZE) > size) {
size = (size_total + FILE_CHUNK_SIZE);
newdata = SDL_realloc(data, (size_t)(size + 1));
if (!newdata) {
if (newdata == NULL) {
SDL_free(data);
data = NULL;
SDL_OutOfMemory();
@ -749,7 +746,7 @@ SDL_LoadFile_RW(SDL_RWops * src, size_t *datasize, int freesrc)
data = newdata;
}
size_read = SDL_RWread(src, (char *)data+size_total, 1, (size_t)(size-size_total));
size_read = SDL_RWread(src, (char *)data + size_total, 1, (size_t)(size - size_total));
if (size_read == 0) {
break;
}
@ -768,26 +765,22 @@ done:
return data;
}
void *
SDL_LoadFile(const char *file, size_t *datasize)
void *SDL_LoadFile(const char *file, size_t *datasize)
{
return SDL_LoadFile_RW(SDL_RWFromFile(file, "rb"), datasize, 1);
return SDL_LoadFile_RW(SDL_RWFromFile(file, "rb"), datasize, 1);
}
Sint64
SDL_RWsize(SDL_RWops *context)
Sint64 SDL_RWsize(SDL_RWops *context)
{
return context->size(context);
}
Sint64
SDL_RWseek(SDL_RWops *context, Sint64 offset, int whence)
Sint64 SDL_RWseek(SDL_RWops *context, Sint64 offset, int whence)
{
return context->seek(context, offset, whence);
}
Sint64
SDL_RWtell(SDL_RWops *context)
Sint64 SDL_RWtell(SDL_RWops *context)
{
return context->seek(context, 0, RW_SEEK_CUR);
}
@ -804,123 +797,115 @@ SDL_RWwrite(SDL_RWops *context, const void *ptr, size_t size, size_t num)
return context->write(context, ptr, size, num);
}
int
SDL_RWclose(SDL_RWops *context)
int SDL_RWclose(SDL_RWops *context)
{
return context->close(context);
}
/* Functions for dynamically reading and writing endian-specific values */
Uint8
SDL_ReadU8(SDL_RWops * src)
Uint8 SDL_ReadU8(SDL_RWops *src)
{
Uint8 value = 0;
SDL_RWread(src, &value, sizeof (value), 1);
SDL_RWread(src, &value, sizeof(value), 1);
return value;
}
Uint16
SDL_ReadLE16(SDL_RWops * src)
Uint16 SDL_ReadLE16(SDL_RWops *src)
{
Uint16 value = 0;
SDL_RWread(src, &value, sizeof (value), 1);
SDL_RWread(src, &value, sizeof(value), 1);
return SDL_SwapLE16(value);
}
Uint16
SDL_ReadBE16(SDL_RWops * src)
Uint16 SDL_ReadBE16(SDL_RWops *src)
{
Uint16 value = 0;
SDL_RWread(src, &value, sizeof (value), 1);
SDL_RWread(src, &value, sizeof(value), 1);
return SDL_SwapBE16(value);
}
Uint32
SDL_ReadLE32(SDL_RWops * src)
Uint32 SDL_ReadLE32(SDL_RWops *src)
{
Uint32 value = 0;
SDL_RWread(src, &value, sizeof (value), 1);
SDL_RWread(src, &value, sizeof(value), 1);
return SDL_SwapLE32(value);
}
Uint32
SDL_ReadBE32(SDL_RWops * src)
Uint32 SDL_ReadBE32(SDL_RWops *src)
{
Uint32 value = 0;
SDL_RWread(src, &value, sizeof (value), 1);
SDL_RWread(src, &value, sizeof(value), 1);
return SDL_SwapBE32(value);
}
Uint64
SDL_ReadLE64(SDL_RWops * src)
Uint64 SDL_ReadLE64(SDL_RWops *src)
{
Uint64 value = 0;
SDL_RWread(src, &value, sizeof (value), 1);
SDL_RWread(src, &value, sizeof(value), 1);
return SDL_SwapLE64(value);
}
Uint64
SDL_ReadBE64(SDL_RWops * src)
Uint64 SDL_ReadBE64(SDL_RWops *src)
{
Uint64 value = 0;
SDL_RWread(src, &value, sizeof (value), 1);
SDL_RWread(src, &value, sizeof(value), 1);
return SDL_SwapBE64(value);
}
size_t
SDL_WriteU8(SDL_RWops * dst, Uint8 value)
SDL_WriteU8(SDL_RWops *dst, Uint8 value)
{
return SDL_RWwrite(dst, &value, sizeof (value), 1);
return SDL_RWwrite(dst, &value, sizeof(value), 1);
}
size_t
SDL_WriteLE16(SDL_RWops * dst, Uint16 value)
SDL_WriteLE16(SDL_RWops *dst, Uint16 value)
{
const Uint16 swapped = SDL_SwapLE16(value);
return SDL_RWwrite(dst, &swapped, sizeof (swapped), 1);
return SDL_RWwrite(dst, &swapped, sizeof(swapped), 1);
}
size_t
SDL_WriteBE16(SDL_RWops * dst, Uint16 value)
SDL_WriteBE16(SDL_RWops *dst, Uint16 value)
{
const Uint16 swapped = SDL_SwapBE16(value);
return SDL_RWwrite(dst, &swapped, sizeof (swapped), 1);
return SDL_RWwrite(dst, &swapped, sizeof(swapped), 1);
}
size_t
SDL_WriteLE32(SDL_RWops * dst, Uint32 value)
SDL_WriteLE32(SDL_RWops *dst, Uint32 value)
{
const Uint32 swapped = SDL_SwapLE32(value);
return SDL_RWwrite(dst, &swapped, sizeof (swapped), 1);
return SDL_RWwrite(dst, &swapped, sizeof(swapped), 1);
}
size_t
SDL_WriteBE32(SDL_RWops * dst, Uint32 value)
SDL_WriteBE32(SDL_RWops *dst, Uint32 value)
{
const Uint32 swapped = SDL_SwapBE32(value);
return SDL_RWwrite(dst, &swapped, sizeof (swapped), 1);
return SDL_RWwrite(dst, &swapped, sizeof(swapped), 1);
}
size_t
SDL_WriteLE64(SDL_RWops * dst, Uint64 value)
SDL_WriteLE64(SDL_RWops *dst, Uint64 value)
{
const Uint64 swapped = SDL_SwapLE64(value);
return SDL_RWwrite(dst, &swapped, sizeof (swapped), 1);
return SDL_RWwrite(dst, &swapped, sizeof(swapped), 1);
}
size_t
SDL_WriteBE64(SDL_RWops * dst, Uint64 value)
SDL_WriteBE64(SDL_RWops *dst, Uint64 value)
{
const Uint64 swapped = SDL_SwapBE64(value);
return SDL_RWwrite(dst, &swapped, sizeof (swapped), 1);
return SDL_RWwrite(dst, &swapped, sizeof(swapped), 1);
}
/* vi: set ts=4 sw=4 expandtab: */

4
Engine/lib/sdl/src/file/cocoa/SDL_rwopsbundlesupport.h
View file

@ -1,6 +1,6 @@
/*
Simple DirectMedia Layer
Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
Copyright (C) 1997-2023 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
@ -25,6 +25,6 @@
#ifndef SDL_rwopsbundlesupport_h
#define SDL_rwopsbundlesupport_h
FILE* SDL_OpenFPFromBundleOrFallback(const char *file, const char *mode);
FILE *SDL_OpenFPFromBundleOrFallback(const char *file, const char *mode);
#endif
#endif

49
Engine/lib/sdl/src/file/cocoa/SDL_rwopsbundlesupport.m
View file

@ -1,6 +1,6 @@
/*
Simple DirectMedia Layer
Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
Copyright (C) 1997-2023 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
@ -32,30 +32,35 @@
but we would somehow need to know what the bundle identifiers we need to search are.
Also, note the bundle layouts are different for iPhone and Mac.
*/
FILE* SDL_OpenFPFromBundleOrFallback(const char *file, const char *mode)
{ @autoreleasepool
FILE *SDL_OpenFPFromBundleOrFallback(const char *file, const char *mode)
{
FILE* fp = NULL;
@autoreleasepool {
FILE *fp = NULL;
NSFileManager *file_manager;
NSString *resource_path;
NSString *ns_string_file_component;
NSString *full_path_with_file_to_try;
/* If the file mode is writable, skip all the bundle stuff because generally the bundle is read-only. */
if(strcmp("r", mode) && strcmp("rb", mode)) {
return fopen(file, mode);
/* If the file mode is writable, skip all the bundle stuff because generally the bundle is read-only. */
if (SDL_strchr(mode, 'r') == NULL) {
return fopen(file, mode);
}
file_manager = [NSFileManager defaultManager];
resource_path = [[NSBundle mainBundle] resourcePath];
ns_string_file_component = [file_manager stringWithFileSystemRepresentation:file length:strlen(file)];
full_path_with_file_to_try = [resource_path stringByAppendingPathComponent:ns_string_file_component];
if ([file_manager fileExistsAtPath:full_path_with_file_to_try]) {
fp = fopen([full_path_with_file_to_try fileSystemRepresentation], mode);
} else {
fp = fopen(file, mode);
}
return fp;
}
NSFileManager* file_manager = [NSFileManager defaultManager];
NSString* resource_path = [[NSBundle mainBundle] resourcePath];
NSString* ns_string_file_component = [file_manager stringWithFileSystemRepresentation:file length:strlen(file)];
NSString* full_path_with_file_to_try = [resource_path stringByAppendingPathComponent:ns_string_file_component];
if([file_manager fileExistsAtPath:full_path_with_file_to_try]) {
fp = fopen([full_path_with_file_to_try fileSystemRepresentation], mode);
} else {
fp = fopen(file, mode);
}
return fp;
}}
}
#endif /* __APPLE__ */

92
Engine/lib/sdl/src/file/n3ds/SDL_rwopsromfs.c Normal file
View file

@ -0,0 +1,92 @@
/*
Simple DirectMedia Layer
Copyright (C) 1997-2023 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_rwopsromfs.h"
#include "SDL_error.h"
/* Checks if the mode is a kind of reading */
static SDL_bool IsReadMode(const char *mode);
/* Checks if the file starts with the given prefix */
static SDL_bool HasPrefix(const char *file, const char *prefix);
static FILE *TryOpenFile(const char *file, const char *mode);
static FILE *TryOpenInRomfs(const char *file, const char *mode);
/* Nintendo 3DS applications may embed resources in the executable. The
resources are stored in a special read-only partition prefixed with
'romfs:/'. As such, when opening a file, we should first try the romfs
unless sdmc is specifically mentionned.
*/
FILE *N3DS_FileOpen(const char *file, const char *mode)
{
/* romfs are read-only */
if (!IsReadMode(mode)) {
return fopen(file, mode);
}
/* If the path has an explicit prefix, we skip the guess work */
if (HasPrefix(file, "romfs:/") || HasPrefix(file, "sdmc:/")) {
return fopen(file, mode);
}
return TryOpenFile(file, mode);
}
static SDL_bool IsReadMode(const char *mode)
{
return SDL_strchr(mode, 'r') != NULL;
}
static SDL_bool HasPrefix(const char *file, const char *prefix)
{
return SDL_strncmp(prefix, file, SDL_strlen(prefix)) == 0;
}
static FILE *TryOpenFile(const char *file, const char *mode)
{
FILE *fp = NULL;
fp = TryOpenInRomfs(file, mode);
if (fp == NULL) {
fp = fopen(file, mode);
}
return fp;
}
static FILE *TryOpenInRomfs(const char *file, const char *mode)
{
FILE *fp = NULL;
char *prefixed_filepath = NULL;
if (SDL_asprintf(&prefixed_filepath, "romfs:/%s", file) < 0) {
SDL_OutOfMemory();
return NULL;
}
fp = fopen(prefixed_filepath, mode);
SDL_free(prefixed_filepath);
return fp;
}
/* vi: set sts=4 ts=4 sw=4 expandtab: */

30
Engine/lib/sdl/src/file/n3ds/SDL_rwopsromfs.h Normal file
View file

@ -0,0 +1,30 @@
/*
Simple DirectMedia Layer
Copyright (C) 1997-2023 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"
#ifndef SDL_rwopsromfs_h_
#define SDL_rwopsromfs_h_
FILE *N3DS_FileOpen(const char *file, const char *mode);
#endif /* SDL_rwopsromfs_h_ */
/* vi: set sts=4 ts=4 sw=4 expandtab: */