porffor 0.2.0-fdf0fc5 → 0.14.0-0d97d1e6a

package/compiler/builtins/set.ts

@@ -1,5 +1,187 @@
-// @porf --funsafe-no-unlikely-proto-checks
+// dark wasm magic for dealing with memory, sorry.
+export const __Porffor_allocate = (): number => {
+  Porffor.wasm`i32.const 1
+memory.grow 0
+drop
+memory.size 0
+i32.const 1
+i32.sub
+i32.const 65536
+i32.mul
+i32.from_u
+return`;
+};
 
-export const Set = (iterable: any): Set => {
+export const __Porffor_set_read = (_this: Set, index: number): any => {
+  Porffor.wasm`
+local offset i32
+local.get ${index}
+i32.to_u
+i32.const 9
+i32.mul
+local.get ${_this}
+i32.to_u
+i32.add
+local.set offset
 
+local.get offset
+f64.load 0 4
+
+local.get offset
+i32.load8_u 0 12
+return`;
+};
+
+export const __Porffor_set_write = (_this: Set, index: number, value: any): boolean => {
+  Porffor.wasm`
+local offset i32
+local.get ${index}
+i32.to_u
+i32.const 9
+i32.mul
+local.get ${_this}
+i32.to_u
+i32.add
+local.set offset
+
+local.get offset
+local.get ${value}
+f64.store 0 4
+
+local.get offset
+local.get ${value+1}
+i32.store8 0 12`;
+
+  return true;
+};
+
+
+// todo: this should be a getter somehow not a method
+export const __Set_prototype_size = (_this: Set) => {
+  return Porffor.wasm.i32.load(_this, 0, 0);
+};
+
+export const __Set_prototype_values = (_this: Set) => {
+  // todo: this should return an iterator not array
+  const size: number = __Set_prototype_size(_this);
+
+  const out: any[] = __Porffor_allocate();
+  for (let i: number = 0; i < size; i++) {
+    const val: any = __Porffor_set_read(_this, i);
+    out.push(val);
+  }
+
+  return out;
+};
+
+export const __Set_prototype_keys = (_this: Set) => {
+  return __Set_prototype_values(_this);
+};
+
+export const __Set_prototype_has = (_this: Set, value: any) => {
+  const size: number = __Set_prototype_size(_this);
+
+  for (let i: number = 0; i < size; i++) {
+    if (__Porffor_set_read(_this, i) === value) return true;
+  }
+
+  return false;
+};
+
+export const __Set_prototype_add = (_this: Set, value: any) => {
+  const size: number = __Set_prototype_size(_this);
+
+  // check if already in set
+  for (let i: number = 0; i < size; i++) {
+    if (__Porffor_set_read(_this, i) === value) return _this;
+  }
+
+  // not, add it
+  // increment size by 1
+  Porffor.wasm.i32.store(_this, size + 1, 0, 0);
+
+  // write new value at end
+  __Porffor_set_write(_this, size, value);
+
+  return _this;
+};
+
+export const __Set_prototype_delete = (_this: Set, value: any) => {
+  const size: number = __Set_prototype_size(_this);
+
+  // check if already in set
+  for (let i: number = 0; i < size; i++) {
+    if (__Porffor_set_read(_this, i) === value) {
+      // found, delete
+      // decrement size by 1
+      Porffor.wasm.i32.store(_this, size - 1, 0, 0);
+
+      // offset all elements after by -1 ind
+      Porffor.wasm`
+local offset i32
+local.get ${i}
+i32.to_u
+i32.const 9
+i32.mul
+local.get ${_this}
+i32.to_u
+i32.add
+i32.const 4
+i32.add
+local.set offset
+
+;; dst = offset (this element)
+local.get offset
+
+;; src = offset + 9 (this element + 1 element)
+local.get offset
+i32.const 9
+i32.add
+
+;; size = (size - i - 1) * 9
+local.get ${size}
+local.get ${i}
+f64.sub
+i32.to_u
+i32.const 1
+i32.sub
+i32.const 9
+i32.mul
+
+memory.copy 0 0`;
+
+      return true;
+    }
+  }
+
+  // not, return false
+  return false;
+};
+
+export const __Set_prototype_clear = (_this: Set) => {
+  // just set size to 0
+  // do not need to delete any as will not be accessed anymore,
+  // and will be overwritten with new add
+  Porffor.wasm.i32.store(_this, 0, 0, 0);
+};
+
+export const Set = () => {
+  throw new TypeError("Constructor Set requires 'new'");
+};
+
+export const Set$constructor = (iterable: any): Set => {
+  const out: Set = __Porffor_allocate();
+
+  const type: number = Porffor.rawType(iterable);
+  if (Porffor.fastOr(
+    type == Porffor.TYPES.array,
+    type == Porffor.TYPES.string, type == Porffor.TYPES.bytestring,
+    type == Porffor.TYPES.set
+  )) {
+    for (const x of iterable) {
+      __Set_prototype_add(out, x);
+    }
+  }
+
+  return out;
 };

package/compiler/builtins/string.ts

@@ -1,4 +1,4 @@
-// @porf --funsafe-no-unlikely-proto-checks --valtype=i32
+// @porf --valtype=i32
 
 export const __String_fromCharCode = (code: i32) => {
   // todo: support >1 arg

package/compiler/builtins/symbol.ts

@@ -0,0 +1,61 @@
+export const __Porffor_symbol_descStore = (op: boolean, value: any): any => {
+  const ptr: bytestring = '';
+
+  if (op) { // write
+    const size: number = Porffor.wasm.i32.load(ptr, 0, 0);
+    Porffor.wasm.i32.store(ptr, size + 1, 0, 0)
+
+    // reuse set internals to store description
+    __Porffor_set_write(ptr, size, value);
+    return size;
+  } else { // read
+    return __Porffor_set_read(ptr, value);
+  }
+};
+
+export const Symbol = (description: any): Symbol => {
+  // 1-based so always truthy as numeric value
+  return __Porffor_symbol_descStore(true, description) + 1;
+};
+
+// todo: this should be a getter somehow not a method
+export const __Symbol_prototype_description = (_this: Symbol) => {
+  const description: bytestring = __Porffor_symbol_descStore(false,
+    Porffor.wasm`local.get ${_this}` - 1);
+  return description;
+};
+
+export const __Symbol_prototype_toString = (_this: Symbol) => {
+  let out: bytestring = '';
+
+  // Symbol(
+  Porffor.wasm.i32.store8(out, 83, 0, 4);
+  Porffor.wasm.i32.store8(out, 121, 0, 5);
+  Porffor.wasm.i32.store8(out, 109, 0, 6);
+  Porffor.wasm.i32.store8(out, 98, 0, 7);
+  Porffor.wasm.i32.store8(out, 111, 0, 8);
+  Porffor.wasm.i32.store8(out, 108, 0, 9);
+  Porffor.wasm.i32.store8(out, 40, 0, 10);
+
+  const description: bytestring = __Porffor_symbol_descStore(false,
+    Porffor.wasm`local.get ${_this}` - 1);
+
+  const descLen: i32 = description.length;
+  let outPtr: i32 = Porffor.wasm`local.get ${out}` + 7;
+  let descPtr: i32 = Porffor.wasm`local.get ${description}`;
+  const descPtrEnd: i32 = descPtr + descLen;
+  while (descPtr < descPtrEnd) {
+    Porffor.wasm.i32.store8(outPtr++, Porffor.wasm.i32.load8_u(descPtr++, 0, 4), 0, 4);
+  }
+
+  // )
+  Porffor.wasm.i32.store8(Porffor.wasm`local.get ${out}` + descLen, 41, 0, 11);
+
+  out.length = 8 + descLen;
+
+  return out;
+};
+
+export const __Symbol_prototype_valueOf = (_this: Symbol) => {
+  return _this;
+};

package/compiler/builtins.js

@@ -1,8 +1,8 @@
-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';
+import { Blocktype, Opcodes, Valtype, ValtypeSize } from './wasmSpec.js';
+import { number } from './embedding.js';
 import { TYPES } from './types.js';
+import Prefs from './prefs.js';
 
 export const importedFuncs = [
   {
@@ -48,8 +48,6 @@ for (let i = 0; i < importedFuncs.length; i++) {
   importedFuncs[f.name] = i;
 }
 
-const char = c => number(c.charCodeAt(0));
-
 const printStaticStr = str => {
   const out = [];
 
@@ -140,7 +138,7 @@ export const BuiltinVars = function() {
   this.Math = number(1);
 
   // wintercg(tm)
-  this.__navigator_userAgent = (scope, { makeString }) => makeString(scope, `Porffor/0.2.0`, false, '__navigator_userAgent');
+  this.__navigator_userAgent = (scope, { makeString }) => makeString(scope, `Porffor/0.14.0`, false, '__navigator_userAgent');
   this.__navigator_userAgent.type = Prefs.bytestring ? TYPES.bytestring : TYPES.string;
 
   for (const x in TYPES) {
@@ -200,7 +198,8 @@ export const BuiltinFuncs = function() {
     returns: [ valtypeBinary ],
     wasm: [
       [ Opcodes.local_get, 0 ]
-    ]
+    ],
+    constr: true
   };
 
   // just return given (default 0) for (new) Object() as we somewhat supports object just not constructor
@@ -212,7 +211,8 @@ export const BuiltinFuncs = function() {
     wasm: [
       // [ Opcodes.local_get, 0 ]
       ...number(1)
-    ]
+    ],
+    constr: true
   };
 
 
@@ -569,7 +569,6 @@ export const BuiltinFuncs = function() {
 
   // this is an implementation of xorshift128+ (in wasm bytecode)
   // fun fact: v8, SM, JSC also use this (you will need this fun fact to maintain your sanity reading this code)
-  // const prngSeed0 = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER), prngSeed1 = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
   const prngSeed0 = (Math.random() * (2 ** 30)) | 0, prngSeed1 = (Math.random() * (2 ** 30)) | 0;
 
   const prng = ({