sdl-ios-xcode: src/video/SDL_video.c comparison

comparison src/video/SDL_video.c @ 3695:f6a8be3fefa0

Added magic to detect already freed or otherwise invalid windows and textures.

author	Sam Lantinga <slouken@libsdl.org>
date	Sun, 24 Jan 2010 20:21:51 +0000
parents	b0a707f589a6
children	f7b03b6838cb

comparison

equal deleted inserted replaced

-:b0a707f589a6
+:f6a8be3fefa0
 NULL
 };
 static SDL_VideoDevice *_this = NULL;
+#define CHECK_WINDOW_MAGIC(window, retval) \
+if (!_this) { \
+SDL_UninitializedVideo(); \
+return retval; \
+} \
+	if (!window || window->magic != &_this->window_magic) { \
+SDL_SetError("Invalid window"); \
+return retval; \
+}
+#define CHECK_TEXTURE_MAGIC(texture, retval) \
+if (!_this) { \
+SDL_UninitializedVideo(); \
+return retval; \
+} \
+	if (!texture || texture->magic != &_this->texture_magic) { \
+SDL_SetError("Invalid texture"); \
+return retval; \
+}
 /* Various local functions */
 static void SDL_UpdateWindowGrab(SDL_Window * window);
 static int
 cmpmodes(const void *A, const void *B)
 }
 int
 SDL_SetWindowDisplayMode(SDL_Window * window, const SDL_DisplayMode * mode)
 {
-if (!window) {
+CHECK_WINDOW_MAGIC(window, -1);
-return -1;
-}
 if (mode) {
 window->fullscreen_mode = *mode;
 } else {
 SDL_zero(window->fullscreen_mode);
 int
 SDL_GetWindowDisplayMode(SDL_Window * window, SDL_DisplayMode * mode)
 {
 SDL_DisplayMode fullscreen_mode;
-if (!window) {
+CHECK_WINDOW_MAGIC(window, -1);
-return -1;
-}
 fullscreen_mode = window->fullscreen_mode;
 if (!fullscreen_mode.w) {
 fullscreen_mode.w = window->w;
 }
 }
 SDL_GL_LoadLibrary(NULL);
 }
 display = SDL_CurrentDisplay;
 window = (SDL_Window *)SDL_calloc(1, sizeof(*window));
+window->magic = &_this->window_magic;
 window->id = _this->next_object_id++;
 window->x = x;
 window->y = y;
 window->w = w;
 window->h = h;
 SDL_UninitializedVideo();
 return NULL;
 }
 display = SDL_CurrentDisplay;
 window = (SDL_Window *)SDL_calloc(1, sizeof(*window));
+window->magic = &_this->window_magic;
 window->id = _this->next_object_id++;
 window->flags = SDL_WINDOW_FOREIGN;
 window->display = display;
 window->next = display->windows;
 if (display->windows) {
 }
 Uint32
 SDL_GetWindowID(SDL_Window * window)
 {
-if (!window) {
+CHECK_WINDOW_MAGIC(window, 0);
-return 0;
-}
 return window->id;
 }
 SDL_Window *
 SDL_GetWindowFromID(Uint32 id)
 }
 Uint32
 SDL_GetWindowFlags(SDL_Window * window)
 {
-if (!window) {
+CHECK_WINDOW_MAGIC(window, 0);
-return 0;
-}
 return window->flags;
 }
 void
 SDL_SetWindowTitle(SDL_Window * window, const char *title)
 {
-if (!window || title == window->title) {
+CHECK_WINDOW_MAGIC(window, );
+if (title == window->title) {
 return;
 }
 if (window->title) {
 SDL_free(window->title);
 }
 }
 const char *
 SDL_GetWindowTitle(SDL_Window * window)
 {
-if (!window) {
+CHECK_WINDOW_MAGIC(window, NULL);
-return NULL;
-}
 return window->title;
 }
 void
 SDL_SetWindowIcon(SDL_Window * window, SDL_Surface * icon)
 {
-if (!window) {
+CHECK_WINDOW_MAGIC(window, );
-return;
-}
 if (_this->SetWindowIcon) {
 _this->SetWindowIcon(_this, window, icon);
 }
 }
 void
 SDL_SetWindowData(SDL_Window * window, void *userdata)
 {
-if (!window) {
+CHECK_WINDOW_MAGIC(window, );
-return;
-}
 window->userdata = userdata;
 }
 void *
 SDL_GetWindowData(SDL_Window * window)
 {
-if (!window) {
+CHECK_WINDOW_MAGIC(window, NULL);
-return NULL;
-}
 return window->userdata;
 }
 void
 SDL_SetWindowPosition(SDL_Window * window, int x, int y)
 {
-if (!window) {
+CHECK_WINDOW_MAGIC(window, );
-return;
-}
 if (x != SDL_WINDOWPOS_UNDEFINED) {
 window->x = x;
 }
 if (y != SDL_WINDOWPOS_UNDEFINED) {
 window->y = y;
 }
 void
 SDL_GetWindowPosition(SDL_Window * window, int *x, int *y)
 {
-if (!window) {
+CHECK_WINDOW_MAGIC(window, );
-return;
-}
 if (x) {
 *x = window->x;
 }
 if (y) {
 *y = window->y;
 }
 void
 SDL_SetWindowSize(SDL_Window * window, int w, int h)
 {
-if (!window) {
+CHECK_WINDOW_MAGIC(window, );
-return;
-}
 window->w = w;
 window->h = h;
 if (_this->SetWindowSize) {
 _this->SetWindowSize(_this, window);
 }
 void
 SDL_ShowWindow(SDL_Window * window)
 {
-if (!window || (window->flags & SDL_WINDOW_SHOWN)) {
+CHECK_WINDOW_MAGIC(window, );
+if (window->flags & SDL_WINDOW_SHOWN) {
 return;
 }
 if (_this->ShowWindow) {
 _this->ShowWindow(_this, window);
 }
 void
 SDL_HideWindow(SDL_Window * window)
 {
-if (!window || !(window->flags & SDL_WINDOW_SHOWN)) {
+CHECK_WINDOW_MAGIC(window, );
+if (!(window->flags & SDL_WINDOW_SHOWN)) {
 return;
 }
 if (_this->HideWindow) {
 _this->HideWindow(_this, window);
 }
 void
 SDL_RaiseWindow(SDL_Window * window)
 {
-if (!window || !(window->flags & SDL_WINDOW_SHOWN)) {
+CHECK_WINDOW_MAGIC(window, );
+if (!(window->flags & SDL_WINDOW_SHOWN)) {
 return;
 }
 if (_this->RaiseWindow) {
 _this->RaiseWindow(_this, window);
 } else {
 }
 void
 SDL_MaximizeWindow(SDL_Window * window)
 {
-if (!window || (window->flags & SDL_WINDOW_MAXIMIZED)) {
+CHECK_WINDOW_MAGIC(window, );
+if (window->flags & SDL_WINDOW_MAXIMIZED) {
 return;
 }
 if (_this->MaximizeWindow) {
 _this->MaximizeWindow(_this, window);
 }
 void
 SDL_MinimizeWindow(SDL_Window * window)
 {
-if (!window || (window->flags & SDL_WINDOW_MINIMIZED)) {
+CHECK_WINDOW_MAGIC(window, );
+if (window->flags & SDL_WINDOW_MINIMIZED) {
 return;
 }
 if (_this->MinimizeWindow) {
 _this->MinimizeWindow(_this, window);
 }
 void
 SDL_RestoreWindow(SDL_Window * window)
 {
-if (!window
+CHECK_WINDOW_MAGIC(window, );
-|| !(window->flags & (SDL_WINDOW_MAXIMIZED | SDL_WINDOW_MINIMIZED))) {
+if (!(window->flags & (SDL_WINDOW_MAXIMIZED | SDL_WINDOW_MINIMIZED))) {
 return;
 }
 if (_this->RestoreWindow) {
 _this->RestoreWindow(_this, window);
 }
 int
 SDL_SetWindowFullscreen(SDL_Window * window, int fullscreen)
 {
-if (!window) {
+CHECK_WINDOW_MAGIC(window, -1);
-return -1;
-}
 if (fullscreen) {
 fullscreen = SDL_WINDOW_FULLSCREEN;
 }
 if ((window->flags & SDL_WINDOW_FULLSCREEN) == fullscreen) {
 return 0;
 }
 void
 SDL_SetWindowGrab(SDL_Window * window, int mode)
 {
-if (!window || (!!mode == !!(window->flags & SDL_WINDOW_INPUT_GRABBED))) {
+CHECK_WINDOW_MAGIC(window, );
+if ((!!mode == !!(window->flags & SDL_WINDOW_INPUT_GRABBED))) {
 return;
 }
 if (mode) {
 window->flags |= SDL_WINDOW_INPUT_GRABBED;
 } else {
 }
 int
 SDL_GetWindowGrab(SDL_Window * window)
 {
-if (!window) {
+CHECK_WINDOW_MAGIC(window, 0);
-return 0;
-}
 return ((window->flags & SDL_WINDOW_INPUT_GRABBED) != 0);
 }
 void
 SDL_OnWindowShown(SDL_Window * window)
 void
 SDL_DestroyWindow(SDL_Window * window)
 {
 SDL_VideoDisplay *display;
-if (!_this || !window || !window->id) {
+CHECK_WINDOW_MAGIC(window, );
-SDL_SetError("Invalid window");
+window->magic = NULL;
-return;
-}
 if (window->title) {
 SDL_free(window->title);
 }
 if (window->renderer) {
 if (window->prev) {
 window->prev->next = window->next;
 } else {
 display->windows = window->next;
 }
-/* Clear the ID so we know it was destroyed */
-window->id = 0;
 SDL_free(window);
 }
 void
 }
 int
 SDL_CreateRenderer(SDL_Window * window, int index, Uint32 flags)
 {
-if (!window) {
+CHECK_WINDOW_MAGIC(window, -1);
-SDL_SetError("Invalid window");
-return -1;
-}
 /* Free any existing renderer */
 SDL_DestroyRenderer(window);
 if (index < 0) {
 int
 SDL_SelectRenderer(SDL_Window * window)
 {
 SDL_Renderer *renderer;
-if (!window) {
+CHECK_WINDOW_MAGIC(window, -1);
-SDL_SetError("Invalid window");
-return -1;
-}
 renderer = window->renderer;
 if (!renderer) {
 SDL_SetError("Use SDL_CreateRenderer() to create a renderer");
 return -1;
 }
 texture = (SDL_Texture *) SDL_calloc(1, sizeof(*texture));
 if (!texture) {
 SDL_OutOfMemory();
 return 0;
 }
+texture->magic = &_this->texture_magic;
 texture->format = format;
 texture->access = access;
 texture->w = w;
 texture->h = h;
 texture->r = 255;
 int
 SDL_QueryTexture(SDL_Texture * texture, Uint32 * format, int *access,
 int *w, int *h)
 {
-if (!texture) {
+CHECK_TEXTURE_MAGIC(texture, -1);
-return -1;
-}
 if (format) {
 *format = texture->format;
 }
 if (access) {
 *access = texture->access;
 int
 SDL_QueryTexturePixels(SDL_Texture * texture, void **pixels, int *pitch)
 {
 SDL_Renderer *renderer;
-if (!texture) {
+CHECK_TEXTURE_MAGIC(texture, -1);
-return -1;
-}
 renderer = texture->renderer;
 if (!renderer->QueryTexturePixels) {
 SDL_Unsupported();
 return -1;
 }
 SDL_SetTexturePalette(SDL_Texture * texture, const SDL_Color * colors,
 int firstcolor, int ncolors)
 {
 SDL_Renderer *renderer;
-if (!texture) {
+CHECK_TEXTURE_MAGIC(texture, -1);
-return -1;
-}
 renderer = texture->renderer;
 if (!renderer->SetTexturePalette) {
 SDL_Unsupported();
 return -1;
 }
 SDL_GetTexturePalette(SDL_Texture * texture, SDL_Color * colors,
 int firstcolor, int ncolors)
 {
 SDL_Renderer *renderer;
-if (!texture) {
+CHECK_TEXTURE_MAGIC(texture, -1);
-return -1;
-}
 renderer = texture->renderer;
 if (!renderer->GetTexturePalette) {
 SDL_Unsupported();
 return -1;
 }
 int
 SDL_SetTextureColorMod(SDL_Texture * texture, Uint8 r, Uint8 g, Uint8 b)
 {
 SDL_Renderer *renderer;
-if (!texture) {
+CHECK_TEXTURE_MAGIC(texture, -1);
-return -1;
-}
 renderer = texture->renderer;
 if (!renderer->SetTextureColorMod) {
 SDL_Unsupported();
 return -1;
 }
 SDL_GetTextureColorMod(SDL_Texture * texture, Uint8 * r, Uint8 * g,
 Uint8 * b)
 {
 SDL_Renderer *renderer;
-if (!texture) {
+CHECK_TEXTURE_MAGIC(texture, -1);
-return -1;
-}
 renderer = texture->renderer;
 if (r) {
 *r = texture->r;
 }
 if (g) {
 int
 SDL_SetTextureAlphaMod(SDL_Texture * texture, Uint8 alpha)
 {
 SDL_Renderer *renderer;
-if (!texture) {
+CHECK_TEXTURE_MAGIC(texture, -1);
-return -1;
-}
 renderer = texture->renderer;
 if (!renderer->SetTextureAlphaMod) {
 SDL_Unsupported();
 return -1;
 }
 }
 int
 SDL_GetTextureAlphaMod(SDL_Texture * texture, Uint8 * alpha)
 {
-if (!texture) {
+CHECK_TEXTURE_MAGIC(texture, -1);
-return -1;
-}
 if (alpha) {
 *alpha = texture->a;
 }
 return 0;
 }
 int
 SDL_SetTextureBlendMode(SDL_Texture * texture, int blendMode)
 {
 SDL_Renderer *renderer;
-if (!texture) {
+CHECK_TEXTURE_MAGIC(texture, -1);
-return -1;
-}
 renderer = texture->renderer;
 if (!renderer->SetTextureBlendMode) {
 SDL_Unsupported();
 return -1;
 }
 }
 int
 SDL_GetTextureBlendMode(SDL_Texture * texture, int *blendMode)
 {
-if (!texture) {
+CHECK_TEXTURE_MAGIC(texture, -1);
-return -1;
-}
 if (blendMode) {
 *blendMode = texture->blendMode;
 }
 return 0;
 }
 int
 SDL_SetTextureScaleMode(SDL_Texture * texture, int scaleMode)
 {
 SDL_Renderer *renderer;
-if (!texture) {
+CHECK_TEXTURE_MAGIC(texture, -1);
-return -1;
-}
 renderer = texture->renderer;
 if (!renderer->SetTextureScaleMode) {
 SDL_Unsupported();
 return -1;
 }
 }
 int
 SDL_GetTextureScaleMode(SDL_Texture * texture, int *scaleMode)
 {
-if (!texture) {
+CHECK_TEXTURE_MAGIC(texture, -1);
-return -1;
-}
 if (scaleMode) {
 *scaleMode = texture->scaleMode;
 }
 return 0;
 }
 const void *pixels, int pitch)
 {
 SDL_Renderer *renderer;
 SDL_Rect full_rect;
-if (!texture) {
+CHECK_TEXTURE_MAGIC(texture, -1);
-return -1;
-}
 renderer = texture->renderer;
 if (!renderer->UpdateTexture) {
 SDL_Unsupported();
 return -1;
 }
 void **pixels, int *pitch)
 {
 SDL_Renderer *renderer;
 SDL_Rect full_rect;
-if (!texture) {
+CHECK_TEXTURE_MAGIC(texture, -1);
-return -1;
-}
 if (texture->access != SDL_TEXTUREACCESS_STREAMING) {
 SDL_SetError("SDL_LockTexture(): texture must be streaming");
 return -1;
 }
 renderer = texture->renderer;
 void
 SDL_UnlockTexture(SDL_Texture * texture)
 {
 SDL_Renderer *renderer;
-if (!texture) {
+CHECK_TEXTURE_MAGIC(texture, );
-return;
-}
 if (texture->access != SDL_TEXTUREACCESS_STREAMING) {
 return;
 }
 renderer = texture->renderer;
 if (!renderer->UnlockTexture) {
 SDL_DirtyTexture(SDL_Texture * texture, int numrects,
 const SDL_Rect * rects)
 {
 SDL_Renderer *renderer;
-if (!texture) {
+CHECK_TEXTURE_MAGIC(texture, );
-return;
-}
 if (texture->access != SDL_TEXTUREACCESS_STREAMING) {
 return;
 }
 renderer = texture->renderer;
 if (!renderer->DirtyTexture) {
 SDL_Renderer *renderer;
 SDL_Window *window;
 SDL_Rect real_srcrect;
 SDL_Rect real_dstrect;
+CHECK_TEXTURE_MAGIC(texture, -1);
 renderer = SDL_GetCurrentRenderer(SDL_TRUE);
 if (!renderer) {
-return -1;
-}
-if (!texture) {
-SDL_SetError("Texture not found");
 return -1;
 }
 if (texture->renderer != renderer) {
 SDL_SetError("Texture was not created with this renderer");
 return -1;
 void
 SDL_DestroyTexture(SDL_Texture * texture)
 {
 SDL_Renderer *renderer;
-if (!texture || !texture->renderer) {
+CHECK_TEXTURE_MAGIC(texture, );
-SDL_SetError("Invalid texture");
+texture->magic = NULL;
-return;
-}
 renderer = texture->renderer;
 if (texture->next) {
 texture->next->prev = texture->prev;
 }
 if (texture->prev) {
 texture->prev->next = texture->next;
 } else {
 renderer->textures = texture->next;
 }
-texture->renderer = NULL;
 renderer->DestroyTexture(renderer, texture);
 SDL_free(texture);
 }
 void
 SDL_DestroyRenderer(SDL_Window * window)
 {
 SDL_Renderer *renderer;
-if (!window) {
+CHECK_WINDOW_MAGIC(window, );
-return;
-}
 renderer = window->renderer;
 if (!renderer) {
 return;
 }
 }
 SDL_GLContext
 SDL_GL_CreateContext(SDL_Window * window)
 {
-if (!window) {
+CHECK_WINDOW_MAGIC(window, NULL);
-return NULL;
-}
 if (!(window->flags & SDL_WINDOW_OPENGL)) {
 SDL_SetError("The specified window isn't an OpenGL window");
 return NULL;
 }
 return _this->GL_CreateContext(_this, window);
 }
 int
 SDL_GL_MakeCurrent(SDL_Window * window, SDL_GLContext context)
 {
-if (window && !(window->flags & SDL_WINDOW_OPENGL)) {
+CHECK_WINDOW_MAGIC(window, -1);
+if (!(window->flags & SDL_WINDOW_OPENGL)) {
 SDL_SetError("The specified window isn't an OpenGL window");
 return -1;
 }
 if (!context) {
 window = NULL;
 }
 void
 SDL_GL_SwapWindow(SDL_Window * window)
 {
-if (!window) {
+CHECK_WINDOW_MAGIC(window, );
-return;
-}
 if (!(window->flags & SDL_WINDOW_OPENGL)) {
 SDL_SetError("The specified window isn't an OpenGL window");
 return;
 }
 _this->GL_SwapWindow(_this, window);
 #endif
 SDL_bool
 SDL_GetWindowWMInfo(SDL_Window * window, struct SDL_SysWMinfo *info)
 {
-if (!window || !_this->GetWindowWMInfo) {
+CHECK_WINDOW_MAGIC(window, SDL_FALSE);
+if (!_this->GetWindowWMInfo) {
 return SDL_FALSE;
 }
 return (_this->GetWindowWMInfo(_this, window, info));
 }

Mercurial > sdl-ios-xcode

comparison src/video/SDL_video.c @ 3695:f6a8be3fefa0