porffor 0.2.0-a6c01f5 → 0.2.0-a88bbe6

package/compiler/opt.js

@@ -172,14 +172,14 @@ export default (funcs, globals, pages, tags, exceptions) => {
           }
         }
 
-        if (inst[inst.length - 1] === 'string_only' && !pages.hasAnyString) {
+        if (inst[inst.length - 1] === 'string_only' && !pages.hasAnyString && !Prefs.noRmUnusedTypes) {
           // remove this inst
           wasm.splice(i, 1);
           if (i > 0) i--;
           inst = wasm[i];
         }
 
-        if (inst[inst.length - 1] === 'string_only|start' && !pages.hasAnyString) {
+        if (inst[inst.length - 1] === 'string_only|start' && !pages.hasAnyString&& !Prefs.noRmUnusedTypes) {
           let j = i;
           for (; j < wasm.length; j++) {
             const op = wasm[j];
@@ -193,7 +193,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
           inst = wasm[i];
         }
 
-        if (inst[0] === Opcodes.if && typeof inst[2] === 'string') {
+        if (inst[0] === Opcodes.if && typeof inst[2] === 'string' && !Prefs.noRmUnusedTypes) {
           // remove unneeded typeswitch checks
 
           const type = inst[2].split('|')[1];

package/compiler/parse.js

@@ -9,8 +9,10 @@ if (typeof process === 'undefined' && typeof Deno !== 'undefined') {
   globalThis.process = { argv: ['', '', ...Deno.args], stdout: { write: str => Deno.writeAllSync(Deno.stdout, textEncoder.encode(str)) } };
 }
 
+const file = process.argv.slice(2).find(x => x[0] !== '-');
+
 // should we try to support types (while parsing)
-const types = Prefs.parseTypes;
+const types = Prefs.parseTypes || file?.endsWith('.ts');
 globalThis.typedInput = types && Prefs.optTypes;
 
 // todo: review which to use by default
@@ -23,7 +25,7 @@ globalThis.typedInput = types && Prefs.optTypes;
 globalThis.parser = '';
 let parse;
 const loadParser = async (fallbackParser = 'acorn', forceParser) => {
-  parser = forceParser ?? process.argv.find(x => x.startsWith('-parser='))?.split('=')?.[1] ?? fallbackParser;
+  parser = forceParser ?? process.argv.find(x => x.startsWith('--parser='))?.split('=')?.[1] ?? fallbackParser;
   0, { parse } = (await import((globalThis.document || globalThis.Deno ? 'https://esm.sh/' : '') + parser));
 };
 globalThis._porf_loadParser = loadParser;

package/compiler/precompile.js

@@ -7,9 +7,6 @@ import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 const __dirname = fileURLToPath(new URL('.', import.meta.url));
 
-// import porfParse from './parse.js';
-// import porfCodegen from './codeGen.js';
-
 const argv = process.argv.slice();
 
 const compile = async (file, [ _funcs, _globals ]) => {
@@ -21,17 +18,12 @@ const compile = async (file, [ _funcs, _globals ]) => {
     first = source.slice(0, source.indexOf('\n'));
   }
 
-  let args = ['-bytestring', '-todo-time=compile', '-no-aot-pointer-opt', '-no-treeshake-wasm-imports', '-scoped-page-names', '-parse-types', '-opt-types'];
+  let args = ['--bytestring', '--todo-time=compile', '--no-aot-pointer-opt', '--no-treeshake-wasm-imports', '--no-rm-unused-types', '--scoped-page-names', '--funsafe-no-unlikely-proto-checks', '--parse-types', '--opt-types'];
   if (first.startsWith('// @porf')) {
     args = args.concat(first.slice('// @porf '.length).split(' '));
   }
   process.argv = argv.concat(args);
 
-  // const porfParse = (await import(`./parse.js?_=${Date.now()}`)).default;
-  // const porfCodegen = (await import(`./codeGen.js?_=${Date.now()}`)).default;
-
-  // let { funcs, globals, data } = porfCodegen(porfParse(source, ['module']));
-
   const porfCompile = (await import(`./index.js?_=${Date.now()}`)).default;
 
   let { funcs, globals, data, exceptions } = porfCompile(source, ['module']);
@@ -70,7 +62,7 @@ const compile = async (file, [ _funcs, _globals ]) => {
       if (y[0] === Opcodes.const && (n[0] === Opcodes.local_set || n[0] === Opcodes.local_tee)) {
         const l = locals[n[1]];
         if (!l) continue;
-        if (![TYPES.string, TYPES._array, TYPES._bytestring].includes(l.metadata?.type)) continue;
+        if (![TYPES.string, TYPES.array, TYPES.bytestring].includes(l.metadata?.type)) continue;
         if (!x.pages) continue;
 
         const pageName = [...x.pages.keys()].find(z => z.endsWith(l.name));
@@ -78,7 +70,14 @@ const compile = async (file, [ _funcs, _globals ]) => {
         allocated.add(pageName);
 
         y.splice(0, 10, 'alloc', pageName, x.pages.get(pageName).type, valtypeBinary);
-        // y.push(x.pages.get(pageName));
+      }
+
+      if (y[0] === Opcodes.i32_const && n[0] === Opcodes.throw) {
+        const id = y[1];
+        y.splice(0, 10, 'throw', exceptions[id].constructor, exceptions[id].message);
+
+        // remove throw inst
+        x.wasm.splice(i + 1, 1);
       }
     }
   }
@@ -93,31 +92,29 @@ const precompile = async () => {
   let funcs = [], globals = [];
   for (const file of fs.readdirSync(dir)) {
     if (file.endsWith('.d.ts')) continue;
+    console.log(file);
+
     await compile(join(dir, file), [ funcs, globals ]);
   }
 
-  // ${x.pages && x.pages.size > 0 ? `    pages: ${JSON.stringify(Object.fromEntries(x.pages.entries()))},` : ''}
-  // ${x.used && x.used.length > 0 ? `    used: ${JSON.stringify(x.used)},` : ''}
-
   return `// autogenerated by compiler/precompile.js
 import { number } from './embedding.js';
 
 export const BuiltinFuncs = function() {
-${funcs.map(x => `  this.${x.name} = {
-    wasm: (scope, { allocPage, builtin }) => ${JSON.stringify(x.wasm.filter(x => x.length && x[0] != null)).replace(/\["alloc","(.*?)","(.*?)",(.*?)\]/g, (_, reason, type, valtype) => `...number(allocPage(scope, '${reason}', '${type}') * pageSize, ${valtype})`).replace(/\[16,"(.*?)"]/g, (_, name) => `[16, builtin('${name}')]`)},
+${funcs.map(x => {
+  const wasm = JSON.stringify(x.wasm.filter(x => x.length && x[0] != null)).replace(/\["alloc","(.*?)","(.*?)",(.*?)\]/g, (_, reason, type, valtype) => `...number(allocPage(scope, '${reason}', '${type}') * pageSize, ${valtype})`).replace(/\[16,"(.*?)"]/g, (_, name) => `[16, builtin('${name}')]`).replace(/\["throw","(.*?)","(.*?)"\]/g, (_, constructor, message) => `...internalThrow(scope, '${constructor}', \`${message}\`)`);
+  return `  this.${x.name} = {
+    wasm: (scope, {${wasm.includes('allocPage(') ? 'allocPage,' : ''}${wasm.includes('builtin(') ? 'builtin,' : ''}${wasm.includes('internalThrow(') ? 'internalThrow,' : ''}}) => ${wasm},
     params: ${JSON.stringify(x.params)},
     typedParams: true,
     returns: ${JSON.stringify(x.returns)},
     ${x.returnType != null ? `returnType: ${JSON.stringify(x.returnType)}` : 'typedReturns: true'},
     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.exceptions && x.exceptions.length > 0 ? `    exceptions: ${JSON.stringify(x.exceptions)},` : ''}
-  };`.replaceAll('\n\n', '\n').replaceAll('\n\n', '\n')).join('\n')}
+${x.data && x.data.length > 0 ? `    data: ${JSON.stringify(x.data)}` : ''}
+  };`.replaceAll('\n\n', '\n').replaceAll('\n\n', '\n')
+}).join('\n')}
 };`;
 };
 
-const code = await precompile();
-// console.log(code);
-
-fs.writeFileSync(join(__dirname, 'generated_builtins.js'), code);
+fs.writeFileSync(join(__dirname, 'generated_builtins.js'), await precompile());

package/compiler/prefs.js

@@ -1,4 +1,4 @@
-const onByDefault = [ 'bytestring', 'aotPointerOpt', 'treeshakeWasmImports' ];
+const onByDefault = [ 'bytestring', 'aotPointerOpt', 'treeshakeWasmImports', 'alwaysMemory' ];
 
 let cache = {};
 const obj = new Proxy({}, {
@@ -9,11 +9,12 @@ const obj = new Proxy({}, {
     return cache[p] = (() => {
       // fooBar -> foo-bar
       const name = p[0] === '_' ? p : p.replace(/[A-Z]/g, c => `-${c.toLowerCase()}`);
-      if (process.argv.includes('-' + name)) return true;
-      if (process.argv.includes('-no-' + name)) return false;
+      const prefix = name.length === 1 ? '-' : '--';
+      if (process.argv.includes(prefix + name)) return true;
+      if (process.argv.includes(prefix + 'no-' + name)) return false;
 
-      const valArg = process.argv.find(x => x.startsWith(`-${name}=`));
-      if (valArg) return valArg.slice(name.length + 2);
+      const valArg = process.argv.find(x => x.startsWith(`${prefix}${name}=`));
+      if (valArg) return valArg.slice(name.length + 1 + prefix.length);
 
       if (onByDefault.includes(p)) return true;
       return undefined;

package/compiler/prototype.js

@@ -14,7 +14,7 @@ export const PrototypeFuncs = function() {
   if (Prefs.zeroChecks) zeroChecks = Prefs.zeroChecks.split('=')[1].split(',').reduce((acc, x) => { acc[x.toLowerCase()] = true; return acc; }, {});
     else zeroChecks = {};
 
-  this[TYPES._array] = {
+  this[TYPES.array] = {
     // lX = local accessor of X ({ get, set }), iX = local index of X, wX = wasm ops of X
     at: (pointer, length, wIndex, iTmp) => [
       ...wIndex,
@@ -253,10 +253,10 @@ export const PrototypeFuncs = function() {
     ]
   };
 
-  this[TYPES._array].at.local = Valtype.i32;
-  this[TYPES._array].push.noArgRetLength = true;
-  this[TYPES._array].fill.local = valtypeBinary;
-  this[TYPES._array].fill.returnType = TYPES._array;
+  this[TYPES.array].at.local = Valtype.i32;
+  this[TYPES.array].push.noArgRetLength = true;
+  this[TYPES.array].fill.local = valtypeBinary;
+  this[TYPES.array].fill.returnType = TYPES.array;
 
   this[TYPES.string] = {
     at: (pointer, length, wIndex, iTmp, _, arrayShell) => {
@@ -476,7 +476,7 @@ export const PrototypeFuncs = function() {
   this[TYPES.string].isWellFormed.returnType = TYPES.boolean;
 
   if (Prefs.bytestring) {
-    this[TYPES._bytestring] = {
+    this[TYPES.bytestring] = {
       at: (pointer, length, wIndex, iTmp, _, arrayShell) => {
         const [ newOut, newPointer ] = arrayShell(1, 'i8');
 
@@ -606,14 +606,14 @@ export const PrototypeFuncs = function() {
       }
     };
 
-    this[TYPES._bytestring].at.local = Valtype.i32;
-    this[TYPES._bytestring].at.returnType = TYPES._bytestring;
-    this[TYPES._bytestring].charAt.returnType = TYPES._bytestring;
-    this[TYPES._bytestring].charCodeAt.local = Valtype.i32;
-    this[TYPES._bytestring].charCodeAt.noPointerCache = zeroChecks.charcodeat;
+    this[TYPES.bytestring].at.local = Valtype.i32;
+    this[TYPES.bytestring].at.returnType = TYPES.bytestring;
+    this[TYPES.bytestring].charAt.returnType = TYPES.bytestring;
+    this[TYPES.bytestring].charCodeAt.local = Valtype.i32;
+    this[TYPES.bytestring].charCodeAt.noPointerCache = zeroChecks.charcodeat;
 
-    this[TYPES._bytestring].isWellFormed.local = Valtype.i32;
-    this[TYPES._bytestring].isWellFormed.local2 = Valtype.i32;
-    this[TYPES._bytestring].isWellFormed.returnType = TYPES.boolean;
+    this[TYPES.bytestring].isWellFormed.local = Valtype.i32;
+    this[TYPES.bytestring].isWellFormed.local2 = Valtype.i32;
+    this[TYPES.bytestring].isWellFormed.returnType = TYPES.boolean;
   }
 };

package/compiler/types.js

@@ -24,7 +24,7 @@ export const INTERNAL_TYPE_BASE = 0x10;
 let internalTypeIndex = INTERNAL_TYPE_BASE;
 const registerInternalType = name => {
   const n = internalTypeIndex++;
-  TYPES['_' + name.toLowerCase()] = n;
+  TYPES[name.toLowerCase()] = n;
   TYPE_NAMES[n] = name;
 };
 
@@ -34,4 +34,5 @@ const registerInternalType = name => {
 registerInternalType('Array');
 registerInternalType('RegExp');
 registerInternalType('ByteString');
-registerInternalType('Date');
+registerInternalType('Date');
+registerInternalType('Set');

package/compiler/wrap.js

@@ -7,6 +7,70 @@ import { TYPES } from './types.js';
 
 const bold = x => `\u001b[1m${x}\u001b[0m`;
 
+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)) => {
   const times = [];
 
@@ -148,62 +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 (type) {
-          case TYPES.boolean: return Boolean(ret);
-          case TYPES.undefined: return undefined;
-          case TYPES.object: return ret === 0 ? null : {};
-
-          case TYPES.string: {
-            const pointer = ret;
-            const length = (new Int32Array(memory.buffer, pointer, 1))[0];
-
-            return Array.from(new Uint16Array(memory.buffer, pointer + 4, length)).map(x => String.fromCharCode(x)).join('');
-          }
+        const ret = exp.apply(this, arguments);
 
-          case TYPES.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 () {};
+        if (ret == null) return undefined;
 
-            // make fake empty func for repl/etc
-            return {[func.name]() {}}[func.name];
-          }
-
-          case TYPES._array: {
-            const pointer = ret;
-            const length = (new Int32Array(memory.buffer, pointer, 1))[0];
-
-            // 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 TYPES._bytestring: {
-            const pointer = ret;
-            const length = (new Int32Array(memory.buffer, pointer, 1))[0];
-
-            return Array.from(new Uint8Array(memory.buffer, pointer + 4, length)).map(x => String.fromCharCode(x)).join('');
-          }
-
-          case TYPES._date: {
-            const pointer = ret;
-            const value = (new Float64Array(memory.buffer, pointer, 1))[0];
-
-            return new Date(value);
-          }
-
-          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,7 +1,7 @@
 {
   "name": "porffor",
   "description": "a basic experimental wip aot optimizing js -> wasm engine/compiler/runtime in js",
-  "version": "0.2.0-a6c01f5",
+  "version": "0.2.0-a88bbe6",
   "author": "CanadaHonk",
   "license": "MIT",
   "scripts": {

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,7 +156,7 @@ const generateSet = (node, negated, get) => {
     out = [
       ...out,
       ...(singleChar ? [] : [ [ Opcodes.local_get, Tmp ] ]),
-      ...generate(x, negated, false)
+      ...generate(x, negated, false, stringSize)
     ];
   }
 
@@ -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),
@@ -192,8 +192,25 @@ const generateGroup = (node, negated, get) => {
   return [];
 };
 
-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 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) => 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,
@@ -201,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 },

package/rhemyn/parse.js

@@ -11,7 +11,7 @@ const Quantifiers = {
 const QuantifierKeys = Object.keys(Quantifiers);
 
 const getArg = (name, def) => {
-  const arg = (typeof process !== 'undefined' ? process.argv : Deno.args).find(x => x.startsWith(`-${name}=`));
+  const arg = (typeof process !== 'undefined' ? process.argv : Deno.args).find(x => x.startsWith(`--${name}=`));
   if (arg) return arg.split('=')[0];
 
   return def;
@@ -20,8 +20,7 @@ const getArg = (name, def) => {
 // full is spec-compliant but slower. not needed most of the time. (evil)
 const DotChars = () => ({
   full: [ '\n', '\r', '\u2028', '\u2029' ],
-  simple: [ '\n', '\r' ],
-  fast: [ '\n' ]
+  fast: [ '\n', '\r' ]
 })[getArg('regex-dot', 'fast')];
 
 const WordChars = () => ({
@@ -31,8 +30,8 @@ const WordChars = () => ({
 
 const WhitespaceChars = () => ({
   full: [ ' ', '\t', '\n', '\r', '\u2028', '\u2029' ],
-  simple: [ ' ', '\t', '\n', '\r' ]
-})[getArg('regex-ws', 'simple')];
+  fast: [ ' ', '\t', '\n', '\r' ]
+})[getArg('regex-ws', 'fast')];
 
 const _Metachars = () => ({
   unescaped: {

package/runner/index.js

@@ -5,7 +5,7 @@ import fs from 'node:fs';
 
 const start = performance.now();
 
-if (process.argv.includes('-compile-hints')) {
+if (process.argv.includes('--compile-hints')) {
   const v8 = await import('node:v8');
   v8.setFlagsFromString(`--experimental-wasm-compilation-hints`);
 
@@ -29,8 +29,8 @@ if (process.argv.includes('--help')) {
   for (const [ cmd, [ color, desc ] ] of Object.entries({
     run: [ 34, 'Run a JS file' ],
     wasm: [ 34, 'Compile a JS file to a Wasm binary\n' ],
-    native: [ 31, 'Compile a JS file to a native binary' ],
-    c: [ 31, 'Compile a JS file to C source code\n' ],
+    c: [ 31, 'Compile a JS file to C source code' ],
+    native: [ 31, 'Compile a JS file to a native binary\n' ],
     profile: [ 33, 'Profile a JS file' ],
     debug: [ 33, 'Debug a JS file' ],
     'debug-wasm': [ 33, 'Debug the compiled Wasm of a JS file' ]
@@ -38,6 +38,22 @@ if (process.argv.includes('--help')) {
     console.log(`  \x1B[1m\x1B[${color}m${cmd}\x1B[0m${' '.repeat(20 - cmd.length - (desc.startsWith('🧪') ? 3 : 0))}${desc}`);
   }
 
+  // console.log();
+
+  // // options
+  // console.log(`\n\u001b[4mCommands\x1B[0m`);
+  // for (const [ cmd, [ color, desc ] ] of Object.entries({
+  //   run: [ 34, 'Run a JS file' ],
+  //   wasm: [ 34, 'Compile a JS file to a Wasm binary\n' ],
+  //   c: [ 31, 'Compile a JS file to C source code' ],
+  //   native: [ 31, 'Compile a JS file to a native binary\n' ],
+  //   profile: [ 33, 'Profile a JS file' ],
+  //   debug: [ 33, 'Debug a JS file' ],
+  //   'debug-wasm': [ 33, 'Debug the compiled Wasm of a JS file' ]
+  // })) {
+  //   console.log(`  \x1B[1m\x1B[${color}m${cmd}\x1B[0m${' '.repeat(20 - cmd.length - (desc.startsWith('🧪') ? 3 : 0))}${desc}`);
+  // }
+
   console.log();
   process.exit(0);
 }
@@ -51,11 +67,11 @@ if (['run', 'wasm', 'native', 'c', 'profile', 'debug', 'debug-wasm'].includes(fi
   }
 
   if (['wasm', 'native', 'c'].includes(file)) {
-    process.argv.push(`-target=${file}`);
+    process.argv.push(`--target=${file}`);
   }
 
   if (file === 'debug-wasm') {
-    process.argv.push('-asur', '-wasm-debug');
+    process.argv.push('--asur', '--wasm-debug');
   }
 
   if (file === 'debug') {
@@ -102,7 +118,7 @@ try {
   if (process.argv.includes('-b')) {
     const { wasm, exports } = await compile(source, process.argv.includes('--module') ? [ 'module' ] : [], {}, print);
 
-    if (!process.argv.includes('-no-run')) exports.main();
+    if (!process.argv.includes('--no-run')) exports.main();
 
     console.log(`\n\nwasm size: ${wasm.byteLength} bytes`);
   } else {

package/runner/repl.js

@@ -21,7 +21,7 @@ try {
 
 globalThis.valtype = 'f64';
 
-const valtypeOpt = process.argv.find(x => x.startsWith('-valtype='));
+const valtypeOpt = process.argv.find(x => x.startsWith('--valtype='));
 if (valtypeOpt) valtype = valtypeOpt.split('=')[1];
 
 let host = globalThis?.navigator?.userAgent;
@@ -116,7 +116,7 @@ replServer.defineCommand('asm', {
     this.clearBufferedCommand();
 
     try {
-      process.argv.push('-opt-funcs');
+      process.argv.push('--opt-funcs');
       await run('', null, null, () => {}, false);
       process.argv.pop();
     } catch { }