porffor 0.0.0-ebc0491 → 0.0.0-f74a73a

package/tmp.c

@@ -0,0 +1,58 @@
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <time.h>
+#endif
+
+#include <stdio.h>
+
+double aux(double n, double acc1, double acc2) {
+  if (n == 0e+0) {
+    return acc1;
+  }
+  if (n == 1e+0) {
+    return acc2;
+  }
+  return aux(n - 1e+0, acc2, acc1 + acc2);
+}
+
+double fib(double n) {
+  return aux(n, 0e+0, 1e+0);
+}
+
+double test(double n, double count) {
+  double res = 0;
+  double i = 0;
+
+  i = 0e+0;
+  while (i < count) {
+    res = fib(n);
+    i = i + 1e+0;
+  }
+  return res;
+}
+
+double inline __performance_now() {
+  double _time_out;
+#ifdef _WIN32
+  LARGE_INTEGER _time_freq, _time_t;
+  QueryPerformanceFrequency(&_time_freq);
+  QueryPerformanceCounter(&_time_t);
+  _time_out = ((double)_time_t.QuadPart / _time_freq.QuadPart) * 1000.;
+#else
+  struct timespec _time;
+  clock_gettime(CLOCK_MONOTONIC, &_time);
+  _time_out = _time.tv_nsec / 1000000.;
+#endif
+  return _time_out;
+}
+
+int main() {
+  double t = 0;
+
+  t = __performance_now();
+  // Sleep(1000);
+  printf("%f\n", test(4.6e+1, 1e+7));
+  printf("%f\n", (__performance_now() - t));
+}
+

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));
-}