porffor 0.0.0-05f898f

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 CanadaHonk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,308 @@
+# porffor
+a basic experimental wip *aot* optimizing js -> wasm/c engine/compiler/runtime in js. not serious/intended for (real) use. (this is a straight forward, honest readme)<br>
+age: ~1 month
+
+## design
+porffor is a very unique js engine, due a very different approach. it is seriously limited, but what it can do, it does pretty well. key differences:
+- 100% aot compiled *(not jit)*
+- no constant runtime/preluded code
+- least Wasm imports possible (only stdio)
+
+porffor is mostly built from scratch, the only thing that is not is the parser (using [acorn](https://github.com/acornjs/acorn)). binaryen/etc is not used, we make final wasm binaries ourself. you could imagine it as compiling a language which is a sub (some things unsupported) and super (new/custom apis) set of javascript. not based on any particular spec version, focusing on function/working over spec compliance.
+
+## limitations
+- no full object support yet
+- little built-ins/prototype
+- no async/promise/await
+- no variables between scopes (except args and globals)
+- literal callees only in calls (eg `print()` works, `a = print; a()` does not)
+
+## rhemyn
+rhemyn is porffor's own regex engine; it compiles literal regex to wasm bytecode aot (remind you of anything?). it is quite basic and wip. see [its readme](rhemyn/README.md) for more details.
+
+## 2c
+2c is porffor's own wasm -> c compiler, using generated wasm bytecode and internal info to generate specific and efficient/fast c code. no boilerplate/preluded code or required external files, just for cli binaries (not like wasm2c very much at all).
+
+## supported
+see [optimizations](#optimizations) for opts implemented/supported.
+
+### proposals
+these include some early (stage 1/0) and/or dead (last commit years ago) proposals but *I* think they are pretty neat, so.
+
+#### `Math` proposals (stage 1/0)
+
+- [`Math.clamp` Proposal](https://github.com/Richienb/proposal-math-clamp): `Math.clamp` (stage 0 - last commit april 2023)
+- [`Math` Extensions Proposal](https://github.com/rwaldron/proposal-math-extensions): `Math.scale`, `Math.radians`, `Math.degrees`, `Math.RAD_PER_DEG`, `Math.DEG_PER_RAD` (stage 1 - last commit september 2020)
+- [`Math.signbit` Proposal](https://github.com/tc39/proposal-Math.signbit): `Math.signbit` (stage 1 - last commit february 2020)
+
+### language
+
+- number literals
+- declaring functions
+- calling functions *literal callees only*
+- `return`
+- `let`/`const`/`var` basic declarations
+- some basic integer operators (`+-/*%`)
+- some basic integer bitwise operators (`&|`)
+- equality operators (`==`, `!=`, etc)
+- gt/lt operators (`>`, `<`, `>=`, etc)
+- some unary operators (`!`, `+`, `-`)
+- logical operators (`&&`, `||`)
+- declaring multiple variables in one (`let a, b = 0`)
+- global variables (`var`/none in top scope)
+- functions returning 1 number
+- bool literals as ints (not real type)
+- `if` and `if ... else`
+- anonymous functions
+- setting functions using vars (`const foo = function() { ... }`)
+- arrow functions
+- `undefined`/`null` as ints (hack)
+- update expressions (`a++`, `++b`, `c--`, etc)
+- `for` loops (`for (let i = 0; i < N; i++)`, etc)
+- hack for "chars" as ints (`'X'` -> `88`)
+- *basic* objects (hack)
+- `console.log` (hack)
+- `while` loops
+- `break` and `continue`
+- named export funcs
+- iife support
+- assignment operators (`+=`, `-=`, `>>=`, `&&=`, etc)
+- conditional/ternary operator (`cond ? a : b`)
+- recursive functions
+- bare returns (`return`)
+- `throw` (literals only)
+- basic `try { ... } catch { ... }` (no error given)
+- calling functions with non-matching arguments (eg `f(a, b); f(0); f(1, 2, 3);`)
+- `typeof` mostly (static-ish)
+- runtime errors for undeclared variables (`ReferenceError`), not functions (`TypeError`)
+- array creation via `[]` (eg `let arr = [ 1, 2, 3 ]`)
+- array member access via `arr[ind]` (eg `arr[0]`)
+- string literals (`'hello world'`)
+- string member (char) access via `str[ind]` (eg `str[0]`)
+- string concat (`+`) (eg `'a' + 'b'`)
+- truthy/falsy (eg `!'' == true`)
+- string comparison (eg `'a' == 'a'`, `'a' != 'b'`)
+- nullish coalescing operator (`??`)
+
+### built-ins
+
+- `NaN` and `Infinity` (f64 only)
+- `isNaN()` and `isFinite()` (f64 only)
+- most of `Number` (`MAX_VALUE`, `MIN_VALUE`, `MAX_SAFE_INTEGER`, `MIN_SAFE_INTEGER`, `POSITIVE_INFINITY`, `NEGATIVE_INFINITY`, `EPSILON`, `NaN`, `isNaN`, `isFinite`, `isInteger`, `isSafeInteger`) (some f64 only)
+- some `Math` funcs (`Math.sqrt`, `Math.abs`, `Math.floor`, `Math.sign`, `Math.round`, `Math.trunc`, `Math.clz32`, `Math.fround`, `Math.random`) (f64 only)
+- basic `globalThis` support
+- basic `Boolean` and `Number`
+- basic `eval` (literals only)
+- `Math.random()` using self-made xorshift128+ PRNG
+- some of `performance` (`now()`)
+- some of `Array.prototype` (`at`, `push`, `pop`, `shift`)
+- some of `String.prototype` (`at`, `charAt`, `charCodeAt`)
+
+### custom
+
+- basic `assert` func
+- supports i32, i64, and f64 for valtypes
+- wip SIMD api (docs needed)
+- intrinsic functions (see below)
+- inlining wasm via ``asm`...``\` "macro"
+
+## todo
+no particular order and no guarentees, just what could happen soon™
+
+- arrays
+  - member setting (`arr[0] = 2`)
+  - more of `Array` prototype
+  - arrays/strings inside arrays
+  - destructuring
+  - for .. of
+- strings
+  - member setting
+- objects
+  - basic object expressions (eg `{}`, `{ a: 0 }`)
+- wasm
+  - *basic* wasm engine (interpreter) in js
+- more math operators (`**`, etc)
+- `do { ... } while (...)`
+- rewrite `console.log` to work with strings/arrays
+- exceptions
+  - rewrite to use actual strings (optional?)
+  - `try { } finally { }`
+  - rethrowing inside catch
+- optimizations
+  - rewrite local indexes per func for smallest local header and remove unused idxs
+  - smarter inline selection (snapshots?)
+  - remove const ifs (`if (true)`, etc)
+  - use data segments for initing arrays
+
+## porfformance
+*for the things it supports*, porffor is blazingly faster compared to most interpreters, and engines running without JIT. for those with JIT, it is not that much slower like a traditional interpreter would be.
+
+![Screenshot of comparison chart](https://github.com/CanadaHonk/porffor/assets/19228318/76c75264-cc68-4be1-8891-c06dc389d97a)
+
+## optimizations
+mostly for reducing size. do not really care about compiler perf/time as long as it is reasonable. we do not use/rely on external opt tools (`wasm-opt`, etc), instead doing optimization inside the compiler itself creating even smaller code sizes than `wasm-opt` itself can produce as we have more internal information. (this also enables fast + small runtime use as a potential cursed jit in frontend).
+
+### traditional opts
+- inlining functions (wip, limited)
+- inline const math ops
+- tail calls (behind flag `-tail-call`)
+
+### wasm transforms
+- `local.set`, `local.get` -> `local.tee`
+- `i32.const 0`, `i32.eq` -> `i32.eqz`
+- `i64.extend_i32_s`, `i32.wrap_i64` -> ``
+- `f64.convert_i32_u`, `i32.trunc_sat_f64_s` -> ``
+- `return`, `end` -> `end`
+- change const, convert to const of converted valtype (eg `f64.const`, `i32.trunc_sat_f64_s -> `i32.const`)
+- remove some redundant sets/gets
+- remove unneeded single just used vars
+- remove unneeded blocks (no `br`s inside)
+- remove unused imports
+
+### wasm module
+- type cache/index (no repeated types)
+- no main func if empty (and other exports)
+
+## test262
+porffor can run test262 via some hacks/transforms which remove unsupported features whilst still doing the same asserts (eg simpler error messages using literals only). it currently passes >10% (see latest commit desc for latest and details). use `node test262` to test, it will also show a difference of overall results between the last commit and current results.
+
+## codebase
+- `compiler`: contains the compiler itself
+  - `builtins.js`: all built-ins of the engine (spec, custom. vars, funcs)
+  - `codeGen.js`: code (wasm) generation, ast -> wasm, the bulk of the effort
+  - `decompile.js`: basic wasm decompiler for debug info
+  - `embedding.js`: utils for embedding consts
+  - `encoding.js`: utils for encoding things as bytes as wasm expects
+  - `expression.js`: mapping most operators to an opcode (advanced are as built-ins eg `f64_%`)
+  - `index.js`: doing all the compiler steps, takes code in, wasm out
+  - `opt.js`: self-made wasm bytecode optimizer
+  - `parse.js`: parser simply wrapping acorn
+  - `sections.js`: assembles wasm ops and metadata into a wasm module/file
+  - `wasmSpec.js`: "enums"/info from wasm spec
+  - `wrap.js`: wrapper for compiler which instantiates and produces nice exports
+
+- `runner`: contains utils for running js with the compiler
+  - `index.js`: the main file, you probably want to use this
+  - `info.js`: runs with extra info printed
+  - `repl.js`: basic repl (uses `node:repl`)
+
+- `rhemyn`: contains [rhemyn](#rhemyn) - the regex engine used by porffor
+  - `compile.js`: compiles regex ast into wasm bytecode
+  - `parse.js`: own regex parser
+
+- `test`: contains many test files for majority of supported features
+- `test262`: test262 runner and utils
+
+## usecases
+basically none (other than giving people headaches). potential as a tiny fast advanced expression evaluator (for math)?
+
+## usage
+basically nothing will work :). see files in `test` for examples.
+
+1. clone repo
+2. `npm install`
+3. `node test` to run tests (all should pass)
+4. `node runner path/to/code.js` to run a file (or `node runner` to use wip repl)
+
+you can also use deno (`deno run -A ...` instead of `node ...`), or bun (`bun ...` instead of `node ...`)
+
+### flags
+- `-target=wasm|c|native` (default: `wasm`) to set target output (native compiles c output to binary, see args below)
+- `-target=c|native` only:
+  - `-o=out.c|out.exe|out` to set file to output c or binary
+- `-target=native` only:
+  - `-compiler=clang` to set compiler binary (path/name) to use to compile
+  - `-cO=O3` to set compiler opt argument
+- `-valtype=i32|i64|f64` (default: `f64`) to set valtype
+- `-O0` to disable opt
+- `-O1` (default) to enable basic opt (simplify insts, treeshake wasm imports)
+- `-O2` to enable advanced opt (inlining)
+- `-O3` to enable advanceder opt (precompute const math)
+- `-no-run` to not run wasm output, just compile
+- `-opt-log` to log some opts
+- `-code-log` to log some codegen (you probably want `-funcs`)
+- `-regex-log` to log some regex
+- `-funcs` to log funcs
+- `-opt-funcs` to log funcs after opt
+- `-sections` to log sections as hex
+- `-opt-no-inline` to not inline any funcs
+- `-tail-call` to enable tail calls (experimental + not widely implemented)
+- `-compile-hints` to enable V8 compilation hints (experimental + doesn't seem to do much?)
+
+## vscode extension
+there is a vscode extension in `porffor-for-vscode` which tweaks js syntax highlighting to be nicer with porffor features (eg highlighting wasm inside of inline asm).
+
+## wasm output
+porffor optimizes for size as much as possible. current output is ~as small as possible (even with manual asm editing) for some simple functions.
+
+### example
+this javascript (159 bytes unminified):
+```js
+function isPrime(number) {
+  if (number === 1) return false;
+
+  for (let i = 2; i < number; i++) {
+    if (number % i == 0) return false;
+  }
+
+  return true;
+}
+```
+
+compiles into this wasm, in 7.3ms (just compile time), 90 bytes large (including module):
+```wasm
+(i32) -> (i32) ;; isPrime
+  local.get 0 ;; number
+  i32.const 1
+  i32.eq
+  if ;; label @2
+    i32.const 0
+    return
+  end
+  i32.const 2
+  local.set 1 ;; i
+  loop ;; label @2
+    local.get 1 ;; i
+    local.get 0 ;; number
+    i32.lt_s
+    if ;; label @3
+      local.get 0 ;; number
+      local.get 1 ;; i
+      i32.rem_s
+      i32.eqz
+      if ;; label @4
+        i32.const 0
+        return
+      end
+      local.get 1 ;; i
+      i32.const 1
+      i32.add
+      local.set 1 ;; i
+      br 1 ;; goto @2
+    end
+  end
+  i32.const 1
+end
+```
+
+## isn't this the same as assemblyscript?
+no. they are not alike at all internally and have different goals/ideals:
+- porffor is made as a generic js engine, not for wasm stuff specifically
+- porffor takes in js, not a different language or typescript like assemblyscript
+- porffor is made in pure js and compiles itself, not using binaryen/etc
+- (also I didn't know it existed when I started this)
+
+## faq
+
+### 1. why name
+`purple` in Welsh is `porffor`. why purple?
+- no other js engine is purple colored
+- purple is pretty cool
+- purple apparently represents "ambition", which is.. one word to describe this project
+- the hard to speak name is also the noise your brain makes in reaction to this idea
+
+### 2. why at all
+yes.
+
+### 3. but what about spec compliance?
+lol, no. (sorry.)

package/compiler/2c.js

@@ -0,0 +1,350 @@
+import { read_ieee754_binary64, read_signedLEB128 } from './encoding.js';
+import { Blocktype, Opcodes, Valtype } from './wasmSpec.js';
+import { operatorOpcode } from './expression.js';
+
+const CValtype = {
+  i8: 'char',
+  i16: 'unsigned short', // presume all i16 stuff is unsigned
+  i32: 'long',
+  i32_u: 'unsigned long',
+  i64: 'long long',
+  i64_u: 'unsigned long long',
+
+  f32: 'float',
+  f64: 'double',
+
+  undefined: 'void'
+};
+
+const inv = (obj, keyMap = x => x) => Object.keys(obj).reduce((acc, x) => { acc[keyMap(obj[x])] = x; return acc; }, {});
+const invOpcodes = inv(Opcodes);
+
+for (const x in CValtype) {
+  if (Valtype[x]) CValtype[Valtype[x]] = CValtype[x];
+}
+
+const todo = msg => {
+  class TodoError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = 'TodoError';
+    }
+  }
+
+  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 = 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(), unixIncludes = new Map(), winIncludes = new Map();
+  let out = '';
+
+  for (const x in globals) {
+    const g = globals[x];
+
+    out += `${CValtype[g.type]} ${x} = ${g.init ?? 0}`;
+    out += ';\n';
+  }
+
+  for (const [ x, p ] of pages) {
+    out += `${CValtype[p.type]} ${x.replace(': ', '_').replace(/[^0-9a-zA-Z_]/g, '')}[100]`;
+    out += ';\n';
+  }
+
+  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');
+
+    const sanitize = str => str.replace(/[^0-9a-zA-Z_]/g, _ => String.fromCharCode(97 + _.charCodeAt(0) % 32));
+
+    const returns = f.returns.length === 1;
+
+    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`;
+
+    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} = 0`);
+    }
+
+    if (localKeys.length !== 0) out += '\n';
+
+    let vals = [];
+    const endNeedsCurly = [], ignoreEnd = [];
+    let beginLoop = false, lastCond = false, ifTernary = false;
+    for (let _ = 0; _ < f.wasm.length; _++) {
+      const i = f.wasm[_];
+
+      if (invOperatorOpcode[i[0]]) {
+        const b = vals.pop();
+        const a = vals.pop();
+
+        let op = invOperatorOpcode[i[0]];
+        if (op.length === 3) op = op.slice(0, 2);
+
+        if (['==', '!=', '>', '>=', '<', '<='].includes(op)) lastCond = true;
+          else lastCond = false;
+
+        // vals.push(`${a} ${op} ${b}`);
+        vals.push(`(${removeBrackets(a)} ${op} ${b})`);
+        continue;
+      }
+
+      // misc insts
+      if (i[0] === 0xfc) {
+        switch (i[1]) {
+          // i32_trunc_sat_f64_s
+          case 0x02:
+            vals.push(`(${CValtype.i32})${vals.pop()}`);
+            break;
+
+          // i32_trunc_sat_f64_u
+          case 0x03:
+            vals.push(`(${CValtype.i32})(${CValtype.i32_u})${vals.pop()}`);
+            break;
+        }
+
+        lastCond = false;
+        continue;
+      }
+
+      switch (i[0]) {
+        case Opcodes.i32_const:
+        case Opcodes.i64_const:
+          vals.push(read_signedLEB128(i.slice(1)).toString());
+          break;
+
+        case Opcodes.f64_const:
+          vals.push(read_ieee754_binary64(i.slice(1)).toExponential());
+          break;
+
+        case Opcodes.local_get:
+          vals.push(`${invLocals[i[1]]}`);
+          break;
+
+        case Opcodes.local_set:
+          line(`${invLocals[i[1]]} = ${removeBrackets(vals.pop())}`);
+          break;
+
+        case Opcodes.local_tee:
+          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)(${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 ? ` ${removeBrackets(vals.pop())}` : ''}`);
+          break;
+
+        case Opcodes.if:
+          let cond = removeBrackets(vals.pop());
+          if (!lastCond) {
+            if (cond.startsWith('(long)')) cond = `${cond.slice(6)} == 1e+0`;
+              else cond += ' == 1';
+          }
+
+          ifTernary = i[1] !== Blocktype.void;
+          if (ifTernary) {
+            ifTernary = cond;
+            break;
+          }
+
+          if (beginLoop) {
+            beginLoop = false;
+            line(`while (${cond}) {`, false);
+
+            depth++;
+            endNeedsCurly.push(true);
+            ignoreEnd.push(false, true);
+            break;
+          }
+
+          line(`if (${cond}) {`, false);
+
+          depth++;
+          endNeedsCurly.push(true);
+          ignoreEnd.push(false);
+          break;
+
+        case Opcodes.else:
+          if (ifTernary) break;
+
+          depth--;
+          line(`} else {`, false);
+          depth++;
+          break;
+
+        case Opcodes.loop:
+          // not doing properly, fake a while loop
+          beginLoop = true;
+          break;
+
+        case Opcodes.end:
+          if (ignoreEnd.pop()) break;
+
+          if (ifTernary) {
+            const b = vals.pop();
+            const a = vals.pop();
+            vals.push(`${ifTernary} ? ${a} : ${b}`);
+            break;
+          }
+
+          depth--;
+          if (endNeedsCurly.pop() === true) line('}', false);
+          break;
+
+        case Opcodes.call:
+          let func = funcs.find(x => x.index === i[1]);
+          if (!func) {
+            const importFunc = importFuncs[i[1]];
+            switch (importFunc.name) {
+              case 'print':
+                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(removeBrackets(vals.pop()));
+
+          if (func.returns.length === 1) vals.push(`${sanitize(func.name)}(${args.join(', ')})`)
+            else line(`${sanitize(func.name)}(${args.join(', ')})`);
+
+          break;
+
+        case Opcodes.drop:
+          line(vals.pop());
+          break;
+
+        case Opcodes.br:
+          // ignore
+          // reset "stack"
+          vals = [];
+          break;
+
+        default:
+          log('2c', `unimplemented op: ${invOpcodes[i[0]]}`);
+          // todo(`unimplemented op: ${invOpcodes[i[0]]}`);
+      }
+
+      lastCond = false;
+    }
+
+    if (vals.length === 1 && returns) {
+      line(`return ${vals.pop()}`);
+    }
+
+    out += '}\n\n';
+  }
+
+  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;
+};