toilscript 0.1.2 → 0.1.5

package/std/assembly/bignum/utils.ts

@@ -0,0 +1,260 @@
+import { CharCode } from "util/string";
+import { u128 } from "./integer/u128";
+import { u256 } from "./integer/u256";
+
+// @ts-ignore: decorator
+@lazy const MaxBaseForExponent128 = memory.data<u64>([
+  u64.MAX_VALUE,       // 0
+  u64.MAX_VALUE,       // 1
+  u64.MAX_VALUE,       // 2
+  0x000006597FA94F5B,  // 3
+  0x00000000FFFFFFFF,  // 4
+  0x0000000003080C00,  // 5
+  0x0000000000285145,  // 6
+  0x000000000004E045,  // 7
+  0x000000000000FFFF,  // 8
+  0x0000000000004AA8,  // 9
+  0x0000000000001BDB,  // 10
+  0x0000000000000C6F,  // 11
+  0x0000000000000659,  // 12
+  0x0000000000000398,  // 13
+  0x0000000000000235,  // 14
+  0x0000000000000172,  // 15
+  0x00000000000000FF,  // 16
+  0x00000000000000B8,  // 17
+  0x000000000000008A,  // 18
+  0x000000000000006A,  // 19
+  0x0000000000000054,  // 20
+  0x0000000000000044,  // 21
+  0x0000000000000038,  // 22
+  0x000000000000002F,  // 23
+  0x0000000000000028,  // 24
+  0x0000000000000022,  // 25
+  0x000000000000001E,  // 26
+  0x000000000000001A,  // 27
+  0x0000000000000017,  // 28
+  0x0000000000000015,  // 29
+  0x0000000000000013,  // 30
+  0x0000000000000011,  // 31
+  0x000000000000000F,  // 32
+  0x000000000000000E,  // 33
+  0x000000000000000D,  // 34
+  0x000000000000000C,  // 35
+  0x000000000000000B,  // 36
+  0x000000000000000B,  // 37
+  0x000000000000000A,  // 38
+]);
+
+// Use LUT wrapped by function for lazy compilation
+// @ts-ignore: decorator
+@lazy const RadixCharsTable = memory.data<u8>([
+  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 36, 36, 36, 36, 36, 36,
+  36, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+  25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 36, 36, 36, 36,
+  36, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+  25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35
+]);
+
+// @ts-ignore: decorator
+@inline export function isPowerOverflow128(base: u128, exponent: i32): bool {
+  // never overflow
+  if (exponent <= 1 || base <= u128.One) {
+    return false;
+  }
+  // always overflow
+  if (base.hi != 0 || exponent >= 128) {
+    return true;
+  }
+  var low = base.lo;
+  if (low <= 10) {
+    switch (<i32>low) {
+      case 2:
+        return exponent > 127;
+      case 3:
+        return exponent > 80;
+      case 4:
+        return exponent > 63;
+      case 5:
+        return exponent > 55;
+      case 6:
+        return exponent > 49;
+      case 7:
+        return exponent > 45;
+      case 8:
+        return exponent > 42;
+      case 9:
+        return exponent > 40;
+      case 10:
+        return exponent > 38;
+    }
+  }
+  if (exponent >= 38) return true;
+  return low > load<u64>(MaxBaseForExponent128 + (exponent << 3));
+}
+
+// helper function for utoa
+function processU64(digits: Uint8Array, value: u64): void {
+  var length = digits.length - 1;
+  for (let i = 63; i != -1; --i) {
+    for (let j = 0; j <= length; ++j) {
+      unchecked(digits[j] += (u8(digits[j] >= 5) * 3));
+    }
+    for (let j = length; j != -1; --j) {
+      let d = unchecked(digits[j]) << 1;
+      if (j < length) unchecked(digits[j + 1] |= u8(d > 15));
+      unchecked(digits[j] = d & 15);
+    }
+    unchecked(digits[0] += u8((value & (1 << i)) != 0));
+  }
+}
+
+export function u128toDecimalString(value: u128): string {
+  var length = 40;
+  var digits = new Uint8Array(length);
+  var result = "", start = false;
+
+  processU64(digits, value.hi);
+  processU64(digits, value.lo);
+
+  for (let i = length - 1; i != -1; --i) {
+    let d = unchecked(digits[i]);
+    if (!start && d != 0) start = true;
+    if (start) {
+      assert(<u32>d <= 9);
+      result += String.fromCharCode(0x30 + d);
+    }
+  }
+  return result;
+}
+
+export function u256toDecimalString(value: u256): string {
+  var length = 78;
+  var digits = new Uint8Array(length);
+  var result = "", start = false;
+
+  processU64(digits, value.hi2);
+  processU64(digits, value.hi1);
+  processU64(digits, value.lo2);
+  processU64(digits, value.lo1);
+
+  for (let i = length - 1; i != -1; --i) {
+    let d = unchecked(digits[i]);
+    if (!start && d != 0) start = true;
+    if (start) {
+      assert(<u32>d <= 9);
+      result += String.fromCharCode(0x30 + d);
+    }
+  }
+  return result;
+}
+
+export function atou128(str: string, radix: i32 = 10): u128 {
+  if (radix < 2 || radix > 36) {
+    throw new Error("Invalid radix");
+  }
+  var len = str.length;
+  if (!len) return u128.Zero;
+
+  var first = str.charCodeAt(0);
+  if (len == 1 && first == CharCode._0) {
+    return u128.Zero;
+  }
+  var isNeg = first == CharCode.MINUS;
+  // @ts-ignore
+  var index = i32(isNeg | (first == CharCode.PLUS));
+
+  if (str.charCodeAt(index) == CharCode._0) {
+    let second = str.charCodeAt(++index);
+    if ((second | 32) == CharCode.x) {
+      radix = 16;
+      ++index;
+    } else if ((second | 32) == CharCode.o) {
+      radix = 8;
+      ++index;
+    } else if ((second | 32) == CharCode.b) {
+      radix = 2;
+      ++index;
+    } else if (second == CharCode._0) {
+      // skip leading zeros
+      while (index < len && str.charCodeAt(index) == CharCode._0) ++index;
+    }
+  }
+  var result = u128.Zero;
+  var table = RadixCharsTable;
+
+  if (index >= len) return result;
+
+  if (ASC_SHRINK_LEVEL >= 1) {
+    let radix128 = u128.fromU64(radix);
+    do {
+      let n: u32 = str.charCodeAt(index) - CharCode._0;
+      if (n > <u32>(CharCode.z - CharCode._0)) break;
+
+      let num = load<u8>(table + n);
+      if (num >= <u8>radix) break;
+
+      // @ts-ignore
+      result *= radix128;
+      // @ts-ignore
+      result += u128.fromU64(num);
+    } while (++index < len);
+  } else {
+    switch (radix) {
+      case 2: {
+        do {
+          let num: u32 = str.charCodeAt(index) - CharCode._0;
+          if (num >= 2) break;
+          // @ts-ignore
+          result <<= 1;
+          // @ts-ignore
+          result |= u128.fromU64(num);
+        } while (++index < len);
+        break;
+      }
+      case 10: {
+        do {
+          let num: u32 = str.charCodeAt(index) - CharCode._0;
+          if (num >= 10) break;
+          // @ts-ignore
+          result = (result << 3) + (result << 1);
+          // @ts-ignore
+          result += u128.fromU64(num);
+        } while (++index < len);
+        break;
+      }
+      case 16: {
+        do {
+          let n: u32 = str.charCodeAt(index) - CharCode._0;
+          if (n > <u32>(CharCode.z - CharCode._0)) break;
+
+          let num = load<u8>(table + n);
+          if (num >= 16) break;
+
+          // @ts-ignore
+          result <<= 4;
+          // @ts-ignore
+          result |= u128.fromU64(num);
+        } while (++index < len);
+        break;
+      }
+      default: {
+        let radix128 = u128.fromU64(radix);
+        do {
+          let n: u32 = str.charCodeAt(index) - CharCode._0;
+          if (n > <u32>(CharCode.z - CharCode._0)) break;
+
+          let num = load<u8>(table + n);
+          if (num >= <u8>radix) break;
+
+          // @ts-ignore
+          result *= radix128;
+          // @ts-ignore
+          result += u128.fromU64(num);
+        } while (++index < len);
+        break;
+      }
+    }
+  }
+  // @ts-ignore
+  return isNeg ? -result : result;
+}

package/std/assembly/bignum.ts

@@ -0,0 +1,18 @@
+// Big integer types (u128 / i128 / u256), vendored verbatim from
+// @btc-vision/as-bignum v1.0.0 (Apache-2.0) under ./bignum. See ./bignum/LICENSE.
+//
+// This file is a top-level standard-library entry, so toilscript globalizes its
+// named re-exports the same way it does Array/Map/String. That makes u128, i128
+// and u256 usable with no import, as native types:
+//
+//     let a = u128.fromU64(40) + u128.fromU64(2);
+//     let b = u256.fromU128(a);
+//
+// The vendored sources are unmodified; only this thin globalizer is toilscript's.
+// i256 is the signed-256 backing type of the family (u128/i128 convert to it),
+// so it is globalized too for a self-consistent surface.
+
+export { u128 } from "./bignum/integer/u128";
+export { i128 } from "./bignum/integer/i128";
+export { u256 } from "./bignum/integer/u256";
+export { i256 } from "./bignum/integer/i256";

package/std/assembly/index.d.ts

@@ -2890,3 +2890,260 @@ declare namespace external {
 
 /** Annotates a global for lazy compilation. */
 declare function lazy(...args: any[]): any;
+
+// Big integers — native globals implemented in std/assembly/bignum (vendored
+// from @btc-vision/as-bignum). The arithmetic/bitwise/comparison operators
+// (+ - * / % & | ^ << >> == != < > <= >=) are operator overloads resolved by
+// the compiler; the equivalent static methods are listed for tooling.
+
+/** A 128-bit unsigned integer. */
+declare class u128 {
+  lo: u64;
+  hi: u64;
+  constructor(lo?: u64, hi?: u64);
+
+  static readonly Zero: u128;
+  static readonly One: u128;
+  static readonly Min: u128;
+  static readonly Max: u128;
+
+  static fromString(value: string, radix?: i32): u128;
+  static fromI256(value: i256): u128;
+  static fromU256(value: u256): u128;
+  static fromI128(value: i128): u128;
+  static fromU128(value: u128): u128;
+  static fromI64(value: i64): u128;
+  static fromU64(value: u64): u128;
+  static fromF64(value: f64): u128;
+  static fromF32(value: f32): u128;
+  static fromI32(value: i32): u128;
+  static fromU32(value: u32): u128;
+  static fromBool(value: bool): u128;
+  static fromBits(lo1: u32, lo2: u32, hi1: u32, hi2: u32): u128;
+  static fromBytes<T>(array: T, bigEndian?: bool): u128;
+  static fromBytesLE(array: u8[]): u128;
+  static fromBytesBE(array: u8[]): u128;
+  static fromUint8ArrayLE(array: Uint8Array): u128;
+  static fromUint8ArrayBE(array: Uint8Array): u128;
+  static from<T>(value: T): u128;
+
+  static isEmpty(value: u128): bool;
+  static or(a: u128, b: u128): u128;
+  static xor(a: u128, b: u128): u128;
+  static and(a: u128, b: u128): u128;
+  static shl(value: u128, shift: i32): u128;
+  static shr(value: u128, shift: i32): u128;
+  static shr_u(value: u128, shift: i32): u128;
+  static rotl(value: u128, shift: i32): u128;
+  static rotr(value: u128, shift: i32): u128;
+  static add(a: u128, b: u128): u128;
+  static sub(a: u128, b: u128): u128;
+  static mul(a: u128, b: u128): u128;
+  static div(a: u128, b: u128): u128;
+  static rem(a: u128, b: u128): u128;
+  static div10(value: u128): u128;
+  static rem10(value: u128): u128;
+  static pow(base: u128, exponent: i32): u128;
+  static sqrt(value: u128): u128;
+  static sqr(value: u128): u128;
+  static muldiv(a: u128, b: u128, c: u128): u128;
+  static eq(a: u128, b: u128): bool;
+  static ne(a: u128, b: u128): bool;
+  static lt(a: u128, b: u128): bool;
+  static gt(a: u128, b: u128): bool;
+  static le(a: u128, b: u128): bool;
+  static ge(a: u128, b: u128): bool;
+  static ord(a: u128, b: u128): i32;
+  static popcnt(value: u128): i32;
+  static clz(value: u128): i32;
+  static ctz(value: u128): i32;
+
+  set(value: u128): this;
+  setI64(value: i64): this;
+  setU64(value: u64): this;
+  setI32(value: i32): this;
+  setU32(value: u32): this;
+  isZero(): bool;
+  not(): u128;
+  neg(): u128;
+  pos(): u128;
+  sqr(): this;
+  preInc(): this;
+  preDec(): this;
+  postInc(): u128;
+  postDec(): u128;
+  clone(): u128;
+  as<T>(): T;
+  toI64(): i64;
+  toU64(): u64;
+  toI32(): i32;
+  toU32(): u32;
+  toBool(): bool;
+  toF64(): f64;
+  toF32(): f32;
+  toI128(): i128;
+  toU128(): this;
+  toI256(): i256;
+  toU256(): u256;
+  toBytes(bigEndian?: bool): u8[];
+  toStaticBytes(bigEndian?: bool): StaticArray<u8>;
+  toUint8Array(bigEndian?: bool): Uint8Array;
+  toString(radix?: i32): string;
+}
+
+/** A 128-bit signed integer. */
+declare class i128 {
+  lo: u64;
+  hi: i64;
+  constructor(lo?: u64, hi?: i64);
+
+  static readonly Zero: i128;
+  static readonly One: i128;
+  static readonly Min: i128;
+  static readonly Max: i128;
+
+  static fromString(value: string, radix?: i32): i128;
+  static fromI256(value: i256): i128;
+  static fromU256(value: u256): i128;
+  static fromI128(value: i128): i128;
+  static fromU128(value: u128): i128;
+  static fromI64(value: i64): i128;
+  static fromU64(value: u64): i128;
+  static fromF64(value: f64): i128;
+  static fromF32(value: f32): i128;
+  static fromI32(value: i32): i128;
+  static fromU32(value: u32): i128;
+  static fromBits(lo1: i32, lo2: i32, hi1: i32, hi2: i32): i128;
+  static fromBytes<T>(array: T, bigEndian?: bool): i128;
+  static fromBytesLE(array: u8[]): i128;
+  static fromBytesBE(array: u8[]): i128;
+  static fromUint8ArrayLE(array: Uint8Array): i128;
+  static fromUint8ArrayBE(array: Uint8Array): i128;
+  static from<T>(value: T): i128;
+
+  static isEmpty(value: i128): bool;
+  static or(a: i128, b: i128): i128;
+  static xor(a: i128, b: i128): i128;
+  static and(a: i128, b: i128): i128;
+  static shl(value: i128, shift: i32): i128;
+  static shr_u(value: i128, shift: i32): i128;
+  static add(a: i128, b: i128): i128;
+  static sub(a: i128, b: i128): i128;
+  static eq(a: i128, b: i128): bool;
+  static ne(a: i128, b: i128): bool;
+  static lt(a: i128, b: i128): bool;
+  static gt(a: i128, b: i128): bool;
+  static le(a: i128, b: i128): bool;
+  static ge(a: i128, b: i128): bool;
+  static ord(a: i128, b: i128): i32;
+  static popcnt(value: i128): i32;
+  static clz(value: i128): i32;
+  static ctz(value: i128): i32;
+  static abs(value: i128): i128;
+
+  isNeg(): bool;
+  isPos(): bool;
+  isZero(): bool;
+  not(): i128;
+  neg(): i128;
+  pos(): i128;
+  toBytes(bigEndian?: bool): u8[];
+  toStaticBytes(bigEndian?: bool): StaticArray<u8>;
+  toUint8Array(bigEndian?: bool): Uint8Array;
+}
+
+/** A 256-bit unsigned integer. */
+declare class u256 {
+  lo1: u64;
+  lo2: u64;
+  hi1: u64;
+  hi2: u64;
+  constructor(lo1?: u64, lo2?: u64, hi1?: u64, hi2?: u64);
+
+  static readonly Zero: u256;
+  static readonly One: u256;
+  static readonly Min: u256;
+  static readonly Max: u256;
+
+  static fromU256(value: u256): u256;
+  static fromU128(value: u128): u256;
+  static fromU64(value: u64): u256;
+  static fromI64(value: i64): u256;
+  static fromU32(value: u32): u256;
+  static fromI32(value: i32): u256;
+  static fromBits(l0: u32, l1: u32, l2: u32, l3: u32, h0: u32, h1: u32, h2: u32, h3: u32): u256;
+  static fromBytes<T>(array: T, bigEndian?: bool): u256;
+  static fromBytesLE(array: u8[]): u256;
+  static fromBytesBE(array: u8[]): u256;
+  static fromUint8ArrayLE(array: Uint8Array): u256;
+  static fromUint8ArrayBE(array: Uint8Array): u256;
+  static fromF64(value: f64): u256;
+  static fromF32(value: f32): u256;
+  static from<T>(value: T): u256;
+  static fromString(str: string, radix?: i32): u256;
+
+  static isEmpty(value: u256): bool;
+  static add(a: u256, b: u256): u256;
+  static sub(a: u256, b: u256): u256;
+  static mul(a: u256, b: u256): u256;
+  static or(a: u256, b: u256): u256;
+  static xor(a: u256, b: u256): u256;
+  static and(a: u256, b: u256): u256;
+  static shr(value: u256, shift: i32): u256;
+  static shr_u(value: u256, shift: i32): u256;
+  static eq(a: u256, b: u256): bool;
+  static ne(a: u256, b: u256): bool;
+  static lt(a: u256, b: u256): bool;
+  static gt(a: u256, b: u256): bool;
+  static le(a: u256, b: u256): bool;
+  static ge(a: u256, b: u256): bool;
+  static popcnt(value: u256): i32;
+  static clz(value: u256): i32;
+  static ctz(value: u256): i32;
+
+  set(value: u256): this;
+  setI64(value: i64): this;
+  setU64(value: u64): this;
+  setI32(value: i32): this;
+  setU32(value: u32): this;
+  setU128(value: u128): this;
+  isZero(): bool;
+  not(): u256;
+  neg(): u256;
+  pos(): u256;
+  postInc(): u256;
+  postDec(): u256;
+  clone(): u256;
+  as<T>(): T;
+  toI64(): i64;
+  toU64(): u64;
+  toI32(): i32;
+  toU32(): u32;
+  toBool(): bool;
+  toI128(): i128;
+  toU128(): u128;
+  toU256(): this;
+  toBytes(bigEndian?: bool): u8[];
+  toStaticBytes(bigEndian?: bool): StaticArray<u8>;
+  toUint8Array(bigEndian?: bool): Uint8Array;
+  toString(radix?: i32): string;
+}
+
+/** A 256-bit signed integer (backs the signed conversions of the family). */
+declare class i256 {
+  lo1: i64;
+  lo2: i64;
+  hi1: i64;
+  hi2: i64;
+  constructor(lo1?: i64, lo2?: i64, hi1?: i64, hi2?: i64);
+
+  static readonly Zero: i256;
+  static readonly One: i256;
+  static readonly Min: i256;
+  static readonly Max: i256;
+
+  static isEmpty(value: i256): bool;
+
+  isNeg(): bool;
+  isZero(): bool;
+}

package/std/assembly/toilscript.ts

@@ -13,4 +13,4 @@
  * exports it as the WebAssembly export `main` — no `export` keyword needed.
  * Exactly one `@main` is allowed per module.
  */
-declare function main(...args: any[]): any;
+declare function main(): void;

package/std/assembly.json

@@ -7,6 +7,7 @@
     "allowJs": false,
     "typeRoots": [ "types" ],
     "types": [ "assembly" ],
+    "plugins": [ { "name": "toilscript/std/ts-plugin.cjs" } ],
     "paths": {
       "*": [
         "./assembly/*"

package/std/ts-plugin.cjs

@@ -0,0 +1,44 @@
+/**
+ * ToilScript TypeScript Language Service plugin.
+ *
+ * Stock TypeScript has no grammar for toil-native decorators applied to
+ * top-level functions and globals (`@main`, `@inline`, `@unmanaged`, ...), so
+ * the editor's language service flags them as errors even though the toilscript
+ * compiler (asc) handles them correctly. This plugin runs only inside the
+ * editor's language service (VS Code, WebStorm, etc. — never `tsc`/asc builds)
+ * and removes exactly those decorator-grammar false positives:
+ *
+ *   TS1206  "Decorators are not valid here."
+ *   TS1249  "A decorator can only decorate a method implementation, not an overload."
+ *
+ * Every other diagnostic — unknown types, bad calls, missing names — passes
+ * through untouched, so real type errors are still surfaced.
+ */
+const DECORATOR_GRAMMAR_CODES = new Set([1206, 1249]);
+
+function init() {
+  return {
+    create(info) {
+      const ls = info.languageService;
+
+      // Proxy the language service, forwarding everything to the real one.
+      const proxy = Object.create(null);
+      for (const key of Object.keys(ls)) {
+        const value = ls[key];
+        proxy[key] = typeof value === 'function' ? value.bind(ls) : value;
+      }
+
+      const strip = (diagnostics) =>
+        diagnostics.filter((d) => !DECORATOR_GRAMMAR_CODES.has(d.code));
+
+      proxy.getSemanticDiagnostics = (fileName) =>
+        strip(ls.getSemanticDiagnostics(fileName));
+      proxy.getSyntacticDiagnostics = (fileName) =>
+        strip(ls.getSyntacticDiagnostics(fileName));
+
+      return proxy;
+    },
+  };
+}
+
+module.exports = init;