include/SDL_stdinc.h
author Ryan C. Gordon <icculus@icculus.org>
Fri, 15 Mar 2013 01:01:20 -0400
changeset 7003 eeaf77005c30
parent 6885 700f1b25f77f
child 7005 6c69ad0b184e
permissions -rw-r--r--
Improvements to stdlib.

All SDL_* functions are always available as real symbols, so you can always
link against them as a stable ABI. By default, however, all the things that
might have dithered down to macros in your application are now force-inlined,
to give you the same effect as before and theoretically better performance,
but still solve the classic macro problems.

Elsewhere, we provide real functions for these things that simply wrap the
inline functions, in case one needs to have a real function available.

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