porffor 0.2.0-c6c8c81 → 0.2.0-cb647c8

package/compiler/2c.js

@@ -1,24 +1,106 @@
-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 uint8_t i8;
+typedef uint16_t i16;
+typedef int32_t i32;
+typedef uint32_t u32;
+typedef int64_t i64;
+typedef uint64_t u64;
+typedef float f32;
+typedef double f64;
+
+f64 NAN = 0e+0/0e+0;
+
+struct ReturnValue {
+  ${CValtype.f64} value;
+  ${CValtype.i32} type;
+};\n\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];
@@ -35,9 +117,19 @@ const todo = msg => {
   throw new TodoError(`todo: ${msg}`);
 };
 
-const removeBrackets = str => str.startsWith('(') && str.endsWith(')') ? str.slice(1, -1) : str;
+const removeBrackets = str => {
+  // 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;
@@ -53,12 +145,11 @@ 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`;
+  includes.set('stdint.h', true);
+
+  let out = ``;
 
   for (const x in globals) {
     const g = globals[x];
@@ -67,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}, (unsigned 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';
@@ -75,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`;
@@ -108,6 +209,8 @@ export default ({ funcs, globals, tags, exceptions, pages }) => {
     return tmp;
   };
 
+  let brId = 0;
+
   for (const f of funcs) {
     depth = 1;
 
@@ -121,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 ? 'double' : '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) {
@@ -131,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();
@@ -157,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;
         }
 
@@ -173,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]]}`);
@@ -189,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:
@@ -204,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]);
@@ -283,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':
@@ -346,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]]}`);
       }
@@ -364,6 +612,11 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
       line(`return ${vals.pop()}`);
     }
 
+    if (f.name === 'main') {
+      out += '\n';
+      line(`return 0`);
+    }
+
     out += '}\n\n';
   }
 
@@ -371,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 = platformSpecific(makeIncludes(winIncludes), makeIncludes(unixIncludes), false) + '\n' + makeIncludes(includes) + '\n' + alwaysPreface + [...prepend.values()].join('\n') + '\n\n' + out;
 
-  return out;
+  return out.trim();
 };

package/compiler/builtins/base64.ts

@@ -0,0 +1,68 @@
+// @porf -funsafe-no-unlikely-proto-checks
+
+import type { i32, bytestring } from './porffor.d.ts';
+
+const keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+
+const btoa = (input: bytestring): bytestring => {
+  // todo: throw invalid character for unicode
+
+  let output: bytestring = "";
+  let i: i32 = 0;
+
+  while (i < input.length) {
+    const chr1: i32 = input.charCodeAt(i++);
+    const chr2: i32 = input.charCodeAt(i++);
+    const chr3: i32 = input.charCodeAt(i++);
+
+    const enc1: i32 = chr1 >> 2;
+    const enc2: i32 = ((chr1 & 3) << 4) | (chr2 >> 4);
+    let enc3: i32 = ((chr2 & 15) << 2) | (chr3 >> 6);
+    let enc4: i32 = chr3 & 63;
+
+    if (isNaN(chr2)) {
+      enc3 = 64;
+      enc4 = 64;
+    } else if (isNaN(chr3)) {
+      enc4 = 64;
+    }
+
+    output += keyStr.charAt(enc1);
+    output += keyStr.charAt(enc2);
+    output += keyStr.charAt(enc3);
+    output += keyStr.charAt(enc4);
+  }
+
+  return output;
+};
+
+/* var atob = function (input) {
+  const keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+
+  let output = "";
+  let chr1, chr2, chr3;
+  let enc1, enc2, enc3, enc4;
+  let i = 0;
+
+  while (i < input.length) {
+    enc1 = keyStr.indexOf(input.charAt(i++));
+    enc2 = keyStr.indexOf(input.charAt(i++));
+    enc3 = keyStr.indexOf(input.charAt(i++));
+    enc4 = keyStr.indexOf(input.charAt(i++));
+
+    chr1 = (enc1 << 2) | (enc2 >> 4);
+    chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
+    chr3 = ((enc3 & 3) << 6) | enc4;
+
+    output += String.fromCharCode(chr1);
+
+    if (enc3 != 64) {
+      output += String.fromCharCode(chr2);
+    }
+    if (enc4 != 64) {
+      output += String.fromCharCode(chr3);
+    }
+  }
+
+  return output;
+}; */

package/compiler/builtins/porffor.d.ts

@@ -0,0 +1,2 @@
+export type i32 = number;
+export type bytestring = string;