porffor 0.2.0-f2bbe1f → 0.2.0-f647e42

package/compiler/builtins/escape.ts

@@ -0,0 +1,141 @@
+// @porf --funsafe-no-unlikely-proto-checks --valtype=i32
+
+import type {} from './porffor';
+
+export const escape = (input: string|bytestring): bytestring => {
+  // we have no byte array yet so use bytestring with 0x00 and 0x01 via escape characters
+  // 0 = should escape, 1 = should not escape
+  // aka if in set 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_@*+-./'
+  const lut: bytestring = '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x01\x00\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x00\x00\x00\x00\x00\x00\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x00\x00\x00\x00\x01\x00\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x00\x00\x00\x00\x00';
+
+  const len: i32 = input.length;
+  let outLength: i32 = len; // at minimum, output length = input length
+
+  let i: i32 = Porffor.wasm`local.get ${input}`;
+
+  if (Porffor.wasm`local.get ${input+1}` == Porffor.TYPES._bytestring) {
+    const endPtr: i32 = i + len;
+    while (i < endPtr) {
+      const chr: i32 = Porffor.wasm.i32.load8_u(i++, 0, 4);
+
+      if (chr < 128) {
+        if (Porffor.wasm.i32.load8_u(Porffor.wasm`local.get ${lut}` + chr, 0, 4)) {
+          continue;
+        }
+      }
+
+      outLength += 2;
+    }
+
+    if (outLength == len) return input;
+
+    let output: bytestring = '';
+    output.length = outLength;
+
+    i = Porffor.wasm`local.get ${input}`;
+    let j: i32 = Porffor.wasm`local.get ${output}`;
+    while (i < endPtr) {
+      const chr: i32 = Porffor.wasm.i32.load8_u(i++, 0, 4);
+
+      if (chr < 128) {
+        if (Porffor.wasm.i32.load8_u(Porffor.wasm`local.get ${lut}` + chr, 0, 4)) {
+          // append just character
+          Porffor.wasm.i32.store8(j++, chr, 0, 4);
+          continue;
+        }
+      }
+
+      // %
+      Porffor.wasm.i32.store8(j++, 37, 0, 4);
+
+      // 8 bit integer to hex (0x12)
+      let lower: i32 = (chr & 0x0f) + 48;
+      if (lower > 57) lower += 7;
+
+      let upper: i32 = (chr >> 4) + 48;
+      if (upper > 57) upper += 7;
+
+      Porffor.wasm.i32.store8(j++, upper, 0, 4);
+      Porffor.wasm.i32.store8(j++, lower, 0, 4);
+    }
+
+    return output;
+  }
+
+  const endPtr: i32 = i + len * 2;
+  while (i < endPtr) {
+    const chr: i32 = Porffor.wasm.i32.load16_u(i, 0, 4);
+    i += 2;
+
+    if (chr < 128) {
+      if (Porffor.wasm.i32.load8_u(Porffor.wasm`local.get ${lut}` + chr, 0, 4)) {
+        continue;
+      }
+    }
+
+    if (chr < 256) {
+      outLength += 2;
+    } else {
+      outLength += 5;
+    }
+  }
+
+  if (outLength == len) return input;
+
+  let output: bytestring = '';
+  output.length = outLength;
+
+  i = Porffor.wasm`local.get ${input}`;
+  let j: i32 = Porffor.wasm`local.get ${output}`;
+
+  while (i < endPtr) {
+    const chr: i32 = Porffor.wasm.i32.load16_u(i, 0, 4);
+    i += 2;
+
+    if (chr < 128) {
+      if (Porffor.wasm.i32.load8_u(Porffor.wasm`local.get ${lut}` + chr, 0, 4)) {
+        // append just character
+        Porffor.wasm.i32.store8(j++, chr, 0, 4);
+        continue;
+      }
+    }
+
+    if (chr < 256) {
+      // %
+      Porffor.wasm.i32.store8(j++, 37, 0, 4);
+
+      // 8 bit integer to hex (0x12)
+      let lower: i32 = (chr & 0x0f) + 48;
+      if (lower > 57) lower += 7;
+
+      let upper: i32 = (chr >> 4) + 48;
+      if (upper > 57) upper += 7;
+
+      Porffor.wasm.i32.store8(j++, upper, 0, 4);
+      Porffor.wasm.i32.store8(j++, lower, 0, 4);
+    } else {
+      // %u
+      Porffor.wasm.i32.store16(j, 29989, 0, 4);
+      j += 2;
+
+      // 16 bit integer to hex (0x1234)
+      let nibble: i32 = ((chr >> 12) & 0x0f) + 48;
+      if (nibble > 57) nibble += 7;
+      Porffor.wasm.i32.store8(j++, nibble, 0, 4);
+
+      nibble = ((chr >> 8) & 0x0f) + 48;
+      if (nibble > 57) nibble += 7;
+      Porffor.wasm.i32.store8(j++, nibble, 0, 4);
+
+      nibble = ((chr >> 4) & 0x0f) + 48;
+      if (nibble > 57) nibble += 7;
+      Porffor.wasm.i32.store8(j++, nibble, 0, 4);
+
+      nibble = (chr & 0x0f) + 48;
+      if (nibble > 57) nibble += 7;
+      Porffor.wasm.i32.store8(j++, nibble, 0, 4);
+    }
+  }
+
+  return output;
+};

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;
+};