This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_stdinc.h
810 lines (707 loc) · 28.1 KB
1
2
/*
Simple DirectMedia Layer
3
Copyright (C) 1997-2013 Sam Lantinga <slouken@libsdl.org>
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
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
93
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
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
/**
* \file SDL_stdinc.h
*
* This is a general header that includes C language support.
*/
#ifndef _SDL_stdinc_h
#define _SDL_stdinc_h
#include "SDL_config.h"
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_STDIO_H
#include <stdio.h>
#endif
#if defined(STDC_HEADERS)
# include <stdlib.h>
# include <stddef.h>
# include <stdarg.h>
#else
# if defined(HAVE_STDLIB_H)
# include <stdlib.h>
# elif defined(HAVE_MALLOC_H)
# include <malloc.h>
# endif
# if defined(HAVE_STDDEF_H)
# include <stddef.h>
# endif
# if defined(HAVE_STDARG_H)
# include <stdarg.h>
# endif
#endif
#ifdef HAVE_STRING_H
# if !defined(STDC_HEADERS) && defined(HAVE_MEMORY_H)
# include <memory.h>
# endif
# include <string.h>
#endif
#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif
#if defined(HAVE_INTTYPES_H)
# include <inttypes.h>
#elif defined(HAVE_STDINT_H)
# include <stdint.h>
#endif
#ifdef HAVE_CTYPE_H
# include <ctype.h>
#endif
#ifdef HAVE_MATH_H
# include <math.h>
#endif
#if defined(HAVE_ICONV) && defined(HAVE_ICONV_H)
# include <iconv.h>
#endif
/**
* The number of elements in an array.
*/
#define SDL_arraysize(array) (sizeof(array)/sizeof(array[0]))
#define SDL_TABLESIZE(table) SDL_arraysize(table)
/**
* \name Cast operators
*
* Use proper C++ casts when compiled as C++ to be compatible with the option
* -Wold-style-cast of GCC (and -Werror=old-style-cast in GCC 4.2 and above).
*/
/*@{*/
#ifdef __cplusplus
#define SDL_reinterpret_cast(type, expression) reinterpret_cast<type>(expression)
#define SDL_static_cast(type, expression) static_cast<type>(expression)
#else
#define SDL_reinterpret_cast(type, expression) ((type)(expression))
#define SDL_static_cast(type, expression) ((type)(expression))
#endif
/*@}*//*Cast operators*/
/* Define a four character code as a Uint32 */
#define SDL_FOURCC(A, B, C, D) \
((SDL_static_cast(Uint32, SDL_static_cast(Uint8, (A))) << 0) | \
(SDL_static_cast(Uint32, SDL_static_cast(Uint8, (B))) << 8) | \
(SDL_static_cast(Uint32, SDL_static_cast(Uint8, (C))) << 16) | \
(SDL_static_cast(Uint32, SDL_static_cast(Uint8, (D))) << 24))
/**
* \name Basic data types
*/
/*@{*/
typedef enum
{
SDL_FALSE = 0,
SDL_TRUE = 1
} SDL_bool;
/**
* \brief A signed 8-bit integer type.
*/
typedef int8_t Sint8;
/**
* \brief An unsigned 8-bit integer type.
*/
typedef uint8_t Uint8;
/**
* \brief A signed 16-bit integer type.
*/
typedef int16_t Sint16;
/**
* \brief An unsigned 16-bit integer type.
*/
typedef uint16_t Uint16;
/**
* \brief A signed 32-bit integer type.
*/
typedef int32_t Sint32;
/**
* \brief An unsigned 32-bit integer type.
*/
typedef uint32_t Uint32;
/**
* \brief A signed 64-bit integer type.
*/
typedef int64_t Sint64;
/**
* \brief An unsigned 64-bit integer type.
*/
typedef uint64_t Uint64;
/*@}*//*Basic data types*/
#define SDL_COMPILE_TIME_ASSERT(name, x) \
typedef int SDL_dummy_ ## name[(x) * 2 - 1]
/** \cond */
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
SDL_COMPILE_TIME_ASSERT(uint8, sizeof(Uint8) == 1);
SDL_COMPILE_TIME_ASSERT(sint8, sizeof(Sint8) == 1);
SDL_COMPILE_TIME_ASSERT(uint16, sizeof(Uint16) == 2);
SDL_COMPILE_TIME_ASSERT(sint16, sizeof(Sint16) == 2);
SDL_COMPILE_TIME_ASSERT(uint32, sizeof(Uint32) == 4);
SDL_COMPILE_TIME_ASSERT(sint32, sizeof(Sint32) == 4);
SDL_COMPILE_TIME_ASSERT(uint64, sizeof(Uint64) == 8);
SDL_COMPILE_TIME_ASSERT(sint64, sizeof(Sint64) == 8);
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
/** \endcond */
/* Check to make sure enums are the size of ints, for structure packing.
For both Watcom C/C++ and Borland C/C++ the compiler option that makes
enums having the size of an int must be enabled.
This is "-b" for Borland C/C++ and "-ei" for Watcom C/C++ (v11).
*/
/* Enable enums always int in CodeWarrior (for MPW use "-enum int") */
#ifdef __MWERKS__
#pragma enumsalwaysint on
#endif
/** \cond */
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
#if !defined(__NINTENDODS__) && !defined(__ANDROID__)
/* TODO: include/SDL_stdinc.h:174: error: size of array 'SDL_dummy_enum' is negative */
typedef enum
{
DUMMY_ENUM_VALUE
} SDL_DUMMY_ENUM;
SDL_COMPILE_TIME_ASSERT(enum, sizeof(SDL_DUMMY_ENUM) == sizeof(int));
#endif
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
/** \endcond */
197
198
199
200
#if !defined(wchar_t) && defined(__NINTENDODS__)
#define wchar_t short /* TODO: figure out why libnds doesn't have this */
#endif
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
#include "begin_code.h"
/* Set up for C function definitions, even when using C++ */
#ifdef __cplusplus
/* *INDENT-OFF* */
extern "C" {
/* *INDENT-ON* */
#endif
#if defined(HAVE_ALLOCA) && !defined(alloca)
# if defined(HAVE_ALLOCA_H)
# include <alloca.h>
# elif defined(__GNUC__)
# define alloca __builtin_alloca
# elif defined(_MSC_VER)
# include <malloc.h>
# define alloca _alloca
# elif defined(__WATCOMC__)
# include <malloc.h>
# elif defined(__BORLANDC__)
# include <malloc.h>
# elif defined(__DMC__)
# include <stdlib.h>
# elif defined(__AIX__)
#pragma alloca
# elif defined(__MRC__)
void *alloca(unsigned);
# else
char *alloca();
# endif
#endif
#ifdef HAVE_ALLOCA
#define SDL_stack_alloc(type, count) (type*)alloca(sizeof(type)*(count))
#define SDL_stack_free(data)
#else
#define SDL_stack_alloc(type, count) (type*)SDL_malloc(sizeof(type)*(count))
#define SDL_stack_free(data) SDL_free(data)
#endif
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
/* SDL stdinc inline functions:
The theory here is that, by default, we forcibly inline what we can--with
real inline functions that avoid macro side-effects--and your app will use
the inline version by default. However, we expose a non-inline version
too, which internally just wraps the inline version in a real function,
so the symbol is always available in the library even if your app
bypassed it with the inline version. The SDL_*_inline versions aren't
guaranteed to exist, so never call them directly; use SDL_* instead,
and trust the system to give you the right thing.
The benefit here is that you can dlsym() these functions, which you
couldn't if you had macros, you can link against a foreign build of SDL
even if you configured differently, and you can drop the unconfigured SDL
headers into a project without #defining HAVE_MALLOC (etc) and still link.
*/
extern DECLSPEC void *SDLCALL SDL_malloc(size_t size);
#ifdef HAVE_MALLOC
SDL_FORCE_INLINE void *SDL_malloc_inline(size_t size) { return malloc(size); }
#define SDL_malloc SDL_malloc_inline
#endif
extern DECLSPEC void *SDLCALL SDL_calloc(size_t nmemb, size_t size);
#ifdef HAVE_CALLOC
SDL_FORCE_INLINE void *SDL_calloc_inline(size_t nmemb, size_t size) { return calloc(nmemb, size); }
#define SDL_calloc SDL_calloc_inline
#endif
extern DECLSPEC void *SDLCALL SDL_realloc(void *mem, size_t size);
#ifdef HAVE_REALLOC
SDL_FORCE_INLINE void *SDL_realloc_inline(void *mem, size_t size) { return realloc(mem, size); }
#define SDL_realloc SDL_realloc_inline
#endif
extern DECLSPEC void SDLCALL SDL_free(void *mem);
#ifdef HAVE_FREE
SDL_FORCE_INLINE void SDL_free_inline(void *mem) { free(mem); }
#define SDL_free SDL_free_inline
#endif
281
extern DECLSPEC char *SDLCALL SDL_getenv(const char *name);
282
283
284
#ifdef HAVE_GETENV
SDL_FORCE_INLINE char *SDL_getenv_inline(const char *name) { return getenv(name); }
#define SDL_getenv SDL_getenv_inline
285
286
#endif
287
extern DECLSPEC int SDLCALL SDL_setenv(const char *name, const char *value, int overwrite);
288
#ifdef HAVE_SETENV
289
290
SDL_FORCE_INLINE int SDL_setenv_inline(const char *name, const char *value, int overwrite) { return setenv(name, value, overwrite); }
#define SDL_setenv SDL_setenv_inline
291
292
#endif
293
extern DECLSPEC void SDLCALL SDL_qsort(void *base, size_t nmemb, size_t size, int (*compare) (const void *, const void *));
294
#ifdef HAVE_QSORT
295
296
SDL_FORCE_INLINE void SDL_qsort_inline(void *base, size_t nmemb, size_t size, int (*compare) (const void *, const void *)) { return qsort(base, nmemb, size, compare); }
#define SDL_qsort SDL_qsort_inline
297
298
#endif
299
extern DECLSPEC int SDLCALL SDL_abs(int x);
300
#ifdef HAVE_ABS
301
SDL_FORCE_INLINE int SDL_abs_inline(int x) { return abs(x); }
302
#else
303
SDL_FORCE_INLINE int SDL_abs_inline(int x) { return ((x) < 0 ? -(x) : (x)); }
304
#endif
305
#define SDL_abs SDL_abs_inline
306
307
308
309
310
/* !!! FIXME: these have side effects. You probably shouldn't use them. */
/* !!! FIXME: Maybe we do forceinline functions of SDL_mini, SDL_minf, etc? */
#define SDL_min(x, y) (((x) < (y)) ? (x) : (y))
#define SDL_max(x, y) (((x) > (y)) ? (x) : (y))
311
312
313
314
315
extern DECLSPEC int SDLCALL SDL_isdigit(int x);
extern DECLSPEC int SDLCALL SDL_isspace(int x);
extern DECLSPEC int SDLCALL SDL_toupper(int x);
extern DECLSPEC int SDLCALL SDL_tolower(int x);
316
#ifdef HAVE_CTYPE_H
317
318
319
320
SDL_FORCE_INLINE int SDL_isdigit_inline(int x) { return isdigit(x); }
SDL_FORCE_INLINE int SDL_isspace_inline(int x) { return isspace(x); }
SDL_FORCE_INLINE int SDL_toupper_inline(int x) { return toupper(x); }
SDL_FORCE_INLINE int SDL_tolower_inline(int x) { return tolower(x); }
321
#else
322
323
324
325
SDL_FORCE_INLINE int SDL_isdigit_inline(int x) { return ((x) >= '0') && ((x) <= '9'); }
SDL_FORCE_INLINE int SDL_isspace_inline(int x) { return ((x) == ' ') || ((x) == '\t') || ((x) == '\r') || ((x) == '\n'); }
SDL_FORCE_INLINE int SDL_toupper_inline(int x) { return ((x) >= 'a') && ((x) <= 'z') ? ('A'+((x)-'a')) : (x); }
SDL_FORCE_INLINE int SDL_tolower_inline(int x) { return ((x) >= 'A') && ((x) <= 'Z') ? ('a'+((x)-'A')) : (x); }
326
#endif
327
328
329
330
#define SDL_isdigit SDL_isdigit_inline
#define SDL_isspace SDL_isspace_inline
#define SDL_toupper SDL_toupper_inline
#define SDL_tolower SDL_tolower_inline
331
332
extern DECLSPEC void *SDLCALL SDL_memset(void *dst, int c, size_t len);
333
334
335
#ifdef HAVE_MEMSET
SDL_FORCE_INLINE void *SDL_memset_inline(void *dst, int c, size_t len) { return memset(dst, c, len); }
#define SDL_memset SDL_memset_inline
336
337
#endif
338
339
340
341
342
343
#define SDL_zero(x) SDL_memset(&(x), 0, sizeof((x)))
#define SDL_zerop(x) SDL_memset((x), 0, sizeof(*(x)))
/* !!! FIXME: does this _really_ beat memset() on any modern platform? */
SDL_FORCE_INLINE void SDL_memset4(void *dst, int val, size_t len)
{
344
#if defined(__GNUC__) && defined(i386)
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
int u0, u1, u2;
__asm__ __volatile__ (
"cld \n\t"
"rep ; stosl \n\t"
: "=&D" (u0), "=&a" (u1), "=&c" (u2)
: "0" (dst), "1" (val), "2" (SDL_static_cast(Uint32, len))
: "memory"
);
/* !!! FIXME: amd64? */
#else
unsigned int _count = (len);
unsigned int _n = (_count + 3) / 4;
Uint32 *_p = SDL_static_cast(Uint32 *, dst);
Uint32 _val = (val);
if (len == 0)
return;
switch (_count % 4)
{
case 0: do { *_p++ = _val;
case 3: *_p++ = _val;
case 2: *_p++ = _val;
case 1: *_p++ = _val;
} while ( --_n );
}
#endif
}
extern DECLSPEC void *SDLCALL SDL_memcpy(void *dst, const void *src, size_t len);
374
#if defined(__MACOSX__)
375
376
377
378
379
380
SDL_FORCE_INLINE void *SDL_memcpy_inline(void *dst, const void *src, size_t len)
{
/* We can count on memcpy existing on Mac OS X and being well-tuned. */
return memcpy(dst, src, len);
}
#define SDL_memcpy SDL_memcpy_inline
381
#elif defined(__GNUC__) && defined(i386) && !defined(__WIN32__)
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
SDL_FORCE_INLINE void *SDL_memcpy_inline(void *dst, const void *src, size_t len)
{
/* !!! FIXME: does this _really_ beat memcpy() on any modern platform? */
/* !!! FIXME: shouldn't we just force the inputs to ecx/edi/esi instead of this tapdance with outputs? */
/* !!! FIXME: amd64? */
int u0, u1, u2;
__asm__ __volatile__ (
"cld \n\t"
"rep ; movsl \n\t"
"testb $2,%b4 \n\t"
"je 1f \n\t"
"movsw \n"
"1:\ttestb $1,%b4 \n\t"
"je 2f \n\t"
"movsb \n"
"2:"
: "=&c" (u0), "=&D" (u1), "=&S" (u2)
: "0" (SDL_static_cast(unsigned, len)/4), "q" (len), "1" (dst), "2" (src)
: "memory"
);
return dst;
}
#define SDL_memcpy SDL_memcpy_inline
#elif defined(HAVE_MEMCPY)
SDL_FORCE_INLINE void *SDL_memcpy_inline(void *dst, const void *src, size_t len)
{
return memcpy(dst, src, len);
}
#define SDL_memcpy SDL_memcpy_inline
#elif defined(HAVE_BCOPY) /* !!! FIXME: is there _really_ ever a time where you have bcopy and not memcpy? */
SDL_FORCE_INLINE void *SDL_memcpy_inline(void *dst, const void *src, size_t len)
{
bcopy(src, dst, len);
return dst;
}
#define SDL_memcpy SDL_memcpy_inline
418
419
#endif
420
421
422
SDL_FORCE_INLINE void *SDL_memcpy4(void *dst, const void *src, size_t dwords)
{
423
#if defined(__MACOSX__)
424
425
/* We can count on memcpy existing on Mac OS X and being well-tuned. */
return memcpy(dst, src, dwords * 4);
426
#elif defined(__GNUC__) && defined(i386)
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
/* !!! FIXME: does this _really_ beat memcpy() on any modern platform? */
/* !!! FIXME: shouldn't we just force the inputs to ecx/edi/esi instead of this tapdance with outputs? */
/* !!! FIXME: amd64? */
int ecx, edi, esi;
__asm__ __volatile__ (
"cld \n\t"
"rep ; movsl \n\t"
: "=&c" (ecx), "=&D" (edi), "=&S" (esi)
: "0" (SDL_static_cast(unsigned, len)), "1" (dst), "2" (src)
: "memory"
);
return dst;
#else
return SDL_memcpy(dst, src, dwords * 4);
#endif
}
extern DECLSPEC void *SDLCALL SDL_memmove(void *dst, const void *src, size_t len);
445
#ifdef HAVE_MEMMOVE
446
447
SDL_FORCE_INLINE void *SDL_memmove_inline(void *dst, const void *src, size_t len) { return memmove(dst, src, len); }
#define SDL_memmove SDL_memmove_inline
448
449
#endif
450
extern DECLSPEC int SDLCALL SDL_memcmp(const void *s1, const void *s2, size_t len);
451
#ifdef HAVE_MEMCMP
452
453
SDL_FORCE_INLINE int SDL_memcmp_inline(const void *s1, const void *s2, size_t len) { return memcmp(s1, s2, len); }
#define SDL_memcmp SDL_memcmp_inline
454
455
#endif
456
extern DECLSPEC size_t SDLCALL SDL_strlen(const char *str);
457
#ifdef HAVE_STRLEN
458
459
SDL_FORCE_INLINE size_t SDL_strlen_inline(const char *str) { return strlen(str); }
#define SDL_strlen SDL_strlen_inline
460
461
#endif
462
extern DECLSPEC size_t SDLCALL SDL_wcslen(const wchar_t *wstr);
463
#ifdef HAVE_WCSLEN
464
465
SDL_FORCE_INLINE size_t SDL_wcslen_inline(const wchar_t *wstr) { return wcslen(wstr); }
#define SDL_wcslen SDL_wcslen_inline
466
467
468
#endif
extern DECLSPEC size_t SDLCALL SDL_wcslcpy(wchar_t *dst, const wchar_t *src, size_t maxlen);
469
470
471
#ifdef HAVE_WCSLCPY
SDL_FORCE_INLINE size_t SDL_wcslcpy_inline(wchar_t *dst, const wchar_t *src, size_t maxlen) { return wcslcpy(dst, src, maxlen); }
#define SDL_wcslcpy SDL_wcslcpy_inline
472
473
474
#endif
extern DECLSPEC size_t SDLCALL SDL_wcslcat(wchar_t *dst, const wchar_t *src, size_t maxlen);
475
476
477
#ifdef HAVE_WCSLCAT
SDL_FORCE_INLINE size_t SDL_wcslcat_inline(wchar_t *dst, const wchar_t *src, size_t maxlen) { return wcslcat(dst, src, maxlen); }
#define SDL_wcslcat SDL_wcslcat_inline
478
479
#endif
480
extern DECLSPEC size_t SDLCALL SDL_strlcpy(char *dst, const char *src, size_t maxlen);
481
#ifdef HAVE_STRLCPY
482
483
SDL_FORCE_INLINE size_t SDL_strlcpy_inline(char *dst, const char *src, size_t maxlen) { return strlcpy(dst, src, maxlen); }
#define SDL_strlcpy SDL_strlcpy_inline
484
485
486
#else
#endif
487
extern DECLSPEC size_t SDLCALL SDL_utf8strlcpy(char *dst, const char *src, size_t dst_bytes);
488
489
extern DECLSPEC size_t SDLCALL SDL_strlcat(char *dst, const char *src, size_t maxlen);
490
#ifdef HAVE_STRLCAT
491
492
SDL_FORCE_INLINE size_t SDL_strlcat_inline(char *dst, const char *src, size_t maxlen) { return strlcat(dst, src, maxlen); }
#define SDL_strlcat SDL_strlcat_inline
493
494
#endif
495
extern DECLSPEC char *SDLCALL SDL_strdup(const char *str);
496
#ifdef HAVE_STRDUP
497
498
SDL_FORCE_INLINE char *SDL_strdup_inline(const char *str) { return strdup(str); }
#define SDL_strdup SDL_strdup_inline
499
500
#endif
501
extern DECLSPEC char *SDLCALL SDL_strrev(char *str);
502
#ifdef HAVE__STRREV
503
504
SDL_FORCE_INLINE char *SDL_strrev_inline(char *str) { return _strrev(str); }
#define SDL_strrev SDL_strrev_inline
505
506
#endif
507
extern DECLSPEC char *SDLCALL SDL_strupr(char *str);
508
#ifdef HAVE__STRUPR
509
510
SDL_FORCE_INLINE char *SDL_strupr_inline(char *str) { return _strupr(str); }
#define SDL_strupr SDL_strupr_inline
511
512
#endif
513
extern DECLSPEC char *SDLCALL SDL_strlwr(char *str);
514
#ifdef HAVE__STRLWR
515
516
SDL_FORCE_INLINE char *SDL_strlwr_inline(char *str) { return _strlwr(str); }
#define SDL_strlwr SDL_strlwr_inline
517
518
#endif
519
extern DECLSPEC char *SDLCALL SDL_strchr(const char *str, int c);
520
#ifdef HAVE_STRCHR
521
522
523
524
525
SDL_FORCE_INLINE char *SDL_strchr_inline(const char *str, int c) { return strchr(str, c); }
#define SDL_strchr SDL_strchr_inline
#elif defined(HAVE_INDEX) /* !!! FIXME: is there anywhere that has this but not strchr? */
SDL_FORCE_INLINE char *SDL_strchr_inline(const char *str, int c) { return index(str, c); }
#define SDL_strchr SDL_strchr_inline
526
527
#endif
528
extern DECLSPEC char *SDLCALL SDL_strrchr(const char *str, int c);
529
#ifdef HAVE_STRRCHR
530
531
532
533
534
SDL_FORCE_INLINE char *SDL_strrchr_inline(const char *str, int c) { return strrchr(str, c); }
#define SDL_strrchr SDL_strrchr_inline
#elif defined(HAVE_RINDEX) /* !!! FIXME: is there anywhere that has this but not strrchr? */
SDL_FORCE_INLINE char *SDL_strrchr_inline(const char *str, int c) { return rindex(str, c); }
#define SDL_strrchr SDL_strrchr_inline
535
536
#endif
537
extern DECLSPEC char *SDLCALL SDL_strstr(const char *haystack, const char *needle);
538
#ifdef HAVE_STRSTR
539
540
SDL_FORCE_INLINE char *SDL_strstr_inline(const char *haystack, const char *needle) { return strstr(haystack, needle); }
#define SDL_strstr SDL_strstr_inline
541
542
#endif
543
544
545
546
547
548
549
extern DECLSPEC char *SDLCALL SDL_ltoa(long value, char *str, int radix);
#ifdef HAVE__LTOA
SDL_FORCE_INLINE char *SDL_ltoa_inline(long value, char *str, int radix) { return _ltoa(value, str, radix); }
#define SDL_ltoa SDL_ltoa_inline
#endif
extern DECLSPEC char *SDLCALL SDL_itoa(int value, char *str, int radix);
550
#ifdef HAVE_ITOA
551
SDL_FORCE_INLINE char *SDL_itoa_inline(int value, char *str, int radix) { return itoa(value, str, radix); }
552
#else
553
SDL_FORCE_INLINE char *SDL_itoa_inline(int value, char *str, int radix) { return SDL_ltoa((long)value, str, radix); }
554
#endif
555
#define SDL_itoa SDL_itoa_inline
556
557
558
559
560
extern DECLSPEC char *SDLCALL SDL_ultoa(unsigned long value, char *str, int radix);
#ifdef HAVE__ULTOA
SDL_FORCE_INLINE char *SDL_ultoa_inline(unsigned long value, char *str, int radix) { return _ultoa(value, str, radix); }
#define SDL_ultoa SDL_ultoa_inline
561
562
#endif
563
extern DECLSPEC char *SDLCALL SDL_uitoa(unsigned int value, char *str, int radix);
564
#ifdef HAVE__UITOA
565
SDL_FORCE_INLINE char *SDL_uitoa_inline(unsigned int value, char *str, int radix) { return _uitoa(value, str, radix); }
566
#else
567
SDL_FORCE_INLINE char *SDL_uitoa_inline(unsigned int value, char *str, int radix) { return SDL_ultoa((unsigned long)value, str, radix); }
568
#endif
569
#define SDL_uitoa SDL_uitoa_inline
570
571
572
extern DECLSPEC long SDLCALL SDL_strtol(const char *str, char **endp, int base);
573
#ifdef HAVE_STRTOL
574
575
SDL_FORCE_INLINE long SDL_strtol_inline(const char *str, char **endp, int base) { return strtol(str, endp, base); }
#define SDL_strtol SDL_strtol_inline
576
577
#endif
578
extern DECLSPEC unsigned long SDLCALL SDL_strtoul(const char *str, char **endp, int base);
579
#ifdef HAVE_STRTOUL
580
581
SDL_FORCE_INLINE unsigned long SDLCALL SDL_strtoul_inline(const char *str, char **endp, int base) { return strtoul(str, endp, base); }
#define SDL_strtoul SDL_strtoul_inline
582
583
#endif
584
extern DECLSPEC char *SDLCALL SDL_lltoa(Sint64 value, char *str, int radix);
585
#ifdef HAVE__I64TOA
586
587
SDL_FORCE_INLINE char *SDL_lltoa_inline(Sint64 value, char *str, int radix) { return _i64toa(value, str, radix); }
#define SDL_lltoa SDL_lltoa_inline
588
589
#endif
590
extern DECLSPEC char *SDLCALL SDL_ulltoa(Uint64 value, char *str, int radix);
591
#ifdef HAVE__UI64TOA
592
593
SDL_FORCE_INLINE char *SDL_ulltoa_inline(Uint64 value, char *str, int radix) { return _ui64toa(value, str, radix); }
#define SDL_ulltoa SDL_ulltoa_inline
594
595
#endif
596
extern DECLSPEC Sint64 SDLCALL SDL_strtoll(const char *str, char **endp, int base);
597
#ifdef HAVE_STRTOLL
598
599
SDL_FORCE_INLINE Sint64 SDL_strtoll_inline(const char *str, char **endp, int base) { return strtoll(str, endp, base); }
#define SDL_strtoll SDL_strtoll_inline
600
601
#endif
602
extern DECLSPEC Uint64 SDLCALL SDL_strtoull(const char *str, char **endp, int base);
603
#ifdef HAVE_STRTOULL
604
605
SDL_FORCE_INLINE Uint64 SDL_strtoull_inline(const char *str, char **endp, int base) { return strtoull(str, endp, base); }
#define SDL_strtoull SDL_strtoull_inline
606
607
#endif
608
extern DECLSPEC double SDLCALL SDL_strtod(const char *str, char **endp);
609
#ifdef HAVE_STRTOD
610
611
SDL_FORCE_INLINE Uint64 SDL_strtod_inline(const char *str, char **endp) { return strtod(str, endp); }
#define SDL_strtod SDL_strtod_inline
612
613
#endif
614
extern DECLSPEC int SDLCALL SDL_atoi(const char *str);
615
#ifdef HAVE_ATOI
616
SDL_FORCE_INLINE int SDL_atoi_inline(const char *str) { return atoi(str); }
617
#else
618
SDL_FORCE_INLINE int SDL_atoi_inline(const char *str) { return SDL_strtol(str, NULL, 0); }
619
#endif
620
#define SDL_atoi SDL_atoi_inline
621
622
extern DECLSPEC double SDLCALL SDL_atof(const char *str);
623
#ifdef HAVE_ATOF
624
SDL_FORCE_INLINE double SDL_atof_inline(const char *str) { return (double) atof(str); }
625
#else
626
SDL_FORCE_INLINE double SDL_atof_inline(const char *str) { return SDL_strtod(str, NULL); }
627
#endif
628
629
#define SDL_atof SDL_atof_inline
630
631
extern DECLSPEC int SDLCALL SDL_strcmp(const char *str1, const char *str2);
632
633
634
#ifdef HAVE_STRCMP
SDL_FORCE_INLINE int SDL_strcmp_inline(const char *str1, const char *str2) { return strcmp(str1, str2); }
#define SDL_strcmp SDL_strcmp_inline
635
636
#endif
637
extern DECLSPEC int SDLCALL SDL_strncmp(const char *str1, const char *str2, size_t maxlen);
638
#ifdef HAVE_STRNCMP
639
640
SDL_FORCE_INLINE int SDL_strncmp_inline(const char *str1, const char *str2, size_t maxlen) { return strncmp(str1, str2, maxlen); }
#define SDL_strncmp SDL_strncmp_inline
641
642
#endif
643
extern DECLSPEC int SDLCALL SDL_strcasecmp(const char *str1, const char *str2);
644
#ifdef HAVE_STRCASECMP
645
646
SDL_FORCE_INLINE int SDL_strcasecmp_inline(const char *str1, const char *str2) { return strcasecmp(str1, str2); }
#define SDL_strcasecmp SDL_strcasecmp_inline
647
#elif defined(HAVE__STRICMP)
648
649
SDL_FORCE_INLINE int SDL_strcasecmp_inline(const char *str1, const char *str2) { return _stricmp(str1, str2); }
#define SDL_strcasecmp SDL_strcasecmp_inline
650
651
#endif
652
extern DECLSPEC int SDLCALL SDL_strncasecmp(const char *str1, const char *str2, size_t len);
653
#ifdef HAVE_STRNCASECMP
654
655
SDL_FORCE_INLINE int SDL_strncasecmp_inline(const char *str1, const char *str2, size_t len) { return strncasecmp(str1, str2, len); }
#define SDL_strncasecmp SDL_strncasecmp_inline
656
#elif defined(HAVE__STRNICMP)
657
658
SDL_FORCE_INLINE int SDL_strncasecmp_inline(const char *str1, const char *str2, size_t len) { return _strnicmp(str1, str2, len); }
#define SDL_strncasecmp SDL_strncasecmp_inline
659
660
#endif
661
662
/* Not doing SDL_*_inline functions for these, because of the varargs. */
extern DECLSPEC int SDLCALL SDL_sscanf(const char *text, const char *fmt, ...);
663
#ifdef HAVE_SSCANF
664
#define SDL_sscanf sscanf
665
666
#endif
667
extern DECLSPEC int SDLCALL SDL_snprintf(char *text, size_t maxlen, const char *fmt, ...);
668
#ifdef HAVE_SNPRINTF
669
#define SDL_snprintf snprintf
670
671
#endif
672
extern DECLSPEC int SDLCALL SDL_vsnprintf(char *text, size_t maxlen, const char *fmt, va_list ap);
673
#ifdef HAVE_VSNPRINTF
674
675
SDL_FORCE_INLINE int SDL_vsnprintf_inline(char *text, size_t maxlen, const char *fmt, va_list ap) { return vsnprintf(text, maxlen, fmt, ap); }
#define SDL_vsnprintf SDL_vsnprintf_inline
676
677
678
679
680
681
682
683
684
#endif
#ifndef HAVE_M_PI
#ifndef M_PI
#define M_PI 3.14159265358979323846264338327950288 /* pi */
#endif
#endif
extern DECLSPEC double SDLCALL SDL_atan(double x);
685
686
687
#ifdef HAVE_ATAN
SDL_FORCE_INLINE double SDL_atan_inline(double x) { return atan(x); }
#define SDL_atan SDL_atan_inline
688
689
#endif
690
extern DECLSPEC double SDLCALL SDL_atan2(double x, double y);
691
#ifdef HAVE_ATAN2
692
693
SDL_FORCE_INLINE double SDL_atan2_inline(double x, double y) { return atan2(x, y); }
#define SDL_atan2 SDL_atan2_inline
694
695
#endif
696
extern DECLSPEC double SDLCALL SDL_ceil(double x);
697
#ifdef HAVE_CEIL
698
SDL_FORCE_INLINE double SDL_ceil_inline(double x) { return ceil(x); }
699
#else
700
SDL_FORCE_INLINE double SDL_ceil_inline(double x) { return (double)(int)((x)+0.5); }
701
#endif
702
#define SDL_ceil SDL_ceil_inline
703
704
extern DECLSPEC double SDLCALL SDL_copysign(double x, double y);
705
706
707
#ifdef HAVE_COPYSIGN
SDL_FORCE_INLINE double SDL_copysign_inline(double x, double y) { return copysign(x, y); }
#define SDL_copysign SDL_copysign_inline
708
709
710
#endif
extern DECLSPEC double SDLCALL SDL_cos(double x);
711
712
713
#ifdef HAVE_COS
SDL_FORCE_INLINE double SDL_cos_inline(double x) { return cos(x); }
#define SDL_cos SDL_cos_inline
714
715
#endif
716
extern DECLSPEC float SDLCALL SDL_cosf(float x);
717
#ifdef HAVE_COSF
718
SDL_FORCE_INLINE float SDL_cosf_inline(float x) { return cosf(x); }
719
#else
720
SDL_FORCE_INLINE float SDL_cosf_inline(float x) { return (float)SDL_cos((double)x); }
721
#endif
722
#define SDL_cosf SDL_cosf_inline
723
724
extern DECLSPEC double SDLCALL SDL_fabs(double x);
725
726
727
#ifdef HAVE_FABS
SDL_FORCE_INLINE double SDL_fabs_inline(double x) { return fabs(x); }
#define SDL_fabs SDL_fabs_inline
728
729
730
#endif
extern DECLSPEC double SDLCALL SDL_floor(double x);
731
732
733
#ifdef HAVE_FLOOR
SDL_FORCE_INLINE double SDL_floor_inline(double x) { return floor(x); }
#define SDL_floor SDL_floor_inline
734
735
736
#endif
extern DECLSPEC double SDLCALL SDL_log(double x);
737
738
739
#ifdef HAVE_LOG
SDL_FORCE_INLINE double SDL_log_inline(double x) { return log(x); }
#define SDL_log SDL_log_inline
740
741
742
#endif
extern DECLSPEC double SDLCALL SDL_pow(double x, double y);
743
744
745
#ifdef HAVE_POW
SDL_FORCE_INLINE double SDL_pow_inline(double x, double y) { return pow(x, y); }
#define SDL_pow SDL_pow_inline
746
747
748
#endif
extern DECLSPEC double SDLCALL SDL_scalbn(double x, int n);
749
750
751
#ifdef HAVE_SCALBN
SDL_FORCE_INLINE double SDL_scalbn_inline(double x, int n) { return scalbn(x, n); }
#define SDL_scalbn SDL_scalbn_inline
752
753
754
#endif
extern DECLSPEC double SDLCALL SDL_sin(double x);
755
756
757
#ifdef HAVE_SIN
SDL_FORCE_INLINE double SDL_sin_inline(double x) { return sin(x); }
#define SDL_sin SDL_sin_inline
758
759
#endif
760
extern DECLSPEC float SDLCALL SDL_sinf(float x);
761
#ifdef HAVE_SINF
762
SDL_FORCE_INLINE float SDL_sinf_inline(float x) { return sinf(x); }
763
#else
764
SDL_FORCE_INLINE float SDL_sinf_inline(float x) { return (float)SDL_sin((double)x); }
765
#endif
766
#define SDL_sinf SDL_sinf_inline
767
768
extern DECLSPEC double SDLCALL SDL_sqrt(double x);
769
770
771
#ifdef HAVE_SQRT
SDL_FORCE_INLINE double SDL_sqrt_inline(double x) { return sqrt(x); }
#define SDL_sqrt SDL_sqrt_inline
772
773
774
775
776
777
778
779
#endif
/* The SDL implementation of iconv() returns these error codes */
#define SDL_ICONV_ERROR (size_t)-1
#define SDL_ICONV_E2BIG (size_t)-2
#define SDL_ICONV_EILSEQ (size_t)-3
#define SDL_ICONV_EINVAL (size_t)-4
780
/* SDL_iconv_* are now always real symbols/types, not macros or inlined. */
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
typedef struct _SDL_iconv_t *SDL_iconv_t;
extern DECLSPEC SDL_iconv_t SDLCALL SDL_iconv_open(const char *tocode,
const char *fromcode);
extern DECLSPEC int SDLCALL SDL_iconv_close(SDL_iconv_t cd);
extern DECLSPEC size_t SDLCALL SDL_iconv(SDL_iconv_t cd, const char **inbuf,
size_t * inbytesleft, char **outbuf,
size_t * outbytesleft);
/**
* This function converts a string between encodings in one pass, returning a
* string that must be freed with SDL_free() or NULL on error.
*/
extern DECLSPEC char *SDLCALL SDL_iconv_string(const char *tocode,
const char *fromcode,
const char *inbuf,
size_t inbytesleft);
#define SDL_iconv_utf8_locale(S) SDL_iconv_string("", "UTF-8", S, SDL_strlen(S)+1)
#define SDL_iconv_utf8_ucs2(S) (Uint16 *)SDL_iconv_string("UCS-2-INTERNAL", "UTF-8", S, SDL_strlen(S)+1)
#define SDL_iconv_utf8_ucs4(S) (Uint32 *)SDL_iconv_string("UCS-4-INTERNAL", "UTF-8", S, SDL_strlen(S)+1)
/* Ends C function definitions when using C++ */
#ifdef __cplusplus
/* *INDENT-OFF* */
}
/* *INDENT-ON* */
#endif
#include "close_code.h"
#endif /* _SDL_stdinc_h */
/* vi: set ts=4 sw=4 expandtab: */