package core:runtime

Source

Allocator :: struct {
	procedure: Allocator_Proc,
	data:      rawptr,
}

Allocator_Error :: enum u8 {
	None                 = 0, 
	Out_Of_Memory        = 1, 
	Invalid_Pointer      = 2, 
	Invalid_Argument     = 3, 
	Mode_Not_Implemented = 4, 
}

Allocator_Mode :: enum u8 {
	Alloc, 
	Free, 
	Free_All, 
	Resize, 
	Query_Features, 
	Query_Info, 
	Alloc_Non_Zeroed, 
}

Allocator_Mode_Set :: distinct bit_set[Allocator_Mode]

Allocator_Proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, size, alignment: int, old_memory: rawptr, old_size: int, location := #caller_location) -> ([]u8, Allocator_Error)

Allocator_Query_Info :: struct {
	pointer:   rawptr,
	size:      Maybe(int),
	alignment: Maybe(int),
}

Arena :: struct {
	backing_allocator:  Allocator,
	curr_block:         ^Memory_Block,
	total_used:         uint,
	total_capacity:     uint,
	minimum_block_size: uint,
	temp_count:         uint,
}

Arena_Temp :: struct {
	arena: ^Arena,
	block: ^Memory_Block,
	used:  uint,
}

Assertion_Failure_Proc :: proc(prefix, message: string, loc: Source_Code_Location) -> !

Calling_Convention :: enum u8 {
	Invalid     = 0, 
	Odin        = 1, 
	Contextless = 2, 
	CDecl       = 3, 
	Std_Call    = 4, 
	Fast_Call   = 5, 
	None        = 6, 
	Naked       = 7, 
	Win64       = 9, 
	SysV        = 10, 
}

Context :: struct {
	allocator:              Allocator,
	temp_allocator:         Allocator,
	assertion_failure_proc: Assertion_Failure_Proc,
	logger:                 Logger,
	user_ptr:               rawptr,
	user_index:             int,
	// Internal use only
	_internal:              rawptr,
}

DLL_Forward_Reason :: enum u32 {
	Process_Detach = 0, // About to unload DLL
	Process_Attach = 1, // Entry point
	Thread_Attach  = 2, 
	Thread_Detach  = 3, 
}

Default_Temp_Allocator :: struct {
	arena: Arena,
}

Equal_Proc :: proc "contextless" (_: rawptr, _: rawptr) -> bool

Hasher_Proc :: proc "contextless" (data: rawptr, seed: uintptr = 0) -> uintptr

Logger :: struct {
	procedure:    Logger_Proc,
	data:         rawptr,
	lowest_level: Logger_Level,
	options:      bit_set[Logger_Option],
}

Logger_Level :: enum uint {
	Debug   = 0, 
	Info    = 10, 
	Warning = 20, 
	Error   = 30, 
	Fatal   = 40, 
}

Logger_Option :: enum int {
	Level, 
	Date, 
	Time, 
	Short_File_Path, 
	Long_File_Path, 
	Line, 
	Procedure, 
	Terminal_Color, 
	Thread_Id, 
}

Logger_Options :: bit_set[Logger_Option]

Logger_Proc :: proc(data: rawptr, level: Logger_Level, text: string, options: bit_set[Logger_Option], location := #caller_location)

Map_Cell :: struct($T: typeid) #align MAP_CACHE_LINE_SIZE {}

Map_Cell_Info :: struct {
	size_of_type:      uintptr,
	// 8-bytes on 64-bit, 4-bytes on 32-bits
	align_of_type:     uintptr,
	// 8-bytes on 64-bit, 4-bytes on 32-bits
	size_of_cell:      uintptr,
	// 8-bytes on 64-bit, 4-bytes on 32-bits
	elements_per_cell: uintptr,
}

Map_Hash :: uintptr

Map_Info :: struct {
	ks:         ^Map_Cell_Info,
	// 8-bytes on 64-bit, 4-bytes on 32-bit
	vs:         ^Map_Cell_Info,
	// 8-bytes on 64-bit, 4-bytes on 32-bit
	key_hasher: proc "contextless" (key: rawptr, seed: uintptr) -> uintptr,
	// 8-bytes on 64-bit, 4-bytes on 32-bit
	key_equal:  proc "contextless" (lhs, rhs: rawptr) -> bool,
}

Maybe :: union($T: typeid) {}

Memory_Block :: struct {
	prev:      ^Memory_Block,
	allocator: Allocator,
	base:      [^]u8,
	used:      uint,
	capacity:  uint,
}

Odin_Arch_Type :: .Odin_Arch_Type

Odin_Build_Mode_Type :: .Odin_Build_Mode_Type

Odin_Endian_Type :: .Odin_Endian_Type

Odin_OS_Type :: .Odin_OS_Type

Platform_Endianness :: enum u8 {
	Platform = 0, 
	Little   = 1, 
	Big      = 2, 
}

Raw_Any :: struct {
	data: rawptr,
	id:   typeid,
}

Raw_Cstring :: struct {
	data: [^]u8,
}

Raw_Dynamic_Array :: struct {
	data:      rawptr,
	len:       int,
	cap:       int,
	allocator: Allocator,
}

Raw_Map :: struct {
	// A single allocation spanning all keys, values, and hashes.
	// {
	//   k: Map_Cell(K) * (capacity / ks_per_cell)
	//   v: Map_Cell(V) * (capacity / vs_per_cell)
	//   h: Map_Cell(H) * (capacity / hs_per_cell)
	// }
	// 
	// The data is allocated assuming 64-byte alignment, meaning the address is
	// always a multiple of 64. This means we have 6 bits of zeros in the pointer
	// to store the capacity. We can store a value as large as 2^6-1 or 63 in
	// there. This conveniently is the maximum log2 capacity we can have for a map
	// as Odin uses signed integers to represent capacity.
	// 
	// Since the hashes are backed by Map_Hash, which is just a 64-bit unsigned
	// integer, the cell structure for hashes is unnecessary because 64/8 is 8 and
	// requires no padding, meaning it can be indexed as a regular array of
	// Map_Hash directly, though for consistency sake it's written as if it were
	// an array of Map_Cell(Map_Hash).
	data:      uintptr,
	// 8-bytes on 64-bits, 4-bytes on 32-bits
	len:       int,
	// 8-bytes on 64-bits, 4-bytes on 32-bits
	allocator: Allocator,
}

Raw_SOA_Footer_Dynamic_Array :: struct {
	len:       int,
	cap:       int,
	allocator: Allocator,
}

Raw_SOA_Footer_Slice :: struct {
	len: int,
}

Raw_Slice :: struct {
	data: rawptr,
	len:  int,
}

Raw_Soa_Pointer :: struct {
	data:  rawptr,
	index: int,
}

Raw_String :: struct {
	data: [^]u8,
	len:  int,
}

Source_Code_Location :: struct {
	file_path: string,
	line,
	column:    i32,
	procedure: string,
}

Type_Info :: struct {
	size:    int,
	align:   int,
	flags:   Type_Info_Flags,
	id:      typeid,
	variant: union {
		Type_Info_Named, 
		Type_Info_Integer, 
		Type_Info_Rune, 
		Type_Info_Float, 
		Type_Info_Complex, 
		Type_Info_Quaternion, 
		Type_Info_String, 
		Type_Info_Boolean, 
		Type_Info_Any, 
		Type_Info_Type_Id, 
		Type_Info_Pointer, 
		Type_Info_Multi_Pointer, 
		Type_Info_Procedure, 
		Type_Info_Array, 
		Type_Info_Enumerated_Array, 
		Type_Info_Dynamic_Array, 
		Type_Info_Slice, 
		Type_Info_Parameters, 
		Type_Info_Struct, 
		Type_Info_Union, 
		Type_Info_Enum, 
		Type_Info_Map, 
		Type_Info_Bit_Set, 
		Type_Info_Simd_Vector, 
		Type_Info_Relative_Pointer, 
		Type_Info_Relative_Slice, 
		Type_Info_Matrix, 
		Type_Info_Soa_Pointer, 
	},
}

Type_Info_Any :: struct {}

Type_Info_Array :: struct {
	elem:      ^Type_Info,
	elem_size: int,
	count:     int,
}

Type_Info_Bit_Set :: struct {
	elem:       ^Type_Info,
	underlying: ^Type_Info,
	// Possibly nil
	lower:      i64,
	upper:      i64,
}

Type_Info_Boolean :: struct {}

Type_Info_Complex :: struct {}

Type_Info_Dynamic_Array :: struct {
	elem:      ^Type_Info,
	elem_size: int,
}

Type_Info_Enum :: struct {
	base:   ^Type_Info,
	names:  []string,
	values: []Type_Info_Enum_Value,
}

Type_Info_Enum_Value :: distinct i64

Type_Info_Enumerated_Array :: struct {
	elem:      ^Type_Info,
	index:     ^Type_Info,
	elem_size: int,
	count:     int,
	min_value: Type_Info_Enum_Value,
	max_value: Type_Info_Enum_Value,
	is_sparse: bool,
}

Type_Info_Flag :: enum u8 {
	Comparable     = 0, 
	Simple_Compare = 1, 
}

Type_Info_Flags :: distinct bit_set[Type_Info_Flag; u32]

Type_Info_Float :: struct {
	endianness: Platform_Endianness,
}

Type_Info_Integer :: struct {
	signed:     bool,
	endianness: Platform_Endianness,
}

Type_Info_Map :: struct {
	key:      ^Type_Info,
	value:    ^Type_Info,
	map_info: ^Map_Info,
}

Type_Info_Matrix :: struct {
	elem:         ^Type_Info,
	elem_size:    int,
	elem_stride:  int,
	// elem_stride >= row_count
	row_count:    int,
	column_count: int,
}

Type_Info_Multi_Pointer :: struct {
	elem: ^Type_Info,
}

Type_Info_Named :: struct {
	name: string,
	base: ^Type_Info,
	pkg:  string,
	loc:  Source_Code_Location,
}

Type_Info_Parameters :: struct {
	// Only used for procedures parameters and results
	types: []^Type_Info,
	names: []string,
}

Type_Info_Pointer :: struct {
	elem: ^Type_Info,
}

Type_Info_Procedure :: struct {
	params:     ^Type_Info,
	// Type_Info_Parameters
	results:    ^Type_Info,
	// Type_Info_Parameters
	variadic:   bool,
	convention: Calling_Convention,
}

Type_Info_Quaternion :: struct {}

Type_Info_Relative_Pointer :: struct {
	pointer:      ^Type_Info,
	base_integer: ^Type_Info,
}

Type_Info_Relative_Slice :: struct {
	slice:        ^Type_Info,
	base_integer: ^Type_Info,
}

Type_Info_Rune :: struct {}

Type_Info_Simd_Vector :: struct {
	elem:      ^Type_Info,
	elem_size: int,
	count:     int,
}

Type_Info_Slice :: struct {
	elem:      ^Type_Info,
	elem_size: int,
}

Type_Info_Soa_Pointer :: struct {
	elem: ^Type_Info,
}

Type_Info_String :: struct {
	is_cstring: bool,
}

Type_Info_Struct :: struct {
	types:         []^Type_Info,
	names:         []string,
	offsets:       []uintptr,
	usings:        []bool,
	tags:          []string,
	is_packed:     bool,
	is_raw_union:  bool,
	is_no_copy:    bool,
	custom_align:  bool,
	equal:         Equal_Proc,
	// These are only set iff this structure is an SOA structure
	soa_kind:      Type_Info_Struct_Soa_Kind,
	soa_base_type: ^Type_Info,
	soa_len:       int,
}

Type_Info_Struct_Soa_Kind :: enum u8 {
	None    = 0, 
	Fixed   = 1, 
	Slice   = 2, 
	Dynamic = 3, 
}

Type_Info_Tuple :: Type_Info_Parameters

Type_Info_Type_Id :: struct {}

Type_Info_Union :: struct {
	variants:     []^Type_Info,
	tag_offset:   uintptr,
	tag_type:     ^Type_Info,
	equal:        Equal_Proc,
	// set only when the struct has .Comparable set but does not have .Simple_Compare set
	custom_align: bool,
	no_nil:       bool,
	shared_nil:   bool,
}

Typeid_Kind :: enum u8 {
	Invalid, 
	Integer, 
	Rune, 
	Float, 
	Complex, 
	Quaternion, 
	String, 
	Boolean, 
	Any, 
	Type_Id, 
	Pointer, 
	Multi_Pointer, 
	Procedure, 
	Array, 
	Enumerated_Array, 
	Dynamic_Array, 
	Slice, 
	Tuple, 
	Struct, 
	Union, 
	Enum, 
	Map, 
	Bit_Set, 
	Simd_Vector, 
	Relative_Pointer, 
	Relative_Slice, 
	Matrix, 
}

Byte :: 1

DEFAULT_ALIGNMENT :: 2 * align_of(rawptr)

DEFAULT_ARENA_GROWING_MINIMUM_BLOCK_SIZE :: uint(DEFAULT_TEMP_ALLOCATOR_BACKING_SIZE)

DEFAULT_RESERVE_CAPACITY :: 16

DEFAULT_TEMP_ALLOCATOR_BACKING_SIZE: int : #config(DEFAULT_TEMP_ALLOCATOR_BACKING_SIZE, 4 * Megabyte)

Gigabyte :: 1024 * Megabyte

HASH_MASK :: 1 << (8 * size_of(uintptr) - 1) - 1

INITIAL_HASH_SEED :: 0xcbf29ce484222325

Kilobyte :: 1024 * Byte

MAP_CACHE_LINE_LOG2 :: 6

MAP_CACHE_LINE_SIZE :: 1 << MAP_CACHE_LINE_LOG2

MAP_LOAD_FACTOR :: 75

MAP_MIN_LOG2_CAPACITY :: 6

Megabyte :: 1024 * Kilobyte

NO_DEFAULT_TEMP_ALLOCATOR: bool : ODIN_OS == .Freestanding || ODIN_OS == .JS || ODIN_DEFAULT_TO_NIL_ALLOCATOR

RUNTIME_REQUIRE :: true

TOMBSTONE_MASK :: 1 << (size_of(Map_Hash) * 8 - 1)

Terabyte :: 1024 * Gigabyte

args__: []cstring

dll_forward_reason: DLL_Forward_Reason

@(thread_local)
global_default_temp_allocator_data: Default_Temp_Allocator

type_table: []Type_Info

DEFAULT_TEMP_ALLOCATOR_TEMP_GUARD :: proc(ignore: bool = false, loc := #caller_location) -> (Arena_Temp, Source_Code_Location) {…}

abs_complex128 :: proc "contextless" (x: complex128) -> f64 {…}

abs_complex32 :: proc "contextless" (x: complex32) -> f16 {…}

abs_complex64 :: proc "contextless" (x: complex64) -> f32 {…}

abs_f16 :: proc "contextless" (x: f16) -> f16 {…}

abs_f32 :: proc "contextless" (x: f32) -> f32 {…}

abs_f64 :: proc "contextless" (x: f64) -> f64 {…}

abs_quaternion128 :: proc "contextless" (x: quaternion128) -> f32 {…}

abs_quaternion256 :: proc "contextless" (x: quaternion256) -> f64 {…}

abs_quaternion64 :: proc "contextless" (x: quaternion64) -> f16 {…}

align_forward_int :: proc(ptr, align: int) -> int {…}

align_forward_uintptr :: proc(ptr, align: uintptr) -> uintptr {…}

alloc_from_memory_block :: proc(block: ^Memory_Block, min_size, alignment: uint) -> (data: []u8, err: Allocator_Error) {…}

append_elem :: proc(array: ^$T/[dynamic]$T, arg: $T, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_ok {…}

append_elem_string :: proc(array: ^$T/[dynamic]$E/u8, arg: $S/string, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_ok {…}

append_elems :: proc(array: ^$T/[dynamic]$T, args: ..$T, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_ok {…}

append_nothing :: proc(array: ^$T/[dynamic]$T, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_ok {…}

append_soa_elem :: proc(array: ^$T/#soa[dynamic]$T, arg: $T, loc := #caller_location) {…}

append_soa_elems :: proc(array: ^$T/#soa[dynamic]$T, args: ..$T, loc := #caller_location) {…}

append_string :: proc(array: ^$T/[dynamic]$E/u8, args: ..string, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_ok {…}

arena_alloc :: proc(arena: ^Arena, size, alignment: uint, loc := #caller_location) -> (data: []u8, err: Allocator_Error) {…}

arena_allocator :: proc(arena: ^Arena) -> Allocator {…}

arena_allocator_proc :: proc(
	allocator_data:  rawptr, 
	mode:            Allocator_Mode, 
	size, alignment: int, 
	old_memory:      rawptr, 
	old_size:        int, 
	location := #caller_location, 
) -> (data: []u8, err: Allocator_Error) {…}

arena_check_temp :: proc(arena: ^Arena, loc := #caller_location) {…}

arena_destroy :: proc(arena: ^Arena, loc := #caller_location) {…}

arena_free_all :: proc(arena: ^Arena, loc := #caller_location) {…}

arena_free_last_memory_block :: proc(arena: ^Arena, loc := #caller_location) {…}

arena_init :: proc(arena: ^Arena, size: uint, backing_allocator: Allocator, loc := #caller_location) -> Allocator_Error {…}

arena_temp_begin :: proc(arena: ^Arena, loc := #caller_location) -> (temp: Arena_Temp) {…}

arena_temp_end :: proc(temp: Arena_Temp, loc := #caller_location) {…}

arena_temp_ignore :: proc(temp: Arena_Temp, loc := #caller_location) {…}

assert :: proc(condition: bool, message: string = "", loc := #caller_location) {…}

assign_at_elem :: proc(array: ^$T/[dynamic]$T, index: int, arg: $T, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #optional_ok {…}

assign_at_elem_string :: proc(array: ^$T/[dynamic]$E/u8, index: int, arg: string, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #optional_ok {…}

assign_at_elems :: proc(array: ^$T/[dynamic]$T, index: int, args: ..$T, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #optional_ok {…}

bounds_check_error :: proc "contextless" (file: string, line, column: i32, index, count: int) {…}

bounds_check_error_loc :: proc "contextless" ( using loc := #caller_location, index, count: int) {…}

bounds_trap :: proc "contextless" () -> ! {…}

bswap_128 :: proc "contextless" (x: u128) -> u128 {…}

bswap_16 :: proc "contextless" (x: u16) -> u16 {…}

bswap_32 :: proc "contextless" (x: u32) -> u32 {…}

bswap_64 :: proc "contextless" (x: u64) -> u64 {…}

bswap_f16 :: proc "contextless" (f: f16) -> f16 {…}

bswap_f32 :: proc "contextless" (f: f32) -> f32 {…}

bswap_f64 :: proc "contextless" (f: f64) -> f64 {…}

card :: proc(s: $S/bit_set[$T]) -> int {…}

clear_dynamic_array :: proc "contextless" (array: ^$T/[dynamic]$T) {…}

clear_map :: proc "contextless" (m: ^$T/map[$T]$T) {…}

complex128_eq :: proc "contextless" (a, b: complex128) -> bool {…}

complex128_ne :: proc "contextless" (a, b: complex128) -> bool {…}

complex32_eq :: proc "contextless" (a, b: complex32) -> bool {…}

complex32_ne :: proc "contextless" (a, b: complex32) -> bool {…}

complex64_eq :: proc "contextless" (a, b: complex64) -> bool {…}

complex64_ne :: proc "contextless" (a, b: complex64) -> bool {…}

container_of :: proc "contextless" (ptr: $P/^$T, $T: typeid, $field_name: string = ) -> ^typeid {…}

copy_from_string :: proc "contextless" (dst: $T/[]$E/u8, src: $S/string) -> int {…}

copy_slice :: proc "contextless" (dst, src: $T/[]$T) -> int {…}

cstring_len :: proc "contextless" (s: cstring) -> int {…}

cstring_to_string :: proc "contextless" (s: cstring) -> string {…}

debug_trap :: intrinsics.debug_trap

default_allocator :: proc() -> Allocator {…}

default_allocator_proc :: proc(
	allocator_data:  rawptr, 
	mode:            Allocator_Mode, 
	size, alignment: int, 
	old_memory:      rawptr, 
	old_size:        int, 
	loc := #caller_location, 
) -> (data: []u8, err: Allocator_Error) {…}

default_assertion_failure_proc :: proc(prefix, message: string, loc: Source_Code_Location) -> ! {…}

default_context :: proc "contextless" () -> Context {…}

default_hasher :: proc "contextless" (data: rawptr, seed: uintptr, N: int) -> uintptr {…}

default_hasher_cstring :: proc "contextless" (data: rawptr, seed: uintptr = 0) -> uintptr {…}

default_hasher_string :: proc "contextless" (data: rawptr, seed: uintptr = 0) -> uintptr {…}

default_logger :: proc() -> Logger {…}

default_logger_proc :: proc(data: rawptr, level: Logger_Level, text: string, options: bit_set[Logger_Option], location := #caller_location) {…}

default_temp_allocator :: proc(allocator: ^Default_Temp_Allocator) -> Allocator {…}

default_temp_allocator_destroy :: proc(s: ^Default_Temp_Allocator) {…}

default_temp_allocator_init :: proc(s: ^Default_Temp_Allocator, size: int, backing_allocator := context.allocator) {…}

default_temp_allocator_proc :: proc(
	allocator_data:  rawptr, 
	mode:            Allocator_Mode, 
	size, alignment: int, 
	old_memory:      rawptr, 
	old_size:        int, 
	loc := #caller_location, 
) -> (data: []u8, err: Allocator_Error) {…}

default_temp_allocator_temp_begin :: proc( using loc: Source_Code_Location) -> (temp: Arena_Temp) {…}

default_temp_allocator_temp_end :: proc(temp: Arena_Temp, loc := #caller_location) {…}

delete_cstring :: proc(str: cstring, allocator := context.allocator, loc := #caller_location) -> Allocator_Error {…}

delete_dynamic_array :: proc(array: $T/[dynamic]$T, loc := #caller_location) -> Allocator_Error {…}

delete_key :: proc(m: ^$T/map[$T]$T, key: $T) -> (deleted_key: $T, deleted_value: $T) {…}

delete_map :: proc(m: $T/map[$T]$T, loc := #caller_location) -> Allocator_Error {…}

delete_slice :: proc(array: $T/[]$T, allocator := context.allocator, loc := #caller_location) -> Allocator_Error {…}

delete_soa_dynamic_array :: proc(array: $T/#soa[dynamic]$T, loc := #caller_location) {…}

delete_soa_slice :: proc(array: $T/#soa[]$T, allocator := context.allocator, loc := #caller_location) {…}

delete_string :: proc(str: string, allocator := context.allocator, loc := #caller_location) -> Allocator_Error {…}

divmodti4 :: proc "c" (a, b: i128, rem: ^i128) -> i128 {…}

divti3 :: proc "c" (a, b: i128) -> i128 {…}

dynamic_array_expr_error :: proc "contextless" (
	file:         string, 
	line, column: i32, 
	low, high, 
	max:          int, 
) {…}

dynamic_array_expr_error_loc :: proc "contextless" ( using loc := #caller_location, low, high, max: int) {…}

encode_rune :: proc "contextless" (c: rune) -> ([4]u8, int) {…}

excl_bit_set :: proc(s: ^$S/bit_set[$T], other: $S/bit_set[$T]) {…}

excl_elem :: proc(s: ^$S/bit_set[$T], elem: $T) {…}

excl_elems :: proc(s: ^$S/bit_set[$T], elems: ..$T) {…}

extendhfsf2 :: proc "c" (value: u16) -> f32 {…}

fixdfti :: proc(a: u64) -> i128 {…}

fixunsdfdi :: proc "c" (a: f64) -> i128 {…}

fixunsdfti :: proc "c" (a: f64) -> u128 {…}

floattidf :: proc "c" (a: i128) -> f64 {…}

floattidf_unsigned :: proc "c" (a: u128) -> f64 {…}

gnu_f2h_ieee :: proc "c" (value: f32) -> u16 {…}

gnu_h2f_ieee :: proc "c" (value: u16) -> f32 {…}

hermitian_adjoint :: proc "contextless" (m: $M/matrix[0, 0]$T) -> $M/matrix[0, 0]$T {…}

incl_bit_set :: proc(s: ^$S/bit_set[$T], other: $S/bit_set[$T]) {…}

incl_elem :: proc(s: ^$S/bit_set[$T], elem: $T) {…}

incl_elems :: proc(s: ^$S/bit_set[$T], elems: ..$T) {…}

init_global_temporary_allocator :: proc(size: int, backup_allocator := context.allocator) {…}

inject_at_elem :: proc(array: ^$T/[dynamic]$T, index: int, arg: $T, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #optional_ok {…}

inject_at_elem_string :: proc(array: ^$T/[dynamic]$E/u8, index: int, arg: string, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #optional_ok {…}

inject_at_elems :: proc(array: ^$T/[dynamic]$T, index: int, args: ..$T, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #optional_ok {…}

is_power_of_two_int :: proc(x: int) -> bool {…}

is_power_of_two_uintptr :: proc(x: uintptr) -> bool {…}

make_aligned :: proc($T: typeid/[]T,  #any_int len: int, alignment: int, allocator := context.allocator, loc := #caller_location) -> (T, Allocator_Error) #optional_ok {…}

make_dynamic_array :: proc($T: typeid/[dynamic]T, allocator := context.allocator, loc := #caller_location) -> (T, Allocator_Error) #optional_ok {…}

make_dynamic_array_error_loc :: proc "contextless" ( using loc := #caller_location, len, cap: int) {…}

make_dynamic_array_len :: proc($T: typeid/[dynamic]T,  #any_int len: int, allocator := context.allocator, loc := #caller_location) -> (T, Allocator_Error) #optional_ok {…}

make_dynamic_array_len_cap :: proc($T: typeid/[dynamic]T,  #any_int len: int,  #any_int cap: int, allocator := context.allocator, loc := #caller_location) -> (array: T, err: Allocator_Error) #optional_ok {…}

make_map :: proc($T: typeid/map[T]T,  #any_int capacity: int = 1 << MAP_MIN_LOG2_CAPACITY, allocator := context.allocator, loc := #caller_location) -> (m: T, err: Allocator_Error) #optional_ok {…}

make_map_expr_error_loc :: proc "contextless" (loc := #caller_location, cap: int) {…}

make_multi_pointer :: proc($T: typeid/[^]T,  #any_int len: int, allocator := context.allocator, loc := #caller_location) -> (mp: $/[^]T, err: Allocator_Error) #optional_ok {…}

make_slice :: proc($T: typeid/[]T,  #any_int len: int, allocator := context.allocator, loc := #caller_location) -> (T, Allocator_Error) #optional_ok {…}

make_slice_error_loc :: proc "contextless" (loc := #caller_location, len: int) {…}

make_soa_aligned :: proc($T: typeid/#soa[]T, length: int, alignment: int, allocator := context.allocator, loc := #caller_location) -> (array: T, err: Allocator_Error) #optional_ok {…}

make_soa_dynamic_array :: proc($T: typeid/#soa[dynamic]T, allocator := context.allocator, loc := #caller_location) -> (array: T) {…}

make_soa_dynamic_array_len :: proc($T: typeid/#soa[dynamic]T,  #any_int length: int, allocator := context.allocator, loc := #caller_location) -> (array: T) {…}

make_soa_dynamic_array_len_cap :: proc($T: typeid/#soa[dynamic]T,  #any_int length,  #any_int capacity: int, allocator := context.allocator, loc := #caller_location) -> (array: T) {…}

make_soa_slice :: proc($T: typeid/#soa[]T, length: int, allocator := context.allocator, loc := #caller_location) -> (array: T, err: Allocator_Error) #optional_ok {…}

map_alloc_dynamic :: proc(info: ^Map_Info, log2_capacity: uintptr, allocator := context.allocator, loc := #caller_location) -> (result: Raw_Map, err: Allocator_Error) {…}

map_cap :: proc "contextless" (m: Raw_Map) -> int {…}

map_cell_index_dynamic :: proc "contextless" (base: uintptr,  #no_alias info: ^Map_Cell_Info, index: uintptr) -> uintptr {…}

map_cell_index_dynamic_const :: proc "contextless" (base: uintptr,  #no_alias info: ^Map_Cell_Info, $INDEX: uintptr = ) -> uintptr {…}

map_cell_index_static :: proc "contextless" (cells: [^]Map_Cell($T), index: uintptr) -> ^$T {…}

map_cell_info :: intrinsics.type_map_cell_info

map_clear_dynamic :: proc "contextless" ( #no_alias m: ^Raw_Map,  #no_alias info: ^Map_Info) {…}

map_data :: proc "contextless" (m: Raw_Map) -> uintptr {…}

map_desired_position :: proc "contextless" (m: Raw_Map, hash: uintptr) -> uintptr {…}

map_erase_dynamic :: proc "contextless" ( #no_alias m: ^Raw_Map,  #no_alias info: ^Map_Info, k: uintptr) -> (old_k, old_v: uintptr, ok: bool) {…}

map_exists_dynamic :: proc "contextless" (m: Raw_Map,  #no_alias info: ^Map_Info, k: uintptr) -> (ok: bool) {…}

map_free_dynamic :: proc(m: Raw_Map, info: ^Map_Info, loc := #caller_location) -> Allocator_Error {…}

map_get :: proc "contextless" (m: $T/map[$T]$T, key: $T) -> (stored_key: $T, stored_value: $T, ok: bool) {…}

map_grow_dynamic :: proc( #no_alias m: ^Raw_Map,  #no_alias info: ^Map_Info, loc := #caller_location) -> Allocator_Error {…}

map_hash_is_deleted :: proc "contextless" (hash: uintptr) -> bool {…}

map_hash_is_empty :: proc "contextless" (hash: uintptr) -> bool {…}

map_hash_is_valid :: proc "contextless" (hash: uintptr) -> bool {…}

map_info :: intrinsics.type_map_info

map_insert :: proc(m: ^$T/map[$T]$T, key: $T, value: $T, loc := #caller_location) -> (ptr: ^$T) {…}

map_insert_hash_dynamic :: proc( #no_alias m: ^Raw_Map,  #no_alias info: ^Map_Info, h: uintptr, ik: uintptr, iv: uintptr) -> (result: uintptr) {…}

map_kvh_data_dynamic :: proc "contextless" (m: Raw_Map,  #no_alias info: ^Map_Info) -> (ks: uintptr, vs: uintptr, hs: [^]uintptr, sk: uintptr, sv: uintptr) {…}

map_kvh_data_static :: proc "contextless" (m: $T/map[$T]$T) -> (ks: [^]Map_Cell(K), vs: [^]Map_Cell(V), hs: [^]uintptr) {…}

map_kvh_data_values_dynamic :: proc "contextless" (m: Raw_Map,  #no_alias info: ^Map_Info) -> (vs: uintptr) {…}

map_len :: proc "contextless" (m: Raw_Map) -> int {…}

map_load_factor :: proc "contextless" (log2_capacity: uintptr) -> uintptr {…}

map_log2_cap :: proc "contextless" (m: Raw_Map) -> uintptr {…}

map_lookup_dynamic :: proc "contextless" (m: Raw_Map,  #no_alias info: ^Map_Info, k: uintptr) -> (index: uintptr, ok: bool) {…}

map_probe_distance :: proc "contextless" (m: Raw_Map, hash: uintptr, slot: uintptr) -> uintptr {…}

map_reserve_dynamic :: proc( #no_alias m: ^Raw_Map,  #no_alias info: ^Map_Info, new_capacity: uintptr, loc := #caller_location) -> Allocator_Error {…}

map_resize_threshold :: proc "contextless" (m: Raw_Map) -> int {…}

map_seed :: proc "contextless" (m: Raw_Map) -> uintptr {…}

map_seed_from_map_data :: proc "contextless" (data: uintptr) -> uintptr {…}

map_shrink_dynamic :: proc( #no_alias m: ^Raw_Map,  #no_alias info: ^Map_Info, loc := #caller_location) -> Allocator_Error {…}

matrix1x1_adjugate :: proc "contextless" (x: $M/matrix[1, 1]$T) -> (y: $M/matrix[1, 1]$T) {…}

matrix1x1_determinant :: proc "contextless" (m: $M/matrix[1, 1]$T) -> (det: $T) {…}

matrix1x1_inverse :: proc "contextless" (x: $M/matrix[1, 1]$T) -> (y: $M/matrix[1, 1]$T) {…}

matrix1x1_inverse_transpose :: proc "contextless" (x: $M/matrix[1, 1]$T) -> (y: $M/matrix[1, 1]$T) {…}

matrix2x2_adjugate :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: $M/matrix[2, 2]$T) {…}

matrix2x2_determinant :: proc "contextless" (m: $M/matrix[2, 2]$T) -> (det: $T) {…}

matrix2x2_inverse :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: $M/matrix[2, 2]$T) {…}

matrix2x2_inverse_transpose :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: $M/matrix[2, 2]$T) {…}

matrix3x3_adjugate :: proc "contextless" (m: $M/matrix[3, 3]$T) -> (y: $M/matrix[3, 3]$T) {…}

matrix3x3_determinant :: proc "contextless" (m: $M/matrix[3, 3]$T) -> (det: $T) {…}

matrix3x3_inverse :: proc "contextless" (x: $M/matrix[3, 3]$T) -> (y: $M/matrix[3, 3]$T) {…}

matrix3x3_inverse_transpose :: proc "contextless" (x: $M/matrix[3, 3]$T) -> (y: $M/matrix[3, 3]$T) {…}

matrix4x4_adjugate :: proc "contextless" (x: $A/matrix[4, 4]$T) -> (y: $A/matrix[4, 4]$T) {…}

matrix4x4_determinant :: proc "contextless" (m: $A/matrix[4, 4]$T) -> (det: $T) {…}

matrix4x4_inverse :: proc "contextless" (x: $A/matrix[4, 4]$T) -> (y: $A/matrix[4, 4]$T) {…}

matrix4x4_inverse_transpose :: proc "contextless" (x: $A/matrix[4, 4]$T) -> (y: $A/matrix[4, 4]$T) {…}

matrix_bounds_check_error :: proc "contextless" (
	file:                               string, 
	line, column:                       i32, 
	row_index, column_index, row_count, 
	column_count:                       int, 
) {…}

matrix_minor :: proc "contextless" (m: $M/matrix[0, 0]$T, row, column: int) -> (minor: $T) {…}

matrix_trace :: proc "contextless" (m: $M/matrix[0, 0]$T) -> (trace: $T) {…}

max_f16 :: proc "contextless" (a, b: f16) -> f16 {…}

max_f32 :: proc "contextless" (a, b: f32) -> f32 {…}

max_f64 :: proc "contextless" (a, b: f64) -> f64 {…}

mem_alloc :: proc(size: int, alignment: int = DEFAULT_ALIGNMENT, allocator := context.allocator, loc := #caller_location) -> ([]u8, Allocator_Error) {…}

mem_alloc_bytes :: proc(size: int, alignment: int = DEFAULT_ALIGNMENT, allocator := context.allocator, loc := #caller_location) -> ([]u8, Allocator_Error) {…}

mem_alloc_non_zeroed :: proc(size: int, alignment: int = DEFAULT_ALIGNMENT, allocator := context.allocator, loc := #caller_location) -> ([]u8, Allocator_Error) {…}

mem_copy :: proc "contextless" (dst, src: rawptr, len: int) -> rawptr {…}

mem_copy_non_overlapping :: proc "contextless" (dst, src: rawptr, len: int) -> rawptr {…}

mem_free :: proc(ptr: rawptr, allocator := context.allocator, loc := #caller_location) -> Allocator_Error {…}

mem_free_all :: proc(allocator := context.allocator, loc := #caller_location) -> (err: Allocator_Error) {…}

mem_free_bytes :: proc(bytes: []u8, allocator := context.allocator, loc := #caller_location) -> Allocator_Error {…}

mem_free_with_size :: proc(ptr: rawptr, byte_count: int, allocator := context.allocator, loc := #caller_location) -> Allocator_Error {…}

mem_resize :: proc(
	ptr:                rawptr, 
	old_size, new_size: int, 
	alignment:          int = DEFAULT_ALIGNMENT, 
	allocator := context.allocator, 
	loc := #caller_location, 
) -> (data: []u8, err: Allocator_Error) {…}

mem_zero :: proc "contextless" (data: rawptr, len: int) -> rawptr {…}

memory_block_alloc :: proc(allocator: Allocator, capacity: uint, loc := #caller_location) -> (block: ^Memory_Block, err: Allocator_Error) {…}

memory_block_dealloc :: proc(block_to_free: ^Memory_Block, loc := #caller_location) {…}

memory_compare :: proc "contextless" (a, b: rawptr, n: int) -> int {…}

memory_compare_zero :: proc "contextless" (a: rawptr, n: int) -> int {…}

memory_equal :: proc "contextless" (x, y: rawptr, n: int) -> bool {…}

memset :: proc "c" (ptr: rawptr, val: i32, len: int) -> rawptr {…}

min_f16 :: proc "contextless" (a, b: f16) -> f16 {…}

min_f32 :: proc "contextless" (a, b: f32) -> f32 {…}

min_f64 :: proc "contextless" (a, b: f64) -> f64 {…}

modti3 :: proc "c" (a, b: i128) -> i128 {…}

mul_quaternion128 :: proc "contextless" (q, r: quaternion128) -> quaternion128 {…}

mul_quaternion256 :: proc "contextless" (q, r: quaternion256) -> quaternion256 {…}

mul_quaternion64 :: proc "contextless" (q, r: quaternion64) -> quaternion64 {…}

multi_pointer_slice_expr_error :: proc "contextless" (file: string, line, column: i32, lo, hi: int) {…}

multi_pointer_slice_handle_error :: proc "contextless" (file: string, line, column: i32, lo, hi: int) -> ! {…}

new :: proc($T: typeid, allocator := context.allocator, loc := #caller_location) -> (^typeid, Allocator_Error) #optional_ok {…}

new_aligned :: proc($T: typeid, alignment: int, allocator := context.allocator, loc := #caller_location) -> (t: ^typeid, err: Allocator_Error) {…}

new_clone :: proc(data: $T, allocator := context.allocator, loc := #caller_location) -> (t: ^$T, err: Allocator_Error) #optional_ok {…}

nil_allocator :: proc() -> Allocator {…}

nil_allocator_proc :: proc(
	allocator_data:  rawptr, 
	mode:            Allocator_Mode, 
	size, alignment: int, 
	old_memory:      rawptr, 
	old_size:        int, 
	loc := #caller_location, 
) -> ([]u8, Allocator_Error) {…}

ordered_remove :: proc(array: ^$T/[dynamic]$T, index: int, loc := #caller_location) {…}

os_write :: proc "contextless" (data: []u8) -> (int, _OS_Errno) {…}

panic :: proc(message: string, loc := #caller_location) -> ! {…}

pop :: proc(array: ^$T/[dynamic]$T, loc := #caller_location) -> (res: $T) {…}

pop_front :: proc(array: ^$T/[dynamic]$T, loc := #caller_location) -> (res: $T) {…}

pop_front_safe :: proc(array: ^$T/[dynamic]$T) -> (res: $T, ok: bool) {…}

pop_safe :: proc(array: ^$T/[dynamic]$T) -> (res: $T, ok: bool) {…}

print_any_single :: proc "contextless" (arg: any) {…}

print_byte :: proc "contextless" (b: u8) -> (n: int) {…}

print_caller_location :: proc "contextless" ( using loc: Source_Code_Location) {…}

print_encoded_rune :: proc "contextless" (r: rune) {…}

print_i64 :: proc "contextless" (x: i64) {…}

print_int :: proc "contextless" (x: int) {…}

print_rune :: proc "contextless" (r: rune) -> int {…}

print_string :: proc "contextless" (str: string) -> (n: int) {…}

print_strings :: proc "contextless" (args: ..string) -> (n: int) {…}

print_type :: proc "contextless" (ti: ^Type_Info) {…}

print_typeid :: proc "contextless" (id: typeid) {…}

print_u64 :: proc "contextless" (x: u64) {…}

print_uint :: proc "contextless" (x: uint) {…}

print_uintptr :: proc "contextless" (x: uintptr) {…}

println_any :: proc "contextless" (args: ..any) {…}

quaternion128_eq :: proc "contextless" (a, b: quaternion128) -> bool {…}

quaternion128_ne :: proc "contextless" (a, b: quaternion128) -> bool {…}

quaternion256_eq :: proc "contextless" (a, b: quaternion256) -> bool {…}

quaternion256_ne :: proc "contextless" (a, b: quaternion256) -> bool {…}

quaternion64_eq :: proc "contextless" (a, b: quaternion64) -> bool {…}

quaternion64_ne :: proc "contextless" (a, b: quaternion64) -> bool {…}

quo_complex128 :: proc "contextless" (n, m: complex128) -> complex128 {…}

quo_complex32 :: proc "contextless" (n, m: complex32) -> complex32 {…}

quo_complex64 :: proc "contextless" (n, m: complex64) -> complex64 {…}

quo_quaternion128 :: proc "contextless" (q, r: quaternion128) -> quaternion128 {…}

quo_quaternion256 :: proc "contextless" (q, r: quaternion256) -> quaternion256 {…}

quo_quaternion64 :: proc "contextless" (q, r: quaternion64) -> quaternion64 {…}

raw_soa_footer_dynamic_array :: proc(array: ^$T/#soa[dynamic]$T) -> (footer: ^Raw_SOA_Footer_Dynamic_Array) {…}

raw_soa_footer_slice :: proc(array: ^$T/#soa[]$T) -> (footer: ^Raw_SOA_Footer_Slice) {…}

read_cycle_counter :: intrinsics.read_cycle_counter

remove_range :: proc(array: ^$T/[dynamic]$T, lo, hi: int, loc := #caller_location) {…}

reserve_dynamic_array :: proc(array: ^$T/[dynamic]$T, capacity: int, loc := #caller_location) -> Allocator_Error {…}

reserve_map :: proc(m: ^$T/map[$T]$T, capacity: int, loc := #caller_location) -> Allocator_Error {…}

reserve_soa :: proc(array: ^$T/#soa[dynamic]$T, capacity: int, loc := #caller_location) -> bool {…}

resize_dynamic_array :: proc(array: ^$T/[dynamic]$T, length: int, loc := #caller_location) -> Allocator_Error {…}

resize_soa :: proc(array: ^$T/#soa[dynamic]$T, length: int, loc := #caller_location) -> bool {…}

shrink_dynamic_array :: proc(array: ^$T/[dynamic]$T, new_cap: int = -1, loc := #caller_location) -> (did_shrink: bool, err: Allocator_Error) {…}

shrink_map :: proc(m: ^$T/map[$T]$T, loc := #caller_location) -> (did_shrink: bool, err: Allocator_Error) {…}

slice_expr_error_hi :: proc "contextless" (file: string, line, column: i32, hi: int, len: int) {…}

slice_expr_error_hi_loc :: proc "contextless" ( using loc := #caller_location, hi: int, len: int) {…}

slice_expr_error_lo_hi :: proc "contextless" (
	file:         string, 
	line, column: i32, 
	lo, hi:       int, 
	len:          int, 
) {…}

slice_expr_error_lo_hi_loc :: proc "contextless" ( using loc := #caller_location, lo, hi: int, len: int) {…}

slice_handle_error :: proc "contextless" (
	file:         string, 
	line, column: i32, 
	lo, hi:       int, 
	len:          int, 
) -> ! {…}

string_cmp :: proc "contextless" (a, b: string) -> int {…}

string_decode_last_rune :: proc "contextless" (s: string) -> (rune, int) {…}

string_decode_rune :: proc "contextless" (s: string) -> (rune, int) {…}

string_eq :: proc "contextless" (lhs, rhs: string) -> bool {…}

string_ge :: proc "contextless" (a, b: string) -> bool {…}

string_gt :: proc "contextless" (a, b: string) -> bool {…}

string_le :: proc "contextless" (a, b: string) -> bool {…}

string_lt :: proc "contextless" (a, b: string) -> bool {…}

string_ne :: proc "contextless" (a, b: string) -> bool {…}

trap :: intrinsics.trap

truncdfhf2 :: proc "c" (value: f64) -> u16 {…}

truncsfhf2 :: proc "c" (value: f32) -> u16 {…}

type_assertion_check :: proc "contextless" (
	ok:           bool, 
	file:         string, 
	line, column: i32, 
	from, 
	to:           typeid, 
) {…}

type_assertion_check2 :: proc "contextless" (
	ok:           bool, 
	file:         string, 
	line, column: i32, 
	from, to:     typeid, 
	from_data:    rawptr, 
) {…}

type_assertion_trap :: proc "contextless" () -> ! {…}

type_info_base :: proc "contextless" (info: ^Type_Info) -> ^Type_Info {…}

type_info_base_without_enum :: type_info_core

type_info_core :: proc "contextless" (info: ^Type_Info) -> ^Type_Info {…}

typeid_base :: proc "contextless" (id: typeid) -> typeid {…}

typeid_base_without_enum :: typeid_core

typeid_core :: proc "contextless" (id: typeid) -> typeid {…}

udivmod128 :: proc "c" (a, b: u128, rem: ^u128) -> u128 {…}

udivmodti4 :: proc "c" (a, b: u128, rem: ^u128) -> u128 {…}

udivti3 :: proc "c" (a, b: u128) -> u128 {…}

umodti3 :: proc "c" (a, b: u128) -> u128 {…}

unimplemented :: proc(message: string, loc := #caller_location) -> ! {…}

unordered_remove :: proc(array: ^$T/[dynamic]$T, index: int, loc := #caller_location) {…}

adjugate :: proc{
	matrix1x1_adjugate,
	matrix2x2_adjugate,
	matrix3x3_adjugate,
	matrix4x4_adjugate,
}

append :: proc{
	append_elem,
	append_elems,
	append_elem_string,
}

append_soa :: proc{
	append_soa_elem,
	append_soa_elems,
}

assign_at :: proc{
	assign_at_elem,
	assign_at_elems,
	assign_at_elem_string,
}

clear :: proc{
	clear_dynamic_array,
	clear_map,
}

copy :: proc{
	copy_slice,
	copy_from_string,
}

delete :: proc{
	delete_string,
	delete_cstring,
	delete_dynamic_array,
	delete_slice,
	delete_map,
}

delete_soa :: proc{
	delete_soa_slice,
	delete_soa_dynamic_array,
}

determinant :: proc{
	matrix1x1_determinant,
	matrix2x2_determinant,
	matrix3x3_determinant,
	matrix4x4_determinant,
}

excl :: proc{
	excl_elem,
	excl_elems,
	excl_bit_set,
}

free :: proc{
	mem_free,
}

free_all :: proc{
	mem_free_all,
}

incl :: proc{
	incl_elem,
	incl_elems,
	incl_bit_set,
}

inject_at :: proc{
	inject_at_elem,
	inject_at_elems,
	inject_at_elem_string,
}

inverse :: proc{
	matrix1x1_inverse,
	matrix2x2_inverse,
	matrix3x3_inverse,
	matrix4x4_inverse,
}

inverse_transpose :: proc{
	matrix1x1_inverse_transpose,
	matrix2x2_inverse_transpose,
	matrix3x3_inverse_transpose,
	matrix4x4_inverse_transpose,
}

make :: proc{
	make_slice,
	make_dynamic_array,
	make_dynamic_array_len,
	make_dynamic_array_len_cap,
	make_map,
	make_multi_pointer,
}

make_soa :: proc{
	make_soa_slice,
	make_soa_dynamic_array,
	make_soa_dynamic_array_len,
	make_soa_dynamic_array_len_cap,
}

raw_soa_footer :: proc{
	raw_soa_footer_slice,
	raw_soa_footer_dynamic_array,
}

reserve :: proc{
	reserve_dynamic_array,
	reserve_map,
}

resize :: proc{
	resize_dynamic_array,
}

shrink :: proc{
	shrink_dynamic_array,
	shrink_map,
}