porffor 0.0.0-579ef36 → 0.0.0-61de729

package/README.md

@@ -76,6 +76,7 @@ these include some early (stage 1/0) and/or dead (last commit years ago) proposa
 - 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'`)
 
 ### built-ins
 
@@ -106,7 +107,6 @@ these include some early (stage 1/0) and/or dead (last commit years ago) proposa
   - arrays/strings inside arrays
 - strings
   - member setting
-  - equality
 - more math operators (`**`, etc)
 - `do { ... } while (...)`
 - exceptions

package/compiler/codeGen.js

@@ -35,7 +35,14 @@ const debug = str => {
 };
 
 const todo = msg => {
-  throw new Error(`todo: ${msg}`);
+  class TodoError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = 'TodoError';
+    }
+  }
+
+  throw new TodoError(`todo: ${msg}`);
 
   const code = [];
 
@@ -101,6 +108,9 @@ const generate = (scope, decl, global = false, name = undefined) => {
     case 'WhileStatement':
       return generateWhile(scope, decl);
 
+    /* case 'ForOfStatement':
+      return generateForOf(scope, decl); */
+
     case 'BreakStatement':
       return generateBreak(scope, decl);
 
@@ -295,10 +305,10 @@ const localTmp = (scope, name, type = valtypeBinary) => {
   return idx;
 };
 
-const performLogicOp = (scope, op, left, right) => {
+const performLogicOp = (scope, op, left, right, leftType, rightType) => {
   const checks = {
-    '||': Opcodes.eqz,
-    '&&': [ Opcodes.i32_to ]
+    '||': falsy,
+    '&&': truthy,
     // todo: ??
   };
 
@@ -310,7 +320,8 @@ const performLogicOp = (scope, op, left, right) => {
   return [
     ...left,
     [ Opcodes.local_tee, localTmp(scope, 'logictmp') ],
-    ...checks[op],
+    ...checks[op](scope, [], leftType),
+    Opcodes.i32_to,
     [ Opcodes.if, valtypeBinary ],
     ...right,
     [ Opcodes.else ],
@@ -327,13 +338,13 @@ const concatStrings = (scope, left, right, global, name, assign) => {
 
   scope.memory = true;
 
-  const pointer = arrays.get(name ?? '$undeclared');
-
   const rightPointer = localTmp(scope, 'concat_right_pointer', Valtype.i32);
   const rightLength = localTmp(scope, 'concat_right_length', Valtype.i32);
   const leftLength = localTmp(scope, 'concat_left_length', Valtype.i32);
 
   if (assign) {
+    const pointer = arrays.get(name ?? '$undeclared');
+
     return [
       // setup right
       ...right,
@@ -384,15 +395,12 @@ const concatStrings = (scope, left, right, global, name, assign) => {
 
   const leftPointer = localTmp(scope, 'concat_left_pointer', Valtype.i32);
 
-  const newOut = makeArray(scope, {
+  // alloc/assign array
+  const [ , pointer ] = makeArray(scope, {
     rawElements: new Array(0)
   }, global, name, true, 'i16');
 
   return [
-    // setup new/out array
-    ...newOut,
-    [ Opcodes.drop ],
-
     // setup left
     ...left,
     Opcodes.i32_to_u,
@@ -458,75 +466,199 @@ const concatStrings = (scope, left, right, global, name, assign) => {
   ];
 };
 
-const falsy = (scope, wasm, type) => {
+const compareStrings = (scope, left, right) => {
+  // todo: this should be rewritten into a built-in/func: String.prototype.concat
+  // todo: convert left and right to strings if not
+  // todo: optimize by looking up names in arrays and using that if exists?
+  // todo: optimize this if using literals/known lengths?
+
+  scope.memory = true;
+
+  const leftPointer = localTmp(scope, 'compare_left_pointer', Valtype.i32);
+  const leftLength = localTmp(scope, 'compare_left_length', Valtype.i32);
+  const rightPointer = localTmp(scope, 'compare_right_pointer', Valtype.i32);
+  const rightLength = localTmp(scope, 'compare_right_length', Valtype.i32);
+
+  const index = localTmp(scope, 'compare_index', Valtype.i32);
+  const indexEnd = localTmp(scope, 'compare_index_end', Valtype.i32);
+
+  return [
+    // setup left
+    ...left,
+    Opcodes.i32_to_u,
+    [ Opcodes.local_tee, leftPointer ],
+
+    // setup right
+    ...right,
+    Opcodes.i32_to_u,
+    [ Opcodes.local_tee, rightPointer ],
+
+    // fast path: check leftPointer == rightPointer
+    // use if (block) for everything after to "return" a value early
+    [ Opcodes.i32_ne ],
+    [ Opcodes.if, Valtype.i32 ],
+
+    // get lengths
+    [ Opcodes.local_get, leftPointer ],
+    [ Opcodes.i32_load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(0) ],
+    [ Opcodes.local_tee, leftLength ],
+
+    [ Opcodes.local_get, rightPointer ],
+    [ Opcodes.i32_load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(0) ],
+    [ Opcodes.local_tee, rightLength ],
+
+    // fast path: check leftLength != rightLength
+    [ Opcodes.i32_ne ],
+    [ Opcodes.if, Blocktype.void ],
+    ...number(0, Valtype.i32),
+    [ Opcodes.br, 1 ],
+    [ Opcodes.end ],
+
+    // no fast path for length = 0 as it would probably be slower for most of the time?
+
+    // setup index end as length * sizeof i16 (2)
+    // we do this instead of having to do mul/div each iter for perf™
+    [ Opcodes.local_get, leftLength ],
+    ...number(ValtypeSize.i16, Valtype.i32),
+    [ Opcodes.i32_mul ],
+    [ Opcodes.local_set, indexEnd ],
+
+    // iterate over each char and check if eq
+    [ Opcodes.loop, Blocktype.void ],
+
+    // fetch left
+    [ Opcodes.local_get, index ],
+    [ Opcodes.local_get, leftPointer ],
+    [ Opcodes.i32_add ],
+    [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+
+    // fetch right
+    [ Opcodes.local_get, index ],
+    [ Opcodes.local_get, rightPointer ],
+    [ Opcodes.i32_add ],
+    [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+
+    // not equal, "return" false
+    [ Opcodes.i32_ne ],
+    [ Opcodes.if, Blocktype.void ],
+    ...number(0, Valtype.i32),
+    [ Opcodes.br, 2 ],
+    [ Opcodes.end ],
+
+    // index += sizeof i16 (2)
+    [ Opcodes.local_get, index ],
+    ...number(ValtypeSize.i16, Valtype.i32),
+    [ Opcodes.i32_add ],
+    [ Opcodes.local_tee, index ],
+
+    // if index != index end (length * sizeof 16), loop
+    [ Opcodes.local_get, indexEnd ],
+    [ Opcodes.i32_ne ],
+    [ Opcodes.br_if, 0 ],
+    [ Opcodes.end ],
+
+    // no failed checks, so true!
+    ...number(1, Valtype.i32),
+
+    // pointers match, so true
+    [ Opcodes.else ],
+    ...number(1, Valtype.i32),
+    [ Opcodes.end ],
+
+    // convert i32 result to valtype
+    // do not do as automatically added by binary exp gen for equality ops
+    // Opcodes.i32_from_u
+  ];
+};
+
+const truthy = (scope, wasm, type) => {
   // arrays are always truthy
   if (type === TYPES._array) return [
     ...wasm,
-    [ Opcodes.drop ],
-    number(0)
+    ...(wasm.length === 0 ? [] : [ [ Opcodes.drop ] ]),
+    number(1)
   ];
 
   if (type === TYPES.string) {
-    // if "" (length = 0)
+    // if not "" (length = 0)
     return [
       // pointer
       ...wasm,
+      Opcodes.i32_to_u,
 
       // get length
       [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
 
-      // if length == 0
-      [ Opcodes.i32_eqz ],
+      // if length != 0
+      /* [ Opcodes.i32_eqz ],
+      [ Opcodes.i32_eqz ], */
       Opcodes.i32_from_u
     ]
   }
 
-  // if = 0
+  // if != 0
   return [
     ...wasm,
 
-    ...Opcodes.eqz,
-    Opcodes.i32_from_u
+    /* Opcodes.eqz,
+    [ Opcodes.i32_eqz ],
+    Opcodes.i32_from */
   ];
 };
 
-const truthy = (scope, wasm, type) => {
+const falsy = (scope, wasm, type) => {
   // arrays are always truthy
   if (type === TYPES._array) return [
     ...wasm,
-    [ Opcodes.drop ],
-    number(1)
+    ...(wasm.length === 0 ? [] : [ [ Opcodes.drop ] ]),
+    number(0)
   ];
 
   if (type === TYPES.string) {
-    // if not "" (length = 0)
+    // if "" (length = 0)
     return [
       // pointer
       ...wasm,
+      Opcodes.i32_to_u,
 
       // get length
       [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
 
-      // if length != 0
-      /* [ Opcodes.i32_eqz ],
-      [ Opcodes.i32_eqz ], */
+      // if length == 0
+      [ Opcodes.i32_eqz ],
       Opcodes.i32_from_u
     ]
   }
 
-  // if != 0
+  // if = 0
   return [
     ...wasm,
 
-    /* Opcodes.eqz,
-    [ Opcodes.i32_eqz ],
-    Opcodes.i32_from */
+    ...Opcodes.eqz,
+    Opcodes.i32_from_u
   ];
 };
 
-const performOp = (scope, op, left, right, leftType, rightType, _global = false, _name = '$unspecified', assign = false) => {
+const performOp = (scope, op, left, right, leftType, rightType, _global = false, _name = '$undeclared', assign = false) => {
   if (op === '||' || op === '&&' || op === '??') {
-    return performLogicOp(scope, op, left, right);
+    return performLogicOp(scope, op, left, right, leftType, rightType);
+  }
+
+  if (codeLog && (!leftType || !rightType)) log('codegen', 'untracked type in op', op, _name, '\n' + new Error().stack.split('\n').slice(1).join('\n'));
+
+  // if strict (in)equal and known types mismatch, return false (===)/true (!==)
+  if ((op === '===' || op === '!==') && leftType && rightType && leftType !== rightType) {
+    return [
+      ...left,
+      ...right,
+
+      // drop values
+      [ Opcodes.drop ],
+      [ Opcodes.drop ],
+
+      // return false (===)/true (!==)
+      ...number(op === '===' ? 0 : 1, Valtype.i32)
+    ];
   }
 
   if (leftType === TYPES.string || rightType === TYPES.string) {
@@ -539,8 +671,20 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
     if (!['==', '===', '!=', '!==', '>', '>=', '<', '<='].includes(op)) return number(NaN);
 
     // else leave bool ops
-    // todo: convert string to number if string and number or le/ge op
-    // todo: string equality
+    // todo: convert string to number if string and number/bool
+    // todo: string (>|>=|<|<=) string
+
+    // string comparison
+    if (op === '===' || op === '==') {
+      return compareStrings(scope, left, right);
+    }
+
+    if (op === '!==' || op === '!=') {
+      return [
+        ...compareStrings(scope, left, right),
+        [ Opcodes.i32_eqz ]
+      ];
+    }
   }
 
   let ops = operatorOpcode[valtype][op];
@@ -569,13 +713,17 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
   ];
 };
 
+let binaryExpDepth = 0;
 const generateBinaryExp = (scope, decl, _global, _name) => {
+  binaryExpDepth++;
+
   const out = [
     ...performOp(scope, decl.operator, generate(scope, decl.left), generate(scope, decl.right), getNodeType(scope, decl.left), getNodeType(scope, decl.right), _global, _name)
   ];
 
   if (valtype !== 'i32' && ['==', '===', '!=', '!==', '>', '>=', '<', '<='].includes(decl.operator)) out.push(Opcodes.i32_from_u);
 
+  binaryExpDepth--;
   return out;
 };
 
@@ -634,7 +782,7 @@ const includeBuiltin = (scope, builtin) => {
 };
 
 const generateLogicExp = (scope, decl) => {
-  return performLogicOp(scope, decl.operator, generate(scope, decl.left), generate(scope, decl.right));
+  return performLogicOp(scope, decl.operator, generate(scope, decl.left), generate(scope, decl.right), getNodeType(scope, decl.left), getNodeType(scope, decl.right));
 };
 
 const TYPES = {
@@ -682,6 +830,7 @@ const getType = (scope, _name) => {
 
 const getNodeType = (scope, node) => {
   if (node.type === 'Literal') {
+    if (['number', 'boolean', 'string', 'undefined', 'object', 'function', 'symbol', 'bigint'].includes(node.value)) return TYPES.number;
     return TYPES[typeof node.value];
   }
 
@@ -696,7 +845,7 @@ const getNodeType = (scope, node) => {
   if (node.type === 'CallExpression' || node.type === 'NewExpression') {
     const name = node.callee.name;
     const func = funcs.find(x => x.name === name);
-    if (func) return func.returnType ?? TYPES.number;
+    if (func) return func.returnType;
 
     if (builtinFuncs[name]) return TYPES[builtinFuncs[name].returnType ?? 'number'];
     if (internalConstrs[name]) return internalConstrs[name].type;
@@ -721,9 +870,7 @@ const getNodeType = (scope, node) => {
       protoFunc = prototypeFuncs[baseType]?.[func];
     }
 
-    if (protoFunc) return protoFunc.returnType ?? TYPES.number;
-
-    return TYPES.number;
+    if (protoFunc) return protoFunc.returnType;
   }
 
   if (node.type === 'ExpressionStatement') {
@@ -755,9 +902,6 @@ const getNodeType = (scope, node) => {
 
     if (objectType === TYPES.string && node.computed) return TYPES.string;
   }
-
-  // default to number
-  return TYPES.number;
 };
 
 const generateLiteral = (scope, decl, global, name) => {
@@ -792,7 +936,7 @@ const generateLiteral = (scope, decl, global, name) => {
 
       return makeArray(scope, {
         rawElements
-      }, global, name, false, 'i16');
+      }, global, name, false, 'i16')[0];
 
     default:
       return todo(`cannot generate literal of type ${typeof decl.value}`);
@@ -941,10 +1085,9 @@ const generateCall = (scope, decl, _global, _name) => {
       if (codeLog) log('codegen', 'cloning unknown dynamic pointer');
 
       // register array
-      makeArray(scope, {
+      const [ , pointer ] = makeArray(scope, {
         rawElements: new Array(0)
       }, _global, baseName, true, baseType === TYPES.string ? 'i16' : valtype);
-      pointer = arrays.get(baseName);
 
       const [ local, isGlobal ] = lookupName(scope, baseName);
 
@@ -980,10 +1123,9 @@ const generateCall = (scope, decl, _global, _name) => {
         set: value => arrayUtil.setLength(pointer, value),
         setI32: value => arrayUtil.setLengthI32(pointer, value)
       }, generate(scope, decl.arguments[0] ?? DEFAULT_VALUE), protoLocal, (length, itemType) => {
-        const out = makeArray(scope, {
+        return makeArray(scope, {
           rawElements: new Array(length)
         }, _global, _name, true, itemType);
-        return [ out, arrays.get(_name ?? '$undeclared') ];
       }),
       [ Opcodes.end ]
     ];
@@ -1057,7 +1199,7 @@ const generateNew = (scope, decl, _global, _name) => {
   // hack: basically treat this as a normal call for builtins for now
   const name = mapName(decl.callee.name);
   if (internalConstrs[name]) return internalConstrs[name].generate(scope, decl, _global, _name);
-  if (!builtinFuncs[name]) return todo(`new statement is not supported yet (new ${unhackName(name)})`);
+  if (!builtinFuncs[name]) return todo(`new statement is not supported yet`); // return todo(`new statement is not supported yet (new ${unhackName(name)})`);
 
   return generateCall(scope, decl, _global, _name);
 };
@@ -1245,7 +1387,7 @@ const generateUnary = (scope, decl) => {
 
     case '!':
       // !=
-      return falsy(scope, generate(scope, decl.argument));
+      return falsy(scope, generate(scope, decl.argument), getNodeType(scope, decl.argument));
 
     case '~':
       return [
@@ -1289,7 +1431,7 @@ const generateUnary = (scope, decl) => {
       return out;
 
     case 'typeof':
-      const type = getNodeType(scope, decl.argument);
+      const type = getNodeType(scope, decl.argument) ?? TYPES.number;
 
       // for custom types, just return object
       if (type > 0xffffffffffff7) return number(TYPES.object);
@@ -1422,9 +1564,28 @@ const generateWhile = (scope, decl) => {
   return out;
 };
 
+const generateForOf = (scope, decl) => {
+  const out = [];
+
+  out.push([ Opcodes.loop, Blocktype.void ]);
+  depth.push('while');
+
+  out.push(...generate(scope, decl.test));
+  out.push(Opcodes.i32_to, [ Opcodes.if, Blocktype.void ]);
+  depth.push('if');
+
+  out.push(...generate(scope, decl.body));
+
+  out.push([ Opcodes.br, 1 ]);
+  out.push([ Opcodes.end ], [ Opcodes.end ]);
+  depth.pop(); depth.pop();
+
+  return out;
+};
+
 const getNearestLoop = () => {
   for (let i = depth.length - 1; i >= 0; i--) {
-    if (depth[i] === 'while' || depth[i] === 'for') return i;
+    if (depth[i] === 'while' || depth[i] === 'for' || depth[i] === 'forof') return i;
   }
 
   return -1;
@@ -1514,7 +1675,16 @@ const allocPage = reason => {
   let ind = pages.size;
   pages.set(reason, ind);
 
-  if (codeLog) log('codegen', `allocated new page of memory (${ind}) | ${reason}`);
+  if (allocLog) log('alloc', `allocated new page of memory (${ind}) | ${reason}`);
+
+  return ind;
+};
+
+const freePage = reason => {
+  let ind = pages.get(reason);
+  pages.delete(reason);
+
+  if (allocLog) log('alloc', `freed page of memory (${ind}) | ${reason}`);
 
   return ind;
 };
@@ -1578,12 +1748,12 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
 
   scope.memory = true;
 
-  return out;
+  return [ out, pointer ];
 };
 
 let arrays = new Map();
 const generateArray = (scope, decl, global = false, name = '$undeclared', initEmpty = false) => {
-  return makeArray(scope, decl, global, name, initEmpty, valtype);
+  return makeArray(scope, decl, global, name, initEmpty, valtype)[0];
 };
 
 export const generateMember = (scope, decl, _global, _name) => {
@@ -1644,10 +1814,9 @@ export const generateMember = (scope, decl, _global, _name) => {
 
   // string
 
-  const newOut = makeArray(scope, {
+  const [ newOut, newPointer ] = makeArray(scope, {
     rawElements: new Array(1)
   }, _global, _name, true, 'i16');
-  const newPointer = arrays.get(_name ?? '$undeclared');
 
   return [
     // setup new/out array
@@ -1753,7 +1922,7 @@ const generateFunc = (scope, decl) => {
     name,
     params: Object.values(innerScope.locals).slice(0, params.length).map(x => x.type),
     returns: innerScope.returns,
-    returnType: innerScope.returnType ?? TYPES.number,
+    returnType: innerScope.returnType,
     locals: innerScope.locals,
     memory: innerScope.memory,
     throws: innerScope.throws,
@@ -1912,10 +2081,9 @@ const internalConstrs = {
 
       // new Array(n)
 
-      makeArray(scope, {
+      const [ , pointer ] = makeArray(scope, {
         rawElements: new Array(0)
       }, global, name, true);
-      const pointer = arrays.get(name ?? '$undeclared');
 
       const arg = decl.arguments[0] ?? DEFAULT_VALUE;
 

package/compiler/index.js

@@ -14,7 +14,8 @@ const bold = x => `\u001b[1m${x}\u001b[0m`;
 const areaColors = {
   codegen: [ 20, 80, 250 ],
   opt: [ 250, 20, 80 ],
-  sections: [ 20, 250, 80 ]
+  sections: [ 20, 250, 80 ],
+  alloc: [ 250, 250, 20 ]
 };
 
 globalThis.log = (area, ...args) => console.log(`\u001b[90m[\u001b[0m${rgb(...areaColors[area], area)}\u001b[90m]\u001b[0m`, ...args);
@@ -38,6 +39,7 @@ const logFuncs = (funcs, globals, exceptions) => {
 export default (code, flags) => {
   globalThis.optLog = process.argv.includes('-opt-log');
   globalThis.codeLog = process.argv.includes('-code-log');
+  globalThis.allocLog = process.argv.includes('-alloc-log');
 
   for (const x in BuiltinPreludes) {
     if (code.indexOf(x + '(') !== -1) code = BuiltinPreludes[x] + code;
@@ -63,5 +65,12 @@ export default (code, flags) => {
   const sections = produceSections(funcs, globals, tags, pages, flags);
   if (flags.includes('info')) console.log(`4. produced sections in ${(performance.now() - t3).toFixed(2)}ms`);
 
+  if (allocLog) {
+    const wasmPages = Math.ceil((pages.size * pageSize) / 65536);
+    const bytes = wasmPages * 65536;
+    log('alloc', `\x1B[1mallocated ${bytes / 1024}KiB\x1B[0m for ${pages.size} things using ${wasmPages} Wasm page${wasmPages === 1 ? '' : 's'}`);
+    // console.log([...pages.keys()].map(x => `\x1B[36m - ${x}\x1B[0m`).join('\n'));
+  }
+
   return { wasm: sections, funcs, globals, tags, exceptions, pages };
 };

package/compiler/opt.js

@@ -20,7 +20,7 @@ export default (funcs, globals) => {
   if (optLevel === 0) return;
 
   const tailCall = process.argv.includes('-tail-call');
-  if (tailCall) log('opt', 'tail call proposal is not widely implemented! (you used -tail-call)');
+  if (tailCall) log('opt', 'warning: tail call proposal is not widely implemented! (you used -tail-call)');
 
   if (optLevel >= 2 && !process.argv.includes('-opt-no-inline')) {
     // inline pass (very WIP)

package/compiler/prototype.js

@@ -25,7 +25,6 @@ export const PrototypeFuncs = function() {
 
   this[TYPES._array] = {
     // lX = local accessor of X ({ get, set }), iX = local index of X, wX = wasm ops of X
-    // todo: out of bounds (>) properly
     at: (pointer, length, wIndex, iTmp) => [
       ...wIndex,
       Opcodes.i32_to,
@@ -147,7 +146,6 @@ export const PrototypeFuncs = function() {
   this[TYPES._array].push.noArgRetLength = true;
 
   this[TYPES.string] = {
-    // todo: out of bounds properly
     at: (pointer, length, wIndex, iTmp, arrayShell) => {
       const [ newOut, newPointer ] = arrayShell(1, 'i16');
 
@@ -157,9 +155,9 @@ export const PrototypeFuncs = function() {
         [ Opcodes.drop ],
 
         ...number(0, Valtype.i32), // base 0 for store later
-        Opcodes.i32_to_u,
 
         ...wIndex,
+        Opcodes.i32_to_u,
         [ Opcodes.local_tee, iTmp ],
 
         // if index < 0: access index + array length
@@ -265,7 +263,7 @@ export const PrototypeFuncs = function() {
     },
   };
 
-  this[TYPES.string].at.local = valtypeBinary;
+  this[TYPES.string].at.local = Valtype.i32;
   this[TYPES.string].at.returnType = TYPES.string;
   this[TYPES.string].charAt.returnType = TYPES.string;
   this[TYPES.string].charCodeAt.local = Valtype.i32;

package/compiler/sections.js

@@ -36,7 +36,7 @@ export default (funcs, globals, tags, pages, flags) => {
     // tree shake imports
     for (const f of funcs) {
       for (const inst of f.wasm) {
-        if (inst[0] === Opcodes.call && inst[1] < importedFuncs.length) {
+        if ((inst[0] === Opcodes.call || inst[0] === Opcodes.return_call) && inst[1] < importedFuncs.length) {
           const idx = inst[1];
           const func = importedFuncs[idx];
 
@@ -51,10 +51,11 @@ export default (funcs, globals, tags, pages, flags) => {
     // fix call indexes for non-imports
     const delta = importedFuncs.length - importFuncs.length;
     for (const f of funcs) {
+      f.originalIndex = f.index;
       f.index -= delta;
 
       for (const inst of f.wasm) {
-        if (inst[0] === Opcodes.call && inst[1] >= importedFuncs.length) {
+        if ((inst[0] === Opcodes.call || inst[0] === Opcodes.return_call) && inst[1] >= importedFuncs.length) {
           inst[1] -= delta;
         }
       }

package/compiler/wrap.js

@@ -1,6 +1,6 @@
 import compile from './index.js';
 import decompile from './decompile.js';
-// import fs from 'node:fs';
+import fs from 'node:fs';
 
 const bold = x => `\u001b[1m${x}\u001b[0m`;
 
@@ -27,7 +27,7 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
 
   if (source.includes('export function')) flags.push('module');
 
-  // fs.writeFileSync('out.wasm', Buffer.from(wasm));
+  fs.writeFileSync('out.wasm', Buffer.from(wasm));
 
   times.push(performance.now() - t1);
   if (flags.includes('info')) console.log(bold(`compiled in ${times[0].toFixed(2)}ms`));
@@ -90,6 +90,15 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
             return Array.from(new Uint16Array(memory.buffer, pointer + 4, length)).map(x => String.fromCharCode(x)).join('');
           }
 
+          case 'function': {
+            // wasm func index, including all imports
+            const func = funcs.find(x => (x.originalIndex ?? x.index) === ret);
+            if (!func) return ret;
+
+            // make fake empty func for repl/etc
+            return {[func.name]() {}}[func.name];
+          }
+
           default: return ret;
         }
       } catch (e) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "porffor",
   "description": "a basic experimental wip aot optimizing js -> wasm engine/compiler/runtime in js",
-  "version": "0.0.0-579ef36",
+  "version": "0.0.0-61de729",
   "author": "CanadaHonk",
   "license": "MIT",
   "dependencies": {

package/runner/index.js

@@ -5,6 +5,12 @@ import fs from 'node:fs';
 
 const file = process.argv.slice(2).find(x => x[0] !== '-');
 if (!file) {
+  if (process.argv.includes('-v')) {
+    // just print version
+    console.log((await import('./version.js')).default);
+    process.exit(0);
+  }
+
   // run repl if no file given
   await import('./repl.js');
 
@@ -30,5 +36,6 @@ try {
   exports.main();
   if (cache) process.stdout.write(cache);
 } catch (e) {
+  if (cache) process.stdout.write(cache);
   console.error(`${e.constructor.name}: ${e.message}`);
 }

package/runner/repl.js

@@ -1,14 +1,7 @@
 import compile from '../compiler/wrap.js';
+import rev from './version.js';
 
 import repl from 'node:repl';
-import fs from 'node:fs';
-
-let rev = 'unknown';
-try {
-  rev = fs.readFileSync(new URL('../.git/refs/heads/main', import.meta.url), 'utf8').trim().slice(0, 7);
-} catch {
-  rev = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version.split('-')[1];
-}
 
 // process.argv.push('-O0'); // disable opts
 
@@ -48,15 +41,17 @@ const memoryToString = mem => {
   return out;
 };
 
+const alwaysPrev = process.argv.includes('-prev');
+
 let prev = '';
 const run = async (source, _context, _filename, callback, run = true) => {
   let toRun = prev + source.trim();
-  // prev = toRun + ';\n';
+  if (alwaysPrev) prev = toRun + ';\n';
 
   const { exports, wasm, pages } = await compile(toRun, []);
-  fs.writeFileSync('out.wasm', Buffer.from(wasm));
+  // fs.writeFileSync('out.wasm', Buffer.from(wasm));
 
-  if (exports.$) {
+  if (run && exports.$) {
     lastMemory = exports.$;
     lastPages = [...pages.keys()];
   }
@@ -64,8 +59,8 @@ const run = async (source, _context, _filename, callback, run = true) => {
   const ret = run ? exports.main() : undefined;
   callback(null, ret);
 
-  // if (source.includes(' = ') || source.includes('let ') || source.includes('var ') || source.includes('const ')) prev += source + ';\n';
-  prev = toRun + ';\n';
+  if (!alwaysPrev && (source.includes(' = ') || source.includes('let ') || source.includes('var ') || source.includes('const ') || source.includes('function '))) prev = toRun + ';\n';
+  // prev = toRun + ';\n';
 };
 
 const replServer = repl.start({ prompt: '> ', eval: run });

package/runner/transform.js

@@ -5,32 +5,10 @@ const file = process.argv.slice(2).find(x => x[0] !== '-');
 
 const source = fs.readFileSync(file, 'utf8');
 
-const underline = x => `\u001b[4m\u001b[1m${x}\u001b[0m`;
-const bold = x => `\u001b[1m${x}\u001b[0m`;
-
-let cache = '';
-const print = str => {
-  cache += str;
-
-  if (str === '\n') {
-    process.stdout.write(cache);
-    cache = '';
-  }
-};
-
 const { wasm } = await compile(source);
 
-if (!raw && typeof Deno === 'undefined') fs.writeFileSync('out.wasm', Buffer.from(wasm));
-
-if (!process.argv.includes('-no-run')) {
-  console.log(`\n\n${underline('output')}`);
-  const t2 = performance.now();
-
-  exports.main();
-  print('\n');
-
-  if (!raw) console.log(bold(`\n\nexecuted in ${(performance.now() - t2).toFixed(2)}ms`));
-}
+// const out = `(async () => { const print = str => process.stdout.write(str); (await WebAssembly.instantiate(Uint8Array.from([${wasm.toString()}]), {'': { p: i => print(i.toString()), c: i => print(String.fromCharCode(i))}})).instance.exports.m()})()`;
+const out = `new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([${wasm.toString()}])),{'':{p:i=>process.stdout.write(i.toString())}}).exports.m()`;
 
-if (!raw) console.log(bold(`wasm binary is ${wasm.byteLength} bytes`));
-if (!raw) console.log(`total: ${(performance.now() - t0).toFixed(2)}ms`);
+console.log(out);
+eval(out);

package/runner/version.js

@@ -0,0 +1,10 @@
+import fs from 'node:fs';
+
+let rev = 'unknown';
+try {
+  rev = fs.readFileSync(new URL('../.git/refs/heads/main', import.meta.url), 'utf8').trim().slice(0, 7);
+} catch {
+  rev = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version.split('-')[1].slice(0, 7);
+}
+
+export default rev;

package/t.js

@@ -0,0 +1,31 @@
+let assert = Object();
+
+assert._isSameValue = function (a, b) {
+  if (a === b) {
+    // Handle +/-0 vs. -/+0
+    return a !== 0 || 1 / a === 1 / b;
+  }
+
+  // Handle NaN vs. NaN
+  return a !== a && b !== b;
+
+  // return a === b;
+};
+
+assert.sameValue = function (actual, expected) {
+  /* try {
+    if (assert._isSameValue(actual, expected)) {
+      return;
+    }
+  } catch (error) {
+    throw new Test262Error('_isSameValue operation threw');
+  } */
+
+  if (assert._isSameValue(actual, expected)) {
+    return;
+  }
+
+  throw new Test262Error('assert.sameValue failed');
+};
+
+assert.sameValue("lego".charAt(), "l");