porffor 0.0.0-ba812f2 → 0.0.0-beff13f

package/compiler/prototype.js

@@ -23,6 +23,9 @@ const TYPES = {
 
 export const PrototypeFuncs = function() {
   const noUnlikelyChecks = process.argv.includes('-funsafe-no-unlikely-proto-checks');
+  let zeroChecks = process.argv.find(x => x.startsWith('-funsafe-zero-proto-checks='));
+  if (zeroChecks) zeroChecks = zeroChecks.split('=')[1].split(',').reduce((acc, x) => { acc[x.toLowerCase()] = true; return acc; }, {});
+    else zeroChecks = {};
 
   this[TYPES._array] = {
     // lX = local accessor of X ({ get, set }), iX = local index of X, wX = wasm ops of X
@@ -36,7 +39,7 @@ export const PrototypeFuncs = function() {
       [ Opcodes.i32_lt_s ],
       [ Opcodes.if, Blocktype.void ],
       [ Opcodes.local_get, iTmp ],
-      ...length.cachedI32,
+      ...length.getCachedI32(),
       [ Opcodes.i32_add ],
       [ Opcodes.local_set, iTmp ],
       [ Opcodes.end ],
@@ -47,7 +50,7 @@ export const PrototypeFuncs = function() {
       [ Opcodes.i32_lt_s ],
 
       [ Opcodes.local_get, iTmp ],
-      ...length.cachedI32,
+      ...length.getCachedI32(),
       [ Opcodes.i32_ge_s ],
       [ Opcodes.i32_or ],
 
@@ -67,7 +70,7 @@ export const PrototypeFuncs = function() {
     // todo: only for 1 argument
     push: (pointer, length, wNewMember) => [
       // get memory offset of array at last index (length)
-      ...length.cachedI32,
+      ...length.getCachedI32(),
       ...number(ValtypeSize[valtype], Valtype.i32),
       [ Opcodes.i32_mul ],
 
@@ -79,17 +82,17 @@ export const PrototypeFuncs = function() {
 
       // bump array length by 1 and return it
       ...length.setI32([
-        ...length.cachedI32,
+        ...length.getCachedI32(),
         ...number(1, Valtype.i32),
         [ Opcodes.i32_add ]
       ]),
 
-      ...length.get
+      ...length.get()
     ],
 
     pop: (pointer, length) => [
       // if length == 0, noop
-      ...length.cachedI32,
+      ...length.getCachedI32(),
       [ Opcodes.i32_eqz ],
       [ Opcodes.if, Blocktype.void ],
       ...number(UNDEFINED),
@@ -100,13 +103,13 @@ export const PrototypeFuncs = function() {
 
       // decrement length by 1
       ...length.setI32([
-        ...length.cachedI32,
+        ...length.getCachedI32(),
         ...number(1, Valtype.i32),
         [ Opcodes.i32_sub ]
       ]),
 
       // load last element
-      ...length.cachedI32,
+      ...length.getCachedI32(),
       ...number(ValtypeSize[valtype], Valtype.i32),
       [ Opcodes.i32_mul ],
 
@@ -115,7 +118,7 @@ export const PrototypeFuncs = function() {
 
     shift: (pointer, length) => [
       // if length == 0, noop
-      ...length.cachedI32,
+      ...length.getCachedI32(),
       Opcodes.i32_eqz,
       [ Opcodes.if, Blocktype.void ],
       ...number(UNDEFINED),
@@ -126,7 +129,7 @@ export const PrototypeFuncs = function() {
 
       // decrement length by 1
       ...length.setI32([
-        ...length.cachedI32,
+        ...length.getCachedI32(),
         ...number(1, Valtype.i32),
         [ Opcodes.i32_sub ]
       ]),
@@ -140,11 +143,66 @@ export const PrototypeFuncs = function() {
       ...number(pointer + ValtypeSize.i32 + ValtypeSize[valtype], Valtype.i32), // src = base array index + length size + an index
       ...number(pageSize - ValtypeSize.i32 - ValtypeSize[valtype], Valtype.i32), // size = PageSize - length size - an index
       [ ...Opcodes.memory_copy, 0x00, 0x00 ]
+    ],
+
+    fill: (pointer, length, wElement, iTmp) => [
+      ...wElement,
+      [ Opcodes.local_set, iTmp ],
+
+      // use cached length i32 as pointer
+      ...length.getCachedI32(),
+
+      // length - 1 for indexes
+      ...number(1, Valtype.i32),
+      [ Opcodes.i32_sub ],
+
+      // * sizeof value
+      ...number(ValtypeSize[valtype], Valtype.i32),
+      [ Opcodes.i32_mul ],
+
+      ...length.setCachedI32(),
+
+      ...(noUnlikelyChecks ? [] : [
+        ...length.getCachedI32(),
+        ...number(0, Valtype.i32),
+        [ Opcodes.i32_lt_s ],
+        [ Opcodes.if, Blocktype.void ],
+        ...number(pointer),
+        [ Opcodes.br, 1 ],
+        [ Opcodes.end ]
+      ]),
+
+      [ Opcodes.loop, Blocktype.void ],
+
+      // set element using pointer
+      ...length.getCachedI32(),
+      [ Opcodes.local_get, iTmp ],
+      [ Opcodes.store, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(pointer + ValtypeSize.i32) ],
+
+      // pointer - sizeof value
+      ...length.getCachedI32(),
+      ...number(ValtypeSize[valtype], Valtype.i32),
+      [ Opcodes.i32_sub ],
+
+      ...length.setCachedI32(),
+
+      // if pointer >= 0, loop
+      ...length.getCachedI32(),
+      ...number(0, Valtype.i32),
+      [ Opcodes.i32_ge_s ],
+      [ Opcodes.br_if, 0 ],
+
+      [ Opcodes.end ],
+
+      // return this array
+      ...number(pointer)
     ]
   };
 
   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) => {
@@ -166,7 +224,7 @@ export const PrototypeFuncs = function() {
         [ Opcodes.i32_lt_s ],
         [ Opcodes.if, Blocktype.void ],
         [ Opcodes.local_get, iTmp ],
-        ...length.cachedI32,
+        ...length.getCachedI32(),
         [ Opcodes.i32_add ],
         [ Opcodes.local_set, iTmp ],
         [ Opcodes.end ],
@@ -177,7 +235,7 @@ export const PrototypeFuncs = function() {
         [ Opcodes.i32_lt_s ],
 
         [ Opcodes.local_get, iTmp ],
-        ...length.cachedI32,
+        ...length.getCachedI32(),
         [ Opcodes.i32_ge_s ],
         [ Opcodes.i32_or ],
 
@@ -233,27 +291,31 @@ export const PrototypeFuncs = function() {
       return [
         ...wIndex,
         Opcodes.i32_to,
-        [ Opcodes.local_set, iTmp ],
 
-        // index < 0
-        ...(noUnlikelyChecks ? [] : [
+        ...(zeroChecks.charcodeat ? [] : [
+          [ Opcodes.local_set, iTmp ],
+
+          // index < 0
+          ...(noUnlikelyChecks ? [] : [
+            [ Opcodes.local_get, iTmp ],
+            ...number(0, Valtype.i32),
+            [ Opcodes.i32_lt_s ],
+          ]),
+
+          // index >= length
           [ Opcodes.local_get, iTmp ],
-          ...number(0, Valtype.i32),
-          [ Opcodes.i32_lt_s ],
-        ]),
+          ...length.getCachedI32(),
+          [ Opcodes.i32_ge_s ],
 
-        // index >= length
-        [ Opcodes.local_get, iTmp ],
-        ...length.cachedI32,
-        [ Opcodes.i32_ge_s ],
+          ...(noUnlikelyChecks ? [] : [ [ Opcodes.i32_or ] ]),
+          [ Opcodes.if, Blocktype.void ],
+          ...number(NaN),
+          [ Opcodes.br, 1 ],
+          [ Opcodes.end ],
 
-        ...(noUnlikelyChecks ? [] : [ [ Opcodes.i32_or ] ]),
-        [ Opcodes.if, Blocktype.void ],
-        ...number(NaN),
-        [ Opcodes.br, 1 ],
-        [ Opcodes.end ],
+          [ Opcodes.local_get, iTmp ],
+        ]),
 
-        [ Opcodes.local_get, iTmp ],
         ...number(ValtypeSize.i16, Valtype.i32),
         [ Opcodes.i32_mul ],
 

package/compiler/sections.js

@@ -1,5 +1,5 @@
 import { Valtype, FuncType, Empty, ExportDesc, Section, Magic, ModuleVersion, Opcodes, PageSize } from './wasmSpec.js';
-import { encodeVector, encodeString, encodeLocal } from './encoding.js';
+import { encodeVector, encodeString, encodeLocal, unsignedLEB128, signedLEB128 } from './encoding.js';
 import { number } from './embedding.js';
 import { importedFuncs } from './builtins.js';
 
@@ -20,7 +20,7 @@ const chHint = (topTier, baselineTier, strategy) => {
   return (strategy | (baselineTier << 2) | (topTier << 4));
 };
 
-export default (funcs, globals, tags, pages, flags) => {
+export default (funcs, globals, tags, pages, data, flags) => {
   const types = [], typeCache = {};
 
   const optLevel = parseInt(process.argv.find(x => x.startsWith('-O'))?.[2] ?? 1);
@@ -155,13 +155,24 @@ export default (funcs, globals, tags, pages, flags) => {
     encodeVector(types)
   );
 
+  const dataSection = data.length === 0 ? [] : createSection(
+    Section.data,
+    encodeVector(data.map(x => [ 0x00, Opcodes.i32_const, ...signedLEB128(x.offset), Opcodes.end, ...encodeVector(x.bytes) ]))
+  );
+
+  const dataCountSection = data.length === 0 ? [] : createSection(
+    Section.data_count,
+    unsignedLEB128(data.length)
+  );
+
   if (process.argv.includes('-sections')) console.log({
     typeSection: typeSection.map(x => x.toString(16)),
     importSection: importSection.map(x => x.toString(16)),
     funcSection: funcSection.map(x => x.toString(16)),
     globalSection: globalSection.map(x => x.toString(16)),
     exportSection: exportSection.map(x => x.toString(16)),
-    codeSection: codeSection.map(x => x.toString(16))
+    codeSection: codeSection.map(x => x.toString(16)),
+    dataSection: dataSection.map(x => x.toString(16)),
   });
 
   return Uint8Array.from([
@@ -175,6 +186,8 @@ export default (funcs, globals, tags, pages, flags) => {
     ...tagSection,
     ...globalSection,
     ...exportSection,
-    ...codeSection
+    ...dataCountSection,
+    ...codeSection,
+    ...dataSection
   ]);
 };

package/compiler/wrap.js

@@ -1,6 +1,6 @@
 import compile from './index.js';
 import decompile from './decompile.js';
-import fs from 'node:fs';
+// import fs from 'node:fs';
 
 const bold = x => `\u001b[1m${x}\u001b[0m`;
 
@@ -29,16 +29,23 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
 
   if (source.includes('export function')) flags.push('module');
 
-  fs.writeFileSync('out.wasm', Buffer.from(wasm));
+  // fs.writeFileSync('out.wasm', Buffer.from(wasm));
 
   times.push(performance.now() - t1);
   if (flags.includes('info')) console.log(bold(`compiled in ${times[0].toFixed(2)}ms`));
 
+  const getString = pointer => {
+    const length = new Int32Array(memory.buffer, pointer, 1);
+
+    return Array.from(new Uint16Array(memory.buffer, pointer + 4, length)).map(x => String.fromCharCode(x)).join('');
+  };
+
   const t2 = performance.now();
   const { instance } = await WebAssembly.instantiate(wasm, {
     '': {
       p: valtype === 'i64' ? i => print(Number(i).toString()) : i => print(i.toString()),
       c: valtype === 'i64' ? i => print(String.fromCharCode(Number(i))) : i => print(String.fromCharCode(i)),
+      s: valtype === 'i64' ? i => print(getString(Number(i))) : i => print(getString(i)),
       a: c => { if (!Number(c)) throw new Error(`assert failed`); },
       t: _ => performance.now(),
       ...customImports

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.0.0-ba812f2",
+  "version": "0.0.0-beff13f",
   "author": "CanadaHonk",
   "license": "MIT",
   "dependencies": {

package/r.js

@@ -1 +1,39 @@
-/a(b)/.test('hi');
+compareArray.isSameValue = function(a, b) {
+  if (a === 0 && b === 0) return 1 / a === 1 / b;
+  if (a !== a && b !== b) return true;
+
+  return a === b;
+};
+
+function compareArray(a, b) {
+  // if either are nullish
+  if (a == null || b == null) return false;
+
+  // megahack: all arrays from now on will be >0 pointer
+  const _hack = '';
+
+  // hack: enforce type inference of being arrays
+  a ??= [];
+  b ??= [];
+
+  if (b.length !== a.length) {
+    return false;
+  }
+
+  for (var i = 0; i < a.length; i++) {
+    if (!compareArray.isSameValue(b[i], a[i])) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+console.log(compareArray(null, []));
+console.log(compareArray(undefined, []));
+
+console.log(compareArray([], []));
+console.log(compareArray([ 1 ], []));
+console.log(compareArray([ 1 ], [ 1 ]));
+console.log(compareArray([ 1, 2 ], [ 1 ]));
+console.log(compareArray([ 1, 2 ], [ 1, 2 ]));

package/rhemyn/README.md

@@ -31,7 +31,7 @@ made for use with porffor but could possibly be adapted, implementation/library
   - 🟠 lazy modifier (eg `a*?`)
   - 🔴 n repetitions (eg `a{4}`)
   - 🔴 n-m repetitions (eg `a{2,4}`)
-- 🔴 anchors
+- 🔴 assertions
   - 🔴 beginning (eg `^a`)
   - 🔴 end (eg `a$`)
   - 🔴 word boundary assertion (eg `\b\B`)

package/rhemyn/compile.js

@@ -21,7 +21,7 @@ const generate = (node, negated = false, get = true, func = 'test') => {
       out = [
         // set length local
         [ Opcodes.local_get, BasePointer ],
-        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128(0) ],
+        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
         [ Opcodes.local_set, Length ],
 
         // set iter pointer local as base + sizeof i32 initially

package/rhemyn/parse.js

@@ -18,35 +18,35 @@ const getArg = (name, def) => {
 };
 
 // full is spec-compliant but slower. not needed most of the time. (evil)
-const DotChars = ({
+const DotChars = () => ({
   full: [ '\n', '\r', '\u2028', '\u2029' ],
   simple: [ '\n', '\r' ],
   fast: [ '\n' ]
 })[getArg('regex-dot', 'fast')];
 
-const WordChars = ({
+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 = ({
+const WhitespaceChars = () => ({
   full: [ ' ', '\t', '\n', '\r', '\u2028', '\u2029' ],
   simple: [ ' ', '\t', '\n', '\r' ]
 })[getArg('regex-ws', 'simple')];
 
-const Metachars = {
+const _Metachars = () => ({
   unescaped: {
-    '.': [ DotChars, true ], // dot
+    '.': [ 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
+    w: [ WordChars(), false ], // word
+    W: [ WordChars(), true ], // not word
+    s: [ WhitespaceChars(), false ], // whitespace
+    S: [ WhitespaceChars(), true ], // not whitespace
   }
-};
+});
 
 const EscapeSequences = {
   f: '\f',
@@ -60,6 +60,8 @@ const EscapeSequences = {
 const HexDigit = /[0-9a-fA-F]/;
 
 export default str => {
+  const Metachars = _Metachars();
+
   const out = {
     type: 'Expression',
     body: []

package/runner/index.js

@@ -34,12 +34,14 @@ const source = fs.readFileSync(file, 'utf8');
 
 let cache = '';
 const print = str => {
-  cache += str;
+  /* cache += str;
 
   if (str === '\n') {
     process.stdout.write(cache);
     cache = '';
-  }
+  } */
+
+  process.stdout.write(str);
 };
 
 try {
@@ -49,5 +51,5 @@ try {
   if (cache) process.stdout.write(cache);
 } catch (e) {
   if (cache) process.stdout.write(cache);
-  console.error(`${e.constructor.name}: ${e.message}`);
+  console.error(process.argv.includes('-i') ? e : `${e.constructor.name}: ${e.message}`);
 }

package/runner/info.js

@@ -36,7 +36,7 @@ const print = str => {
 };
 
 const t0 = performance.now();
-const { wasm, exports } = await compile(source, raw ? [ 'module' ] : [ 'module', 'info' ], {}, print);
+const { wasm, exports, pages } = await compile(source, raw ? [ 'module' ] : [ 'module', 'info' ], {}, print);
 
 if (!raw && typeof Deno === 'undefined') fs.writeFileSync('out.wasm', Buffer.from(wasm));
 
@@ -51,4 +51,39 @@ if (!process.argv.includes('-no-run')) {
 }
 
 if (!raw) console.log(bold(`wasm binary is ${wasm.byteLength} bytes`));
-if (!raw) console.log(`total: ${(performance.now() - t0).toFixed(2)}ms`);
+if (!raw) console.log(`total: ${(performance.now() - t0).toFixed(2)}ms`);
+
+if (!raw && process.argv.includes('-mem') && exports.$) {
+  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;
+  };
+
+  lastPages = [...pages.keys()];
+  lastMemory = exports.$;
+  console.log(memoryToString(lastMemory));
+}

package/tmp.c

@@ -1,37 +1,58 @@
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <time.h>
+#endif
+
 #include <stdio.h>
 
-double inline f64_f(double x, double y) {
-  return x - (int)(x / y) * y;
+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 isPrime(double number) {
-  double i;
+double fib(double n) {
+  return aux(n, 0e+0, 1e+0);
+}
 
-  if (number < 2e+0) {
-    return 0e+0;
-  }
-  i = 2e+0;
-  while (i < number) {
-    if (f64_f(number, i) == 0e+0) {
-      return 0e+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 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 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);
+  double t = 0;
+
+  t = __performance_now();
+  // Sleep(1000);
+  printf("%f\n", test(4.6e+1, 1e+7));
+  printf("%f\n", (__performance_now() - t));
 }