8ae283507e
There is no memory leaks with those functions as far as I understand this code.
Check the following code as a fun playground, which reproduces a
typical use of `wasm_functype_params` or `_results` that both return a
`wasm_valtype_vec_t`:
```rust
struct wasm_valtype_t { x: u8 }
impl Drop for wasm_valtype_t {
fn drop(&mut self) {
println!("wasm_valtype_t {{ {} }} dropped!", self.x)
}
}
struct wasm_valtype_vec_t {
size: usize,
data: *mut *mut wasm_valtype_t,
}
unsafe fn wasm_valtype_vec_delete(ptr: *mut wasm_valtype_vec_t) {
let vec = &mut *ptr;
if !vec.data.is_null() {
let data: Vec<*mut wasm_valtype_t> = Vec::from_raw_parts(vec.data, vec.size, vec.size);
let _data: Vec<Box<wasm_valtype_t>> = ::std::mem::transmute(data);
vec.data = ::std::ptr::null_mut();
vec.size = 0;
}
}
fn main() {
let x = Box::into_raw(Box::new(wasm_valtype_t { x: 1 }));
let y = Box::into_raw(Box::new(wasm_valtype_t { x: 2 }));
let z = Box::into_raw(Box::new(wasm_valtype_t { x: 3 }));
let mut valtypes: Vec<*mut wasm_valtype_t> = vec![x, y, z];
let vec = Box::into_raw(Box::new(wasm_valtype_vec_t {
size: valtypes.len(),
data: valtypes.as_mut_ptr(),
}));
::std::mem::forget(valtypes);
unsafe { wasm_valtype_vec_delete(vec as *mut _); }
}
```
It prints:
```
wasm_valtype_t { 1 } dropped!
wasm_valtype_t { 2 } dropped!
wasm_valtype_t { 3 } dropped!
```
All `wasm_valtype_t` are dropped correctly. Since they contain an
owned value, there is no leaks here.
wasmer-c-api 
This crate exposes a C and a C++ API for the Wasmer runtime. It also fully supports the wasm-c-api common API.
Usage
Once you install Wasmer in your system, the shared object files and the headers will be automatically available inside the Wasmer installed path.
The C (wasmer.h) and C++ (wasmer.hh) header
files can be found in the Wasmer include directory:
wasmer config --includedir
The runtime shared libraries (.so, .dylib, .dll) can be found in the Wasmer
lib directory:
wasmer config --libdir
Note: You can also download the libraries or header files directly from Wasmer release page.
The full C API documentation can be found here: https://wasmerio.github.io/wasmer/c-api/
Here is a simple example to use the C API:
#include <stdio.h>
#include "../wasmer.h"
#include <assert.h>
#include <stdint.h>
int main()
{
// Read the Wasm file bytes.
FILE *file = fopen("sum.wasm", "r");
fseek(file, 0, SEEK_END);
long len = ftell(file);
uint8_t *bytes = malloc(len);
fseek(file, 0, SEEK_SET);
fread(bytes, 1, len, file);
fclose(file);
// Prepare the imports.
wasmer_import_t imports[] = {};
// Instantiate!
wasmer_instance_t *instance = NULL;
wasmer_result_t instantiation_result = wasmer_instantiate(&instance, bytes, len, imports, 0);
assert(instantiation_result == WASMER_OK);
// Let's call a function.
// Start by preparing the arguments.
// Value of argument #1 is `7i32`.
wasmer_value_t argument_one;
argument_one.tag = WASM_I32;
argument_one.value.I32 = 7;
// Value of argument #2 is `8i32`.
wasmer_value_t argument_two;
argument_two.tag = WASM_I32;
argument_two.value.I32 = 8;
// Prepare the arguments.
wasmer_value_t arguments[] = {argument_one, argument_two};
// Prepare the return value.
wasmer_value_t result_one;
wasmer_value_t results[] = {result_one};
// Call the `sum` function with the prepared arguments and the return value.
wasmer_result_t call_result = wasmer_instance_call(instance, "sum", arguments, 2, results, 1);
// Let's display the result.
printf("Call result: %d\n", call_result);
printf("Result: %d\n", results[0].value.I32);
// `sum(7, 8) == 15`.
assert(results[0].value.I32 == 15);
assert(call_result == WASMER_OK);
wasmer_instance_destroy(instance);
return 0;
}
Testing
Tests are run using the release build of the library. If you make changes or compile with non-default features, please ensure you rebuild in release mode for the tests to see the changes.
The tests can be run via cargo test, such as:
$ cargo test --release -- --nocapture
To run tests manually, enter the lib/c-api/tests directory
and run the following commands:
$ cmake .
$ make
$ make test
pkg-config
The Wasmer binary ships with an utility tool that outputs config
in the pkg-config format.
You can use it like:
wasmer config --pkg-config > $PKG_CONFIG_PATH/wasmer.pc
License
Wasmer is primarily distributed under the terms of the MIT license (LICENSE).