diff options
author | Star Rauchenberger <fefferburbia@gmail.com> | 2022-03-20 13:03:18 -0400 |
---|---|---|
committer | Star Rauchenberger <fefferburbia@gmail.com> | 2022-03-20 13:03:18 -0400 |
commit | 304bab2aced9cae51d2e4c09f3d9e06c66ff175d (patch) | |
tree | 8397f81b893feb1cf624eee49c4fb01297aa08ad /vendor/SDL2/include/SDL_assert.h | |
parent | ba350484072c78e5e1a765370c22dbd76474aa39 (diff) | |
download | ether-304bab2aced9cae51d2e4c09f3d9e06c66ff175d.tar.gz ether-304bab2aced9cae51d2e4c09f3d9e06c66ff175d.tar.bz2 ether-304bab2aced9cae51d2e4c09f3d9e06c66ff175d.zip |
we can build a window app!
build type must be set to Release or it's horribly slow, and fullscreen does not work
Diffstat (limited to 'vendor/SDL2/include/SDL_assert.h')
-rw-r--r-- | vendor/SDL2/include/SDL_assert.h | 324 |
1 files changed, 324 insertions, 0 deletions
diff --git a/vendor/SDL2/include/SDL_assert.h b/vendor/SDL2/include/SDL_assert.h new file mode 100644 index 0000000..defadf1 --- /dev/null +++ b/vendor/SDL2/include/SDL_assert.h | |||
@@ -0,0 +1,324 @@ | |||
1 | /* | ||
2 | Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org> | ||
4 | |||
5 | This software is provided 'as-is', without any express or implied | ||
6 | warranty. In no event will the authors be held liable for any damages | ||
7 | arising from the use of this software. | ||
8 | |||
9 | Permission is granted to anyone to use this software for any purpose, | ||
10 | including commercial applications, and to alter it and redistribute it | ||
11 | freely, subject to the following restrictions: | ||
12 | |||
13 | 1. The origin of this software must not be misrepresented; you must not | ||
14 | claim that you wrote the original software. If you use this software | ||
15 | in a product, an acknowledgment in the product documentation would be | ||
16 | appreciated but is not required. | ||
17 | 2. Altered source versions must be plainly marked as such, and must not be | ||
18 | misrepresented as being the original software. | ||
19 | 3. This notice may not be removed or altered from any source distribution. | ||
20 | */ | ||
21 | |||
22 | #ifndef SDL_assert_h_ | ||
23 | #define SDL_assert_h_ | ||
24 | |||
25 | #include "SDL_config.h" | ||
26 | |||
27 | #include "begin_code.h" | ||
28 | /* Set up for C function definitions, even when using C++ */ | ||
29 | #ifdef __cplusplus | ||
30 | extern "C" { | ||
31 | #endif | ||
32 | |||
33 | #ifndef SDL_ASSERT_LEVEL | ||
34 | #ifdef SDL_DEFAULT_ASSERT_LEVEL | ||
35 | #define SDL_ASSERT_LEVEL SDL_DEFAULT_ASSERT_LEVEL | ||
36 | #elif defined(_DEBUG) || defined(DEBUG) || \ | ||
37 | (defined(__GNUC__) && !defined(__OPTIMIZE__)) | ||
38 | #define SDL_ASSERT_LEVEL 2 | ||
39 | #else | ||
40 | #define SDL_ASSERT_LEVEL 1 | ||
41 | #endif | ||
42 | #endif /* SDL_ASSERT_LEVEL */ | ||
43 | |||
44 | /* | ||
45 | These are macros and not first class functions so that the debugger breaks | ||
46 | on the assertion line and not in some random guts of SDL, and so each | ||
47 | assert can have unique static variables associated with it. | ||
48 | */ | ||
49 | |||
50 | #if defined(_MSC_VER) | ||
51 | /* Don't include intrin.h here because it contains C++ code */ | ||
52 | extern void __cdecl __debugbreak(void); | ||
53 | #define SDL_TriggerBreakpoint() __debugbreak() | ||
54 | #elif ( (!defined(__NACL__)) && ((defined(__GNUC__) || defined(__clang__)) && (defined(__i386__) || defined(__x86_64__))) ) | ||
55 | #define SDL_TriggerBreakpoint() __asm__ __volatile__ ( "int $3\n\t" ) | ||
56 | #elif ( defined(__APPLE__) && (defined(__arm64__) || defined(__aarch64__)) ) /* this might work on other ARM targets, but this is a known quantity... */ | ||
57 | #define SDL_TriggerBreakpoint() __asm__ __volatile__ ( "brk #22\n\t" ) | ||
58 | #elif defined(__APPLE__) && defined(__arm__) | ||
59 | #define SDL_TriggerBreakpoint() __asm__ __volatile__ ( "bkpt #22\n\t" ) | ||
60 | #elif defined(__386__) && defined(__WATCOMC__) | ||
61 | #define SDL_TriggerBreakpoint() { _asm { int 0x03 } } | ||
62 | #elif defined(HAVE_SIGNAL_H) && !defined(__WATCOMC__) | ||
63 | #include <signal.h> | ||
64 | #define SDL_TriggerBreakpoint() raise(SIGTRAP) | ||
65 | #else | ||
66 | /* How do we trigger breakpoints on this platform? */ | ||
67 | #define SDL_TriggerBreakpoint() | ||
68 | #endif | ||
69 | |||
70 | #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 supports __func__ as a standard. */ | ||
71 | # define SDL_FUNCTION __func__ | ||
72 | #elif ((__GNUC__ >= 2) || defined(_MSC_VER) || defined (__WATCOMC__)) | ||
73 | # define SDL_FUNCTION __FUNCTION__ | ||
74 | #else | ||
75 | # define SDL_FUNCTION "???" | ||
76 | #endif | ||
77 | #define SDL_FILE __FILE__ | ||
78 | #define SDL_LINE __LINE__ | ||
79 | |||
80 | /* | ||
81 | sizeof (x) makes the compiler still parse the expression even without | ||
82 | assertions enabled, so the code is always checked at compile time, but | ||
83 | doesn't actually generate code for it, so there are no side effects or | ||
84 | expensive checks at run time, just the constant size of what x WOULD be, | ||
85 | which presumably gets optimized out as unused. | ||
86 | This also solves the problem of... | ||
87 | |||
88 | int somevalue = blah(); | ||
89 | SDL_assert(somevalue == 1); | ||
90 | |||
91 | ...which would cause compiles to complain that somevalue is unused if we | ||
92 | disable assertions. | ||
93 | */ | ||
94 | |||
95 | /* "while (0,0)" fools Microsoft's compiler's /W4 warning level into thinking | ||
96 | this condition isn't constant. And looks like an owl's face! */ | ||
97 | #ifdef _MSC_VER /* stupid /W4 warnings. */ | ||
98 | #define SDL_NULL_WHILE_LOOP_CONDITION (0,0) | ||
99 | #else | ||
100 | #define SDL_NULL_WHILE_LOOP_CONDITION (0) | ||
101 | #endif | ||
102 | |||
103 | #define SDL_disabled_assert(condition) \ | ||
104 | do { (void) sizeof ((condition)); } while (SDL_NULL_WHILE_LOOP_CONDITION) | ||
105 | |||
106 | typedef enum | ||
107 | { | ||
108 | SDL_ASSERTION_RETRY, /**< Retry the assert immediately. */ | ||
109 | SDL_ASSERTION_BREAK, /**< Make the debugger trigger a breakpoint. */ | ||
110 | SDL_ASSERTION_ABORT, /**< Terminate the program. */ | ||
111 | SDL_ASSERTION_IGNORE, /**< Ignore the assert. */ | ||
112 | SDL_ASSERTION_ALWAYS_IGNORE /**< Ignore the assert from now on. */ | ||
113 | } SDL_AssertState; | ||
114 | |||
115 | typedef struct SDL_AssertData | ||
116 | { | ||
117 | int always_ignore; | ||
118 | unsigned int trigger_count; | ||
119 | const char *condition; | ||
120 | const char *filename; | ||
121 | int linenum; | ||
122 | const char *function; | ||
123 | const struct SDL_AssertData *next; | ||
124 | } SDL_AssertData; | ||
125 | |||
126 | #if (SDL_ASSERT_LEVEL > 0) | ||
127 | |||
128 | /* Never call this directly. Use the SDL_assert* macros. */ | ||
129 | extern DECLSPEC SDL_AssertState SDLCALL SDL_ReportAssertion(SDL_AssertData *, | ||
130 | const char *, | ||
131 | const char *, int) | ||
132 | #if defined(__clang__) | ||
133 | #if __has_feature(attribute_analyzer_noreturn) | ||
134 | /* this tells Clang's static analysis that we're a custom assert function, | ||
135 | and that the analyzer should assume the condition was always true past this | ||
136 | SDL_assert test. */ | ||
137 | __attribute__((analyzer_noreturn)) | ||
138 | #endif | ||
139 | #endif | ||
140 | ; | ||
141 | |||
142 | /* the do {} while(0) avoids dangling else problems: | ||
143 | if (x) SDL_assert(y); else blah(); | ||
144 | ... without the do/while, the "else" could attach to this macro's "if". | ||
145 | We try to handle just the minimum we need here in a macro...the loop, | ||
146 | the static vars, and break points. The heavy lifting is handled in | ||
147 | SDL_ReportAssertion(), in SDL_assert.c. | ||
148 | */ | ||
149 | #define SDL_enabled_assert(condition) \ | ||
150 | do { \ | ||
151 | while ( !(condition) ) { \ | ||
152 | static struct SDL_AssertData sdl_assert_data = { \ | ||
153 | 0, 0, #condition, 0, 0, 0, 0 \ | ||
154 | }; \ | ||
155 | const SDL_AssertState sdl_assert_state = SDL_ReportAssertion(&sdl_assert_data, SDL_FUNCTION, SDL_FILE, SDL_LINE); \ | ||
156 | if (sdl_assert_state == SDL_ASSERTION_RETRY) { \ | ||
157 | continue; /* go again. */ \ | ||
158 | } else if (sdl_assert_state == SDL_ASSERTION_BREAK) { \ | ||
159 | SDL_TriggerBreakpoint(); \ | ||
160 | } \ | ||
161 | break; /* not retrying. */ \ | ||
162 | } \ | ||
163 | } while (SDL_NULL_WHILE_LOOP_CONDITION) | ||
164 | |||
165 | #endif /* enabled assertions support code */ | ||
166 | |||
167 | /* Enable various levels of assertions. */ | ||
168 | #if SDL_ASSERT_LEVEL == 0 /* assertions disabled */ | ||
169 | # define SDL_assert(condition) SDL_disabled_assert(condition) | ||
170 | # define SDL_assert_release(condition) SDL_disabled_assert(condition) | ||
171 | # define SDL_assert_paranoid(condition) SDL_disabled_assert(condition) | ||
172 | #elif SDL_ASSERT_LEVEL == 1 /* release settings. */ | ||
173 | # define SDL_assert(condition) SDL_disabled_assert(condition) | ||
174 | # define SDL_assert_release(condition) SDL_enabled_assert(condition) | ||
175 | # define SDL_assert_paranoid(condition) SDL_disabled_assert(condition) | ||
176 | #elif SDL_ASSERT_LEVEL == 2 /* normal settings. */ | ||
177 | # define SDL_assert(condition) SDL_enabled_assert(condition) | ||
178 | # define SDL_assert_release(condition) SDL_enabled_assert(condition) | ||
179 | # define SDL_assert_paranoid(condition) SDL_disabled_assert(condition) | ||
180 | #elif SDL_ASSERT_LEVEL == 3 /* paranoid settings. */ | ||
181 | # define SDL_assert(condition) SDL_enabled_assert(condition) | ||
182 | # define SDL_assert_release(condition) SDL_enabled_assert(condition) | ||
183 | # define SDL_assert_paranoid(condition) SDL_enabled_assert(condition) | ||
184 | #else | ||
185 | # error Unknown assertion level. | ||
186 | #endif | ||
187 | |||
188 | /* this assertion is never disabled at any level. */ | ||
189 | #define SDL_assert_always(condition) SDL_enabled_assert(condition) | ||
190 | |||
191 | |||
192 | /** | ||
193 | * A callback that fires when an SDL assertion fails. | ||
194 | * | ||
195 | * \param data a pointer to the SDL_AssertData structure corresponding to the | ||
196 | * current assertion | ||
197 | * \param userdata what was passed as `userdata` to SDL_SetAssertionHandler() | ||
198 | * \returns an SDL_AssertState value indicating how to handle the failure. | ||
199 | */ | ||
200 | typedef SDL_AssertState (SDLCALL *SDL_AssertionHandler)( | ||
201 | const SDL_AssertData* data, void* userdata); | ||
202 | |||
203 | /** | ||
204 | * Set an application-defined assertion handler. | ||
205 | * | ||
206 | * This function allows an application to show its own assertion UI and/or | ||
207 | * force the response to an assertion failure. If the application doesn't | ||
208 | * provide this, SDL will try to do the right thing, popping up a | ||
209 | * system-specific GUI dialog, and probably minimizing any fullscreen windows. | ||
210 | * | ||
211 | * This callback may fire from any thread, but it runs wrapped in a mutex, so | ||
212 | * it will only fire from one thread at a time. | ||
213 | * | ||
214 | * This callback is NOT reset to SDL's internal handler upon SDL_Quit()! | ||
215 | * | ||
216 | * \param handler the SDL_AssertionHandler function to call when an assertion | ||
217 | * fails or NULL for the default handler | ||
218 | * \param userdata a pointer that is passed to `handler` | ||
219 | * | ||
220 | * \since This function is available since SDL 2.0.0. | ||
221 | * | ||
222 | * \sa SDL_GetAssertionHandler | ||
223 | */ | ||
224 | extern DECLSPEC void SDLCALL SDL_SetAssertionHandler( | ||
225 | SDL_AssertionHandler handler, | ||
226 | void *userdata); | ||
227 | |||
228 | /** | ||
229 | * Get the default assertion handler. | ||
230 | * | ||
231 | * This returns the function pointer that is called by default when an | ||
232 | * assertion is triggered. This is an internal function provided by SDL, that | ||
233 | * is used for assertions when SDL_SetAssertionHandler() hasn't been used to | ||
234 | * provide a different function. | ||
235 | * | ||
236 | * \returns the default SDL_AssertionHandler that is called when an assert | ||
237 | * triggers. | ||
238 | * | ||
239 | * \since This function is available since SDL 2.0.2. | ||
240 | * | ||
241 | * \sa SDL_GetAssertionHandler | ||
242 | */ | ||
243 | extern DECLSPEC SDL_AssertionHandler SDLCALL SDL_GetDefaultAssertionHandler(void); | ||
244 | |||
245 | /** | ||
246 | * Get the current assertion handler. | ||
247 | * | ||
248 | * This returns the function pointer that is called when an assertion is | ||
249 | * triggered. This is either the value last passed to | ||
250 | * SDL_SetAssertionHandler(), or if no application-specified function is set, | ||
251 | * is equivalent to calling SDL_GetDefaultAssertionHandler(). | ||
252 | * | ||
253 | * The parameter `puserdata` is a pointer to a void*, which will store the | ||
254 | * "userdata" pointer that was passed to SDL_SetAssertionHandler(). This value | ||
255 | * will always be NULL for the default handler. If you don't care about this | ||
256 | * data, it is safe to pass a NULL pointer to this function to ignore it. | ||
257 | * | ||
258 | * \param puserdata pointer which is filled with the "userdata" pointer that | ||
259 | * was passed to SDL_SetAssertionHandler() | ||
260 | * \returns the SDL_AssertionHandler that is called when an assert triggers. | ||
261 | * | ||
262 | * \since This function is available since SDL 2.0.2. | ||
263 | * | ||
264 | * \sa SDL_SetAssertionHandler | ||
265 | */ | ||
266 | extern DECLSPEC SDL_AssertionHandler SDLCALL SDL_GetAssertionHandler(void **puserdata); | ||
267 | |||
268 | /** | ||
269 | * Get a list of all assertion failures. | ||
270 | * | ||
271 | * This function gets all assertions triggered since the last call to | ||
272 | * SDL_ResetAssertionReport(), or the start of the program. | ||
273 | * | ||
274 | * The proper way to examine this data looks something like this: | ||
275 | * | ||
276 | * ```c | ||
277 | * const SDL_AssertData *item = SDL_GetAssertionReport(); | ||
278 | * while (item) { | ||
279 | * printf("'%s', %s (%s:%d), triggered %u times, always ignore: %s.\\n", | ||
280 | * item->condition, item->function, item->filename, | ||
281 | * item->linenum, item->trigger_count, | ||
282 | * item->always_ignore ? "yes" : "no"); | ||
283 | * item = item->next; | ||
284 | * } | ||
285 | * ``` | ||
286 | * | ||
287 | * \returns a list of all failed assertions or NULL if the list is empty. This | ||
288 | * memory should not be modified or freed by the application. | ||
289 | * | ||
290 | * \since This function is available since SDL 2.0.0. | ||
291 | * | ||
292 | * \sa SDL_ResetAssertionReport | ||
293 | */ | ||
294 | extern DECLSPEC const SDL_AssertData * SDLCALL SDL_GetAssertionReport(void); | ||
295 | |||
296 | /** | ||
297 | * Clear the list of all assertion failures. | ||
298 | * | ||
299 | * This function will clear the list of all assertions triggered up to that | ||
300 | * point. Immediately following this call, SDL_GetAssertionReport will return | ||
301 | * no items. In addition, any previously-triggered assertions will be reset to | ||
302 | * a trigger_count of zero, and their always_ignore state will be false. | ||
303 | * | ||
304 | * \since This function is available since SDL 2.0.0. | ||
305 | * | ||
306 | * \sa SDL_GetAssertionReport | ||
307 | */ | ||
308 | extern DECLSPEC void SDLCALL SDL_ResetAssertionReport(void); | ||
309 | |||
310 | |||
311 | /* these had wrong naming conventions until 2.0.4. Please update your app! */ | ||
312 | #define SDL_assert_state SDL_AssertState | ||
313 | #define SDL_assert_data SDL_AssertData | ||
314 | |||
315 | |||
316 | /* Ends C function definitions when using C++ */ | ||
317 | #ifdef __cplusplus | ||
318 | } | ||
319 | #endif | ||
320 | #include "close_code.h" | ||
321 | |||
322 | #endif /* SDL_assert_h_ */ | ||
323 | |||
324 | /* vi: set ts=4 sw=4 expandtab: */ | ||