warpo 3.1.3 → 3.2.1

package/warpo_extension/std/wasi_snapshot_preview1/wasi_console.ts

@@ -0,0 +1,96 @@
+import { wasi_process } from "./wasi_process";
+
+// @ts-ignore: decorator
+@lazy var timers = new Map<string, u64>();
+
+export namespace wasi_console {
+  export function assert<T>(condition: T, message: string = ""): void {
+    if (!condition) {
+      let stderr = wasi_process.stderr;
+      stderr.write("Assertion failed: ");
+      stderr.write(message);
+      stderr.write("\n");
+    }
+  }
+
+  export function log(message: string = ""): void {
+    let stdout = wasi_process.stdout;
+    stdout.write(message);
+    stdout.write("\n");
+  }
+
+  export function debug(message: string = ""): void {
+    let stdout = wasi_process.stdout;
+    stdout.write("Debug: ");
+    stdout.write(message);
+    stdout.write("\n");
+  }
+
+  export function info(message: string = ""): void {
+    let stdout = wasi_process.stdout;
+    stdout.write("Info: ");
+    stdout.write(message);
+    stdout.write("\n");
+  }
+
+  export function warn(message: string = ""): void {
+    let stdout = wasi_process.stderr;
+    stdout.write("Warning: ");
+    stdout.write(message);
+    stdout.write("\n");
+  }
+
+  export function error(message: string = ""): void {
+    let stdout = wasi_process.stderr;
+    stdout.write("Error: ");
+    stdout.write(message);
+    stdout.write("\n");
+  }
+
+  export function time(label: string = "default"): void {
+    let stdout = wasi_process.stdout;
+    if (timers.has(label)) {
+      stdout.write("Warning: Label '");
+      stdout.write(label);
+      stdout.write("' already exists for console.time()\n");
+      return;
+    }
+    timers.set(label, wasi_process.hrtime());
+  }
+
+  export function timeLog(label: string = "default"): void {
+    let stdout = wasi_process.stdout;
+    if (!timers.has(label)) {
+      stdout.write("Warning: No such label '");
+      stdout.write(label);
+      stdout.write("' for console.timeLog()\n");
+      return;
+    }
+    timeLogImpl(label);
+  }
+
+  export function timeEnd(label: string = "default"): void {
+    let stdout = wasi_process.stdout;
+    if (!timers.has(label)) {
+      stdout.write("Warning: No such label '");
+      stdout.write(label);
+      stdout.write("' for console.timeEnd()\n");
+      return;
+    }
+    timeLogImpl(label);
+    timers.delete(label);
+  }
+}
+
+function timeLogImpl(label: string): void {
+  var start = changetype<u64>(timers.get(label));
+  var end = wasi_process.hrtime();
+  var nanos = end - start;
+  var millis = nanos / 1000000;
+  var millisStr = millis.toString();
+  var stdout = wasi_process.stdout;
+  stdout.write(label);
+  stdout.write(": ");
+  stdout.write(millisStr);
+  stdout.write("ms\n");
+}

package/warpo_extension/std/wasi_snapshot_preview1/wasi_crypto.ts

@@ -0,0 +1,8 @@
+import { errnoToString, random_get } from "./bindings/wasi_snapshot_preview1";
+
+export namespace wasi_crypto {
+  export function getRandomValues(array: Uint8Array): void {
+    let err = random_get(changetype<usize>(array.buffer) + <usize>array.byteOffset, <usize>array.byteLength);
+    if (err) throw new Error(errnoToString(err));
+  }
+}

package/warpo_extension/std/wasi_snapshot_preview1/wasi_date.ts

@@ -0,0 +1,13 @@
+import { clockid, clock_time_get, errnoToString } from "./bindings/wasi_snapshot_preview1";
+
+import { tempbuf } from "./wasi_internal";
+
+import { Date } from "date";
+
+export class wasi_Date extends Date {
+  static now(): i64 {
+    let err = clock_time_get(clockid.REALTIME, 1000000, tempbuf);
+    if (err) throw new Error(errnoToString(err));
+    return load<u64>(tempbuf) / 1000000;
+  }
+}

package/warpo_extension/std/wasi_snapshot_preview1/wasi_internal.ts

@@ -0,0 +1,119 @@
+import { proc_exit, fd_write, iovec, random_get } from "./bindings/wasi_snapshot_preview1";
+
+// A WASI-wide reusable temporary buffer to store and work with out values. Must
+// be large enough to fit any operation it is used in, i.e. process/writeString.
+// @ts-ignore: decorator
+@lazy export const tempbuf = memory.data(4 * sizeof<usize>());
+
+import { MAX_DOUBLE_LENGTH, decimalCount32, dtoa_buffered } from "util/number";
+
+export function wasi_abort(
+  message: string | null = null,
+  fileName: string | null = null,
+  lineNumber: u32 = 0,
+  columnNumber: u32 = 0
+): void {
+  // 0: iov.buf
+  // 4: iov.buf_len
+  // 8: len
+  // 12: buf...
+  const iovPtr: usize = 0;
+  const lenPtr: usize = iovPtr + offsetof<iovec>();
+  const bufPtr: usize = lenPtr + sizeof<usize>();
+  changetype<iovec>(iovPtr).buf = bufPtr;
+  var ptr = bufPtr;
+  store<u64>(ptr, 0x203a74726f6261);
+  ptr += 7; // 'abort: '
+  if (message != null) {
+    ptr += String.UTF8.encodeUnsafe(changetype<usize>(message), message.length, ptr);
+  }
+  store<u32>(ptr, 0x206e6920);
+  ptr += 4; // ' in '
+  if (fileName != null) {
+    ptr += String.UTF8.encodeUnsafe(changetype<usize>(fileName), fileName.length, ptr);
+  }
+  store<u8>(ptr++, 0x28); // (
+  var len = decimalCount32(lineNumber);
+  ptr += len;
+  do {
+    let t = lineNumber / 10;
+    store<u8>(--ptr, 0x30 + (lineNumber % 10));
+    lineNumber = t;
+  } while (lineNumber);
+  ptr += len;
+  store<u8>(ptr++, 0x3a); // :
+  len = decimalCount32(columnNumber);
+  ptr += len;
+  do {
+    let t = columnNumber / 10;
+    store<u8>(--ptr, 0x30 + (columnNumber % 10));
+    columnNumber = t;
+  } while (columnNumber);
+  ptr += len;
+  store<u16>(ptr, 0x0a29);
+  ptr += 2; // )\n
+  changetype<iovec>(iovPtr).buf_len = ptr - bufPtr;
+  fd_write(2, iovPtr, 1, lenPtr);
+  proc_exit(255);
+}
+
+export function wasi_trace(
+  message: string,
+  n: i32 = 0,
+  a0: f64 = 0,
+  a1: f64 = 0,
+  a2: f64 = 0,
+  a3: f64 = 0,
+  a4: f64 = 0
+): void {
+  // 0: iov.buf
+  // 4: iov.buf_len
+  // 8: len
+  // 12: buf...
+  var iovPtr = __alloc(
+    offsetof<iovec>() + sizeof<usize>() + 1 + <usize>max(String.UTF8.byteLength(message), MAX_DOUBLE_LENGTH << 1)
+  );
+  var lenPtr = iovPtr + offsetof<iovec>();
+  var bufPtr = lenPtr + sizeof<usize>();
+  changetype<iovec>(iovPtr).buf = bufPtr;
+  store<u64>(bufPtr, 0x203a6563617274); // 'trace: '
+  changetype<iovec>(iovPtr).buf_len = 7;
+  fd_write(2, iovPtr, 1, lenPtr);
+  changetype<iovec>(iovPtr).buf_len = String.UTF8.encodeUnsafe(changetype<usize>(message), message.length, bufPtr);
+  fd_write(2, iovPtr, 1, lenPtr);
+  if (n) {
+    store<u8>(bufPtr++, 0x20); // space
+    changetype<iovec>(iovPtr).buf_len = 1 + String.UTF8.encodeUnsafe(bufPtr, dtoa_buffered(bufPtr, a0), bufPtr);
+    fd_write(2, iovPtr, 1, lenPtr);
+    if (n > 1) {
+      changetype<iovec>(iovPtr).buf_len = 1 + String.UTF8.encodeUnsafe(bufPtr, dtoa_buffered(bufPtr, a1), bufPtr);
+      fd_write(2, iovPtr, 1, lenPtr);
+      if (n > 2) {
+        changetype<iovec>(iovPtr).buf_len = 1 + String.UTF8.encodeUnsafe(bufPtr, dtoa_buffered(bufPtr, a2), bufPtr);
+        fd_write(2, iovPtr, 1, lenPtr);
+        if (n > 3) {
+          changetype<iovec>(iovPtr).buf_len = 1 + String.UTF8.encodeUnsafe(bufPtr, dtoa_buffered(bufPtr, a3), bufPtr);
+          fd_write(2, iovPtr, 1, lenPtr);
+          if (n > 4) {
+            changetype<iovec>(iovPtr).buf_len = 1 + String.UTF8.encodeUnsafe(bufPtr, dtoa_buffered(bufPtr, a4), bufPtr);
+            fd_write(2, iovPtr, 1, lenPtr);
+          }
+        }
+      }
+    }
+    --bufPtr;
+  }
+  store<u8>(bufPtr, 0x0a); // \n
+  changetype<iovec>(iovPtr).buf_len = 1;
+  fd_write(2, iovPtr, 1, lenPtr);
+  __free(iovPtr);
+}
+
+export function wasi_seed(): f64 {
+  var rand: u64;
+  do {
+    random_get(tempbuf, 8);
+    rand = load<u64>(tempbuf);
+  } while (!rand);
+  return reinterpret<f64>(rand);
+}

package/warpo_extension/std/wasi_snapshot_preview1/wasi_performance.ts

@@ -0,0 +1,11 @@
+import { clock_time_get, clockid, errnoToString } from "./bindings/wasi_snapshot_preview1";
+
+import { tempbuf } from "./wasi_internal";
+
+export namespace wasi_performance {
+  export function now(): f64 {
+    let err = clock_time_get(clockid.MONOTONIC, 1000, tempbuf); // TODO: more precision?
+    if (err) throw new Error(errnoToString(err));
+    return <f64>load<u64>(tempbuf) / 1000000;
+  }
+}

package/warpo_extension/std/wasi_snapshot_preview1/wasi_process.ts

@@ -0,0 +1,191 @@
+import {
+  args_get,
+  args_sizes_get,
+  environ_get,
+  environ_sizes_get,
+  proc_exit,
+  fd_write,
+  fd_close,
+  fd_read,
+  clock_time_get,
+  clockid,
+  errnoToString,
+  fd,
+} from "./bindings/wasi_snapshot_preview1";
+
+import { tempbuf } from "./wasi_internal";
+
+import { E_INDEXOUTOFRANGE } from "util/error";
+
+export namespace wasi_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 var exitCode = 0;
+
+  export function exit(code: i32 = exitCode): void {
+    proc_exit(code);
+  }
+
+  // @ts-ignore: decorator
+  @lazy export const stdin = changetype<ReadableStream>(0);
+  // @ts-ignore: decorator
+  @lazy export const stdout = changetype<WritableStream>(1);
+  // @ts-ignore: decorator
+  @lazy export const stderr = changetype<WritableStream>(2);
+
+  export function time(): i64 {
+    let err = clock_time_get(clockid.REALTIME, 1000000, tempbuf);
+    if (err) throw new Error(errnoToString(err));
+    return load<u64>(tempbuf) / 1000000;
+  }
+
+  export function hrtime(): u64 {
+    let err = clock_time_get(clockid.MONOTONIC, 0, tempbuf);
+    if (err) throw new Error(errnoToString(err));
+    return load<u64>(tempbuf);
+  }
+}
+
+function lazyArgv(): string[] {
+  let err = args_sizes_get(tempbuf, tempbuf + sizeof<usize>());
+  if (err) throw new Error(errnoToString(err));
+  let count = load<usize>(tempbuf);
+  let ptrsSize = count * sizeof<usize>();
+  let dataSize = load<usize>(tempbuf, sizeof<usize>());
+  let bufSize = ptrsSize + dataSize;
+  let buf = __alloc(bufSize);
+  err = args_get(buf, buf + ptrsSize);
+  if (err) throw new Error(errnoToString(err));
+  let count32 = <i32>count;
+  let argv = new Array<string>(count32);
+  for (let i = 0; i < count32; ++i) {
+    let ptr = load<usize>(buf + i * sizeof<usize>());
+    let str = String.UTF8.decodeUnsafe(ptr, ptr + bufSize - buf, true);
+    argv[i] = str;
+  }
+  __free(buf);
+  return argv;
+}
+
+function lazyEnv(): Map<string, string> {
+  let err = environ_sizes_get(tempbuf, tempbuf + 4);
+  if (err) throw new Error(errnoToString(err));
+  let count = load<usize>(tempbuf);
+  let ptrsSize = count * sizeof<usize>();
+  let dataSize = load<usize>(tempbuf, sizeof<usize>());
+  let bufSize = ptrsSize + dataSize;
+  let buf = __alloc(bufSize);
+  err = environ_get(buf, buf + ptrsSize);
+  if (err) throw new Error(errnoToString(err));
+  let env = new Map<string, string>();
+  for (let i: usize = 0; i < count; ++i) {
+    let ptr = load<usize>(buf + i * sizeof<usize>());
+    let str = String.UTF8.decodeUnsafe(ptr, ptr + bufSize - buf, true);
+    let pos = str.indexOf("=");
+    if (~pos) {
+      env.set(str.substring(0, pos), str.substring(pos + 1));
+      // __dispose(changetype<usize>(str));
+    } else {
+      env.set(str, "");
+    }
+  }
+  __free(buf);
+  return env;
+}
+
+
+@unmanaged
+abstract class Stream {
+  close(): void {
+    var err = fd_close(<u32>changetype<usize>(this));
+    if (err) throw new Error(errnoToString(err));
+  }
+}
+
+
+@unmanaged
+abstract class WritableStream extends Stream {
+  write<T>(data: T): void {
+    if (isString<T>()) {
+      writeString(<u32>changetype<usize>(this), changetype<string>(data));
+    } else if (data instanceof ArrayBuffer) {
+      writeBuffer(<u32>changetype<usize>(this), data);
+    } else {
+      ERROR("String or ArrayBuffer expected");
+    }
+  }
+}
+
+
+@unmanaged
+abstract class ReadableStream extends Stream {
+  read(buffer: ArrayBuffer, offset: isize = 0): i32 {
+    var end = <usize>buffer.byteLength;
+    if (offset < 0 || <usize>offset > end) {
+      throw new Error(E_INDEXOUTOFRANGE);
+    }
+    store<usize>(tempbuf, changetype<usize>(buffer) + offset);
+    store<usize>(tempbuf, end - offset, sizeof<usize>());
+    var err = fd_read(<u32>changetype<usize>(this), tempbuf, 1, tempbuf + 2 * sizeof<usize>());
+    if (err) throw new Error(errnoToString(err));
+    return <i32>load<isize>(tempbuf, 2 * sizeof<usize>());
+  }
+}
+
+function writeBuffer(fd: fd, data: ArrayBuffer): void {
+  store<usize>(tempbuf, changetype<usize>(data));
+  store<usize>(tempbuf, data.byteLength, sizeof<usize>());
+  var err = fd_write(<u32>fd, tempbuf, 1, tempbuf + 2 * sizeof<usize>());
+  if (err) throw new Error(errnoToString(err));
+}
+
+function writeString(fd: fd, data: string): void {
+  var len = data.length;
+  var char2: u32 = 0,
+    char3: u32 = 0,
+    char4: u32 = 0;
+  switch (len) {
+    case 4: {
+      // "null"
+      char4 = <u32>load<u16>(changetype<usize>(data), 6);
+      if (char4 >= 0x80) break;
+    }
+    case 3: {
+      // "ms\n"
+      char3 = <u32>load<u16>(changetype<usize>(data), 4);
+      if (char3 >= 0x80) break;
+    }
+    case 2: {
+      // "\r\n"
+      char2 = <u32>load<u16>(changetype<usize>(data), 2);
+      if (char2 >= 0x80) break;
+    }
+    case 1: {
+      // "\n"
+      let char1 = <u32>load<u16>(changetype<usize>(data));
+      if (char1 >= 0x80) break;
+      store<usize>(tempbuf, tempbuf + 2 * sizeof<usize>());
+      store<usize>(tempbuf, len, sizeof<usize>());
+      store<u32>(tempbuf, char1 | (char2 << 8) | (char3 << 16) | (char4 << 24), 2 * sizeof<usize>());
+      let err = fd_write(<u32>fd, tempbuf, 1, tempbuf + 3 * sizeof<usize>());
+      if (err) throw new Error(errnoToString(err));
+    }
+    case 0:
+      return;
+  }
+  var utf8len = <usize>String.UTF8.byteLength(data);
+  var utf8buf = __alloc(utf8len);
+  assert(String.UTF8.encodeUnsafe(changetype<usize>(data), len, utf8buf) == utf8len);
+  store<usize>(tempbuf, utf8buf);
+  store<usize>(tempbuf, utf8len, sizeof<usize>());
+  var err = fd_write(<u32>fd, tempbuf, 1, tempbuf + 2 * sizeof<usize>());
+  __free(utf8buf);
+  if (err) throw new Error(errnoToString(err));
+}