porffor 0.17.0-f43ba190c → 0.18.3

package/compiler/index.js

@@ -89,6 +89,7 @@ export default (code, flags) => {
 
         console.log(`${x.name}: ${preOps} -> ${x.wasm.length} ops`);
       }
+      opt(funcs, globals, pages, tags, exceptions);
 
       console.log(`cyclone total time: ${(performance.now() - t).toFixed(2)}ms`);
 

package/compiler/opt.js

@@ -114,8 +114,6 @@ export default (funcs, globals, pages, tags, exceptions) => {
     while (runs > 0) {
       runs--;
 
-      let depth = [];
-
       let getCount = {}, setCount = {};
       for (const x in f.locals) {
         getCount[f.locals[x].idx] = 0;
@@ -128,9 +126,6 @@ export default (funcs, globals, pages, tags, exceptions) => {
         inst = [ ...inst ];
         wasm[i] = inst;
 
-        if (inst[0] === Opcodes.if || inst[0] === Opcodes.loop || inst[0] === Opcodes.block) depth.push(inst[0]);
-        if (inst[0] === Opcodes.end) depth.pop();
-
         if (inst[0] === Opcodes.local_get) getCount[inst[1]]++;
         if (inst[0] === Opcodes.local_set || inst[0] === Opcodes.local_tee) setCount[inst[1]]++;
 
@@ -203,6 +198,9 @@ export default (funcs, globals, pages, tags, exceptions) => {
           if (type === 'Array') missing = !pages.hasArray;
           if (type === 'String') missing = !pages.hasString;
           if (type === 'ByteString') missing = !pages.hasByteString;
+          if (['Set', 'Uint8Array', 'Int8Array', 'Uint8ClampedArray', 'Uint16Array', 'Int16Array', 'Uint32Array', 'Int32Array', 'Float32Array', 'Float64Array'].includes(type)) {
+            missing = funcs.find(x => x.name === type) == null;
+          }
 
           if (missing) {
             let j = i, depth = 0;

package/compiler/precompile.js

@@ -6,6 +6,8 @@ import { join } from 'node:path';
 
 import { fileURLToPath } from 'node:url';
 const __dirname = fileURLToPath(new URL('.', import.meta.url));
+globalThis.precompileCompilerPath = __dirname;
+globalThis.precompile = true;
 
 const argv = process.argv.slice();
 
@@ -14,7 +16,7 @@ const compile = async (file, [ _funcs, _globals ]) => {
   let first = source.slice(0, source.indexOf('\n'));
 
   if (first.startsWith('export default')) {
-    source = (await import(file)).default();
+    source = await (await import(file)).default();
     first = source.slice(0, source.indexOf('\n'));
   }
 
@@ -117,7 +119,7 @@ ${funcs.map(x => {
     locals: ${JSON.stringify(Object.values(x.locals).slice(x.params.length).map(x => x.type))},
     localNames: ${JSON.stringify(Object.keys(x.locals))},
 ${x.data && x.data.length > 0 ? `    data: ${JSON.stringify(x.data)},` : ''}
-${x.table ? `    table: true` : ''}
+${x.table ? `    table: true,` : ''}${x.constr ? `    constr: true,` : ''}
   };`.replaceAll('\n\n', '\n').replaceAll('\n\n', '\n').replaceAll('\n\n', '\n');
 }).join('\n')}
 };`;

package/compiler/prototype.js

@@ -208,72 +208,6 @@ export const PrototypeFuncs = function() {
       //   ...number(1, Valtype.i32),
       //   [ Opcodes.i32_sub ]
       // ]),
-    ],
-
-    fill: (pointer, length, wElement, wType, iTmp, iTmp2) => [
-      ...wElement,
-      [ Opcodes.local_set, iTmp ],
-
-      // use cached length i32 as pointer
-      ...length.getCachedI32(),
-
-      // length - 1 for indexes
-      ...number(1, Valtype.i32),
-      [ Opcodes.i32_sub ],
-
-      // * sizeof value
-      ...number(ValtypeSize[valtype] + 1, Valtype.i32),
-      [ Opcodes.i32_mul ],
-
-      ...length.setCachedI32(),
-
-      ...(noUnlikelyChecks ? [] : [
-        ...length.getCachedI32(),
-        ...number(0, Valtype.i32),
-        [ Opcodes.i32_lt_s ],
-        [ Opcodes.if, Blocktype.void ],
-        ...pointer,
-        Opcodes.i32_from_u,
-        [ Opcodes.br, 1 ],
-        [ Opcodes.end ]
-      ]),
-
-      [ Opcodes.loop, Blocktype.void ],
-
-      // calculate offset
-      ...length.getCachedI32(),
-      ...pointer,
-      [ Opcodes.i32_add ],
-      [ Opcodes.local_set, iTmp2 ],
-
-      // store value
-      [ Opcodes.local_get, iTmp2 ],
-      [ Opcodes.local_get, iTmp ],
-      [ Opcodes.store, 0, ValtypeSize.i32 ],
-
-      // store type
-      [ Opcodes.local_get, iTmp2 ],
-      ...wType,
-      [ Opcodes.i32_store8, 0, ValtypeSize.i32 + ValtypeSize[valtype] ],
-
-      // pointer - sizeof value
-      ...length.getCachedI32(),
-      ...number(ValtypeSize[valtype] + 1, Valtype.i32),
-      [ Opcodes.i32_sub ],
-
-      ...length.setCachedI32(),
-
-      // if pointer >= 0, loop
-      ...length.getCachedI32(),
-      ...number(0, Valtype.i32),
-      [ Opcodes.i32_ge_s ],
-      [ Opcodes.br_if, 0 ],
-
-      [ Opcodes.end ],
-
-      // return this array
-      ...pointer,
-      Opcodes.i32_from_u,
     ]
   };
 
@@ -282,9 +216,6 @@ export const PrototypeFuncs = function() {
   this[TYPES.array].push.noArgRetLength = true;
   this[TYPES.array].push.local = Valtype.i32;
   this[TYPES.array].pop.local = Valtype.i32;
-  this[TYPES.array].fill.local = valtypeBinary;
-  this[TYPES.array].fill.local2 = Valtype.i32;
-  this[TYPES.array].fill.returnType = TYPES.array;
 
   this[TYPES.string] = {
     at: (pointer, length, wIndex, wType, iTmp, _, arrayShell) => {

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.17.0-f43ba190c",
+  "version": "0.18.3+945765df9",
   "author": "CanadaHonk",
   "license": "MIT",
   "scripts": {},

package/rhemyn/README.md

@@ -24,13 +24,16 @@ Made for use with Porffor but could possibly be adapted, implementation/library
   - 🟢 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?`)
+- 🟡 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}`)
+- 🟠 groups
+  - 🟠 capturing groups (`(a)`)
+  - 🔴 non-capturing groups (`(?:a)`)
 - 🔴 assertions
   - 🔴 beginning (eg `^a`)
   - 🔴 end (eg `a$`)

package/rhemyn/compile.js

@@ -6,75 +6,78 @@ import { TYPES } from '../compiler/types.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 Counter = 2; // what char we are running on
+const Pointer = 3; // next char pointer
+const Length = 4;
+const Tmp = 5;
+const QuantifierTmp = 6; // the temporary variable used for quanitifers
+
+const doesSucceedZero = (node) => {
+  for (const n of node.body) {
+    if (n.type === "Group") {
+      if (!doesSucceedZero(node)) return false;
+    }
+    if (!n.quantifier || n.quantifier[0] > 0) {
+      return false;
+    }
+  }
+  return true;
+}
+
 const generate = (node, negated = false, get = true, stringSize = 2, func = 'test') => {
   let out = [];
   switch (node.type) {
     case 'Expression':
-      exprLastGet = false;
+      let succeedsZero = doesSucceedZero(node);
+
       out = [
         // set length local
         [ Opcodes.local_get, BasePointer ],
         [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
-        [ Opcodes.local_set, Length ],
+        [ Opcodes.local_tee, Length ],
 
-        // set iter pointer local as base + sizeof i32 initially
+        ...number(0, Valtype.i32),
+        [ Opcodes.i32_eq ],
+        [ Opcodes.if, Blocktype.void ],
+          ...number(succeedsZero ? 1 : 0, Valtype.i32),
+          [ Opcodes.return ],
+        [ Opcodes.end ],
+
+        // pointer = base + sizeof i32
         [ 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, true, stringSize, func);
-        }),
-
-        // 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 string size
-        [ Opcodes.local_get, IterPointer ],
-        ...number(stringSize, 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.loop, Blocktype.void ],
+          [ Opcodes.block, Blocktype.void ],
+            // generate checks
+            ...node.body.flatMap(x => generate(x, negated, true, stringSize, func)),
+
+            // reached end without branching out, successful match
+            ...({
+              test: number(1, Valtype.i32),
+              search: [
+                [ Opcodes.local_get, Counter ]
+              ]
+            })[func],
+            [ Opcodes.return ],
+          [ Opcodes.end ],
+
+          // counter++, if length > counter, loop
+          [ Opcodes.local_get, Length ],
+
+          [ Opcodes.local_get, Counter ],
+          ...number(1, Valtype.i32),
+          [ Opcodes.i32_add ],
+          [ Opcodes.local_tee, Counter ],
+
+          [ Opcodes.i32_gt_s ],
+
+          [ Opcodes.br_if, 0 ],
         [ Opcodes.end ],
 
-        // no match, return 0
+        // no match
         ...number(({
           test: 0,
           search: -1
@@ -110,12 +113,12 @@ const generate = (node, negated = false, get = true, stringSize = 2, func = 'tes
   return out;
 };
 
-const getNextChar = (stringSize) => [
+const getNextChar = (stringSize, peek = false) => [
   // get char from pointer
   [ Opcodes.local_get, Pointer ],
   [ stringSize == 2 ? Opcodes.i32_load16_u : Opcodes.i32_load8_u, 0, 0 ],
 
-  ...(exprLastGet ? [] : [
+  ...(peek ? [] : [
     // pointer += string size
     [ Opcodes.local_get, Pointer ],
     ...number(stringSize, Valtype.i32),
@@ -134,37 +137,123 @@ const checkFailure = () => [
   [ Opcodes.br_if, 0 ]
 ];
 
-const generateChar = (node, negated, get, stringSize) => {
+const wrapQuantifier = (node, method, get, stringSize) => {
+  const [ min, max ] = node.quantifier;
   return [
-    ...(get ? getNextChar(stringSize) : []),
+    // initalize our temp value (number of matched characters)
+    ...number(0, Valtype.i32),
+    [Opcodes.local_set, QuantifierTmp],
+
+    // if len - counter == 0, if min == 0, succeed, else fail
+    [ Opcodes.local_get, Length ],
+    [ Opcodes.local_get, Counter ],
+    [ Opcodes.i32_sub ],
+    ...number(0, Valtype.i32),
+    [ Opcodes.i32_eq ],
+    ...(min == 0 ? [
+      [ Opcodes.if, Blocktype.void ],
+    ] : [
+      [ Opcodes.br_if, 0 ],
+    ]),
+
+    // start loop
+    [Opcodes.loop, Blocktype.void],
+      [ Opcodes.block, Blocktype.void ],
+        // if counter + tmp == length, break
+        [ Opcodes.local_get, Counter ],
+        [ Opcodes.local_get, QuantifierTmp ],
+        [ Opcodes.i32_add ],
+        [ Opcodes.local_get, Length ],
+        [ Opcodes.i32_eq ],
+        [ Opcodes.br_if, 0 ],
+
+        // if doesn't match, break
+        ...method,
+        [Opcodes.br_if, 0 ],
+        ...(get ? [
+          // pointer += stringSize
+          [ Opcodes.local_get, Pointer ],
+          ...number(stringSize, Valtype.i32),
+          [ Opcodes.i32_add ],
+          [ Opcodes.local_set, Pointer ]
+        ] : []),
+
+        // if maximum was reached, break
+        ...(max ? [
+          [ Opcodes.local_get, QuantifierTmp ],
+          ...number(max, Valtype.i32),
+          [ Opcodes.i32_eq ],
+          [ Opcodes.br_if, 0 ]
+        ] : []),
+
+        [ Opcodes.local_get, QuantifierTmp ],
+        ...number(1, Valtype.i32),
+        [ Opcodes.i32_add ],
+        [ Opcodes.local_set, QuantifierTmp ],
+        [ Opcodes.br, 1 ],
+      [ Opcodes.end ],
+    [ Opcodes.end ],
+
+    // if less than minimum, fail
+    [Opcodes.local_get, QuantifierTmp],
+    ...number(min, Valtype.i32),
+    [Opcodes.i32_lt_s],
+    ...(get ? checkFailure(): []),
+
+    ...(min == 0 ? [ [ Opcodes.end ] ] : []),
+  ];
+}
+
+const generateChar = (node, negated, get, stringSize) => {
+  const hasQuantifier = !!node.quantifier;
+  const out = [
+    ...(get ? getNextChar(stringSize, hasQuantifier) : []),
     ...number(node.char.charCodeAt(0), Valtype.i32),
     negated ? [ Opcodes.i32_eq ] : [ Opcodes.i32_ne ],
-    ...(get ? checkFailure(): [])
+  ];
+
+  if (node.quantifier) {
+    return wrapQuantifier(node, out, get, stringSize);
+  }
+
+  return [
+    ...out,
+    ...(get ? checkFailure(): []),
   ];
 };
 
 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';
+  if (singleChar) return generateChar(node.body[0], negated, get, stringSize)
 
-  let out = [
-    ...(get ? getNextChar(stringSize) : []),
-    ...(singleChar ? [] : [ [ Opcodes.local_set, Tmp ] ]),
+  const hasQuantifier = !!node.quantifier;
+
+  const out = [
+    ...(get ? getNextChar(stringSize, hasQuantifier) : []),
+    [ Opcodes.local_set, Tmp ],
   ];
 
   for (const x of node.body) {
-    out = [
-      ...out,
-      ...(singleChar ? [] : [ [ Opcodes.local_get, Tmp ] ]),
+    out.push(
+      [ Opcodes.local_get, Tmp ],
       ...generate(x, negated, false, stringSize)
-    ];
+    );
   }
 
-  if (node.body.length > 0) out = out.concat(new Array(node.body.length - 1).fill(negated ? [ Opcodes.i32_or ] : [ Opcodes.i32_and ]));
+  if (node.body.length > 0) {
+    for (let i = 0; i < node.body.length - 1; i++) {
+      out.push(negated ? [ Opcodes.i32_or ] : [ Opcodes.i32_and ])
+    }
+  };
+
+  if (hasQuantifier) {
+    return wrapQuantifier(node, out, get, stringSize);
+  }
 
   return [
     ...out,
-    ...checkFailure()
+    ...checkFailure(),
   ];
 };
 
@@ -206,28 +295,33 @@ const wrapFunc = (regex, func, name, index) => {
     // bytestring
     ...generate(parsed, false, true, 1, func),
     [ Opcodes.end ]
-  ], name, index);
+  ], name, index, types[func]);
 };
 
 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) => ({
+export const types = {
+  test: TYPES.boolean,
+  search: TYPES.number
+};
+
+const outputFunc = (wasm, name, index, returnType) => ({
   name,
   index,
   wasm,
+  returnType,
 
   export: true,
   params: [ Valtype.i32, Valtype.i32 ],
   returns: [ Valtype.i32 ],
-  returnType: TYPES.boolean,
   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 },
+    inputType: { idx: 1, type: Valtype.i32 },
+    counter: { idx: 2, type: Valtype.i32 },
+    pointer: { idx: 3, type: Valtype.i32 },
+    length: { idx: 4, type: Valtype.i32 },
+    tmp: { idx: 5, type: Valtype.i32 },
+    quantifierTmp: { idx: 6, type: Valtype.i32 },
   }
 });

package/runner/index.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
+globalThis.version = '0.18.3+945765df9';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {
@@ -22,7 +23,7 @@ if (process.argv.includes('--compile-hints')) {
 
 if (process.argv.includes('--help')) {
   // description + version
-  console.log(`\x1B[1m\x1B[35mPorffor\x1B[0m is a JavaScript engine/runtime/compiler. \x1B[90m(${(await import('./version.js')).default})\x1B[0m`);
+  console.log(`\x1B[1m\x1B[35mPorffor\x1B[0m is a JavaScript engine/runtime/compiler. \x1B[90m(${globalThis.version})\x1B[0m`);
 
   // basic usage
   console.log(`Usage: \x1B[1mporf [command] path/to/script.js [...prefs] [...args]\x1B[0m`);
@@ -102,7 +103,7 @@ globalThis.file = file;
 if (!file) {
   if (process.argv.includes('-v') || process.argv.includes('--version')) {
     // just print version
-    console.log((await import('./version.js')).default);
+    console.log(globalThis.version);
     process.exit(0);
   }
 

package/runner/repl.js

@@ -1,6 +1,5 @@
 import { TYPE_NAMES } from '../compiler/types.js';
 import compile from '../compiler/wrap.js';
-import version from './version.js';
 
 import util from 'node:util';
 
@@ -32,7 +31,7 @@ if (host.startsWith('Node')) host = '\x1B[92m' + host;
 if (host.startsWith('Deno')) host = '\x1B[97m' + host;
 if (host.startsWith('Bun')) host = '\x1B[93m' + host;
 
-console.log(`Welcome to \x1B[1m\x1B[35mPorffor\x1B[0m \x1B[90m(${version})\x1B[0m running on \x1B[1m${host.replace('/', ' \x1B[0m\x1B[90m(')})\x1B[0m`);
+console.log(`Welcome to \x1B[1m\x1B[35mPorffor\x1B[0m \x1B[90m(${globalThis.version})\x1B[0m running on \x1B[1m${host.replace('/', ' \x1B[0m\x1B[90m(')})\x1B[0m`);
 console.log(`\x1B[90musing opt ${process.argv.find(x => x.startsWith('-O')) ?? '-O1'}, parser ${parser}, valtype ${valtype}\x1B[0m`);
 console.log();
 

package/runner/version.js

@@ -1,12 +0,0 @@
-import { readFileSync } from 'node:fs';
-
-export let version = 'unknown';
-export let rev = 'unknown';
-
-const packageJson = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
-version = packageJson.version.split('-')[0];
-rev = packageJson.version.split('-')[1];
-
-if (!rev) rev = readFileSync(new URL('../.git/refs/heads/main', import.meta.url), 'utf8').trim().slice(0, 9);
-
-export default `${version}-${rev}`;