porffor 0.2.0-181627c → 0.2.0-219912f

package/compiler/builtins/base64.ts

@@ -1,73 +1,116 @@
-// @porf -funsafe-no-unlikely-proto-checks
+// @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
 
-// const appendKeyChar = (target: bytestring, ind: i32): bytestring => {
-//   const keyStr: bytestring = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
-//   return target + keyStr.charAt(ind);
-// };
+// local k i64
+// i64.const 0
+// local.set k
 
-// const appendKeyChar = (target: bytestring, ind: i32): void => {
-//   const keyStr: bytestring = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+// loop 64
+// local.get ${j}
 
-//   Porffor.bytestring.appendCharAt(target, keyStr, ind);
+// local.get ${keyStrPtr}
 
-//   Porffor.wasm`local.get ${ind}
-// i32.to_u
-// i32.const 2
-// i32.mul
-// local.get ${keyStr}
-// i32.to_u
+// 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
 
-// local targetI32 i32
-// local.get ${target}
-// i32.to_u
-// local.tee targetI32
-// local.get targetI32
-// i32.load 1 0
-// i32.const 2
-// i32.mul
+// ;; store in output at j
+// i32.store8 0 4
+
+// local.get ${j}
+// i32.const 1
 // i32.add
+// local.set ${j}
 
-// i32.store8 0 4`;
-// };
+// 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.wasm`local.get ${keyStr}`;
 
-  // todo: throw invalid character for unicode
-
+  let len: i32 = input.length;
   let output: bytestring = '';
-  let i: i32 = 0;
+  output.length = 4 * (len / 3 + !!(len % 3));
 
-  while (i < input.length) {
-    const chr1: i32 = input.charCodeAt(i++);
-    const chr2: i32 = input.charCodeAt(i++);
-    const chr3: i32 = input.charCodeAt(i++);
+  let i: i32 = Porffor.wasm`local.get ${input}`,
+      j: i32 = Porffor.wasm`local.get ${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 >> 4);
-    let enc3: i32 = ((chr2 & 15) << 2) | (chr3 >> 6);
+    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 (Number.isNaN(chr2)) {
+    if (chr2 == -1) {
       enc3 = 64;
       enc4 = 64;
-    } else if (Number.isNaN(chr3)) {
+    } else if (chr3 == -1) {
       enc4 = 64;
     }
 
-    Porffor.bytestring.appendCharAt(output, keyStr, enc1);
-    Porffor.bytestring.appendCharAt(output, keyStr, enc2);
-    Porffor.bytestring.appendCharAt(output, keyStr, enc3);
-    Porffor.bytestring.appendCharAt(output, keyStr, enc4);
-
-    // output += keyStr.charAt(enc1);
-    // output += keyStr.charAt(enc2);
-    // output += keyStr.charAt(enc3);
-    // output += keyStr.charAt(enc4);
+    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;

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