porffor 0.20.6 → 0.20.8

package/compiler/builtins/_internal_object.ts

@@ -0,0 +1,131 @@
+// @porf --valtype=i32
+import type {} from './porffor.d.ts';
+
+// memory layout:
+//  size (i32, 4)
+// per entry (14):
+//  key - value, type MSB encoded (u32, 4)
+//  value - value (f64, 8)
+//  value - type + obj flag (u16, 2)
+// flags:
+//  accessor - 0b0001
+//  configurable - 0b0010
+//  enumerable - 0b0100
+//  writable - 0b1000
+
+export const __Porffor_object_lookup = (_this: object, target: any): i32 => {
+  const targetType: i32 = Porffor.wasm`local.get ${target+1}`;
+
+  let ptr: i32 = Porffor.wasm`local.get ${_this}` + 4;
+
+  const size: i32 = Porffor.wasm.i32.load(_this, 0, 0);
+  const endPtr: i32 = ptr + size * 14;
+
+  if (targetType == Porffor.TYPES.bytestring) {
+    const targetStr: bytestring = target;
+    for (; ptr < endPtr; ptr += 14) {
+      const keyRaw: i32 = Porffor.wasm.i32.load(ptr, 0, 0);
+      if (keyRaw == 0) break; // ran out of keys
+      if (keyRaw >>> 31) continue; // MSB set, regular string type
+
+      const keyStr: bytestring = keyRaw;
+      if (keyStr == targetStr) return ptr;
+    }
+  } else {
+    const targetStr: string = target;
+    for (; ptr < endPtr; ptr += 14) {
+      const keyRaw: i32 = Porffor.wasm.i32.load(ptr, 0, 0);
+      if (keyRaw == 0) break; // ran out of keys
+      if (keyRaw >>> 31) { // MSB set, regular string type
+        const keyStr: string = keyRaw & 0x7FFFFFFF; // unset MSB
+        if (keyStr == targetStr) return ptr;
+      }
+    }
+  }
+
+  return -1;
+};
+
+export const __Porffor_object_get = (_this: object, key: any): any => {
+  const entryPtr: i32 = __Porffor_object_lookup(_this, key);
+  if (entryPtr == -1) {
+    Porffor.wasm`
+f64.const 0
+i32.const 128
+return`;
+  }
+
+  const tail: i32 = Porffor.wasm.i32.load16_u(entryPtr, 0, 12);
+
+  if (tail & 0b0001) {
+    // accessor descriptor
+    // todo
+
+    Porffor.wasm`
+f64.const 0
+i32.const 128
+return`;
+  }
+
+  // data descriptor
+  Porffor.wasm`
+local.get ${entryPtr}
+f64.load 0 4
+local.get ${tail}
+i32.const 8
+i32.shr_u
+return`;
+};
+
+export const __Porffor_object_set = (_this: object, key: any, value: any): any => {
+  let entryPtr: i32 = __Porffor_object_lookup(_this, key);
+  let flags: i32;
+  if (entryPtr == -1) {
+    // add new entry
+    // bump size +1
+    const size: i32 = Porffor.wasm.i32.load(_this, 0, 0);
+    Porffor.wasm.i32.store(_this, size + 1, 0, 0);
+
+    // entryPtr = current end of object
+    entryPtr = Porffor.wasm`local.get ${_this}` + 4 + size * 14;
+
+    // encode key type, set MSB if regular string
+    let keyEnc: i32 = Porffor.wasm`local.get ${key}`;
+    if (Porffor.wasm`local.get ${key+1}` == Porffor.TYPES.string) keyEnc |= 0x80000000;
+
+    // write key value and type (MSB)
+    Porffor.wasm.i32.store(entryPtr, keyEnc, 0, 0);
+
+    // flags = writable, enumerable, configurable, not accessor
+    flags = 0b1110;
+  } else {
+    // existing entry, modify it
+    const tail: i32 = Porffor.wasm.i32.load16_u(entryPtr, 0, 12);
+
+    if (tail & 0b0001) {
+      // accessor descriptor
+      // todo
+
+      return value;
+    }
+
+    // data descriptor
+    if (!(tail & 0b1000)) {
+      // not writable, return now
+      return value;
+    }
+
+    // flags = same flags as before
+    flags = tail & 0xff;
+  }
+
+  // write new value value (lol)
+  Porffor.wasm.f64.store(entryPtr, value, 0, 4);
+
+  // write new tail (value type + flags)
+  Porffor.wasm.i32.store16(entryPtr,
+    flags + (Porffor.wasm`local.get ${value+1}` << 8),
+    0, 12);
+
+  return value;
+};

package/compiler/builtins/console.ts

@@ -62,7 +62,7 @@ export const __Porffor_miniLog = (arg: any) => {
       } else {
         printStatic('[ ');
         for (let i: i32 = 0; i <= arrLen; i++) {
-          __Porffor_miniPrint(arg[i]);
+          __Porffor_miniLog(arg[i]);
           if (i != arrLen) printStatic(', ');
         }
         printStatic(' ]');

package/compiler/builtins/error.js

@@ -2,8 +2,8 @@ export default () => {
   let out = '';
 
   const error = name => out += `export const ${name} = function (message: bytestring) {
-  new.target;
-  return Object();
+  new.target; // trick compiler into allowing as constructor
+  return {};
 };`;
 
   error('Error');

package/compiler/builtins/object.ts

@@ -1,5 +1,19 @@
 import type {} from './porffor.d.ts';
 
+export const Object = function (value: any): object {
+  new.target; // trick compiler into allowing as constructor
+
+  if (value == null) {
+    // if nullish, return new empty object
+    const obj: object = Porffor.allocate();
+    return obj;
+  }
+
+  // todo: turn primitive args into objects
+  // return input
+  return value;
+};
+
 export const __Object_keys = (obj: any): any[] => {
   if (obj == null) throw new TypeError('Argument is nullish, expected object');
 
@@ -7,13 +21,46 @@ export const __Object_keys = (obj: any): any[] => {
 
   const t: i32 = Porffor.rawType(obj);
   if (t == Porffor.TYPES.object) {
-    const keys: Set = Porffor.wasm.i32.load(obj, 0, 0);
-    const size: i32 = Porffor.wasm.i32.load(keys, 0, 0);
-    out.length = size;
-
-    for (let i: i32 = 0; i < size; i++) {
-      out[i] = Porffor.set.read(keys, i);
+    const size: i32 = Porffor.wasm.i32.load(obj, 0, 0);
+    let len: i32 = size;
+
+    let ptr: i32 = Porffor.wasm`local.get ${obj}` + 4;
+    const endPtr: i32 = ptr + size * 14;
+
+    let i: i32 = 0;
+    for (; ptr < endPtr; ptr += 14) {
+      // todo: check enumerable flag
+
+      let key: any;
+      Porffor.wasm`local raw i32
+local.get ${ptr}
+i32.to_u
+i32.load 0 0
+local.set raw
+
+local.get raw
+i32.const 31
+i32.shr_u
+if 127
+  i32.const 67
+  local.set ${key+1}
+
+  local.get raw
+  i32.const 2147483647
+  i32.and
+else
+  i32.const 195
+  local.set ${key+1}
+
+  local.get raw
+end
+i32.from_u
+local.set ${key}`;
+
+      out[i++] = key;
     }
+
+    out.length = len;
   } else if (Porffor.fastOr(
     t == Porffor.TYPES.array,
     t == Porffor.TYPES.bytestring,
@@ -37,13 +84,33 @@ export const __Object_values = (obj: any): any[] => {
 
   const t: i32 = Porffor.rawType(obj);
   if (t == Porffor.TYPES.object) {
-    const size: i32 = Porffor.wasm.i32.load(Porffor.wasm.i32.load(obj, 0, 0), 0, 0);
-    const vals: any[] = Porffor.wasm.i32.load(obj, 0, 4);
+    const size: i32 = Porffor.wasm.i32.load(obj, 0, 0);
+    let len: i32 = size;
 
-    out.length = size;
-    for (let i: i32 = 0; i < size; i++) {
-      out[i] = vals[i];
+    let ptr: i32 = Porffor.wasm`local.get ${obj}` + 4;
+    const endPtr: i32 = ptr + size * 14;
+
+    let i: i32 = 0;
+    for (; ptr < endPtr; ptr += 14) {
+      // todo: check enumerable flag
+
+      let val: any;
+      Porffor.wasm`local ptr32 i32
+local.get ${ptr}
+i32.to_u
+local.tee ptr32
+
+f64.load 0 4
+local.set ${val}
+
+local.get ptr32
+i32.load8_u 0 13
+local.set ${val+1}`;
+
+      out[i++] = val;
     }
+
+    out.length = len;
   } else if (Porffor.fastOr(
     t == Porffor.TYPES.array,
     t == Porffor.TYPES.bytestring,
@@ -83,14 +150,24 @@ export const __Object_entries = (obj: any): any[] => {
   return out;
 };
 
+export const __Object_fromEntries = (iterable: any): object => {
+  const out: object = {};
+
+  for (const x of iterable) {
+    if (Porffor.rawType(x) < 0x06) throw new TypeError('Iterator contains non-object');
+    out[ecma262.ToPropertyKey(x[0])] = x[1];
+  }
+
+  return out;
+};
+
 
 export const __Object_prototype_hasOwnProperty = (_this: any, prop: any) => {
   const p: any = ecma262.ToPropertyKey(prop);
 
   const t: i32 = Porffor.rawType(_this);
   if (t == Porffor.TYPES.object) {
-    const keys: Set = Porffor.wasm.i32.load(_this, 0, 0);
-    return __Set_prototype_has(keys, p);
+    return __Porffor_object_lookup(_this, prop) != -1;
   }
 
   const keys: any[] = __Object_keys(_this);
@@ -103,6 +180,23 @@ export const __Object_hasOwn = (obj: any, prop: any) => {
 };
 
 
+export const __Object_assign = (target: any, ...sources: any[]) => {
+  if (target == null) throw new TypeError('Argument is nullish, expected object');
+
+  for (const x of sources) {
+    const keys: any[] = __Object_keys(x);
+    const vals: any[] = __Object_values(x);
+
+    const len: i32 = keys.length;
+    for (let i: i32 = 0; i < len; i++) {
+      target[keys[i]] = vals[i];
+    }
+  }
+
+  return target;
+};
+
+
 export const __Object_prototype_toString = (_this: object) => {
   let out: bytestring = '[object Object]';
   return out;

package/compiler/builtins/set.ts

@@ -1,17 +1,6 @@
 import type {} from './porffor.d.ts';
 
 // dark wasm magic for dealing with memory, sorry.
-export const __Porffor_allocate = (): number => {
-  Porffor.wasm`
-i32.const 1
-memory.grow 0
-i32.const 65536
-i32.mul
-i32.from_u
-i32.const 1
-return`;
-};
-
 export const __Porffor_set_read = (_this: Set, index: number): any => {
   Porffor.wasm`
 local offset i32
@@ -184,10 +173,7 @@ export const Set = function (iterable: any): Set {
 
   const out: Set = __Porffor_allocate();
 
-  if (Porffor.fastAnd(
-    Porffor.rawType(iterable) != Porffor.TYPES.undefined,
-    iterable !== null
-  )) for (const x of iterable) {
+  if (iterable != null) for (const x of iterable) {
     __Set_prototype_add(out, x);
   }
 

package/compiler/builtins/weakref.ts

@@ -3,7 +3,7 @@ import type {} from './porffor.d.ts';
 export const WeakRef = function (target: any): WeakRef {
   if (!new.target) throw new TypeError("Constructor WeakRef requires 'new'");
 
-  if (Porffor.rawType(target) < 0x04) throw new TypeError('Target for WeakRef needs to be an object or symbol');
+  if (Porffor.rawType(target) < 0x05) throw new TypeError('Target for WeakRef needs to be an object or symbol');
 
   const out: WeakRef = Porffor.allocateBytes(9);
 

package/compiler/builtins/z_ecma262.ts

@@ -26,7 +26,6 @@ export const __ecma262_ToIntegerOrInfinity = (argument: unknown): number => {
 // 7.1.17 ToString (argument)
 // https://tc39.es/ecma262/#sec-tostring
 export const __ecma262_ToString = (argument: unknown): bytestring => {
-  let out: bytestring = Porffor.allocate();
   const type: i32 = Porffor.rawType(argument);
 
   // 1. If argument is a String, return argument.
@@ -37,6 +36,8 @@ export const __ecma262_ToString = (argument: unknown): bytestring => {
   // 2. If argument is a Symbol, throw a TypeError exception.
   if (type == Porffor.TYPES.symbol) throw new TypeError('Cannot convert a Symbol value to a string');
 
+  let out: bytestring = Porffor.allocate();
+
   // 3. If argument is undefined, return "undefined".
   if (Porffor.fastOr(
     type == Porffor.TYPES.undefined,
@@ -68,14 +69,14 @@ export const __ecma262_ToString = (argument: unknown): bytestring => {
 // https://tc39.es/ecma262/#sec-topropertykey
 export const __ecma262_ToPropertyKey = (argument: any): any => {
   // 1. Let key be ? ToPrimitive(argument, string).
-  const key: any = argument;
+  // argument = key
 
   // 2. If key is a Symbol, then
-  if (Porffor.rawType(key) == Porffor.TYPES.symbol) {
+  if (Porffor.rawType(argument) == Porffor.TYPES.symbol) {
     // a. Return key.
-    return key;
+    return argument;
   }
 
   // 3. Return ! ToString(key).
-  return __ecma262_ToString(key);
+  return __ecma262_ToString(argument);
 };

package/compiler/builtins/z_map.ts

@@ -97,10 +97,8 @@ export const Map = function (iterable: any): Map {
   const vals: any[] = Porffor.allocate();
   Porffor.wasm.i32.store(out, vals, 0, 4);
 
-  if (Porffor.fastAnd(
-    Porffor.rawType(iterable) != Porffor.TYPES.undefined,
-    iterable !== null
-  )) for (const x of iterable) {
+  if (iterable != null) for (const x of iterable) {
+    if (Porffor.rawType(x) < 0x06) throw new TypeError('Iterator contains non-object');
     __Map_prototype_set(out, x[0], x[1]);
   }
 

package/compiler/builtins/z_weakmap.ts

@@ -3,7 +3,7 @@ import type {} from './porffor.d.ts';
 export const __WeakMap_prototype_has = (_this: WeakMap, key: any) => __Map_prototype_has(_this, key);
 
 export const __WeakMap_prototype_set = (_this: WeakMap, key: any, value: any) => {
-  if (Porffor.rawType(key) < 0x04) throw new TypeError('Value in WeakSet needs to be an object or symbol');
+  if (Porffor.rawType(key) < 0x05) throw new TypeError('Value in WeakSet needs to be an object or symbol');
 
   __Map_prototype_set(_this, key, value);
   return _this;
@@ -22,10 +22,8 @@ export const WeakMap = function (iterable: any): WeakMap {
   const vals: any[] = Porffor.allocate();
   Porffor.wasm.i32.store(out, vals, 0, 4);
 
-  if (Porffor.fastAnd(
-    Porffor.rawType(iterable) != Porffor.TYPES.undefined,
-    iterable !== null
-  )) for (const x of iterable) {
+  if (iterable != null) for (const x of iterable) {
+    if (Porffor.rawType(x) < 0x06) throw new TypeError('Iterator contains non-object');
     __WeakMap_prototype_set(out, x[0], x[1]);
   }
 

package/compiler/builtins/z_weakset.ts

@@ -3,7 +3,7 @@ import type {} from './porffor.d.ts';
 export const __WeakSet_prototype_has = (_this: WeakSet, value: any) => __Set_prototype_has(_this, value);
 
 export const __WeakSet_prototype_add = (_this: WeakSet, value: any) => {
-  if (Porffor.rawType(value) < 0x04) throw new TypeError('Value in WeakSet needs to be an object or symbol');
+  if (Porffor.rawType(value) < 0x05) throw new TypeError('Value in WeakSet needs to be an object or symbol');
 
   __Set_prototype_add(_this, value);
   return _this;
@@ -16,10 +16,7 @@ export const WeakSet = function (iterable: any): WeakSet {
 
   const out: WeakSet = __Porffor_allocate();
 
-  if (Porffor.fastAnd(
-    Porffor.rawType(iterable) != Porffor.TYPES.undefined,
-    iterable !== null
-  )) for (const x of iterable) {
+  if (iterable != null) for (const x of iterable) {
     __WeakSet_prototype_add(out, x);
   }
 

package/compiler/builtins.js

@@ -248,19 +248,6 @@ export const BuiltinFuncs = function() {
     constr: true
   };
 
-  // just return given (default 0) for (new) Object() as we somewhat supports object just not constructor
-  this.Object = {
-    params: [ valtypeBinary ],
-    locals: [],
-    returns: [ valtypeBinary ],
-    returnType: TYPES.object,
-    wasm: [
-      // [ Opcodes.local_get, 0 ]
-      ...number(1)
-    ],
-    constr: true
-  };
-
   this.isNaN = {
     floatOnly: true,
     params: [ valtypeBinary ],
@@ -427,7 +414,7 @@ export const BuiltinFuncs = function() {
     returnType: TYPES.number,
     wasm: [
       [ Opcodes.local_get, 0 ],
-      Opcodes.i32_trunc_sat_f64_u,
+      Opcodes.i32_to_u,
       [ Opcodes.i32_clz ],
       Opcodes.i32_from
     ]
@@ -455,9 +442,9 @@ export const BuiltinFuncs = function() {
     returnType: TYPES.number,
     wasm: [
       [ Opcodes.local_get, 0 ],
-      Opcodes.i32_trunc_sat_f64_s,
+      Opcodes.i32_to,
       [ Opcodes.local_get, 1 ],
-      Opcodes.i32_trunc_sat_f64_s,
+      Opcodes.i32_to,
       [ Opcodes.i32_mul ],
       Opcodes.i32_from
     ]
@@ -980,6 +967,19 @@ export const BuiltinFuncs = function() {
     ]
   };
 
+  this.__Porffor_allocate = {
+    params: [],
+    locals: [],
+    returns: [ Valtype.i32 ],
+    returnType: TYPES.number,
+    wasm: [
+      ...number(1, Valtype.i32),
+      [ Opcodes.memory_grow, 0 ],
+      ...number(65536, Valtype.i32),
+      [ Opcodes.i32_mul ]
+    ]
+  };
+
   this.__Porffor_allocateBytes = {
     params: [ Valtype.i32 ],
     locals: [],