Atlas - SDL_stdinc.h
Home / ext / SDL / include / SDL3 Lines: 4 | Size: 205764 bytes [Download] [Show on GitHub] [Search similar files] [Raw] [Raw (proxy)][FILE BEGIN]1/* 2 Simple DirectMedia Layer 3 Copyright (C) 1997-2026 Sam Lantinga <[email protected]> 4 5 This software is provided 'as-is', without any express or implied 6 warranty. In no event will the authors be held liable for any damages 7 arising from the use of this software. 8 9 Permission is granted to anyone to use this software for any purpose, 10 including commercial applications, and to alter it and redistribute it 11 freely, subject to the following restrictions: 12 13 1. The origin of this software must not be misrepresented; you must not 14 claim that you wrote the original software. If you use this software 15 in a product, an acknowledgment in the product documentation would be 16 appreciated but is not required. 17 2. Altered source versions must be plainly marked as such, and must not be 18 misrepresented as being the original software. 19 3. This notice may not be removed or altered from any source distribution. 20*/ 21 22/** 23 * # CategoryStdinc 24 * 25 * SDL provides its own implementation of some of the most important C runtime 26 * functions. 27 * 28 * Using these functions allows an app to have access to common C 29 * functionality without depending on a specific C runtime (or a C runtime at 30 * all). More importantly, the SDL implementations work identically across 31 * platforms, so apps can avoid surprises like snprintf() behaving differently 32 * between Windows and Linux builds, or itoa() only existing on some 33 * platforms. 34 * 35 * For many of the most common functions, like SDL_memcpy, SDL might just call 36 * through to the usual C runtime behind the scenes, if it makes sense to do 37 * so (if it's faster and always available/reliable on a given platform), 38 * reducing library size and offering the most optimized option. 39 * 40 * SDL also offers other C-runtime-adjacent functionality in this header that 41 * either isn't, strictly speaking, part of any C runtime standards, like 42 * SDL_crc32() and SDL_reinterpret_cast, etc. It also offers a few better 43 * options, like SDL_strlcpy(), which functions as a safer form of strcpy(). 44 */ 45 46#ifndef SDL_stdinc_h_ 47#define SDL_stdinc_h_ 48 49#include <SDL3/SDL_platform_defines.h> 50 51#include <stdarg.h> 52#include <string.h> 53#include <wchar.h> 54 55/* Most everything except Visual Studio 2008 and earlier has stdint.h now */ 56#if defined(_MSC_VER) && (_MSC_VER < 1600) 57typedef signed __int8 int8_t; 58typedef unsigned __int8 uint8_t; 59typedef signed __int16 int16_t; 60typedef unsigned __int16 uint16_t; 61typedef signed __int32 int32_t; 62typedef unsigned __int32 uint32_t; 63typedef signed __int64 int64_t; 64typedef unsigned __int64 uint64_t; 65#ifndef _INTPTR_T_DEFINED 66#ifdef _WIN64 67typedef __int64 intptr_t; 68#else 69typedef int intptr_t; 70#endif 71#endif 72#ifndef _UINTPTR_T_DEFINED 73#ifdef _WIN64 74typedef unsigned __int64 uintptr_t; 75#else 76typedef unsigned int uintptr_t; 77#endif 78#endif 79#else 80#include <stdint.h> 81#endif 82 83#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || \ 84 defined(SDL_INCLUDE_INTTYPES_H) 85#include <inttypes.h> 86#endif 87 88#ifndef __cplusplus 89#if defined(__has_include) && !defined(SDL_INCLUDE_STDBOOL_H) 90#if __has_include(<stdbool.h>) 91#define SDL_INCLUDE_STDBOOL_H 92#endif 93#endif 94#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || \ 95 (defined(_MSC_VER) && (_MSC_VER >= 1910 /* Visual Studio 2017 */)) || \ 96 defined(SDL_INCLUDE_STDBOOL_H) 97#include <stdbool.h> 98#elif !defined(__bool_true_false_are_defined) && !defined(bool) 99#define bool unsigned char 100#define false 0 101#define true 1 102#define __bool_true_false_are_defined 1 103#endif 104#endif /* !__cplusplus */ 105 106#ifndef SDL_DISABLE_ALLOCA 107# ifndef alloca 108# ifdef HAVE_ALLOCA_H 109# include <alloca.h> 110# elif defined(SDL_PLATFORM_NETBSD) 111# if defined(__STRICT_ANSI__) 112# define SDL_DISABLE_ALLOCA 113# else 114# include <stdlib.h> 115# endif 116# elif defined(__GNUC__) 117# define alloca __builtin_alloca 118# elif defined(_MSC_VER) 119# include <malloc.h> 120# define alloca _alloca 121# elif defined(__WATCOMC__) 122# include <malloc.h> 123# elif defined(__BORLANDC__) 124# include <malloc.h> 125# elif defined(__DMC__) 126# include <stdlib.h> 127# elif defined(SDL_PLATFORM_AIX) 128# pragma alloca 129# elif defined(__MRC__) 130void *alloca(unsigned); 131# else 132void *alloca(size_t); 133# endif 134# endif 135#endif 136 137 138#ifdef SDL_WIKI_DOCUMENTATION_SECTION 139 140/** 141 * Don't let SDL use "long long" C types. 142 * 143 * SDL will define this if it believes the compiler doesn't understand the 144 * "long long" syntax for C datatypes. This can happen on older compilers. 145 * 146 * If _your_ compiler doesn't support "long long" but SDL doesn't know it, it 147 * is safe to define this yourself to build against the SDL headers. 148 * 149 * If this is defined, it will remove access to some C runtime support 150 * functions, like SDL_ulltoa and SDL_strtoll that refer to this datatype 151 * explicitly. The rest of SDL will still be available. 152 * 153 * SDL's own source code cannot be built with a compiler that has this 154 * defined, for various technical reasons. 155 */ 156#define SDL_NOLONGLONG 1 157 158#elif defined(_MSC_VER) && (_MSC_VER < 1310) /* long long introduced in Visual Studio.NET 2003 */ 159# define SDL_NOLONGLONG 1 160#endif 161 162 163#ifdef SDL_WIKI_DOCUMENTATION_SECTION 164 165/** 166 * The largest value that a `size_t` can hold for the target platform. 167 * 168 * `size_t` is generally the same size as a pointer in modern times, but this 169 * can get weird on very old and very esoteric machines. For example, on a 170 * 16-bit Intel 286, you might have a 32-bit "far" pointer (16-bit segment 171 * plus 16-bit offset), but `size_t` is 16 bits, because it can only deal with 172 * the offset into an individual segment. 173 * 174 * In modern times, it's generally expected to cover an entire linear address 175 * space. But be careful! 176 * 177 * \since This macro is available since SDL 3.2.0. 178 */ 179#define SDL_SIZE_MAX SIZE_MAX 180 181#elif defined(SIZE_MAX) 182# define SDL_SIZE_MAX SIZE_MAX 183#else 184# define SDL_SIZE_MAX ((size_t) -1) 185#endif 186 187#ifndef SDL_COMPILE_TIME_ASSERT 188#ifdef SDL_WIKI_DOCUMENTATION_SECTION 189 190/** 191 * A compile-time assertion. 192 * 193 * This can check constant values _known to the compiler at build time_ for 194 * correctness, and end the compile with the error if they fail. 195 * 196 * Often times these are used to verify basic truths, like the size of a 197 * datatype is what is expected: 198 * 199 * ```c 200 * SDL_COMPILE_TIME_ASSERT(uint32_size, sizeof(Uint32) == 4); 201 * ``` 202 * 203 * The `name` parameter must be a valid C symbol, and must be unique across 204 * all compile-time asserts in the same compilation unit (one run of the 205 * compiler), or the build might fail with cryptic errors on some targets. 206 * This is used with a C language trick that works on older compilers that 207 * don't support better assertion techniques. 208 * 209 * If you need an assertion that operates at runtime, on variable data, you 210 * should try SDL_assert instead. 211 * 212 * \param name a unique identifier for this assertion. 213 * \param x the value to test. Must be a boolean value. 214 * 215 * \threadsafety This macro doesn't generate any code to run. 216 * 217 * \since This macro is available since SDL 3.2.0. 218 * 219 * \sa SDL_assert 220 */ 221#define SDL_COMPILE_TIME_ASSERT(name, x) FailToCompileIf_x_IsFalse(x) 222#elif defined(__cplusplus) 223/* Keep C++ case alone: Some versions of gcc will define __STDC_VERSION__ even when compiling in C++ mode. */ 224#if (__cplusplus >= 201103L) 225#define SDL_COMPILE_TIME_ASSERT(name, x) static_assert(x, #x) 226#endif 227#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 202311L) 228#define SDL_COMPILE_TIME_ASSERT(name, x) static_assert(x, #x) 229#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) 230#define SDL_COMPILE_TIME_ASSERT(name, x) _Static_assert(x, #x) 231#endif 232#endif /* !SDL_COMPILE_TIME_ASSERT */ 233 234#ifndef SDL_COMPILE_TIME_ASSERT 235/* universal, but may trigger -Wunused-local-typedefs */ 236#define SDL_COMPILE_TIME_ASSERT(name, x) \ 237 typedef int SDL_compile_time_assert_ ## name[(x) * 2 - 1] 238#endif 239 240/** 241 * The number of elements in a static array. 242 * 243 * This will compile but return incorrect results for a pointer to an array; 244 * it has to be an array the compiler knows the size of. 245 * 246 * This macro looks like it double-evaluates the argument, but it does so 247 * inside of `sizeof`, so there are no side-effects here, as expressions do 248 * not actually run any code in these cases. 249 * 250 * \since This macro is available since SDL 3.2.0. 251 */ 252#define SDL_arraysize(array) (sizeof(array)/sizeof(array[0])) 253 254/** 255 * Macro useful for building other macros with strings in them. 256 * 257 * \param arg the text to turn into a string literal. 258 * 259 * \since This macro is available since SDL 3.2.0. 260 */ 261#define SDL_STRINGIFY_ARG(arg) #arg 262 263/** 264 * \name Cast operators 265 * 266 * Use proper C++ casts when compiled as C++ to be compatible with the option 267 * -Wold-style-cast of GCC (and -Werror=old-style-cast in GCC 4.2 and above). 268 */ 269/* @{ */ 270 271#ifdef SDL_WIKI_DOCUMENTATION_SECTION 272 273/** 274 * Handle a Reinterpret Cast properly whether using C or C++. 275 * 276 * If compiled as C++, this macro offers a proper C++ reinterpret_cast<>. 277 * 278 * If compiled as C, this macro does a normal C-style cast. 279 * 280 * This is helpful to avoid compiler warnings in C++. 281 * 282 * \param type the type to cast the expression to. 283 * \param expression the expression to cast to a different type. 284 * \returns `expression`, cast to `type`. 285 * 286 * \threadsafety It is safe to call this macro from any thread. 287 * 288 * \since This macro is available since SDL 3.2.0. 289 * 290 * \sa SDL_static_cast 291 * \sa SDL_const_cast 292 */ 293#define SDL_reinterpret_cast(type, expression) reinterpret_cast<type>(expression) /* or `((type)(expression))` in C */ 294 295/** 296 * Handle a Static Cast properly whether using C or C++. 297 * 298 * If compiled as C++, this macro offers a proper C++ static_cast<>. 299 * 300 * If compiled as C, this macro does a normal C-style cast. 301 * 302 * This is helpful to avoid compiler warnings in C++. 303 * 304 * \param type the type to cast the expression to. 305 * \param expression the expression to cast to a different type. 306 * \returns `expression`, cast to `type`. 307 * 308 * \threadsafety It is safe to call this macro from any thread. 309 * 310 * \since This macro is available since SDL 3.2.0. 311 * 312 * \sa SDL_reinterpret_cast 313 * \sa SDL_const_cast 314 */ 315#define SDL_static_cast(type, expression) static_cast<type>(expression) /* or `((type)(expression))` in C */ 316 317/** 318 * Handle a Const Cast properly whether using C or C++. 319 * 320 * If compiled as C++, this macro offers a proper C++ const_cast<>. 321 * 322 * If compiled as C, this macro does a normal C-style cast. 323 * 324 * This is helpful to avoid compiler warnings in C++. 325 * 326 * \param type the type to cast the expression to. 327 * \param expression the expression to cast to a different type. 328 * \returns `expression`, cast to `type`. 329 * 330 * \threadsafety It is safe to call this macro from any thread. 331 * 332 * \since This macro is available since SDL 3.2.0. 333 * 334 * \sa SDL_reinterpret_cast 335 * \sa SDL_static_cast 336 */ 337#define SDL_const_cast(type, expression) const_cast<type>(expression) /* or `((type)(expression))` in C */ 338 339#elif defined(__cplusplus) 340#define SDL_reinterpret_cast(type, expression) reinterpret_cast<type>(expression) 341#define SDL_static_cast(type, expression) static_cast<type>(expression) 342#define SDL_const_cast(type, expression) const_cast<type>(expression) 343#else 344#define SDL_reinterpret_cast(type, expression) ((type)(expression)) 345#define SDL_static_cast(type, expression) ((type)(expression)) 346#define SDL_const_cast(type, expression) ((type)(expression)) 347#endif 348 349/* @} *//* Cast operators */ 350 351/** 352 * Define a four character code as a Uint32. 353 * 354 * \param A the first ASCII character. 355 * \param B the second ASCII character. 356 * \param C the third ASCII character. 357 * \param D the fourth ASCII character. 358 * \returns the four characters converted into a Uint32, one character 359 * per-byte. 360 * 361 * \threadsafety It is safe to call this macro from any thread. 362 * 363 * \since This macro is available since SDL 3.2.0. 364 */ 365#define SDL_FOURCC(A, B, C, D) \ 366 ((SDL_static_cast(Uint32, SDL_static_cast(Uint8, (A))) << 0) | \ 367 (SDL_static_cast(Uint32, SDL_static_cast(Uint8, (B))) << 8) | \ 368 (SDL_static_cast(Uint32, SDL_static_cast(Uint8, (C))) << 16) | \ 369 (SDL_static_cast(Uint32, SDL_static_cast(Uint8, (D))) << 24)) 370 371#ifdef SDL_WIKI_DOCUMENTATION_SECTION 372 373/** 374 * Append the 64 bit integer suffix to a signed integer literal. 375 * 376 * This helps compilers that might believe a integer literal larger than 377 * 0xFFFFFFFF is overflowing a 32-bit value. Use `SDL_SINT64_C(0xFFFFFFFF1)` 378 * instead of `0xFFFFFFFF1` by itself. 379 * 380 * \since This macro is available since SDL 3.2.0. 381 * 382 * \sa SDL_UINT64_C 383 */ 384#define SDL_SINT64_C(c) c ## LL /* or whatever the current compiler uses. */ 385 386/** 387 * Append the 64 bit integer suffix to an unsigned integer literal. 388 * 389 * This helps compilers that might believe a integer literal larger than 390 * 0xFFFFFFFF is overflowing a 32-bit value. Use `SDL_UINT64_C(0xFFFFFFFF1)` 391 * instead of `0xFFFFFFFF1` by itself. 392 * 393 * \since This macro is available since SDL 3.2.0. 394 * 395 * \sa SDL_SINT64_C 396 */ 397#define SDL_UINT64_C(c) c ## ULL /* or whatever the current compiler uses. */ 398 399#else /* !SDL_WIKI_DOCUMENTATION_SECTION */ 400 401#ifndef SDL_SINT64_C 402#if defined(INT64_C) 403#define SDL_SINT64_C(c) INT64_C(c) 404#elif defined(_MSC_VER) 405#define SDL_SINT64_C(c) c ## i64 406#elif defined(__LP64__) || defined(_LP64) 407#define SDL_SINT64_C(c) c ## L 408#else 409#define SDL_SINT64_C(c) c ## LL 410#endif 411#endif /* !SDL_SINT64_C */ 412 413#ifndef SDL_UINT64_C 414#if defined(UINT64_C) 415#define SDL_UINT64_C(c) UINT64_C(c) 416#elif defined(_MSC_VER) 417#define SDL_UINT64_C(c) c ## ui64 418#elif defined(__LP64__) || defined(_LP64) 419#define SDL_UINT64_C(c) c ## UL 420#else 421#define SDL_UINT64_C(c) c ## ULL 422#endif 423#endif /* !SDL_UINT64_C */ 424 425#endif /* !SDL_WIKI_DOCUMENTATION_SECTION */ 426 427/** 428 * \name Basic data types 429 */ 430/* @{ */ 431 432/** 433 * A signed 8-bit integer type. 434 * 435 * \since This macro is available since SDL 3.2.0. 436 */ 437typedef int8_t Sint8; 438#define SDL_MAX_SINT8 ((Sint8)0x7F) /* 127 */ 439#define SDL_MIN_SINT8 ((Sint8)(~0x7F)) /* -128 */ 440 441/** 442 * An unsigned 8-bit integer type. 443 * 444 * \since This macro is available since SDL 3.2.0. 445 */ 446typedef uint8_t Uint8; 447#define SDL_MAX_UINT8 ((Uint8)0xFF) /* 255 */ 448#define SDL_MIN_UINT8 ((Uint8)0x00) /* 0 */ 449 450/** 451 * A signed 16-bit integer type. 452 * 453 * \since This macro is available since SDL 3.2.0. 454 */ 455typedef int16_t Sint16; 456#define SDL_MAX_SINT16 ((Sint16)0x7FFF) /* 32767 */ 457#define SDL_MIN_SINT16 ((Sint16)(~0x7FFF)) /* -32768 */ 458 459/** 460 * An unsigned 16-bit integer type. 461 * 462 * \since This macro is available since SDL 3.2.0. 463 */ 464typedef uint16_t Uint16; 465#define SDL_MAX_UINT16 ((Uint16)0xFFFF) /* 65535 */ 466#define SDL_MIN_UINT16 ((Uint16)0x0000) /* 0 */ 467 468/** 469 * A signed 32-bit integer type. 470 * 471 * \since This macro is available since SDL 3.2.0. 472 */ 473typedef int32_t Sint32; 474#define SDL_MAX_SINT32 ((Sint32)0x7FFFFFFF) /* 2147483647 */ 475#define SDL_MIN_SINT32 ((Sint32)(~0x7FFFFFFF)) /* -2147483648 */ 476 477/** 478 * An unsigned 32-bit integer type. 479 * 480 * \since This macro is available since SDL 3.2.0. 481 */ 482typedef uint32_t Uint32; 483#define SDL_MAX_UINT32 ((Uint32)0xFFFFFFFFu) /* 4294967295 */ 484#define SDL_MIN_UINT32 ((Uint32)0x00000000) /* 0 */ 485 486/** 487 * A signed 64-bit integer type. 488 * 489 * \since This macro is available since SDL 3.2.0. 490 * 491 * \sa SDL_SINT64_C 492 */ 493typedef int64_t Sint64; 494#define SDL_MAX_SINT64 SDL_SINT64_C(0x7FFFFFFFFFFFFFFF) /* 9223372036854775807 */ 495#define SDL_MIN_SINT64 ~SDL_SINT64_C(0x7FFFFFFFFFFFFFFF) /* -9223372036854775808 */ 496 497/** 498 * An unsigned 64-bit integer type. 499 * 500 * \since This macro is available since SDL 3.2.0. 501 * 502 * \sa SDL_UINT64_C 503 */ 504typedef uint64_t Uint64; 505#define SDL_MAX_UINT64 SDL_UINT64_C(0xFFFFFFFFFFFFFFFF) /* 18446744073709551615 */ 506#define SDL_MIN_UINT64 SDL_UINT64_C(0x0000000000000000) /* 0 */ 507 508/** 509 * SDL times are signed, 64-bit integers representing nanoseconds since the 510 * Unix epoch (Jan 1, 1970). 511 * 512 * They can be converted between POSIX time_t values with SDL_NS_TO_SECONDS() 513 * and SDL_SECONDS_TO_NS(), and between Windows FILETIME values with 514 * SDL_TimeToWindows() and SDL_TimeFromWindows(). 515 * 516 * \since This datatype is available since SDL 3.2.0. 517 * 518 * \sa SDL_MAX_SINT64 519 * \sa SDL_MIN_SINT64 520 */ 521typedef Sint64 SDL_Time; 522#define SDL_MAX_TIME SDL_MAX_SINT64 523#define SDL_MIN_TIME SDL_MIN_SINT64 524 525/* @} *//* Basic data types */ 526 527/** 528 * \name Floating-point constants 529 */ 530/* @{ */ 531 532#ifdef FLT_EPSILON 533#define SDL_FLT_EPSILON FLT_EPSILON 534#else 535 536/** 537 * Epsilon constant, used for comparing floating-point numbers. 538 * 539 * Equals by default to platform-defined `FLT_EPSILON`, or 540 * `1.1920928955078125e-07F` if that's not available. 541 * 542 * \since This macro is available since SDL 3.2.0. 543 */ 544#define SDL_FLT_EPSILON 1.1920928955078125e-07F /* 0x0.000002p0 */ 545#endif 546 547/* @} *//* Floating-point constants */ 548 549#ifdef SDL_WIKI_DOCUMENTATION_SECTION 550 551/** 552 * A printf-formatting string for an Sint64 value. 553 * 554 * Use it like this: 555 * 556 * ```c 557 * SDL_Log("There are %" SDL_PRIs64 " bottles of beer on the wall.", bottles); 558 * ``` 559 * 560 * \since This macro is available since SDL 3.2.0. 561 */ 562#define SDL_PRIs64 "lld" 563 564/** 565 * A printf-formatting string for a Uint64 value. 566 * 567 * Use it like this: 568 * 569 * ```c 570 * SDL_Log("There are %" SDL_PRIu64 " bottles of beer on the wall.", bottles); 571 * ``` 572 * 573 * \since This macro is available since SDL 3.2.0. 574 */ 575#define SDL_PRIu64 "llu" 576 577/** 578 * A printf-formatting string for a Uint64 value as lower-case hexadecimal. 579 * 580 * Use it like this: 581 * 582 * ```c 583 * SDL_Log("There are %" SDL_PRIx64 " bottles of beer on the wall.", bottles); 584 * ``` 585 * 586 * \since This macro is available since SDL 3.2.0. 587 */ 588#define SDL_PRIx64 "llx" 589 590/** 591 * A printf-formatting string for a Uint64 value as upper-case hexadecimal. 592 * 593 * Use it like this: 594 * 595 * ```c 596 * SDL_Log("There are %" SDL_PRIX64 " bottles of beer on the wall.", bottles); 597 * ``` 598 * 599 * \since This macro is available since SDL 3.2.0. 600 */ 601#define SDL_PRIX64 "llX" 602 603/** 604 * A printf-formatting string for an Sint32 value. 605 * 606 * Use it like this: 607 * 608 * ```c 609 * SDL_Log("There are %" SDL_PRIs32 " bottles of beer on the wall.", bottles); 610 * ``` 611 * 612 * \since This macro is available since SDL 3.2.0. 613 */ 614#define SDL_PRIs32 "d" 615 616/** 617 * A printf-formatting string for a Uint32 value. 618 * 619 * Use it like this: 620 * 621 * ```c 622 * SDL_Log("There are %" SDL_PRIu32 " bottles of beer on the wall.", bottles); 623 * ``` 624 * 625 * \since This macro is available since SDL 3.2.0. 626 */ 627#define SDL_PRIu32 "u" 628 629/** 630 * A printf-formatting string for a Uint32 value as lower-case hexadecimal. 631 * 632 * Use it like this: 633 * 634 * ```c 635 * SDL_Log("There are %" SDL_PRIx32 " bottles of beer on the wall.", bottles); 636 * ``` 637 * 638 * \since This macro is available since SDL 3.2.0. 639 */ 640#define SDL_PRIx32 "x" 641 642/** 643 * A printf-formatting string for a Uint32 value as upper-case hexadecimal. 644 * 645 * Use it like this: 646 * 647 * ```c 648 * SDL_Log("There are %" SDL_PRIX32 " bottles of beer on the wall.", bottles); 649 * ``` 650 * 651 * \since This macro is available since SDL 3.2.0. 652 */ 653#define SDL_PRIX32 "X" 654 655/** 656 * A printf-formatting string prefix for a `long long` value. 657 * 658 * This is just the prefix! You probably actually want SDL_PRILLd, SDL_PRILLu, 659 * SDL_PRILLx, or SDL_PRILLX instead. 660 * 661 * Use it like this: 662 * 663 * ```c 664 * SDL_Log("There are %" SDL_PRILL_PREFIX "d bottles of beer on the wall.", bottles); 665 * ``` 666 * 667 * \since This macro is available since SDL 3.2.0. 668 */ 669#define SDL_PRILL_PREFIX "ll" 670 671/** 672 * A printf-formatting string for a `long long` value. 673 * 674 * Use it like this: 675 * 676 * ```c 677 * SDL_Log("There are %" SDL_PRILLd " bottles of beer on the wall.", bottles); 678 * ``` 679 * 680 * \since This macro is available since SDL 3.2.0. 681 */ 682#define SDL_PRILLd SDL_PRILL_PREFIX "d" 683 684/** 685 * A printf-formatting string for a `unsigned long long` value. 686 * 687 * Use it like this: 688 * 689 * ```c 690 * SDL_Log("There are %" SDL_PRILLu " bottles of beer on the wall.", bottles); 691 * ``` 692 * 693 * \since This macro is available since SDL 3.2.0. 694 */ 695#define SDL_PRILLu SDL_PRILL_PREFIX "u" 696 697/** 698 * A printf-formatting string for an `unsigned long long` value as lower-case 699 * hexadecimal. 700 * 701 * Use it like this: 702 * 703 * ```c 704 * SDL_Log("There are %" SDL_PRILLx " bottles of beer on the wall.", bottles); 705 * ``` 706 * 707 * \since This macro is available since SDL 3.2.0. 708 */ 709#define SDL_PRILLx SDL_PRILL_PREFIX "x" 710 711/** 712 * A printf-formatting string for an `unsigned long long` value as upper-case 713 * hexadecimal. 714 * 715 * Use it like this: 716 * 717 * ```c 718 * SDL_Log("There are %" SDL_PRILLX " bottles of beer on the wall.", bottles); 719 * ``` 720 * 721 * \since This macro is available since SDL 3.2.0. 722 */ 723#define SDL_PRILLX SDL_PRILL_PREFIX "X" 724#endif /* SDL_WIKI_DOCUMENTATION_SECTION */ 725 726/* Make sure we have macros for printing width-based integers. 727 * <inttypes.h> should define these but this is not true all platforms. 728 * (for example win32) */ 729#ifndef SDL_PRIs64 730#if defined(SDL_PLATFORM_WINDOWS) 731#define SDL_PRIs64 "I64d" 732#elif defined(PRId64) 733#define SDL_PRIs64 PRId64 734#elif defined(__LP64__) && !defined(SDL_PLATFORM_APPLE) && !defined(__EMSCRIPTEN__) 735#define SDL_PRIs64 "ld" 736#else 737#define SDL_PRIs64 "lld" 738#endif 739#endif 740#ifndef SDL_PRIu64 741#if defined(SDL_PLATFORM_WINDOWS) 742#define SDL_PRIu64 "I64u" 743#elif defined(PRIu64) 744#define SDL_PRIu64 PRIu64 745#elif defined(__LP64__) && !defined(SDL_PLATFORM_APPLE) && !defined(__EMSCRIPTEN__) 746#define SDL_PRIu64 "lu" 747#else 748#define SDL_PRIu64 "llu" 749#endif 750#endif 751#ifndef SDL_PRIx64 752#if defined(SDL_PLATFORM_WINDOWS) 753#define SDL_PRIx64 "I64x" 754#elif defined(PRIx64) 755#define SDL_PRIx64 PRIx64 756#elif defined(__LP64__) && !defined(SDL_PLATFORM_APPLE) 757#define SDL_PRIx64 "lx" 758#else 759#define SDL_PRIx64 "llx" 760#endif 761#endif 762#ifndef SDL_PRIX64 763#if defined(SDL_PLATFORM_WINDOWS) 764#define SDL_PRIX64 "I64X" 765#elif defined(PRIX64) 766#define SDL_PRIX64 PRIX64 767#elif defined(__LP64__) && !defined(SDL_PLATFORM_APPLE) 768#define SDL_PRIX64 "lX" 769#else 770#define SDL_PRIX64 "llX" 771#endif 772#endif 773#ifndef SDL_PRIs32 774#ifdef PRId32 775#define SDL_PRIs32 PRId32 776#else 777#define SDL_PRIs32 "d" 778#endif 779#endif 780#ifndef SDL_PRIu32 781#ifdef PRIu32 782#define SDL_PRIu32 PRIu32 783#else 784#define SDL_PRIu32 "u" 785#endif 786#endif 787#ifndef SDL_PRIx32 788#ifdef PRIx32 789#define SDL_PRIx32 PRIx32 790#else 791#define SDL_PRIx32 "x" 792#endif 793#endif 794#ifndef SDL_PRIX32 795#ifdef PRIX32 796#define SDL_PRIX32 PRIX32 797#else 798#define SDL_PRIX32 "X" 799#endif 800#endif 801/* Specifically for the `long long` -- SDL-specific. */ 802#ifdef SDL_PLATFORM_WINDOWS 803#ifndef SDL_NOLONGLONG 804SDL_COMPILE_TIME_ASSERT(longlong_size64, sizeof(long long) == 8); /* using I64 for windows - make sure `long long` is 64 bits. */ 805#endif 806#define SDL_PRILL_PREFIX "I64" 807#else 808#define SDL_PRILL_PREFIX "ll" 809#endif 810#ifndef SDL_PRILLd 811#define SDL_PRILLd SDL_PRILL_PREFIX "d" 812#endif 813#ifndef SDL_PRILLu 814#define SDL_PRILLu SDL_PRILL_PREFIX "u" 815#endif 816#ifndef SDL_PRILLx 817#define SDL_PRILLx SDL_PRILL_PREFIX "x" 818#endif 819#ifndef SDL_PRILLX 820#define SDL_PRILLX SDL_PRILL_PREFIX "X" 821#endif 822 823/* Annotations to help code analysis tools */ 824#ifdef SDL_WIKI_DOCUMENTATION_SECTION 825 826/** 827 * Macro that annotates function params with input buffer size. 828 * 829 * If we were to annotate `memcpy`: 830 * 831 * ```c 832 * void *memcpy(void *dst, SDL_IN_BYTECAP(len) const void *src, size_t len); 833 * ``` 834 * 835 * This notes that `src` should be `len` bytes in size and is only read by the 836 * function. The compiler or other analysis tools can warn when this doesn't 837 * appear to be the case. 838 * 839 * On compilers without this annotation mechanism, this is defined to nothing. 840 * 841 * \since This macro is available since SDL 3.2.0. 842 */ 843#define SDL_IN_BYTECAP(x) _In_bytecount_(x) 844 845/** 846 * Macro that annotates function params with input/output string buffer size. 847 * 848 * If we were to annotate `strlcat`: 849 * 850 * ```c 851 * size_t strlcat(SDL_INOUT_Z_CAP(maxlen) char *dst, const char *src, size_t maxlen); 852 * ``` 853 * 854 * This notes that `dst` is a null-terminated C string, should be `maxlen` 855 * bytes in size, and is both read from and written to by the function. The 856 * compiler or other analysis tools can warn when this doesn't appear to be 857 * the case. 858 * 859 * On compilers without this annotation mechanism, this is defined to nothing. 860 * 861 * \since This macro is available since SDL 3.2.0. 862 */ 863#define SDL_INOUT_Z_CAP(x) _Inout_z_cap_(x) 864 865/** 866 * Macro that annotates function params with output string buffer size. 867 * 868 * If we were to annotate `snprintf`: 869 * 870 * ```c 871 * int snprintf(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, const char *fmt, ...); 872 * ``` 873 * 874 * This notes that `text` is a null-terminated C string, should be `maxlen` 875 * bytes in size, and is only written to by the function. The compiler or 876 * other analysis tools can warn when this doesn't appear to be the case. 877 * 878 * On compilers without this annotation mechanism, this is defined to nothing. 879 * 880 * \since This macro is available since SDL 3.2.0. 881 */ 882#define SDL_OUT_Z_CAP(x) _Out_z_cap_(x) 883 884/** 885 * Macro that annotates function params with output buffer size. 886 * 887 * If we were to annotate `wcsncpy`: 888 * 889 * ```c 890 * char *wcscpy(SDL_OUT_CAP(bufsize) wchar_t *dst, const wchar_t *src, size_t bufsize); 891 * ``` 892 * 893 * This notes that `dst` should have a capacity of `bufsize` wchar_t in size, 894 * and is only written to by the function. The compiler or other analysis 895 * tools can warn when this doesn't appear to be the case. 896 * 897 * This operates on counts of objects, not bytes. Use SDL_OUT_BYTECAP for 898 * bytes. 899 * 900 * On compilers without this annotation mechanism, this is defined to nothing. 901 * 902 * \since This macro is available since SDL 3.2.0. 903 */ 904#define SDL_OUT_CAP(x) _Out_cap_(x) 905 906/** 907 * Macro that annotates function params with output buffer size. 908 * 909 * If we were to annotate `memcpy`: 910 * 911 * ```c 912 * void *memcpy(SDL_OUT_BYTECAP(bufsize) void *dst, const void *src, size_t bufsize); 913 * ``` 914 * 915 * This notes that `dst` should have a capacity of `bufsize` bytes in size, 916 * and is only written to by the function. The compiler or other analysis 917 * tools can warn when this doesn't appear to be the case. 918 * 919 * On compilers without this annotation mechanism, this is defined to nothing. 920 * 921 * \since This macro is available since SDL 3.2.0. 922 */ 923#define SDL_OUT_BYTECAP(x) _Out_bytecap_(x) 924 925/** 926 * Macro that annotates function params with output buffer string size. 927 * 928 * If we were to annotate `strcpy`: 929 * 930 * ```c 931 * char *strcpy(SDL_OUT_Z_BYTECAP(bufsize) char *dst, const char *src, size_t bufsize); 932 * ``` 933 * 934 * This notes that `dst` should have a capacity of `bufsize` bytes in size, 935 * and a zero-terminated string is written to it by the function. The compiler 936 * or other analysis tools can warn when this doesn't appear to be the case. 937 * 938 * On compilers without this annotation mechanism, this is defined to nothing. 939 * 940 * \since This macro is available since SDL 3.2.0. 941 */ 942#define SDL_OUT_Z_BYTECAP(x) _Out_z_bytecap_(x) 943 944/** 945 * Macro that annotates function params as printf-style format strings. 946 * 947 * If we were to annotate `fprintf`: 948 * 949 * ```c 950 * int fprintf(FILE *f, SDL_PRINTF_FORMAT_STRING const char *fmt, ...); 951 * ``` 952 * 953 * This notes that `fmt` should be a printf-style format string. The compiler 954 * or other analysis tools can warn when this doesn't appear to be the case. 955 * 956 * On compilers without this annotation mechanism, this is defined to nothing. 957 * 958 * \since This macro is available since SDL 3.2.0. 959 */ 960#define SDL_PRINTF_FORMAT_STRING _Printf_format_string_ 961 962/** 963 * Macro that annotates function params as scanf-style format strings. 964 * 965 * If we were to annotate `fscanf`: 966 * 967 * ```c 968 * int fscanf(FILE *f, SDL_SCANF_FORMAT_STRING const char *fmt, ...); 969 * ``` 970 * 971 * This notes that `fmt` should be a scanf-style format string. The compiler 972 * or other analysis tools can warn when this doesn't appear to be the case. 973 * 974 * On compilers without this annotation mechanism, this is defined to nothing. 975 * 976 * \since This macro is available since SDL 3.2.0. 977 */ 978#define SDL_SCANF_FORMAT_STRING _Scanf_format_string_impl_ 979 980/** 981 * Macro that annotates a vararg function that operates like printf. 982 * 983 * If we were to annotate `fprintf`: 984 * 985 * ```c 986 * int fprintf(FILE *f, const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(2); 987 * ``` 988 * 989 * This notes that the second parameter should be a printf-style format 990 * string, followed by `...`. The compiler or other analysis tools can warn 991 * when this doesn't appear to be the case. 992 * 993 * On compilers without this annotation mechanism, this is defined to nothing. 994 * 995 * This can (and should) be used with SDL_PRINTF_FORMAT_STRING as well, which 996 * between them will cover at least Visual Studio, GCC, and Clang. 997 * 998 * \since This macro is available since SDL 3.2.0. 999 */ 1000#define SDL_PRINTF_VARARG_FUNC( fmtargnumber ) __attribute__ (( format( __printf__, fmtargnumber, fmtargnumber+1 ))) 1001 1002/** 1003 * Macro that annotates a va_list function that operates like printf. 1004 * 1005 * If we were to annotate `vfprintf`: 1006 * 1007 * ```c 1008 * int vfprintf(FILE *f, const char *fmt, va_list ap) SDL_PRINTF_VARARG_FUNCV(2); 1009 * ``` 1010 * 1011 * This notes that the second parameter should be a printf-style format 1012 * string, followed by a va_list. The compiler or other analysis tools can 1013 * warn when this doesn't appear to be the case. 1014 * 1015 * On compilers without this annotation mechanism, this is defined to nothing. 1016 * 1017 * This can (and should) be used with SDL_PRINTF_FORMAT_STRING as well, which 1018 * between them will cover at least Visual Studio, GCC, and Clang. 1019 * 1020 * \since This macro is available since SDL 3.2.0. 1021 */ 1022#define SDL_PRINTF_VARARG_FUNCV( fmtargnumber ) __attribute__(( format( __printf__, fmtargnumber, 0 ))) 1023 1024/** 1025 * Macro that annotates a vararg function that operates like scanf. 1026 * 1027 * If we were to annotate `fscanf`: 1028 * 1029 * ```c 1030 * int fscanf(FILE *f, const char *fmt, ...) SDL_PRINTF_VARARG_FUNCV(2); 1031 * ``` 1032 * 1033 * This notes that the second parameter should be a scanf-style format string, 1034 * followed by `...`. The compiler or other analysis tools can warn when this 1035 * doesn't appear to be the case. 1036 * 1037 * On compilers without this annotation mechanism, this is defined to nothing. 1038 * 1039 * This can (and should) be used with SDL_SCANF_FORMAT_STRING as well, which 1040 * between them will cover at least Visual Studio, GCC, and Clang. 1041 * 1042 * \since This macro is available since SDL 3.2.0. 1043 */ 1044#define SDL_SCANF_VARARG_FUNC( fmtargnumber ) __attribute__ (( format( __scanf__, fmtargnumber, fmtargnumber+1 ))) 1045 1046/** 1047 * Macro that annotates a va_list function that operates like scanf. 1048 * 1049 * If we were to annotate `vfscanf`: 1050 * 1051 * ```c 1052 * int vfscanf(FILE *f, const char *fmt, va_list ap) SDL_PRINTF_VARARG_FUNCV(2); 1053 * ``` 1054 * 1055 * This notes that the second parameter should be a scanf-style format string, 1056 * followed by a va_list. The compiler or other analysis tools can warn when 1057 * this doesn't appear to be the case. 1058 * 1059 * On compilers without this annotation mechanism, this is defined to nothing. 1060 * 1061 * This can (and should) be used with SDL_SCANF_FORMAT_STRING as well, which 1062 * between them will cover at least Visual Studio, GCC, and Clang. 1063 * 1064 * \since This macro is available since SDL 3.2.0. 1065 */ 1066#define SDL_SCANF_VARARG_FUNCV( fmtargnumber ) __attribute__(( format( __scanf__, fmtargnumber, 0 ))) 1067 1068/** 1069 * Macro that annotates a vararg function that operates like wprintf. 1070 * 1071 * If we were to annotate `fwprintf`: 1072 * 1073 * ```c 1074 * int fwprintf(FILE *f, const wchar_t *fmt, ...) SDL_WPRINTF_VARARG_FUNC(2); 1075 * ``` 1076 * 1077 * This notes that the second parameter should be a wprintf-style format wide 1078 * string, followed by `...`. The compiler or other analysis tools can warn 1079 * when this doesn't appear to be the case. 1080 * 1081 * On compilers without this annotation mechanism, this is defined to nothing. 1082 * 1083 * This can (and should) be used with SDL_PRINTF_FORMAT_STRING as well, which 1084 * between them will cover at least Visual Studio, GCC, and Clang. 1085 * 1086 * \since This macro is available since SDL 3.2.0. 1087 */ 1088#define SDL_WPRINTF_VARARG_FUNC( fmtargnumber ) /* __attribute__ (( format( __wprintf__, fmtargnumber, fmtargnumber+1 ))) */ 1089 1090/** 1091 * Macro that annotates a va_list function that operates like wprintf. 1092 * 1093 * If we were to annotate `vfwprintf`: 1094 * 1095 * ```c 1096 * int vfwprintf(FILE *f, const wchar_t *fmt, va_list ap) SDL_WPRINTF_VARARG_FUNC(2); 1097 * ``` 1098 * 1099 * This notes that the second parameter should be a wprintf-style format wide 1100 * string, followed by a va_list. The compiler or other analysis tools can 1101 * warn when this doesn't appear to be the case. 1102 * 1103 * On compilers without this annotation mechanism, this is defined to nothing. 1104 * 1105 * This can (and should) be used with SDL_PRINTF_FORMAT_STRING as well, which 1106 * between them will cover at least Visual Studio, GCC, and Clang. 1107 * 1108 * \since This macro is available since SDL 3.2.0. 1109 */ 1110#define SDL_WPRINTF_VARARG_FUNCV( fmtargnumber ) /* __attribute__ (( format( __wprintf__, fmtargnumber, 0 ))) */ 1111 1112#elif defined(SDL_DISABLE_ANALYZE_MACROS) 1113#define SDL_IN_BYTECAP(x) 1114#define SDL_INOUT_Z_CAP(x) 1115#define SDL_OUT_Z_CAP(x) 1116#define SDL_OUT_CAP(x) 1117#define SDL_OUT_BYTECAP(x) 1118#define SDL_OUT_Z_BYTECAP(x) 1119#define SDL_PRINTF_FORMAT_STRING 1120#define SDL_SCANF_FORMAT_STRING 1121#define SDL_PRINTF_VARARG_FUNC( fmtargnumber ) 1122#define SDL_PRINTF_VARARG_FUNCV( fmtargnumber ) 1123#define SDL_SCANF_VARARG_FUNC( fmtargnumber ) 1124#define SDL_SCANF_VARARG_FUNCV( fmtargnumber ) 1125#define SDL_WPRINTF_VARARG_FUNC( fmtargnumber ) 1126#define SDL_WPRINTF_VARARG_FUNCV( fmtargnumber ) 1127#else 1128#if defined(_MSC_VER) && (_MSC_VER >= 1600) /* VS 2010 and above */ 1129#include <sal.h> 1130 1131#define SDL_IN_BYTECAP(x) _In_bytecount_(x) 1132#define SDL_INOUT_Z_CAP(x) _Inout_z_cap_(x) 1133#define SDL_OUT_Z_CAP(x) _Out_z_cap_(x) 1134#define SDL_OUT_CAP(x) _Out_cap_(x) 1135#define SDL_OUT_BYTECAP(x) _Out_bytecap_(x) 1136#define SDL_OUT_Z_BYTECAP(x) _Out_z_bytecap_(x) 1137 1138#define SDL_PRINTF_FORMAT_STRING _Printf_format_string_ 1139#define SDL_SCANF_FORMAT_STRING _Scanf_format_string_impl_ 1140#else 1141#define SDL_IN_BYTECAP(x) 1142#define SDL_INOUT_Z_CAP(x) 1143#define SDL_OUT_Z_CAP(x) 1144#define SDL_OUT_CAP(x) 1145#define SDL_OUT_BYTECAP(x) 1146#define SDL_OUT_Z_BYTECAP(x) 1147#define SDL_PRINTF_FORMAT_STRING 1148#define SDL_SCANF_FORMAT_STRING 1149#endif 1150#if defined(__GNUC__) || defined(__clang__) 1151#define SDL_PRINTF_VARARG_FUNC( fmtargnumber ) __attribute__ (( format( __printf__, fmtargnumber, fmtargnumber+1 ))) 1152#define SDL_PRINTF_VARARG_FUNCV( fmtargnumber ) __attribute__(( format( __printf__, fmtargnumber, 0 ))) 1153#define SDL_SCANF_VARARG_FUNC( fmtargnumber ) __attribute__ (( format( __scanf__, fmtargnumber, fmtargnumber+1 ))) 1154#define SDL_SCANF_VARARG_FUNCV( fmtargnumber ) __attribute__(( format( __scanf__, fmtargnumber, 0 ))) 1155#define SDL_WPRINTF_VARARG_FUNC( fmtargnumber ) /* __attribute__ (( format( __wprintf__, fmtargnumber, fmtargnumber+1 ))) */ 1156#define SDL_WPRINTF_VARARG_FUNCV( fmtargnumber ) /* __attribute__ (( format( __wprintf__, fmtargnumber, 0 ))) */ 1157#else 1158#define SDL_PRINTF_VARARG_FUNC( fmtargnumber ) 1159#define SDL_PRINTF_VARARG_FUNCV( fmtargnumber ) 1160#define SDL_SCANF_VARARG_FUNC( fmtargnumber ) 1161#define SDL_SCANF_VARARG_FUNCV( fmtargnumber ) 1162#define SDL_WPRINTF_VARARG_FUNC( fmtargnumber ) 1163#define SDL_WPRINTF_VARARG_FUNCV( fmtargnumber ) 1164#endif 1165#endif /* SDL_DISABLE_ANALYZE_MACROS */ 1166 1167/** \cond */ 1168#ifndef DOXYGEN_SHOULD_IGNORE_THIS 1169SDL_COMPILE_TIME_ASSERT(bool_size, sizeof(bool) == 1); 1170SDL_COMPILE_TIME_ASSERT(uint8_size, sizeof(Uint8) == 1); 1171SDL_COMPILE_TIME_ASSERT(sint8_size, sizeof(Sint8) == 1); 1172SDL_COMPILE_TIME_ASSERT(uint16_size, sizeof(Uint16) == 2); 1173SDL_COMPILE_TIME_ASSERT(sint16_size, sizeof(Sint16) == 2); 1174SDL_COMPILE_TIME_ASSERT(uint32_size, sizeof(Uint32) == 4); 1175SDL_COMPILE_TIME_ASSERT(sint32_size, sizeof(Sint32) == 4); 1176SDL_COMPILE_TIME_ASSERT(uint64_size, sizeof(Uint64) == 8); 1177SDL_COMPILE_TIME_ASSERT(sint64_size, sizeof(Sint64) == 8); 1178#ifndef SDL_NOLONGLONG 1179SDL_COMPILE_TIME_ASSERT(uint64_longlong, sizeof(Uint64) <= sizeof(unsigned long long)); 1180SDL_COMPILE_TIME_ASSERT(size_t_longlong, sizeof(size_t) <= sizeof(unsigned long long)); 1181#endif 1182typedef struct SDL_alignment_test 1183{ 1184 Uint8 a; 1185 void *b; 1186} SDL_alignment_test; 1187SDL_COMPILE_TIME_ASSERT(struct_alignment, sizeof(SDL_alignment_test) == (2 * sizeof(void *))); 1188SDL_COMPILE_TIME_ASSERT(two_s_complement, SDL_static_cast(int, ~SDL_static_cast(int, 0)) == SDL_static_cast(int, -1)); 1189#endif /* DOXYGEN_SHOULD_IGNORE_THIS */ 1190/** \endcond */ 1191 1192/* Check to make sure enums are the size of ints, for structure packing. 1193 For both Watcom C/C++ and Borland C/C++ the compiler option that makes 1194 enums having the size of an int must be enabled. 1195 This is "-b" for Borland C/C++ and "-ei" for Watcom C/C++ (v11). 1196*/ 1197 1198/** \cond */ 1199#ifndef DOXYGEN_SHOULD_IGNORE_THIS 1200#if !defined(SDL_PLATFORM_VITA) && !defined(SDL_PLATFORM_3DS) 1201/* TODO: include/SDL_stdinc.h:390: error: size of array 'SDL_dummy_enum' is negative */ 1202typedef enum SDL_DUMMY_ENUM 1203{ 1204 DUMMY_ENUM_VALUE 1205} SDL_DUMMY_ENUM; 1206 1207SDL_COMPILE_TIME_ASSERT(enum, sizeof(SDL_DUMMY_ENUM) == sizeof(int)); 1208#endif 1209#endif /* DOXYGEN_SHOULD_IGNORE_THIS */ 1210/** \endcond */ 1211 1212#include <SDL3/SDL_begin_code.h> 1213/* Set up for C function definitions, even when using C++ */ 1214#ifdef __cplusplus 1215extern "C" { 1216#endif 1217 1218/** 1219 * A macro to initialize an SDL interface. 1220 * 1221 * This macro will initialize an SDL interface structure and should be called 1222 * before you fill out the fields with your implementation. 1223 * 1224 * You can use it like this: 1225 * 1226 * ```c 1227 * SDL_IOStreamInterface iface; 1228 * 1229 * SDL_INIT_INTERFACE(&iface); 1230 * 1231 * // Fill in the interface function pointers with your implementation 1232 * iface.seek = ... 1233 * 1234 * stream = SDL_OpenIO(&iface, NULL); 1235 * ``` 1236 * 1237 * If you are using designated initializers, you can use the size of the 1238 * interface as the version, e.g. 1239 * 1240 * ```c 1241 * SDL_IOStreamInterface iface = { 1242 * .version = sizeof(iface), 1243 * .seek = ... 1244 * }; 1245 * stream = SDL_OpenIO(&iface, NULL); 1246 * ``` 1247 * 1248 * \threadsafety It is safe to call this macro from any thread. 1249 * 1250 * \since This macro is available since SDL 3.2.0. 1251 * 1252 * \sa SDL_IOStreamInterface 1253 * \sa SDL_StorageInterface 1254 * \sa SDL_VirtualJoystickDesc 1255 */ 1256#define SDL_INIT_INTERFACE(iface) \ 1257 do { \ 1258 SDL_zerop(iface); \ 1259 (iface)->version = sizeof(*(iface)); \ 1260 } while (0) 1261 1262 1263#ifdef SDL_WIKI_DOCUMENTATION_SECTION 1264 1265/** 1266 * Allocate memory on the stack (maybe). 1267 * 1268 * If SDL knows how to access alloca() on the current platform, it will use it 1269 * to stack-allocate memory here. If it doesn't, it will use SDL_malloc() to 1270 * heap-allocate memory. 1271 * 1272 * Since this might not be stack memory at all, it's important that you check 1273 * the returned pointer for NULL, and that you call SDL_stack_free on the 1274 * memory when done with it. Since this might be stack memory, it's important 1275 * that you don't allocate large amounts of it, or allocate in a loop without 1276 * returning from the function, so the stack doesn't overflow. 1277 * 1278 * \param type the datatype of the memory to allocate. 1279 * \param count the number of `type` objects to allocate. 1280 * \returns newly-allocated memory, or NULL on failure. 1281 * 1282 * \threadsafety It is safe to call this macro from any thread. 1283 * 1284 * \since This macro is available since SDL 3.2.0. 1285 * 1286 * \sa SDL_stack_free 1287 */ 1288#define SDL_stack_alloc(type, count) (type*)alloca(sizeof(type)*(count)) 1289 1290/** 1291 * Free memory previously allocated with SDL_stack_alloc. 1292 * 1293 * If SDL used alloca() to allocate this memory, this macro does nothing and 1294 * the allocated memory will be automatically released when the function that 1295 * called SDL_stack_alloc() returns. If SDL used SDL_malloc(), it will 1296 * SDL_free the memory immediately. 1297 * 1298 * \param data the pointer, from SDL_stack_alloc(), to free. 1299 * 1300 * \threadsafety It is safe to call this macro from any thread. 1301 * 1302 * \since This macro is available since SDL 3.2.0. 1303 * 1304 * \sa SDL_stack_alloc 1305 */ 1306#define SDL_stack_free(data) 1307#elif !defined(SDL_DISABLE_ALLOCA) 1308#define SDL_stack_alloc(type, count) (type*)alloca(sizeof(type)*(count)) 1309#define SDL_stack_free(data) 1310#else 1311#define SDL_stack_alloc(type, count) (type*)SDL_malloc(sizeof(type)*(count)) 1312#define SDL_stack_free(data) SDL_free(data) 1313#endif 1314 1315/** 1316 * Allocate uninitialized memory. 1317 * 1318 * The allocated memory returned by this function must be freed with 1319 * SDL_free(). 1320 * 1321 * If `size` is 0, it will be set to 1. 1322 * 1323 * If the allocation is successful, the returned pointer is guaranteed to be 1324 * aligned to either the *fundamental alignment* (`alignof(max_align_t)` in 1325 * C11 and later) or `2 * sizeof(void *)`, whichever is smaller. Use 1326 * SDL_aligned_alloc() if you need to allocate memory aligned to an alignment 1327 * greater than this guarantee. 1328 * 1329 * \param size the size to allocate. 1330 * \returns a pointer to the allocated memory, or NULL if allocation failed. 1331 * 1332 * \threadsafety It is safe to call this function from any thread. 1333 * 1334 * \since This function is available since SDL 3.2.0. 1335 * 1336 * \sa SDL_free 1337 * \sa SDL_calloc 1338 * \sa SDL_realloc 1339 * \sa SDL_aligned_alloc 1340 */ 1341extern SDL_DECLSPEC SDL_MALLOC void * SDLCALL SDL_malloc(size_t size); 1342 1343/** 1344 * Allocate a zero-initialized array. 1345 * 1346 * The memory returned by this function must be freed with SDL_free(). 1347 * 1348 * If either of `nmemb` or `size` is 0, they will both be set to 1. 1349 * 1350 * If the allocation is successful, the returned pointer is guaranteed to be 1351 * aligned to either the *fundamental alignment* (`alignof(max_align_t)` in 1352 * C11 and later) or `2 * sizeof(void *)`, whichever is smaller. 1353 * 1354 * \param nmemb the number of elements in the array. 1355 * \param size the size of each element of the array. 1356 * \returns a pointer to the allocated array, or NULL if allocation failed. 1357 * 1358 * \threadsafety It is safe to call this function from any thread. 1359 * 1360 * \since This function is available since SDL 3.2.0. 1361 * 1362 * \sa SDL_free 1363 * \sa SDL_malloc 1364 * \sa SDL_realloc 1365 */ 1366extern SDL_DECLSPEC SDL_MALLOC SDL_ALLOC_SIZE2(1, 2) void * SDLCALL SDL_calloc(size_t nmemb, size_t size); 1367 1368/** 1369 * Change the size of allocated memory. 1370 * 1371 * The memory returned by this function must be freed with SDL_free(). 1372 * 1373 * If `size` is 0, it will be set to 1. Note that this is unlike some other C 1374 * runtime `realloc` implementations, which may treat `realloc(mem, 0)` the 1375 * same way as `free(mem)`. 1376 * 1377 * If `mem` is NULL, the behavior of this function is equivalent to 1378 * SDL_malloc(). Otherwise, the function can have one of three possible 1379 * outcomes: 1380 * 1381 * - If it returns the same pointer as `mem`, it means that `mem` was resized 1382 * in place without freeing. 1383 * - If it returns a different non-NULL pointer, it means that `mem` was freed 1384 * and cannot be dereferenced anymore. 1385 * - If it returns NULL (indicating failure), then `mem` will remain valid and 1386 * must still be freed with SDL_free(). 1387 * 1388 * If the allocation is successfully resized, the returned pointer is 1389 * guaranteed to be aligned to either the *fundamental alignment* 1390 * (`alignof(max_align_t)` in C11 and later) or `2 * sizeof(void *)`, 1391 * whichever is smaller. 1392 * 1393 * \param mem a pointer to allocated memory to reallocate, or NULL. 1394 * \param size the new size of the memory. 1395 * \returns a pointer to the newly allocated memory, or NULL if allocation 1396 * failed. 1397 * 1398 * \threadsafety It is safe to call this function from any thread. 1399 * 1400 * \since This function is available since SDL 3.2.0. 1401 * 1402 * \sa SDL_free 1403 * \sa SDL_malloc 1404 * \sa SDL_calloc 1405 */ 1406extern SDL_DECLSPEC SDL_ALLOC_SIZE(2) void * SDLCALL SDL_realloc(void *mem, size_t size); 1407 1408/** 1409 * Free allocated memory. 1410 * 1411 * The pointer is no longer valid after this call and cannot be dereferenced 1412 * anymore. 1413 * 1414 * If `mem` is NULL, this function does nothing. 1415 * 1416 * \param mem a pointer to allocated memory, or NULL. 1417 * 1418 * \threadsafety It is safe to call this function from any thread. 1419 * 1420 * \since This function is available since SDL 3.2.0. 1421 * 1422 * \sa SDL_malloc 1423 * \sa SDL_calloc 1424 * \sa SDL_realloc 1425 */ 1426extern SDL_DECLSPEC void SDLCALL SDL_free(void *mem); 1427 1428/** 1429 * A callback used to implement SDL_malloc(). 1430 * 1431 * SDL will always ensure that the passed `size` is greater than 0. 1432 * 1433 * \param size the size to allocate. 1434 * \returns a pointer to the allocated memory, or NULL if allocation failed. 1435 * 1436 * \threadsafety It should be safe to call this callback from any thread. 1437 * 1438 * \since This datatype is available since SDL 3.2.0. 1439 * 1440 * \sa SDL_malloc 1441 * \sa SDL_GetOriginalMemoryFunctions 1442 * \sa SDL_GetMemoryFunctions 1443 * \sa SDL_SetMemoryFunctions 1444 */ 1445typedef void *(SDLCALL *SDL_malloc_func)(size_t size); 1446 1447/** 1448 * A callback used to implement SDL_calloc(). 1449 * 1450 * SDL will always ensure that the passed `nmemb` and `size` are both greater 1451 * than 0. 1452 * 1453 * \param nmemb the number of elements in the array. 1454 * \param size the size of each element of the array. 1455 * \returns a pointer to the allocated array, or NULL if allocation failed. 1456 * 1457 * \threadsafety It should be safe to call this callback from any thread. 1458 * 1459 * \since This datatype is available since SDL 3.2.0. 1460 * 1461 * \sa SDL_calloc 1462 * \sa SDL_GetOriginalMemoryFunctions 1463 * \sa SDL_GetMemoryFunctions 1464 * \sa SDL_SetMemoryFunctions 1465 */ 1466typedef void *(SDLCALL *SDL_calloc_func)(size_t nmemb, size_t size); 1467 1468/** 1469 * A callback used to implement SDL_realloc(). 1470 * 1471 * SDL will always ensure that the passed `size` is greater than 0. 1472 * 1473 * \param mem a pointer to allocated memory to reallocate, or NULL. 1474 * \param size the new size of the memory. 1475 * \returns a pointer to the newly allocated memory, or NULL if allocation 1476 * failed. 1477 * 1478 * \threadsafety It should be safe to call this callback from any thread. 1479 * 1480 * \since This datatype is available since SDL 3.2.0. 1481 * 1482 * \sa SDL_realloc 1483 * \sa SDL_GetOriginalMemoryFunctions 1484 * \sa SDL_GetMemoryFunctions 1485 * \sa SDL_SetMemoryFunctions 1486 */ 1487typedef void *(SDLCALL *SDL_realloc_func)(void *mem, size_t size); 1488 1489/** 1490 * A callback used to implement SDL_free(). 1491 * 1492 * SDL will always ensure that the passed `mem` is a non-NULL pointer. 1493 * 1494 * \param mem a pointer to allocated memory. 1495 * 1496 * \threadsafety It should be safe to call this callback from any thread. 1497 * 1498 * \since This datatype is available since SDL 3.2.0. 1499 * 1500 * \sa SDL_free 1501 * \sa SDL_GetOriginalMemoryFunctions 1502 * \sa SDL_GetMemoryFunctions 1503 * \sa SDL_SetMemoryFunctions 1504 */ 1505typedef void (SDLCALL *SDL_free_func)(void *mem); 1506 1507/** 1508 * Get the original set of SDL memory functions. 1509 * 1510 * This is what SDL_malloc and friends will use by default, if there has been 1511 * no call to SDL_SetMemoryFunctions. This is not necessarily using the C 1512 * runtime's `malloc` functions behind the scenes! Different platforms and 1513 * build configurations might do any number of unexpected things. 1514 * 1515 * \param malloc_func filled with malloc function. 1516 * \param calloc_func filled with calloc function. 1517 * \param realloc_func filled with realloc function. 1518 * \param free_func filled with free function. 1519 * 1520 * \threadsafety It is safe to call this function from any thread. 1521 * 1522 * \since This function is available since SDL 3.2.0. 1523 */ 1524extern SDL_DECLSPEC void SDLCALL SDL_GetOriginalMemoryFunctions(SDL_malloc_func *malloc_func, 1525 SDL_calloc_func *calloc_func, 1526 SDL_realloc_func *realloc_func, 1527 SDL_free_func *free_func); 1528 1529/** 1530 * Get the current set of SDL memory functions. 1531 * 1532 * \param malloc_func filled with malloc function. 1533 * \param calloc_func filled with calloc function. 1534 * \param realloc_func filled with realloc function. 1535 * \param free_func filled with free function. 1536 * 1537 * \threadsafety This does not hold a lock, so do not call this in the 1538 * unlikely event of a background thread calling 1539 * SDL_SetMemoryFunctions simultaneously. 1540 * 1541 * \since This function is available since SDL 3.2.0. 1542 * 1543 * \sa SDL_SetMemoryFunctions 1544 * \sa SDL_GetOriginalMemoryFunctions 1545 */ 1546extern SDL_DECLSPEC void SDLCALL SDL_GetMemoryFunctions(SDL_malloc_func *malloc_func, 1547 SDL_calloc_func *calloc_func, 1548 SDL_realloc_func *realloc_func, 1549 SDL_free_func *free_func); 1550 1551/** 1552 * Replace SDL's memory allocation functions with a custom set. 1553 * 1554 * It is not safe to call this function once any allocations have been made, 1555 * as future calls to SDL_free will use the new allocator, even if they came 1556 * from an SDL_malloc made with the old one! 1557 * 1558 * If used, usually this needs to be the first call made into the SDL library, 1559 * if not the very first thing done at program startup time. 1560 * 1561 * \param malloc_func custom malloc function. 1562 * \param calloc_func custom calloc function. 1563 * \param realloc_func custom realloc function. 1564 * \param free_func custom free function. 1565 * \returns true on success or false on failure; call SDL_GetError() for more 1566 * information. 1567 * 1568 * \threadsafety It is safe to call this function from any thread, but one 1569 * should not replace the memory functions once any allocations 1570 * are made! 1571 * 1572 * \since This function is available since SDL 3.2.0. 1573 * 1574 * \sa SDL_GetMemoryFunctions 1575 * \sa SDL_GetOriginalMemoryFunctions 1576 */ 1577extern SDL_DECLSPEC bool SDLCALL SDL_SetMemoryFunctions(SDL_malloc_func malloc_func, 1578 SDL_calloc_func calloc_func, 1579 SDL_realloc_func realloc_func, 1580 SDL_free_func free_func); 1581 1582/** 1583 * Allocate memory aligned to a specific alignment. 1584 * 1585 * The memory returned by this function must be freed with SDL_aligned_free(), 1586 * _not_ SDL_free(). 1587 * 1588 * If `alignment` is less than the size of `void *`, it will be increased to 1589 * match that. 1590 * 1591 * The returned memory address will be a multiple of the alignment value, and 1592 * the size of the memory allocated will be a multiple of the alignment value. 1593 * 1594 * \param alignment the alignment of the memory. 1595 * \param size the size to allocate. 1596 * \returns a pointer to the aligned memory, or NULL if allocation failed. 1597 * 1598 * \threadsafety It is safe to call this function from any thread. 1599 * 1600 * \since This function is available since SDL 3.2.0. 1601 * 1602 * \sa SDL_aligned_free 1603 */ 1604extern SDL_DECLSPEC SDL_MALLOC void * SDLCALL SDL_aligned_alloc(size_t alignment, size_t size); 1605 1606/** 1607 * Free memory allocated by SDL_aligned_alloc(). 1608 * 1609 * The pointer is no longer valid after this call and cannot be dereferenced 1610 * anymore. 1611 * 1612 * If `mem` is NULL, this function does nothing. 1613 * 1614 * \param mem a pointer previously returned by SDL_aligned_alloc(), or NULL. 1615 * 1616 * \threadsafety It is safe to call this function from any thread. 1617 * 1618 * \since This function is available since SDL 3.2.0. 1619 * 1620 * \sa SDL_aligned_alloc 1621 */ 1622extern SDL_DECLSPEC void SDLCALL SDL_aligned_free(void *mem); 1623 1624/** 1625 * Get the number of outstanding (unfreed) allocations. 1626 * 1627 * \returns the number of allocations or -1 if allocation counting is 1628 * disabled. 1629 * 1630 * \threadsafety It is safe to call this function from any thread. 1631 * 1632 * \since This function is available since SDL 3.2.0. 1633 */ 1634extern SDL_DECLSPEC int SDLCALL SDL_GetNumAllocations(void); 1635 1636/** 1637 * A thread-safe set of environment variables 1638 * 1639 * \since This struct is available since SDL 3.2.0. 1640 * 1641 * \sa SDL_GetEnvironment 1642 * \sa SDL_CreateEnvironment 1643 * \sa SDL_GetEnvironmentVariable 1644 * \sa SDL_GetEnvironmentVariables 1645 * \sa SDL_SetEnvironmentVariable 1646 * \sa SDL_UnsetEnvironmentVariable 1647 * \sa SDL_DestroyEnvironment 1648 */ 1649typedef struct SDL_Environment SDL_Environment; 1650 1651/** 1652 * Get the process environment. 1653 * 1654 * This is initialized at application start and is not affected by setenv() 1655 * and unsetenv() calls after that point. Use SDL_SetEnvironmentVariable() and 1656 * SDL_UnsetEnvironmentVariable() if you want to modify this environment, or 1657 * SDL_setenv_unsafe() or SDL_unsetenv_unsafe() if you want changes to persist 1658 * in the C runtime environment after SDL_Quit(). 1659 * 1660 * \returns a pointer to the environment for the process or NULL on failure; 1661 * call SDL_GetError() for more information. 1662 * 1663 * \threadsafety It is safe to call this function from any thread. 1664 * 1665 * \since This function is available since SDL 3.2.0. 1666 * 1667 * \sa SDL_GetEnvironmentVariable 1668 * \sa SDL_GetEnvironmentVariables 1669 * \sa SDL_SetEnvironmentVariable 1670 * \sa SDL_UnsetEnvironmentVariable 1671 */ 1672extern SDL_DECLSPEC SDL_Environment * SDLCALL SDL_GetEnvironment(void); 1673 1674/** 1675 * Create a set of environment variables 1676 * 1677 * \param populated true to initialize it from the C runtime environment, 1678 * false to create an empty environment. 1679 * \returns a pointer to the new environment or NULL on failure; call 1680 * SDL_GetError() for more information. 1681 * 1682 * \threadsafety If `populated` is false, it is safe to call this function 1683 * from any thread, otherwise it is safe if no other threads are 1684 * calling setenv() or unsetenv() 1685 * 1686 * \since This function is available since SDL 3.2.0. 1687 * 1688 * \sa SDL_GetEnvironmentVariable 1689 * \sa SDL_GetEnvironmentVariables 1690 * \sa SDL_SetEnvironmentVariable 1691 * \sa SDL_UnsetEnvironmentVariable 1692 * \sa SDL_DestroyEnvironment 1693 */ 1694extern SDL_DECLSPEC SDL_Environment * SDLCALL SDL_CreateEnvironment(bool populated); 1695 1696/** 1697 * Get the value of a variable in the environment. 1698 * 1699 * \param env the environment to query. 1700 * \param name the name of the variable to get. 1701 * \returns a pointer to the value of the variable or NULL if it can't be 1702 * found. 1703 * 1704 * \threadsafety It is safe to call this function from any thread. 1705 * 1706 * \since This function is available since SDL 3.2.0. 1707 * 1708 * \sa SDL_GetEnvironment 1709 * \sa SDL_CreateEnvironment 1710 * \sa SDL_GetEnvironmentVariables 1711 * \sa SDL_SetEnvironmentVariable 1712 * \sa SDL_UnsetEnvironmentVariable 1713 */ 1714extern SDL_DECLSPEC const char * SDLCALL SDL_GetEnvironmentVariable(SDL_Environment *env, const char *name); 1715 1716/** 1717 * Get all variables in the environment. 1718 * 1719 * \param env the environment to query. 1720 * \returns a NULL terminated array of pointers to environment variables in 1721 * the form "variable=value" or NULL on failure; call SDL_GetError() 1722 * for more information. This is a single allocation that should be 1723 * freed with SDL_free() when it is no longer needed. 1724 * 1725 * \threadsafety It is safe to call this function from any thread. 1726 * 1727 * \since This function is available since SDL 3.2.0. 1728 * 1729 * \sa SDL_GetEnvironment 1730 * \sa SDL_CreateEnvironment 1731 * \sa SDL_GetEnvironmentVariable 1732 * \sa SDL_SetEnvironmentVariable 1733 * \sa SDL_UnsetEnvironmentVariable 1734 */ 1735extern SDL_DECLSPEC char ** SDLCALL SDL_GetEnvironmentVariables(SDL_Environment *env); 1736 1737/** 1738 * Set the value of a variable in the environment. 1739 * 1740 * \param env the environment to modify. 1741 * \param name the name of the variable to set. 1742 * \param value the value of the variable to set. 1743 * \param overwrite true to overwrite the variable if it exists, false to 1744 * return success without setting the variable if it already 1745 * exists. 1746 * \returns true on success or false on failure; call SDL_GetError() for more 1747 * information. 1748 * 1749 * \threadsafety It is safe to call this function from any thread. 1750 * 1751 * \since This function is available since SDL 3.2.0. 1752 * 1753 * \sa SDL_GetEnvironment 1754 * \sa SDL_CreateEnvironment 1755 * \sa SDL_GetEnvironmentVariable 1756 * \sa SDL_GetEnvironmentVariables 1757 * \sa SDL_UnsetEnvironmentVariable 1758 */ 1759extern SDL_DECLSPEC bool SDLCALL SDL_SetEnvironmentVariable(SDL_Environment *env, const char *name, const char *value, bool overwrite); 1760 1761/** 1762 * Clear a variable from the environment. 1763 * 1764 * \param env the environment to modify. 1765 * \param name the name of the variable to unset. 1766 * \returns true on success or false on failure; call SDL_GetError() for more 1767 * information. 1768 * 1769 * \threadsafety It is safe to call this function from any thread. 1770 * 1771 * \since This function is available since SDL 3.2.0. 1772 * 1773 * \sa SDL_GetEnvironment 1774 * \sa SDL_CreateEnvironment 1775 * \sa SDL_GetEnvironmentVariable 1776 * \sa SDL_GetEnvironmentVariables 1777 * \sa SDL_SetEnvironmentVariable 1778 * \sa SDL_UnsetEnvironmentVariable 1779 */ 1780extern SDL_DECLSPEC bool SDLCALL SDL_UnsetEnvironmentVariable(SDL_Environment *env, const char *name); 1781 1782/** 1783 * Destroy a set of environment variables. 1784 * 1785 * \param env the environment to destroy. 1786 * 1787 * \threadsafety It is safe to call this function from any thread, as long as 1788 * the environment is no longer in use. 1789 * 1790 * \since This function is available since SDL 3.2.0. 1791 * 1792 * \sa SDL_CreateEnvironment 1793 */ 1794extern SDL_DECLSPEC void SDLCALL SDL_DestroyEnvironment(SDL_Environment *env); 1795 1796/** 1797 * Get the value of a variable in the environment. 1798 * 1799 * The name of the variable is case sensitive on all platforms. 1800 * 1801 * This function uses SDL's cached copy of the environment and is thread-safe. 1802 * 1803 * \param name the name of the variable to get. 1804 * \returns a pointer to the value of the variable or NULL if it can't be 1805 * found. 1806 * 1807 * \threadsafety It is safe to call this function from any thread. 1808 * 1809 * \since This function is available since SDL 3.2.0. 1810 */ 1811extern SDL_DECLSPEC const char * SDLCALL SDL_getenv(const char *name); 1812 1813/** 1814 * Get the value of a variable in the environment. 1815 * 1816 * This function bypasses SDL's cached copy of the environment and is not 1817 * thread-safe. 1818 * 1819 * On some platforms, this may make case-insensitive matches, while other 1820 * platforms are case-sensitive. It is best to be precise with strings used 1821 * for queries through this interface. SDL_getenv is always case-sensitive, 1822 * however. 1823 * 1824 * \param name the name of the variable to get. 1825 * \returns a pointer to the value of the variable or NULL if it can't be 1826 * found. 1827 * 1828 * \threadsafety This function is not thread safe, consider using SDL_getenv() 1829 * instead. 1830 * 1831 * \since This function is available since SDL 3.2.0. 1832 * 1833 * \sa SDL_getenv 1834 */ 1835extern SDL_DECLSPEC const char * SDLCALL SDL_getenv_unsafe(const char *name); 1836 1837/** 1838 * Set the value of a variable in the environment. 1839 * 1840 * \param name the name of the variable to set. 1841 * \param value the value of the variable to set. 1842 * \param overwrite 1 to overwrite the variable if it exists, 0 to return 1843 * success without setting the variable if it already exists. 1844 * \returns 0 on success, -1 on error. 1845 * 1846 * \threadsafety This function is not thread safe, consider using 1847 * SDL_SetEnvironmentVariable() instead. 1848 * 1849 * \since This function is available since SDL 3.2.0. 1850 * 1851 * \sa SDL_SetEnvironmentVariable 1852 */ 1853extern SDL_DECLSPEC int SDLCALL SDL_setenv_unsafe(const char *name, const char *value, int overwrite); 1854 1855/** 1856 * Clear a variable from the environment. 1857 * 1858 * \param name the name of the variable to unset. 1859 * \returns 0 on success, -1 on error. 1860 * 1861 * \threadsafety This function is not thread safe, consider using 1862 * SDL_UnsetEnvironmentVariable() instead. 1863 * 1864 * \since This function is available since SDL 3.2.0. 1865 * 1866 * \sa SDL_UnsetEnvironmentVariable 1867 */ 1868extern SDL_DECLSPEC int SDLCALL SDL_unsetenv_unsafe(const char *name); 1869 1870/** 1871 * A callback used with SDL sorting and binary search functions. 1872 * 1873 * \param a a pointer to the first element being compared. 1874 * \param b a pointer to the second element being compared. 1875 * \returns -1 if `a` should be sorted before `b`, 1 if `b` should be sorted 1876 * before `a`, 0 if they are equal. If two elements are equal, their 1877 * order in the sorted array is undefined. 1878 * 1879 * \since This callback is available since SDL 3.2.0. 1880 * 1881 * \sa SDL_bsearch 1882 * \sa SDL_qsort 1883 */ 1884typedef int (SDLCALL *SDL_CompareCallback)(const void *a, const void *b); 1885 1886/** 1887 * Sort an array. 1888 * 1889 * For example: 1890 * 1891 * ```c 1892 * typedef struct { 1893 * int key; 1894 * const char *string; 1895 * } data; 1896 * 1897 * int SDLCALL compare(const void *a, const void *b) 1898 * { 1899 * const data *A = (const data *)a; 1900 * const data *B = (const data *)b; 1901 * 1902 * if (A->n < B->n) { 1903 * return -1; 1904 * } else if (B->n < A->n) { 1905 * return 1; 1906 * } else { 1907 * return 0; 1908 * } 1909 * } 1910 * 1911 * data values[] = { 1912 * { 3, "third" }, { 1, "first" }, { 2, "second" } 1913 * }; 1914 * 1915 * SDL_qsort(values, SDL_arraysize(values), sizeof(values[0]), compare); 1916 * ``` 1917 * 1918 * \param base a pointer to the start of the array. 1919 * \param nmemb the number of elements in the array. 1920 * \param size the size of the elements in the array. 1921 * \param compare a function used to compare elements in the array. 1922 * 1923 * \threadsafety It is safe to call this function from any thread. 1924 * 1925 * \since This function is available since SDL 3.2.0. 1926 * 1927 * \sa SDL_bsearch 1928 * \sa SDL_qsort_r 1929 */ 1930extern SDL_DECLSPEC void SDLCALL SDL_qsort(void *base, size_t nmemb, size_t size, SDL_CompareCallback compare); 1931 1932/** 1933 * Perform a binary search on a previously sorted array. 1934 * 1935 * For example: 1936 * 1937 * ```c 1938 * typedef struct { 1939 * int key; 1940 * const char *string; 1941 * } data; 1942 * 1943 * int SDLCALL compare(const void *a, const void *b) 1944 * { 1945 * const data *A = (const data *)a; 1946 * const data *B = (const data *)b; 1947 * 1948 * if (A->n < B->n) { 1949 * return -1; 1950 * } else if (B->n < A->n) { 1951 * return 1; 1952 * } else { 1953 * return 0; 1954 * } 1955 * } 1956 * 1957 * data values[] = { 1958 * { 1, "first" }, { 2, "second" }, { 3, "third" } 1959 * }; 1960 * data key = { 2, NULL }; 1961 * 1962 * data *result = SDL_bsearch(&key, values, SDL_arraysize(values), sizeof(values[0]), compare); 1963 * ``` 1964 * 1965 * \param key a pointer to a key equal to the element being searched for. 1966 * \param base a pointer to the start of the array. 1967 * \param nmemb the number of elements in the array. 1968 * \param size the size of the elements in the array. 1969 * \param compare a function used to compare elements in the array. 1970 * \returns a pointer to the matching element in the array, or NULL if not 1971 * found. 1972 * 1973 * \threadsafety It is safe to call this function from any thread. 1974 * 1975 * \since This function is available since SDL 3.2.0. 1976 * 1977 * \sa SDL_bsearch_r 1978 * \sa SDL_qsort 1979 */ 1980extern SDL_DECLSPEC void * SDLCALL SDL_bsearch(const void *key, const void *base, size_t nmemb, size_t size, SDL_CompareCallback compare); 1981 1982/** 1983 * A callback used with SDL sorting and binary search functions. 1984 * 1985 * \param userdata the `userdata` pointer passed to the sort function. 1986 * \param a a pointer to the first element being compared. 1987 * \param b a pointer to the second element being compared. 1988 * \returns -1 if `a` should be sorted before `b`, 1 if `b` should be sorted 1989 * before `a`, 0 if they are equal. If two elements are equal, their 1990 * order in the sorted array is undefined. 1991 * 1992 * \since This callback is available since SDL 3.2.0. 1993 * 1994 * \sa SDL_qsort_r 1995 * \sa SDL_bsearch_r 1996 */ 1997typedef int (SDLCALL *SDL_CompareCallback_r)(void *userdata, const void *a, const void *b); 1998 1999/** 2000 * Sort an array, passing a userdata pointer to the compare function. 2001 * 2002 * For example: 2003 * 2004 * ```c 2005 * typedef enum { 2006 * sort_increasing, 2007 * sort_decreasing, 2008 * } sort_method; 2009 * 2010 * typedef struct { 2011 * int key; 2012 * const char *string; 2013 * } data; 2014 * 2015 * int SDLCALL compare(const void *userdata, const void *a, const void *b) 2016 * { 2017 * sort_method method = (sort_method)(uintptr_t)userdata; 2018 * const data *A = (const data *)a; 2019 * const data *B = (const data *)b; 2020 * 2021 * if (A->key < B->key) { 2022 * return (method == sort_increasing) ? -1 : 1; 2023 * } else if (B->key < A->key) { 2024 * return (method == sort_increasing) ? 1 : -1; 2025 * } else { 2026 * return 0; 2027 * } 2028 * } 2029 * 2030 * data values[] = { 2031 * { 3, "third" }, { 1, "first" }, { 2, "second" } 2032 * }; 2033 * 2034 * SDL_qsort_r(values, SDL_arraysize(values), sizeof(values[0]), compare, (const void *)(uintptr_t)sort_increasing); 2035 * ``` 2036 * 2037 * \param base a pointer to the start of the array. 2038 * \param nmemb the number of elements in the array. 2039 * \param size the size of the elements in the array. 2040 * \param compare a function used to compare elements in the array. 2041 * \param userdata a pointer to pass to the compare function. 2042 * 2043 * \threadsafety It is safe to call this function from any thread. 2044 * 2045 * \since This function is available since SDL 3.2.0. 2046 * 2047 * \sa SDL_bsearch_r 2048 * \sa SDL_qsort 2049 */ 2050extern SDL_DECLSPEC void SDLCALL SDL_qsort_r(void *base, size_t nmemb, size_t size, SDL_CompareCallback_r compare, void *userdata); 2051 2052/** 2053 * Perform a binary search on a previously sorted array, passing a userdata 2054 * pointer to the compare function. 2055 * 2056 * For example: 2057 * 2058 * ```c 2059 * typedef enum { 2060 * sort_increasing, 2061 * sort_decreasing, 2062 * } sort_method; 2063 * 2064 * typedef struct { 2065 * int key; 2066 * const char *string; 2067 * } data; 2068 * 2069 * int SDLCALL compare(const void *userdata, const void *a, const void *b) 2070 * { 2071 * sort_method method = (sort_method)(uintptr_t)userdata; 2072 * const data *A = (const data *)a; 2073 * const data *B = (const data *)b; 2074 * 2075 * if (A->key < B->key) { 2076 * return (method == sort_increasing) ? -1 : 1; 2077 * } else if (B->key < A->key) { 2078 * return (method == sort_increasing) ? 1 : -1; 2079 * } else { 2080 * return 0; 2081 * } 2082 * } 2083 * 2084 * data values[] = { 2085 * { 1, "first" }, { 2, "second" }, { 3, "third" } 2086 * }; 2087 * data key = { 2, NULL }; 2088 * 2089 * data *result = SDL_bsearch_r(&key, values, SDL_arraysize(values), sizeof(values[0]), compare, (const void *)(uintptr_t)sort_increasing); 2090 * ``` 2091 * 2092 * \param key a pointer to a key equal to the element being searched for. 2093 * \param base a pointer to the start of the array. 2094 * \param nmemb the number of elements in the array. 2095 * \param size the size of the elements in the array. 2096 * \param compare a function used to compare elements in the array. 2097 * \param userdata a pointer to pass to the compare function. 2098 * \returns a pointer to the matching element in the array, or NULL if not 2099 * found. 2100 * 2101 * \threadsafety It is safe to call this function from any thread. 2102 * 2103 * \since This function is available since SDL 3.2.0. 2104 * 2105 * \sa SDL_bsearch 2106 * \sa SDL_qsort_r 2107 */ 2108extern SDL_DECLSPEC void * SDLCALL SDL_bsearch_r(const void *key, const void *base, size_t nmemb, size_t size, SDL_CompareCallback_r compare, void *userdata); 2109 2110/** 2111 * Compute the absolute value of `x`. 2112 * 2113 * \param x an integer value. 2114 * \returns the absolute value of x. 2115 * 2116 * \threadsafety It is safe to call this function from any thread. 2117 * 2118 * \since This function is available since SDL 3.2.0. 2119 */ 2120extern SDL_DECLSPEC int SDLCALL SDL_abs(int x); 2121 2122/** 2123 * Return the lesser of two values. 2124 * 2125 * This is a helper macro that might be more clear than writing out the 2126 * comparisons directly, and works with any type that can be compared with the 2127 * `<` operator. However, it double-evaluates both its parameters, so do not 2128 * use expressions with side-effects here. 2129 * 2130 * \param x the first value to compare. 2131 * \param y the second value to compare. 2132 * \returns the lesser of `x` and `y`. 2133 * 2134 * \threadsafety It is safe to call this macro from any thread. 2135 * 2136 * \since This macro is available since SDL 3.2.0. 2137 */ 2138#define SDL_min(x, y) (((x) < (y)) ? (x) : (y)) 2139 2140/** 2141 * Return the greater of two values. 2142 * 2143 * This is a helper macro that might be more clear than writing out the 2144 * comparisons directly, and works with any type that can be compared with the 2145 * `>` operator. However, it double-evaluates both its parameters, so do not 2146 * use expressions with side-effects here. 2147 * 2148 * \param x the first value to compare. 2149 * \param y the second value to compare. 2150 * \returns the greater of `x` and `y`. 2151 * 2152 * \threadsafety It is safe to call this macro from any thread. 2153 * 2154 * \since This macro is available since SDL 3.2.0. 2155 */ 2156#define SDL_max(x, y) (((x) > (y)) ? (x) : (y)) 2157 2158/** 2159 * Return a value clamped to a range. 2160 * 2161 * If `x` is outside the range a values between `a` and `b`, the returned 2162 * value will be `a` or `b` as appropriate. Otherwise, `x` is returned. 2163 * 2164 * This macro will produce incorrect results if `b` is less than `a`. 2165 * 2166 * This is a helper macro that might be more clear than writing out the 2167 * comparisons directly, and works with any type that can be compared with the 2168 * `<` and `>` operators. However, it double-evaluates all its parameters, so 2169 * do not use expressions with side-effects here. 2170 * 2171 * \param x the value to compare. 2172 * \param a the low end value. 2173 * \param b the high end value. 2174 * \returns x, clamped between a and b. 2175 * 2176 * \threadsafety It is safe to call this macro from any thread. 2177 * 2178 * \since This macro is available since SDL 3.2.0. 2179 */ 2180#define SDL_clamp(x, a, b) (((x) < (a)) ? (a) : (((x) > (b)) ? (b) : (x))) 2181 2182/** 2183 * Query if a character is alphabetic (a letter). 2184 * 2185 * **WARNING**: Regardless of system locale, this will only treat ASCII values 2186 * for English 'a-z' and 'A-Z' as true. 2187 * 2188 * \param x character value to check. 2189 * \returns non-zero if x falls within the character class, zero otherwise. 2190 * 2191 * \threadsafety It is safe to call this function from any thread. 2192 * 2193 * \since This function is available since SDL 3.2.0. 2194 */ 2195extern SDL_DECLSPEC int SDLCALL SDL_isalpha(int x); 2196 2197/** 2198 * Query if a character is alphabetic (a letter) or a number. 2199 * 2200 * **WARNING**: Regardless of system locale, this will only treat ASCII values 2201 * for English 'a-z', 'A-Z', and '0-9' as true. 2202 * 2203 * \param x character value to check. 2204 * \returns non-zero if x falls within the character class, zero otherwise. 2205 * 2206 * \threadsafety It is safe to call this function from any thread. 2207 * 2208 * \since This function is available since SDL 3.2.0. 2209 */ 2210extern SDL_DECLSPEC int SDLCALL SDL_isalnum(int x); 2211 2212/** 2213 * Report if a character is blank (a space or tab). 2214 * 2215 * **WARNING**: Regardless of system locale, this will only treat ASCII values 2216 * 0x20 (space) or 0x9 (tab) as true. 2217 * 2218 * \param x character value to check. 2219 * \returns non-zero if x falls within the character class, zero otherwise. 2220 * 2221 * \threadsafety It is safe to call this function from any thread. 2222 * 2223 * \since This function is available since SDL 3.2.0. 2224 */ 2225extern SDL_DECLSPEC int SDLCALL SDL_isblank(int x); 2226 2227/** 2228 * Report if a character is a control character. 2229 * 2230 * **WARNING**: Regardless of system locale, this will only treat ASCII values 2231 * 0 through 0x1F, and 0x7F, as true. 2232 * 2233 * \param x character value to check. 2234 * \returns non-zero if x falls within the character class, zero otherwise. 2235 * 2236 * \threadsafety It is safe to call this function from any thread. 2237 * 2238 * \since This function is available since SDL 3.2.0. 2239 */ 2240extern SDL_DECLSPEC int SDLCALL SDL_iscntrl(int x); 2241 2242/** 2243 * Report if a character is a numeric digit. 2244 * 2245 * **WARNING**: Regardless of system locale, this will only treat ASCII values 2246 * '0' (0x30) through '9' (0x39), as true. 2247 * 2248 * \param x character value to check. 2249 * \returns non-zero if x falls within the character class, zero otherwise. 2250 * 2251 * \threadsafety It is safe to call this function from any thread. 2252 * 2253 * \since This function is available since SDL 3.2.0. 2254 */ 2255extern SDL_DECLSPEC int SDLCALL SDL_isdigit(int x); 2256 2257/** 2258 * Report if a character is a hexadecimal digit. 2259 * 2260 * **WARNING**: Regardless of system locale, this will only treat ASCII values 2261 * 'A' through 'F', 'a' through 'f', and '0' through '9', as true. 2262 * 2263 * \param x character value to check. 2264 * \returns non-zero if x falls within the character class, zero otherwise. 2265 * 2266 * \threadsafety It is safe to call this function from any thread. 2267 * 2268 * \since This function is available since SDL 3.2.0. 2269 */ 2270extern SDL_DECLSPEC int SDLCALL SDL_isxdigit(int x); 2271 2272/** 2273 * Report if a character is a punctuation mark. 2274 * 2275 * **WARNING**: Regardless of system locale, this is equivalent to 2276 * `((SDL_isgraph(x)) && (!SDL_isalnum(x)))`. 2277 * 2278 * \param x character value to check. 2279 * \returns non-zero if x falls within the character class, zero otherwise. 2280 * 2281 * \threadsafety It is safe to call this function from any thread. 2282 * 2283 * \since This function is available since SDL 3.2.0. 2284 * 2285 * \sa SDL_isgraph 2286 * \sa SDL_isalnum 2287 */ 2288extern SDL_DECLSPEC int SDLCALL SDL_ispunct(int x); 2289 2290/** 2291 * Report if a character is whitespace. 2292 * 2293 * **WARNING**: Regardless of system locale, this will only treat the 2294 * following ASCII values as true: 2295 * 2296 * - space (0x20) 2297 * - tab (0x09) 2298 * - newline (0x0A) 2299 * - vertical tab (0x0B) 2300 * - form feed (0x0C) 2301 * - return (0x0D) 2302 * 2303 * \param x character value to check. 2304 * \returns non-zero if x falls within the character class, zero otherwise. 2305 * 2306 * \threadsafety It is safe to call this function from any thread. 2307 * 2308 * \since This function is available since SDL 3.2.0. 2309 */ 2310extern SDL_DECLSPEC int SDLCALL SDL_isspace(int x); 2311 2312/** 2313 * Report if a character is upper case. 2314 * 2315 * **WARNING**: Regardless of system locale, this will only treat ASCII values 2316 * 'A' through 'Z' as true. 2317 * 2318 * \param x character value to check. 2319 * \returns non-zero if x falls within the character class, zero otherwise. 2320 * 2321 * \threadsafety It is safe to call this function from any thread. 2322 * 2323 * \since This function is available since SDL 3.2.0. 2324 */ 2325extern SDL_DECLSPEC int SDLCALL SDL_isupper(int x); 2326 2327/** 2328 * Report if a character is lower case. 2329 * 2330 * **WARNING**: Regardless of system locale, this will only treat ASCII values 2331 * 'a' through 'z' as true. 2332 * 2333 * \param x character value to check. 2334 * \returns non-zero if x falls within the character class, zero otherwise. 2335 * 2336 * \threadsafety It is safe to call this function from any thread. 2337 * 2338 * \since This function is available since SDL 3.2.0. 2339 */ 2340extern SDL_DECLSPEC int SDLCALL SDL_islower(int x); 2341 2342/** 2343 * Report if a character is "printable". 2344 * 2345 * Be advised that "printable" has a definition that goes back to text 2346 * terminals from the dawn of computing, making this a sort of special case 2347 * function that is not suitable for Unicode (or most any) text management. 2348 * 2349 * **WARNING**: Regardless of system locale, this will only treat ASCII values 2350 * ' ' (0x20) through '~' (0x7E) as true. 2351 * 2352 * \param x character value to check. 2353 * \returns non-zero if x falls within the character class, zero otherwise. 2354 * 2355 * \threadsafety It is safe to call this function from any thread. 2356 * 2357 * \since This function is available since SDL 3.2.0. 2358 */ 2359extern SDL_DECLSPEC int SDLCALL SDL_isprint(int x); 2360 2361/** 2362 * Report if a character is any "printable" except space. 2363 * 2364 * Be advised that "printable" has a definition that goes back to text 2365 * terminals from the dawn of computing, making this a sort of special case 2366 * function that is not suitable for Unicode (or most any) text management. 2367 * 2368 * **WARNING**: Regardless of system locale, this is equivalent to 2369 * `(SDL_isprint(x)) && ((x) != ' ')`. 2370 * 2371 * \param x character value to check. 2372 * \returns non-zero if x falls within the character class, zero otherwise. 2373 * 2374 * \threadsafety It is safe to call this function from any thread. 2375 * 2376 * \since This function is available since SDL 3.2.0. 2377 * 2378 * \sa SDL_isprint 2379 */ 2380extern SDL_DECLSPEC int SDLCALL SDL_isgraph(int x); 2381 2382/** 2383 * Convert low-ASCII English letters to uppercase. 2384 * 2385 * **WARNING**: Regardless of system locale, this will only convert ASCII 2386 * values 'a' through 'z' to uppercase. 2387 * 2388 * This function returns the uppercase equivalent of `x`. If a character 2389 * cannot be converted, or is already uppercase, this function returns `x`. 2390 * 2391 * \param x character value to check. 2392 * \returns capitalized version of x, or x if no conversion available. 2393 * 2394 * \threadsafety It is safe to call this function from any thread. 2395 * 2396 * \since This function is available since SDL 3.2.0. 2397 */ 2398extern SDL_DECLSPEC int SDLCALL SDL_toupper(int x); 2399 2400/** 2401 * Convert low-ASCII English letters to lowercase. 2402 * 2403 * **WARNING**: Regardless of system locale, this will only convert ASCII 2404 * values 'A' through 'Z' to lowercase. 2405 * 2406 * This function returns the lowercase equivalent of `x`. If a character 2407 * cannot be converted, or is already lowercase, this function returns `x`. 2408 * 2409 * \param x character value to check. 2410 * \returns lowercase version of x, or x if no conversion available. 2411 * 2412 * \threadsafety It is safe to call this function from any thread. 2413 * 2414 * \since This function is available since SDL 3.2.0. 2415 */ 2416extern SDL_DECLSPEC int SDLCALL SDL_tolower(int x); 2417 2418/** 2419 * Calculate a CRC-16 value. 2420 * 2421 * https://en.wikipedia.org/wiki/Cyclic_redundancy_check 2422 * 2423 * This function can be called multiple times, to stream data to be 2424 * checksummed in blocks. Each call must provide the previous CRC-16 return 2425 * value to be updated with the next block. The first call to this function 2426 * for a set of blocks should pass in a zero CRC value. 2427 * 2428 * \param crc the current checksum for this data set, or 0 for a new data set. 2429 * \param data a new block of data to add to the checksum. 2430 * \param len the size, in bytes, of the new block of data. 2431 * \returns a CRC-16 checksum value of all blocks in the data set. 2432 * 2433 * \threadsafety It is safe to call this function from any thread. 2434 * 2435 * \since This function is available since SDL 3.2.0. 2436 */ 2437extern SDL_DECLSPEC Uint16 SDLCALL SDL_crc16(Uint16 crc, const void *data, size_t len); 2438 2439/** 2440 * Calculate a CRC-32 value. 2441 * 2442 * https://en.wikipedia.org/wiki/Cyclic_redundancy_check 2443 * 2444 * This function can be called multiple times, to stream data to be 2445 * checksummed in blocks. Each call must provide the previous CRC-32 return 2446 * value to be updated with the next block. The first call to this function 2447 * for a set of blocks should pass in a zero CRC value. 2448 * 2449 * \param crc the current checksum for this data set, or 0 for a new data set. 2450 * \param data a new block of data to add to the checksum. 2451 * \param len the size, in bytes, of the new block of data. 2452 * \returns a CRC-32 checksum value of all blocks in the data set. 2453 * 2454 * \threadsafety It is safe to call this function from any thread. 2455 * 2456 * \since This function is available since SDL 3.2.0. 2457 */ 2458extern SDL_DECLSPEC Uint32 SDLCALL SDL_crc32(Uint32 crc, const void *data, size_t len); 2459 2460/** 2461 * Calculate a 32-bit MurmurHash3 value for a block of data. 2462 * 2463 * https://en.wikipedia.org/wiki/MurmurHash 2464 * 2465 * A seed may be specified, which changes the final results consistently, but 2466 * this does not work like SDL_crc16 and SDL_crc32: you can't feed a previous 2467 * result from this function back into itself as the next seed value to 2468 * calculate a hash in chunks; it won't produce the same hash as it would if 2469 * the same data was provided in a single call. 2470 * 2471 * If you aren't sure what to provide for a seed, zero is fine. Murmur3 is not 2472 * cryptographically secure, so it shouldn't be used for hashing top-secret 2473 * data. 2474 * 2475 * \param data the data to be hashed. 2476 * \param len the size of data, in bytes. 2477 * \param seed a value that alters the final hash value. 2478 * \returns a Murmur3 32-bit hash value. 2479 * 2480 * \threadsafety It is safe to call this function from any thread. 2481 * 2482 * \since This function is available since SDL 3.2.0. 2483 */ 2484extern SDL_DECLSPEC Uint32 SDLCALL SDL_murmur3_32(const void *data, size_t len, Uint32 seed); 2485 2486/** 2487 * Copy non-overlapping memory. 2488 * 2489 * The memory regions must not overlap. If they do, use SDL_memmove() instead. 2490 * 2491 * \param dst The destination memory region. Must not be NULL, and must not 2492 * overlap with `src`. 2493 * \param src The source memory region. Must not be NULL, and must not overlap 2494 * with `dst`. 2495 * \param len The length in bytes of both `dst` and `src`. 2496 * \returns `dst`. 2497 * 2498 * \threadsafety It is safe to call this function from any thread. 2499 * 2500 * \since This function is available since SDL 3.2.0. 2501 * 2502 * \sa SDL_memmove 2503 */ 2504extern SDL_DECLSPEC void * SDLCALL SDL_memcpy(SDL_OUT_BYTECAP(len) void *dst, SDL_IN_BYTECAP(len) const void *src, size_t len); 2505 2506/* Take advantage of compiler optimizations for memcpy */ 2507#ifndef SDL_SLOW_MEMCPY 2508#ifdef SDL_memcpy 2509#undef SDL_memcpy 2510#endif 2511#define SDL_memcpy memcpy 2512#endif 2513 2514 2515/** 2516 * A macro to copy memory between objects, with basic type checking. 2517 * 2518 * SDL_memcpy and SDL_memmove do not care where you copy memory to and from, 2519 * which can lead to bugs. This macro aims to avoid most of those bugs by 2520 * making sure that the source and destination are both pointers to objects 2521 * that are the same size. It does not check that the objects are the same 2522 * _type_, just that the copy will not overflow either object. 2523 * 2524 * The size check happens at compile time, and the compiler will throw an 2525 * error if the objects are different sizes. 2526 * 2527 * Generally this is intended to copy a single object, not an array. 2528 * 2529 * This macro looks like it double-evaluates its parameters, but the extras 2530 * them are in `sizeof` sections, which generate no code nor side-effects. 2531 * 2532 * \param dst a pointer to the destination object. Must not be NULL. 2533 * \param src a pointer to the source object. Must not be NULL. 2534 * 2535 * \threadsafety It is safe to call this function from any thread. 2536 * 2537 * \since This function is available since SDL 3.2.0. 2538 */ 2539#define SDL_copyp(dst, src) \ 2540 { SDL_COMPILE_TIME_ASSERT(SDL_copyp, sizeof (*(dst)) == sizeof (*(src))); } \ 2541 SDL_memcpy((dst), (src), sizeof(*(src))) 2542 2543/** 2544 * Copy memory ranges that might overlap. 2545 * 2546 * It is okay for the memory regions to overlap. If you are confident that the 2547 * regions never overlap, using SDL_memcpy() may improve performance. 2548 * 2549 * \param dst The destination memory region. Must not be NULL. 2550 * \param src The source memory region. Must not be NULL. 2551 * \param len The length in bytes of both `dst` and `src`. 2552 * \returns `dst`. 2553 * 2554 * \threadsafety It is safe to call this function from any thread. 2555 * 2556 * \since This function is available since SDL 3.2.0. 2557 * 2558 * \sa SDL_memcpy 2559 */ 2560extern SDL_DECLSPEC void * SDLCALL SDL_memmove(SDL_OUT_BYTECAP(len) void *dst, SDL_IN_BYTECAP(len) const void *src, size_t len); 2561 2562/* Take advantage of compiler optimizations for memmove */ 2563#ifndef SDL_SLOW_MEMMOVE 2564#ifdef SDL_memmove 2565#undef SDL_memmove 2566#endif 2567#define SDL_memmove memmove 2568#endif 2569 2570/** 2571 * Initialize all bytes of buffer of memory to a specific value. 2572 * 2573 * This function will set `len` bytes, pointed to by `dst`, to the value 2574 * specified in `c`. 2575 * 2576 * Despite `c` being an `int` instead of a `char`, this only operates on 2577 * bytes; `c` must be a value between 0 and 255, inclusive. 2578 * 2579 * \param dst the destination memory region. Must not be NULL. 2580 * \param c the byte value to set. 2581 * \param len the length, in bytes, to set in `dst`. 2582 * \returns `dst`. 2583 * 2584 * \threadsafety It is safe to call this function from any thread. 2585 * 2586 * \since This function is available since SDL 3.2.0. 2587 */ 2588extern SDL_DECLSPEC void * SDLCALL SDL_memset(SDL_OUT_BYTECAP(len) void *dst, int c, size_t len); 2589 2590/** 2591 * Initialize all 32-bit words of buffer of memory to a specific value. 2592 * 2593 * This function will set a buffer of `dwords` Uint32 values, pointed to by 2594 * `dst`, to the value specified in `val`. 2595 * 2596 * Unlike SDL_memset, this sets 32-bit values, not bytes, so it's not limited 2597 * to a range of 0-255. 2598 * 2599 * \param dst the destination memory region. Must not be NULL. 2600 * \param val the Uint32 value to set. 2601 * \param dwords the number of Uint32 values to set in `dst`. 2602 * \returns `dst`. 2603 * 2604 * \threadsafety It is safe to call this function from any thread. 2605 * 2606 * \since This function is available since SDL 3.2.0. 2607 */ 2608extern SDL_DECLSPEC void * SDLCALL SDL_memset4(void *dst, Uint32 val, size_t dwords); 2609 2610/* Take advantage of compiler optimizations for memset */ 2611#ifndef SDL_SLOW_MEMSET 2612#ifdef SDL_memset 2613#undef SDL_memset 2614#endif 2615#define SDL_memset memset 2616#endif 2617 2618/** 2619 * Clear an object's memory to zero. 2620 * 2621 * This is wrapper over SDL_memset that handles calculating the object size, 2622 * so there's no chance of copy/paste errors, and the code is cleaner. 2623 * 2624 * This requires an object, not a pointer to an object, nor an array. 2625 * 2626 * \param x the object to clear. 2627 * 2628 * \threadsafety It is safe to call this macro from any thread. 2629 * 2630 * \since This macro is available since SDL 3.2.0. 2631 * 2632 * \sa SDL_zerop 2633 * \sa SDL_zeroa 2634 */ 2635#define SDL_zero(x) SDL_memset(&(x), 0, sizeof((x))) 2636 2637/** 2638 * Clear an object's memory to zero, using a pointer. 2639 * 2640 * This is wrapper over SDL_memset that handles calculating the object size, 2641 * so there's no chance of copy/paste errors, and the code is cleaner. 2642 * 2643 * This requires a pointer to an object, not an object itself, nor an array. 2644 * 2645 * \param x a pointer to the object to clear. 2646 * 2647 * \threadsafety It is safe to call this macro from any thread. 2648 * 2649 * \since This macro is available since SDL 3.2.0. 2650 * 2651 * \sa SDL_zero 2652 * \sa SDL_zeroa 2653 */ 2654#define SDL_zerop(x) SDL_memset((x), 0, sizeof(*(x))) 2655 2656/** 2657 * Clear an array's memory to zero. 2658 * 2659 * This is wrapper over SDL_memset that handles calculating the array size, so 2660 * there's no chance of copy/paste errors, and the code is cleaner. 2661 * 2662 * This requires an array, not an object, nor a pointer to an object. 2663 * 2664 * \param x an array to clear. 2665 * 2666 * \threadsafety It is safe to call this macro from any thread. 2667 * 2668 * \since This macro is available since SDL 3.2.0. 2669 * 2670 * \sa SDL_zero 2671 * \sa SDL_zerop 2672 */ 2673#define SDL_zeroa(x) SDL_memset((x), 0, sizeof((x))) 2674 2675 2676/** 2677 * Compare two buffers of memory. 2678 * 2679 * \param s1 the first buffer to compare. NULL is not permitted! 2680 * \param s2 the second buffer to compare. NULL is not permitted! 2681 * \param len the number of bytes to compare between the buffers. 2682 * \returns less than zero if s1 is "less than" s2, greater than zero if s1 is 2683 * "greater than" s2, and zero if the buffers match exactly for `len` 2684 * bytes. 2685 * 2686 * \threadsafety It is safe to call this function from any thread. 2687 * 2688 * \since This function is available since SDL 3.2.0. 2689 */ 2690extern SDL_DECLSPEC int SDLCALL SDL_memcmp(const void *s1, const void *s2, size_t len); 2691 2692/** 2693 * This works exactly like wcslen() but doesn't require access to a C runtime. 2694 * 2695 * Counts the number of wchar_t values in `wstr`, excluding the null 2696 * terminator. 2697 * 2698 * Like SDL_strlen only counts bytes and not codepoints in a UTF-8 string, 2699 * this counts wchar_t values in a string, even if the string's encoding is of 2700 * variable width, like UTF-16. 2701 * 2702 * Also be aware that wchar_t is different sizes on different platforms (4 2703 * bytes on Linux, 2 on Windows, etc). 2704 * 2705 * \param wstr The null-terminated wide string to read. Must not be NULL. 2706 * \returns the length (in wchar_t values, excluding the null terminator) of 2707 * `wstr`. 2708 * 2709 * \threadsafety It is safe to call this function from any thread. 2710 * 2711 * \since This function is available since SDL 3.2.0. 2712 * 2713 * \sa SDL_wcsnlen 2714 * \sa SDL_utf8strlen 2715 * \sa SDL_utf8strnlen 2716 */ 2717extern SDL_DECLSPEC size_t SDLCALL SDL_wcslen(const wchar_t *wstr); 2718 2719/** 2720 * This works exactly like wcsnlen() but doesn't require access to a C 2721 * runtime. 2722 * 2723 * Counts up to a maximum of `maxlen` wchar_t values in `wstr`, excluding the 2724 * null terminator. 2725 * 2726 * Like SDL_strnlen only counts bytes and not codepoints in a UTF-8 string, 2727 * this counts wchar_t values in a string, even if the string's encoding is of 2728 * variable width, like UTF-16. 2729 * 2730 * Also be aware that wchar_t is different sizes on different platforms (4 2731 * bytes on Linux, 2 on Windows, etc). 2732 * 2733 * Also, `maxlen` is a count of wide characters, not bytes! 2734 * 2735 * \param wstr The null-terminated wide string to read. Must not be NULL. 2736 * \param maxlen The maximum amount of wide characters to count. 2737 * \returns the length (in wide characters, excluding the null terminator) of 2738 * `wstr` but never more than `maxlen`. 2739 * 2740 * \threadsafety It is safe to call this function from any thread. 2741 * 2742 * \since This function is available since SDL 3.2.0. 2743 * 2744 * \sa SDL_wcslen 2745 * \sa SDL_utf8strlen 2746 * \sa SDL_utf8strnlen 2747 */ 2748extern SDL_DECLSPEC size_t SDLCALL SDL_wcsnlen(const wchar_t *wstr, size_t maxlen); 2749 2750/** 2751 * Copy a wide string. 2752 * 2753 * This function copies `maxlen` - 1 wide characters from `src` to `dst`, then 2754 * appends a null terminator. 2755 * 2756 * `src` and `dst` must not overlap. 2757 * 2758 * If `maxlen` is 0, no wide characters are copied and no null terminator is 2759 * written. 2760 * 2761 * \param dst The destination buffer. Must not be NULL, and must not overlap 2762 * with `src`. 2763 * \param src The null-terminated wide string to copy. Must not be NULL, and 2764 * must not overlap with `dst`. 2765 * \param maxlen The length (in wide characters) of the destination buffer. 2766 * \returns the length (in wide characters, excluding the null terminator) of 2767 * `src`. 2768 * 2769 * \threadsafety It is safe to call this function from any thread. 2770 * 2771 * \since This function is available since SDL 3.2.0. 2772 * 2773 * \sa SDL_wcslcat 2774 */ 2775extern SDL_DECLSPEC size_t SDLCALL SDL_wcslcpy(SDL_OUT_Z_CAP(maxlen) wchar_t *dst, const wchar_t *src, size_t maxlen); 2776 2777/** 2778 * Concatenate wide strings. 2779 * 2780 * This function appends up to `maxlen` - SDL_wcslen(dst) - 1 wide characters 2781 * from `src` to the end of the wide string in `dst`, then appends a null 2782 * terminator. 2783 * 2784 * `src` and `dst` must not overlap. 2785 * 2786 * If `maxlen` - SDL_wcslen(dst) - 1 is less than or equal to 0, then `dst` is 2787 * unmodified. 2788 * 2789 * \param dst The destination buffer already containing the first 2790 * null-terminated wide string. Must not be NULL and must not 2791 * overlap with `src`. 2792 * \param src The second null-terminated wide string. Must not be NULL, and 2793 * must not overlap with `dst`. 2794 * \param maxlen The length (in wide characters) of the destination buffer. 2795 * \returns the length (in wide characters, excluding the null terminator) of 2796 * the string in `dst` plus the length of `src`. 2797 * 2798 * \threadsafety It is safe to call this function from any thread. 2799 * 2800 * \since This function is available since SDL 3.2.0. 2801 * 2802 * \sa SDL_wcslcpy 2803 */ 2804extern SDL_DECLSPEC size_t SDLCALL SDL_wcslcat(SDL_INOUT_Z_CAP(maxlen) wchar_t *dst, const wchar_t *src, size_t maxlen); 2805 2806/** 2807 * Allocate a copy of a wide string. 2808 * 2809 * This allocates enough space for a null-terminated copy of `wstr`, using 2810 * SDL_malloc, and then makes a copy of the string into this space. 2811 * 2812 * The returned string is owned by the caller, and should be passed to 2813 * SDL_free when no longer needed. 2814 * 2815 * \param wstr the string to copy. 2816 * \returns a pointer to the newly-allocated wide string. 2817 * 2818 * \threadsafety It is safe to call this function from any thread. 2819 * 2820 * \since This function is available since SDL 3.2.0. 2821 */ 2822extern SDL_DECLSPEC wchar_t * SDLCALL SDL_wcsdup(const wchar_t *wstr); 2823 2824/** 2825 * Search a wide string for the first instance of a specific substring. 2826 * 2827 * The search ends once it finds the requested substring, or a null terminator 2828 * byte to end the string. 2829 * 2830 * Note that this looks for strings of _wide characters_, not _codepoints_, so 2831 * it's legal to search for malformed and incomplete UTF-16 sequences. 2832 * 2833 * \param haystack the wide string to search. Must not be NULL. 2834 * \param needle the wide string to search for. Must not be NULL. 2835 * \returns a pointer to the first instance of `needle` in the string, or NULL 2836 * if not found. 2837 * 2838 * \threadsafety It is safe to call this function from any thread. 2839 * 2840 * \since This function is available since SDL 3.2.0. 2841 */ 2842extern SDL_DECLSPEC wchar_t * SDLCALL SDL_wcsstr(const wchar_t *haystack, const wchar_t *needle); 2843 2844/** 2845 * Search a wide string, up to n wide chars, for the first instance of a 2846 * specific substring. 2847 * 2848 * The search ends once it finds the requested substring, or a null terminator 2849 * value to end the string, or `maxlen` wide character have been examined. It 2850 * is possible to use this function on a wide string without a null 2851 * terminator. 2852 * 2853 * Note that this looks for strings of _wide characters_, not _codepoints_, so 2854 * it's legal to search for malformed and incomplete UTF-16 sequences. 2855 * 2856 * \param haystack the wide string to search. Must not be NULL. 2857 * \param needle the wide string to search for. Must not be NULL. 2858 * \param maxlen the maximum number of wide characters to search in 2859 * `haystack`. 2860 * \returns a pointer to the first instance of `needle` in the string, or NULL 2861 * if not found. 2862 * 2863 * \threadsafety It is safe to call this function from any thread. 2864 * 2865 * \since This function is available since SDL 3.2.0. 2866 */ 2867extern SDL_DECLSPEC wchar_t * SDLCALL SDL_wcsnstr(const wchar_t *haystack, const wchar_t *needle, size_t maxlen); 2868 2869/** 2870 * Compare two null-terminated wide strings. 2871 * 2872 * This only compares wchar_t values until it hits a null-terminating 2873 * character; it does not care if the string is well-formed UTF-16 (or UTF-32, 2874 * depending on your platform's wchar_t size), or uses valid Unicode values. 2875 * 2876 * \param str1 the first string to compare. NULL is not permitted! 2877 * \param str2 the second string to compare. NULL is not permitted! 2878 * \returns less than zero if str1 is "less than" str2, greater than zero if 2879 * str1 is "greater than" str2, and zero if the strings match 2880 * exactly. 2881 * 2882 * \threadsafety It is safe to call this function from any thread. 2883 * 2884 * \since This function is available since SDL 3.2.0. 2885 */ 2886extern SDL_DECLSPEC int SDLCALL SDL_wcscmp(const wchar_t *str1, const wchar_t *str2); 2887 2888/** 2889 * Compare two wide strings up to a number of wchar_t values. 2890 * 2891 * This only compares wchar_t values; it does not care if the string is 2892 * well-formed UTF-16 (or UTF-32, depending on your platform's wchar_t size), 2893 * or uses valid Unicode values. 2894 * 2895 * Note that while this function is intended to be used with UTF-16 (or 2896 * UTF-32, depending on your platform's definition of wchar_t), it is 2897 * comparing raw wchar_t values and not Unicode codepoints: `maxlen` specifies 2898 * a wchar_t limit! If the limit lands in the middle of a multi-wchar UTF-16 2899 * sequence, it will only compare a portion of the final character. 2900 * 2901 * `maxlen` specifies a maximum number of wchar_t to compare; if the strings 2902 * match to this number of wide chars (or both have matched to a 2903 * null-terminator character before this count), they will be considered 2904 * equal. 2905 * 2906 * \param str1 the first string to compare. NULL is not permitted! 2907 * \param str2 the second string to compare. NULL is not permitted! 2908 * \param maxlen the maximum number of wchar_t to compare. 2909 * \returns less than zero if str1 is "less than" str2, greater than zero if 2910 * str1 is "greater than" str2, and zero if the strings match 2911 * exactly. 2912 * 2913 * \threadsafety It is safe to call this function from any thread. 2914 * 2915 * \since This function is available since SDL 3.2.0. 2916 */ 2917extern SDL_DECLSPEC int SDLCALL SDL_wcsncmp(const wchar_t *str1, const wchar_t *str2, size_t maxlen); 2918 2919/** 2920 * Compare two null-terminated wide strings, case-insensitively. 2921 * 2922 * This will work with Unicode strings, using a technique called 2923 * "case-folding" to handle the vast majority of case-sensitive human 2924 * languages regardless of system locale. It can deal with expanding values: a 2925 * German Eszett character can compare against two ASCII 's' chars and be 2926 * considered a match, for example. A notable exception: it does not handle 2927 * the Turkish 'i' character; human language is complicated! 2928 * 2929 * Depending on your platform, "wchar_t" might be 2 bytes, and expected to be 2930 * UTF-16 encoded (like Windows), or 4 bytes in UTF-32 format. Since this 2931 * handles Unicode, it expects the string to be well-formed and not a 2932 * null-terminated string of arbitrary bytes. Characters that are not valid 2933 * UTF-16 (or UTF-32) are treated as Unicode character U+FFFD (REPLACEMENT 2934 * CHARACTER), which is to say two strings of random bits may turn out to 2935 * match if they convert to the same amount of replacement characters. 2936 * 2937 * \param str1 the first string to compare. NULL is not permitted! 2938 * \param str2 the second string to compare. NULL is not permitted! 2939 * \returns less than zero if str1 is "less than" str2, greater than zero if 2940 * str1 is "greater than" str2, and zero if the strings match 2941 * exactly. 2942 * 2943 * \threadsafety It is safe to call this function from any thread. 2944 * 2945 * \since This function is available since SDL 3.2.0. 2946 */ 2947extern SDL_DECLSPEC int SDLCALL SDL_wcscasecmp(const wchar_t *str1, const wchar_t *str2); 2948 2949/** 2950 * Compare two wide strings, case-insensitively, up to a number of wchar_t. 2951 * 2952 * This will work with Unicode strings, using a technique called 2953 * "case-folding" to handle the vast majority of case-sensitive human 2954 * languages regardless of system locale. It can deal with expanding values: a 2955 * German Eszett character can compare against two ASCII 's' chars and be 2956 * considered a match, for example. A notable exception: it does not handle 2957 * the Turkish 'i' character; human language is complicated! 2958 * 2959 * Depending on your platform, "wchar_t" might be 2 bytes, and expected to be 2960 * UTF-16 encoded (like Windows), or 4 bytes in UTF-32 format. Since this 2961 * handles Unicode, it expects the string to be well-formed and not a 2962 * null-terminated string of arbitrary bytes. Characters that are not valid 2963 * UTF-16 (or UTF-32) are treated as Unicode character U+FFFD (REPLACEMENT 2964 * CHARACTER), which is to say two strings of random bits may turn out to 2965 * match if they convert to the same amount of replacement characters. 2966 * 2967 * Note that while this function might deal with variable-sized characters, 2968 * `maxlen` specifies a _wchar_ limit! If the limit lands in the middle of a 2969 * multi-byte UTF-16 sequence, it may convert a portion of the final character 2970 * to one or more Unicode character U+FFFD (REPLACEMENT CHARACTER) so as not 2971 * to overflow a buffer. 2972 * 2973 * `maxlen` specifies a maximum number of wchar_t values to compare; if the 2974 * strings match to this number of wchar_t (or both have matched to a 2975 * null-terminator character before this number of bytes), they will be 2976 * considered equal. 2977 * 2978 * \param str1 the first string to compare. NULL is not permitted! 2979 * \param str2 the second string to compare. NULL is not permitted! 2980 * \param maxlen the maximum number of wchar_t values to compare. 2981 * \returns less than zero if str1 is "less than" str2, greater than zero if 2982 * str1 is "greater than" str2, and zero if the strings match 2983 * exactly. 2984 * 2985 * \threadsafety It is safe to call this function from any thread. 2986 * 2987 * \since This function is available since SDL 3.2.0. 2988 */ 2989extern SDL_DECLSPEC int SDLCALL SDL_wcsncasecmp(const wchar_t *str1, const wchar_t *str2, size_t maxlen); 2990 2991/** 2992 * Parse a `long` from a wide string. 2993 * 2994 * If `str` starts with whitespace, then those whitespace characters are 2995 * skipped before attempting to parse the number. 2996 * 2997 * If the parsed number does not fit inside a `long`, the result is clamped to 2998 * the minimum and maximum representable `long` values. 2999 * 3000 * \param str The null-terminated wide string to read. Must not be NULL. 3001 * \param endp If not NULL, the address of the first invalid wide character 3002 * (i.e. the next character after the parsed number) will be 3003 * written to this pointer. 3004 * \param base The base of the integer to read. Supported values are 0 and 2 3005 * to 36 inclusive. If 0, the base will be inferred from the 3006 * number's prefix (0x for hexadecimal, 0 for octal, decimal 3007 * otherwise). 3008 * \returns the parsed `long`, or 0 if no number could be parsed. 3009 * 3010 * \threadsafety It is safe to call this function from any thread. 3011 * 3012 * \since This function is available since SDL 3.2.0. 3013 * 3014 * \sa SDL_strtol 3015 */ 3016extern SDL_DECLSPEC long SDLCALL SDL_wcstol(const wchar_t *str, wchar_t **endp, int base); 3017 3018/** 3019 * This works exactly like strlen() but doesn't require access to a C runtime. 3020 * 3021 * Counts the bytes in `str`, excluding the null terminator. 3022 * 3023 * If you need the length of a UTF-8 string, consider using SDL_utf8strlen(). 3024 * 3025 * \param str The null-terminated string to read. Must not be NULL. 3026 * \returns the length (in bytes, excluding the null terminator) of `str`. 3027 * 3028 * \threadsafety It is safe to call this function from any thread. 3029 * 3030 * \since This function is available since SDL 3.2.0. 3031 * 3032 * \sa SDL_strnlen 3033 * \sa SDL_utf8strlen 3034 * \sa SDL_utf8strnlen 3035 */ 3036extern SDL_DECLSPEC size_t SDLCALL SDL_strlen(const char *str); 3037 3038/** 3039 * This works exactly like strnlen() but doesn't require access to a C 3040 * runtime. 3041 * 3042 * Counts up to a maximum of `maxlen` bytes in `str`, excluding the null 3043 * terminator. 3044 * 3045 * If you need the length of a UTF-8 string, consider using SDL_utf8strnlen(). 3046 * 3047 * \param str The null-terminated string to read. Must not be NULL. 3048 * \param maxlen The maximum amount of bytes to count. 3049 * \returns the length (in bytes, excluding the null terminator) of `src` but 3050 * never more than `maxlen`. 3051 * 3052 * \threadsafety It is safe to call this function from any thread. 3053 * 3054 * \since This function is available since SDL 3.2.0. 3055 * 3056 * \sa SDL_strlen 3057 * \sa SDL_utf8strlen 3058 * \sa SDL_utf8strnlen 3059 */ 3060extern SDL_DECLSPEC size_t SDLCALL SDL_strnlen(const char *str, size_t maxlen); 3061 3062/** 3063 * Copy a string. 3064 * 3065 * This function copies up to `maxlen` - 1 characters from `src` to `dst`, 3066 * then appends a null terminator. 3067 * 3068 * If `maxlen` is 0, no characters are copied and no null terminator is 3069 * written. 3070 * 3071 * If you want to copy an UTF-8 string but need to ensure that multi-byte 3072 * sequences are not truncated, consider using SDL_utf8strlcpy(). 3073 * 3074 * \param dst The destination buffer. Must not be NULL, and must not overlap 3075 * with `src`. 3076 * \param src The null-terminated string to copy. Must not be NULL, and must 3077 * not overlap with `dst`. 3078 * \param maxlen The length (in characters) of the destination buffer. 3079 * \returns the length (in characters, excluding the null terminator) of 3080 * `src`. 3081 * 3082 * \threadsafety It is safe to call this function from any thread. 3083 * 3084 * \since This function is available since SDL 3.2.0. 3085 * 3086 * \sa SDL_strlcat 3087 * \sa SDL_utf8strlcpy 3088 */ 3089extern SDL_DECLSPEC size_t SDLCALL SDL_strlcpy(SDL_OUT_Z_CAP(maxlen) char *dst, const char *src, size_t maxlen); 3090 3091/** 3092 * Copy an UTF-8 string. 3093 * 3094 * This function copies up to `dst_bytes` - 1 bytes from `src` to `dst` while 3095 * also ensuring that the string written to `dst` does not end in a truncated 3096 * multi-byte sequence. Finally, it appends a null terminator. 3097 * 3098 * `src` and `dst` must not overlap. 3099 * 3100 * Note that unlike SDL_strlcpy(), this function returns the number of bytes 3101 * written, not the length of `src`. 3102 * 3103 * \param dst The destination buffer. Must not be NULL, and must not overlap 3104 * with `src`. 3105 * \param src The null-terminated UTF-8 string to copy. Must not be NULL, and 3106 * must not overlap with `dst`. 3107 * \param dst_bytes The length (in bytes) of the destination buffer. Must not 3108 * be 0. 3109 * \returns the number of bytes written, excluding the null terminator. 3110 * 3111 * \threadsafety It is safe to call this function from any thread. 3112 * 3113 * \since This function is available since SDL 3.2.0. 3114 * 3115 * \sa SDL_strlcpy 3116 */ 3117extern SDL_DECLSPEC size_t SDLCALL SDL_utf8strlcpy(SDL_OUT_Z_CAP(dst_bytes) char *dst, const char *src, size_t dst_bytes); 3118 3119/** 3120 * Concatenate strings. 3121 * 3122 * This function appends up to `maxlen` - SDL_strlen(dst) - 1 characters from 3123 * `src` to the end of the string in `dst`, then appends a null terminator. 3124 * 3125 * `src` and `dst` must not overlap. 3126 * 3127 * If `maxlen` - SDL_strlen(dst) - 1 is less than or equal to 0, then `dst` is 3128 * unmodified. 3129 * 3130 * \param dst The destination buffer already containing the first 3131 * null-terminated string. Must not be NULL and must not overlap 3132 * with `src`. 3133 * \param src The second null-terminated string. Must not be NULL, and must 3134 * not overlap with `dst`. 3135 * \param maxlen The length (in characters) of the destination buffer. 3136 * \returns the length (in characters, excluding the null terminator) of the 3137 * string in `dst` plus the length of `src`. 3138 * 3139 * \threadsafety It is safe to call this function from any thread. 3140 * 3141 * \since This function is available since SDL 3.2.0. 3142 * 3143 * \sa SDL_strlcpy 3144 */ 3145extern SDL_DECLSPEC size_t SDLCALL SDL_strlcat(SDL_INOUT_Z_CAP(maxlen) char *dst, const char *src, size_t maxlen); 3146 3147/** 3148 * Allocate a copy of a string. 3149 * 3150 * This allocates enough space for a null-terminated copy of `str`, using 3151 * SDL_malloc, and then makes a copy of the string into this space. 3152 * 3153 * The returned string is owned by the caller, and should be passed to 3154 * SDL_free when no longer needed. 3155 * 3156 * \param str the string to copy. 3157 * \returns a pointer to the newly-allocated string. 3158 * 3159 * \threadsafety It is safe to call this function from any thread. 3160 * 3161 * \since This function is available since SDL 3.2.0. 3162 */ 3163extern SDL_DECLSPEC SDL_MALLOC char * SDLCALL SDL_strdup(const char *str); 3164 3165/** 3166 * Allocate a copy of a string, up to n characters. 3167 * 3168 * This allocates enough space for a null-terminated copy of `str`, up to 3169 * `maxlen` bytes, using SDL_malloc, and then makes a copy of the string into 3170 * this space. 3171 * 3172 * If the string is longer than `maxlen` bytes, the returned string will be 3173 * `maxlen` bytes long, plus a null-terminator character that isn't included 3174 * in the count. 3175 * 3176 * The returned string is owned by the caller, and should be passed to 3177 * SDL_free when no longer needed. 3178 * 3179 * \param str the string to copy. 3180 * \param maxlen the maximum length of the copied string, not counting the 3181 * null-terminator character. 3182 * \returns a pointer to the newly-allocated string. 3183 * 3184 * \threadsafety It is safe to call this function from any thread. 3185 * 3186 * \since This function is available since SDL 3.2.0. 3187 */ 3188extern SDL_DECLSPEC SDL_MALLOC char * SDLCALL SDL_strndup(const char *str, size_t maxlen); 3189 3190/** 3191 * Reverse a string's contents. 3192 * 3193 * This reverses a null-terminated string in-place. Only the content of the 3194 * string is reversed; the null-terminator character remains at the end of the 3195 * reversed string. 3196 * 3197 * **WARNING**: This function reverses the _bytes_ of the string, not the 3198 * codepoints. If `str` is a UTF-8 string with Unicode codepoints > 127, this 3199 * will ruin the string data. You should only use this function on strings 3200 * that are completely comprised of low ASCII characters. 3201 * 3202 * \param str the string to reverse. 3203 * \returns `str`. 3204 * 3205 * \threadsafety It is safe to call this function from any thread. 3206 * 3207 * \since This function is available since SDL 3.2.0. 3208 */ 3209extern SDL_DECLSPEC char * SDLCALL SDL_strrev(char *str); 3210 3211/** 3212 * Convert a string to uppercase. 3213 * 3214 * **WARNING**: Regardless of system locale, this will only convert ASCII 3215 * values 'a' through 'z' to uppercase. 3216 * 3217 * This function operates on a null-terminated string of bytes--even if it is 3218 * malformed UTF-8!--and converts ASCII characters 'a' through 'z' to their 3219 * uppercase equivalents in-place, returning the original `str` pointer. 3220 * 3221 * \param str the string to convert in-place. Can not be NULL. 3222 * \returns the `str` pointer passed into this function. 3223 * 3224 * \threadsafety It is safe to call this function from any thread. 3225 * 3226 * \since This function is available since SDL 3.2.0. 3227 * 3228 * \sa SDL_strlwr 3229 */ 3230extern SDL_DECLSPEC char * SDLCALL SDL_strupr(char *str); 3231 3232/** 3233 * Convert a string to lowercase. 3234 * 3235 * **WARNING**: Regardless of system locale, this will only convert ASCII 3236 * values 'A' through 'Z' to lowercase. 3237 * 3238 * This function operates on a null-terminated string of bytes--even if it is 3239 * malformed UTF-8!--and converts ASCII characters 'A' through 'Z' to their 3240 * lowercase equivalents in-place, returning the original `str` pointer. 3241 * 3242 * \param str the string to convert in-place. Can not be NULL. 3243 * \returns the `str` pointer passed into this function. 3244 * 3245 * \threadsafety It is safe to call this function from any thread. 3246 * 3247 * \since This function is available since SDL 3.2.0. 3248 * 3249 * \sa SDL_strupr 3250 */ 3251extern SDL_DECLSPEC char * SDLCALL SDL_strlwr(char *str); 3252 3253/** 3254 * Search a string for the first instance of a specific byte. 3255 * 3256 * The search ends once it finds the requested byte value, or a null 3257 * terminator byte to end the string. 3258 * 3259 * Note that this looks for _bytes_, not _characters_, so you cannot match 3260 * against a Unicode codepoint > 255, regardless of character encoding. 3261 * 3262 * \param str the string to search. Must not be NULL. 3263 * \param c the byte value to search for. 3264 * \returns a pointer to the first instance of `c` in the string, or NULL if 3265 * not found. 3266 * 3267 * \threadsafety It is safe to call this function from any thread. 3268 * 3269 * \since This function is available since SDL 3.2.0. 3270 */ 3271extern SDL_DECLSPEC char * SDLCALL SDL_strchr(const char *str, int c); 3272 3273/** 3274 * Search a string for the last instance of a specific byte. 3275 * 3276 * The search must go until it finds a null terminator byte to end the string. 3277 * 3278 * Note that this looks for _bytes_, not _characters_, so you cannot match 3279 * against a Unicode codepoint > 255, regardless of character encoding. 3280 * 3281 * \param str the string to search. Must not be NULL. 3282 * \param c the byte value to search for. 3283 * \returns a pointer to the last instance of `c` in the string, or NULL if 3284 * not found. 3285 * 3286 * \threadsafety It is safe to call this function from any thread. 3287 * 3288 * \since This function is available since SDL 3.2.0. 3289 */ 3290extern SDL_DECLSPEC char * SDLCALL SDL_strrchr(const char *str, int c); 3291 3292/** 3293 * Search a string for the first instance of a specific substring. 3294 * 3295 * The search ends once it finds the requested substring, or a null terminator 3296 * byte to end the string. 3297 * 3298 * Note that this looks for strings of _bytes_, not _characters_, so it's 3299 * legal to search for malformed and incomplete UTF-8 sequences. 3300 * 3301 * \param haystack the string to search. Must not be NULL. 3302 * \param needle the string to search for. Must not be NULL. 3303 * \returns a pointer to the first instance of `needle` in the string, or NULL 3304 * if not found. 3305 * 3306 * \threadsafety It is safe to call this function from any thread. 3307 * 3308 * \since This function is available since SDL 3.2.0. 3309 */ 3310extern SDL_DECLSPEC char * SDLCALL SDL_strstr(const char *haystack, const char *needle); 3311 3312/** 3313 * Search a string, up to n bytes, for the first instance of a specific 3314 * substring. 3315 * 3316 * The search ends once it finds the requested substring, or a null terminator 3317 * byte to end the string, or `maxlen` bytes have been examined. It is 3318 * possible to use this function on a string without a null terminator. 3319 * 3320 * Note that this looks for strings of _bytes_, not _characters_, so it's 3321 * legal to search for malformed and incomplete UTF-8 sequences. 3322 * 3323 * \param haystack the string to search. Must not be NULL. 3324 * \param needle the string to search for. Must not be NULL. 3325 * \param maxlen the maximum number of bytes to search in `haystack`. 3326 * \returns a pointer to the first instance of `needle` in the string, or NULL 3327 * if not found. 3328 * 3329 * \threadsafety It is safe to call this function from any thread. 3330 * 3331 * \since This function is available since SDL 3.2.0. 3332 */ 3333extern SDL_DECLSPEC char * SDLCALL SDL_strnstr(const char *haystack, const char *needle, size_t maxlen); 3334 3335/** 3336 * Search a UTF-8 string for the first instance of a specific substring, 3337 * case-insensitively. 3338 * 3339 * This will work with Unicode strings, using a technique called 3340 * "case-folding" to handle the vast majority of case-sensitive human 3341 * languages regardless of system locale. It can deal with expanding values: a 3342 * German Eszett character can compare against two ASCII 's' chars and be 3343 * considered a match, for example. A notable exception: it does not handle 3344 * the Turkish 'i' character; human language is complicated! 3345 * 3346 * Since this handles Unicode, it expects the strings to be well-formed UTF-8 3347 * and not a null-terminated string of arbitrary bytes. Bytes that are not 3348 * valid UTF-8 are treated as Unicode character U+FFFD (REPLACEMENT 3349 * CHARACTER), which is to say two strings of random bits may turn out to 3350 * match if they convert to the same amount of replacement characters. 3351 * 3352 * \param haystack the string to search. Must not be NULL. 3353 * \param needle the string to search for. Must not be NULL. 3354 * \returns a pointer to the first instance of `needle` in the string, or NULL 3355 * if not found. 3356 * 3357 * \threadsafety It is safe to call this function from any thread. 3358 * 3359 * \since This function is available since SDL 3.2.0. 3360 */ 3361extern SDL_DECLSPEC char * SDLCALL SDL_strcasestr(const char *haystack, const char *needle); 3362 3363/** 3364 * This works exactly like strtok_r() but doesn't require access to a C 3365 * runtime. 3366 * 3367 * Break a string up into a series of tokens. 3368 * 3369 * To start tokenizing a new string, `str` should be the non-NULL address of 3370 * the string to start tokenizing. Future calls to get the next token from the 3371 * same string should specify a NULL. 3372 * 3373 * Note that this function will overwrite pieces of `str` with null chars to 3374 * split it into tokens. This function cannot be used with const/read-only 3375 * strings! 3376 * 3377 * `saveptr` just needs to point to a `char *` that can be overwritten; SDL 3378 * will use this to save tokenizing state between calls. It is initialized if 3379 * `str` is non-NULL, and used to resume tokenizing when `str` is NULL. 3380 * 3381 * \param str the string to tokenize, or NULL to continue tokenizing. 3382 * \param delim the delimiter string that separates tokens. 3383 * \param saveptr pointer to a char *, used for ongoing state. 3384 * \returns A pointer to the next token, or NULL if no tokens remain. 3385 * 3386 * \threadsafety It is safe to call this function from any thread. 3387 * 3388 * \since This function is available since SDL 3.2.0. 3389 */ 3390extern SDL_DECLSPEC char * SDLCALL SDL_strtok_r(char *str, const char *delim, char **saveptr); 3391 3392/** 3393 * Count the number of codepoints in a UTF-8 string. 3394 * 3395 * Counts the _codepoints_, not _bytes_, in `str`, excluding the null 3396 * terminator. 3397 * 3398 * If you need to count the bytes in a string instead, consider using 3399 * SDL_strlen(). 3400 * 3401 * Since this handles Unicode, it expects the strings to be well-formed UTF-8 3402 * and not a null-terminated string of arbitrary bytes. Bytes that are not 3403 * valid UTF-8 are treated as Unicode character U+FFFD (REPLACEMENT 3404 * CHARACTER), so a malformed or incomplete UTF-8 sequence might increase the 3405 * count by several replacement characters. 3406 * 3407 * \param str The null-terminated UTF-8 string to read. Must not be NULL. 3408 * \returns The length (in codepoints, excluding the null terminator) of 3409 * `src`. 3410 * 3411 * \threadsafety It is safe to call this function from any thread. 3412 * 3413 * \since This function is available since SDL 3.2.0. 3414 * 3415 * \sa SDL_utf8strnlen 3416 * \sa SDL_strlen 3417 */ 3418extern SDL_DECLSPEC size_t SDLCALL SDL_utf8strlen(const char *str); 3419 3420/** 3421 * Count the number of codepoints in a UTF-8 string, up to n bytes. 3422 * 3423 * Counts the _codepoints_, not _bytes_, in `str`, excluding the null 3424 * terminator. 3425 * 3426 * If you need to count the bytes in a string instead, consider using 3427 * SDL_strnlen(). 3428 * 3429 * The counting stops at `bytes` bytes (not codepoints!). This seems 3430 * counterintuitive, but makes it easy to express the total size of the 3431 * string's buffer. 3432 * 3433 * Since this handles Unicode, it expects the strings to be well-formed UTF-8 3434 * and not a null-terminated string of arbitrary bytes. Bytes that are not 3435 * valid UTF-8 are treated as Unicode character U+FFFD (REPLACEMENT 3436 * CHARACTER), so a malformed or incomplete UTF-8 sequence might increase the 3437 * count by several replacement characters. 3438 * 3439 * \param str The null-terminated UTF-8 string to read. Must not be NULL. 3440 * \param bytes The maximum amount of bytes to count. 3441 * \returns The length (in codepoints, excluding the null terminator) of `src` 3442 * but never more than `maxlen`. 3443 * 3444 * \threadsafety It is safe to call this function from any thread. 3445 * 3446 * \since This function is available since SDL 3.2.0. 3447 * 3448 * \sa SDL_utf8strlen 3449 * \sa SDL_strnlen 3450 */ 3451extern SDL_DECLSPEC size_t SDLCALL SDL_utf8strnlen(const char *str, size_t bytes); 3452 3453/** 3454 * Convert an integer into a string. 3455 * 3456 * This requires a radix to specified for string format. Specifying 10 3457 * produces a decimal number, 16 hexadecimal, etc. Must be in the range of 2 3458 * to 36. 3459 * 3460 * Note that this function will overflow a buffer if `str` is not large enough 3461 * to hold the output! It may be safer to use SDL_snprintf to clamp output, or 3462 * SDL_asprintf to allocate a buffer. Otherwise, it doesn't hurt to allocate 3463 * much more space than you expect to use (and don't forget possible negative 3464 * signs, null terminator bytes, etc). 3465 * 3466 * \param value the integer to convert. 3467 * \param str the buffer to write the string into. 3468 * \param radix the radix to use for string generation. 3469 * \returns `str`. 3470 * 3471 * \threadsafety It is safe to call this function from any thread. 3472 * 3473 * \since This function is available since SDL 3.2.0. 3474 * 3475 * \sa SDL_uitoa 3476 * \sa SDL_ltoa 3477 * \sa SDL_lltoa 3478 */ 3479extern SDL_DECLSPEC char * SDLCALL SDL_itoa(int value, char *str, int radix); 3480 3481/** 3482 * Convert an unsigned integer into a string. 3483 * 3484 * This requires a radix to specified for string format. Specifying 10 3485 * produces a decimal number, 16 hexadecimal, etc. Must be in the range of 2 3486 * to 36. 3487 * 3488 * Note that this function will overflow a buffer if `str` is not large enough 3489 * to hold the output! It may be safer to use SDL_snprintf to clamp output, or 3490 * SDL_asprintf to allocate a buffer. Otherwise, it doesn't hurt to allocate 3491 * much more space than you expect to use (and don't forget null terminator 3492 * bytes, etc). 3493 * 3494 * \param value the unsigned integer to convert. 3495 * \param str the buffer to write the string into. 3496 * \param radix the radix to use for string generation. 3497 * \returns `str`. 3498 * 3499 * \threadsafety It is safe to call this function from any thread. 3500 * 3501 * \since This function is available since SDL 3.2.0. 3502 * 3503 * \sa SDL_itoa 3504 * \sa SDL_ultoa 3505 * \sa SDL_ulltoa 3506 */ 3507extern SDL_DECLSPEC char * SDLCALL SDL_uitoa(unsigned int value, char *str, int radix); 3508 3509/** 3510 * Convert a long integer into a string. 3511 * 3512 * This requires a radix to specified for string format. Specifying 10 3513 * produces a decimal number, 16 hexadecimal, etc. Must be in the range of 2 3514 * to 36. 3515 * 3516 * Note that this function will overflow a buffer if `str` is not large enough 3517 * to hold the output! It may be safer to use SDL_snprintf to clamp output, or 3518 * SDL_asprintf to allocate a buffer. Otherwise, it doesn't hurt to allocate 3519 * much more space than you expect to use (and don't forget possible negative 3520 * signs, null terminator bytes, etc). 3521 * 3522 * \param value the long integer to convert. 3523 * \param str the buffer to write the string into. 3524 * \param radix the radix to use for string generation. 3525 * \returns `str`. 3526 * 3527 * \threadsafety It is safe to call this function from any thread. 3528 * 3529 * \since This function is available since SDL 3.2.0. 3530 * 3531 * \sa SDL_ultoa 3532 * \sa SDL_itoa 3533 * \sa SDL_lltoa 3534 */ 3535extern SDL_DECLSPEC char * SDLCALL SDL_ltoa(long value, char *str, int radix); 3536 3537/** 3538 * Convert an unsigned long integer into a string. 3539 * 3540 * This requires a radix to specified for string format. Specifying 10 3541 * produces a decimal number, 16 hexadecimal, etc. Must be in the range of 2 3542 * to 36. 3543 * 3544 * Note that this function will overflow a buffer if `str` is not large enough 3545 * to hold the output! It may be safer to use SDL_snprintf to clamp output, or 3546 * SDL_asprintf to allocate a buffer. Otherwise, it doesn't hurt to allocate 3547 * much more space than you expect to use (and don't forget null terminator 3548 * bytes, etc). 3549 * 3550 * \param value the unsigned long integer to convert. 3551 * \param str the buffer to write the string into. 3552 * \param radix the radix to use for string generation. 3553 * \returns `str`. 3554 * 3555 * \threadsafety It is safe to call this function from any thread. 3556 * 3557 * \since This function is available since SDL 3.2.0. 3558 * 3559 * \sa SDL_ltoa 3560 * \sa SDL_uitoa 3561 * \sa SDL_ulltoa 3562 */ 3563extern SDL_DECLSPEC char * SDLCALL SDL_ultoa(unsigned long value, char *str, int radix); 3564 3565#ifndef SDL_NOLONGLONG 3566 3567/** 3568 * Convert a long long integer into a string. 3569 * 3570 * This requires a radix to specified for string format. Specifying 10 3571 * produces a decimal number, 16 hexadecimal, etc. Must be in the range of 2 3572 * to 36. 3573 * 3574 * Note that this function will overflow a buffer if `str` is not large enough 3575 * to hold the output! It may be safer to use SDL_snprintf to clamp output, or 3576 * SDL_asprintf to allocate a buffer. Otherwise, it doesn't hurt to allocate 3577 * much more space than you expect to use (and don't forget possible negative 3578 * signs, null terminator bytes, etc). 3579 * 3580 * \param value the long long integer to convert. 3581 * \param str the buffer to write the string into. 3582 * \param radix the radix to use for string generation. 3583 * \returns `str`. 3584 * 3585 * \threadsafety It is safe to call this function from any thread. 3586 * 3587 * \since This function is available since SDL 3.2.0. 3588 * 3589 * \sa SDL_ulltoa 3590 * \sa SDL_itoa 3591 * \sa SDL_ltoa 3592 */ 3593extern SDL_DECLSPEC char * SDLCALL SDL_lltoa(long long value, char *str, int radix); 3594 3595/** 3596 * Convert an unsigned long long integer into a string. 3597 * 3598 * This requires a radix to specified for string format. Specifying 10 3599 * produces a decimal number, 16 hexadecimal, etc. Must be in the range of 2 3600 * to 36. 3601 * 3602 * Note that this function will overflow a buffer if `str` is not large enough 3603 * to hold the output! It may be safer to use SDL_snprintf to clamp output, or 3604 * SDL_asprintf to allocate a buffer. Otherwise, it doesn't hurt to allocate 3605 * much more space than you expect to use (and don't forget null terminator 3606 * bytes, etc). 3607 * 3608 * \param value the unsigned long long integer to convert. 3609 * \param str the buffer to write the string into. 3610 * \param radix the radix to use for string generation. 3611 * \returns `str`. 3612 * 3613 * \threadsafety It is safe to call this function from any thread. 3614 * 3615 * \since This function is available since SDL 3.2.0. 3616 * 3617 * \sa SDL_lltoa 3618 * \sa SDL_uitoa 3619 * \sa SDL_ultoa 3620 */ 3621extern SDL_DECLSPEC char * SDLCALL SDL_ulltoa(unsigned long long value, char *str, int radix); 3622#endif 3623 3624/** 3625 * Parse an `int` from a string. 3626 * 3627 * The result of calling `SDL_atoi(str)` is equivalent to 3628 * `(int)SDL_strtol(str, NULL, 10)`. 3629 * 3630 * \param str The null-terminated string to read. Must not be NULL. 3631 * \returns the parsed `int`. 3632 * 3633 * \threadsafety It is safe to call this function from any thread. 3634 * 3635 * \since This function is available since SDL 3.2.0. 3636 * 3637 * \sa SDL_atof 3638 * \sa SDL_strtol 3639 * \sa SDL_strtoul 3640 * \sa SDL_strtoll 3641 * \sa SDL_strtoull 3642 * \sa SDL_strtod 3643 * \sa SDL_itoa 3644 */ 3645extern SDL_DECLSPEC int SDLCALL SDL_atoi(const char *str); 3646 3647/** 3648 * Parse a `double` from a string. 3649 * 3650 * The result of calling `SDL_atof(str)` is equivalent to `SDL_strtod(str, 3651 * NULL)`. 3652 * 3653 * \param str The null-terminated string to read. Must not be NULL. 3654 * \returns the parsed `double`. 3655 * 3656 * \threadsafety It is safe to call this function from any thread. 3657 * 3658 * \since This function is available since SDL 3.2.0. 3659 * 3660 * \sa SDL_atoi 3661 * \sa SDL_strtol 3662 * \sa SDL_strtoul 3663 * \sa SDL_strtoll 3664 * \sa SDL_strtoull 3665 * \sa SDL_strtod 3666 */ 3667extern SDL_DECLSPEC double SDLCALL SDL_atof(const char *str); 3668 3669/** 3670 * Parse a `long` from a string. 3671 * 3672 * If `str` starts with whitespace, then those whitespace characters are 3673 * skipped before attempting to parse the number. 3674 * 3675 * If the parsed number does not fit inside a `long`, the result is clamped to 3676 * the minimum and maximum representable `long` values. 3677 * 3678 * \param str The null-terminated string to read. Must not be NULL. 3679 * \param endp If not NULL, the address of the first invalid character (i.e. 3680 * the next character after the parsed number) will be written to 3681 * this pointer. 3682 * \param base The base of the integer to read. Supported values are 0 and 2 3683 * to 36 inclusive. If 0, the base will be inferred from the 3684 * number's prefix (0x for hexadecimal, 0 for octal, decimal 3685 * otherwise). 3686 * \returns the parsed `long`, or 0 if no number could be parsed. 3687 * 3688 * \threadsafety It is safe to call this function from any thread. 3689 * 3690 * \since This function is available since SDL 3.2.0. 3691 * 3692 * \sa SDL_atoi 3693 * \sa SDL_atof 3694 * \sa SDL_strtoul 3695 * \sa SDL_strtoll 3696 * \sa SDL_strtoull 3697 * \sa SDL_strtod 3698 * \sa SDL_ltoa 3699 * \sa SDL_wcstol 3700 */ 3701extern SDL_DECLSPEC long SDLCALL SDL_strtol(const char *str, char **endp, int base); 3702 3703/** 3704 * Parse an `unsigned long` from a string. 3705 * 3706 * If `str` starts with whitespace, then those whitespace characters are 3707 * skipped before attempting to parse the number. 3708 * 3709 * If the parsed number does not fit inside an `unsigned long`, the result is 3710 * clamped to the maximum representable `unsigned long` value. 3711 * 3712 * \param str The null-terminated string to read. Must not be NULL. 3713 * \param endp If not NULL, the address of the first invalid character (i.e. 3714 * the next character after the parsed number) will be written to 3715 * this pointer. 3716 * \param base The base of the integer to read. Supported values are 0 and 2 3717 * to 36 inclusive. If 0, the base will be inferred from the 3718 * number's prefix (0x for hexadecimal, 0 for octal, decimal 3719 * otherwise). 3720 * \returns the parsed `unsigned long`, or 0 if no number could be parsed. 3721 * 3722 * \threadsafety It is safe to call this function from any thread. 3723 * 3724 * \since This function is available since SDL 3.2.0. 3725 * 3726 * \sa SDL_atoi 3727 * \sa SDL_atof 3728 * \sa SDL_strtol 3729 * \sa SDL_strtoll 3730 * \sa SDL_strtoull 3731 * \sa SDL_strtod 3732 * \sa SDL_ultoa 3733 */ 3734extern SDL_DECLSPEC unsigned long SDLCALL SDL_strtoul(const char *str, char **endp, int base); 3735 3736#ifndef SDL_NOLONGLONG 3737 3738/** 3739 * Parse a `long long` from a string. 3740 * 3741 * If `str` starts with whitespace, then those whitespace characters are 3742 * skipped before attempting to parse the number. 3743 * 3744 * If the parsed number does not fit inside a `long long`, the result is 3745 * clamped to the minimum and maximum representable `long long` values. 3746 * 3747 * \param str The null-terminated string to read. Must not be NULL. 3748 * \param endp If not NULL, the address of the first invalid character (i.e. 3749 * the next character after the parsed number) will be written to 3750 * this pointer. 3751 * \param base The base of the integer to read. Supported values are 0 and 2 3752 * to 36 inclusive. If 0, the base will be inferred from the 3753 * number's prefix (0x for hexadecimal, 0 for octal, decimal 3754 * otherwise). 3755 * \returns the parsed `long long`, or 0 if no number could be parsed. 3756 * 3757 * \threadsafety It is safe to call this function from any thread. 3758 * 3759 * \since This function is available since SDL 3.2.0. 3760 * 3761 * \sa SDL_atoi 3762 * \sa SDL_atof 3763 * \sa SDL_strtol 3764 * \sa SDL_strtoul 3765 * \sa SDL_strtoull 3766 * \sa SDL_strtod 3767 * \sa SDL_lltoa 3768 */ 3769extern SDL_DECLSPEC long long SDLCALL SDL_strtoll(const char *str, char **endp, int base); 3770 3771/** 3772 * Parse an `unsigned long long` from a string. 3773 * 3774 * If `str` starts with whitespace, then those whitespace characters are 3775 * skipped before attempting to parse the number. 3776 * 3777 * If the parsed number does not fit inside an `unsigned long long`, the 3778 * result is clamped to the maximum representable `unsigned long long` value. 3779 * 3780 * \param str The null-terminated string to read. Must not be NULL. 3781 * \param endp If not NULL, the address of the first invalid character (i.e. 3782 * the next character after the parsed number) will be written to 3783 * this pointer. 3784 * \param base The base of the integer to read. Supported values are 0 and 2 3785 * to 36 inclusive. If 0, the base will be inferred from the 3786 * number's prefix (0x for hexadecimal, 0 for octal, decimal 3787 * otherwise). 3788 * \returns the parsed `unsigned long long`, or 0 if no number could be 3789 * parsed. 3790 * 3791 * \threadsafety It is safe to call this function from any thread. 3792 * 3793 * \since This function is available since SDL 3.2.0. 3794 * 3795 * \sa SDL_atoi 3796 * \sa SDL_atof 3797 * \sa SDL_strtol 3798 * \sa SDL_strtoll 3799 * \sa SDL_strtoul 3800 * \sa SDL_strtod 3801 * \sa SDL_ulltoa 3802 */ 3803extern SDL_DECLSPEC unsigned long long SDLCALL SDL_strtoull(const char *str, char **endp, int base); 3804#endif 3805 3806/** 3807 * Parse a `double` from a string. 3808 * 3809 * This function makes fewer guarantees than the C runtime `strtod`: 3810 * 3811 * - Only decimal notation is guaranteed to be supported. The handling of 3812 * scientific and hexadecimal notation is unspecified. 3813 * - Whether or not INF and NAN can be parsed is unspecified. 3814 * - The precision of the result is unspecified. 3815 * 3816 * \param str the null-terminated string to read. Must not be NULL. 3817 * \param endp if not NULL, the address of the first invalid character (i.e. 3818 * the next character after the parsed number) will be written to 3819 * this pointer. 3820 * \returns the parsed `double`, or 0 if no number could be parsed. 3821 * 3822 * \threadsafety It is safe to call this function from any thread. 3823 * 3824 * \since This function is available since SDL 3.2.0. 3825 * 3826 * \sa SDL_atoi 3827 * \sa SDL_atof 3828 * \sa SDL_strtol 3829 * \sa SDL_strtoll 3830 * \sa SDL_strtoul 3831 * \sa SDL_strtoull 3832 */ 3833extern SDL_DECLSPEC double SDLCALL SDL_strtod(const char *str, char **endp); 3834 3835/** 3836 * Compare two null-terminated UTF-8 strings. 3837 * 3838 * Due to the nature of UTF-8 encoding, this will work with Unicode strings, 3839 * since effectively this function just compares bytes until it hits a 3840 * null-terminating character. Also due to the nature of UTF-8, this can be 3841 * used with SDL_qsort() to put strings in (roughly) alphabetical order. 3842 * 3843 * \param str1 the first string to compare. NULL is not permitted! 3844 * \param str2 the second string to compare. NULL is not permitted! 3845 * \returns less than zero if str1 is "less than" str2, greater than zero if 3846 * str1 is "greater than" str2, and zero if the strings match 3847 * exactly. 3848 * 3849 * \threadsafety It is safe to call this function from any thread. 3850 * 3851 * \since This function is available since SDL 3.2.0. 3852 */ 3853extern SDL_DECLSPEC int SDLCALL SDL_strcmp(const char *str1, const char *str2); 3854 3855/** 3856 * Compare two UTF-8 strings up to a number of bytes. 3857 * 3858 * Due to the nature of UTF-8 encoding, this will work with Unicode strings, 3859 * since effectively this function just compares bytes until it hits a 3860 * null-terminating character. Also due to the nature of UTF-8, this can be 3861 * used with SDL_qsort() to put strings in (roughly) alphabetical order. 3862 * 3863 * Note that while this function is intended to be used with UTF-8, it is 3864 * doing a bytewise comparison, and `maxlen` specifies a _byte_ limit! If the 3865 * limit lands in the middle of a multi-byte UTF-8 sequence, it will only 3866 * compare a portion of the final character. 3867 * 3868 * `maxlen` specifies a maximum number of bytes to compare; if the strings 3869 * match to this number of bytes (or both have matched to a null-terminator 3870 * character before this number of bytes), they will be considered equal. 3871 * 3872 * \param str1 the first string to compare. NULL is not permitted! 3873 * \param str2 the second string to compare. NULL is not permitted! 3874 * \param maxlen the maximum number of _bytes_ to compare. 3875 * \returns less than zero if str1 is "less than" str2, greater than zero if 3876 * str1 is "greater than" str2, and zero if the strings match 3877 * exactly. 3878 * 3879 * \threadsafety It is safe to call this function from any thread. 3880 * 3881 * \since This function is available since SDL 3.2.0. 3882 */ 3883extern SDL_DECLSPEC int SDLCALL SDL_strncmp(const char *str1, const char *str2, size_t maxlen); 3884 3885/** 3886 * Compare two null-terminated UTF-8 strings, case-insensitively. 3887 * 3888 * This will work with Unicode strings, using a technique called 3889 * "case-folding" to handle the vast majority of case-sensitive human 3890 * languages regardless of system locale. It can deal with expanding values: a 3891 * German Eszett character can compare against two ASCII 's' chars and be 3892 * considered a match, for example. A notable exception: it does not handle 3893 * the Turkish 'i' character; human language is complicated! 3894 * 3895 * Since this handles Unicode, it expects the string to be well-formed UTF-8 3896 * and not a null-terminated string of arbitrary bytes. Bytes that are not 3897 * valid UTF-8 are treated as Unicode character U+FFFD (REPLACEMENT 3898 * CHARACTER), which is to say two strings of random bits may turn out to 3899 * match if they convert to the same amount of replacement characters. 3900 * 3901 * \param str1 the first string to compare. NULL is not permitted! 3902 * \param str2 the second string to compare. NULL is not permitted! 3903 * \returns less than zero if str1 is "less than" str2, greater than zero if 3904 * str1 is "greater than" str2, and zero if the strings match 3905 * exactly. 3906 * 3907 * \threadsafety It is safe to call this function from any thread. 3908 * 3909 * \since This function is available since SDL 3.2.0. 3910 */ 3911extern SDL_DECLSPEC int SDLCALL SDL_strcasecmp(const char *str1, const char *str2); 3912 3913 3914/** 3915 * Compare two UTF-8 strings, case-insensitively, up to a number of bytes. 3916 * 3917 * This will work with Unicode strings, using a technique called 3918 * "case-folding" to handle the vast majority of case-sensitive human 3919 * languages regardless of system locale. It can deal with expanding values: a 3920 * German Eszett character can compare against two ASCII 's' chars and be 3921 * considered a match, for example. A notable exception: it does not handle 3922 * the Turkish 'i' character; human language is complicated! 3923 * 3924 * Since this handles Unicode, it expects the string to be well-formed UTF-8 3925 * and not a null-terminated string of arbitrary bytes. Bytes that are not 3926 * valid UTF-8 are treated as Unicode character U+FFFD (REPLACEMENT 3927 * CHARACTER), which is to say two strings of random bits may turn out to 3928 * match if they convert to the same amount of replacement characters. 3929 * 3930 * Note that while this function is intended to be used with UTF-8, `maxlen` 3931 * specifies a _byte_ limit! If the limit lands in the middle of a multi-byte 3932 * UTF-8 sequence, it may convert a portion of the final character to one or 3933 * more Unicode character U+FFFD (REPLACEMENT CHARACTER) so as not to overflow 3934 * a buffer. 3935 * 3936 * `maxlen` specifies a maximum number of bytes to compare; if the strings 3937 * match to this number of bytes (or both have matched to a null-terminator 3938 * character before this number of bytes), they will be considered equal. 3939 * 3940 * \param str1 the first string to compare. NULL is not permitted! 3941 * \param str2 the second string to compare. NULL is not permitted! 3942 * \param maxlen the maximum number of bytes to compare. 3943 * \returns less than zero if str1 is "less than" str2, greater than zero if 3944 * str1 is "greater than" str2, and zero if the strings match 3945 * exactly. 3946 * 3947 * \threadsafety It is safe to call this function from any thread. 3948 * 3949 * \since This function is available since SDL 3.2.0. 3950 */ 3951extern SDL_DECLSPEC int SDLCALL SDL_strncasecmp(const char *str1, const char *str2, size_t maxlen); 3952 3953/** 3954 * Searches a string for the first occurrence of any character contained in a 3955 * breakset, and returns a pointer from the string to that character. 3956 * 3957 * \param str The null-terminated string to be searched. Must not be NULL, and 3958 * must not overlap with `breakset`. 3959 * \param breakset A null-terminated string containing the list of characters 3960 * to look for. Must not be NULL, and must not overlap with 3961 * `str`. 3962 * \returns A pointer to the location, in str, of the first occurrence of a 3963 * character present in the breakset, or NULL if none is found. 3964 * 3965 * \threadsafety It is safe to call this function from any thread. 3966 * 3967 * \since This function is available since SDL 3.2.0. 3968 */ 3969extern SDL_DECLSPEC char * SDLCALL SDL_strpbrk(const char *str, const char *breakset); 3970 3971/** 3972 * The Unicode REPLACEMENT CHARACTER codepoint. 3973 * 3974 * SDL_StepUTF8() and SDL_StepBackUTF8() report this codepoint when they 3975 * encounter a UTF-8 string with encoding errors. 3976 * 3977 * This tends to render as something like a question mark in most places. 3978 * 3979 * \since This macro is available since SDL 3.2.0. 3980 * 3981 * \sa SDL_StepBackUTF8 3982 * \sa SDL_StepUTF8 3983 */ 3984#define SDL_INVALID_UNICODE_CODEPOINT 0xFFFD 3985 3986/** 3987 * Decode a UTF-8 string, one Unicode codepoint at a time. 3988 * 3989 * This will return the first Unicode codepoint in the UTF-8 encoded string in 3990 * `*pstr`, and then advance `*pstr` past any consumed bytes before returning. 3991 * 3992 * It will not access more than `*pslen` bytes from the string. `*pslen` will 3993 * be adjusted, as well, subtracting the number of bytes consumed. 3994 * 3995 * `pslen` is allowed to be NULL, in which case the string _must_ be 3996 * NULL-terminated, as the function will blindly read until it sees the NULL 3997 * char. 3998 * 3999 * If `*pslen` is zero, it assumes the end of string is reached and returns a 4000 * zero codepoint regardless of the contents of the string buffer. 4001 * 4002 * If the resulting codepoint is zero (a NULL terminator), or `*pslen` is 4003 * zero, it will not advance `*pstr` or `*pslen` at all. 4004 * 4005 * Generally this function is called in a loop until it returns zero, 4006 * adjusting its parameters each iteration. 4007 * 4008 * If an invalid UTF-8 sequence is encountered, this function returns 4009 * SDL_INVALID_UNICODE_CODEPOINT and advances the string/length by one byte 4010 * (which is to say, a multibyte sequence might produce several 4011 * SDL_INVALID_UNICODE_CODEPOINT returns before it syncs to the next valid 4012 * UTF-8 sequence). 4013 * 4014 * Several things can generate invalid UTF-8 sequences, including overlong 4015 * encodings, the use of UTF-16 surrogate values, and truncated data. Please 4016 * refer to 4017 * [RFC3629](https://www.ietf.org/rfc/rfc3629.txt) 4018 * for details. 4019 * 4020 * \param pstr a pointer to a UTF-8 string pointer to be read and adjusted. 4021 * \param pslen a pointer to the number of bytes in the string, to be read and 4022 * adjusted. NULL is allowed. 4023 * \returns the first Unicode codepoint in the string. 4024 * 4025 * \threadsafety It is safe to call this function from any thread. 4026 * 4027 * \since This function is available since SDL 3.2.0. 4028 */ 4029extern SDL_DECLSPEC Uint32 SDLCALL SDL_StepUTF8(const char **pstr, size_t *pslen); 4030 4031/** 4032 * Decode a UTF-8 string in reverse, one Unicode codepoint at a time. 4033 * 4034 * This will go to the start of the previous Unicode codepoint in the string, 4035 * move `*pstr` to that location and return that codepoint. 4036 * 4037 * If `*pstr` is already at the start of the string), it will not advance 4038 * `*pstr` at all. 4039 * 4040 * Generally this function is called in a loop until it returns zero, 4041 * adjusting its parameter each iteration. 4042 * 4043 * If an invalid UTF-8 sequence is encountered, this function returns 4044 * SDL_INVALID_UNICODE_CODEPOINT. 4045 * 4046 * Several things can generate invalid UTF-8 sequences, including overlong 4047 * encodings, the use of UTF-16 surrogate values, and truncated data. Please 4048 * refer to 4049 * [RFC3629](https://www.ietf.org/rfc/rfc3629.txt) 4050 * for details. 4051 * 4052 * \param start a pointer to the beginning of the UTF-8 string. 4053 * \param pstr a pointer to a UTF-8 string pointer to be read and adjusted. 4054 * \returns the previous Unicode codepoint in the string. 4055 * 4056 * \threadsafety It is safe to call this function from any thread. 4057 * 4058 * \since This function is available since SDL 3.2.0. 4059 */ 4060extern SDL_DECLSPEC Uint32 SDLCALL SDL_StepBackUTF8(const char *start, const char **pstr); 4061 4062/** 4063 * Convert a single Unicode codepoint to UTF-8. 4064 * 4065 * The buffer pointed to by `dst` must be at least 4 bytes long, as this 4066 * function may generate between 1 and 4 bytes of output. 4067 * 4068 * This function returns the first byte _after_ the newly-written UTF-8 4069 * sequence, which is useful for encoding multiple codepoints in a loop, or 4070 * knowing where to write a NULL-terminator character to end the string (in 4071 * either case, plan to have a buffer of _more_ than 4 bytes!). 4072 * 4073 * If `codepoint` is an invalid value (outside the Unicode range, or a UTF-16 4074 * surrogate value, etc), this will use U+FFFD (REPLACEMENT CHARACTER) for the 4075 * codepoint instead, and not set an error. 4076 * 4077 * If `dst` is NULL, this returns NULL immediately without writing to the 4078 * pointer and without setting an error. 4079 * 4080 * \param codepoint a Unicode codepoint to convert to UTF-8. 4081 * \param dst the location to write the encoded UTF-8. Must point to at least 4082 * 4 bytes! 4083 * \returns the first byte past the newly-written UTF-8 sequence. 4084 * 4085 * \threadsafety It is safe to call this function from any thread. 4086 * 4087 * \since This function is available since SDL 3.2.0. 4088 */ 4089extern SDL_DECLSPEC char * SDLCALL SDL_UCS4ToUTF8(Uint32 codepoint, char *dst); 4090 4091/** 4092 * This works exactly like sscanf() but doesn't require access to a C runtime. 4093 * 4094 * Scan a string, matching a format string, converting each '%' item and 4095 * storing it to pointers provided through variable arguments. 4096 * 4097 * \param text the string to scan. Must not be NULL. 4098 * \param fmt a printf-style format string. Must not be NULL. 4099 * \param ... a list of pointers to values to be filled in with scanned items. 4100 * \returns the number of items that matched the format string. 4101 * 4102 * \threadsafety It is safe to call this function from any thread. 4103 * 4104 * \since This function is available since SDL 3.2.0. 4105 */ 4106extern SDL_DECLSPEC int SDLCALL SDL_sscanf(const char *text, SDL_SCANF_FORMAT_STRING const char *fmt, ...) SDL_SCANF_VARARG_FUNC(2); 4107 4108/** 4109 * This works exactly like vsscanf() but doesn't require access to a C 4110 * runtime. 4111 * 4112 * Functions identically to SDL_sscanf(), except it takes a `va_list` instead 4113 * of using `...` variable arguments. 4114 * 4115 * \param text the string to scan. Must not be NULL. 4116 * \param fmt a printf-style format string. Must not be NULL. 4117 * \param ap a `va_list` of pointers to values to be filled in with scanned 4118 * items. 4119 * \returns the number of items that matched the format string. 4120 * 4121 * \threadsafety It is safe to call this function from any thread. 4122 * 4123 * \since This function is available since SDL 3.2.0. 4124 */ 4125extern SDL_DECLSPEC int SDLCALL SDL_vsscanf(const char *text, SDL_SCANF_FORMAT_STRING const char *fmt, va_list ap) SDL_SCANF_VARARG_FUNCV(2); 4126 4127/** 4128 * This works exactly like snprintf() but doesn't require access to a C 4129 * runtime. 4130 * 4131 * Format a string of up to `maxlen`-1 bytes, converting each '%' item with 4132 * values provided through variable arguments. 4133 * 4134 * While some C runtimes differ on how to deal with too-large strings, this 4135 * function null-terminates the output, by treating the null-terminator as 4136 * part of the `maxlen` count. Note that if `maxlen` is zero, however, no 4137 * bytes will be written at all. 4138 * 4139 * This function returns the number of _bytes_ (not _characters_) that should 4140 * be written, excluding the null-terminator character. If this returns a 4141 * number >= `maxlen`, it means the output string was truncated. A negative 4142 * return value means an error occurred. 4143 * 4144 * Referencing the output string's pointer with a format item is undefined 4145 * behavior. 4146 * 4147 * \param text the buffer to write the string into. Must not be NULL. 4148 * \param maxlen the maximum bytes to write, including the null-terminator. 4149 * \param fmt a printf-style format string. Must not be NULL. 4150 * \param ... a list of values to be used with the format string. 4151 * \returns the number of bytes that should be written, not counting the 4152 * null-terminator char, or a negative value on error. 4153 * 4154 * \threadsafety It is safe to call this function from any thread. 4155 * 4156 * \since This function is available since SDL 3.2.0. 4157 */ 4158extern SDL_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); 4159 4160/** 4161 * This works exactly like swprintf() but doesn't require access to a C 4162 * runtime. 4163 * 4164 * Format a wide string of up to `maxlen`-1 wchar_t values, converting each 4165 * '%' item with values provided through variable arguments. 4166 * 4167 * While some C runtimes differ on how to deal with too-large strings, this 4168 * function null-terminates the output, by treating the null-terminator as 4169 * part of the `maxlen` count. Note that if `maxlen` is zero, however, no wide 4170 * characters will be written at all. 4171 * 4172 * This function returns the number of _wide characters_ (not _codepoints_) 4173 * that should be written, excluding the null-terminator character. If this 4174 * returns a number >= `maxlen`, it means the output string was truncated. A 4175 * negative return value means an error occurred. 4176 * 4177 * Referencing the output string's pointer with a format item is undefined 4178 * behavior. 4179 * 4180 * \param text the buffer to write the wide string into. Must not be NULL. 4181 * \param maxlen the maximum wchar_t values to write, including the 4182 * null-terminator. 4183 * \param fmt a printf-style format string. Must not be NULL. 4184 * \param ... a list of values to be used with the format string. 4185 * \returns the number of wide characters that should be written, not counting 4186 * the null-terminator char, or a negative value on error. 4187 * 4188 * \threadsafety It is safe to call this function from any thread. 4189 * 4190 * \since This function is available since SDL 3.2.0. 4191 */ 4192extern SDL_DECLSPEC int SDLCALL SDL_swprintf(SDL_OUT_Z_CAP(maxlen) wchar_t *text, size_t maxlen, SDL_PRINTF_FORMAT_STRING const wchar_t *fmt, ...) SDL_WPRINTF_VARARG_FUNC(3); 4193 4194/** 4195 * This works exactly like vsnprintf() but doesn't require access to a C 4196 * runtime. 4197 * 4198 * Functions identically to SDL_snprintf(), except it takes a `va_list` 4199 * instead of using `...` variable arguments. 4200 * 4201 * \param text the buffer to write the string into. Must not be NULL. 4202 * \param maxlen the maximum bytes to write, including the null-terminator. 4203 * \param fmt a printf-style format string. Must not be NULL. 4204 * \param ap a `va_list` values to be used with the format string. 4205 * \returns the number of bytes that should be written, not counting the 4206 * null-terminator char, or a negative value on error. 4207 * 4208 * \threadsafety It is safe to call this function from any thread. 4209 * 4210 * \since This function is available since SDL 3.2.0. 4211 */ 4212extern SDL_DECLSPEC int SDLCALL SDL_vsnprintf(SDL_OUT_Z_CAP(maxlen) char *text, size_t maxlen, SDL_PRINTF_FORMAT_STRING const char *fmt, va_list ap) SDL_PRINTF_VARARG_FUNCV(3); 4213 4214/** 4215 * This works exactly like vswprintf() but doesn't require access to a C 4216 * runtime. 4217 * 4218 * Functions identically to SDL_swprintf(), except it takes a `va_list` 4219 * instead of using `...` variable arguments. 4220 * 4221 * \param text the buffer to write the string into. Must not be NULL. 4222 * \param maxlen the maximum wide characters to write, including the 4223 * null-terminator. 4224 * \param fmt a printf-style format wide string. Must not be NULL. 4225 * \param ap a `va_list` values to be used with the format string. 4226 * \returns the number of wide characters that should be written, not counting 4227 * the null-terminator char, or a negative value on error. 4228 * 4229 * \threadsafety It is safe to call this function from any thread. 4230 * 4231 * \since This function is available since SDL 3.2.0. 4232 */ 4233extern SDL_DECLSPEC int SDLCALL SDL_vswprintf(SDL_OUT_Z_CAP(maxlen) wchar_t *text, size_t maxlen, SDL_PRINTF_FORMAT_STRING const wchar_t *fmt, va_list ap) SDL_WPRINTF_VARARG_FUNCV(3); 4234 4235/** 4236 * This works exactly like asprintf() but doesn't require access to a C 4237 * runtime. 4238 * 4239 * Functions identically to SDL_snprintf(), except it allocates a buffer large 4240 * enough to hold the output string on behalf of the caller. 4241 * 4242 * On success, this function returns the number of bytes (not characters) 4243 * comprising the output string, not counting the null-terminator character, 4244 * and sets `*strp` to the newly-allocated string. 4245 * 4246 * On error, this function returns a negative number, and the value of `*strp` 4247 * is undefined. 4248 * 4249 * The returned string is owned by the caller, and should be passed to 4250 * SDL_free when no longer needed. 4251 * 4252 * \param strp on output, is set to the new string. Must not be NULL. 4253 * \param fmt a printf-style format string. Must not be NULL. 4254 * \param ... a list of values to be used with the format string. 4255 * \returns the number of bytes in the newly-allocated string, not counting 4256 * the null-terminator char, or a negative value on error. 4257 * 4258 * \threadsafety It is safe to call this function from any thread. 4259 * 4260 * \since This function is available since SDL 3.2.0. 4261 */ 4262extern SDL_DECLSPEC int SDLCALL SDL_asprintf(char **strp, SDL_PRINTF_FORMAT_STRING const char *fmt, ...) SDL_PRINTF_VARARG_FUNC(2); 4263 4264/** 4265 * This works exactly like vasprintf() but doesn't require access to a C 4266 * runtime. 4267 * 4268 * Functions identically to SDL_asprintf(), except it takes a `va_list` 4269 * instead of using `...` variable arguments. 4270 * 4271 * \param strp on output, is set to the new string. Must not be NULL. 4272 * \param fmt a printf-style format string. Must not be NULL. 4273 * \param ap a `va_list` values to be used with the format string. 4274 * \returns the number of bytes in the newly-allocated string, not counting 4275 * the null-terminator char, or a negative value on error. 4276 * 4277 * \threadsafety It is safe to call this function from any thread. 4278 * 4279 * \since This function is available since SDL 3.2.0. 4280 */ 4281extern SDL_DECLSPEC int SDLCALL SDL_vasprintf(char **strp, SDL_PRINTF_FORMAT_STRING const char *fmt, va_list ap) SDL_PRINTF_VARARG_FUNCV(2); 4282 4283/** 4284 * Seeds the pseudo-random number generator. 4285 * 4286 * Reusing the seed number will cause SDL_rand() to repeat the same stream of 4287 * 'random' numbers. 4288 * 4289 * \param seed the value to use as a random number seed, or 0 to use 4290 * SDL_GetPerformanceCounter(). 4291 * 4292 * \threadsafety This should be called on the same thread that calls 4293 * SDL_rand() 4294 * 4295 * \since This function is available since SDL 3.2.0. 4296 * 4297 * \sa SDL_rand 4298 * \sa SDL_rand_bits 4299 * \sa SDL_randf 4300 */ 4301extern SDL_DECLSPEC void SDLCALL SDL_srand(Uint64 seed); 4302 4303/** 4304 * Generate a pseudo-random number less than n for positive n 4305 * 4306 * The method used is faster and of better quality than `rand() % n`. Odds are 4307 * roughly 99.9% even for n = 1 million. Evenness is better for smaller n, and 4308 * much worse as n gets bigger. 4309 * 4310 * Example: to simulate a d6 use `SDL_rand(6) + 1` The +1 converts 0..5 to 4311 * 1..6 4312 * 4313 * If you want to generate a pseudo-random number in the full range of Sint32, 4314 * you should use: (Sint32)SDL_rand_bits() 4315 * 4316 * If you want reproducible output, be sure to initialize with SDL_srand() 4317 * first. 4318 * 4319 * There are no guarantees as to the quality of the random sequence produced, 4320 * and this should not be used for security (cryptography, passwords) or where 4321 * money is on the line (loot-boxes, casinos). There are many random number 4322 * libraries available with different characteristics and you should pick one 4323 * of those to meet any serious needs. 4324 * 4325 * \param n the number of possible outcomes. n must be positive. 4326 * \returns a random value in the range of [0 .. n-1]. 4327 * 4328 * \threadsafety All calls should be made from a single thread 4329 * 4330 * \since This function is available since SDL 3.2.0. 4331 * 4332 * \sa SDL_srand 4333 * \sa SDL_randf 4334 */ 4335extern SDL_DECLSPEC Sint32 SDLCALL SDL_rand(Sint32 n); 4336 4337/** 4338 * Generate a uniform pseudo-random floating point number less than 1.0 4339 * 4340 * If you want reproducible output, be sure to initialize with SDL_srand() 4341 * first. 4342 * 4343 * There are no guarantees as to the quality of the random sequence produced, 4344 * and this should not be used for security (cryptography, passwords) or where 4345 * money is on the line (loot-boxes, casinos). There are many random number 4346 * libraries available with different characteristics and you should pick one 4347 * of those to meet any serious needs. 4348 * 4349 * \returns a random value in the range of [0.0, 1.0). 4350 * 4351 * \threadsafety All calls should be made from a single thread 4352 * 4353 * \since This function is available since SDL 3.2.0. 4354 * 4355 * \sa SDL_srand 4356 * \sa SDL_rand 4357 */ 4358extern SDL_DECLSPEC float SDLCALL SDL_randf(void); 4359 4360/** 4361 * Generate 32 pseudo-random bits. 4362 * 4363 * You likely want to use SDL_rand() to get a pseudo-random number instead. 4364 * 4365 * There are no guarantees as to the quality of the random sequence produced, 4366 * and this should not be used for security (cryptography, passwords) or where 4367 * money is on the line (loot-boxes, casinos). There are many random number 4368 * libraries available with different characteristics and you should pick one 4369 * of those to meet any serious needs. 4370 * 4371 * \returns a random value in the range of [0-SDL_MAX_UINT32]. 4372 * 4373 * \threadsafety All calls should be made from a single thread 4374 * 4375 * \since This function is available since SDL 3.2.0. 4376 * 4377 * \sa SDL_rand 4378 * \sa SDL_randf 4379 * \sa SDL_srand 4380 */ 4381extern SDL_DECLSPEC Uint32 SDLCALL SDL_rand_bits(void); 4382 4383/** 4384 * Generate a pseudo-random number less than n for positive n 4385 * 4386 * The method used is faster and of better quality than `rand() % n`. Odds are 4387 * roughly 99.9% even for n = 1 million. Evenness is better for smaller n, and 4388 * much worse as n gets bigger. 4389 * 4390 * Example: to simulate a d6 use `SDL_rand_r(state, 6) + 1` The +1 converts 4391 * 0..5 to 1..6 4392 * 4393 * If you want to generate a pseudo-random number in the full range of Sint32, 4394 * you should use: (Sint32)SDL_rand_bits_r(state) 4395 * 4396 * There are no guarantees as to the quality of the random sequence produced, 4397 * and this should not be used for security (cryptography, passwords) or where 4398 * money is on the line (loot-boxes, casinos). There are many random number 4399 * libraries available with different characteristics and you should pick one 4400 * of those to meet any serious needs. 4401 * 4402 * \param state a pointer to the current random number state, this may not be 4403 * NULL. 4404 * \param n the number of possible outcomes. n must be positive. 4405 * \returns a random value in the range of [0 .. n-1]. 4406 * 4407 * \threadsafety This function is thread-safe, as long as the state pointer 4408 * isn't shared between threads. 4409 * 4410 * \since This function is available since SDL 3.2.0. 4411 * 4412 * \sa SDL_rand 4413 * \sa SDL_rand_bits_r 4414 * \sa SDL_randf_r 4415 */ 4416extern SDL_DECLSPEC Sint32 SDLCALL SDL_rand_r(Uint64 *state, Sint32 n); 4417 4418/** 4419 * Generate a uniform pseudo-random floating point number less than 1.0 4420 * 4421 * There are no guarantees as to the quality of the random sequence produced, 4422 * and this should not be used for security (cryptography, passwords) or where 4423 * money is on the line (loot-boxes, casinos). There are many random number 4424 * libraries available with different characteristics and you should pick one 4425 * of those to meet any serious needs. 4426 * 4427 * \param state a pointer to the current random number state, this may not be 4428 * NULL. 4429 * \returns a random value in the range of [0.0, 1.0). 4430 * 4431 * \threadsafety This function is thread-safe, as long as the state pointer 4432 * isn't shared between threads. 4433 * 4434 * \since This function is available since SDL 3.2.0. 4435 * 4436 * \sa SDL_rand_bits_r 4437 * \sa SDL_rand_r 4438 * \sa SDL_randf 4439 */ 4440extern SDL_DECLSPEC float SDLCALL SDL_randf_r(Uint64 *state); 4441 4442/** 4443 * Generate 32 pseudo-random bits. 4444 * 4445 * You likely want to use SDL_rand_r() to get a pseudo-random number instead. 4446 * 4447 * There are no guarantees as to the quality of the random sequence produced, 4448 * and this should not be used for security (cryptography, passwords) or where 4449 * money is on the line (loot-boxes, casinos). There are many random number 4450 * libraries available with different characteristics and you should pick one 4451 * of those to meet any serious needs. 4452 * 4453 * \param state a pointer to the current random number state, this may not be 4454 * NULL. 4455 * \returns a random value in the range of [0-SDL_MAX_UINT32]. 4456 * 4457 * \threadsafety This function is thread-safe, as long as the state pointer 4458 * isn't shared between threads. 4459 * 4460 * \since This function is available since SDL 3.2.0. 4461 * 4462 * \sa SDL_rand_r 4463 * \sa SDL_randf_r 4464 */ 4465extern SDL_DECLSPEC Uint32 SDLCALL SDL_rand_bits_r(Uint64 *state); 4466 4467#ifndef SDL_PI_D 4468 4469/** 4470 * The value of Pi, as a double-precision floating point literal. 4471 * 4472 * \since This macro is available since SDL 3.2.0. 4473 * 4474 * \sa SDL_PI_F 4475 */ 4476#define SDL_PI_D 3.141592653589793238462643383279502884 /**< pi (double) */ 4477#endif 4478 4479#ifndef SDL_PI_F 4480 4481/** 4482 * The value of Pi, as a single-precision floating point literal. 4483 * 4484 * \since This macro is available since SDL 3.2.0. 4485 * 4486 * \sa SDL_PI_D 4487 */ 4488#define SDL_PI_F 3.141592653589793238462643383279502884F /**< pi (float) */ 4489#endif 4490 4491/** 4492 * Compute the arc cosine of `x`. 4493 * 4494 * The definition of `y = acos(x)` is `x = cos(y)`. 4495 * 4496 * Domain: `-1 <= x <= 1` 4497 * 4498 * Range: `0 <= y <= Pi` 4499 * 4500 * This function operates on double-precision floating point values, use 4501 * SDL_acosf for single-precision floats. 4502 * 4503 * This function may use a different approximation across different versions, 4504 * platforms and configurations. i.e, it can return a different value given 4505 * the same input on different machines or operating systems, or if SDL is 4506 * updated. 4507 * 4508 * \param x floating point value. 4509 * \returns arc cosine of `x`, in radians. 4510 * 4511 * \threadsafety It is safe to call this function from any thread. 4512 * 4513 * \since This function is available since SDL 3.2.0. 4514 * 4515 * \sa SDL_acosf 4516 * \sa SDL_asin 4517 * \sa SDL_cos 4518 */ 4519extern SDL_DECLSPEC double SDLCALL SDL_acos(double x); 4520 4521/** 4522 * Compute the arc cosine of `x`. 4523 * 4524 * The definition of `y = acos(x)` is `x = cos(y)`. 4525 * 4526 * Domain: `-1 <= x <= 1` 4527 * 4528 * Range: `0 <= y <= Pi` 4529 * 4530 * This function operates on single-precision floating point values, use 4531 * SDL_acos for double-precision floats. 4532 * 4533 * This function may use a different approximation across different versions, 4534 * platforms and configurations. i.e, it can return a different value given 4535 * the same input on different machines or operating systems, or if SDL is 4536 * updated. 4537 * 4538 * \param x floating point value. 4539 * \returns arc cosine of `x`, in radians. 4540 * 4541 * \threadsafety It is safe to call this function from any thread. 4542 * 4543 * \since This function is available since SDL 3.2.0. 4544 * 4545 * \sa SDL_acos 4546 * \sa SDL_asinf 4547 * \sa SDL_cosf 4548 */ 4549extern SDL_DECLSPEC float SDLCALL SDL_acosf(float x); 4550 4551/** 4552 * Compute the arc sine of `x`. 4553 * 4554 * The definition of `y = asin(x)` is `x = sin(y)`. 4555 * 4556 * Domain: `-1 <= x <= 1` 4557 * 4558 * Range: `-Pi/2 <= y <= Pi/2` 4559 * 4560 * This function operates on double-precision floating point values, use 4561 * SDL_asinf for single-precision floats. 4562 * 4563 * This function may use a different approximation across different versions, 4564 * platforms and configurations. i.e, it can return a different value given 4565 * the same input on different machines or operating systems, or if SDL is 4566 * updated. 4567 * 4568 * \param x floating point value. 4569 * \returns arc sine of `x`, in radians. 4570 * 4571 * \threadsafety It is safe to call this function from any thread. 4572 * 4573 * \since This function is available since SDL 3.2.0. 4574 * 4575 * \sa SDL_asinf 4576 * \sa SDL_acos 4577 * \sa SDL_sin 4578 */ 4579extern SDL_DECLSPEC double SDLCALL SDL_asin(double x); 4580 4581/** 4582 * Compute the arc sine of `x`. 4583 * 4584 * The definition of `y = asin(x)` is `x = sin(y)`. 4585 * 4586 * Domain: `-1 <= x <= 1` 4587 * 4588 * Range: `-Pi/2 <= y <= Pi/2` 4589 * 4590 * This function operates on single-precision floating point values, use 4591 * SDL_asin for double-precision floats. 4592 * 4593 * This function may use a different approximation across different versions, 4594 * platforms and configurations. i.e, it can return a different value given 4595 * the same input on different machines or operating systems, or if SDL is 4596 * updated. 4597 * 4598 * \param x floating point value. 4599 * \returns arc sine of `x`, in radians. 4600 * 4601 * \threadsafety It is safe to call this function from any thread. 4602 * 4603 * \since This function is available since SDL 3.2.0. 4604 * 4605 * \sa SDL_asin 4606 * \sa SDL_acosf 4607 * \sa SDL_sinf 4608 */ 4609extern SDL_DECLSPEC float SDLCALL SDL_asinf(float x); 4610 4611/** 4612 * Compute the arc tangent of `x`. 4613 * 4614 * The definition of `y = atan(x)` is `x = tan(y)`. 4615 * 4616 * Domain: `-INF <= x <= INF` 4617 * 4618 * Range: `-Pi/2 <= y <= Pi/2` 4619 * 4620 * This function operates on double-precision floating point values, use 4621 * SDL_atanf for single-precision floats. 4622 * 4623 * To calculate the arc tangent of y / x, use SDL_atan2. 4624 * 4625 * This function may use a different approximation across different versions, 4626 * platforms and configurations. i.e, it can return a different value given 4627 * the same input on different machines or operating systems, or if SDL is 4628 * updated. 4629 * 4630 * \param x floating point value. 4631 * \returns arc tangent of of `x` in radians, or 0 if `x = 0`. 4632 * 4633 * \threadsafety It is safe to call this function from any thread. 4634 * 4635 * \since This function is available since SDL 3.2.0. 4636 * 4637 * \sa SDL_atanf 4638 * \sa SDL_atan2 4639 * \sa SDL_tan 4640 */ 4641extern SDL_DECLSPEC double SDLCALL SDL_atan(double x); 4642 4643/** 4644 * Compute the arc tangent of `x`. 4645 * 4646 * The definition of `y = atan(x)` is `x = tan(y)`. 4647 * 4648 * Domain: `-INF <= x <= INF` 4649 * 4650 * Range: `-Pi/2 <= y <= Pi/2` 4651 * 4652 * This function operates on single-precision floating point values, use 4653 * SDL_atan for dboule-precision floats. 4654 * 4655 * To calculate the arc tangent of y / x, use SDL_atan2f. 4656 * 4657 * This function may use a different approximation across different versions, 4658 * platforms and configurations. i.e, it can return a different value given 4659 * the same input on different machines or operating systems, or if SDL is 4660 * updated. 4661 * 4662 * \param x floating point value. 4663 * \returns arc tangent of of `x` in radians, or 0 if `x = 0`. 4664 * 4665 * \threadsafety It is safe to call this function from any thread. 4666 * 4667 * \since This function is available since SDL 3.2.0. 4668 * 4669 * \sa SDL_atan 4670 * \sa SDL_atan2f 4671 * \sa SDL_tanf 4672 */ 4673extern SDL_DECLSPEC float SDLCALL SDL_atanf(float x); 4674 4675/** 4676 * Compute the arc tangent of `y / x`, using the signs of x and y to adjust 4677 * the result's quadrant. 4678 * 4679 * The definition of `z = atan2(x, y)` is `y = x tan(z)`, where the quadrant 4680 * of z is determined based on the signs of x and y. 4681 * 4682 * Domain: `-INF <= x <= INF`, `-INF <= y <= INF` 4683 * 4684 * Range: `-Pi <= z <= Pi` 4685 * 4686 * This function operates on double-precision floating point values, use 4687 * SDL_atan2f for single-precision floats. 4688 * 4689 * To calculate the arc tangent of a single value, use SDL_atan. 4690 * 4691 * This function may use a different approximation across different versions, 4692 * platforms and configurations. i.e, it can return a different value given 4693 * the same input on different machines or operating systems, or if SDL is 4694 * updated. 4695 * 4696 * \param y floating point value of the numerator (y coordinate). 4697 * \param x floating point value of the denominator (x coordinate). 4698 * \returns arc tangent of `y / x` in radians, or, if `x = 0`, either `-Pi/2`, 4699 * `0`, or `Pi/2`, depending on the value of `y`. 4700 * 4701 * \threadsafety It is safe to call this function from any thread. 4702 * 4703 * \since This function is available since SDL 3.2.0. 4704 * 4705 * \sa SDL_atan2f 4706 * \sa SDL_atan 4707 * \sa SDL_tan 4708 */ 4709extern SDL_DECLSPEC double SDLCALL SDL_atan2(double y, double x); 4710 4711/** 4712 * Compute the arc tangent of `y / x`, using the signs of x and y to adjust 4713 * the result's quadrant. 4714 * 4715 * The definition of `z = atan2(x, y)` is `y = x tan(z)`, where the quadrant 4716 * of z is determined based on the signs of x and y. 4717 * 4718 * Domain: `-INF <= x <= INF`, `-INF <= y <= INF` 4719 * 4720 * Range: `-Pi <= y <= Pi` 4721 * 4722 * This function operates on single-precision floating point values, use 4723 * SDL_atan2 for double-precision floats. 4724 * 4725 * To calculate the arc tangent of a single value, use SDL_atanf. 4726 * 4727 * This function may use a different approximation across different versions, 4728 * platforms and configurations. i.e, it can return a different value given 4729 * the same input on different machines or operating systems, or if SDL is 4730 * updated. 4731 * 4732 * \param y floating point value of the numerator (y coordinate). 4733 * \param x floating point value of the denominator (x coordinate). 4734 * \returns arc tangent of of `y / x` in radians, or, if `x = 0`, either 4735 * `-Pi/2`, `0`, or `Pi/2`, depending on the value of `y`. 4736 * 4737 * \threadsafety It is safe to call this function from any thread. 4738 * 4739 * \since This function is available since SDL 3.2.0. 4740 * 4741 * \sa SDL_atan2 4742 * \sa SDL_atan 4743 * \sa SDL_tan 4744 */ 4745extern SDL_DECLSPEC float SDLCALL SDL_atan2f(float y, float x); 4746 4747/** 4748 * Compute the ceiling of `x`. 4749 * 4750 * The ceiling of `x` is the smallest integer `y` such that `y >= x`, i.e `x` 4751 * rounded up to the nearest integer. 4752 * 4753 * Domain: `-INF <= x <= INF` 4754 * 4755 * Range: `-INF <= y <= INF`, y integer 4756 * 4757 * This function operates on double-precision floating point values, use 4758 * SDL_ceilf for single-precision floats. 4759 * 4760 * \param x floating point value. 4761 * \returns the ceiling of `x`. 4762 * 4763 * \threadsafety It is safe to call this function from any thread. 4764 * 4765 * \since This function is available since SDL 3.2.0. 4766 * 4767 * \sa SDL_ceilf 4768 * \sa SDL_floor 4769 * \sa SDL_trunc 4770 * \sa SDL_round 4771 * \sa SDL_lround 4772 */ 4773extern SDL_DECLSPEC double SDLCALL SDL_ceil(double x); 4774 4775/** 4776 * Compute the ceiling of `x`. 4777 * 4778 * The ceiling of `x` is the smallest integer `y` such that `y >= x`, i.e `x` 4779 * rounded up to the nearest integer. 4780 * 4781 * Domain: `-INF <= x <= INF` 4782 * 4783 * Range: `-INF <= y <= INF`, y integer 4784 * 4785 * This function operates on single-precision floating point values, use 4786 * SDL_ceil for double-precision floats. 4787 * 4788 * \param x floating point value. 4789 * \returns the ceiling of `x`. 4790 * 4791 * \threadsafety It is safe to call this function from any thread. 4792 * 4793 * \since This function is available since SDL 3.2.0. 4794 * 4795 * \sa SDL_ceil 4796 * \sa SDL_floorf 4797 * \sa SDL_truncf 4798 * \sa SDL_roundf 4799 * \sa SDL_lroundf 4800 */ 4801extern SDL_DECLSPEC float SDLCALL SDL_ceilf(float x); 4802 4803/** 4804 * Copy the sign of one floating-point value to another. 4805 * 4806 * The definition of copysign is that ``copysign(x, y) = abs(x) * sign(y)``. 4807 * 4808 * Domain: `-INF <= x <= INF`, ``-INF <= y <= f`` 4809 * 4810 * Range: `-INF <= z <= INF` 4811 * 4812 * This function operates on double-precision floating point values, use 4813 * SDL_copysignf for single-precision floats. 4814 * 4815 * \param x floating point value to use as the magnitude. 4816 * \param y floating point value to use as the sign. 4817 * \returns the floating point value with the sign of y and the magnitude of 4818 * x. 4819 * 4820 * \threadsafety It is safe to call this function from any thread. 4821 * 4822 * \since This function is available since SDL 3.2.0. 4823 * 4824 * \sa SDL_copysignf 4825 * \sa SDL_fabs 4826 */ 4827extern SDL_DECLSPEC double SDLCALL SDL_copysign(double x, double y); 4828 4829/** 4830 * Copy the sign of one floating-point value to another. 4831 * 4832 * The definition of copysign is that ``copysign(x, y) = abs(x) * sign(y)``. 4833 * 4834 * Domain: `-INF <= x <= INF`, ``-INF <= y <= f`` 4835 * 4836 * Range: `-INF <= z <= INF` 4837 * 4838 * This function operates on single-precision floating point values, use 4839 * SDL_copysign for double-precision floats. 4840 * 4841 * \param x floating point value to use as the magnitude. 4842 * \param y floating point value to use as the sign. 4843 * \returns the floating point value with the sign of y and the magnitude of 4844 * x. 4845 * 4846 * \threadsafety It is safe to call this function from any thread. 4847 * 4848 * \since This function is available since SDL 3.2.0. 4849 * 4850 * \sa SDL_copysign 4851 * \sa SDL_fabsf 4852 */ 4853extern SDL_DECLSPEC float SDLCALL SDL_copysignf(float x, float y); 4854 4855/** 4856 * Compute the cosine of `x`. 4857 * 4858 * Domain: `-INF <= x <= INF` 4859 * 4860 * Range: `-1 <= y <= 1` 4861 * 4862 * This function operates on double-precision floating point values, use 4863 * SDL_cosf for single-precision floats. 4864 * 4865 * This function may use a different approximation across different versions, 4866 * platforms and configurations. i.e, it can return a different value given 4867 * the same input on different machines or operating systems, or if SDL is 4868 * updated. 4869 * 4870 * \param x floating point value, in radians. 4871 * \returns cosine of `x`. 4872 * 4873 * \threadsafety It is safe to call this function from any thread. 4874 * 4875 * \since This function is available since SDL 3.2.0. 4876 * 4877 * \sa SDL_cosf 4878 * \sa SDL_acos 4879 * \sa SDL_sin 4880 */ 4881extern SDL_DECLSPEC double SDLCALL SDL_cos(double x); 4882 4883/** 4884 * Compute the cosine of `x`. 4885 * 4886 * Domain: `-INF <= x <= INF` 4887 * 4888 * Range: `-1 <= y <= 1` 4889 * 4890 * This function operates on single-precision floating point values, use 4891 * SDL_cos for double-precision floats. 4892 * 4893 * This function may use a different approximation across different versions, 4894 * platforms and configurations. i.e, it can return a different value given 4895 * the same input on different machines or operating systems, or if SDL is 4896 * updated. 4897 * 4898 * \param x floating point value, in radians. 4899 * \returns cosine of `x`. 4900 * 4901 * \threadsafety It is safe to call this function from any thread. 4902 * 4903 * \since This function is available since SDL 3.2.0. 4904 * 4905 * \sa SDL_cos 4906 * \sa SDL_acosf 4907 * \sa SDL_sinf 4908 */ 4909extern SDL_DECLSPEC float SDLCALL SDL_cosf(float x); 4910 4911/** 4912 * Compute the exponential of `x`. 4913 * 4914 * The definition of `y = exp(x)` is `y = e^x`, where `e` is the base of the 4915 * natural logarithm. The inverse is the natural logarithm, SDL_log. 4916 * 4917 * Domain: `-INF <= x <= INF` 4918 * 4919 * Range: `0 <= y <= INF` 4920 * 4921 * The output will overflow if `exp(x)` is too large to be represented. 4922 * 4923 * This function operates on double-precision floating point values, use 4924 * SDL_expf for single-precision floats. 4925 * 4926 * This function may use a different approximation across different versions, 4927 * platforms and configurations. i.e, it can return a different value given 4928 * the same input on different machines or operating systems, or if SDL is 4929 * updated. 4930 * 4931 * \param x floating point value. 4932 * \returns value of `e^x`. 4933 * 4934 * \threadsafety It is safe to call this function from any thread. 4935 * 4936 * \since This function is available since SDL 3.2.0. 4937 * 4938 * \sa SDL_expf 4939 * \sa SDL_log 4940 */ 4941extern SDL_DECLSPEC double SDLCALL SDL_exp(double x); 4942 4943/** 4944 * Compute the exponential of `x`. 4945 * 4946 * The definition of `y = exp(x)` is `y = e^x`, where `e` is the base of the 4947 * natural logarithm. The inverse is the natural logarithm, SDL_logf. 4948 * 4949 * Domain: `-INF <= x <= INF` 4950 * 4951 * Range: `0 <= y <= INF` 4952 * 4953 * The output will overflow if `exp(x)` is too large to be represented. 4954 * 4955 * This function operates on single-precision floating point values, use 4956 * SDL_exp for double-precision floats. 4957 * 4958 * This function may use a different approximation across different versions, 4959 * platforms and configurations. i.e, it can return a different value given 4960 * the same input on different machines or operating systems, or if SDL is 4961 * updated. 4962 * 4963 * \param x floating point value. 4964 * \returns value of `e^x`. 4965 * 4966 * \threadsafety It is safe to call this function from any thread. 4967 * 4968 * \since This function is available since SDL 3.2.0. 4969 * 4970 * \sa SDL_exp 4971 * \sa SDL_logf 4972 */ 4973extern SDL_DECLSPEC float SDLCALL SDL_expf(float x); 4974 4975/** 4976 * Compute the absolute value of `x` 4977 * 4978 * Domain: `-INF <= x <= INF` 4979 * 4980 * Range: `0 <= y <= INF` 4981 * 4982 * This function operates on double-precision floating point values, use 4983 * SDL_fabsf for single-precision floats. 4984 * 4985 * \param x floating point value to use as the magnitude. 4986 * \returns the absolute value of `x`. 4987 * 4988 * \threadsafety It is safe to call this function from any thread. 4989 * 4990 * \since This function is available since SDL 3.2.0. 4991 * 4992 * \sa SDL_fabsf 4993 */ 4994extern SDL_DECLSPEC double SDLCALL SDL_fabs(double x); 4995 4996/** 4997 * Compute the absolute value of `x` 4998 * 4999 * Domain: `-INF <= x <= INF` 5000 * 5001 * Range: `0 <= y <= INF` 5002 * 5003 * This function operates on single-precision floating point values, use 5004 * SDL_fabs for double-precision floats. 5005 * 5006 * \param x floating point value to use as the magnitude. 5007 * \returns the absolute value of `x`. 5008 * 5009 * \threadsafety It is safe to call this function from any thread. 5010 * 5011 * \since This function is available since SDL 3.2.0. 5012 * 5013 * \sa SDL_fabs 5014 */ 5015extern SDL_DECLSPEC float SDLCALL SDL_fabsf(float x); 5016 5017/** 5018 * Compute the floor of `x`. 5019 * 5020 * The floor of `x` is the largest integer `y` such that `y <= x`, i.e `x` 5021 * rounded down to the nearest integer. 5022 * 5023 * Domain: `-INF <= x <= INF` 5024 * 5025 * Range: `-INF <= y <= INF`, y integer 5026 * 5027 * This function operates on double-precision floating point values, use 5028 * SDL_floorf for single-precision floats. 5029 * 5030 * \param x floating point value. 5031 * \returns the floor of `x`. 5032 * 5033 * \threadsafety It is safe to call this function from any thread. 5034 * 5035 * \since This function is available since SDL 3.2.0. 5036 * 5037 * \sa SDL_floorf 5038 * \sa SDL_ceil 5039 * \sa SDL_trunc 5040 * \sa SDL_round 5041 * \sa SDL_lround 5042 */ 5043extern SDL_DECLSPEC double SDLCALL SDL_floor(double x); 5044 5045/** 5046 * Compute the floor of `x`. 5047 * 5048 * The floor of `x` is the largest integer `y` such that `y <= x`, i.e `x` 5049 * rounded down to the nearest integer. 5050 * 5051 * Domain: `-INF <= x <= INF` 5052 * 5053 * Range: `-INF <= y <= INF`, y integer 5054 * 5055 * This function operates on single-precision floating point values, use 5056 * SDL_floor for double-precision floats. 5057 * 5058 * \param x floating point value. 5059 * \returns the floor of `x`. 5060 * 5061 * \threadsafety It is safe to call this function from any thread. 5062 * 5063 * \since This function is available since SDL 3.2.0. 5064 * 5065 * \sa SDL_floor 5066 * \sa SDL_ceilf 5067 * \sa SDL_truncf 5068 * \sa SDL_roundf 5069 * \sa SDL_lroundf 5070 */ 5071extern SDL_DECLSPEC float SDLCALL SDL_floorf(float x); 5072 5073/** 5074 * Truncate `x` to an integer. 5075 * 5076 * Rounds `x` to the next closest integer to 0. This is equivalent to removing 5077 * the fractional part of `x`, leaving only the integer part. 5078 * 5079 * Domain: `-INF <= x <= INF` 5080 * 5081 * Range: `-INF <= y <= INF`, y integer 5082 * 5083 * This function operates on double-precision floating point values, use 5084 * SDL_truncf for single-precision floats. 5085 * 5086 * \param x floating point value. 5087 * \returns `x` truncated to an integer. 5088 * 5089 * \threadsafety It is safe to call this function from any thread. 5090 * 5091 * \since This function is available since SDL 3.2.0. 5092 * 5093 * \sa SDL_truncf 5094 * \sa SDL_fmod 5095 * \sa SDL_ceil 5096 * \sa SDL_floor 5097 * \sa SDL_round 5098 * \sa SDL_lround 5099 */ 5100extern SDL_DECLSPEC double SDLCALL SDL_trunc(double x); 5101 5102/** 5103 * Truncate `x` to an integer. 5104 * 5105 * Rounds `x` to the next closest integer to 0. This is equivalent to removing 5106 * the fractional part of `x`, leaving only the integer part. 5107 * 5108 * Domain: `-INF <= x <= INF` 5109 * 5110 * Range: `-INF <= y <= INF`, y integer 5111 * 5112 * This function operates on single-precision floating point values, use 5113 * SDL_trunc for double-precision floats. 5114 * 5115 * \param x floating point value. 5116 * \returns `x` truncated to an integer. 5117 * 5118 * \threadsafety It is safe to call this function from any thread. 5119 * 5120 * \since This function is available since SDL 3.2.0. 5121 * 5122 * \sa SDL_trunc 5123 * \sa SDL_fmodf 5124 * \sa SDL_ceilf 5125 * \sa SDL_floorf 5126 * \sa SDL_roundf 5127 * \sa SDL_lroundf 5128 */ 5129extern SDL_DECLSPEC float SDLCALL SDL_truncf(float x); 5130 5131/** 5132 * Return the floating-point remainder of `x / y` 5133 * 5134 * Divides `x` by `y`, and returns the remainder. 5135 * 5136 * Domain: `-INF <= x <= INF`, `-INF <= y <= INF`, `y != 0` 5137 * 5138 * Range: `-y <= z <= y` 5139 * 5140 * This function operates on double-precision floating point values, use 5141 * SDL_fmodf for single-precision floats. 5142 * 5143 * \param x the numerator. 5144 * \param y the denominator. Must not be 0. 5145 * \returns the remainder of `x / y`. 5146 * 5147 * \threadsafety It is safe to call this function from any thread. 5148 * 5149 * \since This function is available since SDL 3.2.0. 5150 * 5151 * \sa SDL_fmodf 5152 * \sa SDL_modf 5153 * \sa SDL_trunc 5154 * \sa SDL_ceil 5155 * \sa SDL_floor 5156 * \sa SDL_round 5157 * \sa SDL_lround 5158 */ 5159extern SDL_DECLSPEC double SDLCALL SDL_fmod(double x, double y); 5160 5161/** 5162 * Return the floating-point remainder of `x / y` 5163 * 5164 * Divides `x` by `y`, and returns the remainder. 5165 * 5166 * Domain: `-INF <= x <= INF`, `-INF <= y <= INF`, `y != 0` 5167 * 5168 * Range: `-y <= z <= y` 5169 * 5170 * This function operates on single-precision floating point values, use 5171 * SDL_fmod for double-precision floats. 5172 * 5173 * \param x the numerator. 5174 * \param y the denominator. Must not be 0. 5175 * \returns the remainder of `x / y`. 5176 * 5177 * \threadsafety It is safe to call this function from any thread. 5178 * 5179 * \since This function is available since SDL 3.2.0. 5180 * 5181 * \sa SDL_fmod 5182 * \sa SDL_truncf 5183 * \sa SDL_modff 5184 * \sa SDL_ceilf 5185 * \sa SDL_floorf 5186 * \sa SDL_roundf 5187 * \sa SDL_lroundf 5188 */ 5189extern SDL_DECLSPEC float SDLCALL SDL_fmodf(float x, float y); 5190 5191/** 5192 * Return whether the value is infinity. 5193 * 5194 * \param x double-precision floating point value. 5195 * \returns non-zero if the value is infinity, 0 otherwise. 5196 * 5197 * \threadsafety It is safe to call this function from any thread. 5198 * 5199 * \since This function is available since SDL 3.2.0. 5200 * 5201 * \sa SDL_isinff 5202 */ 5203extern SDL_DECLSPEC int SDLCALL SDL_isinf(double x); 5204 5205/** 5206 * Return whether the value is infinity. 5207 * 5208 * \param x floating point value. 5209 * \returns non-zero if the value is infinity, 0 otherwise. 5210 * 5211 * \threadsafety It is safe to call this function from any thread. 5212 * 5213 * \since This function is available since SDL 3.2.0. 5214 * 5215 * \sa SDL_isinf 5216 */ 5217extern SDL_DECLSPEC int SDLCALL SDL_isinff(float x); 5218 5219/** 5220 * Return whether the value is NaN. 5221 * 5222 * \param x double-precision floating point value. 5223 * \returns non-zero if the value is NaN, 0 otherwise. 5224 * 5225 * \threadsafety It is safe to call this function from any thread. 5226 * 5227 * \since This function is available since SDL 3.2.0. 5228 * 5229 * \sa SDL_isnanf 5230 */ 5231extern SDL_DECLSPEC int SDLCALL SDL_isnan(double x); 5232 5233/** 5234 * Return whether the value is NaN. 5235 * 5236 * \param x floating point value. 5237 * \returns non-zero if the value is NaN, 0 otherwise. 5238 * 5239 * \threadsafety It is safe to call this function from any thread. 5240 * 5241 * \since This function is available since SDL 3.2.0. 5242 * 5243 * \sa SDL_isnan 5244 */ 5245extern SDL_DECLSPEC int SDLCALL SDL_isnanf(float x); 5246 5247/** 5248 * Compute the natural logarithm of `x`. 5249 * 5250 * Domain: `0 < x <= INF` 5251 * 5252 * Range: `-INF <= y <= INF` 5253 * 5254 * It is an error for `x` to be less than or equal to 0. 5255 * 5256 * This function operates on double-precision floating point values, use 5257 * SDL_logf for single-precision floats. 5258 * 5259 * This function may use a different approximation across different versions, 5260 * platforms and configurations. i.e, it can return a different value given 5261 * the same input on different machines or operating systems, or if SDL is 5262 * updated. 5263 * 5264 * \param x floating point value. Must be greater than 0. 5265 * \returns the natural logarithm of `x`. 5266 * 5267 * \threadsafety It is safe to call this function from any thread. 5268 * 5269 * \since This function is available since SDL 3.2.0. 5270 * 5271 * \sa SDL_logf 5272 * \sa SDL_log10 5273 * \sa SDL_exp 5274 */ 5275extern SDL_DECLSPEC double SDLCALL SDL_log(double x); 5276 5277/** 5278 * Compute the natural logarithm of `x`. 5279 * 5280 * Domain: `0 < x <= INF` 5281 * 5282 * Range: `-INF <= y <= INF` 5283 * 5284 * It is an error for `x` to be less than or equal to 0. 5285 * 5286 * This function operates on single-precision floating point values, use 5287 * SDL_log for double-precision floats. 5288 * 5289 * This function may use a different approximation across different versions, 5290 * platforms and configurations. i.e, it can return a different value given 5291 * the same input on different machines or operating systems, or if SDL is 5292 * updated. 5293 * 5294 * \param x floating point value. Must be greater than 0. 5295 * \returns the natural logarithm of `x`. 5296 * 5297 * \threadsafety It is safe to call this function from any thread. 5298 * 5299 * \since This function is available since SDL 3.2.0. 5300 * 5301 * \sa SDL_log 5302 * \sa SDL_expf 5303 */ 5304extern SDL_DECLSPEC float SDLCALL SDL_logf(float x); 5305 5306/** 5307 * Compute the base-10 logarithm of `x`. 5308 * 5309 * Domain: `0 < x <= INF` 5310 * 5311 * Range: `-INF <= y <= INF` 5312 * 5313 * It is an error for `x` to be less than or equal to 0. 5314 * 5315 * This function operates on double-precision floating point values, use 5316 * SDL_log10f for single-precision floats. 5317 * 5318 * This function may use a different approximation across different versions, 5319 * platforms and configurations. i.e, it can return a different value given 5320 * the same input on different machines or operating systems, or if SDL is 5321 * updated. 5322 * 5323 * \param x floating point value. Must be greater than 0. 5324 * \returns the logarithm of `x`. 5325 * 5326 * \threadsafety It is safe to call this function from any thread. 5327 * 5328 * \since This function is available since SDL 3.2.0. 5329 * 5330 * \sa SDL_log10f 5331 * \sa SDL_log 5332 * \sa SDL_pow 5333 */ 5334extern SDL_DECLSPEC double SDLCALL SDL_log10(double x); 5335 5336/** 5337 * Compute the base-10 logarithm of `x`. 5338 * 5339 * Domain: `0 < x <= INF` 5340 * 5341 * Range: `-INF <= y <= INF` 5342 * 5343 * It is an error for `x` to be less than or equal to 0. 5344 * 5345 * This function operates on single-precision floating point values, use 5346 * SDL_log10 for double-precision floats. 5347 * 5348 * This function may use a different approximation across different versions, 5349 * platforms and configurations. i.e, it can return a different value given 5350 * the same input on different machines or operating systems, or if SDL is 5351 * updated. 5352 * 5353 * \param x floating point value. Must be greater than 0. 5354 * \returns the logarithm of `x`. 5355 * 5356 * \threadsafety It is safe to call this function from any thread. 5357 * 5358 * \since This function is available since SDL 3.2.0. 5359 * 5360 * \sa SDL_log10 5361 * \sa SDL_logf 5362 * \sa SDL_powf 5363 */ 5364extern SDL_DECLSPEC float SDLCALL SDL_log10f(float x); 5365 5366/** 5367 * Split `x` into integer and fractional parts 5368 * 5369 * This function operates on double-precision floating point values, use 5370 * SDL_modff for single-precision floats. 5371 * 5372 * \param x floating point value. 5373 * \param y output pointer to store the integer part of `x`. 5374 * \returns the fractional part of `x`. 5375 * 5376 * \threadsafety It is safe to call this function from any thread. 5377 * 5378 * \since This function is available since SDL 3.2.0. 5379 * 5380 * \sa SDL_modff 5381 * \sa SDL_trunc 5382 * \sa SDL_fmod 5383 */ 5384extern SDL_DECLSPEC double SDLCALL SDL_modf(double x, double *y); 5385 5386/** 5387 * Split `x` into integer and fractional parts 5388 * 5389 * This function operates on single-precision floating point values, use 5390 * SDL_modf for double-precision floats. 5391 * 5392 * \param x floating point value. 5393 * \param y output pointer to store the integer part of `x`. 5394 * \returns the fractional part of `x`. 5395 * 5396 * \threadsafety It is safe to call this function from any thread. 5397 * 5398 * \since This function is available since SDL 3.2.0. 5399 * 5400 * \sa SDL_modf 5401 * \sa SDL_truncf 5402 * \sa SDL_fmodf 5403 */ 5404extern SDL_DECLSPEC float SDLCALL SDL_modff(float x, float *y); 5405 5406/** 5407 * Raise `x` to the power `y` 5408 * 5409 * Domain: `-INF <= x <= INF`, `-INF <= y <= INF` 5410 * 5411 * Range: `-INF <= z <= INF` 5412 * 5413 * If `y` is the base of the natural logarithm (e), consider using SDL_exp 5414 * instead. 5415 * 5416 * This function operates on double-precision floating point values, use 5417 * SDL_powf for single-precision floats. 5418 * 5419 * This function may use a different approximation across different versions, 5420 * platforms and configurations. i.e, it can return a different value given 5421 * the same input on different machines or operating systems, or if SDL is 5422 * updated. 5423 * 5424 * \param x the base. 5425 * \param y the exponent. 5426 * \returns `x` raised to the power `y`. 5427 * 5428 * \threadsafety It is safe to call this function from any thread. 5429 * 5430 * \since This function is available since SDL 3.2.0. 5431 * 5432 * \sa SDL_powf 5433 * \sa SDL_exp 5434 * \sa SDL_log 5435 */ 5436extern SDL_DECLSPEC double SDLCALL SDL_pow(double x, double y); 5437 5438/** 5439 * Raise `x` to the power `y` 5440 * 5441 * Domain: `-INF <= x <= INF`, `-INF <= y <= INF` 5442 * 5443 * Range: `-INF <= z <= INF` 5444 * 5445 * If `y` is the base of the natural logarithm (e), consider using SDL_exp 5446 * instead. 5447 * 5448 * This function operates on single-precision floating point values, use 5449 * SDL_pow for double-precision floats. 5450 * 5451 * This function may use a different approximation across different versions, 5452 * platforms and configurations. i.e, it can return a different value given 5453 * the same input on different machines or operating systems, or if SDL is 5454 * updated. 5455 * 5456 * \param x the base. 5457 * \param y the exponent. 5458 * \returns `x` raised to the power `y`. 5459 * 5460 * \threadsafety It is safe to call this function from any thread. 5461 * 5462 * \since This function is available since SDL 3.2.0. 5463 * 5464 * \sa SDL_pow 5465 * \sa SDL_expf 5466 * \sa SDL_logf 5467 */ 5468extern SDL_DECLSPEC float SDLCALL SDL_powf(float x, float y); 5469 5470/** 5471 * Round `x` to the nearest integer. 5472 * 5473 * Rounds `x` to the nearest integer. Values halfway between integers will be 5474 * rounded away from zero. 5475 * 5476 * Domain: `-INF <= x <= INF` 5477 * 5478 * Range: `-INF <= y <= INF`, y integer 5479 * 5480 * This function operates on double-precision floating point values, use 5481 * SDL_roundf for single-precision floats. To get the result as an integer 5482 * type, use SDL_lround. 5483 * 5484 * \param x floating point value. 5485 * \returns the nearest integer to `x`. 5486 * 5487 * \threadsafety It is safe to call this function from any thread. 5488 * 5489 * \since This function is available since SDL 3.2.0. 5490 * 5491 * \sa SDL_roundf 5492 * \sa SDL_lround 5493 * \sa SDL_floor 5494 * \sa SDL_ceil 5495 * \sa SDL_trunc 5496 */ 5497extern SDL_DECLSPEC double SDLCALL SDL_round(double x); 5498 5499/** 5500 * Round `x` to the nearest integer. 5501 * 5502 * Rounds `x` to the nearest integer. Values halfway between integers will be 5503 * rounded away from zero. 5504 * 5505 * Domain: `-INF <= x <= INF` 5506 * 5507 * Range: `-INF <= y <= INF`, y integer 5508 * 5509 * This function operates on single-precision floating point values, use 5510 * SDL_round for double-precision floats. To get the result as an integer 5511 * type, use SDL_lroundf. 5512 * 5513 * \param x floating point value. 5514 * \returns the nearest integer to `x`. 5515 * 5516 * \threadsafety It is safe to call this function from any thread. 5517 * 5518 * \since This function is available since SDL 3.2.0. 5519 * 5520 * \sa SDL_round 5521 * \sa SDL_lroundf 5522 * \sa SDL_floorf 5523 * \sa SDL_ceilf 5524 * \sa SDL_truncf 5525 */ 5526extern SDL_DECLSPEC float SDLCALL SDL_roundf(float x); 5527 5528/** 5529 * Round `x` to the nearest integer representable as a long 5530 * 5531 * Rounds `x` to the nearest integer. Values halfway between integers will be 5532 * rounded away from zero. 5533 * 5534 * Domain: `-INF <= x <= INF` 5535 * 5536 * Range: `MIN_LONG <= y <= MAX_LONG` 5537 * 5538 * This function operates on double-precision floating point values, use 5539 * SDL_lroundf for single-precision floats. To get the result as a 5540 * floating-point type, use SDL_round. 5541 * 5542 * \param x floating point value. 5543 * \returns the nearest integer to `x`. 5544 * 5545 * \threadsafety It is safe to call this function from any thread. 5546 * 5547 * \since This function is available since SDL 3.2.0. 5548 * 5549 * \sa SDL_lroundf 5550 * \sa SDL_round 5551 * \sa SDL_floor 5552 * \sa SDL_ceil 5553 * \sa SDL_trunc 5554 */ 5555extern SDL_DECLSPEC long SDLCALL SDL_lround(double x); 5556 5557/** 5558 * Round `x` to the nearest integer representable as a long 5559 * 5560 * Rounds `x` to the nearest integer. Values halfway between integers will be 5561 * rounded away from zero. 5562 * 5563 * Domain: `-INF <= x <= INF` 5564 * 5565 * Range: `MIN_LONG <= y <= MAX_LONG` 5566 * 5567 * This function operates on single-precision floating point values, use 5568 * SDL_lround for double-precision floats. To get the result as a 5569 * floating-point type, use SDL_roundf. 5570 * 5571 * \param x floating point value. 5572 * \returns the nearest integer to `x`. 5573 * 5574 * \threadsafety It is safe to call this function from any thread. 5575 * 5576 * \since This function is available since SDL 3.2.0. 5577 * 5578 * \sa SDL_lround 5579 * \sa SDL_roundf 5580 * \sa SDL_floorf 5581 * \sa SDL_ceilf 5582 * \sa SDL_truncf 5583 */ 5584extern SDL_DECLSPEC long SDLCALL SDL_lroundf(float x); 5585 5586/** 5587 * Scale `x` by an integer power of two. 5588 * 5589 * Multiplies `x` by the `n`th power of the floating point radix (always 2). 5590 * 5591 * Domain: `-INF <= x <= INF`, `n` integer 5592 * 5593 * Range: `-INF <= y <= INF` 5594 * 5595 * This function operates on double-precision floating point values, use 5596 * SDL_scalbnf for single-precision floats. 5597 * 5598 * \param x floating point value to be scaled. 5599 * \param n integer exponent. 5600 * \returns `x * 2^n`. 5601 * 5602 * \threadsafety It is safe to call this function from any thread. 5603 * 5604 * \since This function is available since SDL 3.2.0. 5605 * 5606 * \sa SDL_scalbnf 5607 * \sa SDL_pow 5608 */ 5609extern SDL_DECLSPEC double SDLCALL SDL_scalbn(double x, int n); 5610 5611/** 5612 * Scale `x` by an integer power of two. 5613 * 5614 * Multiplies `x` by the `n`th power of the floating point radix (always 2). 5615 * 5616 * Domain: `-INF <= x <= INF`, `n` integer 5617 * 5618 * Range: `-INF <= y <= INF` 5619 * 5620 * This function operates on single-precision floating point values, use 5621 * SDL_scalbn for double-precision floats. 5622 * 5623 * \param x floating point value to be scaled. 5624 * \param n integer exponent. 5625 * \returns `x * 2^n`. 5626 * 5627 * \threadsafety It is safe to call this function from any thread. 5628 * 5629 * \since This function is available since SDL 3.2.0. 5630 * 5631 * \sa SDL_scalbn 5632 * \sa SDL_powf 5633 */ 5634extern SDL_DECLSPEC float SDLCALL SDL_scalbnf(float x, int n); 5635 5636/** 5637 * Compute the sine of `x`. 5638 * 5639 * Domain: `-INF <= x <= INF` 5640 * 5641 * Range: `-1 <= y <= 1` 5642 * 5643 * This function operates on double-precision floating point values, use 5644 * SDL_sinf for single-precision floats. 5645 * 5646 * This function may use a different approximation across different versions, 5647 * platforms and configurations. i.e, it can return a different value given 5648 * the same input on different machines or operating systems, or if SDL is 5649 * updated. 5650 * 5651 * \param x floating point value, in radians. 5652 * \returns sine of `x`. 5653 * 5654 * \threadsafety It is safe to call this function from any thread. 5655 * 5656 * \since This function is available since SDL 3.2.0. 5657 * 5658 * \sa SDL_sinf 5659 * \sa SDL_asin 5660 * \sa SDL_cos 5661 */ 5662extern SDL_DECLSPEC double SDLCALL SDL_sin(double x); 5663 5664/** 5665 * Compute the sine of `x`. 5666 * 5667 * Domain: `-INF <= x <= INF` 5668 * 5669 * Range: `-1 <= y <= 1` 5670 * 5671 * This function operates on single-precision floating point values, use 5672 * SDL_sin for double-precision floats. 5673 * 5674 * This function may use a different approximation across different versions, 5675 * platforms and configurations. i.e, it can return a different value given 5676 * the same input on different machines or operating systems, or if SDL is 5677 * updated. 5678 * 5679 * \param x floating point value, in radians. 5680 * \returns sine of `x`. 5681 * 5682 * \threadsafety It is safe to call this function from any thread. 5683 * 5684 * \since This function is available since SDL 3.2.0. 5685 * 5686 * \sa SDL_sin 5687 * \sa SDL_asinf 5688 * \sa SDL_cosf 5689 */ 5690extern SDL_DECLSPEC float SDLCALL SDL_sinf(float x); 5691 5692/** 5693 * Compute the square root of `x`. 5694 * 5695 * Domain: `0 <= x <= INF` 5696 * 5697 * Range: `0 <= y <= INF` 5698 * 5699 * This function operates on double-precision floating point values, use 5700 * SDL_sqrtf for single-precision floats. 5701 * 5702 * This function may use a different approximation across different versions, 5703 * platforms and configurations. i.e, it can return a different value given 5704 * the same input on different machines or operating systems, or if SDL is 5705 * updated. 5706 * 5707 * \param x floating point value. Must be greater than or equal to 0. 5708 * \returns square root of `x`. 5709 * 5710 * \threadsafety It is safe to call this function from any thread. 5711 * 5712 * \since This function is available since SDL 3.2.0. 5713 * 5714 * \sa SDL_sqrtf 5715 */ 5716extern SDL_DECLSPEC double SDLCALL SDL_sqrt(double x); 5717 5718/** 5719 * Compute the square root of `x`. 5720 * 5721 * Domain: `0 <= x <= INF` 5722 * 5723 * Range: `0 <= y <= INF` 5724 * 5725 * This function operates on single-precision floating point values, use 5726 * SDL_sqrt for double-precision floats. 5727 * 5728 * This function may use a different approximation across different versions, 5729 * platforms and configurations. i.e, it can return a different value given 5730 * the same input on different machines or operating systems, or if SDL is 5731 * updated. 5732 * 5733 * \param x floating point value. Must be greater than or equal to 0. 5734 * \returns square root of `x`. 5735 * 5736 * \threadsafety It is safe to call this function from any thread. 5737 * 5738 * \since This function is available since SDL 3.2.0. 5739 * 5740 * \sa SDL_sqrt 5741 */ 5742extern SDL_DECLSPEC float SDLCALL SDL_sqrtf(float x); 5743 5744/** 5745 * Compute the tangent of `x`. 5746 * 5747 * Domain: `-INF <= x <= INF` 5748 * 5749 * Range: `-INF <= y <= INF` 5750 * 5751 * This function operates on double-precision floating point values, use 5752 * SDL_tanf for single-precision floats. 5753 * 5754 * This function may use a different approximation across different versions, 5755 * platforms and configurations. i.e, it can return a different value given 5756 * the same input on different machines or operating systems, or if SDL is 5757 * updated. 5758 * 5759 * \param x floating point value, in radians. 5760 * \returns tangent of `x`. 5761 * 5762 * \threadsafety It is safe to call this function from any thread. 5763 * 5764 * \since This function is available since SDL 3.2.0. 5765 * 5766 * \sa SDL_tanf 5767 * \sa SDL_sin 5768 * \sa SDL_cos 5769 * \sa SDL_atan 5770 * \sa SDL_atan2 5771 */ 5772extern SDL_DECLSPEC double SDLCALL SDL_tan(double x); 5773 5774/** 5775 * Compute the tangent of `x`. 5776 * 5777 * Domain: `-INF <= x <= INF` 5778 * 5779 * Range: `-INF <= y <= INF` 5780 * 5781 * This function operates on single-precision floating point values, use 5782 * SDL_tan for double-precision floats. 5783 * 5784 * This function may use a different approximation across different versions, 5785 * platforms and configurations. i.e, it can return a different value given 5786 * the same input on different machines or operating systems, or if SDL is 5787 * updated. 5788 * 5789 * \param x floating point value, in radians. 5790 * \returns tangent of `x`. 5791 * 5792 * \threadsafety It is safe to call this function from any thread. 5793 * 5794 * \since This function is available since SDL 3.2.0. 5795 * 5796 * \sa SDL_tan 5797 * \sa SDL_sinf 5798 * \sa SDL_cosf 5799 * \sa SDL_atanf 5800 * \sa SDL_atan2f 5801 */ 5802extern SDL_DECLSPEC float SDLCALL SDL_tanf(float x); 5803 5804/** 5805 * An opaque handle representing string encoding conversion state. 5806 * 5807 * \since This datatype is available since SDL 3.2.0. 5808 * 5809 * \sa SDL_iconv_open 5810 */ 5811typedef struct SDL_iconv_data_t *SDL_iconv_t; 5812 5813/** 5814 * This function allocates a context for the specified character set 5815 * conversion. 5816 * 5817 * \param tocode The target character encoding, must not be NULL. 5818 * \param fromcode The source character encoding, must not be NULL. 5819 * \returns a handle that must be freed with SDL_iconv_close, or 5820 * SDL_ICONV_ERROR on failure. 5821 * 5822 * \threadsafety It is safe to call this function from any thread. 5823 * 5824 * \since This function is available since SDL 3.2.0. 5825 * 5826 * \sa SDL_iconv 5827 * \sa SDL_iconv_close 5828 * \sa SDL_iconv_string 5829 */ 5830extern SDL_DECLSPEC SDL_iconv_t SDLCALL SDL_iconv_open(const char *tocode, 5831 const char *fromcode); 5832 5833/** 5834 * This function frees a context used for character set conversion. 5835 * 5836 * \param cd The character set conversion handle. 5837 * \returns 0 on success, or -1 on failure. 5838 * 5839 * \threadsafety It is safe to call this function from any thread. 5840 * 5841 * \since This function is available since SDL 3.2.0. 5842 * 5843 * \sa SDL_iconv 5844 * \sa SDL_iconv_open 5845 * \sa SDL_iconv_string 5846 */ 5847extern SDL_DECLSPEC int SDLCALL SDL_iconv_close(SDL_iconv_t cd); 5848 5849/** 5850 * This function converts text between encodings, reading from and writing to 5851 * a buffer. 5852 * 5853 * It returns the number of successful conversions on success. On error, 5854 * SDL_ICONV_E2BIG is returned when the output buffer is too small, or 5855 * SDL_ICONV_EILSEQ is returned when an invalid input sequence is encountered, 5856 * or SDL_ICONV_EINVAL is returned when an incomplete input sequence is 5857 * encountered. 5858 * 5859 * On exit: 5860 * 5861 * - inbuf will point to the beginning of the next multibyte sequence. On 5862 * error, this is the location of the problematic input sequence. On 5863 * success, this is the end of the input sequence. 5864 * - inbytesleft will be set to the number of bytes left to convert, which 5865 * will be 0 on success. 5866 * - outbuf will point to the location where to store the next output byte. 5867 * - outbytesleft will be set to the number of bytes left in the output 5868 * buffer. 5869 * 5870 * \param cd The character set conversion context, created in 5871 * SDL_iconv_open(). 5872 * \param inbuf Address of variable that points to the first character of the 5873 * input sequence. 5874 * \param inbytesleft The number of bytes in the input buffer. 5875 * \param outbuf Address of variable that points to the output buffer. 5876 * \param outbytesleft The number of bytes in the output buffer. 5877 * \returns the number of conversions on success, or a negative error code. 5878 * 5879 * \threadsafety Do not use the same SDL_iconv_t from two threads at once. 5880 * 5881 * \since This function is available since SDL 3.2.0. 5882 * 5883 * \sa SDL_iconv_open 5884 * \sa SDL_iconv_close 5885 * \sa SDL_iconv_string 5886 */ 5887extern SDL_DECLSPEC size_t SDLCALL SDL_iconv(SDL_iconv_t cd, const char **inbuf, 5888 size_t *inbytesleft, char **outbuf, 5889 size_t *outbytesleft); 5890 5891#define SDL_ICONV_ERROR (size_t)-1 /**< Generic error. Check SDL_GetError()? */ 5892#define SDL_ICONV_E2BIG (size_t)-2 /**< Output buffer was too small. */ 5893#define SDL_ICONV_EILSEQ (size_t)-3 /**< Invalid input sequence was encountered. */ 5894#define SDL_ICONV_EINVAL (size_t)-4 /**< Incomplete input sequence was encountered. */ 5895 5896 5897/** 5898 * Helper function to convert a string's encoding in one call. 5899 * 5900 * This function converts a buffer or string between encodings in one pass. 5901 * 5902 * The string does not need to be NULL-terminated; this function operates on 5903 * the number of bytes specified in `inbytesleft` whether there is a NULL 5904 * character anywhere in the buffer. 5905 * 5906 * The returned string is owned by the caller, and should be passed to 5907 * SDL_free when no longer needed. 5908 * 5909 * \param tocode the character encoding of the output string. Examples are 5910 * "UTF-8", "UCS-4", etc. 5911 * \param fromcode the character encoding of data in `inbuf`. 5912 * \param inbuf the string to convert to a different encoding. 5913 * \param inbytesleft the size of the input string _in bytes_. 5914 * \returns a new string, converted to the new encoding, or NULL on error. 5915 * 5916 * \threadsafety It is safe to call this function from any thread. 5917 * 5918 * \since This function is available since SDL 3.2.0. 5919 * 5920 * \sa SDL_iconv_open 5921 * \sa SDL_iconv_close 5922 * \sa SDL_iconv 5923 */ 5924extern SDL_DECLSPEC char * SDLCALL SDL_iconv_string(const char *tocode, 5925 const char *fromcode, 5926 const char *inbuf, 5927 size_t inbytesleft); 5928 5929/* Some helper macros for common SDL_iconv_string cases... */ 5930 5931/** 5932 * Convert a UTF-8 string to the current locale's character encoding. 5933 * 5934 * This is a helper macro that might be more clear than calling 5935 * SDL_iconv_string directly. However, it double-evaluates its parameter, so 5936 * do not use an expression with side-effects here. 5937 * 5938 * \param S the string to convert. 5939 * \returns a new string, converted to the new encoding, or NULL on error. 5940 * 5941 * \threadsafety It is safe to call this macro from any thread. 5942 * 5943 * \since This macro is available since SDL 3.2.0. 5944 */ 5945#define SDL_iconv_utf8_locale(S) SDL_iconv_string("", "UTF-8", S, SDL_strlen(S)+1) 5946 5947/** 5948 * Convert a UTF-8 string to UCS-2. 5949 * 5950 * This is a helper macro that might be more clear than calling 5951 * SDL_iconv_string directly. However, it double-evaluates its parameter, so 5952 * do not use an expression with side-effects here. 5953 * 5954 * \param S the string to convert. 5955 * \returns a new string, converted to the new encoding, or NULL on error. 5956 * 5957 * \threadsafety It is safe to call this macro from any thread. 5958 * 5959 * \since This macro is available since SDL 3.2.0. 5960 */ 5961#define SDL_iconv_utf8_ucs2(S) SDL_reinterpret_cast(Uint16 *, SDL_iconv_string("UCS-2", "UTF-8", S, SDL_strlen(S)+1)) 5962 5963/** 5964 * Convert a UTF-8 string to UCS-4. 5965 * 5966 * This is a helper macro that might be more clear than calling 5967 * SDL_iconv_string directly. However, it double-evaluates its parameter, so 5968 * do not use an expression with side-effects here. 5969 * 5970 * \param S the string to convert. 5971 * \returns a new string, converted to the new encoding, or NULL on error. 5972 * 5973 * \threadsafety It is safe to call this macro from any thread. 5974 * 5975 * \since This macro is available since SDL 3.2.0. 5976 */ 5977#define SDL_iconv_utf8_ucs4(S) SDL_reinterpret_cast(Uint32 *, SDL_iconv_string("UCS-4", "UTF-8", S, SDL_strlen(S)+1)) 5978 5979/** 5980 * Convert a wchar_t string to UTF-8. 5981 * 5982 * This is a helper macro that might be more clear than calling 5983 * SDL_iconv_string directly. However, it double-evaluates its parameter, so 5984 * do not use an expression with side-effects here. 5985 * 5986 * \param S the string to convert. 5987 * \returns a new string, converted to the new encoding, or NULL on error. 5988 * 5989 * \threadsafety It is safe to call this macro from any thread. 5990 * 5991 * \since This macro is available since SDL 3.2.0. 5992 */ 5993#define SDL_iconv_wchar_utf8(S) SDL_iconv_string("UTF-8", "WCHAR_T", SDL_reinterpret_cast(const char *, S), (SDL_wcslen(S)+1)*sizeof(wchar_t)) 5994 5995 5996/* force builds using Clang's static analysis tools to use literal C runtime 5997 here, since there are possibly tests that are ineffective otherwise. */ 5998#if defined(__clang_analyzer__) && !defined(SDL_DISABLE_ANALYZE_MACROS) 5999 6000/* The analyzer knows about strlcpy even when the system doesn't provide it */ 6001#if !defined(HAVE_STRLCPY) && !defined(strlcpy) 6002size_t strlcpy(char *dst, const char *src, size_t size); 6003#endif 6004 6005/* The analyzer knows about strlcat even when the system doesn't provide it */ 6006#if !defined(HAVE_STRLCAT) && !defined(strlcat) 6007size_t strlcat(char *dst, const char *src, size_t size); 6008#endif 6009 6010#if !defined(HAVE_WCSLCPY) && !defined(wcslcpy) 6011size_t wcslcpy(wchar_t *dst, const wchar_t *src, size_t size); 6012#endif 6013 6014#if !defined(HAVE_WCSLCAT) && !defined(wcslcat) 6015size_t wcslcat(wchar_t *dst, const wchar_t *src, size_t size); 6016#endif 6017 6018#if !defined(HAVE_STRTOK_R) && !defined(strtok_r) 6019char *strtok_r(char *str, const char *delim, char **saveptr); 6020#endif 6021 6022#ifndef _WIN32 6023/* strdup is not ANSI but POSIX, and its prototype might be hidden... */ 6024/* not for windows: might conflict with string.h where strdup may have 6025 * dllimport attribute: https://github.com/libsdl-org/SDL/issues/12948 */ 6026char *strdup(const char *str); 6027#endif 6028 6029/* Starting LLVM 16, the analyser errors out if these functions do not have 6030 their prototype defined (clang-diagnostic-implicit-function-declaration) */ 6031#include <stdio.h> 6032#include <stdlib.h> 6033 6034#define SDL_malloc malloc 6035#define SDL_calloc calloc 6036#define SDL_realloc realloc 6037#define SDL_free free 6038#ifndef SDL_memcpy 6039#define SDL_memcpy memcpy 6040#endif 6041#ifndef SDL_memmove 6042#define SDL_memmove memmove 6043#endif 6044#ifndef SDL_memset 6045#define SDL_memset memset 6046#endif 6047#define SDL_memcmp memcmp 6048#define SDL_strlcpy strlcpy 6049#define SDL_strlcat strlcat 6050#define SDL_strlen strlen 6051#define SDL_wcslen wcslen 6052#define SDL_wcslcpy wcslcpy 6053#define SDL_wcslcat wcslcat 6054#define SDL_strdup strdup 6055#define SDL_wcsdup wcsdup 6056#define SDL_strchr strchr 6057#define SDL_strrchr strrchr 6058#define SDL_strstr strstr 6059#define SDL_wcsstr wcsstr 6060#define SDL_strtok_r strtok_r 6061#define SDL_strcmp strcmp 6062#define SDL_wcscmp wcscmp 6063#define SDL_strncmp strncmp 6064#define SDL_wcsncmp wcsncmp 6065#define SDL_strcasecmp strcasecmp 6066#define SDL_strncasecmp strncasecmp 6067#define SDL_strpbrk strpbrk 6068#define SDL_sscanf sscanf 6069#define SDL_vsscanf vsscanf 6070#define SDL_snprintf snprintf 6071#define SDL_vsnprintf vsnprintf 6072#endif 6073 6074/** 6075 * Multiply two integers, checking for overflow. 6076 * 6077 * If `a * b` would overflow, return false. 6078 * 6079 * Otherwise store `a * b` via ret and return true. 6080 * 6081 * \param a the multiplicand. 6082 * \param b the multiplier. 6083 * \param ret on non-overflow output, stores the multiplication result, may 6084 * not be NULL. 6085 * \returns false on overflow, true if result is multiplied without overflow. 6086 * 6087 * \threadsafety It is safe to call this function from any thread. 6088 * 6089 * \since This function is available since SDL 3.2.0. 6090 */ 6091SDL_FORCE_INLINE bool SDL_size_mul_check_overflow(size_t a, size_t b, size_t *ret) 6092{ 6093 if (a != 0 && b > SDL_SIZE_MAX / a) { 6094 return false; 6095 } 6096 *ret = a * b; 6097 return true; 6098} 6099 6100#ifndef SDL_WIKI_DOCUMENTATION_SECTION 6101#if SDL_HAS_BUILTIN(__builtin_mul_overflow) 6102/* This needs to be wrapped in an inline rather than being a direct #define, 6103 * because __builtin_mul_overflow() is type-generic, but we want to be 6104 * consistent about interpreting a and b as size_t. */ 6105SDL_FORCE_INLINE bool SDL_size_mul_check_overflow_builtin(size_t a, size_t b, size_t *ret) 6106{ 6107 return (__builtin_mul_overflow(a, b, ret) == 0); 6108} 6109#define SDL_size_mul_check_overflow(a, b, ret) SDL_size_mul_check_overflow_builtin(a, b, ret) 6110#endif 6111#endif 6112 6113/** 6114 * Add two integers, checking for overflow. 6115 * 6116 * If `a + b` would overflow, return false. 6117 * 6118 * Otherwise store `a + b` via ret and return true. 6119 * 6120 * \param a the first addend. 6121 * \param b the second addend. 6122 * \param ret on non-overflow output, stores the addition result, may not be 6123 * NULL. 6124 * \returns false on overflow, true if result is added without overflow. 6125 * 6126 * \threadsafety It is safe to call this function from any thread. 6127 * 6128 * \since This function is available since SDL 3.2.0. 6129 */ 6130SDL_FORCE_INLINE bool SDL_size_add_check_overflow(size_t a, size_t b, size_t *ret) 6131{ 6132 if (b > SDL_SIZE_MAX - a) { 6133 return false; 6134 } 6135 *ret = a + b; 6136 return true; 6137} 6138 6139#ifndef SDL_WIKI_DOCUMENTATION_SECTION 6140#if SDL_HAS_BUILTIN(__builtin_add_overflow) 6141/* This needs to be wrapped in an inline rather than being a direct #define, 6142 * the same as the call to __builtin_mul_overflow() above. */ 6143SDL_FORCE_INLINE bool SDL_size_add_check_overflow_builtin(size_t a, size_t b, size_t *ret) 6144{ 6145 return (__builtin_add_overflow(a, b, ret) == 0); 6146} 6147#define SDL_size_add_check_overflow(a, b, ret) SDL_size_add_check_overflow_builtin(a, b, ret) 6148#endif 6149#endif 6150 6151/* This is a generic function pointer which should be cast to the type you expect */ 6152#ifdef SDL_WIKI_DOCUMENTATION_SECTION 6153 6154/** 6155 * A generic function pointer. 6156 * 6157 * In theory, generic function pointers should use this, instead of `void *`, 6158 * since some platforms could treat code addresses differently than data 6159 * addresses. Although in current times no popular platforms make this 6160 * distinction, it is more correct and portable to use the correct type for a 6161 * generic pointer. 6162 * 6163 * If for some reason you need to force this typedef to be an actual `void *`, 6164 * perhaps to work around a compiler or existing code, you can define 6165 * `SDL_FUNCTION_POINTER_IS_VOID_POINTER` before including any SDL headers. 6166 * 6167 * \since This datatype is available since SDL 3.2.0. 6168 */ 6169typedef void (*SDL_FunctionPointer)(void); 6170#elif defined(SDL_FUNCTION_POINTER_IS_VOID_POINTER) 6171typedef void *SDL_FunctionPointer; 6172#else 6173typedef void (*SDL_FunctionPointer)(void); 6174#endif 6175 6176/* Ends C function definitions when using C++ */ 6177#ifdef __cplusplus 6178} 6179#endif 6180#include <SDL3/SDL_close_code.h> 6181 6182#endif /* SDL_stdinc_h_ */ 6183[FILE END](C) 2025 0x4248 (C) 2025 4248 Media and 4248 Systems, All part of 0x4248 See LICENCE files for more information. Not all files are by 0x4248 always check Licencing.