package core:c/libc
Index
Types (114)
- FILE
- atomic_bool
- atomic_char
- atomic_char16_t
- atomic_char32_t
- atomic_flag
- atomic_int
- atomic_int_fast16_t
- atomic_int_fast32_t
- atomic_int_fast64_t
- atomic_int_fast8_t
- atomic_int_least16_t
- atomic_int_least32_t
- atomic_int_least64_t
- atomic_int_least8_t
- atomic_intmax_t
- atomic_intptr_t
- atomic_llong
- atomic_long
- atomic_ptrdiff_t
- atomic_schar
- atomic_short
- atomic_size_t
- atomic_uchar
- atomic_uint
- atomic_uint_fast16_t
- atomic_uint_fast32_t
- atomic_uint_fast64_t
- atomic_uint_fast8_t
- atomic_uint_least16_t
- atomic_uint_least32_t
- atomic_uint_least64_t
- atomic_uint_least8_t
- atomic_uintmax_t
- atomic_uintptr_t
- atomic_ullong
- atomic_ulong
- atomic_ushort
- atomic_wchar_t
- bool
- char
- char16_t
- char32_t
- clock_t
- cnd_t
- complex_double
- complex_float
- div_t
- double
- double_t
- float
- float_t
- fpos_t
- int
- int16_t
- int32_t
- int64_t
- int8_t
- int_fast16_t
- int_fast32_t
- int_fast64_t
- int_fast8_t
- int_least16_t
- int_least32_t
- int_least64_t
- int_least8_t
- intmax_t
- intptr_t
- jmp_buf
- ldiv_t
- lldiv_t
- long
- longlong
- mbstate_t
- memory_order
- mtx_t
- once_flag
- ptrdiff_t
- schar
- short
- sig_atomic_t
- size_t
- ssize_t
- thrd_start_t
- thrd_t
- time_t
- timespec
- tm
- tss_dtor_t
- tss_t
- uchar
- uint
- uint16_t
- uint32_t
- uint64_t
- uint8_t
- uint_fast16_t
- uint_fast32_t
- uint_fast64_t
- uint_fast8_t
- uint_least16_t
- uint_least32_t
- uint_least64_t
- uint_least8_t
- uintmax_t
- uintptr_t
- ulong
- ulonglong
- ushort
- va_list
- wchar_t
- wctrans_t
- wctype_t
- wint_t
Constants (89)
- ATOMIC_BOOL_LOCK_FREE
- ATOMIC_CHAR16_T_LOCK_FREE
- ATOMIC_CHAR32_T_LOCK_FREE
- ATOMIC_CHAR_LOCK_FREE
- ATOMIC_INT_LOCK_FREE
- ATOMIC_LLONG_LOCK_FREE
- ATOMIC_LONG_LOCK_FREE
- ATOMIC_POINTER_LOCK_FREE
- ATOMIC_SHORT_LOCK_FREE
- ATOMIC_WCHAR_T_LOCK_FREE
- BUFSIZ
- CHAR_BIT
- CLOCKS_PER_SEC
- EDOM
- EILSEQ
- EOF
- ERANGE
- EXIT_FAILURE
- EXIT_SUCCESS
- FILENAME_MAX
- FOPEN_MAX
- FP_ILOGB0
- FP_ILOGBNAN
- FP_INFINITE
- FP_NAN
- FP_NORMAL
- FP_SUBNORMAL
- FP_ZERO
- HUGE_VAL
- HUGE_VALF
- INFINITY
- INT16_MAX
- INT16_MIN
- INT32_MAX
- INT32_MIN
- INT64_MAX
- INT64_MIN
- INT8_MAX
- INT8_MIN
- L_tmpnam
- MATH_ERREXCEPT
- MATH_ERRNO
- NDEBUG
- NULL
- PTRDIFF_MAX
- PTRDIFF_MIN
- RAND_MAX
- SEEK_CUR
- SEEK_END
- SEEK_SET
- SIGABRT
- SIGFPE
- SIGILL
- SIGINT
- SIGSEGV
- SIGTERM
- SIG_ATOMIC_MAX
- SIG_ATOMIC_MIN
- SIG_DFL
- SIG_ERR
- SIG_IGN
- SIZE_MAX
- TIME_UTC
- TMP_MAX
- TSS_DTOR_ITERATIONS
- UINT16_MAX
- UINT32_MAX
- UINT64_MAX
- UINT8_MAX
- WCHAR_MAX
- WCHAR_MIN
- WEOF
- WINT_MAX
- WINT_MIN
- math_errhandling
- memory_order_acq_rel
- memory_order_acquire
- memory_order_consume
- memory_order_relaxed
- memory_order_release
- memory_order_seq_cst
- mtx_plain
- mtx_recursive
- mtx_timed
- thrd_busy
- thrd_error
- thrd_nomem
- thrd_success
- thrd_timedout
Procedures (326)
- ATOMIC_VAR_INIT
- CMPLX
- CMPLXF
- MB_CUR_MAX
- abort
- abs
- aligned_alloc
- aligned_free
- asctime
- at_quick_exit
- atexit
- atof
- atoi
- atol
- atoll
- atomic_compare_exchange_strong
- atomic_compare_exchange_strong_explicit
- atomic_compare_exchange_weak
- atomic_compare_exchange_weak_explicit
- atomic_exchange
- atomic_exchange_explicit
- atomic_fetch_add
- atomic_fetch_add_explicit
- atomic_fetch_and
- atomic_fetch_and_explicit
- atomic_fetch_or
- atomic_fetch_or_explicit
- atomic_fetch_sub
- atomic_fetch_sub_explicit
- atomic_fetch_xor
- atomic_fetch_xor_explicit
- atomic_flag_clear
- atomic_flag_clear_explicit
- atomic_flag_test_and_set
- atomic_flag_test_and_set_explicit
- atomic_init
- atomic_is_lock_free
- atomic_load
- atomic_load_explicit
- atomic_signal_fence
- atomic_store
- atomic_store_explicit
- atomic_thread_fence
- bsearch
- btowc
- c16rtomb
- c32rtomb
- cabs
- cabsf
- cacos
- cacosf
- cacosh
- cacoshf
- call_once
- calloc
- carg
- cargf
- casin
- casinf
- casinh
- casinhf
- catan
- catanf
- catanh
- catanhf
- ccos
- ccosf
- ccosh
- ccoshf
- cexp
- cexpf
- cimag
- cimagf
- clearerr
- clock
- clog
- clogf
- cnd_broadcast
- cnd_destroy
- cnd_init
- cnd_signal
- cnd_timedwait
- cnd_wait
- conj
- conjf
- cpow
- cpowf
- cproj
- cprojf
- creal
- crealf
- csin
- csinf
- csinh
- csinhf
- csqrt
- csqrtf
- ctan
- ctanf
- ctanh
- ctanhf
- ctime
- difftime
- div
- errno
- exit
- fclose
- feof
- ferror
- fflush
- fgetc
- fgetpos
- fgets
- fgetws
- fopen
- fprintf
- fputc
- fputwc
- fputws
- fread
- free
- freopen
- fscanf
- fseek
- fsetpos
- ftell
- fwgetc
- fwide
- fwprintf
- fwrite
- fwscanf
- getc
- getchar
- getenv
- getwc
- getwchar
- gmtime
- isalnum
- isalpha
- isblank
- iscntrl
- isdigit
- isfinite
- isgraph
- isgreater
- isgreaterequal
- isinf
- isless
- islessequal
- islessgreater
- islower
- isnan
- isnormal
- isprint
- ispunct
- isspace
- isunordered
- isupper
- iswalnum
- iswalpha
- iswblank
- iswcntrl
- iswctype
- iswdigit
- iswgraph
- iswlower
- iswprint
- iswpunct
- iswspace
- iswupper
- iswxdigit
- isxdigit
- kill_dependency
- labs
- ldiv
- llabs
- lldiv
- localtime
- longjmp
- malloc
- mblen
- mbrlen
- mbrtoc16
- mbrtoc32
- mbrtowc
- mbsinit
- mbsrtowcs
- mbstowcs
- mbtowc
- memchr
- memcmp
- memcpy
- memmove
- memset
- mktime
- mtx_destroy
- mtx_init
- mtx_lock
- mtx_timedlock
- mtx_trylock
- mtx_unlock
- perror
- printf
- putc
- putchar
- puts
- putwc
- putwchar
- qsort
- quick_exit
- raise
- rand
- realloc
- remove
- rename
- rewind
- scanf
- setbuf
- setjmp
- setvbuf
- signal
- snprintf
- srand
- sscanf
- strcat
- strchr
- strcmp
- strcoll
- strcpn
- strcpy
- strcspn
- strerror
- strftime
- strlen
- strncat
- strncmp
- strncpy
- strpbrk
- strrchr
- strtod
- strtof
- strtok
- strtol
- strtoll
- strtoul
- strtoull
- strxfrm
- swprintf
- swscanf
- system
- thrd_create
- thrd_current
- thrd_detach
- thrd_equal
- thrd_exit
- thrd_join
- thrd_sleep
- thrd_yield
- time
- timespec_get
- tmpfile
- tmpnam
- tolower
- toupper
- towctrans
- towlower
- towupper
- tss_create
- tss_delete
- tss_get
- tss_set
- ungetc
- ungetwc
- va_copy
- va_end
- va_start
- vfprintf
- vfscanf
- vfwprintf
- vfwscanf
- vprintf
- vscanf
- vsnprintf
- vsprintf
- vsscanf
- vswprintf
- vswscanf
- vwprintf
- vwscanf
- wcrtomb
- wcscat
- wcschr
- wcscmp
- wcscoll
- wcscpy
- wcscspn
- wcsftime
- wcslen
- wcsncat
- wcsncmp
- wcsncpy
- wcspbrk
- wcsrchr
- wcsrtombs
- wcsspn
- wcsstr
- wcstod
- wcstof
- wcstok
- wcstol
- wcstoll
- wcstombs
- wcstoul
- wcstoull
- wcsxfrm
- wctob
- wctomb
- wctrans
- wctype
- wmemchr
- wmemcmp
- wmemcpy
- wmemmove
- wmemset
- wprintf
- wscanf
Procedure Groups (114)
- acos
- acosf
- acosh
- acoshf
- asin
- asinf
- asinh
- asinhf
- atan
- atan2
- atan2f
- atanf
- atanh
- atanhf
- cbrt
- cbrtf
- ceil
- ceilf
- copysign
- copysignf
- cos
- cosf
- cosh
- coshf
- erf
- erfc
- erfcf
- erff
- exp
- exp2
- exp2f
- expf
- expm1
- expm1f
- fabs
- fabsf
- fdim
- fdimf
- floor
- floorf
- fma
- fmaf
- fmax
- fmaxf
- fmin
- fminf
- fmod
- fmodf
- fpclassify
- frexp
- frexpf
- hypot
- hypotf
- ilogb
- ilogbf
- ldexp
- ldexpf
- lgamma
- lgammaf
- llrint
- llrintf
- llround
- llroundf
- log
- log10
- log10f
- log1p
- log1pf
- log2
- log2f
- logb
- logbf
- logf
- lrint
- lrintf
- lround
- lroundf
- modf
- modff
- nan
- nanf
- nearbyint
- nearbyintf
- nextafter
- nextafterf
- pow
- powf
- remainder
- remainderf
- remquo
- remquof
- rint
- rintf
- round
- roundf
- scalbln
- scalblnf
- scalbn
- scalbnf
- signbit
- sin
- sinf
- sinh
- sinhf
- sqrt
- sqrtf
- tan
- tanf
- tanh
- tanhf
- tgamma
- tgammaf
- trunc
- truncf
Types
FILE ¶
FILE :: struct($Key: typeid, $Value: typeid) where intrinsics.type_is_valid_map_key(Key) {}
atomic_char ¶
atomic_char :: distinct u8
atomic_char16_t ¶
atomic_char16_t :: distinct u16
atomic_char32_t ¶
atomic_char32_t :: distinct u32
atomic_int ¶
atomic_int :: distinct i32
atomic_int_fast16_t ¶
atomic_int_fast16_t :: distinct i32
atomic_int_fast32_t ¶
atomic_int_fast32_t :: distinct i32
atomic_int_fast64_t ¶
atomic_int_fast64_t :: distinct i64
atomic_int_fast8_t ¶
atomic_int_fast8_t :: distinct i8
atomic_int_least16_t ¶
atomic_int_least16_t :: distinct i16
atomic_int_least32_t ¶
atomic_int_least32_t :: distinct i32
atomic_int_least64_t ¶
atomic_int_least64_t :: distinct i64
atomic_int_least8_t ¶
atomic_int_least8_t :: distinct i8
atomic_intmax_t ¶
atomic_intmax_t :: distinct i64
atomic_intptr_t ¶
atomic_intptr_t :: distinct int
atomic_llong ¶
atomic_llong :: distinct i64
atomic_long ¶
atomic_long :: distinct i32
atomic_ptrdiff_t ¶
atomic_ptrdiff_t :: distinct int
atomic_schar ¶
atomic_schar :: distinct u8
atomic_short ¶
atomic_short :: distinct i16
atomic_size_t ¶
atomic_size_t :: distinct uint
atomic_uchar ¶
atomic_uchar :: distinct u8
atomic_uint ¶
atomic_uint :: distinct u32
atomic_uint_fast16_t ¶
atomic_uint_fast16_t :: distinct u32
atomic_uint_fast32_t ¶
atomic_uint_fast32_t :: distinct u32
atomic_uint_fast64_t ¶
atomic_uint_fast64_t :: distinct u64
atomic_uint_fast8_t ¶
atomic_uint_fast8_t :: distinct u8
atomic_uint_least16_t ¶
atomic_uint_least16_t :: distinct u16
atomic_uint_least32_t ¶
atomic_uint_least32_t :: distinct u32
atomic_uint_least64_t ¶
atomic_uint_least64_t :: distinct u64
atomic_uint_least8_t ¶
atomic_uint_least8_t :: distinct u8
atomic_uintmax_t ¶
atomic_uintmax_t :: distinct u64
atomic_uintptr_t ¶
atomic_uintptr_t :: distinct uintptr
atomic_ullong ¶
atomic_ullong :: distinct u64
atomic_ulong ¶
atomic_ulong :: distinct u32
atomic_ushort ¶
atomic_ushort :: distinct u16
atomic_wchar_t ¶
atomic_wchar_t :: distinct u16
char16_t ¶
char16_t :: u16
char32_t ¶
char32_t :: u32
complex_double ¶
complex_double :: distinct complex128
complex_float ¶
complex_float :: distinct complex64
div_t ¶
div_t :: struct { quot, rem: i32, }
C does not declare which order 'quot' and 'rem' should be for the divide structures. An implementation could put 'rem' first. However, nobody actually does and everyone appears to have agreed upon this layout.
double_t ¶
double_t :: f64
float_t ¶
float_t :: f32
On amd64 Windows and Linux, float_t and double_t are respectively both their usual types. On x86 it's not possible to define these types correctly since they would be long double which Odin does have support for.
int_fast16_t ¶
int_fast16_t :: i32
int_fast32_t ¶
int_fast32_t :: i32
int_fast64_t ¶
int_fast64_t :: i64
int_fast8_t ¶
int_fast8_t :: i8
int_least16_t ¶
int_least16_t :: i16
int_least32_t ¶
int_least32_t :: i32
int_least64_t ¶
int_least64_t :: i64
int_least8_t ¶
int_least8_t :: i8
intmax_t ¶
intmax_t :: i64
intptr_t ¶
intptr_t :: int
jmp_buf ¶
jmp_buf :: struct #align 16 { _: [4096]u8, }
The C99 Rationale describes jmp_buf as being an array type for backward compatibility. Odin does not need to honor this and couldn't as arrays in Odin don't decay to pointers. It is somewhat easy for us to bind this, we just need to ensure the structure contains enough storage with appropriate alignment. Since there are no types in C with an alignment larger than that of max_align_t, which cannot be larger than sizeof(long double) as any other exposed type wouldn't be valid C, the maximum alignment possible in a strictly conformant C implementation is 16 on the platforms we care about. The choice of 4096 bytes for storage of this type is more than enough on all relevant platforms.
longlong ¶
longlong :: i64
mbstate_t ¶
mbstate_t :: struct #align 16 { _: [32]u8, }
Large enough and aligned enough for any wide-spread in-use libc.
memory_order ¶
memory_order :: enum i32 { relaxed, consume, acquire, release, acq_rel, seq_cst, }
7.17.3 Order and consistency
ptrdiff_t ¶
ptrdiff_t :: c.ptrdiff_t
sig_atomic_t ¶
sig_atomic_t :: distinct i32
thrd_start_t ¶
thrd_start_t :: proc "cdecl" (_: rawptr) -> i32
timespec ¶
timespec :: struct #align 8 { tv_sec: time_t, tv_nsec: i32, }
tm ¶
tm :: struct #align 8 { tm_sec, tm_min, tm_hour, tm_mday, tm_mon, tm_year, tm_wday, tm_yday, tm_isdst: i32, }
tss_dtor_t ¶
tss_dtor_t :: proc "cdecl" (_: rawptr)
uint16_t ¶
uint16_t :: u16
uint32_t ¶
uint32_t :: u32
uint64_t ¶
uint64_t :: u64
uint_fast16_t ¶
uint_fast16_t :: u32
uint_fast32_t ¶
uint_fast32_t :: u32
uint_fast64_t ¶
uint_fast64_t :: u64
uint_fast8_t ¶
uint_fast8_t :: u8
uint_least16_t ¶
uint_least16_t :: u16
uint_least32_t ¶
uint_least32_t :: u32
uint_least64_t ¶
uint_least64_t :: u64
uint_least8_t ¶
uint_least8_t :: u8
uintmax_t ¶
uintmax_t :: u64
uintptr_t ¶
uintptr_t :: uintptr
ulonglong ¶
ulonglong :: u64
va_list ¶
va_list :: struct #align 16 { _: [4096]u8, }
Since there are no types in C with an alignment larger than that of max_align_t, which cannot be larger than sizeof(long double) as any other exposed type wouldn't be valid C, the maximum alignment possible in a strictly conformant C implementation is 16 on the platforms we care about. The choice of 4096 bytes for storage of this type is more than enough on all relevant platforms.
wctrans_t ¶
wctrans_t :: distinct u16
wctype_t ¶
wctype_t :: distinct u16
Constants
ATOMIC_BOOL_LOCK_FREE ¶
ATOMIC_BOOL_LOCK_FREE :: true
ATOMIC_CHAR16_T_LOCK_FREE ¶
ATOMIC_CHAR16_T_LOCK_FREE :: true
ATOMIC_CHAR32_T_LOCK_FREE ¶
ATOMIC_CHAR32_T_LOCK_FREE :: true
ATOMIC_CHAR_LOCK_FREE ¶
ATOMIC_CHAR_LOCK_FREE :: true
ATOMIC_INT_LOCK_FREE ¶
ATOMIC_INT_LOCK_FREE :: true
ATOMIC_LLONG_LOCK_FREE ¶
ATOMIC_LLONG_LOCK_FREE :: true
ATOMIC_LONG_LOCK_FREE ¶
ATOMIC_LONG_LOCK_FREE :: true
ATOMIC_POINTER_LOCK_FREE ¶
ATOMIC_POINTER_LOCK_FREE :: true
ATOMIC_SHORT_LOCK_FREE ¶
ATOMIC_SHORT_LOCK_FREE :: true
ATOMIC_WCHAR_T_LOCK_FREE ¶
ATOMIC_WCHAR_T_LOCK_FREE :: true
CHAR_BIT ¶
CHAR_BIT :: 8
CLOCKS_PER_SEC ¶
CLOCKS_PER_SEC :: 1000
EXIT_FAILURE ¶
EXIT_FAILURE :: 1
EXIT_SUCCESS ¶
EXIT_SUCCESS :: 0
C does not declare what these values should be, as an implementation is free to use any two distinct values it wants to indicate success or failure. However, nobody actually does and everyone appears to have agreed upon these values.
FILENAME_MAX ¶
FILENAME_MAX :: 260
FOPEN_MAX ¶
FOPEN_MAX :: 20
FP_ILOGB0 ¶
FP_ILOGB0: i32 : FP_ILOGBNAN
FP_ILOGBNAN ¶
FP_ILOGBNAN: i32 : -1 - int((~uint(0)) >> 1)
FP_INFINITE ¶
FP_INFINITE :: 1
FP_NAN ¶
FP_NAN :: 0
Number classification constants. These do not have to match libc since we implement our own classification functions as libc requires they be macros, which means libc does not export standard functions for them.
FP_NORMAL ¶
FP_NORMAL :: 3
FP_SUBNORMAL ¶
FP_SUBNORMAL :: 4
HUGE_VAL ¶
HUGE_VAL: f64 : double(INFINITY)
HUGE_VALF ¶
HUGE_VALF :: INFINITY
INFINITY ¶
INFINITY :: 1e5000
INT16_MAX ¶
INT16_MAX: i32 : c.INT16_MAX
INT16_MIN ¶
INT16_MIN: i32 : c.INT16_MIN
INT32_MAX ¶
INT32_MAX: i32 : c.INT32_MAX
INT32_MIN ¶
INT32_MIN: i32 : c.INT32_MIN
INT64_MAX ¶
INT64_MAX: i64 : c.INT64_MAX
INT64_MIN ¶
INT64_MIN: i64 : c.INT64_MIN
INT8_MAX ¶
INT8_MAX: i32 : c.INT8_MAX
Copy C's rules for type promotion here by forcing the type on the literals.
INT8_MIN ¶
INT8_MIN: i32 : c.INT8_MIN
MATH_ERREXCEPT ¶
MATH_ERREXCEPT :: 2
MATH_ERRNO ¶
MATH_ERRNO :: 1
PTRDIFF_MAX ¶
PTRDIFF_MAX: c.ptrdiff_t : c.PTRDIFF_MAX
PTRDIFF_MIN ¶
PTRDIFF_MIN: c.ptrdiff_t : c.PTRDIFF_MIN
RAND_MAX ¶
RAND_MAX :: 0x7fff
SEEK_CUR ¶
SEEK_CUR :: 1
SEEK_END ¶
SEEK_END :: 2
SEEK_SET ¶
SEEK_SET :: 0
SIG_ATOMIC_MAX ¶
SIG_ATOMIC_MAX: sig_atomic_t : max(sig_atomic_t)
SIG_ATOMIC_MIN ¶
SIG_ATOMIC_MIN: sig_atomic_t : min(sig_atomic_t)
SIZE_MAX ¶
SIZE_MAX: uint : c.SIZE_MAX
TIME_UTC ¶
TIME_UTC :: 1
UINT16_MAX ¶
UINT16_MAX: i32 : c.UINT16_MAX
UINT32_MAX ¶
UINT32_MAX: u32 : c.UINT32_MAX
UINT64_MAX ¶
UINT64_MAX: u64 : c.UINT64_MAX
UINT8_MAX ¶
UINT8_MAX: i32 : c.UINT8_MAX
WCHAR_MAX ¶
WCHAR_MAX: u16 : c.WCHAR_MAX
WCHAR_MIN ¶
WCHAR_MIN: u16 : c.WCHAR_MIN
WINT_MAX ¶
WINT_MAX :: 1 << (size_of(wint_t) * 8)
WINT_MIN ¶
WINT_MIN :: 0
Calculate these values correctly regardless of what type wchar_t actually is.
memory_order_acq_rel ¶
memory_order_acq_rel :: memory_order.acq_rel
memory_order_acquire ¶
memory_order_acquire :: memory_order.acquire
memory_order_consume ¶
memory_order_consume :: memory_order.consume
memory_order_relaxed ¶
memory_order_relaxed :: memory_order.relaxed
memory_order_release ¶
memory_order_release :: memory_order.release
memory_order_seq_cst ¶
memory_order_seq_cst :: memory_order.seq_cst
Variables
Procedures
CMPLX ¶
CMPLX :: proc "odin" (x, y: f64) -> complex_double {…}
CMPLXF ¶
CMPLXF :: proc "odin" (x, y: f32) -> complex_float {…}
MB_CUR_MAX ¶
MB_CUR_MAX :: proc "odin" () -> uint {…}
aligned_alloc ¶
aligned_alloc :: proc "cdecl" (alignment, size: uint) -> rawptr {…}
aligned_free ¶
aligned_free :: proc "cdecl" (ptr: rawptr) {…}
at_quick_exit ¶
at_quick_exit :: proc "cdecl" (func: proc "cdecl" ()) -> i32 ---
atomic_compare_exchange_strong ¶
atomic_compare_exchange_strong :: proc "odin" (object, expected: ^$T, desired: $T) -> bool {…}
C does not allow failure memory order to be order_release or acq_rel. Similarly, it does not allow the failure order to be stronger than success order. Since consume and acquire are both monotonic, we can count them as one, for a total of three memory orders that are relevant in compare exchange.
relaxed, acquire (consume), seq_cst.
The requirement that the failure order cannot be stronger than success limits the valid combinations for the failure order to this table:
[success = seq_cst, failure = seq_cst] => _ [success = acquire, failure = seq_cst] => acq [success = release, failure = seq_cst] => rel [success = acq_rel, failure = seq_cst] => acqrel [success = relaxed, failure = relaxed] => relaxed [success = seq_cst, failure = relaxed] => failrelaxed [success = seq_cst, failure = acquire] => failacq [success = acquire, failure = relaxed] => acq_failrelaxed [success = acq_rel, failure = relaxed] => acqrel_failrelaxed
atomic_compare_exchange_strong_explicit ¶
atomic_compare_exchange_strong_explicit :: proc "odin" (object, expected: ^$T, desired: $T, success, failure: memory_order) -> bool {…}
atomic_compare_exchange_weak ¶
atomic_compare_exchange_weak :: proc "odin" (object, expected: ^$T, desired: $T) -> bool {…}
atomic_compare_exchange_weak_explicit ¶
atomic_compare_exchange_weak_explicit :: proc "odin" (object, expected: ^$T, desited: $T, success, failure: memory_order) -> bool {…}
atomic_exchange ¶
atomic_exchange :: proc "odin" (object: ^$T, desired: $T) -> $T {…}
atomic_exchange_explicit ¶
atomic_exchange_explicit :: proc "odin" (object: ^$T, desired: $T, order: memory_order) -> $T {…}
atomic_fetch_add ¶
atomic_fetch_add :: proc "odin" (object: ^$T, operand: $T) -> $T {…}
7.17.7.5 The atomic_fetch and modify generic functions
atomic_fetch_add_explicit ¶
atomic_fetch_add_explicit :: proc "odin" (object: ^$T, operand: $T, order: memory_order) -> $T {…}
atomic_fetch_and ¶
atomic_fetch_and :: proc "odin" (object: ^$T, operand: $T) -> $T {…}
atomic_fetch_and_explicit ¶
atomic_fetch_and_explicit :: proc "odin" (object: ^$T, operand: $T, order: memory_order) -> $T {…}
atomic_fetch_or ¶
atomic_fetch_or :: proc "odin" (object: ^$T, operand: $T) -> $T {…}
atomic_fetch_or_explicit ¶
atomic_fetch_or_explicit :: proc "odin" (object: ^$T, operand: $T, order: memory_order) -> $T {…}
atomic_fetch_sub ¶
atomic_fetch_sub :: proc "odin" (object: ^$T, operand: $T) -> $T {…}
atomic_fetch_sub_explicit ¶
atomic_fetch_sub_explicit :: proc "odin" (object: ^$T, operand: $T, order: memory_order) -> $T {…}
atomic_fetch_xor ¶
atomic_fetch_xor :: proc "odin" (object: ^$T, operand: $T) -> $T {…}
atomic_fetch_xor_explicit ¶
atomic_fetch_xor_explicit :: proc "odin" (object: ^$T, operand: $T, order: memory_order) -> $T {…}
atomic_flag_clear ¶
atomic_flag_clear :: proc "odin" (flag: ^atomic_flag) {…}
atomic_flag_clear_explicit ¶
atomic_flag_clear_explicit :: proc "odin" (flag: ^atomic_flag, order: memory_order) {…}
atomic_flag_test_and_set ¶
atomic_flag_test_and_set :: proc "odin" (flag: ^atomic_flag) -> bool {…}
atomic_flag_test_and_set_explicit ¶
atomic_flag_test_and_set_explicit :: proc "odin" (flag: ^atomic_flag, order: memory_order) -> bool {…}
atomic_init ¶
atomic_init :: proc "odin" (obj: ^$T, value: $T) {…}
atomic_is_lock_free ¶
atomic_is_lock_free :: proc "odin" (obj: ^$T) -> bool {…}
7.17.5 Lock-free property
atomic_load ¶
atomic_load :: proc "odin" (object: ^$T) -> $T {…}
atomic_load_explicit ¶
atomic_load_explicit :: proc "odin" (object: ^$T, order: memory_order) {…}
atomic_signal_fence ¶
atomic_signal_fence :: proc "odin" (order: memory_order) {…}
atomic_store ¶
atomic_store :: proc "odin" (object: ^$T, desired: $T) {…}
7.17.7 Operations on atomic types
atomic_store_explicit ¶
atomic_store_explicit :: proc "odin" (object: ^$T, desired: $T, order: memory_order) {…}
bsearch ¶
bsearch :: proc "cdecl" (key, base: rawptr, nmemb, size: uint, compar: proc "cdecl" (lhs, rhs: rawptr) -> i32) -> rawptr ---
7.22.5 Searching and sorting utilities
btowc ¶
btowc :: proc "cdecl" (c: i32) -> wint_t ---
7.29.6.1 Single-byte/wide character conversion functions
c16rtomb ¶
c16rtomb :: proc "cdecl" (s: ^u8, c16: u16, ps: ^mbstate_t) -> uint ---
c32rtomb ¶
c32rtomb :: proc "cdecl" (s: ^u8, c32: u32, ps: ^mbstate_t) -> uint ---
cabs ¶
cabs :: proc "cdecl" (z: complex_double) -> complex_double ---
7.3.8 Power and absolute-value functions
cabsf ¶
cabsf :: proc "cdecl" (z: complex_float) -> complex_float ---
cacos ¶
cacos :: proc "cdecl" (z: complex_double) -> complex_double ---
7.3.5 Trigonometric functions
cacosf ¶
cacosf :: proc "cdecl" (z: complex_float) -> complex_float ---
cacosh ¶
cacosh :: proc "cdecl" (z: complex_double) -> complex_double ---
7.3.6 Hyperbolic functions
cacoshf ¶
cacoshf :: proc "cdecl" (z: complex_float) -> complex_float ---
call_once ¶
call_once :: proc "cdecl" (flag: ^once_flag, func: proc "cdecl" ()) ---
calloc ¶
calloc :: proc "cdecl" (nmemb, size: uint) -> rawptr ---
7.22.3 Memory management functions
cargf ¶
cargf :: proc "cdecl" (z: complex_float) -> f32 ---
casin ¶
casin :: proc "cdecl" (z: complex_double) -> complex_double ---
casinf ¶
casinf :: proc "cdecl" (z: complex_float) -> complex_float ---
casinh ¶
casinh :: proc "cdecl" (z: complex_double) -> complex_double ---
casinhf ¶
casinhf :: proc "cdecl" (z: complex_float) -> complex_float ---
catan ¶
catan :: proc "cdecl" (z: complex_double) -> complex_double ---
catanf ¶
catanf :: proc "cdecl" (z: complex_float) -> complex_float ---
catanh ¶
catanh :: proc "cdecl" (z: complex_double) -> complex_double ---
catanhf ¶
catanhf :: proc "cdecl" (z: complex_float) -> complex_float ---
ccos ¶
ccos :: proc "cdecl" (z: complex_double) -> complex_double ---
ccosf ¶
ccosf :: proc "cdecl" (z: complex_float) -> complex_float ---
ccosh ¶
ccosh :: proc "cdecl" (z: complex_double) -> complex_double ---
ccoshf ¶
ccoshf :: proc "cdecl" (z: complex_float) -> complex_float ---
cexp ¶
cexp :: proc "cdecl" (z: complex_double) -> complex_double ---
7.3.7 Exponential and logarithmic functions
cexpf ¶
cexpf :: proc "cdecl" (z: complex_float) -> complex_float ---
cimag ¶
cimag :: proc "cdecl" (z: complex_double) -> f64 ---
cimagf ¶
cimagf :: proc "cdecl" (z: complex_float) -> f32 ---
clog ¶
clog :: proc "cdecl" (z: complex_double) -> complex_double ---
clogf ¶
clogf :: proc "cdecl" (z: complex_float) -> complex_float ---
cnd_broadcast ¶
cnd_broadcast :: proc "cdecl" (cond: ^cnd_t) -> i32 ---
cnd_destroy ¶
cnd_destroy :: proc "cdecl" (cond: ^cnd_t) ---
cnd_init ¶
cnd_init :: proc "cdecl" (cond: ^cnd_t) -> i32 ---
cnd_signal ¶
cnd_signal :: proc "cdecl" (cond: ^cnd_t) -> i32 ---
conj ¶
conj :: proc "cdecl" (z: complex_double) -> complex_double ---
conjf ¶
conjf :: proc "cdecl" (z: complex_float) -> complex_float ---
cpow ¶
cpow :: proc "cdecl" (x, y: complex_double) -> complex_double ---
cpowf ¶
cpowf :: proc "cdecl" (x, y: complex_float) -> complex_float ---
cproj ¶
cproj :: proc "cdecl" (z: complex_double) -> complex_double ---
cprojf ¶
cprojf :: proc "cdecl" (z: complex_float) -> complex_float ---
creal ¶
creal :: proc "cdecl" (z: complex_double) -> f64 ---
crealf ¶
crealf :: proc "cdecl" (z: complex_float) -> f32 ---
csin ¶
csin :: proc "cdecl" (z: complex_double) -> complex_double ---
csinf ¶
csinf :: proc "cdecl" (z: complex_float) -> complex_float ---
csinh ¶
csinh :: proc "cdecl" (z: complex_double) -> complex_double ---
csinhf ¶
csinhf :: proc "cdecl" (z: complex_float) -> complex_float ---
csqrt ¶
csqrt :: proc "cdecl" (z: complex_double) -> complex_double ---
csqrtf ¶
csqrtf :: proc "cdecl" (z: complex_float) -> complex_float ---
ctan ¶
ctan :: proc "cdecl" (z: complex_double) -> complex_double ---
ctanf ¶
ctanf :: proc "cdecl" (z: complex_float) -> complex_float ---
ctanh ¶
ctanh :: proc "cdecl" (z: complex_double) -> complex_double ---
ctanhf ¶
ctanhf :: proc "cdecl" (z: complex_float) -> complex_float ---
difftime ¶
difftime :: proc "cdecl" (time1, time2: time_t) -> f64 ---
errno ¶
errno :: proc "odin" () -> ^i32 {…}
Odin has no way to make an identifier "errno" behave as a function call to read the value, or to produce an lvalue such that you can assign a different error value to errno. To work around this, just expose it as a function like it actually is.
fgetpos ¶
7.21.9 File positioning functions
fprintf ¶
fprintf :: proc "cdecl" (stream: ^FILE, format: cstring, args: ..any) -> i32 ---
7.21.6 Formatted input/output functions
fwgetc ¶
7.29.3 Wide character input/output functions
fwprintf ¶
fwprintf :: proc "cdecl" (stream: ^FILE, format: [^]u16, arg: ..any) -> i32 ---
7.29.2 Formatted wide character input/output functions
getwchar ¶
getwchar :: proc "cdecl" () -> wint_t ---
isfinite ¶
isfinite :: proc "odin" (x: $T) -> bool {…}
isgreater ¶
isgreater :: proc "odin" (x, y: $T) -> bool {…}
These are special in that they avoid float exceptions. They cannot just be implemented as the relational comparisons, as that would produce an invalid "sticky" state that propagates and affects maths results. These need to be implemented natively in Odin assuming isunordered to prevent that.
isgreaterequal ¶
isgreaterequal :: proc "odin" (x, y: $T) -> bool {…}
islessequal ¶
islessequal :: proc "odin" (x, y: $T) -> bool {…}
islessgreater ¶
islessgreater :: proc "odin" (x, y: $T) -> bool {…}
isnormal ¶
isnormal :: proc "odin" (x: $T) -> bool {…}
isunordered ¶
isunordered :: proc "odin" (x, y: $T) -> bool {…}
iswalnum ¶
iswalnum :: proc "cdecl" (wc: wint_t) -> i32 ---
7.30.2.1 Wide character classification functions
iswalpha ¶
iswalpha :: proc "cdecl" (wc: wint_t) -> i32 ---
iswblank ¶
iswblank :: proc "cdecl" (wc: wint_t) -> i32 ---
iswcntrl ¶
iswcntrl :: proc "cdecl" (wc: wint_t) -> i32 ---
iswctype ¶
7.30.2.2 Extensible wide character classification functions
iswdigit ¶
iswdigit :: proc "cdecl" (wc: wint_t) -> i32 ---
iswgraph ¶
iswgraph :: proc "cdecl" (wc: wint_t) -> i32 ---
iswlower ¶
iswlower :: proc "cdecl" (wc: wint_t) -> i32 ---
iswprint ¶
iswprint :: proc "cdecl" (wc: wint_t) -> i32 ---
iswpunct ¶
iswpunct :: proc "cdecl" (wc: wint_t) -> i32 ---
iswspace ¶
iswspace :: proc "cdecl" (wc: wint_t) -> i32 ---
iswupper ¶
iswupper :: proc "cdecl" (wc: wint_t) -> i32 ---
iswxdigit ¶
iswxdigit :: proc "cdecl" (wc: wint_t) -> i32 ---
isxdigit ¶
isxdigit :: proc "cdecl" (c: i32) -> i32 ---
kill_dependency ¶
kill_dependency :: proc "odin" (value: $T) -> $T {…}
longjmp ¶
longjmp :: proc "cdecl" (env: ^jmp_buf, val: i32) -> ! ---
7.13.2 Restore calling environment
mblen ¶
mblen :: proc "cdecl" (s: cstring, n: uint) -> i32 ---
7.22.7 Multibyte/wide character conversion functions
mbrlen ¶
mbrlen :: proc "cdecl" (s: cstring, n: uint, ps: ^mbstate_t) -> uint ---
7.29.6.3 Restartable multibyte/wide character conversion functions
mbrtoc16 ¶
mbrtoc16 :: proc "cdecl" (pc16: [^]u16, s: cstring, n: uint, ps: ^mbstate_t) -> uint ---
7.28.1 Restartable multibyte/wide character conversion functions
mbrtoc32 ¶
mbrtoc32 :: proc "cdecl" (pc32: [^]u32, s: cstring, n: uint, ps: ^mbstate_t) -> uint ---
mbsrtowcs ¶
mbsrtowcs :: proc "cdecl" (dst: [^]u16, src: ^cstring, len: uint, ps: ^mbstate_t) -> uint ---
7.29.6.4 Restartable multibyte/wide string conversion functions
mbstowcs ¶
mbstowcs :: proc "cdecl" (pwcs: ^u16, s: cstring, n: uint) -> uint ---
7.22.8 Multibyte/wide string conversion functions
mtx_destroy ¶
mtx_destroy :: proc "cdecl" (mtx: ^mtx_t) ---
mtx_init ¶
mtx_init :: proc "cdecl" (mtx: ^mtx_t, type: i32) -> i32 ---
mtx_lock ¶
mtx_lock :: proc "cdecl" (mtx: ^mtx_t) -> i32 ---
mtx_trylock ¶
mtx_trylock :: proc "cdecl" (mtx: ^mtx_t) -> i32 ---
mtx_unlock ¶
mtx_unlock :: proc "cdecl" (mtx: ^mtx_t) -> i32 ---
putwchar ¶
putwchar :: proc "cdecl" (c: u16) -> wint_t ---
qsort ¶
qsort :: proc "cdecl" (base: rawptr, nmemb, size: uint, compar: proc "cdecl" (lhs, rhs: rawptr) -> i32) ---
quick_exit ¶
quick_exit :: proc "cdecl" (status: i32) -> ! ---
signal ¶
signal :: proc "cdecl" (sig: i32, func: proc "cdecl" (_: i32)) -> proc "cdecl" (_: i32) ---
snprintf ¶
snprintf :: proc "cdecl" (s: [^]u8, format: cstring, args: ..any) -> i32 ---
strcat ¶
strcat :: proc "cdecl" (s1: [^]u8, s2: cstring) -> [^]u8 ---
7.24.3 Concatenation functions
strftime ¶
strftime :: proc "cdecl" (s: [^]u8, maxsize: uint, format: cstring, timeptr: ^tm) -> uint ---
strtoull ¶
strtoull :: proc "cdecl" (nptr: cstring, endptr: ^[^]u8, base: i32) -> u64 ---
swprintf ¶
swprintf :: proc "cdecl" (stream: ^FILE, n: uint, format: [^]u16, arg: ..any) -> i32 ---
thrd_create ¶
thrd_create :: proc "cdecl" (thr: ^thrd_t, func: thrd_start_t, arg: rawptr) -> i32 ---
thrd_current ¶
thrd_current :: proc "cdecl" () -> thrd_t ---
thrd_detach ¶
thrd_detach :: proc "cdecl" (thr: thrd_t) -> i32 ---
thrd_equal ¶
thrd_equal :: proc "cdecl" (lhs, rhs: thrd_t) -> i32 ---
thrd_exit ¶
thrd_exit :: proc "cdecl" (res: i32) -> ! ---
thrd_join ¶
thrd_join :: proc "cdecl" (thr: thrd_t, res: ^i32) -> i32 ---
thrd_sleep ¶
thrd_sleep :: proc "cdecl" (duration, remaining: ^timespec) -> i32 ---
thrd_yield ¶
thrd_yield :: proc "cdecl" () ---
timespec_get ¶
timespec_get :: proc "cdecl" (ts: ^timespec, base: i32) -> i32 ---
towctrans ¶
7.30.3.2 Extensible wide character case mapping functions
towlower ¶
7.30.3 Wide character case mapping utilities
tss_create ¶
tss_create :: proc "cdecl" (key: ^tss_t, dtor: tss_dtor_t) -> i32 ---
tss_delete ¶
tss_delete :: proc "cdecl" (key: tss_t) ---
va_start ¶
va_start :: proc "odin" (ap: ^va_list, _: any) {…}
vsnprintf ¶
vsnprintf :: proc "cdecl" (s: [^]u8, n: uint, format: cstring, arg: ^va_list) -> i32 ---
vsprintf ¶
vsprintf :: proc "cdecl" (s: [^]u8, format: cstring, arg: ^va_list) -> i32 ---
vswprintf ¶
vswprintf :: proc "cdecl" (s: [^]u16, n: uint, format: [^]u16, arg: va_list) -> i32 ---
vswscanf ¶
vswscanf :: proc "cdecl" (s, format: [^]u16, arg: va_list) -> i32 ---
vwprintf ¶
vwprintf :: proc "cdecl" (format: [^]u16, arg: va_list) -> i32 ---
wcscat ¶
wcscat :: proc "cdecl" (s1, s2: [^]u16) -> [^]u16 ---
7.29.4.3 Wide string concatenation functions
wcschr ¶
wcschr :: proc "cdecl" (s: [^]u16, c: u16) -> [^]u16 ---
7.29.4.5 Wide string search functions
wcscmp ¶
wcscmp :: proc "cdecl" (s1, s2: [^]u16) -> i32 ---
7.29.4.4 Wide string comparison functions
wcscpy ¶
wcscpy :: proc "cdecl" (s1, s2: [^]u16) -> [^]u16 ---
7.29.4.2 Wide string copying functions
wcsftime ¶
wcsftime :: proc "cdecl" (s: [^]u16, maxsize: uint, format: [^]u16, timeptr: ^tm) -> uint ---
7.29.5 Wide character time conversion functions
wcsrtombs ¶
wcsrtombs :: proc "cdecl" (dst: ^u8, src: ^[^]u16, len: uint, ps: ^mbstate_t) -> uint ---
wcstod ¶
wcstod :: proc "cdecl" (nptr: [^]u16, endptr: ^[^]u16) -> f64 ---
7.29.4 General wide string utilities
wcstombs ¶
wcstombs :: proc "cdecl" (s: [^]u8, pwcs: ^u16, n: uint) -> uint ---
wcstoull ¶
wcstoull :: proc "cdecl" (nptr: [^]u16, endptr: ^[^]u16, base: i32) -> u64 ---
wmemmove ¶
wmemmove :: proc "cdecl" (s1, s2: [^]u16, n: uint) -> [^]u16 ---
Procedure Groups
acos ¶
acos :: proc{ libc_acos, libc_acosf, cacos, cacosf, }
Emulate tgmath.h behavior with explicit procedure overloading here.
acosf ¶
acosf :: proc{ libc_acosf, }
But retain the 'f' suffix-variant functions as well so they can be used, a trick is used here where we use explicit procedural overloading of one procedure. This is done because the foreign block is marked @(private) and aliasing functions does not remove privateness from the entity.
acosh ¶
acosh :: proc{ libc_acosh, libc_acoshf, cacosh, cacoshf, }
acoshf ¶
acoshf :: proc{ libc_acoshf, }
asinf ¶
asinf :: proc{ libc_asinf, }
asinh ¶
asinh :: proc{ libc_asinh, libc_asinhf, casinh, casinhf, }
asinhf ¶
asinhf :: proc{ libc_asinhf, }
atan2 ¶
atan2 :: proc{ libc_atan2, libc_atan2f, }
atan2f ¶
atan2f :: proc{ libc_atan2f, }
atanf ¶
atanf :: proc{ libc_atanf, }
atanh ¶
atanh :: proc{ libc_atanh, libc_atanhf, catanh, catanhf, }
atanhf ¶
atanhf :: proc{ libc_atanhf, }
cbrt ¶
cbrt :: proc{ libc_cbrt, libc_cbrtf, }
cbrtf ¶
cbrtf :: proc{ libc_cbrtf, }
ceil ¶
ceil :: proc{ libc_ceil, libc_ceilf, }
ceilf ¶
ceilf :: proc{ libc_ceilf, }
copysign ¶
copysign :: proc{ libc_copysign, libc_copysignf, }
copysignf ¶
copysignf :: proc{ libc_copysignf, }
coshf ¶
coshf :: proc{ libc_coshf, }
erfc ¶
erfc :: proc{ libc_erfc, libc_erfcf, }
erfcf ¶
erfcf :: proc{ libc_erfcf, }
exp2 ¶
exp2 :: proc{ libc_exp2, libc_exp2f, }
exp2f ¶
exp2f :: proc{ libc_exp2f, }
expm1 ¶
expm1 :: proc{ libc_expm1, libc_expm1f, }
expm1f ¶
expm1f :: proc{ libc_expm1f, }
fabsf ¶
fabsf :: proc{ libc_fabsf, }
fdim ¶
fdim :: proc{ libc_fdim, libc_fdimf, }
fdimf ¶
fdimf :: proc{ libc_fdimf, }
floor ¶
floor :: proc{ libc_floor, libc_floorf, }
floorf ¶
floorf :: proc{ libc_floorf, }
fmax ¶
fmax :: proc{ libc_fmax, libc_fmaxf, }
fmaxf ¶
fmaxf :: proc{ libc_fmaxf, }
fmin ¶
fmin :: proc{ libc_fmin, libc_fminf, }
fminf ¶
fminf :: proc{ libc_fminf, }
fmod ¶
fmod :: proc{ libc_fmod, libc_fmodf, }
fmodf ¶
fmodf :: proc{ libc_fmodf, }
fpclassify ¶
fpclassify :: proc{ _fpclassify, _fpclassifyf, }
frexp ¶
frexp :: proc{ libc_frexp, libc_frexpf, }
frexpf ¶
frexpf :: proc{ libc_frexpf, }
hypot ¶
hypot :: proc{ libc_hypot, libc_hypotf, }
hypotf ¶
hypotf :: proc{ libc_hypotf, }
ilogb ¶
ilogb :: proc{ libc_ilogb, libc_ilogbf, }
ilogbf ¶
ilogbf :: proc{ libc_ilogbf, }
ldexp ¶
ldexp :: proc{ libc_ldexp, libc_ldexpf, }
ldexpf ¶
ldexpf :: proc{ libc_ldexpf, }
lgamma ¶
lgamma :: proc{ libc_lgamma, libc_lgammaf, }
lgammaf ¶
lgammaf :: proc{ libc_lgammaf, }
llrint ¶
llrint :: proc{ libc_llrint, libc_llrintf, }
llrintf ¶
llrintf :: proc{ libc_llrintf, }
llround ¶
llround :: proc{ libc_llround, libc_llroundf, }
llroundf ¶
llroundf :: proc{ libc_llroundf, }
log10 ¶
log10 :: proc{ libc_log10, libc_log10f, }
log10f ¶
log10f :: proc{ libc_log10f, }
log1p ¶
log1p :: proc{ libc_log1p, libc_log1pf, }
log1pf ¶
log1pf :: proc{ libc_log1pf, }
log2 ¶
log2 :: proc{ libc_log2, libc_log2f, }
log2f ¶
log2f :: proc{ libc_log2f, }
logb ¶
logb :: proc{ libc_logb, libc_logbf, }
logbf ¶
logbf :: proc{ libc_logbf, }
lrint ¶
lrint :: proc{ libc_lrint, libc_lrintf, }
lrintf ¶
lrintf :: proc{ libc_lrintf, }
lround ¶
lround :: proc{ libc_lround, libc_lroundf, }
lroundf ¶
lroundf :: proc{ libc_lroundf, }
modf ¶
modf :: proc{ libc_modf, libc_modff, }
modff ¶
modff :: proc{ libc_modff, }
nan ¶
nan :: proc{ libc_nan, }
These two functions are special and not made type generic in tgmath.h since they only differ by their return type.
nearbyint ¶
nearbyint :: proc{ libc_nearbyint, libc_nearbyintf, }
nearbyintf ¶
nearbyintf :: proc{ libc_nearbyintf, }
nextafter ¶
nextafter :: proc{ libc_nextafter, libc_nextafterf, }
nextafterf ¶
nextafterf :: proc{ libc_nextafterf, }
remainder ¶
remainder :: proc{ libc_remainder, libc_remainderf, }
remainderf ¶
remainderf :: proc{ libc_remainderf, }
remquo ¶
remquo :: proc{ libc_remquo, libc_remquof, }
remquof ¶
remquof :: proc{ libc_remquof, }
rint ¶
rint :: proc{ libc_rint, libc_rintf, }
rintf ¶
rintf :: proc{ libc_rintf, }
round ¶
round :: proc{ libc_round, libc_roundf, }
roundf ¶
roundf :: proc{ libc_roundf, }
scalbln ¶
scalbln :: proc{ libc_scalbln, libc_scalblnf, }
scalblnf ¶
scalblnf :: proc{ libc_scalblnf, }
scalbn ¶
scalbn :: proc{ libc_scalbn, libc_scalbnf, }
scalbnf ¶
scalbnf :: proc{ libc_scalbnf, }
sinhf ¶
sinhf :: proc{ libc_sinhf, }
sqrtf ¶
sqrtf :: proc{ libc_sqrtf, }
tanhf ¶
tanhf :: proc{ libc_tanhf, }
tgamma ¶
tgamma :: proc{ libc_tgamma, libc_tgammaf, }
tgammaf ¶
tgammaf :: proc{ libc_tgammaf, }
trunc ¶
trunc :: proc{ libc_trunc, libc_truncf, }
truncf ¶
truncf :: proc{ libc_truncf, }
Source Files
- complex.odin
- ctype.odin
- errno.odin
- math.odin
- setjmp.odin
- signal.odin
- stdarg.odin
- stdatomic.odin
- stdio.odin
- stdlib.odin
- string.odin
- threads.odin
- time.odin
- types.odin
- uchar.odin
- wchar.odin
- wctype.odin
Generation Information
Generated with odin version dev-2023-03 (vendor "odin") Windows_amd64 @ 2023-03-29 21:09:05.430817700 +0000 UTC