porffor 0.20.7 → 0.20.9

package/compiler/builtins/_internal_object.ts

@@ -0,0 +1,222 @@
+// @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;
+};
+
+export const __Porffor_object_define = (_this: object, key: any, value: any, flags: any): any => {
+  let entryPtr: i32 = __Porffor_object_lookup(_this, key);
+  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);
+  } else {
+    // existing entry, check and maybe modify it
+    const tail: i32 = Porffor.wasm.i32.load16_u(entryPtr, 0, 12);
+
+    if ((tail & 0b0010) == 0) {
+      // not already configurable, check to see if we can redefine
+      if ((tail & 0b1111) != flags) {
+        // flags have changed, perform checks
+        let err: boolean = false;
+
+        // descriptor type (accessor/data) and/or flags (other than writable) have changed
+        if ((tail & 0b0111) != flags) err = true;
+          else if (!(tail & 0b0001) && !(tail & 0b1000)) {
+          // data descriptor and already non-writable only checks
+          // trying to change writable false -> true
+          if (flags & 0b1000) {
+            err = true;
+          } else {
+            // if already non-writable, check value isn't being changed
+            Porffor.wasm`
+local.get ${entryPtr}
+f64.load 0 4
+local.get ${value}
+f64.ne
+
+local.get ${entryPtr}
+i32.load8_u 0 13
+local.get ${value+1}
+i32.ne
+i32.or
+local.set ${err}`;
+          }
+        }
+
+        if (err) throw new TypeError('Cannot redefine property');
+      }
+    }
+  }
+
+  // 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);
+};
+
+export const __Porffor_object_isEnumerable = (ptr: i32): boolean => {
+  return Porffor.wasm.i32.load8_u(ptr, 0, 12) & 0b0100;
+};
+
+export const __Porffor_object_isObject = (arg: any): boolean => {
+  const t: i32 = Porffor.wasm`local.get ${arg+1}`;
+  return Porffor.fastAnd(
+    arg != 0, // null
+    t > 0x05,
+    t != Porffor.TYPES.undefined,
+    t != Porffor.TYPES.string,
+    t != Porffor.TYPES.bytestring,
+  );
+};
+
+export const __Porffor_object_isObjectOrSymbol = (arg: any): boolean => {
+  const t: i32 = Porffor.wasm`local.get ${arg+1}`;
+  return Porffor.fastAnd(
+    arg != 0, // null
+    t > 0x04,
+    t != Porffor.TYPES.undefined,
+    t != Porffor.TYPES.string,
+    t != Porffor.TYPES.bytestring,
+  );
+};

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,43 @@ 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);
+    let ptr: i32 = Porffor.wasm`local.get ${obj}` + 4;
+    const endPtr: i32 = ptr + Porffor.wasm.i32.load(obj, 0, 0) * 14;
+
+    let i: i32 = 0;
+    for (; ptr < endPtr; ptr += 14) {
+      if (!Porffor.object.isEnumerable(ptr)) continue;
+
+      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 = i;
   } else if (Porffor.fastOr(
     t == Porffor.TYPES.array,
     t == Porffor.TYPES.bytestring,
@@ -37,13 +81,30 @@ 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);
+    let ptr: i32 = Porffor.wasm`local.get ${obj}` + 4;
+    const endPtr: i32 = ptr + Porffor.wasm.i32.load(obj, 0, 0) * 14;
+
+    let i: i32 = 0;
+    for (; ptr < endPtr; ptr += 14) {
+      if (!Porffor.object.isEnumerable(ptr)) continue;
 
-    out.length = size;
-    for (let i: i32 = 0; i < size; i++) {
-      out[i] = vals[i];
+      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 = i;
   } else if (Porffor.fastOr(
     t == Porffor.TYPES.array,
     t == Porffor.TYPES.bytestring,
@@ -87,7 +148,7 @@ 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');
+    if (!Porffor.object.isObject(x)) throw new TypeError('Iterator contains non-object');
     out[ecma262.ToPropertyKey(x[0])] = x[1];
   }
 
@@ -100,8 +161,7 @@ export const __Object_prototype_hasOwnProperty = (_this: any, prop: any) => {
 
   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, p) != -1;
   }
 
   const keys: any[] = __Object_keys(_this);
@@ -130,6 +190,49 @@ export const __Object_assign = (target: any, ...sources: any[]) => {
   return target;
 };
 
+export const __Object_defineProperty = (target: any, prop: any, descriptor: any) => {
+  if (!Porffor.object.isObject(target)) throw new TypeError('Target is a non-object');
+
+  // if (Porffor.rawType(descriptor) < 0x06) {
+  if (Porffor.rawType(descriptor) != Porffor.TYPES.object) {
+    throw new TypeError('Descriptor is a non-object');
+  }
+
+  const p: any = ecma262.ToPropertyKey(prop);
+
+  const desc: object = descriptor;
+
+  // base keys
+  const configurable: any = desc.configurable; // defaults to false/undefined
+  const enumerable: any = desc.enumerable; // defaults to false/undefined
+
+  // data descriptor keys
+  const value: any = desc.value;
+  const writable: any = desc.writable;
+
+  const get: any = desc.get;
+  const set: any = desc.set;
+
+  let accessor: boolean = false;
+
+  if (get || set) {
+    if (value || writable) {
+      throw new TypeError('Descriptor cannot define both accessor and data descriptor attributes');
+    }
+
+    accessor = true;
+  }
+
+  let flags: i32 = 0b0000;
+  if (accessor) flags |= 0b0001;
+  if (configurable) flags |= 0b0010;
+  if (enumerable) flags |= 0b0100;
+  if (writable) flags |= 0b1000;
+
+  Porffor.object.define(target, p, value, flags);
+  return target;
+};
+
 
 export const __Object_prototype_toString = (_this: object) => {
   let out: bytestring = '[object Object]';

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

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) < 0x05) throw new TypeError('Target for WeakRef needs to be an object or symbol');
+  if (!Porffor.object.isObjectOrSymbol(target)) 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

@@ -22,11 +22,9 @@ export const __ecma262_ToIntegerOrInfinity = (argument: unknown): number => {
   return number;
 };
 
-// todo: support non-bytestring properly
 // 7.1.17 ToString (argument)
 // https://tc39.es/ecma262/#sec-tostring
-export const __ecma262_ToString = (argument: unknown): bytestring => {
-  let out: bytestring = Porffor.allocate();
+export const __ecma262_ToString = (argument: unknown): any => {
   const type: i32 = Porffor.rawType(argument);
 
   // 1. If argument is a String, return argument.
@@ -37,6 +35,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 +68,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

@@ -98,7 +98,7 @@ export const Map = function (iterable: any): Map {
   Porffor.wasm.i32.store(out, vals, 0, 4);
 
   if (iterable != null) for (const x of iterable) {
-    if (Porffor.rawType(x) < 0x06) throw new TypeError('Iterator contains non-object');
+    if (!Porffor.object.isObject(x)) 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) < 0x05) throw new TypeError('Value in WeakSet needs to be an object or symbol');
+  if (!Porffor.object.isObjectOrSymbol(key)) throw new TypeError('Value in WeakSet needs to be an object or symbol');
 
   __Map_prototype_set(_this, key, value);
   return _this;
@@ -23,7 +23,7 @@ export const WeakMap = function (iterable: any): WeakMap {
   Porffor.wasm.i32.store(out, vals, 0, 4);
 
   if (iterable != null) for (const x of iterable) {
-    if (Porffor.rawType(x) < 0x06) throw new TypeError('Iterator contains non-object');
+    if (!Porffor.object.isObject(x)) 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) < 0x05) throw new TypeError('Value in WeakSet needs to be an object or symbol');
+  if (!Porffor.object.isObjectOrSymbol(value)) throw new TypeError('Value in WeakSet needs to be an object or symbol');
 
   __Set_prototype_add(_this, value);
   return _this;

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: [],