include/SDL_stdinc.h
author Ryan C. Gordon <icculus@icculus.org>
Thu, 28 May 2015 01:54:52 -0400
changeset 9671 0e1f57b051f4
parent 9619 b94b6d0bff0f
child 9998 f67cf37e9cd4
permissions -rw-r--r--
Windows GetBasePath should use GetModuleFileNameExW() and check for overflows.

Apparently you might get strange paths from GetModuleFileName(), such as
short path names or UNC filenames, so this avoids that problem. Since you have
to tapdance with linking different libraries and defining macros depending on
what Windows you plan to target, we dynamically load the API we need, which
works on all versions of Windows (on Win7, it'll load a compatibility wrapper
for the newer API location).

What a mess.

This also now does the right thing if there isn't enough space to store the
path, looping with a larger allocated buffer each try.

Fixes Bugzilla #2435.
slouken@4761
     1
/*
slouken@5535
     2
  Simple DirectMedia Layer
slouken@9619
     3
  Copyright (C) 1997-2015 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@7191
    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
#ifdef HAVE_SYS_TYPES_H
slouken@4761
    34
#include <sys/types.h>
slouken@4761
    35
#endif
slouken@4761
    36
#ifdef HAVE_STDIO_H
slouken@4761
    37
#include <stdio.h>
slouken@4761
    38
#endif
slouken@4761
    39
#if defined(STDC_HEADERS)
slouken@4761
    40
# include <stdlib.h>
slouken@4761
    41
# include <stddef.h>
slouken@4761
    42
# include <stdarg.h>
slouken@4761
    43
#else
slouken@4761
    44
# if defined(HAVE_STDLIB_H)
slouken@4761
    45
#  include <stdlib.h>
slouken@4761
    46
# elif defined(HAVE_MALLOC_H)
slouken@4761
    47
#  include <malloc.h>
slouken@4761
    48
# endif
slouken@4761
    49
# if defined(HAVE_STDDEF_H)
slouken@4761
    50
#  include <stddef.h>
slouken@4761
    51
# endif
slouken@4761
    52
# if defined(HAVE_STDARG_H)
slouken@4761
    53
#  include <stdarg.h>
slouken@4761
    54
# endif
slouken@4761
    55
#endif
slouken@4761
    56
#ifdef HAVE_STRING_H
slouken@4761
    57
# if !defined(STDC_HEADERS) && defined(HAVE_MEMORY_H)
slouken@4761
    58
#  include <memory.h>
slouken@4761
    59
# endif
slouken@4761
    60
# include <string.h>
slouken@4761
    61
#endif
slouken@4761
    62
#ifdef HAVE_STRINGS_H
slouken@4761
    63
# include <strings.h>
slouken@4761
    64
#endif
slouken@4761
    65
#if defined(HAVE_INTTYPES_H)
slouken@4761
    66
# include <inttypes.h>
slouken@4761
    67
#elif defined(HAVE_STDINT_H)
slouken@4761
    68
# include <stdint.h>
slouken@4761
    69
#endif
slouken@4761
    70
#ifdef HAVE_CTYPE_H
slouken@4761
    71
# include <ctype.h>
slouken@4761
    72
#endif
slouken@4761
    73
#ifdef HAVE_MATH_H
dludwig@8316
    74
# if defined(__WINRT__)
dludwig@8316
    75
/* Defining _USE_MATH_DEFINES is required to get M_PI to be defined on
dludwig@8500
    76
   WinRT.  See http://msdn.microsoft.com/en-us/library/4hwaceh6.aspx
dludwig@8316
    77
   for more information.
dludwig@8316
    78
*/
dludwig@8316
    79
#  define _USE_MATH_DEFINES
dludwig@8316
    80
# endif
slouken@4761
    81
# include <math.h>
slouken@4761
    82
#endif
dludwig@8478
    83
#ifdef HAVE_FLOAT_H
dludwig@8478
    84
# include <float.h>
dludwig@8478
    85
#endif
slouken@4761
    86
#if defined(HAVE_ICONV) && defined(HAVE_ICONV_H)
slouken@4761
    87
# include <iconv.h>
slouken@4761
    88
#endif
slouken@4761
    89
slouken@4761
    90
/**
slouken@4761
    91
 *  The number of elements in an array.
slouken@4761
    92
 */
slouken@7191
    93
#define SDL_arraysize(array)    (sizeof(array)/sizeof(array[0]))
slouken@7191
    94
#define SDL_TABLESIZE(table)    SDL_arraysize(table)
slouken@4761
    95
slouken@4761
    96
/**
slouken@4761
    97
 *  \name Cast operators
slouken@7191
    98
 *
slouken@4761
    99
 *  Use proper C++ casts when compiled as C++ to be compatible with the option
slouken@4761
   100
 *  -Wold-style-cast of GCC (and -Werror=old-style-cast in GCC 4.2 and above).
slouken@4761
   101
 */
gabomdq@7678
   102
/* @{ */
slouken@4761
   103
#ifdef __cplusplus
slouken@4761
   104
#define SDL_reinterpret_cast(type, expression) reinterpret_cast<type>(expression)
slouken@4761
   105
#define SDL_static_cast(type, expression) static_cast<type>(expression)
icculus@7076
   106
#define SDL_const_cast(type, expression) const_cast<type>(expression)
slouken@4761
   107
#else
slouken@4761
   108
#define SDL_reinterpret_cast(type, expression) ((type)(expression))
slouken@4761
   109
#define SDL_static_cast(type, expression) ((type)(expression))
icculus@7076
   110
#define SDL_const_cast(type, expression) ((type)(expression))
slouken@4761
   111
#endif
gabomdq@7678
   112
/* @} *//* Cast operators */
slouken@4761
   113
slouken@4761
   114
/* Define a four character code as a Uint32 */
slouken@4761
   115
#define SDL_FOURCC(A, B, C, D) \
slouken@4761
   116
    ((SDL_static_cast(Uint32, SDL_static_cast(Uint8, (A))) << 0) | \
slouken@4761
   117
     (SDL_static_cast(Uint32, SDL_static_cast(Uint8, (B))) << 8) | \
slouken@4761
   118
     (SDL_static_cast(Uint32, SDL_static_cast(Uint8, (C))) << 16) | \
slouken@4761
   119
     (SDL_static_cast(Uint32, SDL_static_cast(Uint8, (D))) << 24))
slouken@4761
   120
slouken@4761
   121
/**
slouken@4761
   122
 *  \name Basic data types
slouken@4761
   123
 */
gabomdq@7678
   124
/* @{ */
slouken@4761
   125
slouken@4761
   126
typedef enum
slouken@4761
   127
{
slouken@4761
   128
    SDL_FALSE = 0,
slouken@4761
   129
    SDL_TRUE = 1
slouken@4761
   130
} SDL_bool;
slouken@4761
   131
slouken@4761
   132
/**
slouken@4761
   133
 * \brief A signed 8-bit integer type.
slouken@4761
   134
 */
slouken@4761
   135
typedef int8_t Sint8;
slouken@4761
   136
/**
slouken@4761
   137
 * \brief An unsigned 8-bit integer type.
slouken@4761
   138
 */
slouken@4761
   139
typedef uint8_t Uint8;
slouken@4761
   140
/**
slouken@4761
   141
 * \brief A signed 16-bit integer type.
slouken@4761
   142
 */
slouken@4761
   143
typedef int16_t Sint16;
slouken@4761
   144
/**
slouken@4761
   145
 * \brief An unsigned 16-bit integer type.
slouken@4761
   146
 */
slouken@4761
   147
typedef uint16_t Uint16;
slouken@4761
   148
/**
slouken@4761
   149
 * \brief A signed 32-bit integer type.
slouken@4761
   150
 */
slouken@4761
   151
typedef int32_t Sint32;
slouken@4761
   152
/**
slouken@4761
   153
 * \brief An unsigned 32-bit integer type.
slouken@4761
   154
 */
slouken@4761
   155
typedef uint32_t Uint32;
slouken@4761
   156
slouken@4761
   157
/**
slouken@4761
   158
 * \brief A signed 64-bit integer type.
slouken@4761
   159
 */
slouken@4761
   160
typedef int64_t Sint64;
slouken@4761
   161
/**
slouken@4761
   162
 * \brief An unsigned 64-bit integer type.
slouken@4761
   163
 */
slouken@4761
   164
typedef uint64_t Uint64;
slouken@4761
   165
gabomdq@7678
   166
/* @} *//* Basic data types */
slouken@4761
   167
slouken@8883
   168
/* Make sure we have macros for printing 64 bit values.
slouken@8883
   169
 * <stdint.h> should define these but this is not true all platforms.
slouken@8883
   170
 * (for example win32) */
slouken@8917
   171
#ifndef SDL_PRIs64
slouken@8917
   172
#ifdef PRIs64
slouken@8917
   173
#define SDL_PRIs64 PRIs64
slouken@8917
   174
#elif defined(__WIN32__)
urkle@9261
   175
#define SDL_PRIs64 "I64d"
icculus@9376
   176
#elif defined(__LINUX__) && defined(__LP64__)
icculus@9376
   177
#define SDL_PRIs64 "ld"
slouken@8883
   178
#else
slouken@8917
   179
#define SDL_PRIs64 "lld"
slouken@8883
   180
#endif
slouken@8883
   181
#endif
slouken@8917
   182
#ifndef SDL_PRIu64
slouken@8917
   183
#ifdef PRIu64
slouken@8917
   184
#define SDL_PRIu64 PRIu64
slouken@8917
   185
#elif defined(__WIN32__)
slouken@8917
   186
#define SDL_PRIu64 "I64u"
icculus@9376
   187
#elif defined(__LINUX__) && defined(__LP64__)
icculus@9376
   188
#define SDL_PRIu64 "lu"
slouken@8883
   189
#else
slouken@8917
   190
#define SDL_PRIu64 "llu"
slouken@8883
   191
#endif
slouken@8883
   192
#endif
urkle@9260
   193
#ifndef SDL_PRIx64
urkle@9260
   194
#ifdef PRIx64
urkle@9260
   195
#define SDL_PRIx64 PRIx64
urkle@9260
   196
#elif defined(__WIN32__)
urkle@9260
   197
#define SDL_PRIx64 "I64x"
icculus@9376
   198
#elif defined(__LINUX__) && defined(__LP64__)
icculus@9376
   199
#define SDL_PRIx64 "lx"
urkle@9260
   200
#else
urkle@9260
   201
#define SDL_PRIx64 "llx"
urkle@9260
   202
#endif
urkle@9260
   203
#endif
urkle@9260
   204
#ifndef SDL_PRIX64
urkle@9260
   205
#ifdef PRIX64
urkle@9260
   206
#define SDL_PRIX64 PRIX64
urkle@9260
   207
#elif defined(__WIN32__)
urkle@9260
   208
#define SDL_PRIX64 "I64X"
icculus@9376
   209
#elif defined(__LINUX__) && defined(__LP64__)
icculus@9376
   210
#define SDL_PRIX64 "lX"
urkle@9260
   211
#else
urkle@9260
   212
#define SDL_PRIX64 "llX"
urkle@9260
   213
#endif
urkle@9260
   214
#endif
slouken@4761
   215
slouken@8820
   216
/* Annotations to help code analysis tools */
slouken@8820
   217
#ifdef SDL_DISABLE_ANALYZE_MACROS
slouken@8820
   218
#define SDL_IN_BYTECAP(x)
slouken@8820
   219
#define SDL_INOUT_Z_CAP(x)
slouken@8820
   220
#define SDL_OUT_Z_CAP(x)
slouken@8820
   221
#define SDL_OUT_CAP(x)
slouken@8820
   222
#define SDL_OUT_BYTECAP(x)
slouken@8820
   223
#define SDL_OUT_Z_BYTECAP(x)
slouken@8820
   224
#define SDL_PRINTF_FORMAT_STRING
slouken@8820
   225
#define SDL_SCANF_FORMAT_STRING
slouken@8820
   226
#define SDL_PRINTF_VARARG_FUNC( fmtargnumber )
slouken@8820
   227
#define SDL_SCANF_VARARG_FUNC( fmtargnumber )
slouken@8820
   228
#else
icculus@9473
   229
#if defined(_MSC_VER) && (_MSC_VER >= 1600) /* VS 2010 and above */
slouken@8820
   230
#include <sal.h>
slouken@8820
   231
slouken@8820
   232
#define SDL_IN_BYTECAP(x) _In_bytecount_(x)
slouken@8820
   233
#define SDL_INOUT_Z_CAP(x) _Inout_z_cap_(x)
slouken@8820
   234
#define SDL_OUT_Z_CAP(x) _Out_z_cap_(x)
slouken@8820
   235
#define SDL_OUT_CAP(x) _Out_cap_(x)
slouken@8820
   236
#define SDL_OUT_BYTECAP(x) _Out_bytecap_(x)
slouken@8820
   237
#define SDL_OUT_Z_BYTECAP(x) _Out_z_bytecap_(x)
slouken@8820
   238
slouken@8820
   239
#define SDL_PRINTF_FORMAT_STRING _Printf_format_string_
slouken@8820
   240
#define SDL_SCANF_FORMAT_STRING _Scanf_format_string_impl_
slouken@8820
   241
#else
slouken@8820
   242
#define SDL_IN_BYTECAP(x)
slouken@8820
   243
#define SDL_INOUT_Z_CAP(x)
slouken@8820
   244
#define SDL_OUT_Z_CAP(x)
slouken@8820
   245
#define SDL_OUT_CAP(x)
slouken@8820
   246
#define SDL_OUT_BYTECAP(x)
slouken@8820
   247
#define SDL_OUT_Z_BYTECAP(x)
slouken@8820
   248
#define SDL_PRINTF_FORMAT_STRING
slouken@8820
   249
#define SDL_SCANF_FORMAT_STRING
slouken@8820
   250
#endif
slouken@8820
   251
#if defined(__GNUC__)
slouken@8820
   252
#define SDL_PRINTF_VARARG_FUNC( fmtargnumber ) __attribute__ (( format( __printf__, fmtargnumber, fmtargnumber+1 )))
slouken@8820
   253
#define SDL_SCANF_VARARG_FUNC( fmtargnumber ) __attribute__ (( format( __scanf__, fmtargnumber, fmtargnumber+1 )))
slouken@8820
   254
#else
slouken@8820
   255
#define SDL_PRINTF_VARARG_FUNC( fmtargnumber )
slouken@8820
   256
#define SDL_SCANF_VARARG_FUNC( fmtargnumber )
slouken@8820
   257
#endif
philipp@8844
   258
#endif /* SDL_DISABLE_ANALYZE_MACROS */
slouken@8820
   259
slouken@4761
   260
#define SDL_COMPILE_TIME_ASSERT(name, x)               \
slouken@4761
   261
       typedef int SDL_dummy_ ## name[(x) * 2 - 1]
slouken@4761
   262
/** \cond */
slouken@4761
   263
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
slouken@4761
   264
SDL_COMPILE_TIME_ASSERT(uint8, sizeof(Uint8) == 1);
slouken@4761
   265
SDL_COMPILE_TIME_ASSERT(sint8, sizeof(Sint8) == 1);
slouken@4761
   266
SDL_COMPILE_TIME_ASSERT(uint16, sizeof(Uint16) == 2);
slouken@4761
   267
SDL_COMPILE_TIME_ASSERT(sint16, sizeof(Sint16) == 2);
slouken@4761
   268
SDL_COMPILE_TIME_ASSERT(uint32, sizeof(Uint32) == 4);
slouken@4761
   269
SDL_COMPILE_TIME_ASSERT(sint32, sizeof(Sint32) == 4);
slouken@4761
   270
SDL_COMPILE_TIME_ASSERT(uint64, sizeof(Uint64) == 8);
slouken@4761
   271
SDL_COMPILE_TIME_ASSERT(sint64, sizeof(Sint64) == 8);
slouken@4761
   272
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
slouken@4761
   273
/** \endcond */
slouken@4761
   274
slouken@4761
   275
/* Check to make sure enums are the size of ints, for structure packing.
slouken@4761
   276
   For both Watcom C/C++ and Borland C/C++ the compiler option that makes
slouken@4761
   277
   enums having the size of an int must be enabled.
slouken@4761
   278
   This is "-b" for Borland C/C++ and "-ei" for Watcom C/C++ (v11).
slouken@4761
   279
*/
slouken@4761
   280
slouken@4761
   281
/** \cond */
slouken@4761
   282
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
slouken@7191
   283
#if !defined(__ANDROID__)
paul@4697
   284
   /* TODO: include/SDL_stdinc.h:174: error: size of array 'SDL_dummy_enum' is negative */
slouken@4761
   285
typedef enum
slouken@4761
   286
{
slouken@4761
   287
    DUMMY_ENUM_VALUE
slouken@4761
   288
} SDL_DUMMY_ENUM;
slouken@4761
   289
slouken@4761
   290
SDL_COMPILE_TIME_ASSERT(enum, sizeof(SDL_DUMMY_ENUM) == sizeof(int));
slouken@4761
   291
#endif
slouken@4761
   292
#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
slouken@4761
   293
/** \endcond */
slouken@4761
   294
slouken@4761
   295
#include "begin_code.h"
slouken@4761
   296
/* Set up for C function definitions, even when using C++ */
slouken@4761
   297
#ifdef __cplusplus
slouken@4761
   298
extern "C" {
slouken@4761
   299
#endif
slouken@4761
   300
slouken@4761
   301
#if defined(HAVE_ALLOCA) && !defined(alloca)
slouken@4761
   302
# if defined(HAVE_ALLOCA_H)
slouken@4761
   303
#  include <alloca.h>
slouken@4761
   304
# elif defined(__GNUC__)
slouken@4761
   305
#  define alloca __builtin_alloca
slouken@4761
   306
# elif defined(_MSC_VER)
slouken@4761
   307
#  include <malloc.h>
slouken@4761
   308
#  define alloca _alloca
slouken@4761
   309
# elif defined(__WATCOMC__)
slouken@4761
   310
#  include <malloc.h>
slouken@4761
   311
# elif defined(__BORLANDC__)
slouken@4761
   312
#  include <malloc.h>
slouken@4761
   313
# elif defined(__DMC__)
slouken@4761
   314
#  include <stdlib.h>
slouken@4761
   315
# elif defined(__AIX__)
slouken@4761
   316
#pragma alloca
slouken@4761
   317
# elif defined(__MRC__)
slouken@4761
   318
void *alloca(unsigned);
slouken@4761
   319
# else
slouken@4761
   320
char *alloca();
slouken@4761
   321
# endif
slouken@4761
   322
#endif
slouken@4761
   323
#ifdef HAVE_ALLOCA
slouken@4761
   324
#define SDL_stack_alloc(type, count)    (type*)alloca(sizeof(type)*(count))
slouken@4761
   325
#define SDL_stack_free(data)
slouken@4761
   326
#else
slouken@4761
   327
#define SDL_stack_alloc(type, count)    (type*)SDL_malloc(sizeof(type)*(count))
slouken@4761
   328
#define SDL_stack_free(data)            SDL_free(data)
slouken@4761
   329
#endif
slouken@4761
   330
icculus@7003
   331
extern DECLSPEC void *SDLCALL SDL_malloc(size_t size);
icculus@7003
   332
extern DECLSPEC void *SDLCALL SDL_calloc(size_t nmemb, size_t size);
icculus@7003
   333
extern DECLSPEC void *SDLCALL SDL_realloc(void *mem, size_t size);
icculus@7003
   334
extern DECLSPEC void SDLCALL SDL_free(void *mem);
slouken@4761
   335
icculus@7003
   336
extern DECLSPEC char *SDLCALL SDL_getenv(const char *name);
icculus@7003
   337
extern DECLSPEC int SDLCALL SDL_setenv(const char *name, const char *value, int overwrite);
slouken@4761
   338
icculus@7003
   339
extern DECLSPEC void SDLCALL SDL_qsort(void *base, size_t nmemb, size_t size, int (*compare) (const void *, const void *));
slouken@4761
   340
icculus@7003
   341
extern DECLSPEC int SDLCALL SDL_abs(int x);
icculus@7003
   342
icculus@7003
   343
/* !!! FIXME: these have side effects. You probably shouldn't use them. */
icculus@7003
   344
/* !!! FIXME: Maybe we do forceinline functions of SDL_mini, SDL_minf, etc? */
icculus@7003
   345
#define SDL_min(x, y) (((x) < (y)) ? (x) : (y))
icculus@7003
   346
#define SDL_max(x, y) (((x) > (y)) ? (x) : (y))
icculus@7003
   347
icculus@7003
   348
extern DECLSPEC int SDLCALL SDL_isdigit(int x);
icculus@7003
   349
extern DECLSPEC int SDLCALL SDL_isspace(int x);
icculus@7003
   350
extern DECLSPEC int SDLCALL SDL_toupper(int x);
icculus@7003
   351
extern DECLSPEC int SDLCALL SDL_tolower(int x);
icculus@7003
   352
slouken@8820
   353
extern DECLSPEC void *SDLCALL SDL_memset(SDL_OUT_BYTECAP(len) void *dst, int c, size_t len);
slouken@4761
   354
icculus@7003
   355
#define SDL_zero(x) SDL_memset(&(x), 0, sizeof((x)))
icculus@7003
   356
#define SDL_zerop(x) SDL_memset((x), 0, sizeof(*(x)))
icculus@7003
   357
slouken@7386
   358
/* Note that memset() is a byte assignment and this is a 32-bit assignment, so they're not directly equivalent. */
slouken@7901
   359
SDL_FORCE_INLINE void SDL_memset4(void *dst, Uint32 val, size_t dwords)
icculus@7003
   360
{
slouken@7385
   361
#if defined(__GNUC__) && defined(i386)
slouken@7385
   362
    int u0, u1, u2;
slouken@7385
   363
    __asm__ __volatile__ (
slouken@7385
   364
        "cld \n\t"
slouken@7385
   365
        "rep ; stosl \n\t"
slouken@7385
   366
        : "=&D" (u0), "=&a" (u1), "=&c" (u2)
slouken@7385
   367
        : "0" (dst), "1" (val), "2" (SDL_static_cast(Uint32, dwords))
slouken@7385
   368
        : "memory"
slouken@7385
   369
    );
slouken@7385
   370
#else
slouken@7385
   371
    size_t _n = (dwords + 3) / 4;
slouken@7385
   372
    Uint32 *_p = SDL_static_cast(Uint32 *, dst);
slouken@7385
   373
    Uint32 _val = (val);
slouken@7385
   374
    if (dwords == 0)
slouken@7385
   375
        return;
slouken@7385
   376
    switch (dwords % 4)
slouken@7385
   377
    {
slouken@7385
   378
        case 0: do {    *_p++ = _val;
slouken@7385
   379
        case 3:         *_p++ = _val;
slouken@7385
   380
        case 2:         *_p++ = _val;
slouken@7385
   381
        case 1:         *_p++ = _val;
slouken@7385
   382
        } while ( --_n );
slouken@7385
   383
    }
slouken@7385
   384
#endif
icculus@7003
   385
}
icculus@7003
   386
slouken@7385
   387
slouken@8820
   388
extern DECLSPEC void *SDLCALL SDL_memcpy(SDL_OUT_BYTECAP(len) void *dst, SDL_IN_BYTECAP(len) const void *src, size_t len);
icculus@7003
   389
slouken@8820
   390
extern DECLSPEC void *SDLCALL SDL_memmove(SDL_OUT_BYTECAP(len) void *dst, SDL_IN_BYTECAP(len) const void *src, size_t len);
slouken@7351
   391
extern DECLSPEC int SDLCALL SDL_memcmp(const void *s1, const void *s2, size_t len);
slouken@4761
   392
slouken@7351
   393
extern DECLSPEC size_t SDLCALL SDL_wcslen(const wchar_t *wstr);
slouken@8820
   394
extern DECLSPEC size_t SDLCALL SDL_wcslcpy(SDL_OUT_Z_CAP(maxlen) wchar_t *dst, const wchar_t *src, size_t maxlen);
slouken@8820
   395
extern DECLSPEC size_t SDLCALL SDL_wcslcat(SDL_INOUT_Z_CAP(maxlen) wchar_t *dst, const wchar_t *src, size_t maxlen);
slouken@4761
   396
icculus@7003
   397
extern DECLSPEC size_t SDLCALL SDL_strlen(const char *str);
slouken@8820
   398
extern DECLSPEC size_t SDLCALL SDL_strlcpy(SDL_OUT_Z_CAP(maxlen) char *dst, const char *src, size_t maxlen);
slouken@8820
   399
extern DECLSPEC size_t SDLCALL SDL_utf8strlcpy(SDL_OUT_Z_CAP(dst_bytes) char *dst, const char *src, size_t dst_bytes);
slouken@8820
   400
extern DECLSPEC size_t SDLCALL SDL_strlcat(SDL_INOUT_Z_CAP(maxlen) char *dst, const char *src, size_t maxlen);
icculus@7003
   401
extern DECLSPEC char *SDLCALL SDL_strdup(const char *str);
icculus@7003
   402
extern DECLSPEC char *SDLCALL SDL_strrev(char *str);
icculus@7003
   403
extern DECLSPEC char *SDLCALL SDL_strupr(char *str);
icculus@7003
   404
extern DECLSPEC char *SDLCALL SDL_strlwr(char *str);
icculus@7003
   405
extern DECLSPEC char *SDLCALL SDL_strchr(const char *str, int c);
icculus@7003
   406
extern DECLSPEC char *SDLCALL SDL_strrchr(const char *str, int c);
icculus@7003
   407
extern DECLSPEC char *SDLCALL SDL_strstr(const char *haystack, const char *needle);
slouken@4761
   408
icculus@7003
   409
extern DECLSPEC char *SDLCALL SDL_itoa(int value, char *str, int radix);
slouken@7351
   410
extern DECLSPEC char *SDLCALL SDL_uitoa(unsigned int value, char *str, int radix);
slouken@7351
   411
extern DECLSPEC char *SDLCALL SDL_ltoa(long value, char *str, int radix);
icculus@7003
   412
extern DECLSPEC char *SDLCALL SDL_ultoa(unsigned long value, char *str, int radix);
icculus@7003
   413
extern DECLSPEC char *SDLCALL SDL_lltoa(Sint64 value, char *str, int radix);
icculus@7003
   414
extern DECLSPEC char *SDLCALL SDL_ulltoa(Uint64 value, char *str, int radix);
slouken@4761
   415
icculus@7003
   416
extern DECLSPEC int SDLCALL SDL_atoi(const char *str);
icculus@7003
   417
extern DECLSPEC double SDLCALL SDL_atof(const char *str);
slouken@7351
   418
extern DECLSPEC long SDLCALL SDL_strtol(const char *str, char **endp, int base);
slouken@7351
   419
extern DECLSPEC unsigned long SDLCALL SDL_strtoul(const char *str, char **endp, int base);
slouken@7351
   420
extern DECLSPEC Sint64 SDLCALL SDL_strtoll(const char *str, char **endp, int base);
slouken@7351
   421
extern DECLSPEC Uint64 SDLCALL SDL_strtoull(const char *str, char **endp, int base);
slouken@7351
   422
extern DECLSPEC double SDLCALL SDL_strtod(const char *str, char **endp);
icculus@7003
   423
icculus@7003
   424
extern DECLSPEC int SDLCALL SDL_strcmp(const char *str1, const char *str2);
slouken@7351
   425
extern DECLSPEC int SDLCALL SDL_strncmp(const char *str1, const char *str2, size_t maxlen);
slouken@7351
   426
extern DECLSPEC int SDLCALL SDL_strcasecmp(const char *str1, const char *str2);
slouken@7351
   427
extern DECLSPEC int SDLCALL SDL_strncasecmp(const char *str1, const char *str2, size_t len);
slouken@4761
   428
slouken@8820
   429
extern DECLSPEC int SDLCALL SDL_sscanf(const char *text, SDL_SCANF_FORMAT_STRING const char *fmt, ...) SDL_SCANF_VARARG_FUNC(2);
icculus@8089
   430
extern DECLSPEC int SDLCALL SDL_vsscanf(const char *text, const char *fmt, va_list ap);
slouken@8820
   431
extern DECLSPEC int SDLCALL SDL_snprintf(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, SDL_PRINTF_FORMAT_STRING const char *fmt, ... ) SDL_PRINTF_VARARG_FUNC(3);
slouken@8820
   432
extern DECLSPEC int SDLCALL SDL_vsnprintf(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, const char *fmt, va_list ap);
slouken@4761
   433
slouken@4761
   434
#ifndef HAVE_M_PI
slouken@6627
   435
#ifndef M_PI
slouken@4761
   436
#define M_PI    3.14159265358979323846264338327950288   /* pi */
slouken@4761
   437
#endif
slouken@6627
   438
#endif
slouken@4761
   439
slouken@8004
   440
extern DECLSPEC double SDLCALL SDL_acos(double x);
slouken@8004
   441
extern DECLSPEC double SDLCALL SDL_asin(double x);
icculus@7003
   442
extern DECLSPEC double SDLCALL SDL_atan(double x);
icculus@7003
   443
extern DECLSPEC double SDLCALL SDL_atan2(double x, double y);
icculus@7003
   444
extern DECLSPEC double SDLCALL SDL_ceil(double x);
icculus@7003
   445
extern DECLSPEC double SDLCALL SDL_copysign(double x, double y);
icculus@7003
   446
extern DECLSPEC double SDLCALL SDL_cos(double x);
icculus@7003
   447
extern DECLSPEC float SDLCALL SDL_cosf(float x);
icculus@7003
   448
extern DECLSPEC double SDLCALL SDL_fabs(double x);
icculus@7003
   449
extern DECLSPEC double SDLCALL SDL_floor(double x);
icculus@7003
   450
extern DECLSPEC double SDLCALL SDL_log(double x);
icculus@7003
   451
extern DECLSPEC double SDLCALL SDL_pow(double x, double y);
icculus@7003
   452
extern DECLSPEC double SDLCALL SDL_scalbn(double x, int n);
icculus@7003
   453
extern DECLSPEC double SDLCALL SDL_sin(double x);
icculus@7003
   454
extern DECLSPEC float SDLCALL SDL_sinf(float x);
icculus@7003
   455
extern DECLSPEC double SDLCALL SDL_sqrt(double x);
slouken@8840
   456
extern DECLSPEC float SDLCALL SDL_sqrtf(float x);
slouken@8840
   457
extern DECLSPEC double SDLCALL SDL_tan(double x);
slouken@8840
   458
extern DECLSPEC float SDLCALL SDL_tanf(float x);
slouken@4761
   459
slouken@4761
   460
/* The SDL implementation of iconv() returns these error codes */
slouken@7191
   461
#define SDL_ICONV_ERROR     (size_t)-1
slouken@7191
   462
#define SDL_ICONV_E2BIG     (size_t)-2
slouken@7191
   463
#define SDL_ICONV_EILSEQ    (size_t)-3
slouken@7191
   464
#define SDL_ICONV_EINVAL    (size_t)-4
slouken@4761
   465
icculus@7003
   466
/* SDL_iconv_* are now always real symbols/types, not macros or inlined. */
slouken@4761
   467
typedef struct _SDL_iconv_t *SDL_iconv_t;
slouken@4761
   468
extern DECLSPEC SDL_iconv_t SDLCALL SDL_iconv_open(const char *tocode,
slouken@4761
   469
                                                   const char *fromcode);
slouken@4761
   470
extern DECLSPEC int SDLCALL SDL_iconv_close(SDL_iconv_t cd);
slouken@4761
   471
extern DECLSPEC size_t SDLCALL SDL_iconv(SDL_iconv_t cd, const char **inbuf,
slouken@4761
   472
                                         size_t * inbytesleft, char **outbuf,
slouken@4761
   473
                                         size_t * outbytesleft);
slouken@4761
   474
/**
slouken@4761
   475
 *  This function converts a string between encodings in one pass, returning a
slouken@4761
   476
 *  string that must be freed with SDL_free() or NULL on error.
slouken@4761
   477
 */
slouken@4761
   478
extern DECLSPEC char *SDLCALL SDL_iconv_string(const char *tocode,
slouken@4761
   479
                                               const char *fromcode,
slouken@4761
   480
                                               const char *inbuf,
slouken@4761
   481
                                               size_t inbytesleft);
slouken@7191
   482
#define SDL_iconv_utf8_locale(S)    SDL_iconv_string("", "UTF-8", S, SDL_strlen(S)+1)
slouken@7191
   483
#define SDL_iconv_utf8_ucs2(S)      (Uint16 *)SDL_iconv_string("UCS-2-INTERNAL", "UTF-8", S, SDL_strlen(S)+1)
slouken@7191
   484
#define SDL_iconv_utf8_ucs4(S)      (Uint32 *)SDL_iconv_string("UCS-4-INTERNAL", "UTF-8", S, SDL_strlen(S)+1)
slouken@4761
   485
icculus@9306
   486
/* force builds using Clang's static analysis tools to use literal C runtime
icculus@9306
   487
   here, since there are possibly tests that are ineffective otherwise. */
icculus@9306
   488
#if defined(__clang_analyzer__) && !defined(SDL_DISABLE_ANALYZE_MACROS)
icculus@9306
   489
#define SDL_malloc malloc
icculus@9306
   490
#define SDL_calloc calloc
icculus@9306
   491
#define SDL_realloc realloc
icculus@9306
   492
#define SDL_free free
icculus@9306
   493
#define SDL_memset memset
icculus@9306
   494
#define SDL_memcpy memcpy
icculus@9306
   495
#define SDL_memmove memmove
icculus@9306
   496
#define SDL_memcmp memcmp
icculus@9306
   497
#define SDL_strlen strlen
icculus@9306
   498
#define SDL_strlcpy strlcpy
icculus@9306
   499
#define SDL_strlcat strlcat
icculus@9306
   500
#define SDL_strdup strdup
icculus@9306
   501
#define SDL_strchr strchr
icculus@9306
   502
#define SDL_strrchr strrchr
icculus@9306
   503
#define SDL_strstr strstr
icculus@9306
   504
#define SDL_strcmp strcmp
icculus@9306
   505
#define SDL_strncmp strncmp
icculus@9306
   506
#define SDL_strcasecmp strcasecmp
icculus@9306
   507
#define SDL_strncasecmp strncasecmp
icculus@9306
   508
#define SDL_sscanf sscanf
icculus@9306
   509
#define SDL_vsscanf vsscanf
icculus@9306
   510
#define SDL_snprintf snprintf
icculus@9306
   511
#define SDL_vsnprintf vsnprintf
icculus@9306
   512
#endif
icculus@9306
   513
icculus@9306
   514
SDL_FORCE_INLINE void *SDL_memcpy4(SDL_OUT_BYTECAP(dwords*4) void *dst, SDL_IN_BYTECAP(dwords*4) const void *src, size_t dwords)
icculus@9306
   515
{
icculus@9306
   516
    return SDL_memcpy(dst, src, dwords * 4);
icculus@9306
   517
}
icculus@9306
   518
slouken@4761
   519
/* Ends C function definitions when using C++ */
slouken@4761
   520
#ifdef __cplusplus
slouken@4761
   521
}
slouken@4761
   522
#endif
slouken@4761
   523
#include "close_code.h"
slouken@4761
   524
slouken@4761
   525
#endif /* _SDL_stdinc_h */
slouken@4761
   526
slouken@4761
   527
/* vi: set ts=4 sw=4 expandtab: */