porffor 0.2.0-4035760 → 0.2.0-4b72c49

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/porffor.d.ts

@@ -0,0 +1,23 @@
+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;
+  }
+};
+
+declare global {
+  const Porffor: PorfforGlobal;
+}

package/compiler/builtins.js

@@ -1,5 +1,7 @@
 import { Blocktype, Opcodes, Valtype, ValtypeSize } from "./wasmSpec.js";
 import { number, i32x4 } from "./embedding.js";
+import Prefs from './prefs.js';
+import * as GeneratedBuiltins from './generated_builtins.js';
 
 export const importedFuncs = [
   {
@@ -170,25 +172,6 @@ export const BuiltinFuncs = function() {
     ]
   };
 
-  // todo: return false for NaN
-  this.Boolean = {
-    params: [ valtypeBinary ],
-    locals: [],
-    returns: [ valtypeBinary ],
-    returnType: 'boolean',
-    wasm: [
-      [ Opcodes.local_get, 0 ],
-      ...(valtype === 'f64' ? [
-        ...number(0),
-        [ Opcodes.f64_ne ]
-      ] : [
-        ...Opcodes.eqz,
-        [ Opcodes.i32_eqz ]
-      ]),
-      Opcodes.i32_from
-    ]
-  };
-
   // just return given (default 0) for (new) Object() as we somewhat supports object just not constructor
   this.Object = {
     params: [ valtypeBinary ],
@@ -258,6 +241,40 @@ export const BuiltinFuncs = function() {
 
           [ Opcodes.end ]
         ],
+        [TYPES._bytestring]: [
+          // simply print a (byte)string :))
+          // cache input pointer as i32
+          [ Opcodes.local_get, 0 ],
+          Opcodes.i32_to_u,
+          [ Opcodes.local_tee, 2 ],
+
+          // make end pointer
+          [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+          [ Opcodes.local_get, 2 ],
+          [ Opcodes.i32_add ],
+          [ Opcodes.local_set, 3 ],
+
+          [ Opcodes.loop, Blocktype.void ],
+
+          // print current char
+          [ Opcodes.local_get, 2 ],
+          [ Opcodes.i32_load8_u, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
+          Opcodes.i32_from_u,
+          [ Opcodes.call, importedFuncs.printChar ],
+
+          // increment pointer
+          [ Opcodes.local_get, 2 ],
+          [ Opcodes.i32_const, 1 ],
+          [ Opcodes.i32_add ],
+          [ Opcodes.local_tee, 2 ],
+
+          // if pointer != end pointer, loop
+          [ Opcodes.local_get, 3 ],
+          [ Opcodes.i32_ne ],
+          [ Opcodes.br_if, 0 ],
+
+          [ Opcodes.end ]
+        ],
         [TYPES._array]: [
           ...printStaticStr('[ '),
 
@@ -699,206 +716,76 @@ export const BuiltinFuncs = function() {
   };
 
 
-  this.__SIMD_i32x4_load = {
-    params: [ Valtype.i32 ],
-    locals: [],
-    returns: [ Valtype.v128 ],
-    wasm: [
-      [ Opcodes.local_get, 0 ],
-      [ ...Opcodes.v128_load, 0, 0 ]
-    ]
-  };
-
-  this.__SIMD_i32x4_splat = {
-    params: [ Valtype.i32 ],
-    locals: [],
-    returns: [ Valtype.v128 ],
-    wasm: [
-      [ Opcodes.local_get, 0 ],
-      [ ...Opcodes.i32x4_splat ],
-    ]
-  };
-
-  this.__SIMD_i16x8_create = {
-    params: [ Valtype.i32, Valtype.i32, Valtype.i32, Valtype.i32, Valtype.i32, Valtype.i32, Valtype.i32, Valtype.i32 ],
-    locals: [],
-    returns: [ Valtype.v128 ],
-    wasm: [
-      ...i32x4(0, 0, 0, 0),
-      [ Opcodes.local_get, 0 ],
-      [ ...Opcodes.i16x8_replace_lane, 0 ],
-      [ Opcodes.local_get, 1 ],
-      [ ...Opcodes.i16x8_replace_lane, 1 ],
-      [ Opcodes.local_get, 2 ],
-      [ ...Opcodes.i16x8_replace_lane, 2 ],
-      [ Opcodes.local_get, 3 ],
-      [ ...Opcodes.i16x8_replace_lane, 3 ],
-      [ Opcodes.local_get, 4 ],
-      [ ...Opcodes.i16x8_replace_lane, 4 ],
-      [ Opcodes.local_get, 5 ],
-      [ ...Opcodes.i16x8_replace_lane, 5 ],
-      [ Opcodes.local_get, 6 ],
-      [ ...Opcodes.i16x8_replace_lane, 6 ],
-      [ Opcodes.local_get, 7 ],
-      [ ...Opcodes.i16x8_replace_lane, 7 ],
-    ]
-  };
-
-  this.__SIMD_i32x4_dot_i16x8 = {
-    params: [ Valtype.v128, Valtype.v128 ],
-    locals: [],
-    returns: [ Valtype.v128 ],
-    wasm: [
-      [ Opcodes.local_get, 0 ],
-      [ Opcodes.local_get, 1 ],
-      [ ...Opcodes.i32x4_dot_i16x8_s ]
-    ]
+  this.__Porffor_type = {
+    params: [ valtypeBinary, Valtype.i32 ],
+    typedParams: true,
+    locals: [ Valtype.i32, Valtype.i32 ],
+    returns: [ valtypeBinary ],
+    returnType: Prefs.bytestring ? '_bytestring' : 'string',
+    wasm: (scope, { TYPE_NAMES, typeSwitch, makeString }) => {
+      const bc = {};
+      for (const x in TYPE_NAMES) {
+        bc[x] = makeString(scope, TYPE_NAMES[x], false, '#Porffor_type_result');
+      }
+
+      return typeSwitch(scope, [ [ Opcodes.local_get, 1 ] ], bc);
+    }
   };
 
-  this.__SIMD_i32x4_create = {
-    params: [ Valtype.i32, Valtype.i32, Valtype.i32, Valtype.i32 ],
-    locals: [],
-    returns: [ Valtype.v128 ],
-    wasm: [
-      ...i32x4(0, 0, 0, 0),
-      [ Opcodes.local_get, 0 ],
-      [ ...Opcodes.i32x4_replace_lane, 0 ],
-      [ Opcodes.local_get, 1 ],
-      [ ...Opcodes.i32x4_replace_lane, 1 ],
-      [ Opcodes.local_get, 2 ],
-      [ ...Opcodes.i32x4_replace_lane, 2 ],
-      [ Opcodes.local_get, 3 ],
-      [ ...Opcodes.i32x4_replace_lane, 3 ],
-    ]
-  };
+  const localIsOneOf = (getter, arr, valtype = valtypeBinary) => {
+    const out = [];
 
-  this.__SIMD_i32x4_add = {
-    params: [ Valtype.v128, Valtype.v128 ],
-    locals: [],
-    returns: [ Valtype.v128 ],
-    wasm: [
-      [ Opcodes.local_get, 0 ],
-      [ Opcodes.local_get, 1 ],
-      [ ...Opcodes.i32x4_add ]
-    ]
-  };
+    for (let i = 0; i < arr.length; i++) {
+      out.push(...getter, ...number(arr[i], valtype), valtype === Valtype.f64 ? [ Opcodes.f64_eq ] : [ Opcodes.i32_eq ]);
+      if (i !== 0) out.push([ Opcodes.i32_or ]);
+    }
 
-  this.__SIMD_i32x4_sub = {
-    params: [ Valtype.v128, Valtype.v128 ],
-    locals: [],
-    returns: [ Valtype.v128 ],
-    wasm: [
-      [ Opcodes.local_get, 0 ],
-      [ Opcodes.local_get, 1 ],
-      [ ...Opcodes.i32x4_sub ]
-    ]
+    return out;
   };
 
-  this.__SIMD_i32x4_mul = {
-    params: [ Valtype.v128, Valtype.v128 ],
-    locals: [],
-    returns: [ Valtype.v128 ],
-    wasm: [
+  this.__Porffor_ptr = {
+    params: [ valtypeBinary, Valtype.i32 ],
+    typedParams: true,
+    locals: [ Valtype.i32, Valtype.i32 ],
+    returns: [ valtypeBinary ],
+    wasm: (scope, { TYPES }) => [
+      ...localIsOneOf([ [ Opcodes.local_get, 1 ] ], [ TYPES.string, TYPES._array, TYPES._bytestring ], Valtype.i32),
+      [ Opcodes.if, valtypeBinary ],
       [ Opcodes.local_get, 0 ],
-      [ Opcodes.local_get, 1 ],
-      [ ...Opcodes.i32x4_mul ]
+      [ Opcodes.else ],
+      ...number(NaN),
+      [ Opcodes.end ]
     ]
   };
 
-  this.__SIMD_i32x4_get0 = {
-    params: [ Valtype.v128 ],
-    locals: [],
-    returns: [ Valtype.i32 ],
-    wasm: [
-      [ Opcodes.local_get, 0 ],
-      [ ...Opcodes.i32x4_extract_lane, 0 ],
-    ],
-  },
-
-  this.__SIMD_i32x4_get1 = {
-    params: [ Valtype.v128 ],
-    locals: [],
-    returns: [ Valtype.i32 ],
-    wasm: [
-      [ Opcodes.local_get, 0 ],
-      [ ...Opcodes.i32x4_extract_lane, 1 ],
-    ],
-  };
-
-  this.__SIMD_i32x4_get2 = {
-    params: [ Valtype.v128 ],
-    locals: [],
-    returns: [ Valtype.i32 ],
-    wasm: [
-      [ Opcodes.local_get, 0 ],
-      [ ...Opcodes.i32x4_extract_lane, 2 ],
-    ],
-  };
-
-  this.__SIMD_i32x4_get3 = {
-    params: [ Valtype.v128 ],
-    locals: [],
+  this.__Porffor_i32_ptr = {
+    params: [ Valtype.i32, Valtype.i32 ],
+    typedParams: true,
+    locals: [ Valtype.i32, Valtype.i32 ],
     returns: [ Valtype.i32 ],
-    wasm: [
-      [ Opcodes.local_get, 0 ],
-      [ ...Opcodes.i32x4_extract_lane, 3 ],
-    ],
-  };
-
-  this.__SIMD_i32x4_shuffle_000c = {
-    params: [ Valtype.v128 ],
-    locals: [],
-    returns: [ Valtype.v128 ],
-    wasm: [
+    wasm: (scope, { TYPES }) => [
+      ...localIsOneOf([ [ Opcodes.local_get, 1 ] ], [ TYPES.string, TYPES._array, TYPES._bytestring ], Valtype.i32),
+      [ Opcodes.if, Valtype.i32 ],
       [ Opcodes.local_get, 0 ],
-      ...i32x4(0, 0, 0, 0),
-      [ ...Opcodes.i8x16_shuffle, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 8, 9, 10, 11 ], // i32x4 (a, b, c, d) -> i32x4 (0, 0, 0, c)
+      [ Opcodes.else ],
+      ...number(-1, Valtype.i32),
+      [ Opcodes.end ]
     ]
   };
 
-  this.__SIMD_i32x4_shuffle_00ab = {
-    params: [ Valtype.v128 ],
+  // unsafe: does not check type just ~casts to number
+  this.__Porffor_i32_ptrUnsafe = {
+    params: [ Valtype.i32 ],
     locals: [],
-    returns: [ Valtype.v128 ],
+    returns: [ Valtype.i32 ],
     wasm: [
       [ Opcodes.local_get, 0 ],
-      ...i32x4(0, 0, 0, 0),
-      [ ...Opcodes.i8x16_shuffle, 16, 16, 16, 16, 16, 16, 16, 16, 0, 1, 2, 3, 4, 5, 6, 7 ], // i32x4 (a, b, c, d) -> i32x4 (0, 0, a, b)
     ]
   };
-};
 
-export const BuiltinPreludes = {
-  btoa: `var keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
-var btoa = function (input) {
-  // todo: throw invalid character for unicode
-
-  let output = "";
-  let chr1, chr2, chr3, enc1, enc2, enc3, enc4;
-  let i = 0;
-
-  while (i < input.length) {
-    chr1 = input.charCodeAt(i++);
-    chr2 = input.charCodeAt(i++);
-    chr3 = input.charCodeAt(i++);
-
-    enc1 = chr1 >> 2;
-    enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
-    enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
-    enc4 = chr3 & 63;
-
-    if (isNaN(chr2)) {
-      enc3 = enc4 = 64;
-    } else if (isNaN(chr3)) {
-      enc4 = 64;
-    }
 
-    output += keyStr.charAt(enc1);
-    output += keyStr.charAt(enc2);
-    output += keyStr.charAt(enc3);
-    output += keyStr.charAt(enc4);
+  const generated = new GeneratedBuiltins.BuiltinFuncs();
+  for (const x in generated) {
+    this[x] = generated[x];
   }
-
-  return output;
-};`
 };