porffor 0.14.0-7bef6473d → 0.14.0-86ac87fa4

package/compiler/assemble.js

@@ -65,6 +65,7 @@ export default (funcs, globals, tags, pages, data, flags) => {
     importFuncs = [...imports.values()];
 
     // fix call indexes for non-imports
+    // also fix call_indirect types
     const delta = importedFuncs.length - importFuncs.length;
     for (const f of funcs) {
       f.originalIndex = f.index;
@@ -74,6 +75,16 @@ export default (funcs, globals, tags, pages, data, flags) => {
         if ((inst[0] === Opcodes.call || inst[0] === Opcodes.return_call) && inst[1] >= importedFuncs.length) {
           inst[1] -= delta;
         }
+
+        if (inst[0] === Opcodes.call_indirect) {
+          const params = [];
+          for (let i = 0; i < inst[1]; i++) {
+            params.push(valtypeBinary, Valtype.i32);
+          }
+
+          const returns = [ valtypeBinary, Valtype.i32 ];
+          inst[1] = getType(params, returns);
+        }
       }
     }
   }
@@ -101,7 +112,7 @@ export default (funcs, globals, tags, pages, data, flags) => {
     encodeVector([ [
       0x00,
       Opcodes.i32_const, 0, Opcodes.end,
-      encodeVector(funcs.map(x => x.index))
+      ...encodeVector(funcs.map(x => x.index))
     ] ])
   );
 

package/compiler/builtins/boolean.ts

@@ -15,4 +15,4 @@ export const __Boolean_prototype_toString = (_this: boolean) => {
 export const __Boolean_prototype_valueOf = (_this: boolean) => {
   // 1. Return ? ThisBooleanValue(this value).
   return _this;
-};
+};

package/compiler/builtins/symbol.ts

@@ -0,0 +1,61 @@
+export const __Porffor_symbol_descStore = (op: boolean, value: any): any => {
+  const ptr: bytestring = '';
+
+  if (op) { // write
+    const size: number = Porffor.wasm.i32.load(ptr, 0, 0);
+    Porffor.wasm.i32.store(ptr, size + 1, 0, 0)
+
+    // reuse set internals to store description
+    __Porffor_set_write(ptr, size, value);
+    return size;
+  } else { // read
+    return __Porffor_set_read(ptr, value);
+  }
+};
+
+export const Symbol = (description: any): Symbol => {
+  // 1-based so always truthy as numeric value
+  return __Porffor_symbol_descStore(true, description) + 1;
+};
+
+// todo: this should be a getter somehow not a method
+export const __Symbol_prototype_description = (_this: Symbol) => {
+  const description: bytestring = __Porffor_symbol_descStore(false,
+    Porffor.wasm`local.get ${_this}` - 1);
+  return description;
+};
+
+export const __Symbol_prototype_toString = (_this: Symbol) => {
+  let out: bytestring = '';
+
+  // Symbol(
+  Porffor.wasm.i32.store8(out, 83, 0, 4);
+  Porffor.wasm.i32.store8(out, 121, 0, 5);
+  Porffor.wasm.i32.store8(out, 109, 0, 6);
+  Porffor.wasm.i32.store8(out, 98, 0, 7);
+  Porffor.wasm.i32.store8(out, 111, 0, 8);
+  Porffor.wasm.i32.store8(out, 108, 0, 9);
+  Porffor.wasm.i32.store8(out, 40, 0, 10);
+
+  const description: bytestring = __Porffor_symbol_descStore(false,
+    Porffor.wasm`local.get ${_this}` - 1);
+
+  const descLen: i32 = description.length;
+  let outPtr: i32 = Porffor.wasm`local.get ${out}` + 7;
+  let descPtr: i32 = Porffor.wasm`local.get ${description}`;
+  const descPtrEnd: i32 = descPtr + descLen;
+  while (descPtr < descPtrEnd) {
+    Porffor.wasm.i32.store8(outPtr++, Porffor.wasm.i32.load8_u(descPtr++, 0, 4), 0, 4);
+  }
+
+  // )
+  Porffor.wasm.i32.store8(Porffor.wasm`local.get ${out}` + descLen, 41, 0, 11);
+
+  out.length = 8 + descLen;
+
+  return out;
+};
+
+export const __Symbol_prototype_valueOf = (_this: Symbol) => {
+  return _this;
+};

package/compiler/builtins.js

@@ -198,7 +198,8 @@ export const BuiltinFuncs = function() {
     returns: [ valtypeBinary ],
     wasm: [
       [ Opcodes.local_get, 0 ]
-    ]
+    ],
+    constr: true
   };
 
   // just return given (default 0) for (new) Object() as we somewhat supports object just not constructor
@@ -210,7 +211,8 @@ export const BuiltinFuncs = function() {
     wasm: [
       // [ Opcodes.local_get, 0 ]
       ...number(1)
-    ]
+    ],
+    constr: true
   };
 
 

package/compiler/codegen.js

@@ -58,10 +58,11 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
 
     case 'ArrowFunctionExpression':
     case 'FunctionDeclaration':
+    case 'FunctionExpression':
       const func = generateFunc(scope, decl);
 
       if (decl.type.endsWith('Expression')) {
-        return number(func.index);
+        return number(func.index - importedFuncs.length);
       }
 
       return [];
@@ -139,6 +140,9 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
     case 'ArrayExpression':
       return generateArray(scope, decl, global, name);
 
+    case 'ObjectExpression':
+      return generateObject(scope, decl, global, name);
+
     case 'MemberExpression':
       return generateMember(scope, decl, global, name);
 
@@ -187,7 +191,7 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
             if (!Array.isArray(inst)) inst = [ inst ];
             const immediates = asm.slice(1).map(x => {
               const int = parseInt(x);
-              if (Number.isNaN(int)) return scope.locals[x]?.idx;
+              if (Number.isNaN(int)) return scope.locals[x]?.idx ?? globals[x].idx;
               return int;
             });
 
@@ -313,10 +317,10 @@ const generateIdent = (scope, decl) => {
 
     if (local?.idx === undefined) {
       // no local var with name
-      if (Object.hasOwn(importedFuncs, name)) return number(importedFuncs[name]);
-      if (Object.hasOwn(funcIndex, name)) return number(funcIndex[name]);
-
       if (Object.hasOwn(globals, name)) return [ [ Opcodes.global_get, globals[name].idx ] ];
+
+      if (Object.hasOwn(importedFuncs, name)) return number(importedFuncs[name] - importedFuncs.length);
+      if (Object.hasOwn(funcIndex, name)) return number(funcIndex[name] - importedFuncs.length);
     }
 
     if (local?.idx === undefined && rawName.startsWith('__')) {
@@ -350,9 +354,7 @@ const generateReturn = (scope, decl) => {
 
   return [
     ...generate(scope, decl.argument),
-    ...(scope.returnType != null ? [] : [
-      ...getNodeType(scope, decl.argument)
-    ]),
+    ...(scope.returnType != null ? [] : getNodeType(scope, decl.argument)),
     [ Opcodes.return ]
   ];
 };
@@ -1450,6 +1452,10 @@ const countLeftover = wasm => {
             } else count--;
             if (func) count += func.returns.length;
           }
+        } else if (inst[0] === Opcodes.call_indirect) {
+          count--; // funcidx
+          count -= inst[1] * 2; // params * 2 (typed)
+          count += 2; // fixed return (value, type)
         } else count--;
 
     // console.log(count, decompile([ inst ]).slice(0, -1));
@@ -1831,7 +1837,45 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   }
 
   if (idx === undefined) {
-    if (scope.locals[name] !== undefined || globals[name] !== undefined || builtinVars[name] !== undefined) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, true);
+    if (scope.locals[name] !== undefined || globals[name] !== undefined || builtinVars[name] !== undefined) {
+      const [ local, global ] = lookupName(scope, name);
+      if (!Prefs.indirectCalls || local == null) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, true);
+
+      // todo: only works when:
+      //   1. arg count matches arg count of function
+      //   2. function uses typedParams and typedReturns
+
+      funcs.table = true;
+
+      let args = decl.arguments;
+      let argWasm = [];
+
+      for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        argWasm = argWasm.concat(generate(scope, arg));
+
+        if (valtypeBinary !== Valtype.i32 && (
+          (builtinFuncs[name] && builtinFuncs[name].params[i * (typedParams ? 2 : 1)] === Valtype.i32) ||
+          (importedFuncs[name] && name.startsWith('profile'))
+        )) {
+          argWasm.push(Opcodes.i32_to);
+        }
+
+        argWasm = argWasm.concat(getNodeType(scope, arg));
+      }
+
+      return typeSwitch(scope, getNodeType(scope, decl.callee), {
+        [TYPES.function]: [
+          ...argWasm,
+          [ global ? Opcodes.global_get : Opcodes.local_get, local.idx ],
+          Opcodes.i32_to_u,
+          [ Opcodes.call_indirect, args.length, 0 ],
+          ...setLastType(scope)
+        ],
+        default: internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, true)
+      });
+    }
+
     return internalThrow(scope, 'ReferenceError', `${unhackName(name)} is not defined`, true);
   }
 
@@ -1860,11 +1904,16 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     const arg = args[i];
     out = out.concat(generate(scope, arg));
 
-    if (builtinFuncs[name] && builtinFuncs[name].params[i * (typedParams ? 2 : 1)] === Valtype.i32 && valtypeBinary !== Valtype.i32) {
-      out.push(Opcodes.i32_to);
+    if (i >= paramCount) {
+      // over param count of func, drop arg
+      out.push([ Opcodes.drop ]);
+      continue;
     }
 
-    if (importedFuncs[name] && name.startsWith('profile')) {
+    if (valtypeBinary !== Valtype.i32 && (
+      (builtinFuncs[name] && builtinFuncs[name].params[i * (typedParams ? 2 : 1)] === Valtype.i32) ||
+      (importedFuncs[name] && name.startsWith('profile'))
+    )) {
       out.push(Opcodes.i32_to);
     }
 
@@ -1909,6 +1958,11 @@ const generateNew = (scope, decl, _global, _name) => {
     }, _global, _name);
   }
 
+  if (
+    (builtinFuncs[name] && !builtinFuncs[name].constr) ||
+    (internalConstrs[name] && builtinFuncs[name].notConstr)
+  ) return internalThrow(scope, 'TypeError', `${name} is not a constructor`);
+
   if (!builtinFuncs[name]) return todo(scope, `new statement is not supported yet`); // return todo(scope, `new statement is not supported yet (new ${unhackName(name)})`);
 
   return generateCall(scope, decl, _global, _name);
@@ -2174,6 +2228,22 @@ const generateVar = (scope, decl) => {
     }
 
     if (x.init) {
+      // if (isFuncType(x.init.type)) {
+      //   // let a = function () { ... }
+      //   x.init.id = { name };
+
+      //   const func = generateFunc(scope, x.init);
+
+      //   out.push(
+      //     ...number(func.index - importedFuncs.length),
+      //     [ global ? Opcodes.global_set : Opcodes.local_set, idx ],
+
+      //     ...setType(scope, name, TYPES.function)
+      //   );
+
+      //   continue;
+      // }
+
       const generated = generate(scope, x.init, global, name);
       if (scope.arrays?.get(name) != null) {
         // hack to set local as pointer before
@@ -2185,6 +2255,7 @@ const generateVar = (scope, decl) => {
         out = out.concat(generated);
         out.push([ global ? Opcodes.global_set : Opcodes.local_set, idx ]);
       }
+
       out.push(...setType(scope, name, getNodeType(scope, x.init)));
     }
 
@@ -2198,6 +2269,7 @@ const generateVar = (scope, decl) => {
 // todo: optimize this func for valueUnused
 const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
   const { type, name } = decl.left;
+  const [ local, isGlobal ] = lookupName(scope, name);
 
   if (type === 'ObjectPattern') {
     // hack: ignore object parts of `var a = {} = 2`
@@ -2207,8 +2279,18 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
   if (isFuncType(decl.right.type)) {
     // hack for a = function () { ... }
     decl.right.id = { name };
-    generateFunc(scope, decl.right);
-    return [];
+
+    const func = generateFunc(scope, decl.right);
+
+    return [
+      ...number(func.index - importedFuncs.length),
+      ...(local != null ? [
+        [ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx ],
+        [ isGlobal ? Opcodes.global_get : Opcodes.local_get, local.idx ],
+
+        ...setType(scope, name, TYPES.function)
+      ] : [])
+    ];
   }
 
   const op = decl.operator.slice(0, -1) || '=';
@@ -2307,8 +2389,6 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
 
   if (!name) return todo(scope, 'destructuring is not supported yet', true);
 
-  const [ local, isGlobal ] = lookupName(scope, name);
-
   if (local === undefined) {
     // todo: this should be a sloppy mode only thing
 
@@ -2457,6 +2537,7 @@ const generateUnary = (scope, decl) => {
         [TYPES.string]: makeString(scope, 'string', false, '#typeof_result'),
         [TYPES.undefined]: makeString(scope, 'undefined', false, '#typeof_result'),
         [TYPES.function]: makeString(scope, 'function', false, '#typeof_result'),
+        [TYPES.symbol]: makeString(scope, 'symbol', false, '#typeof_result'),
 
         [TYPES.bytestring]: makeString(scope, 'string', false, '#typeof_result'),
 
@@ -3147,7 +3228,18 @@ const generateArray = (scope, decl, global = false, name = '$undeclared', initEm
   return makeArray(scope, decl, global, name, initEmpty, valtype)[0];
 };
 
-export const generateMember = (scope, decl, _global, _name) => {
+const generateObject = (scope, decl, global = false, name = '$undeclared') => {
+  if (decl.properties.length > 0) return todo(scope, 'objects are not supported yet', true);
+
+  return [
+    ...number(1),
+
+    ...number(TYPES.object, Valtype.i32),
+    ...setLastType(scope)
+  ];
+};
+
+const generateMember = (scope, decl, _global, _name) => {
   const name = decl.object.name;
   const pointer = scope.arrays?.get(name);
 
@@ -3368,7 +3460,7 @@ const generateFunc = (scope, decl) => {
 
   if (typedInput && decl.returnType) {
     const { type } = extractTypeAnnotation(decl.returnType);
-    if (type != null) {
+    if (type != null && !Prefs.indirectCalls) {
       innerScope.returnType = type;
       innerScope.returns = [ valtypeBinary ];
     }
@@ -3586,8 +3678,10 @@ const internalConstrs = {
           }),
 
           // print space
-          ...number(32),
-          [ Opcodes.call, importedFuncs.printChar ]
+          ...(i !== decl.arguments.length - 1 ? [
+            ...number(32),
+            [ Opcodes.call, importedFuncs.printChar ]
+          ] : [])
         );
       }
 
@@ -3597,6 +3691,8 @@ const internalConstrs = {
         [ Opcodes.call, importedFuncs.printChar ]
       );
 
+      out.push(...number(UNDEFINED));
+
       return out;
     },
     type: TYPES.undefined,

package/compiler/decompile.js

@@ -119,7 +119,7 @@ export const highlightAsm = asm => asm
   .replace(/(local|global|memory)\.[^\s]*/g, _ => `\x1B[31m${_}\x1B[0m`)
   .replace(/(i(8|16|32|64)x[0-9]+|v128)(\.[^\s]*)?/g, _ => `\x1B[34m${_}\x1B[0m`)
   .replace(/(i32|i64|f32|f64|drop)(\.[^\s]*)?/g, _ => `\x1B[36m${_}\x1B[0m`)
-  .replace(/(return_call|call|br_if|br|return|rethrow|throw)/g, _ => `\x1B[35m${_}\x1B[0m`)
+  .replace(/(return_call|call_indirect|call|br_if|br|return|rethrow|throw)/g, _ => `\x1B[35m${_}\x1B[0m`)
   .replace(/(block|loop|if|end|else|try|catch_all|catch|delegate)/g, _ => `\x1B[95m${_}\x1B[0m`)
   .replace(/unreachable/g, _ => `\x1B[91m${_}\x1B[0m`)
   .replace(/ \-?[0-9\.]+/g, _ => ` \x1B[33m${_.slice(1)}\x1B[0m`)

package/compiler/generated_builtins.js

@@ -1622,4 +1622,49 @@ export const BuiltinFuncs = function() {
     locals: [],
     localNames: ["_this","_this#type"],
   };
+  this.__Porffor_symbol_descStore = {
+    wasm: (scope, {allocPage,builtin,}) => [...number(allocPage(scope, 'bytestring: __Porffor_symbol_descStore/ptr', 'i8') * pageSize, 124),[33,4],[32,0],[252,3],[4,64],[32,4],[252,2],[40,0,0],[183],[33,5],[32,4],[252,2],[32,5],[68,0,0,0,0,0,0,240,63],[160],[252,2],[54,0,0],[32,4],[65,18],[32,5],[65,0],[32,2],[32,3],[16, builtin('__Porffor_set_write')],[26],[32,5],[65,0],[15],[5],[32,4],[65,18],[32,2],[32,3],[16, builtin('__Porffor_set_read')],[34,6],[15],[11],[68,0,0,0,0,0,0,0,0],[65,3],[15]],
+    params: [124,127,124,127],
+    typedParams: true,
+    returns: [124,127],
+    typedReturns: true,
+    locals: [124,124,127],
+    localNames: ["op","op#type","value","value#type","ptr","size","#last_type"],
+  };
+  this.Symbol = {
+    wasm: (scope, {builtin,}) => [[68,0,0,0,0,0,0,240,63],[65,1],[32,0],[32,1],[16, builtin('__Porffor_symbol_descStore')],[33,2],[68,0,0,0,0,0,0,240,63],[160],[15]],
+    params: [124,127],
+    typedParams: true,
+    returns: [124],
+    returnType: 6,
+    locals: [127],
+    localNames: ["description","description#type","#last_type"],
+  };
+  this.__Symbol_prototype_description = {
+    wasm: (scope, {builtin,}) => [[68,0,0,0,0,0,0,0,0],[65,1],[32,0],[68,0,0,0,0,0,0,240,63],[161],[65,0],[16, builtin('__Porffor_symbol_descStore')],[33,3],[34,2],[65,18],[15]],
+    params: [124,127],
+    typedParams: true,
+    returns: [124,127],
+    typedReturns: true,
+    locals: [124,127],
+    localNames: ["_this","_this#type","description","#last_type"],
+  };
+  this.__Symbol_prototype_toString = {
+    wasm: (scope, {allocPage,builtin,}) => [...number(allocPage(scope, 'bytestring: __Symbol_prototype_toString/out', 'i8') * pageSize, 124),[34,2],[252,2],[65,211,0],[58,0,4],[32,2],[252,2],[65,249,0],[58,0,5],[32,2],[252,2],[65,237,0],[58,0,6],[32,2],[252,2],[65,226,0],[58,0,7],[32,2],[252,2],[65,239,0],[58,0,8],[32,2],[252,2],[65,236,0],[58,0,9],[32,2],[252,2],[65,40],[58,0,10],[68,0,0,0,0,0,0,0,0],[65,1],[32,0],[68,0,0,0,0,0,0,240,63],[161],[65,0],[16, builtin('__Porffor_symbol_descStore')],[33,4],[34,3],[252,3],[40,1,0],[184],[33,5],[32,2],[68,0,0,0,0,0,0,28,64],[160],[33,6],[32,3],[34,7],[32,5],[160],[33,8],[3,64],[32,7],[32,8],[99],[4,64],[32,6],[32,6],[68,0,0,0,0,0,0,240,63],[160],[33,6],[252,2],[32,7],[32,7],[68,0,0,0,0,0,0,240,63],[160],[33,7],[252,2],[45,0,4],[58,0,4],[12,1],[11],[11],[32,2],[32,5],[160],[252,2],[65,41],[58,0,11],[32,2],[252,3],[68,0,0,0,0,0,0,32,64],[32,5],[160],[34,9],[252,3],[54,1,0],[32,2],[65,18],[15]],
+    params: [124,127],
+    typedParams: true,
+    returns: [124,127],
+    typedReturns: true,
+    locals: [124,124,127,124,124,124,124,124],
+    localNames: ["_this","_this#type","out","description","#last_type","descLen","outPtr","descPtr","descPtrEnd","__length_setter_tmp"],
+  };
+  this.__Symbol_prototype_valueOf = {
+    wasm: (scope, {}) => [[32,0],[65,6],[15]],
+    params: [124,127],
+    typedParams: true,
+    returns: [124,127],
+    typedReturns: true,
+    locals: [],
+    localNames: ["_this","_this#type"],
+  };
 };

package/compiler/index.js

@@ -12,14 +12,7 @@ globalThis.decompile = decompile;
 const logFuncs = (funcs, globals, exceptions) => {
   console.log('\n' + underline(bold('funcs')));
 
-  const startIndex = funcs.sort((a, b) => a.index - b.index)[0].index;
   for (const f of funcs) {
-    console.log(`${underline(f.name)} (${f.index - startIndex})`);
-
-    console.log(`params: ${f.params.map((_, i) => Object.keys(f.locals)[Object.values(f.locals).indexOf(Object.values(f.locals).find(x => x.idx === i))]).join(', ')}`);
-    console.log(`returns: ${f.returns.length > 0 ? true : false}`);
-    console.log(`locals: ${Object.keys(f.locals).sort((a, b) => f.locals[a].idx - f.locals[b].idx).map(x => `${x} (${f.locals[x].idx})`).join(', ')}`);
-    console.log();
     console.log(decompile(f.wasm, f.name, f.index, f.locals, f.params, f.returns, funcs, globals, exceptions));
   }
 
@@ -44,12 +37,14 @@ export default (code, flags) => {
   opt(funcs, globals, pages, tags, exceptions);
   if (Prefs.profileCompiler) console.log(`3. optimized in ${(performance.now() - t2).toFixed(2)}ms`);
 
-  if (Prefs.optFuncs) logFuncs(funcs, globals, exceptions);
+  // if (Prefs.optFuncs) logFuncs(funcs, globals, exceptions);
 
   const t3 = performance.now();
   const wasm = assemble(funcs, globals, tags, pages, data, flags);
   if (Prefs.profileCompiler) console.log(`4. assembled in ${(performance.now() - t3).toFixed(2)}ms`);
 
+  if (Prefs.optFuncs) logFuncs(funcs, globals, exceptions);
+
   if (Prefs.allocLog) {
     const wasmPages = Math.ceil((pages.size * pageSize) / 65536);
     const bytes = wasmPages * 65536;

package/compiler/precompile.js

@@ -18,7 +18,7 @@ const compile = async (file, [ _funcs, _globals ]) => {
     first = source.slice(0, source.indexOf('\n'));
   }
 
-  let args = ['--bytestring', '--todo-time=compile', '--no-aot-pointer-opt', '--no-treeshake-wasm-imports', '--no-rm-unused-types', '--scoped-page-names', '--funsafe-no-unlikely-proto-checks', '--parse-types', '--opt-types'];
+  let args = ['--bytestring', '--todo-time=compile', '--no-aot-pointer-opt', '--no-indirect-calls', '--no-treeshake-wasm-imports', '--no-rm-unused-types', '--scoped-page-names', '--funsafe-no-unlikely-proto-checks', '--parse-types', '--opt-types'];
   if (first.startsWith('// @porf')) {
     args = args.concat(first.slice('// @porf '.length).split(' '));
   }

package/compiler/prefs.js

@@ -1,4 +1,4 @@
-const onByDefault = [ 'bytestring', 'aotPointerOpt', 'treeshakeWasmImports', 'alwaysMemory' ];
+const onByDefault = [ 'bytestring', 'aotPointerOpt', 'treeshakeWasmImports', 'alwaysMemory', 'indirectCalls' ];
 
 let cache = {};
 const obj = new Proxy({}, {
@@ -6,7 +6,7 @@ const obj = new Proxy({}, {
     // intentionally misses with undefined values cached
     if (cache[p]) return cache[p];
 
-    return cache[p] = (() => {
+    const ret = (() => {
       // fooBar -> foo-bar
       const name = p[0] === '_' ? p : p.replace(/[A-Z]/g, c => `-${c.toLowerCase()}`);
       const prefix = name.length === 1 ? '-' : '--';
@@ -19,6 +19,10 @@ const obj = new Proxy({}, {
       if (onByDefault.includes(p)) return true;
       return undefined;
     })();
+
+    // do not cache in web demo as args are changed live
+    if (!globalThis.document) cache[p] = ret;
+    return ret;
   }
 });
 

package/compiler/wrap.js

@@ -1,22 +1,27 @@
+import { encodeVector, encodeLocal } from './encoding.js';
+import { importedFuncs } from './builtins.js';
 import compile from './index.js';
 import decompile from './decompile.js';
-import { encodeVector, encodeLocal } from './encoding.js';
 import { TYPES } from './types.js';
 import { log } from './log.js';
 import Prefs from './prefs.js';
 
 const bold = x => `\u001b[1m${x}\u001b[0m`;
 
-const porfToJSValue = (memory, funcs, value, type) => {
+const porfToJSValue = ({ memory, funcs, pages }, value, type) => {
   switch (type) {
     case TYPES.boolean: return Boolean(value);
     case TYPES.undefined: return undefined;
     case TYPES.object: return value === 0 ? null : {};
 
     case TYPES.function: {
-      // wasm func index, including all imports
-      const func = funcs.find(x => (x.originalIndex ?? x.index) === value);
-      // if (!func) return value;
+      let func;
+      if (value < 0) {
+        func = importedFuncs[value + importedFuncs.length];
+      } else {
+        func = funcs.find(x => ((x.originalIndex ?? x.index) - importedFuncs.length) === value);
+      }
+
       if (!func) return function () {};
 
       // make fake empty func for repl/etc
@@ -61,12 +66,24 @@ const porfToJSValue = (memory, funcs, value, type) => {
         // console.log('  memory:', Array.from(new Uint8Array(memory.buffer, offset, 9)).map(x => x.toString(16).padStart(2, '0')).join(' '));
         // console.log('  read:', { value: v, type: t }, '\n');
 
-        out.add(porfToJSValue(memory, funcs, v, t));
+        out.add(porfToJSValue({ memory, funcs, pages }, v, t));
       }
 
       return out;
     }
 
+    case TYPES.symbol: {
+      const descStore = pages.get('bytestring: __Porffor_symbol_descStore/ptr').ind * pageSize;
+      const offset = descStore + 4 + ((value - 1) * 9);
+
+      const v = (new Float64Array(memory.buffer.slice(offset, offset + 8), 0, 1))[0];
+      const t = (new Uint8Array(memory.buffer, offset + 8, 1))[0];
+
+      const desc = porfToJSValue({ memory, funcs, pages }, v, t);
+
+      return Symbol(desc);
+    }
+
     default: return value;
   }
 };
@@ -213,10 +230,11 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
     exports[func.name] = function() {
       try {
         const ret = exp.apply(this, arguments);
-
         if (ret == null) return undefined;
 
-        return porfToJSValue(memory, funcs, ret[0], ret[1])
+        if (Prefs.rawValue) return { value: ret[0], type: ret[1] };
+
+        return porfToJSValue({ memory, funcs, pages }, ret[0], ret[1]);
       } catch (e) {
         if (e.is && e.is(exceptTag)) {
           const exceptId = e.getArg(exceptTag, 0);

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.14.0-7bef6473d",
+  "version": "0.14.0-86ac87fa4",
   "author": "CanadaHonk",
   "license": "MIT",
   "scripts": {