porffor 0.2.0-fdf0fc5 → 0.14.0-0ad2c8a7c

package/compiler/builtins/porffor.d.ts

@@ -7,18 +7,18 @@ type PorfforGlobal = {
   wasm: {
     (...args: any[]): any;
     i32: {
-      load(pointer: i32, align: i32, offset: i32): i32;
-      store(pointer: i32, value: i32, align: i32, offset: i32): i32;
-      load8_u(pointer: i32, align: i32, offset: i32): i32;
-      store8(pointer: i32, value: i32, align: i32, offset: i32): i32;
-      load16_u(pointer: i32, align: i32, offset: i32): i32;
-      store16(pointer: i32, value: i32, align: i32, offset: i32): i32;
+      load(pointer: any, align: i32, offset: i32): i32;
+      store(pointer: any, value: i32, align: i32, offset: i32): i32;
+      load8_u(pointer: any, align: i32, offset: i32): i32;
+      store8(pointer: any, value: i32, align: i32, offset: i32): i32;
+      load16_u(pointer: any, align: i32, offset: i32): i32;
+      store16(pointer: any, value: i32, align: i32, offset: i32): i32;
       const(value: i32): i32;
     }
 
     f64: {
-      load(pointer: i32, align: i32, offset: i32): i32;
-      store(pointer: i32, value: f64, align: i32, offset: i32): f64;
+      load(pointer: any, align: i32, offset: i32): i32;
+      store(pointer: any, value: f64, align: i32, offset: i32): f64;
     }
   }
 
@@ -40,6 +40,7 @@ type PorfforGlobal = {
     regexp: i32;
     bytestring: i32;
     date: i32;
+    set: i32;
   }
 
   fastOr(...args: any): boolean;

package/compiler/builtins/set.ts

@@ -1,5 +1,199 @@
-// @porf --funsafe-no-unlikely-proto-checks
+import type {} from './porffor.d.ts';
 
-export const Set = (iterable: any): Set => {
+// 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 __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;
+};
+
+
+export const __Set_prototype_size$get = (_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 = Porffor.wasm.i32.load(_this, 0, 0);
+
+  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 = Porffor.wasm.i32.load(_this, 0, 0);
+
+  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 = Porffor.wasm.i32.load(_this, 0, 0);
+
+  // 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 = Porffor.wasm.i32.load(_this, 0, 0);
+
+  // 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;
+};
+
+export const __Set_prototype_union = (_this: Set, other: any) => {
+  if (Porffor.rawType(other) != Porffor.TYPES.set) {
+    throw new TypeError("Set.union requires 'Set'");
+  }
+  const out: Set = new Set(_this);
+  for (const x of other) {
+    out.add(x);
+  }
+  return out;
+};

package/compiler/builtins/string.ts

@@ -1,4 +1,5 @@
-// @porf --funsafe-no-unlikely-proto-checks --valtype=i32
+// @porf --valtype=i32
+import type {} from './porffor.d.ts';
 
 export const __String_fromCharCode = (code: i32) => {
   // todo: support >1 arg

package/compiler/builtins/symbol.ts

@@ -0,0 +1,62 @@
+import type {} from './porffor.d.ts';
+
+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;
+};
+
+export const __Symbol_prototype_description$get = (_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 = [
   {
@@ -40,6 +40,18 @@ export const importedFuncs = [
     import: 'z',
     params: 1,
     returns: 0
+  },
+  {
+    name: '__Porffor_readArgv',
+    import: 'w',
+    params: 2,
+    returns: 0
+  },
+  {
+    name: '__Porffor_readFile',
+    import: 'q',
+    params: 2,
+    returns: 0
   }
 ];
 
@@ -48,8 +60,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 +150,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 +210,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 +223,8 @@ export const BuiltinFuncs = function() {
     wasm: [
       // [ Opcodes.local_get, 0 ]
       ...number(1)
-    ]
+    ],
+    constr: true
   };
 
 
@@ -221,7 +233,7 @@ export const BuiltinFuncs = function() {
     typedParams: true,
     locals: [ Valtype.i32, Valtype.i32 ],
     returns: [],
-    wasm: (scope, { typeSwitch }) => [
+    wasm: (scope, { typeSwitch, builtin }) => [
       ...typeSwitch(scope, [ [ Opcodes.local_get, 1 ] ], {
         [TYPES.number]: [
           [ Opcodes.local_get, 0 ],
@@ -317,7 +329,7 @@ export const BuiltinFuncs = function() {
 
           // make end pointer
           [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
-          ...number(ValtypeSize[valtype], Valtype.i32),
+          ...number(ValtypeSize[valtype] + 1, Valtype.i32),
           [ Opcodes.i32_mul ],
 
           [ Opcodes.local_get, 2 ],
@@ -326,14 +338,18 @@ export const BuiltinFuncs = function() {
 
           [ Opcodes.loop, Blocktype.void ],
 
-          // print current char
+          // print current array element
           [ Opcodes.local_get, 2 ],
-          [ Opcodes.load, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
-          [ Opcodes.call, importedFuncs.print ],
+          [ Opcodes.load, 0, ValtypeSize.i32 ],
+
+          [ Opcodes.local_get, 2 ],
+          [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 + ValtypeSize[valtype] ],
+
+          [ Opcodes.call, builtin('__Porffor_print') ],
 
           // increment pointer by sizeof valtype
           [ Opcodes.local_get, 2 ],
-          ...number(ValtypeSize[valtype], Valtype.i32),
+          ...number(ValtypeSize[valtype] + 1, Valtype.i32),
           [ Opcodes.i32_add ],
           [ Opcodes.local_tee, 2 ],
 
@@ -569,7 +585,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 = ({