porffor 0.2.0-6aff0fa → 0.2.0-6bc63ef

package/compiler/wrap.js

@@ -1,27 +1,74 @@
 import compile from './index.js';
 import decompile from './decompile.js';
 import { encodeVector, encodeLocal } from './encoding.js';
-import Prefs from './prefs.js';
+import { TYPES } from './types.js';
 import { log } from './log.js';
+import Prefs from './prefs.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'
+const porfToJSValue = (memory, funcs, value, type) => {
+  switch (type) {
+    case TYPES.boolean: return Boolean(value);
+    case TYPES.undefined: return undefined;
+    case TYPES.object: return value === 0 ? null : {};
+
+    case TYPES.function: {
+      // wasm func index, including all imports
+      const func = funcs.find(x => (x.originalIndex ?? x.index) === value);
+      // if (!func) return value;
+      if (!func) return function () {};
+
+      // make fake empty func for repl/etc
+      return {[func.name]() {}}[func.name];
+    }
+
+    case TYPES.string: {
+      const length = (new Int32Array(memory.buffer, value, 1))[0];
+      return Array.from(new Uint16Array(memory.buffer, value + 4, length)).map(x => String.fromCharCode(x)).join('');
+    }
+
+    case TYPES.bytestring: {
+      const length = (new Int32Array(memory.buffer, value, 1))[0];
+      return Array.from(new Uint8Array(memory.buffer, value + 4, length)).map(x => String.fromCharCode(x)).join('');
+    }
+
+    case TYPES.array: {
+      const length = (new Int32Array(memory.buffer, value, 1))[0];
+
+      // have to slice because of memory alignment (?)
+      const buf = memory.buffer.slice(value + 4, value + 4 + 8 * length);
+      return Array.from(new Float64Array(buf, 0, length));
+    }
+
+    case TYPES.date: {
+      const t = (new Float64Array(memory.buffer, value, 1))[0];
+      return new Date(t);
+    }
+
+    case TYPES.set: {
+      const size = (new Int32Array(memory.buffer, value, 1))[0];
+
+      const out = new Set();
+      for (let i = 0; i < size; i++) {
+        const offset = value + 4 + (i * 9);
+
+        // have to slice because of memory alignment (?)
+        const v = (new Float64Array(memory.buffer.slice(offset, offset + 8), 0, 1))[0];
+        const t = (new Uint8Array(memory.buffer, offset + 8, 1))[0];
+
+        // console.log(`reading value at index ${i}...`)
+        // console.log('  memory:', Array.from(new Uint8Array(memory.buffer, offset, 9)).map(x => x.toString(16).padStart(2, '0')).join(' '));
+        // console.log('  read:', { value: v, type: t }, '\n');
+
+        out.add(porfToJSValue(memory, funcs, v, t));
+      }
+
+      return out;
+    }
+
+    default: return value;
+  }
 };
 
 export default async (source, flags = [ 'module' ], customImports = {}, print = str => process.stdout.write(str)) => {
@@ -30,12 +77,14 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
   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');
 
   // (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();
 
@@ -51,7 +100,10 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
       '': {
         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
       }
     });
@@ -59,8 +111,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
@@ -138,7 +192,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 = {};
 
@@ -158,55 +212,11 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
 
     exports[func.name] = function() {
       try {
-        const _ret = exp.apply(this, arguments);
-
-        if (_ret == null) return undefined;
-
-        const [ ret, type ] = _ret;
-
-        // 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 : {};
+        const ret = exp.apply(this, arguments);
 
-          case '_array': {
-            const pointer = ret;
-            const length = new Int32Array(memory.buffer, pointer, 1);
+        if (ret == null) return undefined;
 
-            // 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 'string': {
-            const pointer = ret;
-            const length = new Int32Array(memory.buffer, pointer, 1);
-
-            return Array.from(new Uint16Array(memory.buffer, pointer + 4, length)).map(x => String.fromCharCode(x)).join('');
-          }
-
-          case '_bytestring': {
-            const pointer = ret;
-            const length = new Int32Array(memory.buffer, pointer, 1);
-
-            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 () {};
-
-            // make fake empty func for repl/etc
-            return {[func.name]() {}}[func.name];
-          }
-
-          default: return ret;
-        }
+        return porfToJSValue(memory, funcs, ret[0], ret[1])
       } catch (e) {
         if (e.is && e.is(exceptTag)) {
           const exceptId = e.getArg(exceptTag, 0);

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-6aff0fa",
+  "version": "0.2.0-6bc63ef",
   "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

@@ -1,8 +1,8 @@
-import { Blocktype, Opcodes, Valtype, PageSize, ValtypeSize } from '../compiler/wasmSpec.js';
+import { Blocktype, Opcodes, Valtype, ValtypeSize } from '../compiler/wasmSpec.js';
 import { number } from '../compiler/embedding.js';
-import { signedLEB128, unsignedLEB128 } from '../compiler/encoding.js';
 import parse from './parse.js';
 import Prefs from '../compiler/prefs.js';
+import { TYPES } from '../compiler/types.js';
 
 // local indexes
 const BasePointer = 0; // base string pointer
@@ -14,7 +14,7 @@ const Length = 5;
 const Tmp = 6;
 
 let exprLastGet = false;
-const generate = (node, negated = false, get = true, func = 'test') => {
+const generate = (node, negated = false, get = true, stringSize = 2, func = 'test') => {
   let out = [];
   switch (node.type) {
     case 'Expression':
@@ -42,7 +42,7 @@ const generate = (node, negated = false, get = true, func = 'test') => {
         // generate checks
         ...node.body.flatMap((x, i) => {
           exprLastGet = x.type !== 'Group' && i === (node.body.length - 1);
-          return generate(x, negated);
+          return generate(x, negated, true, stringSize, func);
         }),
 
         // reached end without branching out, successful match
@@ -56,9 +56,9 @@ const generate = (node, negated = false, get = true, func = 'test') => {
 
         [ Opcodes.end ],
 
-        // increment iter pointer by sizeof i16
+        // increment iter pointer by string size
         [ Opcodes.local_get, IterPointer ],
-        ...number(ValtypeSize.i16, Valtype.i32),
+        ...number(stringSize, Valtype.i32),
         [ Opcodes.i32_add ],
         [ Opcodes.local_set, IterPointer ],
 
@@ -91,34 +91,34 @@ const generate = (node, negated = false, get = true, func = 'test') => {
       break;
 
     case 'Character':
-      out = generateChar(node, node.negated ^ negated, get);
+      out = generateChar(node, node.negated ^ negated, get, stringSize);
       break;
 
     case 'Set':
-      out = generateSet(node, node.negated, get);
+      out = generateSet(node, node.negated, get, stringSize);
       break;
 
     case 'Group':
-      out = generateGroup(node, negated, get);
+      out = generateGroup(node, negated, get, stringSize);
       break;
 
     case 'Range':
-      out = generateRange(node, negated, get);
+      out = generateRange(node, negated, get, stringSize);
       break;
   }
 
   return out;
 };
 
-const getNextChar = () => [
+const getNextChar = (stringSize) => [
   // get char from pointer
   [ Opcodes.local_get, Pointer ],
-  [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(0) ],
+  [ stringSize == 2 ? Opcodes.i32_load16_u : Opcodes.i32_load8_u, 0, 0 ],
 
   ...(exprLastGet ? [] : [
-    // pointer += sizeof i16
+    // pointer += string size
     [ Opcodes.local_get, Pointer ],
-    ...number(ValtypeSize.i16, Valtype.i32),
+    ...number(stringSize, Valtype.i32),
     [ Opcodes.i32_add ],
     [ Opcodes.local_set, Pointer ]
   ])
@@ -134,21 +134,21 @@ const checkFailure = () => [
   [ Opcodes.br_if, 0 ]
 ];
 
-const generateChar = (node, negated, get) => {
+const generateChar = (node, negated, get, stringSize) => {
   return [
-    ...(get ? getNextChar() : []),
+    ...(get ? getNextChar(stringSize) : []),
     ...number(node.char.charCodeAt(0), Valtype.i32),
     negated ? [ Opcodes.i32_eq ] : [ Opcodes.i32_ne ],
     ...(get ? checkFailure(): [])
   ];
 };
 
-const generateSet = (node, negated, get) => {
+const generateSet = (node, negated, get, stringSize) => {
   // for a single char we do not need a tmp, it is like just
   const singleChar = node.body.length === 1 && node.body[0].type === 'Character';
 
   let out = [
-    ...(get ? getNextChar() : []),
+    ...(get ? getNextChar(stringSize) : []),
     ...(singleChar ? [] : [ [ Opcodes.local_set, Tmp ] ]),
   ];
 
@@ -156,11 +156,11 @@ const generateSet = (node, negated, get) => {
     out = [
       ...out,
       ...(singleChar ? [] : [ [ Opcodes.local_get, Tmp ] ]),
-      ...generate(x, negated, false)
+      ...generate(x, negated, false, stringSize)
     ];
   }
 
-  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,
@@ -168,9 +168,9 @@ const generateSet = (node, negated, get) => {
   ];
 };
 
-const generateRange = (node, negated, get) => {
+const generateRange = (node, negated, get, stringSize) => {
   return [
-    ...(get ? getNextChar() : []),
+    ...(get ? getNextChar(stringSize) : []),
     ...(get ? [ [ Opcodes.local_tee, Tmp ] ] : []),
 
     ...number(node.from.charCodeAt(0), Valtype.i32),
@@ -188,11 +188,29 @@ const generateRange = (node, negated, get) => {
 };
 
 const generateGroup = (node, negated, get) => {
+  // todo
+  return [];
+};
 
+const wrapFunc = (regex, func, name, index) => {
+  const parsed = parse(regex);
+
+  return outputFunc([
+    [ Opcodes.local_get, 1 ],
+    ...number(TYPES.string, Valtype.i32),
+    [ Opcodes.i32_eq ],
+    [ Opcodes.if, Valtype.i32 ],
+    // string
+    ...generate(parsed, false, true, 2, func),
+    [ Opcodes.else ],
+    // bytestring
+    ...generate(parsed, false, true, 1, func),
+    [ Opcodes.end ]
+  ], name, index);
 };
 
-export const test = (regex, index = 0, name = 'regex_test_' + regex) => outputFunc(generate(parse(regex), false, true, 'test'), name, index);
-export const search = (regex, index = 0, name = 'regex_search_' + regex) => outputFunc(generate(parse(regex), false, true, 'search'), name, index);
+export const test = (regex, index = 0, name = 'regex_test_' + regex) => wrapFunc(regex, 'test', name, index);
+export const search = (regex, index = 0, name = 'regex_search_' + regex) => wrapFunc(regex, 'search', name, index);
 
 const outputFunc = (wasm, name, index) => ({
   name,
@@ -200,9 +218,9 @@ const outputFunc = (wasm, name, index) => ({
   wasm,
 
   export: true,
-  params: [ Valtype.i32 ],
+  params: [ Valtype.i32, Valtype.i32 ],
   returns: [ Valtype.i32 ],
-  returnType: 0xffffffffffff1, // boolean - todo: do not hardcode this
+  returnType: TYPES.boolean,
   locals: {
     basePointer: { idx: 0, type: Valtype.i32 },
     iterPointer: { idx: 1, type: Valtype.i32 },