hedgewars: comparison misc/winutils/include/SDL

equal deleted inserted replaced

-:4feced261c68
+:de822cd3df3a
 #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_arraysize(array)    (sizeof(array)/sizeof(array[0]))
-#define SDL_TABLESIZE(table)	SDL_arraysize(table)
+#define SDL_TABLESIZE(table)    SDL_arraysize(table)
 /* 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)
 #endif
 /** @name Basic data types */
 /*@{*/
 typedef enum {
-	SDL_FALSE = 0,
+SDL_FALSE = 0,
-	SDL_TRUE  = 1
+SDL_TRUE  = 1
 } SDL_bool;
-typedef int8_t		Sint8;
+typedef int8_t      Sint8;
-typedef uint8_t		Uint8;
+typedef uint8_t     Uint8;
-typedef int16_t		Sint16;
+typedef int16_t     Sint16;
-typedef uint16_t	Uint16;
+typedef uint16_t    Uint16;
-typedef int32_t		Sint32;
+typedef int32_t     Sint32;
-typedef uint32_t	Uint32;
+typedef uint32_t    Uint32;
 #ifdef SDL_HAS_64BIT_TYPE
-typedef int64_t		Sint64;
+typedef int64_t     Sint64;
 #ifndef SYMBIAN32_GCCE
-typedef uint64_t	Uint64;
+typedef uint64_t    Uint64;
 #endif
 #else
 /* This is really just a hack to prevent the compiler from complaining */
 typedef struct {
-	Uint32 hi;
+Uint32 hi;
-	Uint32 lo;
+Uint32 lo;
 } Uint64, Sint64;
 #endif
 /*@}*/
 #ifdef __MWERKS__
 #pragma enumsalwaysint on
 #endif
 typedef enum {
-	DUMMY_ENUM_VALUE
+DUMMY_ENUM_VALUE
 } SDL_DUMMY_ENUM;
 #ifndef __NDS__
 SDL_COMPILE_TIME_ASSERT(enum, sizeof(SDL_DUMMY_ENUM) == sizeof(int));
 #endif
 #ifdef __cplusplus
 extern "C" {
 #endif
 #ifdef HAVE_MALLOC
-#define SDL_malloc	malloc
+#define SDL_malloc  malloc
 #else
 extern DECLSPEC void * SDLCALL SDL_malloc(size_t size);
 #endif
 #ifdef HAVE_CALLOC
-#define SDL_calloc	calloc
+#define SDL_calloc  calloc
 #else
 extern DECLSPEC void * SDLCALL SDL_calloc(size_t nmemb, size_t size);
 #endif
 #ifdef HAVE_REALLOC
-#define SDL_realloc	realloc
+#define SDL_realloc realloc
 #else
 extern DECLSPEC void * SDLCALL SDL_realloc(void *mem, size_t size);
 #endif
 #ifdef HAVE_FREE
-#define SDL_free	free
+#define SDL_free    free
 #else
 extern DECLSPEC void SDLCALL SDL_free(void *mem);
 #endif
 #if defined(HAVE_ALLOCA) && !defined(alloca)
 #define SDL_stack_alloc(type, count)    (type*)SDL_malloc(sizeof(type)*(count))
 #define SDL_stack_free(data)            SDL_free(data)
 #endif
 #ifdef HAVE_GETENV
-#define SDL_getenv	getenv
+#define SDL_getenv  getenv
 #else
 extern DECLSPEC char * SDLCALL SDL_getenv(const char *name);
 #endif
 #ifdef HAVE_PUTENV
-#define SDL_putenv	putenv
+#define SDL_putenv  putenv
 #else
 extern DECLSPEC int SDLCALL SDL_putenv(const char *variable);
 #endif
 #ifdef HAVE_QSORT
-#define SDL_qsort	qsort
+#define SDL_qsort   qsort
 #else
 extern DECLSPEC void SDLCALL SDL_qsort(void *base, size_t nmemb, size_t size,
 int (*compare)(const void *, const void *));
 #endif
 #ifdef HAVE_ABS
-#define SDL_abs		abs
+#define SDL_abs     abs
 #else
-#define SDL_abs(X)	((X) < 0 ? -(X) : (X))
+#define SDL_abs(X)  ((X) < 0 ? -(X) : (X))
 #endif
-#define SDL_min(x, y)	(((x) < (y)) ? (x) : (y))
+#define SDL_min(x, y)   (((x) < (y)) ? (x) : (y))
-#define SDL_max(x, y)	(((x) > (y)) ? (x) : (y))
+#define SDL_max(x, y)   (((x) > (y)) ? (x) : (y))
 #ifdef HAVE_CTYPE_H
 #define SDL_isdigit(X)  isdigit(X)
 #define SDL_isspace(X)  isspace(X)
 #define SDL_toupper(X)  toupper(X)
 #else
 extern DECLSPEC void * SDLCALL SDL_memset(void *dst, int c, size_t len);
 #endif
 #if defined(__GNUC__) && defined(i386)
-#define SDL_memset4(dst, val, len)				\
+#define SDL_memset4(dst, val, len)              \
-do {								\
+do {                                \
-	int u0, u1, u2;						\
+int u0, u1, u2;                     \
-	__asm__ __volatile__ (					\
+__asm__ __volatile__ (                  \
-		"cld\n\t"					\
+"cld\n\t"                   \
-		"rep ; stosl\n\t"				\
+"rep ; stosl\n\t"               \
-		: "=&D" (u0), "=&a" (u1), "=&c" (u2)		\
+: "=&D" (u0), "=&a" (u1), "=&c" (u2)        \
-		: "0" (dst), "1" (val), "2" (SDL_static_cast(Uint32, len))	\
+: "0" (dst), "1" (val), "2" (SDL_static_cast(Uint32, len))  \
-		: "memory" );					\
+: "memory" );                   \
 } while(0)
 #endif
 #ifndef SDL_memset4
-#define SDL_memset4(dst, val, len)		\
+#define SDL_memset4(dst, val, len)      \
-do {						\
+do {                        \
-	unsigned _count = (len);		\
+unsigned _count = (len);        \
-	unsigned _n = (_count + 3) / 4;		\
+unsigned _n = (_count + 3) / 4;     \
-	Uint32 *_p = SDL_static_cast(Uint32 *, dst);	\
+Uint32 *_p = SDL_static_cast(Uint32 *, dst);    \
-	Uint32 _val = (val);			\
+Uint32 _val = (val);            \
-	if (len == 0) break;			\
+if (len == 0) break;            \
-switch (_count % 4) {			\
+switch (_count % 4) {           \
-case 0: do {    *_p++ = _val;		\
+case 0: do {    *_p++ = _val;       \
-case 3:         *_p++ = _val;		\
+case 3:         *_p++ = _val;       \
-case 2:         *_p++ = _val;		\
+case 2:         *_p++ = _val;       \
-case 1:         *_p++ = _val;		\
+case 1:         *_p++ = _val;       \
-		} while ( --_n );		\
+} while ( --_n );       \
-	}					\
+}                   \
 } while(0)
 #endif
 /* We can count on memcpy existing on Mac OS X and being well-tuned. */
 #if defined(__MACH__) && defined(__APPLE__)
 #define SDL_memcpy(dst, src, len) memcpy(dst, src, len)
 #elif defined(__GNUC__) && defined(i386)
-#define SDL_memcpy(dst, src, len)					  \
+#define SDL_memcpy(dst, src, len)                     \
-do {									  \
+do {                                      \
-	int u0, u1, u2;						  	  \
+int u0, u1, u2;                           \
-	__asm__ __volatile__ (						  \
+__asm__ __volatile__ (                        \
-		"cld\n\t"						  \
+"cld\n\t"                         \
-		"rep ; movsl\n\t"					  \
+"rep ; movsl\n\t"                     \
-		"testb $2,%b4\n\t"					  \
+"testb $2,%b4\n\t"                    \
-		"je 1f\n\t"						  \
+"je 1f\n\t"                       \
-		"movsw\n"						  \
+"movsw\n"                         \
-		"1:\ttestb $1,%b4\n\t"					  \
+"1:\ttestb $1,%b4\n\t"                    \
-		"je 2f\n\t"						  \
+"je 2f\n\t"                       \
-		"movsb\n"						  \
+"movsb\n"                         \
-		"2:"							  \
+"2:"                              \
-		: "=&c" (u0), "=&D" (u1), "=&S" (u2)			  \
+: "=&c" (u0), "=&D" (u1), "=&S" (u2)              \
-		: "0" (SDL_static_cast(unsigned, len)/4), "q" (len), "1" (dst),"2" (src) \
+: "0" (SDL_static_cast(unsigned, len)/4), "q" (len), "1" (dst),"2" (src) \
-		: "memory" );						  \
+: "memory" );                         \
 } while(0)
 #endif
 #ifndef SDL_memcpy
 #ifdef HAVE_MEMCPY
 #define SDL_memcpy      memcpy
 #elif defined(HAVE_BCOPY)
-#define SDL_memcpy(d, s, n)	bcopy((s), (d), (n))
+#define SDL_memcpy(d, s, n) bcopy((s), (d), (n))
 #else
 extern DECLSPEC void * SDLCALL SDL_memcpy(void *dst, const void *src, size_t len);
 #endif
 #endif
 /* We can count on memcpy existing on Mac OS X and being well-tuned. */
 #if defined(__MACH__) && defined(__APPLE__)
 #define SDL_memcpy4(dst, src, len) memcpy(dst, src, (len)*4)
 #elif defined(__GNUC__) && defined(i386)
-#define SDL_memcpy4(dst, src, len)				\
+#define SDL_memcpy4(dst, src, len)              \
-do {								\
+do {                                \
-	int ecx, edi, esi;					\
+int ecx, edi, esi;                  \
-	__asm__ __volatile__ (					\
+__asm__ __volatile__ (                  \
-		"cld\n\t"					\
+"cld\n\t"                   \
-		"rep ; movsl"					\
+"rep ; movsl"                   \
-		: "=&c" (ecx), "=&D" (edi), "=&S" (esi)		\
+: "=&c" (ecx), "=&D" (edi), "=&S" (esi)     \
-		: "0" (SDL_static_cast(unsigned, len)), "1" (dst), "2" (src)	\
+: "0" (SDL_static_cast(unsigned, len)), "1" (dst), "2" (src)    \
-		: "memory" );					\
+: "memory" );                   \
 } while(0)
 #endif
 #ifndef SDL_memcpy4
-#define SDL_memcpy4(dst, src, len)	SDL_memcpy(dst, src, (len) << 2)
+#define SDL_memcpy4(dst, src, len)  SDL_memcpy(dst, src, (len) << 2)
 #endif
 #if defined(__GNUC__) && defined(i386)
-#define SDL_revcpy(dst, src, len)			\
+#define SDL_revcpy(dst, src, len)           \
-do {							\
+do {                            \
-	int u0, u1, u2;					\
+int u0, u1, u2;                 \
-	char *dstp = SDL_static_cast(char *, dst);	\
+char *dstp = SDL_static_cast(char *, dst);  \
-	char *srcp = SDL_static_cast(char *, src);	\
+char *srcp = SDL_static_cast(char *, src);  \
-	int n = (len);					\
+int n = (len);                  \
-	if ( n >= 4 ) {					\
+if ( n >= 4 ) {                 \
-	__asm__ __volatile__ (				\
+__asm__ __volatile__ (              \
-		"std\n\t"				\
+"std\n\t"               \
-		"rep ; movsl\n\t"			\
+"rep ; movsl\n\t"           \
-		"cld\n\t"				\
+"cld\n\t"               \
-		: "=&c" (u0), "=&D" (u1), "=&S" (u2)	\
+: "=&c" (u0), "=&D" (u1), "=&S" (u2)    \
-		: "0" (n >> 2),				\
+: "0" (n >> 2),             \
-		  "1" (dstp+(n-4)), "2" (srcp+(n-4))	\
+"1" (dstp+(n-4)), "2" (srcp+(n-4))    \
-		: "memory" );				\
+: "memory" );               \
-	}						\
+}                       \
-	switch (n & 3) {				\
+switch (n & 3) {                \
-		case 3: dstp[2] = srcp[2];		\
+case 3: dstp[2] = srcp[2];      \
-		case 2: dstp[1] = srcp[1];		\
+case 2: dstp[1] = srcp[1];      \
-		case 1: dstp[0] = srcp[0];		\
+case 1: dstp[0] = srcp[0];      \
-			break;				\
+break;              \
-		default:				\
+default:                \
-			break;				\
+break;              \
-	}						\
+}                       \
 } while(0)
 #endif
 #ifndef SDL_revcpy
 extern DECLSPEC void * SDLCALL SDL_revcpy(void *dst, const void *src, size_t len);
 #endif
 #ifdef HAVE_MEMMOVE
 #define SDL_memmove     memmove
 #elif defined(HAVE_BCOPY)
-#define SDL_memmove(d, s, n)	bcopy((s), (d), (n))
+#define SDL_memmove(d, s, n)    bcopy((s), (d), (n))
 #else
-#define SDL_memmove(dst, src, len)			\
+#define SDL_memmove(dst, src, len)          \
-do {							\
+do {                            \
-	if ( dst < src ) {				\
+if ( dst < src ) {              \
-		SDL_memcpy(dst, src, len);		\
+SDL_memcpy(dst, src, len);      \
-	} else {					\
+} else {                    \
-		SDL_revcpy(dst, src, len);		\
+SDL_revcpy(dst, src, len);      \
-	}						\
+}                       \
 } while(0)
 #endif
 #ifdef HAVE_MEMCMP
 #define SDL_memcmp      memcmp
 #endif
 #ifdef HAVE_ITOA
 #define SDL_itoa        itoa
 #else
-#define SDL_itoa(value, string, radix)	SDL_ltoa((long)value, string, radix)
+#define SDL_itoa(value, string, radix)  SDL_ltoa((long)value, string, radix)
 #endif
 #ifdef HAVE__LTOA
 #define SDL_ltoa        _ltoa
 #else
 #endif
 #ifdef HAVE__UITOA
 #define SDL_uitoa       _uitoa
 #else
-#define SDL_uitoa(value, string, radix)	SDL_ultoa((long)value, string, radix)
+#define SDL_uitoa(value, string, radix) SDL_ultoa((long)value, string, radix)
 #endif
 #ifdef HAVE__ULTOA
 #define SDL_ultoa       _ultoa
 #else
 #else
 extern DECLSPEC int SDLCALL SDL_vsnprintf(char *text, size_t maxlen, const char *fmt, va_list ap);
 #endif
 /** @name SDL_ICONV Error Codes
 *  The SDL implementation of iconv() returns these error codes
 */
 /*@{*/
-#define SDL_ICONV_ERROR		(size_t)-1
+#define SDL_ICONV_ERROR     (size_t)-1
-#define SDL_ICONV_E2BIG		(size_t)-2
+#define SDL_ICONV_E2BIG     (size_t)-2
-#define SDL_ICONV_EILSEQ	(size_t)-3
+#define SDL_ICONV_EILSEQ    (size_t)-3
-#define SDL_ICONV_EINVAL	(size_t)-4
+#define SDL_ICONV_EINVAL    (size_t)-4
 /*@}*/
 #if defined(HAVE_ICONV) && defined(HAVE_ICONV_H)
 #define SDL_iconv_t     iconv_t
 #define SDL_iconv_open  iconv_open
 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_locale(S)    SDL_iconv_string("", "UTF-8", S, SDL_strlen(S)+1)
-#define SDL_iconv_utf8_ucs2(S)		(Uint16 *)SDL_iconv_string("UCS-2", "UTF-8", S, SDL_strlen(S)+1)
+#define SDL_iconv_utf8_ucs2(S)      (Uint16 *)SDL_iconv_string("UCS-2", "UTF-8", S, SDL_strlen(S)+1)
-#define SDL_iconv_utf8_ucs4(S)		(Uint32 *)SDL_iconv_string("UCS-4", "UTF-8", S, SDL_strlen(S)+1)
+#define SDL_iconv_utf8_ucs4(S)      (Uint32 *)SDL_iconv_string("UCS-4", "UTF-8", S, SDL_strlen(S)+1)
 /* Ends C function definitions when using C++ */
 #ifdef __cplusplus
 }
 #endif

changeset 10017	de822cd3df3a
parent 7809	7d4fb2f35f4f