macosx/plugins/DFInput/SDL/include/SDL_stdinc.h

   1 /*
   2     SDL - Simple DirectMedia Layer
   3     Copyright (C) 1997-2010 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 /**
  24  *  \file SDL_stdinc.h
  25  *
  26  *  This is a general header that includes C language support.
  27  */
  28
  29 #ifndef _SDL_stdinc_h
  30 #define _SDL_stdinc_h
  31
  32 #include "SDL_config.h"
  33
  34
  35 #ifdef HAVE_SYS_TYPES_H
  36 #include <sys/types.h>
  37 #endif
  38 #ifdef HAVE_STDIO_H
  39 #include <stdio.h>
  40 #endif
  41 #if defined(STDC_HEADERS)
  42 # include <stdlib.h>
  43 # include <stddef.h>
  44 # include <stdarg.h>
  45 #else
  46 # if defined(HAVE_STDLIB_H)
  47 #  include <stdlib.h>
  48 # elif defined(HAVE_MALLOC_H)
  49 #  include <malloc.h>
  50 # endif
  51 # if defined(HAVE_STDDEF_H)
  52 #  include <stddef.h>
  53 # endif
  54 # if defined(HAVE_STDARG_H)
  55 #  include <stdarg.h>
  56 # endif
  57 #endif
  58 #ifdef HAVE_STRING_H
  59 # if !defined(STDC_HEADERS) && defined(HAVE_MEMORY_H)
  60 #  include <memory.h>
  61 # endif
  62 # include <string.h>
  63 #endif
  64 #ifdef HAVE_STRINGS_H
  65 # include <strings.h>
  66 #endif
  67 #if defined(HAVE_INTTYPES_H)
  68 # include <inttypes.h>
  69 #elif defined(HAVE_STDINT_H)
  70 # include <stdint.h>
  71 #endif
  72 #ifdef HAVE_CTYPE_H
  73 # include <ctype.h>
  74 #endif
  75 #ifdef HAVE_MATH_H
  76 # include <math.h>
  77 #endif
  78 #if defined(HAVE_ICONV) && defined(HAVE_ICONV_H)
  79 # include <iconv.h>
  80 #endif
  81
  82 /**
  83  *  The number of elements in an array.
  84  */
  85 #define SDL_arraysize(array)    (sizeof(array)/sizeof(array[0]))
  86 #define SDL_TABLESIZE(table)    SDL_arraysize(table)
  87
  88 /**
  89  *  \name Cast operators
  90  *
  91  *  Use proper C++ casts when compiled as C++ to be compatible with the option
  92  *  -Wold-style-cast of GCC (and -Werror=old-style-cast in GCC 4.2 and above).
  93  */
  94 /*@{*/
  95 #ifdef __cplusplus
  96 #define SDL_reinterpret_cast(type, expression) reinterpret_cast<type>(expression)
  97 #define SDL_static_cast(type, expression) static_cast<type>(expression)
  98 #else
  99 #define SDL_reinterpret_cast(type, expression) ((type)(expression))
 100 #define SDL_static_cast(type, expression) ((type)(expression))
 101 #endif
 102 /*@}*//*Cast operators*/
 103
 104 /* Define a four character code as a Uint32 */
 105 #define SDL_FOURCC(A, B, C, D) \
 106     ((SDL_static_cast(Uint32, SDL_static_cast(Uint8, (A))) << 0) | \
 107      (SDL_static_cast(Uint32, SDL_static_cast(Uint8, (B))) << 8) | \
 108      (SDL_static_cast(Uint32, SDL_static_cast(Uint8, (C))) << 16) | \
 109      (SDL_static_cast(Uint32, SDL_static_cast(Uint8, (D))) << 24))
 110
 111 /**
 112  *  \name Basic data types
 113  */
 114 /*@{*/
 115
 116 typedef enum
 117 {
 118     SDL_FALSE = 0,
 119     SDL_TRUE = 1
 120 } SDL_bool;
 121
 122 /**
 123  * \brief A signed 8-bit integer type.
 124  */
 125 typedef int8_t Sint8;
 126 /**
 127  * \brief An unsigned 8-bit integer type.
 128  */
 129 typedef uint8_t Uint8;
 130 /**
 131  * \brief A signed 16-bit integer type.
 132  */
 133 typedef int16_t Sint16;
 134 /**
 135  * \brief An unsigned 16-bit integer type.
 136  */
 137 typedef uint16_t Uint16;
 138 /**
 139  * \brief A signed 32-bit integer type.
 140  */
 141 typedef int32_t Sint32;
 142 /**
 143  * \brief An unsigned 32-bit integer type.
 144  */
 145 typedef uint32_t Uint32;
 146
 147 #ifdef SDL_HAS_64BIT_TYPE
 148 /**
 149  * \brief A signed 64-bit integer type.
 150  * \warning On platforms without any sort of 64-bit datatype, this is equivalent to Sint32!
 151  */
 152 typedef int64_t Sint64;
 153 /**
 154  * \brief An unsigned 64-bit integer type.
 155  * \warning On platforms without any sort of 64-bit datatype, this is equivalent to Uint32!
 156  */
 157 typedef uint64_t Uint64;
 158 #else
 159 /* This is really just a hack to prevent the compiler from complaining */
 160 typedef Sint32 Sint64;
 161 typedef Uint32 Uint64;
 162 #endif
 163
 164 /*@}*//*Basic data types*/
 165
 166
 167 #define SDL_COMPILE_TIME_ASSERT(name, x)               \
 168        typedef int SDL_dummy_ ## name[(x) * 2 - 1]
 169 /** \cond */
 170 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
 171 SDL_COMPILE_TIME_ASSERT(uint8, sizeof(Uint8) == 1);
 172 SDL_COMPILE_TIME_ASSERT(sint8, sizeof(Sint8) == 1);
 173 SDL_COMPILE_TIME_ASSERT(uint16, sizeof(Uint16) == 2);
 174 SDL_COMPILE_TIME_ASSERT(sint16, sizeof(Sint16) == 2);
 175 SDL_COMPILE_TIME_ASSERT(uint32, sizeof(Uint32) == 4);
 176 SDL_COMPILE_TIME_ASSERT(sint32, sizeof(Sint32) == 4);
 177 #ifndef __NINTENDODS__          /* TODO: figure out why the following happens:
 178                                    include/SDL_stdinc.h:150: error: size of array 'SDL_dummy_uint64' is negative
 179                                    include/SDL_stdinc.h:151: error: size of array 'SDL_dummy_sint64' is negative */
 180 SDL_COMPILE_TIME_ASSERT(uint64, sizeof(Uint64) == 8);
 181 SDL_COMPILE_TIME_ASSERT(sint64, sizeof(Sint64) == 8);
 182 #endif
 183 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 184 /** \endcond */
 185
 186 /* Check to make sure enums are the size of ints, for structure packing.
 187    For both Watcom C/C++ and Borland C/C++ the compiler option that makes
 188    enums having the size of an int must be enabled.
 189    This is "-b" for Borland C/C++ and "-ei" for Watcom C/C++ (v11).
 190 */
 191 /* Enable enums always int in CodeWarrior (for MPW use "-enum int") */
 192 #ifdef __MWERKS__
 193 #pragma enumsalwaysint on
 194 #endif
 195
 196 /** \cond */
 197 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
 198 #ifndef __NINTENDODS__          /* TODO: include/SDL_stdinc.h:174: error: size of array 'SDL_dummy_enum' is negative */
 199 typedef enum
 200 {
 201     DUMMY_ENUM_VALUE
 202 } SDL_DUMMY_ENUM;
 203
 204 SDL_COMPILE_TIME_ASSERT(enum, sizeof(SDL_DUMMY_ENUM) == sizeof(int));
 205 #endif
 206 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
 207 /** \endcond */
 208
 209 #include "begin_code.h"
 210 /* Set up for C function definitions, even when using C++ */
 211 #ifdef __cplusplus
 212 /* *INDENT-OFF* */
 213 extern "C" {
 214 /* *INDENT-ON* */
 215 #endif
 216
 217 #ifdef HAVE_MALLOC
 218 #define SDL_malloc      malloc
 219 #else
 220 extern DECLSPEC void *SDLCALL SDL_malloc(size_t size);
 221 #endif
 222
 223 #ifdef HAVE_CALLOC
 224 #define SDL_calloc      calloc
 225 #else
 226 extern DECLSPEC void *SDLCALL SDL_calloc(size_t nmemb, size_t size);
 227 #endif
 228
 229 #ifdef HAVE_REALLOC
 230 #define SDL_realloc     realloc
 231 #else
 232 extern DECLSPEC void *SDLCALL SDL_realloc(void *mem, size_t size);
 233 #endif
 234
 235 #ifdef HAVE_FREE
 236 #define SDL_free        free
 237 #else
 238 extern DECLSPEC void SDLCALL SDL_free(void *mem);
 239 #endif
 240
 241 #if defined(HAVE_ALLOCA) && !defined(alloca)
 242 # if defined(HAVE_ALLOCA_H)
 243 #  include <alloca.h>
 244 # elif defined(__GNUC__)
 245 #  define alloca __builtin_alloca
 246 # elif defined(_MSC_VER)
 247 #  include <malloc.h>
 248 #  define alloca _alloca
 249 # elif defined(__WATCOMC__)
 250 #  include <malloc.h>
 251 # elif defined(__BORLANDC__)
 252 #  include <malloc.h>
 253 # elif defined(__DMC__)
 254 #  include <stdlib.h>
 255 # elif defined(__AIX__)
 256 #pragma alloca
 257 # elif defined(__MRC__)
 258 void *alloca(unsigned);
 259 # else
 260 char *alloca();
 261 # endif
 262 #endif
 263 #ifdef HAVE_ALLOCA
 264 #define SDL_stack_alloc(type, count)    (type*)alloca(sizeof(type)*(count))
 265 #define SDL_stack_free(data)
 266 #else
 267 #define SDL_stack_alloc(type, count)    (type*)SDL_malloc(sizeof(type)*(count))
 268 #define SDL_stack_free(data)            SDL_free(data)
 269 #endif
 270
 271 #ifdef HAVE_GETENV
 272 #define SDL_getenv      getenv
 273 #else
 274 extern DECLSPEC char *SDLCALL SDL_getenv(const char *name);
 275 #endif
 276
 277 /* SDL_putenv() has moved to SDL_compat. */
 278 #ifdef HAVE_SETENV
 279 #define SDL_setenv      setenv
 280 #else
 281 extern DECLSPEC int SDLCALL SDL_setenv(const char *name, const char *value,
 282                                        int overwrite);
 283 #endif
 284
 285 #ifdef HAVE_QSORT
 286 #define SDL_qsort       qsort
 287 #else
 288 extern DECLSPEC void SDLCALL SDL_qsort(void *base, size_t nmemb, size_t size,
 289                                        int (*compare) (const void *,
 290                                                        const void *));
 291 #endif
 292
 293 #ifdef HAVE_ABS
 294 #define SDL_abs         abs
 295 #else
 296 #define SDL_abs(X)      ((X) < 0 ? -(X) : (X))
 297 #endif
 298
 299 #define SDL_min(x, y)   (((x) < (y)) ? (x) : (y))
 300 #define SDL_max(x, y)   (((x) > (y)) ? (x) : (y))
 301
 302 #ifdef HAVE_CTYPE_H
 303 #define SDL_isdigit(X)  isdigit(X)
 304 #define SDL_isspace(X)  isspace(X)
 305 #define SDL_toupper(X)  toupper(X)
 306 #define SDL_tolower(X)  tolower(X)
 307 #else
 308 #define SDL_isdigit(X)  (((X) >= '0') && ((X) <= '9'))
 309 #define SDL_isspace(X)  (((X) == ' ') || ((X) == '\t') || ((X) == '\r') || ((X) == '\n'))
 310 #define SDL_toupper(X)  (((X) >= 'a') && ((X) <= 'z') ? ('A'+((X)-'a')) : (X))
 311 #define SDL_tolower(X)  (((X) >= 'A') && ((X) <= 'Z') ? ('a'+((X)-'A')) : (X))
 312 #endif
 313
 314 #ifdef HAVE_MEMSET
 315 #define SDL_memset      memset
 316 #else
 317 extern DECLSPEC void *SDLCALL SDL_memset(void *dst, int c, size_t len);
 318 #endif
 319 #define SDL_zero(x)     SDL_memset(&(x), 0, sizeof((x)))
 320 #define SDL_zerop(x)    SDL_memset((x), 0, sizeof(*(x)))
 321
 322 #if defined(__GNUC__) && defined(i386)
 323 #define SDL_memset4(dst, val, len)                              \
 324 do {                                                            \
 325         int u0, u1, u2;                                         \
 326         __asm__ __volatile__ (                                  \
 327                 "cld\n\t"                                       \
 328                 "rep ; stosl\n\t"                               \
 329                 : "=&D" (u0), "=&a" (u1), "=&c" (u2)            \
 330                 : "0" (dst), "1" (val), "2" (SDL_static_cast(Uint32, len))      \
 331                 : "memory" );                                   \
 332 } while(0)
 333 #endif
 334 #ifndef SDL_memset4
 335 #define SDL_memset4(dst, val, len)              \
 336 do {                                            \
 337         unsigned _count = (len);                \
 338         unsigned _n = (_count + 3) / 4;         \
 339         Uint32 *_p = SDL_static_cast(Uint32 *, dst);            \
 340         Uint32 _val = (val);                    \
 341         if (len == 0) break;                    \
 342         switch (_count % 4) {                   \
 343         case 0: do {    *_p++ = _val;           \
 344         case 3:         *_p++ = _val;           \
 345         case 2:         *_p++ = _val;           \
 346         case 1:         *_p++ = _val;           \
 347                 } while ( --_n );               \
 348         }                                       \
 349 } while(0)
 350 #endif
 351
 352 /* We can count on memcpy existing on Mac OS X and being well-tuned. */
 353 #if defined(__MACH__) && defined(__APPLE__)
 354 #define SDL_memcpy(dst, src, len) memcpy(dst, src, len)
 355 #elif defined(__GNUC__) && defined(i386)
 356 #define SDL_memcpy(dst, src, len)                                         \
 357 do {                                                                      \
 358         int u0, u1, u2;                                                   \
 359         __asm__ __volatile__ (                                            \
 360                 "cld\n\t"                                                 \
 361                 "rep ; movsl\n\t"                                         \
 362                 "testb $2,%b4\n\t"                                        \
 363                 "je 1f\n\t"                                               \
 364                 "movsw\n"                                                 \
 365                 "1:\ttestb $1,%b4\n\t"                                    \
 366                 "je 2f\n\t"                                               \
 367                 "movsb\n"                                                 \
 368                 "2:"                                                      \
 369                 : "=&c" (u0), "=&D" (u1), "=&S" (u2)                      \
 370                 : "0" (SDL_static_cast(unsigned, len)/4), "q" (len), "1" (dst),"2" (src) \
 371                 : "memory" );                                             \
 372 } while(0)
 373 #endif
 374 #ifndef SDL_memcpy
 375 #ifdef HAVE_MEMCPY
 376 #define SDL_memcpy      memcpy
 377 #elif defined(HAVE_BCOPY)
 378 #define SDL_memcpy(d, s, n)     bcopy((s), (d), (n))
 379 #else
 380 extern DECLSPEC void *SDLCALL SDL_memcpy(void *dst, const void *src,
 381                                          size_t len);
 382 #endif
 383 #endif
 384
 385 /* We can count on memcpy existing on Mac OS X and being well-tuned. */
 386 #if defined(__MACH__) && defined(__APPLE__)
 387 #define SDL_memcpy4(dst, src, len) memcpy(dst, src, (len)*4)
 388 #elif defined(__GNUC__) && defined(i386)
 389 #define SDL_memcpy4(dst, src, len)                              \
 390 do {                                                            \
 391         int ecx, edi, esi;                                      \
 392         __asm__ __volatile__ (                                  \
 393                 "cld\n\t"                                       \
 394                 "rep ; movsl"                                   \
 395                 : "=&c" (ecx), "=&D" (edi), "=&S" (esi)         \
 396                 : "0" (SDL_static_cast(unsigned, len)), "1" (dst), "2" (src)    \
 397                 : "memory" );                                   \
 398 } while(0)
 399 #endif
 400 #ifndef SDL_memcpy4
 401 #define SDL_memcpy4(dst, src, len)      SDL_memcpy(dst, src, (len) << 2)
 402 #endif
 403
 404 #if defined(__GNUC__) && defined(i386)
 405 #define SDL_revcpy(dst, src, len)                       \
 406 do {                                                    \
 407         int u0, u1, u2;                                 \
 408         char *dstp = SDL_static_cast(char *, dst);                      \
 409         char *srcp = SDL_static_cast(char *, src);                      \
 410         int n = (len);                                  \
 411         if ( n >= 4 ) {                                 \
 412         __asm__ __volatile__ (                          \
 413                 "std\n\t"                               \
 414                 "rep ; movsl\n\t"                       \
 415                 "cld\n\t"                               \
 416                 : "=&c" (u0), "=&D" (u1), "=&S" (u2)    \
 417                 : "0" (n >> 2),                         \
 418                   "1" (dstp+(n-4)), "2" (srcp+(n-4))    \
 419                 : "memory" );                           \
 420         }                                               \
 421         switch (n & 3) {                                \
 422                 case 3: dstp[2] = srcp[2];              \
 423                 case 2: dstp[1] = srcp[1];              \
 424                 case 1: dstp[0] = srcp[0];              \
 425                         break;                          \
 426                 default:                                \
 427                         break;                          \
 428         }                                               \
 429 } while(0)
 430 #endif
 431 #ifndef SDL_revcpy
 432 extern DECLSPEC void *SDLCALL SDL_revcpy(void *dst, const void *src,
 433                                          size_t len);
 434 #endif
 435
 436 #ifdef HAVE_MEMMOVE
 437 #define SDL_memmove     memmove
 438 #elif defined(HAVE_BCOPY)
 439 #define SDL_memmove(d, s, n)    bcopy((s), (d), (n))
 440 #else
 441 #define SDL_memmove(dst, src, len)                      \
 442 do {                                                    \
 443         if ( dst < src ) {                              \
 444                 SDL_memcpy(dst, src, len);              \
 445         } else {                                        \
 446                 SDL_revcpy(dst, src, len);              \
 447         }                                               \
 448 } while(0)
 449 #endif
 450
 451 #ifdef HAVE_MEMCMP
 452 #define SDL_memcmp      memcmp
 453 #else
 454 extern DECLSPEC int SDLCALL SDL_memcmp(const void *s1, const void *s2,
 455                                        size_t len);
 456 #endif
 457
 458 #ifdef HAVE_STRLEN
 459 #define SDL_strlen      strlen
 460 #else
 461 extern DECLSPEC size_t SDLCALL SDL_strlen(const char *string);
 462 #endif
 463
 464 #ifdef HAVE_WCSLEN
 465 #define SDL_wcslen      wcslen
 466 #else
 467 #if !defined(wchar_t) && defined(__NINTENDODS__)
 468 #define wchar_t short           /* TODO: figure out why libnds doesn't have this */
 469 #endif
 470 extern DECLSPEC size_t SDLCALL SDL_wcslen(const wchar_t * string);
 471 #endif
 472
 473 #ifdef HAVE_STRLCPY
 474 #define SDL_strlcpy     strlcpy
 475 #else
 476 extern DECLSPEC size_t SDLCALL SDL_strlcpy(char *dst, const char *src,
 477                                            size_t maxlen);
 478 #endif
 479
 480 #ifdef HAVE_STRLCAT
 481 #define SDL_strlcat    strlcat
 482 #else
 483 extern DECLSPEC size_t SDLCALL SDL_strlcat(char *dst, const char *src,
 484                                            size_t maxlen);
 485 #endif
 486
 487 #ifdef HAVE_STRDUP
 488 #define SDL_strdup     strdup
 489 #else
 490 extern DECLSPEC char *SDLCALL SDL_strdup(const char *string);
 491 #endif
 492
 493 #ifdef HAVE__STRREV
 494 #define SDL_strrev      _strrev
 495 #else
 496 extern DECLSPEC char *SDLCALL SDL_strrev(char *string);
 497 #endif
 498
 499 #ifdef HAVE__STRUPR
 500 #define SDL_strupr      _strupr
 501 #else
 502 extern DECLSPEC char *SDLCALL SDL_strupr(char *string);
 503 #endif
 504
 505 #ifdef HAVE__STRLWR
 506 #define SDL_strlwr      _strlwr
 507 #else
 508 extern DECLSPEC char *SDLCALL SDL_strlwr(char *string);
 509 #endif
 510
 511 #ifdef HAVE_STRCHR
 512 #define SDL_strchr      strchr
 513 #elif defined(HAVE_INDEX)
 514 #define SDL_strchr      index
 515 #else
 516 extern DECLSPEC char *SDLCALL SDL_strchr(const char *string, int c);
 517 #endif
 518
 519 #ifdef HAVE_STRRCHR
 520 #define SDL_strrchr     strrchr
 521 #elif defined(HAVE_RINDEX)
 522 #define SDL_strrchr     rindex
 523 #else
 524 extern DECLSPEC char *SDLCALL SDL_strrchr(const char *string, int c);
 525 #endif
 526
 527 #ifdef HAVE_STRSTR
 528 #define SDL_strstr      strstr
 529 #else
 530 extern DECLSPEC char *SDLCALL SDL_strstr(const char *haystack,
 531                                          const char *needle);
 532 #endif
 533
 534 #ifdef HAVE_ITOA
 535 #define SDL_itoa        itoa
 536 #else
 537 #define SDL_itoa(value, string, radix)  SDL_ltoa((long)value, string, radix)
 538 #endif
 539
 540 #ifdef HAVE__LTOA
 541 #define SDL_ltoa        _ltoa
 542 #else
 543 extern DECLSPEC char *SDLCALL SDL_ltoa(long value, char *string, int radix);
 544 #endif
 545
 546 #ifdef HAVE__UITOA
 547 #define SDL_uitoa       _uitoa
 548 #else
 549 #define SDL_uitoa(value, string, radix) SDL_ultoa((long)value, string, radix)
 550 #endif
 551
 552 #ifdef HAVE__ULTOA
 553 #define SDL_ultoa       _ultoa
 554 #else
 555 extern DECLSPEC char *SDLCALL SDL_ultoa(unsigned long value, char *string,
 556                                         int radix);
 557 #endif
 558
 559 #ifdef HAVE_STRTOL
 560 #define SDL_strtol      strtol
 561 #else
 562 extern DECLSPEC long SDLCALL SDL_strtol(const char *string, char **endp,
 563                                         int base);
 564 #endif
 565
 566 #ifdef HAVE_STRTOUL
 567 #define SDL_strtoul      strtoul
 568 #else
 569 extern DECLSPEC unsigned long SDLCALL SDL_strtoul(const char *string,
 570                                                   char **endp, int base);
 571 #endif
 572
 573 #ifdef SDL_HAS_64BIT_TYPE
 574
 575 #ifdef HAVE__I64TOA
 576 #define SDL_lltoa       _i64toa
 577 #else
 578 extern DECLSPEC char *SDLCALL SDL_lltoa(Sint64 value, char *string,
 579                                         int radix);
 580 #endif
 581
 582 #ifdef HAVE__UI64TOA
 583 #define SDL_ulltoa      _ui64toa
 584 #else
 585 extern DECLSPEC char *SDLCALL SDL_ulltoa(Uint64 value, char *string,
 586                                          int radix);
 587 #endif
 588
 589 #ifdef HAVE_STRTOLL
 590 #define SDL_strtoll     strtoll
 591 #else
 592 extern DECLSPEC Sint64 SDLCALL SDL_strtoll(const char *string, char **endp,
 593                                            int base);
 594 #endif
 595
 596 #ifdef HAVE_STRTOULL
 597 #define SDL_strtoull     strtoull
 598 #else
 599 extern DECLSPEC Uint64 SDLCALL SDL_strtoull(const char *string, char **endp,
 600                                             int base);
 601 #endif
 602
 603 #endif /* SDL_HAS_64BIT_TYPE */
 604
 605 #ifdef HAVE_STRTOD
 606 #define SDL_strtod      strtod
 607 #else
 608 extern DECLSPEC double SDLCALL SDL_strtod(const char *string, char **endp);
 609 #endif
 610
 611 #ifdef HAVE_ATOI
 612 #define SDL_atoi        atoi
 613 #else
 614 #define SDL_atoi(X)     SDL_strtol(X, NULL, 0)
 615 #endif
 616
 617 #ifdef HAVE_ATOF
 618 #define SDL_atof        atof
 619 #else
 620 #define SDL_atof(X)     SDL_strtod(X, NULL)
 621 #endif
 622
 623 #ifdef HAVE_STRCMP
 624 #define SDL_strcmp      strcmp
 625 #else
 626 extern DECLSPEC int SDLCALL SDL_strcmp(const char *str1, const char *str2);
 627 #endif
 628
 629 #ifdef HAVE_STRNCMP
 630 #define SDL_strncmp     strncmp
 631 #else
 632 extern DECLSPEC int SDLCALL SDL_strncmp(const char *str1, const char *str2,
 633                                         size_t maxlen);
 634 #endif
 635
 636 #ifdef HAVE_STRCASECMP
 637 #define SDL_strcasecmp  strcasecmp
 638 #elif defined(HAVE__STRICMP)
 639 #define SDL_strcasecmp  _stricmp
 640 #else
 641 extern DECLSPEC int SDLCALL SDL_strcasecmp(const char *str1,
 642                                            const char *str2);
 643 #endif
 644
 645 #ifdef HAVE_STRNCASECMP
 646 #define SDL_strncasecmp strncasecmp
 647 #elif defined(HAVE__STRNICMP)
 648 #define SDL_strncasecmp _strnicmp
 649 #else
 650 extern DECLSPEC int SDLCALL SDL_strncasecmp(const char *str1,
 651                                             const char *str2, size_t maxlen);
 652 #endif
 653
 654 #ifdef HAVE_SSCANF
 655 #define SDL_sscanf      sscanf
 656 #else
 657 extern DECLSPEC int SDLCALL SDL_sscanf(const char *text, const char *fmt,
 658                                        ...);
 659 #endif
 660
 661 #ifdef HAVE_SNPRINTF
 662 #define SDL_snprintf    snprintf
 663 #else
 664 extern DECLSPEC int SDLCALL SDL_snprintf(char *text, size_t maxlen,
 665                                          const char *fmt, ...);
 666 #endif
 667
 668 #ifdef HAVE_VSNPRINTF
 669 #define SDL_vsnprintf   vsnprintf
 670 #else
 671 extern DECLSPEC int SDLCALL SDL_vsnprintf(char *text, size_t maxlen,
 672                                           const char *fmt, va_list ap);
 673 #endif
 674
 675 #ifndef HAVE_M_PI
 676 #define M_PI    3.14159265358979323846264338327950288   /* pi */
 677 #endif
 678
 679 #ifdef HAVE_CEIL
 680 #define SDL_ceil        ceil
 681 #else
 682 #define SDL_ceil(x)     ((double)(int)((x)+0.5))
 683 #endif
 684
 685 #ifdef HAVE_COPYSIGN
 686 #define SDL_copysign    copysign
 687 #else
 688 extern DECLSPEC double SDLCALL SDL_copysign(double x, double y);
 689 #endif
 690
 691 #ifdef HAVE_COS
 692 #define SDL_cos         cos
 693 #else
 694 extern DECLSPEC double SDLCALL SDL_cos(double x);
 695 #endif
 696
 697 #ifdef HAVE_COSF
 698 #define SDL_cosf        cosf
 699 #else
 700 #define SDL_cosf(x) (float)SDL_cos((double)x)
 701 #endif
 702
 703 #ifdef HAVE_FABS
 704 #define SDL_fabs        fabs
 705 #else
 706 extern DECLSPEC double SDLCALL SDL_fabs(double x);
 707 #endif
 708
 709 #ifdef HAVE_FLOOR
 710 #define SDL_floor       floor
 711 #else
 712 extern DECLSPEC double SDLCALL SDL_floor(double x);
 713 #endif
 714
 715 #ifdef HAVE_LOG
 716 #define SDL_log         log
 717 #else
 718 extern DECLSPEC double SDLCALL SDL_log(double x);
 719 #endif
 720
 721 #ifdef HAVE_POW
 722 #define SDL_pow         pow
 723 #else
 724 extern DECLSPEC double SDLCALL SDL_pow(double x, double y);
 725 #endif
 726
 727 #ifdef HAVE_SCALBN
 728 #define SDL_scalbn      scalbn
 729 #else
 730 extern DECLSPEC double SDLCALL SDL_scalbn(double x, int n);
 731 #endif
 732
 733 #ifdef HAVE_SIN
 734 #define SDL_sin         sin
 735 #else
 736 extern DECLSPEC double SDLCALL SDL_sin(double x);
 737 #endif
 738
 739 #ifdef HAVE_SINF
 740 #define SDL_sinf        sinf
 741 #else
 742 #define SDL_sinf(x) (float)SDL_sin((double)x)
 743 #endif
 744
 745 #ifdef HAVE_SQRT
 746 #define SDL_sqrt        sqrt
 747 #else
 748 extern DECLSPEC double SDLCALL SDL_sqrt(double x);
 749 #endif
 750
 751 /* The SDL implementation of iconv() returns these error codes */
 752 #define SDL_ICONV_ERROR         (size_t)-1
 753 #define SDL_ICONV_E2BIG         (size_t)-2
 754 #define SDL_ICONV_EILSEQ        (size_t)-3
 755 #define SDL_ICONV_EINVAL        (size_t)-4
 756
 757 #if defined(HAVE_ICONV) && defined(HAVE_ICONV_H)
 758 #define SDL_iconv_t     iconv_t
 759 #define SDL_iconv_open  iconv_open
 760 #define SDL_iconv_close iconv_close
 761 #else
 762 typedef struct _SDL_iconv_t *SDL_iconv_t;
 763 extern DECLSPEC SDL_iconv_t SDLCALL SDL_iconv_open(const char *tocode,
 764                                                    const char *fromcode);
 765 extern DECLSPEC int SDLCALL SDL_iconv_close(SDL_iconv_t cd);
 766 #endif
 767 extern DECLSPEC size_t SDLCALL SDL_iconv(SDL_iconv_t cd, const char **inbuf,
 768                                          size_t * inbytesleft, char **outbuf,
 769                                          size_t * outbytesleft);
 770 /**
 771  *  This function converts a string between encodings in one pass, returning a
 772  *  string that must be freed with SDL_free() or NULL on error.
 773  */
 774 extern DECLSPEC char *SDLCALL SDL_iconv_string(const char *tocode,
 775                                                const char *fromcode,
 776                                                const char *inbuf,
 777                                                size_t inbytesleft);
 778 #define SDL_iconv_utf8_locale(S)        SDL_iconv_string("", "UTF-8", S, SDL_strlen(S)+1)
 779 #define SDL_iconv_utf8_ucs2(S)          (Uint16 *)SDL_iconv_string("UCS-2", "UTF-8", S, SDL_strlen(S)+1)
 780 #define SDL_iconv_utf8_ucs4(S)          (Uint32 *)SDL_iconv_string("UCS-4", "UTF-8", S, SDL_strlen(S)+1)
 781
 782 /* Ends C function definitions when using C++ */
 783 #ifdef __cplusplus
 784 /* *INDENT-OFF* */
 785 }
 786 /* *INDENT-ON* */
 787 #endif
 788 #include "close_code.h"
 789
 790 #endif /* _SDL_stdinc_h */
 791
 792 /* vi: set ts=4 sw=4 expandtab: */