porffor 0.2.0-2265539 → 0.2.0-22b3092

package/compiler/builtins/base64.ts

@@ -1,61 +1,71 @@
 // @porf -funsafe-no-unlikely-proto-checks -valtype=i32
 
-import type { i32, i64, bytestring } from './porffor.d.ts';
-
-//   while (len >= 8) {
-//     // Porffor.wasm`local tmp i64`;
-//     // const tmp: i64 = Porffor.wasm.i64.load(i, 0, 4);
-
-// Porffor.wasm`
+// while (len >= 8) {
+//   Porffor.wasm`
 // local tmp i64
-// local k i32
-
 // local.get ${i}
 // i64.load 0 4
 // local.set tmp
 
+// local k i64
+// i64.const 0
+// local.set k
+
 // loop 64
-//   local.get ${j}
-//   local.get ${j}
-//   i32.const 1
-//   i32.add
-//   local.set ${j}
+// local.get ${j}
+
+// local.get ${keyStrPtr}
 
-//   local.get ${keyStrPtr}
-//   local.get tmp
+// local.get tmp
 
-//   i32.const 58
+// ;; k * 6
+// i64.const 58
 
-//   local.get k
-//   i32.const 6
-//   i32.mul
+// local.get k
+// i64.const 6
+// i64.mul
 
-//   i32.sub
+// i64.sub
 
-//   i64.extend_i32_u
+// ;; tmp >> (58 - (k * 6))
+// i64.shr_u
 
-//   i64.shr_u
+// ;; (tmp >> (58 - (k * 6))) & 0x3f
+// i64.const 63
+// i64.and
 
-//   i64.const 63
-//   i64.and
+// i32.wrap_i64
 
-//   i32.wrap_i64
-//   i32.add
+// ;; keyStrPtr + ...
+// i32.add
 
-//   i32.load8_u 0 4
-//   i32.store8 0 4
+// ;; load character from keyStr
+// i32.load8_u 0 4
 
-//   local.get k
-//   i32.const 1
-//   i32.add
-//   local.tee k
+// ;; store in output at j
+// i32.store8 0 4
 
-//   i32.const 8
-//   i32.lt_s
-//   br_if 1
+// local.get ${j}
+// i32.const 1
+// i32.add
+// local.set ${j}
+
+// local.get k
+// i64.const 1
+// i64.add
+// local.tee k
+
+// i64.const 8
+// i64.lt_s
+// br_if 0
 // end
 
 // `;
+
+//   // len -= 6;
+//   i += 6;
+// }
+
 //     // while (k < 8) {
 //     //   Porffor.wasm.i32.store8(j++, Porffor.wasm.i32.load8_u(keyStrPtr + Porffor.wasm.i32.wrap_i64(Porffor.wasm.i64.and(
 //     //     Porffor.wasm.i64.shr_u(tmp, Porffor.wasm.i64.extend_i32_u(58 - k * 6)),
@@ -70,14 +80,14 @@ import type { i32, i64, bytestring } from './porffor.d.ts';
 
 export const btoa = (input: bytestring): bytestring => {
   const keyStr: bytestring = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
-  const keyStrPtr: i32 = Porffor.i32.ptrUnsafe(keyStr);
+  const keyStrPtr: i32 = Porffor.wasm`local.get ${keyStr}`;
 
   let len: i32 = input.length;
   let output: bytestring = '';
   output.length = 4 * (len / 3 + !!(len % 3));
 
-  let i: i32 = Porffor.i32.ptrUnsafe(input),
-      j: i32 = Porffor.i32.ptrUnsafe(output);
+  let i: i32 = Porffor.wasm`local.get ${input}`,
+      j: i32 = Porffor.wasm`local.get ${output}`;
 
   const endPtr = i + len;
   while (i < endPtr) {

package/compiler/builtins/crypto.ts

@@ -0,0 +1,120 @@
+// @porf -funsafe-no-unlikely-proto-checks -valtype=i32
+
+export const __crypto_randomUUID = (): bytestring => {
+  let bytes: bytestring = '................';
+
+  const bytesPtr: i32 = Porffor.wasm`local.get ${bytes}`;
+
+  let a: i32 = bytesPtr;
+  let aEndPtr: i32 = a + 16;
+  while (a < aEndPtr) {
+    Porffor.wasm.i32.store8(a++, Porffor.randomByte(), 0, 4);
+  }
+
+  // bytes[6] = (bytes[6] & 0b00001111) | 0b01000000
+  Porffor.wasm.i32.store8(
+    bytesPtr,
+    (Porffor.wasm.i32.load8_u(bytesPtr, 0, 10) & 0b00001111) | 0b01000000,
+    0,
+    10 // 4 + 6
+  );
+
+  // bytes[8] = (bytes[8] & 0b00111111) | 0b10000000
+  Porffor.wasm.i32.store8(
+    bytesPtr,
+    (Porffor.wasm.i32.load8_u(bytesPtr, 0, 12) & 0b00111111) | 0b10000000,
+    0,
+    12 // 4 + 8
+  );
+
+  let output: bytestring = '------------------------------------';
+
+  let i: i32 = Porffor.wasm`local.get ${output}`;
+  let j: i32 = bytesPtr;
+
+  // bytes[0..4]-bytes[4..6]-bytes[6..8]-bytes[8..10]-bytes[10..15]
+  // 00112233-4455-6677-8899-aabbccddeeff
+
+  // bytes[0..4]-
+  let endPtr: i32 = i + 8;
+  while (i < endPtr) {
+    const byte: i32 = Porffor.wasm.i32.load8_u(j++, 0, 4);
+
+    let lower: i32 = (byte & 0x0f) + 48;
+    if (lower > 57) lower += 39;
+
+    let upper: i32 = (byte >> 4) + 48;
+    if (upper > 57) upper += 39;
+
+    Porffor.wasm.i32.store8(i++, upper, 0, 4);
+    Porffor.wasm.i32.store8(i++, lower, 0, 4);
+  }
+  i++;
+
+  // bytes[4..6]-
+  endPtr = i + 4;
+  while (i < endPtr) {
+    const byte: i32 = Porffor.wasm.i32.load8_u(j++, 0, 4);
+
+    let lower: i32 = (byte & 0x0f) + 48;
+    if (lower > 57) lower += 39;
+
+    let upper: i32 = (byte >> 4) + 48;
+    if (upper > 57) upper += 39;
+
+    Porffor.wasm.i32.store8(i++, upper, 0, 4);
+    Porffor.wasm.i32.store8(i++, lower, 0, 4);
+  }
+  i++;
+
+  // bytes[6..8]-
+  endPtr = i + 4;
+  while (i < endPtr) {
+    const byte: i32 = Porffor.wasm.i32.load8_u(j++, 0, 4);
+
+    let lower: i32 = (byte & 0x0f) + 48;
+    if (lower > 57) lower += 39;
+
+    let upper: i32 = (byte >> 4) + 48;
+    if (upper > 57) upper += 39;
+
+    Porffor.wasm.i32.store8(i++, upper, 0, 4);
+    Porffor.wasm.i32.store8(i++, lower, 0, 4);
+  }
+  i++;
+
+  // bytes[8..10]-
+  endPtr = i + 4;
+  while (i < endPtr) {
+    const byte: i32 = Porffor.wasm.i32.load8_u(j++, 0, 4);
+
+    let lower: i32 = (byte & 0x0f) + 48;
+    if (lower > 57) lower += 39;
+
+    let upper: i32 = (byte >> 4) + 48;
+    if (upper > 57) upper += 39;
+
+    Porffor.wasm.i32.store8(i++, upper, 0, 4);
+    Porffor.wasm.i32.store8(i++, lower, 0, 4);
+  }
+  i++;
+
+  // bytes[10..15]
+  endPtr = i + 12;
+  while (i < endPtr) {
+    const byte: i32 = Porffor.wasm.i32.load8_u(j++, 0, 4);
+
+    let lower: i32 = (byte & 0x0f) + 48;
+    if (lower > 57) lower += 39;
+
+    let upper: i32 = (byte >> 4) + 48;
+    if (upper > 57) upper += 39;
+
+    Porffor.wasm.i32.store8(i++, upper, 0, 4);
+    Porffor.wasm.i32.store8(i++, lower, 0, 4);
+  }
+  i++;
+
+
+  return output;
+};

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