New ArrayBuffer/TypedArray; Stdlib restructure; Fix importing stdlib in stdlib; Traverse constructors; Allow initialization of readonly instance fields in constructors

std/assembly/internal/allocator.ts

@@ -0,0 +1,11 @@
+/** Number of alignment bits. */
+export const AL_BITS: u32 = 3;
+
+/** Number of possible alignment values. */
+export const AL_SIZE: usize = 1 << <usize>AL_BITS;
+
+/** Mask to obtain just the alignment bits. */
+export const AL_MASK: usize = AL_SIZE - 1;
+
+/** Maximum 32-bit allocation size. */
+export const MAX_SIZE_32: usize = 1 << 30; // 1GB

std/assembly/internal/array.ts

@@ -0,0 +1,109 @@
+import { Array } from "../array";
+
+/** Obtains the default comparator for the specified type. */
+export function defaultComparator<T>(): (a: T, b: T) => i32 {
+  return (a: T, b: T): i32 => (<i32>(a > b) - <i32>(a < b)); // compiles to a constant function index
+}
+
+/** Sorts an Array with the 'Insertion Sort' algorithm. */
+export function insertionSort<T>(arr: Array<T>, comparator: (a: T, b: T) => i32): Array<T> {
+  var a: T, b: T, j: i32;
+  const typeShift = alignof<T>();
+
+  for (let i: i32 = 0, len: i32 = arr.length; i < len; i++) {
+    a = load<T>(arr.__memory + (i << typeShift)); // a = <T>arr[i];
+    j = i - 1;
+    while (j >= 0) {
+      b = load<T>(arr.__memory + (j << typeShift));  // b = <T>arr[j];
+      if (comparator(a, b) < 0) {
+        store<T>(arr.__memory + ((j + 1) << typeShift), b); // arr[j + 1] = b;
+        j--;
+      } else break;
+    }
+
+    store<T>(arr.__memory + ((j + 1) << typeShift), a); // arr[j + 1] = a;
+  }
+
+  return arr;
+}
+
+/** Sorts an Array with the 'Weak Heap Sort' algorithm. */
+export function weakHeapSort<T>(arr: Array<T>, comparator: (a: T, b: T) => i32): Array<T> {
+  // see: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.21.1863&rep=rep1&type=pdf
+  var len: i32 = arr.length;
+  var i: i32, j: i32, y: i32, p: i32, a: T, b: T;
+
+  const typeShift = alignof<T>();
+  const intShift  = alignof<i32>();
+
+  var blen = (len + 7) >> 3;
+  var bitset = allocate_memory(blen << intShift);
+
+  set_memory(bitset, 0, blen << intShift);
+
+  for (i = len - 1; i > 0; i--) {
+    j = i;
+    while ((j & 1) == ((load<i32>(bitset + ((j >> 4) << intShift)) >> ((j >> 1) & 7)) & 1)) {
+      j >>= 1;
+    }
+
+    p = j >> 1;
+
+    a = load<T>(arr.__memory + (p << typeShift)); // a = <T>arr[p];
+    b = load<T>(arr.__memory + (i << typeShift)); // b = <T>arr[i];
+
+    if (comparator(a, b) < 0) {
+      store<i32>(
+        bitset + ((i >> 3) << intShift),
+        load<i32>(bitset + ((i >> 3) << intShift)) ^ (1 << (i & 7))
+      );
+      store<T>(arr.__memory + (i << typeShift), a); // arr[i] = a;
+      store<T>(arr.__memory + (p << typeShift), b); // arr[p] = b;
+    }
+  }
+
+  for (i = len - 1; i >= 2; i--) {
+    /*
+    a      = <T>arr[0];
+    arr[0] = <T>arr[i];
+    arr[i] = a;
+    */
+    a = load<T>(arr.__memory, 0);
+    store<T>(arr.__memory, load<T>(arr.__memory + (i << typeShift)), 0);
+    store<T>(arr.__memory + (i << typeShift), a);
+
+    let x = 1;
+    while ((y = (x << 1) + ((load<i32>(bitset + ((x >> 3) << intShift)) >> (x & 7)) & 1)) < i) {
+      x = y;
+    }
+
+    while (x > 0) {
+      a = load<T>(arr.__memory, 0);                 // a = <T>arr[0];
+      b = load<T>(arr.__memory + (x << typeShift)); // b = <T>arr[x];
+
+      if (comparator(a, b) < 0) {
+        store<i32>(
+          bitset + ((x >> 3) << intShift),
+          load<i32>(bitset + ((x >> 3) << intShift)) ^ (1 << (x & 7))
+        );
+
+        store<T>(arr.__memory + (x << typeShift), a); // arr[x] = a;
+        store<T>(arr.__memory, b, 0);                 // arr[0] = b;
+      }
+      x >>= 1;
+    }
+  }
+
+  free_memory(bitset);
+
+  /*
+  let t  = <T>arr[1];
+  arr[1] = <T>arr[0];
+  arr[0] = t;
+  */
+  var t = load<T>(arr.__memory, sizeof<T>());
+  store<T>(arr.__memory, load<T>(arr.__memory, 0), sizeof<T>());
+  store<T>(arr.__memory, t, 0);
+
+  return arr;
+}

std/assembly/internal/arraybuffer.ts

@@ -0,0 +1,34 @@
+import { AL_MASK, MAX_SIZE_32 } from "./allocator";
+
+/** Size of an ArrayBuffer header. */
+export const HEADER_SIZE: usize = (offsetof<ArrayBuffer>() + AL_MASK) & ~AL_MASK;
+
+/** Maximum byte length of an ArrayBuffer. */
+export const MAX_BLENGTH: i32 = <i32>MAX_SIZE_32 - HEADER_SIZE;
+
+/** Computes an ArrayBuffer's size in memory. */
+export function computeSize(byteLength: i32): usize {
+  // round up to power of 2, with HEADER_SIZE=8:
+  // 0            -> 2^3  = 8
+  // 1..8         -> 2^4  = 16
+  // 9..24        -> 2^5  = 32
+  // ...
+  // MAX_LENGTH   -> 2^30 = 0x40000000 (MAX_SIZE_32)
+  return <usize>1 << <usize>(<u32>32 - clz<u32>(byteLength + HEADER_SIZE - 1));
+}
+
+/** Allocates a raw ArrayBuffer with uninitialized contents. */
+export function allocate(byteLength: i32): ArrayBuffer {
+  assert(<u32>byteLength <= <u32>MAX_BLENGTH);
+  var buffer = allocate_memory(computeSize(byteLength));
+  store<i32>(buffer, byteLength, offsetof<ArrayBuffer>("byteLength"));
+  return changetype<ArrayBuffer>(buffer);
+}
+
+/** Common typed array interface. Not a global object. */
+// export declare interface ArrayBufferView<T> {
+//   readonly buffer: ArrayBuffer;
+//   readonly byteOffset: i32;
+//   readonly byteLength: i32;
+//   readonly length: i32;
+// }

std/assembly/internal/string.ts

@@ -0,0 +1,149 @@
+import {
+  MAX_SIZE_32
+} from "./allocator";
+
+import {
+  String
+} from "../string";
+
+/** Size of a String header. */
+export const HEADER_SIZE = (offsetof<String>() + 1) & ~1; // 2 byte aligned
+
+/** Maximum length of a String. */
+export const MAX_LENGTH = (<i32>MAX_SIZE_32 - HEADER_SIZE) >>> 1;
+
+/** Singleton empty String. */
+export const EMPTY = changetype<String>(""); // TODO: is this a bad idea with '===' in place?
+
+/** Allocates a raw String with uninitialized contents. */
+export function allocate(length: i32): String {
+  assert(length > 0 && length <= MAX_LENGTH);
+  var buffer = allocate_memory(HEADER_SIZE + (<usize>length << 1));
+  store<i32>(buffer, length);
+  return changetype<String>(buffer);
+}
+
+export function isWhiteSpaceOrLineTerminator(c: u16): bool {
+  switch (c) {
+    case 10:      // <LF>
+    case 13:      // <CR>
+    case 8232:    // <LS>
+    case 8233:    // <PS>
+    case 9:       // <TAB>
+    case 11:      // <VT>
+    case 12:      // <FF>
+    case 32:      // <SP>
+    case 160:     // <NBSP>
+    case 65279: { // <ZWNBSP>
+      return true;
+    }
+    default: return false;
+  }
+}
+
+export const enum CharCode {
+  PLUS = 0x2B,
+  MINUS = 0x2D,
+  DOT = 0x2E,
+  _0 = 0x30,
+  _1 = 0x31,
+  _2 = 0x32,
+  _3 = 0x33,
+  _4 = 0x34,
+  _5 = 0x35,
+  _6 = 0x36,
+  _7 = 0x37,
+  _8 = 0x38,
+  _9 = 0x39,
+  A = 0x41,
+  B = 0x42,
+  E = 0x45,
+  O = 0x4F,
+  X = 0x58,
+  Z = 0x5a,
+  a = 0x61,
+  b = 0x62,
+  e = 0x65,
+  o = 0x6F,
+  x = 0x78,
+  z = 0x7A
+}
+
+export function parse<T>(str: String, radix: i32 = 0): T {
+  var len: i32 = str.length;
+  if (!len) {
+    return <T>NaN;
+  }
+  var ptr = changetype<usize>(str) /* + HEAD -> offset */;
+  var code = <i32>load<u16>(ptr, HEADER_SIZE);
+
+  // determine sign
+  var sign: T;
+  if (code == CharCode.MINUS) {
+    if (!--len) {
+      return <T>NaN;
+    }
+    code = <i32>load<u16>(ptr += 2, HEADER_SIZE);
+    sign = -1;
+  } else if (code == CharCode.PLUS) {
+    if (!--len) {
+      return <T>NaN;
+    }
+    code = <i32>load<u16>(ptr += 2, HEADER_SIZE);
+    sign = 1;
+  } else {
+    sign = 1;
+  }
+
+  // determine radix
+  if (!radix) {
+    if (code == CharCode._0 && len > 2) {
+      switch (<i32>load<u16>(ptr + 2, HEADER_SIZE)) {
+        case CharCode.B:
+        case CharCode.b: {
+          ptr += 4; len -= 2;
+          radix = 2;
+          break;
+        }
+        case CharCode.O:
+        case CharCode.o: {
+          ptr += 4; len -= 2;
+          radix = 8;
+          break;
+        }
+        case CharCode.X:
+        case CharCode.x: {
+          ptr += 4; len -= 2;
+          radix = 16;
+          break;
+        }
+        default: {
+          radix = 10;
+        }
+      }
+    } else radix = 10;
+  } else if (radix < 2 || radix > 36) {
+    return <T>NaN;
+  }
+
+  // calculate value
+  var num: T = 0;
+  while (len--) {
+    code = <i32>load<u16>(ptr, HEADER_SIZE);
+    if (code >= CharCode._0 && code <= CharCode._9) {
+      code -= CharCode._0;
+    } else if (code >= CharCode.A && code <= CharCode.Z) {
+      code -= CharCode.A - 10;
+    } else if (code >= CharCode.a && code <= CharCode.z) {
+      code -= CharCode.a - 10;
+    } else {
+      break;
+    }
+    if (code >= radix) {
+      break;
+    }
+    num = (num * radix) + code;
+    ptr += 2;
+  }
+  return sign * num;
+}

std/assembly/internal/typedarray.ts

@@ -0,0 +1,34 @@
+import {
+  MAX_BLENGTH,
+  allocate
+  // ArrayBufferView
+} from "./arraybuffer";
+
+/** Typed array base class. Not a global object. */
+export abstract class TypedArray<T> /* implements ArrayBufferView<T> */ {
+
+  readonly buffer: ArrayBuffer;
+  readonly byteOffset: i32;
+  readonly byteLength: i32;
+
+  constructor(length: i32) {
+    const MAX_LENGTH = <u32>MAX_BLENGTH / sizeof<T>();
+    if (<u32>length > MAX_LENGTH) throw new RangeError("Invalid typed array length");
+    var byteLength = length << alignof<T>();
+    this.buffer = allocate(byteLength);
+    this.byteOffset = 0;
+    this.byteLength = byteLength;
+  }
+
+  get length(): i32 {
+    return this.byteLength >> alignof<T>();
+  }
+
+  // @operator("[]") - maybe injected through ArrayBufferView?
+
+  // @operator("[]=") - maybe injected through ArrayBufferView?
+
+  // copyWithin(target: i32, start: i32, end: i32 = 0x7fffffff): TypedArray<T>
+
+  // subarray(begin: i32 = 0, end: i32 = 0x7fffffff): TypedArray<T>
+}