From fd9fe1bb7b3f3c4e13b1bc42e7a5e77cead6c9a0 Mon Sep 17 00:00:00 2001 From: Sam Lantinga 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 63958e7e44..2ee69991d5 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 fe70c124ba..4909e55244 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 1a8ccd5198..939a6ad64f 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 4383671940..1a8063b877 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 651e8a4089..9fdf202d78 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 ff08db8d85..9f7c70cfda 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 1a426e0131..e7fbd070c9 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 0e4c42b081..5d023396aa 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 77d1770455..708289941a 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) */