porffor 0.0.0-ebc0491 → 0.0.0-ee33579

package/runner/index.js

@@ -1,53 +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 = '';
-  }
-};
-
-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}`);
+#!/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 = '';
+  }
+};
+
+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/tmp.c

@@ -0,0 +1,37 @@
+#include <stdio.h>
+
+double inline f64_f(double x, double y) {
+  return x - (int)(x / y) * y;
+}
+
+double isPrime(double number) {
+  double i;
+
+  if (number < 2e+0) {
+    return 0e+0;
+  }
+  i = 2e+0;
+  while (i < number) {
+    if (f64_f(number, i) == 0e+0) {
+      return 0e+0;
+    }
+    i = i + 1e+0;
+  }
+  return 1e+0;
+}
+
+int main() {
+  double sum;
+  double counter;
+
+  sum = 0e+0;
+  counter = 0e+0;
+  while (counter <= 1e+5) {
+    if (isPrime(counter) == 1e+0) {
+      sum = sum + counter;
+    }
+    counter = counter + 1e+0;
+  }
+  printf("%f\n", sum);
+}
+

package/compiler/rhemyn/compile.js

@@ -1,173 +0,0 @@
-import { Blocktype, Opcodes, Valtype, PageSize, ValtypeSize } from '../wasmSpec.js';
-import { signedLEB128, unsignedLEB128 } from '../encoding.js';
-import parse from './parse.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 BYTE pointer
-const Length = 4;
-const Tmp = 5;
-
-const generate = (node, get = true) => {
-  let out = [];
-  switch (node.type) {
-    case 'Expression':
-      out = [
-        // set length local
-        [ Opcodes.local_get, BasePointer ],
-        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128(0) ],
-        [ Opcodes.local_set, Length ],
-
-        // set iter pointer local as base + sizeof i32 initially
-        [ Opcodes.local_get, BasePointer ],
-        ...number(ValtypeSize.i32, Valtype.i32),
-        [ Opcodes.i32_add ],
-        [ 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
-        ...generate(x),
-
-        // reached end without branching out, successful match
-        ...number(1, Valtype.i32),
-        [ Opcodes.return ],
-
-        [ Opcodes.end ],
-
-        // increment iter pointer by sizeof i16
-        [ Opcodes.local_get, IterPointer ],
-        ...number(ValtypeSize.i16, 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, 1 ],
-
-        [ Opcodes.end ],
-
-        // no match, return 0
-        ...number(0, Valtype.i32)
-      ];
-
-      break;
-
-    case 'Character':
-      out = generateChar(node, get);
-      break;
-
-    case 'Set':
-      out = generateSet(node, get);
-      break;
-
-    case 'Group':
-      out = generateGroup(node, get);
-      break;
-
-    case 'Range':
-      out = generateRange(node, get);
-      break;
-  }
-
-  return out;
-};
-
-const getNextChar = () => [
-  // get char from pointer
-  [ Opcodes.local_get, Pointer ],
-  [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(0) ],
-
-  // pointer += sizeof i16
-  [ Opcodes.local_get, Pointer ],
-  ...number(ValtypeSize.i16, Valtype.i32),
-  [ Opcodes.i32_add ],
-  [ Opcodes.local_set, Pointer ]
-];
-
-const checkFailure = () => [
-  // surely we do not need to do this for every single mismatch, right?
-  /* [ Opcodes.if, Blocktype.void ],
-  ...number(0, Valtype.i32),
-  [ Opcodes.return ],
-  [ Opcodes.end ], */
-
-  [ Opcodes.br, 1 ]
-];
-
-const generateChar = (node, get) => {
-  return [
-    ...(get ? getNextChar() : []),
-    ...number(String.fromCharCode(node.char), Valtype.i32),
-    [ Opcodes.i32_ne ],
-    ...checkFailure()
-  ];
-};
-
-const generateSet = (node, get) => {
-  const out = [
-    ...(get ? getNextChar() : []),
-    [ Opcodes.local_set, Tmp ],
-  ];
-
-  for (const x of node.body) {
-    out = [
-      ...out,
-      [ Opcodes.local_get, Tmp ],
-      ...generate(x, false)
-    ];
-  }
-
-  out = out.concat(new Array(node.body.length - 1).fill([ Opcodes.i32_or ]));
-
-  return [
-    ...out,
-    ...checkFailure()
-  ];
-};
-
-const generateGroup = (node, get) => {
-
-};
-
-const generateRange = (node, get) => {
-
-};
-
-
-export const match = regex => {
-
-};
-
-export const test = regex => {
-  const code = generate(parse(regex));
-};
-
-const wasmify = code => {
-  const funcs = [{
-    name: 'exp',
-    export: true,
-    params: [ Valtype.i32 ],
-    returns: [ Valtype.i32 ],
-    locals: {
-      iterPointer: { idx: 1, 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 },
-    }
-  }]
-};

package/compiler/rhemyn/parse.js

@@ -1,125 +0,0 @@
-const State = {
-  none: 0,
-  insideSet: 1
-};
-
-const Quantifiers = {
-  '*': [ 0 ], // 0 -
-  '+': [ 1 ], // 1 -
-  '?': [ 0, 1 ], // 0 - 1
-};
-const QuantifierKeys = Object.keys(Quantifiers);
-
-export default str => {
-  const out = {
-    type: 'Expression',
-    body: []
-  };
-  let node = out, parents = [];
-
-  let state = State.none, escape = false;
-  for (let i = 0; i < str.length; i++) {
-    const c = str[i];
-
-    const addChar = () => {
-      node.body.push({
-        type: 'Character',
-        char: c
-      });
-    };
-
-    const seek = () => {
-      const cNext = str[++i];
-
-      if (cNext === '\\') return str[++i];
-      return cNext;
-    };
-
-    if (escape) {
-      addChar();
-
-      escape = false;
-      continue;
-    }
-
-    if (c === '\\') {
-      escape = true;
-      continue;
-    }
-
-    switch (state) {
-      case State.none:
-        if (c === '[') {
-          parents.push(node);
-          node = {
-            type: 'Set',
-            body: []
-          };
-
-          parents.at(-1).body.push(node);
-
-          state = State.insideSet;
-          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)) {
-          const amount = Quantifiers[c];
-          node.body.at(-1).quantifier = amount;
-          continue;
-        }
-
-        addChar();
-        break;
-
-      case State.insideSet:
-        if (c === ']') {
-          state = State.none;
-          node = parents.pop();
-
-          continue;
-        }
-
-        // range
-        if (c === '-') {
-          const from = node.body.pop().char;
-          const to = seek();
-
-          node.body.push({
-            type: 'Range',
-            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/compiler/rhemyn/test/parse.js

@@ -1,20 +0,0 @@
-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)+': {}
-}
-
-for (const str in tests) {
-  console.log(str, util.inspect(parse(str), false, null, true));
-}