porffor 0.2.0-b9abe0d → 0.2.0-bae0c5b

package/compiler/builtins.js

@@ -216,7 +216,7 @@ export const BuiltinFuncs = function() {
   };
 
 
-  this.__console_log = {
+  this.__Porffor_print = {
     params: [ valtypeBinary, Valtype.i32 ],
     typedParams: true,
     locals: [ Valtype.i32, Valtype.i32 ],
@@ -368,10 +368,7 @@ export const BuiltinFuncs = function() {
           [ Opcodes.local_get, 0 ],
           [ Opcodes.call, importedFuncs.print ],
         ]
-      }, Blocktype.void),
-
-      ...char('\n'),
-      [ Opcodes.call, importedFuncs.printChar ]
+      }, Blocktype.void)
     ]
   };
 
@@ -1058,19 +1055,6 @@ export const BuiltinFuncs = function() {
   };
 
 
-  // this.__Date_now = {
-  //   params: [],
-  //   locals: [],
-  //   returns: [ valtypeBinary ],
-  //   wasm: [
-  //     [ Opcodes.call, importedFuncs.timeOrigin ],
-  //     [ Opcodes.call, importedFuncs.time ],
-  //     [ Opcodes.f64_add ],
-  //     [ Opcodes.f64_trunc ]
-  //   ]
-  // };
-
-
   this.__Porffor_type = {
     params: [ valtypeBinary, Valtype.i32 ],
     typedParams: true,

package/compiler/codegen.js

@@ -210,7 +210,7 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
               return int;
             });
 
-            out.push([ ...inst, ...immediates ]);
+            out.push([ ...inst, ...immediates.flatMap(x => signedLEB128(x)) ]);
           }
 
           return out;
@@ -1472,7 +1472,7 @@ const countLeftover = wasm => {
     if (depth === 0)
       if ([Opcodes.throw, Opcodes.drop, Opcodes.local_set, Opcodes.global_set].includes(inst[0])) count--;
         else if ([null, Opcodes.i32_eqz, Opcodes.i64_eqz, Opcodes.f64_ceil, Opcodes.f64_floor, Opcodes.f64_trunc, Opcodes.f64_nearest, Opcodes.f64_sqrt, Opcodes.local_tee, Opcodes.i32_wrap_i64, Opcodes.i64_extend_i32_s, Opcodes.i64_extend_i32_u, Opcodes.f32_demote_f64, Opcodes.f64_promote_f32, Opcodes.f64_convert_i32_s, Opcodes.f64_convert_i32_u, Opcodes.i32_clz, Opcodes.i32_ctz, Opcodes.i32_popcnt, Opcodes.f64_neg, Opcodes.end, Opcodes.i32_trunc_sat_f64_s[0], Opcodes.i32x4_extract_lane, Opcodes.i16x8_extract_lane, Opcodes.i32_load, Opcodes.i64_load, Opcodes.f64_load, Opcodes.v128_load, Opcodes.i32_load16_u, Opcodes.i32_load16_s, Opcodes.i32_load8_u, Opcodes.i32_load8_s, Opcodes.memory_grow].includes(inst[0]) && (inst[0] !== 0xfc || inst[1] < 0x0a)) {}
-        else if ([Opcodes.local_get, Opcodes.global_get, Opcodes.f64_const, Opcodes.i32_const, Opcodes.i64_const, Opcodes.v128_const].includes(inst[0])) count++;
+        else if ([Opcodes.local_get, Opcodes.global_get, Opcodes.f64_const, Opcodes.i32_const, Opcodes.i64_const, Opcodes.v128_const, Opcodes.memory_size].includes(inst[0])) count++;
         else if ([Opcodes.i32_store, Opcodes.i64_store, Opcodes.f64_store, Opcodes.i32_store16, Opcodes.i32_store8].includes(inst[0])) count -= 2;
         else if (Opcodes.memory_copy[0] === inst[0] && Opcodes.memory_copy[1] === inst[1]) count -= 3;
         else if (inst[0] === Opcodes.return) count = 0;
@@ -1646,18 +1646,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}`;
 
-      funcIndex[func.name] = func.index;
-      funcs.push(func);
+      if (!funcIndex[rhemynName]) {
+        const func = Rhemyn[funcName](regex, currentFuncIndex++, rhemynName);
 
+        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 +1704,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
 
         protoBC[type] = generateCall(scope, {
           callee: {
+            type: 'Identifier',
             name: x
           },
           arguments: [ target, ...decl.arguments ],
@@ -1845,31 +1853,28 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   if (idx === undefined && name.startsWith('__Porffor_wasm_')) {
     const wasmOps = {
       // pointer, align, offset
-      i32_load: { imms: 2, args: 1, returns: 1 },
+      i32_load: { imms: 2, args: [ true ], returns: 1 },
       // pointer, value, align, offset
-      i32_store: { imms: 2, args: 2, returns: 0 },
+      i32_store: { imms: 2, args: [ true, true ], returns: 0 },
       // pointer, align, offset
-      i32_load8_u: { imms: 2, args: 1, returns: 1 },
+      i32_load8_u: { imms: 2, args: [ true ], returns: 1 },
       // pointer, value, align, offset
-      i32_store8: { imms: 2, args: 2, returns: 0 },
+      i32_store8: { imms: 2, args: [ true, true ], returns: 0 },
       // pointer, align, offset
-      i32_load16_u: { imms: 2, args: 1, returns: 1 },
+      i32_load16_u: { imms: 2, args: [ true ], returns: 1 },
       // pointer, value, align, offset
-      i32_store16: { imms: 2, args: 2, returns: 0 },
+      i32_store16: { imms: 2, args: [ true, true ], returns: 0 },
 
       // pointer, align, offset
-      f64_load: { imms: 2, args: 1, returns: 1 },
+      f64_load: { imms: 2, args: [ true ], returns: 0 }, // 0 due to not i32
       // pointer, value, align, offset
-      f64_store: { imms: 2, args: 2, returns: 0 },
+      f64_store: { imms: 2, args: [ true, false ], returns: 0 },
 
       // value
-      i32_const: { imms: 1, args: 0, returns: 1 },
+      i32_const: { imms: 1, args: [], returns: 1 },
 
       // a, b
-      i32_or: { imms: 0, args: 2, returns: 1 },
-
-      add: { imms: 0, args: 2, returns: 1 },
-      i32_to_u: { imms: 0, args: 1, returns: 1 }
+      i32_or: { imms: 0, args: [ true, true ], returns: 1 },
     };
 
     const opName = name.slice('__Porffor_wasm_'.length);
@@ -1878,13 +1883,13 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       const op = wasmOps[opName];
 
       const argOut = [];
-      for (let i = 0; i < op.args; i++) argOut.push(
+      for (let i = 0; i < op.args.length; i++) argOut.push(
         ...generate(scope, decl.arguments[i]),
-        Opcodes.i32_to
+        ...(op.args[i] ? [ Opcodes.i32_to ] : [])
       );
 
       // literals only
-      const imms = decl.arguments.slice(op.args).map(x => x.value);
+      const imms = decl.arguments.slice(op.args.length).map(x => x.value);
 
       return [
         ...argOut,
@@ -2229,7 +2234,7 @@ const generateVar = (scope, decl) => {
     }
 
     const typed = typedInput && x.id.typeAnnotation;
-    let idx = allocVar(scope, name, global, !typed);
+    let idx = allocVar(scope, name, global, !(typed && extractTypeAnnotation(x.id).type != null));
 
     if (typed) {
       addVarMetadata(scope, name, global, extractTypeAnnotation(x.id));
@@ -3508,6 +3513,8 @@ const internalConstrs = {
         );
       }
 
+      out.push(Opcodes.i32_from_u);
+
       return out;
     },
     type: TYPES.boolean,
@@ -3526,6 +3533,8 @@ const internalConstrs = {
         );
       }
 
+      out.push(Opcodes.i32_from_u);
+
       return out;
     },
     type: TYPES.boolean,
@@ -3580,6 +3589,39 @@ const internalConstrs = {
     type: TYPES.number,
     notConstr: true,
     length: 2
+  },
+
+  __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 out;
+    },
+    type: TYPES.undefined,
+    notConstr: true,
+    length: 0
   }
 };
 
@@ -3614,7 +3656,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];
@@ -3622,7 +3664,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