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

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

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++ */

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;

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

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)

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();

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;
             }

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) {

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) */