Skip to content

Commit d3ac890

Browse files
jtennerjtenner
authored
Update to latest as-pect, fix compiler errors (#26)
* update to latest as-pect, fix ArrayBufferView errors * add compiler errors detection for code exit * remove excess type info * fix up wasi * general cleanups * update to latest aspect and assemblyscript, remove index signatures, add in some unreachable tests * use promises to write files, optimize allocUnsafe
1 parent b6ef8c7 commit d3ac890

5 files changed

Lines changed: 532 additions & 534 deletions

File tree

‎assembly/buffer/index.ts‎

Lines changed: 77 additions & 69 deletions
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,8 @@ import { E_INVALIDLENGTH, E_INDEXOUTOFRANGE } from "util/error";
33
import { Uint8Array } from "typedarray";
44

55
export class Buffer extends Uint8Array {
6+
[key: number]: u8;
7+
68
constructor(size: i32) {
79
super(size);
810
}
@@ -12,15 +14,18 @@ export class Buffer extends Uint8Array {
1214
}
1315

1416
@unsafe static allocUnsafe(size: i32): Buffer {
15-
// Node throws an error if size is less than 0
16-
if (<u32>size > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);
17+
// range must be valid
18+
if (<usize>size > BLOCK_MAXSIZE) throw new RangeError(E_INVALIDLENGTH);
1719
let buffer = __alloc(size, idof<ArrayBuffer>());
18-
// This retains the pointer to the result Buffer.
19-
let result = changetype<Buffer>(__alloc(offsetof<Buffer>(), idof<Buffer>()));
20-
result.data = changetype<ArrayBuffer>(buffer);
21-
result.dataStart = buffer;
22-
result.dataLength = size;
23-
return result;
20+
let result = __alloc(offsetof<Buffer>(), idof<Buffer>());
21+
22+
// set the properties
23+
store<usize>(result, __retain(buffer), offsetof<Buffer>("buffer"));
24+
store<usize>(result, buffer, offsetof<Buffer>("dataStart"));
25+
store<i32>(result, size, offsetof<Buffer>("byteLength"));
26+
27+
// return and retain
28+
return changetype<Buffer>(result);
2429
}
2530

2631
static isBuffer<T>(value: T): bool {
@@ -29,248 +34,251 @@ export class Buffer extends Uint8Array {
2934

3035
// Adapted from https://github.com/AssemblyScript/assemblyscript/blob/master/std/assembly/typedarray.ts
3136
subarray(begin: i32 = 0, end: i32 = 0x7fffffff): Buffer {
32-
var len = <i32>this.dataLength;
37+
var len = <i32>this.byteLength;
3338
begin = begin < 0 ? max(len + begin, 0) : min(begin, len);
3439
end = end < 0 ? max(len + end, 0) : min(end, len);
3540
end = max(end, begin);
36-
var out = changetype<Buffer>(__alloc(offsetof<Buffer>(), idof<Buffer>())); // retains
37-
out.data = this.data; // retains
38-
out.dataStart = this.dataStart + <usize>begin;
39-
out.dataLength = end - begin;
40-
return out;
41+
42+
var out = __alloc(offsetof<Buffer>(), idof<Buffer>()); // retains
43+
store<usize>(out, __retain(changetype<usize>(this.buffer)), offsetof<Buffer>("buffer"));
44+
store<usize>(out, this.dataStart + <usize>begin, offsetof<Buffer>("dataStart"));
45+
store<i32>(out, end - begin, offsetof<Buffer>("byteLength"));
46+
47+
// retains
48+
return changetype<Buffer>(out);
4149
}
4250

4351
readInt8(offset: i32 = 0): i8 {
44-
if (i32(offset < 0) | i32(<u32>offset >= this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
52+
if (i32(offset < 0) | i32(offset >= this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
4553
return load<i8>(this.dataStart + <usize>offset);
4654
}
4755

4856
readUInt8(offset: i32 = 0): u8 {
49-
if (i32(offset < 0) | i32(<u32>offset >= this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
57+
if (i32(offset < 0) | i32(offset >= this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
5058
return load<u8>(this.dataStart + <usize>offset);
5159
}
5260

5361
writeInt8(value: i8, offset: i32 = 0): i32 {
54-
if (i32(offset < 0) | i32(<u32>offset >= this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
62+
if (i32(offset < 0) | i32(offset >= this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
5563
store<i8>(this.dataStart + offset, value);
5664
return offset + 1;
5765
}
5866

5967
writeUInt8(value: u8, offset: i32 = 0): i32 {
60-
if (i32(offset < 0) | i32(<u32>offset >= this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
68+
if (i32(offset < 0) | i32(offset >= this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
6169
store<u8>(this.dataStart + offset, value);
6270
return offset + 1;
6371
}
6472

6573
readInt16LE(offset: i32 = 0): i16 {
66-
if (i32(offset < 0) | i32(<u32>offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
74+
if (i32(offset < 0) | i32(offset + 2 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
6775
return load<i16>(this.dataStart + <usize>offset);
6876
}
6977

7078
readInt16BE(offset: i32 = 0): i16 {
71-
if (i32(offset < 0) | i32(<u32>offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
79+
if (i32(offset < 0) | i32(offset + 2 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
7280
return bswap(load<i16>(this.dataStart + <usize>offset));
7381
}
7482

7583
readUInt16LE(offset: i32 = 0): u16 {
76-
if (i32(offset < 0) | i32(<u32>offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
84+
if (i32(offset < 0) | i32(offset + 2 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
7785
return load<u16>(this.dataStart + <usize>offset);
7886
}
7987

8088
readUInt16BE(offset: i32 = 0): u16 {
81-
if (i32(offset < 0) | i32(<u32>offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
89+
if (i32(offset < 0) | i32(offset + 2 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
8290
return bswap(load<u16>(this.dataStart + <usize>offset));
8391
}
8492

8593
writeInt16LE(value: i16, offset: i32 = 0): i32 {
86-
if (i32(offset < 0) | i32(<u32>offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
94+
if (i32(offset < 0) | i32(offset + 2 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
8795
store<i16>(this.dataStart + offset, value);
8896
return offset + 2;
8997
}
9098

9199
writeInt16BE(value: i16, offset: i32 = 0): i32 {
92-
if (i32(offset < 0) | i32(<u32>offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
100+
if (i32(offset < 0) | i32(offset + 2 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
93101
store<i16>(this.dataStart + offset, bswap(value));
94102
return offset + 2;
95103
}
96104

97105
writeUInt16LE(value: u16, offset: i32 = 0): i32 {
98-
if (i32(offset < 0) | i32(<u32>offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
106+
if (i32(offset < 0) | i32(offset + 2 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
99107
store<u16>(this.dataStart + offset, value);
100108
return offset + 2;
101109
}
102110

103111
writeUInt16BE(value: u16, offset: i32 = 0): i32 {
104-
if (i32(offset < 0) | i32(<u32>offset + 2 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
112+
if (i32(offset < 0) | i32(offset + 2 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
105113
store<u16>(this.dataStart + offset, bswap(value));
106114
return offset + 2;
107115
}
108116

109117
readInt32LE(offset: i32 = 0): i32 {
110-
if (i32(offset < 0) | i32(<u32>offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
118+
if (i32(offset < 0) | i32(offset + 4 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
111119
return load<i32>(this.dataStart + <usize>offset);
112120
}
113121

114122
readInt32BE(offset: i32 = 0): i32 {
115-
if (i32(offset < 0) | i32(<u32>offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
123+
if (i32(offset < 0) | i32(offset + 4 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
116124
return bswap(load<i32>(this.dataStart + <usize>offset));
117125
}
118126

119127
readUInt32LE(offset: i32 = 0): u32 {
120-
if (i32(offset < 0) | i32(<u32>offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
128+
if (i32(offset < 0) | i32(offset + 4 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
121129
return load<u32>(this.dataStart + <usize>offset);
122130
}
123131

124132
readUInt32BE(offset: i32 = 0): u32 {
125-
if (i32(offset < 0) | i32(<u32>offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
133+
if (i32(offset < 0) | i32(offset + 4 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
126134
return bswap(load<u32>(this.dataStart + <usize>offset));
127135
}
128136

129137
writeInt32LE(value: i32, offset: i32 = 0): i32 {
130-
if (i32(offset < 0) | i32(<u32>offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
138+
if (i32(offset < 0) | i32(offset + 4 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
131139
store<i32>(this.dataStart + offset, value);
132140
return offset + 4;
133141
}
134142

135143
writeInt32BE(value: i32, offset: i32 = 0): i32 {
136-
if (i32(offset < 0) | i32(<u32>offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
144+
if (i32(offset < 0) | i32(offset + 4 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
137145
store<i32>(this.dataStart + offset, bswap(value));
138146
return offset + 4;
139147
}
140148

141149
writeUInt32LE(value: u32, offset: i32 = 0): i32 {
142-
if (i32(offset < 0) | i32(<u32>offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
150+
if (i32(offset < 0) | i32(offset + 4 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
143151
store<u32>(this.dataStart + offset, value);
144152
return offset + 4;
145153
}
146154

147155
writeUInt32BE(value: u32, offset: i32 = 0): i32 {
148-
if (i32(offset < 0) | i32(<u32>offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
156+
if (i32(offset < 0) | i32(offset + 4 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
149157
store<u32>(this.dataStart + offset, bswap(value));
150158
return offset + 4;
151159
}
152160

153161
readFloatLE(offset: i32 = 0): f32 {
154-
if (i32(offset < 0) | i32(<u32>offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
162+
if (i32(offset < 0) | i32(offset + 4 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
155163
return load<f32>(this.dataStart + <usize>offset);
156164
}
157165

158166
readFloatBE(offset: i32 = 0): f32 {
159-
if (i32(offset < 0) | i32(<u32>offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
167+
if (i32(offset < 0) | i32(offset + 4 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
160168
return reinterpret<f32>(bswap(load<i32>(this.dataStart + <usize>offset)));
161169
}
162170

163171
writeFloatLE(value: f32, offset: i32 = 0): i32 {
164-
if (i32(offset < 0) | i32(<u32>offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
172+
if (i32(offset < 0) | i32(offset + 4 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
165173
store<f32>(this.dataStart + offset, value);
166174
return offset + 4;
167175
}
168176

169177
writeFloatBE(value: f32, offset: i32 = 0): i32 {
170-
if (i32(offset < 0) | i32(<u32>offset + 4 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
178+
if (i32(offset < 0) | i32(offset + 4 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
171179
store<i32>(this.dataStart + offset, bswap(reinterpret<i32>(value)));
172180
return offset + 4;
173181
}
174182

175183
readBigInt64LE(offset: i32 = 0): i64 {
176-
if (i32(offset < 0) | i32(<u32>offset + 8 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
184+
if (i32(offset < 0) | i32(offset + 8 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
177185
return load<i64>(this.dataStart + <usize>offset);
178186
}
179187

180188
readBigInt64BE(offset: i32 = 0): i64 {
181-
if (i32(offset < 0) | i32(<u32>offset + 8 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
189+
if (i32(offset < 0) | i32(offset + 8 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
182190
return bswap(load<i64>(this.dataStart + <usize>offset));
183191
}
184192

185193
readBigUInt64LE(offset: i32 = 0): u64 {
186-
if (i32(offset < 0) | i32(<u32>offset + 8 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
194+
if (i32(offset < 0) | i32(offset + 8 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
187195
return load<u64>(this.dataStart + <usize>offset);
188196
}
189197

190198
readBigUInt64BE(offset: i32 = 0): u64 {
191-
if (i32(offset < 0) | i32(<u32>offset + 8 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
199+
if (i32(offset < 0) | i32(offset + 8 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
192200
return bswap(load<u64>(this.dataStart + <usize>offset));
193201
}
194202

195203
writeBigInt64LE(value: i64, offset: i32 = 0): i32 {
196-
if (i32(offset < 0) | i32(<u32>offset + 8 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
204+
if (i32(offset < 0) | i32(offset + 8 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
197205
store<i64>(this.dataStart + offset, value);
198206
return offset + 8;
199207
}
200208

201209
writeBigInt64BE(value: i64, offset: i32 = 0): i32 {
202-
if (i32(offset < 0) | i32(<u32>offset + 8 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
210+
if (i32(offset < 0) | i32(offset + 8 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
203211
store<i64>(this.dataStart + offset, bswap(value));
204212
return offset + 8;
205213
}
206214

207215
writeBigUInt64LE(value: u64, offset: i32 = 0): i32 {
208-
if (i32(offset < 0) | i32(<u32>offset + 8 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
216+
if (i32(offset < 0) | i32(offset + 8 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
209217
store<u64>(this.dataStart + offset, value);
210218
return offset + 8;
211219
}
212220

213221
writeBigUInt64BE(value: u64, offset: i32 = 0): i32 {
214-
if (i32(offset < 0) | i32(<u32>offset + 8 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
222+
if (i32(offset < 0) | i32(offset + 8 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
215223
store<u64>(this.dataStart + offset, bswap(value));
216224
return offset + 8;
217225
}
218226

219227
readDoubleLE(offset: i32 = 0): f64 {
220-
if (i32(offset < 0) | i32(<u32>offset + 8 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
228+
if (i32(offset < 0) | i32(offset + 8 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
221229
return load<f64>(this.dataStart + <usize>offset);
222230
}
223231

224232
readDoubleBE(offset: i32 = 0): f64 {
225-
if (i32(offset < 0) | i32(<u32>offset + 8 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
233+
if (i32(offset < 0) | i32(offset + 8 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
226234
return reinterpret<f64>(bswap(load<i64>(this.dataStart + <usize>offset)));
227235
}
228236

229237
writeDoubleLE(value: f64, offset: i32 = 0): i32 {
230-
if (i32(offset < 0) | i32(<u32>offset + 8 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
238+
if (i32(offset < 0) | i32(offset + 8 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
231239
store<f64>(this.dataStart + offset, value);
232240
return offset + 8;
233241
}
234242

235243
writeDoubleBE(value: f64, offset: i32 = 0): i32 {
236-
if (i32(offset < 0) | i32(<u32>offset + 8 > this.dataLength)) throw new RangeError(E_INDEXOUTOFRANGE);
244+
if (i32(offset < 0) | i32(offset + 8 > this.byteLength)) throw new RangeError(E_INDEXOUTOFRANGE);
237245
store<i64>(this.dataStart + offset, bswap(reinterpret<i64>(value)));
238246
return offset + 8;
239247
}
240248

241249
swap16(): Buffer {
242-
let dataLength = this.dataLength;
243-
// Make sure dataLength is even
244-
if (dataLength & 1) throw new RangeError(E_INVALIDLENGTH);
250+
let byteLength = <usize>this.byteLength;
251+
// Make sure byteLength is even
252+
if (byteLength & 1) throw new RangeError(E_INVALIDLENGTH);
245253
let dataStart = this.dataStart;
246-
dataLength += dataStart;
247-
while (dataStart < dataLength) {
254+
byteLength += dataStart;
255+
while (dataStart < byteLength) {
248256
store<u16>(dataStart, bswap(load<u16>(dataStart)));
249257
dataStart += 2;
250258
}
251259
return this;
252260
}
253261

254262
swap32(): Buffer {
255-
let dataLength = this.dataLength;
256-
// Make sure dataLength is divisible by 4
257-
if (dataLength & 3) throw new RangeError(E_INVALIDLENGTH);
263+
let byteLength = <usize>this.byteLength;
264+
// Make sure byteLength is divisible by 4
265+
if (byteLength & 3) throw new RangeError(E_INVALIDLENGTH);
258266
let dataStart = this.dataStart;
259-
dataLength += dataStart;
260-
while (dataStart < dataLength) {
267+
byteLength += dataStart;
268+
while (dataStart < byteLength) {
261269
store<u32>(dataStart, bswap(load<u32>(dataStart)));
262270
dataStart += 4;
263271
}
264272
return this;
265273
}
266274

267275
swap64(): Buffer {
268-
let dataLength = this.dataLength;
269-
// Make sure dataLength is divisible by 8
270-
if (dataLength & 7) throw new RangeError(E_INVALIDLENGTH);
276+
let byteLength = <usize>this.byteLength;
277+
// Make sure byteLength is divisible by 8
278+
if (byteLength & 7) throw new RangeError(E_INVALIDLENGTH);
271279
let dataStart = this.dataStart;
272-
dataLength += dataStart;
273-
while (dataStart < dataLength) {
280+
byteLength += dataStart;
281+
while (dataStart < <usize>byteLength) {
274282
store<u64>(dataStart, bswap(load<u64>(dataStart)));
275283
dataStart += 8;
276284
}
@@ -283,8 +291,8 @@ export namespace Buffer {
283291
/** Calculates the byte length of the specified string when encoded as HEX. */
284292
export function byteLength(str: string): i32 {
285293
let ptr = changetype<usize>(str);
286-
let byteCount = changetype<BLOCK>(changetype<usize>(str) - BLOCK_OVERHEAD).rtSize;
287-
let length = byteCount >> 2;
294+
let byteCount = <usize>changetype<BLOCK>(changetype<usize>(str) - BLOCK_OVERHEAD).rtSize;
295+
let length = byteCount >>> 2;
288296
// The string length must be even because the bytes come in pairs of characters two wide
289297
if (byteCount & 3) return 0; // encoding fails and returns an empty ArrayBuffer
290298

@@ -300,7 +308,7 @@ export namespace Buffer {
300308
return 0;
301309
}
302310
}
303-
return length;
311+
return <i32>length;
304312
}
305313

306314
/** Creates an ArrayBuffer from a given string that is encoded in the HEX format. */
@@ -311,7 +319,7 @@ export namespace Buffer {
311319

312320
// long path: loop over each enociding pair and perform the conversion
313321
let ptr = changetype<usize>(str);
314-
let byteEnd = changetype<BLOCK>(changetype<usize>(str) - BLOCK_OVERHEAD).rtSize + ptr;
322+
let byteEnd = ptr + <usize>changetype<BLOCK>(changetype<usize>(str) - BLOCK_OVERHEAD).rtSize;
315323
let result = __alloc(bufferLength, idof<ArrayBuffer>());
316324
let b: u32 = 0;
317325
let outChar = 0;

0 commit comments

Comments
 (0)