porffor 0.0.0-ee33579 → 0.0.0-f74a73a

package/README.md

@@ -83,6 +83,7 @@ these include some early (stage 1/0) and/or dead (last commit years ago) proposa
 - truthy/falsy (eg `!'' == true`)
 - string comparison (eg `'a' == 'a'`, `'a' != 'b'`)
 - nullish coalescing operator (`??`)
+- `for...of` (arrays and strings)
 
 ### built-ins
 
@@ -114,7 +115,6 @@ no particular order and no guarentees, just what could happen soon™
   - more of `Array` prototype
   - arrays/strings inside arrays
   - destructuring
-  - for .. of
 - strings
   - member setting
 - objects

package/compiler/2c.js

@@ -34,18 +34,24 @@ const todo = msg => {
   throw new TodoError(`todo: ${msg}`);
 };
 
+const removeBrackets = str => str.startsWith('(') && str.endsWith(')') ? str.slice(1, -1) : str;
+
 export default ({ funcs, globals, tags, exceptions, pages }) => {
-  const invOperatorOpcode = inv(operatorOpcode[valtype]);
+  const invOperatorOpcode = Object.values(operatorOpcode).reduce((acc, x) => {
+    for (const k in x) {
+      acc[x[k]] = k;
+    }
+    return acc;
+  }, {});
   const invGlobals = inv(globals, x => x.idx);
 
-  const includes = new Map();
+  const includes = new Map(), unixIncludes = new Map(), winIncludes = new Map();
   let out = '';
 
   for (const x in globals) {
     const g = globals[x];
 
-    out += `${CValtype[g.type]} ${x}`;
-    if (x.init) out += ` ${x.init}`;
+    out += `${CValtype[g.type]} ${x} = ${g.init ?? 0}`;
     out += ';\n';
   }
 
@@ -56,7 +62,43 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
 
   if (out) out += '\n';
 
+  let depth = 1;
+  const line = (str, semi = true) => out += `${' '.repeat(depth * 2)}${str}${semi ? ';' : ''}\n`;
+  const lines = lines => {
+    for (const x of lines) {
+      out += `${' '.repeat(depth * 2)}${x}\n`;
+    }
+  };
+
+  const platformSpecific = (win, unix, add = true) => {
+    let tmp = '';
+
+    if (win) {
+      if (add) out += '#ifdef _WIN32\n';
+        else tmp += '#ifdef _WIN32\n';
+
+      if (add) lines(win.split('\n'));
+        else tmp += win + (win.endsWith('\n') ? '' : '\n');
+    }
+
+    if (unix) {
+      if (add) out += (win ? '#else' : '#ifndef _WIN32') + '\n';
+        else tmp += (win ? '#else' : '#ifndef _WIN32') + '\n';
+
+      if (add) lines(unix.split('\n'));
+        else tmp += unix + (unix.endsWith('\n') ? '' : '\n');
+    }
+
+    if (win || unix)
+      if (add) out += '#endif\n';
+        else tmp += '#endif\n';
+
+    return tmp;
+  };
+
   for (const f of funcs) {
+    depth = 1;
+
     const invLocals = inv(f.locals, x => x.idx);
     if (f.returns.length > 1) todo('funcs returning >1 value unsupported');
 
@@ -64,16 +106,13 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
 
     const returns = f.returns.length === 1;
 
-    const shouldInline = ['f64_%'].includes(f.name);
+    const shouldInline = f.internal;
     out += `${f.name === 'main' ? 'int' : CValtype[f.returns[0]]} ${shouldInline ? 'inline ' : ''}${sanitize(f.name)}(${f.params.map((x, i) => `${CValtype[x]} ${invLocals[i]}`).join(', ')}) {\n`;
 
-    let depth = 1;
-    const line = (str, semi = true) => out += `${' '.repeat(depth * 2)}${str}${semi ? ';' : ''}\n`;
-
     const localKeys = Object.keys(f.locals).sort((a, b) => f.locals[a].idx - f.locals[b].idx).slice(f.params.length).sort((a, b) => f.locals[a].idx - f.locals[b].idx);
     for (const x of localKeys) {
       const l = f.locals[x];
-      line(`${CValtype[l.type]} ${x}`);
+      line(`${CValtype[l.type]} ${x} = 0`);
     }
 
     if (localKeys.length !== 0) out += '\n';
@@ -94,7 +133,8 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
         if (['==', '!=', '>', '>=', '<', '<='].includes(op)) lastCond = true;
           else lastCond = false;
 
-        vals.push(`${a} ${op} ${b}`);
+        // vals.push(`${a} ${op} ${b}`);
+        vals.push(`(${removeBrackets(a)} ${op} ${b})`);
         continue;
       }
 
@@ -118,6 +158,7 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
 
       switch (i[0]) {
         case Opcodes.i32_const:
+        case Opcodes.i64_const:
           vals.push(read_signedLEB128(i.slice(1)).toString());
           break;
 
@@ -130,24 +171,42 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
           break;
 
         case Opcodes.local_set:
-          line(`${invLocals[i[1]]} = ${vals.pop()}`);
+          line(`${invLocals[i[1]]} = ${removeBrackets(vals.pop())}`);
           break;
 
         case Opcodes.local_tee:
-          vals.push(`${invLocals[i[1]]} = ${vals.pop()}`);
+          line(`${invLocals[i[1]]} = ${removeBrackets(vals.pop())}`);
+          vals.push(`${invLocals[i[1]]}`);
+          // vals.push(`${invLocals[i[1]]} = ${vals.pop()}`);
+          break;
+
+        case Opcodes.global_get:
+          vals.push(`${invGlobals[i[1]]}`);
+          break;
+
+        case Opcodes.global_set:
+          line(`${invGlobals[i[1]]} = ${removeBrackets(vals.pop())}`);
           break;
 
         case Opcodes.f64_trunc:
           // vals.push(`trunc(${vals.pop()})`);
-          vals.push(`(int)(${vals.pop()})`); // this is ~10x faster with clang. what the fuck.
+          vals.push(`(int)(${removeBrackets(vals.pop())})`); // this is ~10x faster with clang??
+          break;
+
+        case Opcodes.f64_convert_i32_u:
+        case Opcodes.f64_convert_i32_s:
+        case Opcodes.f64_convert_i64_u:
+        case Opcodes.f64_convert_i64_s:
+          // int to double
+          vals.push(`(double)${vals.pop()}`);
           break;
 
         case Opcodes.return:
-          line(`return${returns ? ` ${vals.pop()}` : ''}`);
+          line(`return${returns ? ` ${removeBrackets(vals.pop())}` : ''}`);
           break;
 
         case Opcodes.if:
-          let cond = vals.pop();
+          let cond = removeBrackets(vals.pop());
           if (!lastCond) {
             if (cond.startsWith('(long)')) cond = `${cond.slice(6)} == 1e+0`;
               else cond += ' == 1';
@@ -212,12 +271,44 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
                 line(`printf("%f\\n", ${vals.pop()})`);
                 includes.set('stdio.h', true);
                 break;
+
+              case 'time':
+                line(`double _time_out`);
+                /* platformSpecific(
+`FILETIME _time_filetime;
+GetSystemTimeAsFileTime(&_time_filetime);
+
+ULARGE_INTEGER _time_ularge;
+_time_ularge.LowPart = _time_filetime.dwLowDateTime;
+_time_ularge.HighPart = _time_filetime.dwHighDateTime;
+_time_out = (_time_ularge.QuadPart - 116444736000000000i64) / 10000.;`,
+`struct timespec _time;
+clock_gettime(CLOCK_MONOTONIC, &_time);
+_time_out = _time.tv_nsec / 1000000.;`); */
+                platformSpecific(
+`LARGE_INTEGER _time_freq, _time_t;
+QueryPerformanceFrequency(&_time_freq);
+QueryPerformanceCounter(&_time_t);
+_time_out = ((double)_time_t.QuadPart / _time_freq.QuadPart) * 1000.;`,
+`struct timespec _time;
+clock_gettime(CLOCK_MONOTONIC, &_time);
+_time_out = _time.tv_nsec / 1000000.;`);
+                vals.push(`_time_out`);
+
+                unixIncludes.set('time.h', true);
+                winIncludes.set('windows.h', true);
+                break;
+
+              default:
+                log('2c', `unimplemented import: ${importFunc.name}`);
+                break;
             }
+
             break;
           }
 
           let args = [];
-          for (let j = 0; j < func.params.length; j++) args.unshift(vals.pop());
+          for (let j = 0; j < func.params.length; j++) args.unshift(removeBrackets(vals.pop()));
 
           if (func.returns.length === 1) vals.push(`${sanitize(func.name)}(${args.join(', ')})`)
             else line(`${sanitize(func.name)}(${args.join(', ')})`);
@@ -249,7 +340,11 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
     out += '}\n\n';
   }
 
-  out = [...includes.keys()].map(x => `#include <${x}>`).join('\n') + '\n\n' + out;
+  depth = 0;
+
+  const makeIncludes = includes => [...includes.keys()].map(x => `#include <${x}>\n`).join('');
+
+  out = platformSpecific(makeIncludes(winIncludes), makeIncludes(unixIncludes), false) + '\n' + makeIncludes(includes) + '\n' + out;
 
   return out;
 };

package/compiler/codeGen.js

@@ -109,8 +109,8 @@ const generate = (scope, decl, global = false, name = undefined) => {
     case 'WhileStatement':
       return generateWhile(scope, decl);
 
-    /* case 'ForOfStatement':
-      return generateForOf(scope, decl); */
+    case 'ForOfStatement':
+      return generateForOf(scope, decl);
 
     case 'BreakStatement':
       return generateBreak(scope, decl);
@@ -732,17 +732,11 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
   ];
 };
 
-let binaryExpDepth = 0;
 const generateBinaryExp = (scope, decl, _global, _name) => {
-  binaryExpDepth++;
-
-  const out = [
-    ...performOp(scope, decl.operator, generate(scope, decl.left), generate(scope, decl.right), getNodeType(scope, decl.left), getNodeType(scope, decl.right), _global, _name)
-  ];
+  const out = performOp(scope, decl.operator, generate(scope, decl.left), generate(scope, decl.right), getNodeType(scope, decl.left), getNodeType(scope, decl.right), _global, _name);
 
   if (valtype !== 'i32' && ['==', '===', '!=', '!==', '>', '>=', '<', '<='].includes(decl.operator)) out.push(Opcodes.i32_from_u);
 
-  binaryExpDepth--;
   return out;
 };
 
@@ -1567,7 +1561,7 @@ const generateUpdate = (scope, decl) => {
 };
 
 const generateIf = (scope, decl) => {
-  const out = truthy(scope, generate(scope, decl.test), decl.test);
+  const out = truthy(scope, generate(scope, decl.test), getNodeType(scope, decl.test));
 
   out.push(Opcodes.i32_to, [ Opcodes.if, Blocktype.void ]);
   depth.push('if');
@@ -1660,18 +1654,106 @@ const generateWhile = (scope, decl) => {
 const generateForOf = (scope, decl) => {
   const out = [];
 
+  const rightType = getNodeType(scope, decl.right);
+  const valtypeSize = rightType === TYPES._array ? ValtypeSize[valtype] : ValtypeSize.i16; // presume array (:()
+
+  // todo: for of inside for of might fuck up?
+  const pointer = localTmp(scope, 'forof_base_pointer', Valtype.i32);
+  const length = localTmp(scope, 'forof_length', Valtype.i32);
+  const counter = localTmp(scope, 'forof_counter', Valtype.i32);
+
+  out.push(
+    // set pointer as right
+    ...generate(scope, decl.right),
+    Opcodes.i32_to_u,
+    [ Opcodes.local_set, pointer ],
+
+    // get length
+    [ Opcodes.local_get, pointer ],
+    [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+    [ Opcodes.local_set, length ]
+  );
+
   out.push([ Opcodes.loop, Blocktype.void ]);
-  depth.push('while');
+  depth.push('forof');
 
-  out.push(...generate(scope, decl.test));
-  out.push(Opcodes.i32_to, [ Opcodes.if, Blocktype.void ]);
-  depth.push('if');
+  // setup local for left
+  generate(scope, decl.left);
 
-  out.push(...generate(scope, decl.body));
+  const leftName = decl.left.declarations[0].id.name;
 
-  out.push([ Opcodes.br, 1 ]);
-  out.push([ Opcodes.end ], [ Opcodes.end ]);
-  depth.pop(); depth.pop();
+  // set type for local
+  typeStates[leftName] = rightType === TYPES._array ? TYPES.number : TYPES.string;
+
+  const [ local, isGlobal ] = lookupName(scope, leftName);
+
+  if (rightType === TYPES._array) { // array
+    out.push(
+      [ Opcodes.local_get, pointer ],
+      [ Opcodes.load, Math.log2(valtypeSize) - 1, ...unsignedLEB128(ValtypeSize.i32) ]
+    );
+  } else { // string
+    const [ newOut, newPointer ] = makeArray(scope, {
+      rawElements: new Array(1)
+    }, isGlobal, leftName, true, 'i16');
+
+    out.push(
+      // setup new/out array
+      ...newOut,
+      [ Opcodes.drop ],
+
+      ...number(0, Valtype.i32), // base 0 for store after
+
+      // load current string ind {arg}
+      [ Opcodes.local_get, pointer ],
+      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+
+      // store to new string ind 0
+      [ Opcodes.i32_store16, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
+
+      // return new string (page)
+      ...number(newPointer)
+    );
+  }
+
+  // set left value
+  out.push([ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx ]);
+
+  out.push(
+    [ Opcodes.block, Blocktype.void ],
+    [ Opcodes.block, Blocktype.void ]
+  );
+  depth.push('block');
+  depth.push('block');
+
+  out.push(
+    ...generate(scope, decl.body),
+    [ Opcodes.end ]
+  );
+  depth.pop();
+
+  out.push(
+    // increment iter pointer by valtype size
+    [ Opcodes.local_get, pointer ],
+    ...number(valtypeSize, Valtype.i32),
+    [ Opcodes.i32_add ],
+    [ Opcodes.local_set, pointer ],
+
+    // increment counter by 1
+    [ Opcodes.local_get, counter ],
+    ...number(1, Valtype.i32),
+    [ Opcodes.i32_add ],
+    [ Opcodes.local_tee, counter ],
+
+    // loop if counter != length
+    [ Opcodes.local_get, length ],
+    [ Opcodes.i32_ne ],
+    [ Opcodes.br_if, 1 ],
+
+    [ Opcodes.end ], [ Opcodes.end ]
+  );
+  depth.pop();
+  depth.pop();
 
   return out;
 };

package/compiler/index.js

@@ -100,10 +100,10 @@ export default (code, flags) => {
 
   if (target === 'native') {
     const compiler = getArg('compiler') ?? 'clang';
-    const cO = getArg('cO') ?? 'O3';
+    const cO = getArg('cO') ?? 'Ofast';
 
     const tmpfile = 'tmp.c';
-    const args = [ compiler, tmpfile, '-o', outFile ?? (process.platform === 'win32' ? 'out.exe' : 'out'), '-' + cO ];
+    const args = [ compiler, tmpfile, '-o', outFile ?? (process.platform === 'win32' ? 'out.exe' : 'out'), '-' + cO, '-march=native' ];
 
     const c = toc(out);
     writeFileSync(tmpfile, c);

package/compiler/parse.js

@@ -1,5 +1,5 @@
-import { parse } from 'acorn';
-// const { parse } = (await import(globalThis.document ? 'https://esm.sh/acorn' : 'acorn'));
+// import { parse } from 'acorn';
+const { parse } = (await import(globalThis.document ? 'https://esm.sh/acorn' : 'acorn'));
 
 export default (input, flags) => {
   return parse(input, {

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-ee33579",
+  "version": "0.0.0-f74a73a",
   "author": "CanadaHonk",
   "license": "MIT",
   "dependencies": {

package/r.js

@@ -1 +1 @@
-/a(b)/.test('hi');
+print(performance.now());

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/runner/index.js

@@ -49,5 +49,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/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));
 }