Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
11 | pmbaty | 1 | /* |
2 | Simple DirectMedia Layer |
||
3 | Copyright (C) 1997-2023 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 | /** |
||
23 | * \file SDL_stdinc.h |
||
24 | * |
||
25 | * This is a general header that includes C language support. |
||
26 | */ |
||
27 | |||
28 | #ifndef SDL_stdinc_h_ |
||
29 | #define SDL_stdinc_h_ |
||
30 | |||
31 | #include "SDL_config.h" |
||
32 | |||
33 | #ifdef HAVE_SYS_TYPES_H |
||
34 | #include <sys/types.h> |
||
35 | #endif |
||
36 | #ifdef HAVE_STDIO_H |
||
37 | #include <stdio.h> |
||
38 | #endif |
||
39 | #if defined(STDC_HEADERS) |
||
40 | # include <stdlib.h> |
||
41 | # include <stddef.h> |
||
42 | # include <stdarg.h> |
||
43 | #else |
||
44 | # if defined(HAVE_STDLIB_H) |
||
45 | # include <stdlib.h> |
||
46 | # elif defined(HAVE_MALLOC_H) |
||
47 | # include <malloc.h> |
||
48 | # endif |
||
49 | # if defined(HAVE_STDDEF_H) |
||
50 | # include <stddef.h> |
||
51 | # endif |
||
52 | # if defined(HAVE_STDARG_H) |
||
53 | # include <stdarg.h> |
||
54 | # endif |
||
55 | #endif |
||
56 | #ifdef HAVE_STRING_H |
||
57 | # if !defined(STDC_HEADERS) && defined(HAVE_MEMORY_H) |
||
58 | # include <memory.h> |
||
59 | # endif |
||
60 | # include <string.h> |
||
61 | #endif |
||
62 | #ifdef HAVE_STRINGS_H |
||
63 | # include <strings.h> |
||
64 | #endif |
||
65 | #ifdef HAVE_WCHAR_H |
||
66 | # include <wchar.h> |
||
67 | #endif |
||
68 | #if defined(HAVE_INTTYPES_H) |
||
69 | # include <inttypes.h> |
||
70 | #elif defined(HAVE_STDINT_H) |
||
71 | # include <stdint.h> |
||
72 | #endif |
||
73 | #ifdef HAVE_CTYPE_H |
||
74 | # include <ctype.h> |
||
75 | #endif |
||
76 | #ifdef HAVE_MATH_H |
||
77 | # if defined(_MSC_VER) |
||
78 | /* Defining _USE_MATH_DEFINES is required to get M_PI to be defined on |
||
79 | Visual Studio. See http://msdn.microsoft.com/en-us/library/4hwaceh6.aspx |
||
80 | for more information. |
||
81 | */ |
||
82 | # ifndef _USE_MATH_DEFINES |
||
83 | # define _USE_MATH_DEFINES |
||
84 | # endif |
||
85 | # endif |
||
86 | # include <math.h> |
||
87 | #endif |
||
88 | #ifdef HAVE_FLOAT_H |
||
89 | # include <float.h> |
||
90 | #endif |
||
91 | #if defined(HAVE_ALLOCA) && !defined(alloca) |
||
92 | # if defined(HAVE_ALLOCA_H) |
||
93 | # include <alloca.h> |
||
94 | # elif defined(__GNUC__) |
||
95 | # define alloca __builtin_alloca |
||
96 | # elif defined(_MSC_VER) |
||
97 | # include <malloc.h> |
||
98 | # define alloca _alloca |
||
99 | # elif defined(__WATCOMC__) |
||
100 | # include <malloc.h> |
||
101 | # elif defined(__BORLANDC__) |
||
102 | # include <malloc.h> |
||
103 | # elif defined(__DMC__) |
||
104 | # include <stdlib.h> |
||
105 | # elif defined(__AIX__) |
||
106 | #pragma alloca |
||
107 | # elif defined(__MRC__) |
||
108 | void *alloca(unsigned); |
||
109 | # else |
||
110 | char *alloca(); |
||
111 | # endif |
||
112 | #endif |
||
113 | |||
114 | #ifdef SIZE_MAX |
||
115 | # define SDL_SIZE_MAX SIZE_MAX |
||
116 | #else |
||
117 | # define SDL_SIZE_MAX ((size_t) -1) |
||
118 | #endif |
||
119 | |||
120 | /** |
||
121 | * Check if the compiler supports a given builtin. |
||
122 | * Supported by virtually all clang versions and recent gcc. Use this |
||
123 | * instead of checking the clang version if possible. |
||
124 | */ |
||
125 | #ifdef __has_builtin |
||
126 | #define _SDL_HAS_BUILTIN(x) __has_builtin(x) |
||
127 | #else |
||
128 | #define _SDL_HAS_BUILTIN(x) 0 |
||
129 | #endif |
||
130 | |||
131 | /** |
||
132 | * The number of elements in an array. |
||
133 | */ |
||
134 | #define SDL_arraysize(array) (sizeof(array)/sizeof(array[0])) |
||
135 | #define SDL_TABLESIZE(table) SDL_arraysize(table) |
||
136 | |||
137 | /** |
||
138 | * Macro useful for building other macros with strings in them |
||
139 | * |
||
140 | * e.g. #define LOG_ERROR(X) OutputDebugString(SDL_STRINGIFY_ARG(__FUNCTION__) ": " X "\n") |
||
141 | */ |
||
142 | #define SDL_STRINGIFY_ARG(arg) #arg |
||
143 | |||
144 | /** |
||
145 | * \name Cast operators |
||
146 | * |
||
147 | * Use proper C++ casts when compiled as C++ to be compatible with the option |
||
148 | * -Wold-style-cast of GCC (and -Werror=old-style-cast in GCC 4.2 and above). |
||
149 | */ |
||
150 | /* @{ */ |
||
151 | #ifdef __cplusplus |
||
152 | #define SDL_reinterpret_cast(type, expression) reinterpret_cast<type>(expression) |
||
153 | #define SDL_static_cast(type, expression) static_cast<type>(expression) |
||
154 | #define SDL_const_cast(type, expression) const_cast<type>(expression) |
||
155 | #else |
||
156 | #define SDL_reinterpret_cast(type, expression) ((type)(expression)) |
||
157 | #define SDL_static_cast(type, expression) ((type)(expression)) |
||
158 | #define SDL_const_cast(type, expression) ((type)(expression)) |
||
159 | #endif |
||
160 | /* @} *//* Cast operators */ |
||
161 | |||
162 | /* Define a four character code as a Uint32 */ |
||
163 | #define SDL_FOURCC(A, B, C, D) \ |
||
164 | ((SDL_static_cast(Uint32, SDL_static_cast(Uint8, (A))) << 0) | \ |
||
165 | (SDL_static_cast(Uint32, SDL_static_cast(Uint8, (B))) << 8) | \ |
||
166 | (SDL_static_cast(Uint32, SDL_static_cast(Uint8, (C))) << 16) | \ |
||
167 | (SDL_static_cast(Uint32, SDL_static_cast(Uint8, (D))) << 24)) |
||
168 | |||
169 | /** |
||
170 | * \name Basic data types |
||
171 | */ |
||
172 | /* @{ */ |
||
173 | |||
174 | #ifdef __CC_ARM |
||
175 | /* ARM's compiler throws warnings if we use an enum: like "SDL_bool x = a < b;" */ |
||
176 | #define SDL_FALSE 0 |
||
177 | #define SDL_TRUE 1 |
||
178 | typedef int SDL_bool; |
||
179 | #else |
||
180 | typedef enum |
||
181 | { |
||
182 | SDL_FALSE = 0, |
||
183 | SDL_TRUE = 1 |
||
184 | } SDL_bool; |
||
185 | #endif |
||
186 | |||
187 | /** |
||
188 | * \brief A signed 8-bit integer type. |
||
189 | */ |
||
190 | #define SDL_MAX_SINT8 ((Sint8)0x7F) /* 127 */ |
||
191 | #define SDL_MIN_SINT8 ((Sint8)(~0x7F)) /* -128 */ |
||
192 | typedef int8_t Sint8; |
||
193 | /** |
||
194 | * \brief An unsigned 8-bit integer type. |
||
195 | */ |
||
196 | #define SDL_MAX_UINT8 ((Uint8)0xFF) /* 255 */ |
||
197 | #define SDL_MIN_UINT8 ((Uint8)0x00) /* 0 */ |
||
198 | typedef uint8_t Uint8; |
||
199 | /** |
||
200 | * \brief A signed 16-bit integer type. |
||
201 | */ |
||
202 | #define SDL_MAX_SINT16 ((Sint16)0x7FFF) /* 32767 */ |
||
203 | #define SDL_MIN_SINT16 ((Sint16)(~0x7FFF)) /* -32768 */ |
||
204 | typedef int16_t Sint16; |
||
205 | /** |
||
206 | * \brief An unsigned 16-bit integer type. |
||
207 | */ |
||
208 | #define SDL_MAX_UINT16 ((Uint16)0xFFFF) /* 65535 */ |
||
209 | #define SDL_MIN_UINT16 ((Uint16)0x0000) /* 0 */ |
||
210 | typedef uint16_t Uint16; |
||
211 | /** |
||
212 | * \brief A signed 32-bit integer type. |
||
213 | */ |
||
214 | #define SDL_MAX_SINT32 ((Sint32)0x7FFFFFFF) /* 2147483647 */ |
||
215 | #define SDL_MIN_SINT32 ((Sint32)(~0x7FFFFFFF)) /* -2147483648 */ |
||
216 | typedef int32_t Sint32; |
||
217 | /** |
||
218 | * \brief An unsigned 32-bit integer type. |
||
219 | */ |
||
220 | #define SDL_MAX_UINT32 ((Uint32)0xFFFFFFFFu) /* 4294967295 */ |
||
221 | #define SDL_MIN_UINT32 ((Uint32)0x00000000) /* 0 */ |
||
222 | typedef uint32_t Uint32; |
||
223 | |||
224 | /** |
||
225 | * \brief A signed 64-bit integer type. |
||
226 | */ |
||
227 | #define SDL_MAX_SINT64 ((Sint64)0x7FFFFFFFFFFFFFFFll) /* 9223372036854775807 */ |
||
228 | #define SDL_MIN_SINT64 ((Sint64)(~0x7FFFFFFFFFFFFFFFll)) /* -9223372036854775808 */ |
||
229 | typedef int64_t Sint64; |
||
230 | /** |
||
231 | * \brief An unsigned 64-bit integer type. |
||
232 | */ |
||
233 | #define SDL_MAX_UINT64 ((Uint64)0xFFFFFFFFFFFFFFFFull) /* 18446744073709551615 */ |
||
234 | #define SDL_MIN_UINT64 ((Uint64)(0x0000000000000000ull)) /* 0 */ |
||
235 | typedef uint64_t Uint64; |
||
236 | |||
237 | /* @} *//* Basic data types */ |
||
238 | |||
239 | /** |
||
240 | * \name Floating-point constants |
||
241 | */ |
||
242 | /* @{ */ |
||
243 | |||
244 | #ifdef FLT_EPSILON |
||
245 | #define SDL_FLT_EPSILON FLT_EPSILON |
||
246 | #else |
||
247 | #define SDL_FLT_EPSILON 1.1920928955078125e-07F /* 0x0.000002p0 */ |
||
248 | #endif |
||
249 | |||
250 | /* @} *//* Floating-point constants */ |
||
251 | |||
252 | /* Make sure we have macros for printing width-based integers. |
||
253 | * <stdint.h> should define these but this is not true all platforms. |
||
254 | * (for example win32) */ |
||
255 | #ifndef SDL_PRIs64 |
||
256 | #ifdef PRIs64 |
||
257 | #define SDL_PRIs64 PRIs64 |
||
258 | #elif defined(__WIN32__) || defined(__GDK__) |
||
259 | #define SDL_PRIs64 "I64d" |
||
260 | #elif defined(__LINUX__) && defined(__LP64__) |
||
261 | #define SDL_PRIs64 "ld" |
||
262 | #else |
||
263 | #define SDL_PRIs64 "lld" |
||
264 | #endif |
||
265 | #endif |
||
266 | #ifndef SDL_PRIu64 |
||
267 | #ifdef PRIu64 |
||
268 | #define SDL_PRIu64 PRIu64 |
||
269 | #elif defined(__WIN32__) || defined(__GDK__) |
||
270 | #define SDL_PRIu64 "I64u" |
||
271 | #elif defined(__LINUX__) && defined(__LP64__) |
||
272 | #define SDL_PRIu64 "lu" |
||
273 | #else |
||
274 | #define SDL_PRIu64 "llu" |
||
275 | #endif |
||
276 | #endif |
||
277 | #ifndef SDL_PRIx64 |
||
278 | #ifdef PRIx64 |
||
279 | #define SDL_PRIx64 PRIx64 |
||
280 | #elif defined(__WIN32__) || defined(__GDK__) |
||
281 | #define SDL_PRIx64 "I64x" |
||
282 | #elif defined(__LINUX__) && defined(__LP64__) |
||
283 | #define SDL_PRIx64 "lx" |
||
284 | #else |
||
285 | #define SDL_PRIx64 "llx" |
||
286 | #endif |
||
287 | #endif |
||
288 | #ifndef SDL_PRIX64 |
||
289 | #ifdef PRIX64 |
||
290 | #define SDL_PRIX64 PRIX64 |
||
291 | #elif defined(__WIN32__) || defined(__GDK__) |
||
292 | #define SDL_PRIX64 "I64X" |
||
293 | #elif defined(__LINUX__) && defined(__LP64__) |
||
294 | #define SDL_PRIX64 "lX" |
||
295 | #else |
||
296 | #define SDL_PRIX64 "llX" |
||
297 | #endif |
||
298 | #endif |
||
299 | #ifndef SDL_PRIs32 |
||
300 | #ifdef PRId32 |
||
301 | #define SDL_PRIs32 PRId32 |
||
302 | #else |
||
303 | #define SDL_PRIs32 "d" |
||
304 | #endif |
||
305 | #endif |
||
306 | #ifndef SDL_PRIu32 |
||
307 | #ifdef PRIu32 |
||
308 | #define SDL_PRIu32 PRIu32 |
||
309 | #else |
||
310 | #define SDL_PRIu32 "u" |
||
311 | #endif |
||
312 | #endif |
||
313 | #ifndef SDL_PRIx32 |
||
314 | #ifdef PRIx32 |
||
315 | #define SDL_PRIx32 PRIx32 |
||
316 | #else |
||
317 | #define SDL_PRIx32 "x" |
||
318 | #endif |
||
319 | #endif |
||
320 | #ifndef SDL_PRIX32 |
||
321 | #ifdef PRIX32 |
||
322 | #define SDL_PRIX32 PRIX32 |
||
323 | #else |
||
324 | #define SDL_PRIX32 "X" |
||
325 | #endif |
||
326 | #endif |
||
327 | |||
328 | /* Annotations to help code analysis tools */ |
||
329 | #ifdef SDL_DISABLE_ANALYZE_MACROS |
||
330 | #define SDL_IN_BYTECAP(x) |
||
331 | #define SDL_INOUT_Z_CAP(x) |
||
332 | #define SDL_OUT_Z_CAP(x) |
||
333 | #define SDL_OUT_CAP(x) |
||
334 | #define SDL_OUT_BYTECAP(x) |
||
335 | #define SDL_OUT_Z_BYTECAP(x) |
||
336 | #define SDL_PRINTF_FORMAT_STRING |
||
337 | #define SDL_SCANF_FORMAT_STRING |
||
338 | #define SDL_PRINTF_VARARG_FUNC( fmtargnumber ) |
||
339 | #define SDL_SCANF_VARARG_FUNC( fmtargnumber ) |
||
340 | #else |
||
341 | #if defined(_MSC_VER) && (_MSC_VER >= 1600) /* VS 2010 and above */ |
||
342 | #include <sal.h> |
||
343 | |||
344 | #define SDL_IN_BYTECAP(x) _In_bytecount_(x) |
||
345 | #define SDL_INOUT_Z_CAP(x) _Inout_z_cap_(x) |
||
346 | #define SDL_OUT_Z_CAP(x) _Out_z_cap_(x) |
||
347 | #define SDL_OUT_CAP(x) _Out_cap_(x) |
||
348 | #define SDL_OUT_BYTECAP(x) _Out_bytecap_(x) |
||
349 | #define SDL_OUT_Z_BYTECAP(x) _Out_z_bytecap_(x) |
||
350 | |||
351 | #define SDL_PRINTF_FORMAT_STRING _Printf_format_string_ |
||
352 | #define SDL_SCANF_FORMAT_STRING _Scanf_format_string_impl_ |
||
353 | #else |
||
354 | #define SDL_IN_BYTECAP(x) |
||
355 | #define SDL_INOUT_Z_CAP(x) |
||
356 | #define SDL_OUT_Z_CAP(x) |
||
357 | #define SDL_OUT_CAP(x) |
||
358 | #define SDL_OUT_BYTECAP(x) |
||
359 | #define SDL_OUT_Z_BYTECAP(x) |
||
360 | #define SDL_PRINTF_FORMAT_STRING |
||
361 | #define SDL_SCANF_FORMAT_STRING |
||
362 | #endif |
||
363 | #if defined(__GNUC__) |
||
364 | #define SDL_PRINTF_VARARG_FUNC( fmtargnumber ) __attribute__ (( format( __printf__, fmtargnumber, fmtargnumber+1 ))) |
||
365 | #define SDL_SCANF_VARARG_FUNC( fmtargnumber ) __attribute__ (( format( __scanf__, fmtargnumber, fmtargnumber+1 ))) |
||
366 | #else |
||
367 | #define SDL_PRINTF_VARARG_FUNC( fmtargnumber ) |
||
368 | #define SDL_SCANF_VARARG_FUNC( fmtargnumber ) |
||
369 | #endif |
||
370 | #endif /* SDL_DISABLE_ANALYZE_MACROS */ |
||
371 | |||
372 | #ifndef SDL_COMPILE_TIME_ASSERT |
||
373 | #if defined(__cplusplus) |
||
374 | #if (__cplusplus >= 201103L) |
||
375 | #define SDL_COMPILE_TIME_ASSERT(name, x) static_assert(x, #x) |
||
376 | #endif |
||
377 | #elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) |
||
378 | #define SDL_COMPILE_TIME_ASSERT(name, x) _Static_assert(x, #x) |
||
379 | #endif |
||
380 | #endif /* !SDL_COMPILE_TIME_ASSERT */ |
||
381 | |||
382 | #ifndef SDL_COMPILE_TIME_ASSERT |
||
383 | /* universal, but may trigger -Wunused-local-typedefs */ |
||
384 | #define SDL_COMPILE_TIME_ASSERT(name, x) \ |
||
385 | typedef int SDL_compile_time_assert_ ## name[(x) * 2 - 1] |
||
386 | #endif |
||
387 | |||
388 | /** \cond */ |
||
389 | #ifndef DOXYGEN_SHOULD_IGNORE_THIS |
||
390 | SDL_COMPILE_TIME_ASSERT(uint8, sizeof(Uint8) == 1); |
||
391 | SDL_COMPILE_TIME_ASSERT(sint8, sizeof(Sint8) == 1); |
||
392 | SDL_COMPILE_TIME_ASSERT(uint16, sizeof(Uint16) == 2); |
||
393 | SDL_COMPILE_TIME_ASSERT(sint16, sizeof(Sint16) == 2); |
||
394 | SDL_COMPILE_TIME_ASSERT(uint32, sizeof(Uint32) == 4); |
||
395 | SDL_COMPILE_TIME_ASSERT(sint32, sizeof(Sint32) == 4); |
||
396 | SDL_COMPILE_TIME_ASSERT(uint64, sizeof(Uint64) == 8); |
||
397 | SDL_COMPILE_TIME_ASSERT(sint64, sizeof(Sint64) == 8); |
||
398 | #endif /* DOXYGEN_SHOULD_IGNORE_THIS */ |
||
399 | /** \endcond */ |
||
400 | |||
401 | /* Check to make sure enums are the size of ints, for structure packing. |
||
402 | For both Watcom C/C++ and Borland C/C++ the compiler option that makes |
||
403 | enums having the size of an int must be enabled. |
||
404 | This is "-b" for Borland C/C++ and "-ei" for Watcom C/C++ (v11). |
||
405 | */ |
||
406 | |||
407 | /** \cond */ |
||
408 | #ifndef DOXYGEN_SHOULD_IGNORE_THIS |
||
409 | #if !defined(__ANDROID__) && !defined(__VITA__) && !defined(__3DS__) |
||
410 | /* TODO: include/SDL_stdinc.h:174: error: size of array 'SDL_dummy_enum' is negative */ |
||
411 | typedef enum |
||
412 | { |
||
413 | DUMMY_ENUM_VALUE |
||
414 | } SDL_DUMMY_ENUM; |
||
415 | |||
416 | SDL_COMPILE_TIME_ASSERT(enum, sizeof(SDL_DUMMY_ENUM) == sizeof(int)); |
||
417 | #endif |
||
418 | #endif /* DOXYGEN_SHOULD_IGNORE_THIS */ |
||
419 | /** \endcond */ |
||
420 | |||
421 | #include "begin_code.h" |
||
422 | /* Set up for C function definitions, even when using C++ */ |
||
423 | #ifdef __cplusplus |
||
424 | extern "C" { |
||
425 | #endif |
||
426 | |||
427 | #ifdef HAVE_ALLOCA |
||
428 | #define SDL_stack_alloc(type, count) (type*)alloca(sizeof(type)*(count)) |
||
429 | #define SDL_stack_free(data) |
||
430 | #else |
||
431 | #define SDL_stack_alloc(type, count) (type*)SDL_malloc(sizeof(type)*(count)) |
||
432 | #define SDL_stack_free(data) SDL_free(data) |
||
433 | #endif |
||
434 | |||
435 | extern DECLSPEC void *SDLCALL SDL_malloc(size_t size); |
||
436 | extern DECLSPEC void *SDLCALL SDL_calloc(size_t nmemb, size_t size); |
||
437 | extern DECLSPEC void *SDLCALL SDL_realloc(void *mem, size_t size); |
||
438 | extern DECLSPEC void SDLCALL SDL_free(void *mem); |
||
439 | |||
440 | typedef void *(SDLCALL *SDL_malloc_func)(size_t size); |
||
441 | typedef void *(SDLCALL *SDL_calloc_func)(size_t nmemb, size_t size); |
||
442 | typedef void *(SDLCALL *SDL_realloc_func)(void *mem, size_t size); |
||
443 | typedef void (SDLCALL *SDL_free_func)(void *mem); |
||
444 | |||
445 | /** |
||
446 | * Get the original set of SDL memory functions |
||
447 | * |
||
448 | * \since This function is available since SDL 2.24.0. |
||
449 | */ |
||
450 | extern DECLSPEC void SDLCALL SDL_GetOriginalMemoryFunctions(SDL_malloc_func *malloc_func, |
||
451 | SDL_calloc_func *calloc_func, |
||
452 | SDL_realloc_func *realloc_func, |
||
453 | SDL_free_func *free_func); |
||
454 | |||
455 | /** |
||
456 | * Get the current set of SDL memory functions |
||
457 | * |
||
458 | * \since This function is available since SDL 2.0.7. |
||
459 | */ |
||
460 | extern DECLSPEC void SDLCALL SDL_GetMemoryFunctions(SDL_malloc_func *malloc_func, |
||
461 | SDL_calloc_func *calloc_func, |
||
462 | SDL_realloc_func *realloc_func, |
||
463 | SDL_free_func *free_func); |
||
464 | |||
465 | /** |
||
466 | * Replace SDL's memory allocation functions with a custom set |
||
467 | * |
||
468 | * \since This function is available since SDL 2.0.7. |
||
469 | */ |
||
470 | extern DECLSPEC int SDLCALL SDL_SetMemoryFunctions(SDL_malloc_func malloc_func, |
||
471 | SDL_calloc_func calloc_func, |
||
472 | SDL_realloc_func realloc_func, |
||
473 | SDL_free_func free_func); |
||
474 | |||
475 | /** |
||
476 | * Get the number of outstanding (unfreed) allocations |
||
477 | * |
||
478 | * \since This function is available since SDL 2.0.7. |
||
479 | */ |
||
480 | extern DECLSPEC int SDLCALL SDL_GetNumAllocations(void); |
||
481 | |||
482 | extern DECLSPEC char *SDLCALL SDL_getenv(const char *name); |
||
483 | extern DECLSPEC int SDLCALL SDL_setenv(const char *name, const char *value, int overwrite); |
||
484 | |||
485 | extern DECLSPEC void SDLCALL SDL_qsort(void *base, size_t nmemb, size_t size, int (SDLCALL *compare) (const void *, const void *)); |
||
486 | extern DECLSPEC void * SDLCALL SDL_bsearch(const void *key, const void *base, size_t nmemb, size_t size, int (SDLCALL *compare) (const void *, const void *)); |
||
487 | |||
488 | extern DECLSPEC int SDLCALL SDL_abs(int x); |
||
489 | |||
490 | /* NOTE: these double-evaluate their arguments, so you should never have side effects in the parameters */ |
||
491 | #define SDL_min(x, y) (((x) < (y)) ? (x) : (y)) |
||
492 | #define SDL_max(x, y) (((x) > (y)) ? (x) : (y)) |
||
493 | #define SDL_clamp(x, a, b) (((x) < (a)) ? (a) : (((x) > (b)) ? (b) : (x))) |
||
494 | |||
495 | extern DECLSPEC int SDLCALL SDL_isalpha(int x); |
||
496 | extern DECLSPEC int SDLCALL SDL_isalnum(int x); |
||
497 | extern DECLSPEC int SDLCALL SDL_isblank(int x); |
||
498 | extern DECLSPEC int SDLCALL SDL_iscntrl(int x); |
||
499 | extern DECLSPEC int SDLCALL SDL_isdigit(int x); |
||
500 | extern DECLSPEC int SDLCALL SDL_isxdigit(int x); |
||
501 | extern DECLSPEC int SDLCALL SDL_ispunct(int x); |
||
502 | extern DECLSPEC int SDLCALL SDL_isspace(int x); |
||
503 | extern DECLSPEC int SDLCALL SDL_isupper(int x); |
||
504 | extern DECLSPEC int SDLCALL SDL_islower(int x); |
||
505 | extern DECLSPEC int SDLCALL SDL_isprint(int x); |
||
506 | extern DECLSPEC int SDLCALL SDL_isgraph(int x); |
||
507 | extern DECLSPEC int SDLCALL SDL_toupper(int x); |
||
508 | extern DECLSPEC int SDLCALL SDL_tolower(int x); |
||
509 | |||
510 | extern DECLSPEC Uint16 SDLCALL SDL_crc16(Uint16 crc, const void *data, size_t len); |
||
511 | extern DECLSPEC Uint32 SDLCALL SDL_crc32(Uint32 crc, const void *data, size_t len); |
||
512 | |||
513 | extern DECLSPEC void *SDLCALL SDL_memset(SDL_OUT_BYTECAP(len) void *dst, int c, size_t len); |
||
514 | |||
515 | #define SDL_zero(x) SDL_memset(&(x), 0, sizeof((x))) |
||
516 | #define SDL_zerop(x) SDL_memset((x), 0, sizeof(*(x))) |
||
517 | #define SDL_zeroa(x) SDL_memset((x), 0, sizeof((x))) |
||
518 | |||
519 | #define SDL_copyp(dst, src) \ |
||
520 | { SDL_COMPILE_TIME_ASSERT(SDL_copyp, sizeof (*(dst)) == sizeof (*(src))); } \ |
||
521 | SDL_memcpy((dst), (src), sizeof (*(src))) |
||
522 | |||
523 | |||
524 | /* Note that memset() is a byte assignment and this is a 32-bit assignment, so they're not directly equivalent. */ |
||
525 | SDL_FORCE_INLINE void SDL_memset4(void *dst, Uint32 val, size_t dwords) |
||
526 | { |
||
527 | #if defined(__GNUC__) && defined(__i386__) |
||
528 | int u0, u1, u2; |
||
529 | __asm__ __volatile__ ( |
||
530 | "cld \n\t" |
||
531 | "rep ; stosl \n\t" |
||
532 | : "=&D" (u0), "=&a" (u1), "=&c" (u2) |
||
533 | : "0" (dst), "1" (val), "2" (SDL_static_cast(Uint32, dwords)) |
||
534 | : "memory" |
||
535 | ); |
||
536 | #else |
||
537 | size_t _n = (dwords + 3) / 4; |
||
538 | Uint32 *_p = SDL_static_cast(Uint32 *, dst); |
||
539 | Uint32 _val = (val); |
||
540 | if (dwords == 0) { |
||
541 | return; |
||
542 | } |
||
543 | switch (dwords % 4) { |
||
544 | case 0: do { *_p++ = _val; SDL_FALLTHROUGH; |
||
545 | case 3: *_p++ = _val; SDL_FALLTHROUGH; |
||
546 | case 2: *_p++ = _val; SDL_FALLTHROUGH; |
||
547 | case 1: *_p++ = _val; |
||
548 | } while ( --_n ); |
||
549 | } |
||
550 | #endif |
||
551 | } |
||
552 | |||
553 | extern DECLSPEC void *SDLCALL SDL_memcpy(SDL_OUT_BYTECAP(len) void *dst, SDL_IN_BYTECAP(len) const void *src, size_t len); |
||
554 | |||
555 | extern DECLSPEC void *SDLCALL SDL_memmove(SDL_OUT_BYTECAP(len) void *dst, SDL_IN_BYTECAP(len) const void *src, size_t len); |
||
556 | extern DECLSPEC int SDLCALL SDL_memcmp(const void *s1, const void *s2, size_t len); |
||
557 | |||
558 | extern DECLSPEC size_t SDLCALL SDL_wcslen(const wchar_t *wstr); |
||
559 | extern DECLSPEC size_t SDLCALL SDL_wcslcpy(SDL_OUT_Z_CAP(maxlen) wchar_t *dst, const wchar_t *src, size_t maxlen); |
||
560 | extern DECLSPEC size_t SDLCALL SDL_wcslcat(SDL_INOUT_Z_CAP(maxlen) wchar_t *dst, const wchar_t *src, size_t maxlen); |
||
561 | extern DECLSPEC wchar_t *SDLCALL SDL_wcsdup(const wchar_t *wstr); |
||
562 | extern DECLSPEC wchar_t *SDLCALL SDL_wcsstr(const wchar_t *haystack, const wchar_t *needle); |
||
563 | |||
564 | extern DECLSPEC int SDLCALL SDL_wcscmp(const wchar_t *str1, const wchar_t *str2); |
||
565 | extern DECLSPEC int SDLCALL SDL_wcsncmp(const wchar_t *str1, const wchar_t *str2, size_t maxlen); |
||
566 | extern DECLSPEC int SDLCALL SDL_wcscasecmp(const wchar_t *str1, const wchar_t *str2); |
||
567 | extern DECLSPEC int SDLCALL SDL_wcsncasecmp(const wchar_t *str1, const wchar_t *str2, size_t len); |
||
568 | |||
569 | extern DECLSPEC size_t SDLCALL SDL_strlen(const char *str); |
||
570 | extern DECLSPEC size_t SDLCALL SDL_strlcpy(SDL_OUT_Z_CAP(maxlen) char *dst, const char *src, size_t maxlen); |
||
571 | extern DECLSPEC size_t SDLCALL SDL_utf8strlcpy(SDL_OUT_Z_CAP(dst_bytes) char *dst, const char *src, size_t dst_bytes); |
||
572 | extern DECLSPEC size_t SDLCALL SDL_strlcat(SDL_INOUT_Z_CAP(maxlen) char *dst, const char *src, size_t maxlen); |
||
573 | extern DECLSPEC char *SDLCALL SDL_strdup(const char *str); |
||
574 | extern DECLSPEC char *SDLCALL SDL_strrev(char *str); |
||
575 | extern DECLSPEC char *SDLCALL SDL_strupr(char *str); |
||
576 | extern DECLSPEC char *SDLCALL SDL_strlwr(char *str); |
||
577 | extern DECLSPEC char *SDLCALL SDL_strchr(const char *str, int c); |
||
578 | extern DECLSPEC char *SDLCALL SDL_strrchr(const char *str, int c); |
||
579 | extern DECLSPEC char *SDLCALL SDL_strstr(const char *haystack, const char *needle); |
||
580 | extern DECLSPEC char *SDLCALL SDL_strcasestr(const char *haystack, const char *needle); |
||
581 | extern DECLSPEC char *SDLCALL SDL_strtokr(char *s1, const char *s2, char **saveptr); |
||
582 | extern DECLSPEC size_t SDLCALL SDL_utf8strlen(const char *str); |
||
583 | extern DECLSPEC size_t SDLCALL SDL_utf8strnlen(const char *str, size_t bytes); |
||
584 | |||
585 | extern DECLSPEC char *SDLCALL SDL_itoa(int value, char *str, int radix); |
||
586 | extern DECLSPEC char *SDLCALL SDL_uitoa(unsigned int value, char *str, int radix); |
||
587 | extern DECLSPEC char *SDLCALL SDL_ltoa(long value, char *str, int radix); |
||
588 | extern DECLSPEC char *SDLCALL SDL_ultoa(unsigned long value, char *str, int radix); |
||
589 | extern DECLSPEC char *SDLCALL SDL_lltoa(Sint64 value, char *str, int radix); |
||
590 | extern DECLSPEC char *SDLCALL SDL_ulltoa(Uint64 value, char *str, int radix); |
||
591 | |||
592 | extern DECLSPEC int SDLCALL SDL_atoi(const char *str); |
||
593 | extern DECLSPEC double SDLCALL SDL_atof(const char *str); |
||
594 | extern DECLSPEC long SDLCALL SDL_strtol(const char *str, char **endp, int base); |
||
595 | extern DECLSPEC unsigned long SDLCALL SDL_strtoul(const char *str, char **endp, int base); |
||
596 | extern DECLSPEC Sint64 SDLCALL SDL_strtoll(const char *str, char **endp, int base); |
||
597 | extern DECLSPEC Uint64 SDLCALL SDL_strtoull(const char *str, char **endp, int base); |
||
598 | extern DECLSPEC double SDLCALL SDL_strtod(const char *str, char **endp); |
||
599 | |||
600 | extern DECLSPEC int SDLCALL SDL_strcmp(const char *str1, const char *str2); |
||
601 | extern DECLSPEC int SDLCALL SDL_strncmp(const char *str1, const char *str2, size_t maxlen); |
||
602 | extern DECLSPEC int SDLCALL SDL_strcasecmp(const char *str1, const char *str2); |
||
603 | extern DECLSPEC int SDLCALL SDL_strncasecmp(const char *str1, const char *str2, size_t len); |
||
604 | |||
605 | extern DECLSPEC int SDLCALL SDL_sscanf(const char *text, SDL_SCANF_FORMAT_STRING const char *fmt, ...) SDL_SCANF_VARARG_FUNC(2); |
||
606 | extern DECLSPEC int SDLCALL SDL_vsscanf(const char *text, const char *fmt, va_list ap); |
||
607 | extern DECLSPEC int SDLCALL SDL_snprintf(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, SDL_PRINTF_FORMAT_STRING const char *fmt, ... ) SDL_PRINTF_VARARG_FUNC(3); |
||
608 | extern DECLSPEC int SDLCALL SDL_vsnprintf(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, const char *fmt, va_list ap); |
||
609 | extern DECLSPEC int SDLCALL SDL_asprintf(char **strp, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(2); |
||
610 | extern DECLSPEC int SDLCALL SDL_vasprintf(char **strp, const char *fmt, va_list ap); |
||
611 | |||
612 | #ifndef HAVE_M_PI |
||
613 | #ifndef M_PI |
||
614 | #define M_PI 3.14159265358979323846264338327950288 /**< pi */ |
||
615 | #endif |
||
616 | #endif |
||
617 | |||
618 | /** |
||
619 | * Use this function to compute arc cosine of `x`. |
||
620 | * |
||
621 | * The definition of `y = acos(x)` is `x = cos(y)`. |
||
622 | * |
||
623 | * Domain: `-1 <= x <= 1` |
||
624 | * |
||
625 | * Range: `0 <= y <= Pi` |
||
626 | * |
||
627 | * \param x floating point value, in radians. |
||
628 | * \returns arc cosine of `x`. |
||
629 | * |
||
630 | * \since This function is available since SDL 2.0.2. |
||
631 | */ |
||
632 | extern DECLSPEC double SDLCALL SDL_acos(double x); |
||
633 | extern DECLSPEC float SDLCALL SDL_acosf(float x); |
||
634 | extern DECLSPEC double SDLCALL SDL_asin(double x); |
||
635 | extern DECLSPEC float SDLCALL SDL_asinf(float x); |
||
636 | extern DECLSPEC double SDLCALL SDL_atan(double x); |
||
637 | extern DECLSPEC float SDLCALL SDL_atanf(float x); |
||
638 | extern DECLSPEC double SDLCALL SDL_atan2(double y, double x); |
||
639 | extern DECLSPEC float SDLCALL SDL_atan2f(float y, float x); |
||
640 | extern DECLSPEC double SDLCALL SDL_ceil(double x); |
||
641 | extern DECLSPEC float SDLCALL SDL_ceilf(float x); |
||
642 | extern DECLSPEC double SDLCALL SDL_copysign(double x, double y); |
||
643 | extern DECLSPEC float SDLCALL SDL_copysignf(float x, float y); |
||
644 | extern DECLSPEC double SDLCALL SDL_cos(double x); |
||
645 | extern DECLSPEC float SDLCALL SDL_cosf(float x); |
||
646 | extern DECLSPEC double SDLCALL SDL_exp(double x); |
||
647 | extern DECLSPEC float SDLCALL SDL_expf(float x); |
||
648 | extern DECLSPEC double SDLCALL SDL_fabs(double x); |
||
649 | extern DECLSPEC float SDLCALL SDL_fabsf(float x); |
||
650 | extern DECLSPEC double SDLCALL SDL_floor(double x); |
||
651 | extern DECLSPEC float SDLCALL SDL_floorf(float x); |
||
652 | extern DECLSPEC double SDLCALL SDL_trunc(double x); |
||
653 | extern DECLSPEC float SDLCALL SDL_truncf(float x); |
||
654 | extern DECLSPEC double SDLCALL SDL_fmod(double x, double y); |
||
655 | extern DECLSPEC float SDLCALL SDL_fmodf(float x, float y); |
||
656 | extern DECLSPEC double SDLCALL SDL_log(double x); |
||
657 | extern DECLSPEC float SDLCALL SDL_logf(float x); |
||
658 | extern DECLSPEC double SDLCALL SDL_log10(double x); |
||
659 | extern DECLSPEC float SDLCALL SDL_log10f(float x); |
||
660 | extern DECLSPEC double SDLCALL SDL_pow(double x, double y); |
||
661 | extern DECLSPEC float SDLCALL SDL_powf(float x, float y); |
||
662 | extern DECLSPEC double SDLCALL SDL_round(double x); |
||
663 | extern DECLSPEC float SDLCALL SDL_roundf(float x); |
||
664 | extern DECLSPEC long SDLCALL SDL_lround(double x); |
||
665 | extern DECLSPEC long SDLCALL SDL_lroundf(float x); |
||
666 | extern DECLSPEC double SDLCALL SDL_scalbn(double x, int n); |
||
667 | extern DECLSPEC float SDLCALL SDL_scalbnf(float x, int n); |
||
668 | extern DECLSPEC double SDLCALL SDL_sin(double x); |
||
669 | extern DECLSPEC float SDLCALL SDL_sinf(float x); |
||
670 | extern DECLSPEC double SDLCALL SDL_sqrt(double x); |
||
671 | extern DECLSPEC float SDLCALL SDL_sqrtf(float x); |
||
672 | extern DECLSPEC double SDLCALL SDL_tan(double x); |
||
673 | extern DECLSPEC float SDLCALL SDL_tanf(float x); |
||
674 | |||
675 | /* The SDL implementation of iconv() returns these error codes */ |
||
676 | #define SDL_ICONV_ERROR (size_t)-1 |
||
677 | #define SDL_ICONV_E2BIG (size_t)-2 |
||
678 | #define SDL_ICONV_EILSEQ (size_t)-3 |
||
679 | #define SDL_ICONV_EINVAL (size_t)-4 |
||
680 | |||
681 | /* SDL_iconv_* are now always real symbols/types, not macros or inlined. */ |
||
682 | typedef struct _SDL_iconv_t *SDL_iconv_t; |
||
683 | extern DECLSPEC SDL_iconv_t SDLCALL SDL_iconv_open(const char *tocode, |
||
684 | const char *fromcode); |
||
685 | extern DECLSPEC int SDLCALL SDL_iconv_close(SDL_iconv_t cd); |
||
686 | extern DECLSPEC size_t SDLCALL SDL_iconv(SDL_iconv_t cd, const char **inbuf, |
||
687 | size_t * inbytesleft, char **outbuf, |
||
688 | size_t * outbytesleft); |
||
689 | |||
690 | /** |
||
691 | * This function converts a buffer or string between encodings in one pass, returning a |
||
692 | * string that must be freed with SDL_free() or NULL on error. |
||
693 | * |
||
694 | * \since This function is available since SDL 2.0.0. |
||
695 | */ |
||
696 | extern DECLSPEC char *SDLCALL SDL_iconv_string(const char *tocode, |
||
697 | const char *fromcode, |
||
698 | const char *inbuf, |
||
699 | size_t inbytesleft); |
||
700 | #define SDL_iconv_utf8_locale(S) SDL_iconv_string("", "UTF-8", S, SDL_strlen(S)+1) |
||
701 | #define SDL_iconv_utf8_ucs2(S) (Uint16 *)SDL_iconv_string("UCS-2-INTERNAL", "UTF-8", S, SDL_strlen(S)+1) |
||
702 | #define SDL_iconv_utf8_ucs4(S) (Uint32 *)SDL_iconv_string("UCS-4-INTERNAL", "UTF-8", S, SDL_strlen(S)+1) |
||
703 | #define SDL_iconv_wchar_utf8(S) SDL_iconv_string("UTF-8", "WCHAR_T", (char *)S, (SDL_wcslen(S)+1)*sizeof(wchar_t)) |
||
704 | |||
705 | /* force builds using Clang's static analysis tools to use literal C runtime |
||
706 | here, since there are possibly tests that are ineffective otherwise. */ |
||
707 | #if defined(__clang_analyzer__) && !defined(SDL_DISABLE_ANALYZE_MACROS) |
||
708 | |||
709 | /* The analyzer knows about strlcpy even when the system doesn't provide it */ |
||
710 | #ifndef HAVE_STRLCPY |
||
711 | size_t strlcpy(char* dst, const char* src, size_t size); |
||
712 | #endif |
||
713 | |||
714 | /* The analyzer knows about strlcat even when the system doesn't provide it */ |
||
715 | #ifndef HAVE_STRLCAT |
||
716 | size_t strlcat(char* dst, const char* src, size_t size); |
||
717 | #endif |
||
718 | |||
719 | #ifndef HAVE_WCSLCPY |
||
720 | size_t wcslcpy(wchar_t *dst, const wchar_t *src, size_t size); |
||
721 | #endif |
||
722 | |||
723 | #ifndef HAVE_WCSLCAT |
||
724 | size_t wcslcat(wchar_t *dst, const wchar_t *src, size_t size); |
||
725 | #endif |
||
726 | |||
727 | /* Starting LLVM 16, the analyser errors out if these functions do not have |
||
728 | their prototype defined (clang-diagnostic-implicit-function-declaration) */ |
||
729 | #include <stdlib.h> |
||
730 | #include <string.h> |
||
731 | #include <stdio.h> |
||
732 | |||
733 | #define SDL_malloc malloc |
||
734 | #define SDL_calloc calloc |
||
735 | #define SDL_realloc realloc |
||
736 | #define SDL_free free |
||
737 | #define SDL_memset memset |
||
738 | #define SDL_memcpy memcpy |
||
739 | #define SDL_memmove memmove |
||
740 | #define SDL_memcmp memcmp |
||
741 | #define SDL_strlcpy strlcpy |
||
742 | #define SDL_strlcat strlcat |
||
743 | #define SDL_strlen strlen |
||
744 | #define SDL_wcslen wcslen |
||
745 | #define SDL_wcslcpy wcslcpy |
||
746 | #define SDL_wcslcat wcslcat |
||
747 | #define SDL_strdup strdup |
||
748 | #define SDL_wcsdup wcsdup |
||
749 | #define SDL_strchr strchr |
||
750 | #define SDL_strrchr strrchr |
||
751 | #define SDL_strstr strstr |
||
752 | #define SDL_wcsstr wcsstr |
||
753 | #define SDL_strtokr strtok_r |
||
754 | #define SDL_strcmp strcmp |
||
755 | #define SDL_wcscmp wcscmp |
||
756 | #define SDL_strncmp strncmp |
||
757 | #define SDL_wcsncmp wcsncmp |
||
758 | #define SDL_strcasecmp strcasecmp |
||
759 | #define SDL_strncasecmp strncasecmp |
||
760 | #define SDL_sscanf sscanf |
||
761 | #define SDL_vsscanf vsscanf |
||
762 | #define SDL_snprintf snprintf |
||
763 | #define SDL_vsnprintf vsnprintf |
||
764 | #endif |
||
765 | |||
766 | SDL_FORCE_INLINE void *SDL_memcpy4(SDL_OUT_BYTECAP(dwords*4) void *dst, SDL_IN_BYTECAP(dwords*4) const void *src, size_t dwords) |
||
767 | { |
||
768 | return SDL_memcpy(dst, src, dwords * 4); |
||
769 | } |
||
770 | |||
771 | /** |
||
772 | * If a * b would overflow, return -1. Otherwise store a * b via ret |
||
773 | * and return 0. |
||
774 | * |
||
775 | * \since This function is available since SDL 2.24.0. |
||
776 | */ |
||
777 | SDL_FORCE_INLINE int SDL_size_mul_overflow (size_t a, |
||
778 | size_t b, |
||
779 | size_t *ret) |
||
780 | { |
||
781 | if (a != 0 && b > SDL_SIZE_MAX / a) { |
||
782 | return -1; |
||
783 | } |
||
784 | *ret = a * b; |
||
785 | return 0; |
||
786 | } |
||
787 | |||
788 | #if _SDL_HAS_BUILTIN(__builtin_mul_overflow) |
||
789 | /* This needs to be wrapped in an inline rather than being a direct #define, |
||
790 | * because __builtin_mul_overflow() is type-generic, but we want to be |
||
791 | * consistent about interpreting a and b as size_t. */ |
||
792 | SDL_FORCE_INLINE int _SDL_size_mul_overflow_builtin (size_t a, |
||
793 | size_t b, |
||
794 | size_t *ret) |
||
795 | { |
||
796 | return __builtin_mul_overflow(a, b, ret) == 0 ? 0 : -1; |
||
797 | } |
||
798 | #define SDL_size_mul_overflow(a, b, ret) (_SDL_size_mul_overflow_builtin(a, b, ret)) |
||
799 | #endif |
||
800 | |||
801 | /** |
||
802 | * If a + b would overflow, return -1. Otherwise store a + b via ret |
||
803 | * and return 0. |
||
804 | * |
||
805 | * \since This function is available since SDL 2.24.0. |
||
806 | */ |
||
807 | SDL_FORCE_INLINE int SDL_size_add_overflow (size_t a, |
||
808 | size_t b, |
||
809 | size_t *ret) |
||
810 | { |
||
811 | if (b > SDL_SIZE_MAX - a) { |
||
812 | return -1; |
||
813 | } |
||
814 | *ret = a + b; |
||
815 | return 0; |
||
816 | } |
||
817 | |||
818 | #if _SDL_HAS_BUILTIN(__builtin_add_overflow) |
||
819 | /* This needs to be wrapped in an inline rather than being a direct #define, |
||
820 | * the same as the call to __builtin_mul_overflow() above. */ |
||
821 | SDL_FORCE_INLINE int _SDL_size_add_overflow_builtin (size_t a, |
||
822 | size_t b, |
||
823 | size_t *ret) |
||
824 | { |
||
825 | return __builtin_add_overflow(a, b, ret) == 0 ? 0 : -1; |
||
826 | } |
||
827 | #define SDL_size_add_overflow(a, b, ret) (_SDL_size_add_overflow_builtin(a, b, ret)) |
||
828 | #endif |
||
829 | |||
830 | /* Ends C function definitions when using C++ */ |
||
831 | #ifdef __cplusplus |
||
832 | } |
||
833 | #endif |
||
834 | #include "close_code.h" |
||
835 | |||
836 | #endif /* SDL_stdinc_h_ */ |
||
837 | |||
838 | /* vi: set ts=4 sw=4 expandtab: */ |