porffor 0.22.8 → 0.22.10

package/compiler/assemble.js

@@ -164,13 +164,31 @@ export default (funcs, globals, tags, pages, data, flags, noTreeshake = false) =
     // generate func lut data
     const bytes = [];
     for (let i = 0; i < funcs.length; i++) {
-      const argc = Math.floor(funcs[i].params.length / 2);
+      const func = funcs[i];
+      let name = func.name;
+
+      const typedParams = !func.internal || func.typedParams;
+      let argc = Math.floor(typedParams ? func.params.length / 2 : func.params.length);
+
+      // hack: argc-- for prototype methods to remove _this hack from count
+      if (name.includes('_prototype_')) argc--;
+
       bytes.push(argc % 256, (argc / 256 | 0) % 256);
 
       let flags = 0b00000000; // 8 flag bits
-      if (funcs[i].returnType != null) flags |= 0b1;
-      if (funcs[i].constr) flags |= 0b10;
+      if (func.returnType != null) flags |= 0b1;
+      if (func.constr) flags |= 0b10;
       bytes.push(flags);
+
+      // eg: __String_prototype_toLowerCase -> toLowerCase
+      if (name.startsWith('__')) name = name.split('_').pop();
+
+      bytes.push(...new Uint8Array(new Int32Array([ name.length ]).buffer));
+
+      for (let i = 0; i < (128 - 3 - 4); i++) {
+        const c = name.charCodeAt(i);
+        bytes.push((c || 0) % 256);
+      }
     }
 
     data.push({

package/compiler/builtins/_internal_object.ts

@@ -62,8 +62,7 @@ export const __Porffor_object_checkAllFlags = (_this: object, dataAnd: i32, acce
   return true;
 };
 
-
-export const __Porffor_object_packAccessor = (get: i32, set: i32): f64 => {
+export const __Porffor_object_packAccessor = (get: any, set: any): f64 => {
   // pack i32s get & set into a single f64 (i64)
   Porffor.wasm`
 local.get ${set}
@@ -81,11 +80,23 @@ return`;
 
 export const __Porffor_object_accessorGet = (entryPtr: i32): Function => {
   const out: Function = Porffor.wasm.i32.load(entryPtr, 0, 4);
+
+  // no getter, return undefined
+  if (Porffor.wasm`local.get ${out}` == 0) {
+    return undefined;
+  }
+
   return out;
 };
 
 export const __Porffor_object_accessorSet = (entryPtr: i32): Function => {
   const out: Function = Porffor.wasm.i32.load(entryPtr, 0, 8);
+
+  // no setter, return undefined
+  if (Porffor.wasm`local.get ${out}` == 0) {
+    return undefined;
+  }
+
   return out;
 };
 
@@ -134,7 +145,37 @@ export const __Porffor_object_lookup = (_this: object, target: any): i32 => {
   return -1;
 };
 
-export const __Porffor_object_get = (_this: object, key: any): any => {
+export const __Porffor_object_get = (_this: any, key: any): any => {
+  if (Porffor.wasm`local.get ${_this+1}` == Porffor.TYPES.function) {
+    let tmp: bytestring = '';
+    tmp = 'name';
+    if (key == tmp) {
+      const o: bytestring = __Porffor_funcLut_name(_this);
+      const t: i32 = Porffor.TYPES.bytestring;
+      Porffor.wasm`
+local.get ${o}
+f64.convert_i32_u
+local.get ${t}
+return`;
+    }
+
+    tmp = 'length';
+    if (key == tmp) {
+      const o: i32 = __Porffor_funcLut_length(_this);
+      Porffor.wasm`
+local.get ${o}
+f64.convert_i32_u
+i32.const 1
+return`;
+    }
+
+    // undefined
+    Porffor.wasm`
+f64.const 0
+i32.const 128
+return`;
+  }
+
   const entryPtr: i32 = __Porffor_object_lookup(_this, key);
   if (entryPtr == -1) {
     Porffor.wasm`
@@ -148,6 +189,15 @@ return`;
   if (tail & 0b0001) {
     // accessor descriptor
     const get: Function = __Porffor_object_accessorGet(entryPtr);
+
+    // no getter, return undefined
+    if (Porffor.wasm`local.get ${get}` == 0) {
+      Porffor.wasm`
+f64.const 0
+i32.const 128
+return`;
+    }
+
     Porffor.wasm`
 local.get ${get}
 call_indirect 0 0
@@ -205,7 +255,14 @@ export const __Porffor_object_set = (_this: object, key: any, value: any): any =
     if (tail & 0b0001) {
       // accessor descriptor
       const set: Function = __Porffor_object_accessorSet(entryPtr);
-    Porffor.wasm`
+
+      // no setter, return early
+      if (Porffor.wasm`local.get ${set}` == 0) {
+        // todo: throw in strict mode?
+        return value;
+      }
+
+      Porffor.wasm`
 local.get ${value}
 local.get ${value+1}
 local.get ${set}

package/compiler/builtins/console.ts

@@ -141,8 +141,23 @@ export const __Porffor_print = (arg: any, colors: boolean = true) => {
 
     case Porffor.TYPES.object:
       if (arg) {
-        if (colors) printStatic('\x1b[34m'); // blue
-        printStatic('[Object]');
+        printStatic('{\n');
+
+        const keys = Object.keys(arg);
+        const len = keys.length - 1;
+        for (let i: i32 = 0; i <= len; i++) {
+          const x = keys[i];
+
+          printStatic('  ');
+          __Porffor_printString(x);
+
+          printStatic(': ');
+          __Porffor_print(arg[x]);
+
+          if (i != len) printStatic(',\n');
+        }
+
+        printStatic('\n}');
       } else {
         if (colors) printStatic('\x1b[1m'); // bold
         printStatic('null');

package/compiler/builtins/object.ts

@@ -170,6 +170,18 @@ export const __Object_prototype_hasOwnProperty = (_this: any, prop: any) => {
     return Porffor.object.lookup(_this, p) != -1;
   }
 
+  if (t == Porffor.TYPES.function) {
+    let tmp: bytestring = '';
+
+    tmp = 'name';
+    if (p == tmp) return true;
+
+    tmp = 'length';
+    if (p == tmp) return true;
+
+    return false;
+  }
+
   const keys: any[] = __Object_keys(_this);
   return __Array_prototype_includes(keys, p);
 };
@@ -397,12 +409,29 @@ export const __Object_isSealed = (obj: any): any => {
 
 
 export const __Object_getOwnPropertyDescriptor = (obj: any, prop: any): any => {
+  const p: any = ecma262.ToPropertyKey(prop);
+
+  const objType: i32 = Porffor.rawType(obj);
+  if (objType == Porffor.TYPES.function) {
+    // hack: function .name and .length
+    const out: object = {};
+
+    out.writable = false;
+    out.enumerable = false;
+    out.configurable = true;
+
+    const v = obj[p];
+    if (v != null) {
+      out.value = v;
+      return out;
+    }
+  }
+
   // todo: support non-pure-objects
-  if (Porffor.rawType(obj) != Porffor.TYPES.object) {
+  if (objType != Porffor.TYPES.object) {
     return undefined;
   }
 
-  const p: any = ecma262.ToPropertyKey(prop);
   const entryPtr: i32 = Porffor.object.lookup(obj, p);
   if (entryPtr == -1) return undefined;
 

package/compiler/builtins.js

@@ -1,8 +1,10 @@
-import * as GeneratedBuiltins from './generated_builtins.js';
+import * as PrecompiledBuiltins from './builtins_precompiled.js';
+import ObjectBuiltins from './builtins_objects.js';
 import { Blocktype, Opcodes, Valtype, ValtypeSize } from './wasmSpec.js';
 import { number } from './embedding.js';
 import { TYPES, TYPE_NAMES } from './types.js';
 import Prefs from './prefs.js';
+import { unsignedLEB128 } from './encoding.js';
 
 export const importedFuncs = [
   {
@@ -81,11 +83,10 @@ const printStaticStr = str => {
   return out;
 };
 
-// todo: somehow diff between these (undefined != null) while remaining falsey in wasm as a number value
 export const UNDEFINED = 0;
 export const NULL = 0;
 
-export const BuiltinVars = function() {
+export const BuiltinVars = function(ctx) {
   this.undefined = number(UNDEFINED);
   this.undefined.type = TYPES.undefined;
 
@@ -114,7 +115,6 @@ export const BuiltinVars = function() {
 
       this.__Number_MAX_SAFE_INTEGER = this.__Number_MAX_VALUE;
       this.__Number_MIN_SAFE_INTEGER = this.__Number_MIN_VALUE;
-
       break;
 
     case 'i64':
@@ -124,7 +124,6 @@ export const BuiltinVars = function() {
 
       this.__Number_MAX_SAFE_INTEGER = this.__Number_MAX_VALUE;
       this.__Number_MIN_SAFE_INTEGER = this.__Number_MIN_VALUE;
-
       break;
 
     case 'f64':
@@ -135,30 +134,9 @@ export const BuiltinVars = function() {
       this.__Number_MIN_SAFE_INTEGER = number(-9007199254740991);
 
       this.__Number_EPSILON = number(2.220446049250313e-16);
-
-      this.__Math_E = number(Math.E);
-      this.__Math_LN10 = number(Math.LN10);
-      this.__Math_LN2 = number(Math.LN2);
-      this.__Math_LOG10E = number(Math.LOG10E);
-      this.__Math_LOG2E = number(Math.LOG2E);
-      this.__Math_PI = number(Math.PI);
-      this.__Math_SQRT1_2 = number(Math.SQRT1_2);
-      this.__Math_SQRT2 = number(Math.SQRT2);
-
-      // https://github.com/rwaldron/proposal-math-extensions/issues/10
-      this.__Math_RAD_PER_DEG = number(Math.PI / 180);
-      this.__Math_DEG_PER_RAD = number(180 / Math.PI);
-
       break;
   }
 
-  // stubs just so that parent objects exist
-  this.Math = number(1);
-
-  // wintercg(tm)
-  this.__navigator_userAgent = (scope, { makeString }) => makeString(scope, `Porffor/${globalThis.version ?? '0.17.0'}`, false, '__navigator_userAgent');
-  this.__navigator_userAgent.type = Prefs.bytestring ? TYPES.bytestring : TYPES.string;
-
   for (const x in TYPES) {
     this['__Porffor_TYPES_' + x] = number(TYPES[x]);
   }
@@ -176,6 +154,8 @@ export const BuiltinVars = function() {
   this.__Int32Array_BYTES_PER_ELEMENT = number(4);
   this.__Float32Array_BYTES_PER_ELEMENT = number(4);
   this.__Float64Array_BYTES_PER_ELEMENT = number(8);
+
+  ObjectBuiltins.call(this, ctx, Prefs);
 };
 
 export const BuiltinFuncs = function() {
@@ -1089,5 +1069,34 @@ export const BuiltinFuncs = function() {
     ]
   };
 
-  GeneratedBuiltins.BuiltinFuncs.call(this);
+  this.__Porffor_funcLut_length = {
+    params: [ Valtype.i32 ],
+    returns: [ Valtype.i32 ],
+    returnType: TYPES.number,
+    wasm: (scope, { allocPage }) => [
+      [ Opcodes.local_get, 0 ],
+      ...number(128, Valtype.i32),
+      [ Opcodes.i32_mul ],
+      [ Opcodes.i32_load16_u, 0, ...unsignedLEB128(allocPage(scope, 'func lut') * pageSize) ]
+    ],
+    table: true
+  };
+
+  this.__Porffor_funcLut_name = {
+    params: [ Valtype.i32 ],
+    returns: [ Valtype.i32 ],
+    returnType: TYPES.bytestring,
+    wasm: (scope, { allocPage }) => [
+      [ Opcodes.local_get, 0 ],
+      ...number(128, Valtype.i32),
+      [ Opcodes.i32_mul ],
+      ...number(3, Valtype.i32),
+      [ Opcodes.i32_add ],
+      ...number(allocPage(scope, 'func lut') * pageSize, Valtype.i32),
+      [ Opcodes.i32_add ]
+    ],
+    table: true
+  };
+
+  PrecompiledBuiltins.BuiltinFuncs.call(this);
 };

package/compiler/builtins_objects.js

@@ -0,0 +1,181 @@
+import { Opcodes, PageSize, Valtype } from './wasmSpec.js';
+import { TYPES } from './types.js';
+import { number } from './embedding.js';
+
+export default function({ builtinFuncs }, Prefs) {
+  const done = new Set();
+  const object = (name, props) => {
+    done.add(name);
+
+    let cached;
+    this[name] = (scope, { allocPage, makeString, generateIdent, getNodeType, builtin }) => {
+      if (cached) {
+        return number(cached);
+      }
+
+      // todo: precompute bytes here instead of calling real funcs if we really care about perf later
+
+      const page = allocPage(scope, `builtin object: ${name}`);
+      const ptr = page === 0 ? 4 : page * PageSize;
+      cached = ptr;
+
+      const out = [];
+
+      for (const x in props) {
+        const value = {
+          type: 'Identifier',
+          name: '__' + name + '_' + x
+        };
+
+        let flags = 0b0000;
+
+        const d = props[x];
+        if (d.configurable) flags |= 0b0010;
+        if (d.enumerable) flags |= 0b0100;
+        if (d.writable) flags |= 0b1000;
+
+        out.push(
+          ...number(ptr, Valtype.i32),
+          ...number(TYPES.object, Valtype.i32),
+
+          ...makeString(scope, x, false, `#builtin_object_${name}_${x}`),
+          Opcodes.i32_to_u,
+          ...number(TYPES.bytestring, Valtype.i32),
+
+          ...generateIdent(scope, value),
+          ...getNodeType(scope, value),
+
+          ...number(flags, Valtype.i32),
+          ...number(TYPES.number, Valtype.i32),
+
+          [ Opcodes.call, ...builtin('__Porffor_object_define') ],
+          [ Opcodes.drop ],
+          [ Opcodes.drop ]
+        );
+      }
+
+      out.push(...number(ptr));
+      return out;
+    };
+    this[name].type = TYPES.object;
+
+    for (const x in props) {
+      const d = props[x];
+
+      if (d.value) {
+        const k = '__' + name + '_' + x;
+
+        if (typeof d.value === 'number') {
+          this[k] = number(d.value);
+          this[k].type = TYPES.number;
+          continue;
+        }
+
+        if (typeof d.value === 'string') {
+          this[k] = (scope, { makeString }) => makeString(scope, d.value, false, k);
+          this[k].type = TYPES.bytestring;
+          continue;
+        }
+
+        throw new Error(`unsupported value type (${typeof d.value})`);
+      }
+    }
+  };
+
+  const props = (base, vals) => {
+    const out = {};
+
+    if (Array.isArray(vals)) {
+      // array of keys with no value
+      for (const x of vals) {
+        out[x] = {
+          ...base
+        };
+      }
+    } else for (const x in vals) {
+      // object of key values
+      out[x] = {
+        ...base,
+        value: vals[x]
+      };
+    }
+
+    return out;
+  };
+
+  const builtinFuncKeys = Object.keys(builtinFuncs);
+  const autoFuncs = name => builtinFuncKeys.filter(x => x.startsWith('__' + name + '_')).map(x => x.slice(name.length + 3));
+
+  object('Math', {
+    ...props({
+      writable: false,
+      enumerable: false,
+      configurable: false
+    }, {
+      E: Math.E,
+      LN10: Math.LN10,
+      LN2: Math.LN2,
+      LOG10E: Math.LOG10E,
+      LOG2E: Math.LOG2E,
+      PI: Math.PI,
+      SQRT1_2: Math.SQRT1_2,
+      SQRT2: Math.SQRT2,
+
+      // https://github.com/rwaldron/proposal-math-extensions/issues/10
+      RAD_PER_DEG: Math.PI / 180,
+      DEG_PER_RAD: 180 / Math.PI
+    }),
+
+    ...props({
+      writable: true,
+      enumerable: false,
+      configurable: true
+    }, autoFuncs('Math'))
+  });
+
+
+  // todo: support when existing func
+  // object('Number', {
+  //   NaN: NaN,
+  //   POSITIVE_INFINITY: Infinity,
+  //   NEGATIVE_INFINITY: -Infinity,
+
+  //   MAX_VALUE: valtype === 'i32' ? 2147483647 : 1.7976931348623157e+308,
+  //   MIN_VALUE: valtype === 'i32' ? -2147483648 : 5e-324,
+
+  //   MAX_SAFE_INTEGER: valtype === 'i32' ? 2147483647 : 9007199254740991,
+  //   MIN_SAFE_INTEGER: valtype === 'i32' ? -2147483648 : -9007199254740991,
+
+  //   EPSILON: 2.220446049250313e-16
+  // });
+
+
+  // technically not spec compliant as it should be a navigator class but bleh
+  object('navigator', {
+    ...props({
+      writable: false,
+      enumerable: true,
+      configurable: false
+    }, {
+      userAgent: `Porffor/${globalThis.version}`
+    })
+  });
+
+  if (Prefs.logMissingObjects) for (const x of Object.keys(builtinFuncs).concat(Object.keys(this))) {
+    if (!x.startsWith('__')) continue;
+
+    const name = x.split('_').slice(2, -1).join('_').replaceAll('_', '.');
+
+    let t = globalThis;
+    for (const x of name.split('.')) {
+      t = t[x];
+      if (!t) break;
+    }
+    if (!t) continue;
+
+    if (!done.has(name)) {
+      console.log(name);
+      done.add(name);
+    }
+  }
+};