From 998d6525b7e1cc046f9cf58577fa71ee88b7c9a0 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Thu, 23 Jan 2025 14:13:15 +0000 Subject: [PATCH] stdinc --- vendor/sdl3/sdl3_stdinc.odin | 399 +++++++++++++++++++++++++++++++++++ 1 file changed, 399 insertions(+) create mode 100644 vendor/sdl3/sdl3_stdinc.odin diff --git a/vendor/sdl3/sdl3_stdinc.odin b/vendor/sdl3/sdl3_stdinc.odin new file mode 100644 index 000000000..9f7c04bf3 --- /dev/null +++ b/vendor/sdl3/sdl3_stdinc.odin @@ -0,0 +1,399 @@ +package sdl3 + +import "base:builtin" +import "base:intrinsics" +import "core:c" + +#assert(size_of(c.int) == size_of(b32)) +#assert(size_of(c.int) == size_of(rune)) + +foreign import lib { + "SDL3.lib" +} + + +SIZE_MAX :: 1<<(8*size_of(uint)) - 1 + +@(require_results) +FOURCC :: #force_inline proc "contextless" (#any_int A, B, C, D: u8) -> u32 { + return u32(A)<<0 | u32(B)<<8 | u32(C)<<16 | u32(D)<<24 +} + + +Sint8 :: i8 +Uint8 :: u8 + +Sint16 :: i16 +Uint16 :: u16 + +Sint32 :: i32 +Uint32 :: u32 + +Sint64 :: i64 +Uint64 :: u64 + +wchar_t :: c.wchar_t + +/** + * SDL times are signed, 64-bit integers representing nanoseconds since the + * Unix epoch (Jan 1, 1970). + * + * They can be converted between POSIX time_t values with SDL_NS_TO_SECONDS() + * and SDL_SECONDS_TO_NS(), and between Windows FILETIME values with + * SDL_TimeToWindows() and SDL_TimeFromWindows(). + * + * \since This macro is available since SDL 3.2.0. + * + * \sa SDL_MAX_SINT64 + * \sa SDL_MIN_SINT64 + */ +Time :: distinct i64 + +FLT_EPSILON :: 1.1920928955078125e-07 /* 0x0.000002p0 */ + + +INIT_INTERFACE :: proc "contextless" (iface: ^$T) { + zerop(iface) + iface.version = size_of(iface^) +} + +stack_alloc :: intrinsics.alloca + + +malloc_func :: #type proc "c" (size: uint) -> rawptr +calloc_func :: #type proc "c" (nmemb: uint, size: uint) -> rawptr +realloc_func :: #type proc "c" (mem: rawptr, size: uint) -> rawptr +free_func :: #type proc "c" (mem: rawptr) + +@(default_calling_convention="c", link_prefix="SDL_") +foreign lib { + @(require_results) + malloc :: proc(size: uint) -> rawptr --- + + @(require_results) + calloc :: proc(nmemb: uint, size: uint) -> rawptr --- + + @(require_results) + realloc :: proc(mem: rawptr, size: uint) -> rawptr --- + + free :: proc(mem: rawptr) --- + + GetOriginalMemoryFunctions :: proc(malloc_func: ^malloc_func, + calloc_func: ^calloc_func, + realloc_func: ^realloc_func, + free_func: ^free_func) --- + + GetMemoryFunctions :: proc(malloc_func: ^malloc_func, + calloc_func: ^calloc_func, + realloc_func: ^realloc_func, + free_func: ^free_func) --- + + SetMemoryFunctions :: proc(malloc_func: malloc_func, + calloc_func: calloc_func, + realloc_func: realloc_func, + free_func: free_func) --- + + @(require_results) + aligned_alloc :: proc(alignment: uint, size: uint) -> rawptr --- + aligned_free :: proc(mem: rawptr) --- + + @(require_results) + GetNumAllocations :: proc() -> c.int --- + +} + +Environment :: struct {} + +@(default_calling_convention="c", link_prefix="SDL_") +foreign lib { + @(require_results) + GetEnvironment :: proc() -> ^Environment --- + @(require_results) + CreateEnvironment :: proc(populated: bool) -> ^Environment --- + @(require_results) + GetEnvironmentVariable :: proc(env: ^Environment, name: cstring) -> cstring --- + @(require_results) + GetEnvironmentVariables :: proc(env: ^Environment) -> [^]cstring --- + SetEnvironmentVariable :: proc(env: ^Environment, name, value: cstring, overwrite: bool) -> bool --- + UnsetEnvironmentVariable :: proc(env: ^Environment, name: cstring) -> bool --- + DestroyEnvironment :: proc(env: ^Environment) --- +} + +@(default_calling_convention="c", link_prefix="SDL_") +foreign lib { + @(require_results) + getenv :: proc(name: cstring) -> cstring --- + @(require_results) + getenv_unsafe :: proc(name: cstring) -> cstring --- + setenv_unsafe :: proc(name, value: cstring, overwrite: b32) -> c.int --- + unsetenv_unsafe :: proc(name: cstring) -> c.int --- + +} + +CompareCallback :: #type proc "c" (a, b: rawptr) -> c.int +CompareCallback_r :: #type proc "c" (userdata: rawptr, a, b: rawptr) -> c.int + +@(default_calling_convention="c", link_prefix="SDL_") +foreign lib { + qsort :: proc(base: rawptr, nmemb: uint, size: uint, compare: CompareCallback) --- + bsearch :: proc(key: rawptr, base: rawptr, nmemb: uint, size: uint, compare: CompareCallback) -> rawptr --- + + qsort_r :: proc(base: rawptr, nmemb: uint, size: uint, compare: CompareCallback_r, userdata: rawptr) --- + bsearch_r :: proc(key: rawptr, base: rawptr, nmemb: uint, size: uint, compare: CompareCallback_r, userdata: rawptr) -> rawptr --- +} + + +abs :: builtin.abs +min :: builtin.min +max :: builtin.max +clamp :: builtin.clamp + + +@(default_calling_convention="c", link_prefix="SDL_", require_results) +foreign lib { + isalpha :: proc(x: rune) -> b32 --- + isalnum :: proc(x: rune) -> b32 --- + isblank :: proc(x: rune) -> b32 --- + iscntrl :: proc(x: rune) -> b32 --- + isdigit :: proc(x: rune) -> b32 --- + isxdigit :: proc(x: rune) -> b32 --- + ispunct :: proc(x: rune) -> b32 --- + isspace :: proc(x: rune) -> b32 --- + isupper :: proc(x: rune) -> b32 --- + islower :: proc(x: rune) -> b32 --- + isprint :: proc(x: rune) -> b32 --- + isgraph :: proc(x: rune) -> b32 --- + + toupper :: proc(x: rune) -> rune --- + tolower :: proc(x: rune) -> rune --- + + crc16 :: proc(crc: Uint16, data: rawptr, len: uint) -> Uint16 --- + crc32 :: proc(crc: Uint32, data: rawptr, len: uint) -> Uint32 --- + murmur3_32 :: proc(data: rawptr, len: uint, seed: Uint32) -> Uint32 --- +} + +copyp :: #force_inline proc "contextless" (dst, src: ^$T) -> ^T { + return (^T)(memcpy(dst, src, size_of(T))) +} + +zerop :: #force_inline proc "contextless" (x: ^$T) { + memset(x, 0, size_of(T)) +} + +zeroa :: #force_inline proc "contextless" (x: []$T) { + memset(raw_data(x), 0, uint(size_of(T)*len(x))) +} + +@(default_calling_convention="c", link_prefix="SDL_") +foreign lib { + memcpy :: proc(dst, src: rawptr, len: uint) -> rawptr --- + memmove :: proc(dst, src: rawptr, len: uint) -> rawptr --- + memset :: proc(dst: rawptr, c: c.int, len: uint) -> rawptr --- + @(require_results) + memcmp :: proc(s1, s2: rawptr, len: c.int) -> c.int --- +} + +@(default_calling_convention="c", link_prefix="SDL_", require_results) +foreign lib { + wcslen :: proc(wstr: [^]wchar_t) -> uint --- + wcsnlen :: proc(wstr: [^]wchar_t, maxlen: uint) -> uint --- + wcslcpy :: proc(dst, src: [^]wchar_t, maxlen: uint) -> uint --- + wcslcat :: proc(dst, src: [^]wchar_t, maxlen: uint) -> uint --- + wcsdup :: proc(wstr: [^]wchar_t) -> [^]wchar_t --- + wcsstr :: proc(haystack, needle: [^]wchar_t) -> [^]wchar_t --- + wcsnstr :: proc(haystack, needle: [^]wchar_t, maxlen: uint) -> [^]wchar_t --- + wcscmp :: proc(str1, str2: [^]wchar_t) -> int --- + wcsncmp :: proc(str1, str2: [^]wchar_t, maxlen: uint) -> int --- + wcscasecmp :: proc(str1, str2: [^]wchar_t) -> int --- + wcsncasecmp :: proc(str1, str2: [^]wchar_t, maxlen: uint) -> int --- + wcstol :: proc(str: [^]wchar_t, endp: ^[^]wchar_t, base: c.int) -> c.long --- +} + +@(default_calling_convention="c", link_prefix="SDL_", require_results) +foreign lib { + strlen :: proc(str: cstring) -> uint --- + strnlen :: proc(str: cstring, maxlen: uint) -> uint --- + strlcpy :: proc(dst: [^]u8, src: cstring, maxlen: uint) -> uint --- + utf8strlcpy :: proc(dst: [^]u8, src: cstring, dst_bytes: uint) -> uint --- + strlcat :: proc(dst: [^]u8, src: cstring, maxlen: uint) -> uint --- + strdup :: proc(str: cstring) -> [^]u8 --- + strndup :: proc(str: cstring, maxlen: uint) -> [^]u8 --- + strrev :: proc(str: [^]u8) -> [^]u8 --- + strupr :: proc(str: [^]u8) -> [^]u8 --- + strlwr :: proc(str: [^]u8) -> [^]u8 --- + strchr :: proc(str: cstring, c: rune) -> [^]u8 --- + strrchr :: proc(str: cstring, c: rune) -> [^]u8 --- + strstr :: proc(haystack: cstring, needle: cstring) -> [^]u8 --- + strnstr :: proc(haystack: cstring, needle: cstring, maxlen: uint) -> [^]u8 --- + strcasestr :: proc(haystack: cstring, needle: cstring) -> [^]u8 --- + strtok_r :: proc(str: [^]u8, delim: cstring, saveptr: ^[^]u8) -> [^]u8 --- + utf8strlen :: proc(str: cstring) -> uint --- + utf8strnlen :: proc(str: cstring, bytes: uint) -> uint --- + + itoa :: proc(value: c.int, str: [^]u8, radix: c.int) -> [^]u8 --- + uitoa :: proc(value: c.uint, str: [^]u8, radix: c.int) -> [^]u8 --- + ltoa :: proc(value: c.long, str: [^]u8, radix: c.int) -> [^]u8 --- + ultoa :: proc(value: c.ulong, str: [^]u8, radix: c.int) -> [^]u8 --- + lltoa :: proc(value: c.longlong, str: [^]u8, radix: c.int) -> [^]u8 --- + ulltoa :: proc(value: c.ulonglong, str: [^]u8, radix: c.int) -> [^]u8 --- + atoi :: proc(str: cstring) -> c.int --- + atof :: proc(str: cstring) -> f64 --- + + strtol :: proc(str: cstring, endp: ^[^]u8, base: c.int) -> c.long --- + strtoul :: proc(str: cstring, endp: ^[^]u8, base: c.int) -> c.ulong --- + strtoll :: proc(str: cstring, endp: ^[^]u8, base: c.int) -> c.longlong --- + strtoull :: proc(str: cstring, endp: ^[^]u8, base: c.int) -> c.ulonglong --- + strtod :: proc(str: cstring, endp: ^[^]u8) -> f64 --- + strcmp :: proc(str1, str2: cstring) -> c.int --- + strncmp :: proc(str1, str2: cstring, maxlen: uint) -> c.int --- + strcasecmp :: proc(str1, str2: cstring) -> c.int --- + strncasecmp :: proc(str1, str2: cstring, maxlen: uint) -> c.int --- + strpbrk :: proc(str: cstring, breakset: cstring) -> [^]u8 --- + StepUTF8 :: proc(pstr: ^cstring, pslen: ^uint) -> Uint32 --- + StepBackUTF8 :: proc(start: cstring, pstr: ^cstring) -> Uint32 --- + UCS4ToUTF8 :: proc(codepoint: rune, dst: [^]u8) -> [^]u8 --- +} + +@(default_calling_convention="c", link_prefix="SDL_") +foreign lib { + sscanf :: proc(text: cstring, fmt: cstring, #c_vararg args: ..any) -> c.int --- + vsscanf :: proc(text: cstring, fmt: cstring, ap: c.va_list) -> c.int --- + snprintf :: proc(text: [^]u8, maxlen: uint, fmt: cstring, #c_vararg args: ..any) -> c.int --- + swprintf :: proc(text: [^]wchar_t, maxlen: uint, fmt: cstring, #c_vararg args: ..any) -> c.int --- + vsnprintf :: proc(text: [^]u8, maxlen: uint, fmt: cstring, ap: c.va_list) -> c.int --- + vswprintf :: proc(text: [^]wchar_t, maxlen: uint, fmt: cstring, ap: c.va_list) -> c.int --- + asprintf :: proc(strp: ^[^]u8, fmt: cstring, #c_vararg args: ..any) -> c.int --- + vasprintf :: proc(strp: ^[^]u8, fmt: cstring, ap: c.va_list) -> c.int --- +} + +@(default_calling_convention="c", link_prefix="SDL_", require_results) +foreign lib { + srand :: proc(seed: Uint64) --- + rand :: proc(n: Sint32) -> Sint32 --- + randf :: proc() -> f32 --- + rand_bits :: proc() -> Uint32 --- + rand_r :: proc(state: ^Uint64, n: Sint32) -> Sint32 --- + randf_r :: proc(state: ^Uint64) -> f32 --- + rand_bits_r :: proc(state: ^Uint64) -> Uint32 --- +} + +@(default_calling_convention="c", link_prefix="SDL_", require_results) +foreign lib { + acos :: proc(x: f64) -> f64 --- + acosf :: proc(x: f32) -> f32 --- + asin :: proc(x: f64) -> f64 --- + asinf :: proc(x: f32) -> f32 --- + atan :: proc(x: f64) -> f64 --- + atanf :: proc(x: f32) -> f32 --- + atan2 :: proc(y: f64, x: f64) -> f64 --- + atan2f :: proc(y: f32, x: f32) -> f32 --- + ceil :: proc(x: f64) -> f64 --- + ceilf :: proc(x: f32) -> f32 --- + copysign :: proc(x: f64, y: f64) -> f64 --- + copysignf :: proc(x: f32, y: f32) -> f32 --- + cos :: proc(x: f64) -> f64 --- + cosf :: proc(x: f32) -> f32 --- + exp :: proc(x: f64) -> f64 --- + expf :: proc(x: f32) -> f32 --- + fabs :: proc(x: f64) -> f64 --- + fabsf :: proc(x: f32) -> f32 --- + floor :: proc(x: f64) -> f64 --- + floorf :: proc(x: f32) -> f32 --- + trunc :: proc(x: f64) -> f64 --- + truncf :: proc(x: f32) -> f32 --- + fmod :: proc(x: f64, y: f64) -> f64 --- + fmodf :: proc(x: f32, y: f32) -> f32 --- + isinf :: proc(x: f64) -> c.int --- + isinff :: proc(x: f32) -> c.int --- + isnan :: proc(x: f64) -> c.int --- + isnanf :: proc(x: f32) -> c.int --- + log :: proc(x: f64) -> f64 --- + logf :: proc(x: f32) -> f32 --- + log10 :: proc(x: f64) -> f64 --- + log10f :: proc(x: f32) -> f32 --- + modf :: proc(x: f64, y: ^f64) -> f64 --- + modff :: proc(x: f32, y: ^f32) -> f32 --- + pow :: proc(x: f64, y: f64) -> f64 --- + powf :: proc(x: f32, y: f32) -> f32 --- + round :: proc(x: f64) -> f64 --- + roundf :: proc(x: f32) -> f32 --- + lround :: proc(x: f64) -> c.long --- + lroundf :: proc(x: f32) -> c.long --- + scalbn :: proc(x: f64, n: c.int) -> f64 --- + scalbnf :: proc(x: f32, n: c.int) -> f32 --- + sin :: proc(x: f64) -> f64 --- + sinf :: proc(x: f32) -> f32 --- + sqrt :: proc(x: f64) -> f64 --- + sqrtf :: proc(x: f32) -> f32 --- + tan :: proc(x: f64) -> f64 --- + tanf :: proc(x: f32) -> f32 --- +} + +iconv_data_t :: struct{} +iconv_t :: ^iconv_data_t + + +@(default_calling_convention="c", link_prefix="SDL_") +foreign lib { + iconv_open :: proc(tocode: cstring) -> iconv_t --- + iconv_close :: proc(cd: iconv_t) -> c.int --- + iconv :: proc(cd: iconv_t, inbuf: ^cstring, inbytesleft: ^uint, outbuf: ^[^]u8, outbytesleft: ^uint) -> uint --- + iconv_string :: proc(tocode: cstring, fromcode: cstring, inbuf: cstring, inbytesleft: uint) -> [^]byte --- +} + +ICONV_ERROR :: transmute(uint)-1 /**< Generic error. Check SDL_GetError()? */ +ICONV_E2BIG :: transmute(uint)-2 /**< Output buffer was too small. */ +ICONV_EILSEQ :: transmute(uint)-3 /**< Invalid input sequence was encountered. */ +ICONV_EINVAL :: transmute(uint)-4 /**< Incomplete input sequence was encountered. */ + + +@(require_results) +iconv_utf8_locale :: #force_inline proc "c" (S: cstring) -> [^]byte { + return iconv_string("", "UTF-8", S, strlen(S)+1) +} + +@(require_results) +iconv_utf8_ucs2 :: #force_inline proc "c" (S: cstring) -> [^]Uint16 { + return cast([^]Uint16)iconv_string("UCS-2", "UTF-8", S, strlen(S)+1) +} + +@(require_results) +iconv_utf8_ucs4 :: #force_inline proc "c" (S: cstring) -> [^]rune { + return cast([^]rune)iconv_string("UCS-4", "UTF-8", S, strlen(S)+1) +} + +@(require_results) +iconv_wchar_utf8 :: #force_inline proc "c" (S: [^]wchar_t) -> [^]byte { + return iconv_string("UTF-8", "WCHAR_T", cstring(([^]u8)(raw_data(S))), (wcslen(S)+1)*size_of(wchar_t)) +} + + +@(require_results) +size_mul_check_overflow_ptr :: #force_inline proc "c" (a, b: uint, ret: ^uint) -> bool { + if a != 0 && b > SIZE_MAX / a { + return false + } + ret^ = a * b + return true +} +@(require_results) +size_mul_check_overflow :: #force_inline proc "c" (a, b: uint, ret: ^uint) -> (uint, bool) { + return a * b, !(a != 0 && b > SIZE_MAX / a) +} + + +@(require_results) +size_add_check_overflow_ptr :: #force_inline proc "c" (a, b: uint, ret: ^uint) -> bool { + if b > SIZE_MAX - a { + return false + } + ret^ = a + b + return true +} +@(require_results) +size_add_check_overflow :: #force_inline proc "c" (a, b: uint) -> (uint, bool) { + return a + b, !(b > SIZE_MAX - a) +} + + +FunctionPointer :: #type proc "c" () \ No newline at end of file