porffor 0.2.0-1afe9b8 → 0.2.0-2b0f14b

package/compiler/2c.js

@@ -1,24 +1,107 @@
-import { read_ieee754_binary64, read_signedLEB128 } from './encoding.js';
+import { read_ieee754_binary64, read_signedLEB128, read_unsignedLEB128 } from './encoding.js';
 import { Blocktype, Opcodes, Valtype } from './wasmSpec.js';
 import { operatorOpcode } from './expression.js';
 import { log } from "./log.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',
+  i8: 'i8',
+  i16: 'i16',
+  i32: 'i32',
+  u32: 'u32',
+  i64: 'i64',
+  u64: 'u64',
 
-  f32: 'float',
-  f64: 'double',
+  f32: 'f32',
+  f64: 'f64',
 
   undefined: 'void'
 };
 
+const alwaysPreface = `typedef unsigned char i8;
+typedef unsigned short i16;
+typedef long i32;
+typedef unsigned long u32;
+typedef long long i64;
+typedef unsigned long long u64;
+typedef float f32;
+typedef double f64;
+
+f64 NAN = 0e+0/0e+0;
+
+struct ReturnValue {
+  ${CValtype.f64} value;
+  ${CValtype.i32} type;
+};
+\n`;
+
+// todo: is memcpy/etc safe with host endianness?
+
+// all:
+// immediates: ['align', 'offset']
+const CMemFuncs = {
+  [Opcodes.i32_store]: {
+    c: `memcpy(_memory + offset + pointer, &value, sizeof(value));`,
+    args: ['pointer', 'value'],
+    argTypes: [CValtype.i32, CValtype.i32],
+    returns: false
+  },
+  [Opcodes.i32_store16]: {
+    c: `memcpy(_memory + offset + pointer, &value, sizeof(value));`,
+    args: ['pointer', 'value'],
+    argTypes: [CValtype.i32, CValtype.i16],
+    returns: false
+  },
+  [Opcodes.i32_store8]: {
+    c: `memcpy(_memory + offset + pointer, &value, sizeof(value));`,
+    args: ['pointer', 'value'],
+    argTypes: [CValtype.i32, CValtype.i8],
+    returns: false
+  },
+
+  [Opcodes.i32_load]: {
+    c: `${CValtype.i32} out;
+memcpy(&out, _memory + offset + pointer, sizeof(out));
+return out;`,
+    args: ['pointer'],
+    argTypes: [CValtype.i32],
+    returns: CValtype.i32
+  },
+  [Opcodes.i32_load16_u]: {
+    c: `${CValtype.i16} out;
+memcpy(&out, _memory + offset + pointer, sizeof(out));
+return out;`,
+    args: ['pointer'],
+    argTypes: [CValtype.i32],
+    returns: CValtype.i32
+  },
+  [Opcodes.i32_load8_u]: {
+    c: `${CValtype.i8} out;
+memcpy(&out, _memory + offset + pointer, sizeof(out));
+return out;`,
+    args: ['pointer'],
+    argTypes: [CValtype.i32],
+    returns: CValtype.i32
+  },
+
+  [Opcodes.f64_store]: {
+    c: `memcpy(_memory + offset + pointer, &value, sizeof(value));`,
+    args: ['pointer', 'value'],
+    argTypes: [CValtype.i32, CValtype.f64],
+    returns: false
+  },
+  [Opcodes.f64_load]: {
+    c: `${CValtype.f64} out;
+memcpy(&out, _memory + offset + pointer, sizeof(out));
+return out;`,
+    args: ['pointer'],
+    argTypes: [CValtype.i32],
+    returns: CValtype.f64
+  },
+};
+
 const inv = (obj, keyMap = x => x) => Object.keys(obj).reduce((acc, x) => { acc[keyMap(obj[x])] = x; return acc; }, {});
 const invOpcodes = inv(Opcodes);
+const invValtype = inv(Valtype);
 
 for (const x in CValtype) {
   if (Valtype[x]) CValtype[Valtype[x]] = CValtype[x];
@@ -36,11 +119,18 @@ const todo = msg => {
 };
 
 const removeBrackets = str => {
-  if (str.startsWith('(long)(unsigned long)')) return '(long)(unsigned long)(' + removeBrackets(str.slice(22, -1)) + ')';
+  // return str;
+  // if (str.startsWith(`(${CValtype.i32})(${CValtype.u32})`)) return `(${CValtype.i32})(${CValtype.u32})(` + removeBrackets(str.slice(22, -1)) + ')';
+
+  for (const x in CValtype) {
+    const p = `(${x})`;
+    if (str.startsWith(p)) return p + removeBrackets(str.slice(p.length));
+  }
+
   return str.startsWith('(') && str.endsWith(')') ? str.slice(1, -1) : str;
 };
 
-export default ({ funcs, globals, tags, exceptions, pages }) => {
+export default ({ funcs, globals, tags, data, exceptions, pages }) => {
   const invOperatorOpcode = Object.values(operatorOpcode).reduce((acc, x) => {
     for (const k in x) {
       acc[x[k]] = k;
@@ -56,12 +146,10 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
   }
 
   const includes = new Map(), unixIncludes = new Map(), winIncludes = new Map();
+  const prepend = new Map(), prependMain = new Map();
 
-  // TODO: make type i16
-  let out = `struct ReturnValue {
-  ${CValtype.f64} value;
-  ${CValtype.i32} type;
-};\n\n`;
+  // presume all <i32 work is unsigned
+  let out = ``;
 
   for (const x in globals) {
     const g = globals[x];
@@ -70,6 +158,15 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
     out += ';\n';
   }
 
+  if (pages.size > 0) {
+    prepend.set('_memory', `char _memory[${pages.size * pageSize}];\n`);
+    includes.set('string.h', true);
+  }
+
+  if (data.length > 0) {
+    prependMain.set('_data', data.map(x => `memcpy(_memory + ${x.offset}, (char[]){${x.bytes.join(',')}}, ${x.bytes.length});`).join('\n'));
+  }
+
   // for (const [ x, p ] of pages) {
     // out += `${CValtype[p.type]} ${x.replace(': ', '_').replace(/[^0-9a-zA-Z_]/g, '')}[100]`;
     // out += ';\n';
@@ -78,7 +175,8 @@ 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`;
+  let brDepth = 0;
+  const line = (str, semi = true) => out += `${' '.repeat(depth * 2 + brDepth * 2)}${str}${semi ? ';' : ''}\n`;
   const lines = lines => {
     for (const x of lines) {
       out += `${' '.repeat(depth * 2)}${x}\n`;
@@ -111,6 +209,8 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
     return tmp;
   };
 
+  let brId = 0;
+
   for (const f of funcs) {
     depth = 1;
 
@@ -124,7 +224,12 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
     const returns = f.returns.length > 0;
 
     const shouldInline = f.internal;
-    out += `${f.name === 'main' ? 'int' : (f.internal ? (returns ? 'double' : 'void') : 'struct ReturnValue')} ${shouldInline ? 'inline ' : ''}${sanitize(f.name)}(${f.params.map((x, i) => `${CValtype[x]} ${invLocals[i]}`).join(', ')}) {\n`;
+    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`;
+
+    if (f.name === 'main') {
+      out += [...prependMain.values()].join('\n');
+      if (prependMain.size > 0) out += '\n\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) {
@@ -134,11 +239,58 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
 
     if (localKeys.length !== 0) out += '\n';
 
+    const rets = [];
+    const runOnEnd = [];
+
     let vals = [];
-    const endNeedsCurly = [], ignoreEnd = [];
-    let beginLoop = false, lastCond = false, ifTernary = false;
+    const endNeedsCurly = [];
+    const brs = [];
+    let lastCond = false;
+
+    // let brDepth = 0;
+
+    const blockStart = (i, loop) => {
+      // reset "stack"
+      // vals = [];
+
+      rets.push(i[1]);
+
+      const br = brId++;
+      brs.push(br);
+      if (loop) {
+        line(`j${br}:;`, false);
+        runOnEnd.push(null);
+      } else {
+        runOnEnd.push(() => line(`j${br}:;`, false));
+      }
+
+      if (i[1] !== Blocktype.void) line(`${CValtype[i[1]]} _r${br}`);
+
+      brDepth++;
+    };
+
+    const highlight = i => {
+      const surrounding = 6;
+
+      const decomp = decompile(f.wasm.slice(i - surrounding, i + surrounding + 1), '', 0, f.locals, f.params, f.returns, funcs, globals, exceptions).slice(0, -1).split('\n');
+
+      const noAnsi = s => s.replace(/\u001b\[[0-9]+m/g, '');
+      let longest = 0;
+      for (let j = 0; j < decomp.length; j++) {
+        longest = Math.max(longest, noAnsi(decomp[j]).length);
+      }
+
+      const middle = Math.floor(decomp.length / 2);
+      decomp[middle] = `\x1B[47m\x1B[30m${noAnsi(decomp[middle])}${'\u00a0'.repeat(longest - noAnsi(decomp[middle]).length)}\x1B[0m`;
+
+      console.log('\x1B[90m...\x1B[0m');
+      console.log(decomp.join('\n'));
+      console.log('\x1B[90m...\x1B[0m\n');
+    };
+
     for (let _ = 0; _ < f.wasm.length; _++) {
       const i = f.wasm[_];
+      if (!i || !i[0]) continue;
 
       if (invOperatorOpcode[i[0]]) {
         const b = vals.pop();
@@ -160,12 +312,12 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
         switch (i[1]) {
           // i32_trunc_sat_f64_s
           case 0x02:
-            vals.push(`(${CValtype.i32})${vals.pop()}`);
+            vals.push(`(${CValtype.i32})(${vals.pop()})`);
             break;
 
           // i32_trunc_sat_f64_u
           case 0x03:
-            vals.push(`(${CValtype.i32})(${CValtype.i32_u})${vals.pop()}`);
+            vals.push(`(${CValtype.u32})(${vals.pop()})`);
             break;
         }
 
@@ -176,12 +328,19 @@ 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());
+          // vals.push(read_signedLEB128(i.slice(1)).toString());
+          vals.push(new String(read_signedLEB128(i.slice(1)).toString()));
+          vals.at(-1).offset = _;
           break;
 
-        case Opcodes.f64_const:
-          vals.push(read_ieee754_binary64(i.slice(1)).toExponential());
+        case Opcodes.f64_const: {
+          // const val = read_ieee754_binary64(i.slice(1)).toExponential();
+          const val = new String(read_ieee754_binary64(i.slice(1)).toExponential());
+          // vals.push(val == 'NaN' ? 'NAN' : val);
+          vals.push(val == 'NaN' ? new String('NAN') : val);
+          vals.at(-1).offset = _;
           break;
+        }
 
         case Opcodes.local_get:
           vals.push(`${invLocals[i[1]]}`);
@@ -192,9 +351,9 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
           break;
 
         case Opcodes.local_tee:
-          // line(`${invLocals[i[1]]} = ${removeBrackets(vals.pop())}`);
-          // vals.push(`${invLocals[i[1]]}`);
-          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:
@@ -207,78 +366,102 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
 
         case Opcodes.f64_trunc:
           // vals.push(`trunc(${vals.pop()})`);
-          vals.push(`(int)(${removeBrackets(vals.pop())})`); // this is ~10x faster with clang??
+          vals.push(`(${CValtype.i32})(${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()}`);
+          // int to f64
+          vals.push(`(${CValtype.f64})(${removeBrackets(vals.pop())})`);
           break;
 
+        case Opcodes.i32_eqz:
+          if (lastCond) {
+            vals.push(`!(${removeBrackets(vals.pop())})`);
+          } else {
+            let cond = '(' + removeBrackets(vals.pop());
+            if (cond.startsWith(`(${CValtype.i32})`)) cond = `${cond.slice(`(${CValtype.i32})`.length)}) == 0e+0`;
+              else cond += ') == 0';
+            vals.push(cond);
+          }
+          lastCond = true;
+          continue;
+
         case Opcodes.return:
           // line(`return${returns ? ` ${removeBrackets(vals.pop())}` : ''}`);
           line(`return${returns ? ` (struct ReturnValue){ ${removeBrackets(vals.pop())}, ${removeBrackets(vals.pop())} }` : ''}`);
           break;
 
-        case Opcodes.if:
+        case Opcodes.if: {
           let cond = removeBrackets(vals.pop());
           if (!lastCond) {
-            if (cond.startsWith('(long)')) cond = `${cond.slice(6)} == 1e+0`;
-              else cond += ' == 1';
+            if (cond.startsWith(`(${CValtype.i32})`)) cond = `(${cond.slice(`(${CValtype.i32})`.length)}) != 0e+0`;
+              else cond = `(${cond}) != 0`;
           }
 
-          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 ${invValtype[i[1]] ?? ''}`, false);
+          blockStart(i, false);
 
           line(`if (${cond}) {`, false);
 
           depth++;
           endNeedsCurly.push(true);
-          ignoreEnd.push(false);
           break;
+        }
 
-        case Opcodes.else:
-          if (ifTernary) break;
+        case Opcodes.else: {
+          const br = brs.at(-1);
+          const ret = rets.at(-1);
+          if (ret && ret !== Blocktype.void) {
+            // console.log(vals, ret);
+            // console.log(decompile(f.wasm.slice(_ - 5, _ + 1)));
+            if (vals.length > 0) line(`_r${br} = ${removeBrackets(vals.pop())}`);
+            // vals.push(`_r${br}`);
+          }
 
           depth--;
           line(`} else {`, false);
           depth++;
+
+          // reset "stack"
+          // vals = [];
           break;
+        }
 
-        case Opcodes.loop:
-          // not doing properly, fake a while loop
-          beginLoop = true;
+        case Opcodes.loop: {
+          line(`// loop ${invValtype[i[1]] ?? ''}`, false);
+          blockStart(i, true);
+          endNeedsCurly.push(false);
           break;
+        }
 
-        case Opcodes.end:
-          if (ignoreEnd.pop()) break;
+        case Opcodes.end: {
+          const br = brs.pop();
+          const ret = rets.pop();
+          if (ret && ret !== Blocktype.void) {
+            // console.log(vals, ret);
+            // console.log(decompile(f.wasm.slice(_ - 5, _ + 1)));
+            if (vals.length > 0) line(`_r${br} = ${removeBrackets(vals.pop())}`);
+            vals.push(`_r${br}`);
+          }
 
-          if (ifTernary) {
-            const b = vals.pop();
-            const a = vals.pop();
-            vals.push(`${ifTernary} ? ${a} : ${b}`);
-            break;
+          const enc = endNeedsCurly.pop() === true;
+          if (enc) {
+            depth--;
+            line('}', false);
           }
 
-          depth--;
-          if (endNeedsCurly.pop() === true) line('}', false);
+          brDepth--;
+
+          line(`// end`, false);
+
+          const roe = runOnEnd.pop();
+          if (roe) roe();
+
           break;
+        }
 
         case Opcodes.call:
           let func = funcs.find(x => x.index === i[1]);
@@ -286,7 +469,8 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
             const importFunc = importFuncs[i[1]];
             switch (importFunc.name) {
               case 'print':
-                line(`printf("%f\\n", ${vals.pop()})`);
+                // line(`printf("%f\\n", ${vals.pop()})`);
+                line(`printf("${valtype === 'f64' ? '%g' : '%i'}\\n", ${vals.pop()})`);
                 includes.set('stdio.h', true);
                 break;
               case 'printChar':
@@ -349,13 +533,74 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
           vals.pop();
           break;
 
-        case Opcodes.br:
-          // ignore
-          // reset "stack"
-          vals = [];
+        case Opcodes.block:
+          line(`// block ${invValtype[i[1]] ?? ''}`, false);
+          blockStart(i, false);
+          endNeedsCurly.push(false);
+          break;
+
+        case Opcodes.br: {
+          const ret = rets[brDepth - i[1] - 1];
+          // console.log(rets, brDepth, i[1], brDepth - i[1] - 1, ret, vals);
+          if (ret !== Blocktype.void) line(`_r${brs[brDepth - i[1] - 1]} = ${removeBrackets(vals.pop())}`);
+          line(`goto j${brs[brDepth - i[1] - 1]}`);
+
+          // // reset "stack"
+          // vals = [];
+          break;
+        }
+
+        case Opcodes.br_if: {
+          const ret = rets[brDepth - i[1] - 1];
+          // console.log(rets, brDepth, i[1], brDepth - i[1] - 1, ret, vals);
+
+          let cond = removeBrackets(vals.pop());
+          if (!lastCond) {
+            if (cond.startsWith(`(${CValtype.i32})`)) cond = `(${cond.slice(`(${CValtype.i32})`.length)}) != 0e+0`;
+              else cond = `(${cond}) != 0`;
+          }
+
+          line(`if (${cond}) {`, false);
+          depth++;
+          if (ret !== Blocktype.void) line(`_r${brs[brDepth - i[1] - 1]} = ${removeBrackets(vals.at(-1))}`);
+          line(`goto j${brs[brDepth - i[1] - 1]}`);
+          depth--;
+          line(`}`, false);
+
+          break;
+        }
+
+        case Opcodes.throw: {
+          const id = vals.pop();
+
+          line(`printf("Uncaught ${exceptions[id].constructor}: ${exceptions[id].message}\\n")`);
+          line(`exit(1)`);
+
+          includes.set('stdlib.h', true);
+
           break;
+        }
 
         default:
+          if (CMemFuncs[i[0]]) {
+            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
+            }
+
+            const immediates = [ i[1], read_unsignedLEB128(i.slice(2)) ];
+
+            let args = [];
+            for (let j = 0; j < func.args.length; j++) args.unshift(removeBrackets(vals.pop()));
+
+            if (func.returns !== false) {
+              vals.push(`${name}(${immediates[0]}, ${immediates[1]}, ${args.join(', ')})`);
+            } else line(`${name}(${immediates[0]}, ${immediates[1]}, ${args.join(', ')})`);
+            break;
+          }
+
           log.warning('2c', `unimplemented op: ${invOpcodes[i[0]]}`);
           // todo(`unimplemented op: ${invOpcodes[i[0]]}`);
       }
@@ -379,7 +624,7 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
 
   const makeIncludes = includes => [...includes.keys()].map(x => `#include <${x}>\n`).join('');
 
-  out = platformSpecific(makeIncludes(winIncludes), makeIncludes(unixIncludes), false) + '\n' + makeIncludes(includes) + '\n' + out;
+  out = alwaysPreface + platformSpecific(makeIncludes(winIncludes), makeIncludes(unixIncludes), false) + '\n' + makeIncludes(includes) + '\n' + [...prepend.values()].join('\n') + '\n\n' + out;
 
-  return out;
+  return out.trim();
 };

package/compiler/builtins.js

@@ -696,6 +696,32 @@ export const BuiltinFuncs = function() {
     }
   };
 
+  const localIsOneOf = (getter, arr, valtype = valtypeBinary) => {
+    const out = [];
+
+    for (let i = 0; i < arr.length; i++) {
+      out.push(...getter, ...number(arr[i], valtype), valtype === Valtype.f64 ? [ Opcodes.f64_eq ] : [ Opcodes.i32_eq ]);
+      if (i !== 0) out.push([ Opcodes.i32_or ]);
+    }
+
+    return out;
+  };
+
+  this.__Porffor_pointer = {
+    params: [ valtypeBinary, Valtype.i32 ],
+    typedParams: true,
+    locals: [ Valtype.i32, Valtype.i32 ],
+    returns: [ valtypeBinary ],
+    wasm: (scope, { TYPES }) => [
+      ...localIsOneOf([ [ Opcodes.local_get, 1 ] ], [ TYPES.string, TYPES._array, TYPES._bytestring ], Valtype.i32),
+      [ Opcodes.if, valtypeBinary ],
+      [ Opcodes.local_get, 0 ],
+      [ Opcodes.else ],
+      ...number(NaN),
+      [ Opcodes.end ]
+    ]
+  };
+
 
   this.__SIMD_i32x4_load = {
     params: [ Valtype.i32 ],

package/compiler/codeGen.js

@@ -160,7 +160,7 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
 
     case 'TaggedTemplateExpression': {
       const funcs = {
-        asm: str => {
+        __Porffor_asm: str => {
           let out = [];
 
           for (const line of str.split('\n')) {
@@ -194,8 +194,21 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
           }
 
           return out;
-        }
-      }
+        },
+
+        __Porffor_bs: str => [
+          ...makeString(scope, str, undefined, undefined, true),
+
+          ...number(TYPES._bytestring, Valtype.i32),
+          setLastType(scope)
+        ],
+        __Porffor_s: str => [
+          ...makeString(scope, str, undefined, undefined, false),
+
+          ...number(TYPES.string, Valtype.i32),
+          setLastType(scope)
+        ],
+      };
 
       const name = decl.tag.name;
       // hack for inline asm
@@ -912,7 +925,7 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
       [ Opcodes.i32_or ],
       [ Opcodes.if, Blocktype.void ],
       ...number(0, Valtype.i32),
-      [ Opcodes.br, 1 ],
+      [ Opcodes.br, 2 ],
       [ Opcodes.end ],
 
       ...compareStrings(scope, [ [ Opcodes.local_get, tmpLeft ] ], [ [ Opcodes.local_get, tmpRight ] ]),
@@ -2721,7 +2734,7 @@ const byteStringable = str => {
   return true;
 };
 
-const makeString = (scope, str, global = false, name = '$undeclared') => {
+const makeString = (scope, str, global = false, name = '$undeclared', forceBytestring = undefined) => {
   const rawElements = new Array(str.length);
   let byteStringable = process.argv.includes('-bytestring');
   for (let i = 0; i < str.length; i++) {
@@ -2731,6 +2744,8 @@ const makeString = (scope, str, global = false, name = '$undeclared') => {
     if (byteStringable && c > 0xFF) byteStringable = false;
   }
 
+  if (byteStringable && forceBytestring === false) byteStringable = false;
+
   return makeArray(scope, {
     rawElements
   }, global, name, false, byteStringable ? 'i8' : 'i16')[0];

package/compiler/index.js

@@ -68,11 +68,17 @@ export default (code, flags) => {
     console.log([...pages.keys()].map(x => `\x1B[36m - ${x}\x1B[0m`).join('\n') + '\n');
   }
 
-  const out = { wasm: sections, funcs, globals, tags, exceptions, pages };
+  const out = { wasm: sections, funcs, globals, tags, exceptions, pages, data };
 
   const target = getArg('target') ?? getArg('t') ?? 'wasm';
   const outFile = getArg('o');
 
+  if (target === 'wasm' && outFile) {
+    writeFileSync(outFile, Buffer.from(sections));
+
+    if (process.version) process.exit();
+  }
+
   if (target === 'c') {
     const c = toc(out);
     out.c = c;
@@ -87,11 +93,16 @@ export default (code, flags) => {
   }
 
   if (target === 'native') {
-    const compiler = getArg('compiler') ?? 'clang';
+    let compiler = getArg('compiler') ?? 'clang';
     const cO = getArg('cO') ?? 'Ofast';
 
+    if (compiler === 'zig') compiler = [ 'zig', 'cc' ];
+      else compiler = [ compiler ];
+
     const tmpfile = 'tmp.c';
-    const args = [ compiler, tmpfile, '-o', outFile ?? (process.platform === 'win32' ? 'out.exe' : 'out'), '-' + cO, '-march=native' ];
+    // const args = [ compiler, tmpfile, '-o', outFile ?? (process.platform === 'win32' ? 'out.exe' : 'out'), '-' + cO, '-march=native', '-s', '-fno-unwind-tables', '-fno-asynchronous-unwind-tables', '-ffunction-sections', '-fdata-sections', '-Wl', '-fno-ident', '-fno-exceptions', '-ffast-math' ];
+    // const args = [ ...compiler, tmpfile, '-o', outFile ?? (process.platform === 'win32' ? 'out.exe' : 'out'), '-' + cO, '-march=native', '-s', '-ffast-math', '-fno-exceptions', '-target', 'x86_64-linux' ];
+    const args = [ ...compiler, tmpfile, '-o', outFile ?? (process.platform === 'win32' ? 'out.exe' : 'out'), '-' + cO, '-march=native', '-s', '-ffast-math', '-fno-exceptions' ];
 
     const c = toc(out);
     writeFileSync(tmpfile, c);

package/filesize.cmd

@@ -0,0 +1,2 @@
+@echo off
+echo %~z1

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.2.0-1afe9b8",
+  "version": "0.2.0-2b0f14b",
   "author": "CanadaHonk",
   "license": "MIT",
   "dependencies": {

package/runner/index.js

@@ -15,9 +15,22 @@ if (process.argv.includes('-compile-hints')) {
   // --experimental-wasm-return-call (on by default)
 }
 
-const file = process.argv.slice(2).find(x => x[0] !== '-');
+let file = process.argv.slice(2).find(x => x[0] !== '-');
+if (['run', 'wasm', 'native', 'c'].includes(file)) {
+  if (['wasm', 'native', 'c'].includes(file)) {
+    process.argv.push(`-target=${file}`);
+  }
+
+  file = process.argv.slice(process.argv.indexOf(file) + 1).find(x => x[0] !== '-');
+
+  const nonOptOutFile = process.argv.slice(process.argv.indexOf(file) + 1).find(x => x[0] !== '-');
+  if (nonOptOutFile) {
+    process.argv.push(`-o=${nonOptOutFile}`);
+  }
+}
+
 if (!file) {
-  if (process.argv.includes('-v')) {
+  if (process.argv.includes('-v') || process.argv.includes('--version')) {
     // just print version
     console.log((await import('./version.js')).default);
     process.exit(0);

package/r.js

@@ -1,4 +0,0 @@
-var supreme = 5
-var count;
-
-for(count=0;;) {console.log(count); if (count===supreme)break;else count++; }