w2c2 0.1.0

High level crate for w2c2-sys
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

# w2c2-rs


[![Crate](https://img.shields.io/crates/v/w2c2.svg)](https://crates.io/crates/w2c2)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

`w2c2-rs` is a Rust wrapper for `w2c2`, a WebAssembly to C compiler. This project provides low-level bindings (`w2c2-sys`) to the underlying C library, enabling Rust applications to compile WebAssembly modules into C code.

## Workspace Crates


This repository is a Cargo workspace containing the following crates:

*   `w2c2`: A high-level, safe Rust wrapper for `w2c2` (currently under development).
*   `w2c2-sys`: Low-level, unsafe bindings to the `w2c2` C library, generated using `bindgen`.
*   `example-simple`: A basic example demonstrating how to use the `w2c2-sys` crate to compile a WebAssembly module.

## Features


The `w2c2-sys` crate provides the following Cargo features:

*   `bindgen`: Enables the automatic regeneration of Rust bindings from the C source code. This is useful for developers who want to update the underlying C library or customize the bindings.

## Usage


Here is a basic example of how to use `w2c2-sys` to compile a WebAssembly module to C code. This example is based on the `example-simple` crate.

### 1. Add `w2c2-sys` to your `Cargo.toml`


```toml
[dependencies]
w2c2-sys = { version = "0.1.0", path = "path/to/w2c2-sys" }
```

### 2. Compile a WebAssembly Module


The following Rust code demonstrates how to load a WebAssembly module, parse it, and compile it into a C source file named `test.c`.

```rust
use std::{ffi::CStr, ptr::null_mut};

use const_default::ConstDefault;
use w2c2_sys::{
    Buffer, WasmCWriteModuleOptions, WasmFunctionIDs, WasmModuleReader, WasmModuleReaderError,
    wasmCWriteModule, wasmModuleRead, wasmModuleReaderErrorMessage,
};

macro_rules! const_wat2wasm {
    ($e:expr) => {
        crabtime::eval! {
            #![dependency(wat = "1.234.0")]
            crabtime::output_str!("{}", format!("{:?}", wat::parse_str($e).unwrap()))
        }
    };
}

const WASM: &[u8] = &const_wat2wasm!(
    r#"(module
        (func $foo)

        (func (export "bar")
            call $foo
        )
    )"#
);

fn main() {
    unsafe {
        let mut error: *mut WasmModuleReaderError = null_mut();

        let reader = WasmModuleReader::builder()
            .buffer(
                Buffer::builder()
                    .data(WASM.as_ptr() as *mut _)
                    .length(WASM.len())
                    .build(),
            )
            .debug(false)
            .module(null_mut())
            .build();

        wasmModuleRead(&reader as *const _ as *mut _, &mut error);
        if error != null_mut() {
            println!(
                "w2c2: failed to read module: {:?}",
                CStr::from_ptr(wasmModuleReaderErrorMessage(error))
            )
        }

        let mut output_path = b"test.c".to_vec();
        output_path.resize(1024, 0);

        wasmCWriteModule(
            reader.module,
            c"test".as_ptr(),
            WasmCWriteModuleOptions {
                outputPath: output_path.as_ptr() as *const _,
                ..WasmCWriteModuleOptions::DEFAULT
            },
            WasmFunctionIDs::DEFAULT,
            WasmFunctionIDs::DEFAULT,
        );
    }
}
```

### Workflow


The following diagram illustrates the compilation workflow:

```mermaid
graph TD
    A[Start] --> B{Load .wasm bytes};
    B --> C{Create Buffer};
    C --> D{Instantiate WasmModuleReader};
    D --> E{Call wasmModuleRead};
    E --> F{Check for errors};
    F -- No errors --> G{Call wasmCWriteModule};
    G --> H[Output test.c];
    F -- Error --> I[Print error message];
    H --> J[End];
    I --> J;
```

## Building from Source


The `w2c2` C library is automatically compiled and linked by the `build.rs` script in the `w2c2-sys` crate. No manual compilation of the C source code is required.

## License


This project is licensed under the [MIT License](https://opensource.org/licenses/MIT).