porffor 0.17.0-05070e1f0 → 0.17.0-0564424f4

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/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-05070e1f0",
+  "version": "0.17.0-0564424f4",
   "author": "CanadaHonk",
   "license": "MIT",
   "scripts": {},

package/rhemyn/compile.js

@@ -6,34 +6,50 @@ import { TYPES } from '../compiler/types.js';
 
 // local indexes
 const BasePointer = 0; // base string pointer
-const IterPointer = 1; // this iteration base pointer
 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':
+      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.local_set, Pointer ],
 
         [ 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 => generate(x, negated, true, stringSize, func)),
@@ -48,20 +64,15 @@ const generate = (node, negated = false, get = true, stringSize = 2, func = 'tes
             [ 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 ],
+          // counter++, if length > counter, loop
+          [ Opcodes.local_get, Length ],
 
-          // 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.i32_gt_s ],
 
           [ Opcodes.br_if, 0 ],
         [ Opcodes.end ],
@@ -133,6 +144,18 @@ const wrapQuantifier = (node, method, get, stringSize) => {
     ...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 ],
@@ -177,13 +200,7 @@ const wrapQuantifier = (node, method, get, stringSize) => {
     [Opcodes.i32_lt_s],
     ...(get ? checkFailure(): []),
 
-    // counter += tmp - 1
-    [ Opcodes.local_get, QuantifierTmp ],
-    ...number(1, Valtype.i32),
-    [ Opcodes.i32_sub ],
-    [ Opcodes.local_get, Counter ],
-    [ Opcodes.i32_add ],
-    [ Opcodes.local_set, Counter ]
+    ...(min == 0 ? [ [ Opcodes.end ] ] : []),
   ];
 }
 
@@ -201,7 +218,7 @@ const generateChar = (node, negated, get, stringSize) => {
 
   return [
     ...out,
-    ...(get ? checkFailure(): [])
+    ...(get ? checkFailure(): []),
   ];
 };
 
@@ -236,7 +253,7 @@ const generateSet = (node, negated, get, stringSize) => {
 
   return [
     ...out,
-    ...checkFailure()
+    ...checkFailure(),
   ];
 };
 
@@ -268,7 +285,7 @@ const wrapFunc = (regex, func, name, index) => {
   const parsed = parse(regex);
 
   return outputFunc([
-    [ Opcodes.local_get, IterPointer ],
+    [ Opcodes.local_get, 1 ],
     ...number(TYPES.string, Valtype.i32),
     [ Opcodes.i32_eq ],
     [ Opcodes.if, Valtype.i32 ],
@@ -278,24 +295,29 @@ 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 },
+    inputType: { idx: 1, type: Valtype.i32 },
     counter: { idx: 2, type: Valtype.i32 },
     pointer: { idx: 3, type: Valtype.i32 },
     length: { idx: 4, type: Valtype.i32 },