eden-emu/SDL
15
0
Fork 0
mirror of https://github.com/libsdl-org/SDL.git synced 2025-06-01 09:27:39 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Renamed event memory to temporary memory, since it's not just used for events

Browse source
This commit is contained in:
Sam Lantinga 2024-07-19 09:50:25 -07:00
parent c4eac60000
commit fd9fe1bb7b
9 changed files with 121 additions and 128 deletions
Download patch file Download diff file Expand all files Collapse all files

33
include/SDL3/SDL_events.h
View file

@ -1407,10 +1407,9 @@ extern SDL_DECLSPEC SDL_bool SDLCALL SDL_EventEnabled(Uint32 type);
extern SDL_DECLSPEC Uint32 SDLCALL SDL_RegisterEvents(int numevents);
/**
* Allocate temporary memory for an SDL event.
* Allocate temporary memory.
*
* You can use this to allocate memory for user events that will be
* automatically freed after the event is processed.
* You can use this to allocate memory that will be automatically freed later, after event processing is complete.
*
* \param size the amount of memory to allocate.
* \returns a pointer to the memory allocated or NULL on failure; call
@ -1420,35 +1419,33 @@ extern SDL_DECLSPEC Uint32 SDLCALL SDL_RegisterEvents(int numevents);
*
* \since This function is available since SDL 3.0.0.
*
* \sa SDL_ClaimEventMemory
* \sa SDL_FreeEventMemory
* \sa SDL_ClaimTemporaryMemory
* \sa SDL_FreeTemporaryMemory
*/
extern SDL_DECLSPEC void * SDLCALL SDL_AllocateEventMemory(size_t size);
extern SDL_DECLSPEC void * SDLCALL SDL_AllocateTemporaryMemory(size_t size);
/**
* Claim ownership of temporary event memory allocated by SDL.
* Claim ownership of temporary memory allocated by SDL.
*
* This function changes ownership of temporary event memory allocated for events and APIs that
* follow the SDL_GetStringRule. If this function succeeds, the memory will no longer be automatically freed by SDL, it must be freed using SDL_free() by the application.
* This function changes ownership of temporary memory allocated for events and APIs that
* return temporary memory. If this function succeeds, the memory will no longer be automatically freed by SDL, it must be freed using SDL_free() by the application.
*
* If the memory isn't temporary, or it was allocated on a different thread, or if it is associated with an event currently in the event queue, this will return NULL, and the application does not have ownership of the memory.
*
* Note that even if a function follows the SDL_GetStringRule it may not be using temporary event memory, and this function will return NULL in that case.
*
* \param mem a pointer allocated with SDL_AllocateEventMemory().
* \param mem a pointer allocated with SDL_AllocateTemporaryMemory().
* \returns a pointer to the memory now owned by the application, which must be freed using SDL_free(), or NULL if the memory is not temporary or was allocated on a different thread.
*
* \threadsafety It is safe to call this function from any thread.
*
* \since This function is available since SDL 3.0.0.
*
* \sa SDL_AllocateEventMemory
* \sa SDL_AllocateTemporaryMemory
* \sa SDL_free
*/
extern SDL_DECLSPEC void * SDLCALL SDL_ClaimEventMemory(const void *mem);
extern SDL_DECLSPEC void * SDLCALL SDL_ClaimTemporaryMemory(const void *mem);
/**
* Free temporary event memory allocated by SDL.
* Free temporary memory allocated by SDL.
*
* This function frees temporary memory allocated for events and APIs that
* follow the SDL_GetStringRule. This memory is local to the thread that creates
@ -1460,15 +1457,15 @@ extern SDL_DECLSPEC void * SDLCALL SDL_ClaimEventMemory(const void *mem);
*
* All temporary memory is freed on the main thread in SDL_Quit() and for other threads when they call SDL_CleanupTLS(), which is automatically called at cleanup time for threads created using SDL_CreateThread().
*
* \param mem a pointer allocated with SDL_AllocateEventMemory(), or NULL to free all pending temporary allocations.
* \param mem a pointer allocated with SDL_AllocateTemporaryMemory(), or NULL to free all pending temporary allocations.
*
* \threadsafety It is safe to call this function from any thread.
*
* \since This function is available since SDL 3.0.0.
*
* \sa SDL_AllocateEventMemory
* \sa SDL_AllocateTemporaryMemory
*/
extern SDL_DECLSPEC void SDLCALL SDL_FreeEventMemory(const void *mem);
extern SDL_DECLSPEC void SDLCALL SDL_FreeTemporaryMemory(const void *mem);
/* Ends C function definitions when using C++ */
#ifdef __cplusplus

6
src/SDL_internal.h
View file

@ -298,11 +298,7 @@ extern SDL_bool SDLCALL SDL_WaitEventTimeoutNS(SDL_Event *event, Sint64 timeoutN
extern const char *SDL_CreateTemporaryString(const char *string);
/* Queue `memory` to be passed to SDL_free once the event queue is emptied.
this manages the list of pointers to SDL_AllocateEventMemory, but you
can use it to queue pointers from other subsystems that can die at any
moment but definitely need to live long enough for the app to copy them
if they happened to query them in their last moments. */
/* Add memory to the temporary memory pool, to be freed automatically later */
extern void *SDL_FreeLater(void *memory);
/* Ends C function definitions when using C++ */

6
src/dynapi/SDL_dynapi.sym
View file

@ -11,7 +11,7 @@ SDL3_0.0.0 {
SDL_AddTimer;
SDL_AddTimerNS;
SDL_AddVulkanRenderSemaphores;
SDL_AllocateEventMemory;
SDL_AllocateTemporaryMemory;
SDL_AtomicAdd;
SDL_AtomicCompareAndSwap;
SDL_AtomicCompareAndSwapPointer;
@ -29,7 +29,7 @@ SDL3_0.0.0 {
SDL_BlitSurfaceUncheckedScaled;
SDL_BroadcastCondition;
SDL_CaptureMouse;
SDL_ClaimEventMemory;
SDL_ClaimTemporaryMemory;
SDL_CleanupTLS;
SDL_ClearAudioStream;
SDL_ClearClipboardData;
@ -125,7 +125,7 @@ SDL3_0.0.0 {
SDL_FlushEvent;
SDL_FlushEvents;
SDL_FlushRenderer;
SDL_FreeEventMemory;
SDL_FreeTemporaryMemory;
SDL_GDKSuspendComplete;
SDL_GL_CreateContext;
SDL_GL_DestroyContext;

6
src/dynapi/SDL_dynapi_overrides.h
View file

@ -36,7 +36,7 @@
#define SDL_AddTimer SDL_AddTimer_REAL
#define SDL_AddTimerNS SDL_AddTimerNS_REAL
#define SDL_AddVulkanRenderSemaphores SDL_AddVulkanRenderSemaphores_REAL
#define SDL_AllocateEventMemory SDL_AllocateEventMemory_REAL
#define SDL_AllocateTemporaryMemory SDL_AllocateTemporaryMemory_REAL
#define SDL_AtomicAdd SDL_AtomicAdd_REAL
#define SDL_AtomicCompareAndSwap SDL_AtomicCompareAndSwap_REAL
#define SDL_AtomicCompareAndSwapPointer SDL_AtomicCompareAndSwapPointer_REAL
@ -54,7 +54,7 @@
#define SDL_BlitSurfaceUncheckedScaled SDL_BlitSurfaceUncheckedScaled_REAL
#define SDL_BroadcastCondition SDL_BroadcastCondition_REAL
#define SDL_CaptureMouse SDL_CaptureMouse_REAL
#define SDL_ClaimEventMemory SDL_ClaimEventMemory_REAL
#define SDL_ClaimTemporaryMemory SDL_ClaimTemporaryMemory_REAL
#define SDL_CleanupTLS SDL_CleanupTLS_REAL
#define SDL_ClearAudioStream SDL_ClearAudioStream_REAL
#define SDL_ClearClipboardData SDL_ClearClipboardData_REAL
@ -150,7 +150,7 @@
#define SDL_FlushEvent SDL_FlushEvent_REAL
#define SDL_FlushEvents SDL_FlushEvents_REAL
#define SDL_FlushRenderer SDL_FlushRenderer_REAL
#define SDL_FreeEventMemory SDL_FreeEventMemory_REAL
#define SDL_FreeTemporaryMemory SDL_FreeTemporaryMemory_REAL
#define SDL_GDKSuspendComplete SDL_GDKSuspendComplete_REAL
#define SDL_GL_CreateContext SDL_GL_CreateContext_REAL
#define SDL_GL_DestroyContext SDL_GL_DestroyContext_REAL

6
src/dynapi/SDL_dynapi_procs.h
View file

@ -56,7 +56,7 @@ SDL_DYNAPI_PROC(int,SDL_AddHintCallback,(const char *a, SDL_HintCallback b, void
SDL_DYNAPI_PROC(SDL_TimerID,SDL_AddTimer,(Uint32 a, SDL_TimerCallback b, void *c),(a,b,c),return)
SDL_DYNAPI_PROC(SDL_TimerID,SDL_AddTimerNS,(Uint64 a, SDL_NSTimerCallback b, void *c),(a,b,c),return)
SDL_DYNAPI_PROC(int,SDL_AddVulkanRenderSemaphores,(SDL_Renderer *a, Uint32 b, Sint64 c, Sint64 d),(a,b,c,d),return)
SDL_DYNAPI_PROC(void*,SDL_AllocateEventMemory,(size_t a),(a),return)
SDL_DYNAPI_PROC(void*,SDL_AllocateTemporaryMemory,(size_t a),(a),return)
SDL_DYNAPI_PROC(int,SDL_AtomicAdd,(SDL_AtomicInt *a, int b),(a,b),return)
SDL_DYNAPI_PROC(SDL_bool,SDL_AtomicCompareAndSwap,(SDL_AtomicInt *a, int b, int c),(a,b,c),return)
SDL_DYNAPI_PROC(SDL_bool,SDL_AtomicCompareAndSwapPointer,(void **a, void *b, void *c),(a,b,c),return)
@ -74,7 +74,7 @@ SDL_DYNAPI_PROC(int,SDL_BlitSurfaceUnchecked,(SDL_Surface *a, const SDL_Rect *b,
SDL_DYNAPI_PROC(int,SDL_BlitSurfaceUncheckedScaled,(SDL_Surface *a, const SDL_Rect *b, SDL_Surface *c, const SDL_Rect *d, SDL_ScaleMode e),(a,b,c,d,e),return)
SDL_DYNAPI_PROC(int,SDL_BroadcastCondition,(SDL_Condition *a),(a),return)
SDL_DYNAPI_PROC(int,SDL_CaptureMouse,(SDL_bool a),(a),return)
SDL_DYNAPI_PROC(void*,SDL_ClaimEventMemory,(const void *a),(a),return)
SDL_DYNAPI_PROC(void*,SDL_ClaimTemporaryMemory,(const void *a),(a),return)
SDL_DYNAPI_PROC(void,SDL_CleanupTLS,(void),(),)
SDL_DYNAPI_PROC(int,SDL_ClearAudioStream,(SDL_AudioStream *a),(a),return)
SDL_DYNAPI_PROC(int,SDL_ClearClipboardData,(void),(),return)
@ -170,7 +170,7 @@ SDL_DYNAPI_PROC(int,SDL_FlushAudioStream,(SDL_AudioStream *a),(a),return)
SDL_DYNAPI_PROC(void,SDL_FlushEvent,(Uint32 a),(a),)
SDL_DYNAPI_PROC(void,SDL_FlushEvents,(Uint32 a, Uint32 b),(a,b),)
SDL_DYNAPI_PROC(int,SDL_FlushRenderer,(SDL_Renderer *a),(a),return)
SDL_DYNAPI_PROC(void,SDL_FreeEventMemory,(const void *a),(a),)
SDL_DYNAPI_PROC(void,SDL_FreeTemporaryMemory,(const void *a),(a),)
SDL_DYNAPI_PROC(void,SDL_GDKSuspendComplete,(void),(),)
SDL_DYNAPI_PROC(SDL_GLContext,SDL_GL_CreateContext,(SDL_Window *a),(a),return)
SDL_DYNAPI_PROC(int,SDL_GL_DestroyContext,(SDL_GLContext a),(a),return)

134
src/events/SDL_events.c
View file

@ -71,25 +71,25 @@ typedef struct
static SDL_DisabledEventBlock *SDL_disabled_events[256];
static Uint32 SDL_userevents = SDL_EVENT_USER;
typedef struct SDL_EventMemory
typedef struct SDL_TemporaryMemory
{
void *memory;
struct SDL_EventMemory *prev;
struct SDL_EventMemory *next;
} SDL_EventMemory;
struct SDL_TemporaryMemory *prev;
struct SDL_TemporaryMemory *next;
} SDL_TemporaryMemory;
typedef struct SDL_EventMemoryState
typedef struct SDL_TemporaryMemoryState
{
SDL_EventMemory *head;
SDL_EventMemory *tail;
} SDL_EventMemoryState;
SDL_TemporaryMemory *head;
SDL_TemporaryMemory *tail;
} SDL_TemporaryMemoryState;
static SDL_TLSID SDL_event_memory;
static SDL_TLSID SDL_temporary_memory;
typedef struct SDL_EventEntry
{
SDL_Event event;
SDL_EventMemory *memory;
SDL_TemporaryMemory *memory;
struct SDL_EventEntry *prev;
struct SDL_EventEntry *next;
} SDL_EventEntry;
@ -105,30 +105,30 @@ static struct
SDL_EventEntry *free;
} SDL_EventQ = { NULL, SDL_FALSE, { 0 }, 0, NULL, NULL, NULL };
static void SDL_CleanupEventMemory(void *data)
static void SDL_CleanupTemporaryMemory(void *data)
{
SDL_EventMemoryState *state = (SDL_EventMemoryState *)data;
SDL_TemporaryMemoryState *state = (SDL_TemporaryMemoryState *)data;
SDL_FreeEventMemory(NULL);
SDL_FreeTemporaryMemory(NULL);
SDL_free(state);
}
static SDL_EventMemoryState *SDL_GetEventMemoryState(SDL_bool create)
static SDL_TemporaryMemoryState *SDL_GetTemporaryMemoryState(SDL_bool create)
{
SDL_EventMemoryState *state;
SDL_TemporaryMemoryState *state;
state = SDL_GetTLS(&SDL_event_memory);
state = SDL_GetTLS(&SDL_temporary_memory);
if (!state) {
if (!create) {
return NULL;
}
state = (SDL_EventMemoryState *)SDL_calloc(1, sizeof(*state));
state = (SDL_TemporaryMemoryState *)SDL_calloc(1, sizeof(*state));
if (!state) {
return NULL;
}
if (SDL_SetTLS(&SDL_event_memory, state, SDL_CleanupEventMemory) < 0) {
if (SDL_SetTLS(&SDL_temporary_memory, state, SDL_CleanupTemporaryMemory) < 0) {
SDL_free(state);
return NULL;
}
@ -136,9 +136,9 @@ static SDL_EventMemoryState *SDL_GetEventMemoryState(SDL_bool create)
return state;
}
static SDL_EventMemory *SDL_GetEventMemoryEntry(SDL_EventMemoryState *state, const void *mem)
static SDL_TemporaryMemory *SDL_GetTemporaryMemoryEntry(SDL_TemporaryMemoryState *state, const void *mem)
{
SDL_EventMemory *entry;
SDL_TemporaryMemory *entry;
// Start from the end, it's likely to have been recently allocated
for (entry = state->tail; entry; entry = entry->prev) {
@ -149,7 +149,7 @@ static SDL_EventMemory *SDL_GetEventMemoryEntry(SDL_EventMemoryState *state, con
return NULL;
}
static void SDL_LinkEventMemoryEntry(SDL_EventMemoryState *state, SDL_EventMemory *entry)
static void SDL_LinkTemporaryMemoryEntry(SDL_TemporaryMemoryState *state, SDL_TemporaryMemory *entry)
{
entry->prev = state->tail;
entry->next = NULL;
@ -162,7 +162,7 @@ static void SDL_LinkEventMemoryEntry(SDL_EventMemoryState *state, SDL_EventMemor
state->tail = entry;
}
static void SDL_UnlinkEventMemoryEntry(SDL_EventMemoryState *state, SDL_EventMemory *entry)
static void SDL_UnlinkTemporaryMemoryEntry(SDL_TemporaryMemoryState *state, SDL_TemporaryMemory *entry)
{
if (state->head == entry) {
state->head = entry->next;
@ -182,7 +182,7 @@ static void SDL_UnlinkEventMemoryEntry(SDL_EventMemoryState *state, SDL_EventMem
entry->next = NULL;
}
static void SDL_FreeEventMemoryEntry(SDL_EventMemoryState *state, SDL_EventMemory *entry, SDL_bool free_data)
static void SDL_FreeTemporaryMemoryEntry(SDL_TemporaryMemoryState *state, SDL_TemporaryMemory *entry, SDL_bool free_data)
{
if (free_data) {
SDL_free(entry->memory);
@ -190,102 +190,102 @@ static void SDL_FreeEventMemoryEntry(SDL_EventMemoryState *state, SDL_EventMemor
SDL_free(entry);
}
static void SDL_LinkEventMemoryToEvent(SDL_EventEntry *event, const void *mem)
static void SDL_LinkTemporaryMemoryToEvent(SDL_EventEntry *event, const void *mem)
{
SDL_EventMemoryState *state;
SDL_EventMemory *entry;
SDL_TemporaryMemoryState *state;
SDL_TemporaryMemory *entry;
state = SDL_GetEventMemoryState(SDL_FALSE);
state = SDL_GetTemporaryMemoryState(SDL_FALSE);
if (!state) {
return;
}
entry = SDL_GetEventMemoryEntry(state, mem);
entry = SDL_GetTemporaryMemoryEntry(state, mem);
if (entry) {
SDL_UnlinkEventMemoryEntry(state, entry);
SDL_UnlinkTemporaryMemoryEntry(state, entry);
entry->next = event->memory;
event->memory = entry;
}
}
// Transfer the event memory from the thread-local event memory list to the event
static void SDL_TransferEventMemoryToEvent(SDL_EventEntry *event)
static void SDL_TransferTemporaryMemoryToEvent(SDL_EventEntry *event)
{
switch (event->event.type) {
case SDL_EVENT_TEXT_EDITING:
SDL_LinkEventMemoryToEvent(event, event->event.edit.text);
SDL_LinkTemporaryMemoryToEvent(event, event->event.edit.text);
break;
case SDL_EVENT_TEXT_EDITING_CANDIDATES:
SDL_LinkEventMemoryToEvent(event, event->event.edit_candidates.candidates);
SDL_LinkTemporaryMemoryToEvent(event, event->event.edit_candidates.candidates);
break;
case SDL_EVENT_TEXT_INPUT:
SDL_LinkEventMemoryToEvent(event, event->event.text.text);
SDL_LinkTemporaryMemoryToEvent(event, event->event.text.text);
break;
case SDL_EVENT_DROP_BEGIN:
case SDL_EVENT_DROP_FILE:
case SDL_EVENT_DROP_TEXT:
case SDL_EVENT_DROP_COMPLETE:
case SDL_EVENT_DROP_POSITION:
SDL_LinkEventMemoryToEvent(event, event->event.drop.source);
SDL_LinkEventMemoryToEvent(event, event->event.drop.data);
SDL_LinkTemporaryMemoryToEvent(event, event->event.drop.source);
SDL_LinkTemporaryMemoryToEvent(event, event->event.drop.data);
break;
default:
if (event->event.type >= SDL_EVENT_USER && event->event.type <= SDL_EVENT_LAST-1) {
SDL_LinkEventMemoryToEvent(event, event->event.user.data1);
SDL_LinkEventMemoryToEvent(event, event->event.user.data2);
SDL_LinkTemporaryMemoryToEvent(event, event->event.user.data1);
SDL_LinkTemporaryMemoryToEvent(event, event->event.user.data2);
}
break;
}
}
// Transfer the event memory from the event to the thread-local event memory list
static void SDL_TransferEventMemoryFromEvent(SDL_EventEntry *event)
static void SDL_TransferTemporaryMemoryFromEvent(SDL_EventEntry *event)
{
SDL_EventMemoryState *state;
SDL_EventMemory *entry, *next;
SDL_TemporaryMemoryState *state;
SDL_TemporaryMemory *entry, *next;
if (!event->memory) {
return;
}
state = SDL_GetEventMemoryState(SDL_TRUE);
state = SDL_GetTemporaryMemoryState(SDL_TRUE);
if (!state) {
return; // this is now a leak, but you probably have bigger problems if malloc failed.
}
for (entry = event->memory; entry; entry = next) {
next = entry->next;
SDL_LinkEventMemoryEntry(state, entry);
SDL_LinkTemporaryMemoryEntry(state, entry);
}
event->memory = NULL;
}
void *SDL_FreeLater(void *memory)
{
SDL_EventMemoryState *state;
SDL_TemporaryMemoryState *state;
if (memory == NULL) {
return NULL;
}
state = SDL_GetEventMemoryState(SDL_TRUE);
state = SDL_GetTemporaryMemoryState(SDL_TRUE);
if (!state) {
return memory; // this is now a leak, but you probably have bigger problems if malloc failed.
}
SDL_EventMemory *entry = (SDL_EventMemory *)SDL_malloc(sizeof(*entry));
SDL_TemporaryMemory *entry = (SDL_TemporaryMemory *)SDL_malloc(sizeof(*entry));
if (!entry) {
return memory; // this is now a leak, but you probably have bigger problems if malloc failed. We could probably pool up and reuse entries, though.
}
entry->memory = memory;
SDL_LinkEventMemoryEntry(state, entry);
SDL_LinkTemporaryMemoryEntry(state, entry);
return memory;
}
void *SDL_AllocateEventMemory(size_t size)
void *SDL_AllocateTemporaryMemory(size_t size)
{
return SDL_FreeLater(SDL_malloc(size));
}
@ -298,43 +298,43 @@ const char *SDL_CreateTemporaryString(const char *string)
return NULL;
}
void *SDL_ClaimEventMemory(const void *mem)
void *SDL_ClaimTemporaryMemory(const void *mem)
{
SDL_EventMemoryState *state;
SDL_TemporaryMemoryState *state;
state = SDL_GetEventMemoryState(SDL_FALSE);
state = SDL_GetTemporaryMemoryState(SDL_FALSE);
if (state && mem) {
SDL_EventMemory *entry = SDL_GetEventMemoryEntry(state, mem);
SDL_TemporaryMemory *entry = SDL_GetTemporaryMemoryEntry(state, mem);
if (entry) {
SDL_UnlinkEventMemoryEntry(state, entry);
SDL_FreeEventMemoryEntry(state, entry, SDL_FALSE);
SDL_UnlinkTemporaryMemoryEntry(state, entry);
SDL_FreeTemporaryMemoryEntry(state, entry, SDL_FALSE);
return (void *)mem;
}
}
return NULL;
}
void SDL_FreeEventMemory(const void *mem)
void SDL_FreeTemporaryMemory(const void *mem)
{
SDL_EventMemoryState *state;
SDL_TemporaryMemoryState *state;
state = SDL_GetEventMemoryState(SDL_FALSE);
state = SDL_GetTemporaryMemoryState(SDL_FALSE);
if (!state) {
return;
}
if (mem) {
SDL_EventMemory *entry = SDL_GetEventMemoryEntry(state, mem);
SDL_TemporaryMemory *entry = SDL_GetTemporaryMemoryEntry(state, mem);
if (entry) {
SDL_UnlinkEventMemoryEntry(state, entry);
SDL_FreeEventMemoryEntry(state, entry, SDL_TRUE);
SDL_UnlinkTemporaryMemoryEntry(state, entry);
SDL_FreeTemporaryMemoryEntry(state, entry, SDL_TRUE);
}
} else {
while (state->head) {
SDL_EventMemory *entry = state->head;
SDL_TemporaryMemory *entry = state->head;
SDL_UnlinkEventMemoryEntry(state, entry);
SDL_FreeEventMemoryEntry(state, entry, SDL_TRUE);
SDL_UnlinkTemporaryMemoryEntry(state, entry);
SDL_FreeTemporaryMemoryEntry(state, entry, SDL_TRUE);
}
}
}
@ -842,7 +842,7 @@ void SDL_StopEventLoop(void)
/* Clean out EventQ */
for (entry = SDL_EventQ.head; entry;) {
SDL_EventEntry *next = entry->next;
SDL_TransferEventMemoryFromEvent(entry);
SDL_TransferTemporaryMemoryFromEvent(entry);
SDL_free(entry);
entry = next;
}
@ -859,7 +859,7 @@ void SDL_StopEventLoop(void)
SDL_EventQ.free = NULL;
SDL_AtomicSet(&SDL_sentinel_pending, 0);
SDL_FreeEventMemory(NULL);
SDL_FreeTemporaryMemory(NULL);
/* Clear disabled event state */
for (i = 0; i < SDL_arraysize(SDL_disabled_events); ++i) {
@ -950,7 +950,7 @@ static int SDL_AddEvent(SDL_Event *event)
SDL_AtomicAdd(&SDL_sentinel_pending, 1);
}
entry->memory = NULL;
SDL_TransferEventMemoryToEvent(entry);
SDL_TransferTemporaryMemoryToEvent(entry);
if (SDL_EventQ.tail) {
SDL_EventQ.tail->next = entry;
@ -978,7 +978,7 @@ static int SDL_AddEvent(SDL_Event *event)
/* Remove an event from the queue -- called with the queue locked */
static void SDL_CutEvent(SDL_EventEntry *entry)
{
SDL_TransferEventMemoryFromEvent(entry);
SDL_TransferTemporaryMemoryFromEvent(entry);
if (entry->prev) {
entry->prev->next = entry->next;
@ -1156,7 +1156,7 @@ static void SDL_PumpEventsInternal(SDL_bool push_sentinel)
SDL_VideoDevice *_this = SDL_GetVideoDevice();
/* Free old event memory */
SDL_FreeEventMemory(NULL);
SDL_FreeTemporaryMemory(NULL);
/* Release any keys held down from last frame */
SDL_ReleaseAutoReleaseKeys();

2
src/events/SDL_keyboard.c
View file

@ -778,7 +778,7 @@ int SDL_SendEditingTextCandidates(char **candidates, int num_candidates, int sel
event.common.timestamp = 0;
event.edit.windowID = keyboard->focus ? keyboard->focus->id : 0;
if (num_candidates > 0) {
const char **event_candidates = (const char **)SDL_AllocateEventMemory((num_candidates + 1) * sizeof(*event_candidates));
const char **event_candidates = (const char **)SDL_AllocateTemporaryMemory((num_candidates + 1) * sizeof(*event_candidates));
if (!event_candidates) {
return 0;
}

2
src/joystick/SDL_gamepad.c
View file

@ -2400,7 +2400,7 @@ const SDL_JoystickID *SDL_GetGamepads(int *count)
{
int num_joysticks = 0;
int num_gamepads = 0;
SDL_JoystickID *joysticks = SDL_ClaimEventMemory(SDL_GetJoysticks(&num_joysticks));
SDL_JoystickID *joysticks = SDL_ClaimTemporaryMemory(SDL_GetJoysticks(&num_joysticks));
if (joysticks) {
int i;
for (i = num_joysticks - 1; i >= 0; --i) {

54
test/testautomation_events.c
View file

@ -178,7 +178,7 @@ static int events_addDelEventWatchWithUserdata(void *arg)
/**
* Creates and validates temporary event memory
*/
static int events_eventMemory(void *arg)
static int events_temporaryMemory(void *arg)
{
SDL_Event event;
void *mem, *claimed, *tmp;
@ -186,20 +186,20 @@ static int events_eventMemory(void *arg)
{
/* Create and claim event memory */
mem = SDL_AllocateEventMemory(1);
SDLTest_AssertCheck(mem != NULL, "SDL_AllocateEventMemory()");
mem = SDL_AllocateTemporaryMemory(1);
SDLTest_AssertCheck(mem != NULL, "SDL_AllocateTemporaryMemory()");
*(char *)mem = '1';
claimed = SDL_ClaimEventMemory(mem);
SDLTest_AssertCheck(claimed != NULL, "SDL_ClaimEventMemory() returned a valid pointer");
claimed = SDL_ClaimTemporaryMemory(mem);
SDLTest_AssertCheck(claimed != NULL, "SDL_ClaimTemporaryMemory() returned a valid pointer");
/* Verify that we can't claim it again */
tmp = SDL_ClaimEventMemory(mem);
SDLTest_AssertCheck(tmp == NULL, "SDL_ClaimEventMemory() can't claim memory twice");
tmp = SDL_ClaimTemporaryMemory(mem);
SDLTest_AssertCheck(tmp == NULL, "SDL_ClaimTemporaryMemory() can't claim memory twice");
/* Verify that freeing the original pointer does nothing */
SDL_FreeEventMemory(mem);
SDLTest_AssertCheck(*(char *)mem == '1', "SDL_FreeEventMemory() on claimed memory has no effect");
SDL_FreeTemporaryMemory(mem);
SDLTest_AssertCheck(*(char *)mem == '1', "SDL_FreeTemporaryMemory() on claimed memory has no effect");
/* Clean up */
SDL_free(claimed);
@ -207,19 +207,19 @@ static int events_eventMemory(void *arg)
{
/* Create and free event memory */
mem = SDL_AllocateEventMemory(1);
SDLTest_AssertCheck(mem != NULL, "SDL_AllocateEventMemory()");
mem = SDL_AllocateTemporaryMemory(1);
SDLTest_AssertCheck(mem != NULL, "SDL_AllocateTemporaryMemory()");
*(char *)mem = '1';
SDL_FreeEventMemory(mem);
claimed = SDL_ClaimEventMemory(mem);
SDLTest_AssertCheck(claimed == NULL, "SDL_ClaimEventMemory() can't claim memory after it's been freed");
SDL_FreeTemporaryMemory(mem);
claimed = SDL_ClaimTemporaryMemory(mem);
SDLTest_AssertCheck(claimed == NULL, "SDL_ClaimTemporaryMemory() can't claim memory after it's been freed");
}
{
/* Create event memory and queue it */
mem = SDL_AllocateEventMemory(1);
SDLTest_AssertCheck(mem != NULL, "SDL_AllocateEventMemory()");
mem = SDL_AllocateTemporaryMemory(1);
SDLTest_AssertCheck(mem != NULL, "SDL_AllocateTemporaryMemory()");
*(char *)mem = '2';
SDL_zero(event);
@ -228,8 +228,8 @@ static int events_eventMemory(void *arg)
SDL_PushEvent(&event);
/* Verify that we can't claim the memory once it's on the queue */
claimed = SDL_ClaimEventMemory(mem);
SDLTest_AssertCheck(claimed == NULL, "SDL_ClaimEventMemory() can't claim memory on the event queue");
claimed = SDL_ClaimTemporaryMemory(mem);
SDLTest_AssertCheck(claimed == NULL, "SDL_ClaimTemporaryMemory() can't claim memory on the event queue");
/* Get the event and verify the memory is valid */
found = SDL_FALSE;
@ -241,8 +241,8 @@ static int events_eventMemory(void *arg)
SDLTest_AssertCheck(found, "SDL_PollEvent() returned queued event");
/* Verify that we can claim the memory now that we've dequeued it */
claimed = SDL_ClaimEventMemory(mem);
SDLTest_AssertCheck(claimed != NULL, "SDL_ClaimEventMemory() can claim memory after dequeuing event");
claimed = SDL_ClaimTemporaryMemory(mem);
SDLTest_AssertCheck(claimed != NULL, "SDL_ClaimTemporaryMemory() can claim memory after dequeuing event");
/* Clean up */
SDL_free(claimed);
@ -250,8 +250,8 @@ static int events_eventMemory(void *arg)
{
/* Create event memory and queue it */
mem = SDL_AllocateEventMemory(1);
SDLTest_AssertCheck(mem != NULL, "SDL_AllocateEventMemory()");
mem = SDL_AllocateTemporaryMemory(1);
SDLTest_AssertCheck(mem != NULL, "SDL_AllocateTemporaryMemory()");
*(char *)mem = '3';
SDL_zero(event);
@ -270,8 +270,8 @@ static int events_eventMemory(void *arg)
/* Verify that pumping the event loop frees event memory */
SDL_PumpEvents();
claimed = SDL_ClaimEventMemory(mem);
SDLTest_AssertCheck(claimed == NULL, "SDL_ClaimEventMemory() can't claim memory after pumping the event loop");
claimed = SDL_ClaimTemporaryMemory(mem);
SDLTest_AssertCheck(claimed == NULL, "SDL_ClaimTemporaryMemory() can't claim memory after pumping the event loop");
}
return TEST_COMPLETED;
@ -292,13 +292,13 @@ static const SDLTest_TestCaseReference eventsTest3 = {
(SDLTest_TestCaseFp)events_addDelEventWatchWithUserdata, "events_addDelEventWatchWithUserdata", "Adds and deletes an event watch function with userdata", TEST_ENABLED
};
static const SDLTest_TestCaseReference eventsTestEventMemory = {
(SDLTest_TestCaseFp)events_eventMemory, "events_eventMemory", "Creates and validates temporary event memory", TEST_ENABLED
static const SDLTest_TestCaseReference eventsTestTemporaryMemory = {
(SDLTest_TestCaseFp)events_temporaryMemory, "events_temporaryMemory", "Creates and validates temporary event memory", TEST_ENABLED
};
/* Sequence of Events test cases */
static const SDLTest_TestCaseReference *eventsTests[] = {
&eventsTest1, &eventsTest2, &eventsTest3, &eventsTestEventMemory, NULL
&eventsTest1, &eventsTest2, &eventsTest3, &eventsTestTemporaryMemory, NULL
};
/* Events test suite (global) */