1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
|
package slice
import "core:mem"
ptr_add :: proc(p: $P/^$T, x: int) -> ^T {
return (^T)(uintptr(p) + size_of(T)*x);
}
ptr_sub :: proc(p: $P/^$T, x: int) -> ^T {
return #force_inline ptr_add(p, -x);
}
ptr_swap_non_overlapping :: proc(x, y: rawptr, len: int) {
if len <= 0 {
return;
}
if x == y { // Ignore pointers that are the same
return;
}
Block :: distinct [4]u64;
BLOCK_SIZE :: size_of(Block);
i := 0;
t := &Block{};
for ; i + BLOCK_SIZE <= len; i += BLOCK_SIZE {
a := rawptr(uintptr(x) + uintptr(i));
b := rawptr(uintptr(y) + uintptr(i));
mem.copy(t, a, BLOCK_SIZE);
mem.copy(a, b, BLOCK_SIZE);
mem.copy(b, t, BLOCK_SIZE);
}
if i < len {
rem := len - i;
a := rawptr(uintptr(x) + uintptr(i));
b := rawptr(uintptr(y) + uintptr(i));
mem.copy(t, a, rem);
mem.copy(a, b, rem);
mem.copy(b, t, rem);
}
}
ptr_rotate :: proc(left: int, mid: ^$T, right: int) {
when size_of(T) != 0 {
left, mid, right := left, mid, right;
// TODO(bill): Optimization with a buffer for smaller ranges
if left >= right {
for {
ptr_swap_non_overlapping(ptr_sub(mid, right), mid, right);
mid = ptr_sub(mid, right);
left -= right;
if left < right {
break;
}
}
} else {
ptr_swap_non_overlapping(ptr_sub(mid, left), mid, left);
mid = ptr_add(mid, left);
right -= left;
if right < left {
break;
}
}
}
}
|
