fluencelabs/assemblyscript
1
0
Fork 0
mirror of https://github.com/fluencelabs/assemblyscript synced 2025-04-29 08:52:15 +00:00
Code Issues Projects Releases Wiki Activity

dataview

Browse Source
This commit is contained in:
dcode 2019-03-13 03:39:27 +01:00
parent e78c4c7f54
commit 37d361bafd
1 changed files with 111 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

211
std/assembly/dataview.ts
View File

@ -1,189 +1,200 @@
import { import { ArrayBuffer } from "./arraybuffer";
HEADER_SIZE,
MAX_BLENGTH
} from "./internal/arraybuffer";
export class DataView { export class DataView {
private data: ArrayBuffer;
private dataStart: usize;
private dataEnd: usize;
constructor( constructor(
readonly buffer: ArrayBuffer, buffer: ArrayBuffer,
readonly byteOffset: i32 = 0, byteOffset: i32 = 0,
readonly byteLength: i32 = i32.MIN_VALUE // FIXME byteLength: i32 = i32.MIN_VALUE // FIXME
) { ) {
if (byteLength === i32.MIN_VALUE) byteLength = buffer.byteLength - byteOffset; // FIXME if (byteLength === i32.MIN_VALUE) byteLength = buffer.byteLength - byteOffset; // FIXME
if (<u32>byteOffset > <u32>MAX_BLENGTH) throw new RangeError("Invalid byteOffset"); if (<u32>byteLength > <u32>ArrayBuffer.MAX_BYTELENGTH) throw new RangeError("Invalid byteLength");
if (<u32>byteLength > <u32>MAX_BLENGTH) throw new RangeError("Invalid byteLength"); if (<u32>byteOffset + byteLength > <u32>buffer.byteLength) throw new RangeError("Invalid length");
if (byteOffset + byteLength > buffer.byteLength) throw new RangeError("Invalid length"); this.data = buffer; // links
var dataStart = changetype<usize>(buffer) + <usize>byteOffset;
this.dataStart = dataStart;
this.dataEnd = dataStart + <usize>byteLength;
}
get buffer(): ArrayBuffer {
return this.data;
}
get byteOffset(): i32 {
return <i32>(this.dataStart - changetype<usize>(this.data));
}
get byteLength(): i32 {
return <i32>(this.dataEnd - this.dataStart);
} }
getFloat32(byteOffset: i32, littleEndian: boolean = false): f32 { getFloat32(byteOffset: i32, littleEndian: boolean = false): f32 {
checkOffset(byteOffset, 4, this.byteLength); var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 4 > this.dataEnd) throw new Error("Offset out of bounds");
return littleEndian return littleEndian
? load<f32>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE) ? load<f32>(dataOffset)
: reinterpret<f32>( : reinterpret<f32>(
bswap<u32>( bswap<u32>(
load<u32>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE) load<u32>(dataOffset)
) )
); );
} }
getFloat64(byteOffset: i32, littleEndian: boolean = false): f64 { getFloat64(byteOffset: i32, littleEndian: boolean = false): f64 {
checkOffset(byteOffset, 8, this.byteLength); var dataStart = this.dataStart;
var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 4 > this.dataEnd) throw new Error("Offset out of bounds");
return littleEndian return littleEndian
? load<f64>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE) ? load<f64>(dataOffset)
: reinterpret<f64>( : reinterpret<f64>(
bswap( bswap<u64>(
load<u64>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE) load<u64>(dataOffset)
) )
); );
} }
getInt8(byteOffset: i32): i8 { getInt8(byteOffset: i32): i8 {
checkOffset(byteOffset, 1, this.byteLength); var dataStart = this.dataStart;
return load<i8>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE); var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset >= this.dataEnd) throw new Error("Offset out of bounds");
return load<i8>(dataOffset);
} }
getInt16(byteOffset: i32, littleEndian: boolean = false): i16 { getInt16(byteOffset: i32, littleEndian: boolean = false): i16 {
checkOffset(byteOffset, 2, this.byteLength); var dataStart = this.dataStart;
var result: i16 = load<i16>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE); var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 2 > this.dataEnd) throw new Error("Offset out of bounds");
var result: i16 = load<i16>(dataOffset);
return littleEndian ? result : bswap<i16>(result); return littleEndian ? result : bswap<i16>(result);
} }
getInt32(byteOffset: i32, littleEndian: boolean = false): i32 { getInt32(byteOffset: i32, littleEndian: boolean = false): i32 {
checkOffset(byteOffset, 4, this.byteLength); var dataStart = this.dataStart;
var result = load<i32>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE); var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 4 > this.dataEnd) throw new Error("Offset out of bounds");
var result: i32 = load<i32>(dataOffset);
return littleEndian ? result : bswap<i32>(result); return littleEndian ? result : bswap<i32>(result);
} }
getUint8(byteOffset: i32): u8 { getUint8(byteOffset: i32): u8 {
checkOffset(byteOffset, 1, this.byteLength); var dataStart = this.dataStart;
return load<u8>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE); var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset >= this.dataEnd) throw new Error("Offset out of bounds");
return load<u8>(dataOffset);
} }
getUint16(byteOffset: i32, littleEndian: boolean = false): u16 { getUint16(byteOffset: i32, littleEndian: boolean = false): u16 {
checkOffset(byteOffset, 2, this.byteLength); var dataStart = this.dataStart;
var result: u16 = load<u16>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE); var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 2 > this.dataEnd) throw new Error("Offset out of bounds");
var result: u16 = load<u16>(dataOffset);
return littleEndian ? result : bswap<u16>(result); return littleEndian ? result : bswap<u16>(result);
} }
getUint32(byteOffset: i32, littleEndian: boolean = false): u32 { getUint32(byteOffset: i32, littleEndian: boolean = false): u32 {
checkOffset(byteOffset, 4, this.byteLength); var dataStart = this.dataStart;
var result = load<u32>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE); var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset + 2 > this.dataEnd) throw new Error("Offset out of bounds");
var result: u32 = load<u32>(dataOffset);
return littleEndian ? result : bswap<u32>(result); return littleEndian ? result : bswap<u32>(result);
} }
setFloat32(byteOffset: i32, value: f32, littleEndian: boolean = false): void { setFloat32(byteOffset: i32, value: f32, littleEndian: boolean = false): void {
checkOffset(byteOffset, 4, this.byteLength); var dataStart = this.dataStart;
if (littleEndian) { var dataOffset = dataStart + <usize>byteOffset;
store<f32>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, value, HEADER_SIZE); if (dataOffset + 4 > this.dataEnd) throw new Error("Offset out of bounds");
} else { if (littleEndian) store<f32>(dataOffset, value);
store<u32>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, else store<u32>(dataOffset, bswap(reinterpret<u32>(value)));
bswap(
reinterpret<u32>(value)
),
HEADER_SIZE
);
}
} }
setFloat64(byteOffset: i32, value: f64, littleEndian: boolean = false): void { setFloat64(byteOffset: i32, value: f64, littleEndian: boolean = false): void {
checkOffset(byteOffset, 8, this.byteLength); var dataStart = this.dataStart;
if (littleEndian) { var dataOffset = dataStart + <usize>byteOffset;
store<f64>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, value, HEADER_SIZE); if (dataOffset + 4 > this.dataEnd) throw new Error("Offset out of bounds");
} else { if (littleEndian) store<f64>(dataOffset, value);
store<u64>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, else store<u64>(dataOffset, bswap(reinterpret<u64>(value)));
bswap(
reinterpret<u64>(value)
),
HEADER_SIZE
);
}
} }
setInt8(byteOffset: i32, value: i8): void { setInt8(byteOffset: i32, value: i8): void {
checkOffset(byteOffset, 1, this.byteLength); var dataStart = this.dataStart;
store<i8>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, value, HEADER_SIZE); var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset >= this.dataEnd) throw new Error("Offset out of bounds");
store<i8>(dataOffset, value);
} }
setInt16(byteOffset: i32, value: i16, littleEndian: boolean = false): void { setInt16(byteOffset: i32, value: i16, littleEndian: boolean = false): void {
checkOffset(byteOffset, 2, this.byteLength); var dataStart = this.dataStart;
store<i16>( var dataOffset = dataStart + <usize>byteOffset;
changetype<usize>(this.buffer) + this.byteOffset + byteOffset, if (dataOffset + 2 > this.dataEnd) throw new Error("Offset out of bounds");
littleEndian ? value : bswap(value), store<i16>(dataOffset, littleEndian ? value : bswap(value));
HEADER_SIZE
);
} }
setInt32(byteOffset: i32, value: i32, littleEndian: boolean = false): void { setInt32(byteOffset: i32, value: i32, littleEndian: boolean = false): void {
checkOffset(byteOffset, 4, this.byteLength); var dataStart = this.dataStart;
store<i32>( var dataOffset = dataStart + <usize>byteOffset;
changetype<usize>(this.buffer) + this.byteOffset + byteOffset, if (dataOffset + 4 > this.dataEnd) throw new Error("Offset out of bounds");
littleEndian ? value : bswap(value), store<i32>(dataOffset, littleEndian ? value : bswap(value));
HEADER_SIZE
);
} }
setUint8(byteOffset: i32, value: u8): void { setUint8(byteOffset: i32, value: u8): void {
checkOffset(byteOffset, 1, this.byteLength); var dataStart = this.dataStart;
store<u8>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, value, HEADER_SIZE); var dataOffset = dataStart + <usize>byteOffset;
if (dataOffset >= this.dataEnd) throw new Error("Offset out of bounds");
store<u8>(dataOffset, value);
} }
setUint16(byteOffset: i32, value: u16, littleEndian: boolean = false): void { setUint16(byteOffset: i32, value: u16, littleEndian: boolean = false): void {
checkOffset(byteOffset, 2, this.byteLength); var dataStart = this.dataStart;
store<u16>( var dataOffset = dataStart + <usize>byteOffset;
changetype<usize>(this.buffer) + this.byteOffset + byteOffset, if (dataOffset + 2 > this.dataEnd) throw new Error("Offset out of bounds");
littleEndian ? value : bswap(value), store<u16>(dataOffset, littleEndian ? value : bswap(value));
HEADER_SIZE
);
} }
setUint32(byteOffset: i32, value: u32, littleEndian: boolean = false): void { setUint32(byteOffset: i32, value: u32, littleEndian: boolean = false): void {
checkOffset(byteOffset, 4, this.byteLength); var dataStart = this.dataStart;
store<u32>( var dataOffset = dataStart + <usize>byteOffset;
changetype<usize>(this.buffer) + this.byteOffset + byteOffset, if (dataOffset + 4 > this.dataEnd) throw new Error("Offset out of bounds");
littleEndian ? value : bswap(value), store<u32>(dataOffset, littleEndian ? value : bswap(value));
HEADER_SIZE
);
} }
// Non-standard additions that make sense in WebAssembly, but won't work in JS: // Non-standard additions that make sense in WebAssembly, but won't work in JS:
getInt64(byteOffset: i32, littleEndian: boolean = false): i64 { getInt64(byteOffset: i32, littleEndian: boolean = false): i64 {
checkOffset(byteOffset, 8, this.byteLength); var dataStart = this.dataStart;
var result = load<i64>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE); 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); return littleEndian ? result : bswap(result);
} }
getUint64(byteOffset: i32, littleEndian: boolean = false): u64 { getUint64(byteOffset: i32, littleEndian: boolean = false): u64 {
checkOffset(byteOffset, 8, this.byteLength); var dataStart = this.dataStart;
var result = load<u64>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE); 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); return littleEndian ? result : bswap(result);
} }
setInt64(byteOffset: i32, value: i64, littleEndian: boolean = false): void { setInt64(byteOffset: i32, value: i64, littleEndian: boolean = false): void {
checkOffset(byteOffset, 8, this.byteLength); var dataStart = this.dataStart;
store<i64>( var dataOffset = dataStart + <usize>byteOffset;
changetype<usize>(this.buffer) + this.byteOffset + byteOffset, if (dataOffset + 8 > this.dataEnd) throw new Error("Offset out of bounds");
littleEndian ? value : bswap(value), store<i64>(dataOffset, littleEndian ? value : bswap(value));
HEADER_SIZE
);
} }
setUint64(byteOffset: i32, value: u64, littleEndian: boolean = false): void { setUint64(byteOffset: i32, value: u64, littleEndian: boolean = false): void {
checkOffset(byteOffset, 8, this.byteLength); var dataStart = this.dataStart;
store<u64>( var dataOffset = dataStart + <usize>byteOffset;
changetype<usize>(this.buffer) + this.byteOffset + byteOffset, if (dataOffset + 8 > this.dataEnd) throw new Error("Offset out of bounds");
littleEndian ? value : bswap(value), store<u64>(dataOffset, littleEndian ? value : bswap(value));
HEADER_SIZE
);
} }
toString(): string { toString(): string {
return "[object DataView]"; return "[object DataView]";
} }
} }
@inline function checkOffset(byteOffset: i32, n: i32, byteLength: i32): void {
// n and byteLength must be known to be in bounds
if (<u32>byteOffset > <u32>MAX_BLENGTH || byteOffset + n > byteLength) throw new Error("Offset out of bounds");
}