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

Replace usage of inline proc with #force_inline proc in the core library

Browse Source
This commit is contained in:
gingerBill
2021-02-23 16:14:47 +00:00
parent 41b854f192
commit aa93305015
26 changed files with 182 additions and 182 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/mem/mem.odin
+23 -23
View File
@@ -6,10 +6,10 @@ import "core:intrinsics"
set :: proc(data: rawptr, value: byte, len: int) -> rawptr {
return runtime.memset(data, i32(value), len);
}
zero :: inline proc(data: rawptr, len: int) -> rawptr {
zero :: proc(data: rawptr, len: int) -> rawptr {
return set(data, 0, len);
}
zero_item :: inline proc(item: $P/^$T) {
zero_item :: proc(item: $P/^$T) {
set(item, 0, size_of(T));
}
zero_slice :: proc(data: $T/[]$E) {
@@ -23,7 +23,7 @@ copy :: proc(dst, src: rawptr, len: int) -> rawptr {
copy_non_overlapping :: proc(dst, src: rawptr, len: int) -> rawptr {
return runtime.mem_copy_non_overlapping(dst, src, len);
}
compare :: inline proc(a, b: []byte) -> int {
compare :: proc(a, b: []byte) -> int {
res := compare_byte_ptrs(raw_data(a), raw_data(b), min(len(a), len(b)));
if res == 0 && len(a) != len(b) {
return len(a) <= len(b) ? -1 : +1;
@@ -121,20 +121,20 @@ simple_equal :: proc(a, b: $T) -> bool where intrinsics.type_is_simple_compare(T
return compare_byte_ptrs((^byte)(&a), (^byte)(&b), size_of(T)) == 0;
}
compare_ptrs :: inline proc(a, b: rawptr, n: int) -> int {
compare_ptrs :: proc(a, b: rawptr, n: int) -> int {
return compare_byte_ptrs((^byte)(a), (^byte)(b), n);
}
ptr_offset :: inline proc(ptr: $P/^$T, n: int) -> P {
ptr_offset :: proc(ptr: $P/^$T, n: int) -> P {
new := int(uintptr(ptr)) + size_of(T)*n;
return P(uintptr(new));
}
ptr_sub :: inline proc(a, b: $P/^$T) -> int {
ptr_sub :: proc(a, b: $P/^$T) -> int {
return (int(uintptr(a)) - int(uintptr(b)))/size_of(T);
}
slice_ptr :: inline proc(ptr: ^$T, len: int) -> []T {
slice_ptr :: proc(ptr: ^$T, len: int) -> []T {
assert(len >= 0);
return transmute([]T)Raw_Slice{data = ptr, len = len};
}
@@ -144,13 +144,13 @@ slice_ptr_to_bytes :: proc(ptr: rawptr, len: int) -> []byte {
return transmute([]byte)Raw_Slice{data = ptr, len = len};
}
slice_to_bytes :: inline proc(slice: $E/[]$T) -> []byte {
slice_to_bytes :: proc(slice: $E/[]$T) -> []byte {
s := transmute(Raw_Slice)slice;
s.len *= size_of(T);
return transmute([]byte)s;
}
slice_data_cast :: inline proc($T: typeid/[]$A, slice: $S/[]$B) -> T {
slice_data_cast :: proc($T: typeid/[]$A, slice: $S/[]$B) -> T {
when size_of(A) == 0 || size_of(B) == 0 {
return nil;
} else {
@@ -165,7 +165,7 @@ slice_to_components :: proc(slice: $E/[]$T) -> (data: ^T, len: int) {
return s.data, s.len;
}
buffer_from_slice :: inline proc(backing: $T/[]$E) -> [dynamic]E {
buffer_from_slice :: proc(backing: $T/[]$E) -> [dynamic]E {
return transmute([dynamic]E)Raw_Dynamic_Array{
data = raw_data(backing),
len = 0,
@@ -174,31 +174,31 @@ buffer_from_slice :: inline proc(backing: $T/[]$E) -> [dynamic]E {
};
}
ptr_to_bytes :: inline proc(ptr: ^$T, len := 1) -> []byte {
ptr_to_bytes :: proc(ptr: ^$T, len := 1) -> []byte {
assert(len >= 0);
return transmute([]byte)Raw_Slice{ptr, len*size_of(T)};
}
any_to_bytes :: inline proc(val: any) -> []byte {
any_to_bytes :: proc(val: any) -> []byte {
ti := type_info_of(val.id);
size := ti != nil ? ti.size : 0;
return transmute([]byte)Raw_Slice{val.data, size};
}
kilobytes :: inline proc(x: int) -> int { return (x) * 1024; }
megabytes :: inline proc(x: int) -> int { return kilobytes(x) * 1024; }
gigabytes :: inline proc(x: int) -> int { return megabytes(x) * 1024; }
terabytes :: inline proc(x: int) -> int { return gigabytes(x) * 1024; }
kilobytes :: proc(x: int) -> int { return (x) * 1024; }
megabytes :: proc(x: int) -> int { return kilobytes(x) * 1024; }
gigabytes :: proc(x: int) -> int { return megabytes(x) * 1024; }
terabytes :: proc(x: int) -> int { return gigabytes(x) * 1024; }
is_power_of_two :: inline proc(x: uintptr) -> bool {
is_power_of_two :: proc(x: uintptr) -> bool {
if x <= 0 {
return false;
}
return (x & (x-1)) == 0;
}
align_forward :: inline proc(ptr: rawptr, align: uintptr) -> rawptr {
align_forward :: proc(ptr: rawptr, align: uintptr) -> rawptr {
return rawptr(align_forward_uintptr(uintptr(ptr), align));
}
@@ -213,14 +213,14 @@ align_forward_uintptr :: proc(ptr, align: uintptr) -> uintptr {
return p;
}
align_forward_int :: inline proc(ptr, align: int) -> int {
align_forward_int :: proc(ptr, align: int) -> int {
return int(align_forward_uintptr(uintptr(ptr), uintptr(align)));
}
align_forward_uint :: inline proc(ptr, align: uint) -> uint {
align_forward_uint :: proc(ptr, align: uint) -> uint {
return uint(align_forward_uintptr(uintptr(ptr), uintptr(align)));
}
align_backward :: inline proc(ptr: rawptr, align: uintptr) -> rawptr {
align_backward :: proc(ptr: rawptr, align: uintptr) -> rawptr {
return rawptr(align_backward_uintptr(uintptr(ptr), align));
}
@@ -229,10 +229,10 @@ align_backward_uintptr :: proc(ptr, align: uintptr) -> uintptr {
return align_forward_uintptr(ptr - align + 1, align);
}
align_backward_int :: inline proc(ptr, align: int) -> int {
align_backward_int :: proc(ptr, align: int) -> int {
return int(align_backward_uintptr(uintptr(ptr), uintptr(align)));
}
align_backward_uint :: inline proc(ptr, align: uint) -> uint {
align_backward_uint :: proc(ptr, align: uint) -> uint {
return uint(align_backward_uintptr(uintptr(ptr), uintptr(align)));
}