porffor 0.2.0-dcc06c8 → 0.2.0-de394c3

package/compiler/wrap.js

@@ -1,50 +1,45 @@
 import compile from './index.js';
 import decompile from './decompile.js';
 import { encodeVector, encodeLocal } from './encoding.js';
-// import fs from 'node:fs';
+import Prefs from './prefs.js';
+import { log } from './log.js';
+import { TYPES } from './types.js';
 
 const bold = x => `\u001b[1m${x}\u001b[0m`;
 
-const typeBase = 0x00;
-const internalTypeBase = 0x10;
-const TYPES = {
-  [typeBase]: 'number',
-  [typeBase + 1]: 'boolean',
-  [typeBase + 2]: 'string',
-  [typeBase + 3]: 'undefined',
-  [typeBase + 4]: 'object',
-  [typeBase + 5]: 'function',
-  [typeBase + 6]: 'symbol',
-  [typeBase + 7]: 'bigint',
-
-  // internal
-  [internalTypeBase]: '_array',
-  [internalTypeBase + 1]: '_regexp',
-  [internalTypeBase + 2]: '_bytestring'
-};
-
 export default async (source, flags = [ 'module' ], customImports = {}, print = str => process.stdout.write(str)) => {
   const times = [];
 
   const t1 = performance.now();
   const { wasm, funcs, globals, tags, exceptions, pages, c } = compile(source, flags);
 
+  globalThis.porfDebugInfo = { funcs, globals };
+
   if (source.includes('export function')) flags.push('module');
 
-  // fs.writeFileSync('out.wasm', Buffer.from(wasm));
+  // (await import('node:fs')).writeFileSync('out.wasm', Buffer.from(wasm));
 
   times.push(performance.now() - t1);
-  if (flags.includes('info')) console.log(bold(`compiled in ${times[0].toFixed(2)}ms`));
+  if (Prefs.profileCompiler) console.log(bold(`compiled in ${times[0].toFixed(2)}ms`));
 
   const t2 = performance.now();
 
   let instance;
   try {
-    0, { instance } = await WebAssembly.instantiate(wasm, {
+    let wasmEngine = WebAssembly;
+    if (Prefs.asur) {
+      log.warning('wrap', 'using our !experimental! asur wasm engine instead of host to run');
+      wasmEngine = await import('../asur/index.js');
+    }
+
+    0, { instance } = await wasmEngine.instantiate(wasm, {
       '': {
         p: valtype === 'i64' ? i => print(Number(i).toString()) : i => print(i.toString()),
         c: valtype === 'i64' ? i => print(String.fromCharCode(Number(i))) : i => print(String.fromCharCode(i)),
-        t: _ => performance.now(),
+        t: () => performance.now(),
+        u: () => performance.timeOrigin,
+        y: () => {},
+        z: () => {},
         ...customImports
       }
     });
@@ -52,8 +47,10 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
     // only backtrace for runner, not test262/etc
     if (!process.argv[1].includes('/runner')) throw e;
 
-    const funcInd = parseInt(e.message.match(/function #([0-9]+) /)[1]);
-    const blobOffset = parseInt(e.message.split('@')[1]);
+    const funcInd = parseInt(e.message.match(/function #([0-9]+) /)?.[1]);
+    const blobOffset = parseInt(e.message.split('@')?.[1]);
+
+    if (!funcInd) throw e;
 
     // convert blob offset -> function wasm offset.
     // this is not good code and is somewhat duplicated
@@ -131,7 +128,7 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
   }
 
   times.push(performance.now() - t2);
-  if (flags.includes('info')) console.log(`instantiated in ${times[1].toFixed(2)}ms`);
+  if (Prefs.profileCompiler) console.log(`instantiated in ${times[1].toFixed(2)}ms`);
 
   const exports = {};
 
@@ -159,43 +156,50 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
 
         // if (ret >= typeBase && ret <= typeBase + 8) return ret > (typeBase + 7) ? 'object' : TYPES[ret];
 
-        switch (TYPES[type]) {
-          case 'boolean': return Boolean(ret);
-          case 'undefined': return undefined;
-          case 'object': return ret === 0 ? null : {};
+        switch (type) {
+          case TYPES.boolean: return Boolean(ret);
+          case TYPES.undefined: return undefined;
+          case TYPES.object: return ret === 0 ? null : {};
 
-          case '_array': {
+          case TYPES.string: {
             const pointer = ret;
-            const length = new Int32Array(memory.buffer, pointer, 1);
+            const length = (new Int32Array(memory.buffer, pointer, 1))[0];
 
-            // have to slice because of memory alignment
-            const buf = memory.buffer.slice(pointer + 4, pointer + 4 + 8 * length);
+            return Array.from(new Uint16Array(memory.buffer, pointer + 4, length)).map(x => String.fromCharCode(x)).join('');
+          }
 
-            return Array.from(new Float64Array(buf));
+          case TYPES.function: {
+            // wasm func index, including all imports
+            const func = funcs.find(x => (x.originalIndex ?? x.index) === ret);
+            // if (!func) return ret;
+            if (!func) return function () {};
+
+            // make fake empty func for repl/etc
+            return {[func.name]() {}}[func.name];
           }
 
-          case 'string': {
+          case TYPES._array: {
             const pointer = ret;
-            const length = new Int32Array(memory.buffer, pointer, 1);
+            const length = (new Int32Array(memory.buffer, pointer, 1))[0];
 
-            return Array.from(new Uint16Array(memory.buffer, pointer + 4, length)).map(x => String.fromCharCode(x)).join('');
+            // have to slice because of memory alignment
+            const buf = memory.buffer.slice(pointer + 4, pointer + 4 + 8 * length);
+
+            return Array.from(new Float64Array(buf));
           }
 
-          case '_bytestring': {
+          case TYPES._bytestring: {
             const pointer = ret;
-            const length = new Int32Array(memory.buffer, pointer, 1);
+            const length = (new Int32Array(memory.buffer, pointer, 1))[0];
 
             return Array.from(new Uint8Array(memory.buffer, pointer + 4, length)).map(x => String.fromCharCode(x)).join('');
           }
 
-          case 'function': {
-            // wasm func index, including all imports
-            const func = funcs.find(x => (x.originalIndex ?? x.index) === ret);
-            // if (!func) return ret;
-            if (!func) return function () {};
+          case TYPES._date: {
+            const pointer = ret;
+            const value = (new Float64Array(memory.buffer, pointer, 1))[0];
 
-            // make fake empty func for repl/etc
-            return {[func.name]() {}}[func.name];
+            return new Date(value);
           }
 
           default: return ret;

package/fib.js

@@ -0,0 +1,7 @@
+export const fib = n => {
+  if (n < 2) {
+    return n;
+  } else {
+    return fib(n - 1) + fib(n - 2);
+  }
+};

package/package.json

@@ -1,21 +1,25 @@
 {
   "name": "porffor",
   "description": "a basic experimental wip aot optimizing js -> wasm engine/compiler/runtime in js",
-  "version": "0.2.0-dcc06c8",
+  "version": "0.2.0-de394c3",
   "author": "CanadaHonk",
   "license": "MIT",
+  "scripts": {
+    "precompile": "node ./compiler/precompile.js"
+  },
   "dependencies": {
-    "acorn": "^8.9.0"
+    "acorn": "^8.11.3",
+    "node-repl-polyfill": "^0.1.1"
   },
   "optionalDependencies": {
-    "@babel/parser": "^7.23.6",
+    "@babel/parser": "^7.24.4",
     "hermes-parser": "^0.18.2",
     "meriyah": "^4.3.9"
   },
   "bin": {
     "porf": "./runner/index.js"
   },
-  "main": "./runner/index.js",
+  "main": "./compiler/wrap.js",
   "type": "module",
   "repository": {
     "type": "git",
@@ -25,4 +29,4 @@
     "url": "https://github.com/CanadaHonk/porffor/issues"
   },
   "homepage": "https://porffor.goose.icu"
-}
+}

package/porf

@@ -1,2 +1,4 @@
 #!/bin/sh
 node runner/index.js "$@"
+# deno run -A runner/index.js "$@"
+# bun runner/index.js "$@"

package/rhemyn/compile.js

@@ -160,7 +160,7 @@ const generateSet = (node, negated, get) => {
     ];
   }
 
-  out = out.concat(new Array(node.body.length - 1).fill(negated ? [ Opcodes.i32_or ] : [ Opcodes.i32_and ]));
+  if (node.body.length > 0) out = out.concat(new Array(node.body.length - 1).fill(negated ? [ Opcodes.i32_or ] : [ Opcodes.i32_and ]));
 
   return [
     ...out,
@@ -188,7 +188,8 @@ const generateRange = (node, negated, get) => {
 };
 
 const generateGroup = (node, negated, get) => {
-
+  // todo
+  return [];
 };
 
 export const test = (regex, index = 0, name = 'regex_test_' + regex) => outputFunc(generate(parse(regex), false, true, 'test'), name, index);