kraken/comp_wasm.kp

(with_import "./wasm.kp"
(let (
    _ (println "args" *ARGV*)
    (_ _ out) (cond (!= (len *ARGV*) 3) (error "wrong number of params to comp_wasm (please provide out)")
                       true                *ARGV*)
    _ (println "out" out)
    wasm_code (module
        (import "wasi_unstable" "fd_write" (func $fd_write (param i32 i32 i32 i32) (result i32)))
        (func $add (param $num i32) (result i32)
            (local $tmp1 i32)
            (local $tmp2 i32)
            (block $test
                (i32.const 1337)
                (i32.const 1338)
                drop
                drop
                (block $inner_test
                    (br $inner_test)
                    (br $test)
                )
                (br $test)
                drop

                (call $fd_write
                      (i32.const 0) ;; file descriptor
                      (i32.const 8) ;; *iovs
                      (i32.const 1) ;; iovs_len
                      (i32.const 4) ;; nwritten
                )
                drop
            )
            (i32.const 11)
            (local.get $tmp2)
            i32.add
            (i32.add (local.get $num))
        )
        ; nothing
        (export "add" (func $add))
    )


    _ (write_file out (wasm_to_binary wasm_code))
    return_code 0
) return_code ))
Started working on basic wasm encoding/serialization. Added binary_file_writing, generalized arity comparison operators, bitwise operators, parsing of hex numbers, and wasm w/ memory section deserialization 2021-04-19 01:39:04 -04:00			`(with_import "./wasm.kp"`
			`(let (`
			`_ (println "args" ARGV)`
Starting to add control instruction stuff, beginning with the block instruction. No nice labels or anything yet 2021-07-22 01:14:51 -04:00			`(_ _ out) (cond (!= (len ARGV) 3) (error "wrong number of params to comp_wasm (please provide out)")`
Started working on basic wasm encoding/serialization. Added binary_file_writing, generalized arity comparison operators, bitwise operators, parsing of hex numbers, and wasm w/ memory section deserialization 2021-04-19 01:39:04 -04:00			`true ARGV)`
Super basic and a tiny bit hardcoded WAT-like syntax for generating the array of arrays of arrays of arrays wasm implementation in wasm.kp, allowing us to write psudo-WAT in kraken and output binary wasm with 1 function call 2021-07-18 23:42:19 -04:00			`_ (println "out" out)`
			`wasm_code (module`
Add import (only for functions for now) and call 2021-07-25 18:10:10 -04:00			`(import "wasi_unstable" "fd_write" (func $fd_write (param i32 i32 i32 i32) (result i32)))`
Implemented $ references for functions and parameters, which are also parsed for real now, along with the result. Setup for locals added, but not it's backend. Added pretty interesting add-dict-to-env function to collections.kp, which has also been added to put collections stuff in one place. 2021-07-20 00:37:27 -04:00			`(func $add (param $num i32) (result i32)`
			`(local $tmp1 i32)`
			`(local $tmp2 i32)`
Implement the env shuffling to enable blocks with labels and breaking to them (via 'hidden' depth constant added to each block env, from which the block depth is subtracted in the br vau 2021-07-25 02:14:20 -04:00			`(block $test`
Starting to add control instruction stuff, beginning with the block instruction. No nice labels or anything yet 2021-07-22 01:14:51 -04:00			`(i32.const 1337)`
			`(i32.const 1338)`
			`drop`
			`drop`
Implement the env shuffling to enable blocks with labels and breaking to them (via 'hidden' depth constant added to each block env, from which the block depth is subtracted in the br vau 2021-07-25 02:14:20 -04:00			`(block $inner_test`
			`(br $inner_test)`
			`(br $test)`
			`)`
			`(br $test)`
Quick commit adding br instruction 2021-07-24 00:39:45 -04:00			`drop`
Add import (only for functions for now) and call 2021-07-25 18:10:10 -04:00
			`(call $fd_write`
			`(i32.const 0) ;; file descriptor`
			`(i32.const 8) ;; *iovs`
			`(i32.const 1) ;; iovs_len`
			`(i32.const 4) ;; nwritten`
			`)`
			`drop`
Starting to add control instruction stuff, beginning with the block instruction. No nice labels or anything yet 2021-07-22 01:14:51 -04:00			`)`
Implemented $ references for functions and parameters, which are also parsed for real now, along with the result. Setup for locals added, but not it's backend. Added pretty interesting add-dict-to-env function to collections.kp, which has also been added to put collections stuff in one place. 2021-07-20 00:37:27 -04:00			`(i32.const 11)`
Implement locals and foldl, which is the direction we should have been folding to not reverse the params/locals anyway 2021-07-20 23:36:03 -04:00			`(local.get $tmp2)`
Add both bare WAT ins and nested WAT ins 2021-07-19 00:32:42 -04:00			`i32.add`
Implemented $ references for functions and parameters, which are also parsed for real now, along with the result. Setup for locals added, but not it's backend. Added pretty interesting add-dict-to-env function to collections.kp, which has also been added to put collections stuff in one place. 2021-07-20 00:37:27 -04:00			`(i32.add (local.get $num))`
Super basic and a tiny bit hardcoded WAT-like syntax for generating the array of arrays of arrays of arrays wasm implementation in wasm.kp, allowing us to write psudo-WAT in kraken and output binary wasm with 1 function call 2021-07-18 23:42:19 -04:00			`)`
Implemented $ references for functions and parameters, which are also parsed for real now, along with the result. Setup for locals added, but not it's backend. Added pretty interesting add-dict-to-env function to collections.kp, which has also been added to put collections stuff in one place. 2021-07-20 00:37:27 -04:00			`; nothing`
			`(export "add" (func $add))`
Super basic and a tiny bit hardcoded WAT-like syntax for generating the array of arrays of arrays of arrays wasm implementation in wasm.kp, allowing us to write psudo-WAT in kraken and output binary wasm with 1 function call 2021-07-18 23:42:19 -04:00			`)`


Started working on basic wasm encoding/serialization. Added binary_file_writing, generalized arity comparison operators, bitwise operators, parsing of hex numbers, and wasm w/ memory section deserialization 2021-04-19 01:39:04 -04:00			`_ (write_file out (wasm_to_binary wasm_code))`
			`return_code 0`
			`) return_code ))`