porffor 0.17.0-30b9c5fa5 → 0.17.0-41e9c641a

package/compiler/codegen.js

@@ -1590,7 +1590,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   if (!name && decl.callee.type === 'MemberExpression') {
     // megahack for /regex/.func()
     const funcName = decl.callee.property.name;
-    if (decl.callee.object.regex && Object.hasOwn(Rhemyn, funcName)) {
+    if (decl.callee.object.regex && ['test'].includes(funcName)) {
       const regex = decl.callee.object.regex.pattern;
       const rhemynName = `regex_${funcName}_${regex}`;
 
@@ -1613,7 +1613,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
         [ Opcodes.call, idx ],
         Opcodes.i32_from_u,
 
-        ...setLastType(scope, TYPES.boolean)
+        ...setLastType(scope, Rhemyn.types[funcName])
       ];
     }
 
@@ -1622,24 +1622,35 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     target = decl.callee.object;
   }
 
-  // if (protoName && baseType === TYPES.string && Rhemyn[protoName]) {
-  //   const func = Rhemyn[protoName](decl.arguments[0].regex.pattern, currentFuncIndex++);
+  if (protoName) {
+    if (['search'].includes(protoName)) {
+      const regex = decl.arguments[0].regex.pattern;
+      const rhemynName = `regex_${protoName}_${regex}`;
+
+      if (!funcIndex[rhemynName]) {
+        const func = Rhemyn[protoName](regex, currentFuncIndex++, rhemynName);
+        func.internal = true;
+
+        funcIndex[func.name] = func.index;
+        funcs.push(func);
+      }
 
-  //   funcIndex[func.name] = func.index;
-  //   funcs.push(func);
+      const idx = funcIndex[rhemynName];
+      return [
+        // make string arg
+        ...generate(scope, target),
+        Opcodes.i32_to_u,
+        ...getNodeType(scope, target),
 
-  //   return [
-  //     generate(scope, decl.callee.object)
+        // call regex func
+        [ Opcodes.call, idx ],
+        Opcodes.i32_from_u,
 
-  //     // call regex func
-  //     [ Opcodes.call, func.index ],
-  //     Opcodes.i32_from_u
-  //   ];
-  // }
+        ...setLastType(scope, Rhemyn.types[protoName])
+      ];
+    }
 
-  if (protoName) {
     const protoBC = {};
-
     const builtinProtoCands = Object.keys(builtinFuncs).filter(x => x.startsWith('__') && x.endsWith('_prototype_' + protoName));
 
     if (!decl._protoInternalCall && builtinProtoCands.length > 0) {

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-30b9c5fa5",
+  "version": "0.17.0-41e9c641a",
   "author": "CanadaHonk",
   "license": "MIT",
   "scripts": {},

package/rhemyn/compile.js

@@ -267,21 +267,26 @@ 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 },
     inputType: { idx: 1, type: Valtype.i32 },