porffor 0.14.0-f67c123a1 → 0.16.0-08983b6b1

package/CONTRIBUTING.md

@@ -26,7 +26,7 @@ You can also swap out `node` in the alias to use another runtime like Deno (`den
 
 ### Precompile
 
-**If you update any file inside `compiler/builtins` you will need to do this for it to update inside Porffor otherwise your changes will have no effect.** Run `node compiler/precompile.js` to precompile. It may error during this, if so, you might have an error in your code or there could be a compiler error with Porffor (feel free to ask for help as soon as you encounter any errors with it).
+**If you update any file inside `compiler/builtins` you will need to do this for it to update inside Porffor otherwise your changes will have no effect.** Run `./porf precompile` to precompile. It may error during this, if so, you might have an error in your code or there could be a compiler error with Porffor (feel free to ask for help as soon as you encounter any errors with it).
 
 <br>
 
@@ -98,7 +98,7 @@ Loads the character code at the pointer `pointer` **for a String**.[^1]
 Porffor.wasm.i32.store(pointer, length, 0, 0)
 ```
 
-Stores the length `length` at pointer `pointer`, setting the length of an object. This is mostly unneeded today as you can just do `obj.length = length`. [^2]
+Stores the length `length` at pointer `pointer`, setting the length of an object. This is mostly unneeded today as you can just do `obj.length = length`. (The `0, 4` args are necessary for the Wasm instruction, but you don't need to worry about them (`0` alignment, `0` byte offset).
 
 <br>
 
@@ -198,11 +198,15 @@ Store the character code into the `out` pointer variable, and increment it.
 
 ## Porffor-specific TS notes
 
-- For declaring variables, you must use explicit type annotations currently (eg `let a: number = 1`, not `let a = 1`)
+- For declaring variables, you must use explicit type annotations currently (eg `let a: number = 1`, not `let a = 1`).
 - You might spot `Porffor.fastOr`/`Porffor.fastAnd`, these are non-short circuiting versions of `||`/`&&`, taking any number of conditions as arguments. You shouldn't don't need to use or worry about these.
-- **There are ~no objects, you cannot use them/literals.**
+- **There are ~no objects, you cannot use them.**
 - Attempt to avoid string/array-heavy code and use more variables instead if possible, easier on memory and CPU/perf.
 - Do not set a return type for prototype methods, it can cause errors/unexpected results.
+- You cannot use other functions in the file not exported, or variables not inside the current function.
+- `if (...)` uses a fast truthy implementation which is not spec-compliant as most conditions should be strictly checked. To use spec-compliant behavior, use `if (Boolean(...))`.
+- For object (string/array/etc) literals, you must use a variable eg `const out: bytestring = 'foobar'; console.log(out);` instead of `console.log('foobar')` due to precompile's allocator constraints.
+- Generally prefer/use non-strict equality ops (`==`/`!=`).
 
 <br>
 
@@ -229,9 +233,13 @@ builtins/tostring_number: impl radix
 
 ## Test262
 
-Make sure you have Test262 cloned already **inside of `test262/`** (`git clone https://github.com/tc39/test262.git test262/test262`) and run `npm install` inside `test262/` too.
+For the first time, ensure you run `./test262/setup.sh`.
 
-Run `node test262` to run all the tests and get an output of total overall test results. The main thing you want to pay attention to is the emoji summary (lol):
+Run `node test262` to run all the tests and get an output of total overall test results.
+
+Warning: this will consume 1-6GB of memory and ~90% of all CPU cores while running (depending on thread count), it should take 15-120s depending on machine. You can specify how many threads with `--threads=N`, it will use the number of CPU threads by default.
+
+The main thing you want to pay attention to is the emoji summary (lol):
 ```
 🧪 50005 | 🤠 7007 (-89) | ❌ 1914 (-32) | 💀 13904 (-61) | 📝 23477 (-120) | ⏰ 2 | 🏗 2073 (+302) | 💥 1628
 ```
@@ -239,7 +247,7 @@ Run `node test262` to run all the tests and get an output of total overall test
 To break this down:
 🧪 total 🤠 pass ❌ fail 💀 runtime error 📝 todo (error) ⏰ timeout 🏗️ wasm compile error 💥 compile error
 
-The diff compared to the last commit (with test262 data) is shown in brackets. Basically, you can passes 🤠 up, and errors 💀📝🏗💥 down. It is fine if some errors change balance/etc, as long as they are not new failures.
+The diff compared to the last commit (with test262 data) is shown in brackets. Basically, you want passes 🤠 up, and errors 💀📝🏗💥 down. It is fine if some errors change balance/etc, as long as they are not new failures.
 
 It will also log new passes/fails. Be careful as sometimes the overall passes can increase, but other files have also regressed into failures which you might miss. Also keep in mind some tests may have been false positives before, but we can investigate the diff together :)
 
@@ -251,6 +259,4 @@ It will also log new passes/fails. Be careful as sometimes the overall passes ca
 
 <br>
 
-[^1]: The `0, 4` args are necessary for the Wasm instruction, but you don't need to worry about them (`0` alignment, `4` byte offset for length).
-
-[^2]: The `0, 4` args are necessary for the Wasm instruction, but you don't need to worry about them (`0` alignment, `0` byte offset).
+[^1]: The `0, 4` args are necessary for the Wasm instruction, but you don't need to worry about them (`0` alignment, `4` byte offset for length).

package/README.md

@@ -14,7 +14,7 @@ Porffor is primarily built from scratch, the only thing that is not is the parse
 Expect nothing to work! Only very limited JS is currently supported. See files in `bench` for examples.
 
 ### Install
-**`npm install -g porffor`**. It's that easy (hopefully) :)
+**`npm install -g porffor@latest`**. It's that easy (hopefully) :)
 
 ### Trying a REPL
 **`porf`**. Just run it with no script file argument.
@@ -29,7 +29,7 @@ Expect nothing to work! Only very limited JS is currently supported. See files i
 > [!WARNING]
 > Compiling to native binaries uses [2c](#2c), Porffor's own Wasm -> C compiler, which is experimental.
 
-**`porf native path/to/script.js out(.exe)`**. You can specify the compiler with `--compiler=clang/zig/gcc`, and which opt level to use with `--cO=O3` (`Ofast` by default). Output binaries are also stripped by default.
+**`porf native path/to/script.js out(.exe)`**. You can specify the compiler with `--compiler=clang|gcc|zig` (`clang` by default), and which optimization level to use with `--cO=Ofast|O3|O2|O1|O0` (`Ofast` by default). Output binaries are also stripped by default.
 
 ### Compiling to C
 > [!WARNING]
@@ -49,7 +49,7 @@ Expect nothing to work! Only very limited JS is currently supported. See files i
 
 **`porf debug path/to/script.js`**
 
-### Profiling the generated Wasm of a JS file
+### Debugging the compiled Wasm of a JS file
 > [!WARNING]
 > Very experimental WIP feature!
 
@@ -63,26 +63,14 @@ Expect nothing to work! Only very limited JS is currently supported. See files i
 - `--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). unstable
-- `-O3` to enable advanceder opt (precompute const math). unstable
-- `--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
-- `--ast-log` to log AST
-- `--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?)
+- `-O2` to enable advanced opt (inlining). unstable!
+- `-O3` to enable advanceder opt (precompute const math). unstable!
 
 ## 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)
 - No `eval()` etc (since it is AOT)
 
 ## Sub-engines
@@ -112,7 +100,7 @@ These include some early (stage 1/0) and/or dead (last commit years ago) proposa
 
 - Number literals
 - Declaring functions
-- Calling functions *literal callees only*
+- Calling functions
 - `return`
 - `let`/`const`/`var` basic declarations
 - Some basic integer operators (`+-/*%`)
@@ -266,8 +254,6 @@ Basically none right now (other than giving people headaches). Potential ideas:
 No particular order and no guarentees, just what could happen soon™
 
 - Arrays
-  - More of `Array` prototype
-  - Arrays/strings inside arrays
   - Destructuring
 - Objects
   - Basic object expressions (eg `{}`, `{ a: 0 }`)
@@ -315,16 +301,10 @@ Porffor intentionally does not use Wasm proposals which are not commonly impleme
 
 - Multi-value **(required)**
 - Non-trapping float-to-int conversions **(required)**
-- Bulk memory operations (required, but uncommonly used)
-- Exception handling (optional, for errors)
+- Bulk memory operations (optional, can get away without sometimes)
+- Exception handling (optional, only for errors)
 - Tail calls (opt-in, off by default)
 
-## Isn't this the same as AssemblyScript/other Wasm langs?
-No. they are not alike at all internally and have very different goals/ideals:
-- Porffor is made as a generic JS engine, not for Wasm stuff specifically
-- Porffor primarily consumes JS
-- Porffor is written in pure JS and compiles itself, not using Binaryen/etc
-- (Also I didn't know it existed when I started this, lol)
 
 ## FAQ
 
@@ -338,5 +318,9 @@ No. they are not alike at all internally and have very different goals/ideals:
 ### 2. Why at all?
 Yes!
 
-### 3. But what about spec compliance?
-Lol, no. (sorry.)
+## 3. Isn't this the same as AssemblyScript/other Wasm langs?
+No. they are not alike at all internally and have very different goals/ideals:
+- Porffor is made as a generic JS engine, not for Wasm stuff specifically
+- Porffor primarily consumes JS
+- Porffor is written in pure JS and compiles itself, not using Binaryen/etc
+- (Also I didn't know it existed when I started this, lol)

package/asur/index.js

@@ -1155,7 +1155,7 @@ if (bc.porfFunc && paused && op) {
   switch (byg(
     paused,
     funcLines[currentFunc] + currentLine,
-    '\x1b[1masur\x1b[22m: ' + callStack.join(' -> ') + (parents.length > 1 ? \` | \${parents.slice(1).map(x => invOpcodes[x.opcode]).join(' -> ')}\` : ''),
+    '\x1b[1masur debugger\x1b[22m: ' + callStack.join(' -> ') + (parents.length > 1 ? \` | \${parents.slice(1).map(x => invOpcodes[x.opcode]).join(' -> ')}\` : ''),
     [
       {
         x: termWidth - 1 - width - 6,

package/compiler/2c.js

@@ -2,10 +2,11 @@ import { read_ieee754_binary64, read_signedLEB128, read_unsignedLEB128 } from '.
 import { Blocktype, Opcodes, Valtype } from './wasmSpec.js';
 import { operatorOpcode } from './expression.js';
 import { log } from './log.js';
+import Prefs from './prefs.js';
 
 const CValtype = {
-  i8: 'i8',
-  i16: 'i16',
+  i8: 'u8',
+  i16: 'u16',
   i32: 'i32',
   u32: 'u32',
   i64: 'i64',
@@ -17,8 +18,8 @@ const CValtype = {
   undefined: 'void'
 };
 
-const alwaysPreface = `typedef uint8_t i8;
-typedef uint16_t i16;
+const alwaysPreface = `typedef uint8_t u8;
+typedef uint16_t u16;
 typedef int32_t i32;
 typedef uint32_t u32;
 typedef int64_t i64;
@@ -29,72 +30,123 @@ typedef double f64;
 f64 NAN = 0e+0/0e+0;
 
 struct ReturnValue {
-  ${CValtype.f64} value;
-  ${CValtype.i32} type;
+  f64 value;
+  i32 type;
 };\n\n`;
 
-// todo: is memcpy/etc safe with host endianness?
+// todo: review whether 2cMemcpy should be default or not
 
 // all:
 // immediates: ['align', 'offset']
-const CMemFuncs = {
+const CMemFuncs = Prefs['2cMemcpy'] ? {
   [Opcodes.i32_store]: {
     c: `memcpy(_memory + offset + pointer, &value, sizeof(value));`,
     args: ['pointer', 'value'],
-    argTypes: [CValtype.i32, CValtype.i32],
+    argTypes: ['i32', 'i32'],
     returns: false
   },
   [Opcodes.i32_store16]: {
     c: `memcpy(_memory + offset + pointer, &value, sizeof(value));`,
     args: ['pointer', 'value'],
-    argTypes: [CValtype.i32, CValtype.i16],
+    argTypes: ['i32', 'u16'],
     returns: false
   },
   [Opcodes.i32_store8]: {
     c: `memcpy(_memory + offset + pointer, &value, sizeof(value));`,
     args: ['pointer', 'value'],
-    argTypes: [CValtype.i32, CValtype.i8],
+    argTypes: ['i32', 'u8'],
     returns: false
   },
 
   [Opcodes.i32_load]: {
-    c: `${CValtype.i32} out;
+    c: `i32 out;
 memcpy(&out, _memory + offset + pointer, sizeof(out));
 return out;`,
     args: ['pointer'],
-    argTypes: [CValtype.i32],
-    returns: CValtype.i32
+    argTypes: ['i32'],
+    returns: 'i32'
   },
   [Opcodes.i32_load16_u]: {
-    c: `${CValtype.i16} out;
+    c: `u16 out;
 memcpy(&out, _memory + offset + pointer, sizeof(out));
 return out;`,
     args: ['pointer'],
-    argTypes: [CValtype.i32],
-    returns: CValtype.i32
+    argTypes: ['i32'],
+    returns: 'i32'
   },
   [Opcodes.i32_load8_u]: {
-    c: `${CValtype.i8} out;
+    c: `u8 out;
 memcpy(&out, _memory + offset + pointer, sizeof(out));
 return out;`,
     args: ['pointer'],
-    argTypes: [CValtype.i32],
-    returns: CValtype.i32
+    argTypes: ['i32'],
+    returns: 'i32'
   },
 
   [Opcodes.f64_store]: {
     c: `memcpy(_memory + offset + pointer, &value, sizeof(value));`,
     args: ['pointer', 'value'],
-    argTypes: [CValtype.i32, CValtype.f64],
+    argTypes: ['i32', 'f64'],
     returns: false
   },
   [Opcodes.f64_load]: {
-    c: `${CValtype.f64} out;
+    c: `f64 out;
 memcpy(&out, _memory + offset + pointer, sizeof(out));
 return out;`,
     args: ['pointer'],
-    argTypes: [CValtype.i32],
-    returns: CValtype.f64
+    argTypes: ['i32'],
+    returns: 'f64'
+  },
+} : {
+  [Opcodes.i32_store]: {
+    c: `*((i32*)(_memory + offset + pointer)) = value;`,
+    args: ['pointer', 'value'],
+    argTypes: ['i32', 'i32'],
+    returns: false
+  },
+  [Opcodes.i32_store16]: {
+    c: `*((u16*)(_memory + offset + pointer)) = value;`,
+    args: ['pointer', 'value'],
+    argTypes: ['i32', 'u16'],
+    returns: false
+  },
+  [Opcodes.i32_store8]: {
+    c: `*((u8*)(_memory + offset + pointer)) = value;`,
+    args: ['pointer', 'value'],
+    argTypes: ['i32', 'u8'],
+    returns: false
+  },
+
+  [Opcodes.i32_load]: {
+    c: `return *((i32*)(_memory + offset + pointer));`,
+    args: ['pointer'],
+    argTypes: ['i32'],
+    returns: 'i32'
+  },
+  [Opcodes.i32_load16_u]: {
+    c: `return *((u16*)(_memory + offset + pointer));`,
+    args: ['pointer'],
+    argTypes: ['i32'],
+    returns: 'i32'
+  },
+  [Opcodes.i32_load8_u]: {
+    c: `return *((u8*)(_memory + offset + pointer));`,
+    args: ['pointer'],
+    argTypes: ['i32'],
+    returns: 'i32'
+  },
+
+  [Opcodes.f64_store]: {
+    c: `*((f64*)(_memory + offset + pointer)) = value;`,
+    args: ['pointer', 'value'],
+    argTypes: ['i32', 'f64'],
+    returns: false
+  },
+  [Opcodes.f64_load]: {
+    c: `return *((f64*)(_memory + offset + pointer));`,
+    args: ['pointer'],
+    argTypes: ['i32'],
+    returns: 'f64'
   },
 };
 
@@ -108,7 +160,7 @@ for (const x in CValtype) {
 
 const removeBrackets = str => {
   // return str;
-  // if (str.startsWith(`(${CValtype.i32})(${CValtype.u32})`)) return `(${CValtype.i32})(${CValtype.u32})(` + removeBrackets(str.slice(22, -1)) + ')';
+  // if (str.startsWith('(i32)(u32)')) return '(i32)(u32)(' + removeBrackets(str.slice(22, -1)) + ')';
 
   for (const x in CValtype) {
     const p = `(${x})`;
@@ -119,6 +171,9 @@ const removeBrackets = str => {
 };
 
 export default ({ funcs, globals, tags, data, exceptions, pages }) => {
+  // fix declaring order for c
+  funcs.reverse();
+
   const invOperatorOpcode = Object.values(operatorOpcode).reduce((acc, x) => {
     for (const k in x) {
       acc[x[k]] = k;
@@ -149,21 +204,31 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
 
   if (pages.size > 0) {
     prepend.set('_memory', `char _memory[${pages.size * pageSize}];\n`);
-    includes.set('string.h', true);
+    if (Prefs['2cMemcpy']) includes.set('string.h', true);
   }
 
   if (data.length > 0) {
-    prependMain.set('_data', data.map(x => `memcpy(_memory + ${x.offset}, (unsigned char[]){${x.bytes.join(',')}}, ${x.bytes.length});`).join('\n'));
+    if (Prefs['2cMemcpy']) {
+      prependMain.set('_data', data.map(x => `memcpy(_memory + ${x.offset}, (unsigned char[]){${x.bytes.join(',')}}, ${x.bytes.length});`).join('\n  '));
+      includes.set('string.h', true);
+    } else {
+      prependMain.set('_data', data.map(x => x.bytes.reduce((acc, y, i) => acc + `_memory[${x.offset + i}]=(u8)${y};`, '')).join('\n  '));
+    }
+  }
+
+  if (importFuncs.find(x => x.name === '__Porffor_readArgv')) {
+    prepend.set('argv', `int _argc; char** _argv;`);
+    prependMain.set('argv', `_argc = argc; _argv = argv;`);
   }
 
   if (out) out += '\n';
 
   let depth = 1;
   let brDepth = 0;
-  const line = (str, semi = true) => out += `${' '.repeat(depth * 2 + brDepth * 2)}${str}${semi ? ';' : ''}\n`;
+  const line = (str, semi = true) => out += `${' '.repeat((depth + brDepth) * 2)}${str}${semi ? ';' : ''}\n`;
   const lines = lines => {
     for (const x of lines) {
-      out += `${' '.repeat(depth * 2)}${x}\n`;
+      out += `${' '.repeat((depth + brDepth) * 2)}${x}\n`;
     }
   };
 
@@ -199,6 +264,8 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
     depth = 1;
     brDepth = 0;
 
+    let retTmpId = 0;
+
     const invLocals = inv(f.locals, x => x.idx);
 
     for (const x in invLocals) {
@@ -207,11 +274,12 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
 
     const returns = f.returns.length > 0;
 
-    const shouldInline = f.internal;
-    out += `${f.name === 'main' ? 'int' : (f.internal ? (returns ? CValtype.f64 : 'void') : 'struct ReturnValue')} ${shouldInline ? 'inline ' : ''}${sanitize(f.name)}(${f.params.map((x, i) => `${CValtype[x]} ${invLocals[i]}`).join(', ')}) {\n`;
+    const shouldInline = false; // f.internal;
+    if (f.name === 'main') out += `int main(${prependMain.has('argv') ? 'int argc, char* argv[]' : ''}) {\n`;
+      else out += `${f.internal ? (returns ? 'f64' : 'void') : 'struct ReturnValue'} ${shouldInline ? 'inline ' : ''}${sanitize(f.name)}(${f.params.map((x, i) => `${CValtype[x]} ${invLocals[i]}`).join(', ')}) {\n`;
 
     if (f.name === 'main') {
-      out += [...prependMain.values()].join('\n');
+      out += '  ' + [...prependMain.values()].join('\n  ');
       if (prependMain.size > 0) out += '\n\n';
     }
 
@@ -272,12 +340,12 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
         switch (i[1]) {
           // i32_trunc_sat_f64_s
           case 0x02:
-            vals.push(`(${CValtype.i32})(${vals.pop()})`);
+            vals.push(`(i32)(${vals.pop()})`);
             break;
 
           // i32_trunc_sat_f64_u
           case 0x03:
-            vals.push(`(${CValtype.u32})(${vals.pop()})`);
+            vals.push(`(u32)(${vals.pop()})`);
             break;
         }
 
@@ -326,7 +394,7 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
 
         case Opcodes.f64_trunc:
           // vals.push(`trunc(${vals.pop()})`);
-          vals.push(`(${CValtype.i32})(${removeBrackets(vals.pop())})`); // this is ~10x faster with clang??
+          vals.push(`(i32)(${removeBrackets(vals.pop())})`); // this is ~10x faster with clang??
           break;
 
         case Opcodes.f64_convert_i32_u:
@@ -334,7 +402,7 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
         case Opcodes.f64_convert_i64_u:
         case Opcodes.f64_convert_i64_s:
           // int to f64
-          vals.push(`(${CValtype.f64})(${removeBrackets(vals.pop())})`);
+          vals.push(`(f64)(${removeBrackets(vals.pop())})`);
           break;
 
         case Opcodes.i32_eqz:
@@ -342,7 +410,7 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
             vals.push(`!(${removeBrackets(vals.pop())})`);
           } else {
             let cond = '(' + removeBrackets(vals.pop());
-            if (cond.startsWith(`(${CValtype.i32})`)) cond = `${cond.slice(`(${CValtype.i32})`.length)}) == 0e+0`;
+            if (cond.startsWith(`(i32)`)) cond = `${cond.slice(5)} == 0e+0`;
               else cond += ') == 0';
             vals.push(cond);
           }
@@ -351,13 +419,16 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
 
         case Opcodes.return:
           // line(`return${returns ? ` ${removeBrackets(vals.pop())}` : ''}`);
-          line(`return${returns ? ` (struct ReturnValue){ ${removeBrackets(vals.pop())}, ${removeBrackets(vals.pop())} }` : ''}`);
+          const b = vals.pop();
+          const a = vals.pop();
+          line(`return${returns ? ` (struct ReturnValue){ ${removeBrackets(a)}, ${removeBrackets(b)} }` : ''}`);
+          // line(`return${returns ? ` (struct ReturnValue){ ${removeBrackets(vals.pop())}, ${removeBrackets(vals.pop())} }` : ''}`);
           break;
 
         case Opcodes.if: {
           let cond = removeBrackets(vals.pop());
           if (!lastCond) {
-            if (cond.startsWith(`(${CValtype.i32})`)) cond = `(${cond.slice(`(${CValtype.i32})`.length)}) != 0e+0`;
+            if (cond.startsWith(`(i32)`)) cond = `${cond.slice(5)} != 0e+0`;
               else cond = `(${cond}) != 0`;
           }
 
@@ -423,28 +494,16 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
             const importFunc = importFuncs[i[1]];
             switch (importFunc.name) {
               case 'print':
-                // line(`printf("%f\\n", ${vals.pop()})`);
                 line(`printf("${valtype === 'f64' ? '%g' : '%i'}\\n", ${vals.pop()})`);
                 includes.set('stdio.h', true);
                 break;
               case 'printChar':
-                line(`printf("%c", (int)(${vals.pop()}))`);
+                line(`putchar((int)(${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);
@@ -459,6 +518,61 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
                 winIncludes.set('windows.h', true);
                 break;
 
+              case '__Porffor_readArgv': {
+                prepend.set('__Porffor_readArgv',
+`i32 __Porffor_readArgv(u32 index, u32 outPtr) {
+  if (index >= _argc) {
+    return -1;
+  }
+
+  char* arg = _argv[index];
+
+  u32 read = 0;
+  char* out = _memory + outPtr + 4;
+  char ch;
+  while ((ch = *(arg++)) != 0) {
+    out[read++] = ch;
+  }
+
+  *((i32*)(_memory + outPtr)) = (i32)read;
+  return read;
+}`);
+
+                const outPtr = vals.pop();
+                const index = vals.pop();
+                vals.push(`(f64)__Porffor_readArgv((u32)(${index}), (u32)(${outPtr}))`);
+                break;
+              }
+
+              case '__Porffor_readFile': {
+                includes.set('stdio.h', true);
+
+                prepend.set('__Porffor_readFile',
+`i32 __Porffor_readFile(u32 pathPtr, u32 outPtr) {
+  char* path = _memory + pathPtr + 4;
+  FILE* fp = fopen(path, "r");
+  if (fp == NULL) {
+    return -1;
+  }
+
+  u32 read = 0;
+  char* out = _memory + outPtr + 4;
+  char ch;
+  while ((ch = fgetc(fp)) != EOF) {
+    out[read++] = ch;
+  }
+
+  fclose(fp);
+
+  *((i32*)(_memory + outPtr)) = (i32)read;
+  return read;
+}`);
+                const outPtr = vals.pop();
+                const pathPtr = vals.pop();
+                vals.push(`(f64)__Porffor_readFile((u32)(${pathPtr}), (u32)(${outPtr}))`);
+                break;
+              }
+
               default:
                 log.warning('2c', `unimplemented import: ${importFunc.name}`);
                 break;
@@ -474,9 +588,10 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
             if (func.internal) {
               vals.push(`${sanitize(func.name)}(${args.join(', ')})`);
             } else {
-              line(`const struct ReturnValue _ = ${sanitize(func.name)}(${args.join(', ')})`);
-              vals.push(`_.value`);
-              vals.push(`_.type`);
+              const id = retTmpId++;
+              line(`const struct ReturnValue _${id} = ${sanitize(func.name)}(${args.join(', ')})`);
+              vals.push(`_${id}.value`);
+              vals.push(`_${id}.type`);
             }
           } else line(`${sanitize(func.name)}(${args.join(', ')})`);
 
@@ -506,7 +621,7 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
 
           let cond = removeBrackets(vals.pop());
           if (!lastCond) {
-            if (cond.startsWith(`(${CValtype.i32})`)) cond = `(${cond.slice(`(${CValtype.i32})`.length)}) != 0e+0`;
+            if (cond.startsWith(`(i32)`)) cond = `${cond.slice(5)} != 0e+0`;
               else cond = `(${cond}) != 0`;
           }
 
@@ -536,8 +651,7 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
             const name = invOpcodes[i[0]];
             const func = CMemFuncs[i[0]];
             if (!prepend.has(name)) {
-              prepend.set(name, `${func.returns || 'void'} ${name}(${CValtype.i32} align, ${CValtype.i32} offset, ${func.args.map((x, i) => `${func.argTypes[i]} ${x}`).join(', ')}) {\n  ${func.c.replaceAll('\n', '\n  ')}\n}\n`);
-              // generate func c and prepend
+              prepend.set(name, `${func.returns || 'void'} ${name}(i32 align, i32 offset, ${func.args.map((x, i) => `${func.argTypes[i]} ${x}`).join(', ')}) {\n  ${func.c.replaceAll('\n', '\n  ')}\n}\n`);
             }
 
             const immediates = [ i[1], read_unsignedLEB128(i.slice(2)) ];
@@ -572,7 +686,6 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
   depth = 0;
 
   const makeIncludes = includes => [...includes.keys()].map(x => `#include <${x}>\n`).join('');
-
   out = platformSpecific(makeIncludes(winIncludes), makeIncludes(unixIncludes), false) + '\n' + makeIncludes(includes) + '\n' + alwaysPreface + [...prepend.values()].join('\n') + '\n\n' + out;
 
   return out.trim();