toilscript 0.0.1

package/std/assembly/set.ts

@@ -0,0 +1,225 @@
+/// <reference path="./rt/index.d.ts" />
+
+import { HASH } from "./util/hash";
+import { Runtime } from "shared/runtime";
+
+// A deterministic hash set based on CloseTable from https://github.com/jorendorff/dht
+
+// @ts-ignore: decorator
+@inline const INITIAL_CAPACITY = 4;
+
+// @ts-ignore: decorator
+@inline const FILL_FACTOR_N = 8;
+
+// @ts-ignore: decorator
+@inline const FILL_FACTOR_D = 3;
+
+// @ts-ignore: decorator
+@inline const FREE_FACTOR_N = 3;
+
+// @ts-ignore: decorator
+@inline const FREE_FACTOR_D = 4;
+
+/** Structure of a set entry. */
+@unmanaged class SetEntry<K> {
+  key: K;
+  taggedNext: usize; // LSB=1 indicates EMPTY
+}
+
+/** Empty bit. */
+// @ts-ignore: decorator
+@inline const EMPTY: usize = 1 << 0;
+
+/** Size of a bucket. */
+// @ts-ignore: decorator
+@inline const BUCKET_SIZE = sizeof<usize>();
+
+/** Computes the alignment of an entry. */
+// @ts-ignore: decorator
+@inline
+function ENTRY_ALIGN<T>(): usize {
+  // can align to 4 instead of 8 if 32-bit and K is <= 32-bits
+  const align = (sizeof<T>() > sizeof<usize>() ? sizeof<T>() : sizeof<usize>()) - 1;
+  return align;
+}
+
+/** Computes the aligned size of an entry. */
+// @ts-ignore: decorator
+@inline
+function ENTRY_SIZE<T>(): usize {
+  const align = ENTRY_ALIGN<T>();
+  const size = (offsetof<SetEntry<T>>() + align) & ~align;
+  return size;
+}
+
+export class Set<T> {
+
+  // buckets referencing their respective first entry, usize[bucketsMask + 1]
+  private buckets: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * <i32>BUCKET_SIZE);
+  private bucketsMask: u32 = INITIAL_CAPACITY - 1;
+
+  // entries in insertion order, SetEntry<K>[entriesCapacity]
+  private entries: ArrayBuffer = new ArrayBuffer(INITIAL_CAPACITY * <i32>ENTRY_SIZE<T>());
+  private entriesCapacity: i32 = INITIAL_CAPACITY;
+  private entriesOffset: i32 = 0;
+  private entriesCount: i32 = 0;
+
+  constructor() {
+    /* nop */
+  }
+
+  get size(): i32 {
+    return this.entriesCount;
+  }
+
+  clear(): void {
+    this.buckets = new ArrayBuffer(INITIAL_CAPACITY * <i32>BUCKET_SIZE);
+    this.bucketsMask = INITIAL_CAPACITY - 1;
+    this.entries = new ArrayBuffer(INITIAL_CAPACITY * <i32>ENTRY_SIZE<T>());
+    this.entriesCapacity = INITIAL_CAPACITY;
+    this.entriesOffset = 0;
+    this.entriesCount = 0;
+  }
+
+  private find(key: T, hashCode: u32): SetEntry<T> | null {
+    let entry = load<SetEntry<T>>( // unmanaged!
+      changetype<usize>(this.buckets) + <usize>(hashCode & this.bucketsMask) * BUCKET_SIZE
+    );
+    while (entry) {
+      let taggedNext = entry.taggedNext;
+      if (!(taggedNext & EMPTY) && entry.key == key) return entry;
+      entry = changetype<SetEntry<T>>(taggedNext & ~EMPTY);
+    }
+    return null;
+  }
+
+  @operator("[]")
+  has(key: T): bool {
+    return this.find(key, HASH<T>(key)) != null;
+  }
+
+  add(key: T): this {
+    let hashCode = HASH<T>(key);
+    let entry = this.find(key, hashCode); // unmanaged!
+    if (!entry) {
+      // check if rehashing is necessary
+      if (this.entriesOffset == this.entriesCapacity) {
+        this.rehash(
+          this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D
+            ?  this.bucketsMask           // just rehash if 1/4+ entries are empty
+            : (this.bucketsMask << 1) | 1 // grow capacity to next 2^N
+        );
+      }
+      // append new entry
+      entry = changetype<SetEntry<T>>(changetype<usize>(this.entries) + <usize>(this.entriesOffset++) * ENTRY_SIZE<T>());
+      entry.key = key;
+      if (isManaged<T>()) {
+        if (ASC_RUNTIME != Runtime.Memory) {
+          __link(changetype<usize>(this), changetype<usize>(key), true);
+        }
+      }
+      ++this.entriesCount;
+      // link with previous entry in bucket
+      let bucketPtrBase = changetype<usize>(this.buckets) + <usize>(hashCode & this.bucketsMask) * BUCKET_SIZE;
+      entry.taggedNext = load<usize>(bucketPtrBase);
+      store<usize>(bucketPtrBase, changetype<usize>(entry));
+    }
+    return this;
+  }
+
+  @operator("[]=")
+  private __set(key: T, value: bool): void {
+    if (value) this.add(key);
+    else this.delete(key);
+  }
+
+  delete(key: T): bool {
+    let entry = this.find(key, HASH<T>(key)); // unmanaged!
+    if (!entry) return false;
+    entry.taggedNext |= EMPTY;
+    --this.entriesCount;
+    // check if rehashing is appropriate
+    let halfBucketsMask = this.bucketsMask >> 1;
+    if (
+      halfBucketsMask + 1 >= max<u32>(INITIAL_CAPACITY, this.entriesCount) &&
+      this.entriesCount < this.entriesCapacity * FREE_FACTOR_N / FREE_FACTOR_D
+    ) this.rehash(halfBucketsMask);
+    return true;
+  }
+
+  private rehash(newBucketsMask: u32): void {
+    let newBucketsCapacity = <i32>(newBucketsMask + 1);
+    let newBuckets = new ArrayBuffer(newBucketsCapacity * <i32>BUCKET_SIZE);
+    let newEntriesCapacity = newBucketsCapacity * FILL_FACTOR_N / FILL_FACTOR_D;
+    let newEntries = new ArrayBuffer(newEntriesCapacity * <i32>ENTRY_SIZE<T>());
+
+    // copy old entries to new entries
+    let oldPtr = changetype<usize>(this.entries);
+    let oldEnd = oldPtr + <usize>this.entriesOffset * ENTRY_SIZE<T>();
+    let newPtr = changetype<usize>(newEntries);
+    while (oldPtr != oldEnd) {
+      let oldEntry = changetype<SetEntry<T>>(oldPtr); // unmanaged!
+      if (!(oldEntry.taggedNext & EMPTY)) {
+        let newEntry = changetype<SetEntry<T>>(newPtr); // unmanaged!
+        let oldEntryKey = oldEntry.key;
+        newEntry.key = oldEntryKey;
+        let newBucketIndex = HASH<T>(oldEntryKey) & newBucketsMask;
+        let newBucketPtrBase = changetype<usize>(newBuckets) + <usize>newBucketIndex * BUCKET_SIZE;
+        newEntry.taggedNext = load<usize>(newBucketPtrBase);
+        store<usize>(newBucketPtrBase, newPtr);
+        newPtr += ENTRY_SIZE<T>();
+      }
+      oldPtr += ENTRY_SIZE<T>();
+    }
+
+    this.buckets = newBuckets;
+    this.bucketsMask = newBucketsMask;
+    this.entries = newEntries;
+    this.entriesCapacity = newEntriesCapacity;
+    this.entriesOffset = this.entriesCount;
+  }
+
+  values(): T[] {
+    // FIXME: this is preliminary, needs iterators/closures
+    let start = changetype<usize>(this.entries);
+    let size = this.entriesOffset;
+    let values = new Array<T>(size);
+    let length = 0;
+    for (let i = 0; i < size; ++i) {
+      let entry = changetype<SetEntry<T>>(start + <usize>i * ENTRY_SIZE<T>());
+      if (!(entry.taggedNext & EMPTY)) {
+        unchecked(values[length++] = entry.key);
+      }
+    }
+    values.length = length;
+    return values;
+  }
+
+  toString(): string {
+    return "[object Set]";
+  }
+
+  // RT integration
+
+  @unsafe private __visit(cookie: u32): void {
+    if (ASC_RUNTIME != Runtime.Memory) {
+      __visit(changetype<usize>(this.buckets), cookie);
+      let entries = changetype<usize>(this.entries);
+      if (isManaged<T>()) {
+        let cur = entries;
+        let end = cur + <usize>this.entriesOffset * ENTRY_SIZE<T>();
+        while (cur < end) {
+          let entry = changetype<SetEntry<T>>(cur);
+          if (!(entry.taggedNext & EMPTY)) {
+            let val = changetype<usize>(entry.key);
+            if (isNullable<T>()) {
+              if (val) __visit(val, cookie);
+            } else __visit(val, cookie);
+          }
+          cur += ENTRY_SIZE<T>();
+        }
+      }
+      __visit(entries, cookie);
+    }
+  }
+}

package/std/assembly/shared/feature.ts

@@ -0,0 +1,68 @@
+// This file is shared with the compiler and must remain portable
+
+/** Indicates specific features to activate. */
+export const enum Feature {
+  /** No additional features. */
+  None = 0,
+  /** Sign extension operations. */
+  SignExtension = 1 << 0, // see: https://github.com/WebAssembly/sign-extension-ops
+  /** Mutable global imports and exports. */
+  MutableGlobals = 1 << 1, // see: https://github.com/WebAssembly/mutable-global
+  /** Non-trapping float to integer operations. */
+  NontrappingF2I = 1 << 2, // see: https://github.com/WebAssembly/nontrapping-float-to-int-conversions
+  /** Bulk memory operations. */
+  BulkMemory = 1 << 3, // see: https://github.com/WebAssembly/bulk-memory-operations
+  /** SIMD types and operations. */
+  Simd = 1 << 4, // see: https://github.com/WebAssembly/simd
+  /** Threading and atomic operations. */
+  Threads = 1 << 5, // see: https://github.com/WebAssembly/threads
+  /** Exception handling operations. */
+  ExceptionHandling = 1 << 6, // see: https://github.com/WebAssembly/exception-handling
+  /** Tail call operations. */
+  TailCalls = 1 << 7, // see: https://github.com/WebAssembly/tail-call
+  /** Reference types. */
+  ReferenceTypes = 1 << 8, // see: https://github.com/WebAssembly/reference-types
+  /** Multi value types. */
+  MultiValue = 1 << 9, // see: https://github.com/WebAssembly/multi-value
+  /** Garbage collection. */
+  GC = 1 << 10, // see: https://github.com/WebAssembly/gc
+  /** Memory64. */
+  Memory64 = 1 << 11, // see: https://github.com/WebAssembly/memory64
+  /** Relaxed SIMD. */
+  RelaxedSimd = 1 << 12, // see: https://github.com/WebAssembly/relaxed-simd
+  /** Extended const expressions. */
+  ExtendedConst = 1 << 13, // see: https://github.com/WebAssembly/extended-const
+  /** Reference typed strings. */
+  Strings = 1 << 14, // see: https://github.com/WebAssembly/stringref
+  /** Shared-everything threads. */
+  SharedEverything = 1 << 15, // see: https://github.com/WebAssembly/shared-everything-threads
+  /** Closures. */
+  Closures = 1 << 16,
+  /** All features. */
+  All = (1 << 17) - 1
+}
+
+/** Gets the name of the specified feature one would specify on the command line. */
+export function featureToString(feature: Feature): string {
+  switch (feature) {
+    case Feature.SignExtension: return "sign-extension";
+    case Feature.MutableGlobals: return "mutable-globals";
+    case Feature.NontrappingF2I: return "nontrapping-f2i";
+    case Feature.BulkMemory: return "bulk-memory";
+    case Feature.Simd: return "simd";
+    case Feature.Threads: return "threads";
+    case Feature.ExceptionHandling: return "exception-handling";
+    case Feature.TailCalls: return "tail-calls";
+    case Feature.ReferenceTypes: return "reference-types";
+    case Feature.MultiValue: return "multi-value";
+    case Feature.GC: return "gc";
+    case Feature.Memory64: return "memory64";
+    case Feature.RelaxedSimd: return "relaxed-simd";
+    case Feature.ExtendedConst: return "extended-const";
+    case Feature.Strings: return "stringref";
+    case Feature.SharedEverything: return "shared-everything";
+    case Feature.Closures: return "closures";
+  }
+  assert(false);
+  return "";
+}

package/std/assembly/shared/runtime.ts

@@ -0,0 +1,13 @@
+// This file is shared with the compiler and must remain portable
+
+/** Runtime types. */
+export enum Runtime {
+  /** Simple bump allocator without GC. */
+  Stub = 0,
+  /** Stop the world semi-automatic GC. */
+  Minimal = 1,
+  /** incremental GC. */
+  Incremental = 2,
+  /** Bare minimum allocator, no GC. */
+  Memory = 3,
+}

package/std/assembly/shared/target.ts

@@ -0,0 +1,11 @@
+// This file is shared with the compiler and must remain portable
+
+/** Compilation target. */
+export enum Target {
+  /** Portable. */
+  Js = 0,
+  /** WebAssembly with 32-bit pointers. */
+  Wasm32 = 1,
+  /** WebAssembly with 64-bit pointers. Experimental and not supported by any runtime yet. */
+  Wasm64 = 2,
+}

package/std/assembly/shared/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../portable.json",
+  "compilerOptions": {
+    "outDir": "../../../out",
+    "allowJs": false,
+    "sourceMap": true
+  },
+  "include": [
+    "./**/*.ts"
+  ]
+}

package/std/assembly/shared/typeinfo.ts

@@ -0,0 +1,72 @@
+// This file is shared with the compiler and must remain portable
+
+// ╒═══════════════════ Typeinfo interpretation ═══════════════════╕
+//    3                   2                   1
+//  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0  bits
+// ├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤ ◄─ __rtti_base
+// │                             count                             │
+// ╞═══════════════════════════════════════════════════════════════╡ ┐
+// │                      Typeinfo#flags [id=0]                    │ id < count
+// ├───────────────────────────────────────────────────────────────┤
+// │                              ...                              │
+
+/** Runtime type information data structure. */
+@unmanaged
+export class Typeinfo {
+  /** Flags describing the shape of this class type. */
+  flags: TypeinfoFlags = TypeinfoFlags.NONE;
+}
+
+/** Runtime type information flags. */
+export const enum TypeinfoFlags {
+  /** No specific flags. */
+  NONE = 0,
+  /** Type is an `ArrayBufferView`. */
+  ARRAYBUFFERVIEW = 1 << 0,
+  /** Type is an `Array`. */
+  ARRAY = 1 << 1,
+  /** Type is a `StaticArray`. */
+  STATICARRAY = 1 << 2,
+  /** Type is a `Set`. */
+  SET = 1 << 3,
+  /** Type is a `Map`. */
+  MAP = 1 << 4,
+  /** Type has no outgoing pointers. */
+  POINTERFREE = 1 << 5,
+  /** Value alignment of 1 byte. */
+  VALUE_ALIGN_0 = 1 << 6,
+  /** Value alignment of 2 bytes. */
+  VALUE_ALIGN_1 = 1 << 7,
+  /** Value alignment of 4 bytes. */
+  VALUE_ALIGN_2 = 1 << 8,
+  /** Value alignment of 8 bytes. */
+  VALUE_ALIGN_3 = 1 << 9,
+  /** Value alignment of 16 bytes. */
+  VALUE_ALIGN_4 = 1 << 10,
+  /** Value is a signed type. */
+  VALUE_SIGNED = 1 << 11,
+  /** Value is a float type. */
+  VALUE_FLOAT = 1 << 12,
+  /** Value type is nullable. */
+  VALUE_NULLABLE = 1 << 13,
+  /** Value type is managed. */
+  VALUE_MANAGED = 1 << 14,
+  /** Key alignment of 1 byte. */
+  KEY_ALIGN_0 = 1 << 15,
+  /** Key alignment of 2 bytes. */
+  KEY_ALIGN_1 = 1 << 16,
+  /** Key alignment of 4 bytes. */
+  KEY_ALIGN_2 = 1 << 17,
+  /** Key alignment of 8 bytes. */
+  KEY_ALIGN_3 = 1 << 18,
+  /** Key alignment of 16 bytes. */
+  KEY_ALIGN_4 = 1 << 19,
+  /** Key is a signed type. */
+  KEY_SIGNED = 1 << 20,
+  /** Key is a float type. */
+  KEY_FLOAT = 1 << 21,
+  /** Key type is nullable. */
+  KEY_NULLABLE = 1 << 22,
+  /** Key type is managed. */
+  KEY_MANAGED = 1 << 23
+}