From fd9fe1bb7b3f3c4e13b1bc42e7a5e77cead6c9a0 Mon Sep 17 00:00:00 2001
From: Sam Lantinga <[EMAIL REDACTED]>
Date: Fri, 19 Jul 2024 09:50:25 -0700
Subject: [PATCH] Renamed event memory to temporary memory, since it's not just
used for events
---
include/SDL3/SDL_events.h | 33 ++++----
src/SDL_internal.h | 6 +-
src/dynapi/SDL_dynapi.sym | 6 +-
src/dynapi/SDL_dynapi_overrides.h | 6 +-
src/dynapi/SDL_dynapi_procs.h | 6 +-
src/events/SDL_events.c | 134 +++++++++++++++---------------
src/events/SDL_keyboard.c | 2 +-
src/joystick/SDL_gamepad.c | 2 +-
test/testautomation_events.c | 54 ++++++------
9 files changed, 121 insertions(+), 128 deletions(-)
diff --git a/include/SDL3/SDL_events.h b/include/SDL3/SDL_events.h
index 63958e7e441bb..2ee69991d5c0a 100644
--- a/include/SDL3/SDL_events.h
+++ b/include/SDL3/SDL_events.h
@@ -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
diff --git a/src/SDL_internal.h b/src/SDL_internal.h
index fe70c124ba688..4909e55244ec8 100644
--- a/src/SDL_internal.h
+++ b/src/SDL_internal.h
@@ -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++ */
diff --git a/src/dynapi/SDL_dynapi.sym b/src/dynapi/SDL_dynapi.sym
index 1a8ccd51983c3..939a6ad64fe8b 100644
--- a/src/dynapi/SDL_dynapi.sym
+++ b/src/dynapi/SDL_dynapi.sym
@@ -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;
diff --git a/src/dynapi/SDL_dynapi_overrides.h b/src/dynapi/SDL_dynapi_overrides.h
index 4383671940e30..1a8063b877431 100644
--- a/src/dynapi/SDL_dynapi_overrides.h
+++ b/src/dynapi/SDL_dynapi_overrides.h
@@ -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
diff --git a/src/dynapi/SDL_dynapi_procs.h b/src/dynapi/SDL_dynapi_procs.h
index 651e8a4089843..9fdf202d785f7 100644
--- a/src/dynapi/SDL_dynapi_procs.h
+++ b/src/dynapi/SDL_dynapi_procs.h
@@ -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)
diff --git a/src/events/SDL_events.c b/src/events/SDL_events.c
index ff08db8d85ab2..9f7c70cfda3e9 100644
--- a/src/events/SDL_events.c
+++ b/src/events/SDL_events.c
@@ -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();
diff --git a/src/events/SDL_keyboard.c b/src/events/SDL_keyboard.c
index 1a426e0131c44..e7fbd070c9ad2 100644
--- a/src/events/SDL_keyboard.c
+++ b/src/events/SDL_keyboard.c
@@ -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;
}
diff --git a/src/joystick/SDL_gamepad.c b/src/joystick/SDL_gamepad.c
index 0e4c42b081e4b..5d023396aa25c 100644
--- a/src/joystick/SDL_gamepad.c
+++ b/src/joystick/SDL_gamepad.c
@@ -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) {
diff --git a/test/testautomation_events.c b/test/testautomation_events.c
index 77d1770455e57..708289941a169 100644
--- a/test/testautomation_events.c
+++ b/test/testautomation_events.c
@@ -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) */