porffor 0.20.6 → 0.20.8

package/compiler/precompile.js

@@ -1,4 +1,4 @@
-import { Opcodes } from './wasmSpec.js';
+import { Opcodes, Valtype } from './wasmSpec.js';
 import { read_unsignedLEB128 } from './encoding.js';
 import { TYPES } from './types.js';
 
@@ -41,6 +41,15 @@ const compile = async (file, _funcs) => {
     return acc;
   }, {});
 
+  const returnOverrides = {
+    __Porffor_object_get: [ Valtype.f64, Valtype.i32 ],
+    __Porffor_object_set: [ Valtype.f64, Valtype.i32 ]
+  };
+
+  const paramOverrides = {
+    __Porffor_object_set: [ Valtype.i32, Valtype.i32, Valtype.i32, Valtype.i32, Valtype.f64, Valtype.i32 ],
+  };
+
   const main = funcs.find(x => x.name === 'main');
   const exports = funcs.filter(x => x.export && x.name !== 'main');
   for (const x of exports) {
@@ -59,6 +68,9 @@ const compile = async (file, _funcs) => {
       }).filter(x => x);
     }
 
+    if (returnOverrides[x.name]) x.returns = returnOverrides[x.name];
+    if (paramOverrides[x.name]) x.params = paramOverrides[x.name];
+
     const rewriteWasm = (x, wasm, rewriteLocals = false) => {
       const locals = Object.keys(x.locals).reduce((acc, y) => {
         acc[x.locals[y].idx] = { ...x.locals[y], name: y };

package/compiler/types.js

@@ -1,26 +1,22 @@
-export const TYPES = {
-  empty: 0x00,
-  number: 0x01,
-  boolean: 0x02,
-  string: 0x03,
-  undefined: 0x04,
-  object: 0x05,
-  function: 0x06,
-  symbol: 0x07,
-  bigint: 0x08
-};
+import Prefs from './prefs.js';
 
-// flags
 export const TYPE_FLAGS = {
-  // iterable:  0b10000000,
   parity:    0b10000000,
   length:    0b01000000,
 };
 
-// TYPES.string |= TYPE_FLAGS.iterable;
-TYPES.string |= TYPE_FLAGS.length;
+export const TYPES = {
+  empty: 0x00,
+  number: 0x01,
+  boolean: 0x02,
+  string: 0x03 | TYPE_FLAGS.length,
+  bigint: 0x04,
+  symbol: 0x05,
+  function: 0x06,
+  object: 0x07,
 
-TYPES.undefined = TYPES.empty | TYPE_FLAGS.parity;
+  undefined: 0x00 | TYPE_FLAGS.parity,
+};
 
 export const TYPE_NAMES = {
   [TYPES.empty]: 'empty',
@@ -74,4 +70,23 @@ registerInternalType('Float64Array', ['iterable', 'length']);
 
 registerInternalType('WeakRef');
 registerInternalType('WeakSet');
-registerInternalType('WeakMap');
+registerInternalType('WeakMap');
+
+if (Prefs.largestTypes) {
+  const typeKeys = Object.keys(TYPES);
+  const typeVals = Object.values(TYPES);
+
+  const largestType = (vals, keys) => {
+    const val = Math.max(...vals);
+    const key = keys[vals.indexOf(val)];
+    return [ val, key ];
+  };
+
+  const unflag = val => val & 0b00111111;
+
+  const logType = (label, val, key) => console.log(`${label}    ${key} - ${val} (0x${val.toString(16)}, 0b${val.toString(2).padStart(8, '0')})`);
+
+  logType(`largest type:         `, ...largestType(typeVals.map(unflag), typeKeys));
+  logType(`largest type w/ flags:`, ...largestType(typeVals, typeKeys));
+  console.log();
+}

package/compiler/wrap.js

@@ -45,23 +45,37 @@ const porfToJSValue = ({ memory, funcs, pages }, value, type) => {
     case TYPES.object: {
       if (value === 0 || checkOOB(memory, value)) return null;
 
-      const [ keysPtr, valsPtr ] = read(Uint32Array, memory, value, 2);
-      if (checkOOB(memory, keysPtr) || checkOOB(memory, valsPtr)) return null;
-
-      const size = read(Uint32Array, memory, keysPtr, 1);
+      const size = read(Uint32Array, memory, value, 1)[0];
 
       const out = {};
       for (let i = 0; i < size; i++) {
-        const offset = 4 + (i * 9);
+        const offset = 4 + (i * 14);
 
-        const kValue = read(Float64Array, memory, keysPtr + offset, 1)[0];
-        const kType = read(Uint8Array, memory, keysPtr + offset + 8, 1)[0];
+        const kRaw = read(Uint32Array, memory, value + offset, 1)[0];
+        const kType = kRaw >>> 31 ? TYPES.string : TYPES.bytestring;
+        const kValue = kRaw & 0x7fffffff;
         const k = porfToJSValue({ memory, funcs, pages }, kValue, kType);
 
-        const vValue = read(Float64Array, memory, valsPtr + offset, 1)[0];
-        const vType = read(Uint8Array, memory, valsPtr + offset + 8, 1)[0];
+        const tail = read(Uint16Array, memory, value + offset + 12, 1)[0];
+
+        const vValue = read(Float64Array, memory, value + offset + 4, 1)[0];
+        const vType = tail >>> 8;
         const v = porfToJSValue({ memory, funcs, pages }, vValue, vType);
 
+        const flags = tail & 0xff;
+
+        if (Prefs.d) {
+          console.log(`\x1b[4m\x1b[1m${k}\x1b[0m \x1B[90m(${TYPE_NAMES[kType]})\x1B[0m
+  value: \x1B[92m${v}\x1B[0m \x1B[90m(${TYPE_NAMES[vType]})\x1B[0m
+  flags: 0b\x1B[93m${flags.toString(2)}\x1B[0m\x1B[90m
+    accessor: ${!!(flags & 0b0001)}
+    configurable: ${!!(flags & 0b0010)}
+    enumerable: ${!!(flags & 0b0100)}
+    writable: ${!!(flags & 0b1000)}
+\x1B[0m`);
+        }
+
+        // todo: use object.defineproperty
         out[k] = v;
       }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "porffor",
   "description": "a basic experimental wip aot optimizing js -> wasm engine/compiler/runtime in js",
-  "version": "0.20.6+c859e2f26",
+  "version": "0.20.8+6cd20b620",
   "author": "CanadaHonk",
   "license": "MIT",
   "scripts": {},

package/runner/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
-globalThis.version = '0.20.6+c859e2f26';
+globalThis.version = '0.20.8+6cd20b620';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {