ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-08-08 08:38:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add @(require_results) and contextless to procedures in core:math/bits

Browse Source
This commit is contained in:
gingerBill
2023-05-22 12:13:44 +01:00
parent a1172d31f4
commit 18c5a53685
1 changed files with 154 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/math/bits/bits.odin
+154 -77
View File
@@ -37,68 +37,96 @@ overflowing_sub :: intrinsics.overflow_sub
overflowing_mul :: intrinsics.overflow_mul overflowing_mul :: intrinsics.overflow_mul
log2 :: proc(x: $T) -> T where intrinsics.type_is_integer(T), intrinsics.type_is_unsigned(T) { @(require_results)
log2 :: proc "contextless" (x: $T) -> T where intrinsics.type_is_integer(T), intrinsics.type_is_unsigned(T) {
return (8*size_of(T)-1) - count_leading_zeros(x) return (8*size_of(T)-1) - count_leading_zeros(x)
} }
rotate_left8 :: proc(x: u8, k: int) -> u8 { @(require_results)
rotate_left8 :: proc "contextless" (x: u8, k: int) -> u8 {
n :: 8 n :: 8
s := uint(k) & (n-1) s := uint(k) & (n-1)
return x <<s | x>>(n-s) return x <<s | x>>(n-s)
} }
rotate_left16 :: proc(x: u16, k: int) -> u16 { @(require_results)
rotate_left16 :: proc "contextless" (x: u16, k: int) -> u16 {
n :: 16 n :: 16
s := uint(k) & (n-1) s := uint(k) & (n-1)
return x <<s | x>>(n-s) return x <<s | x>>(n-s)
} }
rotate_left32 :: proc(x: u32, k: int) -> u32 { @(require_results)
rotate_left32 :: proc "contextless" (x: u32, k: int) -> u32 {
n :: 32 n :: 32
s := uint(k) & (n-1) s := uint(k) & (n-1)
return x <<s | x>>(n-s) return x <<s | x>>(n-s)
} }
rotate_left64 :: proc(x: u64, k: int) -> u64 { @(require_results)
rotate_left64 :: proc "contextless" (x: u64, k: int) -> u64 {
n :: 64 n :: 64
s := uint(k) & (n-1) s := uint(k) & (n-1)
return x <<s | x>>(n-s) return x <<s | x>>(n-s)
} }
rotate_left :: proc(x: uint, k: int) -> uint { @(require_results)
rotate_left :: proc "contextless" (x: uint, k: int) -> uint {
n :: 8*size_of(uint) n :: 8*size_of(uint)
s := uint(k) & (n-1) s := uint(k) & (n-1)
return x <<s | x>>(n-s) return x <<s | x>>(n-s)
} }
from_be_u8 :: proc(i: u8) -> u8 { return i } @(require_results)
from_be_u16 :: proc(i: u16) -> u16 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } from_be_u8 :: proc "contextless" (i: u8) -> u8 { return i }
from_be_u32 :: proc(i: u32) -> u32 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } @(require_results)
from_be_u64 :: proc(i: u64) -> u64 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } from_be_u16 :: proc "contextless" (i: u16) -> u16 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } }
from_be_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } @(require_results)
from_be_u32 :: proc "contextless" (i: u32) -> u32 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } }
@(require_results)
from_be_u64 :: proc "contextless" (i: u64) -> u64 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } }
@(require_results)
from_be_uint :: proc "contextless" (i: uint) -> uint { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } }
from_le_u8 :: proc(i: u8) -> u8 { return i } @(require_results)
from_le_u16 :: proc(i: u16) -> u16 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } from_le_u8 :: proc "contextless" (i: u8) -> u8 { return i }
from_le_u32 :: proc(i: u32) -> u32 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } @(require_results)
from_le_u64 :: proc(i: u64) -> u64 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } from_le_u16 :: proc "contextless" (i: u16) -> u16 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } }
from_le_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } @(require_results)
from_le_u32 :: proc "contextless" (i: u32) -> u32 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } }
@(require_results)
from_le_u64 :: proc "contextless" (i: u64) -> u64 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } }
@(require_results)
from_le_uint :: proc "contextless" (i: uint) -> uint { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } }
to_be_u8 :: proc(i: u8) -> u8 { return i } @(require_results)
to_be_u16 :: proc(i: u16) -> u16 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } to_be_u8 :: proc "contextless" (i: u8) -> u8 { return i }
to_be_u32 :: proc(i: u32) -> u32 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } @(require_results)
to_be_u64 :: proc(i: u64) -> u64 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } to_be_u16 :: proc "contextless" (i: u16) -> u16 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } }
to_be_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } @(require_results)
to_be_u32 :: proc "contextless" (i: u32) -> u32 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } }
@(require_results)
to_be_u64 :: proc "contextless" (i: u64) -> u64 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } }
@(require_results)
to_be_uint :: proc "contextless" (i: uint) -> uint { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } }
to_le_u8 :: proc(i: u8) -> u8 { return i } @(require_results)
to_le_u16 :: proc(i: u16) -> u16 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } to_le_u8 :: proc "contextless" (i: u8) -> u8 { return i }
to_le_u32 :: proc(i: u32) -> u32 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } @(require_results)
to_le_u64 :: proc(i: u64) -> u64 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } to_le_u16 :: proc "contextless" (i: u16) -> u16 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } }
to_le_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } @(require_results)
to_le_u32 :: proc "contextless" (i: u32) -> u32 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } }
@(require_results)
to_le_u64 :: proc "contextless" (i: u64) -> u64 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } }
@(require_results)
to_le_uint :: proc "contextless" (i: uint) -> uint { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } }
len_u8 :: proc(x: u8) -> int { @(require_results)
len_u8 :: proc "contextless" (x: u8) -> int {
return int(len_u8_table[x]) return int(len_u8_table[x])
} }
len_u16 :: proc(x: u16) -> (n: int) { @(require_results)
len_u16 :: proc "contextless" (x: u16) -> (n: int) {
x := x x := x
if x >= 1<<8 { if x >= 1<<8 {
x >>= 8 x >>= 8
@@ -106,7 +134,8 @@ len_u16 :: proc(x: u16) -> (n: int) {
} }
return n + int(len_u8_table[x]) return n + int(len_u8_table[x])
} }
len_u32 :: proc(x: u32) -> (n: int) { @(require_results)
len_u32 :: proc "contextless" (x: u32) -> (n: int) {
x := x x := x
if x >= 1<<16 { if x >= 1<<16 {
x >>= 16 x >>= 16
@@ -118,7 +147,8 @@ len_u32 :: proc(x: u32) -> (n: int) {
} }
return n + int(len_u8_table[x]) return n + int(len_u8_table[x])
} }
len_u64 :: proc(x: u64) -> (n: int) { @(require_results)
len_u64 :: proc "contextless" (x: u64) -> (n: int) {
x := x x := x
if x >= 1<<32 { if x >= 1<<32 {
x >>= 32 x >>= 32
@@ -134,7 +164,8 @@ len_u64 :: proc(x: u64) -> (n: int) {
} }
return n + int(len_u8_table[x]) return n + int(len_u8_table[x])
} }
len_uint :: proc(x: uint) -> (n: int) { @(require_results)
len_uint :: proc "contextless" (x: uint) -> (n: int) {
when size_of(uint) == size_of(u64) { when size_of(uint) == size_of(u64) {
return len_u64(u64(x)) return len_u64(u64(x))
} else { } else {
@@ -146,21 +177,24 @@ len_uint :: proc(x: uint) -> (n: int) {
len :: proc{len_u8, len_u16, len_u32, len_u64, len_uint} len :: proc{len_u8, len_u16, len_u32, len_u64, len_uint}
add_u32 :: proc(x, y, carry: u32) -> (sum, carry_out: u32) { @(require_results)
add_u32 :: proc "contextless" (x, y, carry: u32) -> (sum, carry_out: u32) {
tmp_carry, tmp_carry2: bool tmp_carry, tmp_carry2: bool
sum, tmp_carry = intrinsics.overflow_add(x, y) sum, tmp_carry = intrinsics.overflow_add(x, y)
sum, tmp_carry2 = intrinsics.overflow_add(sum, carry) sum, tmp_carry2 = intrinsics.overflow_add(sum, carry)
carry_out = u32(tmp_carry | tmp_carry2) carry_out = u32(tmp_carry | tmp_carry2)
return return
} }
add_u64 :: proc(x, y, carry: u64) -> (sum, carry_out: u64) { @(require_results)
add_u64 :: proc "contextless" (x, y, carry: u64) -> (sum, carry_out: u64) {
tmp_carry, tmp_carry2: bool tmp_carry, tmp_carry2: bool
sum, tmp_carry = intrinsics.overflow_add(x, y) sum, tmp_carry = intrinsics.overflow_add(x, y)
sum, tmp_carry2 = intrinsics.overflow_add(sum, carry) sum, tmp_carry2 = intrinsics.overflow_add(sum, carry)
carry_out = u64(tmp_carry | tmp_carry2) carry_out = u64(tmp_carry | tmp_carry2)
return return
} }
add_uint :: proc(x, y, carry: uint) -> (sum, carry_out: uint) { @(require_results)
add_uint :: proc "contextless" (x, y, carry: uint) -> (sum, carry_out: uint) {
when size_of(uint) == size_of(u64) { when size_of(uint) == size_of(u64) {
a, b := add_u64(u64(x), u64(y), u64(carry)) a, b := add_u64(u64(x), u64(y), u64(carry))
} else { } else {
@@ -172,21 +206,24 @@ add_uint :: proc(x, y, carry: uint) -> (sum, carry_out: uint) {
add :: proc{add_u32, add_u64, add_uint} add :: proc{add_u32, add_u64, add_uint}
sub_u32 :: proc(x, y, borrow: u32) -> (diff, borrow_out: u32) { @(require_results)
sub_u32 :: proc "contextless" (x, y, borrow: u32) -> (diff, borrow_out: u32) {
tmp_borrow, tmp_borrow2: bool tmp_borrow, tmp_borrow2: bool
diff, tmp_borrow = intrinsics.overflow_sub(x, y) diff, tmp_borrow = intrinsics.overflow_sub(x, y)
diff, tmp_borrow2 = intrinsics.overflow_sub(diff, borrow) diff, tmp_borrow2 = intrinsics.overflow_sub(diff, borrow)
borrow_out = u32(tmp_borrow | tmp_borrow2) borrow_out = u32(tmp_borrow | tmp_borrow2)
return return
} }
sub_u64 :: proc(x, y, borrow: u64) -> (diff, borrow_out: u64) { @(require_results)
sub_u64 :: proc "contextless" (x, y, borrow: u64) -> (diff, borrow_out: u64) {
tmp_borrow, tmp_borrow2: bool tmp_borrow, tmp_borrow2: bool
diff, tmp_borrow = intrinsics.overflow_sub(x, y) diff, tmp_borrow = intrinsics.overflow_sub(x, y)
diff, tmp_borrow2 = intrinsics.overflow_sub(diff, borrow) diff, tmp_borrow2 = intrinsics.overflow_sub(diff, borrow)
borrow_out = u64(tmp_borrow | tmp_borrow2) borrow_out = u64(tmp_borrow | tmp_borrow2)
return return
} }
sub_uint :: proc(x, y, borrow: uint) -> (diff, borrow_out: uint) { @(require_results)
sub_uint :: proc "contextless" (x, y, borrow: uint) -> (diff, borrow_out: uint) {
when size_of(uint) == size_of(u64) { when size_of(uint) == size_of(u64) {
a, b := sub_u64(u64(x), u64(y), u64(borrow)) a, b := sub_u64(u64(x), u64(y), u64(borrow))
} else { } else {
@@ -198,18 +235,21 @@ sub_uint :: proc(x, y, borrow: uint) -> (diff, borrow_out: uint) {
sub :: proc{sub_u32, sub_u64, sub_uint} sub :: proc{sub_u32, sub_u64, sub_uint}
mul_u32 :: proc(x, y: u32) -> (hi, lo: u32) { @(require_results)
mul_u32 :: proc "contextless" (x, y: u32) -> (hi, lo: u32) {
z := u64(x) * u64(y) z := u64(x) * u64(y)
hi, lo = u32(z>>32), u32(z) hi, lo = u32(z>>32), u32(z)
return return
} }
mul_u64 :: proc(x, y: u64) -> (hi, lo: u64) { @(require_results)
mul_u64 :: proc "contextless" (x, y: u64) -> (hi, lo: u64) {
prod_wide := u128(x) * u128(y) prod_wide := u128(x) * u128(y)
hi, lo = u64(prod_wide>>64), u64(prod_wide) hi, lo = u64(prod_wide>>64), u64(prod_wide)
return return
} }
mul_uint :: proc(x, y: uint) -> (hi, lo: uint) { @(require_results)
mul_uint :: proc "contextless" (x, y: uint) -> (hi, lo: uint) {
when size_of(uint) == size_of(u32) { when size_of(uint) == size_of(u32) {
a, b := mul_u32(u32(x), u32(y)) a, b := mul_u32(u32(x), u32(y))
} else { } else {
@@ -222,13 +262,15 @@ mul_uint :: proc(x, y: uint) -> (hi, lo: uint) {
mul :: proc{mul_u32, mul_u64, mul_uint} mul :: proc{mul_u32, mul_u64, mul_uint}
div_u32 :: proc(hi, lo, y: u32) -> (quo, rem: u32) { @(require_results)
div_u32 :: proc "odin" (hi, lo, y: u32) -> (quo, rem: u32) {
assert(y != 0 && y <= hi) assert(y != 0 && y <= hi)
z := u64(hi)<<32 | u64(lo) z := u64(hi)<<32 | u64(lo)
quo, rem = u32(z/u64(y)), u32(z%u64(y)) quo, rem = u32(z/u64(y)), u32(z%u64(y))
return return
} }
div_u64 :: proc(hi, lo, y: u64) -> (quo, rem: u64) { @(require_results)
div_u64 :: proc "odin" (hi, lo, y: u64) -> (quo, rem: u64) {
y := y y := y
two32 :: 1 << 32 two32 :: 1 << 32
mask32 :: two32 - 1 mask32 :: two32 - 1
@@ -273,7 +315,8 @@ div_u64 :: proc(hi, lo, y: u64) -> (quo, rem: u64) {
return q1*two32 + q0, (un21*two32 + un0 - q0*y) >> s return q1*two32 + q0, (un21*two32 + un0 - q0*y) >> s
} }
div_uint :: proc(hi, lo, y: uint) -> (quo, rem: uint) { @(require_results)
div_uint :: proc "odin" (hi, lo, y: uint) -> (quo, rem: uint) {
when size_of(uint) == size_of(u32) { when size_of(uint) == size_of(u32) {
a, b := div_u32(u32(hi), u32(lo), u32(y)) a, b := div_u32(u32(hi), u32(lo), u32(y))
} else { } else {
@@ -286,16 +329,26 @@ div :: proc{div_u32, div_u64, div_uint}
is_power_of_two_u8 :: proc(i: u8) -> bool { return i > 0 && (i & (i-1)) == 0 } @(require_results)
is_power_of_two_i8 :: proc(i: i8) -> bool { return i > 0 && (i & (i-1)) == 0 } is_power_of_two_u8 :: proc "contextless" (i: u8) -> bool { return i > 0 && (i & (i-1)) == 0 }
is_power_of_two_u16 :: proc(i: u16) -> bool { return i > 0 && (i & (i-1)) == 0 } @(require_results)
is_power_of_two_i16 :: proc(i: i16) -> bool { return i > 0 && (i & (i-1)) == 0 } is_power_of_two_i8 :: proc "contextless" (i: i8) -> bool { return i > 0 && (i & (i-1)) == 0 }
is_power_of_two_u32 :: proc(i: u32) -> bool { return i > 0 && (i & (i-1)) == 0 } @(require_results)
is_power_of_two_i32 :: proc(i: i32) -> bool { return i > 0 && (i & (i-1)) == 0 } is_power_of_two_u16 :: proc "contextless" (i: u16) -> bool { return i > 0 && (i & (i-1)) == 0 }
is_power_of_two_u64 :: proc(i: u64) -> bool { return i > 0 && (i & (i-1)) == 0 } @(require_results)
is_power_of_two_i64 :: proc(i: i64) -> bool { return i > 0 && (i & (i-1)) == 0 } is_power_of_two_i16 :: proc "contextless" (i: i16) -> bool { return i > 0 && (i & (i-1)) == 0 }
is_power_of_two_uint :: proc(i: uint) -> bool { return i > 0 && (i & (i-1)) == 0 } @(require_results)
is_power_of_two_int :: proc(i: int) -> bool { return i > 0 && (i & (i-1)) == 0 } is_power_of_two_u32 :: proc "contextless" (i: u32) -> bool { return i > 0 && (i & (i-1)) == 0 }
@(require_results)
is_power_of_two_i32 :: proc "contextless" (i: i32) -> bool { return i > 0 && (i & (i-1)) == 0 }
@(require_results)
is_power_of_two_u64 :: proc "contextless" (i: u64) -> bool { return i > 0 && (i & (i-1)) == 0 }
@(require_results)
is_power_of_two_i64 :: proc "contextless" (i: i64) -> bool { return i > 0 && (i & (i-1)) == 0 }
@(require_results)
is_power_of_two_uint :: proc "contextless" (i: uint) -> bool { return i > 0 && (i & (i-1)) == 0 }
@(require_results)
is_power_of_two_int :: proc "contextless" (i: int) -> bool { return i > 0 && (i & (i-1)) == 0 }
is_power_of_two :: proc{ is_power_of_two :: proc{
is_power_of_two_u8, is_power_of_two_i8, is_power_of_two_u8, is_power_of_two_i8,
@@ -320,44 +373,56 @@ len_u8_table := [256]u8{
} }
bitfield_extract_u8 :: proc(value: u8, offset, bits: uint) -> u8 { return (value >> offset) & u8(1<<bits - 1) } @(require_results)
bitfield_extract_u16 :: proc(value: u16, offset, bits: uint) -> u16 { return (value >> offset) & u16(1<<bits - 1) } bitfield_extract_u8 :: proc "contextless" (value: u8, offset, bits: uint) -> u8 { return (value >> offset) & u8(1<<bits - 1) }
bitfield_extract_u32 :: proc(value: u32, offset, bits: uint) -> u32 { return (value >> offset) & u32(1<<bits - 1) } @(require_results)
bitfield_extract_u64 :: proc(value: u64, offset, bits: uint) -> u64 { return (value >> offset) & u64(1<<bits - 1) } bitfield_extract_u16 :: proc "contextless" (value: u16, offset, bits: uint) -> u16 { return (value >> offset) & u16(1<<bits - 1) }
bitfield_extract_u128 :: proc(value: u128, offset, bits: uint) -> u128 { return (value >> offset) & u128(1<<bits - 1) } @(require_results)
bitfield_extract_uint :: proc(value: uint, offset, bits: uint) -> uint { return (value >> offset) & uint(1<<bits - 1) } bitfield_extract_u32 :: proc "contextless" (value: u32, offset, bits: uint) -> u32 { return (value >> offset) & u32(1<<bits - 1) }
@(require_results)
bitfield_extract_u64 :: proc "contextless" (value: u64, offset, bits: uint) -> u64 { return (value >> offset) & u64(1<<bits - 1) }
@(require_results)
bitfield_extract_u128 :: proc "contextless" (value: u128, offset, bits: uint) -> u128 { return (value >> offset) & u128(1<<bits - 1) }
@(require_results)
bitfield_extract_uint :: proc "contextless" (value: uint, offset, bits: uint) -> uint { return (value >> offset) & uint(1<<bits - 1) }
bitfield_extract_i8 :: proc(value: i8, offset, bits: uint) -> i8 { @(require_results)
bitfield_extract_i8 :: proc "contextless" (value: i8, offset, bits: uint) -> i8 {
v := (u8(value) >> offset) & u8(1<<bits - 1) v := (u8(value) >> offset) & u8(1<<bits - 1)
m := u8(1<<(bits-1)) m := u8(1<<(bits-1))
r := (v~m) - m r := (v~m) - m
return i8(r) return i8(r)
} }
bitfield_extract_i16 :: proc(value: i16, offset, bits: uint) -> i16 { @(require_results)
bitfield_extract_i16 :: proc "contextless" (value: i16, offset, bits: uint) -> i16 {
v := (u16(value) >> offset) & u16(1<<bits - 1) v := (u16(value) >> offset) & u16(1<<bits - 1)
m := u16(1<<(bits-1)) m := u16(1<<(bits-1))
r := (v~m) - m r := (v~m) - m
return i16(r) return i16(r)
} }
bitfield_extract_i32 :: proc(value: i32, offset, bits: uint) -> i32 { @(require_results)
bitfield_extract_i32 :: proc "contextless" (value: i32, offset, bits: uint) -> i32 {
v := (u32(value) >> offset) & u32(1<<bits - 1) v := (u32(value) >> offset) & u32(1<<bits - 1)
m := u32(1<<(bits-1)) m := u32(1<<(bits-1))
r := (v~m) - m r := (v~m) - m
return i32(r) return i32(r)
} }
bitfield_extract_i64 :: proc(value: i64, offset, bits: uint) -> i64 { @(require_results)
bitfield_extract_i64 :: proc "contextless" (value: i64, offset, bits: uint) -> i64 {
v := (u64(value) >> offset) & u64(1<<bits - 1) v := (u64(value) >> offset) & u64(1<<bits - 1)
m := u64(1<<(bits-1)) m := u64(1<<(bits-1))
r := (v~m) - m r := (v~m) - m
return i64(r) return i64(r)
} }
bitfield_extract_i128 :: proc(value: i128, offset, bits: uint) -> i128 { @(require_results)
bitfield_extract_i128 :: proc "contextless" (value: i128, offset, bits: uint) -> i128 {
v := (u128(value) >> offset) & u128(1<<bits - 1) v := (u128(value) >> offset) & u128(1<<bits - 1)
m := u128(1<<(bits-1)) m := u128(1<<(bits-1))
r := (v~m) - m r := (v~m) - m
return i128(r) return i128(r)
} }
bitfield_extract_int :: proc(value: int, offset, bits: uint) -> int { @(require_results)
bitfield_extract_int :: proc "contextless" (value: int, offset, bits: uint) -> int {
v := (uint(value) >> offset) & uint(1<<bits - 1) v := (uint(value) >> offset) & uint(1<<bits - 1)
m := uint(1<<(bits-1)) m := uint(1<<(bits-1))
r := (v~m) - m r := (v~m) - m
@@ -381,52 +446,64 @@ bitfield_extract :: proc{
} }
bitfield_insert_u8 :: proc(base, insert: u8, offset, bits: uint) -> u8 { @(require_results)
bitfield_insert_u8 :: proc "contextless" (base, insert: u8, offset, bits: uint) -> u8 {
mask := u8(1<<bits - 1) mask := u8(1<<bits - 1)
return (base &~ (mask<<offset)) | ((insert&mask) << offset) return (base &~ (mask<<offset)) | ((insert&mask) << offset)
} }
bitfield_insert_u16 :: proc(base, insert: u16, offset, bits: uint) -> u16 { @(require_results)
bitfield_insert_u16 :: proc "contextless" (base, insert: u16, offset, bits: uint) -> u16 {
mask := u16(1<<bits - 1) mask := u16(1<<bits - 1)
return (base &~ (mask<<offset)) | ((insert&mask) << offset) return (base &~ (mask<<offset)) | ((insert&mask) << offset)
} }
bitfield_insert_u32 :: proc(base, insert: u32, offset, bits: uint) -> u32 { @(require_results)
bitfield_insert_u32 :: proc "contextless" (base, insert: u32, offset, bits: uint) -> u32 {
mask := u32(1<<bits - 1) mask := u32(1<<bits - 1)
return (base &~ (mask<<offset)) | ((insert&mask) << offset) return (base &~ (mask<<offset)) | ((insert&mask) << offset)
} }
bitfield_insert_u64 :: proc(base, insert: u64, offset, bits: uint) -> u64 { @(require_results)
bitfield_insert_u64 :: proc "contextless" (base, insert: u64, offset, bits: uint) -> u64 {
mask := u64(1<<bits - 1) mask := u64(1<<bits - 1)
return (base &~ (mask<<offset)) | ((insert&mask) << offset) return (base &~ (mask<<offset)) | ((insert&mask) << offset)
} }
bitfield_insert_u128 :: proc(base, insert: u128, offset, bits: uint) -> u128 { @(require_results)
bitfield_insert_u128 :: proc "contextless" (base, insert: u128, offset, bits: uint) -> u128 {
mask := u128(1<<bits - 1) mask := u128(1<<bits - 1)
return (base &~ (mask<<offset)) | ((insert&mask) << offset) return (base &~ (mask<<offset)) | ((insert&mask) << offset)
} }
bitfield_insert_uint :: proc(base, insert: uint, offset, bits: uint) -> uint { @(require_results)
bitfield_insert_uint :: proc "contextless" (base, insert: uint, offset, bits: uint) -> uint {
mask := uint(1<<bits - 1) mask := uint(1<<bits - 1)
return (base &~ (mask<<offset)) | ((insert&mask) << offset) return (base &~ (mask<<offset)) | ((insert&mask) << offset)
} }
bitfield_insert_i8 :: proc(base, insert: i8, offset, bits: uint) -> i8 { @(require_results)
bitfield_insert_i8 :: proc "contextless" (base, insert: i8, offset, bits: uint) -> i8 {
mask := i8(1<<bits - 1) mask := i8(1<<bits - 1)
return (base &~ (mask<<offset)) | ((insert&mask) << offset) return (base &~ (mask<<offset)) | ((insert&mask) << offset)
} }
bitfield_insert_i16 :: proc(base, insert: i16, offset, bits: uint) -> i16 { @(require_results)
bitfield_insert_i16 :: proc "contextless" (base, insert: i16, offset, bits: uint) -> i16 {
mask := i16(1<<bits - 1) mask := i16(1<<bits - 1)
return (base &~ (mask<<offset)) | ((insert&mask) << offset) return (base &~ (mask<<offset)) | ((insert&mask) << offset)
} }
bitfield_insert_i32 :: proc(base, insert: i32, offset, bits: uint) -> i32 { @(require_results)
bitfield_insert_i32 :: proc "contextless" (base, insert: i32, offset, bits: uint) -> i32 {
mask := i32(1<<bits - 1) mask := i32(1<<bits - 1)
return (base &~ (mask<<offset)) | ((insert&mask) << offset) return (base &~ (mask<<offset)) | ((insert&mask) << offset)
} }
bitfield_insert_i64 :: proc(base, insert: i64, offset, bits: uint) -> i64 { @(require_results)
bitfield_insert_i64 :: proc "contextless" (base, insert: i64, offset, bits: uint) -> i64 {
mask := i64(1<<bits - 1) mask := i64(1<<bits - 1)
return (base &~ (mask<<offset)) | ((insert&mask) << offset) return (base &~ (mask<<offset)) | ((insert&mask) << offset)
} }
bitfield_insert_i128 :: proc(base, insert: i128, offset, bits: uint) -> i128 { @(require_results)
bitfield_insert_i128 :: proc "contextless" (base, insert: i128, offset, bits: uint) -> i128 {
mask := i128(1<<bits - 1) mask := i128(1<<bits - 1)
return (base &~ (mask<<offset)) | ((insert&mask) << offset) return (base &~ (mask<<offset)) | ((insert&mask) << offset)
} }
bitfield_insert_int :: proc(base, insert: int, offset, bits: uint) -> int { @(require_results)
bitfield_insert_int :: proc "contextless" (base, insert: int, offset, bits: uint) -> int {
mask := int(1<<bits - 1) mask := int(1<<bits - 1)
return (base &~ (mask<<offset)) | ((insert&mask) << offset) return (base &~ (mask<<offset)) | ((insert&mask) << offset)
} }