This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_assert.c
475 lines (401 loc) · 13.4 KB
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2010 Sam Lantinga
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL.h"
24
#include "SDL_assert.h"
25
#include "video/SDL_sysvideo.h"
26
27
28
29
30
31
32
#ifdef _WINDOWS
#define WIN32_LEAN_AND_MEAN 1
#include <windows.h>
#else /* fprintf, _exit(), etc. */
#include <stdio.h>
#include <stdlib.h>
33
#include <unistd.h>
34
35
#endif
36
37
38
39
40
static SDL_assert_state
SDL_PromptAssertion(const SDL_assert_data *data, void *userdata);
/*
* We keep all triggered assertions in a singly-linked list so we can
41
42
43
44
* generate a report later.
*/
static SDL_assert_data assertion_list_terminator = { 0, 0, 0, 0, 0, 0, 0 };
static SDL_assert_data *triggered_assertions = &assertion_list_terminator;
45
46
47
48
static SDL_mutex *assertion_mutex = NULL;
static SDL_AssertionHandler assertion_handler = SDL_PromptAssertion;
static void *assertion_userdata = NULL;
49
50
#ifdef __GNUC__
51
52
static void
debug_print(const char *fmt, ...) __attribute__((format (printf, 1, 2)));
53
54
55
56
#endif
static void
debug_print(const char *fmt, ...)
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
{
#ifdef _WINDOWS
/* Format into a buffer for OutputDebugStringA(). */
char buf[1024];
char *startptr;
char *ptr;
int len;
va_list ap;
va_start(ap, fmt);
len = (int) SDL_vsnprintf(buf, sizeof (buf), fmt, ap);
va_end(ap);
/* Visual C's vsnprintf() may not null-terminate the buffer. */
if ((len >= sizeof (buf)) || (len < 0)) {
buf[sizeof (buf) - 1] = '\0';
}
/* Write it, sorting out the Unix newlines... */
startptr = buf;
for (ptr = startptr; *ptr; ptr++) {
if (*ptr == '\n') {
*ptr = '\0';
OutputDebugStringA(startptr);
OutputDebugStringA("\r\n");
startptr = ptr+1;
}
}
/* catch that last piece if it didn't have a newline... */
if (startptr != ptr) {
OutputDebugStringA(startptr);
}
#else
/* Unix has it easy. Just dump it to stderr. */
va_list ap;
va_start(ap, fmt);
93
vfprintf(stderr, fmt, ap);
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
va_end(ap);
fflush(stderr);
#endif
}
#ifdef _WINDOWS
static SDL_assert_state SDL_Windows_AssertChoice = SDL_ASSERTION_ABORT;
static const SDL_assert_data *SDL_Windows_AssertData = NULL;
static LRESULT CALLBACK
SDL_Assertion_WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg)
{
case WM_CREATE:
{
/* !!! FIXME: all this code stinks. */
const SDL_assert_data *data = SDL_Windows_AssertData;
char buf[1024];
const int w = 100;
const int h = 25;
const int gap = 10;
int x = gap;
int y = 50;
int len;
int i;
static const struct {
const char *name;
SDL_assert_state state;
} buttons[] = {
{"Abort", SDL_ASSERTION_ABORT },
{"Break", SDL_ASSERTION_BREAK },
{"Retry", SDL_ASSERTION_RETRY },
{"Ignore", SDL_ASSERTION_IGNORE },
{"Always Ignore", SDL_ASSERTION_ALWAYS_IGNORE },
};
len = (int) SDL_snprintf(buf, sizeof (buf),
"Assertion failure at %s (%s:%d), triggered %u time%s:\r\n '%s'",
data->function, data->filename, data->linenum,
data->trigger_count, (data->trigger_count == 1) ? "" : "s",
data->condition);
if ((len < 0) || (len >= sizeof (buf))) {
buf[sizeof (buf) - 1] = '\0';
}
CreateWindowA("STATIC", buf,
WS_VISIBLE | WS_CHILD | SS_LEFT,
x, y, 550, 100,
hwnd, (HMENU) 1, NULL, NULL);
y += 110;
for (i = 0; i < (sizeof (buttons) / sizeof (buttons[0])); i++) {
CreateWindowA("BUTTON", buttons[i].name,
WS_VISIBLE | WS_CHILD,
x, y, w, h,
hwnd, (HMENU) buttons[i].state, NULL, NULL);
x += w + gap;
}
break;
}
case WM_COMMAND:
SDL_Windows_AssertChoice = ((SDL_assert_state) (LOWORD(wParam)));
SDL_Windows_AssertData = NULL;
break;
case WM_DESTROY:
SDL_Windows_AssertData = NULL;
break;
}
return DefWindowProc(hwnd, msg, wParam, lParam);
}
static SDL_assert_state
SDL_PromptAssertion_windows(const SDL_assert_data *data)
{
HINSTANCE hInstance = 0; /* !!! FIXME? */
HWND hwnd;
MSG msg;
WNDCLASS wc = {0};
SDL_Windows_AssertChoice = SDL_ASSERTION_ABORT;
SDL_Windows_AssertData = data;
wc.lpszClassName = TEXT("SDL_assert");
wc.hInstance = hInstance ;
wc.hbrBackground = GetSysColorBrush(COLOR_3DFACE);
wc.lpfnWndProc = SDL_Assertion_WndProc;
wc.hCursor = LoadCursor(0, IDC_ARROW);
RegisterClass(&wc);
hwnd = CreateWindow(wc.lpszClassName, TEXT("SDL assertion failure"),
WS_OVERLAPPEDWINDOW | WS_VISIBLE,
150, 150, 570, 260, 0, 0, hInstance, 0);
while (GetMessage(&msg, NULL, 0, 0) && (SDL_Windows_AssertData != NULL)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
DestroyWindow(hwnd);
UnregisterClass(wc.lpszClassName, hInstance);
return SDL_Windows_AssertChoice;
}
#endif
static void SDL_AddAssertionToReport(SDL_assert_data *data)
{
/* (data) is always a static struct defined with the assert macros, so
we don't have to worry about copying or allocating them. */
if (data->next == NULL) { /* not yet added? */
data->next = triggered_assertions;
triggered_assertions = data;
}
}
214
215
216
static void SDL_GenerateAssertionReport(void)
{
217
const SDL_assert_data *item;
218
219
220
221
222
223
224
225
/* only do this if the app hasn't assigned an assertion handler. */
if (assertion_handler != SDL_PromptAssertion)
return;
item = SDL_GetAssertionReport();
if (item->condition)
{
226
227
228
debug_print("\n\nSDL assertion report.\n");
debug_print("All SDL assertions between last init/quit:\n\n");
229
while (item->condition) {
230
231
232
233
234
235
236
237
238
239
240
241
242
debug_print(
"'%s'\n"
" * %s (%s:%d)\n"
" * triggered %u time%s.\n"
" * always ignore: %s.\n",
item->condition, item->function, item->filename,
item->linenum, item->trigger_count,
(item->trigger_count == 1) ? "" : "s",
item->always_ignore ? "yes" : "no");
item = item->next;
}
debug_print("\n");
243
SDL_ResetAssertionReport();
244
245
246
}
}
247
static void SDL_ExitProcess(int exitcode)
248
249
250
251
{
#ifdef _WINDOWS
ExitProcess(42);
#else
252
_exit(42);
253
254
#endif
}
255
256
257
258
259
260
261
static void SDL_AbortAssertion(void)
{
SDL_Quit();
SDL_ExitProcess(42);
}
262
263
264
static SDL_assert_state
SDL_PromptAssertion(const SDL_assert_data *data, void *userdata)
265
266
{
const char *envr;
267
SDL_assert_state state = SDL_ASSERTION_ABORT;
268
SDL_Window *window;
269
270
271
(void) userdata; /* unused in default handler. */
272
273
274
275
276
277
278
279
debug_print("\n\n"
"Assertion failure at %s (%s:%d), triggered %u time%s:\n"
" '%s'\n"
"\n",
data->function, data->filename, data->linenum,
data->trigger_count, (data->trigger_count == 1) ? "" : "s",
data->condition);
280
/* let env. variable override, so unit tests won't block in a GUI. */
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
envr = SDL_getenv("SDL_ASSERT");
if (envr != NULL) {
if (SDL_strcmp(envr, "abort") == 0) {
return SDL_ASSERTION_ABORT;
} else if (SDL_strcmp(envr, "break") == 0) {
return SDL_ASSERTION_BREAK;
} else if (SDL_strcmp(envr, "retry") == 0) {
return SDL_ASSERTION_RETRY;
} else if (SDL_strcmp(envr, "ignore") == 0) {
return SDL_ASSERTION_IGNORE;
} else if (SDL_strcmp(envr, "always_ignore") == 0) {
return SDL_ASSERTION_ALWAYS_IGNORE;
} else {
return SDL_ASSERTION_ABORT; /* oh well. */
}
}
298
299
300
301
302
303
/* Leave fullscreen mode, if possible (scary!) */
window = SDL_GetFocusWindow();
if (window) {
if (SDL_GetWindowFlags(window) & SDL_WINDOW_FULLSCREEN) {
SDL_MinimizeWindow(window);
} else {
304
/* !!! FIXME: ungrab the input if we're not fullscreen? */
305
306
307
308
309
/* No need to mess with the window */
window = 0;
}
}
310
311
312
/* platform-specific UI... */
#ifdef _WINDOWS
313
state = SDL_PromptAssertion_windows(data);
314
315
#elif __MACOSX__
316
317
/* This has to be done in an Objective-C (*.m) file, so we call out. */
extern SDL_assert_state SDL_PromptAssertion_cocoa(const SDL_assert_data *);
318
state = SDL_PromptAssertion_cocoa(data);
319
320
#else
321
322
323
324
325
326
/* this is a little hacky. */
for ( ; ; ) {
char buf[32];
fprintf(stderr, "Abort/Break/Retry/Ignore/AlwaysIgnore? [abriA] : ");
fflush(stderr);
if (fgets(buf, sizeof (buf), stdin) == NULL) {
327
break;
328
329
330
}
if (SDL_strcmp(buf, "a") == 0) {
331
332
state = SDL_ASSERTION_ABORT;
break;
333
} else if (SDL_strcmp(envr, "b") == 0) {
334
335
state = SDL_ASSERTION_BREAK;
break;
336
} else if (SDL_strcmp(envr, "r") == 0) {
337
338
state = SDL_ASSERTION_RETRY;
break;
339
} else if (SDL_strcmp(envr, "i") == 0) {
340
341
state = SDL_ASSERTION_IGNORE;
break;
342
} else if (SDL_strcmp(envr, "A") == 0) {
343
344
state = SDL_ASSERTION_ALWAYS_IGNORE;
break;
345
346
347
348
}
}
#endif
349
350
351
352
353
354
/* Re-enter fullscreen mode */
if (window) {
SDL_RestoreWindow(window);
}
return state;
355
356
357
358
}
SDL_assert_state
359
360
SDL_ReportAssertion(SDL_assert_data *data, const char *func, const char *file,
int line)
361
{
362
static int assertion_running = 0;
363
static SDL_SpinLock spinlock = 0;
364
SDL_assert_state state = SDL_ASSERTION_IGNORE;
365
366
367
368
369
370
371
372
373
374
375
SDL_AtomicLock(&spinlock);
if (assertion_mutex == NULL) { /* never called SDL_Init()? */
assertion_mutex = SDL_CreateMutex();
if (assertion_mutex == NULL) {
SDL_AtomicUnlock(&spinlock);
return SDL_ASSERTION_IGNORE; /* oh well, I guess. */
}
}
SDL_AtomicUnlock(&spinlock);
376
377
378
379
380
381
382
if (SDL_LockMutex(assertion_mutex) < 0) {
return SDL_ASSERTION_IGNORE; /* oh well, I guess. */
}
/* doing this because Visual C is upset over assigning in the macro. */
if (data->trigger_count == 0) {
data->function = func;
383
384
data->filename = file;
data->linenum = line;
385
386
387
388
389
}
SDL_AddAssertionToReport(data);
data->trigger_count++;
390
391
392
393
394
395
396
397
398
399
assertion_running++;
if (assertion_running > 1) { /* assert during assert! Abort. */
if (assertion_running == 2) {
SDL_AbortAssertion();
} else if (assertion_running == 3) { /* Abort asserted! */
SDL_ExitProcess(42);
} else {
while (1) { /* do nothing but spin; what else can you do?! */ }
}
400
401
}
402
if (!data->always_ignore) {
403
state = assertion_handler(data, assertion_userdata);
404
}
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
switch (state)
{
case SDL_ASSERTION_ABORT:
SDL_AbortAssertion();
return SDL_ASSERTION_IGNORE; /* shouldn't return, but oh well. */
case SDL_ASSERTION_ALWAYS_IGNORE:
state = SDL_ASSERTION_IGNORE;
data->always_ignore = 1;
break;
case SDL_ASSERTION_IGNORE:
case SDL_ASSERTION_RETRY:
case SDL_ASSERTION_BREAK:
break; /* macro handles these. */
}
423
assertion_running--;
424
425
426
427
428
429
430
431
SDL_UnlockMutex(assertion_mutex);
return state;
}
int SDL_AssertionsInit(void)
{
432
/* this is a no-op at the moment. */
433
434
435
436
437
438
return 0;
}
void SDL_AssertionsQuit(void)
{
SDL_GenerateAssertionReport();
439
440
441
442
if (assertion_mutex != NULL) {
SDL_DestroyMutex(assertion_mutex);
assertion_mutex = NULL;
}
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
}
void SDL_SetAssertionHandler(SDL_AssertionHandler handler, void *userdata)
{
if (handler != NULL) {
assertion_handler = handler;
assertion_userdata = userdata;
} else {
assertion_handler = SDL_PromptAssertion;
assertion_userdata = NULL;
}
}
const SDL_assert_data *SDL_GetAssertionReport(void)
{
return triggered_assertions;
}
void SDL_ResetAssertionReport(void)
{
SDL_assert_data *item = triggered_assertions;
SDL_assert_data *next = NULL;
for (item = triggered_assertions; item->condition; item = next) {
next = (SDL_assert_data *) item->next;
item->always_ignore = SDL_FALSE;
item->trigger_count = 0;
item->next = NULL;
}
triggered_assertions = &assertion_list_terminator;
473
474
475
}
/* vi: set ts=4 sw=4 expandtab: */