toilscript 0.0.1

package/std/assembly/byteslice.ts

@@ -0,0 +1,177 @@
+/// <reference path="./rt/index.d.ts" />
+
+import { Pointer } from "./pointer";
+import { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from "./util/error";
+
+// Zero-alloc memory view: pointer + length with bounds-checked endian-aware reads/writes.
+// Unlike DataView, does not own an ArrayBuffer — the viewed memory is unowned/raw.
+
+@final
+export class ByteSlice {
+  readonly ptr: usize;
+  readonly length: i32;
+
+  constructor(ptr: usize, length: i32) {
+    if (length < 0) throw new RangeError(E_INVALIDLENGTH);
+    this.ptr = ptr;
+    this.length = length;
+  }
+
+  // --- Unsigned reads ---
+
+  @inline getU8(offset: i32): u8 {
+    if (<u32>offset >= <u32>this.length) throw new RangeError(E_INDEXOUTOFRANGE);
+    return load<u8>(this.ptr + <usize>offset);
+  }
+
+  @inline getU16(offset: i32, be: bool = true): u16 {
+    if ((offset >>> 31) | i32(offset + 2 > this.length)) throw new RangeError(E_INDEXOUTOFRANGE);
+    let v = load<u16>(this.ptr + <usize>offset);
+    return be ? bswap<u16>(v) : v;
+  }
+
+  @inline getU32(offset: i32, be: bool = true): u32 {
+    if ((offset >>> 31) | i32(offset + 4 > this.length)) throw new RangeError(E_INDEXOUTOFRANGE);
+    let v = load<u32>(this.ptr + <usize>offset);
+    return be ? bswap<u32>(v) : v;
+  }
+
+  @inline getU64(offset: i32, be: bool = true): u64 {
+    if ((offset >>> 31) | i32(offset + 8 > this.length)) throw new RangeError(E_INDEXOUTOFRANGE);
+    let v = load<u64>(this.ptr + <usize>offset);
+    return be ? bswap<u64>(v) : v;
+  }
+
+  // --- Signed reads ---
+
+  @inline getI8(offset: i32): i8 {
+    if (<u32>offset >= <u32>this.length) throw new RangeError(E_INDEXOUTOFRANGE);
+    return load<i8>(this.ptr + <usize>offset);
+  }
+
+  @inline getI16(offset: i32, be: bool = true): i16 {
+    if ((offset >>> 31) | i32(offset + 2 > this.length)) throw new RangeError(E_INDEXOUTOFRANGE);
+    let v = load<i16>(this.ptr + <usize>offset);
+    return be ? <i16>bswap<u16>(<u16>v) : v;
+  }
+
+  @inline getI32(offset: i32, be: bool = true): i32 {
+    if ((offset >>> 31) | i32(offset + 4 > this.length)) throw new RangeError(E_INDEXOUTOFRANGE);
+    let v = load<i32>(this.ptr + <usize>offset);
+    return be ? <i32>bswap<u32>(<u32>v) : v;
+  }
+
+  @inline getI64(offset: i32, be: bool = true): i64 {
+    if ((offset >>> 31) | i32(offset + 8 > this.length)) throw new RangeError(E_INDEXOUTOFRANGE);
+    let v = load<i64>(this.ptr + <usize>offset);
+    return be ? <i64>bswap<u64>(<u64>v) : v;
+  }
+
+  // --- Unsigned writes ---
+
+  @inline setU8(offset: i32, value: u8): void {
+    if (<u32>offset >= <u32>this.length) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<u8>(this.ptr + <usize>offset, value);
+  }
+
+  @inline setU16(offset: i32, value: u16, be: bool = true): void {
+    if ((offset >>> 31) | i32(offset + 2 > this.length)) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<u16>(this.ptr + <usize>offset, be ? bswap<u16>(value) : value);
+  }
+
+  @inline setU32(offset: i32, value: u32, be: bool = true): void {
+    if ((offset >>> 31) | i32(offset + 4 > this.length)) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<u32>(this.ptr + <usize>offset, be ? bswap<u32>(value) : value);
+  }
+
+  @inline setU64(offset: i32, value: u64, be: bool = true): void {
+    if ((offset >>> 31) | i32(offset + 8 > this.length)) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<u64>(this.ptr + <usize>offset, be ? bswap<u64>(value) : value);
+  }
+
+  // --- Signed writes ---
+
+  @inline setI8(offset: i32, value: i8): void {
+    if (<u32>offset >= <u32>this.length) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<i8>(this.ptr + <usize>offset, value);
+  }
+
+  @inline setI16(offset: i32, value: i16, be: bool = true): void {
+    if ((offset >>> 31) | i32(offset + 2 > this.length)) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<i16>(this.ptr + <usize>offset, be ? <i16>bswap<u16>(<u16>value) : value);
+  }
+
+  @inline setI32(offset: i32, value: i32, be: bool = true): void {
+    if ((offset >>> 31) | i32(offset + 4 > this.length)) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<i32>(this.ptr + <usize>offset, be ? <i32>bswap<u32>(<u32>value) : value);
+  }
+
+  @inline setI64(offset: i32, value: i64, be: bool = true): void {
+    if ((offset >>> 31) | i32(offset + 8 > this.length)) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<i64>(this.ptr + <usize>offset, be ? <i64>bswap<u64>(<u64>value) : value);
+  }
+
+  // --- Byte indexing operators ---
+
+  @operator("[]") private __get(index: i32): u8 {
+    if (<u32>index >= <u32>this.length) throw new RangeError(E_INDEXOUTOFRANGE);
+    return load<u8>(this.ptr + <usize>index);
+  }
+
+  @operator("[]=") private __set(index: i32, value: u8): void {
+    if (<u32>index >= <u32>this.length) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<u8>(this.ptr + <usize>index, value);
+  }
+
+  // --- Bulk operations ---
+
+  slice(start: i32, end: i32 = this.length): ByteSlice {
+    let len = this.length;
+    if (start < 0) start = max(len + start, 0);
+    if (end < 0) end = max(len + end, 0);
+    start = min(start, len);
+    end = min(end, len);
+    let newLen = max(end - start, 0);
+    return new ByteSlice(this.ptr + <usize>start, newLen);
+  }
+
+  copyTo(dst: ByteSlice, dstOff: i32 = 0, srcOff: i32 = 0, count: i32 = this.length - srcOff): void {
+    if (
+      (count >>> 31) |
+      (srcOff >>> 31) | i32(srcOff + count > this.length) |
+      (dstOff >>> 31) | i32(dstOff + count > dst.length)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    memory.copy(dst.ptr + <usize>dstOff, this.ptr + <usize>srcOff, <usize>count);
+  }
+
+  fill(value: u8, start: i32 = 0, end: i32 = this.length): void {
+    let len = this.length;
+    if (start < 0) start = max(len + start, 0);
+    if (end < 0) end = max(len + end, 0);
+    start = min(start, len);
+    end = min(end, len);
+    if (start < end) {
+      memory.fill(this.ptr + <usize>start, value, <usize>(end - start));
+    }
+  }
+
+  equals(other: ByteSlice): bool {
+    if (this.length != other.length) return false;
+    if (this.length == 0) return true;
+    return memory.compare(this.ptr, other.ptr, <usize>this.length) == 0;
+  }
+
+  toPointer<T>(): Pointer<T> {
+    return new Pointer<T>(this.ptr);
+  }
+
+  toString(): string {
+    return "[object ByteSlice]";
+  }
+
+  // RT integration — ptr is raw usize, not managed
+
+  @unsafe private __visit(_cookie: u32): void {
+    // no-op: ptr is raw, not a managed reference
+  }
+}

package/std/assembly/compat.ts

@@ -0,0 +1,2 @@
+export type ReturnType<T> = returnof<T>;
+export type NonNullable<T> = nonnull<T>;

package/std/assembly/console.ts

@@ -0,0 +1,42 @@
+import {
+  console as binding
+} from "./bindings/dom";
+
+export namespace console {
+
+  export function assert<T>(condition: T, message: string = ""): void {
+    binding.assert(!!condition, message);
+  }
+
+  export function log(message: string = ""): void {
+    binding.log(message);
+  }
+
+  export function debug(message: string = ""): void {
+    binding.debug(message);
+  }
+
+  export function info(message: string = ""): void {
+    binding.info(message);
+  }
+
+  export function warn(message: string = ""): void {
+    binding.warn(message);
+  }
+
+  export function error(message: string = ""): void {
+    binding.error(message);
+  }
+
+  export function time(label: string = "default"): void {
+    binding.time(label);
+  }
+
+  export function timeLog(label: string = "default"): void {
+    binding.timeLog(label);
+  }
+
+  export function timeEnd(label: string = "default"): void {
+    binding.timeEnd(label);
+  }
+}

package/std/assembly/crypto.ts

@@ -0,0 +1,9 @@
+import {
+  crypto as crypto_binding
+} from "bindings/dom";
+
+export namespace crypto {
+  export function getRandomValues(array: Uint8Array): void {
+    crypto_binding.getRandomValues(array);
+  }
+}

package/std/assembly/dataview.ts

@@ -0,0 +1,181 @@
+import { BLOCK_MAXSIZE } from "./rt/common";
+import { ArrayBuffer } from "./arraybuffer";
+import { E_INDEXOUTOFRANGE, E_INVALIDLENGTH } from "./util/error";
+
+// TODO: there is probably a smarter way to check byteOffset for accesses larger than 1 byte
+
+export class DataView {
+
+  readonly buffer: ArrayBuffer;
+  @unsafe readonly dataStart: usize;
+  readonly byteLength: i32;
+
+  get byteOffset(): i32 {
+    return <i32>(this.dataStart - changetype<usize>(this.buffer));
+  }
+
+  constructor(
+    buffer: ArrayBuffer,
+    byteOffset: i32 = 0,
+    byteLength: i32 = buffer.byteLength
+  ) {
+    if (
+      i32(<u32>byteLength > <u32>BLOCK_MAXSIZE) |
+      i32(<u32>byteOffset + byteLength > <u32>buffer.byteLength)
+    ) throw new RangeError(E_INVALIDLENGTH);
+    this.buffer = buffer; // links
+    let dataStart = changetype<usize>(buffer) + <usize>byteOffset;
+    this.dataStart = dataStart;
+    this.byteLength = byteLength;
+  }
+
+  getFloat32(byteOffset: i32, littleEndian: bool = false): f32 {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    return littleEndian
+      ? load<f32>(this.dataStart + <usize>byteOffset)
+      : reinterpret<f32>(bswap<u32>(load<u32>(this.dataStart + <usize>byteOffset)));
+  }
+
+  getFloat64(byteOffset: i32, littleEndian: bool = false): f64 {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    return littleEndian
+      ? load<f64>(this.dataStart + <usize>byteOffset)
+      : reinterpret<f64>(bswap<u64>(load<u64>(this.dataStart + <usize>byteOffset)));
+  }
+
+  getInt8(byteOffset: i32): i8 {
+    if (<u32>byteOffset >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);
+    return load<i8>(this.dataStart + <usize>byteOffset);
+  }
+
+  getInt16(byteOffset: i32, littleEndian: bool = false): i16 {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    let result: i16 = load<i16>(this.dataStart + <usize>byteOffset);
+    return littleEndian ? result : bswap<u16>(result);
+  }
+
+  getInt32(byteOffset: i32, littleEndian: bool = false): i32 {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    let result: i32 = load<i32>(this.dataStart + <usize>byteOffset);
+    return littleEndian ? result : bswap<u32>(result);
+  }
+
+  getUint8(byteOffset: i32): u8 {
+    if (<u32>byteOffset >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);
+    return load<u8>(this.dataStart + <usize>byteOffset);
+  }
+
+  getUint16(byteOffset: i32, littleEndian: bool = false): u16 {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    let result: u16 = load<u16>(this.dataStart + <usize>byteOffset);
+    return littleEndian ? result : bswap<u16>(result);
+  }
+
+  getUint32(byteOffset: i32, littleEndian: bool = false): u32 {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    let result: u32 = load<u32>(this.dataStart + <usize>byteOffset);
+    return littleEndian ? result : bswap<u32>(result);
+  }
+
+  setFloat32(byteOffset: i32, value: f32, littleEndian: bool = false): void {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    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: bool = false): void {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    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 {
+    if (<u32>byteOffset >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<i8>(this.dataStart + <usize>byteOffset, value);
+  }
+
+  setInt16(byteOffset: i32, value: i16, littleEndian: bool = false): void {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<i16>(this.dataStart + <usize>byteOffset, littleEndian ? value : bswap<u16>(value));
+  }
+
+  setInt32(byteOffset: i32, value: i32, littleEndian: bool = false): void {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<i32>(this.dataStart + <usize>byteOffset, littleEndian ? value : bswap<u32>(value));
+  }
+
+  setUint8(byteOffset: i32, value: u8): void {
+    if (<u32>byteOffset >= <u32>this.byteLength) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<u8>(this.dataStart + <usize>byteOffset, value);
+  }
+
+  setUint16(byteOffset: i32, value: u16, littleEndian: bool = false): void {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 2 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<u16>(this.dataStart + <usize>byteOffset, littleEndian ? value : bswap<u16>(value));
+  }
+
+  setUint32(byteOffset: i32, value: u32, littleEndian: bool = false): void {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 4 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    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: bool = false): i64 {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    let result: i64 = load<i64>(this.dataStart + <usize>byteOffset);
+    return littleEndian ? result : bswap<u64>(result);
+  }
+
+  getUint64(byteOffset: i32, littleEndian: bool = false): u64 {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    let result = load<u64>(this.dataStart + <usize>byteOffset);
+    return littleEndian ? result : bswap<u64>(result);
+  }
+
+  setInt64(byteOffset: i32, value: i64, littleEndian: bool = false): void {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<i64>(this.dataStart + <usize>byteOffset, littleEndian ? value : bswap<u64>(value));
+  }
+
+  setUint64(byteOffset: i32, value: u64, littleEndian: bool = false): void {
+    if (
+      (byteOffset >>> 31) | i32(byteOffset + 8 > this.byteLength)
+    ) throw new RangeError(E_INDEXOUTOFRANGE);
+    store<u64>(this.dataStart + <usize>byteOffset, littleEndian ? value : bswap<u64>(value));
+  }
+
+  toString(): string {
+    return "[object DataView]";
+  }
+}