watr 0.0.0 → 1.0.0

package/example/amp.wat

@@ -0,0 +1,81 @@
+;; test passing array to and back
+(module
+  (import "js" "mem" (memory 1))
+  (import "console" "log" (func $log (param i32 f32)))
+
+  (global $blockSize (import "js" "blockSize") (mut i32))
+  (global $len (mut i32) (i32.const 0))
+
+  ;; len = blockSize * 4
+  (func (global.set $len (i32.mul (global.get $blockSize) (i32.const 4))))
+  (start 1)
+
+  ;; gain processing function
+  (func $amp (export "amp") (param $amp f32)
+    (local $i i32)
+    (local $x f32)
+
+    (loop $gain
+      ;; x = input[i]
+      (local.set $x (f32.load (local.get $i)))
+
+      ;; console.log(i, x)
+      ;; (call $log (local.get $i) (local.get $x))
+
+      ;; x = x * amp
+      (local.set $x (f32.mul (local.get $x) (local.get $amp)))
+
+      ;; input[i] = x * amp
+      (f32.store (local.get $i) (local.get $x))
+
+      ;; i++
+      (local.set $i (i32.add (local.get $i) (i32.const 4)))
+
+      ;; if (i < len) repeat
+      (br_if $gain (i32.lt_s (local.get $i) (global.get $len)))
+    )
+  )
+
+  ;; multivar amp
+  (func $ampMulti (export "ampMulti") (param $amp f32)
+    (local i32 f32)
+    ;; note: indexing here is 1, 2, since 0 is taken by $amp
+
+    (loop $gain
+      ;; x = input[i]
+      (local.set 2 (f32.load (local.get 1)))
+
+      ;; console.log(i, x)
+      ;; (call $log (local.get 1) (local.get 2))
+
+      ;; x = x * amp
+      (local.set 2 (f32.mul (local.get $amp) (local.get 2)))
+
+      ;; ;; input[i] = x * amp
+      (f32.store (local.get 1) (local.get 2))
+
+      ;; ;; i++
+      (local.set 1 (i32.add (local.get 1) (i32.const 4)))
+
+      ;; if (i < len) repeat
+      (br_if $gain (i32.lt_s (local.get 1) (global.get $len)))
+    )
+  )
+
+  ;; optimized amp
+  (func $ampShort (export "ampShort") (param $amp f32)
+    (local i32 f32)
+    ;; note: indexing here is 1, 0
+
+    (loop $gain
+      ;; console.log(i, x)
+      ;; (call $log (local.get 1) (local.get 0))
+
+      ;; input[i] = input[i] * amp
+      (f32.store (local.get 1) (f32.mul (f32.load (local.get 1)) (local.get $amp)))
+
+      ;; if (i++ < len) repeat
+      (br_if $gain (i32.lt_s (local.tee 1 (i32.add (local.get 1) (i32.const 4))) (global.get $len)))
+    )
+  )
+)

package/example/array.wat

@@ -0,0 +1,26 @@
+;; test passing array to and back
+(module
+  (import "js" "mem" (memory 1))
+  (import "console" "log" (func $log (param i32 f32)))
+
+  ;; gain processing function
+  (func $arr (export "arr")
+    (local.array i32[] (i32.const 0))
+    ;; doesn't work, although that's what walt generates
+    ;; (local.set arr
+    ;;   (subscript
+    ;;     (local.set arr)
+    ;;     (i32.const 0)
+    ;;   )
+    ;;   (i32.const 20)
+    ;; )
+    ;; (local.set arr
+    ;;   (subscript
+    ;;     (local.set arr)
+    ;;     (i32.const 1)
+    ;;   )
+    ;;   (i32.const 15)
+    ;; )
+    ;; (return arr)
+  )
+)

package/example/global.wat

@@ -0,0 +1,28 @@
+(module
+  (import "js" "log" (func $log (param i32)))
+
+  ;; (import "js" "g1" (global $g1 (mut i32)))  ;; identical to line below
+  (global $g1 (import "js" "g1") (mut i32))  ;; import from js
+  ;; (global $g1 (import "js" "g1") i32)  ;; immutable import
+
+  ;; (global $g0 i32 (i32.const 1)) ;; local global immutable (not imported)
+  (global $g0 (mut i32) (i32.const 1)) ;; local global mutable, initialized
+
+  ;; ? is that mandatory to initialize that?
+  ;; yep, initializer is needed, same time we cannot push to stack in global scope, so we use lispy style
+
+  ;; ? is there a short way to initialize?
+  ;; − this is short way, reminds lispy syntax (operator a b)
+
+  (func (export "getG0") (result i32)
+    global.get $g0
+  )
+
+  (func $getG1 (export "getG1") (result i32)
+    global.get $g1
+  )
+  (func $setG1 (export "setG1") (param i32)
+    local.get 0
+    global.set $g1
+  )
+)

package/example/loops.wat

@@ -0,0 +1,34 @@
+(module
+  ;; import the browser console object, you'll need to pass this in from JavaScript
+  (import "console" "log" (func $log (param i32)))
+
+  ;; the difference between block and loop is: you cannot goto beginning of block again
+  ;; block defines scope for variables, loop adds goto label
+
+  (func
+    ;; (loop xxx)
+    ;; identical to
+    ;; loop ... end
+
+    ;; create a global variable and initialize it to 0
+    (local $i i32)
+
+    (loop $my_loop
+
+      ;; add one to $i
+      local.get $i
+      i32.const 1
+      i32.add
+      local.set $i
+
+      ;; log the current value of $i
+      local.get $i
+      call $log
+
+      ;; if $i is less than 10 branch to loop
+      (br_if $my_loop (i32.lt_s (local.get $i) (i32.const 10)))
+    )
+  )
+
+  (start 1) ;; run the first function automatically
+)

package/example/memory.wat

@@ -0,0 +1,34 @@
+(module
+  (import "js" "log" (func $log (param i32)))
+
+  ;; reexport memory
+  ;; note: it requires import.
+  (import "js" "mem" (memory $mem 2))
+  (export "mem" (memory $mem))
+
+  ;; (memory $mem (import "js" "mem") (export "mem") 1) ;; create memory with 1 page - per module
+
+  ;; (import "js" "g" (global $g f32))
+  ;; (export "g" (global $g))
+
+  ;; (global (export "g") (mut f32) (f32.const 1.5))
+  ;; (memory $xxx 1) ;; create memory with 1 page - per module
+
+  (func $populate (export "populate")
+    i32.const 0
+    i32.const 123
+    i32.store
+
+    i32.const 10
+    i32.const 1230
+    i32.store
+  )
+
+  (func $get (export "get") (param i32) (result i32)
+    (i32.load (local.get 0))
+  )
+
+  (func $set (export "set") (param i32) (param i32)
+    (i32.store (local.get 0) (local.get 1))
+  )
+)

package/example/multivar.wat

@@ -0,0 +1,13 @@
+;; test passing array to and back
+(module
+  (import "js" "mem" (memory 1))
+  (import "console" "log" (func $log (param i32 f32)))
+
+  (global $blockSize (import "js" "blockSize") (mut i32))
+  (global $len (mut i32) (i32.const 0))
+  ;; len = blockSize * 4
+  (func (global.set $len (i32.mul (global.get $blockSize) (i32.const 4))))
+  (start 1)
+
+  ;; NOTE: see array.wat
+)

package/example/stack.wat

@@ -0,0 +1,38 @@
+;; test multiple values & stack
+(module
+
+  (global $g0 i32 (i32.const 12))
+
+  (func i32.const 0 return) ;; TF?
+
+  (func $get (export "get") (result i32 i32)
+    ;; note: you cannot push more items to stack than needed for the next op
+    ;; global.get $g0
+
+    ;; (return (i32.add (global.get $g0) (global.get $g0)) (global.get $g0))
+    ;; in case of returning multiple values js receives an array
+
+    ;; equivalend notation is this
+    (global.get $g0) (global.get $g0) (i32.add)
+    (global.get $g0)
+  )
+
+
+  (func $mul (export "mul") (param i32 i32) (result i32) (i32.mul (local.get 1) (local.get 0)))
+
+  (func $swap (export "swap") (param i32 i32 i32) (param i32) (result i32 i32)
+    (local.get 3) (local.get 0)
+  )
+
+  ;; (func $fac (param i64) (result i64)
+  ;;   (i64.const 1) (local.get 0)
+  ;;   (loop $l (param i64 i64) (result i64)
+  ;;     (pick 1) (pick 1) (i64.mul)
+  ;;     (pick 1) (i64.const 1) (i64.sub)
+  ;;     (pick 0) (i64.const 0) (i64.gt_u)
+  ;;     (br_if $l)
+  ;;     (pick 1) (return)
+  ;;   )
+  ;; )
+)
+

package/example/table.wat

@@ -0,0 +1,24 @@
+(module
+  (table $x 2 funcref)
+  (table $y 2 funcref)
+  (elem (table $y) (i32.const 0) $f1 $f2)
+
+  ;; w is this?
+  ;; (elem funcref (ref.func 1) (ref.null func))
+  ;; (elem declare func 0)
+
+  (func $f1 (result i32) i32.const 42)
+  (func $f2 (result i32) i32.const 13)
+
+  (type $return_i32 (func (result i32)))
+  (func (export "callByIndex") (param $i i32) (result i32)
+    local.get $i
+    call_indirect $y (type $return_i32))
+
+  (func (export "getByIndex") (param $i i32) (result funcref)
+    ;; (return (ref.func $f2)) ;; return direct function
+
+    ;; return from table
+    (table.get $y (local.get $i))
+  )
+)

package/example/types.wat

@@ -0,0 +1,21 @@
+;; test passing array to and back
+(module
+  (import "console" "log" (func $log (param i32 f32 externref)))
+
+  ;; NOTE: JS doesn't allow functions with v128 arguments
+  ;; (func $run (export "run") (param i32 f32) (param v128) (result i32 f32 v128)
+  ;;   (call $log (local.get 0) (local.get 1) (local.get 2))
+  ;;   (return (local.get 0) (local.get 1) (local.get 2))
+  ;; )
+
+  (func $run (export "run") (param i32 f32) (param externref) (result i32 f32 externref)
+    (call $log (local.get 0) (local.get 1) (local.get 2))
+    (ref.null extern)
+    (return (local.get 0) (local.get 1) (local.get 2))
+  )
+
+  (elem func 0)
+  (func $f (export "f") (result funcref)
+    (return (ref.func 0))
+  )
+)