fluencelabs/assemblyscript
1
0
Fork 0
mirror of https://github.com/fluencelabs/assemblyscript synced 2025-06-23 19:51:47 +00:00
Code Issues Projects Releases Wiki Activity

Add bounds checks to DataView and fix some lint issues

Browse Source
This commit is contained in:
dcodeIO
2018-11-12 09:11:04 +01:00
parent 1882679807
commit 84ffa91db9
5 changed files with 4541 additions and 3046 deletions
Download Patch File Download Diff File Expand all files Collapse all files

156
std/assembly/dataview.ts
View File

@ -1,129 +1,185 @@
import { HEADER_SIZE } from "./internal/arraybuffer";
import {
HEADER_SIZE,
MAX_BLENGTH
} from "./internal/arraybuffer";
export class DataView {
constructor(
readonly buffer: ArrayBuffer,
readonly byteOffset: i32 = 0,
readonly byteLength: i32 = i32.MIN_VALUE,
readonly byteLength: i32 = i32.MIN_VALUE // FIXME
) {
if (byteLength === i32.MIN_VALUE) byteLength = buffer.byteLength - byteOffset;
if (byteOffset < 0) throw new RangeError("byteOffset cannot be negative");
if (byteLength < 0) throw new RangeError("byteLength cannot be negative");
if (byteOffset + byteLength > buffer.byteLength) throw new RangeError("Length out of range of buffer");
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>MAX_BLENGTH) throw new RangeError("Invalid byteLength");
if (byteOffset + byteLength > buffer.byteLength) throw new RangeError("Invalid length");
}
@inline
getFloat32(byteOffset: i32, littleEndian: boolean = false): f32 {
var result: u32 = load<u32>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE);
return reinterpret<f32>(littleEndian ? result : bswap<u32>(result));
checkOffset(byteOffset, 4, this.byteLength);
return littleEndian
? load<f32>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE)
: reinterpret<f32>(
bswap<u32>(
load<u32>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE)
)
);
}
@inline
getFloat64(byteOffset: i32, littleEndian: boolean = false): f64 {
var result: u64 = load<u64>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE);
return reinterpret<f64>(littleEndian ? result : bswap<u64>(result));
checkOffset(byteOffset, 8, this.byteLength);
return littleEndian
? load<f64>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE)
: reinterpret<f64>(
bswap(
load<u64>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE)
)
);
}
@inline
getInt8(byteOffset: i32): i8 {
checkOffset(byteOffset, 1, this.byteLength);
return load<i8>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE);
}
@inline
getInt16(byteOffset: i32, littleEndian: boolean = false): i16 {
checkOffset(byteOffset, 2, this.byteLength);
var result: i16 = load<i16>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE);
return littleEndian ? result : bswap<i16>(result);
}
@inline
getInt32(byteOffset: i32, littleEndian: boolean = false): i32 {
var result: i32 = load<i32>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE);
checkOffset(byteOffset, 4, this.byteLength);
var result = load<i32>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE);
return littleEndian ? result : bswap<i32>(result);
}
@inline
getUint8(byteOffset: i32): u8 {
checkOffset(byteOffset, 1, this.byteLength);
return load<u8>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE);
}
@inline
getUint16(byteOffset: i32, littleEndian: boolean = false): u16 {
checkOffset(byteOffset, 2, this.byteLength);
var result: u16 = load<u16>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE);
return littleEndian ? result : bswap<u16>(result);
}
@inline
getUint32(byteOffset: i32, littleEndian: boolean = false): u32 {
var result: u32 = load<u32>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE);
checkOffset(byteOffset, 4, this.byteLength);
var result = load<u32>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE);
return littleEndian ? result : bswap<u32>(result);
}
@inline
setFloat32(byteOffset: i32, value: f32, littleEndian: boolean = false): void {
var input: f32 = littleEndian ? value : reinterpret<f32>(bswap<u32>(reinterpret<u32>(value)));
store<f32>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, input, HEADER_SIZE);
checkOffset(byteOffset, 4, this.byteLength);
if (littleEndian) {
store<f32>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, value, HEADER_SIZE);
} else {
store<u32>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset,
bswap(
reinterpret<u32>(value)
),
HEADER_SIZE
);
}
}
@inline
setFloat64(byteOffset: i32, value: f64, littleEndian: boolean = false): void {
var input: f64 = littleEndian ? value : reinterpret<f64>(bswap<u64>(reinterpret<u64>(value)));
store<f64>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, input, HEADER_SIZE);
checkOffset(byteOffset, 8, this.byteLength);
if (littleEndian) {
store<f64>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, value, HEADER_SIZE);
} else {
store<u64>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset,
bswap(
reinterpret<u64>(value)
),
HEADER_SIZE
);
}
}
@inline
setInt8(byteOffset: i32, value: i8): void {
checkOffset(byteOffset, 1, this.byteLength);
store<i8>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, value, HEADER_SIZE);
}
@inline
setInt16(byteOffset: i32, value: i16, littleEndian: boolean = false): void {
store<i16>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, littleEndian ? value : bswap<i16>(value), HEADER_SIZE);
checkOffset(byteOffset, 2, this.byteLength);
store<i16>(
changetype<usize>(this.buffer) + this.byteOffset + byteOffset,
littleEndian ? value : bswap(value),
HEADER_SIZE
);
}
@inline
setInt32(byteOffset: i32, value: i32, littleEndian: boolean = false): void {
store<i32>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, littleEndian ? value : bswap<i32>(value), HEADER_SIZE);
checkOffset(byteOffset, 4, this.byteLength);
store<i32>(
changetype<usize>(this.buffer) + this.byteOffset + byteOffset,
littleEndian ? value : bswap(value),
HEADER_SIZE
);
}
@inline
setUint8(byteOffset: i32, value: u8): void {
checkOffset(byteOffset, 1, this.byteLength);
store<u8>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, value, HEADER_SIZE);
}
@inline
setUint16(byteOffset: i32, value: u16, littleEndian: boolean = false): void {
store<u16>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, littleEndian ? value : bswap<u16>(value), HEADER_SIZE);
checkOffset(byteOffset, 2, this.byteLength);
store<u16>(
changetype<usize>(this.buffer) + this.byteOffset + byteOffset,
littleEndian ? value : bswap(value),
HEADER_SIZE
);
}
@inline
setUint32(byteOffset: i32, value: u32, littleEndian: boolean = false): void {
store<u32>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, littleEndian ? value : bswap<u32>(value), HEADER_SIZE);
checkOffset(byteOffset, 4, this.byteLength);
store<u32>(
changetype<usize>(this.buffer) + this.byteOffset + byteOffset,
littleEndian ? value : bswap(value),
HEADER_SIZE
);
}
/**
* Non-standard additions that makes sense in WebAssembly, but won't work in JS
*/
// Non-standard additions that make sense in WebAssembly, but won't work in JS:
@inline
getInt64(byteOffset: i32, littleEndian: boolean = false): i64 {
var result: i64 = load<i64>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE);
return littleEndian ? result : bswap<i64>(result);
checkOffset(byteOffset, 8, this.byteLength);
var result = load<i64>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE);
return littleEndian ? result : bswap(result);
}
@inline
getUint64(byteOffset: i32, littleEndian: boolean = false): u64 {
var result: u64 = load<u64>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE);
return littleEndian ? result : bswap<u64>(result);
checkOffset(byteOffset, 8, this.byteLength);
var result = load<u64>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, HEADER_SIZE);
return littleEndian ? result : bswap(result);
}
@inline
setInt64(byteOffset: i32, value: i64, littleEndian: boolean = false): void {
store<i64>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, littleEndian ? value : bswap<i64>(value), HEADER_SIZE);
checkOffset(byteOffset, 8, this.byteLength);
store<i64>(
changetype<usize>(this.buffer) + this.byteOffset + byteOffset,
littleEndian ? value : bswap(value),
HEADER_SIZE
);
}
@inline
setUint64(byteOffset: i32, value: u64, littleEndian: boolean = false): void {
store<u64>(changetype<usize>(this.buffer) + this.byteOffset + byteOffset, littleEndian ? value : bswap<u64>(value), HEADER_SIZE);
checkOffset(byteOffset, 8, this.byteLength);
store<u64>(
changetype<usize>(this.buffer) + this.byteOffset + byteOffset,
littleEndian ? value : bswap(value),
HEADER_SIZE
);
}
}
@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");
}