porffor 0.2.0-15592d6 → 0.2.0-181627c

package/compiler/builtins/base64.ts

@@ -2,6 +2,38 @@
 
 import type { i32, bytestring } from './porffor.d.ts';
 
+// const appendKeyChar = (target: bytestring, ind: i32): bytestring => {
+//   const keyStr: bytestring = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+//   return target + keyStr.charAt(ind);
+// };
+
+// const appendKeyChar = (target: bytestring, ind: i32): void => {
+//   const keyStr: bytestring = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+
+//   Porffor.bytestring.appendCharAt(target, keyStr, ind);
+
+//   Porffor.wasm`local.get ${ind}
+// i32.to_u
+// i32.const 2
+// i32.mul
+// local.get ${keyStr}
+// i32.to_u
+// i32.add
+// i32.load8_u 0 4
+
+// local targetI32 i32
+// local.get ${target}
+// i32.to_u
+// local.tee targetI32
+// local.get targetI32
+// i32.load 1 0
+// i32.const 2
+// i32.mul
+// i32.add
+
+// i32.store8 0 4`;
+// };
+
 export const btoa = (input: bytestring): bytestring => {
   const keyStr: bytestring = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
 
@@ -20,37 +52,22 @@ export const btoa = (input: bytestring): bytestring => {
     let enc3: i32 = ((chr2 & 15) << 2) | (chr3 >> 6);
     let enc4: i32 = chr3 & 63;
 
-    if (isNaN(chr2)) {
+    if (Number.isNaN(chr2)) {
       enc3 = 64;
       enc4 = 64;
-    } else if (isNaN(chr3)) {
+    } else if (Number.isNaN(chr3)) {
       enc4 = 64;
     }
 
-    // const endPtr: i32 = output.length * 2;
-
-    // smile :)
-//     Porffor.wasm`local.get ${enc1}
-// i32.to_u
-// i32.const 2
-// i32.mul
-// local.get ${keyStr}
-// i32.to_u
-// i32.add
-// i32.load16_u 0 4
-
-// local.get ${output}
-// i32.to_u
-// local.get ${endPtr}
-// i32.to_u
-// i32.add
-
-// i32.store16 0 4`;
+    Porffor.bytestring.appendCharAt(output, keyStr, enc1);
+    Porffor.bytestring.appendCharAt(output, keyStr, enc2);
+    Porffor.bytestring.appendCharAt(output, keyStr, enc3);
+    Porffor.bytestring.appendCharAt(output, keyStr, enc4);
 
-    output += keyStr.charAt(enc1);
-    output += keyStr.charAt(enc2);
-    output += keyStr.charAt(enc3);
-    output += keyStr.charAt(enc4);
+    // output += keyStr.charAt(enc1);
+    // output += keyStr.charAt(enc2);
+    // output += keyStr.charAt(enc3);
+    // output += keyStr.charAt(enc4);
   }
 
   return output;
@@ -74,13 +91,16 @@ export const btoa = (input: bytestring): bytestring => {
     chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
     chr3 = ((enc3 & 3) << 6) | enc4;
 
-    output += String.fromCharCode(chr1);
+    // output += String.fromCharCode(chr1);
+    Porffor.bytestring.appendCharCode(output, chr1);
 
     if (enc3 != 64) {
-      output += String.fromCharCode(chr2);
+      // output += String.fromCharCode(chr2);
+      Porffor.bytestring.appendCharCode(output, chr2);
     }
     if (enc4 != 64) {
-      output += String.fromCharCode(chr3);
+      // output += String.fromCharCode(chr3);
+      Porffor.bytestring.appendCharCode(output, chr3);
     }
   }
 

package/compiler/builtins/porffor.d.ts

@@ -3,6 +3,11 @@ export type bytestring = string;
 
 type PorfforGlobal = {
   wasm: (...args: any[]) => void;
+
+  bytestring: {
+    appendCharAt: (target: bytestring, lookup: bytestring, ind: i32) => void;
+    appendCharCode: (target: bytestring, code: i32) => void;
+  }
 };
 
 declare global {

package/compiler/builtins.js

@@ -1,5 +1,6 @@
 import { Blocktype, Opcodes, Valtype, ValtypeSize } from "./wasmSpec.js";
 import { number, i32x4 } from "./embedding.js";
+import Prefs from './prefs.js';
 
 export const importedFuncs = [
   {
@@ -685,7 +686,7 @@ export const BuiltinFuncs = function() {
     typedParams: true,
     locals: [ Valtype.i32, Valtype.i32 ],
     returns: [ valtypeBinary ],
-    returnType: process.argv.includes('-bytestring') ? '_bytestring' : 'string',
+    returnType: Prefs.bytestring ? '_bytestring' : 'string',
     wasm: (scope, { TYPE_NAMES, typeSwitch, makeString }) => {
       const bc = {};
       for (const x in TYPE_NAMES) {
@@ -722,6 +723,82 @@ export const BuiltinFuncs = function() {
     ]
   };
 
+  this.__Porffor_bytestring_appendCharAt = {
+    params: [ valtypeBinary, valtypeBinary, valtypeBinary ],
+    locals: [ Valtype.i32 ],
+    localNames: ['target', 'lookup', 'index', 'length'],
+    returns: [],
+    wasm: [
+      // get ptr for target[target.length]
+      [ Opcodes.local_get, 0 ],
+      Opcodes.i32_to_u,
+      [ Opcodes.local_get, 0 ],
+      Opcodes.i32_to_u,
+      [ Opcodes.i32_load, 1, 0 ],
+      [ Opcodes.local_tee, 3 ],
+      [ Opcodes.i32_const, 2 ],
+      [ Opcodes.i32_mul ],
+      [ Opcodes.i32_add ],
+
+      // get lookup[index]
+      [ Opcodes.local_get, 2 ],
+      Opcodes.i32_to_u,
+      [ Opcodes.i32_const, 2 ],
+      [ Opcodes.i32_mul ],
+      [ Opcodes.local_get, 1 ],
+      Opcodes.i32_to_u,
+      [ Opcodes.i32_add ],
+      [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 ],
+
+      // store target[target.length] = lookup[index]
+      [ Opcodes.i32_store8, 0, 4 ],
+
+      // store target.length = target.length + 1
+      [ Opcodes.local_get, 0 ],
+      Opcodes.i32_to_u,
+      [ Opcodes.local_get, 3 ],
+      [ Opcodes.i32_const, 1 ],
+      [ Opcodes.i32_add ],
+      [ Opcodes.i32_store, 0, 0 ],
+    ]
+  };
+
+  this.__Porffor_bytestring_appendCharCode = {
+    params: [ valtypeBinary, valtypeBinary ],
+    locals: [ Valtype.i32 ],
+    localnames: ['target', 'code', 'length'],
+    returns: [],
+    wasm: [
+      // get ptr for target[target.length]
+      [ Opcodes.local_get, 0 ],
+      Opcodes.i32_to_u,
+      [ Opcodes.local_get, 0 ],
+      Opcodes.i32_to_u,
+      [ Opcodes.i32_load, 1, 0 ],
+      [ Opcodes.local_tee, 3 ],
+      [ Opcodes.i32_const, 2 ],
+      [ Opcodes.i32_mul ],
+      [ Opcodes.i32_add ],
+
+      // get code
+      [ Opcodes.local_get, 1 ],
+      [ Opcodes.i32_to_u ],
+
+      // set target[target.length] = code
+      [ Opcodes.i32_store8, 0, 4 ],
+
+      // store target.length = target.length + 1
+      [ Opcodes.local_get, 0 ],
+      Opcodes.i32_to_u,
+      [ Opcodes.local_get, 3 ],
+      [ Opcodes.i32_const, 1 ],
+      [ Opcodes.i32_add ],
+      [ Opcodes.i32_store, 0, 0 ],
+    ]
+  };
+
+  // todo: indexOfCharAt
+
 
   this.__SIMD_i32x4_load = {
     params: [ Valtype.i32 ],

package/compiler/codeGen.js

@@ -7,6 +7,7 @@ import { number, i32x4, enforceOneByte, enforceTwoBytes, enforceFourBytes, enfor
 import { log } from "./log.js";
 import parse from "./parse.js";
 import * as Rhemyn from "../rhemyn/compile.js";
+import Prefs from './prefs.js';
 
 let globals = {};
 let globalInd = 0;
@@ -168,8 +169,8 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
             if (asm[0] === '') continue; // blank
 
             if (asm[0] === 'local') {
-              const [ name, idx, type ] = asm.slice(1);
-              scope.locals[name] = { idx: parseInt(idx), type: Valtype[type] };
+              const [ name, type ] = asm.slice(1);
+              scope.locals[name] = { idx: scope.localInd++, type: Valtype[type] };
               continue;
             }
 
@@ -188,7 +189,7 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
             if (!inst) throw new Error(`inline asm: inst ${asm[0]} not found`);
 
             if (!Array.isArray(inst)) inst = [ inst ];
-            const immediates = asm.slice(1).map(x => parseInt(x));
+            const immediates = asm.slice(1).map(x => parseInt(x) || scope.locals[x]?.idx);
 
             out.push([ ...inst, ...immediates ]);
           }
@@ -419,9 +420,6 @@ const concatStrings = (scope, left, right, global, name, assign) => {
   const rightLength = localTmp(scope, 'concat_right_length', Valtype.i32);
   const leftLength = localTmp(scope, 'concat_left_length', Valtype.i32);
 
-  const aotWFA = process.argv.includes('-aot-well-formed-string-approximation');
-  if (aotWFA) addVarMeta(name, { wellFormed: undefined });
-
   if (assign) {
     const pointer = arrays.get(name ?? '$undeclared');
 
@@ -1273,7 +1271,7 @@ const getNodeType = (scope, node) => {
       if (node.operator === '!') return TYPES.boolean;
       if (node.operator === 'void') return TYPES.undefined;
       if (node.operator === 'delete') return TYPES.boolean;
-      if (node.operator === 'typeof') return process.argv.includes('-bytestring') ? TYPES._bytestring : TYPES.string;
+      if (node.operator === 'typeof') return Prefs.bytestring ? TYPES._bytestring : TYPES.string;
 
       return TYPES.number;
     }
@@ -1836,14 +1834,14 @@ const brTable = (input, bc, returns) => {
 };
 
 const typeSwitch = (scope, type, bc, returns = valtypeBinary) => {
-  if (!process.argv.includes('-bytestring')) delete bc[TYPES._bytestring];
+  if (!Prefs.bytestring) delete bc[TYPES._bytestring];
 
   const known = knownType(scope, type);
   if (known != null) {
     return bc[known] ?? bc.default;
   }
 
-  if (process.argv.includes('-typeswitch-use-brtable'))
+  if (Prefs.typeswitchUseBrtable)
     return brTable(type, bc, returns);
 
   const tmp = localTmp(scope, '#typeswitch_tmp', Valtype.i32);
@@ -1938,7 +1936,7 @@ const extractTypeAnnotation = decl => {
   const typeName = type;
   type = typeAnnoToPorfType(type);
 
-  if (type === TYPES._bytestring && !process.argv.includes('-bytestring')) type = TYPES.string;
+  if (type === TYPES._bytestring && !Prefs.bytestring) type = TYPES.string;
 
   // if (decl.name) console.log(decl.name, { type, elementType });
 
@@ -2631,7 +2629,7 @@ const allocPage = (scope, reason, type) => {
   scope.pages ??= new Map();
   scope.pages.set(reason, { ind, type });
 
-  if (allocLog) log('alloc', `allocated new page of memory (${ind}) | ${reason} (type: ${type})`);
+  if (Prefs.allocLog) log('alloc', `allocated new page of memory (${ind}) | ${reason} (type: ${type})`);
 
   return ind;
 };
@@ -2641,7 +2639,7 @@ const freePage = reason => {
   const { ind } = pages.get(reason);
   pages.delete(reason);
 
-  if (allocLog) log('alloc', `freed page of memory (${ind}) | ${reason}`);
+  if (Prefs.allocLog) log('alloc', `freed page of memory (${ind}) | ${reason}`);
 
   return ind;
 };
@@ -2710,21 +2708,24 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
   const length = elements.length;
 
   if (firstAssign && useRawElements) {
-    let bytes = compileBytes(length, 'i32');
+    // if length is 0 memory/data will just be 0000... anyway
+    if (length !== 0) {
+      let bytes = compileBytes(length, 'i32');
 
-    if (!initEmpty) for (let i = 0; i < length; i++) {
-      if (elements[i] == null) continue;
+      if (!initEmpty) for (let i = 0; i < length; i++) {
+        if (elements[i] == null) continue;
 
-      bytes.push(...compileBytes(elements[i], itemType));
-    }
+        bytes.push(...compileBytes(elements[i], itemType));
+      }
 
-    const ind = data.push({
-      offset: pointer,
-      bytes
-    }) - 1;
+      const ind = data.push({
+        offset: pointer,
+        bytes
+      }) - 1;
 
-    scope.data ??= [];
-    scope.data.push(ind);
+      scope.data ??= [];
+      scope.data.push(ind);
+    }
 
     // local value as pointer
     out.push(...number(pointer));
@@ -2758,7 +2759,7 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
 };
 
 const byteStringable = str => {
-  if (!process.argv.includes('-bytestring')) return false;
+  if (!Prefs.bytestring) return false;
 
   for (let i = 0; i < str.length; i++) {
     if (str.charCodeAt(i) > 0xFF) return false;
@@ -2769,7 +2770,7 @@ const byteStringable = str => {
 
 const makeString = (scope, str, global = false, name = '$undeclared', forceBytestring = undefined) => {
   const rawElements = new Array(str.length);
-  let byteStringable = process.argv.includes('-bytestring');
+  let byteStringable = Prefs.bytestring;
   for (let i = 0; i < str.length; i++) {
     const c = str.charCodeAt(i);
     rawElements[i] = c;
@@ -2930,7 +2931,7 @@ const objectHack = node => {
     if (!objectName) return node;
 
     const name = '__' + objectName + '_' + node.property.name;
-    if (codeLog) log('codegen', `object hack! ${node.object.name}.${node.property.name} -> ${name}`);
+    if (Prefs.codeLog) log('codegen', `object hack! ${node.object.name}.${node.property.name} -> ${name}`);
 
     return {
       type: 'Identifier',
@@ -3157,7 +3158,7 @@ export default program => {
     body: program.body
   };
 
-  if (process.argv.includes('-ast-log')) console.log(program.body.body);
+  if (Prefs.astLog) console.log(program.body.body);
 
   generateFunc(scope, program);
 

package/compiler/index.js

@@ -5,6 +5,7 @@ import opt from './opt.js';
 import produceSections from './sections.js';
 import decompile from './decompile.js';
 import toc from './2c.js';
+import Prefs from './prefs.js';
 
 globalThis.decompile = decompile;
 
@@ -25,17 +26,10 @@ const logFuncs = (funcs, globals, exceptions) => {
   console.log();
 };
 
-const getArg = name => process.argv.find(x => x.startsWith(`-${name}=`))?.slice(name.length + 2);
-
 const writeFileSync = (typeof process?.version !== 'undefined' ? (await import('node:fs')).writeFileSync : undefined);
 const execSync = (typeof process?.version !== 'undefined' ? (await import('node:child_process')).execSync : undefined);
 
 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');
-  globalThis.regexLog = process.argv.includes('-regex-log');
-
   const t0 = performance.now();
   const program = parse(code, flags);
   if (flags.includes('info')) console.log(`1. parsed in ${(performance.now() - t0).toFixed(2)}ms`);
@@ -44,19 +38,19 @@ export default (code, flags) => {
   const { funcs, globals, tags, exceptions, pages, data } = codeGen(program);
   if (flags.includes('info')) console.log(`2. generated code in ${(performance.now() - t1).toFixed(2)}ms`);
 
-  if (process.argv.includes('-funcs')) logFuncs(funcs, globals, exceptions);
+  if (Prefs.funcs) logFuncs(funcs, globals, exceptions);
 
   const t2 = performance.now();
   opt(funcs, globals, pages, tags, exceptions);
   if (flags.includes('info')) console.log(`3. optimized code in ${(performance.now() - t2).toFixed(2)}ms`);
 
-  if (process.argv.includes('-opt-funcs')) logFuncs(funcs, globals, exceptions);
+  if (Prefs.optFuncs) logFuncs(funcs, globals, exceptions);
 
   const t3 = performance.now();
   const sections = produceSections(funcs, globals, tags, pages, data, flags);
   if (flags.includes('info')) console.log(`4. produced sections in ${(performance.now() - t3).toFixed(2)}ms`);
 
-  if (allocLog) {
+  if (Prefs.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'}`);
@@ -65,8 +59,8 @@ export default (code, flags) => {
 
   const out = { wasm: sections, funcs, globals, tags, exceptions, pages, data };
 
-  const target = getArg('target') ?? getArg('t') ?? 'wasm';
-  const outFile = getArg('o');
+  const target = Prefs.target ?? 'wasm';
+  const outFile = Prefs.o;
 
   if (target === 'wasm' && outFile) {
     writeFileSync(outFile, Buffer.from(sections));
@@ -88,8 +82,8 @@ export default (code, flags) => {
   }
 
   if (target === 'native') {
-    let compiler = getArg('compiler') ?? 'clang';
-    const cO = getArg('cO') ?? 'Ofast';
+    let compiler = Prefs.compiler ?? 'clang';
+    const cO = Prefs._cO ?? 'Ofast';
 
     if (compiler === 'zig') compiler = [ 'zig', 'cc' ];
       else compiler = [ compiler ];

package/compiler/opt.js

@@ -2,6 +2,7 @@ import { Opcodes, Valtype } from "./wasmSpec.js";
 import { number } from "./embedding.js";
 import { read_signedLEB128, read_ieee754_binary64 } from "./encoding.js";
 import { log } from "./log.js";
+import Prefs from './prefs.js';
 
 const performWasmOp = (op, a, b) => {
   switch (op) {
@@ -15,17 +16,17 @@ export default (funcs, globals, pages, tags, exceptions) => {
   const optLevel = parseInt(process.argv.find(x => x.startsWith('-O'))?.[2] ?? 1);
   if (optLevel === 0) return;
 
-  const tailCall = process.argv.includes('-tail-call');
+  const tailCall = Prefs.tailCall;
   if (tailCall) log.warning('opt', 'tail call proposal is not widely implemented! (you used -tail-call)');
 
-  if (optLevel >= 2 && !process.argv.includes('-opt-no-inline')) {
+  if (optLevel >= 2 && !Prefs.optNoInline) {
     // inline pass (very WIP)
     // get candidates for inlining
     // todo: pick smart in future (if func is used <N times? or?)
     const callsSelf = f => f.wasm.some(x => x[0] === Opcodes.call && x[1] === f.index);
     const suitableReturns = wasm => wasm.reduce((acc, x) => acc + (x[0] === Opcodes.return), 0) <= 1;
     const candidates = funcs.filter(x => x.name !== 'main' && Object.keys(x.locals).length === x.params.length && (x.returns.length === 0 || suitableReturns(x.wasm)) && !callsSelf(x) && !x.throws).reverse();
-    if (optLog) {
+    if (Prefs.optLog) {
       log('opt', `found inline candidates: ${candidates.map(x => x.name).join(', ')} (${candidates.length}/${funcs.length - 1})`);
 
       let reasons = {};
@@ -53,7 +54,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
         for (let i = 0; i < tWasm.length; i++) {
           const inst = tWasm[i];
           if (inst[0] === Opcodes.call && inst[1] === c.index) {
-            if (optLog) log('opt', `inlining call for ${c.name} (in ${t.name})`);
+            if (Prefs.optLog) log('opt', `inlining call for ${c.name} (in ${t.name})`);
             tWasm.splice(i, 1); // remove this call
 
             // add params as locals and set in reverse order
@@ -80,7 +81,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
             // adjust local operands to go to correct param index
             for (const inst of iWasm) {
               if ((inst[0] === Opcodes.local_get || inst[0] === Opcodes.local_set) && inst[1] < c.params.length) {
-                if (optLog) log('opt', `replacing local operand in inlined wasm (${inst[1]} -> ${paramIdx[inst[1]]})`);
+                if (Prefs.optLog) log('opt', `replacing local operand in inlined wasm (${inst[1]} -> ${paramIdx[inst[1]]})`);
                 inst[1] = paramIdx[inst[1]];
               }
             }
@@ -97,7 +98,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
     }
   }
 
-  if (process.argv.includes('-opt-inline-only')) return;
+  if (Prefs.optInlineOnly) return;
 
   const tagUse = tags.reduce((acc, x) => { acc[x.idx] = 0; return acc; }, {});
   const exceptionUse = exceptions.reduce((acc, _, i) => { acc[i] = 0; return acc; }, {});
@@ -166,7 +167,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
 
             wasm.splice(j - 1, 1); // remove end of this block
 
-            if (optLog) log('opt', `removed unneeded block in for loop`);
+            if (Prefs.optLog) log('opt', `removed unneeded block in for loop`);
           }
         }
 
@@ -215,7 +216,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
             i -= 4;
             inst = wasm[i];
 
-            if (optLog) log('opt', `removed unneeded typeswitch check`);
+            if (Prefs.optLog) log('opt', `removed unneeded typeswitch check`);
           }
         }
 
@@ -238,7 +239,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
             wasm.splice(j - 1, 2, [ Opcodes.drop ]); // remove typeswitch start
             wasm.splice(i - 1, 1); // remove this inst
 
-            if (optLog) log('opt', 'removed unneeded entire typeswitch');
+            if (Prefs.optLog) log('opt', 'removed unneeded entire typeswitch');
 
             if (i > 0) i--;
             continue;
@@ -267,7 +268,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
 
           getCount[inst[1]]--;
           i--;
-          // if (optLog) log('opt', `consolidated set, get -> tee`);
+          // if (Prefs.optLog) log('opt', `consolidated set, get -> tee`);
           continue;
         }
 
@@ -335,7 +336,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
 
           wasm.splice(i - 1, 2); // remove this inst and last
           i -= 2;
-          // if (optLog) log('opt', `removed redundant i32 -> i64 -> i32 conversion ops`);
+          // if (Prefs.optLog) log('opt', `removed redundant i32 -> i64 -> i32 conversion ops`);
           continue;
         }
 
@@ -348,7 +349,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
 
           wasm.splice(i - 1, 2); // remove this inst and last
           i -= 2;
-          // if (optLog) log('opt', `removed redundant i32 -> f64 -> i32 conversion ops`);
+          // if (Prefs.optLog) log('opt', `removed redundant i32 -> f64 -> i32 conversion ops`);
           continue;
         }
 
@@ -363,7 +364,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
 
           wasm.splice(i, 1); // remove this inst
           i--;
-          if (optLog) log('opt', `converted const -> i32 convert into i32 const`);
+          if (Prefs.optLog) log('opt', `converted const -> i32 convert into i32 const`);
           continue;
         }
 
@@ -378,7 +379,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
 
           wasm.splice(i, 1); // remove this inst
           i--;
-          if (optLog) log('opt', `converted i32 const -> convert into const`);
+          if (Prefs.optLog) log('opt', `converted i32 const -> convert into const`);
           continue;
         }
 
@@ -393,7 +394,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
 
           wasm.splice(i, 1); // remove this inst (return)
           i--;
-          if (optLog) log('opt', `tail called return, call`);
+          if (Prefs.optLog) log('opt', `tail called return, call`);
           continue;
         }
 
@@ -406,7 +407,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
 
           wasm.splice(i, 1); // remove this inst (return)
           i--;
-          // if (optLog) log('opt', `removed redundant return at end`);
+          // if (Prefs.optLog) log('opt', `removed redundant return at end`);
           continue;
         }
 
@@ -436,7 +437,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
           // <nothing>
 
           wasm.splice(i - 2, 3); // remove this, last, 2nd last insts
-          if (optLog) log('opt', `removed redundant inline param local handling`);
+          if (Prefs.optLog) log('opt', `removed redundant inline param local handling`);
           i -= 3;
           continue;
         }
@@ -444,12 +445,12 @@ export default (funcs, globals, pages, tags, exceptions) => {
 
       if (optLevel < 2) continue;
 
-      if (optLog) log('opt', `get counts: ${Object.keys(f.locals).map(x => `${x} (${f.locals[x].idx}): ${getCount[f.locals[x].idx]}`).join(', ')}`);
+      if (Prefs.optLog) log('opt', `get counts: ${Object.keys(f.locals).map(x => `${x} (${f.locals[x].idx}): ${getCount[f.locals[x].idx]}`).join(', ')}`);
 
       // remove unneeded var: remove pass
       // locals only got once. we don't need to worry about sets/else as these are only candidates and we will check for matching set + get insts in wasm
       let unneededCandidates = Object.keys(getCount).filter(x => getCount[x] === 0 || (getCount[x] === 1 && setCount[x] === 0)).map(x => parseInt(x));
-      if (optLog) log('opt', `found unneeded locals candidates: ${unneededCandidates.join(', ')} (${unneededCandidates.length}/${Object.keys(getCount).length})`);
+      if (Prefs.optLog) log('opt', `found unneeded locals candidates: ${unneededCandidates.join(', ')} (${unneededCandidates.length}/${Object.keys(getCount).length})`);
 
       // note: disabled for now due to instability
       if (unneededCandidates.length > 0 && false) for (let i = 0; i < wasm.length; i++) {
@@ -467,7 +468,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
           wasm.splice(i - 1, 2); // remove insts
           i -= 2;
           delete f.locals[Object.keys(f.locals)[inst[1]]]; // remove from locals
-          if (optLog) log('opt', `removed redundant local (get set ${inst[1]})`);
+          if (Prefs.optLog) log('opt', `removed redundant local (get set ${inst[1]})`);
         }
 
         if (inst[0] === Opcodes.local_tee && unneededCandidates.includes(inst[1])) {
@@ -495,7 +496,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
           unneededCandidates.splice(unneededCandidates.indexOf(inst[1]), 1);
           unneededCandidates = unneededCandidates.map(x => x > removedIdx ? (x - 1) : x);
 
-          if (optLog) log('opt', `removed redundant local ${localName} (tee ${inst[1]})`);
+          if (Prefs.optLog) log('opt', `removed redundant local ${localName} (tee ${inst[1]})`);
         }
       }
 
@@ -531,7 +532,7 @@ export default (funcs, globals, pages, tags, exceptions) => {
           let b = lastInst[1];
 
           const val = performWasmOp(inst[0], a, b);
-          if (optLog) log('opt', `inlined math op (${a} ${inst[0].toString(16)} ${b} -> ${val})`);
+          if (Prefs.optLog) log('opt', `inlined math op (${a} ${inst[0].toString(16)} ${b} -> ${val})`);
 
           wasm.splice(i - 2, 3, ...number(val)); // remove consts, math op and add new const
           i -= 2;
@@ -543,12 +544,12 @@ export default (funcs, globals, pages, tags, exceptions) => {
       for (const x in useCount) {
         if (useCount[x] === 0) {
           const name = Object.keys(f.locals)[localIdxs.indexOf(parseInt(x))];
-          if (optLog) log('opt', `removed internal local ${x} (${name})`);
+          if (Prefs.optLog) log('opt', `removed internal local ${x} (${name})`);
           delete f.locals[name];
         }
       }
 
-      if (optLog) log('opt', `final use counts: ${Object.keys(f.locals).map(x => `${x} (${f.locals[x].idx}): ${useCount[f.locals[x].idx]}`).join(', ')}`);
+      if (Prefs.optLog) log('opt', `final use counts: ${Object.keys(f.locals).map(x => `${x} (${f.locals[x].idx}): ${useCount[f.locals[x].idx]}`).join(', ')}`);
     }
   }
 

package/compiler/parse.js

@@ -1,4 +1,6 @@
 import { log } from "./log.js";
+import Prefs from './prefs.js';
+
 // import { parse } from 'acorn';
 
 // deno compat
@@ -8,8 +10,8 @@ if (typeof process === 'undefined' && typeof Deno !== 'undefined') {
 }
 
 // should we try to support types (while parsing)
-const types = process.argv.includes('-parse-types');
-globalThis.typedInput = types && process.argv.includes('-opt-types');
+const types = Prefs.parseTypes;
+globalThis.typedInput = types && Prefs.optTypes;
 
 // todo: review which to use by default
 // supported parsers: