fluencelabs/wasmer
1
0
Fork 0
mirror of https://github.com/fluencelabs/wasmer synced 2025-06-21 04:31:33 +00:00
Code Issues Projects Releases Wiki Activity

Consolidate result type to one enum

Browse Source
This commit is contained in:
Brandon Fish
2019-02-11 19:07:28 -06:00
parent b70e319f5c
commit 019ef9ea01
7 changed files with 84 additions and 138 deletions
Download Patch File Download Diff File Expand all files Collapse all files

74
lib/runtime-c-api/src/lib.rs
View File

@ -29,33 +29,9 @@ pub struct wasmer_instance_context_t();
#[allow(non_camel_case_types)] #[allow(non_camel_case_types)]
#[no_mangle] #[no_mangle]
#[repr(C)] #[repr(C)]
pub enum wasmer_compile_result_t { pub enum wasmer_result_t {
WASMER_COMPILE_OK = 1, WASMER_OK = 1,
WASMER_COMPILE_ERROR = 2, WASMER_ERROR = 2,
}
#[allow(non_camel_case_types)]
#[no_mangle]
#[repr(C)]
pub enum wasmer_call_result_t {
WASMER_CALL_OK = 1,
WASMER_CALL_ERROR = 2,
}
#[allow(non_camel_case_types)]
#[no_mangle]
#[repr(C)]
pub enum wasmer_memory_result_t {
WASMER_MEMORY_OK = 1,
WASMER_MEMORY_ERROR = 2,
}
#[allow(non_camel_case_types)]
#[no_mangle]
#[repr(C)]
pub enum wasmer_table_result_t {
WASMER_TABLE_OK = 1,
WASMER_TABLE_ERROR = 2,
} }
#[repr(u32)] #[repr(u32)]
@ -131,7 +107,7 @@ pub extern "C" fn wasmer_import_object_new() -> *mut wasmer_import_object_t {
pub unsafe extern "C" fn wasmer_memory_new( pub unsafe extern "C" fn wasmer_memory_new(
mut memory: *mut *mut wasmer_memory_t, mut memory: *mut *mut wasmer_memory_t,
limits: wasmer_limits_t, limits: wasmer_limits_t,
) -> wasmer_memory_result_t { ) -> wasmer_result_t {
let desc = MemoryDescriptor { let desc = MemoryDescriptor {
minimum: Pages(limits.min), minimum: Pages(limits.min),
maximum: Some(Pages(limits.max)), maximum: Some(Pages(limits.max)),
@ -142,11 +118,11 @@ pub unsafe extern "C" fn wasmer_memory_new(
Ok(memory) => memory, Ok(memory) => memory,
Err(error) => { Err(error) => {
update_last_error(error); update_last_error(error);
return wasmer_memory_result_t::WASMER_MEMORY_ERROR; return wasmer_result_t::WASMER_ERROR;
} }
}; };
unsafe { *memory = Box::into_raw(Box::new(new_memory)) as *mut wasmer_memory_t }; unsafe { *memory = Box::into_raw(Box::new(new_memory)) as *mut wasmer_memory_t };
wasmer_memory_result_t::WASMER_MEMORY_OK wasmer_result_t::WASMER_OK
} }
#[allow(clippy::cast_ptr_alignment)] #[allow(clippy::cast_ptr_alignment)]
@ -154,14 +130,14 @@ pub unsafe extern "C" fn wasmer_memory_new(
pub extern "C" fn wasmer_memory_grow( pub extern "C" fn wasmer_memory_grow(
memory: *mut wasmer_memory_t, memory: *mut wasmer_memory_t,
delta: uint32_t, delta: uint32_t,
) -> wasmer_memory_result_t { ) -> wasmer_result_t {
let memory = unsafe { Box::from_raw(memory as *mut Memory) }; let memory = unsafe { Box::from_raw(memory as *mut Memory) };
let maybe_delta = memory.grow(Pages(delta)); let maybe_delta = memory.grow(Pages(delta));
Box::into_raw(memory); Box::into_raw(memory);
if let Some(_delta) = maybe_delta { if let Some(_delta) = maybe_delta {
wasmer_memory_result_t::WASMER_MEMORY_OK wasmer_result_t::WASMER_OK
} else { } else {
wasmer_memory_result_t::WASMER_MEMORY_ERROR wasmer_result_t::WASMER_ERROR
} }
} }
@ -178,7 +154,7 @@ pub extern "C" fn wasmer_memory_length(memory: *mut wasmer_memory_t) -> uint32_t
pub unsafe extern "C" fn wasmer_table_new( pub unsafe extern "C" fn wasmer_table_new(
mut table: *mut *mut wasmer_table_t, mut table: *mut *mut wasmer_table_t,
limits: wasmer_limits_t, limits: wasmer_limits_t,
) -> wasmer_table_result_t { ) -> wasmer_result_t {
let desc = TableDescriptor { let desc = TableDescriptor {
element: ElementType::Anyfunc, element: ElementType::Anyfunc,
minimum: limits.min, minimum: limits.min,
@ -189,11 +165,11 @@ pub unsafe extern "C" fn wasmer_table_new(
Ok(table) => table, Ok(table) => table,
Err(error) => { Err(error) => {
update_last_error(error); update_last_error(error);
return wasmer_table_result_t::WASMER_TABLE_ERROR; return wasmer_result_t::WASMER_ERROR;
} }
}; };
unsafe { *table = Box::into_raw(Box::new(new_table)) as *mut wasmer_table_t }; unsafe { *table = Box::into_raw(Box::new(new_table)) as *mut wasmer_table_t };
wasmer_table_result_t::WASMER_TABLE_OK wasmer_result_t::WASMER_OK
} }
#[allow(clippy::cast_ptr_alignment)] #[allow(clippy::cast_ptr_alignment)]
@ -201,14 +177,14 @@ pub unsafe extern "C" fn wasmer_table_new(
pub extern "C" fn wasmer_table_grow( pub extern "C" fn wasmer_table_grow(
table: *mut wasmer_table_t, table: *mut wasmer_table_t,
delta: uint32_t, delta: uint32_t,
) -> wasmer_table_result_t { ) -> wasmer_result_t {
let table = unsafe { Box::from_raw(table as *mut Table) }; let table = unsafe { Box::from_raw(table as *mut Table) };
let maybe_delta = table.grow(delta); let maybe_delta = table.grow(delta);
Box::into_raw(table); Box::into_raw(table);
if let Some(_delta) = maybe_delta { if let Some(_delta) = maybe_delta {
wasmer_table_result_t::WASMER_TABLE_OK wasmer_result_t::WASMER_OK
} else { } else {
wasmer_table_result_t::WASMER_TABLE_ERROR wasmer_result_t::WASMER_ERROR
} }
} }
@ -305,10 +281,10 @@ pub unsafe extern "C" fn wasmer_instantiate(
wasm_bytes: *mut uint8_t, wasm_bytes: *mut uint8_t,
wasm_bytes_len: uint32_t, wasm_bytes_len: uint32_t,
import_object: *mut wasmer_import_object_t, import_object: *mut wasmer_import_object_t,
) -> wasmer_compile_result_t { ) -> wasmer_result_t {
let import_object = unsafe { Box::from_raw(import_object as *mut ImportObject) }; let import_object = unsafe { Box::from_raw(import_object as *mut ImportObject) };
if wasm_bytes.is_null() { if wasm_bytes.is_null() {
return wasmer_compile_result_t::WASMER_COMPILE_ERROR; return wasmer_result_t::WASMER_ERROR;
} }
let bytes: &[u8] = let bytes: &[u8] =
unsafe { ::std::slice::from_raw_parts_mut(wasm_bytes, wasm_bytes_len as usize) }; unsafe { ::std::slice::from_raw_parts_mut(wasm_bytes, wasm_bytes_len as usize) };
@ -316,12 +292,12 @@ pub unsafe extern "C" fn wasmer_instantiate(
let new_instance = match result { let new_instance = match result {
Ok(instance) => instance, Ok(instance) => instance,
Err(error) => { Err(error) => {
return wasmer_compile_result_t::WASMER_COMPILE_ERROR; return wasmer_result_t::WASMER_ERROR;
} }
}; };
unsafe { *instance = Box::into_raw(Box::new(new_instance)) as *mut wasmer_instance_t }; unsafe { *instance = Box::into_raw(Box::new(new_instance)) as *mut wasmer_instance_t };
Box::into_raw(import_object); Box::into_raw(import_object);
wasmer_compile_result_t::WASMER_COMPILE_OK wasmer_result_t::WASMER_OK
} }
#[allow(clippy::cast_ptr_alignment)] #[allow(clippy::cast_ptr_alignment)]
@ -333,17 +309,17 @@ pub unsafe extern "C" fn wasmer_instance_call(
params_len: c_int, params_len: c_int,
results: *mut wasmer_value_t, results: *mut wasmer_value_t,
results_len: c_int, results_len: c_int,
) -> wasmer_call_result_t { ) -> wasmer_result_t {
// TODO handle params and results // TODO handle params and results
if instance.is_null() { if instance.is_null() {
return wasmer_call_result_t::WASMER_CALL_ERROR; return wasmer_result_t::WASMER_ERROR;
} }
if name.is_null() { if name.is_null() {
return wasmer_call_result_t::WASMER_CALL_ERROR; return wasmer_result_t::WASMER_ERROR;
} }
if params.is_null() { if params.is_null() {
return wasmer_call_result_t::WASMER_CALL_ERROR; return wasmer_result_t::WASMER_ERROR;
} }
let params: &[wasmer_value_t] = slice::from_raw_parts(params, params_len as usize); let params: &[wasmer_value_t] = slice::from_raw_parts(params, params_len as usize);
@ -382,11 +358,11 @@ pub unsafe extern "C" fn wasmer_instance_call(
}; };
results[0] = ret; results[0] = ret;
} }
wasmer_call_result_t::WASMER_CALL_OK wasmer_result_t::WASMER_OK
} }
Err(err) => { Err(err) => {
update_last_error(err); update_last_error(err);
wasmer_call_result_t::WASMER_CALL_ERROR wasmer_result_t::WASMER_ERROR
} }
} }
} }

8
lib/runtime-c-api/tests/test-import-function.c
View File

@ -39,15 +39,15 @@ int main()
fclose(file); fclose(file);
wasmer_instance_t *instance = NULL; wasmer_instance_t *instance = NULL;
wasmer_compile_result_t compile_result = wasmer_instantiate(&instance, bytes, len, import_object); wasmer_result_t compile_result = wasmer_instantiate(&instance, bytes, len, import_object);
printf("Compile result: %d\n", compile_result); printf("Compile result: %d\n", compile_result);
assert(compile_result == WASMER_COMPILE_OK); assert(compile_result == WASMER_OK);
wasmer_value_t params[] = {}; wasmer_value_t params[] = {};
wasmer_value_t results[] = {}; wasmer_value_t results[] = {};
wasmer_call_result_t call_result = wasmer_instance_call(instance, "hello_wasm", params, 0, results, 0); wasmer_result_t call_result = wasmer_instance_call(instance, "hello_wasm", params, 0, results, 0);
printf("Call result: %d\n", call_result); printf("Call result: %d\n", call_result);
assert(call_result == WASMER_CALL_OK); assert(call_result == WASMER_OK);
assert(print_str_called); assert(print_str_called);
assert(memory_len == 17); assert(memory_len == 17);

12
lib/runtime-c-api/tests/test-instantiate.c
View File

@ -17,9 +17,9 @@ int main()
fclose(file); fclose(file);
wasmer_instance_t *instance = NULL; wasmer_instance_t *instance = NULL;
wasmer_compile_result_t compile_result = wasmer_instantiate(&instance, bytes, len, import_object); wasmer_result_t compile_result = wasmer_instantiate(&instance, bytes, len, import_object);
printf("Compile result: %d\n", compile_result); printf("Compile result: %d\n", compile_result);
assert(compile_result == WASMER_COMPILE_OK); assert(compile_result == WASMER_OK);
wasmer_value_t param_one; wasmer_value_t param_one;
param_one.tag = WASM_I32; param_one.tag = WASM_I32;
@ -32,16 +32,16 @@ int main()
wasmer_value_t result_one; wasmer_value_t result_one;
wasmer_value_t results[] = {result_one}; wasmer_value_t results[] = {result_one};
wasmer_call_result_t call_result = wasmer_instance_call(instance, "sum", params, 2, results, 1); wasmer_result_t call_result = wasmer_instance_call(instance, "sum", params, 2, results, 1);
printf("Call result: %d\n", call_result); printf("Call result: %d\n", call_result);
printf("Result: %d\n", results[0].value.I32); printf("Result: %d\n", results[0].value.I32);
assert(results[0].value.I32 == 15); assert(results[0].value.I32 == 15);
assert(call_result == WASMER_CALL_OK); assert(call_result == WASMER_OK);
wasmer_call_result_t call_result2 = wasmer_instance_call(instance, "sum", params, 1, results, 1); wasmer_result_t call_result2 = wasmer_instance_call(instance, "sum", params, 1, results, 1);
printf("Call result bad: %d\n", call_result2); printf("Call result bad: %d\n", call_result2);
assert(call_result2 == WASMER_CALL_ERROR); assert(call_result2 == WASMER_ERROR);
int error_len = wasmer_last_error_length(); int error_len = wasmer_last_error_length();
printf("Error len: `%d`\n", error_len); printf("Error len: `%d`\n", error_len);

14
lib/runtime-c-api/tests/test-memory.c
View File

@ -9,16 +9,16 @@ int main()
wasmer_limits_t descriptor; wasmer_limits_t descriptor;
descriptor.min = 10; descriptor.min = 10;
descriptor.max = 15; descriptor.max = 15;
wasmer_memory_result_t memory_result = wasmer_memory_new(&memory, descriptor); wasmer_result_t memory_result = wasmer_memory_new(&memory, descriptor);
printf("Memory result: %d\n", memory_result); printf("Memory result: %d\n", memory_result);
assert(memory_result == WASMER_MEMORY_OK); assert(memory_result == WASMER_OK);
uint32_t len = wasmer_memory_length(memory); uint32_t len = wasmer_memory_length(memory);
printf("Memory pages length: %d\n", len); printf("Memory pages length: %d\n", len);
assert(len == 10); assert(len == 10);
wasmer_memory_result_t grow_result = wasmer_memory_grow(memory, 2); wasmer_result_t grow_result = wasmer_memory_grow(memory, 2);
assert(grow_result == WASMER_MEMORY_OK); assert(grow_result == WASMER_OK);
uint32_t new_len = wasmer_memory_length(memory); uint32_t new_len = wasmer_memory_length(memory);
printf("Memory pages length: %d\n", new_len); printf("Memory pages length: %d\n", new_len);
@ -29,8 +29,8 @@ int main()
assert(bytes_len == 12 * 65536); assert(bytes_len == 12 * 65536);
// Err, grow beyond max // Err, grow beyond max
wasmer_memory_result_t grow_result2 = wasmer_memory_grow(memory, 10); wasmer_result_t grow_result2 = wasmer_memory_grow(memory, 10);
assert(grow_result2 == WASMER_MEMORY_ERROR); assert(grow_result2 == WASMER_ERROR);
// int error_len = wasmer_last_error_length(); // int error_len = wasmer_last_error_length();
// char *error_str = malloc(error_len); // char *error_str = malloc(error_len);
// wasmer_last_error_message(error_str, error_len); // wasmer_last_error_message(error_str, error_len);
@ -42,7 +42,7 @@ int main()
// wasmer_limits_t bad_descriptor; // wasmer_limits_t bad_descriptor;
// bad_descriptor.min = 15; // bad_descriptor.min = 15;
// bad_descriptor.max = 10; // bad_descriptor.max = 10;
// wasmer_memory_result_t bad_memory_result = wasmer_memory_new(&bad_memory, bad_descriptor); // wasmer_result_t bad_memory_result = wasmer_memory_new(&bad_memory, bad_descriptor);
// printf("Bad memory result: %d\n", bad_memory_result); // printf("Bad memory result: %d\n", bad_memory_result);
// assert(memory_result == WASMER_MEMORY_ERROR); // assert(memory_result == WASMER_MEMORY_ERROR);
// //

16
lib/runtime-c-api/tests/test-tables.c
View File

@ -9,23 +9,23 @@ int main()
wasmer_limits_t descriptor; wasmer_limits_t descriptor;
descriptor.min = 10; descriptor.min = 10;
descriptor.max = 15; descriptor.max = 15;
wasmer_table_result_t table_result = wasmer_table_new(&table, descriptor); wasmer_result_t table_result = wasmer_table_new(&table, descriptor);
printf("Table result: %d\n", table_result); printf("Table result: %d\n", table_result);
assert(table_result == WASMER_TABLE_OK); assert(table_result == WASMER_OK);
uint32_t len = wasmer_table_length(table); uint32_t len = wasmer_table_length(table);
printf("Table length: %d\n", len); printf("Table length: %d\n", len);
assert(len == 15); assert(len == 15);
// wasmer_table_result_t grow_result1 = wasmer_table_grow(&table, 5); // wasmer_result_t grow_result1 = wasmer_table_grow(&table, 5);
// assert(grow_result1 == WASMER_TABLE_OK); // assert(grow_result1 == WASMER_OK);
// uint32_t len_grow1 = wasmer_table_length(table); // uint32_t len_grow1 = wasmer_table_length(table);
// printf("Table length: %d\n", len_grow1); // printf("Table length: %d\n", len_grow1);
// assert(len_grow1 == 15); // assert(len_grow1 == 15);
// // Try to grow beyond max // // Try to grow beyond max
// wasmer_table_result_t grow_result2 = wasmer_table_grow(&table, 1); // wasmer_result_t grow_result2 = wasmer_table_grow(&table, 1);
// assert(grow_result2 == WASMER_TABLE_ERROR); // assert(grow_result2 == WASMER_ERROR);
// uint32_t len_grow2 = wasmer_table_length(table); // uint32_t len_grow2 = wasmer_table_length(table);
// printf("Table length: %d\n", len_grow2); // printf("Table length: %d\n", len_grow2);
// assert(len_grow2 == 15); // assert(len_grow2 == 15);
@ -34,9 +34,9 @@ int main()
// wasmer_limits_t bad_descriptor; // wasmer_limits_t bad_descriptor;
// bad_descriptor.min = 15; // bad_descriptor.min = 15;
// bad_descriptor.max = 10; // bad_descriptor.max = 10;
// wasmer_table_result_t table_bad_result = wasmer_table_new(&table_bad, bad_descriptor); // wasmer_result_t table_bad_result = wasmer_table_new(&table_bad, bad_descriptor);
// printf("Table result: %d\n", table_bad_result); // printf("Table result: %d\n", table_bad_result);
// assert(table_result == WASMER_TABLE_ERROR); // assert(table_result == WASMER_ERROR);
printf("Destroy table\n"); printf("Destroy table\n");
wasmer_table_destroy(table); wasmer_table_destroy(table);

49
lib/runtime-c-api/wasmer.h
View File

@ -7,24 +7,9 @@
#include <stdlib.h> #include <stdlib.h>
typedef enum { typedef enum {
WASMER_CALL_OK = 1, WASMER_OK = 1,
WASMER_CALL_ERROR = 2, WASMER_ERROR = 2,
} wasmer_call_result_t; } wasmer_result_t;
typedef enum {
WASMER_COMPILE_OK = 1,
WASMER_COMPILE_ERROR = 2,
} wasmer_compile_result_t;
typedef enum {
WASMER_MEMORY_OK = 1,
WASMER_MEMORY_ERROR = 2,
} wasmer_memory_result_t;
typedef enum {
WASMER_TABLE_OK = 1,
WASMER_TABLE_ERROR = 2,
} wasmer_table_result_t;
enum wasmer_value_tag { enum wasmer_value_tag {
WASM_I32, WASM_I32,
@ -97,22 +82,22 @@ void wasmer_imports_set_import_func(wasmer_import_object_t *import_object,
const wasmer_value_tag *returns, const wasmer_value_tag *returns,
int returns_len); int returns_len);
wasmer_call_result_t wasmer_instance_call(wasmer_instance_t *instance, wasmer_result_t wasmer_instance_call(wasmer_instance_t *instance,
const char *name, const char *name,
const wasmer_value_t *params, const wasmer_value_t *params,
int params_len, int params_len,
wasmer_value_t *results, wasmer_value_t *results,
int results_len); int results_len);
const wasmer_memory_t *wasmer_instance_context_memory(wasmer_instance_context_t *ctx, const wasmer_memory_t *wasmer_instance_context_memory(wasmer_instance_context_t *ctx,
uint32_t memory_idx); uint32_t memory_idx);
void wasmer_instance_destroy(wasmer_instance_t *instance); void wasmer_instance_destroy(wasmer_instance_t *instance);
wasmer_compile_result_t wasmer_instantiate(wasmer_instance_t **instance, wasmer_result_t wasmer_instantiate(wasmer_instance_t **instance,
uint8_t *wasm_bytes, uint8_t *wasm_bytes,
uint32_t wasm_bytes_len, uint32_t wasm_bytes_len,
wasmer_import_object_t *import_object); wasmer_import_object_t *import_object);
int wasmer_last_error_length(void); int wasmer_last_error_length(void);
@ -124,19 +109,19 @@ uint32_t wasmer_memory_data_length(wasmer_memory_t *mem);
void wasmer_memory_destroy(wasmer_memory_t *memory); void wasmer_memory_destroy(wasmer_memory_t *memory);
wasmer_memory_result_t wasmer_memory_grow(wasmer_memory_t *memory, uint32_t delta); wasmer_result_t wasmer_memory_grow(wasmer_memory_t *memory, uint32_t delta);
uint32_t wasmer_memory_length(wasmer_memory_t *memory); uint32_t wasmer_memory_length(wasmer_memory_t *memory);
wasmer_memory_result_t wasmer_memory_new(wasmer_memory_t **memory, wasmer_limits_t limits); wasmer_result_t wasmer_memory_new(wasmer_memory_t **memory, wasmer_limits_t limits);
void wasmer_table_destroy(wasmer_table_t *table); void wasmer_table_destroy(wasmer_table_t *table);
wasmer_table_result_t wasmer_table_grow(wasmer_table_t *table, uint32_t delta); wasmer_result_t wasmer_table_grow(wasmer_table_t *table, uint32_t delta);
uint32_t wasmer_table_length(wasmer_table_t *table); uint32_t wasmer_table_length(wasmer_table_t *table);
wasmer_table_result_t wasmer_table_new(wasmer_table_t **table, wasmer_limits_t limits); wasmer_result_t wasmer_table_new(wasmer_table_t **table, wasmer_limits_t limits);
bool wasmer_validate(uint8_t *wasm_bytes, uint32_t wasm_bytes_len); bool wasmer_validate(uint8_t *wasm_bytes, uint32_t wasm_bytes_len);

49
lib/runtime-c-api/wasmer.hh
View File

@ -5,24 +5,9 @@
#include <cstdint> #include <cstdint>
#include <cstdlib> #include <cstdlib>
enum class wasmer_call_result_t { enum class wasmer_result_t {
WASMER_CALL_OK = 1, WASMER_OK = 1,
WASMER_CALL_ERROR = 2, WASMER_ERROR = 2,
};
enum class wasmer_compile_result_t {
WASMER_COMPILE_OK = 1,
WASMER_COMPILE_ERROR = 2,
};
enum class wasmer_memory_result_t {
WASMER_MEMORY_OK = 1,
WASMER_MEMORY_ERROR = 2,
};
enum class wasmer_table_result_t {
WASMER_TABLE_OK = 1,
WASMER_TABLE_ERROR = 2,
}; };
enum class wasmer_value_tag : uint32_t { enum class wasmer_value_tag : uint32_t {
@ -97,22 +82,22 @@ void wasmer_imports_set_import_func(wasmer_import_object_t *import_object,
const wasmer_value_tag *returns, const wasmer_value_tag *returns,
int returns_len); int returns_len);
wasmer_call_result_t wasmer_instance_call(wasmer_instance_t *instance, wasmer_result_t wasmer_instance_call(wasmer_instance_t *instance,
const char *name, const char *name,
const wasmer_value_t *params, const wasmer_value_t *params,
int params_len, int params_len,
wasmer_value_t *results, wasmer_value_t *results,
int results_len); int results_len);
const wasmer_memory_t *wasmer_instance_context_memory(wasmer_instance_context_t *ctx, const wasmer_memory_t *wasmer_instance_context_memory(wasmer_instance_context_t *ctx,
uint32_t memory_idx); uint32_t memory_idx);
void wasmer_instance_destroy(wasmer_instance_t *instance); void wasmer_instance_destroy(wasmer_instance_t *instance);
wasmer_compile_result_t wasmer_instantiate(wasmer_instance_t **instance, wasmer_result_t wasmer_instantiate(wasmer_instance_t **instance,
uint8_t *wasm_bytes, uint8_t *wasm_bytes,
uint32_t wasm_bytes_len, uint32_t wasm_bytes_len,
wasmer_import_object_t *import_object); wasmer_import_object_t *import_object);
int wasmer_last_error_length(); int wasmer_last_error_length();
@ -124,19 +109,19 @@ uint32_t wasmer_memory_data_length(wasmer_memory_t *mem);
void wasmer_memory_destroy(wasmer_memory_t *memory); void wasmer_memory_destroy(wasmer_memory_t *memory);
wasmer_memory_result_t wasmer_memory_grow(wasmer_memory_t *memory, uint32_t delta); wasmer_result_t wasmer_memory_grow(wasmer_memory_t *memory, uint32_t delta);
uint32_t wasmer_memory_length(wasmer_memory_t *memory); uint32_t wasmer_memory_length(wasmer_memory_t *memory);
wasmer_memory_result_t wasmer_memory_new(wasmer_memory_t **memory, wasmer_limits_t limits); wasmer_result_t wasmer_memory_new(wasmer_memory_t **memory, wasmer_limits_t limits);
void wasmer_table_destroy(wasmer_table_t *table); void wasmer_table_destroy(wasmer_table_t *table);
wasmer_table_result_t wasmer_table_grow(wasmer_table_t *table, uint32_t delta); wasmer_result_t wasmer_table_grow(wasmer_table_t *table, uint32_t delta);
uint32_t wasmer_table_length(wasmer_table_t *table); uint32_t wasmer_table_length(wasmer_table_t *table);
wasmer_table_result_t wasmer_table_new(wasmer_table_t **table, wasmer_limits_t limits); wasmer_result_t wasmer_table_new(wasmer_table_t **table, wasmer_limits_t limits);
bool wasmer_validate(uint8_t *wasm_bytes, uint32_t wasm_bytes_len); bool wasmer_validate(uint8_t *wasm_bytes, uint32_t wasm_bytes_len);