watr 2.2.1 → 2.2.3

package/package.json

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

package/readme.md

@@ -7,7 +7,7 @@ Useful for hi-level languages or dynamic (in-browser) compilation.<br>
 
 &nbsp; | Size (gzipped) | Performance (op/s)
 ---|---|---
-watr | 3.8 kb | 6250
+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
 
@@ -99,7 +99,6 @@ parse(`(func (export "double") (param f64) (result f64) (f64.mul (local.get 0) (
 ## Status
 
 * [x] wasm core
-* [ ] floating HEX support, eg. `(f32.const 0x1.fffffep+127)`.
 * [x] multiple values
 * [x] bulk memory ops (0 index)
 * [ ] func/ref types

package/src/util.js

@@ -1,21 +1,21 @@
 // encoding ref: https://github.com/j-s-n/WebBS/blob/master/compiler/byteCode.js
-export const uleb = (number, buffer=[]) => {
-  if (typeof number === 'string') number = parseInt(number.replaceAll('_',''))
+export const uleb = (n, buffer = []) => {
+  if (typeof n === 'string') n = parseInt(n.replaceAll('_', ''))
 
-  let byte = number & 0b01111111;
-  number = number >>> 7;
+  let byte = n & 0b01111111;
+  n = n >>> 7;
 
-  if (number === 0) {
+  if (n === 0) {
     buffer.push(byte);
     return buffer;
   } else {
     buffer.push(byte | 0b10000000);
-    return uleb(number, buffer);
+    return uleb(n, buffer);
   }
 }
 
-export function leb (n, buffer=[]) {
-  if (typeof n === 'string') n = parseInt(n.replaceAll('_',''))
+export function leb(n, buffer = []) {
+  if (typeof n === 'string') n = parseInt(n.replaceAll('_', ''))
 
   while (true) {
     const byte = Number(n & 0x7F)
@@ -29,10 +29,10 @@ export function leb (n, buffer=[]) {
   return buffer
 }
 
-export function bigleb(n, buffer=[]) {
+export function bigleb(n, buffer = []) {
   if (typeof n === 'string') {
-    n = n.replaceAll('_','')
-    n = n[0]==='-'?-BigInt(n.slice(1)):BigInt(n)
+    n = n.replaceAll('_', '')
+    n = n[0] === '-' ? -BigInt(n.slice(1)) : BigInt(n)
     byteView.setBigInt64(0, n)
     n = byteView.getBigInt64(0)
   }
@@ -50,21 +50,36 @@ export function bigleb(n, buffer=[]) {
 }
 
 // generalized float cases parser
-const flt = input => input==='nan'||input==='+nan'?NaN:input==='-nan'?-NaN:
-    input==='inf'||input==='+inf'?Infinity:input==='-inf'?-Infinity:parseFloat(input.replaceAll('_',''))
+const flt = input => {
+  if (input.includes('nan')) return input[0] === '-' ? -NaN : NaN;
+  if (input.includes('inf')) return input[0] === '-' ? -Infinity : Infinity;
+
+  input = input.replaceAll('_', '')
+
+  // 0x1.5p3
+  if (/^[+-]?0x/.test(input)) {
+    let sign = input[0] === '-' ? (input = input.slice(1), -1) : 1,
+      [sig, exp] = input.split(/p/i), [dec, fract] = sig.split('.')
+    sig = parseInt(dec) + (fract ? parseInt(fract, 16) / (16 ** fract.length) : 0)
+    return sign * (exp ? sig * 2 ** parseInt(exp, 10) : sig);
+  }
+
+  return parseFloat(input)
+}
+
 
 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))
+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 |= F32_NAN
     if (input[0] === '-') value |= F32_SIGN
     byteView.setInt32(0, value)
   }
   else {
-    value=typeof input === 'string' ? flt(input) : input
+    value = typeof input === 'string' ? flt(input) : input
     byteView.setFloat32(0, value);
   }
 
@@ -76,16 +91,16 @@ 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))
+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 |= F64_NAN
     if (input[0] === '-') value |= F64_SIGN
     byteView.setBigInt64(0, value)
   }
   else {
-    value=typeof input === 'string' ? flt(input) : input
+    value = typeof input === 'string' ? flt(input) : input
     byteView.setFloat64(0, value);
   }