porffor 0.0.0-05f898f

package/rhemyn/parse.js

@@ -0,0 +1,321 @@
+const State = {
+  none: 0,
+  insideSet: 1
+};
+
+const Quantifiers = {
+  '*': [ 0 ], // 0 -
+  '+': [ 1 ], // 1 -
+  '?': [ 0, 1 ], // 0 - 1
+};
+const QuantifierKeys = Object.keys(Quantifiers);
+
+const getArg = (name, def) => {
+  const arg = (typeof process !== 'undefined' ? process.argv : Deno.args).find(x => x.startsWith(`-${name}=`));
+  if (arg) return arg.split('=')[0];
+
+  return 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' ]
+})[getArg('regex-dot', 'fast')];
+
+const WordChars = () => ({
+  full: [ [ 'a', 'z' ], [ 'A', 'Z' ], [ '0', '9' ], '_' ],
+  fast: [ [ '_', 'z' ], [ 'A', 'Z' ], [ '0', '9' ] ] // skip individual _ with _-z BUT it also matches '`'
+})[getArg('regex-word', 'full')];
+
+const WhitespaceChars = () => ({
+  full: [ ' ', '\t', '\n', '\r', '\u2028', '\u2029' ],
+  simple: [ ' ', '\t', '\n', '\r' ]
+})[getArg('regex-ws', 'simple')];
+
+const _Metachars = () => ({
+  unescaped: {
+    '.': [ DotChars(), true ], // dot
+  },
+  escaped: {
+    d: [ [ [ '0', '9' ] ], false ], // digit
+    D: [ [ [ '0', '9' ] ], true ], // not digit
+    w: [ WordChars(), false ], // word
+    W: [ WordChars(), true ], // not word
+    s: [ WhitespaceChars(), false ], // whitespace
+    S: [ WhitespaceChars(), true ], // not whitespace
+  }
+});
+
+const EscapeSequences = {
+  f: '\f',
+  n: '\n',
+  r: '\r',
+  t: '\t',
+  v: '\v',
+  '0': '\0'
+};
+
+const HexDigit = /[0-9a-fA-F]/;
+
+export default str => {
+  const Metachars = _Metachars();
+
+  const out = {
+    type: 'Expression',
+    body: []
+  };
+  let node = out, parents = [];
+
+  let state = State.none, setIndex = 0, escape = false;
+  for (let i = 0; i < str.length; i++) {
+    const c = str[i];
+
+    const charNode = char => ({
+      type: 'Character',
+      char
+    });
+
+    const rangeNode = (from, to) => ({
+      type: 'Range',
+      from,
+      to
+    });
+
+    const addChar = (char = c) => {
+      node.body.push(charNode(char));
+    };
+
+    const addSet = (matches, negated = false) => {
+      let body = matches.map(x => x[1] ? rangeNode(x[0], x[1]) : charNode(x));
+      if (state === State.insideSet) {
+        // if negated, mark each node as negated for merge
+        if (negated) body = body.map(x => {
+          x.negated = true;
+          return x;
+        });
+
+        // already in set, merge bodies
+        node.body.push(...body);
+        return;
+      }
+
+      node.body.push({
+        type: 'Set',
+        body,
+        negated
+      });
+    };
+
+    const addMetachar = meta => {
+      const [ matches, negated = false ] = meta;
+      return addSet(matches, negated);
+    };
+
+    // get next char and consume it
+    const seek = (allowEscaped = true) => {
+      const cNext = str[++i];
+
+      if (cNext === '\\') return !allowEscaped ? undefined : [ str[++i], true ];
+      return !allowEscaped ? cNext : [ cNext, false ];
+    };
+
+    // get next char without consuming
+    const peek = (allowEscaped = true, offset = 0) => {
+      const cNext = str[i + 1 + offset];
+
+      if (cNext === '\\') return !allowEscaped ? undefined : [ str[i + 2 + offset], true ];
+      return !allowEscaped ? cNext : [ cNext, false ];
+    };
+
+    if (escape) {
+      escape = false;
+      if (EscapeSequences[c]) {
+        addChar(EscapeSequences[c]);
+        continue;
+      }
+
+      if (Metachars.escaped[c]) {
+        addMetachar(Metachars.escaped[c]);
+        continue;
+      }
+
+      if (c === 'c') {
+        // \c (not [A-Za-z] ...) = literal \c... (WHY)
+        const next = peek(false);
+        if (next == null || /[^a-zA-Z]/.test(next)) {
+          addChar('\\');
+          addChar('c');
+          continue;
+        }
+
+        // \c[A-Za-z]
+        const code = seek(false).charCodeAt(0);
+        addChar(String.fromCharCode(code % 32));
+        continue;
+      }
+
+      if (c === 'x') {
+        // \x = x
+        // \xH = xH
+        // \x[0-9a-zA-Z][0-9a-zA-Z] = \xAB
+        const next1 = peek(false);
+        const next2 = peek(false, 1);
+
+        // missing a char or invalid hex digit
+        if (next1 == null || next2 == null || !HexDigit.test(next1) || !HexDigit.test(next2)) {
+          addChar('x');
+          continue;
+        }
+
+        const code = parseInt(seek(false) + seek(false), 16);
+        addChar(String.fromCodePoint(code));
+        continue;
+      }
+
+      if (c === 'u') {
+        // '\u' = u
+        // '\uHHH' = uHHH
+        // '\uABCD' = \uABCD
+        const next1 = peek(false);
+        const next2 = peek(false, 1);
+        const next3 = peek(false, 2);
+        const next4 = peek(false, 3);
+
+        // missing a char or invalid hex digit
+        if (next1 == null || next2 == null || next3 == null || next4 == null || !HexDigit.test(next1) || !HexDigit.test(next2) || !HexDigit.test(next3) || !HexDigit.test(next4)) {
+          addChar('u');
+          continue;
+        }
+
+        const code = parseInt(seek(false) + seek(false) + seek(false) + seek(false), 16);
+        addChar(String.fromCodePoint(code));
+        continue;
+      }
+
+      addChar();
+      continue;
+    }
+
+    if (c === '\\') {
+      escape = true;
+      continue;
+    }
+
+    switch (state) {
+      case State.none:
+        if (c === '[') {
+          parents.push(node);
+          node = {
+            type: 'Set',
+            body: [],
+            negated: false
+          };
+
+          parents.at(-1).body.push(node);
+
+          state = State.insideSet;
+          setIndex = 0;
+          continue;
+        }
+
+        if (c === '(') {
+          parents.push(node);
+          node = {
+            type: 'Group',
+            body: []
+          };
+
+          parents.at(-1).body.push(node);
+          continue;
+        }
+
+        if (c === ')') {
+          if (node.type !== 'Group') throw new SyntaxError('Unmatched closing parenthesis');
+
+          node = parents.pop();
+          continue;
+        }
+
+        if (QuantifierKeys.includes(c)) {
+          node.body.at(-1).quantifier = Quantifiers[c];
+
+          // lazy modifier
+          if (peek(false) === '?') node.body.at(-1).lazy = true;
+
+          continue;
+        }
+
+        if (Metachars.unescaped[c]) {
+          addMetachar(Metachars.unescaped[c]);
+          continue;
+        }
+
+        addChar();
+        break;
+
+      case State.insideSet:
+        setIndex++;
+        if (setIndex === 1) {
+          // first char in set
+          if (c === '^') {
+            node.negated = true;
+            continue;
+          }
+        }
+
+        if (c === ']') {
+          state = State.none;
+          node = parents.pop();
+
+          continue;
+        }
+
+        // range
+        if (c === '-') {
+          // start of set (or not char), just literal -
+          if (node.body.at(-1)?.char == null) {
+            addChar(); // add -
+            continue;
+          }
+
+          const from = node.body.pop().char;
+          const [ to, escaped ] = seek();
+
+          // end of set, just literal -
+          if (to == null || (!escaped && to === ']')) {
+            addChar(from); // add from char back
+            i--; // rollback seek
+
+            addChar(); // add -
+            continue;
+          }
+
+          // next char was escaped and a metachar, just literal -
+          if (escaped && Metachars.escaped[to] != null) {
+            i -= 2; // rollback seek
+
+            addChar(); // add -
+            continue;
+          }
+
+          if (to < from) throw new SyntaxError('Range out of order');
+
+          node.body.push(rangeNode(from, to));
+          continue;
+        }
+
+        addChar();
+        break;
+    }
+  }
+
+  // still in a group by the end
+  if (node.type !== 'Expression') throw new SyntaxError('Unmatched opening parenthesis');
+
+  // still in a set by the end
+  if (state === State.insideSet) throw new SyntaxError('Unmatched opening square bracket');
+
+  return out;
+};

package/rhemyn/test/parse.js

@@ -0,0 +1,59 @@
+import util from 'node:util';
+
+import parse from '../parse.js';
+
+const tests = {
+  'a': {},
+  'a(b)': {},
+  'a(b(c))': {},
+  'ab': {},
+  '[ab]': {},
+  '[a-z]': {},
+  'a*': {},
+  'a+': {},
+  'a?': {},
+  'a(b)+': {},
+  '[^a]': {},
+  '[a^]': {},
+  '[^ab]': {},
+  '.': {},
+
+  // not range
+  '[-]': {},
+  '[0-]': {},
+  '[-0]': {},
+  '[\\s-\\S]': {},
+  '[\\s-.]': {},
+
+  '[\\S]': {},
+
+  '\\c': {},
+  '\\c0': {},
+  '\\cJ': {},
+
+  '\\x': {},
+  '\\x0': {},
+  '\\x0g': {},
+  '\\x0a': {},
+
+  '\\u': {},
+  '\\u0': {},
+  '\\u000': {},
+  '\\u000g': {},
+  '\\u000a': {},
+
+  /*
+  // email regexes
+  '^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$': {},
+
+  // input type=email from HTML spec
+  // https://html.spec.whatwg.org/multipage/input.html#email-state-(type=email)
+  // simpler form
+  '^[a-zA-Z0-9.!#$%&’*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\\.[a-zA-Z0-9-]+)*$': {},
+  // full/complex form
+  '^[a-zA-Z0-9.!#$%&\'*+\\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$': {}*/
+};
+
+for (const str in tests) {
+  console.log(str, util.inspect(parse(str), false, null, true));
+}

package/runner/compare.js

@@ -0,0 +1,35 @@
+import { execSync } from 'node:child_process';
+import { pathToFileURL } from 'node:url';
+import fs from 'node:fs';
+
+const [ commitsAgo, file ] = process.argv.slice(2);
+const source = fs.readFileSync(file, 'utf8');
+
+const compileNow = (await import('../compiler/index.js')).default;
+const wasmNow = compileNow(source).byteLength;
+
+execSync(`git checkout HEAD~${commitsAgo}`);
+
+let failed = false;
+
+fs.writeFileSync('tmp.js', source);
+try {
+  execSync(`node runner/index.js tmp.js`);
+} catch {
+  failed = true;
+} finally {
+  fs.rmSync('tmp.js');
+  execSync(`git checkout main`);
+}
+
+console.log();
+
+if (failed) {
+  console.log(`!! failed to compile then`);
+  process.exit();
+}
+
+const wasmThen = Buffer.byteLength(fs.readFileSync('out.wasm'));
+
+console.log(`now: ${wasmNow} bytes`);
+console.log(`${commitsAgo} commit${commitsAgo > 1 ? 's' : ''} ago: ${wasmThen} bytes`);

package/runner/index.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+
+import compile from '../compiler/wrap.js';
+import fs from 'node:fs';
+
+if (process.argv.includes('-compile-hints')) {
+  const v8 = await import('node:v8');
+  v8.setFlagsFromString(`--experimental-wasm-compilation-hints`);
+
+  // see also these flags:
+  // --experimental-wasm-branch-hinting
+  // --experimental-wasm-extended-const
+  // --experimental-wasm-inlining (?)
+  // --experimental-wasm-js-inlining (?)
+  // --experimental-wasm-return-call (on by default)
+}
+
+const file = process.argv.slice(2).find(x => x[0] !== '-');
+if (!file) {
+  if (process.argv.includes('-v')) {
+    // just print version
+    console.log((await import('./version.js')).default);
+    process.exit(0);
+  }
+
+  // run repl if no file given
+  await import('./repl.js');
+
+  // do nothing for the rest of this file
+  await new Promise(() => {});
+}
+
+const source = fs.readFileSync(file, 'utf8');
+
+let cache = '';
+const print = str => {
+  cache += str;
+
+  if (str === '\n') {
+    process.stdout.write(cache);
+    cache = '';
+  } else print('\n');
+};
+
+try {
+  const { exports } = await compile(source, process.argv.includes('--module') ? [ 'module' ] : [], {}, print);
+
+  exports.main();
+  if (cache) process.stdout.write(cache);
+} catch (e) {
+  if (cache) process.stdout.write(cache);
+  console.error(`${e.constructor.name}: ${e.message}`);
+}

package/runner/info.js

@@ -0,0 +1,54 @@
+import compile from '../compiler/wrap.js';
+import fs from 'node:fs';
+
+/* if (globalThis.process) {
+  const v8 = await import('node:v8');
+  v8.setFlagsFromString('--experimental-wasm-gc');
+} */
+
+const raw = process.argv.includes('-raw');
+
+const file = process.argv.slice(2).find(x => x[0] !== '-');
+if (!file) {
+  // run repl if no file given
+  await import('./repl.js');
+
+  // do nothing for the rest of this file
+  await new Promise(() => {});
+}
+
+const source = fs.readFileSync(file, 'utf8');
+
+const underline = x => `\u001b[4m\u001b[1m${x}\u001b[0m`;
+const bold = x => `\u001b[1m${x}\u001b[0m`;
+
+if (!raw) console.log(`\n${underline('source')}\n` + source);
+if (!raw) console.log(`\n\n${underline('processing')}`);
+
+let cache = '';
+const print = str => {
+  cache += str;
+
+  if (str === '\n') {
+    process.stdout.write(cache);
+    cache = '';
+  }
+};
+
+const t0 = performance.now();
+const { wasm, exports } = await compile(source, raw ? [ 'module' ] : [ 'module', 'info' ], {}, print);
+
+if (!raw && typeof Deno === 'undefined') fs.writeFileSync('out.wasm', Buffer.from(wasm));
+
+if (!process.argv.includes('-no-run')) {
+  console.log(`\n\n${underline('output')}`);
+  const t2 = performance.now();
+
+  exports.main();
+  print('\n');
+
+  if (!raw) console.log(bold(`\n\nexecuted in ${(performance.now() - t2).toFixed(2)}ms`));
+}
+
+if (!raw) console.log(bold(`wasm binary is ${wasm.byteLength} bytes`));
+if (!raw) console.log(`total: ${(performance.now() - t0).toFixed(2)}ms`);

package/runner/profile.js

@@ -0,0 +1,47 @@
+import compile from '../compiler/index.js';
+import fs from 'node:fs';
+
+let csv = `phase,time\n`;
+
+csv += `node,${performance.now()}\n`;
+
+const t0 = performance.now();
+const file = process.argv.slice(2).find(x => x[0] !== '-');
+const source = fs.readFileSync(file, 'utf8');
+csv += `read,${performance.now() - t0}\n`;
+
+console.log = x => {
+  if (x.includes(' in ')) {
+    csv += [ 'parse', 'codegen', 'opt', 'sections' ][parseInt(x[0]) - 1] + ',' + x.split(' in ')[1].slice(0, -2) + '\n';
+  }
+};
+
+const wasm = compile(source, [ 'info' ]);
+
+let cache = '';
+const print = str => {
+  cache += str;
+
+  if (str === '\n') {
+    process.stdout.write(cache);
+    cache = '';
+  }
+};
+
+const t1 = performance.now();
+const { instance } = await WebAssembly.instantiate(wasm, {
+  '': {
+    p: i => print(Number(i).toString()),
+    c: i => print(String.fromCharCode(Number(i))),
+    a: c => { if (!Number(c)) throw new Error(`assert failed`); }
+  }
+});
+csv += `inst,${performance.now() - t1}\n`;
+
+const t2 = performance.now();
+instance.exports.m();
+print('\n');
+
+csv += `exec,${performance.now() - t2}`;
+
+fs.writeFileSync(`profile.csv`, csv);

package/runner/repl.js

@@ -0,0 +1,99 @@
+import compile from '../compiler/wrap.js';
+import rev from './version.js';
+
+import repl from 'node:repl';
+
+// process.argv.push('-O0'); // disable opts
+
+globalThis.valtype = 'f64';
+
+const valtypeOpt = process.argv.find(x => x.startsWith('-valtype='));
+if (valtypeOpt) valtype = valtypeOpt.split('=')[1];
+
+console.log(`welcome to porffor rev ${rev.slice(0, 7)}`);
+console.log(`info: using opt ${process.argv.find(x => x.startsWith('-O')) ?? '-O1'} and valtype ${valtype}`);
+console.log();
+
+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}KiB\x1B[0m for ${pages} things using ${wasmPages} Wasm page${wasmPages === 1 ? '' : 's'}\n`;
+
+  const buf = new Uint8Array(mem.buffer);
+
+  for (let i = 0; i < pages; i++) {
+    out += `\x1B[36m${lastPages[i]}\x1B[2m | \x1B[0m`;
+
+    for (let j = 0; j < 50; j++) {
+      const val = buf[i * pageSize + j];
+      if (val === 0) out += '\x1B[2m';
+      out += val.toString(16).padStart(2, '0');
+      if (val === 0) out += '\x1B[0m';
+      out += ' ';
+    }
+    out += '\n';
+  }
+
+  return out;
+};
+
+const alwaysPrev = process.argv.includes('-prev');
+
+let prev = '';
+const run = async (source, _context, _filename, callback, run = true) => {
+  let toRun = prev + source.trim();
+  if (alwaysPrev) prev = toRun + ';\n';
+
+  const { exports, wasm, pages } = await compile(toRun, []);
+  // fs.writeFileSync('out.wasm', Buffer.from(wasm));
+
+  if (run && exports.$) {
+    lastMemory = exports.$;
+    lastPages = [...pages.keys()];
+  }
+
+  const ret = run ? exports.main() : undefined;
+  callback(null, ret);
+
+  if (!alwaysPrev && (source.includes(' = ') || source.includes('let ') || source.includes('var ') || source.includes('const ') || source.includes('function '))) prev = toRun + ';\n';
+  // prev = toRun + ';\n';
+};
+
+const replServer = repl.start({ prompt: '> ', eval: run });
+
+replServer.setupHistory('.repl_history', () => {});
+
+replServer.defineCommand('memory', {
+  help: 'Log Wasm memory',
+  action() {
+    this.clearBufferedCommand();
+    console.log(memoryToString(lastMemory));
+    this.displayPrompt();
+  }
+});
+replServer.defineCommand('asm', {
+  help: 'Log Wasm decompiled bytecode',
+  async action() {
+    this.clearBufferedCommand();
+
+    try {
+      process.argv.push('-opt-funcs');
+      await run('', null, null, () => {}, false);
+      process.argv.pop();
+    } catch { }
+
+    this.displayPrompt();
+  }
+});
+replServer.defineCommand('js', {
+  help: 'Log JS being actually ran',
+  async action() {
+    this.clearBufferedCommand();
+    console.log(prev);
+    this.displayPrompt();
+  }
+});

package/runner/sizes.js

@@ -0,0 +1,38 @@
+import fs from 'node:fs';
+import compile from '../compiler/index.js';
+
+// deno compat
+const textEncoder = new TextEncoder();
+if (typeof process === 'undefined') globalThis.process = { argv: ['', '', ...Deno.args], stdout: { write: str => Deno.writeAllSync(Deno.stdout, textEncoder.encode(str)) } };
+
+let csv = `file,porffor i32 -O0,porffor i32 -O1,porffor i32 -O2,porffor i32 -O3,porffor i64 -O0,porffor i64 -O1,porffor i64 -O2,porffor i64 -O3,porffor f64 -O0, porffor f64 -O1, porffor f64 -O2, porffor f64 -O3\n`;
+const perform = async (file, args) => {
+  process.argv = process.argv.slice(0, 2).concat(args);
+  const source = fs.readFileSync(file, 'utf8');
+
+  const { wasm } = compile(source, []);
+  const size = wasm.byteLength;
+
+  const label = `${file} ${args.join(' ')}`;
+  csv += `${size},`;
+  console.log(label, ' '.repeat(40 - label.length), `${size}b`);
+};
+
+const argsValtypes = [ '-valtype=i32', '-valtype=i64', '-valtype=f64' ];
+const argsOptlevels = [ '-O0', '-O1', '-O2', '-O3' ];
+
+for (const file of [ 'bench/prime_basic.js', 'bench/fib_iter.js', 'test/math_1.js', 'test/math_3.js', 'test/while_1.js', 'test/for_2.js', 'test/unary_3.js', 'test/updateexp_1.js', 'test/eq_3.js', 'test/empty.js' ]) {
+  const niceFile = file.split('/')[1].slice(0, -3);
+  csv += `${niceFile},`;
+
+  for (const x of argsValtypes) {
+    for (const y of argsOptlevels) {
+      await perform(file, [ x, y ]);
+    }
+  }
+
+  csv = csv.slice(0, -1) + '\n';
+}
+
+fs.writeFileSync('sizes.csv', csv);
+console.log(csv);