watr 2.0.0 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "watr",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Ligth & fast WAT compiler",
   "main": "watr.js",
   "exports": {

package/src/compile.js

@@ -46,7 +46,7 @@ export default (nodes) => {
   }
 
   // code must be compiled after all definitions
-  for (let cb of postcall) cb && cb.call && cb()
+  for (let cb of postcall) cb?.()
 
   // 3. build binary
   for (let name in sections) {
@@ -66,31 +66,10 @@ const build = {
   // (type $name? (func (param $x i32) (param i64 i32) (result i32 i64)))
   // signature part is identical to function
   // FIXME: handle non-function types
-  type([, typeName, decl], ctx) {
-    if (typeName[0] !== '$') decl = typeName, typeName = null
-    let params = [], result = [], [kind, ...sig] = decl, idx, bytes
-
-    if (kind === 'func') {
-      // collect params
-      while (sig[0]?.[0] === 'param') {
-        let [, ...types] = sig.shift()
-        if (types[0]?.[0] === '$') params[types.shift()] = params.length
-        params.push(...types.map(t => TYPE[t]))
-      }
-
-      // collect result type
-      if (sig[0]?.[0] === 'result') result = sig.shift().slice(1).map(t => TYPE[t])
-
-      // reuse existing type or register new one
-      bytes = [TYPE.func, ...uleb(params.length), ...params, ...uleb(result.length), ...result]
-
-      idx = ctx.type.findIndex((prevType) => prevType.every((byte, i) => byte === bytes[i]))
-      if (idx < 0) idx = ctx.type.push(bytes) - 1
-    }
-
+  type([, typeName, [kind, ...sig]], ctx) {
+    if (kind !== 'func') err(`Unknown type kind '${kind}'`)
+    const [idx] = consumeType(sig, ctx)
     if (typeName) ctx.type[typeName] = idx
-
-    return [idx, params, result]
   },
 
   // (func $name? ...params result ...body)
@@ -104,10 +83,10 @@ const build = {
     // export binding
     if (body[0]?.[0] === 'export') build.export([...body.shift(), ['func', ctx.func.length]], ctx)
 
-    // register type
-    let [typeIdx, params, result] = build.type([, ['func', ...body]], ctx)
-    // FIXME: try merging with build.type: it should be able to consume body
-    while (body[0]?.[0] === 'param' || body[0]?.[0] === 'result') body.shift()
+    // register/consume type info
+    let [typeIdx, params, result] = consumeType(body, ctx)
+
+    // register new function
     ctx.func.push([typeIdx])
 
     // collect locals
@@ -182,40 +161,54 @@ const build = {
         immed = [0]
       }
 
-      // (if (result i32)? (local.get 0) (then a b) (argse a b)?)
-      else if (opCode == 4) {
+      // (if ...), (block ...), (loop ...)
+      else if (opCode > 1 && opCode < 5) {
         blocks.push(opCode)
-        let [, type] = args[0][0] === 'result' ? args.shift() : [, 'void']
-        immed = [TYPE[type]] // FIXME: what if that's multiple values return?
 
-        // (if ... (then) (else)) -> `... if ... else ... end`
+        // (block $x) (loop $y)
+        if (opCode < 4 && args[0]?.[0] === '$') (blocks[args.shift()] = blocks.length)
+
+        // get type
+        // (result i32)
+        if (args[0]?.[0] === 'result') {
+          if (args[0].length < 3) {
+            let [, type] = args.shift()
+            immed = [TYPE[type]]
+          }
+          // (result i32 i32)
+          else {
+            let [typeId] = consumeType(args, ctx)
+            immed = [typeId]
+          }
+        }
+        else immed = [TYPE.void]
+
         if (group) {
           nodes.unshift('end')
-          if (args[args.length - 1][0] === 'else') nodes.unshift(args.pop())
-          if (args[args.length - 1][0] === 'then') nodes.unshift(args.pop())
+
+          // (block xxx) -> block xxx end
+          if (opCode < 4) while (args.length) nodes.unshift(args.pop())
+
+          // (if cond a) -> cond if a end
+          else if (args.length < 3) nodes.unshift(args.pop())
+          // (if cond (then a) (else b)) -> `cond if a else b end`
+          else {
+            nodes.unshift(args.pop())
+            // (if cond a b) -> (if cond a else b)
+            if (nodes[0][0] !== 'else') nodes.unshift('else')
+            // (if a b (else)) -> (if a b)
+            else if (nodes[0].length < 2) nodes.shift()
+            nodes.unshift(args.pop())
+          }
         }
       }
+
       // (else)
       else if (opCode === 5) {
-        // ignore empty else
-        if (!args.length && nodes[0] === 'end') return
         // (else xxx) -> else xxx
         if (group) while (args.length) nodes.unshift(args.pop())
       }
 
-      // (block ...), (loop ...)
-      else if (opCode == 2 || opCode == 3) {
-        blocks.push(opCode)
-        if (args[0]?.[0] === '$') (blocks[args.shift()] = blocks.length)
-        let [, type] = args[0]?.[0] === 'result' ? args.shift() : [, 'void']
-        immed = [TYPE[type]]
-        // (block xxx) -> block xxx end
-        if (group) {
-          nodes.unshift('end')
-          while (args.length) nodes.unshift(args.pop())
-        }
-      }
-
       // (end)
       else if (opCode == 0x0b) blocks.pop()
 
@@ -304,7 +297,7 @@ const build = {
     if (kind === 'func') {
       // we track imported funcs in func section to share namespace, and skip them on final build
       if (name) ctx.func[name] = ctx.func.length
-      let [typeIdx] = build.type([, ['func', ...parts]], ctx)
+      let [typeIdx] = consumeType(parts, ctx)
       ctx.func.push(details = uleb(typeIdx))
       ctx.func.importc = (ctx.func.importc || 0) + 1
     }
@@ -358,8 +351,33 @@ const str = str => {
   return res
 }
 
-
 // build range/limits sequence (non-consuming)
 const range = ([min, max, shared]) => isNaN(parseInt(max)) ? [0, ...uleb(min)] : [shared === 'shared' ? 3 : 1, ...uleb(min), ...uleb(max)]
 
+// get type info from (params) (result) nodes sequence (consumes nodes)
+// returns registered (reused) type idx, params bytes, result bytes
+// eg. (type $return_i32 (func (result i32)))
+const consumeType = (nodes, ctx) => {
+  let params = [], result = [], idx, bytes
+
+  // collect params
+  while (nodes[0]?.[0] === 'param') {
+    let [, ...types] = nodes.shift()
+    if (types[0]?.[0] === '$') params[types.shift()] = params.length
+    params.push(...types.map(t => TYPE[t]))
+  }
+
+  // collect result type
+  if (nodes[0]?.[0] === 'result') result = nodes.shift().slice(1).map(t => TYPE[t])
+
+  // reuse existing type or register new one
+  bytes = [TYPE.func, ...uleb(params.length), ...params, ...uleb(result.length), ...result]
+  idx = ctx.type.findIndex((t) => t.every((byte, i) => byte === bytes[i]))
+
+  // register new type, if not found
+  if (idx < 0) idx = ctx.type.push(bytes) - 1
+
+  return [idx, params, result]
+}
+
 const err = text => { throw Error(text) }