porffor 0.2.0-aea77ff → 0.2.0-b9abe0d

package/compiler/builtins/int.ts

@@ -0,0 +1,147 @@
+// @porf -funsafe-no-unlikely-proto-checks
+
+// radix: number|any for rawType check
+// export const parseInt = (input: string|bytestring, radix: number|any): f64 => {
+export const parseInt = (input: string|bytestring, radix: number): f64 => {
+  // todo/perf: optimize this instead of doing a naive algo (https://kholdstare.github.io/technical/2020/05/26/faster-integer-parsing.html)
+  // todo/perf: use i32s here once that becomes not annoying
+
+  if (Porffor.rawType(radix) != Porffor.TYPES.number) {
+    // todo: string to number
+    radix = 10;
+  }
+
+  if (radix == 0) radix = 10;
+  if (radix < 2 || radix > 36) return NaN;
+
+  let nMax: f64 = 58;
+  if (radix < 10) nMax = 48 + radix;
+
+  // if (Porffor.rawType(input) == Porffor.TYPES._bytestring) input = ___bytestring_prototype_trimStart(input);
+  //   else input = __String_prototype_trimStart(input);
+
+  let n: f64 = NaN;
+
+  const inputPtr: f64 = Porffor.wasm`local.get ${input}`;
+  const len: f64 = Porffor.wasm.i32.load(inputPtr, 0, 0);
+  let i: f64 = inputPtr;
+
+  let negative: boolean = false;
+
+  if (Porffor.rawType(input) == Porffor.TYPES._bytestring) {
+    const endPtr: f64 = i + len;
+
+    // check start of string
+    const startChr: f64 = Porffor.wasm.i32.load8_u(i, 0, 4);
+
+    // +, ignore
+    if (startChr == 43) i++;
+
+    // -, switch to negative
+    if (startChr == 45) {
+      negative = true;
+      i++;
+    }
+
+    // 0, potential start of hex
+    if (startChr == 48) {
+      const second: f64 = Porffor.wasm.i32.load8_u(i + 1, 0, 4);
+      // 0x or 0X
+      if (second == 120 || second == 88) {
+        // set radix to 16 and skip leading 2 chars
+        i += 2;
+        radix = 16;
+      }
+    }
+
+    while (i < endPtr) {
+      const chr: f64 = Porffor.wasm.i32.load8_u(i++, 0, 4);
+
+      if (chr >= 48 && chr < nMax) {
+        if (Number.isNaN(n)) n = 0;
+
+        n *= radix;
+        n += chr - 48;
+      } else if (radix > 10) {
+        if (chr >= 97 && chr < (87 + radix)) {
+          if (Number.isNaN(n)) n = 0;
+
+          n *= radix;
+          n += chr - 87;
+        } else if (chr >= 65 && chr < (55 + radix)) {
+          if (Number.isNaN(n)) n = 0;
+
+          n *= radix;
+          n += chr - 55;
+        } else {
+          if (negative) return -n;
+          return n;
+        }
+      } else {
+        if (negative) return -n;
+        return n;
+      }
+    }
+
+    if (negative) return -n;
+    return n;
+  }
+
+  const endPtr: f64 = i + len * 2;
+
+  // check start of string
+  const startChr: f64 = Porffor.wasm.i32.load16_u(i, 0, 4);
+
+  // +, ignore
+  if (startChr == 43) i += 2;
+
+  // -, switch to negative
+  if (startChr == 45) {
+    negative = true;
+    i += 2;
+  }
+
+  // 0, potential start of hex
+  if (startChr == 48) {
+    const second: f64 = Porffor.wasm.i32.load16_u(i + 2, 0, 4);
+    // 0x or 0X
+    if (second == 120 || second == 88) {
+      // set radix to 16 and skip leading 2 chars
+      i += 4;
+      radix = 16;
+    }
+  }
+
+  while (i < endPtr) {
+    const chr: f64 = Porffor.wasm.i32.load16_u(i, 0, 4);
+    i += 2;
+
+    if (chr >= 48 && chr < nMax) {
+      if (Number.isNaN(n)) n = 0;
+
+      n *= radix;
+      n += chr - 48;
+    } else if (radix > 10) {
+      if (chr >= 97 && chr < (87 + radix)) {
+        if (Number.isNaN(n)) n = 0;
+
+        n *= radix;
+        n += chr - 87;
+      } else if (chr >= 65 && chr < (55 + radix)) {
+        if (Number.isNaN(n)) n = 0;
+
+        n *= radix;
+        n += chr - 55;
+      } else {
+        if (negative) return -n;
+        return n;
+      }
+    } else {
+      if (negative) return -n;
+      return n;
+    }
+  }
+
+  if (negative) return -n;
+  return n;
+};

package/compiler/builtins/number.ts

@@ -0,0 +1,527 @@
+// // @porf -funsafe-no-unlikely-proto-checks
+
+// radix: number|any for rawType check
+export const __Number_prototype_toString = (_this: number, radix: number|any) => {
+  let out: bytestring = '';
+  let outPtr: i32 = Porffor.wasm`local.get ${out}`;
+
+  if (!Number.isFinite(_this)) {
+    if (Number.isNaN(_this)) out = 'NaN';
+      else if (_this == Infinity) out = 'Infinity';
+      else out = '-Infinity';
+
+    return out;
+  }
+
+  if (Porffor.rawType(radix) != Porffor.TYPES.number) {
+    // todo: string to number
+    radix = 10;
+  }
+
+  radix |= 0;
+  if (radix < 2 || radix > 36) {
+    // todo: throw RangeError: toString() radix argument must be between 2 and 36
+    return out;
+  }
+
+  if (_this == 0) {
+    out = '0';
+    return out;
+  }
+
+  // if negative value
+  if (_this < 0) {
+    _this = -_this; // turn value positive for later use
+    Porffor.wasm.i32.store8(outPtr++, 45, 0, 4); // prepend -
+  }
+
+  let i: f64 = Math.trunc(_this);
+
+  let digits: bytestring = ''; // byte "array"
+
+  let l: i32 = 0;
+  if (radix == 10) {
+    if (i >= 1e21) {
+      // large exponential
+      let trailing: boolean = true;
+      let e: i32 = -1;
+      while (i > 0) {
+        const digit: f64 = i % radix;
+        i = Math.trunc(i / radix);
+
+        e++;
+        if (trailing) {
+          if (digit == 0) { // skip trailing 0s
+            continue;
+          }
+          trailing = false;
+        }
+
+        Porffor.wasm.i32.store8(Porffor.wasm`local.get ${digits}` + l, digit, 0, 4);
+        l++;
+      }
+
+      let digitsPtr: i32 = Porffor.wasm`local.get ${digits}` + l;
+      let endPtr: i32 = outPtr + l;
+      let dotPlace: i32 = outPtr + 1;
+      while (outPtr < endPtr) {
+        if (outPtr == dotPlace) {
+          Porffor.wasm.i32.store8(outPtr++, 46, 0, 4); // .
+          endPtr++;
+        }
+
+        let digit: i32 = Porffor.wasm.i32.load8_u(--digitsPtr, 0, 4);
+
+        if (digit < 10) digit += 48; // 0-9
+          else digit += 87; // a-z
+
+        Porffor.wasm.i32.store8(outPtr++, digit, 0, 4);
+      }
+
+      Porffor.wasm.i32.store8(outPtr++, 101, 0, 4); // e
+      Porffor.wasm.i32.store8(outPtr++, 43, 0, 4); // +
+
+      l = 0;
+      for (; e > 0; l++) {
+        Porffor.wasm.i32.store8(Porffor.wasm`local.get ${digits}` + l, e % radix, 0, 4);
+        e = Math.trunc(e / radix);
+      }
+
+      digitsPtr = Porffor.wasm`local.get ${digits}` + l;
+
+      endPtr = outPtr + l;
+      while (outPtr < endPtr) {
+        let digit: i32 = Porffor.wasm.i32.load8_u(--digitsPtr, 0, 4);
+
+        if (digit < 10) digit += 48; // 0-9
+          else digit += 87; // a-z
+
+        Porffor.wasm.i32.store8(outPtr++, digit, 0, 4);
+      }
+
+      out.length = outPtr - Porffor.wasm`local.get ${out}`;
+
+      return out;
+    }
+
+    if (_this < 1e-6) {
+      // small exponential
+      let decimal: f64 = _this;
+
+      let e: i32 = 1;
+      while (true) {
+        decimal *= radix;
+
+        const intPart: i32 = Math.trunc(decimal);
+        if (intPart > 0) {
+          if (decimal - intPart < 1e-10) break;
+        } else e++;
+      }
+
+      while (decimal > 0) {
+        const digit: f64 = decimal % radix;
+        decimal = Math.trunc(decimal / radix);
+
+        Porffor.wasm.i32.store8(Porffor.wasm`local.get ${digits}` + l, digit, 0, 4);
+        l++;
+      }
+
+      let digitsPtr: i32 = Porffor.wasm`local.get ${digits}` + l;
+      let endPtr: i32 = outPtr + l;
+      let dotPlace: i32 = outPtr + 1;
+      while (outPtr < endPtr) {
+        let digit: i32 = Porffor.wasm.i32.load8_u(--digitsPtr, 0, 4);
+
+        if (outPtr == dotPlace) {
+          Porffor.wasm.i32.store8(outPtr++, 46, 0, 4); // .
+          endPtr++;
+        }
+
+        if (digit < 10) digit += 48; // 0-9
+          else digit += 87; // a-z
+
+        Porffor.wasm.i32.store8(outPtr++, digit, 0, 4);
+      }
+
+      Porffor.wasm.i32.store8(outPtr++, 101, 0, 4); // e
+      Porffor.wasm.i32.store8(outPtr++, 45, 0, 4); // -
+
+      l = 0;
+      for (; e > 0; l++) {
+        Porffor.wasm.i32.store8(Porffor.wasm`local.get ${digits}` + l, e % radix, 0, 4);
+        e = Math.trunc(e / radix);
+      }
+
+      digitsPtr = Porffor.wasm`local.get ${digits}` + l;
+
+      endPtr = outPtr + l;
+      while (outPtr < endPtr) {
+        let digit: i32 = Porffor.wasm.i32.load8_u(--digitsPtr, 0, 4);
+
+        if (digit < 10) digit += 48; // 0-9
+          else digit += 87; // a-z
+
+        Porffor.wasm.i32.store8(outPtr++, digit, 0, 4);
+      }
+
+      out.length = outPtr - Porffor.wasm`local.get ${out}`;
+
+      return out;
+    }
+  }
+
+  if (i == 0) {
+    Porffor.wasm.i32.store8(Porffor.wasm`local.get ${digits}`, 0, 0, 4);
+    l = 1;
+  } else {
+    for (; i > 0; l++) {
+      Porffor.wasm.i32.store8(Porffor.wasm`local.get ${digits}` + l, i % radix, 0, 4);
+      i = Math.trunc(i / radix);
+    }
+  }
+
+  let digitsPtr: i32 = Porffor.wasm`local.get ${digits}` + l;
+  let endPtr: i32 = outPtr + l;
+  while (outPtr < endPtr) {
+    let digit: i32 = Porffor.wasm.i32.load8_u(--digitsPtr, 0, 4);
+
+    if (digit < 10) digit += 48; // 0-9
+      else digit += 87; // a-z
+
+    Porffor.wasm.i32.store8(outPtr++, digit, 0, 4);
+  }
+
+  let decimal: f64 = _this - Math.trunc(_this);
+  if (decimal > 0) {
+    Porffor.wasm.i32.store8(outPtr++, 46, 0, 4); // .
+
+    decimal += 1;
+
+    // todo: doesn't handle non-10 radix properly
+    let decimalDigits: i32 = 16 - l;
+    for (let j: i32 = 0; j < decimalDigits; j++) {
+      decimal *= radix;
+    }
+
+    decimal = Math.round(decimal);
+
+    l = 0;
+    let trailing: boolean = true;
+    while (decimal > 1) {
+      const digit: f64 = decimal % radix;
+      decimal = Math.trunc(decimal / radix);
+
+      if (trailing) {
+        if (digit == 0) { // skip trailing 0s
+          continue;
+        }
+        trailing = false;
+      }
+
+      Porffor.wasm.i32.store8(Porffor.wasm`local.get ${digits}` + l, digit, 0, 4);
+      l++;
+    }
+
+    digitsPtr = Porffor.wasm`local.get ${digits}` + l;
+
+    endPtr = outPtr + l;
+    while (outPtr < endPtr) {
+      let digit: i32 = Porffor.wasm.i32.load8_u(--digitsPtr, 0, 4);
+
+      if (digit < 10) digit += 48; // 0-9
+        else digit += 87; // a-z
+
+      Porffor.wasm.i32.store8(outPtr++, digit, 0, 4);
+    }
+  }
+
+  out.length = outPtr - Porffor.wasm`local.get ${out}`;
+
+  return out;
+};
+
+export const __Number_prototype_toFixed = (_this: number, fractionDigits: number) => {
+  let out: bytestring = '';
+  let outPtr: i32 = Porffor.wasm`local.get ${out}`;
+
+  if (!Number.isFinite(_this)) {
+    if (Number.isNaN(_this)) out = 'NaN';
+      else if (_this == Infinity) out = 'Infinity';
+      else out = '-Infinity';
+
+    return out;
+  }
+
+  fractionDigits |= 0;
+  if (fractionDigits < 0 || fractionDigits > 100) {
+    // todo: throw RangeError: toFixed() digits argument must be between 0 and 100
+    return out;
+  }
+
+  // if negative value
+  if (_this < 0) {
+    _this = -_this; // turn value positive for later use
+    Porffor.wasm.i32.store8(outPtr++, 45, 0, 4); // prepend -
+  }
+
+  let i: f64 = Math.trunc(_this);
+
+  let digits: bytestring = ''; // byte "array"
+
+  let l: i32 = 0;
+
+  if (i == 0) {
+    Porffor.wasm.i32.store8(Porffor.wasm`local.get ${digits}`, 0, 0, 4);
+    l = 1;
+  } else {
+    for (; i > 0; l++) {
+      Porffor.wasm.i32.store8(Porffor.wasm`local.get ${digits}` + l, i % 10, 0, 4);
+      i = Math.trunc(i / 10);
+    }
+  }
+
+  let digitsPtr: i32 = Porffor.wasm`local.get ${digits}` + l;
+  let endPtr: i32 = outPtr + l;
+  while (outPtr < endPtr) {
+    let digit: i32 = Porffor.wasm.i32.load8_u(--digitsPtr, 0, 4);
+
+    if (digit < 10) digit += 48; // 0-9
+      else digit += 87; // a-z
+
+    Porffor.wasm.i32.store8(outPtr++, digit, 0, 4);
+  }
+
+  let decimal: f64 = _this - Math.trunc(_this);
+  if (fractionDigits > 0) {
+    Porffor.wasm.i32.store8(outPtr++, 46, 0, 4); // .
+
+    decimal += 1;
+
+    for (let j: i32 = 0; j < fractionDigits; j++) {
+      decimal *= 10;
+    }
+
+    decimal = Math.round(decimal);
+
+    l = 0;
+    while (decimal > 1) {
+      const digit: f64 = decimal % 10;
+      decimal = Math.trunc(decimal / 10);
+
+      Porffor.wasm.i32.store8(Porffor.wasm`local.get ${digits}` + l, digit, 0, 4);
+      l++;
+    }
+
+    digitsPtr = Porffor.wasm`local.get ${digits}` + l;
+
+    endPtr = outPtr + l;
+    while (outPtr < endPtr) {
+      let digit: i32 = Porffor.wasm.i32.load8_u(--digitsPtr, 0, 4);
+
+      if (digit < 10) digit += 48; // 0-9
+        else digit += 87; // a-z
+
+      Porffor.wasm.i32.store8(outPtr++, digit, 0, 4);
+    }
+  }
+
+  out.length = outPtr - Porffor.wasm`local.get ${out}`;
+
+  return out;
+};
+
+// fractionDigits: number|any for rawType check
+export const __Number_prototype_toExponential = (_this: number, fractionDigits: number|any) => {
+  let out: bytestring = '';
+  let outPtr: i32 = Porffor.wasm`local.get ${out}`;
+
+  if (!Number.isFinite(_this)) {
+    if (Number.isNaN(_this)) out = 'NaN';
+      else if (_this == Infinity) out = 'Infinity';
+      else out = '-Infinity';
+
+    return out;
+  }
+
+  if (Porffor.rawType(fractionDigits) != Porffor.TYPES.number) {
+    // todo: string to number
+    fractionDigits = undefined;
+  } else {
+    fractionDigits |= 0;
+    if (fractionDigits < 0 || fractionDigits > 100) {
+      // todo: throw RangeError: toExponential() digits argument must be between 0 and 100
+      return out;
+    }
+  }
+
+  // if negative value
+  if (_this < 0) {
+    _this = -_this; // turn value positive for later use
+    Porffor.wasm.i32.store8(outPtr++, 45, 0, 4); // prepend -
+  }
+
+  let i: f64 = _this;
+
+  let digits: bytestring = ''; // byte "array"
+
+  let l: i32 = 0;
+  let e: i32 = 0;
+  let digitsPtr: i32;
+  let endPtr: i32;
+  if (_this == 0) {
+    Porffor.wasm.i32.store8(outPtr++, 48, 0, 4); // 0
+
+    if (fractionDigits > 0) {
+      Porffor.wasm.i32.store8(outPtr++, 46, 0, 4); // .
+      for (let j: i32 = 0; j < fractionDigits; j++) {
+        Porffor.wasm.i32.store8(outPtr++, 48, 0, 4); // 0
+      }
+    }
+
+    Porffor.wasm.i32.store8(outPtr++, 101, 0, 4); // e
+    Porffor.wasm.i32.store8(outPtr++, 43, 0, 4); // +
+  } else if (_this < 1) {
+    // small exponential
+    if (Porffor.rawType(fractionDigits) != Porffor.TYPES.number) {
+      e = 1;
+      while (true) {
+        i *= 10;
+
+        const intPart: i32 = Math.trunc(i);
+        if (intPart > 0) {
+          if (i - intPart < 1e-10) break;
+        } else e++;
+      }
+    } else {
+      e = 1;
+      let j: i32 = 0;
+      while (j <= fractionDigits) {
+        i *= 10;
+
+        const intPart: i32 = Math.trunc(i);
+        if (intPart == 0) e++;
+          else j++;
+      }
+    }
+
+    while (i > 0) {
+      const digit: f64 = i % 10;
+      i = Math.trunc(i / 10);
+
+      Porffor.wasm.i32.store8(Porffor.wasm`local.get ${digits}` + l, digit, 0, 4);
+      l++;
+    }
+
+    digitsPtr = Porffor.wasm`local.get ${digits}` + l;
+    endPtr = outPtr + l;
+    let dotPlace: i32 = outPtr + 1;
+    while (outPtr < endPtr) {
+      let digit: i32 = Porffor.wasm.i32.load8_u(--digitsPtr, 0, 4);
+
+      if (outPtr == dotPlace) {
+        Porffor.wasm.i32.store8(outPtr++, 46, 0, 4); // .
+        endPtr++;
+      }
+
+      if (digit < 10) digit += 48; // 0-9
+        else digit += 87; // a-z
+
+      Porffor.wasm.i32.store8(outPtr++, digit, 0, 4);
+    }
+
+    Porffor.wasm.i32.store8(outPtr++, 101, 0, 4); // e
+    Porffor.wasm.i32.store8(outPtr++, 45, 0, 4); // -
+  } else {
+    // large exponential
+    e = -1;
+    while (i >= 1) {
+      i /= 10;
+      e++;
+    }
+
+    if (Porffor.rawType(fractionDigits) != Porffor.TYPES.number) {
+      while (true) {
+        i *= 10;
+
+        const intPart: i32 = Math.trunc(i);
+        if (intPart > 0) {
+          if (i - intPart < 1e-10) break;
+        } else e++;
+      }
+    } else {
+      // i = _this;
+      // if (e >= fractionDigits) {
+      //   for (let j: i32 = 0; j < e - fractionDigits; j++) {
+      //     i /= 10;
+      //   }
+      // } else {
+      //   for (let j: i32 = 0; j < fractionDigits - e; j++) {
+      //     i *= 10;
+      //   }
+      // }
+
+      // eg: 1.2345 -> 123.45, if fractionDigits = 2
+      for (let j: i32 = 0; j <= fractionDigits; j++) {
+        i *= 10;
+      }
+    }
+
+    // eg: 123.45 -> 123
+    i = Math.round(i);
+
+    while (i > 0) {
+      const digit: f64 = i % 10;
+      i = Math.trunc(i / 10);
+
+      Porffor.wasm.i32.store8(Porffor.wasm`local.get ${digits}` + l, digit, 0, 4);
+      l++;
+    }
+
+    digitsPtr = Porffor.wasm`local.get ${digits}` + l;
+    endPtr = outPtr + l;
+    let dotPlace: i32 = outPtr + 1;
+    while (outPtr < endPtr) {
+      if (outPtr == dotPlace) {
+        Porffor.wasm.i32.store8(outPtr++, 46, 0, 4); // .
+        endPtr++;
+      }
+
+      let digit: i32 = Porffor.wasm.i32.load8_u(--digitsPtr, 0, 4);
+
+      if (digit < 10) digit += 48; // 0-9
+        else digit += 87; // a-z
+
+      Porffor.wasm.i32.store8(outPtr++, digit, 0, 4);
+    }
+
+    Porffor.wasm.i32.store8(outPtr++, 101, 0, 4); // e
+    Porffor.wasm.i32.store8(outPtr++, 43, 0, 4); // +
+  }
+
+  if (e == 0) {
+    Porffor.wasm.i32.store8(Porffor.wasm`local.get ${digits}`, 0, 0, 4);
+    l = 1;
+  } else {
+    l = 0;
+    for (; e > 0; l++) {
+      Porffor.wasm.i32.store8(Porffor.wasm`local.get ${digits}` + l, e % 10, 0, 4);
+      e = Math.trunc(e / 10);
+    }
+  }
+
+  digitsPtr = Porffor.wasm`local.get ${digits}` + l;
+
+  endPtr = outPtr + l;
+  while (outPtr < endPtr) {
+    let digit: i32 = Porffor.wasm.i32.load8_u(--digitsPtr, 0, 4);
+
+    if (digit < 10) digit += 48; // 0-9
+      else digit += 87; // a-z
+
+    Porffor.wasm.i32.store8(outPtr++, digit, 0, 4);
+  }
+
+  out.length = outPtr - Porffor.wasm`local.get ${out}`;
+
+  return out;
+};

package/compiler/builtins/porffor.d.ts

@@ -0,0 +1,42 @@
+export type i32 = number;
+export type i64 = number;
+export type f64 = number;
+export type bytestring = string;
+
+type PorfforGlobal = {
+  wasm: {
+    (...args: any[]): any;
+    i32: {
+      or(a: i32, b: i32): i32;
+
+      load(pointer: i32, align: i32, offset: i32): i32;
+      store(pointer: i32, value: i32, align: i32, offset: i32): i32;
+      load8_u(pointer: i32, align: i32, offset: i32): i32;
+      store8(pointer: i32, value: i32, align: i32, offset: i32): i32;
+      load16_u(pointer: i32, align: i32, offset: i32): i32;
+      store16(pointer: i32, value: i32, align: i32, offset: i32): i32;
+    }
+  }
+
+  // randomInt(): i32;
+  randomByte(): i32;
+
+  type(x: any): bytestring;
+  rawType(x: any): i32;
+  TYPES: Record<string, i32>;
+
+  fastOr(...args: any): boolean;
+  fastAnd(...args: any): boolean;
+
+  s(...args: any): string;
+  bs(...args: any): bytestring;
+};
+
+declare global {
+  const Porffor: PorfforGlobal;
+
+  type i32 = number;
+  type i64 = number;
+  type f64 = number;
+  type bytestring = string;
+}