libc

7.21 Input/output

7.17.6 Atomic integer types

7.17.8 Atomic flag type and operations

assuming -funsigned-char

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.

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.

Large enough and aligned enough for any wide-spread in-use libc.

7.17.3 Order and consistency

7.26 Threads

Odin does not have default argument promotion so the need for a separate type here isn't necessary, though make it distinct just to be safe.

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.

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.

+Inf

Copy C's rules for type promotion here by forcing the type on the literals.

Calculate these values correctly regardless of what type wchar_t actually is.

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 NOT have support for.

Windows, Linux, macOS all use this mode.

7.17.2 Initialization

Cannot implement _Complex_I or _Imaginary_I in Odin, thus complex and imaginary cannot be implement either.

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

7.17.7.5 The atomic_fetch and modify generic functions

7.17.5 Lock-free property

7.17.7 Operations on atomic types

7.17.4 Fences

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.

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.

Emulate tgmath.h behavior with explicit procedure overloading here.

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.

These two functions are special and not made type generic in tgmath.h since they only differ by their return type.