porffor 0.2.0-536e463 → 0.2.0-5ac7ea0

package/compiler/builtins/base64.ts

@@ -0,0 +1,153 @@
+// @porf -funsafe-no-unlikely-proto-checks -valtype=i32
+
+import type { i32, bytestring } from './porffor.d.ts';
+
+// while (len >= 8) {
+//   Porffor.wasm`
+// local tmp i64
+// 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 ${keyStrPtr}
+
+// local.get tmp
+
+// ;; k * 6
+// i64.const 58
+
+// local.get k
+// i64.const 6
+// i64.mul
+
+// i64.sub
+
+// ;; tmp >> (58 - (k * 6))
+// i64.shr_u
+
+// ;; (tmp >> (58 - (k * 6))) & 0x3f
+// i64.const 63
+// i64.and
+
+// i32.wrap_i64
+
+// ;; keyStrPtr + ...
+// i32.add
+
+// ;; load character from keyStr
+// i32.load8_u 0 4
+
+// ;; store in output at j
+// i32.store8 0 4
+
+// 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)),
+//     //     Porffor.wasm.i64.const(0x3f)
+//     //   )), 0, 4), 0, 4);
+//     //   k += 1;
+//     // }
+
+//     i += 6;
+//     len -= 6;
+//   }
+
+export const btoa = (input: bytestring): bytestring => {
+  const keyStr: bytestring = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+  const keyStrPtr: i32 = Porffor.i32.ptrUnsafe(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);
+
+  const endPtr = i + len;
+  while (i < endPtr) {
+    const chr1: i32 = Porffor.wasm.i32.load8_u(i++, 0, 4);
+    const chr2: i32 = i < endPtr ? Porffor.wasm.i32.load8_u(i++, 0, 4) : -1;
+    const chr3: i32 = i < endPtr ? Porffor.wasm.i32.load8_u(i++, 0, 4) : -1;
+
+    const enc1: i32 = chr1 >> 2;
+    const enc2: i32 = ((chr1 & 3) << 4) | (chr2 == -1 ? 0 : (chr2 >> 4));
+    let enc3: i32 = ((chr2 & 15) << 2) | (chr3 == -1 ? 0 : (chr3 >> 6));
+    let enc4: i32 = chr3 & 63;
+
+    if (chr2 == -1) {
+      enc3 = 64;
+      enc4 = 64;
+    } else if (chr3 == -1) {
+      enc4 = 64;
+    }
+
+    Porffor.wasm.i32.store8(j++, Porffor.wasm.i32.load8_u(keyStrPtr + enc1, 0, 4), 0, 4);
+    Porffor.wasm.i32.store8(j++, Porffor.wasm.i32.load8_u(keyStrPtr + enc2, 0, 4), 0, 4);
+    Porffor.wasm.i32.store8(j++, Porffor.wasm.i32.load8_u(keyStrPtr + enc3, 0, 4), 0, 4);
+    Porffor.wasm.i32.store8(j++, Porffor.wasm.i32.load8_u(keyStrPtr + enc4, 0, 4), 0, 4);
+  }
+
+  return output;
+};
+
+/* var atob = function (input) {
+  const keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+
+  let output = "";
+  let chr1, chr2, chr3;
+  let enc1, enc2, enc3, enc4;
+  let i = 0;
+
+  while (i < input.length) {
+    enc1 = keyStr.indexOf(input.charAt(i++));
+    enc2 = keyStr.indexOf(input.charAt(i++));
+    enc3 = keyStr.indexOf(input.charAt(i++));
+    enc4 = keyStr.indexOf(input.charAt(i++));
+
+    chr1 = (enc1 << 2) | (enc2 >> 4);
+    chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
+    chr3 = ((enc3 & 3) << 6) | enc4;
+
+    // output += String.fromCharCode(chr1);
+    Porffor.bytestring.appendCharCode(output, chr1);
+
+    if (enc3 != 64) {
+      // output += String.fromCharCode(chr2);
+      Porffor.bytestring.appendCharCode(output, chr2);
+    }
+    if (enc4 != 64) {
+      // output += String.fromCharCode(chr3);
+      Porffor.bytestring.appendCharCode(output, chr3);
+    }
+  }
+
+  return output;
+}; */

package/compiler/builtins/crypto.ts

@@ -0,0 +1,132 @@
+// @porf -funsafe-no-unlikely-proto-checks -valtype=i32
+
+import type { i32, bytestring } from './porffor.d.ts';
+
+export const __crypto_randomUUID = (): bytestring => {
+  let bytes: bytestring = '................';
+
+  let bytesPtr: i32 = Porffor.i32.ptrUnsafe(bytes);
+
+  let a: i32 = bytesPtr;
+  let aEndPtr: i32 = a + 16;
+  while (a < aEndPtr) {
+    Porffor.wasm.i32.store8(a++, Porffor.i32.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.i32.ptrUnsafe(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 = Porffor.wasm.i32.load8_u(j++, 0, 4);
+
+    let lower = byte & 0xf;
+    if (lower < 10) lower = 48 + lower;
+      else lower = 97 + (lower - 10);
+
+    let upper = byte >> 4;
+    if (upper < 10) upper = 48 + upper;
+      else upper = 97 + (upper - 10);
+
+    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 = Porffor.wasm.i32.load8_u(j++, 0, 4);
+
+    let lower = byte & 0xf;
+    if (lower < 10) lower = 48 + lower;
+      else lower = 97 + (lower - 10);
+
+    let upper = byte >> 4;
+    if (upper < 10) upper = 48 + upper;
+      else upper = 97 + (upper - 10);
+
+    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 = Porffor.wasm.i32.load8_u(j++, 0, 4);
+
+    let lower = byte & 0xf;
+    if (lower < 10) lower = 48 + lower;
+      else lower = 97 + (lower - 10);
+
+    let upper = byte >> 4;
+    if (upper < 10) upper = 48 + upper;
+      else upper = 97 + (upper - 10);
+
+    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 = Porffor.wasm.i32.load8_u(j++, 0, 4);
+
+    let lower = byte & 0xf;
+    if (lower < 10) lower = 48 + lower;
+      else lower = 97 + (lower - 10);
+
+    let upper = byte >> 4;
+    if (upper < 10) upper = 48 + upper;
+      else upper = 97 + (upper - 10);
+
+    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 = Porffor.wasm.i32.load8_u(j++, 0, 4);
+
+    let lower = byte & 0xf;
+    if (lower < 10) lower = 48 + lower;
+      else lower = 97 + (lower - 10);
+
+    let upper = byte >> 4;
+    if (upper < 10) upper = 48 + upper;
+      else upper = 97 + (upper - 10);
+
+    Porffor.wasm.i32.store8(i++, upper, 0, 4);
+    Porffor.wasm.i32.store8(i++, lower, 0, 4);
+  }
+  i++;
+
+
+  return output;
+};

package/compiler/builtins/porffor.d.ts

@@ -0,0 +1,26 @@
+export type i32 = number;
+export type i64 = number;
+export type bytestring = string;
+
+type PorfforGlobal = {
+  wasm: {
+    (...args: any[]): void;
+    i32: {
+      load8_u: (pointer: i32, align: i32, offset: i32) => i32;
+      store8: (pointer: i32, value: i32, align: i32, offset: i32) => i32;
+    }
+  }
+  ptr: (obj: any) => i32;
+
+  i32: {
+    ptr: (obj: any) => i32;
+    ptrUnsafe: (obj: any) => i32;
+
+    random: () => i32;
+    randomByte: () => i32;
+  }
+};
+
+declare global {
+  const Porffor: PorfforGlobal;
+}