warpo 3.2.0 → 3.2.1

package/assemblyscript/std/assembly/memory.ts

@@ -0,0 +1,110 @@
+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
+  }
+
+  /** 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/assemblyscript/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/assemblyscript/std/assembly/object.ts

@@ -0,0 +1,30 @@
+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/assemblyscript/std/assembly/polyfills.ts

@@ -0,0 +1,24 @@
+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/assemblyscript/std/assembly/process.ts

@@ -0,0 +1,7 @@
+export namespace process {
+  // @ts-ignore: decorator
+  @lazy export const arch = "wasm32";
+
+  // @ts-ignore: decorator
+  @lazy export const platform = "wasm";
+}