porffor 0.55.15 → 0.55.16

package/compiler/builtins/bigint.ts

@@ -0,0 +1,233 @@
+import type {} from './porffor.d.ts';
+
+// digits is an array of u32s as digits in base 2^32
+export const __Porffor_bigint_fromDigits = (negative: boolean, digits: i32[]): bigint => {
+  const len: i32 = digits.length;
+  if (len > 16383) throw new RangeError('Maximum BigInt size exceeded'); // (65536 - 4) / 4
+
+  // const ptr: i32 = Porffor.allocate();
+  const ptr: i32 = Porffor.wasm`local.get ${digits}`;
+
+  Porffor.wasm.i32.store8(ptr, negative ? 1 : 0, 0, 0);
+  Porffor.wasm.i32.store16(ptr, len, 0, 2);
+
+  for (let i: i32 = 0; i < len; i++) {
+    Porffor.wasm.i32.store(ptr + i * 4, digits[i], 0, 4);
+  }
+
+  const out: bigint = ptr;
+  return out;
+};
+
+export const __Porffor_bigint_fromNumber = (n: number): bigint => {
+  if (!Number.isInteger(n) || !Number.isFinite(n)) throw new RangeError('Cannot convert non-integer to BigInt');
+
+  const negative: boolean = n < 0;
+  n = Math.abs(n);
+
+  const digits: i32[] = Porffor.allocate();
+  while (n > 0) {
+    digits.unshift(n % 0x100000000);
+    n = Math.trunc(n / 0x100000000);
+  }
+
+  return __Porffor_bigint_fromDigits(negative, digits);
+};
+
+export const __Porffor_bigint_toNumber = (ptr: i32): number => {
+  const negative: boolean = Porffor.wasm.i32.load8_u(ptr, 0, 0) != 0;
+  const len: i32 = Porffor.wasm.i32.load16_u(ptr, 0, 2);
+
+  let out: number = 0;
+  for (let i: i32 = 0; i < len; i++) {
+    const d: i32 = Porffor.wasm.i32.load(ptr + i * 4, 0, 4);
+    out = out * 0x100000000 + d;
+  }
+
+  if (negative) out = -out;
+  return out;
+};
+
+export const __Porffor_bigint_fromString = (n: string|bytestring): bigint => {
+  const len: i32 = n.length;
+
+  let negative: boolean = false;
+  let end: i32 = 0;
+  if (n[0] === '-') {
+    negative = true;
+    end = 1;
+  } else if (n[0] === '+') {
+    end = 1;
+  }
+
+  // n -> digits (base 2^32) (most to least significant)
+  // 4294967294 -> [ 4294967294 ]
+  // 4294967295 -> [ 4294967295 ]
+  // 4294967296 -> [ 1, 0 ]
+  // 4294967297 -> [ 1, 1 ]
+  // 4294967298 -> [ 1, 2 ]
+  // 9007199254740992 -> [ 2097152 ]
+  // 9007199254740993 -> [ 2097152, 1 ]
+  // 9007199254740994 -> [ 2097152, 2 ]
+  // 9007199254740995 -> [ 2097152, 3 ]
+
+  const digits: i32[] = Porffor.allocate();
+
+  const base = 0x100000000; // 2^32
+
+  for (let i: i32 = end; i < len; i++) {
+    const char: i32 = n.charCodeAt(i);
+    const digit: i32 = char - 48;
+    if (digit < 0 || digit > 9) throw new SyntaxError('Invalid characters in BigInt string');
+
+    // Multiply current digits by 10 and add the new digit
+    let carry: i32 = digit;
+    for (let j: i32 = 0; j < digits.length; j++) {
+      const value: i32 = digits[j] * 10 + carry;
+      digits[j] = value % base;
+      carry = Math.trunc(value / base);
+    }
+
+    // If there's a carry left, push it as a new digit
+    if (carry > 0) {
+      digits.push(carry);
+    }
+  }
+
+  return __Porffor_bigint_fromDigits(negative, digits);
+};
+
+export const __Porffor_bigint_toString = (ptr: i32, radix: number): string => {
+  // todo
+  // return '';
+};
+
+export const __Porffor_bigint_add = (a: i32, b: i32, sub: boolean): bigint => {
+  const aNegative: boolean = Porffor.wasm.i32.load8_u(a, 0, 0) != 0;
+  const aLen: i32 = Porffor.wasm.i32.load16_u(a, 0, 2);
+
+  let bNegative: boolean = Porffor.wasm.i32.load8_u(b, 0, 0) != 0;
+  if (sub) bNegative = !bNegative;
+  const bLen: i32 = Porffor.wasm.i32.load16_u(b, 0, 2);
+
+  const maxLen: i32 = Math.max(aLen, bLen);
+  const digits: i32[] = Porffor.allocate();
+
+  // fast path: same sign
+  let negative: boolean = false;
+  let carry: i32 = 0;
+  if (aNegative == bNegative) {
+    negative = aNegative;
+
+    for (let i: i32 = 0; i < maxLen; i++) {
+      let aDigit: i32 = 0;
+      const aOffset: i32 = aLen - i;
+      if (aOffset > 0) aDigit = Porffor.wasm.i32.load(a + aOffset * 4, 0, 0);
+
+      let bDigit: i32 = 0;
+      const bOffset: i32 = bLen - i;
+      if (bOffset > 0) bDigit = Porffor.wasm.i32.load(b + bOffset * 4, 0, 0);
+
+      let sum: i32 = aDigit + bDigit + carry;
+      if (sum >= 0x100000000) {
+        sum -= 0x100000000;
+        carry = 1;
+      } else if (sum < 0) {
+        sum += 0x100000000;
+        carry = 1;
+      } else {
+        carry = 0;
+      }
+
+      digits.unshift(sum);
+    }
+  } else {
+    let aLarger: i32 = 0;
+    for (let i: i32 = 0; i < maxLen; i++) {
+      let aDigit: i32 = 0;
+      const aOffset: i32 = aLen - i;
+      if (aOffset > 0) aDigit = Porffor.wasm.i32.load(a + aOffset * 4, 0, 0);
+
+      let bDigit: i32 = 0;
+      const bOffset: i32 = bLen - i;
+      if (bOffset > 0) bDigit = Porffor.wasm.i32.load(b + bOffset * 4, 0, 0);
+
+      let sum: i32 = carry;
+      if (aNegative) sum -= aDigit;
+        else sum += aDigit;
+      if (bNegative) sum -= bDigit;
+        else sum += bDigit;
+
+      if (aDigit != bDigit) aLarger = aDigit > bDigit ? 1 : -1;
+
+      if (sum >= 0x100000000) {
+        sum -= 0x100000000;
+        carry = 1;
+      } else if (sum < 0) {
+        sum += 0x100000000;
+        carry = -1;
+      } else {
+        carry = 0;
+      }
+
+      digits.unshift(sum);
+    }
+
+    if (aLarger == 1) negative = aNegative;
+      else if (aLarger == -1) negative = bNegative;
+  }
+
+  if (carry != 0) {
+    digits.unshift(Math.abs(carry));
+    if (carry < 0) negative = !negative;
+  }
+
+  return __Porffor_bigint_fromDigits(negative, digits);
+};
+
+export const __Porffor_bigint_sub = (a: i32, b: i32): bigint => {
+  return __Porffor_bigint_add(a, b, true);
+};
+
+export const __Porffor_bigint_mul = (a: i32, b: i32): bigint => {
+  // todo
+  // return 0n;
+};
+
+export const __Porffor_bigint_div = (a: i32, b: i32): bigint => {
+  // todo
+  // return 0n;
+};
+
+export const __Porffor_bigint_rem = (a: i32, b: i32): bigint => {
+  // todo
+  // return 0n;
+};
+
+export const __Porffor_bigint_eq = (a: i32, b: i32): boolean => {
+  // todo
+  // return false;
+};
+
+export const __Porffor_bigint_ne = (a: i32, b: i32): boolean => {
+  return !__Porffor_bigint_eq(a, b);
+};
+
+export const __Porffor_bigint_gt = (a: i32, b: i32): boolean => {
+  // todo
+  // return false;
+};
+
+export const __Porffor_bigint_ge = (a: i32, b: i32): boolean => {
+  // todo
+  // return false;
+};
+
+export const __Porffor_bigint_lt = (a: i32, b: i32): boolean => {
+  return !__Porffor_bigint_ge(a, b);
+};
+
+export const __Porffor_bigint_le = (a: i32, b: i32): boolean => {
+  return !__Porffor_bigint_gt(a, b);
+};
+