porffor 0.0.0-05f898f

package/compiler/wrap.js

@@ -0,0 +1,130 @@
+import compile from './index.js';
+import decompile from './decompile.js';
+// import fs from 'node:fs';
+
+const bold = x => `\u001b[1m${x}\u001b[0m`;
+
+const typeBase = 0xffffffffffff0;
+const internalTypeBase = 0xfffffffffff0f;
+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'
+};
+
+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 } = compile(source, flags);
+
+  if (source.includes('export function')) flags.push('module');
+
+  // 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`));
+
+  const t2 = performance.now();
+  const { instance } = await WebAssembly.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)),
+      a: c => { if (!Number(c)) throw new Error(`assert failed`); },
+      t: _ => performance.now(),
+      ...customImports
+    }
+  });
+
+  times.push(performance.now() - t2);
+  if (flags.includes('info')) console.log(`instantiated in ${times[1].toFixed(2)}ms`);
+
+  const exports = {};
+
+  const exceptTag = instance.exports['0'], memory = instance.exports['$'];
+  for (const x in instance.exports) {
+    if (x === '0') continue;
+    if (x === '$') {
+      exports.$ = instance.exports.$;
+      continue;
+    }
+
+    const name = x === 'm' ? 'main' : x;
+    const func = funcs.find(x => x.name === name);
+
+    const exp = instance.exports[x];
+    exports[func.name] = exp;
+
+    exports[func.name] = function() {
+      try {
+        const ret = exp.apply(this, arguments);
+
+        if (ret >= typeBase && ret <= typeBase + 8) return ret > (typeBase + 7) ? 'object' : TYPES[ret];
+
+        switch (TYPES[func.returnType]) {
+          case 'boolean': return Boolean(ret);
+          case 'undefined': return undefined;
+          case 'object': return ret === 0 ? null : {};
+
+          case '_array': {
+            const pointer = ret;
+            const length = new Int32Array(memory.buffer, pointer, 1);
+
+            // 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 'function': {
+            // wasm func index, including all imports
+            const func = funcs.find(x => (x.originalIndex ?? x.index) === ret);
+            if (!func) return ret;
+
+            // make fake empty func for repl/etc
+            return {[func.name]() {}}[func.name];
+          }
+
+          default: return ret;
+        }
+      } catch (e) {
+        if (e.is && e.is(exceptTag)) {
+          const exceptId = e.getArg(exceptTag, 0);
+          const exception = exceptions[exceptId];
+
+          const constructorName = exception.constructor;
+
+          // no constructor, just throw message
+          if (!constructorName) throw exception.message;
+
+          const constructor = globalThis[constructorName] ?? eval(`class ${constructorName} extends Error { constructor(message) { super(message); this.name = "${constructorName}"; } }; ${constructorName}`);
+          throw new constructor(exception.message);
+        }
+
+        throw e;
+      }
+    };
+  }
+
+  if (flags.includes('decomp')) {
+    return { exports, wasm, times, decomps: funcs.map(x => decompile(x.wasm, x.name, x.index, x.locals, x.params, x.returns, funcs, globals, exceptions)) };
+  }
+
+  return { exports, wasm, times, pages };
+};

package/hi.c

@@ -0,0 +1,37 @@
+#include <stdio.h>
+
+double inline f64_f(double x, double y) {
+  return x - (int)(x / y) * y;
+}
+
+double isPrime(double number) {
+  double i;
+
+  if (number < 2e+0) {
+    return 0e+0;
+  }
+  i = 2e+0;
+  while (i < number) {
+    if (f64_f(number, i) == 0e+0) {
+      return 0e+0;
+    }
+    i = i + 1e+0;
+  }
+  return 1e+0;
+}
+
+int main() {
+  double sum;
+  double counter;
+
+  sum = 0e+0;
+  counter = 0e+0;
+  while (counter <= 1e+5) {
+    if (isPrime(counter) == 1e+0) {
+      sum = sum + counter;
+    }
+    counter = counter + 1e+0;
+  }
+  printf("%f\n", sum);
+}
+

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "porffor",
+  "description": "a basic experimental wip aot optimizing js -> wasm engine/compiler/runtime in js",
+  "version": "0.0.0-05f898f",
+  "author": "CanadaHonk",
+  "license": "MIT",
+  "dependencies": {
+    "acorn": "^8.9.0"
+  },
+  "bin": {
+    "porf": "./runner/index.js"
+  },
+  "main": "./runner/index.js",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CanadaHonk/porffor.git"
+  },
+  "bugs": {
+    "url": "https://github.com/CanadaHonk/porffor/issues"
+  },
+  "homepage": "https://porffor.goose.icu"
+}

package/porf.cmd

@@ -0,0 +1,2 @@
+@echo off
+node runner %*

package/publish.js

@@ -0,0 +1,13 @@
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+
+const rev = fs.readFileSync('.git/refs/heads/main', 'utf8').trim().slice(0, 7);
+
+const packageJson = fs.readFileSync('package.json', 'utf8');
+fs.writeFileSync('package.json', packageJson.replace('"0.0.0"', `"0.0.0-${rev}"`));
+
+console.log(rev, packageJson);
+
+execSync(`npm publish`, { stdio: 'inherit' });
+
+fs.writeFileSync('package.json', packageJson);

package/r.js

@@ -0,0 +1 @@
+print(performance.now());

package/rhemyn/README.md

@@ -0,0 +1,37 @@
+# rhemyn
+a basic experimental wip regex engine/aot wasm compiler in js. regex engine for porffor. uses own regex parser, no dependencies (excluding porffor internals). <br>
+age: ~1 day
+
+made for use with porffor but could possibly be adapted, implementation/library notes:
+- exposes functions for each regex "operation" (eg test, match)
+- given a regex pattern string (eg `a+`), it returns a "function" object
+- wasm function returned expects an i32 pointer to a utf-16 string (can add utf-8 option later if someone else actually wants to use this)
+
+## syntax
+🟢 supported 🟡 partial 🟠 parsed only 🔴 unsupported
+
+- 🟢 literal characters (eg `a`)
+- 🟢 escaping (eg `\.\n\cJ\x0a\u000a`)
+  - 🟢 character itself (eg `\.`)
+  - 🟢 escape sequences (eg `\n`)
+  - 🟢 control character (eg `\cJ`)
+  - 🟢 unicode code points (eg `\x00`, `\u0000`)
+- 🟢 sets (eg `[ab]`)
+  - 🟢 ranges (eg `[a-z]`)
+  - 🟢 negated sets (eg `[^ab]`)
+- 🟢 metacharacters
+  - 🟢 dot (eg `a.b`)
+  - 🟢 digit, not digit (eg `\d\D`)
+  - 🟢 word, not word (eg `\w\W`)
+  - 🟢 whitespace, not whitespace (eg `\s\S`)
+- 🟠 quantifiers
+  - 🟠 star (eg `a*`)
+  - 🟠 plus (eg `a+`)
+  - 🟠 optional (eg `a?`)
+  - 🟠 lazy modifier (eg `a*?`)
+  - 🔴 n repetitions (eg `a{4}`)
+  - 🔴 n-m repetitions (eg `a{2,4}`)
+- 🔴 assertions
+  - 🔴 beginning (eg `^a`)
+  - 🔴 end (eg `a$`)
+  - 🔴 word boundary assertion (eg `\b\B`)

package/rhemyn/compile.js

@@ -0,0 +1,214 @@
+import { Blocktype, Opcodes, Valtype, PageSize, ValtypeSize } from '../compiler/wasmSpec.js';
+import { number } from '../compiler/embedding.js';
+import { signedLEB128, unsignedLEB128 } from '../compiler/encoding.js';
+import parse from './parse.js';
+
+// local indexes
+const BasePointer = 0; // base string pointer
+const IterPointer = 1; // this iteration base pointer
+const EndPointer = 2; // pointer for the end
+const Counter = 3; // what char we are running on
+const Pointer = 4; // next char BYTE pointer
+const Length = 5;
+const Tmp = 6;
+
+let exprLastGet = false;
+const generate = (node, negated = false, get = true, func = 'test') => {
+  let out = [];
+  switch (node.type) {
+    case 'Expression':
+      exprLastGet = false;
+      out = [
+        // set length local
+        [ Opcodes.local_get, BasePointer ],
+        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128(0) ],
+        [ Opcodes.local_set, Length ],
+
+        // set iter pointer local as base + sizeof i32 initially
+        [ Opcodes.local_get, BasePointer ],
+        ...number(ValtypeSize.i32, Valtype.i32),
+        [ Opcodes.i32_add ],
+        [ Opcodes.local_set, IterPointer ],
+
+        [ Opcodes.loop, Blocktype.void ],
+
+        // reset pointer as iter pointer
+        [ Opcodes.local_get, IterPointer ],
+        [ Opcodes.local_set, Pointer ],
+
+        [ Opcodes.block, Blocktype.void ],
+
+        // generate checks
+        ...node.body.flatMap((x, i) => {
+          exprLastGet = x.type !== 'Group' && i === (node.body.length - 1);
+          return generate(x, negated);
+        }),
+
+        // reached end without branching out, successful match
+        ...({
+          test: number(1, Valtype.i32),
+          search: [
+            [ Opcodes.local_get, Counter ]
+          ]
+        })[func],
+        [ Opcodes.return ],
+
+        [ Opcodes.end ],
+
+        // increment iter pointer by sizeof i16
+        [ Opcodes.local_get, IterPointer ],
+        ...number(ValtypeSize.i16, Valtype.i32),
+        [ Opcodes.i32_add ],
+        [ Opcodes.local_set, IterPointer ],
+
+        // increment counter by 1, check if eq length, if not loop
+        [ Opcodes.local_get, Counter ],
+        ...number(1, Valtype.i32),
+        [ Opcodes.i32_add ],
+        [ Opcodes.local_tee, Counter ],
+
+        [ Opcodes.local_get, Length ],
+        [ Opcodes.i32_ne ],
+
+        [ Opcodes.br_if, 0 ],
+        [ Opcodes.end ],
+
+        // no match, return 0
+        ...number(({
+          test: 0,
+          search: -1
+        })[func], Valtype.i32)
+      ];
+
+      if (globalThis.regexLog) {
+        const underline = x => `\u001b[4m\u001b[1m${x}\u001b[0m`;
+        console.log(`\n${underline('ast')}`);
+        console.log(node);
+        console.log(`\n${underline('wasm bytecode')}\n` + decompile(out) + '\n');
+      }
+
+      break;
+
+    case 'Character':
+      out = generateChar(node, node.negated ^ negated, get);
+      break;
+
+    case 'Set':
+      out = generateSet(node, node.negated, get);
+      break;
+
+    case 'Group':
+      out = generateGroup(node, negated, get);
+      break;
+
+    case 'Range':
+      out = generateRange(node, negated, get);
+      break;
+  }
+
+  return out;
+};
+
+const getNextChar = () => [
+  // get char from pointer
+  [ Opcodes.local_get, Pointer ],
+  [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(0) ],
+
+  ...(exprLastGet ? [] : [
+    // pointer += sizeof i16
+    [ Opcodes.local_get, Pointer ],
+    ...number(ValtypeSize.i16, Valtype.i32),
+    [ Opcodes.i32_add ],
+    [ Opcodes.local_set, Pointer ]
+  ])
+];
+
+const checkFailure = () => [
+  // surely we do not need to do this for every single mismatch, right?
+  /* [ Opcodes.if, Blocktype.void ],
+  ...number(0, Valtype.i32),
+  [ Opcodes.return ],
+  [ Opcodes.end ], */
+
+  [ Opcodes.br_if, 0 ]
+];
+
+const generateChar = (node, negated, get) => {
+  return [
+    ...(get ? getNextChar() : []),
+    ...number(node.char.charCodeAt(0), Valtype.i32),
+    negated ? [ Opcodes.i32_eq ] : [ Opcodes.i32_ne ],
+    ...(get ? checkFailure(): [])
+  ];
+};
+
+const generateSet = (node, negated, get) => {
+  // 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() : []),
+    ...(singleChar ? [] : [ [ Opcodes.local_set, Tmp ] ]),
+  ];
+
+  for (const x of node.body) {
+    out = [
+      ...out,
+      ...(singleChar ? [] : [ [ Opcodes.local_get, Tmp ] ]),
+      ...generate(x, negated, false)
+    ];
+  }
+
+  out = out.concat(new Array(node.body.length - 1).fill(negated ? [ Opcodes.i32_or ] : [ Opcodes.i32_and ]));
+
+  return [
+    ...out,
+    ...checkFailure()
+  ];
+};
+
+const generateRange = (node, negated, get) => {
+  return [
+    ...(get ? getNextChar() : []),
+    ...(get ? [ [ Opcodes.local_tee, Tmp ] ] : []),
+
+    ...number(node.from.charCodeAt(0), Valtype.i32),
+    // negated ? [ Opcodes.i32_lt_s ] : [ Opcodes.i32_ge_s ],
+    negated ? [ Opcodes.i32_ge_s ] : [ Opcodes.i32_lt_s ],
+
+    [ Opcodes.local_get, Tmp ],
+    ...number(node.to.charCodeAt(0), Valtype.i32),
+    // negated ? [ Opcodes.i32_gt_s ] : [ Opcodes.i32_le_s ],
+    negated ? [ Opcodes.i32_le_s ] : [ Opcodes.i32_gt_s ],
+
+    negated ? [ Opcodes.i32_and ] : [ Opcodes.i32_or ],
+    ...(get ? checkFailure(): [])
+  ];
+};
+
+const generateGroup = (node, negated, get) => {
+
+};
+
+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);
+
+const outputFunc = (wasm, name, index) => ({
+  name,
+  index,
+  wasm,
+
+  export: true,
+  params: [ Valtype.i32 ],
+  returns: [ Valtype.i32 ],
+  returnType: 0xffffffffffff1, // boolean - todo: do not hardcode this
+  locals: {
+    basePointer: { idx: 0, type: Valtype.i32 },
+    iterPointer: { idx: 1, type: Valtype.i32 },
+    endPointer: { idx: 2, type: Valtype.i32 },
+    counter: { idx: 3, type: Valtype.i32 },
+    pointer: { idx: 4, type: Valtype.i32 },
+    length: { idx: 5, type: Valtype.i32 },
+    tmp: { idx: 6, type: Valtype.i32 },
+  }
+});