This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_assert.c
476 lines (402 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 "SDL_assert_c.h"
26
#include "video/SDL_sysvideo.h"
27
28
29
30
31
32
33
#ifdef _WINDOWS
#define WIN32_LEAN_AND_MEAN 1
#include <windows.h>
#else /* fprintf, _exit(), etc. */
#include <stdio.h>
#include <stdlib.h>
34
#include <unistd.h>
35
36
#endif
37
38
39
40
41
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
42
43
44
45
* 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;
46
47
48
49
static SDL_mutex *assertion_mutex = NULL;
static SDL_AssertionHandler assertion_handler = SDL_PromptAssertion;
static void *assertion_userdata = NULL;
50
51
#ifdef __GNUC__
52
53
static void
debug_print(const char *fmt, ...) __attribute__((format (printf, 1, 2)));
54
55
56
57
#endif
static void
debug_print(const char *fmt, ...)
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
93
{
#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);
94
vfprintf(stderr, fmt, ap);
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
214
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;
}
}
215
216
217
static void SDL_GenerateAssertionReport(void)
{
218
const SDL_assert_data *item;
219
220
221
222
223
224
225
226
/* only do this if the app hasn't assigned an assertion handler. */
if (assertion_handler != SDL_PromptAssertion)
return;
item = SDL_GetAssertionReport();
if (item->condition)
{
227
228
229
debug_print("\n\nSDL assertion report.\n");
debug_print("All SDL assertions between last init/quit:\n\n");
230
while (item->condition) {
231
232
233
234
235
236
237
238
239
240
241
242
243
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");
244
SDL_ResetAssertionReport();
245
246
247
}
}
248
static void SDL_ExitProcess(int exitcode)
249
250
251
252
{
#ifdef _WINDOWS
ExitProcess(42);
#else
253
_exit(42);
254
255
#endif
}
256
257
258
259
260
261
262
static void SDL_AbortAssertion(void)
{
SDL_Quit();
SDL_ExitProcess(42);
}
263
264
265
static SDL_assert_state
SDL_PromptAssertion(const SDL_assert_data *data, void *userdata)
266
267
{
const char *envr;
268
SDL_assert_state state = SDL_ASSERTION_ABORT;
269
SDL_Window *window;
270
271
272
(void) userdata; /* unused in default handler. */
273
274
275
276
277
278
279
280
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);
281
/* let env. variable override, so unit tests won't block in a GUI. */
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
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. */
}
}
299
300
301
302
303
304
/* Leave fullscreen mode, if possible (scary!) */
window = SDL_GetFocusWindow();
if (window) {
if (SDL_GetWindowFlags(window) & SDL_WINDOW_FULLSCREEN) {
SDL_MinimizeWindow(window);
} else {
305
/* !!! FIXME: ungrab the input if we're not fullscreen? */
306
307
308
309
310
/* No need to mess with the window */
window = 0;
}
}
311
312
313
/* platform-specific UI... */
#ifdef _WINDOWS
314
state = SDL_PromptAssertion_windows(data);
315
316
#elif __MACOSX__
317
318
/* 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 *);
319
state = SDL_PromptAssertion_cocoa(data);
320
321
#else
322
323
324
325
326
327
/* 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) {
328
break;
329
330
331
}
if (SDL_strcmp(buf, "a") == 0) {
332
333
state = SDL_ASSERTION_ABORT;
break;
334
} else if (SDL_strcmp(envr, "b") == 0) {
335
336
state = SDL_ASSERTION_BREAK;
break;
337
} else if (SDL_strcmp(envr, "r") == 0) {
338
339
state = SDL_ASSERTION_RETRY;
break;
340
} else if (SDL_strcmp(envr, "i") == 0) {
341
342
state = SDL_ASSERTION_IGNORE;
break;
343
} else if (SDL_strcmp(envr, "A") == 0) {
344
345
state = SDL_ASSERTION_ALWAYS_IGNORE;
break;
346
347
348
349
}
}
#endif
350
351
352
353
354
355
/* Re-enter fullscreen mode */
if (window) {
SDL_RestoreWindow(window);
}
return state;
356
357
358
359
}
SDL_assert_state
360
361
SDL_ReportAssertion(SDL_assert_data *data, const char *func, const char *file,
int line)
362
{
363
static int assertion_running = 0;
364
static SDL_SpinLock spinlock = 0;
365
SDL_assert_state state = SDL_ASSERTION_IGNORE;
366
367
368
369
370
371
372
373
374
375
376
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);
377
378
379
380
381
382
383
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;
384
385
data->filename = file;
data->linenum = line;
386
387
388
389
390
}
SDL_AddAssertionToReport(data);
data->trigger_count++;
391
392
393
394
395
396
397
398
399
400
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?! */ }
}
401
402
}
403
if (!data->always_ignore) {
404
state = assertion_handler(data, assertion_userdata);
405
}
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
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. */
}
424
assertion_running--;
425
426
427
428
429
430
431
432
SDL_UnlockMutex(assertion_mutex);
return state;
}
int SDL_AssertionsInit(void)
{
433
/* this is a no-op at the moment. */
434
435
436
437
438
439
return 0;
}
void SDL_AssertionsQuit(void)
{
SDL_GenerateAssertionReport();
440
441
442
443
if (assertion_mutex != NULL) {
SDL_DestroyMutex(assertion_mutex);
assertion_mutex = NULL;
}
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
473
}
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;
474
475
476
}
/* vi: set ts=4 sw=4 expandtab: */