porffor 0.16.0-fe07da0f4 → 0.17.0-05070e1f0

package/rhemyn/compile.js

@@ -7,18 +7,16 @@ 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;
+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
 
-let exprLastGet = false;
 const generate = (node, negated = false, get = true, stringSize = 2, func = 'test') => {
   let out = [];
   switch (node.type) {
     case 'Expression':
-      exprLastGet = false;
       out = [
         // set length local
         [ Opcodes.local_get, BasePointer ],
@@ -32,49 +30,43 @@ const generate = (node, negated = false, get = true, stringSize = 2, func = 'tes
         [ 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 ],
+          // 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)),
+
+            // 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.end ],
 
-        // no match, return 0
+        // no match
         ...number(({
           test: 0,
           search: -1
@@ -110,12 +102,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,11 +126,81 @@ 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],
+
+    // 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(): []),
+
+    // 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 ]
+  ];
+}
+
+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 ],
+  ];
+
+  if (node.quantifier) {
+    return wrapQuantifier(node, out, get, stringSize);
+  }
+
+  return [
+    ...out,
     ...(get ? checkFailure(): [])
   ];
 };
@@ -146,21 +208,31 @@ const generateChar = (node, negated, get, stringSize) => {
 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,
@@ -196,7 +268,7 @@ const wrapFunc = (regex, func, name, index) => {
   const parsed = parse(regex);
 
   return outputFunc([
-    [ Opcodes.local_get, 1 ],
+    [ Opcodes.local_get, IterPointer ],
     ...number(TYPES.string, Valtype.i32),
     [ Opcodes.i32_eq ],
     [ Opcodes.if, Valtype.i32 ],
@@ -224,10 +296,10 @@ const outputFunc = (wasm, name, index) => ({
   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 },
+    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/debug.js

@@ -43,7 +43,7 @@ let lastLine;
 let output = '';
 
 try {
-  const { exports } = await compile(source, process.argv.includes('--module') ? [ 'module' ] : [], {
+  const { exports } = compile(source, process.argv.includes('--module') ? [ 'module' ] : [], {
     y: n => {
       if (callStarts[callStarts.length - 1] === n - 1) {
         // end of call

package/runner/index.js

@@ -1,8 +1,11 @@
 #!/usr/bin/env node
-
-import compile from '../compiler/wrap.js';
 import fs from 'node:fs';
 
+// deno compat
+if (typeof process === 'undefined' && typeof Deno !== 'undefined') {
+  globalThis.process = await import('node:process');
+}
+
 const start = performance.now();
 
 if (process.argv.includes('--compile-hints')) {
@@ -59,12 +62,22 @@ if (process.argv.includes('--help')) {
 }
 
 let file = process.argv.slice(2).find(x => x[0] !== '-');
-if (['run', 'wasm', 'native', 'c', 'profile', 'debug', 'debug-wasm'].includes(file)) {
+if (['precompile', 'run', 'wasm', 'native', 'c', 'profile', 'debug', 'debug-wasm'].includes(file)) {
   // remove this arg
   process.argv.splice(process.argv.indexOf(file), 1);
 
+  if (file === 'precompile') {
+    await import('../compiler/precompile.js');
+    await new Promise(() => {}); // do nothing for the rest of this file
+  }
+
   if (file === 'profile') {
-    await import('./profiler.js');
+    await import('./profile.js');
+    await new Promise(() => {}); // do nothing for the rest of this file
+  }
+
+  if (file === 'debug') {
+    await import('./debug.js');
     await new Promise(() => {}); // do nothing for the rest of this file
   }
 
@@ -76,11 +89,6 @@ if (['run', 'wasm', 'native', 'c', 'profile', 'debug', 'debug-wasm'].includes(fi
     process.argv.push('--asur', '--wasm-debug');
   }
 
-  if (file === 'debug') {
-    await import('./debug.js');
-    await new Promise(() => {}); // do nothing for the rest of this file
-  }
-
   file = process.argv.slice(2).find(x => x[0] !== '-');
 
   const nonOptOutFile = process.argv.slice(process.argv.indexOf(file) + 1).find(x => x[0] !== '-');
@@ -89,6 +97,8 @@ if (['run', 'wasm', 'native', 'c', 'profile', 'debug', 'debug-wasm'].includes(fi
   }
 }
 
+globalThis.file = file;
+
 if (!file) {
   if (process.argv.includes('-v') || process.argv.includes('--version')) {
     // just print version
@@ -103,6 +113,8 @@ if (!file) {
 
 const source = fs.readFileSync(file, 'utf8');
 
+const compile = (await import('../compiler/wrap.js')).default;
+
 let cache = '';
 const print = str => {
   /* cache += str;
@@ -115,22 +127,27 @@ const print = str => {
   process.stdout.write(str);
 };
 
+let runStart;
 try {
   if (process.argv.includes('-b')) {
-    const { wasm, exports } = await compile(source, process.argv.includes('--module') ? [ 'module' ] : [], {}, print);
+    const { wasm, exports } = compile(source, process.argv.includes('--module') ? [ 'module' ] : [], {}, print);
 
+    runStart = performance.now();
     if (!process.argv.includes('--no-run')) exports.main();
 
     console.log(`\n\nwasm size: ${wasm.byteLength} bytes`);
   } else {
-    const { exports } = await compile(source, process.argv.includes('--module') ? [ 'module' ] : [], {}, print);
+    const { exports } = compile(source, process.argv.includes('--module') ? [ 'module' ] : [], {}, print);
 
-    if (!process.argv.includes('-no-run')) exports.main();
+    runStart = performance.now();
+    if (!process.argv.includes('--no-run')) exports.main();
   }
   // if (cache) process.stdout.write(cache);
 } catch (e) {
   // if (cache) process.stdout.write(cache);
-  console.error(process.argv.includes('-i') ? e : `${e.constructor.name}: ${e.message}`);
+  let out = e;
+  if (!process.argv.includes('-i') && Object.getPrototypeOf(e).message != null) out = `${e.constructor.name}${e.message != null ? `: ${e.message}` : ''}`;
+  console.error(out);
 }
 
-if (process.argv.includes('-t')) console.log(`${process.argv.includes('-b') ? '' : '\n\n'}total time: ${(performance.now() - start).toFixed(2)}ms`);
+if (process.argv.includes('-t')) console.log(`${process.argv.includes('-b') ? '' : '\n\n'}total time: ${(performance.now() - start).toFixed(2)}ms\nexecution time: ${(performance.now() - runStart).toFixed(2)}ms`);

package/runner/{profiler.js → profile.js}

@@ -20,7 +20,7 @@ let spin = 0;
 let last = 0;
 
 try {
-  const { exports } = await compile(source, process.argv.includes('--module') ? [ 'module' ] : [], {
+  const { exports } = compile(source, process.argv.includes('--module') ? [ 'module' ] : [], {
     y: n => {
       tmp[n] = performance.now();
     },

package/runner/repl.js

@@ -40,10 +40,9 @@ let lastMemory, lastPages;
 const PageSize = 65536;
 const memoryToString = mem => {
   let out = '';
-  const pages = lastPages.length;
   const wasmPages = mem.buffer.byteLength / PageSize;
 
-  out += `\x1B[1mallocated ${mem.buffer.byteLength / 1024}KB\x1B[0m for ${pages} thing${pages === 1 ? '' : 's'} using ${wasmPages} Wasm page${wasmPages === 1 ? '' : 's'}\n\n`;
+  out += `\x1B[1mallocated ${mem.buffer.byteLength / 1024}KiB\x1B[0m (using ${wasmPages} Wasm page${wasmPages === 1 ? '' : 's'})\n\n`;
 
   const buf = new Uint8Array(mem.buffer);
 
@@ -55,10 +54,16 @@ const memoryToString = mem => {
   }
 
   out += `\x1B[0m\x1B[1m  name${' '.repeat(longestName - 4)} \x1B[0m\x1B[90m│\x1B[0m\x1B[1m type${' '.repeat(longestType - 4)} \x1B[0m\x1B[90m│\x1B[0m\x1B[1m memory\x1B[0m\n`; // ─
-  for (let i = 0; i < pages; i++) {
-    const [ type, name ] = lastPages[i].split(': ');
-    // out += `\x1B[36m${lastPages[i].replace(':', '\x1B[90m:\x1B[34m')}\x1B[90m${' '.repeat(longestName - lastPages[i].length)} | \x1B[0m`;
-    out += `  \x1B[34m${name}${' '.repeat(longestName - name.length)} \x1B[90m│\x1B[0m \x1B[36m${type}${' '.repeat(longestType - type.length)} \x1B[90m│\x1B[0m `;
+  for (let i = 0; i < wasmPages; i++) {
+    if (lastPages[i]) {
+      const [ type, name ] = lastPages[i].split(': ');
+      // out += `\x1B[36m${lastPages[i].replace(':', '\x1B[90m:\x1B[34m')}\x1B[90m${' '.repeat(longestName - lastPages[i].length)} | \x1B[0m`;
+      out += `  \x1B[34m${name}${' '.repeat(longestName - name.length)} \x1B[90m│\x1B[0m \x1B[36m${type}${' '.repeat(longestType - type.length)} \x1B[90m│\x1B[0m `;
+    } else {
+      const type = '???';
+      const name = '???';
+      out += `  \x1B[34m${name}${' '.repeat(longestName - name.length)} \x1B[90m│\x1B[0m \x1B[36m${type}${' '.repeat(longestType - type.length)} \x1B[90m│\x1B[0m `;
+    }
 
     for (let j = 0; j < 40; j++) {
       const val = buf[i * pageSize + j];
@@ -75,13 +80,13 @@ const memoryToString = mem => {
 };
 
 let prev = '';
-const run = async (source, _context, _filename, callback, run = true) => {
+const run = (source, _context, _filename, callback, run = true) => {
   // hack: print "secret" before latest code ran to only enable printing for new code
 
   let toRun = (prev ? (prev + `;\nprint(-0x1337);\n`) : '') + source.trim();
 
   let shouldPrint = !prev;
-  const { exports, pages } = await compile(toRun, [], {}, str => {
+  const { exports, pages } = compile(toRun, [], {}, str => {
     if (shouldPrint) process.stdout.write(str);
     if (str === '-4919') shouldPrint = true;
   });
@@ -122,12 +127,12 @@ replServer.defineCommand('memory', {
 });
 replServer.defineCommand('asm', {
   help: 'Log Wasm decompiled bytecode',
-  async action() {
+  action() {
     this.clearBufferedCommand();
 
     try {
       process.argv.push('--opt-funcs');
-      await run('', null, null, () => {}, false);
+      run('', null, null, () => {}, false);
       process.argv.pop();
     } catch { }
 
@@ -136,7 +141,7 @@ replServer.defineCommand('asm', {
 });
 replServer.defineCommand('js', {
   help: 'Log JS being actually ran',
-  async action() {
+  action() {
     this.clearBufferedCommand();
     console.log(prev);
     this.displayPrompt();