fluencelabs/assemblyscript
1
0
Fork 0
mirror of https://github.com/fluencelabs/assemblyscript synced 2025-06-18 09:21:35 +00:00
Code Issues Projects Releases Wiki Activity

checked builtin array get, optimize abv layout

Browse Source
This commit is contained in:
dcode
2019-03-17 08:46:26 +01:00
parent e63c6bd388
commit f21b339563
20 changed files with 4772 additions and 1568 deletions
Download Patch File Download Diff File Expand all files Collapse all files

138
std/assembly/dataview.ts
View File

@ -5,7 +5,7 @@ export class DataView {
private data: ArrayBuffer;
private dataStart: usize;
private dataEnd: usize;
private dataLength: u32;
constructor(
buffer: ArrayBuffer,
@ -18,7 +18,7 @@ export class DataView {
this.data = buffer; // links
var dataStart = changetype<usize>(buffer) + <usize>byteOffset;
this.dataStart = dataStart;
this.dataEnd = dataStart + <usize>byteLength;
this.dataLength = byteLength;
}
get buffer(): ArrayBuffer {
@ -30,169 +30,129 @@ export class DataView {
}
get byteLength(): i32 {
return <i32>(this.dataEnd - this.dataStart);
return this.dataLength;
}
getFloat32(byteOffset: i32, littleEndian: boolean = false): f32 {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 4 > this.dataEnd) throw new Error("Offset out of bounds");
if (byteOffset + 4 > this.dataLength) throw new Error("Offset out of bounds");
return littleEndian
? load<f32>(dataOffset)
? load<f32>(this.dataStart + <usize>byteOffset)
: reinterpret<f32>(
bswap<u32>(
load<u32>(dataOffset)
load<u32>(this.dataStart + <usize>byteOffset)
)
);
}
getFloat64(byteOffset: i32, littleEndian: boolean = false): f64 {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 4 > this.dataEnd) throw new Error("Offset out of bounds");
if (byteOffset + 4 > this.dataLength) throw new Error("Offset out of bounds");
return littleEndian
? load<f64>(dataOffset)
? load<f64>(this.dataStart + <usize>byteOffset)
: reinterpret<f64>(
bswap<u64>(
load<u64>(dataOffset)
load<u64>(this.dataStart + <usize>byteOffset)
)
);
}
getInt8(byteOffset: i32): i8 {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset >= this.dataEnd) throw new Error("Offset out of bounds");
return load<i8>(dataOffset);
if (byteOffset >= this.dataLength) throw new Error("Offset out of bounds");
return load<i8>(this.dataStart + <usize>byteOffset);
}
getInt16(byteOffset: i32, littleEndian: boolean = false): i16 {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 2 > this.dataEnd) throw new Error("Offset out of bounds");
var result: i16 = load<i16>(dataOffset);
if (byteOffset + 2 > this.dataLength) throw new Error("Offset out of bounds");
var result: i16 = load<i16>(this.dataStart + <usize>byteOffset);
return littleEndian ? result : bswap<i16>(result);
}
getInt32(byteOffset: i32, littleEndian: boolean = false): i32 {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 4 > this.dataEnd) throw new Error("Offset out of bounds");
var result: i32 = load<i32>(dataOffset);
if (byteOffset + 4 > this.dataLength) throw new Error("Offset out of bounds");
var result: i32 = load<i32>(this.dataStart + <usize>byteOffset);
return littleEndian ? result : bswap<i32>(result);
}
getUint8(byteOffset: i32): u8 {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset >= this.dataEnd) throw new Error("Offset out of bounds");
return load<u8>(dataOffset);
if (byteOffset >= this.dataLength) throw new Error("Offset out of bounds");
return load<u8>(this.dataStart + <usize>byteOffset);
}
getUint16(byteOffset: i32, littleEndian: boolean = false): u16 {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 2 > this.dataEnd) throw new Error("Offset out of bounds");
var result: u16 = load<u16>(dataOffset);
if (byteOffset + 2 > this.dataLength) throw new Error("Offset out of bounds");
var result: u16 = load<u16>(this.dataStart + <usize>byteOffset);
return littleEndian ? result : bswap<u16>(result);
}
getUint32(byteOffset: i32, littleEndian: boolean = false): u32 {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 2 > this.dataEnd) throw new Error("Offset out of bounds");
var result: u32 = load<u32>(dataOffset);
if (byteOffset + 2 > this.dataLength) throw new Error("Offset out of bounds");
var result: u32 = load<u32>(this.dataStart + <usize>byteOffset);
return littleEndian ? result : bswap<u32>(result);
}
setFloat32(byteOffset: i32, value: f32, littleEndian: boolean = false): void {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 4 > this.dataEnd) throw new Error("Offset out of bounds");
if (littleEndian) store<f32>(dataOffset, value);
else store<u32>(dataOffset, bswap(reinterpret<u32>(value)));
if (byteOffset + 4 > this.dataLength) throw new Error("Offset out of bounds");
if (littleEndian) store<f32>(this.dataStart + <usize>byteOffset, value);
else store<u32>(this.dataStart + <usize>byteOffset, bswap<u32>(reinterpret<u32>(value)));
}
setFloat64(byteOffset: i32, value: f64, littleEndian: boolean = false): void {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 4 > this.dataEnd) throw new Error("Offset out of bounds");
if (littleEndian) store<f64>(dataOffset, value);
else store<u64>(dataOffset, bswap(reinterpret<u64>(value)));
if (byteOffset + 8 > this.dataLength) throw new Error("Offset out of bounds");
if (littleEndian) store<f64>(this.dataStart + <usize>byteOffset, value);
else store<u64>(this.dataStart + <usize>byteOffset, bswap<u64>(reinterpret<u64>(value)));
}
setInt8(byteOffset: i32, value: i8): void {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset >= this.dataEnd) throw new Error("Offset out of bounds");
store<i8>(dataOffset, value);
if (byteOffset >= this.dataLength) throw new Error("Offset out of bounds");
store<i8>(this.dataStart + <usize>byteOffset, value);
}
setInt16(byteOffset: i32, value: i16, littleEndian: boolean = false): void {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 2 > this.dataEnd) throw new Error("Offset out of bounds");
store<i16>(dataOffset, littleEndian ? value : bswap(value));
if (byteOffset + 2 > this.dataLength) throw new Error("Offset out of bounds");
store<i16>(this.dataStart + <usize>byteOffset, littleEndian ? value : bswap<i16>(value));
}
setInt32(byteOffset: i32, value: i32, littleEndian: boolean = false): void {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 4 > this.dataEnd) throw new Error("Offset out of bounds");
store<i32>(dataOffset, littleEndian ? value : bswap(value));
if (byteOffset + 4 > this.dataLength) throw new Error("Offset out of bounds");
store<i32>(this.dataStart + <usize>byteOffset, littleEndian ? value : bswap<i32>(value));
}
setUint8(byteOffset: i32, value: u8): void {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset >= this.dataEnd) throw new Error("Offset out of bounds");
store<u8>(dataOffset, value);
if (byteOffset >= this.dataLength) throw new Error("Offset out of bounds");
store<u8>(this.dataStart + <usize>byteOffset, value);
}
setUint16(byteOffset: i32, value: u16, littleEndian: boolean = false): void {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 2 > this.dataEnd) throw new Error("Offset out of bounds");
store<u16>(dataOffset, littleEndian ? value : bswap(value));
if (byteOffset + 2 > this.dataLength) throw new Error("Offset out of bounds");
store<u16>(this.dataStart + <usize>byteOffset, littleEndian ? value : bswap<u16>(value));
}
setUint32(byteOffset: i32, value: u32, littleEndian: boolean = false): void {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 4 > this.dataEnd) throw new Error("Offset out of bounds");
store<u32>(dataOffset, littleEndian ? value : bswap(value));
if (byteOffset + 4 > this.dataLength) throw new Error("Offset out of bounds");
store<u32>(this.dataStart + <usize>byteOffset, littleEndian ? value : bswap<u32>(value));
}
// Non-standard additions that make sense in WebAssembly, but won't work in JS:
getInt64(byteOffset: i32, littleEndian: boolean = false): i64 {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 8 > this.dataEnd) throw new Error("Offset out of bounds");
var result: i64 = load<i64>(dataOffset);
return littleEndian ? result : bswap(result);
if (byteOffset + 8 > this.dataLength) throw new Error("Offset out of bounds");
var result: i64 = load<i64>(this.dataStart + <usize>byteOffset);
return littleEndian ? result : bswap<i64>(result);
}
getUint64(byteOffset: i32, littleEndian: boolean = false): u64 {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 8 > this.dataEnd) throw new Error("Offset out of bounds");
var result = load<u64>(dataOffset);
return littleEndian ? result : bswap(result);
if (byteOffset + 8 > this.dataLength) throw new Error("Offset out of bounds");
var result = load<u64>(this.dataStart + <usize>byteOffset);
return littleEndian ? result : bswap<u64>(result);
}
setInt64(byteOffset: i32, value: i64, littleEndian: boolean = false): void {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 8 > this.dataEnd) throw new Error("Offset out of bounds");
store<i64>(dataOffset, littleEndian ? value : bswap(value));
if (byteOffset + 8 > this.dataLength) throw new Error("Offset out of bounds");
store<i64>(this.dataStart + <usize>byteOffset, littleEndian ? value : bswap<i64>(value));
}
setUint64(byteOffset: i32, value: u64, littleEndian: boolean = false): void {
var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 8 > this.dataEnd) throw new Error("Offset out of bounds");
store<u64>(dataOffset, littleEndian ? value : bswap(value));
if (byteOffset + 8 > this.dataLength) throw new Error("Offset out of bounds");
store<u64>(this.dataStart + <usize>byteOffset, littleEndian ? value : bswap<u64>(value));
}
toString(): string {