-
-
Notifications
You must be signed in to change notification settings - Fork 687
Expand file tree
/
Copy pathbytes.ts
More file actions
107 lines (102 loc) · 2.73 KB
/
bytes.ts
File metadata and controls
107 lines (102 loc) · 2.73 KB
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
export function REVERSE<T>(ptr: usize, len: usize): void {
if (len > 1) {
let
i: usize = 0,
tail: usize,
hlen: usize = len >> 1;
if (ASC_SHRINK_LEVEL < 1) {
if (sizeof<T>() == 1) {
// TODO: Decide later: Does we need this fast path cases?
//
// if (len == 4) {
// store<u32>(ptr, bswap(load<u32>(ptr)));
// return;
// }
// if (len == 8) {
// store<u64>(ptr, bswap(load<u64>(ptr)));
// return;
// }
tail = len - 8;
while (i + 7 < hlen) {
let front = ptr + i;
let back = ptr + tail - i;
let temp = bswap(load<u64>(front));
store<u64>(front, bswap(load<u64>(back)));
store<u64>(back, temp);
i += 8;
}
}
if (sizeof<T>() == 2) {
tail = len - 2;
while (i + 1 < hlen) {
let front = ptr + (i << 1);
let back = ptr + (tail - i << 1);
let temp = rotr(load<u32>(back), 16);
store<u32>(back, rotr(load<u32>(front), 16));
store<u32>(front, temp);
i += 2;
}
}
}
tail = len - 1;
while (i < hlen) {
let front = ptr + (i << alignof<T>());
let back = ptr + (tail - i << alignof<T>());
let temp = load<T>(front);
store<T>(front, load<T>(back));
store<T>(back, temp);
i++;
}
}
}
export function FILL<T>(
ptr: usize,
len: usize,
value: T,
start: isize,
end: isize
): void {
start = start < 0 ? max(len + start, 0) : min(start, len);
end = end < 0 ? max(len + end, 0) : min(end, len);
if (sizeof<T>() == 1) {
if (start < end) {
memory.fill(
ptr + <usize>start,
u8(value),
<usize>(end - start)
);
}
} else {
if (ASC_SHRINK_LEVEL <= 1) {
if (isInteger<T>()) {
// @ts-ignore
if (value == <T>0 | value == <T>-1) {
if (start < end) {
memory.fill(
ptr + (<usize>start << alignof<T>()),
u8(value),
<usize>(end - start) << alignof<T>()
);
}
return;
}
} else if (isFloat<T>()) {
// for floating non-negative zeros we can use fast memory.fill
if ((sizeof<T>() == 4 && reinterpret<u32>(f32(value)) == 0) ||
(sizeof<T>() == 8 && reinterpret<u64>(f64(value)) == 0)) {
if (start < end) {
memory.fill(
ptr + (<usize>start << alignof<T>()),
0,
<usize>(end - start) << alignof<T>()
);
}
return;
}
}
}
for (; start < end; ++start) {
store<T>(ptr + (<usize>start << alignof<T>()), value);
}
}
}