24 releases

Uses old Rust 2015

0.10.0 Jul 27, 2020
0.9.2 Sep 10, 2019
0.9.1 Aug 12, 2019
0.9.0 Jul 24, 2019
0.2.2 Mar 11, 2018

#119 in WebAssembly

Download history 1025/week @ 2020-12-22 1420/week @ 2020-12-29 2810/week @ 2021-01-05 1892/week @ 2021-01-12 2025/week @ 2021-01-19 2382/week @ 2021-01-26 2297/week @ 2021-02-02 2354/week @ 2021-02-09 2212/week @ 2021-02-16 2476/week @ 2021-02-23 2279/week @ 2021-03-02 2169/week @ 2021-03-09 2173/week @ 2021-03-16 2029/week @ 2021-03-23 2059/week @ 2021-03-30 2244/week @ 2021-04-06

8,993 downloads per month
Used in 50 crates (41 directly)

Apache-2.0

15MB
251K SLoC

WebAssembly 139K SLoC // 0.0% comments C++ 75K SLoC // 0.1% comments Python 20K SLoC // 0.3% comments JavaScript 9K SLoC // 0.1% comments Visual Studio Project 3K SLoC C 2.5K SLoC // 0.1% comments Rust 1.5K SLoC // 0.0% comments Automake 422 SLoC // 0.2% comments Shell 399 SLoC // 0.6% comments Visual Studio Solution 233 SLoC VB6 149 SLoC Xcode Config 32 SLoC // 0.7% comments Batch 6 SLoC // 0.7% comments

WABT bindings for Rust

crates.io docs.rs

Rust bindings for WABT.

Usage

Add this to your Cargo.toml:

[dependencies]
wabt = "0.9.0"

Use cases

Assemble a given program in WebAssembly text format (aka wat) and translate it into binary.

extern crate wabt;
use wabt::wat2wasm;

fn main() {
    assert_eq!(
        wat2wasm("(module)").unwrap(),
        &[
            0, 97, 115, 109, // \0ASM - magic
            1, 0, 0, 0       //  0x01 - version
        ]
    );
}

or disassemble a wasm binary into the text format.

extern crate wabt;
use wabt::wasm2wat;
fn main() {
    assert_eq!(
        wasm2wat(&[
            0, 97, 115, 109, // \0ASM - magic
            1, 0, 0, 0       //    01 - version
        ]),
        Ok("(module)\n".to_owned()),
    );
}

wabt can be also used for parsing the official testsuite scripts.

use wabt::script::{ScriptParser, Command, CommandKind, Action, Value};

let wast = r#"
;; Define anonymous module with function export named `sub`.
(module
  (func (export "sub") (param $x i32) (param $y i32) (result i32)
    ;; return x - y;
    (i32.sub
      (get_local $x) (get_local $y)
    )
  )
)

;; Assert that invoking export `sub` with parameters (8, 3)
;; should return 5.
(assert_return
  (invoke "sub"
    (i32.const 8) (i32.const 3)
  )
  (i32.const 5)
)
"#;

let mut parser = ScriptParser::<f32, f64>::from_str(wast)?;
while let Some(Command { kind, .. }) = parser.next()? {
    match kind {
        CommandKind::Module { module, name } => {
            // The module is declared as anonymous.
            assert_eq!(name, None);

            // Convert the module into the binary representation and check the magic number.
            let module_binary = module.into_vec();
            assert_eq!(&module_binary[0..4], &[0, 97, 115, 109]);
        }
        CommandKind::AssertReturn { action, expected } => {
            assert_eq!(action, Action::Invoke {
                module: None,
                field: "sub".to_string(),
                args: vec![
                    Value::I32(8),
                    Value::I32(3)
                ],
            });
            assert_eq!(expected, vec![Value::I32(5)]);
        },
        _ => panic!("there are no other commands apart from that defined above"),
    }
}

Alternatives

You might find wat or wast crate useful if you only want to parse .wat or .wast source. The advantage of using them is that they are implemented completely in Rust. Moreover, wast among other things allows you to add your own extensions to WebAssembly text format.

For print the text representation of a wasm binary, wasmprinter can work better for you, since it is implemented completely in Rust.

Dependencies