Mercurial Mercurial > SDL / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
include/SDL_stdinc.h
author Sam Lantinga <slouken@libsdl.org>
Wed, 17 May 2006 08:18:28 +0000
branchSDL-1.3
changeset 1659 14717b52abc0
parent 1626 a80e1e0880b8
child 1662 782fd950bd46
permissions -rw-r--r--
Merge trunk-1.3-3 
     1 /*

     2     SDL - Simple DirectMedia Layer

     3     Copyright (C) 1997-2006 Sam Lantinga

     4 

     5     This library is free software; you can redistribute it and/or

     6     modify it under the terms of the GNU Lesser General Public

     7     License as published by the Free Software Foundation; either

     8     version 2.1 of the License, or (at your option) any later version.

     9 

    10     This library is distributed in the hope that it will be useful,

    11     but WITHOUT ANY WARRANTY; without even the implied warranty of

    12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    13     Lesser General Public License for more details.

    14 

    15     You should have received a copy of the GNU Lesser General Public

    16     License along with this library; if not, write to the Free Software

    17     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    18 

    19     Sam Lantinga

    20     slouken@libsdl.org

    21 */

    22 

    23 /* This is a general header that includes C language support */

    24 

    25 #ifndef _SDL_stdinc_h

    26 #define _SDL_stdinc_h

    27 

    28 #include "SDL_config.h"

    29 

    30 

    31 #ifdef HAVE_SYS_TYPES_H

    32 #include <sys/types.h>

    33 #endif

    34 #ifdef HAVE_STDIO_H

    35 #include <stdio.h>

    36 #endif

    37 #if defined(STDC_HEADERS)

    38 # include <stdlib.h>

    39 # include <stddef.h>

    40 # include <stdarg.h>

    41 #else

    42 # if defined(HAVE_STDLIB_H)

    43 #  include <stdlib.h>

    44 # elif defined(HAVE_MALLOC_H)

    45 #  include <malloc.h>

    46 # endif

    47 # if defined(HAVE_STDDEF_H)

    48 #  include <stddef.h>

    49 # endif

    50 # if defined(HAVE_STDARG_H)

    51 #  include <stdarg.h>

    52 # endif

    53 #endif

    54 #ifdef HAVE_STRING_H

    55 # if !defined(STDC_HEADERS) && defined(HAVE_MEMORY_H)

    56 #  include <memory.h>

    57 # endif

    58 # include <string.h>

    59 #endif

    60 #ifdef HAVE_STRINGS_H

    61 # include <strings.h>

    62 #endif

    63 #if defined(HAVE_INTTYPES_H)

    64 # include <inttypes.h>

    65 #elif defined(HAVE_STDINT_H)

    66 # include <stdint.h>

    67 #endif

    68 #ifdef HAVE_CTYPE_H

    69 # include <ctype.h>

    70 #endif

    71 #ifdef HAVE_ICONV_H

    72 # include <iconv.h>

    73 #endif

    74 

    75 /* The number of elements in an array */

    76 #define SDL_arraysize(array)	(sizeof(array)/sizeof(array[0]))

    77 #define SDL_TABLESIZE(table)	SDL_arraysize(table)

    78 

    79 /* Basic data types */

    80 typedef enum SDL_bool {

    81 	SDL_FALSE = 0,

    82 	SDL_TRUE  = 1

    83 } SDL_bool;

    84 

    85 typedef int8_t		Sint8;

    86 typedef uint8_t		Uint8;

    87 typedef int16_t		Sint16;

    88 typedef uint16_t	Uint16;

    89 typedef int32_t		Sint32;

    90 typedef uint32_t	Uint32;

    91 

    92 #ifdef SDL_HAS_64BIT_TYPE

    93 typedef int64_t		Sint64;

    94 typedef uint64_t	Uint64;

    95 #else

    96 /* This is really just a hack to prevent the compiler from complaining */

    97 typedef struct {

    98 	Uint32 hi;

    99 	Uint32 lo;

   100 } Uint64, Sint64;

   101 #endif

   102 

   103 /* Make sure the types really have the right sizes */

   104 #define SDL_COMPILE_TIME_ASSERT(name, x)               \

   105        typedef int SDL_dummy_ ## name[(x) * 2 - 1]

   106 

   107 SDL_COMPILE_TIME_ASSERT(uint8, sizeof(Uint8) == 1);

   108 SDL_COMPILE_TIME_ASSERT(sint8, sizeof(Sint8) == 1);

   109 SDL_COMPILE_TIME_ASSERT(uint16, sizeof(Uint16) == 2);

   110 SDL_COMPILE_TIME_ASSERT(sint16, sizeof(Sint16) == 2);

   111 SDL_COMPILE_TIME_ASSERT(uint32, sizeof(Uint32) == 4);

   112 SDL_COMPILE_TIME_ASSERT(sint32, sizeof(Sint32) == 4);

   113 SDL_COMPILE_TIME_ASSERT(uint64, sizeof(Uint64) == 8);

   114 SDL_COMPILE_TIME_ASSERT(sint64, sizeof(Sint64) == 8);

   115 

   116 /* Check to make sure enums are the size of ints, for structure packing.

   117    For both Watcom C/C++ and Borland C/C++ the compiler option that makes

   118    enums having the size of an int must be enabled.

   119    This is "-b" for Borland C/C++ and "-ei" for Watcom C/C++ (v11).

   120 */

   121 /* Enable enums always int in CodeWarrior (for MPW use "-enum int") */

   122 #ifdef __MWERKS__

   123 #pragma enumsalwaysint on

   124 #endif

   125 

   126 typedef enum {

   127 	DUMMY_ENUM_VALUE

   128 } SDL_DUMMY_ENUM;

   129 

   130 SDL_COMPILE_TIME_ASSERT(enum, sizeof(SDL_DUMMY_ENUM) == sizeof(int));

   131 

   132 

   133 #include "begin_code.h"

   134 /* Set up for C function definitions, even when using C++ */

   135 #ifdef __cplusplus

   136 extern "C" {

   137 #endif

   138 

   139 #ifdef HAVE_MALLOC

   140 #define SDL_malloc	malloc

   141 #else

   142 extern DECLSPEC void * SDLCALL SDL_malloc(size_t size);

   143 #endif

   144 

   145 #ifdef HAVE_CALLOC

   146 #define SDL_calloc	calloc

   147 #else

   148 extern DECLSPEC void * SDLCALL SDL_calloc(size_t nmemb, size_t size);

   149 #endif

   150 

   151 #ifdef HAVE_REALLOC

   152 #define SDL_realloc	realloc

   153 #else

   154 extern DECLSPEC void * SDLCALL SDL_realloc(void *mem, size_t size);

   155 #endif

   156 

   157 #ifdef HAVE_FREE

   158 #define SDL_free	free

   159 #else

   160 extern DECLSPEC void SDLCALL SDL_free(void *mem);

   161 #endif

   162 

   163 #if defined(HAVE_ALLOCA) && !defined(alloca)

   164 # if defined(HAVE_ALLOCA_H)

   165 #  include <alloca.h>

   166 # elif defined(__GNUC__)

   167 #  define alloca __builtin_alloca

   168 # elif defined(_MSC_VER)

   169 #  include <malloc.h>

   170 #  define alloca _alloca

   171 # elif defined(__WATCOMC__)

   172 #  include <malloc.h>

   173 # elif defined(__AIX__)

   174   #pragma alloca

   175 # elif defined(__MRC__)

   176    void *alloca (unsigned);

   177 # else

   178    char *alloca ();

   179 # endif

   180 #endif

   181 #ifdef HAVE_ALLOCA

   182 #define SDL_stack_alloc(type, count)    (type*)alloca(sizeof(type)*count)

   183 #define SDL_stack_free(data)

   184 #else

   185 #define SDL_stack_alloc(type, count)    (type*)SDL_malloc(sizeof(type)*count)

   186 #define SDL_stack_free(data)            SDL_free(data)

   187 #endif

   188 

   189 #ifdef HAVE_GETENV

   190 #define SDL_getenv	getenv

   191 #else

   192 extern DECLSPEC char * SDLCALL SDL_getenv(const char *name);

   193 #endif

   194 

   195 #ifdef HAVE_PUTENV

   196 #define SDL_putenv	putenv

   197 #else

   198 extern DECLSPEC int SDLCALL SDL_putenv(const char *variable);

   199 #endif

   200 

   201 #ifdef HAVE_QSORT

   202 #define SDL_qsort	qsort

   203 #else

   204 extern DECLSPEC void SDLCALL SDL_qsort(void *base, size_t nmemb, size_t size,

   205            int (*compare)(const void *, const void *));

   206 #endif

   207 

   208 #ifdef HAVE_ABS

   209 #define SDL_abs		abs

   210 #else

   211 #define SDL_abs(X)	((X) < 0 ? -(X) : (X))

   212 #endif

   213 

   214 #define SDL_min(x, y)	(((x) < (y)) ? (x) : (y))

   215 #define SDL_max(x, y)	(((x) > (y)) ? (x) : (y))

   216 

   217 #ifdef HAVE_CTYPE_H

   218 #define SDL_isdigit(X)  isdigit(X)

   219 #define SDL_isspace(X)  isspace(X)

   220 #define SDL_toupper(X)  toupper(X)

   221 #define SDL_tolower(X)  tolower(X)

   222 #else

   223 #define SDL_isdigit(X)  (((X) >= '0') && ((X) <= '9'))

   224 #define SDL_isspace(X)  (((X) == ' ') || ((X) == '\t') || ((X) == '\r') || ((X) == '\n'))

   225 #define SDL_toupper(X)  (((X) >= 'a') && ((X) <= 'z') ? ('A'+((X)-'a')) : (X))

   226 #define SDL_tolower(X)  (((X) >= 'A') && ((X) <= 'Z') ? ('a'+((X)-'A')) : (X))

   227 #endif

   228 

   229 #ifdef HAVE_MEMSET

   230 #define SDL_memset      memset

   231 #else

   232 extern DECLSPEC void * SDLCALL SDL_memset(void *dst, int c, size_t len);

   233 #endif

   234 

   235 #if defined(__GNUC__) && defined(i386)

   236 #define SDL_memset4(dst, val, len)				\

   237 do {								\

   238 	int u0, u1, u2;						\

   239 	__asm__ __volatile__ (					\

   240 		"cld\n\t"					\

   241 		"rep ; stosl\n\t"				\

   242 		: "=&D" (u0), "=&a" (u1), "=&c" (u2)		\

   243 		: "0" (dst), "1" (val), "2" ((Uint32)(len))	\

   244 		: "memory" );					\

   245 } while(0)

   246 #endif

   247 #ifndef SDL_memset4

   248 #define SDL_memset4(dst, val, len)		\

   249 do {						\

   250 	unsigned _count = (len);		\

   251 	unsigned _n = (_count + 3) / 4;		\

   252 	Uint32 *_p = (Uint32 *)(dst);		\

   253 	Uint32 _val = (val);			\

   254         switch (_count % 4) {			\

   255         case 0: do {    *_p++ = _val;		\

   256         case 3:         *_p++ = _val;		\

   257         case 2:         *_p++ = _val;		\

   258         case 1:         *_p++ = _val;		\

   259 		} while ( --_n );		\

   260 	}					\

   261 } while(0)

   262 #endif

   263 

   264 #if defined(__GNUC__) && defined(i386)

   265 #define SDL_memcpy(dst, src, len)					  \

   266 do {									  \

   267 	int u0, u1, u2;						  	  \

   268 	__asm__ __volatile__ (						  \

   269 		"cld\n\t"						  \

   270 		"rep ; movsl\n\t"					  \

   271 		"testb $2,%b4\n\t"					  \

   272 		"je 1f\n\t"						  \

   273 		"movsw\n"						  \

   274 		"1:\ttestb $1,%b4\n\t"					  \

   275 		"je 2f\n\t"						  \

   276 		"movsb\n"						  \

   277 		"2:"							  \

   278 		: "=&c" (u0), "=&D" (u1), "=&S" (u2)			  \

   279 		: "0" ((unsigned)(len)/4), "q" (len), "1" (dst),"2" (src) \

   280 		: "memory" );						  \

   281 } while(0)

   282 #endif

   283 #ifndef SDL_memcpy

   284 #ifdef HAVE_MEMCPY

   285 #define SDL_memcpy      memcpy

   286 #elif defined(HAVE_BCOPY)

   287 #define SDL_memcpy(d, s, n)	bcopy((s), (d), (n))

   288 #else

   289 extern DECLSPEC void * SDLCALL SDL_memcpy(void *dst, const void *src, size_t len);

   290 #endif

   291 #endif

   292 

   293 #if defined(__GNUC__) && defined(i386)

   294 #define SDL_memcpy4(dst, src, len)				\

   295 do {								\

   296 	int ecx, edi, esi;					\

   297 	__asm__ __volatile__ (					\

   298 		"cld\n\t"					\

   299 		"rep ; movsl"					\

   300 		: "=&c" (ecx), "=&D" (edi), "=&S" (esi)		\

   301 		: "0" ((unsigned)(len)), "1" (dst), "2" (src)	\

   302 		: "memory" );					\

   303 } while(0)

   304 #endif

   305 #ifndef SDL_memcpy4

   306 #define SDL_memcpy4(dst, src, len)	SDL_memcpy(dst, src, (len) << 2)

   307 #endif

   308 

   309 #if defined(__GNUC__) && defined(i386)

   310 #define SDL_revcpy(dst, src, len)			\

   311 do {							\

   312 	int u0, u1, u2;					\

   313 	char *dstp = (char *)(dst);			\

   314 	char *srcp = (char *)(src);			\

   315 	int n = (len);					\

   316 	if ( n >= 4 ) {					\

   317 	__asm__ __volatile__ (				\

   318 		"std\n\t"				\

   319 		"rep ; movsl\n\t"			\

   320 		: "=&c" (u0), "=&D" (u1), "=&S" (u2)	\

   321 		: "0" (n >> 2),				\

   322 		  "1" (dstp+(n-4)), "2" (srcp+(n-4))	\

   323 		: "memory" );				\

   324 	}						\

   325 	switch (n & 3) {				\

   326 		case 3: dstp[2] = srcp[2];		\

   327 		case 2: dstp[1] = srcp[1];		\

   328 		case 1: dstp[0] = srcp[0];		\

   329 			break;				\

   330 		default:				\

   331 			break;				\

   332 	}						\

   333 } while(0)

   334 #endif

   335 #ifndef SDL_revcpy

   336 extern DECLSPEC void * SDLCALL SDL_revcpy(void *dst, const void *src, size_t len);

   337 #endif

   338 

   339 #ifdef HAVE_MEMMOVE

   340 #define SDL_memmove     memmove

   341 #elif defined(HAVE_BCOPY)

   342 #define SDL_memmove(d, s, n)	bcopy((s), (d), (n))

   343 #else

   344 #define SDL_memmove(dst, src, len)			\

   345 do {							\

   346 	if ( dst < src ) {				\

   347 		SDL_memcpy(dst, src, len);		\

   348 	} else {					\

   349 		SDL_revcpy(dst, src, len);		\

   350 	}						\

   351 } while(0)

   352 #endif

   353 

   354 #ifdef HAVE_MEMCMP

   355 #define SDL_memcmp      memcmp

   356 #else

   357 extern DECLSPEC int SDLCALL SDL_memcmp(const void *s1, const void *s2, size_t len);

   358 #endif

   359 

   360 #ifdef HAVE_STRLEN

   361 #define SDL_strlen      strlen

   362 #else

   363 extern DECLSPEC size_t SDLCALL SDL_strlen(const char *string);

   364 #endif

   365 

   366 #ifdef HAVE_STRLCPY

   367 #define SDL_strlcpy     strlcpy

   368 #else

   369 extern DECLSPEC size_t SDLCALL SDL_strlcpy(char *dst, const char *src, size_t maxlen);

   370 #endif

   371 

   372 #ifdef HAVE_STRLCAT

   373 #define SDL_strlcat    strlcat

   374 #else

   375 extern DECLSPEC size_t SDLCALL SDL_strlcat(char *dst, const char *src, size_t maxlen);

   376 #endif

   377 

   378 #ifdef HAVE_STRDUP

   379 #define SDL_strdup     strdup

   380 #else

   381 extern DECLSPEC char * SDLCALL SDL_strdup(const char *string);

   382 #endif

   383 

   384 #ifdef HAVE__STRREV

   385 #define SDL_strrev      _strrev

   386 #else

   387 extern DECLSPEC char * SDLCALL SDL_strrev(char *string);

   388 #endif

   389 

   390 #ifdef HAVE__STRUPR

   391 #define SDL_strupr      _strupr

   392 #else

   393 extern DECLSPEC char * SDLCALL SDL_strupr(char *string);

   394 #endif

   395 

   396 #ifdef HAVE__STRLWR

   397 #define SDL_strlwr      _strlwr

   398 #else

   399 extern DECLSPEC char * SDLCALL SDL_strlwr(char *string);

   400 #endif

   401 

   402 #ifdef HAVE_STRCHR

   403 #define SDL_strchr      strchr

   404 #elif defined(HAVE_INDEX)

   405 #define SDL_strchr      index

   406 #else

   407 extern DECLSPEC char * SDLCALL SDL_strchr(const char *string, int c);

   408 #endif

   409 

   410 #ifdef HAVE_STRRCHR

   411 #define SDL_strrchr     strrchr

   412 #elif defined(HAVE_RINDEX)

   413 #define SDL_strrchr     rindex

   414 #else

   415 extern DECLSPEC char * SDLCALL SDL_strrchr(const char *string, int c);

   416 #endif

   417 

   418 #ifdef HAVE_STRSTR

   419 #define SDL_strstr      strstr

   420 #else

   421 extern DECLSPEC char * SDLCALL SDL_strstr(const char *haystack, const char *needle);

   422 #endif

   423 

   424 #ifdef HAVE_ITOA

   425 #define SDL_itoa        itoa

   426 #else

   427 #define SDL_itoa(value, string, radix)	SDL_ltoa((long)value, string, radix)

   428 #endif

   429 

   430 #ifdef HAVE__LTOA

   431 #define SDL_ltoa        _ltoa

   432 #else

   433 extern DECLSPEC char * SDLCALL SDL_ltoa(long value, char *string, int radix);

   434 #endif

   435 

   436 #ifdef HAVE__UITOA

   437 #define SDL_uitoa       _uitoa

   438 #else

   439 #define SDL_uitoa(value, string, radix)	SDL_ultoa((long)value, string, radix)

   440 #endif

   441 

   442 #ifdef HAVE__ULTOA

   443 #define SDL_ultoa       _ultoa

   444 #else

   445 extern DECLSPEC char * SDLCALL SDL_ultoa(unsigned long value, char *string, int radix);

   446 #endif

   447 

   448 #ifdef HAVE_STRTOL

   449 #define SDL_strtol      strtol

   450 #else

   451 extern DECLSPEC long SDLCALL SDL_strtol(const char *string, char **endp, int base);

   452 #endif

   453 

   454 #ifdef HAVE_STRTOUL

   455 #define SDL_strtoul      strtoul

   456 #else

   457 extern DECLSPEC unsigned long SDLCALL SDL_strtoul(const char *string, char **endp, int base);

   458 #endif

   459 

   460 #ifdef SDL_HAS_64BIT_TYPE

   461 

   462 #ifdef HAVE__I64TOA

   463 #define SDL_lltoa       _i64toa

   464 #else

   465 extern DECLSPEC char* SDLCALL SDL_lltoa(Sint64 value, char *string, int radix);

   466 #endif

   467 

   468 #ifdef HAVE__UI64TOA

   469 #define SDL_ulltoa      _ui64toa

   470 #else

   471 extern DECLSPEC char* SDLCALL SDL_ulltoa(Uint64 value, char *string, int radix);

   472 #endif

   473 

   474 #ifdef HAVE_STRTOLL

   475 #define SDL_strtoll     strtoll

   476 #else

   477 extern DECLSPEC Sint64 SDLCALL SDL_strtoll(const char *string, char **endp, int base);

   478 #endif

   479 

   480 #ifdef HAVE_STRTOULL

   481 #define SDL_strtoull     strtoull

   482 #else

   483 extern DECLSPEC Uint64 SDLCALL SDL_strtoull(const char *string, char **endp, int base);

   484 #endif

   485 

   486 #endif /* SDL_HAS_64BIT_TYPE */

   487 

   488 #ifdef HAVE_STRTOD

   489 #define SDL_strtod      strtod

   490 #else

   491 extern DECLSPEC double SDLCALL SDL_strtod(const char *string, char **endp);

   492 #endif

   493 

   494 #ifdef HAVE_ATOI

   495 #define SDL_atoi        atoi

   496 #else

   497 #define SDL_atoi(X)     SDL_strtol(X, NULL, 0)

   498 #endif

   499 

   500 #ifdef HAVE_ATOF

   501 #define SDL_atof        atof

   502 #else

   503 #define SDL_atof(X)     SDL_strtod(X, NULL)

   504 #endif

   505 

   506 #ifdef HAVE_STRCMP

   507 #define SDL_strcmp      strcmp

   508 #else

   509 extern DECLSPEC int SDLCALL SDL_strcmp(const char *str1, const char *str2);

   510 #endif

   511 

   512 #ifdef HAVE_STRNCMP

   513 #define SDL_strncmp     strncmp

   514 #else

   515 extern DECLSPEC int SDLCALL SDL_strncmp(const char *str1, const char *str2, size_t maxlen);

   516 #endif

   517 

   518 #ifdef HAVE_STRCASECMP

   519 #define SDL_strcasecmp  strcasecmp

   520 #elif defined(HAVE__STRICMP)

   521 #define SDL_strcasecmp  _stricmp

   522 #else

   523 extern DECLSPEC int SDLCALL SDL_strcasecmp(const char *str1, const char *str2);

   524 #endif

   525 

   526 #ifdef HAVE_STRNCASECMP

   527 #define SDL_strncasecmp strncasecmp

   528 #elif defined(HAVE__STRNICMP)

   529 #define SDL_strncasecmp _strnicmp

   530 #else

   531 extern DECLSPEC int SDLCALL SDL_strncasecmp(const char *str1, const char *str2, size_t maxlen);

   532 #endif

   533 

   534 #ifdef HAVE_SSCANF

   535 #define SDL_sscanf      sscanf

   536 #else

   537 extern DECLSPEC int SDLCALL SDL_sscanf(const char *text, const char *fmt, ...);

   538 #endif

   539 

   540 #ifdef HAVE_SNPRINTF

   541 #define SDL_snprintf    snprintf

   542 #else

   543 extern DECLSPEC int SDLCALL SDL_snprintf(char *text, size_t maxlen, const char *fmt, ...);

   544 #endif

   545 

   546 #ifdef HAVE_VSNPRINTF

   547 #define SDL_vsnprintf   vsnprintf

   548 #else

   549 extern DECLSPEC int SDLCALL SDL_vsnprintf(char *text, size_t maxlen, const char *fmt, va_list ap);

   550 #endif

   551 

   552 /* The SDL implementation of iconv() returns these error codes */

   553 #define SDL_ICONV_ERROR		(size_t)-1

   554 #define SDL_ICONV_E2BIG		(size_t)-2

   555 #define SDL_ICONV_EILSEQ	(size_t)-3

   556 #define SDL_ICONV_EINVAL	(size_t)-4

   557 

   558 #ifdef HAVE_ICONV

   559 #define SDL_iconv_t     iconv_t

   560 #define SDL_iconv_open  iconv_open

   561 #define SDL_iconv_close iconv_close

   562 extern DECLSPEC size_t SDLCALL SDL_iconv(SDL_iconv_t cd, char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft);

   563 #else

   564 typedef struct _SDL_iconv_t *SDL_iconv_t;

   565 extern DECLSPEC SDL_iconv_t SDLCALL SDL_iconv_open(const char *tocode, const char *fromcode);

   566 extern DECLSPEC int SDLCALL SDL_iconv_close(SDL_iconv_t cd);

   567 extern DECLSPEC size_t SDLCALL SDL_iconv(SDL_iconv_t cd, char **inbuf, size_t *inbytesleft, char **outbuf, size_t *outbytesleft);

   568 #endif

   569 /* This function converts a string between encodings in one pass, returning a

   570    string that must be freed with SDL_free() or NULL on error.

   571 */

   572 extern DECLSPEC char * SDLCALL SDL_iconv_string(const char *tocode, const char *fromcode, char *inbuf, size_t inbytesleft);

   573 #define SDL_iconv_utf8_ascii(S)		SDL_iconv_string("ASCII", "UTF-8", S, SDL_strlen(S)+1)

   574 #define SDL_iconv_utf8_latin1(S)	SDL_iconv_string("LATIN1", "UTF-8", S, SDL_strlen(S)+1)

   575 #define SDL_iconv_utf8_ucs2(S)		(Uint16 *)SDL_iconv_string("UCS-2", "UTF-8", S, SDL_strlen(S)+1)

   576 #define SDL_iconv_utf8_ucs4(S)		(Uint32 *)SDL_iconv_string("UCS-4", "UTF-8", S, SDL_strlen(S)+1)

   577 

   578 /* Ends C function definitions when using C++ */

   579 #ifdef __cplusplus

   580 }

   581 #endif

   582 #include "close_code.h"

   583 

   584 #endif /* _SDL_stdinc_h */
SDL