toilscript 0.0.1

package/std/assembly/memory.ts

@@ -0,0 +1,123 @@
+import { memcmp, memmove, memset } from "./util/memory";
+import { E_NOTIMPLEMENTED } from "./util/error";
+
+/** Memory manager interface. */
+export namespace memory {
+
+  /** Gets the size of the memory in pages. */
+  // @ts-ignore: decorator
+  @builtin
+  export declare function size(): i32;
+
+  /** Grows the memory by the given size in pages and returns the previous size in pages. */
+  // @ts-ignore: decorator
+  @unsafe @builtin
+  export declare function grow(pages: i32): i32;
+
+  /** Fills a section in memory with the specified byte value. */
+  // @ts-ignore: decorator
+  @unsafe @builtin
+  export function fill(dst: usize, c: u8, n: usize): void {
+    memset(dst, c, n); // fallback if "bulk-memory" isn't enabled
+  }
+
+  /** Copies a section of memory to another. Has move semantics. */
+  // @ts-ignore: decorator
+  @unsafe @builtin
+  export function copy(dst: usize, src: usize, n: usize): void {
+    memmove(dst, src, n); // fallback if "bulk-memory" isn't enabled
+  }
+
+  export namespace atomic {
+
+    // @ts-ignore: decorator
+    @unsafe @builtin
+    export declare function wait32(ptr: usize, expected: i32, timeout: i64): AtomicWaitResult;
+
+    // @ts-ignore: decorator
+    @unsafe @builtin
+    export declare function wait64(ptr: usize, expected: i64, timeout: i64): AtomicWaitResult;
+  }
+
+  /** Initializes a memory segment. */
+  // @ts-ignore: decorator
+  @unsafe
+  export function init(segmentIndex: u32, srcOffset: usize, dstOffset: usize, n: usize): void {
+    throw new Error(E_NOTIMPLEMENTED);
+  }
+
+  /** Drops a memory segment. */
+  // @ts-ignore: decorator
+  @unsafe
+  export function drop(segmentIndex: u32): void {
+    throw new Error(E_NOTIMPLEMENTED);
+  }
+
+  /** Repeats a section of memory at a specific address. */
+  // @ts-ignore: decorator
+  @unsafe
+  export function repeat(dst: usize, src: usize, srcLength: usize, count: usize): void {
+    let index: usize = 0;
+    let total = srcLength * count;
+    while (index < total) {
+      memory.copy(dst + index, src, srcLength);
+      index += srcLength;
+    }
+  }
+
+  /** Compares a section of memory to another. */
+  // @ts-ignore: decorator
+  @inline
+  export function compare(vl: usize, vr: usize, n: usize): i32 {
+    return memcmp(vl, vr, n);
+  }
+
+  /** Gets a pointer to a static chunk of memory of the given size. */
+  // @ts-ignore: decorator
+  @builtin
+  export declare function data<T>(size: T, align?: i32): usize;
+}
+
+// @ts-ignore: decorator
+@builtin
+export declare const __data_end: usize;
+
+// @ts-ignore: decorator
+@builtin
+export declare let __stack_pointer: usize;
+
+// @ts-ignore: decorator
+@builtin
+export declare const __heap_base: usize;
+
+/** Heap memory interface. */
+export namespace heap {
+
+  /** Allocates a chunk of memory of at least the specified size. */
+  // @ts-ignore: decorator
+  @unsafe export function alloc(size: usize): usize {
+    return __alloc(size);
+  }
+
+  /** Reallocates a chunk of memory to have at least the specified size. */
+  // @ts-ignore: decorator
+  @unsafe export function realloc(ptr: usize, size: usize): usize {
+    return __realloc(ptr, size);
+  }
+
+  /** Frees a chunk of memory. Does hardly anything (most recent block only) with the stub runtime. */
+  // @ts-ignore: decorator
+  @unsafe export function free(ptr: usize): void {
+    __free(ptr);
+  }
+
+  /** Dangerously resets the entire heap. Specific to the stub runtime. */
+  // @ts-ignore: decorator
+  @unsafe export function reset(): void {
+    if (isDefined(__reset)) {
+      __reset();
+    } else {
+      throw new Error(E_NOTIMPLEMENTED);
+    }
+  }
+}

package/std/assembly/number.ts

@@ -0,0 +1,388 @@
+import { itoa32, utoa32, itoa64, utoa64, dtoa } from "./util/number";
+import { strtol, strtod } from "./util/string";
+
+// @ts-ignore: decorator
+@builtin @inline
+export const NaN: f64 = 0 / 0; // context-aware
+
+// @ts-ignore: decorator
+@builtin @inline
+export const Infinity: f64 = 1 / 0; // context-aware
+
+// @ts-ignore: decorator
+@builtin
+export declare function isNaN<T extends number>(value: T): bool;
+
+// @ts-ignore: decorator
+@builtin
+export declare function isFinite<T extends number>(value: T): bool;
+
+@final @unmanaged
+export abstract class I8 {
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly MIN_VALUE: i8 = i8.MIN_VALUE;
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly MAX_VALUE: i8 = i8.MAX_VALUE;
+
+  /** @deprecated */
+  static parseInt(value: string, radix: i32 = 0): i8 {
+    return <i8>strtol<i32>(value, radix);
+  }
+
+  toString(this: i8, radix: i32 = 10): String {
+    return itoa32(this, radix);
+  }
+}
+
+@final @unmanaged
+export abstract class I16 {
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly MIN_VALUE: i16 = i16.MIN_VALUE;
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly MAX_VALUE: i16 = i16.MAX_VALUE;
+
+  /** @deprecated */
+  static parseInt(value: string, radix: i32 = 0): i16 {
+    return <i16>strtol<i32>(value, radix);
+  }
+
+  toString(this: i16, radix: i32 = 10): String {
+    return itoa32(this, radix);
+  }
+}
+
+@final @unmanaged
+export abstract class I32 {
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly MIN_VALUE: i32 = i32.MIN_VALUE;
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly MAX_VALUE: i32 = i32.MAX_VALUE;
+
+  /** @deprecated */
+  static parseInt(value: string, radix: i32 = 0): i32 {
+    return <i32>strtol<i32>(value, radix);
+  }
+
+  toString(this: i32, radix: i32 = 10): String {
+    return itoa32(this, radix);
+  }
+}
+
+@final @unmanaged
+export abstract class I64 {
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly MIN_VALUE: i64 = i64.MIN_VALUE;
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly MAX_VALUE: i64 = i64.MAX_VALUE;
+
+  /** @deprecated */
+  static parseInt(value: string, radix: i32 = 0): i64 {
+    return strtol<i64>(value, radix);
+  }
+
+  toString(this: i64, radix: i32 = 10): String {
+    return itoa64(this, radix);
+  }
+}
+
+@final @unmanaged
+export abstract class Isize {
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly MIN_VALUE: isize = isize.MIN_VALUE;
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly MAX_VALUE: isize = isize.MAX_VALUE;
+
+  /** @deprecated */
+  static parseInt(value: string, radix: i32 = 0): isize {
+    return <isize>strtol<i64>(value, radix);
+  }
+
+  toString(this: isize, radix: i32 = 10): String {
+    if (sizeof<isize>() == 4) {
+      return itoa32(<i32>this, radix);
+    } else {
+      return itoa64(<i64>this, radix);
+    }
+  }
+}
+
+@final @unmanaged
+export abstract class U8 {
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly MIN_VALUE: u8 = u8.MIN_VALUE;
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly MAX_VALUE: u8 = u8.MAX_VALUE;
+
+  /** @deprecated */
+  static parseInt(value: string, radix: i32 = 0): u8 {
+    return <u8>strtol<i32>(value, radix);
+  }
+
+  toString(this: u8, radix: i32 = 10): String {
+    return utoa32(this, radix);
+  }
+}
+
+@final @unmanaged
+export abstract class U16 {
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly MIN_VALUE: u16 = u16.MIN_VALUE;
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly MAX_VALUE: u16 = u16.MAX_VALUE;
+
+  /** @deprecated */
+  static parseInt(value: string, radix: i32 = 0): u16 {
+    return <u16>strtol<i32>(value, radix);
+  }
+
+  toString(this: u16, radix: i32 = 10): String {
+    return utoa32(this, radix);
+  }
+}
+
+@final @unmanaged
+export abstract class U32 {
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly MIN_VALUE: u32 = u32.MIN_VALUE;
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly MAX_VALUE: u32 = u32.MAX_VALUE;
+
+  /** @deprecated */
+  static parseInt(value: string, radix: i32 = 0): u32 {
+    return <u32>strtol<i32>(value, radix);
+  }
+
+  toString(this: u32, radix: i32 = 10): String {
+    return utoa32(this, radix);
+  }
+}
+
+@final @unmanaged
+export abstract class U64 {
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly MIN_VALUE: u64 = u64.MIN_VALUE;
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly MAX_VALUE: u64 = u64.MAX_VALUE;
+
+  /** @deprecated */
+  static parseInt(value: string, radix: i32 = 0): u64 {
+    return <u64>strtol<i64>(value, radix);
+  }
+
+  toString(this: u64, radix: i32 = 10): String {
+    return utoa64(this, radix);
+  }
+}
+
+@final @unmanaged
+export abstract class Usize {
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly MIN_VALUE: usize = usize.MIN_VALUE;
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly MAX_VALUE: usize = usize.MAX_VALUE;
+
+  /** @deprecated */
+  static parseInt(value: string, radix: i32 = 0): usize {
+    return <usize>strtol<i64>(value, radix);
+  }
+
+  toString(this: usize, radix: i32 = 10): String {
+    if (sizeof<usize>() == 4) {
+      return utoa32(<u32>this, radix);
+    } else {
+      return utoa64(<u64>this, radix);
+    }
+  }
+}
+
+@final @unmanaged
+export abstract class Bool {
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly MIN_VALUE: bool = bool.MIN_VALUE;
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly MAX_VALUE: bool = bool.MAX_VALUE;
+
+  toString(this: bool, radix: i32 = 0): String {
+    return this ? "true" : "false";
+  }
+}
+
+export { Bool as Boolean };
+
+@final @unmanaged
+export abstract class F32 {
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly EPSILON: f32 = f32.EPSILON;
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly MIN_VALUE: f32 = f32.MIN_VALUE;
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly MAX_VALUE: f32 = f32.MAX_VALUE;
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly MIN_SAFE_INTEGER: f32 = f32.MIN_SAFE_INTEGER;
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly MAX_SAFE_INTEGER: f32 = f32.MAX_SAFE_INTEGER;
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly POSITIVE_INFINITY: f32 = f32.POSITIVE_INFINITY;
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly NEGATIVE_INFINITY: f32 = f32.NEGATIVE_INFINITY;
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly NaN: f32 = f32.NaN;
+
+  static isNaN(value: f32): bool {
+    return isNaN<f32>(value);
+  }
+
+  static isFinite(value: f32): bool {
+    return isFinite<f32>(value);
+  }
+
+  static isSafeInteger(value: f32): bool {
+    return abs<f32>(value) <= f32.MAX_SAFE_INTEGER && trunc<f32>(value) == value;
+  }
+
+  static isInteger(value: f32): bool {
+    return isFinite<f32>(value) && trunc<f32>(value) == value;
+  }
+
+  /** @deprecated */
+  static parseInt(value: string, radix: i32 = 0): f32 {
+    return <f32>strtol<f64>(value, radix);
+  }
+
+  /** @deprecated */
+  static parseFloat(value: string): f32 {
+    return <f32>strtod(value);
+  }
+
+  toString(this: f32, radix: i32 = 0): String {
+    return dtoa(this);
+  }
+}
+
+@final @unmanaged
+export abstract class F64 {
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly EPSILON: f64 = f64.EPSILON;
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly MIN_VALUE: f64 = f64.MIN_VALUE;
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly MAX_VALUE: f64 = f64.MAX_VALUE;
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly MIN_SAFE_INTEGER: f64 = f64.MIN_SAFE_INTEGER;
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly MAX_SAFE_INTEGER: f64 = f64.MAX_SAFE_INTEGER;
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly POSITIVE_INFINITY: f64 = f64.POSITIVE_INFINITY;
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly NEGATIVE_INFINITY: f64 = f64.NEGATIVE_INFINITY;
+
+  // @ts-ignore: decorator
+  @lazy
+  static readonly NaN: f64 = f64.NaN;
+
+  static isNaN(value: f64): bool {
+    return isNaN<f64>(value);
+  }
+
+  static isFinite(value: f64): bool {
+    return isFinite<f64>(value);
+  }
+
+  static isSafeInteger(value: f64): bool {
+    return abs<f64>(value) <= f64.MAX_SAFE_INTEGER && trunc<f64>(value) == value;
+  }
+
+  static isInteger(value: f64): bool {
+    return isFinite<f64>(value) && trunc<f64>(value) == value;
+  }
+
+  /** @deprecated */
+  static parseInt(value: string, radix: i32 = 0): f64 {
+    return strtol<f64>(value, radix);
+  }
+
+  /** @deprecated */
+  static parseFloat(value: string): f64 {
+    return strtod(value);
+  }
+
+  toString(this: f64, radix: i32 = 0): String {
+    return dtoa(this);
+  }
+}
+
+export { F64 as Number };

package/std/assembly/object.ts

@@ -0,0 +1,36 @@
+export abstract class Object {
+  static is<T>(x: T, y: T): bool {
+    if (isFloat<T>()) {
+      // Float pointing is special we shoulr presere following identities:
+      // 0.0 !=-0.0
+      // NaN == NaN
+      if (sizeof<T>() == 8) {
+        return (
+          bool(u32(x != x) & u32(y != y) |
+          u32(reinterpret<u64>(f64(x)) == reinterpret<u64>(f64(y))))
+        );
+      } else {
+        return (
+          bool(u32(x != x) & u32(y != y) |
+          u32(reinterpret<u32>(f32(x)) == reinterpret<u32>(f32(y))))
+        );
+      }
+    }
+    // For references, strings, integers and booleans
+    return x == y;
+  }
+
+  // TODO: Wrapper classes like `Function<T>` override the `this` type of
+  // `toString`, which is covariant and hence fails to overload. Wrapper classes
+  // might need a different mechanism to indicate such special `this` types.
+  // toString(): string {
+  //   return "[object Object]";
+  // }
+}
+
+// TODO: The types `Object` and `object` differ in TypeScript, in that the
+// latter indicates any non-primitive type, not including `string` for example.
+// The `object` type hence remains reserved for now, also to potentially address
+// the above `toString` TODO in alternative ways.
+// @ts-ignore: nolib
+// export type object = Object;

package/std/assembly/performance.ts

@@ -0,0 +1,9 @@
+import {
+  performance as performance_binding
+} from "bindings/dom";
+
+export namespace performance {
+  export function now(): f64 {
+    return performance_binding.now();
+  }
+}

package/std/assembly/pointer.ts

@@ -0,0 +1,80 @@
+// Zero-overhead typed pointer. @unmanaged + changetype = no allocation, no GC.
+// Promoted from tests/compiler/std/pointer.ts experiment.
+
+@final @unmanaged
+export class Pointer<T> {
+
+  @inline constructor(offset: usize = 0) {
+    return changetype<Pointer<T>>(offset);
+  }
+
+  @inline get offset(): usize {
+    return changetype<usize>(this);
+  }
+
+  @inline get value(): T {
+    if (isReference<T>()) {
+      return changetype<T>(changetype<usize>(this));
+    } else {
+      return load<T>(changetype<usize>(this));
+    }
+  }
+
+  @inline set value(value: T) {
+    if (isReference<T>()) {
+      if (isManaged<T>()) ERROR("Unsafe unmanaged set of a managed object");
+      if (value == null) {
+        memory.fill(changetype<usize>(this), 0, offsetof<T>());
+      } else {
+        memory.copy(changetype<usize>(this), changetype<usize>(value), offsetof<T>());
+      }
+    } else {
+      store<T>(changetype<usize>(this), value);
+    }
+  }
+
+  @inline @operator("+") add(other: Pointer<T>): Pointer<T> {
+    return changetype<Pointer<T>>(changetype<usize>(this) + changetype<usize>(other));
+  }
+
+  @inline @operator("-") sub(other: Pointer<T>): Pointer<T> {
+    return changetype<Pointer<T>>(changetype<usize>(this) - changetype<usize>(other));
+  }
+
+  @inline @operator.prefix("++") inc(): Pointer<T> {
+    const size = isReference<T>() ? offsetof<T>() : sizeof<T>();
+    return changetype<Pointer<T>>(changetype<usize>(this) + size);
+  }
+
+  @inline @operator.prefix("--") dec(): Pointer<T> {
+    const size = isReference<T>() ? offsetof<T>() : sizeof<T>();
+    return changetype<Pointer<T>>(changetype<usize>(this) - size);
+  }
+
+  @inline @operator("[]") get(index: i32): T {
+    const size = isReference<T>() ? offsetof<T>() : sizeof<T>();
+    return load<T>(changetype<usize>(this) + (<usize>index * size));
+  }
+
+  @inline @operator("[]=") set(index: i32, value: T): void {
+    const size = isReference<T>() ? offsetof<T>() : sizeof<T>();
+    store<T>(changetype<usize>(this) + (<usize>index * size), value);
+  }
+
+  @inline isNull(): bool {
+    return changetype<usize>(this) == 0;
+  }
+
+  @inline equals(other: Pointer<T>): bool {
+    return changetype<usize>(this) == changetype<usize>(other);
+  }
+
+  @inline copyTo(dst: Pointer<T>, count: i32): void {
+    const size = isReference<T>() ? offsetof<T>() : sizeof<T>();
+    memory.copy(changetype<usize>(dst), changetype<usize>(this), <usize>count * size);
+  }
+
+  @inline static null<T>(): Pointer<T> {
+    return changetype<Pointer<T>>(0);
+  }
+}

package/std/assembly/polyfills.ts

@@ -0,0 +1,27 @@
+export function bswap<T extends number>(value: T): T {
+  if (isInteger<T>()) {
+    if (sizeof<T>() == 1) {
+      return value;
+    }
+    if (sizeof<T>() == 2) {
+      return <T>(<u16>value << 8 | (<u16>value >> 8));
+    }
+    if (sizeof<T>() == 4) {
+      return <T>(
+        rotl(<u32>value & 0xFF00FF00, 8) |
+        rotr(<u32>value & 0x00FF00FF, 8)
+      );
+    }
+    if (sizeof<T>() == 8) {
+      let a = (<u64>value >> 8) & 0x00FF00FF00FF00FF;
+      let b = (<u64>value & 0x00FF00FF00FF00FF) << 8;
+      let v = a | b;
+
+      a = (v >>> 16) & 0x0000FFFF0000FFFF;
+      b = (v & 0x0000FFFF0000FFFF) << 16;
+
+      return <T>rotr(a | b, 32);
+    }
+  }
+  ERROR("Unsupported generic type");
+}

package/std/assembly/process.ts

@@ -0,0 +1,50 @@
+import {
+  Date as Date_binding,
+  performance as performance_binding
+} from "bindings/dom";
+
+import {
+  process as process_binding
+} from "bindings/node";
+
+export namespace process {
+
+  // @ts-ignore: decorator
+  @lazy export const arch = sizeof<usize>() == 4 ? "wasm32" : "wasm64";
+
+  // @ts-ignore: decorator
+  @lazy export const platform = "wasm";
+
+  // @ts-ignore: decorator
+  @lazy export const argv = lazyArgv();
+
+  // @ts-ignore: decorator
+  @lazy export const env = lazyEnv();
+
+  // @ts-ignore: decorator
+  @lazy export let exitCode = 0;
+
+  export function exit(code: i32 = exitCode): void {
+    process_binding.exit(code);
+  }
+
+  export function time(): i64 {
+    return <i64>Date_binding.now();
+  }
+
+  export function hrtime(): u64 {
+    let now = performance_binding.now();
+    let millis = <u64>now;
+    let fraction = now - <f64>millis;
+    return millis * 1000000 + <u64>(fraction * 1000000);
+  }
+}
+
+function lazyArgv(): string[] {
+  return process_binding.argv;
+}
+
+function lazyEnv(): Map<string,string> {
+  // TODO: What about Node?
+  return new Map();
+}