porffor 0.2.0-9928127 → 0.2.0-9f58210

package/compiler/codegen.js

@@ -59,6 +59,10 @@ const todo = (scope, msg, expectsValue = undefined) => {
 };
 
 const isFuncType = type => type === 'FunctionDeclaration' || type === 'FunctionExpression' || type === 'ArrowFunctionExpression';
+const hasFuncWithName = name => {
+  const func = funcs.find(x => x.name === name);
+  return !!(func || builtinFuncs[name] || importedFuncs[name] || internalConstrs[name]);
+};
 const generate = (scope, decl, global = false, name = undefined, valueUnused = false) => {
   switch (decl.type) {
     case 'BinaryExpression':
@@ -201,7 +205,7 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
             }
 
             let inst = Opcodes[asm[0].replace('.', '_')];
-            if (!inst) throw new Error(`inline asm: inst ${asm[0]} not found`);
+            if (inst == null) throw new Error(`inline asm: inst ${asm[0]} not found`);
 
             if (!Array.isArray(inst)) inst = [ inst ];
             const immediates = asm.slice(1).map(x => {
@@ -219,8 +223,8 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
         __Porffor_bs: str => [
           ...makeString(scope, str, global, name, true),
 
-          ...(name ? setType(scope, name, TYPES._bytestring) : [
-            ...number(TYPES._bytestring, Valtype.i32),
+          ...(name ? setType(scope, name, TYPES.bytestring) : [
+            ...number(TYPES.bytestring, Valtype.i32),
             ...setLastType(scope)
           ])
         ],
@@ -460,7 +464,7 @@ const concatStrings = (scope, left, right, global, name, assign = false, bytestr
   const rightLength = localTmp(scope, 'concat_right_length', Valtype.i32);
   const leftLength = localTmp(scope, 'concat_left_length', Valtype.i32);
 
-  if (assign) {
+  if (assign && Prefs.aotPointerOpt) {
     const pointer = scope.arrays?.get(name ?? '$undeclared');
 
     return [
@@ -723,7 +727,7 @@ const truthy = (scope, wasm, type, intIn = false, intOut = false) => {
 
     ...typeSwitch(scope, type, {
       // [TYPES.number]: def,
-      [TYPES._array]: [
+      [TYPES.array]: [
         // arrays are always truthy
         ...number(1, intOut ? Valtype.i32 : valtypeBinary)
       ],
@@ -739,7 +743,7 @@ const truthy = (scope, wasm, type, intIn = false, intOut = false) => {
         [ Opcodes.i32_eqz ], */
         ...(intOut ? [] : [ Opcodes.i32_from_u ])
       ],
-      [TYPES._bytestring]: [ // duplicate of string
+      [TYPES.bytestring]: [ // duplicate of string
       ...(!useTmp ? [] : [ [ Opcodes.local_get, tmp ] ]),
         ...(intIn ? [] : [ Opcodes.i32_to_u ]),
 
@@ -762,7 +766,7 @@ const falsy = (scope, wasm, type, intIn = false, intOut = false) => {
     ...(!useTmp ? [] : [ [ Opcodes.local_set, tmp ] ]),
 
     ...typeSwitch(scope, type, {
-      [TYPES._array]: [
+      [TYPES.array]: [
         // arrays are always truthy
         ...number(0, intOut ? Valtype.i32 : valtypeBinary)
       ],
@@ -777,7 +781,7 @@ const falsy = (scope, wasm, type, intIn = false, intOut = false) => {
         [ Opcodes.i32_eqz ],
         ...(intOut ? [] : [ Opcodes.i32_from_u ])
       ],
-      [TYPES._bytestring]: [ // duplicate of string
+      [TYPES.bytestring]: [ // duplicate of string
         ...(!useTmp ? [] : [ [ Opcodes.local_get, tmp ] ]),
         ...(intIn ? [] : [ Opcodes.i32_to_u ]),
 
@@ -922,7 +926,7 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
     }
   }
 
-  if (knownLeft === TYPES._bytestring || knownRight === TYPES._bytestring) {
+  if (knownLeft === TYPES.bytestring || knownRight === TYPES.bytestring) {
     if (op === '+') {
       // todo: this should be dynamic too but for now only static
       // string concat (a + b)
@@ -1041,12 +1045,12 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
 
       // if left is bytestring
       ...leftType,
-      ...number(TYPES._bytestring, Valtype.i32),
+      ...number(TYPES.bytestring, Valtype.i32),
       [ Opcodes.i32_eq ],
 
       // if right is bytestring
       ...rightType,
-      ...number(TYPES._bytestring, Valtype.i32),
+      ...number(TYPES.bytestring, Valtype.i32),
       [ Opcodes.i32_eq ],
 
       // if both are true
@@ -1177,7 +1181,6 @@ const generateLogicExp = (scope, decl) => {
 // js type: 4 bits
 // internal type: ? bits
 // pointer: 32 bits
-
 // generic
 // 1              23   4             5
 // 0 11111111111 11TTTTIIII??????????PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
@@ -1188,7 +1191,7 @@ const generateLogicExp = (scope, decl) => {
 // 5: pointer
 
 const isExistingProtoFunc = name => {
-  if (name.startsWith('__Array_prototype')) return !!prototypeFuncs[TYPES._array][name.slice(18)];
+  if (name.startsWith('__Array_prototype')) return !!prototypeFuncs[TYPES.array][name.slice(18)];
   if (name.startsWith('__String_prototype_')) return !!prototypeFuncs[TYPES.string][name.slice(19)];
 
   return false;
@@ -1247,9 +1250,9 @@ const setLastType = scope => {
 const getNodeType = (scope, node) => {
   const inner = () => {
     if (node.type === 'Literal') {
-      if (node.regex) return TYPES._regexp;
+      if (node.regex) return TYPES.regexp;
 
-      if (typeof node.value === 'string' && byteStringable(node.value)) return TYPES._bytestring;
+      if (typeof node.value === 'string' && byteStringable(node.value)) return TYPES.bytestring;
 
       return TYPES[typeof node.value];
     }
@@ -1303,7 +1306,7 @@ const getNodeType = (scope, node) => {
         const spl = name.slice(2).split('_');
 
         const func = spl[spl.length - 1];
-        const protoFuncs = Object.keys(prototypeFuncs).filter(x => x != TYPES._bytestring && prototypeFuncs[x][func] != null);
+        const protoFuncs = Object.keys(prototypeFuncs).filter(x => x != TYPES.bytestring && prototypeFuncs[x][func] != null);
         if (protoFuncs.length === 1) return protoFuncs[0].returnType ?? TYPES.number;
       }
 
@@ -1355,7 +1358,7 @@ const getNodeType = (scope, node) => {
     }
 
     if (node.type === 'ArrayExpression') {
-      return TYPES._array;
+      return TYPES.array;
     }
 
     if (node.type === 'BinaryExpression') {
@@ -1367,7 +1370,7 @@ const getNodeType = (scope, node) => {
 
       // todo: this should be dynamic but for now only static
       if (knownLeft === TYPES.string || knownRight === TYPES.string) return TYPES.string;
-      if (knownLeft === TYPES._bytestring || knownRight === TYPES._bytestring) return TYPES._bytestring;
+      if (knownLeft === TYPES.bytestring || knownRight === TYPES.bytestring) return TYPES.bytestring;
 
       return TYPES.number;
 
@@ -1393,19 +1396,28 @@ 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 Prefs.bytestring ? TYPES._bytestring : TYPES.string;
+      if (node.operator === 'typeof') return Prefs.bytestring ? TYPES.bytestring : TYPES.string;
 
       return TYPES.number;
     }
 
     if (node.type === 'MemberExpression') {
+      // hack: if something.name, string type
+      if (node.property.name === 'name') {
+        if (hasFuncWithName(node.object.name)) {
+          return TYPES.bytestring;
+        } else {
+          return TYPES.undefined;
+        }
+      }
+
       // hack: if something.length, number type
       if (node.property.name === 'length') return TYPES.number;
 
       // ts hack
       if (scope.locals[node.object.name]?.metadata?.type === TYPES.string) return TYPES.string;
-      if (scope.locals[node.object.name]?.metadata?.type === TYPES._bytestring) return TYPES._bytestring;
-      if (scope.locals[node.object.name]?.metadata?.type === TYPES._array) return TYPES.number;
+      if (scope.locals[node.object.name]?.metadata?.type === TYPES.bytestring) return TYPES.bytestring;
+      if (scope.locals[node.object.name]?.metadata?.type === TYPES.array) return TYPES.number;
 
       if (scope.locals['#last_type']) return getLastType(scope);
 
@@ -1646,18 +1658,25 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     // megahack for /regex/.func()
     const funcName = decl.callee.property.name;
     if (decl.callee.object.regex && Object.hasOwn(Rhemyn, funcName)) {
-      const func = Rhemyn[funcName](decl.callee.object.regex.pattern, currentFuncIndex++);
+      const regex = decl.callee.object.regex.pattern;
+      const rhemynName = `regex_${funcName}_${regex}`;
+
+      if (!funcIndex[rhemynName]) {
+        const func = Rhemyn[funcName](regex, currentFuncIndex++, rhemynName);
 
-      funcIndex[func.name] = func.index;
-      funcs.push(func);
+        funcIndex[func.name] = func.index;
+        funcs.push(func);
+      }
 
+      const idx = funcIndex[rhemynName];
       return [
         // make string arg
         ...generate(scope, decl.arguments[0]),
+        Opcodes.i32_to_u,
+        ...getNodeType(scope, decl.arguments[0]),
 
         // call regex func
-        Opcodes.i32_to_u,
-        [ Opcodes.call, func.index ],
+        [ Opcodes.call, idx ],
         Opcodes.i32_from_u,
 
         ...number(TYPES.boolean, Valtype.i32),
@@ -1697,6 +1716,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
 
         protoBC[type] = generateCall(scope, {
           callee: {
+            type: 'Identifier',
             name: x
           },
           arguments: [ target, ...decl.arguments ],
@@ -1819,20 +1839,20 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     idx = funcIndex[name];
 
     // infer arguments types from builtins params
-    const func = funcs.find(x => x.name === name);
-    for (let i = 0; i < decl.arguments.length; i++) {
-      const arg = decl.arguments[i];
-      if (!arg.name) continue;
-
-      const local = scope.locals[arg.name];
-      if (!local) continue;
-
-      local.type = func.params[i];
-      if (local.type === Valtype.v128) {
-        // specify vec subtype inferred from last vec type in function name
-        local.vecType = name.split('_').reverse().find(x => x.includes('x'));
-      }
-    }
+    // const func = funcs.find(x => x.name === name);
+    // for (let i = 0; i < decl.arguments.length; i++) {
+    //   const arg = decl.arguments[i];
+    //   if (!arg.name) continue;
+
+    //   const local = scope.locals[arg.name];
+    //   if (!local) continue;
+
+    //   local.type = func.params[i];
+    //   if (local.type === Valtype.v128) {
+    //     // specify vec subtype inferred from last vec type in function name
+    //     local.vecType = name.split('_').reverse().find(x => x.includes('x'));
+    //   }
+    // }
   }
 
   if (idx === undefined && internalConstrs[name]) return internalConstrs[name].generate(scope, decl, _global, _name);
@@ -1864,9 +1884,6 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
 
       // value
       i32_const: { imms: 1, args: [], returns: 1 },
-
-      // a, b
-      i32_or: { imms: 0, args: [ true, true ], returns: 1 },
     };
 
     const opName = name.slice('__Porffor_wasm_'.length);
@@ -2087,7 +2104,7 @@ const brTable = (input, bc, returns) => {
 };
 
 const typeSwitch = (scope, type, bc, returns = valtypeBinary) => {
-  if (!Prefs.bytestring) delete bc[TYPES._bytestring];
+  if (!Prefs.bytestring) delete bc[TYPES.bytestring];
 
   const known = knownType(scope, type);
   if (known != null) {
@@ -2190,7 +2207,7 @@ const extractTypeAnnotation = decl => {
   const typeName = type;
   type = typeAnnoToPorfType(type);
 
-  if (type === TYPES._bytestring && !Prefs.bytestring) type = TYPES.string;
+  if (type === TYPES.bytestring && !Prefs.bytestring) type = TYPES.string;
 
   // if (decl.name) console.log(decl.name, { type, elementType });
 
@@ -2204,6 +2221,7 @@ const generateVar = (scope, decl) => {
 
   // global variable if in top scope (main) and var ..., or if wanted
   const global = topLevel || decl._bare; // decl.kind === 'var';
+  const target = global ? globals : scope.locals;
 
   for (const x of decl.declarations) {
     const name = mapName(x.id.name);
@@ -2225,6 +2243,10 @@ const generateVar = (scope, decl) => {
       continue; // always ignore
     }
 
+    // // generate init before allocating var
+    // let generated;
+    // if (x.init) generated = generate(scope, x.init, global, name);
+
     const typed = typedInput && x.id.typeAnnotation;
     let idx = allocVar(scope, name, global, !(typed && extractTypeAnnotation(x.id).type != null));
 
@@ -2233,9 +2255,17 @@ const generateVar = (scope, decl) => {
     }
 
     if (x.init) {
-      out = out.concat(generate(scope, x.init, global, name));
-
-      out.push([ global ? Opcodes.global_set : Opcodes.local_set, idx ]);
+      const generated = generate(scope, x.init, global, name);
+      if (scope.arrays?.get(name) != null) {
+        // hack to set local as pointer before
+        out.push(...number(scope.arrays.get(name)), [ global ? Opcodes.global_set : Opcodes.local_set, idx ]);
+        if (generated.at(-1) == Opcodes.i32_from_u) generated.pop();
+        generated.pop();
+        out = out.concat(generated);
+      } else {
+        out = out.concat(generated);
+        out.push([ global ? Opcodes.global_set : Opcodes.local_set, idx ]);
+      }
       out.push(...setType(scope, name, getNodeType(scope, x.init)));
     }
 
@@ -2262,6 +2292,8 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
     return [];
   }
 
+  const op = decl.operator.slice(0, -1) || '=';
+
   // hack: .length setter
   if (decl.left.type === 'MemberExpression' && decl.left.property.name === 'length') {
     const name = decl.left.object.name;
@@ -2270,14 +2302,20 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
     const aotPointer = Prefs.aotPointerOpt && pointer != null;
 
     const newValueTmp = localTmp(scope, '__length_setter_tmp');
+    const pointerTmp = op === '=' ? null : localTmp(scope, '__member_setter_ptr_tmp', Valtype.i32);
 
     return [
       ...(aotPointer ? number(0, Valtype.i32) : [
         ...generate(scope, decl.left.object),
         Opcodes.i32_to_u
       ]),
+      ...(!pointerTmp ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
 
-      ...generate(scope, decl.right),
+      ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+        [ Opcodes.local_get, pointerTmp ],
+        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+        Opcodes.i32_from_u
+      ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right))),
       [ Opcodes.local_tee, newValueTmp ],
 
       Opcodes.i32_to_u,
@@ -2287,8 +2325,6 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
     ];
   }
 
-  const op = decl.operator.slice(0, -1) || '=';
-
   // arr[i]
   if (decl.left.type === 'MemberExpression' && decl.left.computed) {
     const name = decl.left.object.name;
@@ -2301,7 +2337,7 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
 
     return [
       ...typeSwitch(scope, getNodeType(scope, decl.left.object), {
-        [TYPES._array]: [
+        [TYPES.array]: [
           ...(aotPointer ? [] : [
             ...generate(scope, decl.left.object),
             Opcodes.i32_to_u
@@ -2503,7 +2539,7 @@ const generateUnary = (scope, decl) => {
         [TYPES.undefined]: makeString(scope, 'undefined', false, '#typeof_result'),
         [TYPES.function]: makeString(scope, 'function', false, '#typeof_result'),
 
-        [TYPES._bytestring]: makeString(scope, 'string', false, '#typeof_result'),
+        [TYPES.bytestring]: makeString(scope, 'string', false, '#typeof_result'),
 
         // object and internal types
         default: makeString(scope, 'object', false, '#typeof_result'),
@@ -2739,7 +2775,7 @@ const generateForOf = (scope, decl) => {
   // set type for local
   // todo: optimize away counter and use end pointer
   out.push(...typeSwitch(scope, getNodeType(scope, decl.right), {
-    [TYPES._array]: [
+    [TYPES.array]: [
       ...setType(scope, leftName, TYPES.number),
 
       [ Opcodes.loop, Blocktype.void ],
@@ -2822,8 +2858,8 @@ const generateForOf = (scope, decl) => {
       [ Opcodes.end ],
       [ Opcodes.end ]
     ],
-    [TYPES._bytestring]: [
-      ...setType(scope, leftName, TYPES._bytestring),
+    [TYPES.bytestring]: [
+      ...setType(scope, leftName, TYPES.bytestring),
 
       [ Opcodes.loop, Blocktype.void ],
 
@@ -3092,12 +3128,14 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
     // todo: can we just have 1 undeclared array? probably not? but this is not really memory efficient
     const uniqueName = name === '$undeclared' ? name + Math.random().toString().slice(2) : name;
 
-    if (Prefs.scopedPageNames) scope.arrays.set(name, allocPage(scope, `${scope.name} | ${getAllocType(itemType)}: ${uniqueName}`, itemType) * pageSize);
+    if (Prefs.scopedPageNames) scope.arrays.set(name, allocPage(scope, `${getAllocType(itemType)}: ${scope.name}/${uniqueName}`, itemType) * pageSize);
       else scope.arrays.set(name, allocPage(scope, `${getAllocType(itemType)}: ${uniqueName}`, itemType) * pageSize);
   }
 
   const pointer = scope.arrays.get(name);
 
+  const local = global ? globals[name] : scope.locals[name];
+
   const useRawElements = !!decl.rawElements;
   const elements = useRawElements ? decl.rawElements : decl.elements;
 
@@ -3130,11 +3168,22 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
     return [ out, pointer ];
   }
 
+  const pointerTmp = local != null ? localTmp(scope, '#makearray_pointer_tmp', Valtype.i32) : null;
+  if (pointerTmp != null) {
+    out.push(
+      [ global ? Opcodes.global_get : Opcodes.local_get, local.idx ],
+      Opcodes.i32_to_u,
+      [ Opcodes.local_set, pointerTmp ]
+    );
+  }
+
+  const pointerWasm = pointerTmp != null ? [ [ Opcodes.local_get, pointerTmp ] ] : number(pointer, Valtype.i32);
+
   // store length as 0th array
   out.push(
-    ...number(0, Valtype.i32),
+    ...pointerWasm,
     ...number(length, Valtype.i32),
-    [ Opcodes.i32_store, Math.log2(ValtypeSize.i32) - 1, ...unsignedLEB128(pointer) ]
+    [ Opcodes.i32_store, Math.log2(ValtypeSize.i32) - 1, 0 ]
   );
 
   const storeOp = StoreOps[itemType];
@@ -3143,14 +3192,14 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
     if (elements[i] == null) continue;
 
     out.push(
-      ...number(0, Valtype.i32),
+      ...pointerWasm,
       ...(useRawElements ? number(elements[i], Valtype[valtype]) : generate(scope, elements[i])),
-      [ storeOp, (Math.log2(ValtypeSize[itemType]) || 1) - 1, ...unsignedLEB128(pointer + ValtypeSize.i32 + i * ValtypeSize[itemType]) ]
+      [ storeOp, (Math.log2(ValtypeSize[itemType]) || 1) - 1, ...unsignedLEB128(ValtypeSize.i32 + i * ValtypeSize[itemType]) ]
     );
   }
 
   // local value as pointer
-  out.push(...number(pointer));
+  out.push(...pointerWasm, Opcodes.i32_from_u);
 
   return [ out, pointer ];
 };
@@ -3192,6 +3241,20 @@ export const generateMember = (scope, decl, _global, _name) => {
 
   const aotPointer = Prefs.aotPointerOpt && pointer != null;
 
+  // hack: .name
+  if (decl.property.name === 'name') {
+    if (hasFuncWithName(name)) {
+      let nameProp = name;
+
+      // eg: __String_prototype_toLowerCase -> toLowerCase
+      if (nameProp.startsWith('__')) nameProp = nameProp.split('_').pop();
+
+      return makeString(scope, nameProp, _global, _name, true);
+    } else {
+      return generate(scope, DEFAULT_VALUE);
+    }
+  }
+
   // hack: .length
   if (decl.property.name === 'length') {
     const func = funcs.find(x => x.name === name);
@@ -3201,6 +3264,16 @@ export const generateMember = (scope, decl, _global, _name) => {
       return number(typedParams ? func.params.length / 2 : func.params.length);
     }
 
+    if (builtinFuncs[name + '$constructor']) {
+      const regularFunc = builtinFuncs[name];
+      const regularParams = regularFunc.typedParams ? (regularFunc.params.length / 2) : regularFunc.params.length;
+
+      const constructorFunc = builtinFuncs[name + '$constructor'];
+      const constructorParams = constructorFunc.typedParams ? (constructorFunc.params.length / 2) : constructorFunc.params.length;
+
+      return number(Math.max(regularParams, constructorParams));
+    }
+
     if (builtinFuncs[name]) return number(builtinFuncs[name].typedParams ? (builtinFuncs[name].params.length / 2) : builtinFuncs[name].params.length);
     if (importedFuncs[name]) return number(importedFuncs[name].params);
     if (internalConstrs[name]) return number(internalConstrs[name].length ?? 0);
@@ -3229,7 +3302,7 @@ export const generateMember = (scope, decl, _global, _name) => {
   }
 
   return typeSwitch(scope, getNodeType(scope, decl.object), {
-    [TYPES._array]: [
+    [TYPES.array]: [
       // get index as valtype
       ...property,
 
@@ -3282,7 +3355,7 @@ export const generateMember = (scope, decl, _global, _name) => {
       ...number(TYPES.string, Valtype.i32),
       ...setLastType(scope)
     ],
-    [TYPES._bytestring]: [
+    [TYPES.bytestring]: [
       // setup new/out array
       ...newOut,
       [ Opcodes.drop ],
@@ -3307,7 +3380,7 @@ export const generateMember = (scope, decl, _global, _name) => {
       // return new string (page)
       ...number(newPointer),
 
-      ...number(TYPES._bytestring, Valtype.i32),
+      ...number(TYPES.bytestring, Valtype.i32),
       ...setLastType(scope)
     ],
 
@@ -3332,8 +3405,8 @@ const objectHack = node => {
 
       if (!objectName) objectName = objectHack(node.object)?.name?.slice?.(2);
 
-      // if .length, give up (hack within a hack!)
-      if (node.property.name === 'length') {
+      // if .name or .length, give up (hack within a hack!)
+      if (['name', 'length'].includes(node.property.name)) {
         node.object = objectHack(node.object);
         return;
       }
@@ -3476,7 +3549,7 @@ const internalConstrs = {
         ...number(pointer)
       ];
     },
-    type: TYPES._array,
+    type: TYPES.array,
     length: 1
   },
 
@@ -3488,7 +3561,7 @@ const internalConstrs = {
         elements: decl.arguments
       }, global, name);
     },
-    type: TYPES._array,
+    type: TYPES.array,
     notConstr: true,
     length: 0
   },
@@ -3581,25 +3654,41 @@ const internalConstrs = {
     type: TYPES.number,
     notConstr: true,
     length: 2
-  }
-};
+  },
 
-// const _ = Array.prototype.push;
-// Array.prototype.push = function (a) {
-//   const check = arr => {
-//     for (const x of arr) {
-//       if (x === undefined) {
-//         console.trace(arr);
-//         process.exit();
-//       }
-//       if (Array.isArray(x)) check(x);
-//     }
-//   };
-//   if (Array.isArray(a) && !new Error().stack.includes('node:')) check(a);
-//   // if (Array.isArray(a)) check(a);
+  __console_log: {
+    generate: (scope, decl) => {
+      const out = [];
+
+      for (let i = 0; i < decl.arguments.length; i++) {
+        out.push(
+          ...generateCall(scope, {
+            callee: {
+              type: 'Identifier',
+              name: '__Porffor_print'
+            },
+            arguments: [ decl.arguments[i] ]
+          }),
+
+          // print space
+          ...number(32),
+          [ Opcodes.call, importedFuncs.printChar ]
+        );
+      }
+
+      // print newline
+      out.push(
+        ...number(10),
+        [ Opcodes.call, importedFuncs.printChar ]
+      );
 
-//   return _.apply(this, arguments);
-// };
+      return out;
+    },
+    type: TYPES.undefined,
+    notConstr: true,
+    length: 0
+  }
+};
 
 export default program => {
   globals = {};
@@ -3615,7 +3704,7 @@ export default program => {
 
   globalThis.valtype = 'f64';
 
-  const valtypeOpt = process.argv.find(x => x.startsWith('-valtype='));
+  const valtypeOpt = process.argv.find(x => x.startsWith('--valtype='));
   if (valtypeOpt) valtype = valtypeOpt.split('=')[1];
 
   globalThis.valtypeBinary = Valtype[valtype];
@@ -3623,7 +3712,7 @@ export default program => {
   const valtypeInd = ['i32', 'i64', 'f64'].indexOf(valtype);
 
   globalThis.pageSize = PageSize;
-  const pageSizeOpt = process.argv.find(x => x.startsWith('-page-size='));
+  const pageSizeOpt = process.argv.find(x => x.startsWith('--page-size='));
   if (pageSizeOpt) pageSize = parseInt(pageSizeOpt.split('=')[1]) * 1024;
 
   // set generic opcodes for current valtype

package/compiler/decompile.js

@@ -110,7 +110,6 @@ export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = []
 
     out += '\n';
     lastInst = inst;
-    i++;
   }
 
   return highlightAsm(out);