wabam 0.3.0

WebAssembly Builder and Assembler of Modules: WABAM
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

[![Crates.io](https://img.shields.io/crates/v/wabam?style=flat-square)](https://crates.io/crates/wabam)
[![docs.rs](https://img.shields.io/docsrs/wabam?style=flat-square)](https://docs.rs/wabam/)
[![GitHub Repo stars](https://img.shields.io/github/stars/Cyborus04/wabam?style=social)](https://github.com/Cyborus04/wabam)

# wabam

A crate for creating WebAssembly modules.

## Example

```rust
let mut module = wabam::Module::default();

module.types = vec![
    wabam::func_type!((param) (result)),
    wabam::func_type!((param i32 i32 i32 i32) (result i32)),
];

// Import WASI's `fd_write`, to print to the terminal
let fd_write = wabam::interface::FuncImport {
    module: "wasi_snapshot_preview1".into(),
    name: "fd_write".into(),
    type_idx: 1, // types[1], see above
};
module.imports.functions.push(fd_write);

// Define memory
let memory = wabam::Limit {
    start: 1,
    end: None,
};
module.memories.push(memory);

let text = "Hello, wasm!";
let text_ptr = 12;

// Load the text into memory
let data = wabam::Data::Active {
    mem_index: 0,
    offset: wabam::instr!(i32.const { text_ptr }).into(),
    data: text.into(),
};
module.datas.push(data);

let body = wabam::instrs!(
    (i32.const 0) // Where the `(ptr, len)` pair is
    (i32.const { text_ptr })
    (i32.store) // Write ptr
    
    (i32.const 0) // Where the `(ptr, len)` pair is
    (i32.const { text.len() as i32 })
    (i32.store offset=4) // Write len

    (i32.const 1) // File descriptor, stdout is 1.
    (i32.const 0) // Where the `(ptr, len)` pair is
    (i32.const 1) // How many `(ptr, len)` pairs there are
    (i32.const 8) // Where to write the number of written bytes
    (call 0) // imported functions are at the start of the address space
    // this current function would be 1 (this is important later!)
    (drop) // Ignore the error, this is just an example after all!
);

let func = wabam::functions::Function {
    type_idx: 0, // types[0], see above
    locals: vec![], // no local variables
    body: body.into(),
};
module.functions.push(func);

// Export the start function
let func_export = wabam::interface::Export {
    name: "_start".into(),
    idx: 1, // this is where that's important
};

// Export memory
let mem_export = wabam::interface::Export {
    name: "memory".into(),
    idx: 0,
};
module.exports.functions.push(func_export);
module.exports.memories.push(mem_export);

let output = module.build();

std::fs::write("./hello.wasm", &output).unwrap();
```

Then run it:

```txt
$ wasmtime ./hello.wasm
Hello, wasm!
```

# Licensing

This project is licensed under either
[Apache License Version 2.0](LICENSE-APACHE) or [MIT License](LICENSE-MIT)
at your option.

Unless you explicitly state otherwise, any contribution intentionally submitted
for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
dual licensed as above, without any additional terms or conditions.