watr 2.3.1 → 2.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "watr",
-  "version": "2.3.1",
+  "version": "2.4.0",
   "description": "Ligth & fast WAT compiler",
   "main": "watr.js",
   "exports": {
@@ -15,7 +15,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/audio-lab/watr.git"
+    "url": "git+https://github.com/dy/watr.git"
   },
   "files": [
     "src",
@@ -35,9 +35,9 @@
   "author": "Dmitry Iv",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/audio-lab/watr/issues"
+    "url": "https://github.com/dy/watr/issues"
   },
-  "homepage": "https://github.com/audio-lab/watr#readme",
+  "homepage": "https://github.com/dy/watr#readme",
   "devDependencies": {
     "tst": "^7.3.0",
     "wabt": "^1.0.28",

package/readme.md

@@ -3,15 +3,6 @@
 Bare minimum wasm text compiler/formatter. A light & fast alternative to [wat2wasm](https://github.com/AssemblyScript/wabt.js).<br/>
 Useful for hi-level languages or dynamic (in-browser) compilation.<br>
 
-<!-- See [REPL](https://audio-lab.github.io/watr/repl.html).-->
-
-&nbsp; | Size (gzipped) | Performance (op/s)
----|---|---
-watr | 3.8 kb | 6000
-[wat-compiler](https://github.com/stagas/wat-compiler) | 6 kb | 348
-[wabt](https://github.com/AssemblyScript/wabt.js) | 300 kb | 574
-<!-- [wassemble](https://github.com/wingo/wassemble) | ? kb | ? -->
-
 ## Usage
 
 ### Compile
@@ -77,16 +68,27 @@ parse(`(func (export "double") (param f64) (result f64) (f64.mul (local.get 0) (
 // ]
 ```
 
+<!-- See [REPL](https://audio-lab.github.io/watr/repl.html).-->
+
 ## Status
 
-* [x] wasm core
+* [x] core
 * [x] [multi-value](https://github.com/WebAssembly/spec/blob/master/proposals/multi-value/Overview.md)
 * [x] [bulk memory ops](https://github.com/WebAssembly/bulk-memory-operations/blob/master/proposals/bulk-memory-operations/Overview.md)
 * [x] [simd](https://github.com/WebAssembly/simd/blob/master/proposals/simd/SIMD.md)
+* [x] [extended const](https://github.com/WebAssembly/extended-const/blob/main/proposals/extended-const/Overview.md)
 * [ ] [multiple memories](https://github.com/WebAssembly/multi-memory/blob/master/proposals/multi-memory/Overview.md)
 * [ ] [func refs](https://github.com/WebAssembly/function-references/blob/main/proposals/function-references/Overview.md)
 * [ ] [gc](https://github.com/WebAssembly/gc)
 
+## Alternatives
+
+&nbsp; | Size (gzipped) | Performance (op/s)
+---|---|---
+watr | 5 kb | 6000
+[wat-compiler](https://github.com/stagas/wat-compiler) | 6 kb | 348
+[wabt](https://github.com/AssemblyScript/wabt.js) | 300 kb | 574
+<!-- [wassemble](https://github.com/wingo/wassemble) | ? kb | ? -->
 
 <!--
 ## Projects using watr

package/src/compile.js

@@ -2,7 +2,7 @@ import * as encode from './encode.js'
 import { uleb } from './encode.js'
 import { OP, SECTION, ALIGN, TYPE, KIND } from './const.js'
 import parse from './parse.js'
-import { err, TypedArray } from './util.js'
+import { err } from './util.js'
 
 
 /**
@@ -139,9 +139,15 @@ const build = {
           // (v128.load_lane_zero)
           if (opCode <= 0x5b) immed.push(...uleb(args.shift()))
         }
-        // (v128.const i32x4), (i8x16.shuffle 0 1 ... 15 a b)
-        else if (opCode === 0x0c || opCode === 0x0d) {
-          immed.push(...consumeConst(op.split('.')[0], args))
+        // (i8x16.shuffle 0 1 ... 15 a b)
+        else if (opCode === 0x0d) {
+          // i8, i16, i32 - bypass the encoding
+          for (let i = 0; i < 16; i++) immed.push(encode.i32.parse(args.shift()))
+        }
+        // (v128.const i32x4)
+        else if (opCode === 0x0c) {
+          args.unshift(op)
+          immed = consumeConst(args, ctx)
         }
         // (i8x16.extract_lane_s 0 ...)
         else if (opCode >= 0x15 && opCode <= 0x22) {
@@ -310,8 +316,8 @@ const build = {
   global([, ...args], ctx) {
     let name = args[0][0] === '$' && args.shift()
     if (name) ctx.global[name] = ctx.global.length
-    let [type, init] = args, mut = type[0] === 'mut' ? 1 : 0
-    ctx.global.push([TYPE[mut ? type[1] : type], mut, ...initGlobal(init)])
+    let [type, [...init]] = args, mut = type[0] === 'mut' ? 1 : 0
+    ctx.global.push([TYPE[mut ? type[1] : type], mut, ...consumeConst(init, ctx), 0x0b])
   },
 
   // (table 1 2? funcref)
@@ -324,9 +330,9 @@ const build = {
   },
 
   // (elem (i32.const 0) $f1 $f2), (elem (global.get 0) $f1 $f2)
-  elem([, offset, ...elems], ctx) {
+  elem([, [...offset], ...elems], ctx) {
     const tableIdx = 0 // FIXME: table index can be defined
-    ctx.elem.push([tableIdx, ...initGlobal(offset, ctx), ...uleb(elems.length), ...elems.flatMap(el => uleb(el[0] === '$' ? ctx.func[el] : el))])
+    ctx.elem.push([tableIdx, ...consumeConst(offset, ctx), 0x0b, ...uleb(elems.length), ...elems.flatMap(el => uleb(el[0] === '$' ? ctx.func[el] : el))])
   },
 
   //  (export "name" (kind $name|idx))
@@ -379,7 +385,7 @@ const build = {
     if (!offset && !mem) offset = inits.shift()
     if (!offset) offset = ['i32.const', 0]
 
-    ctx.data.push([0, ...initGlobal(offset, ctx), ...str(inits.map(i => i[0] === '"' ? i.slice(1, -1) : i).join(''))])
+    ctx.data.push([0, ...consumeConst([...offset], ctx), 0x0b, ...str(inits.map(i => i[0] === '"' ? i.slice(1, -1) : i).join(''))])
   },
 
   // (start $main)
@@ -388,30 +394,50 @@ const build = {
   }
 }
 
-// (i32.const 0), (global.get idx) - instantiation time initializer
-const initGlobal = ([op, literal, ...args], ctx) => {
-  if (op === 'global.get') return [0x23, ...uleb(literal[0] === '$' ? ctx.global[literal] : literal), 0x0b]
-  const [type] = op.split('.')
+// instantiation time const initializer
+const consumeConst = (node, ctx) => {
+  let op = node.shift(), [type, cmd] = op.split('.')
+
+  // (global.get idx)
+  if (type === 'global') return [0x23, ...uleb(node[0][0] === '$' ? ctx.global[node[0]] : node[0])]
+
   // (v128.const i32x4 1 2 3 4)
-  return [...(type === 'v128' ? [0xfd, 0x0c] : [0x41 + ['i32', 'i64', 'f32', 'f64'].indexOf(type)]), ...consumeConst(type, [literal, ...args]), 0x0b]
+  if (type === 'v128') return [0xfd, 0x0c, ...v128(node)]
+
+  // (i32.const 1)
+  if (cmd === 'const') return [0x41 + ['i32', 'i64', 'f32', 'f64'].indexOf(type), ...encode[type](node[0])]
+
+  // (i32.add a b), (i32.mult a b) etc
+  return [
+    ...consumeConst(node.shift(), ctx),
+    ...consumeConst(node.shift(), ctx),
+    OP.indexOf(op)
+  ]
 }
 
-// consume cost, no op type
-const consumeConst = (type, args) => {
-  // (v128.const i32x4 1 2 3 4), (i8x16.shuffle 1 2 ... 15)
-  if (type === 'v128' || type === 'i8x16') {
-    let [t, n] = (type === 'v128' ? args.shift() : type).split('x'),
-      bytes = new Uint8Array(16),
-      arr = new TypedArray[t](bytes.buffer)
+// (v128.const i32x4 1 2 3 4)
+const v128 = (args) => {
+  let [t, n] = args.shift().split('x'),
+    stride = t.slice(1) >>> 3 // i16 -> 2, f32 -> 4
+
+  n = +n
 
+  // i8, i16, i32 - bypass the encoding
+  if (t[0] === 'i') {
+    let arr = n === 16 ? new Uint8Array(16) : n === 8 ? new Uint16Array(8) : n === 4 ? new Uint32Array(4) : new BigInt64Array(2)
     for (let i = 0; i < n; i++) {
       arr[i] = encode[t].parse(args.shift())
     }
+    return new Uint8Array(arr.buffer)
+  }
 
-    return bytes
+  // f32, f64 - encode
+  let arr = new Uint8Array(16)
+  for (let i = 0; i < n; i++) {
+    arr.set(encode[t](args.shift()), i * stride)
   }
-  // (i32.const 1)
-  return encode[type](args[0])
+
+  return arr
 }
 
 // escape codes

package/src/encode.js

@@ -63,7 +63,7 @@ const byteView = new DataView(new BigInt64Array(1).buffer)
 const F32_SIGN = 0x80000000, F32_NAN = 0x7f800000
 export function f32(input, value, idx) {
   if (~(idx = input.indexOf('nan:'))) {
-    value = parseInt(input.slice(idx + 4))
+    value = i32.parse(input.slice(idx + 4))
     value |= F32_NAN
     if (input[0] === '-') value |= F32_SIGN
     byteView.setInt32(0, value)
@@ -84,7 +84,7 @@ export function f32(input, value, idx) {
 const F64_SIGN = 0x8000000000000000n, F64_NAN = 0x7ff0000000000000n
 export function f64(input, value, idx) {
   if (~(idx = input.indexOf('nan:'))) {
-    value = BigInt(input.slice(idx + 4))
+    value = i64.parse(input.slice(idx + 4))
     value |= F64_NAN
     if (input[0] === '-') value |= F64_SIGN
     byteView.setBigInt64(0, value)

package/src/parse.js

@@ -17,13 +17,14 @@ export default (str) => {
 
   const parseLevel = () => {
     for (let c, root; i < str.length;) {
+
       c = str.charCodeAt(i)
       if (c === DQUOTE) commit(), buf = str.slice(i++, i = str.indexOf('"', i) + 1), commit()
       else if (c === OPAREN) {
         if (str.charCodeAt(i + 1) === SEMIC) i = str.indexOf(';)', i) + 2 // (; ... ;)
         else commit(), i++, (root = level).push(level = []), parseLevel(), level = root
       }
-      else if (c === SEMIC) i = str.indexOf('\n', i) + 1  // ; ...
+      else if (c === SEMIC) i = str.indexOf('\n', i) + 1 || str.length  // ; ...
       else if (c <= SPACE) commit(), i++
       else if (c === CPAREN) return commit(), i++
       else buf += str[i++]

package/src/util.js

@@ -1,3 +1 @@
-export const TypedArray = { i64: BigInt64Array, i32: Int32Array, i16: Int16Array, i8: Int8Array, f64: Float64Array, f32: Float32Array }
-
 export const err = text => { throw Error(text) }